void callback(uint64_t prime){ if (*i < pi){ PyList_SET_ITEM(list, (*i)++, PyInt_FromSize_t(prime)); } else { PyObject* pyprime = PyInt_FromSize_t(prime); PyList_Append(list, pyprime); Py_DECREF(pyprime); } }
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 int pybackend_allowed_address(u_int32_t addr) { int result = 0; PyObject *ret = NULL; PyObject *arg0 = NULL; dbglog("pybackend plugin: allowed_address_hook(addr = %d)", addr); arg0 = PyInt_FromSize_t(addr); ret = pybackend_call_function("allowed_address_hook", 1, arg0); if (ret == NULL || ret == Py_None) { goto Exit; } if (!PyBool_Check(ret)) { warn("pybackend plugin: allowed_address_hook() did not return a boolean value"); goto Exit; } if (ret == Py_True) { result = 1; } Exit: Py_CLEAR(arg0); Py_CLEAR(ret); dbglog("pybackend plugin: allowed_address_hook: %d", result); return result; }
/** * Calculate key size. */ static PyObject * key_sizeof(Key *self) { size_t sz = sizeof(Key); if(self->flags == KEY_SHARED) { sz += sizeof(SharedKeyInfo); } else { sz += Key_SIZE(self); } return PyInt_FromSize_t(sz); }
static PyObject * _getattr4 (PyObject *self, char *name) { PyAuthData *py_ad = (PyAuthData *)self; struct mu_auth_data *ad = py_ad->auth_data; if (!ad) return NULL; if (strcmp (name, "name") == 0) return PyString_FromString (ad->name); else if (strcmp (name, "passwd") == 0) return PyString_FromString (ad->passwd); /* FIXME: The use of PyInt_FromSize_t to convert uid_t and gid_t is a bit dubious, but so far there's no other feasible way in Python, save for converting uid (gid) to string and using PyInt_FromString. */ else if (strcmp (name, "uid") == 0) return PyInt_FromSize_t (ad->uid); else if (strcmp (name, "gid") == 0) return PyInt_FromSize_t (ad->gid); else if (strcmp (name, "gecos") == 0) return PyString_FromString (ad->gecos); else if (strcmp (name, "dir") == 0) return PyString_FromString (ad->dir); else if (strcmp (name, "shell") == 0) return PyString_FromString (ad->shell); else if (strcmp (name, "mailbox") == 0) return PyString_FromString (ad->mailbox); else if (strcmp (name, "source") == 0) return PyString_FromString (ad->source); else if (strcmp (name, "quota") == 0) /* FIXME: quota is mu_off_t rather than size_t. See comment for uid above */ return PyInt_FromSize_t (ad->quota); else if (strcmp (name, "flags") == 0) return PyInt_FromLong (ad->flags); else if (strcmp (name, "change_uid") == 0) return PyInt_FromLong (ad->change_uid); return NULL; }
static PyObject * api_mime_get_num_parts (PyObject *self, PyObject *args) { int status; size_t nparts; PyMime *py_mime; if (!PyArg_ParseTuple (args, "O!", &PyMimeType, &py_mime)) return NULL; status = mu_mime_get_num_parts (py_mime->mime, &nparts); return status_object (status, PyInt_FromSize_t (nparts)); }
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { #if PY_VERSION_HEX < 0x02050000 if (ival <= LONG_MAX) return PyInt_FromLong((long)ival); else { unsigned char *bytes = (unsigned char *) &ival; int one = 1; int little = (int)*(unsigned char*)&one; return _PyLong_FromByteArray(bytes, sizeof(size_t), little, 0); } #else return PyInt_FromSize_t(ival); #endif }
static PyObject *py_lz4f_getFrameInfo(PyObject *self, PyObject *args) { const char *source; int src_size; LZ4F_decompressionContext_t dCtx; LZ4F_frameInfo_t frameInfo; PyObject *blkSize; PyObject *blkMode; PyObject *contChkFlag; PyObject *py_dCtx; PyObject *result = PyDict_New(); size_t ssrc_size; size_t err; (void)self; if (!PyArg_ParseTuple(args, "s#O", &source, &src_size, &py_dCtx)) { return NULL; } dCtx = (LZ4F_decompressionContext_t)PyCapsule_GetPointer(py_dCtx, NULL); ssrc_size = (size_t)src_size; err = LZ4F_getFrameInfo(dCtx, &frameInfo, (unsigned char*)source, &ssrc_size); CHECK(LZ4F_isError(err), "Failed getting frameInfo. (error %i)", (int)err); blkSize = PyInt_FromSize_t(frameInfo.blockSizeID); blkMode = PyInt_FromSize_t(frameInfo.blockMode); contChkFlag = PyInt_FromSize_t(frameInfo.contentChecksumFlag); PyDict_SetItemString(result, "blkSize", blkSize); PyDict_SetItemString(result, "blkMode", blkMode); PyDict_SetItemString(result, "chkFlag", contChkFlag); return result; _output_error: return Py_None; }
static PyObject* factorize(PyObject* self, PyObject* args){ Py_ssize_t n = 0; if (!PyArg_ParseTuple(args, "n:factorize", &n)) return NULL; PyObject* prime_factorization = PyList_New(0); if (n < 2) return prime_factorization; size_t i = 0; while (!(n & 1)){ n /= 2; i++; } if (i > 0){ PyObject* tuple = PyTuple_Pack(2, PyInt_FromLong(2), PyInt_FromSize_t(i)); PyList_Append(prime_factorization, tuple); Py_DECREF(tuple); } Py_ssize_t p = 3; while (p*p <= n){ i = 0; while (n % p == 0){ n /= p; i++; } if (i > 0){ PyObject* tuple = PyTuple_Pack(2, PyInt_FromSsize_t(p), PyInt_FromSize_t(i)); PyList_Append(prime_factorization, tuple); Py_DECREF(tuple); } p += 2; } if (n > 1){ PyObject* tuple = PyTuple_Pack(2, PyInt_FromSsize_t(n), PyInt_FromLong(1)); PyList_Append(prime_factorization, tuple); Py_DECREF(tuple); } return prime_factorization; }
static PyObject * hash(PyObject * self, PyObject * args) { PyArrayObject * desc; PyObject * out_list; int cnt = 0; // get reference to the numpy.ndarray that OpenCV stores the descriptor matrix in if(!PyArg_ParseTuple(args, "O!", &PyArray_Type, &desc)) { PyErr_SetString(lsh_error, "Invalid arguments."); return NULL; } // get a pointer to the input matrix (must be contiguous!!!!!) unsigned char * arr = (unsigned char *)PyArray_DATA(desc); // get the dimensions of the input matrix npy_intp * dims = PyArray_DIMS(desc); // allocate output out_list = PyList_New(dims[0] * NUMBER_OF_TABLES); if(!out_list) { PyErr_SetString(lsh_error, "Failed to allocate list."); return NULL; } // for each feature... for(int i = 0; i < dims[0]; i++) { // for each table... for(int tb = 0; tb < NUMBER_OF_TABLES; tb++) { // hash the feature size_t key_raw = get_key(tb, arr); // store in the output PyObject * key = PyInt_FromSize_t(key_raw); PyList_SET_ITEM(out_list, cnt, key); cnt++; } // move to the next feature arr += FEATURE_SIZE; } return out_list; }
static PyObject *py_lz4f_decompress(PyObject *self, PyObject *args, PyObject *keywds) { const char* source; char* dest; LZ4F_decompressionContext_t dCtx; int src_size; PyObject *decomp; PyObject *next; PyObject *py_dCtx; PyObject *result = PyDict_New(); size_t ssrc_size; size_t dest_size; size_t err; static char *kwlist[] = {"source", "dCtx", "blkSizeID"}; unsigned int blkID=7; (void)self; if (!PyArg_ParseTupleAndKeywords(args, keywds, "s#O|i", kwlist, &source, &src_size, &py_dCtx, &blkID)) { return NULL; } dest_size = LZ4S_GetBlockSize_FromBlockId(blkID); dCtx = (LZ4F_decompressionContext_t)PyCapsule_GetPointer(py_dCtx, NULL); ssrc_size = (size_t)src_size; dest = (char*)malloc(dest_size); err = LZ4F_decompress(dCtx, dest, &dest_size, source, &ssrc_size, NULL); CHECK(LZ4F_isError(err), "Failed getting frameInfo. (error %i)", (int)err); //fprintf(stdout, "Dest_size: %zu Error Code:%zu \n", dest_size, err); decomp = PyBytes_FromStringAndSize(dest, dest_size); next = PyInt_FromSize_t(err); PyDict_SetItemString(result, "decomp", decomp); PyDict_SetItemString(result, "next", next); Py_XDECREF(decomp); Py_XDECREF(next); free(dest); return result; _output_error: return Py_None; }
std::vector<std::string> PyInterpreter::Complete(const std::string& cmd, int max_options) { std::vector<std::string> ret; PyErr_Clear(); if(pycomplete) { for(int i=0; i < max_options; ++i) { #if PY_MAJOR_VERSION >= 3 PyUniqueObj args = PyTuple_Pack( 2, PyUnicode_FromString(cmd.c_str()), PyLong_FromSize_t(i) ); PyUniqueObj result = PyObject_CallObject(pycomplete, args); if (result && PyUnicode_Check(result)) { std::string res_str(PyUnicode_AsUTF8(result)); #else PyUniqueObj args = PyTuple_Pack(2, PyString_FromString(cmd.c_str()), PyInt_FromSize_t(i)); PyUniqueObj result = PyObject_CallObject(pycomplete, args); if (result && PyString_Check(result)) { std::string res_str(PyString_AsString(result)); #endif if( res_str.find("__")==std::string::npos || cmd.find("__")!=std::string::npos || (cmd.size() > 0 && cmd[cmd.size()-1] == '_') ) { ret.push_back( res_str ); } }else{ break; } } } return ret; } void PyInterpreter::PushCommand(const std::string& cmd) { PyUniqueObj obj = EvalExec(cmd); if(obj && obj != Py_None) { const std::string output = ToString(obj); line_queue.push( ConsoleLine(output, ConsoleLineTypeOutput) ); } }
static PyObject* _mktime_ymd(PyObject* self, PyObject* arg) { if (!PyUnicode_CheckExact(arg)) return NULL; Py_UNICODE *src = PyUnicode_AS_UNICODE(arg), *bPtr; size_t year = 0, month = 0, day = 0, timestamp = 0, multiplier, size = PyUnicode_GET_SIZE(arg); if (size >= 4) { ATOI(src, src + 4, year); } if (size >= 6) { ATOI(src + 4, src + 6, month); } if (size >= 8) { ATOI(src + 6, src + 8, day); } if (year < 1970 || year > 2038 || month > 13 || day > 32) { Py_RETURN_NONE; } timestamp = YEARS[year - 1970] + (IS_LEAP(year) ? MONTHS2[month] : MONTHS1[month]) + DAYS[day]; return PyInt_FromSize_t(timestamp); }
static PyObject* _mktime_tuple(PyObject* self, PyObject* arg) { if (!PyTuple_CheckExact(arg)) return NULL; PyTupleObject* tuple = (PyTupleObject*) arg; size_t year = 0, month = 0, day = 0, hour = 0, minute = 0, second = 0, size = tuple->ob_size, timestamp = 0; if (size > 0) year = PyInt_AsSsize_t(tuple->ob_item[0]); if (size > 1) month = PyInt_AsSsize_t(tuple->ob_item[1]); if (size > 2) day = PyInt_AsSsize_t(tuple->ob_item[2]); if (size > 3) hour = PyInt_AsSsize_t(tuple->ob_item[3]); if (size > 4) minute = PyInt_AsSsize_t(tuple->ob_item[4]); if (size > 5) second = PyInt_AsSsize_t(tuple->ob_item[5]); if (year < 1970 || year > 2038 || month > 13 || day > 32 || hour > 24 || minute > 60 || second > 60) { Py_RETURN_NONE; } timestamp = YEARS[year - 1970] + (IS_LEAP(year) ? MONTHS2[month] : MONTHS1[month]) + DAYS[day] + HOURS[hour] + MINUTES[minute] + second; return PyInt_FromSize_t(timestamp); }
static PyObject* sys_getsizeof(PyObject* self, PyObject* args, PyObject* kwds) noexcept { static const char* kwlist[] = { "object", "default", 0 }; size_t size; PyObject* o, * dflt = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof", const_cast<char**>(kwlist), &o, &dflt)) return NULL; size = _PySys_GetSizeOf(o); if (size == (size_t)-1 && PyErr_Occurred()) { /* Has a default value been given */ if (dflt != NULL && PyErr_ExceptionMatches(PyExc_TypeError)) { PyErr_Clear(); Py_INCREF(dflt); return dflt; } else return NULL; } return PyInt_FromSize_t(size); }
static void pybackend_notifier(void *hook, int arg) { const char *name = (const char *)hook; PyObject *ret = NULL; PyObject *arg0 = NULL; dbglog("pybackend plugin: %s(arg = %d)", name, arg); arg0 = PyInt_FromSize_t(arg); ret = pybackend_call_function(name, 1, arg0); if (ret == NULL || ret == Py_None) { goto Exit; } Exit: Py_CLEAR(arg0); Py_CLEAR(ret); dbglog("pybackend plugin: %s: void", name); return; }
void Pywrap::AddArgument (unsigned int argument) { PyTuple_SetItem(args, index, PyInt_FromSize_t(argument)); index++; }
PyObject * option(PyObject *self, PyObject *args) { long option; int error; PyObject *py_option; py_option = PyTuple_GetItem(args, 0); if (!py_option) return NULL; if (!PyInt_Check(py_option)) return Error_type_error( "option should be an integer, got %.200s", py_option); option = PyInt_AsLong(py_option); switch (option) { case GIT_OPT_GET_MWINDOW_SIZE: { size_t size; error = git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &size); if (error < 0) return Error_set(error); return PyInt_FromSize_t(size); } case GIT_OPT_SET_MWINDOW_SIZE: { size_t size; PyObject *py_size; py_size = PyTuple_GetItem(args, 1); if (!py_size) return NULL; if (!PyInt_Check(py_size)) return Error_type_error( "size should be an integer, got %.200s", py_size); size = PyInt_AsSize_t(py_size); error = git_libgit2_opts(GIT_OPT_SET_MWINDOW_SIZE, size); if (error < 0) return Error_set(error); Py_RETURN_NONE; } case GIT_OPT_GET_MWINDOW_MAPPED_LIMIT: { size_t limit; error = git_libgit2_opts(GIT_OPT_GET_MWINDOW_MAPPED_LIMIT, &limit); if (error < 0) return Error_set(error); return PyInt_FromSize_t(limit); } case GIT_OPT_SET_MWINDOW_MAPPED_LIMIT: { size_t limit; PyObject *py_limit; py_limit = PyTuple_GetItem(args, 1); if (!py_limit) return NULL; if (PyInt_Check(py_limit)) { limit = PyInt_AsSize_t(py_limit); } else if (PyLong_Check(py_limit)) { limit = PyLong_AsSize_t(py_limit); } else { return Error_type_error( "limit should be an integer, got %.200s", py_limit); } error = git_libgit2_opts(GIT_OPT_SET_MWINDOW_MAPPED_LIMIT, limit); if (error < 0) return Error_set(error); Py_RETURN_NONE; } case GIT_OPT_GET_SEARCH_PATH: { PyObject *py_level; py_level = PyTuple_GetItem(args, 1); if (!py_level) return NULL; if (!PyInt_Check(py_level)) return Error_type_error( "level should be an integer, got %.200s", py_level); return get_search_path(PyInt_AsLong(py_level)); } case GIT_OPT_SET_SEARCH_PATH: { PyObject *py_level, *py_path, *tpath; const char *path; int err; py_level = PyTuple_GetItem(args, 1); if (!py_level) return NULL; py_path = PyTuple_GetItem(args, 2); if (!py_path) return NULL; if (!PyInt_Check(py_level)) return Error_type_error( "level should be an integer, got %.200s", py_level); path = py_str_borrow_c_str(&tpath, py_path, NULL); if (!path) return NULL; err = git_libgit2_opts( GIT_OPT_SET_SEARCH_PATH, PyInt_AsLong(py_level), path); Py_DECREF(tpath); if (err < 0) return Error_set(err); Py_RETURN_NONE; } case GIT_OPT_SET_CACHE_OBJECT_LIMIT: { size_t limit; int object_type; PyObject *py_object_type, *py_limit; py_object_type = PyTuple_GetItem(args, 1); if (!py_object_type) return NULL; py_limit = PyTuple_GetItem(args, 2); if (!py_limit) return NULL; if (!PyInt_Check(py_limit)) return Error_type_error( "limit should be an integer, got %.200s", py_limit); object_type = PyInt_AsLong(py_object_type); limit = PyInt_AsSize_t(py_limit); error = git_libgit2_opts( GIT_OPT_SET_CACHE_OBJECT_LIMIT, object_type, limit); if (error < 0) return Error_set(error); Py_RETURN_NONE; } case GIT_OPT_SET_CACHE_MAX_SIZE: { size_t max_size; PyObject *py_max_size; py_max_size = PyTuple_GetItem(args, 1); if (!py_max_size) return NULL; if (!PyInt_Check(py_max_size)) return Error_type_error( "max_size should be an integer, got %.200s", py_max_size); max_size = PyInt_AsSize_t(py_max_size); error = git_libgit2_opts(GIT_OPT_SET_CACHE_MAX_SIZE, max_size); if (error < 0) return Error_set(error); Py_RETURN_NONE; } case GIT_OPT_GET_CACHED_MEMORY: { size_t current; size_t allowed; PyObject* tup = PyTuple_New(2); error = git_libgit2_opts(GIT_OPT_GET_CACHED_MEMORY, ¤t, &allowed); if (error < 0) return Error_set(error); PyTuple_SetItem(tup, 0, PyInt_FromLong(current)); PyTuple_SetItem(tup, 1, PyInt_FromLong(allowed)); return tup; } case GIT_OPT_SET_SSL_CERT_LOCATIONS: { PyObject *py_file, *py_dir; const char *file_path, *dir_path; int err; py_file = PyTuple_GetItem(args, 1); py_dir = PyTuple_GetItem(args, 2); /* py_file and py_dir are only valid if they are strings */ if (PyUnicode_Check(py_file) || PyBytes_Check(py_file)) { file_path = py_str_to_c_str(py_file, Py_FileSystemDefaultEncoding); } else { file_path = NULL; } if (PyUnicode_Check(py_dir) || PyBytes_Check(py_dir)) { dir_path = py_str_to_c_str(py_dir, Py_FileSystemDefaultEncoding); } else { dir_path = NULL; } err = git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS, file_path, dir_path); if (err < 0) return Error_set(err); Py_RETURN_NONE; } // int enabled case GIT_OPT_ENABLE_CACHING: case GIT_OPT_ENABLE_STRICT_OBJECT_CREATION: case GIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATION: case GIT_OPT_ENABLE_OFS_DELTA: case GIT_OPT_ENABLE_FSYNC_GITDIR: case GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION: case GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY: { PyObject *py_enabled; int enabled; py_enabled = PyTuple_GetItem(args, 1); if (!py_enabled) return NULL; if (!PyInt_Check(py_enabled)) return Error_type_error("expected integer, got %.200s", py_enabled); enabled = PyInt_AsSize_t(py_enabled); error = git_libgit2_opts(option, enabled); if (error < 0) return Error_set(error); Py_RETURN_NONE; } // Not implemented case GIT_OPT_GET_TEMPLATE_PATH: case GIT_OPT_SET_TEMPLATE_PATH: case GIT_OPT_SET_USER_AGENT: case GIT_OPT_SET_SSL_CIPHERS: case GIT_OPT_GET_USER_AGENT: case GIT_OPT_GET_WINDOWS_SHAREMODE: case GIT_OPT_SET_WINDOWS_SHAREMODE: case GIT_OPT_SET_ALLOCATOR: case GIT_OPT_GET_PACK_MAX_OBJECTS: case GIT_OPT_SET_PACK_MAX_OBJECTS: { Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } } PyErr_SetString(PyExc_ValueError, "unknown/unsupported option value"); return NULL; }
static void _seq_set_int(PyObject* seq, locale_t loc, ssize_t index, char data) { PyObject* item = PyInt_FromSize_t(data); if (item!=NULL) PyStructSequence_SET_ITEM(seq, index, item); }
void callback(uint64_t p){ if (++i == n){ prime = PyInt_FromSize_t(p); throw StopPrimeGeneration(); } }
PyObject* XPolygon_size(PyObject *obj, PyObject *args) { XPolygon *self = (XPolygon*)obj; return PyInt_FromSize_t(self->line_ring.point_list.size()); }
static PyObject * sizeof_py_ssize_t(PyObject *self, PyObject *args) { return PyInt_FromSize_t(sizeof(Py_ssize_t)); }
static void _sieve_action_printer (void *data, mu_stream_t stream, size_t msgno, mu_message_t msg, const char *action, const char *fmt, va_list ap) { PyObject *py_args; PyObject *py_dict = PyDict_New (); PyStream *py_stm; if (!py_dict) return; py_stm = PyStream_NEW (); if (py_stm) { PyMessage *py_msg = PyMessage_NEW (); char *buf = NULL; size_t buflen = 0; if (py_msg) { PyStream *py_stm = PyStream_NEW (); if (py_stm) { py_stm->stm = stream; mu_stream_ref (stream); py_msg->msg = msg; Py_INCREF (py_msg); PyDict_SetItemString (py_dict, "msgno", PyInt_FromSize_t (msgno)); PyDict_SetItemString (py_dict, "msg", (PyObject *)py_msg); PyDict_SetItemString (py_dict, "action", PyString_FromString (action ? action : "")); if (mu_vasnprintf (&buf, &buflen, fmt, ap)) { mu_stream_unref (stream); return; } PyDict_SetItemString (py_dict, "text", PyString_FromString (buf ? buf : "")); free (buf); py_args = PyTuple_New (1); if (py_args) { struct _mu_py_sieve_logger *s = data; PyObject *py_fnc = s->py_action_printer; Py_INCREF (py_dict); PyTuple_SetItem (py_args, 0, py_dict); if (py_fnc && PyCallable_Check (py_fnc)) PyObject_CallObject (py_fnc, py_args); Py_DECREF (py_dict); Py_DECREF (py_args); } } } } }
// _tnetstring_load: parse tnetstring-format value from a file. // // This takes care to read no more data than is required to get the // full tnetstring-encoded value. It might read arbitrarily-much // data if the file doesn't begin with a valid tnetstring. // static PyObject* _tnetstring_load(PyObject* self, PyObject *args) { PyObject *val = NULL; PyObject *file = NULL; PyObject *encoding = Py_None; PyObject *methnm = NULL; PyObject *metharg = NULL; PyObject *res = NULL; tns_ops *ops = &_tnetstring_ops_bytes; char c, *data; size_t datalen = 0; if(!PyArg_UnpackTuple(args, "load", 1, 2, &file, &encoding)) { goto error; } Py_INCREF(file); if(encoding != Py_None) { if(!PyString_Check(encoding)) { PyErr_SetString(PyExc_TypeError, "encoding must be a string"); goto error; } Py_INCREF(encoding); ops = _tnetstring_get_unicode_ops(encoding); if(ops == NULL) { goto error; } } // We're going to read one char at a time if((methnm = PyString_FromString("read")) == NULL) { goto error; } if((metharg = PyInt_FromLong(1)) == NULL) { goto error; } // Read the length prefix one char at a time res = PyObject_CallMethodObjArgs(file, methnm, metharg, NULL); if(res == NULL) { goto error; } Py_INCREF(res); if(!PyString_Check(res) || !PyString_GET_SIZE(res)) { PyErr_SetString(PyExc_ValueError, "Not a tnetstring: invalid or missing length prefix"); goto error; } c = PyString_AS_STRING(res)[0]; Py_DECREF(res); res = NULL; // Note that the netstring spec explicitly forbids padding zeroes. // If the first char is zero, it must be the only char. if(c < '0' || c > '9') { PyErr_SetString(PyExc_ValueError, "Not a tnetstring: invalid or missing length prefix"); goto error; } else if (c == '0') { res = PyObject_CallMethodObjArgs(file, methnm, metharg, NULL); if(res == NULL) { goto error; } Py_INCREF(res); if(!PyString_Check(res) || !PyString_GET_SIZE(res)) { PyErr_SetString(PyExc_ValueError, "Not a tnetstring: invalid or missing length prefix"); goto error; } c = PyString_AS_STRING(res)[0]; Py_DECREF(res); res = NULL; } else { do { datalen = (10 * datalen) + (c - '0'); check(datalen <= TNS_MAX_LENGTH, "Not a tnetstring: absurdly large length prefix"); res = PyObject_CallMethodObjArgs(file, methnm, metharg, NULL); if(res == NULL) { goto error; } Py_INCREF(res); if(!PyString_Check(res) || !PyString_GET_SIZE(res)) { PyErr_SetString(PyExc_ValueError, "Not a tnetstring: invalid or missing length prefix"); goto error; } c = PyString_AS_STRING(res)[0]; Py_DECREF(res); res = NULL; } while(c >= '0' && c <= '9'); } // Validate end-of-length-prefix marker. if(c != ':') { PyErr_SetString(PyExc_ValueError, "Not a tnetstring: missing length prefix"); goto error; } // Read the data plus terminating type tag. Py_DECREF(metharg); if((metharg = PyInt_FromSize_t(datalen + 1)) == NULL) { goto error; } res = PyObject_CallMethodObjArgs(file, methnm, metharg, NULL); if(res == NULL) { goto error; } Py_INCREF(res); Py_DECREF(file); file = NULL; Py_DECREF(methnm); methnm = NULL; Py_DECREF(metharg); metharg = NULL; if(!PyString_Check(res) || PyString_GET_SIZE(res) != datalen + 1) { PyErr_SetString(PyExc_ValueError, "Not a tnetstring: invalid length prefix"); goto error; } // Parse out the payload object data = PyString_AS_STRING(res); val = tns_parse_payload(ops, data[datalen], data, datalen); Py_DECREF(res); res = NULL; if(ops != &_tnetstring_ops_bytes) { free(ops); Py_DECREF(encoding); } return val; error: if(file != NULL) { Py_DECREF(file); } if(ops != &_tnetstring_ops_bytes) { free(ops); Py_DECREF(encoding); } if(methnm != NULL) { Py_DECREF(methnm); } if(metharg != NULL) { Py_DECREF(metharg); } if(res != NULL) { Py_DECREF(res); } if(val != NULL) { Py_DECREF(val); } return NULL; }
static PyObject *get_noperands(instruction_t *self, PyObject *args) { return PyInt_FromSize_t(xed_decoded_inst_noperands(self->decoded_inst)); }
static PyObject * get_thread_lock_count(PyObject *self) { (void)self; return PyInt_FromSize_t(thread_lock_count); }