static void clearRegion(gPainter &painter, eWindowStyle &style, eListboxStyle *local_style, ePyObject pforeColor, ePyObject pforeColorSelected, ePyObject pbackColor, ePyObject pbackColorSelected, int selected, gRegion &rc, eRect &sel_clip, const ePoint &offset, bool cursorValid, bool clear=true) { if (selected && sel_clip.valid()) { gRegion part = rc - sel_clip; if (!part.empty()) { painter.clip(part); style.setStyle(painter, eWindowStyle::styleListboxNormal); clearRegionHelper(painter, local_style, offset, pbackColor, cursorValid, clear); painter.clippop(); selected = 0; } part = rc & sel_clip; if (!part.empty()) { painter.clip(part); style.setStyle(painter, eWindowStyle::styleListboxSelected); clearRegionSelectedHelper(painter, local_style, offset, pbackColorSelected, cursorValid, clear); painter.clippop(); selected = 1; } } else if (selected) { style.setStyle(painter, eWindowStyle::styleListboxSelected); clearRegionSelectedHelper(painter, local_style, offset, pbackColorSelected, cursorValid, clear); if (local_style && local_style->m_selection) painter.blit(local_style->m_selection, offset, eRect(), gPainter::BT_ALPHATEST); } else { style.setStyle(painter, eWindowStyle::styleListboxNormal); clearRegionHelper(painter, local_style, offset, pbackColor, cursorValid, clear); } if (selected) { if (pforeColorSelected) { unsigned int color = PyInt_AsUnsignedLongMask(pforeColorSelected); painter.setForegroundColor(gRGB(color)); } /* if we have a local foreground color set, use that. */ else if (local_style && local_style->m_foreground_color_selected_set) painter.setForegroundColor(local_style->m_foreground_color_selected); } else { if (pforeColor) { unsigned int color = PyInt_AsUnsignedLongMask(pforeColor); painter.setForegroundColor(gRGB(color)); } /* if we have a local foreground color set, use that. */ else if (local_style && local_style->m_foreground_color_set) painter.setForegroundColor(local_style->m_foreground_color); } }
/* This function not only tests the 'k' getargs code, but also the PyInt_AsUnsignedLongMask() and PyInt_AsUnsignedLongMask() functions. */ static PyObject * test_k_code(PyObject *self) { PyObject *tuple, *num; unsigned long value; tuple = PyTuple_New(1); if (tuple == NULL) return NULL; /* a number larger than ULONG_MAX even on 64-bit platforms */ num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16); if (num == NULL) return NULL; value = PyInt_AsUnsignedLongMask(num); if (value != ULONG_MAX) return raiseTestError("test_k_code", "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF"); PyTuple_SET_ITEM(tuple, 0, num); value = 0; if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0) return NULL; if (value != ULONG_MAX) return raiseTestError("test_k_code", "k code returned wrong value for long 0xFFF...FFF"); Py_DECREF(num); num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16); if (num == NULL) return NULL; value = PyInt_AsUnsignedLongMask(num); if (value != (unsigned long)-0x42) return raiseTestError("test_k_code", "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF"); PyTuple_SET_ITEM(tuple, 0, num); value = 0; if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0) return NULL; if (value != (unsigned long)-0x42) return raiseTestError("test_k_code", "k code returned wrong value for long -0xFFF..000042"); Py_DECREF(tuple); Py_INCREF(Py_None); return Py_None; }
static PyObject * win32_SetNamedPipeHandleState(PyObject *self, PyObject *args) { HANDLE hNamedPipe; PyObject *oArgs[3]; DWORD dwArgs[3], *pArgs[3] = {NULL, NULL, NULL}; int i; if (!PyArg_ParseTuple(args, F_HANDLE "OOO", &hNamedPipe, &oArgs[0], &oArgs[1], &oArgs[2])) return NULL; PyErr_Clear(); for (i = 0 ; i < 3 ; i++) { if (oArgs[i] != Py_None) { dwArgs[i] = PyInt_AsUnsignedLongMask(oArgs[i]); if (PyErr_Occurred()) return NULL; pArgs[i] = &dwArgs[i]; } } if (!SetNamedPipeHandleState(hNamedPipe, pArgs[0], pArgs[1], pArgs[2])) return PyErr_SetFromWindowsErr(0); Py_RETURN_NONE; }
// @object PROPSPEC|Identifies a property. Can be either an int property id, or a str/unicode property name. BOOL PyWinObject_AsPROPSPECs( PyObject *ob, PROPSPEC **ppRet, ULONG *pcRet) { TmpPyObject tuple=PyWinSequence_Tuple(ob, pcRet); if (tuple==NULL) return FALSE; size_t numBytes = sizeof(PROPSPEC) * *pcRet; *ppRet = (PROPSPEC *)malloc(numBytes); if (*ppRet==NULL) { PyErr_NoMemory(); return FALSE; } ZeroMemory(*ppRet, numBytes); for (DWORD i=0; i<*pcRet; i++) { PyObject *sub = PyTuple_GET_ITEM((PyObject *)tuple, i); (*ppRet)[i].propid = PyInt_AsUnsignedLongMask(sub); if ((*ppRet)[i].propid != (ULONG)-1 || !PyErr_Occurred()) (*ppRet)[i].ulKind = PRSPEC_PROPID; else{ PyErr_Clear(); (*ppRet)[i].lpwstr = NULL; if (PyWinObject_AsWCHAR(sub, &(*ppRet)[i].lpwstr)) (*ppRet)[i].ulKind = PRSPEC_LPWSTR; else{ PyErr_Clear(); PyErr_SetString(PyExc_TypeError, "PROPSPECs must be a sequence of strings or integers"); PyObject_FreePROPSPECs(*ppRet, *pcRet); *ppRet=NULL; return FALSE; } } } return TRUE; }
static PyObject* Cache_iterload(Cache* self, PyObject *args, PyObject *kwds) { PyObject *addrs; unsigned int length = 1; static char *kwlist[] = {"addrs", "length", NULL}; PyArg_ParseTupleAndKeywords(args, kwds, "O|I", kwlist, &addrs, &length); // Get and check iterator PyObject *addrs_iter = PyObject_GetIter(addrs); if(addrs_iter == NULL) { PyErr_SetString(PyExc_ValueError, "addrs is not iteratable"); return NULL; } // Iterate of elements in addrs PyObject *addr; while((addr = PyIter_Next(addrs_iter))) { // Each address is expanded to a certain length (default is 1) for(int i=0; i<length; i++) { #if PY_MAJOR_VERSION >= 3 Cache__load(self, PyLong_AsUnsignedLongMask(addr)+i); #else Cache__load(self, PyInt_AsUnsignedLongMask(addr)+i); #endif } Py_DECREF(addr); } Py_DECREF(addrs_iter); Py_RETURN_NONE; }
static void clearRegionHelper(gPainter &painter, eListboxStyle *local_style, const ePoint &offset, ePyObject &pbackColor, bool cursorValid, bool clear=true) { if (pbackColor) { unsigned int color = PyInt_AsUnsignedLongMask(pbackColor); painter.setBackgroundColor(gRGB(color)); } else if (local_style) { if (local_style && local_style->m_background_color_set) painter.setBackgroundColor(local_style->m_background_color); if (local_style->m_background && cursorValid) { if (local_style->m_transparent_background) painter.blit(local_style->m_background, offset, eRect(), gPainter::BT_ALPHATEST); else painter.blit(local_style->m_background, offset, eRect(), 0); return; } else if (local_style->m_transparent_background) return; } if (clear) painter.clear(); }
static void pybackend_ip_choose(u_int32_t *addr) { PyObject *ret = NULL; PyObject *arg0 = NULL; dbglog("pybackend plugin: ip_choose_hook(addr = %d)", *addr); arg0 = PyInt_FromSize_t(*addr); ret = pybackend_call_function("ip_choose_hook", 1, arg0); if (ret == NULL || ret == Py_None) { goto Exit; } if (!PyInt_Check(ret)) { warn("pybackend plugin: return value of ip_choose_hook() is not an int"); goto Exit; } // // No failure. // *addr = PyInt_AsUnsignedLongMask(ret); Exit: Py_CLEAR(arg0); Py_CLEAR(ret); dbglog("pybackend plugin: ip_choose_hook: %d", *addr); return; }
static PyObject * P_set(void *ptr, PyObject *value, Py_ssize_t size) { void *v; if (value == Py_None) { *(void **)ptr = NULL; _RET(value); } if (!PyInt_Check(value) && !PyLong_Check(value)) { PyErr_SetString(PyExc_TypeError, "cannot be converted to pointer"); return NULL; } #if SIZEOF_VOID_P <= SIZEOF_LONG v = (void *)PyInt_AsUnsignedLongMask(value); #else #ifndef HAVE_LONG_LONG # error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long" #elif SIZEOF_LONG_LONG < SIZEOF_VOID_P # error "PyLong_AsVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)" #endif v = (void *)PyInt_AsUnsignedLongLongMask(value); #endif if (PyErr_Occurred()) return NULL; *(void **)ptr = v; _RET(value); }
static PyObject * do_close_file (PyObject *self, PyObject *args, PyObject *kwds) { PyObject *cobj; PyObject *iobj; NsLibrary *lib; ns_RESULT res; uint32 file_id; if (!PyArg_ParseTuple (args, "OO", &cobj, &iobj)) { PyErr_SetString (PyExc_StandardError, "Could not parse arguments"); return NULL; } if (!PyCObject_Check (cobj) || !PyInt_Check (iobj)) { PyErr_SetString (PyExc_TypeError, "Wrong argument type(s)"); return NULL; } lib = PyCObject_AsVoidPtr (cobj); file_id = (uint32) PyInt_AsUnsignedLongMask (iobj); res = lib->CloseFile (file_id); if (check_result_is_error (res, lib)) return NULL; Py_RETURN_NONE; }
static PyObject * z_set(void *ptr, PyObject *value, Py_ssize_t size) { if (value == Py_None) { *(char **)ptr = NULL; Py_INCREF(value); return value; } if (PyString_Check(value)) { *(char **)ptr = PyString_AS_STRING(value); Py_INCREF(value); return value; } else if (PyUnicode_Check(value)) { PyObject *str = PyUnicode_AsEncodedString(value, _ctypes_conversion_encoding, _ctypes_conversion_errors); if (str == NULL) return NULL; *(char **)ptr = PyString_AS_STRING(str); return str; } else if (PyInt_Check(value) || PyLong_Check(value)) { #if SIZEOF_VOID_P == SIZEOF_LONG_LONG *(char **)ptr = (char *)PyInt_AsUnsignedLongLongMask(value); #else *(char **)ptr = (char *)PyInt_AsUnsignedLongMask(value); #endif _RET(value); } PyErr_Format(PyExc_TypeError, "string or integer address expected instead of %s instance", value->ob_type->tp_name); return NULL; }
void PythonScriptController_pyObjectToValue(PyObject* pyObject, unsigned int & val) { if (pyObject && pyObject!=Py_None && PyInt_Check(pyObject)) val = (unsigned int)PyInt_AsUnsignedLongMask(pyObject); else SP_MESSAGE_ERROR("Cannot convert pyObject to unsigned int"); }
static PyObject * do_get_index_by_time(PyObject *self, PyObject *args, PyObject *kwds) { NsLibrary *lib; PyObject *cobj; PyObject *iobj, *id_obj, *tp_obj, *fl_obj; double timepoint; uint32 file_id; uint32 entity_id; uint32 index; uint32 flags; ns_RESULT res; if (!PyArg_ParseTuple (args, "OOOOO", &cobj, &iobj, &id_obj, &tp_obj, &fl_obj)) { PyErr_SetString (PyExc_StandardError, "Could not parse arguments"); return NULL; } if (!PyCObject_Check (cobj) || !PyInt_Check (iobj) || !PyInt_Check (id_obj) || !PyFloat_Check (tp_obj) || !PyInt_Check (fl_obj)) { PyErr_SetString (PyExc_TypeError, "Wrong argument type(s)"); return NULL; } lib = PyCObject_AsVoidPtr (cobj); file_id = (uint32) PyInt_AsUnsignedLongMask (iobj); entity_id = (uint32) PyInt_AsUnsignedLongMask (id_obj); timepoint = PyFloat_AsDouble (tp_obj); flags = (uint32) PyInt_AsUnsignedLongMask (fl_obj); res = lib->GetIndexByTime (file_id, entity_id, timepoint, flags, &index); if (check_result_is_error (res, lib)) return NULL; return PyInt_FromLong (index); }
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 PyObject * fs_dir_iterate (Filesystem *self, PyObject *args, PyObject *kwargs) { errcode_t ret; WalkData wdata; PyObject *py_func, *py_data = NULL, *py_dir = NULL; uint64_t dir; int flags = OCFS2_DIRENT_FLAG_EXCLUDE_DOTS; static char *kwlist[] = { "callback", "data", "dir", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwargs, "O|OOi:dir_iterate", kwlist, &py_func, &py_data, &py_dir, &flags)) return NULL; if (!PyCallable_Check (py_func)) { PyErr_SetString (PyExc_TypeError, "callback must be a callable object"); return NULL; } if (py_dir == NULL || py_dir == Py_None) dir = self->fs->fs_root_blkno; else if (DirEntry_Check (py_dir)) dir = ((DirEntry *) py_dir)->dentry.inode; else if (PyInt_Check (py_dir)) dir = PyInt_AsUnsignedLongMask (py_dir); else if (PyLong_Check (py_dir)) dir = PyLong_AsUnsignedLongLongMask (py_dir); else { PyErr_SetString (PyExc_TypeError, "dir must be DirEntry or integer"); return NULL; } Py_INCREF (py_func); wdata.func = py_func; Py_XINCREF (py_data); wdata.data = py_data; wdata.fs = self; /* XXX: handle errors */ ret = ocfs2_dir_iterate (self->fs, dir, flags, NULL, walk_dirs, &wdata); Py_DECREF (py_func); Py_XDECREF (py_data); Py_INCREF (Py_None); return Py_None; }
static int hdrAppendItem(Header h, rpmTagVal tag, rpmTagType type, PyObject *item) { int rc = 0; switch (type) { case RPM_I18NSTRING_TYPE: /* XXX this needs to be handled separately */ case RPM_STRING_TYPE: case RPM_STRING_ARRAY_TYPE: { PyObject *str = NULL; if (utf8FromPyObject(item, &str)) rc = headerPutString(h, tag, PyBytes_AsString(str)); Py_XDECREF(str); } break; case RPM_BIN_TYPE: { uint8_t *val = (uint8_t *) PyBytes_AsString(item); rpm_count_t len = PyBytes_Size(item); rc = headerPutBin(h, tag, val, len); } break; case RPM_INT64_TYPE: { uint64_t val = PyInt_AsUnsignedLongLongMask(item); rc = headerPutUint64(h, tag, &val, 1); } break; case RPM_INT32_TYPE: { uint32_t val = PyInt_AsUnsignedLongMask(item); rc = headerPutUint32(h, tag, &val, 1); } break; case RPM_INT16_TYPE: { uint16_t val = PyInt_AsUnsignedLongMask(item); rc = headerPutUint16(h, tag, &val, 1); } break; case RPM_INT8_TYPE: case RPM_CHAR_TYPE: { uint8_t val = PyInt_AsUnsignedLongMask(item); rc = headerPutUint8(h, tag, &val, 1); } break; default: PyErr_SetString(PyExc_TypeError, "unhandled datatype"); } return rc; }
static PyObject * do_get_time_by_index (PyObject *self, PyObject *args, PyObject *kwds) { NsLibrary *lib; PyObject *cobj; PyObject *iobj, *id_obj, *idx_obj; uint32 file_id; uint32 entity_id; uint32 index; double timepoint; ns_RESULT res; if (!PyArg_ParseTuple (args, "OOOO", &cobj, &iobj, &id_obj, &idx_obj)) { PyErr_SetString (PyExc_StandardError, "Could not parse arguments"); return NULL; } if (!PyCObject_Check (cobj) || !PyInt_Check (iobj) || !PyInt_Check (id_obj) || !PyInt_Check (idx_obj)) { PyErr_SetString (PyExc_TypeError, "Wrong argument type(s)"); return NULL; } lib = PyCObject_AsVoidPtr (cobj); file_id = (uint32) PyInt_AsUnsignedLongMask (iobj); entity_id = (uint32) PyInt_AsUnsignedLongMask (id_obj); index = (uint32) PyInt_AsUnsignedLongMask (idx_obj); res = lib->GetTimeByIndex (file_id, entity_id, index, &timepoint); if (check_result_is_error (res, lib)) return NULL; return Py_BuildValue ("d", timepoint); }
PyObject* graph_colorize(PyObject* self, PyObject* pyobject) { INIT_SELF_GRAPH(); unsigned int ncolors = PyInt_AsUnsignedLongMask(pyobject); try { so->_graph->colorize(ncolors); RETURN_VOID(); } catch (std::runtime_error e) { PyErr_SetString(PyExc_RuntimeError, e.what()); return NULL; } }
static PyObject * ETContext_open(ETContextObject* self, PyObject *args) { DWORD dwRet; ET_OPENINFO OpenInfo; PyObject *pyOpenInfo=NULL; if (!PyArg_ParseTuple(args, "|O", &pyOpenInfo)) { return NULL; } Py_XINCREF(pyOpenInfo); #if defined(WIN32) if(NULL != pyOpenInfo){ //printf("PyTuple_Check(pyOpenInfo)=%d\n",PyTuple_Check(pyOpenInfo)); //printf("PyTuple_Size(pyOpenInfo)=%d\n",PyTuple_Size(pyOpenInfo)); //printf("PyInt_Check(PyTuple_GetItem(pyOpenInfo,0)=%d\n",PyInt_Check(PyTuple_GetItem(pyOpenInfo,0))); //printf("PyInt_Check(PyTuple_GetItem(pyOpenInfo,1))=%d\n",PyInt_Check(PyTuple_GetItem(pyOpenInfo,1))); if(!PyTuple_Check(pyOpenInfo) || 2!=PyTuple_Size(pyOpenInfo) || !PyInt_Check(PyTuple_GetItem(pyOpenInfo,0)) || !PyInt_Check(PyTuple_GetItem(pyOpenInfo,1))){ INVALID_PARAMS("Open Info must be a tuple with 2 integers.",NULL); } OpenInfo.dwOpenInfoSize=PyInt_AsUnsignedLongMask(PyTuple_GetItem(pyOpenInfo,0)); OpenInfo.dwShareMode=PyInt_AsUnsignedLongMask(PyTuple_GetItem(pyOpenInfo,1)); //printf("OpenInfo: %08x,%08x\n",OpenInfo.dwOpenInfoSize,OpenInfo.dwShareMode); dwRet= ETOpenEx(&self->context,&OpenInfo); }else{ dwRet = ETOpen(&self->context); } #else dwRet = ETOpen(&self->context); #endif /*WIN32 | LINUX*/ Py_XDECREF(pyOpenInfo); DWRET_VALIDATE(dwRet,NULL); Py_XINCREF(self); return self; }
static int get_ulong(PyObject *v, unsigned long *p) { unsigned long x; if (PyFloat_Check(v)) { PyErr_SetString(PyExc_TypeError, "int expected instead of float"); return -1; } x = PyInt_AsUnsignedLongMask(v); if (x == (unsigned long)-1 && PyErr_Occurred()) return -1; *p = x; return 0; }
static inline int seq2array(const PyObject *seq, u8 *arr) { u8 i, j; PyObject *item; for(i = 0; i < 10; i++) { arr[i] = 0; for (j = 0; j < 8; j++) { item = PySequence_Fast_GET_ITEM(seq, 8 * i + j); if(!item) return 1; arr[i] |= (((u8)PyInt_AsUnsignedLongMask(item)) << j); } } return 0; }
bool py_to_color(PyObject *o, SproxelColor &c) { if (PyInt_Check(o) || PyLong_Check(o)) { unsigned i=PyInt_AsUnsignedLongMask(o); if (PyErr_Occurred()) { PyErr_Clear(); i=PyLong_AsUnsignedLongMask(o); if (PyErr_Occurred()) return false; } if ((i&0xFF000000)==0 && i!=0) i|=0xFF000000; c.a=((i>>24)&0xFF)/255.0f; c.r=((i>>16)&0xFF)/255.0f; c.g=((i>> 8)&0xFF)/255.0f; c.b=((i )&0xFF)/255.0f; return true; }
QUISK_EXPORT long QuiskGetConfigLong(const char * name, long deflt) { // return deflt for failure. Accept int or float. long res; PyObject * attr; if (!quisk_pyConfig || PyErr_Occurred()) { return deflt; } attr = PyObject_GetAttrString(quisk_pyConfig, name); if (attr) { res = PyInt_AsUnsignedLongMask(attr); // This works for floats too! Py_DECREF(attr); return res; // success } else { PyErr_Clear(); } return deflt; // failure }
static PyObject * ETContext_create_dir(ETContextObject* self, PyObject *args) { BYTE pszDirId[5]={0}; WORD dirId=0; DWORD dwRet,dwDirSize,dwFlags=ET_CREATE_ROOT_DIR; ET_CREATEDIRINFO createInfo={0}; PyObject *pyDirInfo=NULL,*pyAtr=NULL; if(!PyArg_ParseTuple(args, "HII|O", &dirId,&dwDirSize,&dwFlags,&pyDirInfo)) { return NULL; } Py_XINCREF(pyDirInfo); if(0!=dirId){ sprintf(pszDirId,"%04x",dirId); }else{ dwDirSize=0; dwFlags=ET_CREATE_ROOT_DIR; } if(NULL != pyDirInfo){ if(!PyTuple_Check(pyDirInfo) || 2!=PyTuple_Size(pyDirInfo) || !PyInt_Check(PyTuple_GetItem(pyDirInfo,0)) || !PyString_Check(PyTuple_GetItem(pyDirInfo,1))){ INVALID_PARAMS("DirInfo should be a tuple with one integer and one bytearray!",NULL); } pyAtr = PyTuple_GetItem(pyDirInfo,1); Py_XINCREF(pyAtr); dwRet = PyString_Size(pyAtr); if(dwRet>16 || dwRet<1){ INVALID_PARAMS("ATR length must between 1~16!",NULL); } createInfo.dwCreateDirInfoSize = PyInt_AsUnsignedLongMask(PyTuple_GetItem(pyDirInfo,0)); memcpy(createInfo.szAtr,PyString_AsString(pyAtr),dwRet); dwRet = ETCreateDirEx(&self->context,pszDirId,dwDirSize,dwFlags,&createInfo); DWRET_VALIDATE(dwRet,NULL); }else{ dwRet = ETCreateDir(&self->context,pszDirId,dwDirSize,dwFlags); DWRET_VALIDATE(dwRet,NULL); } Py_XDECREF(pyAtr); Py_XDECREF(pyDirInfo); Py_RETURN_TRUE; }
// Alocates and populates an array of DWORDS from a sequence of Python ints BOOL PyWinObject_AsDWORDArray(PyObject *obdwords, DWORD **pdwords, DWORD *item_cnt, BOOL bNoneOk) { BOOL ret=TRUE; DWORD bufsize, tuple_index; PyObject *dwords_tuple=NULL, *tuple_item; *pdwords=NULL; *item_cnt=0; if (obdwords==Py_None){ if (bNoneOk) return TRUE; PyErr_SetString(PyExc_ValueError,"Sequence of dwords cannot be None"); return FALSE; } if ((dwords_tuple=PyWinSequence_Tuple(obdwords, item_cnt))==NULL) return FALSE; // last exit without cleaning up bufsize=*item_cnt * sizeof(DWORD); *pdwords=(DWORD *)malloc(bufsize); if (*pdwords==NULL){ PyErr_Format(PyExc_MemoryError, "Unable to allocate %d bytes", bufsize); ret=FALSE; } else for (tuple_index=0; tuple_index<*item_cnt; tuple_index++){ tuple_item=PyTuple_GET_ITEM(dwords_tuple,tuple_index); // Doesn't check for overflow, but will accept a python long // greater than INT_MAX (even on python 2.3). Also accepts // negatives and converts to the correct hex representation (*pdwords)[tuple_index]=PyInt_AsUnsignedLongMask(tuple_item); if (((*pdwords)[tuple_index]==-1) && PyErr_Occurred()){ ret=FALSE; break; } } if (!ret) if (*pdwords!=NULL){ free(*pdwords); *pdwords=NULL; *item_cnt=0; } Py_XDECREF(dwords_tuple); return ret; }
static ePyObject lookupColor(ePyObject color, ePyObject data) { if (color == Py_None) return ePyObject(); if ((!color) && (!data)) return color; unsigned int icolor = PyInt_AsUnsignedLongMask(color); /* check if we have the "magic" template color */ if ((icolor & 0xFF000000) == 0xFF000000) { int index = icolor & 0xFFFFFF; eDebug("[eListboxPythonMultiContent] template color index: %d", index); return PyTuple_GetItem(data, index); } if (color == Py_None) return ePyObject(); return color; }
static ePyObject lookupColor(ePyObject color, ePyObject data) { if (color == Py_None) return ePyObject(); if ((!color) && (!data)) return color; unsigned int icolor = PyInt_AsUnsignedLongMask(color); /* check if we have the "magic" template color */ if (data && (icolor & 0xFF000000) == 0xFF000000) { int index = icolor & 0xFFFFFF; if (PyTuple_GetItem(data, index) == Py_None) return ePyObject(); return PyTuple_GetItem(data, index); } if (color == Py_None) return ePyObject(); return color; }
static void __pyx_f_13cunsignedlong_f(void) { unsigned long __pyx_v_x; PyObject *__pyx_v_y; unsigned long __pyx_1; PyObject *__pyx_2 = 0; __pyx_v_y = Py_None; Py_INCREF(Py_None); /* "/Local/Projects/D/Pyrex/Source/Tests/8/cunsignedlong.pyx":4 */ __pyx_1 = PyInt_AsUnsignedLongMask(__pyx_v_y); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; goto __pyx_L1;} __pyx_v_x = __pyx_1; /* "/Local/Projects/D/Pyrex/Source/Tests/8/cunsignedlong.pyx":5 */ __pyx_2 = PyLong_FromUnsignedLong(__pyx_v_x); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; goto __pyx_L1;} Py_DECREF(__pyx_v_y); __pyx_v_y = __pyx_2; __pyx_2 = 0; goto __pyx_L0; __pyx_L1:; Py_XDECREF(__pyx_2); __Pyx_WriteUnraisable("cunsignedlong.f"); __pyx_L0:; Py_DECREF(__pyx_v_y); }
int get_python_uint_value(PyObject* dv, unsigned int* pint) { int cc = 1; if (PyInt_Check(dv) || PyLong_Check(dv)) { unsigned long v = PyInt_AsUnsignedLongMask(dv); *pint = (unsigned int)v; } else if (PyString_Check(dv)) { /* Convert from string to int */ unsigned long tid; char *endptr; char* p = PyString_AsString(dv); tid = strtoul(p, &endptr, 10); if(endptr == p || *endptr) cc = -1; /* Invalid numeric format */ else *pint = (unsigned int)tid; } else { cc = -1; /* Don't know how to convert this */ } return cc; }
static PyObject * fs_dir_scan (Filesystem *self, PyObject *args, PyObject *kwargs) { errcode_t ret; PyObject *py_dir = NULL; uint64_t dir; int flags = OCFS2_DIR_SCAN_FLAG_EXCLUDE_DOTS; ocfs2_dir_scan *scan; static char *kwlist[] = { "dir", "flags", NULL }; if (!PyArg_ParseTupleAndKeywords (args, kwargs, "|Oi:dir_scan", kwlist, &py_dir, &flags)) return NULL; if (py_dir == NULL || py_dir == Py_None) dir = self->fs->fs_root_blkno; else if (DirEntry_Check (py_dir)) dir = ((DirEntry *) py_dir)->dentry.inode; else if (PyInt_Check (py_dir)) dir = PyInt_AsUnsignedLongMask (py_dir); else if (PyLong_Check (py_dir)) dir = PyLong_AsUnsignedLongLongMask (py_dir); else { PyErr_SetString (PyExc_TypeError, "dir must be DirEntry or integer"); return NULL; } CHECK_ERROR (ocfs2_open_dir_scan (self->fs, dir, flags, &scan)); return dir_scan_iter_new (self, scan); }
static char * convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf, size_t bufsize, PyObject **freelist) { char *format = *p_format; char c = *format++; switch (c) { case 'b': { /* unsigned byte -- very short int */ char *p = va_arg(*p_va, char *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<b>", arg, msgbuf, bufsize); else if (ival < 0) { PyErr_SetString(PyExc_OverflowError, "unsigned byte integer is less than minimum"); return converterr("integer<b>", arg, msgbuf, bufsize); } else if (ival > UCHAR_MAX) { PyErr_SetString(PyExc_OverflowError, "unsigned byte integer is greater than maximum"); return converterr("integer<b>", arg, msgbuf, bufsize); } else *p = (unsigned char) ival; break; } case 'B': {/* byte sized bitfield - both signed and unsigned values allowed */ char *p = va_arg(*p_va, char *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsUnsignedLongMask(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<B>", arg, msgbuf, bufsize); else *p = (unsigned char) ival; break; } case 'h': {/* signed short int */ short *p = va_arg(*p_va, short *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<h>", arg, msgbuf, bufsize); else if (ival < SHRT_MIN) { PyErr_SetString(PyExc_OverflowError, "signed short integer is less than minimum"); return converterr("integer<h>", arg, msgbuf, bufsize); } else if (ival > SHRT_MAX) { PyErr_SetString(PyExc_OverflowError, "signed short integer is greater than maximum"); return converterr("integer<h>", arg, msgbuf, bufsize); } else *p = (short) ival; break; } case 'H': { /* short int sized bitfield, both signed and unsigned allowed */ unsigned short *p = va_arg(*p_va, unsigned short *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsUnsignedLongMask(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<H>", arg, msgbuf, bufsize); else *p = (unsigned short) ival; break; } case 'i': {/* signed int */ int *p = va_arg(*p_va, int *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<i>", arg, msgbuf, bufsize); else if (ival > INT_MAX) { PyErr_SetString(PyExc_OverflowError, "signed integer is greater than maximum"); return converterr("integer<i>", arg, msgbuf, bufsize); } else if (ival < INT_MIN) { PyErr_SetString(PyExc_OverflowError, "signed integer is less than minimum"); return converterr("integer<i>", arg, msgbuf, bufsize); } else *p = ival; break; } case 'I': { /* int sized bitfield, both signed and unsigned allowed */ unsigned int *p = va_arg(*p_va, unsigned int *); unsigned int ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsUnsignedLongMask(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<I>", arg, msgbuf, bufsize); else *p = ival; break; } case 'l': {/* long int */ long *p = va_arg(*p_va, long *); long ival; if (float_argument_error(arg)) return NULL; ival = PyInt_AsLong(arg); if (ival == -1 && PyErr_Occurred()) return converterr("integer<l>", arg, msgbuf, bufsize); else *p = ival; break; } case 'k': { /* long sized bitfield */ unsigned long *p = va_arg(*p_va, unsigned long *); unsigned long ival; if (PyInt_Check(arg)) ival = PyInt_AsUnsignedLongMask(arg); else if (PyLong_Check(arg)) ival = PyLong_AsUnsignedLongMask(arg); else return converterr("integer<k>", arg, msgbuf, bufsize); *p = ival; break; } case 'f': {/* float */ float *p = va_arg(*p_va, float *); double dval = PyFloat_AsDouble(arg); if (PyErr_Occurred()) return converterr("float<f>", arg, msgbuf, bufsize); else *p = (float) dval; break; } case 'd': {/* double */ double *p = va_arg(*p_va, double *); double dval = PyFloat_AsDouble(arg); if (PyErr_Occurred()) return converterr("float<d>", arg, msgbuf, bufsize); else *p = dval; break; } case 'c': {/* char */ char *p = va_arg(*p_va, char *); if (PyString_Check(arg) && PyString_Size(arg) == 1) *p = PyString_AS_STRING(arg)[0]; else return converterr("char", arg, msgbuf, bufsize); break; } case 's': {/* string */ if (*format == '#') { void **p = (void **)va_arg(*p_va, char **); int *q = va_arg(*p_va, int *); if (PyString_Check(arg)) { *p = PyString_AS_STRING(arg); *q = PyString_GET_SIZE(arg); } else { /* any buffer-like object */ char *buf; int count = convertbuffer(arg, p, &buf); if (count < 0) return converterr(buf, arg, msgbuf, bufsize); *q = count; } format++; } else { char **p = va_arg(*p_va, char **); if (PyString_Check(arg)) *p = PyString_AS_STRING(arg); else return converterr("string", arg, msgbuf, bufsize); if ((int)strlen(*p) != PyString_Size(arg)) return converterr("string without null bytes", arg, msgbuf, bufsize); } break; }