// @pymethod (int, ...)/int|PyIDispatch|GetIDsOfNames|Get the DISPID for the passed names. PyObject *PyIDispatch::GetIDsOfNames(PyObject *self, PyObject *args) { // @rdesc If the first parameter is a sequence, the result will be a tuple of integers // for each name in the sequence. If the first parameter is a single string, the result // is a single integer with the ID of requested item. UINT i; // @pyparm string|name||A name to query for // @pyparmalt1 [string, ...]|[name, ...]||A sequence of string names to query // @comm Currently the LCID can not be specified, and LOCALE_SYSTEM_DEFAULT is used. int argc = PyTuple_GET_SIZE(args); if ( argc < 1 ) return PyErr_Format(PyExc_TypeError, "At least one argument must be supplied"); LCID lcid = LOCALE_SYSTEM_DEFAULT; UINT offset = 0; if ( argc > 1 ){ PyObject *ob = PyTuple_GET_ITEM(args, 0); lcid=PyLong_AsLong(ob); if (lcid==-1 && PyErr_Occurred()){ PyErr_Clear(); lcid=LOCALE_SYSTEM_DEFAULT; } else offset = 1; } UINT cNames = argc - offset; OLECHAR FAR* FAR* rgszNames = new LPOLESTR[cNames]; for ( i = 0 ; i < cNames; ++i ) { PyObject *ob = PySequence_GetItem(args, i + offset); if ( !ob ) { for (;i>0;i--) PyWinObject_FreeBstr(rgszNames[i-1]); delete [] rgszNames; return NULL; } if (!PyWinObject_AsBstr(ob, rgszNames+i)) { for (;i>0;i--) PyWinObject_FreeBstr(rgszNames[i-1]); delete [] rgszNames; return NULL; } Py_DECREF(ob); } DISPID FAR* rgdispid = new DISPID[cNames]; IDispatch *pMyDispatch = GetI(self); if (pMyDispatch==NULL) return NULL; PY_INTERFACE_PRECALL; HRESULT hr = pMyDispatch->GetIDsOfNames(IID_NULL, rgszNames, cNames, lcid, rgdispid); PY_INTERFACE_POSTCALL; for (i=0;i<cNames;i++) PyWinObject_FreeBstr(rgszNames[i]); delete [] rgszNames; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pMyDispatch, IID_IDispatch); PyObject *result; /* if we have just one name, then return a single DISPID (int) */ if ( cNames == 1 ) { result = PyInt_FromLong(rgdispid[0]); } else { result = PyTuple_New(cNames); if ( result ) { for ( i = 0; i < cNames; ++i ) { PyObject *ob = PyInt_FromLong(rgdispid[i]); if ( !ob ) { delete [] rgdispid; return NULL; } PyTuple_SET_ITEM(result, i, ob); } } } delete [] rgdispid; return result; }
/* "/home/abhinav/projects/fb-puzzles/breathalyzer/levenshtein.pyx":4 * int levenshtein_distance(char *s,char *t) * * def levenshtein(char* s1, char* s2): # <<<<<<<<<<<<<< * return levenshtein_distance(s1, s2) */ static PyObject *__pyx_pf_11levenshtein_levenshtein(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pf_11levenshtein_levenshtein(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { char *__pyx_v_s1; char *__pyx_v_s2; PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; static PyObject **__pyx_pyargnames[] = {&__pyx_n_s__s1,&__pyx_n_s__s2,0}; __Pyx_RefNannySetupContext("levenshtein"); __pyx_self = __pyx_self; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args = PyDict_Size(__pyx_kwds); PyObject* values[2] = {0,0}; switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } switch (PyTuple_GET_SIZE(__pyx_args)) { case 0: values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s__s1); if (likely(values[0])) kw_args--; else goto __pyx_L5_argtuple_error; case 1: values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s__s2); if (likely(values[1])) kw_args--; else { __Pyx_RaiseArgtupleInvalid("levenshtein", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, PyTuple_GET_SIZE(__pyx_args), "levenshtein") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_v_s1 = __Pyx_PyBytes_AsString(values[0]); if (unlikely((!__pyx_v_s1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_s2 = __Pyx_PyBytes_AsString(values[1]); if (unlikely((!__pyx_v_s2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { __pyx_v_s1 = __Pyx_PyBytes_AsString(PyTuple_GET_ITEM(__pyx_args, 0)); if (unlikely((!__pyx_v_s1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_s2 = __Pyx_PyBytes_AsString(PyTuple_GET_ITEM(__pyx_args, 1)); if (unlikely((!__pyx_v_s2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("levenshtein", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("levenshtein.levenshtein"); return NULL; __pyx_L4_argument_unpacking_done:; /* "/home/abhinav/projects/fb-puzzles/breathalyzer/levenshtein.pyx":5 * * def levenshtein(char* s1, char* s2): * return levenshtein_distance(s1, s2) # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyInt_FromLong(levenshtein_distance(__pyx_v_s1, __pyx_v_s2)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("levenshtein.levenshtein"); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; }
PyObject* pysqlite_row_subscript(pysqlite_Row* self, PyObject* idx) { Py_ssize_t _idx; char* key; Py_ssize_t nitems, i; char* compare_key; char* p1; char* p2; PyObject* item; if (PyLong_Check(idx)) { _idx = PyNumber_AsSsize_t(idx, PyExc_IndexError); if (_idx == -1 && PyErr_Occurred()) return NULL; if (_idx < 0) _idx += PyTuple_GET_SIZE(self->data); item = PyTuple_GetItem(self->data, _idx); Py_XINCREF(item); return item; } else if (PyUnicode_Check(idx)) { key = _PyUnicode_AsString(idx); if (key == NULL) return NULL; nitems = PyTuple_Size(self->description); for (i = 0; i < nitems; i++) { PyObject *obj; obj = PyTuple_GET_ITEM(self->description, i); obj = PyTuple_GET_ITEM(obj, 0); compare_key = _PyUnicode_AsString(obj); if (!compare_key) { return NULL; } p1 = key; p2 = compare_key; while (1) { if ((*p1 == (char)0) || (*p2 == (char)0)) { break; } if ((*p1 | 0x20) != (*p2 | 0x20)) { break; } p1++; p2++; } if ((*p1 == (char)0) && (*p2 == (char)0)) { /* found item */ item = PyTuple_GetItem(self->data, i); Py_INCREF(item); return item; } } PyErr_SetString(PyExc_IndexError, "No item with that key"); return NULL; } else if (PySlice_Check(idx)) { PyErr_SetString(PyExc_ValueError, "slices not implemented, yet"); return NULL; } else { PyErr_SetString(PyExc_IndexError, "Index must be int or string"); return NULL; } }
static int vgetargs1(PyObject *args, const char *format, va_list *p_va, int flags) { char msgbuf[256]; int levels[32]; const char *fname = NULL; const char *message = NULL; int min = -1; int max = 0; int level = 0; int endfmt = 0; const char *formatsave = format; Py_ssize_t i, len; char *msg; PyObject *freelist = NULL; int compat = flags & FLAG_COMPAT; assert(compat || (args != (PyObject*)NULL)); flags = flags & ~FLAG_COMPAT; while (endfmt == 0) { int c = *format++; switch (c) { case '(': if (level == 0) max++; level++; if (level >= 30) Py_FatalError("too many tuple nesting levels " "in argument format string"); break; case ')': if (level == 0) Py_FatalError("excess ')' in getargs format"); else level--; break; case '\0': endfmt = 1; break; case ':': fname = format; endfmt = 1; break; case ';': message = format; endfmt = 1; break; default: if (level == 0) { if (c == 'O') max++; else if (isalpha(Py_CHARMASK(c))) { if (c != 'e') /* skip encoded */ max++; } else if (c == '|') min = max; } break; } } if (level != 0) Py_FatalError(/* '(' */ "missing ')' in getargs format"); if (min < 0) min = max; format = formatsave; if (compat) { if (max == 0) { if (args == NULL) return 1; PyOS_snprintf(msgbuf, sizeof(msgbuf), "%.200s%s takes no arguments", fname==NULL ? "function" : fname, fname==NULL ? "" : "()"); PyErr_SetString(PyExc_TypeError, msgbuf); return 0; } else if (min == 1 && max == 1) { if (args == NULL) { PyOS_snprintf(msgbuf, sizeof(msgbuf), "%.200s%s takes at least one argument", fname==NULL ? "function" : fname, fname==NULL ? "" : "()"); PyErr_SetString(PyExc_TypeError, msgbuf); return 0; } msg = convertitem(args, &format, p_va, flags, levels, msgbuf, sizeof(msgbuf), &freelist); if (msg == NULL) return cleanreturn(1, freelist); seterror(levels[0], msg, levels+1, fname, message); return cleanreturn(0, freelist); } else { PyErr_SetString(PyExc_SystemError, "old style getargs format uses new features"); return 0; } } if (!PyTuple_Check(args)) { PyErr_SetString(PyExc_SystemError, "new style getargs format but argument is not a tuple"); return 0; } len = PyTuple_GET_SIZE(args); if (len < min || max < len) { if (message == NULL) { PyOS_snprintf(msgbuf, sizeof(msgbuf), "%.150s%s takes %s %d argument%s " "(%ld given)", fname==NULL ? "function" : fname, fname==NULL ? "" : "()", min==max ? "exactly" : len < min ? "at least" : "at most", len < min ? min : max, (len < min ? min : max) == 1 ? "" : "s", Py_SAFE_DOWNCAST(len, Py_ssize_t, long)); message = msgbuf; } PyErr_SetString(PyExc_TypeError, message); return 0; }
static PyObject * GMPy_MPZ_Function_Divm(PyObject *self, PyObject *args) { MPZ_Object *result = NULL, *num = NULL, *den = NULL, *mod = NULL; mpz_t numz, denz, modz, gcdz; int ok = 0; if (PyTuple_GET_SIZE(args) != 3) { TYPE_ERROR("divm() requires 'mpz','mpz','mpz' arguments"); return NULL; } if (!(result = GMPy_MPZ_New(NULL))) { /* LCOV_EXCL_START */ return NULL; /* LCOV_EXCL_STOP */ } if (!(num = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL)) || !(den = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 1), NULL)) || !(mod = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 2), NULL))) { TYPE_ERROR("divm() requires 'mpz','mpz','mpz' arguments"); Py_XDECREF((PyObject*)num); Py_XDECREF((PyObject*)den); Py_XDECREF((PyObject*)mod); Py_DECREF((PyObject*)result); return NULL; } /* Make copies so we don't destroy the input. */ mpz_inoc(numz); mpz_inoc(denz); mpz_inoc(modz); mpz_set(numz, num->z); mpz_set(denz, den->z); mpz_set(modz, mod->z); Py_DECREF((PyObject*)num); Py_DECREF((PyObject*)den); Py_DECREF((PyObject*)mod); if (mpz_invert(result->z, denz, modz)) { /* inverse exists */ ok = 1; } else { /* last-ditch attempt: do num, den AND mod have a gcd>1 ? */ mpz_inoc(gcdz); mpz_gcd(gcdz, numz, denz); mpz_gcd(gcdz, gcdz, modz); mpz_divexact(numz, numz, gcdz); mpz_divexact(denz, denz, gcdz); mpz_divexact(modz, modz, gcdz); mpz_cloc(gcdz); ok = mpz_invert(result->z, denz, modz); } if (ok) { mpz_mul(result->z, result->z, numz); mpz_mod(result->z, result->z, modz); mpz_cloc(numz); mpz_cloc(denz); mpz_cloc(modz); return (PyObject*)result; } else { ZERO_ERROR("not invertible"); mpz_cloc(numz); mpz_cloc(denz); mpz_cloc(modz); Py_DECREF((PyObject*)result); return NULL; } }
static int _buffer_format_string(PyArray_Descr *descr, _tmp_string_t *str, PyArrayObject* arr, Py_ssize_t *offset, char *active_byteorder) { int k; char _active_byteorder = '@'; Py_ssize_t _offset = 0; if (active_byteorder == NULL) { active_byteorder = &_active_byteorder; } if (offset == NULL) { offset = &_offset; } if (descr->subarray) { PyObject *item, *subarray_tuple; Py_ssize_t total_count = 1; Py_ssize_t dim_size; char buf[128]; int old_offset; int ret; if (PyTuple_Check(descr->subarray->shape)) { subarray_tuple = descr->subarray->shape; Py_INCREF(subarray_tuple); } else { subarray_tuple = Py_BuildValue("(O)", descr->subarray->shape); } _append_char(str, '('); for (k = 0; k < PyTuple_GET_SIZE(subarray_tuple); ++k) { if (k > 0) { _append_char(str, ','); } item = PyTuple_GET_ITEM(subarray_tuple, k); dim_size = PyNumber_AsSsize_t(item, NULL); PyOS_snprintf(buf, sizeof(buf), "%ld", (long)dim_size); _append_str(str, buf); total_count *= dim_size; } _append_char(str, ')'); Py_DECREF(subarray_tuple); old_offset = *offset; ret = _buffer_format_string(descr->subarray->base, str, arr, offset, active_byteorder); *offset = old_offset + (*offset - old_offset) * total_count; return ret; } else if (PyDataType_HASFIELDS(descr)) { int base_offset = *offset; _append_str(str, "T{"); for (k = 0; k < PyTuple_GET_SIZE(descr->names); ++k) { PyObject *name, *item, *offset_obj, *tmp; PyArray_Descr *child; char *p; Py_ssize_t len; int new_offset; name = PyTuple_GET_ITEM(descr->names, k); item = PyDict_GetItem(descr->fields, name); child = (PyArray_Descr*)PyTuple_GetItem(item, 0); offset_obj = PyTuple_GetItem(item, 1); new_offset = base_offset + PyInt_AsLong(offset_obj); /* Insert padding manually */ if (*offset > new_offset) { PyErr_SetString(PyExc_RuntimeError, "This should never happen: Invalid offset in " "buffer format string generation. Please " "report a bug to the Numpy developers."); return -1; } while (*offset < new_offset) { _append_char(str, 'x'); ++*offset; } /* Insert child item */ _buffer_format_string(child, str, arr, offset, active_byteorder); /* Insert field name */ #if defined(NPY_PY3K) /* FIXME: XXX -- should it use UTF-8 here? */ tmp = PyUnicode_AsUTF8String(name); #else tmp = name; #endif if (tmp == NULL || PyBytes_AsStringAndSize(tmp, &p, &len) < 0) { PyErr_SetString(PyExc_ValueError, "invalid field name"); return -1; } _append_char(str, ':'); while (len > 0) { if (*p == ':') { Py_DECREF(tmp); PyErr_SetString(PyExc_ValueError, "':' is not an allowed character in buffer " "field names"); return -1; } _append_char(str, *p); ++p; --len; } _append_char(str, ':'); #if defined(NPY_PY3K) Py_DECREF(tmp); #endif } _append_char(str, '}'); } else { int is_standard_size = 1; int is_native_only_type = (descr->type_num == NPY_LONGDOUBLE || descr->type_num == NPY_CLONGDOUBLE); #if NPY_SIZEOF_LONG_LONG != 8 is_native_only_type = is_native_only_type || ( descr->type_num == NPY_LONGLONG || descr->type_num == NPY_ULONGLONG); #endif *offset += descr->elsize; if (descr->byteorder == '=' && _is_natively_aligned_at(descr, arr, *offset)) { /* Prefer native types, to cater for Cython */ is_standard_size = 0; if (*active_byteorder != '@') { _append_char(str, '@'); *active_byteorder = '@'; } } else if (descr->byteorder == '=' && is_native_only_type) { /* Data types that have no standard size */ is_standard_size = 0; if (*active_byteorder != '^') { _append_char(str, '^'); *active_byteorder = '^'; } } else if (descr->byteorder == '<' || descr->byteorder == '>' || descr->byteorder == '=') { is_standard_size = 1; if (*active_byteorder != descr->byteorder) { _append_char(str, descr->byteorder); *active_byteorder = descr->byteorder; } if (is_native_only_type) { /* It's not possible to express native-only data types in non-native byte orders */ PyErr_Format(PyExc_ValueError, "cannot expose native-only dtype '%c' in " "non-native byte order '%c' via buffer interface", descr->type, descr->byteorder); } } switch (descr->type_num) { case NPY_BOOL: if (_append_char(str, '?')) return -1; break; case NPY_BYTE: if (_append_char(str, 'b')) return -1; break; case NPY_UBYTE: if (_append_char(str, 'B')) return -1; break; case NPY_SHORT: if (_append_char(str, 'h')) return -1; break; case NPY_USHORT: if (_append_char(str, 'H')) return -1; break; case NPY_INT: if (_append_char(str, 'i')) return -1; break; case NPY_UINT: if (_append_char(str, 'I')) return -1; break; case NPY_LONG: if (is_standard_size && (NPY_SIZEOF_LONG == 8)) { if (_append_char(str, 'q')) return -1; } else { if (_append_char(str, 'l')) return -1; } break; case NPY_ULONG: if (is_standard_size && (NPY_SIZEOF_LONG == 8)) { if (_append_char(str, 'Q')) return -1; } else { if (_append_char(str, 'L')) return -1; } break; case NPY_LONGLONG: if (_append_char(str, 'q')) return -1; break; case NPY_ULONGLONG: if (_append_char(str, 'Q')) return -1; break; case NPY_HALF: if (_append_char(str, 'e')) return -1; break; case NPY_FLOAT: if (_append_char(str, 'f')) return -1; break; case NPY_DOUBLE: if (_append_char(str, 'd')) return -1; break; case NPY_LONGDOUBLE: if (_append_char(str, 'g')) return -1; break; case NPY_CFLOAT: if (_append_str(str, "Zf")) return -1; break; case NPY_CDOUBLE: if (_append_str(str, "Zd")) return -1; break; case NPY_CLONGDOUBLE: if (_append_str(str, "Zg")) return -1; break; /* XXX: datetime */ /* XXX: timedelta */ case NPY_OBJECT: if (_append_char(str, 'O')) return -1; break; case NPY_STRING: { char buf[128]; PyOS_snprintf(buf, sizeof(buf), "%ds", descr->elsize); if (_append_str(str, buf)) return -1; break; } case NPY_UNICODE: { /* Numpy Unicode is always 4-byte */ char buf[128]; assert(descr->elsize % 4 == 0); PyOS_snprintf(buf, sizeof(buf), "%dw", descr->elsize / 4); if (_append_str(str, buf)) return -1; break; } case NPY_VOID: { /* Insert padding bytes */ char buf[128]; PyOS_snprintf(buf, sizeof(buf), "%dx", descr->elsize); if (_append_str(str, buf)) return -1; break; } default: PyErr_Format(PyExc_ValueError, "cannot include dtype '%c' in a buffer", descr->type); return -1; } } return 0; }
static PyObject * Pympz_mpmath_normalize(PyObject *self, PyObject *args) { long sign = 0; long bc = 0, prec = 0, shift, zbits, carry = 0; PyObject *exp = 0, *newexp = 0, *newexp2 = 0, *tmp = 0, *rndstr = 0; MPZ_Object *man = 0, *upper = 0, *lower = 0; char rnd = 0; int err1, err2, err3; if (PyTuple_GET_SIZE(args) == 6) { /* Need better error-checking here. Under Python 3.0, overflow into C-long is possible. */ sign = GMPy_Integer_AsLongAndError(PyTuple_GET_ITEM(args, 0), &err1); man = (MPZ_Object *)PyTuple_GET_ITEM(args, 1); exp = PyTuple_GET_ITEM(args, 2); bc = GMPy_Integer_AsLongAndError(PyTuple_GET_ITEM(args, 3), &err2); prec = GMPy_Integer_AsLongAndError(PyTuple_GET_ITEM(args, 4), &err3); rndstr = PyTuple_GET_ITEM(args, 5); if (err1 || err2 || err3) { TYPE_ERROR("arguments long, MPZ_Object*, PyObject*, long, long, char needed"); return NULL; } } else { TYPE_ERROR("6 arguments required"); return NULL; } if (!MPZ_Check(man)) { TYPE_ERROR("argument is not an mpz"); return NULL; } /* If rndstr really is a string, extract the first character. */ if (Py2or3String_Check(rndstr)) { rnd = Py2or3String_AsString(rndstr)[0]; } else { VALUE_ERROR("invalid rounding mode specified"); return NULL; } /* If the mantissa is 0, return the normalized representation. */ if (!mpz_sgn(man->z)) { Py_INCREF((PyObject*)man); return mpmath_build_mpf(0, man, 0, 0); } /* if bc <= prec and the number is odd return it */ if ((bc <= prec) && mpz_odd_p(man->z)) { Py_INCREF((PyObject*)man); Py_INCREF((PyObject*)exp); return mpmath_build_mpf(sign, man, exp, bc); } if (!(upper = GMPy_MPZ_New(NULL)) || !(lower = GMPy_MPZ_New(NULL))) { Py_XDECREF((PyObject*)upper); Py_XDECREF((PyObject*)lower); } shift = bc - prec; if (shift>0) { switch (rnd) { case 'f': if(sign) { mpz_cdiv_q_2exp(upper->z, man->z, shift); } else { mpz_fdiv_q_2exp(upper->z, man->z, shift); } break; case 'c': if(sign) { mpz_fdiv_q_2exp(upper->z, man->z, shift); } else { mpz_cdiv_q_2exp(upper->z, man->z, shift); } break; case 'd': mpz_fdiv_q_2exp(upper->z, man->z, shift); break; case 'u': mpz_cdiv_q_2exp(upper->z, man->z, shift); break; case 'n': default: mpz_tdiv_r_2exp(lower->z, man->z, shift); mpz_tdiv_q_2exp(upper->z, man->z, shift); if (mpz_sgn(lower->z)) { /* lower is not 0 so it must have at least 1 bit set */ if (mpz_sizeinbase(lower->z, 2) == shift) { /* lower is >= 1/2 */ if (mpz_scan1(lower->z, 0) == shift-1) { /* lower is exactly 1/2 */ if (mpz_odd_p(upper->z)) carry = 1; } else { carry = 1; } } } if (carry) mpz_add_ui(upper->z, upper->z, 1); } if (!(tmp = PyIntOrLong_FromLong(shift))) { Py_DECREF((PyObject*)upper); Py_DECREF((PyObject*)lower); return NULL; } if (!(newexp = PyNumber_Add(exp, tmp))) { Py_DECREF((PyObject*)upper); Py_DECREF((PyObject*)lower); Py_DECREF(tmp); return NULL; } Py_DECREF(tmp); bc = prec; } else { mpz_set(upper->z, man->z); newexp = exp; Py_INCREF(newexp); } /* Strip trailing 0 bits. */ if ((zbits = mpz_scan1(upper->z, 0))) mpz_tdiv_q_2exp(upper->z, upper->z, zbits); if (!(tmp = PyIntOrLong_FromLong(zbits))) { Py_DECREF((PyObject*)upper); Py_DECREF((PyObject*)lower); Py_DECREF(newexp); return NULL; } if (!(newexp2 = PyNumber_Add(newexp, tmp))) { Py_DECREF((PyObject*)upper); Py_DECREF((PyObject*)lower); Py_DECREF(tmp); Py_DECREF(newexp); return NULL; } Py_DECREF(newexp); Py_DECREF(tmp); bc -= zbits; /* Check if one less than a power of 2 was rounded up. */ if (!mpz_cmp_ui(upper->z, 1)) bc = 1; Py_DECREF((PyObject*)lower); return mpmath_build_mpf(sign, upper, newexp2, bc); }
// Parse the given Python type object. bool Chimera::parse_py_type(PyTypeObject *type_obj) { const sipTypeDef *td = sipTypeFromPyTypeObject(type_obj); if (td) { if (sipTypeIsNamespace(td)) return false; _type = td; _name = sipTypeName(td); if (sipTypeIsClass(td)) set_flag(); if (sipTypeIsEnum(td) || isFlag()) { _metatype = QMetaType::Int; } else { bool is_a_QObject = PyType_IsSubtype(type_obj, sipTypeAsPyTypeObject(sipType_QObject)); // If there is no assignment helper then assume it is a // pointer-type. if (!get_assign_helper()) _name.append('*'); _metatype = QMetaType::type(_name.constData()); // This will deal with cases where the registered type is a // super-class and specifically allows for multiple inheritance. // The problem we are solving is that we want a QGraphicsWidget to // be handled as a QGraphicsItem (which Qt registers) rather than a // QObject, specifically in the value passed as a QVariant to // QGraphicsItem::itemChange(). This solution means that it will // always be passed as a QGraphicsItem, even if there are // circumstances where it should be passed as a QObject. If we // come across such a circumstance then we may need to remove this // and implement a more specific solution in %MethodCode for the // various itemChange() implementations. if (_metatype == 0 && is_a_QObject) { PyObject *mro = type_obj->tp_mro; Q_ASSERT(PyTuple_Check(mro)); Q_ASSERT(PyTuple_GET_SIZE(mro) >= 3); for (SIP_SSIZE_T i = 1; i < PyTuple_GET_SIZE(mro) - 1; ++i) { PyTypeObject *sc = (PyTypeObject *)PyTuple_GET_ITEM(mro, i); if (sc == sipSimpleWrapper_Type || sc == sipWrapper_Type) continue; QByteArray sc_name(sc->tp_name); // QObjects are always pointers. sc_name.append('*'); _metatype = QMetaType::type(sc_name.constData()); if (_metatype >= QMetaType::User) { _type = sipTypeFromPyTypeObject(sc); _name = sc_name; _py_type = (PyObject *)sc; Py_INCREF(_py_type); return true; } } } // If it is a user type then it must be a type that SIP knows // about but was registered by Qt. if (_metatype < QMetaType::User) { if (sipType_QWidget && PyType_IsSubtype(type_obj, sipTypeAsPyTypeObject(sipType_QWidget))) { _metatype = QMetaType::QWidgetStar; } else if (is_a_QObject) { _metatype = QMetaType::QObjectStar; } else if (!sipIsExactWrappedType((sipWrapperType *)type_obj)) { // It must be a (non-QObject, non-QWidget) Python // sub-class so make sure it gets wrapped in a // PyQt_PyObject. _type = 0; _metatype = PyQt_PyObject::metatype; _name.clear(); } } } } #if PY_MAJOR_VERSION >= 3 else if (type_obj == &PyUnicode_Type) { _type = sipType_QString; _metatype = QMetaType::QString; } #else else if (type_obj == &PyString_Type || type_obj == &PyUnicode_Type) { // In this case we accept that the reverse conversion will result in an // object of a different type (i.e. a QString rather than a Python // string). _type = sipType_QString; _metatype = QMetaType::QString; } #endif else if (type_obj == &PyBool_Type) { _metatype = QMetaType::Bool; } #if PY_MAJOR_VERSION < 3 else if (type_obj == &PyInt_Type) { // We choose to map to a C++ int, even though a Python int is // potentially much larger, as it represents the most common usage in // Qt. However we will allow a larger type to be used if the context // is right. _metatype = QMetaType::Int; _inexact = true; } #endif else if (type_obj == &PyLong_Type) { // We choose to map to a C++ int for the same reasons as above and to // be consistent with Python3 where everything is a long object. If // this isn't appropriate the user can always use a string to specify // the exact C++ type they want. _metatype = QMetaType::Int; _inexact = true; } else if (type_obj == &PyFloat_Type) { _metatype = QMetaType::Double; } // Fallback to using a PyQt_PyObject. if (_metatype == QMetaType::Void) _metatype = PyQt_PyObject::metatype; // If there is no name so far then use the meta-type name. if (_name.isEmpty()) _name = QMetaType::typeName(_metatype); _py_type = (PyObject *)type_obj; Py_INCREF(_py_type); return true; }
Box* superGetattribute(Box* _s, Box* _attr) { RELEASE_ASSERT(_s->cls == super_cls, ""); BoxedSuper* s = static_cast<BoxedSuper*>(_s); RELEASE_ASSERT(_attr->cls == str_cls, ""); BoxedString* attr = static_cast<BoxedString*>(_attr); bool skip = s->obj_type == NULL; if (!skip) { // Looks like __class__ is supposed to be "super", not the class of the the proxied object. skip = (attr->s() == class_str); } if (!skip) { PyObject* mro, *res, *tmp, *dict; PyTypeObject* starttype; descrgetfunc f; Py_ssize_t i, n; starttype = s->obj_type; mro = starttype->tp_mro; if (mro == NULL) n = 0; else { assert(PyTuple_Check(mro)); n = PyTuple_GET_SIZE(mro); } for (i = 0; i < n; i++) { if ((PyObject*)(s->type) == PyTuple_GET_ITEM(mro, i)) break; } i++; res = NULL; for (; i < n; i++) { tmp = PyTuple_GET_ITEM(mro, i); // Pyston change: #if 0 if (PyType_Check(tmp)) dict = ((PyTypeObject *)tmp)->tp_dict; else if (PyClass_Check(tmp)) dict = ((PyClassObject *)tmp)->cl_dict; else continue; res = PyDict_GetItem(dict, name); #endif res = tmp->getattr(std::string(attr->s())); if (res != NULL) { // Pyston change: #if 0 Py_INCREF(res); f = Py_TYPE(res)->tp_descr_get; if (f != NULL) { tmp = f(res, /* Only pass 'obj' param if this is instance-mode sper (See SF ID #743627) */ (s->obj == (PyObject *) s->obj_type ? (PyObject *)NULL : s->obj), (PyObject *)starttype); Py_DECREF(res); res = tmp; } #endif return processDescriptor(res, (s->obj == s->obj_type ? None : s->obj), s->obj_type); } } } Box* r = typeLookup(s->cls, std::string(attr->s()), NULL); // TODO implement this RELEASE_ASSERT(r, "should call the equivalent of objectGetattr here"); return processDescriptor(r, s, s->cls); }
int pycbc_tc_encode_value(pycbc_Bucket *conn, PyObject *srcbuf, PyObject *srcflags, pycbc_pybuffer *dstbuf, lcb_U32 *dstflags) { PyObject *flags_obj; PyObject *new_value = NULL; PyObject *result_tuple = NULL; lcb_U32 flags_stackval; int rv; Py_ssize_t plen; if (!srcflags) { srcflags = conn->dfl_fmt; } if (!conn->tc) { if (srcflags == pycbc_helpers.fmt_auto) { srcflags = pycbc_tc_determine_format(srcbuf); } rv = pycbc_get_u32(srcflags, &flags_stackval); if (rv < 0) { PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_ARGUMENTS, 0, "Bad value for flags", srcflags); return -1; } *dstflags = flags_stackval; return encode_common(srcbuf, dstbuf, flags_stackval); } /** * Calling into Transcoder */ rv = do_call_tc(conn, srcbuf, srcflags, &result_tuple, ENCODE_VALUE); if (rv < 0) { return -1; } if (!PyTuple_Check(result_tuple) || PyTuple_GET_SIZE(result_tuple) != 2) { PYCBC_EXC_WRAP_EX(PYCBC_EXC_ENCODING, 0, "Expected return of (bytes, flags)", srcbuf, result_tuple); Py_XDECREF(result_tuple); return -1; } new_value = PyTuple_GET_ITEM(result_tuple, 0); flags_obj = PyTuple_GET_ITEM(result_tuple, 1); if (new_value == NULL || flags_obj == NULL) { PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_INTERNAL, 0, "Tuple GET_ITEM had NULL", result_tuple); Py_XDECREF(result_tuple); return -1; } rv = pycbc_get_u32(flags_obj, &flags_stackval); if (rv < 0) { Py_XDECREF(result_tuple); PYCBC_EXC_WRAP_VALUE(PYCBC_EXC_ENCODING, 0, "Transcoder.encode_value() returned a bad " "value for flags", srcbuf); return -1; } *dstflags = flags_stackval; rv = PyBytes_AsStringAndSize(new_value, (char**)&dstbuf->buffer, &plen); if (rv == -1) { Py_XDECREF(result_tuple); PYCBC_EXC_WRAP_VALUE(PYCBC_EXC_ENCODING, 0, "Value returned by Transcoder.encode_value() " "could not be converted to bytes", srcbuf); return -1; } dstbuf->pyobj = new_value; dstbuf->length = plen; Py_INCREF(new_value); Py_XDECREF(result_tuple); return 0; }
/** * Compare this Key with another. */ static PyObject * key_richcompare(Key *self, PyObject *other, int op) { int cmpres = 0; if(Py_TYPE(other) == &KeyType) { Key *otherk = (Key *)other; Slice s1 = {Key_DATA(self), Key_DATA(self) + Key_SIZE(self)}; Slice s2 = {Key_DATA(otherk), Key_DATA(otherk) + Key_SIZE(otherk)}; cmpres = acid_memcmp(&s1, &s2); } else if(Py_TYPE(other) == &PyTuple_Type) { struct writer wtr; if(acid_writer_init(&wtr, 64)) { return NULL; } Py_ssize_t ti = 0; Py_ssize_t remain = Key_SIZE(self); uint8_t *kp = Key_DATA(self); while(remain && ti < PyTuple_GET_SIZE(other)) { if(acid_write_element(&wtr, PyTuple_GET_ITEM(other, ti++))) { acid_writer_abort(&wtr); return NULL; } uint8_t *p = acid_writer_ptr(&wtr) - wtr.pos; Py_ssize_t minsz = (remain < wtr.pos) ? remain : wtr.pos; if((cmpres = memcmp(kp, p, minsz))) { break; } kp += minsz; remain -= minsz; wtr.pos = 0; } acid_writer_abort(&wtr); if(! cmpres) { if(remain) { cmpres = 1; } else if(ti < PyTuple_GET_SIZE(other)) { cmpres = -1; } } } else if(op == Py_EQ) { Py_RETURN_FALSE; } else if(op == Py_NE) { Py_RETURN_TRUE; } else { PyErr_Format(PyExc_TypeError, "Keys cannot be compared with '%s' objects.", other->ob_type->tp_name); return NULL; } int ok = 0; switch(op) { case Py_LT: ok = cmpres < 0; break; case Py_LE: ok = cmpres <= 0; break; case Py_EQ: ok = cmpres == 0; break; case Py_NE: ok = cmpres != 0; break; case Py_GT: ok = cmpres > 0; break; case Py_GE: ok = cmpres >= 0; } if(ok) { Py_RETURN_TRUE; } Py_RETURN_FALSE; }
PyObject * PyObject_GenericGetAttr(PyObject *obj, PyObject *name) { PyTypeObject *tp = obj->ob_type; PyObject *descr = NULL; PyObject *res = NULL; descrgetfunc f; Py_ssize_t dictoffset; PyObject **dictptr; if (!PyString_Check(name)){ #ifdef Py_USING_UNICODE /* The Unicode to string conversion is done here because the existing tp_setattro slots expect a string object as name and we wouldn't want to break those. */ if (PyUnicode_Check(name)) { name = PyUnicode_AsEncodedString(name, NULL, NULL); if (name == NULL) return NULL; } else #endif { PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); return NULL; } } else Py_INCREF(name); if (tp->tp_dict == NULL) { if (PyType_Ready(tp) < 0) goto done; } /* Inline _PyType_Lookup */ { Py_ssize_t i, n; PyObject *mro, *base, *dict; /* Look in tp_dict of types in MRO */ mro = tp->tp_mro; assert(mro != NULL); assert(PyTuple_Check(mro)); n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { base = PyTuple_GET_ITEM(mro, i); if (PyClass_Check(base)) dict = ((PyClassObject *)base)->cl_dict; else { assert(PyType_Check(base)); dict = ((PyTypeObject *)base)->tp_dict; } assert(dict && PyDict_Check(dict)); descr = PyDict_GetItem(dict, name); if (descr != NULL) break; } } Py_XINCREF(descr); f = NULL; if (descr != NULL && PyType_HasFeature(descr->ob_type, Py_TPFLAGS_HAVE_CLASS)) { f = descr->ob_type->tp_descr_get; if (f != NULL && PyDescr_IsData(descr)) { res = f(descr, obj, (PyObject *)obj->ob_type); Py_DECREF(descr); goto done; } } /* Inline _PyObject_GetDictPtr */ dictoffset = tp->tp_dictoffset; if (dictoffset != 0) { PyObject *dict; if (dictoffset < 0) { Py_ssize_t tsize; size_t size; tsize = ((PyVarObject *)obj)->ob_size; if (tsize < 0) tsize = -tsize; size = _PyObject_VAR_SIZE(tp, tsize); dictoffset += (long)size; assert(dictoffset > 0); assert(dictoffset % SIZEOF_VOID_P == 0); } dictptr = (PyObject **) ((char *)obj + dictoffset); dict = *dictptr; if (dict != NULL) { Py_INCREF(dict); res = PyDict_GetItem(dict, name); if (res != NULL) { Py_INCREF(res); Py_XDECREF(descr); Py_DECREF(dict); goto done; } Py_DECREF(dict); } } if (f != NULL) { res = f(descr, obj, (PyObject *)obj->ob_type); Py_DECREF(descr); goto done; } if (descr != NULL) { res = descr; /* descr was already increfed above */ goto done; } PyErr_Format(PyExc_AttributeError, "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(name)); done: Py_DECREF(name); return res; }
PyObject * PyCFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { #define CHECK_RESULT(res) assert(res != NULL || PyErr_Occurred()) PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); PyObject *res; Py_ssize_t size; switch (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)) { case METH_VARARGS: if (kw == NULL || PyDict_Size(kw) == 0) { res = (*meth)(self, arg); CHECK_RESULT(res); return res; } break; case METH_VARARGS | METH_KEYWORDS: res = (*(PyCFunctionWithKeywords)meth)(self, arg, kw); CHECK_RESULT(res); return res; case METH_NOARGS: if (kw == NULL || PyDict_Size(kw) == 0) { size = PyTuple_GET_SIZE(arg); if (size == 0) { res = (*meth)(self, NULL); CHECK_RESULT(res); return res; } PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%zd given)", f->m_ml->ml_name, size); return NULL; } break; case METH_O: if (kw == NULL || PyDict_Size(kw) == 0) { size = PyTuple_GET_SIZE(arg); if (size == 1) { res = (*meth)(self, PyTuple_GET_ITEM(arg, 0)); CHECK_RESULT(res); return res; } PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%zd given)", f->m_ml->ml_name, size); return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags in " "PyCFunction_Call. METH_OLDARGS is no " "longer supported!"); return NULL; } PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", f->m_ml->ml_name); return NULL; #undef CHECK_RESULT }
static PyObject * Pympq_round(PyObject *self, PyObject *args) { Py_ssize_t round_digits = 0; PympqObject *resultq; PympzObject *resultz; mpz_t temp, rem; /* If args is NULL or the size of args is 0, we just return an mpz. */ if (!args || PyTuple_GET_SIZE(args) == 0) { if (!(resultz = (PympzObject*)Pympz_new())) return NULL; mpz_inoc(rem); mpz_fdiv_qr(resultz->z, rem, mpq_numref(Pympq_AS_MPQ(self)), mpq_denref(Pympq_AS_MPQ(self))); mpz_mul_2exp(rem, rem, 1); if (mpz_cmp(rem, mpq_denref(Pympq_AS_MPQ(self))) > 0) { mpz_add_ui(resultz->z, resultz->z, 1); } else if (mpz_cmp(rem, mpq_denref(Pympq_AS_MPQ(self))) == 0) { if (mpz_odd_p(resultz->z)) { mpz_add_ui(resultz->z, resultz->z, 1); } } mpz_cloc(rem); return (PyObject*)resultz; } if (PyTuple_GET_SIZE(args) > 1) { TYPE_ERROR("Too many arguments for __round__()."); return NULL; } if (PyTuple_GET_SIZE(args) == 1) { round_digits = ssize_t_From_Integer(PyTuple_GET_ITEM(args, 0)); if (round_digits == -1 && PyErr_Occurred()) { TYPE_ERROR("__round__() requires 'int' argument"); return NULL; } } if (!(resultq = (PympqObject*)Pympq_new())) return NULL; mpz_inoc(temp); mpz_ui_pow_ui(temp, 10, round_digits > 0 ? round_digits : -round_digits); mpq_set(resultq->q, Pympq_AS_MPQ(self)); if (round_digits > 0) { mpz_mul(mpq_numref(resultq->q), mpq_numref(resultq->q), temp); mpq_canonicalize(resultq->q); if (!(resultz = (PympzObject*)Pympq_round((PyObject*)resultq, NULL))) { mpz_cloc(temp); return NULL; } mpz_set(mpq_numref(resultq->q), resultz->z); Py_DECREF((PyObject*)resultz); mpz_set(mpq_denref(resultq->q), temp); mpz_cloc(temp); mpq_canonicalize(resultq->q); } else { mpz_mul(mpq_denref(resultq->q), mpq_denref(resultq->q), temp); mpq_canonicalize(resultq->q); if (!(resultz = (PympzObject*)Pympq_round((PyObject*)resultq, NULL))) { mpz_cloc(temp); return NULL; } mpq_set_ui(resultq->q, 0, 1); mpz_mul(mpq_numref(resultq->q), resultz->z, temp); Py_DECREF((PyObject*)resultz); mpz_cloc(temp); mpq_canonicalize(resultq->q); } return (PyObject*)resultq; }
/* * Given a tuple of bytes and None objects, join them into a * a single bytes object with sizes. */ static PyObject * _pack_tuple_data(PyObject *tup) { PyObject *rob; Py_ssize_t natts; Py_ssize_t catt; char *buf = NULL; char *bufpos = NULL; Py_ssize_t bufsize = 0; if (!PyTuple_Check(tup)) { PyErr_Format( PyExc_TypeError, "pack_tuple_data requires a tuple, given %s", PyObject_TypeName(tup) ); return(NULL); } natts = PyTuple_GET_SIZE(tup); if (natts == 0) return(PyBytes_FromString("")); /* discover buffer size and valid att types */ for (catt = 0; catt < natts; ++catt) { PyObject *ob; ob = PyTuple_GET_ITEM(tup, catt); if (ob == Py_None) { bufsize = bufsize + 4; } else if (PyBytes_CheckExact(ob)) { bufsize = bufsize + PyBytes_GET_SIZE(ob) + 4; } else { PyErr_Format( PyExc_TypeError, "cannot serialize attribute %d, expected bytes() or None, got %s", (int) catt, PyObject_TypeName(ob) ); return(NULL); } } buf = malloc(bufsize); if (buf == NULL) { PyErr_Format( PyExc_MemoryError, "failed to allocate %d bytes of memory for packing tuple data", bufsize ); return(NULL); } bufpos = buf; for (catt = 0; catt < natts; ++catt) { PyObject *ob; ob = PyTuple_GET_ITEM(tup, catt); if (ob == Py_None) { uint32_t attsize = 0xFFFFFFFFL; /* Indicates NULL */ memcpy(bufpos, &attsize, 4); bufpos = bufpos + 4; } else { Py_ssize_t size = PyBytes_GET_SIZE(ob); uint32_t msg_size; if (size > 0xFFFFFFFE) { PyErr_Format(PyExc_OverflowError, "data size of %d is greater than attribute capacity", catt ); } msg_size = local_ntohl((uint32_t) size); memcpy(bufpos, &msg_size, 4); bufpos = bufpos + 4; memcpy(bufpos, PyBytes_AS_STRING(ob), PyBytes_GET_SIZE(ob)); bufpos = bufpos + PyBytes_GET_SIZE(ob); } } rob = PyBytes_FromStringAndSize(buf, bufsize); free(buf); return(rob); }
static PyObject * func_new(PyTypeObject* type, PyObject* args, PyObject* kw) { PyCodeObject *code; PyObject *globals; PyObject *name = Py_None; PyObject *defaults = Py_None; PyObject *closure = Py_None; PyFunctionObject *newfunc; Py_ssize_t nfree, nclosure; static char *kwlist[] = {"code", "globals", "name", "argdefs", "closure", 0}; if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!|OOO:function", kwlist, &PyCode_Type, &code, &PyDict_Type, &globals, &name, &defaults, &closure)) return NULL; if (name != Py_None && !PyUnicode_Check(name)) { PyErr_SetString(PyExc_TypeError, "arg 3 (name) must be None or string"); return NULL; } if (defaults != Py_None && !PyTuple_Check(defaults)) { PyErr_SetString(PyExc_TypeError, "arg 4 (defaults) must be None or tuple"); return NULL; } nfree = PyTuple_GET_SIZE(code->co_freevars); if (!PyTuple_Check(closure)) { if (nfree && closure == Py_None) { PyErr_SetString(PyExc_TypeError, "arg 5 (closure) must be tuple"); return NULL; } else if (closure != Py_None) { PyErr_SetString(PyExc_TypeError, "arg 5 (closure) must be None or tuple"); return NULL; } } /* check that the closure is well-formed */ nclosure = closure == Py_None ? 0 : PyTuple_GET_SIZE(closure); if (nfree != nclosure) return PyErr_Format(PyExc_ValueError, "%U requires closure of length %zd, not %zd", code->co_name, nfree, nclosure); if (nclosure) { Py_ssize_t i; for (i = 0; i < nclosure; i++) { PyObject *o = PyTuple_GET_ITEM(closure, i); if (!PyCell_Check(o)) { return PyErr_Format(PyExc_TypeError, "arg 5 (closure) expected cell, found %s", o->ob_type->tp_name); } } } newfunc = (PyFunctionObject *)PyFunction_New((PyObject *)code, globals); if (newfunc == NULL) return NULL; if (name != Py_None) { Py_INCREF(name); Py_SETREF(newfunc->func_name, name); } if (defaults != Py_None) { Py_INCREF(defaults); newfunc->func_defaults = defaults; } if (closure != Py_None) { Py_INCREF(closure); newfunc->func_closure = closure; } return (PyObject *)newfunc; }
static PyObject* start_response(PyObject* self, PyObject* args, PyObject* kwargs) { Request* request = ((StartResponse*)self)->request; if(request->state.start_response_called) { /* not the first call of start_response -- * throw away any previous status and headers. */ Py_CLEAR(request->status); Py_CLEAR(request->headers); request->state.response_length_unknown = false; } PyObject* status = NULL; PyObject* headers = NULL; PyObject* exc_info = NULL; if(!PyArg_UnpackTuple(args, "start_response", 2, 3, &status, &headers, &exc_info)) return NULL; if(exc_info && exc_info != Py_None) { if(!PyTuple_Check(exc_info) || PyTuple_GET_SIZE(exc_info) != 3) { TYPE_ERROR("start_response argument 3", "a 3-tuple", exc_info); return NULL; } restore_exception_tuple(exc_info, /* incref items? */ true); if(request->state.wsgi_call_done) { /* Too late to change headers. According to PEP 333, we should let * the exception propagate in this case. */ return NULL; } /* Headers not yet sent; handle this start_response call as if 'exc_info' * would not have been passed, but print and clear the exception. */ PyErr_Print(); } else if(request->state.start_response_called) { PyErr_SetString(PyExc_TypeError, "'start_response' called twice without " "passing 'exc_info' the second time"); return NULL; } if(!PyString_Check(status)) { TYPE_ERROR("start_response argument 1", "a 'status reason' string", status); return NULL; } if(!PyList_Check(headers)) { TYPE_ERROR("start response argument 2", "a list of 2-tuples", headers); return NULL; } request->headers = headers; if(!inspect_headers(request)) { request->headers = NULL; return NULL; } request->status = status; Py_INCREF(request->status); Py_INCREF(request->headers); request->state.start_response_called = true; Py_RETURN_NONE; }
// The type init slot. static int pyqtSignal_init(PyObject *self, PyObject *args, PyObject *kwd_args) { qpycore_pyqtSignal *ps = (qpycore_pyqtSignal *)self; // We are the signal master. ps->master = ps; ps->overloads = new QList<Chimera::Signature *>; // Get the keyword arguments. PyObject *name_obj = 0; const char *name = 0; if (kwd_args) { SIP_SSIZE_T pos = 0; PyObject *key, *value; while (PyDict_Next(kwd_args, &pos, &key, &value)) { #if PY_MAJOR_VERSION >= 3 if (PyUnicode_CompareWithASCIIString(key, "name") != 0) { PyErr_Format(PyExc_TypeError, "pyqtSignal() got an unexpected keyword argument '%U'", key); Py_XDECREF(name_obj); return -1; } #else Q_ASSERT(PyString_Check(key)); if (qstrcmp(PyString_AS_STRING(key), "name") != 0) { PyErr_Format(PyExc_TypeError, "pyqtSignal() got an unexpected keyword argument '%s'", PyString_AS_STRING(key)); Py_XDECREF(name_obj); return -1; } #endif name_obj = value; name = sipString_AsASCIIString(&name_obj); if (!name) return -1; } } // If there is at least one argument and it is a sequence then assume all // arguments are sequences. Unfortunately a string is also a sequence so // check for tuples and lists explicitly. if (PyTuple_GET_SIZE(args) > 0 && (PyTuple_Check(PyTuple_GET_ITEM(args, 0)) || PyList_Check(PyTuple_GET_ITEM(args, 0)))) { for (SIP_SSIZE_T i = 0; i < PyTuple_GET_SIZE(args); ++i) { PyObject *types = PySequence_Tuple(PyTuple_GET_ITEM(args, i)); if (!types) { PyErr_SetString(PyExc_TypeError, "pyqtSignal() argument expected to be sequence of types"); if (name) { Py_DECREF(name_obj); } return -1; } int rc = add_overload(ps, name, types); Py_DECREF(types); if (rc < 0) { if (name) { Py_DECREF(name_obj); } return -1; } } } else if (add_overload(ps, name, args) < 0) { if (name) { Py_DECREF(name_obj); } return -1; } if (name) { Py_DECREF(name_obj); } return 0; }
static PyObject * Pympz_mpmath_create(PyObject *self, PyObject *args) { long sign; long bc, shift, zbits, carry = 0, prec = 0; PyObject *exp = 0, *newexp = 0, *newexp2 = 0, *tmp = 0; MPZ_Object *man = 0, *upper = 0, *lower = 0; int error; const char *rnd = "f"; if (PyTuple_GET_SIZE(args) < 2) { TYPE_ERROR("mpmath_create() expects 'mpz','int'[,'int','str'] arguments"); return NULL; } switch (PyTuple_GET_SIZE(args)) { case 4: rnd = Py2or3String_AsString(PyTuple_GET_ITEM(args, 3)); case 3: prec = GMPy_Integer_AsLongAndError(PyTuple_GET_ITEM(args, 2), &error); if (error) return NULL; prec = ABS(prec); case 2: exp = PyTuple_GET_ITEM(args, 1); case 1: man = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL); if (!man) { TYPE_ERROR("mpmath_create() expects 'mpz','int'[,'int','str'] arguments"); return NULL; } } /* If the mantissa is 0, return the normalized representation. */ if (!mpz_sgn(man->z)) { return mpmath_build_mpf(0, man, 0, 0); } upper = GMPy_MPZ_New(NULL); lower = GMPy_MPZ_New(NULL); if (!upper || !lower) { Py_DECREF((PyObject*)man); Py_XDECREF((PyObject*)upper); Py_XDECREF((PyObject*)lower); return NULL; } /* Extract sign, make man positive, and set bit count */ sign = (mpz_sgn(man->z) == -1); mpz_abs(upper->z, man->z); bc = mpz_sizeinbase(upper->z, 2); if (!prec) prec = bc; shift = bc - prec; if (shift > 0) { switch (rnd[0]) { case 'f': if(sign) { mpz_cdiv_q_2exp(upper->z, upper->z, shift); } else { mpz_fdiv_q_2exp(upper->z, upper->z, shift); } break; case 'c': if(sign) { mpz_fdiv_q_2exp(upper->z, upper->z, shift); } else { mpz_cdiv_q_2exp(upper->z, upper->z, shift); } break; case 'd': mpz_fdiv_q_2exp(upper->z, upper->z, shift); break; case 'u': mpz_cdiv_q_2exp(upper->z, upper->z, shift); break; case 'n': default: mpz_tdiv_r_2exp(lower->z, upper->z, shift); mpz_tdiv_q_2exp(upper->z, upper->z, shift); if (mpz_sgn(lower->z)) { /* lower is not 0 so it must have at least 1 bit set */ if (mpz_sizeinbase(lower->z, 2)==shift) { /* lower is >= 1/2 */ if (mpz_scan1(lower->z, 0)==shift-1) { /* lower is exactly 1/2 */ if (mpz_odd_p(upper->z)) carry = 1; } else { carry = 1; } } } if (carry) mpz_add_ui(upper->z, upper->z, 1); } if (!(tmp = PyIntOrLong_FromLong(shift))) { Py_DECREF((PyObject*)upper); Py_DECREF((PyObject*)lower); return NULL; } if (!(newexp = PyNumber_Add(exp, tmp))) { Py_DECREF((PyObject*)man); Py_DECREF((PyObject*)upper); Py_DECREF((PyObject*)lower); Py_DECREF(tmp); return NULL; } Py_DECREF(tmp); bc = prec; } else { newexp = exp; Py_INCREF(newexp); } /* Strip trailing 0 bits. */ if ((zbits = mpz_scan1(upper->z, 0))) mpz_tdiv_q_2exp(upper->z, upper->z, zbits); if (!(tmp = PyIntOrLong_FromLong(zbits))) { Py_DECREF((PyObject*)man); Py_DECREF((PyObject*)upper); Py_DECREF((PyObject*)lower); Py_DECREF(newexp); return NULL; } if (!(newexp2 = PyNumber_Add(newexp, tmp))) { Py_DECREF((PyObject*)man); Py_DECREF((PyObject*)upper); Py_DECREF((PyObject*)lower); Py_DECREF(tmp); Py_DECREF(newexp); return NULL; } Py_DECREF(newexp); Py_DECREF(tmp); bc -= zbits; /* Check if one less than a power of 2 was rounded up. */ if (!mpz_cmp_ui(upper->z, 1)) bc = 1; Py_DECREF((PyObject*)lower); Py_DECREF((PyObject*)man); return mpmath_build_mpf(sign, upper, newexp2, bc); }
static PyObject * EC_new(PyTypeObject *self, PyObject *args, PyObject *kw) { PyObject *name, *bases=NULL, *dict=NULL; PyObject *new_bases=NULL, *new_args, *result; int have_base = 0, i; if (kw && PyObject_IsTrue(kw)) { PyErr_SetString(PyExc_TypeError, "Keyword arguments are not supported"); return NULL; } if (!PyArg_ParseTuple(args, "O|O!O!", &name, &PyTuple_Type, &bases, &PyDict_Type, &dict)) return NULL; /* Make sure Base is in bases */ if (bases) { for (i = 0; i < PyTuple_GET_SIZE(bases); i++) { if (PyObject_TypeCheck(PyTuple_GET_ITEM(bases, i), &ExtensionClassType)) { have_base = 1; break; } } if (! have_base) { new_bases = PyTuple_New(PyTuple_GET_SIZE(bases) + 1); if (new_bases == NULL) return NULL; for (i = 0; i < PyTuple_GET_SIZE(bases); i++) { Py_XINCREF(PyTuple_GET_ITEM(bases, i)); PyTuple_SET_ITEM(new_bases, i, PyTuple_GET_ITEM(bases, i)); } Py_INCREF(OBJECT(&BaseType)); PyTuple_SET_ITEM(new_bases, PyTuple_GET_SIZE(bases), OBJECT(&BaseType)); } } else { new_bases = Py_BuildValue("(O)", &BaseType); if (new_bases == NULL) return NULL; } if (new_bases) { if (dict) new_args = Py_BuildValue("OOO", name, new_bases, dict); else new_args = Py_BuildValue("OO", name, new_bases); Py_DECREF(new_bases); if (new_args == NULL) return NULL; result = PyType_Type.tp_new(self, new_args, kw); Py_DECREF(new_args); } else { result = PyType_Type.tp_new(self, args, kw); /* We didn't have to add Base, so maybe NoInstanceDictionaryBase is in the bases. We need to check if it was. If it was, we need to suppress instance dictionary support. */ for (i = 0; i < PyTuple_GET_SIZE(bases); i++) { if ( PyObject_TypeCheck(PyTuple_GET_ITEM(bases, i), &ExtensionClassType) && PyType_IsSubtype(TYPE(PyTuple_GET_ITEM(bases, i)), &NoInstanceDictionaryBaseType) ) { TYPE(result)->tp_dictoffset = 0; break; } } } return result; }
PyObject *PyObjectPlus::py_base_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyTypeObject *base_type; /* one or more args is needed */ if (!PyTuple_GET_SIZE(args)) { PyErr_SetString(PyExc_TypeError, "Expected at least one argument"); return NULL; } PyObjectPlus_Proxy *base = (PyObjectPlus_Proxy *)PyTuple_GET_ITEM(args, 0); /** * the 'base' PyObject may be subclassed (multiple times even) * we need to find the first C++ defined class to check 'type' * is a subclass of the base arguments type. * * This way we can share one tp_new function for every PyObjectPlus * * eg. * * # CustomOb is called 'type' in this C code * \code{.py} * class CustomOb(GameTypes.KX_GameObject): * pass * * # this calls py_base_new(...), the type of 'CustomOb' is checked to be a subclass of the 'cont.owner' type * ob = CustomOb(cont.owner) * \endcode * */ base_type= Py_TYPE(base); while (base_type && !BGE_PROXY_CHECK_TYPE(base_type)) base_type= base_type->tp_base; if (base_type==NULL || !BGE_PROXY_CHECK_TYPE(base_type)) { PyErr_SetString(PyExc_TypeError, "can't subclass from a blender game type because the argument given is not a game class or subclass"); return NULL; } /* use base_type rather than Py_TYPE(base) because we could already be subtyped */ if (!PyType_IsSubtype(type, base_type)) { PyErr_Format(PyExc_TypeError, "can't subclass blender game type <%s> from <%s> because it is not a subclass", base_type->tp_name, type->tp_name); return NULL; } /* invalidate the existing base and return a new subclassed one, * this is a bit dodgy in that it also attaches its self to the existing object * which is not really 'correct' python OO but for our use its OK. */ PyObjectPlus_Proxy *ret = (PyObjectPlus_Proxy *) type->tp_alloc(type, 0); /* starts with 1 ref, used for the return ref' */ ret->ref= base->ref; ret->ptr= base->ptr; ret->py_owns= base->py_owns; ret->py_ref = base->py_ref; if (ret->py_ref) { base->ref= NULL; /* invalidate! disallow further access */ base->ptr = NULL; if (ret->ref) ret->ref->m_proxy= NULL; /* 'base' may be freed after this func finished but not necessarily * there is no reference to the BGE data now so it will throw an error on access */ Py_DECREF(base); if (ret->ref) { ret->ref->m_proxy= (PyObject *)ret; /* no need to add a ref because one is added when creating. */ Py_INCREF(ret); /* we return a new ref but m_proxy holds a ref so we need to add one */ } } else { // generic structures don't hold a reference to this proxy, so don't increment ref count if (ret->py_owns) // but if the proxy owns the structure, there can be only one owner base->ptr= NULL; } return (PyObject *)ret; }
PyObject * Base_getattro(PyObject *obj, PyObject *name) { /* This is a modified copy of PyObject_GenericGetAttr. See the change note below. */ PyTypeObject *tp = obj->ob_type; PyObject *descr = NULL; PyObject *res = NULL; descrgetfunc f; long dictoffset; PyObject **dictptr; if (!PyString_Check(name)){ #ifdef Py_USING_UNICODE /* The Unicode to string conversion is done here because the existing tp_setattro slots expect a string object as name and we wouldn't want to break those. */ if (PyUnicode_Check(name)) { name = PyUnicode_AsEncodedString(name, NULL, NULL); if (name == NULL) return NULL; } else #endif { PyErr_SetString(PyExc_TypeError, "attribute name must be string"); return NULL; } } else Py_INCREF(name); if (tp->tp_dict == NULL) { if (PyType_Ready(tp) < 0) goto done; } /* Inline _PyType_Lookup */ { int i, n; PyObject *mro, *base, *dict; /* Look in tp_dict of types in MRO */ mro = tp->tp_mro; assert(mro != NULL); assert(PyTuple_Check(mro)); n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { base = PyTuple_GET_ITEM(mro, i); if (PyClass_Check(base)) dict = ((PyClassObject *)base)->cl_dict; else { assert(PyType_Check(base)); dict = ((PyTypeObject *)base)->tp_dict; } assert(dict && PyDict_Check(dict)); descr = PyDict_GetItem(dict, name); if (descr != NULL) break; } } f = NULL; if (descr != NULL && PyType_HasFeature(descr->ob_type, Py_TPFLAGS_HAVE_CLASS)) { f = descr->ob_type->tp_descr_get; if (f != NULL && PyDescr_IsData(descr)) { res = f(descr, obj, (PyObject *)obj->ob_type); goto done; } } /* Inline _PyObject_GetDictPtr */ dictoffset = tp->tp_dictoffset; if (dictoffset != 0) { PyObject *dict; if (dictoffset < 0) { int tsize; size_t size; tsize = ((PyVarObject *)obj)->ob_size; if (tsize < 0) tsize = -tsize; size = _PyObject_VAR_SIZE(tp, tsize); dictoffset += (long)size; assert(dictoffset > 0); assert(dictoffset % SIZEOF_VOID_P == 0); } dictptr = (PyObject **) ((char *)obj + dictoffset); dict = *dictptr; if (dict != NULL) { res = PyDict_GetItem(dict, name); if (res != NULL) { /* CHANGED! If the tp_descr_get of res is of_get, then call it. */ if (PyObject_TypeCheck(res->ob_type, &ExtensionClassType) && res->ob_type->tp_descr_get != NULL) res = res->ob_type->tp_descr_get( res, obj, OBJECT(obj->ob_type)); else Py_INCREF(res); goto done; } } } if (f != NULL) { res = f(descr, obj, (PyObject *)obj->ob_type); goto done; } if (descr != NULL) { Py_INCREF(descr); res = descr; goto done; } /* CHANGED: Just use the name. Don't format. */ PyErr_SetObject(PyExc_AttributeError, name); done: Py_DECREF(name); return res; }
static PyObject * GMPy_MPZ_Function_Invert(PyObject *self, PyObject *args) { PyObject *x, *y; MPZ_Object *result = NULL, *tempx = NULL, *tempy = NULL; int success; if (PyTuple_GET_SIZE(args) != 2) { TYPE_ERROR("invert() requires 'mpz','mpz' arguments"); return NULL; } if (!(result = GMPy_MPZ_New(NULL))) { /* LCOV_EXCL_START */ return NULL; /* LCOV_EXCL_STOP */ } x = PyTuple_GET_ITEM(args, 0); y = PyTuple_GET_ITEM(args, 1); if (MPZ_Check(x) && MPZ_Check(y)) { if (mpz_sgn(MPZ(y)) == 0) { ZERO_ERROR("invert() division by 0"); Py_DECREF((PyObject*)result); return NULL; } success = mpz_invert(result->z, MPZ(x), MPZ(y)); if (!success) { ZERO_ERROR("invert() no inverse exists"); Py_DECREF((PyObject*)result); return NULL; } } else { if (!(tempx = GMPy_MPZ_From_Integer(x, NULL)) || !(tempy = GMPy_MPZ_From_Integer(y, NULL))) { TYPE_ERROR("invert() requires 'mpz','mpz' arguments"); Py_XDECREF((PyObject*)tempx); Py_XDECREF((PyObject*)tempy); Py_DECREF((PyObject*)result); return NULL; } if (mpz_sgn(tempy->z) == 0) { ZERO_ERROR("invert() division by 0"); Py_DECREF((PyObject*)tempx); Py_DECREF((PyObject*)tempy); Py_DECREF(result); return NULL; } success = mpz_invert(result->z, tempx->z, tempy->z); Py_DECREF((PyObject*)tempx); Py_DECREF((PyObject*)tempy); if (!success) { ZERO_ERROR("invert() no inverse exists"); Py_DECREF((PyObject*)result); return NULL; } } return (PyObject*)result; }
PyFrameObject * PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals, PyObject *locals) { PyFrameObject *back = tstate->frame; PyFrameObject *f; PyObject *builtins; Py_ssize_t i; #ifdef Py_DEBUG if (code == NULL || globals == NULL || !PyDict_Check(globals) || (locals != NULL && !PyMapping_Check(locals))) { PyErr_BadInternalCall(); return NULL; } #endif if (back == NULL || back->f_globals != globals) { builtins = PyDict_GetItem(globals, builtin_object); if (builtins) { if (PyModule_Check(builtins)) { builtins = PyModule_GetDict(builtins); assert(!builtins || PyDict_Check(builtins)); } else if (!PyDict_Check(builtins)) builtins = NULL; } if (builtins == NULL) { /* No builtins! Make up a minimal one Give them 'None', at least. */ builtins = PyDict_New(); if (builtins == NULL || PyDict_SetItemString( builtins, "None", Py_None) < 0) return NULL; } else Py_INCREF(builtins); } else { /* If we share the globals, we share the builtins. Save a lookup and a call. */ builtins = back->f_builtins; assert(builtins != NULL && PyDict_Check(builtins)); Py_INCREF(builtins); } if (code->co_zombieframe != NULL) { f = code->co_zombieframe; code->co_zombieframe = NULL; _Py_NewReference((PyObject *)f); assert(f->f_code == code); } else { Py_ssize_t extras, ncells, nfrees; ncells = PyTuple_GET_SIZE(code->co_cellvars); nfrees = PyTuple_GET_SIZE(code->co_freevars); extras = code->co_stacksize + code->co_nlocals + ncells + nfrees; if (free_list == NULL) { f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type, extras); if (f == NULL) { Py_DECREF(builtins); return NULL; } } else { assert(numfree > 0); --numfree; f = free_list; free_list = free_list->f_back; if (Py_SIZE(f) < extras) { f = PyObject_GC_Resize(PyFrameObject, f, extras); if (f == NULL) { Py_DECREF(builtins); return NULL; } } _Py_NewReference((PyObject *)f); } f->f_code = code; extras = code->co_nlocals + ncells + nfrees; f->f_valuestack = f->f_localsplus + extras; for (i=0; i<extras; i++) f->f_localsplus[i] = NULL; f->f_locals = NULL; f->f_trace = NULL; f->f_exc_type = f->f_exc_value = f->f_exc_traceback = NULL; } f->f_stacktop = f->f_valuestack; f->f_builtins = builtins; Py_XINCREF(back); f->f_back = back; Py_INCREF(code); Py_INCREF(globals); f->f_globals = globals; /* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */ if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) == (CO_NEWLOCALS | CO_OPTIMIZED)) ; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */ else if (code->co_flags & CO_NEWLOCALS) { locals = PyDict_New(); if (locals == NULL) { Py_DECREF(f); return NULL; } f->f_locals = locals; } else { if (locals == NULL) locals = globals; Py_INCREF(locals); f->f_locals = locals; } f->f_tstate = tstate; f->f_lasti = -1; f->f_lineno = code->co_firstlineno; f->f_iblock = 0; _PyObject_GC_TRACK(f); return f; }
//============================================================================= // Tuple iteration functions // itemValue is borrowed reference, no ref counting //============================================================================= void Tuple_iterBegin(JSOBJ obj, JSONTypeContext *tc) { GET_TC(tc)->index = 0; GET_TC(tc)->size = PyTuple_GET_SIZE( (PyObject *) obj); GET_TC(tc)->itemValue = NULL; }
static uint32_t pointless_export_py_rec(pointless_export_state_t* state, PyObject* py_object, uint32_t depth) { // don't go too deep if (depth >= POINTLESS_MAX_DEPTH) { PyErr_SetString(PyExc_ValueError, "structure is too deep"); state->is_error = 1; printf("line: %i\n", __LINE__); state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } // check simple types first uint32_t handle = POINTLESS_CREATE_VALUE_FAIL; // return an error on failure #define RETURN_OOM(state) {PyErr_NoMemory(); (state)->is_error = 1; printf("line: %i\n", __LINE__); state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL;} #define RETURN_OOM_IF_FAIL(handle, state) if ((handle) == POINTLESS_CREATE_VALUE_FAIL) RETURN_OOM(state); // booleans, need this above integer check, cause PyInt_Check return 1 for booleans if (PyBool_Check(py_object)) { if (py_object == Py_True) handle = pointless_create_boolean_true(&state->c); else handle = pointless_create_boolean_false(&state->c); RETURN_OOM_IF_FAIL(handle, state); // integer } else if (PyInt_Check(py_object)) { long v = PyInt_AS_LONG(py_object); // unsigned if (v >= 0) { if (v > UINT32_MAX) { PyErr_Format(PyExc_ValueError, "integer too large for mere 32 bits"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_u32(&state->c, (uint32_t)v); // signed } else { if (!(INT32_MIN <= v && v <= INT32_MAX)) { PyErr_Format(PyExc_ValueError, "integer too large for mere 32 bits with a sign"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_i32(&state->c, (int32_t)v); } RETURN_OOM_IF_FAIL(handle, state); // long } else if (PyLong_Check(py_object)) { // this will raise an overflow error if number is outside the legal range of PY_LONG_LONG PY_LONG_LONG v = PyLong_AsLongLong(py_object); // if there was an exception, clear it, and set our own if (PyErr_Occurred()) { PyErr_Clear(); PyErr_SetString(PyExc_ValueError, "value of long is way beyond what we can store right now"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } // unsigned if (v >= 0) { if (v > UINT32_MAX) { PyErr_Format(PyExc_ValueError, "long too large for mere 32 bits"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_u32(&state->c, (uint32_t)v); // signed } else { if (!(INT32_MIN <= v && v <= INT32_MAX)) { PyErr_Format(PyExc_ValueError, "long too large for mere 32 bits with a sign"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_i32(&state->c, (int32_t)v); } RETURN_OOM_IF_FAIL(handle, state); // None object } else if (py_object == Py_None) { handle = pointless_create_null(&state->c); RETURN_OOM_IF_FAIL(handle, state); } else if (PyFloat_Check(py_object)) { handle = pointless_create_float(&state->c, (float)PyFloat_AS_DOUBLE(py_object)); RETURN_OOM_IF_FAIL(handle, state); } if (handle != POINTLESS_CREATE_VALUE_FAIL) return handle; // remaining types are containers/big-values, which we track // either for space-savings or maintaining circular references // if object has been seen before, return its handle handle = pointless_export_get_seen(state, py_object); if (handle != POINTLESS_CREATE_VALUE_FAIL) return handle; // list/tuple object if (PyList_Check(py_object) || PyTuple_Check(py_object)) { // create and cache handle assert(is_container(py_object)); handle = pointless_create_vector_value(&state->c); RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // populate vector Py_ssize_t i, n_items = PyList_Check(py_object) ? PyList_GET_SIZE(py_object) : PyTuple_GET_SIZE(py_object); for (i = 0; i < n_items; i++) { PyObject* child = PyList_Check(py_object) ? PyList_GET_ITEM(py_object, i) : PyTuple_GET_ITEM(py_object, i); uint32_t child_handle = pointless_export_py_rec(state, child, depth + 1); if (child_handle == POINTLESS_CREATE_VALUE_FAIL) return child_handle; if (pointless_create_vector_value_append(&state->c, handle, child_handle) == POINTLESS_CREATE_VALUE_FAIL) { RETURN_OOM(state); } } // pointless value vectors } else if (PyPointlessVector_Check(py_object)) { // currently, we only support value vectors, they are simple PyPointlessVector* v = (PyPointlessVector*)py_object; const char* error = 0; switch(v->v->type) { case POINTLESS_VECTOR_VALUE: case POINTLESS_VECTOR_VALUE_HASHABLE: handle = pointless_recreate_value(&v->pp->p, v->v, &state->c, &error); if (handle == POINTLESS_CREATE_VALUE_FAIL) { printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; PyErr_Format(PyExc_ValueError, "pointless_recreate_value(): %s", error); return POINTLESS_CREATE_VALUE_FAIL; } break; case POINTLESS_VECTOR_I8: handle = pointless_create_vector_i8_owner(&state->c, pointless_reader_vector_i8(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_U8: handle = pointless_create_vector_u8_owner(&state->c, pointless_reader_vector_u8(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_I16: handle = pointless_create_vector_i16_owner(&state->c, pointless_reader_vector_i16(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_U16: handle = pointless_create_vector_u16_owner(&state->c, pointless_reader_vector_u16(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_I32: handle = pointless_create_vector_i32_owner(&state->c, pointless_reader_vector_i32(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_U32: handle = pointless_create_vector_u32_owner(&state->c, pointless_reader_vector_u32(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_I64: handle = pointless_create_vector_i64_owner(&state->c, pointless_reader_vector_i64(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_U64: handle = pointless_create_vector_u64_owner(&state->c, pointless_reader_vector_u64(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_FLOAT: handle = pointless_create_vector_float_owner(&state->c, pointless_reader_vector_float(&v->pp->p, v->v) + v->slice_i, v->slice_n); break; case POINTLESS_VECTOR_EMPTY: handle = pointless_create_vector_value(&state->c); break; default: state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; PyErr_SetString(PyExc_ValueError, "internal error: illegal type for primitive vector"); return POINTLESS_CREATE_VALUE_FAIL; } RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // python bytearray } else if (PyByteArray_Check(py_object)) { // create handle and hand over the memory Py_ssize_t n_items = PyByteArray_GET_SIZE(py_object); if (n_items > UINT32_MAX) { PyErr_SetString(PyExc_ValueError, "bytearray has too many items"); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_vector_u8_owner(&state->c, (uint8_t*)PyByteArray_AS_STRING(py_object), (uint32_t)n_items); RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // primitive vectors } else if (PyPointlessPrimVector_Check(py_object)) { // we just hand over the memory PyPointlessPrimVector* prim_vector = (PyPointlessPrimVector*)py_object; uint32_t n_items = pointless_dynarray_n_items(&prim_vector->array); void* data = prim_vector->array._data; switch (prim_vector->type) { case POINTLESS_PRIM_VECTOR_TYPE_I8: handle = pointless_create_vector_i8_owner(&state->c, (int8_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_U8: handle = pointless_create_vector_u8_owner(&state->c, (uint8_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_I16: handle = pointless_create_vector_i16_owner(&state->c, (int16_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_U16: handle = pointless_create_vector_u16_owner(&state->c, (uint16_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_I32: handle = pointless_create_vector_i32_owner(&state->c, (int32_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_U32: handle = pointless_create_vector_u32_owner(&state->c, (uint32_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_I64: handle = pointless_create_vector_i64_owner(&state->c, (int64_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_U64: handle = pointless_create_vector_u64_owner(&state->c, (uint64_t*)data, n_items); break; case POINTLESS_PRIM_VECTOR_TYPE_FLOAT: handle = pointless_create_vector_float_owner(&state->c, (float*)data, n_items); break; default: PyErr_SetString(PyExc_ValueError, "internal error: illegal type for primitive vector"); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; return POINTLESS_CREATE_VALUE_FAIL; } RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // unicode object } else if (PyUnicode_Check(py_object)) { // get it from python Py_UNICODE* python_buffer = PyUnicode_AS_UNICODE(py_object); // string must not contain zero's Py_ssize_t s_len_python = PyUnicode_GET_SIZE(py_object); #if Py_UNICODE_SIZE == 4 uint32_t s_len_pointless = pointless_ucs4_len(python_buffer); #else uint32_t s_len_pointless = pointless_ucs2_len(python_buffer); #endif if (s_len_python < 0 || (uint64_t)s_len_python != s_len_pointless) { PyErr_SetString(PyExc_ValueError, "unicode string contains a zero, where it shouldn't"); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; return POINTLESS_CREATE_VALUE_FAIL; } #if Py_UNICODE_SIZE == 4 if (state->unwiden_strings && pointless_is_ucs4_ascii((uint32_t*)python_buffer)) handle = pointless_create_string_ucs4(&state->c, python_buffer); else handle = pointless_create_unicode_ucs4(&state->c, python_buffer); #else if (state->unwiden_strings && pointless_is_ucs2_ascii(python_buffer)) handle = pointless_create_string_ucs2(&state->c, python_buffer); else handle = pointless_create_unicode_ucs2(&state->c, python_buffer); #endif RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // string object } else if (PyString_Check(py_object)) { // get it from python uint8_t* python_buffer = (uint8_t*)PyString_AS_STRING(py_object); // string must not contain zero's Py_ssize_t s_len_python = PyString_GET_SIZE(py_object); uint32_t s_len_pointless = pointless_ascii_len(python_buffer); if (s_len_python < 0 || (uint64_t)s_len_python != s_len_pointless) { PyErr_SetString(PyExc_ValueError, "string contains a zero, where it shouldn't"); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; return POINTLESS_CREATE_VALUE_FAIL; } handle = pointless_create_string_ascii(&state->c, python_buffer); RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // dict object } else if (PyDict_Check(py_object)) { handle = pointless_create_map(&state->c); RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } PyObject* key = 0; PyObject* value = 0; Py_ssize_t pos = 0; while (PyDict_Next(py_object, &pos, &key, &value)) { uint32_t key_handle = pointless_export_py_rec(state, key, depth + 1); uint32_t value_handle = pointless_export_py_rec(state, value, depth + 1); if (key_handle == POINTLESS_CREATE_VALUE_FAIL || value_handle == POINTLESS_CREATE_VALUE_FAIL) break; if (pointless_create_map_add(&state->c, handle, key_handle, value_handle) == POINTLESS_CREATE_VALUE_FAIL) { PyErr_SetString(PyExc_ValueError, "error adding key/value pair to map"); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; break; } } if (state->is_error) { return POINTLESS_CREATE_VALUE_FAIL; } // set object } else if (PyAnySet_Check(py_object)) { PyObject* iterator = PyObject_GetIter(py_object); PyObject* item = 0; if (iterator == 0) { printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } // get a handle handle = pointless_create_set(&state->c); RETURN_OOM_IF_FAIL(handle, state); // cache object if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // iterate over it while ((item = PyIter_Next(iterator)) != 0) { uint32_t item_handle = pointless_export_py_rec(state, item, depth + 1); if (item_handle == POINTLESS_CREATE_VALUE_FAIL) break; if (pointless_create_set_add(&state->c, handle, item_handle) == POINTLESS_CREATE_VALUE_FAIL) { PyErr_SetString(PyExc_ValueError, "error adding item to set"); printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; break; } } Py_DECREF(iterator); if (PyErr_Occurred()) { printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; return POINTLESS_CREATE_VALUE_FAIL; } // bitvector } else if (PyPointlessBitvector_Check(py_object)) { PyPointlessBitvector* bitvector = (PyPointlessBitvector*)py_object; if (bitvector->is_pointless) { uint32_t i, n_bits = pointless_reader_bitvector_n_bits(&bitvector->pointless_pp->p, bitvector->pointless_v); void* bits = pointless_calloc(ICEIL(n_bits, 8), 1); if (bits == 0) { RETURN_OOM(state); } for (i = 0; i < n_bits; i++) { if (pointless_reader_bitvector_is_set(&bitvector->pointless_pp->p, bitvector->pointless_v, i)) bm_set_(bits, i); } if (state->normalize_bitvector) handle = pointless_create_bitvector(&state->c, bits, n_bits); else handle = pointless_create_bitvector_no_normalize(&state->c, bits, n_bits); pointless_free(bits); bits = 0; } else { if (state->normalize_bitvector) handle = pointless_create_bitvector(&state->c, bitvector->primitive_bits, bitvector->primitive_n_bits); else handle = pointless_create_bitvector_no_normalize(&state->c, bitvector->primitive_bits, bitvector->primitive_n_bits); } RETURN_OOM_IF_FAIL(handle, state); if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } } else if (PyPointlessSet_Check(py_object)) { PyPointlessSet* set = (PyPointlessSet*)py_object; const char* error = 0; handle = pointless_recreate_value(&set->pp->p, set->v, &state->c, &error); if (handle == POINTLESS_CREATE_VALUE_FAIL) { printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; PyErr_Format(PyExc_ValueError, "pointless_recreate_value(): %s", error); return POINTLESS_CREATE_VALUE_FAIL; } if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } } else if (PyPointlessMap_Check(py_object)) { PyPointlessMap* map = (PyPointlessMap*)py_object; const char* error = 0; handle = pointless_recreate_value(&map->pp->p, map->v, &state->c, &error); if (handle == POINTLESS_CREATE_VALUE_FAIL) { printf("line: %i\n", __LINE__); state->is_error = 1; state->error_line = __LINE__; PyErr_Format(PyExc_ValueError, "pointless_recreate_value(): %s", error); return POINTLESS_CREATE_VALUE_FAIL; } if (!pointless_export_set_seen(state, py_object, handle)) { RETURN_OOM(state); } // type not supported } else { PyErr_Format(PyExc_ValueError, "type <%s> not supported", py_object->ob_type->tp_name); state->error_line = __LINE__; printf("line: %i\n", __LINE__); state->is_error = 1; } #undef RETURN_OOM #undef RETURN_IF_OOM return handle; }
Py_ssize_t pysqlite_row_length(pysqlite_Row* self, PyObject* args, PyObject* kwargs) { return PyTuple_GET_SIZE(self->data); }
/* * Fill in str with an appropriate PEP 3118 format string, based on * descr. For structured dtypes, calls itself recursively. Each call extends * str at offset then updates offset, and uses descr->byteorder, (and * possibly the byte order in obj) to determine the byte-order char. * * Returns 0 for success, -1 for failure */ static int _buffer_format_string(PyArray_Descr *descr, _tmp_string_t *str, PyObject* obj, Py_ssize_t *offset, char *active_byteorder) { int k; char _active_byteorder = '@'; Py_ssize_t _offset = 0; if (active_byteorder == NULL) { active_byteorder = &_active_byteorder; } if (offset == NULL) { offset = &_offset; } if (descr->subarray) { PyObject *item, *subarray_tuple; Py_ssize_t total_count = 1; Py_ssize_t dim_size; Py_ssize_t old_offset; char buf[128]; int ret; if (PyTuple_Check(descr->subarray->shape)) { subarray_tuple = descr->subarray->shape; Py_INCREF(subarray_tuple); } else { subarray_tuple = Py_BuildValue("(O)", descr->subarray->shape); } if (_append_char(str, '(') < 0) { ret = -1; goto subarray_fail; } for (k = 0; k < PyTuple_GET_SIZE(subarray_tuple); ++k) { if (k > 0) { if (_append_char(str, ',') < 0) { ret = -1; goto subarray_fail; } } item = PyTuple_GET_ITEM(subarray_tuple, k); dim_size = PyNumber_AsSsize_t(item, NULL); PyOS_snprintf(buf, sizeof(buf), "%ld", (long)dim_size); if (_append_str(str, buf) < 0) { ret = -1; goto subarray_fail; } total_count *= dim_size; } if (_append_char(str, ')') < 0) { ret = -1; goto subarray_fail; } old_offset = *offset; ret = _buffer_format_string(descr->subarray->base, str, obj, offset, active_byteorder); *offset = old_offset + (*offset - old_offset) * total_count; subarray_fail: Py_DECREF(subarray_tuple); return ret; } else if (PyDataType_HASFIELDS(descr)) { Py_ssize_t base_offset = *offset; if (_append_str(str, "T{") < 0) return -1; for (k = 0; k < PyTuple_GET_SIZE(descr->names); ++k) { PyObject *name, *item, *offset_obj; PyArray_Descr *child; Py_ssize_t new_offset; int ret; name = PyTuple_GET_ITEM(descr->names, k); item = PyDict_GetItem(descr->fields, name); child = (PyArray_Descr*)PyTuple_GetItem(item, 0); offset_obj = PyTuple_GetItem(item, 1); new_offset = PyInt_AsLong(offset_obj); if (error_converting(new_offset)) { return -1; } new_offset += base_offset; /* Insert padding manually */ if (*offset > new_offset) { PyErr_SetString( PyExc_ValueError, "dtypes with overlapping or out-of-order fields are not " "representable as buffers. Consider reordering the fields." ); return -1; } while (*offset < new_offset) { if (_append_char(str, 'x') < 0) return -1; ++*offset; } /* Insert child item */ ret = _buffer_format_string(child, str, obj, offset, active_byteorder); if (ret < 0) { return -1; } /* Insert field name */ if (_append_field_name(str, name) < 0) return -1; } if (_append_char(str, '}') < 0) return -1; } else { int is_standard_size = 1; int is_natively_aligned; int is_native_only_type = (descr->type_num == NPY_LONGDOUBLE || descr->type_num == NPY_CLONGDOUBLE); if (sizeof(npy_longlong) != 8) { is_native_only_type = is_native_only_type || ( descr->type_num == NPY_LONGLONG || descr->type_num == NPY_ULONGLONG); } *offset += descr->elsize; if (PyArray_IsScalar(obj, Generic)) { /* scalars are always natively aligned */ is_natively_aligned = 1; } else { is_natively_aligned = _is_natively_aligned_at(descr, (PyArrayObject*)obj, *offset); } if (descr->byteorder == '=' && is_natively_aligned) { /* Prefer native types, to cater for Cython */ is_standard_size = 0; if (*active_byteorder != '@') { if (_append_char(str, '@') < 0) return -1; *active_byteorder = '@'; } } else if (descr->byteorder == '=' && is_native_only_type) { /* Data types that have no standard size */ is_standard_size = 0; if (*active_byteorder != '^') { if (_append_char(str, '^') < 0) return -1; *active_byteorder = '^'; } } else if (descr->byteorder == '<' || descr->byteorder == '>' || descr->byteorder == '=') { is_standard_size = 1; if (*active_byteorder != descr->byteorder) { if (_append_char(str, descr->byteorder) < 0) return -1; *active_byteorder = descr->byteorder; } if (is_native_only_type) { /* * It's not possible to express native-only data types * in non-native npy_byte orders */ PyErr_Format(PyExc_ValueError, "cannot expose native-only dtype '%c' in " "non-native byte order '%c' via buffer interface", descr->type, descr->byteorder); return -1; } } switch (descr->type_num) { case NPY_BOOL: if (_append_char(str, '?') < 0) return -1; break; case NPY_BYTE: if (_append_char(str, 'b') < 0) return -1; break; case NPY_UBYTE: if (_append_char(str, 'B') < 0) return -1; break; case NPY_SHORT: if (_append_char(str, 'h') < 0) return -1; break; case NPY_USHORT: if (_append_char(str, 'H') < 0) return -1; break; case NPY_INT: if (_append_char(str, 'i') < 0) return -1; break; case NPY_UINT: if (_append_char(str, 'I') < 0) return -1; break; case NPY_LONG: if (is_standard_size && (NPY_SIZEOF_LONG == 8)) { if (_append_char(str, 'q') < 0) return -1; } else { if (_append_char(str, 'l') < 0) return -1; } break; case NPY_ULONG: if (is_standard_size && (NPY_SIZEOF_LONG == 8)) { if (_append_char(str, 'Q') < 0) return -1; } else { if (_append_char(str, 'L') < 0) return -1; } break; case NPY_LONGLONG: if (_append_char(str, 'q') < 0) return -1; break; case NPY_ULONGLONG: if (_append_char(str, 'Q') < 0) return -1; break; case NPY_HALF: if (_append_char(str, 'e') < 0) return -1; break; case NPY_FLOAT: if (_append_char(str, 'f') < 0) return -1; break; case NPY_DOUBLE: if (_append_char(str, 'd') < 0) return -1; break; case NPY_LONGDOUBLE: if (_append_char(str, 'g') < 0) return -1; break; case NPY_CFLOAT: if (_append_str(str, "Zf") < 0) return -1; break; case NPY_CDOUBLE: if (_append_str(str, "Zd") < 0) return -1; break; case NPY_CLONGDOUBLE: if (_append_str(str, "Zg") < 0) return -1; break; /* XXX NPY_DATETIME */ /* XXX NPY_TIMEDELTA */ case NPY_OBJECT: if (_append_char(str, 'O') < 0) return -1; break; case NPY_STRING: { char buf[128]; PyOS_snprintf(buf, sizeof(buf), "%ds", descr->elsize); if (_append_str(str, buf) < 0) return -1; break; } case NPY_UNICODE: { /* NumPy Unicode is always 4-byte */ char buf[128]; assert(descr->elsize % 4 == 0); PyOS_snprintf(buf, sizeof(buf), "%dw", descr->elsize / 4); if (_append_str(str, buf) < 0) return -1; break; } case NPY_VOID: { /* Insert padding bytes */ char buf[128]; PyOS_snprintf(buf, sizeof(buf), "%dx", descr->elsize); if (_append_str(str, buf) < 0) return -1; break; } default: PyErr_Format(PyExc_ValueError, "cannot include dtype '%c' in a buffer", descr->type); return -1; } } return 0; }
static void python_vptuple(VALUE_PAIR **vpp, PyObject *pValue, const char *funcname) { int i; int tuplesize; VALUE_PAIR *vp; /* * If the Python function gave us None for the tuple, * then just return. */ if (pValue == Py_None) return; if (!PyTuple_CheckExact(pValue)) { radlog(L_ERR, "rlm_python:%s: non-tuple passed", funcname); return; } /* Get the tuple tuplesize. */ tuplesize = PyTuple_GET_SIZE(pValue); for (i = 0; i < tuplesize; i++) { PyObject *pTupleElement = PyTuple_GET_ITEM(pValue, i); PyObject *pStr1; PyObject *pStr2; PyObject *pOp; int pairsize; const char *s1; const char *s2; long op; if (!PyTuple_CheckExact(pTupleElement)) { radlog(L_ERR, "rlm_python:%s: tuple element %d is not a tuple", funcname, i); continue; } /* Check if it's a pair */ pairsize = PyTuple_GET_SIZE(pTupleElement); if ((pairsize < 2) || (pairsize > 3)) { radlog(L_ERR, "rlm_python:%s: tuple element %d is a tuple of size %d. Must be 2 or 3.", funcname, i, pairsize); continue; } if (pairsize == 2) { pStr1 = PyTuple_GET_ITEM(pTupleElement, 0); pStr2 = PyTuple_GET_ITEM(pTupleElement, 1); op = T_OP_EQ; } else { pStr1 = PyTuple_GET_ITEM(pTupleElement, 0); pStr2 = PyTuple_GET_ITEM(pTupleElement, 2); pOp = PyTuple_GET_ITEM(pTupleElement, 1); op = PyInt_AsLong(pOp); } if ((!PyString_CheckExact(pStr1)) || (!PyString_CheckExact(pStr2))) { radlog(L_ERR, "rlm_python:%s: tuple element %d must be as (str, str)", funcname, i); continue; } s1 = PyString_AsString(pStr1); s2 = PyString_AsString(pStr2); vp = pairmake(s1, s2, op); if (vp != NULL) { pairadd(vpp, vp); radlog(L_DBG, "rlm_python:%s: '%s' = '%s'", funcname, s1, s2); } else { radlog(L_DBG, "rlm_python:%s: Failed: '%s' = '%s'", funcname, s1, s2); } } }
static void Object_beginTypeContext (JSOBJ _obj, JSONTypeContext *tc, JSONObjectEncoder *enc) { PyObject *obj, *objRepr, *exc; TypeContext *pc; PRINTMARK(); if (!_obj) { tc->type = JT_INVALID; return; } obj = (PyObject*) _obj; tc->prv = PyObject_Malloc(sizeof(TypeContext)); pc = (TypeContext *) tc->prv; if (!pc) { tc->type = JT_INVALID; PyErr_NoMemory(); return; } pc->newObj = NULL; pc->dictObj = NULL; pc->itemValue = NULL; pc->itemName = NULL; pc->iterator = NULL; pc->attrList = NULL; pc->index = 0; pc->size = 0; pc->longValue = 0; pc->rawJSONValue = NULL; if (PyIter_Check(obj)) { PRINTMARK(); goto ISITERABLE; } if (PyBool_Check(obj)) { PRINTMARK(); tc->type = (obj == Py_True) ? JT_TRUE : JT_FALSE; return; } else if (PyLong_Check(obj)) { PRINTMARK(); pc->PyTypeToJSON = PyLongToINT64; tc->type = JT_LONG; GET_TC(tc)->longValue = PyLong_AsLongLong(obj); exc = PyErr_Occurred(); if (!exc) { return; } if (exc && PyErr_ExceptionMatches(PyExc_OverflowError)) { PyErr_Clear(); pc->PyTypeToJSON = PyLongToUINT64; tc->type = JT_ULONG; GET_TC(tc)->unsignedLongValue = PyLong_AsUnsignedLongLong(obj); exc = PyErr_Occurred(); if (exc && PyErr_ExceptionMatches(PyExc_OverflowError)) { PRINTMARK(); goto INVALID; } } return; } else if (PyInt_Check(obj)) { PRINTMARK(); #ifdef _LP64 pc->PyTypeToJSON = PyIntToINT64; tc->type = JT_LONG; #else pc->PyTypeToJSON = PyIntToINT32; tc->type = JT_INT; #endif return; } else if (PyString_Check(obj)) { PRINTMARK(); pc->PyTypeToJSON = PyStringToUTF8; tc->type = JT_UTF8; return; } else if (PyUnicode_Check(obj)) { PRINTMARK(); pc->PyTypeToJSON = PyUnicodeToUTF8; tc->type = JT_UTF8; return; } else if (PyFloat_Check(obj) || (type_decimal && PyObject_IsInstance(obj, type_decimal))) { PRINTMARK(); pc->PyTypeToJSON = PyFloatToDOUBLE; tc->type = JT_DOUBLE; return; } else if (obj == Py_None) { PRINTMARK(); tc->type = JT_NULL; return; } ISITERABLE: if (PyDict_Check(obj)) { PRINTMARK(); tc->type = JT_OBJECT; SetupDictIter(obj, pc, enc); Py_INCREF(obj); return; } else if (PyList_Check(obj)) { PRINTMARK(); tc->type = JT_ARRAY; pc->iterEnd = List_iterEnd; pc->iterNext = List_iterNext; pc->iterGetValue = List_iterGetValue; pc->iterGetName = List_iterGetName; GET_TC(tc)->index = 0; GET_TC(tc)->size = PyList_GET_SIZE( (PyObject *) obj); return; } else if (PyTuple_Check(obj)) { PRINTMARK(); tc->type = JT_ARRAY; pc->iterEnd = Tuple_iterEnd; pc->iterNext = Tuple_iterNext; pc->iterGetValue = Tuple_iterGetValue; pc->iterGetName = Tuple_iterGetName; GET_TC(tc)->index = 0; GET_TC(tc)->size = PyTuple_GET_SIZE( (PyObject *) obj); GET_TC(tc)->itemValue = NULL; return; } if (UNLIKELY(PyObject_HasAttrString(obj, "toDict"))) { PyObject* toDictFunc = PyObject_GetAttrString(obj, "toDict"); PyObject* tuple = PyTuple_New(0); PyObject* toDictResult = PyObject_Call(toDictFunc, tuple, NULL); Py_DECREF(tuple); Py_DECREF(toDictFunc); if (toDictResult == NULL) { goto INVALID; } if (!PyDict_Check(toDictResult)) { Py_DECREF(toDictResult); tc->type = JT_NULL; return; } PRINTMARK(); tc->type = JT_OBJECT; SetupDictIter(toDictResult, pc, enc); return; } else if (UNLIKELY(PyObject_HasAttrString(obj, "__json__"))) { PyObject* toJSONFunc = PyObject_GetAttrString(obj, "__json__"); PyObject* tuple = PyTuple_New(0); PyObject* toJSONResult = PyObject_Call(toJSONFunc, tuple, NULL); Py_DECREF(tuple); Py_DECREF(toJSONFunc); if (toJSONResult == NULL) { goto INVALID; } if (PyErr_Occurred()) { Py_DECREF(toJSONResult); goto INVALID; } if (!PyString_Check(toJSONResult) && !PyUnicode_Check(toJSONResult)) { Py_DECREF(toJSONResult); PyErr_Format (PyExc_TypeError, "expected string"); goto INVALID; } PRINTMARK(); pc->PyTypeToJSON = PyRawJSONToUTF8; tc->type = JT_RAW; GET_TC(tc)->rawJSONValue = toJSONResult; return; } PRINTMARK(); PyErr_Clear(); objRepr = PyObject_Repr(obj); PyErr_Format (PyExc_TypeError, "%s is not JSON serializable", PyString_AS_STRING(objRepr)); Py_DECREF(objRepr); INVALID: PRINTMARK(); tc->type = JT_INVALID; PyObject_Free(tc->prv); tc->prv = NULL; return; }