xdelta3_wrap.c

This program is free software you can redistribute it and/or modify it under the terms of the GNU G

#define SWIGTYPE_p_char swig_types[0]
#define SWIGTYPE_p_p_char swig_types[1]
#define SWIGTYPE_p_unsigned_int swig_types[2]
#define SWIGTYPE_ptrdiff_t swig_types[3]
#define SWIGTYPE_size_t swig_types[4]
static swig_type_info *swig_types[5];
static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */


/*-----------------------------------------------
              @(target):= _xdelta3.so
  ------------------------------------------------*/
#define SWIG_init    init_xdelta3

#define SWIG_name    "_xdelta3"

#include "xdelta3.h"

int xd3_main_cmdline (int ARGC, char **ARGV);

#undef SWIG_init
#undef SWIG_name

#define SWIG_init    initxdelta3
#define SWIG_name    "xdelta3"



/* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
{
  static swig_type_info* pchar_info = 0;
  char* vptr = 0;
  if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
  if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
    if (cptr) *cptr = vptr;
    if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
    return SWIG_OLDOBJ;
  } else {
    PyErr_Clear();
    if (PyString_Check(obj)) {
      if (cptr) {
	*cptr = PyString_AS_STRING(obj);
	if (psize) {
	  *psize = PyString_GET_SIZE(obj) + 1;
	}
      }
      return SWIG_PYSTR;
    }
  }
  if (cptr) {
    SWIG_type_error("char *", obj);
  }
  return 0;
}


#include <limits.h>


SWIGINTERN int
  SWIG_CheckLongInRange(long value, long min_value, long max_value,
			const char *errmsg)
{
  if (value < min_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError, 
		   "value %ld is less than '%s' minimum %ld", 
		   value, errmsg, min_value);
    }
    return 0;    
  } else if (value > max_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError,
		   "value %ld is greater than '%s' maximum %ld", 
		   value, errmsg, max_value);
    }
    return 0;
  }
  return 1;
}


SWIGINTERN int
  SWIG_AsVal_long(PyObject * obj, long* val)
{
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AS_LONG(obj);
    return 1;
  }
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  }
  if (val) {
    SWIG_type_error("long", obj);
  }
  return 0;
 }


#if INT_MAX != LONG_MAX
SWIGINTERN int
  SWIG_AsVal_int(PyObject *obj, int *val)
{ 
  const char* errmsg = val ? "int" : (char*)0;
  long v;
  if (SWIG_AsVal_long(obj, &v)) {
    if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
      if (val) *val = (int)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}
#else
SWIGINTERNINLINE int
  SWIG_AsVal_int(PyObject *obj, int *val)
{
  return SWIG_AsVal_long(obj,(long*)val);
}
#endif


SWIGINTERNINLINE int
SWIG_As_int(PyObject* obj)
{
  int v;
  if (!SWIG_AsVal_int(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(int));
  }
  return v;
}


SWIGINTERNINLINE int
SWIG_AsCharPtr(PyObject *obj, char **val)
{
  if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
    return 1;
  }
  if (val) {
    PyErr_Clear();
    SWIG_type_error("char *", obj);
  }
  return 0;
}


SWIGINTERNINLINE int
  SWIG_CheckUnsignedLongInRange(unsigned long value,
				unsigned long max_value,
				const char *errmsg) 
{
  if (value > max_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError,
		   "value %lu is greater than '%s' minimum %lu",
		   value, errmsg, max_value);
    }
    return 0;
  }
  return 1;
 }


SWIGINTERN int
  SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val) 
{
  if (PyInt_Check(obj)) {
    long v = PyInt_AS_LONG(obj);
    if (v >= 0) {
      if (val) *val = v;
      return 1;
    }   
  }
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  } 
  if (val) {
    SWIG_type_error("unsigned long", obj);
  }
  return 0;
}


#if UINT_MAX != ULONG_MAX
SWIGINTERN int
  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
{ 
  const char* errmsg = val ? "unsigned int" : (char*)0;
  unsigned long v;
  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
    if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
      if (val) *val = (unsigned int)(v);
      return 1;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}
#else
SWIGINTERNINLINE unsigned int
  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
{
  return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
}
#endif

  
SWIGINTERNINLINE int
SWIG_Check_unsigned_SS_int(PyObject* obj)
{
  return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
}

  
SWIGINTERNINLINE int
SWIG_Check_int(PyObject* obj)
{
  return SWIG_AsVal_int(obj, (int*)0);
}


SWIGINTERN PyObject*
t_output_helper(PyObject* target, PyObject* o) {
  if (!target) {
    target = o;
  } else if (target == Py_None) {  
    Py_DECREF(target);
    target = o;
  } else {
    if (!PyList_Check(target)) {
      PyObject *o2 = target;
      target = PyList_New(1);
      PyList_SetItem(target, 0, o2);
    }
    PyList_Append(target,o);
    Py_DECREF(o);
    }
  return target;
}


  /*@/usr/share/swig/1.3.25/python/pymacros.swg,66,SWIG_define@*/
#define SWIG_From_int PyInt_FromLong
/*@@*/


