kadcapi_wrap.c

p2p类源代码 kadc协议官方源代码

/*@C:\\CYGWIN\\USR\\LOCAL\\BIN\\Lib\\python\\pymacros.swg,63,SWIG_define@*/
#define SWIG_From_short PyInt_FromLong
/*@@*/
/*@C:\\CYGWIN\\USR\\LOCAL\\BIN\\Lib\\python\\pymacros.swg,63,SWIG_define@*/
#define SWIG_From_unsigned_SS_short PyInt_FromLong
/*@@*/
/*@C:\\CYGWIN\\USR\\LOCAL\\BIN\\Lib\\python\\pymacros.swg,63,SWIG_define@*/
#define SWIG_From_int PyInt_FromLong
/*@@*/
/*@C:\\CYGWIN\\USR\\LOCAL\\BIN\\Lib\\python\\pymacros.swg,63,SWIG_define@*/
#define SWIG_From_long PyInt_FromLong
/*@@*/
/*@C:\\CYGWIN\\USR\\LOCAL\\BIN\\Lib\\python\\pymacros.swg,63,SWIG_define@*/
#define SWIG_From_float PyFloat_FromDouble
/*@@*/
/*@C:\\CYGWIN\\USR\\LOCAL\\BIN\\Lib\\python\\pymacros.swg,63,SWIG_define@*/
#define SWIG_From_double PyFloat_FromDouble
/*@@*/


#include <limits.h>


SWIGSTATICINLINE(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;
}


SWIGSTATICINLINE(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) {
    PyErr_SetString(PyExc_TypeError, "a long is expected");
  }
  return 0;
 }


#if INT_MAX != LONG_MAX
SWIGSTATICINLINE(int)
  SWIG_AsVal_int(PyObject *obj, int *val)
{ 
  const char* errmsg = val ? "int" : 0;
  long v;
  if (SWIG_AsVal_long(obj, &v)) {
    if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
      if (val) *val = swig_numeric_cast(v, int);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    PyErr_SetString(PyExc_TypeError, "an int is expected");
  }
  return 0;    
}
#else
SWIGSTATICINLINE(int)
  SWIG_AsVal_int(PyObject *obj, int *val)
{
  return SWIG_AsVal_long(obj,(long*)val);
}
#endif


SWIGSTATICINLINE(int)
SWIG_As_int(PyObject* obj)
{
  int v;
  if (!SWIG_AsVal_int(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier.  the other
      solution is throw an exception, but since this code should work
      with plain C ....
     */
    memset((void*)&v, 0, sizeof(int));
  }
  return v;
}

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


/* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
SWIGSTATIC(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 {
    if (PyString_Check(obj)) {
      if (cptr) {
	*cptr = PyString_AS_STRING(obj);
	if (psize) {
	  *psize = PyString_GET_SIZE(obj) + 1;
	}
      }
      return SWIG_PYSTR;
    }
  }
  if (cptr) {
    PyErr_SetString(PyExc_TypeError, "a string is expected");
  }
  return 0;
}


SWIGSTATICINLINE(int)
SWIG_AsCharPtr(PyObject *obj, char **val)
{
  char* cptr = 0;
  if (SWIG_AsCharPtrAndSize(obj, &cptr, (size_t*)(0))) {
    if (val) *val = cptr;
    return 1;
  }
  if (val) {
    PyErr_SetString(PyExc_TypeError, "a char* is expected");
  }
  return 0;
}


SWIGSTATICINLINE(PyObject *)
SWIG_FromCharPtr(const char* cptr)
{ 
  if (cptr) {
    size_t size = strlen(cptr);
    if (size > INT_MAX) {
      return SWIG_NewPointerObj(swig_const_cast(cptr,char*), 
				SWIG_TypeQuery("char *"), 0);
    } else {
      if (size != 0) {
	return PyString_FromStringAndSize(cptr, size);
      } else {
	return PyString_FromString(cptr);
      }
    }
  }
  Py_INCREF(Py_None);
  return Py_None;
}


SWIGSTATICINLINE(PyObject* )
  SWIG_From_unsigned_SS_long(unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) 
    : PyInt_FromLong(swig_numeric_cast(value,long)); 
}


SWIGSTATICINLINE(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) {
    PyErr_SetString(PyExc_TypeError, "an unsigned long is expected");
  }
  return 0;
}


SWIGSTATICINLINE(unsigned long)
SWIG_As_unsigned_SS_long(PyObject* obj)
{
  unsigned long v;
  if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier.  the other
      solution is throw an exception, but since this code should work
      with plain C ....
     */
    memset((void*)&v, 0, sizeof(unsigned long));
  }
  return v;
}

  
SWIGSTATICINLINE(int)
SWIG_Check_unsigned_SS_long(PyObject* obj)
{
  return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
}


