/* 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;
}
