/* Implementation of extinheritset */ static int __pyx_f_13extinheritset_9Norwegian___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_i, PyObject *__pyx_v_x); /*proto*/ static int __pyx_f_13extinheritset_9Norwegian___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_i, PyObject *__pyx_v_x) { int __pyx_r; Py_INCREF((PyObject *)__pyx_v_self); Py_INCREF(__pyx_v_i); Py_INCREF(__pyx_v_x); __pyx_r = 0; Py_DECREF((PyObject *)__pyx_v_self); Py_DECREF(__pyx_v_i); Py_DECREF(__pyx_v_x); return __pyx_r; } static int __pyx_f_13extinheritset_9Norwegian___setslice__(PyObject *__pyx_v_self, Py_ssize_t __pyx_arg_i, Py_ssize_t __pyx_arg_j, PyObject *__pyx_v_x); /*proto*/ static int __pyx_f_13extinheritset_9Norwegian___setslice__(PyObject *__pyx_v_self, Py_ssize_t __pyx_arg_i, Py_ssize_t __pyx_arg_j, PyObject *__pyx_v_x) { PyObject *__pyx_v_i = 0; PyObject *__pyx_v_j = 0; int __pyx_r; Py_INCREF((PyObject *)__pyx_v_self); Py_INCREF(__pyx_v_x); __pyx_v_i = PyInt_FromSsize_t(__pyx_arg_i); if (!__pyx_v_i) { __pyx_filename = __pyx_f[0]; __pyx_lineno = 9; goto __pyx_L1; } __pyx_v_j = PyInt_FromSsize_t(__pyx_arg_j); if (!__pyx_v_j) { __pyx_filename = __pyx_f[0]; __pyx_lineno = 9; goto __pyx_L1; } __pyx_r = 0; goto __pyx_L0; __pyx_L1: ; __Pyx_AddTraceback("extinheritset.Norwegian.__setslice__"); __pyx_r = -1; __pyx_L0: ; Py_DECREF(__pyx_v_i); Py_DECREF(__pyx_v_j); Py_DECREF((PyObject *)__pyx_v_self); Py_DECREF(__pyx_v_x); return __pyx_r; }
PyObject * string_count(PyStringObject *self, PyObject *args) { PyObject *sub_obj; const char *str = PyString_AS_STRING(self), *sub; Py_ssize_t sub_len; Py_ssize_t start = 0, end = PY_SSIZE_T_MAX; if (!stringlib_parse_args_finds("count", args, &sub_obj, &start, &end)) return NULL; if (PyString_Check(sub_obj)) { sub = PyString_AS_STRING(sub_obj); sub_len = PyString_GET_SIZE(sub_obj); } #ifdef Py_USING_UNICODE else if (PyUnicode_Check(sub_obj)) { Py_ssize_t count; count = PyUnicode_Count((PyObject *)self, sub_obj, start, end); if (count == -1) return NULL; else return PyInt_FromSsize_t(count); } #endif else if (PyObject_AsCharBuffer(sub_obj, &sub, &sub_len)) return NULL; ADJUST_INDICES(start, end, PyString_GET_SIZE(self)); return PyInt_FromSsize_t( stringlib_count(str + start, end - start, sub, sub_len, PY_SSIZE_T_MAX) ); }
static PyObject * thread_stack_size(PyObject *self, PyObject *args) { size_t old_size; Py_ssize_t new_size = 0; int rc; if (!PyArg_ParseTuple(args, "|n:stack_size", &new_size)) return NULL; if (new_size < 0) { PyErr_SetString(PyExc_ValueError, "size must be 0 or a positive value"); return NULL; } old_size = PyThread_get_stacksize(); rc = PyThread_set_stacksize((size_t) new_size); if (rc == -1) { PyErr_Format(PyExc_ValueError, "size not valid: %zd bytes", new_size); return NULL; } if (rc == -2) { PyErr_SetString(ThreadError, "setting stack size not supported"); return NULL; } return PyInt_FromSsize_t((Py_ssize_t) old_size); }
static PyObject* java_number_to_pythonintlong(JNIEnv *env, PyObject* n) { jlong value; PyJObject *jnumber = (PyJObject*) n; if (longValue == 0) { longValue = (*env)->GetMethodID(env, JNUMBER_TYPE, "longValue", "()J"); if (process_java_exception(env)) { return NULL; } } #if PY_MAJOR_VERSION < 3 if (intValue == 0) { intValue = (*env)->GetMethodID(env, JNUMBER_TYPE, "intValue", "()I"); if (process_java_exception(env)) { return NULL; } } if ((*env)->IsInstanceOf(env, jnumber->object, JBYTE_OBJ_TYPE) || (*env)->IsInstanceOf(env, jnumber->object, JSHORT_OBJ_TYPE) || (*env)->IsInstanceOf(env, jnumber->object, JINT_OBJ_TYPE)) { jint result = (*env)->CallIntMethod(env, jnumber->object, intValue); return PyInt_FromSsize_t(result); } #endif value = (*env)->CallLongMethod(env, jnumber->object, longValue); return PyLong_FromLongLong(value); }
static PyObject * gc_collect(PyObject *self, PyObject *args, PyObject *kws) { static char *keywords[] = {"generation", NULL}; int genarg = NUM_GENERATIONS - 1; Py_ssize_t n; if (!PyArg_ParseTupleAndKeywords(args, kws, "|i", keywords, &genarg)) return NULL; else if (genarg < 0 || genarg >= NUM_GENERATIONS) { PyErr_SetString(PyExc_ValueError, "invalid generation"); return NULL; } if (collecting) n = 0; /* already collecting, don't do anything */ else { collecting = 1; n = collect(genarg); collecting = 0; } return PyInt_FromSsize_t(n); }
static PyObject * mmap_find_method(mmap_object *self, PyObject *args) { Py_ssize_t start = self->pos; char *needle; Py_ssize_t len; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "s#|n:find", &needle, &len, &start)) { return NULL; } else { char *p; char *e = self->data + self->size; if (start < 0) start += self->size; if (start < 0) start = 0; else if ((size_t)start > self->size) start = self->size; for (p = self->data + start; p + len <= e; ++p) { Py_ssize_t i; for (i = 0; i < len && needle[i] == p[i]; ++i) /* nothing */; if (i == len) { return PyInt_FromSsize_t(p - self->data); } } return PyInt_FromLong(-1); } }
static PyObject * IO_tell(IOobject *self, PyObject *unused) { if (!IO__opencheck(self)) return NULL; return PyInt_FromSsize_t(self->pos); }
struct matcher_entry *matchers_get_response(u_char *data, u_int datalen, struct ctx *ctx, u_int type, u_int src_port, u_int dst_port) { struct matcher_entry *matcher; #ifdef HAVE_PYTHON PyObject *args; PyObject *value; Py_ssize_t rdatalen; char *rdata; #endif if(!(matcher = matchers_match((const char *)data, datalen, ctx, type, src_port, dst_port))) { logger(DBG, "No matchers found for data"); return NULL; } #ifdef HAVE_PYTHON if(matcher->pyfunc) { logger(DBG, "We have a Python code to construct response"); args = PyTuple_New(2); PyTuple_SetItem(args,0,PyString_FromStringAndSize((const char *)data, datalen)); // here is data PyTuple_SetItem(args,1,PyInt_FromSsize_t(datalen)); value = PyObject_CallObject(matcher->pyfunc, args); if(value == NULL) { PyErr_Print(); logger(WARN, "Python function returns no data!"); return NULL; } rdata = PyString_AsString(value); rdatalen = PyString_Size(value); if(rdata != NULL && rdatalen > 0) { matcher->response_len = (u_int) rdatalen; if(matcher->response) { // We already have previous response, free it free(matcher->response); } matcher->response = malloc(matcher->response_len); memcpy(matcher->response, (u_char *) rdata, rdatalen); } else { PyErr_Print(); logger(WARN, "Python cannot convert return string"); return NULL; } return matcher; } #endif if(matcher->response) { logger(DBG, "We have a plain text response"); return matcher; } logger(WARN, "There is no response data!"); return NULL; }
static PyObject *ffi_offsetof(FFIObject *self, PyObject *args) { PyObject *arg; CTypeDescrObject *ct; Py_ssize_t i, offset; if (PyTuple_Size(args) < 2) { PyErr_SetString(PyExc_TypeError, "offsetof() expects at least 2 arguments"); return NULL; } arg = PyTuple_GET_ITEM(args, 0); ct = _ffi_type(self, arg, ACCEPT_STRING|ACCEPT_CTYPE); if (ct == NULL) return NULL; offset = 0; for (i = 1; i < PyTuple_GET_SIZE(args); i++) { Py_ssize_t ofs1; ct = direct_typeoffsetof(ct, PyTuple_GET_ITEM(args, i), i > 1, &ofs1); if (ct == NULL) return NULL; offset += ofs1; } return PyInt_FromSsize_t(offset); }
static PyObject *__pyx_sq_item_9ishimoto1_A(PyObject *o, Py_ssize_t i) { PyObject *r; PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; r = o->ob_type->tp_as_mapping->mp_subscript(o, x); Py_DECREF(x); return r; }
static void install(PyObject *d, char* name, void* value) { PyObject *v = PyInt_FromSsize_t((Py_ssize_t) value); if (!v || PyDict_SetItemString(d, name, v)) PyErr_Clear(); Py_XDECREF(v); }
PyObject * string_find(PyStringObject *self, PyObject *args) { Py_ssize_t result = string_find_internal(self, args, +1); if (result == -2) return NULL; return PyInt_FromSsize_t(result); }
static PyObject * ip_store_size(PyObject *self){ #ifdef IS_PY3K return PyLong_FromSsize_t(ipdb_size); #else return PyInt_FromSsize_t(ipdb_size); #endif }
static PyObject * getargs_n(PyObject *self, PyObject *args) { Py_ssize_t value; if (!PyArg_ParseTuple(args, "n", &value)) return NULL; return PyInt_FromSsize_t(value); }
static PyObject * tupleiter_len(tupleiterobject *it) { Py_ssize_t len = 0; if (it->it_seq) len = PyTuple_GET_SIZE(it->it_seq) - it->it_index; return PyInt_FromSsize_t(len); }
PyObject * _PySlice_FromIndices(Py_ssize_t istart, Py_ssize_t istop) { PyObject *start, *end, *slice; start = PyInt_FromSsize_t(istart); if (!start) return NULL; end = PyInt_FromSsize_t(istop); if (!end) { Py_DECREF(start); return NULL; } slice = PySlice_New(start, end, NULL); Py_DECREF(start); Py_DECREF(end); return slice; }
static PyObject * range_item(rangeobject *r, Py_ssize_t i) { if (i < 0 || i >= r->len) { PyErr_SetString(PyExc_IndexError, "xrange object index out of range"); return NULL; } return PyInt_FromSsize_t(r->start + (i % r->len) * r->step); }
static PyObject *Nuitka_Frame_sizeof( PyFrameObject *frame ) { Py_ssize_t slots = frame->f_code->co_stacksize + frame->f_code->co_nlocals + PyTuple_GET_SIZE( frame->f_code->co_cellvars ) + PyTuple_GET_SIZE( frame->f_code->co_freevars ); return PyInt_FromSsize_t( sizeof( Nuitka_FrameObject ) + slots * sizeof(PyObject *) ); }
/* * Implement getsize() for the type. */ static PyObject *sipVoidPtr_getsize(sipVoidPtrObject *v, PyObject *arg) { #if PY_MAJOR_VERSION >= 3 return PyLong_FromSsize_t(v->size); #elif PY_VERSION_HEX >= 0x02050000 return PyInt_FromSsize_t(v->size); #else return PyInt_FromLong(v->size); #endif }
static PyObject * BaseRowProxy_getitem(PyObject *self, Py_ssize_t i) { PyObject *index; #if PY_MAJOR_VERSION >= 3 index = PyLong_FromSsize_t(i); #else index = PyInt_FromSsize_t(i); #endif return BaseRowProxy_subscript((BaseRowProxy*)self, index); }
PyMODINIT_FUNC init_testcapi(void) { PyObject *m; m = Py_InitModule("_testcapi", TestMethods); if (m == NULL) return; Py_TYPE(&test_structmembersType)=&PyType_Type; Py_INCREF(&test_structmembersType); PyModule_AddObject(m, "test_structmembersType", (PyObject *)&test_structmembersType); PyModule_AddObject(m, "CHAR_MAX", PyInt_FromLong(CHAR_MAX)); PyModule_AddObject(m, "CHAR_MIN", PyInt_FromLong(CHAR_MIN)); PyModule_AddObject(m, "UCHAR_MAX", PyInt_FromLong(UCHAR_MAX)); PyModule_AddObject(m, "SHRT_MAX", PyInt_FromLong(SHRT_MAX)); PyModule_AddObject(m, "SHRT_MIN", PyInt_FromLong(SHRT_MIN)); PyModule_AddObject(m, "USHRT_MAX", PyInt_FromLong(USHRT_MAX)); PyModule_AddObject(m, "INT_MAX", PyLong_FromLong(INT_MAX)); PyModule_AddObject(m, "INT_MIN", PyLong_FromLong(INT_MIN)); PyModule_AddObject(m, "UINT_MAX", PyLong_FromUnsignedLong(UINT_MAX)); PyModule_AddObject(m, "LONG_MAX", PyInt_FromLong(LONG_MAX)); PyModule_AddObject(m, "LONG_MIN", PyInt_FromLong(LONG_MIN)); PyModule_AddObject(m, "ULONG_MAX", PyLong_FromUnsignedLong(ULONG_MAX)); PyModule_AddObject(m, "FLT_MAX", PyFloat_FromDouble(FLT_MAX)); PyModule_AddObject(m, "FLT_MIN", PyFloat_FromDouble(FLT_MIN)); PyModule_AddObject(m, "DBL_MAX", PyFloat_FromDouble(DBL_MAX)); PyModule_AddObject(m, "DBL_MIN", PyFloat_FromDouble(DBL_MIN)); PyModule_AddObject(m, "LLONG_MAX", PyLong_FromLongLong(PY_LLONG_MAX)); PyModule_AddObject(m, "LLONG_MIN", PyLong_FromLongLong(PY_LLONG_MIN)); PyModule_AddObject(m, "ULLONG_MAX", PyLong_FromUnsignedLongLong(PY_ULLONG_MAX)); PyModule_AddObject(m, "PY_SSIZE_T_MAX", PyInt_FromSsize_t(PY_SSIZE_T_MAX)); PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyInt_FromSsize_t(PY_SSIZE_T_MIN)); PyModule_AddObject(m, "SIZEOF_PYGC_HEAD", PyInt_FromSsize_t(sizeof(PyGC_Head))); TestError = PyErr_NewException("_testcapi.error", NULL, NULL); Py_INCREF(TestError); PyModule_AddObject(m, "error", TestError); }
static PyObject * Billiard_read(PyObject *self, PyObject *args) { int fd; Py_buffer view; Py_ssize_t buflen, recvlen = 0; char *buf = NULL; Py_ssize_t n = 0; if (!PyArg_ParseTuple(args, "iw*|n", &fd, &view, &recvlen)) return NULL; buflen = view.len; buf = view.buf; if (recvlen < 0) { PyBuffer_Release(&view); PyErr_SetString(PyExc_ValueError, "negative len for read"); return NULL; } if (recvlen == 0) { recvlen = buflen; } if (buflen < recvlen) { PyBuffer_Release(&view); PyErr_SetString(PyExc_ValueError, "Buffer too small for requested bytes"); return NULL; } if (buflen < 0 || buflen == 0) { errno = EINVAL; goto bail; } // Requires Python 2.7 //if (!_PyVerify_fd(fd)) goto bail; Py_BEGIN_ALLOW_THREADS n = read(fd, buf, recvlen); Py_END_ALLOW_THREADS if (n < 0) goto bail; PyBuffer_Release(&view); return PyInt_FromSsize_t(n); bail: PyBuffer_Release(&view); return PyErr_SetFromErrno(PyExc_OSError); }
static PyObject* SobolSampler_size(PyObject* self) { SobolSampler* s = (SobolSampler *)self; if (s->_is_inf) { Py_INCREF(Py_None); return Py_None; } else return PyInt_FromSsize_t(s->_size); }
PyObject * string_rindex(PyStringObject *self, PyObject *args) { Py_ssize_t result = string_find_internal(self, args, -1); if (result == -2) return NULL; if (result == -1) { PyErr_SetString(PyExc_ValueError, "substring not found"); return NULL; } return PyInt_FromSsize_t(result); }
static PyObject * reversed_len(reversedobject *ro) { Py_ssize_t position, seqsize; if (ro->seq == NULL) return PyInt_FromLong(0); seqsize = PySequence_Size(ro->seq); if (seqsize == -1) return NULL; position = ro->index + 1; return PyInt_FromSsize_t((seqsize < position) ? 0 : position); }
static PyObject * mmap_size_method(mmap_object *self, PyObject *unused) { CHECK_VALID(NULL); #ifdef MS_WINDOWS if (self->file_handle != INVALID_HANDLE_VALUE) { DWORD low,high; PY_LONG_LONG size; low = GetFileSize(self->file_handle, &high); if (low == INVALID_FILE_SIZE) { /* It might be that the function appears to have failed, when indeed its size equals INVALID_FILE_SIZE */ DWORD error = GetLastError(); if (error != NO_ERROR) return PyErr_SetFromWindowsErr(error); } if (!high && low < LONG_MAX) return PyInt_FromLong((long)low); size = (((PY_LONG_LONG)high)<<32) + low; return PyLong_FromLongLong(size); } else { return PyInt_FromSsize_t(self->size); } #endif /* MS_WINDOWS */ #ifdef UNIX { struct stat buf; if (-1 == fstat(self->fd, &buf)) { PyErr_SetFromErrno(mmap_module_error); return NULL; } return PyInt_FromSsize_t(buf.st_size); } #endif /* UNIX */ }
static PyObject * frame_sizeof(PyFrameObject *f) { Py_ssize_t res, extras, ncells, nfrees; ncells = PyTuple_GET_SIZE(f->f_code->co_cellvars); nfrees = PyTuple_GET_SIZE(f->f_code->co_freevars); extras = f->f_code->co_stacksize + f->f_code->co_nlocals + ncells + nfrees; /* subtract one as it is already included in PyFrameObject */ res = sizeof(PyFrameObject) + (extras-1) * sizeof(PyObject *); return PyInt_FromSsize_t(res); }
/* Make an argument list out of a read size */ static PyObject * size2py(Py_ssize_t size) { PyObject *sizeobj, *result; if (!(sizeobj = PyInt_FromSsize_t(size))) return NULL; if (!(result = PyTuple_New(1))) { Py_DECREF(sizeobj); return NULL; } PyTuple_SET_ITEM(result, 0, sizeobj); return result; }
static PyObject * iter_len(seqiterobject *it) { Py_ssize_t seqsize, len; if (it->it_seq) { seqsize = PySequence_Size(it->it_seq); if (seqsize == -1) return NULL; len = seqsize - it->it_index; if (len >= 0) return PyInt_FromSsize_t(len); } return PyInt_FromLong(0); }
static PyObject * weakref_getweakrefcount(PyObject *self, PyObject *object) { PyObject *result = NULL; if (PyType_SUPPORTS_WEAKREFS(object->ob_type)) { PyWeakReference **list = GET_WEAKREFS_LISTPTR(object); result = PyInt_FromSsize_t(_PyWeakref_GetWeakrefCount(*list)); } else result = PyInt_FromLong(0); return result; }