SWIGSTATIC(int)
SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
{ 
  char* cptr; size_t csize;  
  if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
    /* in C you can do:        

         char x[5] = "hello"; 

        ie, assing the array using an extra '0' char.
    */
    if ((csize == size + 1) && !(cptr[csize-1])) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize);
	if (csize < size) memset(val + csize, 0, size - csize);
      }
      return 1;
    }
  }
  if (val) {
    PyErr_Format(PyExc_TypeError, 
		 "a char array of maximum size %ld is expected", 
		 size);
  }
  return 0;
}


SWIGSTATICINLINE(PyObject *)
SWIG_FromCharArray(const char* carray, size_t size)
{
  if (size > INT_MAX) {
    SWIG_NewPointerObj(swig_const_cast(carray,char*), SWIG_TypeQuery("char *"), 0);
    return Py_None;    
  } else {
    return PyString_FromStringAndSize(carray, swig_numeric_cast(size,int));
  }
}

extern KadC_version_t const KadC_version;
#ifdef __cplusplus
extern "C" {
#endif
static PyObject *_wrap_KadCcontext_s_set(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    KadCcontext *arg1 = (KadCcontext *) 0 ;
    int arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:KadCcontext_s_set",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_KadCcontext,
    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
    arg2 = (int)SWIG_As_int(obj1); 
    if (PyErr_Occurred()) SWIG_fail;
    if (arg1) (arg1)->s = (KadC_status )arg2;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_KadCcontext_s_get(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    KadCcontext *arg1 = (KadCcontext *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:KadCcontext_s_get",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_KadCcontext,
    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
    result = (int) ((arg1)->s);
    
    resultobj = SWIG_From_int((int)result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_KadCcontext_errmsg1_set(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    KadCcontext *arg1 = (KadCcontext *) 0 ;
    char *arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:KadCcontext_errmsg1_set",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_KadCcontext,
    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
    {
        if (arg1->errmsg1) free((char*)arg1->errmsg1);
        if (arg2) {
            arg1->errmsg1 = (char *) malloc(strlen(arg2)+1);
            strcpy((char*)arg1->errmsg1,arg2);
        } else {
            arg1->errmsg1 = 0;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_KadCcontext_errmsg1_get(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    KadCcontext *arg1 = (KadCcontext *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:KadCcontext_errmsg1_get",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_KadCcontext,
    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
    result = (char *) ((arg1)->errmsg1);
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_KadCcontext_errmsg2_set(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    KadCcontext *arg1 = (KadCcontext *) 0 ;
    char *arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:KadCcontext_errmsg2_set",&obj0,&obj1)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_KadCcontext,
    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) SWIG_fail;
    {
        if (arg1->errmsg2) free((char*)arg1->errmsg2);
        if (arg2) {
            arg1->errmsg2 = (char *) malloc(strlen(arg2)+1);
            strcpy((char*)arg1->errmsg2,arg2);
        } else {
            arg1->errmsg2 = 0;
        }
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_KadCcontext_errmsg2_get(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    KadCcontext *arg1 = (KadCcontext *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:KadCcontext_errmsg2_get",&obj0)) goto fail;
    if ((SWIG_ConvertPtr(obj0,(void **)(&arg1),SWIGTYPE_p_KadCcontext,
    SWIG_POINTER_EXCEPTION | 0)) == -1) SWIG_fail;
    result = (char *) ((arg1)->errmsg2);
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_KadCcontext_pul_set(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    KadCcontext *arg1 = (KadCcontext *) 0 ;
    void *arg2 = (void *) 0 ;
    PyObject * obj0 = 0 ;