static PyObject * sv_LoadMap(svobject *self, PyObject *args) { PyObject *rgb; PyObject *res = NULL; rgb_tuple *mapp = NULL; int maptype; int i, j; /* indices */ if (!PyArg_Parse(args, "(iO)", &maptype, &rgb)) return NULL; if (!PyList_Check(rgb) || PyList_Size(rgb) != 256) { PyErr_BadArgument(); return NULL; } if (!(mapp = PyMem_NEW(rgb_tuple, 256))) return PyErr_NoMemory(); for (i = 0; i < 256; i++) { PyObject* v = PyList_GetItem(rgb, i); if (!v) goto finally; if (!PyTuple_Check(v) || PyTuple_Size(v) != 3) { PyErr_BadArgument(); goto finally; } for (j = 0; j < 3; j++) { PyObject* cell = PyTuple_GetItem(v, j); if (!cell) goto finally; if (!PyInt_Check(cell)) { PyErr_BadArgument(); goto finally; } switch (j) { case 0: mapp[i].red = PyInt_AsLong(cell); break; case 1: mapp[i].blue = PyInt_AsLong(cell); break; case 2: mapp[i].green = PyInt_AsLong(cell); break; } if (PyErr_Occurred()) goto finally; } } if (svLoadMap(self->ob_svideo, maptype, mapp)) { res = sv_error(); goto finally; } Py_INCREF(Py_None); res = Py_None; finally: PyMem_DEL(mapp); return res; }
PyObject * MpRequest_FromRequest(request_rec *req) { requestobject *result; result = PyMem_NEW(requestobject, 1); if (! result) return PyErr_NoMemory(); result->request_rec = req; result->ob_type = &MpRequest_Type; result->connection = NULL; result->server = NULL; result->next = NULL; result->prev = NULL; result->main = NULL; result->headers_in = MpTable_FromTable(req->headers_in); result->headers_out = MpTable_FromTable(req->headers_out); result->err_headers_out = MpTable_FromTable(req->err_headers_out); result->subprocess_env = MpTable_FromTable(req->subprocess_env); result->notes = MpTable_FromTable(req->notes); result->Request = NULL; result->header_sent = 0; result->content_type_set = 0; result->hstack = NULL; result->rbuff = NULL; result->rbuff_pos = 0; result->rbuff_len = 0; _Py_NewReference(result); ap_register_cleanup(req->pool, (PyObject *)result, python_decref, ap_null_cleanup); return (PyObject *) result; }
void PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc) { PyObject *dict; PyMemberDef* members; int n_members, n_unnamed_members, i, k; #ifdef Py_TRACE_REFS /* if the type object was chained, unchain it first before overwriting its storage */ if (type->_ob_next) { _Py_ForgetReference((PyObject*)type); } #endif n_unnamed_members = 0; for (i = 0; desc->fields[i].name != NULL; ++i) if (desc->fields[i].name == PyStructSequence_UnnamedField) n_unnamed_members++; n_members = i; memcpy(type, &_struct_sequence_template, sizeof(PyTypeObject)); type->tp_name = desc->name; type->tp_doc = desc->doc; type->tp_basicsize = sizeof(PyStructSequence)+ sizeof(PyObject*)*(n_members-1); type->tp_itemsize = 0; members = PyMem_NEW(PyMemberDef, n_members-n_unnamed_members+1); if (members == NULL) return; for (i = k = 0; i < n_members; ++i) { if (desc->fields[i].name == PyStructSequence_UnnamedField) continue; members[k].name = desc->fields[i].name; members[k].type = T_OBJECT; members[k].offset = offsetof(PyStructSequence, ob_item) + i * sizeof(PyObject*); members[k].flags = READONLY; members[k].doc = desc->fields[i].doc; k++; } members[k].name = NULL; type->tp_members = members; if (PyType_Ready(type) < 0) return; Py_INCREF(type); dict = type->tp_dict; PyDict_SetItemString(dict, visible_length_key, PyInt_FromLong((long) desc->n_in_sequence)); PyDict_SetItemString(dict, real_length_key, PyInt_FromLong((long) n_members)); PyDict_SetItemString(dict, unnamed_fields_key, PyInt_FromLong((long) n_unnamed_members)); }
SWIG_newvarlink(void) { swig_varlinkobject *result = 0; result = PyMem_NEW(swig_varlinkobject,1); varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */ result->ob_type = &varlinktype; result->vars = 0; result->ob_refcnt = 0; Py_XINCREF((PyObject *) result); return ((PyObject*) result); }
PyObject * MpTable_FromTable(apr_table_t *t) { tableobject *result; result = PyMem_NEW(tableobject, 1); if (! result) return PyErr_NoMemory(); result->table = t; result->ob_type = &MpTable_Type; result->pool = NULL; _Py_NewReference(result); return (PyObject *)result; }
SWIGSTATIC PyObject * SWIG_newvarlink(void) { swig_varlinkobject *result = 0; result = PyMem_NEW(swig_varlinkobject,1); varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */ result->ob_type = &varlinktype; /* _Py_NewReference(result); Does not seem to be necessary */ result->nvars = 0; result->maxvars = 64; result->vars = (swig_globalvar **) malloc(64*sizeof(swig_globalvar *)); result->vars[0] = 0; Py_XINCREF((PyObject *) result); return ((PyObject*) result); }
PyObject * MpServer_FromServer(server_rec *s) { serverobject *result; result = PyMem_NEW(serverobject, 1); if (! result) return PyErr_NoMemory(); result->server = s; result->ob_type = &MpServer_Type; result->next = NULL; _Py_NewReference(result); return (PyObject *)result; }
grammar * newgrammar(int start) { grammar *g; g = PyMem_NEW(grammar, 1); if (g == NULL) Py_FatalError("no mem for new grammar"); g->g_ndfas = 0; g->g_dfa = NULL; g->g_start = start; g->g_ll.ll_nlabels = 0; g->g_ll.ll_label = NULL; g->g_accel = 0; return g; }
parser_state * PyParser_New(grammar *g, int start) { parser_state *ps; if (!g->g_accel) PyGrammar_AddAccelerators(g); ps = PyMem_NEW(parser_state, 1); if (ps == NULL) return NULL; ps->p_grammar = g; ps->p_generators = 0; ps->p_tree = PyNode_New(start); if (ps->p_tree == NULL) { PyMem_DEL(ps); return NULL; } s_reset(&ps->p_stack); (void) s_push(&ps->p_stack, PyGrammar_FindDFA(g, start), ps->p_tree); return ps; }
static PyObject * select_select(PyObject *self, PyObject *args) { #ifdef SELECT_USES_HEAP pylist *rfd2obj, *wfd2obj, *efd2obj; #else /* !SELECT_USES_HEAP */ /* XXX: All this should probably be implemented as follows: * - find the highest descriptor we're interested in * - add one * - that's the size * See: Stevens, APitUE, $12.5.1 */ pylist rfd2obj[FD_SETSIZE + 1]; pylist wfd2obj[FD_SETSIZE + 1]; pylist efd2obj[FD_SETSIZE + 1]; #endif /* SELECT_USES_HEAP */ PyObject *ifdlist, *ofdlist, *efdlist; PyObject *ret = NULL; PyObject *tout = Py_None; fd_set ifdset, ofdset, efdset; double timeout; struct timeval tv, *tvp; long seconds; int imax, omax, emax, max; int n; /* convert arguments */ if (!PyArg_ParseTuple(args, "OOO|O:select", &ifdlist, &ofdlist, &efdlist, &tout)) return NULL; if (tout == Py_None) tvp = (struct timeval *)0; else if (!PyNumber_Check(tout)) { PyErr_SetString(PyExc_TypeError, "timeout must be a float or None"); return NULL; } else { timeout = PyFloat_AsDouble(tout); if (timeout == -1 && PyErr_Occurred()) return NULL; if (timeout > (double)LONG_MAX) { PyErr_SetString(PyExc_OverflowError, "timeout period too long"); return NULL; } seconds = (long)timeout; timeout = timeout - (double)seconds; tv.tv_sec = seconds; tv.tv_usec = (long)(timeout*1000000.0); tvp = &tv; } #ifdef SELECT_USES_HEAP /* Allocate memory for the lists */ rfd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1); wfd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1); efd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1); if (rfd2obj == NULL || wfd2obj == NULL || efd2obj == NULL) { if (rfd2obj) PyMem_DEL(rfd2obj); if (wfd2obj) PyMem_DEL(wfd2obj); if (efd2obj) PyMem_DEL(efd2obj); return PyErr_NoMemory(); } #endif /* SELECT_USES_HEAP */ /* Convert sequences to fd_sets, and get maximum fd number * propagates the Python exception set in seq2set() */ rfd2obj[0].sentinel = -1; wfd2obj[0].sentinel = -1; efd2obj[0].sentinel = -1; if ((imax=seq2set(ifdlist, &ifdset, rfd2obj)) < 0) goto finally; if ((omax=seq2set(ofdlist, &ofdset, wfd2obj)) < 0) goto finally; if ((emax=seq2set(efdlist, &efdset, efd2obj)) < 0) goto finally; max = imax; if (omax > max) max = omax; if (emax > max) max = emax; Py_BEGIN_ALLOW_THREADS n = select(max, &ifdset, &ofdset, &efdset, tvp); Py_END_ALLOW_THREADS #ifdef MS_WINDOWS if (n == SOCKET_ERROR) { PyErr_SetExcFromWindowsErr(SelectError, WSAGetLastError()); } #else if (n < 0) { PyErr_SetFromErrno(SelectError); } #endif else if (n == 0) { /* optimization */ ifdlist = PyList_New(0); if (ifdlist) { ret = PyTuple_Pack(3, ifdlist, ifdlist, ifdlist); Py_DECREF(ifdlist); } } else { /* any of these three calls can raise an exception. it's more convenient to test for this after all three calls... but is that acceptable? */ ifdlist = set2list(&ifdset, rfd2obj); ofdlist = set2list(&ofdset, wfd2obj); efdlist = set2list(&efdset, efd2obj); if (PyErr_Occurred()) ret = NULL; else ret = PyTuple_Pack(3, ifdlist, ofdlist, efdlist); Py_DECREF(ifdlist); Py_DECREF(ofdlist); Py_DECREF(efdlist); } finally: reap_obj(rfd2obj); reap_obj(wfd2obj); reap_obj(efd2obj); #ifdef SELECT_USES_HEAP PyMem_DEL(rfd2obj); PyMem_DEL(wfd2obj); PyMem_DEL(efd2obj); #endif /* SELECT_USES_HEAP */ return ret; }
PyCodeObject * PyCode_New(int argcount, int kwonlyargcount, int nlocals, int stacksize, int flags, PyObject *code, PyObject *consts, PyObject *names, PyObject *varnames, PyObject *freevars, PyObject *cellvars, PyObject *filename, PyObject *name, int firstlineno, PyObject *lnotab) { PyCodeObject *co; Py_ssize_t *cell2arg = NULL; Py_ssize_t i, n_cellvars, n_varnames, total_args; /* Check argument types */ if (argcount < 0 || kwonlyargcount < 0 || nlocals < 0 || code == NULL || !PyBytes_Check(code) || consts == NULL || !PyTuple_Check(consts) || names == NULL || !PyTuple_Check(names) || varnames == NULL || !PyTuple_Check(varnames) || freevars == NULL || !PyTuple_Check(freevars) || cellvars == NULL || !PyTuple_Check(cellvars) || name == NULL || !PyUnicode_Check(name) || filename == NULL || !PyUnicode_Check(filename) || lnotab == NULL || !PyBytes_Check(lnotab)) { PyErr_BadInternalCall(); return NULL; } /* Ensure that the filename is a ready Unicode string */ if (PyUnicode_READY(filename) < 0) return NULL; intern_strings(names); intern_strings(varnames); intern_strings(freevars); intern_strings(cellvars); intern_string_constants(consts); /* Check for any inner or outer closure references */ n_cellvars = PyTuple_GET_SIZE(cellvars); if (!n_cellvars && !PyTuple_GET_SIZE(freevars)) { flags |= CO_NOFREE; } else { flags &= ~CO_NOFREE; } n_varnames = PyTuple_GET_SIZE(varnames); if (argcount <= n_varnames && kwonlyargcount <= n_varnames) { /* Never overflows. */ total_args = (Py_ssize_t)argcount + (Py_ssize_t)kwonlyargcount + ((flags & CO_VARARGS) != 0) + ((flags & CO_VARKEYWORDS) != 0); } else { total_args = n_varnames + 1; } if (total_args > n_varnames) { PyErr_SetString(PyExc_ValueError, "code: varnames is too small"); return NULL; } /* Create mapping between cells and arguments if needed. */ if (n_cellvars) { bool used_cell2arg = false; cell2arg = PyMem_NEW(Py_ssize_t, n_cellvars); if (cell2arg == NULL) { PyErr_NoMemory(); return NULL; } /* Find cells which are also arguments. */ for (i = 0; i < n_cellvars; i++) { Py_ssize_t j; PyObject *cell = PyTuple_GET_ITEM(cellvars, i); cell2arg[i] = CO_CELL_NOT_AN_ARG; for (j = 0; j < total_args; j++) { PyObject *arg = PyTuple_GET_ITEM(varnames, j); int cmp = PyUnicode_Compare(cell, arg); if (cmp == -1 && PyErr_Occurred()) { PyMem_FREE(cell2arg); return NULL; } if (cmp == 0) { cell2arg[i] = j; used_cell2arg = true; break; } } } if (!used_cell2arg) { PyMem_FREE(cell2arg); cell2arg = NULL; } } co = PyObject_NEW(PyCodeObject, &PyCode_Type); if (co == NULL) { if (cell2arg) PyMem_FREE(cell2arg); return NULL; } co->co_argcount = argcount; co->co_kwonlyargcount = kwonlyargcount; co->co_nlocals = nlocals; co->co_stacksize = stacksize; co->co_flags = flags; Py_INCREF(code); co->co_code = code; Py_INCREF(consts); co->co_consts = consts; Py_INCREF(names); co->co_names = names; Py_INCREF(varnames); co->co_varnames = varnames; Py_INCREF(freevars); co->co_freevars = freevars; Py_INCREF(cellvars); co->co_cellvars = cellvars; co->co_cell2arg = cell2arg; Py_INCREF(filename); co->co_filename = filename; Py_INCREF(name); co->co_name = name; co->co_firstlineno = firstlineno; Py_INCREF(lnotab); co->co_lnotab = lnotab; co->co_zombieframe = NULL; co->co_weakreflist = NULL; co->co_extra = NULL; return co; }
void PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc) { PyObject *dict; PyMemberDef* members; int n_members, n_unnamed_members, i, k; #ifdef Py_TRACE_REFS /* if the type object was chained, unchain it first before overwriting its storage */ if (type->ob_base.ob_base._ob_next) { _Py_ForgetReference((PyObject*)type); } #endif n_unnamed_members = 0; for (i = 0; desc->fields[i].name != NULL; ++i) if (desc->fields[i].name == PyStructSequence_UnnamedField) n_unnamed_members++; n_members = i; memcpy(type, &_struct_sequence_template, sizeof(PyTypeObject)); type->tp_base = &PyTuple_Type; type->tp_name = desc->name; type->tp_doc = desc->doc; members = PyMem_NEW(PyMemberDef, n_members-n_unnamed_members+1); if (members == NULL) return; for (i = k = 0; i < n_members; ++i) { if (desc->fields[i].name == PyStructSequence_UnnamedField) continue; members[k].name = desc->fields[i].name; members[k].type = T_OBJECT; members[k].offset = offsetof(PyStructSequence, ob_item) + i * sizeof(PyObject*); members[k].flags = READONLY; members[k].doc = desc->fields[i].doc; k++; } members[k].name = NULL; type->tp_members = members; if (PyType_Ready(type) < 0) return; Py_INCREF(type); dict = type->tp_dict; #define SET_DICT_FROM_INT(key, value) \ do { \ PyObject *v = PyLong_FromLong((long) value); \ if (v != NULL) { \ PyDict_SetItemString(dict, key, v); \ Py_DECREF(v); \ } \ } while (0) SET_DICT_FROM_INT(visible_length_key, desc->n_in_sequence); SET_DICT_FROM_INT(real_length_key, n_members); SET_DICT_FROM_INT(unnamed_fields_key, n_unnamed_members); }