SWIGINTERN char**
  SWIG_AsArgcArgv(PyObject* input,
		  swig_type_info* ppchar_info,
		  size_t* argc, int* owner)
{  
  char **argv = 0;
  size_t i = 0;
  if (SWIG_ConvertPtr(input, (void **)&argv, ppchar_info, 0) == -1) {
    PyErr_Clear();
    int list = PyList_Check(input);
    if (list || PyTuple_Check(input)) {
      *argc = list ? PyList_Size(input) : PyTuple_Size(input);
      argv = ((char**) malloc((*argc + 1)*sizeof(char*)));
      *owner = 1;
      for (; i < *argc; ++i) {
	PyObject *obj = list ? PyList_GetItem(input,i) : PyTuple_GetItem(input,i);
	if (!SWIG_AsCharPtr(obj, &(argv[i]))) {
	  PyErr_Clear();
	  PyErr_SetString(PyExc_TypeError,"list or tuple must contain strings only");
	}
      }
      argv[i] = 0;
      return argv;
    } else {
      *argc = 0;
      PyErr_SetString(PyExc_TypeError,"a list or tuple is expected");
      return 0;
    }
  } else {
    /* seems dangerous, but the user asked for it... */
    while (argv[i] != 0) ++i;
    *argc = i;
    owner = 0;
    return argv;
  }
}

#ifdef __cplusplus
extern "C" {
#endif
static PyObject *_wrap_xd3_encode_memory(PyObject *self, PyObject *args) {
    PyObject *resultobj = NULL;
    char *arg1 = (char *) 0 ;
    unsigned int arg2 ;
    char *arg3 = (char *) 0 ;
    unsigned int arg4 ;
    char *arg5 = (char *) 0 ;
    unsigned int *arg6 = (unsigned int *) 0 ;
    unsigned int arg7 ;
    int arg8 ;
    int result;
    char *buf1 ;
    size_t size1 ;
    char *buf3 ;
    size_t size3 ;
    unsigned int alloc_size7 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    {
        arg8 = 0;
    }
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO|O:xd3_encode_memory",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        int res = SWIG_AsCharPtrAndSize(obj0, &buf1, &size1);
        if (!res) {
            SWIG_arg_fail(1);SWIG_fail;
        }
        arg1 = (char *) buf1;
        arg2 = (unsigned int) size1 - 1;
    }
    {
        int res = SWIG_AsCharPtrAndSize(obj1, &buf3, &size3);
        if (!res) {
            SWIG_arg_fail(3);SWIG_fail;
        }
        arg3 = (char *) buf3;
        arg4 = (unsigned int) size3 - 1;
    }
    {
        arg7 = alloc_size7 = PyInt_AsLong(obj2);
    }
    if (obj3) {
        {
            arg8 = (int)(SWIG_As_int(obj3)); 
            if (SWIG_arg_fail(8)) SWIG_fail;
        }
    }
    {
        // alloc_size input is #7th position in xd3_xxcode_memory()
        arg5 = malloc(alloc_size7);
        arg6 = &alloc_size7;
    }
    result = (int)xd3_encode_memory((char const *)arg1,arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    {
        if (result == 0) {
            PyObject *o;
            // alloc_size7 now carries actual size
            o = PyString_FromStringAndSize(arg5,alloc_size7);
            resultobj = t_output_helper(resultobj,o);
        } else {
            resultobj = t_output_helper(resultobj,Py_None);
        }
        free(arg5);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_xd3_decode_memory(PyObject *self, PyObject *args) {
    PyObject *resultobj = NULL;
    char *arg1 = (char *) 0 ;
    unsigned int arg2 ;
    char *arg3 = (char *) 0 ;
    unsigned int arg4 ;
    char *arg5 = (char *) 0 ;
    unsigned int *arg6 = (unsigned int *) 0 ;
    unsigned int arg7 ;
    int arg8 ;
    int result;
    char *buf1 ;
    size_t size1 ;
    char *buf3 ;
    size_t size3 ;
    unsigned int alloc_size7 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    {
        arg8 = 0;
    }
    {
        
    }
    if(!PyArg_ParseTuple(args,(char *)"OOO|O:xd3_decode_memory",&obj0,&obj1,&obj2,&obj3)) goto fail;
    {
        int res = SWIG_AsCharPtrAndSize(obj0, &buf1, &size1);
        if (!res) {
            SWIG_arg_fail(1);SWIG_fail;
        }
        arg1 = (char *) buf1;
        arg2 = (unsigned int) size1 - 1;
    }
    {
        int res = SWIG_AsCharPtrAndSize(obj1, &buf3, &size3);
        if (!res) {
            SWIG_arg_fail(3);SWIG_fail;
        }
        arg3 = (char *) buf3;
        arg4 = (unsigned int) size3 - 1;
    }
    {
        arg7 = alloc_size7 = PyInt_AsLong(obj2);
    }
    if (obj3) {
        {
            arg8 = (int)(SWIG_As_int(obj3)); 
            if (SWIG_arg_fail(8)) SWIG_fail;
        }
    }