void tcaxlib_convert_tcas_list_to_buf(PyObject *tcasList, tcas_unit **pTcasBuf, tcas_u32 *pCount) {
int i, count;
PyObject *pyTcasItem;
tcas_s16 x, y;
tcas_u32 rgb;
tcas_byte alpha;
tcas_unit *tcasBuf;
count = PyList_GET_SIZE(tcasList);
/* tcas buffer from user tcax py script: (Start, End, Layer_Type_Pair, PosX, PosY, RGB, Alpha) */
/* a raw tcas chunk defined in TCC file format specification: (Start, End, Layer_Type_Pair, Pos, RGBA) */
tcasBuf = (tcas_unit *)malloc(count * 5 * sizeof(tcas_unit));
for (i = 0; i < count; i++) {
pyTcasItem = PyList_GET_ITEM(tcasList, i);
x = (tcas_s16)PyLong_AsLong(PyTuple_GET_ITEM(pyTcasItem, 3));
y = (tcas_s16)PyLong_AsLong(PyTuple_GET_ITEM(pyTcasItem, 4));
rgb = (tcas_u32)PyLong_AsUnsignedLong(PyTuple_GET_ITEM(pyTcasItem, 5));
alpha = (tcas_byte)PyLong_AsLong(PyTuple_GET_ITEM(pyTcasItem, 6));
tcasBuf[5 * i + 0] = (tcas_s32)PyLong_AsLong(PyTuple_GET_ITEM(pyTcasItem, 0)); /* Start */
tcasBuf[5 * i + 1] = (tcas_s32)PyLong_AsLong(PyTuple_GET_ITEM(pyTcasItem, 1)); /* End */
tcasBuf[5 * i + 2] = (tcas_unit)PyLong_AsUnsignedLong(PyTuple_GET_ITEM(pyTcasItem, 2)); /* Layer_Type_Pair */
tcasBuf[5 * i + 3] = MAKEPOS(x, y);
tcasBuf[5 * i + 4] = (rgb | ((tcas_u32)alpha << 24));
}
*pTcasBuf = tcasBuf;
*pCount = count;
}
bool_t gen_mcev_from_evrepr(PyObject *evrepr, uint_t *tick, midicev_t *mcev)
{
Py_ssize_t list_len = PyTuple_Size(evrepr);
unsigned long chan, type, val1, val2;
if (list_len < 5)
return FALSE;
/* todo: more test */
*tick = (uint_t) PyLong_AsUnsignedLong(PyTuple_GetItem(evrepr, 0));
chan = PyLong_AsUnsignedLong(PyTuple_GetItem(evrepr, 1));
type = PyLong_AsUnsignedLong(PyTuple_GetItem(evrepr, 2));
val1 = PyLong_AsUnsignedLong(PyTuple_GetItem(evrepr, 3));
val2 = PyLong_AsUnsignedLong(PyTuple_GetItem(evrepr, 4));
mcev->chan = (byte_t) chan;
mcev->type = (byte_t) type;
switch (type)
{
case NOTEOFF:
case NOTEON:
mcev->event.note.num = (byte_t) val1;
mcev->event.note.val = (byte_t) val2;
break;
case CONTROLCHANGE:
mcev->event.ctrl.num = (byte_t) val1;
mcev->event.ctrl.val = (byte_t) val2;
break;
case PITCHWHEELCHANGE:
mcev->event.pitchbend.Lval = (byte_t) val1;
mcev->event.pitchbend.Hval = (byte_t) val2;
break;
default:
;
}
return TRUE;
}
static PyObject* pyGLTexture__enter__(pyGLTexture* self) {
// Is the image already loaded?
PyObjectRef bindcode = PyObject_GetAttrString(self->m_blenderImage, "bindcode");
// bindcode changed to a sequence in 2.77. We want the first element for a 2D texture.
// Why did we make this change, exactly?
if (PySequence_Check(bindcode)) {
bindcode = PySequence_GetItem(bindcode, TEXTARGET_TEXTURE_2D);
}
// Now we should have a GLuint...
if (!PyLong_Check(bindcode)) {
PyErr_SetString(PyExc_TypeError, "Image bindcode isn't a long?");
return NULL;
}
glGetIntegerv(GL_TEXTURE_BINDING_2D, &self->m_prevImage);
GLuint image_bindcode = PyLong_AsUnsignedLong(bindcode);
self->m_ownIt = image_bindcode == 0;
// Load image into GL
if (self->m_ownIt) {
PyObjectRef new_bind = PyObject_CallMethod(self->m_blenderImage, "gl_load", NULL);
if (!PyLong_Check(new_bind)) {
PyErr_SetString(PyExc_TypeError, "gl_load() did not return a long");
return NULL;
}
ssize_t result = PyLong_AsSize_t(new_bind);
if (result != GL_NO_ERROR) {
PyErr_Format(PyExc_RuntimeError, "gl_load() error: %d", result);
return NULL;
}
bindcode = PyObject_GetAttrString(self->m_blenderImage, "bindcode");
if (PySequence_Check(bindcode)) {
bindcode = PySequence_GetItem(bindcode, TEXTARGET_TEXTURE_2D);
}
// Now we should have a GLuint...
if (!PyLong_Check(bindcode)) {
PyErr_SetString(PyExc_TypeError, "Image bindcode isn't a long?");
return NULL;
}
image_bindcode = PyLong_AsUnsignedLong(bindcode);
}
// Set image as current in GL
if (self->m_prevImage != image_bindcode) {
self->m_changedState = true;
glBindTexture(GL_TEXTURE_2D, image_bindcode);
}
// Misc GL state
glGetTexParameteriv(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, &self->m_mipmapState);
Py_INCREF(self);
return (PyObject*)self;
}
// @object PySPropTagArray|A sequence of integers
BOOL PyMAPIObject_AsSPropTagArray(PyObject *obta, SPropTagArray **ppta)
{
if (obta==Py_None) {
*ppta = NULL;
return TRUE;
}
BOOL bSeq = TRUE;
int seqLen;
if (PySequence_Check(obta)) {
seqLen = PySequence_Length(obta);
} else if (PyInt_Check(obta)) {
seqLen = 1;
bSeq = FALSE;
} else {
PyErr_SetString(PyExc_TypeError, "SPropTagArray must be a sequence of integers");
return FALSE;
}
DWORD cBytes = (seqLen * sizeof(ULONG)) + sizeof(ULONG);
SPropTagArray *pta;
HRESULT hr = MAPIAllocateBuffer(cBytes, (void **)&pta);
if (FAILED(hr)) {
OleSetOleError(hr);
return FALSE;
}
pta->cValues = seqLen;
if (bSeq) {
for (ULONG i=0;i<(ULONG)seqLen;i++) {
PyObject *obItem = PySequence_GetItem(obta, i);
if (obItem==NULL) {
MAPIFreeBuffer(pta);
return FALSE;
}
pta->aulPropTag[i] = PyLong_AsUnsignedLong(obItem);
if (PyErr_Occurred()) {
Py_DECREF(obItem);
MAPIFreeBuffer(pta);
return FALSE;
}
Py_DECREF(obItem);
}
} else {
// Simple int.
pta->aulPropTag[0] = PyLong_AsUnsignedLong(obta);
}
*ppta = pta;
return TRUE;
}
static int convertTo_std_vector_1900(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
std::vector<uint> **sipCppPtr = reinterpret_cast<std::vector<uint> **>(sipCppPtrV);
#line 330 "/home/kdbanman/browseRDF/tulip-3.8.0-src/library/tulip-python/stl/vector.sip"
// Check if type is compatible
if (sipIsErr == NULL) {
if (!PyList_Check(sipPy)) {
return 0;
}
for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i) {
PyObject *item = PyList_GET_ITEM(sipPy, i);
if (!PyLong_Check(item)) {
printErrorMessage("TypeError : object in list of type " + std::string(item->ob_type->tp_name) + " can not be converted to int");
return 0;
}
}
return 1;
}
// Convert Python list of integers to a std::vector<int>
std::vector<unsigned int> *v = new std::vector<unsigned int>();
v->reserve(PyList_GET_SIZE(sipPy));
for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i) {
v->push_back(PyLong_AsUnsignedLong(PyList_GET_ITEM(sipPy, i)));
}
*sipCppPtr = v;
return sipGetState(sipTransferObj);
#line 76 "/home/kdbanman/browseRDF/tulip-3.8.0-src/build/library/tulip-python/stl/sipstlstdvector1900.cpp"
}
static int lightblueobex_add4byteheader(obex_t *obex, obex_object_t *obj, uint8_t hi, PyObject *value)
{
obex_headerdata_t hv;
uint32_t intvalue;
DEBUG("%s()\n", __func__);
if (value == NULL)
return -1;
if (PyInt_Check(value)) {
intvalue = PyInt_AsLong(value);
if (PyErr_Occurred()) {
DEBUG("\tcan't convert header 0x%02x int value to long", hi);
PyErr_Clear();
return -1;
}
} else if (PyLong_Check(value)) {
intvalue = PyLong_AsUnsignedLong(value);
if (PyErr_Occurred()) {
DEBUG("\tcan't convert header 0x%02x long value to long", hi);
PyErr_Clear();
return -1;
}
} else {
DEBUG("\theader value for id 0x%02x must be int or long, was %s\n",
hi, value->ob_type->tp_name);
return -1;
}
hv.bq4 = intvalue;
return OBEX_ObjectAddHeader(obex, obj, hi, hv, 4, OBEX_FL_FIT_ONE_PACKET);
}
static INLINE unsigned long __Pyx_PyInt_AsUnsignedLong(PyObject* x) {
#if PY_VERSION_HEX < 0x03000000
if (likely(PyInt_CheckExact(x) || PyInt_Check(x))) {
long val = PyInt_AS_LONG(x);
if (unlikely(val < 0)) {
PyErr_SetString(PyExc_OverflowError,
"can't convert negative value to unsigned long");
return (unsigned long)-1;
}
return (unsigned long)val;
} else
#endif
if (likely(PyLong_CheckExact(x) || PyLong_Check(x))) {
if (unlikely(Py_SIZE(x) < 0)) {
PyErr_SetString(PyExc_OverflowError,
"can't convert negative value to unsigned long");
return (unsigned long)-1;
}
return PyLong_AsUnsignedLong(x);
} else {
unsigned long val;
PyObject *tmp = __Pyx_PyNumber_Int(x);
if (!tmp) return (unsigned long)-1;
val = __Pyx_PyInt_AsUnsignedLong(tmp);
Py_DECREF(tmp);
return val;
}
}
bool IntType<SPECIFY_TYPE>::isSameType(PyObject* pyValue)
{
int ival = 0;
if(PyLong_Check(pyValue))
{
ival = (int)PyLong_AsLong(pyValue);
if(PyErr_Occurred())
{
PyErr_Clear();
ival = (int)PyLong_AsUnsignedLong(pyValue);
if (PyErr_Occurred())
{
OUT_TYPE_ERROR("INT");
return false;
}
}
}
else
{
OUT_TYPE_ERROR("INT");
return false;
}
SPECIFY_TYPE val = (SPECIFY_TYPE)ival;
if(ival != int(val))
{
ERROR_MSG("IntType::isSameType:%d is out of range (currVal = %d).\n", ival, int(val));
return false;
}
return true;
}
static T extract(PyObject* intermediate)
{
unsigned long x = PyLong_AsUnsignedLong(intermediate);
if (PyErr_Occurred())
throw_error_already_set();
return numeric_cast<T>(x);
}
PyObject *
Blame_getitem(Blame *self, PyObject *value)
{
size_t i;
const git_blame_hunk *hunk;
if (PyLong_Check(value) < 0) {
PyErr_SetObject(PyExc_IndexError, value);
return NULL;
}
i = PyLong_AsUnsignedLong(value);
if (PyErr_Occurred()) {
PyErr_SetObject(PyExc_IndexError, value);
return NULL;
}
hunk = git_blame_get_hunk_byindex(self->blame, i);
if (!hunk) {
PyErr_SetObject(PyExc_IndexError, value);
return NULL;
}
return wrap_blame_hunk(hunk, self);
}
static CYTHON_INLINE signed long __Pyx_PyInt_AsSignedLong(PyObject* x) {
const signed long neg_one = (signed long)-1, const_zero = 0;
const int is_unsigned = neg_one > const_zero;
#if PY_VERSION_HEX < 0x03000000
if (likely(PyInt_Check(x))) {
long val = PyInt_AS_LONG(x);
if (is_unsigned && unlikely(val < 0)) {
PyErr_SetString(PyExc_OverflowError,
"can't convert negative value to signed long");
return (signed long)-1;
}
return (signed long)val;
} else
#endif
if (likely(PyLong_Check(x))) {
if (is_unsigned) {
if (unlikely(Py_SIZE(x) < 0)) {
PyErr_SetString(PyExc_OverflowError,
"can't convert negative value to signed long");
return (signed long)-1;
}
return (signed long)PyLong_AsUnsignedLong(x);
} else {
return (signed long)PyLong_AsLong(x);
}
} else {
signed long val;
PyObject *tmp = __Pyx_PyNumber_Int(x);
if (!tmp) return (signed long)-1;
val = __Pyx_PyInt_AsSignedLong(tmp);
Py_DECREF(tmp);
return val;
}
}
static int Stroke_texture_id_set(BPy_Stroke *self, PyObject *value, void *UNUSED(closure))
{
unsigned int i = PyLong_AsUnsignedLong(value);
if (PyErr_Occurred())
return -1;
self->s->setTextureId(i);
return 0;
}
static int FEdgeSmooth_material_index_set(BPy_FEdgeSmooth *self, PyObject *value, void *UNUSED(closure))
{
unsigned int i = PyLong_AsUnsignedLong(value);
if (PyErr_Occurred())
return -1;
self->fes->setFrsMaterialIndex(i);
return 0;
}
void _extract(PyObject *obj, unsigned long &val)
{
if (PyInt_Check(obj))
val = (unsigned long)PyInt_AsUnsignedLongMask(obj);
else if (PyFloat_Check(obj))
val = (unsigned long)PyFloat_AsDouble(obj);
else
val = PyLong_AsUnsignedLong(obj);
}
static void to_td_val(td_val_t *out, PyObject *pVal)
{
PyObject *pStr;
td_array_t *arr;
PyArrayObject *pArr;
td_tag_t tag = py_type_to_td(pVal);
switch (tag) {
case TD_INT32:
out->tag = TD_INT32;
if (PyInt_Check(pVal))
out->int32_val = PyInt_AS_LONG(pVal);
else
out->int32_val = PyLong_AsLong(pVal);
break;
case TD_UINT32:
out->tag = TD_UINT32;
out->uint32_val = PyLong_AsUnsignedLong(pVal);
break;
case TD_INT64:
out->tag = TD_INT64;
out->int64_val = PyLong_AsLongLong(pVal);
break;
case TD_UINT64:
out->tag = TD_UINT64;
out->uint64_val = PyLong_AsUnsignedLongLong(pVal);
break;
case TD_DOUBLE:
out->tag = TD_DOUBLE;
out->double_val = PyFloat_AsDouble(pVal);
break;
case TD_UTF8:
pStr = pVal;
if (PyUnicode_Check(pStr)) pStr = PyUnicode_AsUTF8String(pStr);
size_t len = PyString_Size(pStr);
char* data = malloc((len+1)*sizeof(char));
strcpy(PyString_AsString(pStr), data);
td_string_t *obj = malloc(sizeof(td_string_t));
obj->length = len;
obj->data = (void*) data;
out->tag = TD_UTF8;
out->object = (void*) obj;
break;
case TD_ARRAY:
arr = (td_array_t *)malloc(sizeof(td_array_t));
pArr = (PyArrayObject *) pVal;
arr->data = PyArray_DATA(pArr);
arr->length = PyArray_SIZE(pArr);
arr->eltype = numpy_type_to_td(PyArray_TYPE(pArr));
arr->ndims = PyArray_NDIM(pArr);
break;
default:
out->tag = TD_OBJECT;
out->owner = td_env_python(NULL, NULL);
out->object = pVal;
}
}
static int convertTo_QPair_1900_1900(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
::QPair<uint,uint> **sipCppPtr = reinterpret_cast< ::QPair<uint,uint> **>(sipCppPtrV);
#line 63 "/home/thais/Faculdade/TCC/NEW/PyQt4_gpl_x11-4.12/sip/QtCore/qpair.sip"
// Check the type if that is all that is required.
if (sipIsErr == NULL)
return (PyTuple_Size(sipPy) == 2);
QPair<unsigned, unsigned> *qp = new QPair<unsigned, unsigned>;
qp->first = PyLong_AsUnsignedLong(PyTuple_GET_ITEM(sipPy, 0));
qp->second = PyLong_AsUnsignedLong(PyTuple_GET_ITEM(sipPy, 1));
*sipCppPtr = qp;
return sipGetState(sipTransferObj);
#line 83 "/home/thais/Faculdade/TCC/NEW/PyQt4_gpl_x11-4.12/QtCore/sipQtCoreQPair19001900.cpp"
}
PyObject *
Diff_getitem(Diff *self, PyObject *value)
{
size_t i;
if (!PyLong_Check(value))
return NULL;
i = PyLong_AsUnsignedLong(value);
return diff_get_patch_byindex(self->diff, i);
}
static PyObject *
_wrap_sugar_key_grabber_get_key(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "keycode", "state", NULL };
PyObject *py_keycode = NULL, *py_state = NULL;
gchar *ret;
guint keycode = 0, state = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:Sugar.KeyGrabber.get_key", kwlist, &py_keycode, &py_state))
return NULL;
if (py_keycode) {
if (PyLong_Check(py_keycode))
keycode = PyLong_AsUnsignedLong(py_keycode);
else if (PyInt_Check(py_keycode))
keycode = PyInt_AsLong(py_keycode);
else
PyErr_SetString(PyExc_TypeError, "Parameter 'keycode' must be an int or a long");
if (PyErr_Occurred())
return NULL;
}
if (py_state) {
if (PyLong_Check(py_state))
state = PyLong_AsUnsignedLong(py_state);
else if (PyInt_Check(py_state))
state = PyInt_AsLong(py_state);
else
PyErr_SetString(PyExc_TypeError, "Parameter 'state' must be an int or a long");
if (PyErr_Occurred())
return NULL;
}
ret = sugar_key_grabber_get_key(SUGAR_KEY_GRABBER(self->obj), keycode, state);
if (ret) {
PyObject *py_ret = PyString_FromString(ret);
g_free(ret);
return py_ret;
}
Py_INCREF(Py_None);
return Py_None;
}
// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP PyGPropertyDescriptionList::GetCount(UINT * pcElem)
{
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetCount", &result);
if (FAILED(hr)) return hr;
*pcElem = PyLong_AsUnsignedLong(result);
if (*pcElem == (UINT)-1 && PyErr_Occurred())
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetCount");
Py_DECREF(result);
return hr;
}
static int convertTo_std_pair_1900_1900(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
std::pair<uint,uint> **sipCppPtr = reinterpret_cast<std::pair<uint,uint> **>(sipCppPtrV);
#line 391 "/home/kdbanman/browseRDF/tulip-3.8.0-src/library/tulip-python/stl/pair.sip"
PyObject *itm1 = NULL;
PyObject *itm2 = NULL;
if (sipIsErr == NULL) {
if (!(PyTuple_Check(sipPy) && PyTuple_Size(sipPy) == 2))
return 0;
itm1 = PyTuple_GetItem(sipPy, 0);
itm2 = PyTuple_GetItem(sipPy, 1);
bool ok = PyLong_Check(itm1);
ok = ok && PyLong_Check(itm2);
if (!ok) {
return 0;
}
return 1;
}
itm1 = PyTuple_GetItem(sipPy, 0);
itm2 = PyTuple_GetItem(sipPy, 1);
int t1State = 0;
int t2State = 0;
unsigned int ui1 = PyLong_AsUnsignedLong(itm1);
unsigned int ui2 = PyLong_AsUnsignedLong(itm2);
std::pair<unsigned int, unsigned int> *p = new std::pair<unsigned int, unsigned int>(ui1, ui2);
*sipCppPtr = p;
return sipGetState(sipTransferObj);
#line 85 "/home/kdbanman/browseRDF/tulip-3.8.0-src/build/library/tulip-python/stl/sipstlstdpair19001900.cpp"
}
//-------------------------------------------------------------------------------------
void SpaceAvatarSelect::kbengine_onEvent(const KBEngine::EventData* lpEventData)
{
switch(lpEventData->id)
{
case CLIENT_EVENT_SCRIPT:
{
const KBEngine::EventData_Script* peventdata = static_cast<const KBEngine::EventData_Script*>(lpEventData);
if(peventdata->name == "update_avatars")
{
if(peventdata->argsSize > 0)
{
PyObject* pyitem = PyTuple_GetItem(peventdata->pyDatas, 0);
for(KBEngine::uint32 i=0; i<g_avatars.size(); i++)
{
mTrayMgr->destroyWidget(g_avatars[i]);
}
g_avatars.clear();
PyObject *key, *value;
Py_ssize_t pos = 0;
while (PyDict_Next(pyitem, &pos, &key, &value))
{
wchar_t* PyUnicode_AsWideCharStringRet0 = PyUnicode_AsWideCharString(PyDict_GetItemString(value, "name"), NULL);
char* name = wchar2char(PyUnicode_AsWideCharStringRet0);
PyMem_Free(PyUnicode_AsWideCharStringRet0);
KBEngine::DBID dbid = 0;
dbid = PyLong_AsUnsignedLongLong(key);
if (PyErr_Occurred())
{
dbid = PyLong_AsUnsignedLong(key);
}
if (PyErr_Occurred())
{
PyErr_PrintEx(0);
}
Ogre::String str = Ogre::String(name) + "_" + KBEngine::StringConv::val2str(dbid);
g_avatars.push_back(str);
mTrayMgr->createButton(OgreBites::TL_CENTER, str, str, 300);
free(name);
}
}
}
}
break;
default:
break;
};
}
STDMETHODIMP PyGShellItemArray::GetCount(
/* [out] */ DWORD * pdwNumItems)
{
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetCount", &result);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
*pdwNumItems = PyLong_AsUnsignedLong(result);
hr = PyCom_SetAndLogCOMErrorFromPyException("GetCount", IID_IShellItemArray);
Py_DECREF(result);
return hr;
}
PyObject *
set_flags(PyObject *self, PyObject *args)
{
PyTypeObject *cls;
PyLongObject *flags_object;
if (!PyArg_UnpackTuple(args, "set_flags", 2, 2, &cls, &flags_object))
return NULL;
unsigned long flags = PyLong_AsUnsignedLong(flags_object);
cls->tp_flags = flags;
Py_RETURN_NONE;
}
static int
get_ulong(PyObject *v, unsigned long *p)
{
if (PyLong_Check(v)) {
unsigned long x = PyLong_AsUnsignedLong(v);
if (x == (unsigned long)(-1) && PyErr_Occurred())
return -1;
*p = x;
return 0;
}
else {
return get_long(v, (long *)p);
}
}
// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP PyGShellItemResources::GetAttributes(
/* [out] */ DWORD * pdwAttributes)
{
PY_GATEWAY_METHOD;
PyObject *result;
HRESULT hr=InvokeViaPolicy("GetAttributes", &result);
if (FAILED(hr)) return hr;
// Process the Python results, and convert back to the real params
*pdwAttributes = PyLong_AsUnsignedLong(result);
if (*pdwAttributes == -1 && PyErr_Occurred())
hr = MAKE_PYCOM_GATEWAY_FAILURE_CODE("GetAttributes");
Py_DECREF(result);
return hr;
}
Interface(int beam_width,
PyObject * py_early_stop_callback,
PyObject * py_shift_callback,
PyObject * py_reduce_callback,
PyObject * py_feature_cb
){
if(PyLong_Check(py_shift_callback)){
shifted_state_generator=(State_Generator *) PyLong_AsUnsignedLong(py_shift_callback);
}else{
shifted_state_generator=new Python_State_Generator(py_shift_callback);
};
reduced_state_generator=NULL;
if(py_reduce_callback!=Py_None){
reduced_state_generator=new Python_Reduced_State_Generator(py_reduce_callback);
};
if(PyLong_Check( py_feature_cb)){
feature_generator=(Feature_Generator*) PyLong_AsUnsignedLong( py_feature_cb);
}else{
feature_generator=new Python_Feature_Generator( py_feature_cb);
};
early_stop_checker=NULL;
if(py_early_stop_callback!=Py_None){
early_stop_checker=new Python_Early_Stop_Checker(py_early_stop_callback);
}
raw=NULL;
this->beam_width=beam_width;
this->data=new General_Searcher_Data(
early_stop_checker,
shifted_state_generator,
reduced_state_generator,
feature_generator);
this->push_down=new My_Searcher(this->data,beam_width);
};
static int
get_wrapped_ulong(PyObject *v, unsigned long *p)
{
long x = (long)PyLong_AsUnsignedLong(v);
if (x == -1 && PyErr_Occurred()) {
PyObject *wrapped;
PyErr_Clear();
#ifdef PY_STRUCT_FLOAT_COERCE
if (PyFloat_Check(v)) {
PyObject *o;
int res;
PyErr_Clear();
if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)
return -1;
o = PyNumber_Int(v);
if (o == NULL)
return -1;
res = get_wrapped_ulong(o, p);
Py_DECREF(o);
return res;
}
#endif
wrapped = PyNumber_And(v, pylong_ulong_mask);
if (wrapped == NULL)
return -1;
if (PyErr_WarnEx(PyExc_DeprecationWarning, INT_OVERFLOW, 2) < 0) {
Py_DECREF(wrapped);
return -1;
}
x = (long)PyLong_AsUnsignedLong(wrapped);
Py_DECREF(wrapped);
if (x == -1 && PyErr_Occurred())
return -1;
}
*p = (unsigned long)x;
return 0;
}
static PyObject *
_wrap_sugar_key_grabber_is_modifier(PyGObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = { "keycode", "mask", NULL };
PyObject *py_keycode = NULL, *py_mask = NULL;
int ret;
guint keycode = 0, mask = -1;
if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O|O:Sugar.KeyGrabber.is_modifier", kwlist, &py_keycode, &py_mask))
return NULL;
if (py_keycode) {
if (PyLong_Check(py_keycode))
keycode = PyLong_AsUnsignedLong(py_keycode);
else if (PyInt_Check(py_keycode))
keycode = PyInt_AsLong(py_keycode);
else
PyErr_SetString(PyExc_TypeError, "Parameter 'keycode' must be an int or a long");
if (PyErr_Occurred())
return NULL;
}
if (py_mask) {
if (PyLong_Check(py_mask))
mask = PyLong_AsUnsignedLong(py_mask);
else if (PyInt_Check(py_mask))
mask = PyInt_AsLong(py_mask);
else
PyErr_SetString(PyExc_TypeError, "Parameter 'mask' must be an int or a long");
if (PyErr_Occurred())
return NULL;
}
ret = sugar_key_grabber_is_modifier(SUGAR_KEY_GRABBER(self->obj), keycode, mask);
return PyBool_FromLong(ret);
}
//-------------------------------------------------------------------------------------
PyObject* PyMemoryStream::__unpickle__(PyObject* self, PyObject* args)
{
Py_ssize_t size = PyTuple_Size(args);
if (size != 3)
{
ERROR_MSG("PyMemoryStream::__unpickle__: args is wrong! (size != 3)");
S_Return;
}
PyObject* pyRpos = PyTuple_GET_ITEM(args, 0);
PyObject* pyWpos = PyTuple_GET_ITEM(args, 1);
PyObject* pybytes = PyTuple_GET_ITEM(args, 2);
if (pybytes == NULL)
{
ERROR_MSG("PyMemoryStream::__unpickle__: args is wrong!");
S_Return;
}
PyMemoryStream* pPyMemoryStream = new PyMemoryStream(pybytes);
pPyMemoryStream->stream().rpos(PyLong_AsUnsignedLong(pyRpos));
pPyMemoryStream->stream().wpos(PyLong_AsUnsignedLong(pyWpos));
return pPyMemoryStream;
}
//-------------------------------------------------------------------------------------
PyObject* Blob::__unpickle__(PyObject* self, PyObject* args)
{
Py_ssize_t size = PyTuple_Size(args);
if(size != 3)
{
ERROR_MSG("Blob::__unpickle__: args is error! size != 3");
S_Return;
}
PyObject* pyRpos = PyTuple_GET_ITEM(args, 0);
PyObject* pyWpos = PyTuple_GET_ITEM(args, 1);
PyObject* pybytes = PyTuple_GET_ITEM(args, 2);
if(pybytes == NULL)
{
ERROR_MSG("Blob::__unpickle__: args is error!");
S_Return;
}
Blob* pBlob = new Blob(pybytes);
pBlob->stream().rpos(PyLong_AsUnsignedLong(pyRpos));
pBlob->stream().wpos(PyLong_AsUnsignedLong(pyWpos));
return pBlob;
}