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