/* Compare v to w. Return -1 if v < w or exception (PyErr_Occurred() true in latter case). 0 if v == w. 1 if v > w. XXX The docs (C API manual) say the return value is undefined in case XXX of error. */ int PyObject_Compare(PyObject *v, PyObject *w) { int result; if (v == NULL || w == NULL) { PyErr_BadInternalCall(); return -1; } if (v == w) return 0; if (Py_EnterRecursiveCall(" in cmp")) return -1; result = do_cmp(v, w); Py_LeaveRecursiveCall(); return result < 0 ? -1 : result; }
static PyObject * path_iter(PyObject *pypath) { PycairoPathiter *it; if (!PyObject_TypeCheck (pypath, &PycairoPath_Type)) { PyErr_BadInternalCall(); return NULL; } it = PyObject_New(PycairoPathiter, &PycairoPathiter_Type); if (it == NULL) return NULL; it->index = 0; Py_INCREF(pypath); it->pypath = (PycairoPath *)pypath; return (PyObject *) it; }
static int transit_event(PyObject *self, PyObject *event, int save) { Context *context; PyObject *state; if (!Validator_Check(self)) { PyErr_BadInternalCall(); return -1; } #ifdef DEBUG_VALIDATION fprintf(stderr, "Validator_ValidateEvent(event="); PyObject_Print(event, stderr, 0); fprintf(stderr, ")\n"); #endif context = Validator_Context(self); /* context may be NULL if we never encounter a declared element */ if (context != NULL) { /* check that this element is allowed here */ /* context->state will be NULL for an ANY content model */ if (context->state != NULL) { state = PyDict_GetItem(context->state, event); if (state == NULL) { /* element not allowed here */ #ifdef DEBUG_VALIDATION fprintf(stderr, " Event not allowed on "); if (context->element) { PyObject_Print(ElementType_GET_NAME(context->element), stderr, 0); } else { fprintf(stderr, " undeclared"); } fprintf(stderr, " element.\n"); #endif return 0; } if (save) { /* save the state for next time */ context->state = state; } } } return 1; }
static PyObject * tuple_iter(PyObject *seq) { tupleiterobject *it; if (!PyTuple_Check(seq)) { PyErr_BadInternalCall(); return NULL; } it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type); if (it == NULL) return NULL; it->it_index = 0; Py_INCREF(seq); it->it_seq = (PyTupleObject *)seq; _PyObject_GC_TRACK(it); return (PyObject *)it; }
static PyObject * range_iter(PyObject *seq) { rangeiterobject *it; if (!PyRange_Check(seq)) { PyErr_BadInternalCall(); return NULL; } it = PyObject_New(rangeiterobject, &Pyrangeiter_Type); if (it == NULL) return NULL; it->index = 0; it->start = ((rangeobject *)seq)->start; it->step = ((rangeobject *)seq)->step; it->len = ((rangeobject *)seq)->len; return (PyObject *)it; }
PyObject * PySeqIter_New(PyObject *seq) { seqiterobject *it; if (!PySequence_Check(seq)) { PyErr_BadInternalCall(); return NULL; } it = PyObject_GC_New(seqiterobject, &PySeqIter_Type); if (it == NULL) return NULL; it->it_index = 0; Py_INCREF(seq); it->it_seq = seq; _PyObject_GC_TRACK(it); return (PyObject *)it; }
static PyObject * record_iter(PyObject *seq) { ApgRecordIterObject *it; if (!ApgRecord_CheckExact(seq)) { PyErr_BadInternalCall(); return NULL; } it = PyObject_GC_New(ApgRecordIterObject, &ApgRecordIter_Type); if (it == NULL) return NULL; it->it_index = 0; Py_INCREF(seq); it->it_seq = (ApgRecordObject *)seq; _PyObject_GC_TRACK(it); return (PyObject *)it; }
extern "C" unsigned PY_LONG_LONG PyLong_AsUnsignedLongLong(PyObject* vv) noexcept { unsigned PY_LONG_LONG bytes; int one = 1; int res; if (vv == NULL || !PyLong_Check(vv)) { PyErr_BadInternalCall(); return (unsigned PY_LONG_LONG) - 1; } res = _PyLong_AsByteArray((PyLongObject*)vv, (unsigned char*)&bytes, SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0); /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */ if (res < 0) return (unsigned PY_LONG_LONG)res; else return bytes; }
int XsltRoot_AppendChild(XsltRootObject *self, XsltNodeObject *child) { PyObject *temp; if (!XsltRoot_Check(self) || !XsltNode_Check(child)) { PyErr_BadInternalCall(); return -1; } /* Make the node our only child */ temp = self->stylesheet; Py_INCREF(child); self->stylesheet = (PyObject *) child; Py_DECREF(temp); /* Set its parent link */ return XsltNode_Link(XsltNode(self), child); }
extern "C" PY_LONG_LONG PyLong_AsLongLong(PyObject* vv) noexcept { PY_LONG_LONG bytes; int one = 1; int res; if (vv == NULL) { PyErr_BadInternalCall(); return -1; } if (!PyLong_Check(vv)) { PyNumberMethods* nb; PyObject* io; if (PyInt_Check(vv)) return (PY_LONG_LONG)PyInt_AsLong(vv); if ((nb = vv->cls->tp_as_number) == NULL || nb->nb_int == NULL) { PyErr_SetString(PyExc_TypeError, "an integer is required"); return -1; } io = (*nb->nb_int)(vv); if (io == NULL) return -1; if (PyInt_Check(io)) { bytes = PyInt_AsLong(io); Py_DECREF(io); return bytes; } if (PyLong_Check(io)) { bytes = PyLong_AsLongLong(io); Py_DECREF(io); return bytes; } Py_DECREF(io); PyErr_SetString(PyExc_TypeError, "integer conversion failed"); return -1; } res = _PyLong_AsByteArray((PyLongObject*)vv, (unsigned char*)&bytes, SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1); /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */ if (res < 0) return (PY_LONG_LONG)-1; else return bytes; }
int PyFunction_SetDefaults(PyObject *op, PyObject *defaults) { if (!PyFunction_Check(op)) { PyErr_BadInternalCall(); return -1; } if (defaults == Py_None) defaults = NULL; else if (defaults && PyTuple_Check(defaults)) { Py_INCREF(defaults); } else { PyErr_SetString(PyExc_SystemError, "non-tuple default args"); return -1; } Py_XSETREF(((PyFunctionObject *)op)->func_defaults, defaults); return 0; }
int _PyCode_GetExtra(PyObject *code, Py_ssize_t index, void **extra) { if (!PyCode_Check(code)) { PyErr_BadInternalCall(); return -1; } PyCodeObject *o = (PyCodeObject*) code; _PyCodeObjectExtra *co_extra = (_PyCodeObjectExtra*) o->co_extra; if (co_extra == NULL || co_extra->ce_size <= index) { *extra = NULL; return 0; } *extra = co_extra->ce_extras[index]; return 0; }
static PyObject* PyPointlessSet_iter(PyObject* set) { if (!PyPointlessSet_Check(set)) { PyErr_BadInternalCall(); return 0; } PyPointlessSetIter* iter = PyObject_New(PyPointlessSetIter, &PyPointlessSetIterType); if (iter == 0) return 0; Py_INCREF(set); iter->set = (PyPointlessSet*)set; iter->iter_state = 0; return (PyObject*)iter; }
static PyObject* PyPointlessVector_iter(PyObject* vector) { if (!PyPointlessVector_Check(vector)) { PyErr_BadInternalCall(); return 0; } PyPointlessVectorIter* iter = PyObject_New(PyPointlessVectorIter, &PyPointlessVectorIterType); if (iter == 0) return 0; Py_INCREF(vector); iter->vector = (PyPointlessVector*)vector; iter->iter_state = 0; return (PyObject*)iter; }
extern "C" long PyLong_AsLongAndOverflow(Box* vv, int* overflow) noexcept { // Ported from CPython; original comment: /* This version by Tim Peters */ *overflow = 0; if (vv == NULL) { PyErr_BadInternalCall(); return -1; } if (PyInt_Check(vv)) return PyInt_AsLong(vv); if (!PyLong_Check(vv)) { PyNumberMethods* nb; nb = vv->cls->tp_as_number; if (nb == NULL || nb->nb_int == NULL) { PyErr_SetString(PyExc_TypeError, "an integer is required"); return -1; } vv = (*nb->nb_int)(vv); if (vv == NULL) return -1; if (PyInt_Check(vv)) return PyInt_AsLong(vv); if (!PyLong_Check(vv)) { PyErr_SetString(PyExc_TypeError, "nb_int should return int object"); return -1; } // fallthrough: this has to be a long } BoxedLong* l = static_cast<BoxedLong*>(vv); if (mpz_fits_slong_p(l->n)) { return mpz_get_si(l->n); } else { *overflow = mpz_sgn(l->n); return -1; } }
int PyTuple_SetItem(PyObject *op, Py_ssize_t i, PyObject *newitem) { PyObject **p; if (!PyTuple_Check(op) || op->ob_refcnt != 1) { Py_XDECREF(newitem); PyErr_BadInternalCall(); return -1; } if (i < 0 || i >= Py_SIZE(op)) { Py_XDECREF(newitem); PyErr_SetString(PyExc_IndexError, "tuple assignment index out of range"); return -1; } p = ((PyTupleObject *)op) -> ob_item + i; Py_XSETREF(*p, newitem); return 0; }
int Validator_AddElementType(PyObject *self, PyObject *element) { if (!Validator_Check(self) && !ElementType_Check(element)) { PyErr_BadInternalCall(); return -1; } /* already defined, keep first decl */ if (PyDict_GetItem(Validator_Elements(self), ElementType_GET_NAME(element))) return 0; /* add the ElementType to our set of legal elements */ if (PyDict_SetItem(Validator_Elements(self), ElementType_GET_NAME(element), element) < 0) { return -1; } return 1; }
/* Create a platform-independent initialisation thread. On success it returns 0 and sets the thread parameter, on failure returns -1. */ int create_init_thread(void *param, ldap_conndata_t *info, XTHREAD *thread) { int rc = 0; ldapInitThreadData *data = (ldapInitThreadData *)param; DEBUG("create_init_thread (ld:%p, info:%p, thread:%lu)", param, info, *thread); #ifdef WIN32 *thread = CreateThread(NULL, 0, ldap_init_thread_func, (void *)data, 0, NULL); if (*thread == NULL) rc = -1; #else data->mux = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); if (data->mux == NULL) { PyErr_NoMemory(); return -1; } rc = pthread_mutex_init(data->mux, NULL); if (rc != 0) { PyErr_BadInternalCall(); return -1; } pthread_mutex_lock(data->mux); data->flag = 0; #ifdef HAVE_KRB5 data->info = info; if (data->info->mech != NULL && (strcmp("GSSAPI", data->info->mech) == 0 || strcmp("GSS-SPNEGO", data->info->mech) == 0) && data->info->realm != NULL && strlen(data->info->realm) != 0 && data->info->authcid != NULL && strlen(data->info->authcid) != 0) { data->info->request_tgt = 1; rc = krb5_init_context(&(data->info->ctx)); if (rc != 0) return -1; } #endif pthread_mutex_unlock(data->mux); rc = pthread_create(thread, NULL, ldap_init_thread_func, data); #endif if (rc != 0) return -1; return 0; }
int Validator_EndElement(PyObject *self) { Context *context; int valid; if (!Validator_Check(self)) { PyErr_BadInternalCall(); return -1; } #ifdef DEBUG_VALIDATION fprintf(stderr, "Validator_EndElement()"); #endif context = Validator_Context(self); /* context may be NULL if we never encounter a declared element */ if (context != NULL) { #ifdef DEBUG_VALIDATION fprintf(stderr, " for "); if (context->element) { PyObject_Print(ElementType_GET_NAME(context->element), stderr, 0); } else { fprintf(stderr, "undeclared"); } fprintf(stderr, " element\n"); #endif /* make sure that we are in the final state */ valid = Validator_ValidateEvent(self, final_event); /* switch the active context to the following one */ Validator_Context(self) = context->next; /* move this one to the free list */ context->next = Validator_FreeContext(self); Validator_FreeContext(self) = context; } else { valid = 1; } return valid; }
/* Poll the answer of the separate thread that runs the binding process. Returns NULL in case of error, Py_None for timeout, and the LDAPConnection object if successfully finished the binding. */ static PyObject * binding(LDAPConnectIter *self) { int rc; if (self->bind_inprogress == 0) { /* First call of bind. */ rc = LDAP_bind(self->conn->ld, self->info, NULL, &(self->message_id)); if (rc != LDAP_SUCCESS) { set_exception(self->conn->ld, rc); return NULL; } self->bind_inprogress = 1; Py_RETURN_NONE; } else { if (self->async) { rc = WaitForSingleObject(self->info->thread, 10); } else { rc = WaitForSingleObject(self->info->thread, INFINITE); } switch (rc) { case WAIT_TIMEOUT: Py_RETURN_NONE; case WAIT_OBJECT_0: GetExitCodeThread(self->info->thread, &rc); CloseHandle(self->info->thread); if (rc != LDAP_SUCCESS) { /* The ldap_connect is failed. Set a Python error. */ set_exception(self->conn->ld, rc); return NULL; } /* The binding is successfully finished. */ self->bind_inprogress = 0; self->conn->closed = 0; Py_INCREF((PyObject *)self->conn); return (PyObject *)self->conn; default: /* The thread is failed. */ PyErr_BadInternalCall(); return NULL; } } }
int PyFunction_SetKwDefaults(PyObject *op, PyObject *defaults) { if (!PyFunction_Check(op)) { PyErr_BadInternalCall(); return -1; } if (defaults == Py_None) defaults = NULL; else if (defaults && PyDict_Check(defaults)) { Py_INCREF(defaults); } else { PyErr_SetString(PyExc_SystemError, "non-dict keyword only default args"); return -1; } Py_SETREF(((PyFunctionObject *)op)->func_kwdefaults, defaults); return 0; }
extern "C" int PyList_SetSlice(PyObject* a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject* v) noexcept { if (!PyList_Check(a)) { PyErr_BadInternalCall(); return -1; } BoxedList* l = (BoxedList*)a; ASSERT(l->cls == list_cls, "%s", l->cls->tp_name); try { if (v) listSetitemSlice(l, new BoxedSlice(boxInt(ilow), boxInt(ihigh), None), v); else listDelitemSlice(l, new BoxedSlice(boxInt(ilow), boxInt(ihigh), None)); return 0; } catch (ExcInfo e) { setCAPIException(e); return -1; } }
int PyFunction_SetAnnotations(PyObject *op, PyObject *annotations) { if (!PyFunction_Check(op)) { PyErr_BadInternalCall(); return -1; } if (annotations == Py_None) annotations = NULL; else if (annotations && PyDict_Check(annotations)) { Py_INCREF(annotations); } else { PyErr_SetString(PyExc_SystemError, "non-dict annotations"); return -1; } Py_XSETREF(((PyFunctionObject *)op)->func_annotations, annotations); return 0; }
static PyTracebackObject * newtracebackobject(PyTracebackObject *next, PyFrameObject *frame) { PyTracebackObject *tb; if ((next != NULL && !PyTraceBack_Check(next)) || frame == NULL || !PyFrame_Check(frame)) { PyErr_BadInternalCall(); return NULL; } tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type); if (tb != NULL) { Py_XINCREF(next); tb->tb_next = next; Py_XINCREF(frame); tb->tb_frame = frame; tb->tb_lasti = frame->f_lasti; tb->tb_lineno = PyFrame_GetLineNumber(frame); PyObject_GC_Track(tb); } return tb; }
int PyFunction_SetClosure(PyObject *op, PyObject *closure) { if (!PyFunction_Check(op)) { PyErr_BadInternalCall(); return -1; } if (closure == Py_None) closure = NULL; else if (PyTuple_Check(closure)) { Py_INCREF(closure); } else { PyErr_Format(PyExc_SystemError, "expected tuple for closure, got '%.100s'", closure->ob_type->tp_name); return -1; } Py_XSETREF(((PyFunctionObject *)op)->func_closure, closure); return 0; }
int _PyCode_SetExtra(PyObject *code, Py_ssize_t index, void *extra) { PyInterpreterState *interp = PyThreadState_Get()->interp; if (!PyCode_Check(code) || index < 0 || index >= interp->co_extra_user_count) { PyErr_BadInternalCall(); return -1; } PyCodeObject *o = (PyCodeObject*) code; _PyCodeObjectExtra *co_extra = (_PyCodeObjectExtra *) o->co_extra; if (co_extra == NULL || co_extra->ce_size <= index) { Py_ssize_t i = (co_extra == NULL ? 0 : co_extra->ce_size); co_extra = PyMem_Realloc( co_extra, sizeof(_PyCodeObjectExtra) + (interp->co_extra_user_count-1) * sizeof(void*)); if (co_extra == NULL) { return -1; } for (; i < interp->co_extra_user_count; i++) { co_extra->ce_extras[i] = NULL; } co_extra->ce_size = interp->co_extra_user_count; o->co_extra = co_extra; } if (co_extra->ce_extras[index] != NULL) { freefunc free = interp->co_extra_freefuncs[index]; if (free != NULL) { free(co_extra->ce_extras[index]); } } co_extra->ce_extras[index] = extra; return 0; }
int PyTraceBack_Print(PyObject *v, PyObject *f) { int err; PyObject *limitv; long limit = PyTraceBack_LIMIT; if (v == NULL) return 0; if (!PyTraceBack_Check(v)) { PyErr_BadInternalCall(); return -1; } limitv = PySys_GetObject("tracebacklimit"); if (limitv) { PyObject *exc_type, *exc_value, *exc_tb; PyErr_Fetch(&exc_type, &exc_value, &exc_tb); limit = PyLong_AsLong(limitv); if (limit == -1 && PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_OverflowError)) { limit = PyTraceBack_LIMIT; } else { Py_XDECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } } else if (limit <= 0) { limit = PyTraceBack_LIMIT; } PyErr_Restore(exc_type, exc_value, exc_tb); } err = PyFile_WriteString("Traceback (most recent call last):\n", f); if (!err) err = tb_printinternal((PyTracebackObject *)v, f, limit); return err; }
static PyObject * thunk_richcmp(thunk *self, PyObject *other, int op) { PyObject *func; PyObject *arg; PyObject *ret; if (!(arg = PyTuple_Pack(2, self, other))) { return NULL; } switch(op) { case Py_LT: func = LzBinary_lt; break; case Py_LE: func = LzBinary_le; break; case Py_EQ: func = LzBinary_eq; break; case Py_NE: func = LzBinary_ne; break; case Py_GT: func = LzBinary_gt; break; case Py_GE: func = LzBinary_ge; break; default: Py_DECREF(arg); PyErr_BadInternalCall(); return NULL; } ret = _thunk_new_no_check(Py_TYPE(self), func, arg, NULL); Py_DECREF(arg); return ret; }
/* pylong -> mpz conversion */ int mpz_set_pylong(mpz_ptr z, PyObject * ll) { register PyLongObject * l = (PyLongObject *) ll; mp_size_t size; int i; if (l==NULL || !PyLong_Check(l)) { PyErr_BadInternalCall(); return -1; } size = mpn_size_from_pylong(l->ob_digit, abs(l->ob_size)); if (z->_mp_alloc < size) _mpz_realloc (z, size); mpn_set_pylong(z->_mp_d, size, l->ob_digit, abs(l->ob_size)); z->_mp_size = l->ob_size < 0 ? -size : size; return size; }
static PyObject * tb_create_raw(PyTracebackObject *next, PyFrameObject *frame, int lasti, int lineno) { PyTracebackObject *tb; if ((next != NULL && !PyTraceBack_Check(next)) || frame == NULL || !PyFrame_Check(frame)) { PyErr_BadInternalCall(); return NULL; } tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type); if (tb != NULL) { Py_XINCREF(next); tb->tb_next = next; Py_XINCREF(frame); tb->tb_frame = frame; tb->tb_lasti = lasti; tb->tb_lineno = lineno; PyObject_GC_Track(tb); } return (PyObject *)tb; }