/* relies on setflags order being write, align, uic */ static int arrayflags_writebackifcopy_set(PyArrayFlagsObject *self, PyObject *obj) { PyObject *res; if (obj == NULL) { PyErr_SetString(PyExc_AttributeError, "Cannot delete flags writebackifcopy attribute"); return -1; } if (self->arr == NULL) { PyErr_SetString(PyExc_ValueError, "Cannot set flags on array scalars."); return -1; } res = PyObject_CallMethod(self->arr, "setflags", "OOO", Py_None, Py_None, (PyObject_IsTrue(obj) ? Py_True : Py_False)); if (res == NULL) { return -1; } Py_DECREF(res); return 0; }
static PyObject * handle_boolean(lcb_t instance, int cmd, int mode, PyObject *val, lcb_error_t *err) { int cval; PyObject *ret; if (val != NULL) { cval = PyObject_IsTrue(val); } if ( (*err = lcb_cntl(instance, mode, cmd, &cval)) != LCB_SUCCESS) { return NULL; } if (cval) { ret = Py_True; } else { ret = Py_False; } Py_INCREF(ret); return ret; }
static PyObject * load(XLPyBook *self, PyObject *args) { const char* fileName; int size; PyObject *raw = NULL; if(!PyArg_ParseTuple(args, "s#|O!", &fileName, &size, &PyBool_Type, &raw)) return NULL; if (raw && PyObject_IsTrue(raw)) { // fileName is treated as the buffer if(!xlBookLoadRaw(self->handler, fileName, size)) { Py_RETURN_FALSE; } } else { if(!xlBookLoad(self->handler, fileName)) { Py_RETURN_FALSE; } } Py_RETURN_TRUE; }
static void py2scm_exception(void) { PyObject *ptype = NULL, *pvalue = NULL, *ptraceback = NULL; PyErr_Fetch(&ptype, &pvalue, &ptraceback); PyObject *pvalue_str = NULL; if (pvalue) { pvalue_str = PyObject_Str(pvalue); if (pvalue_str == NULL) PyErr_Clear(); } scm_throw(scm_from_utf8_symbol("python-exception"), scm_list_2(scm_from_locale_string( ((PyTypeObject *)ptype)->tp_name), pvalue_str != NULL && PyObject_IsTrue(pvalue_str) ? scm_from_locale_string( PyString_AsString(pvalue_str)) : SCM_BOOL_F)); /* does not return */ fprintf(stderr, "*** scm_error shouldn't have returned ***\n"); }
static int recursive_get_files(LIBMTP_mtpdevice_t *dev, uint32_t storage_id, uint32_t parent_id, PyObject *ans, PyObject *errs, PyObject *callback, unsigned int level) { LIBMTP_file_t *f, *files; PyObject *entry, *r; int ok = 1, recurse; Py_BEGIN_ALLOW_THREADS; files = LIBMTP_Get_Files_And_Folders(dev, storage_id, parent_id); Py_END_ALLOW_THREADS; if (files == NULL) return ok; for (f = files; ok && f != NULL; f = f->next) { entry = build_file_metadata(f, storage_id); if (entry == NULL) { ok = 0; } else { r = PyObject_CallFunction(callback, "OI", entry, level); recurse = (r != NULL && PyObject_IsTrue(r)) ? 1 : 0; Py_XDECREF(r); if (PyList_Append(ans, entry) != 0) { ok = 0; } Py_DECREF(entry); } if (ok && recurse && f->filetype == LIBMTP_FILETYPE_FOLDER) { if (!recursive_get_files(dev, storage_id, f->item_id, ans, errs, callback, level+1)) { ok = 0; } } } // Release memory f = files; while (f != NULL) { files = f; f = f->next; LIBMTP_destroy_file_t(files); } return ok; }
static PyObject * session_scp_recv(SSH2_SessionObj *self, PyObject *args, PyObject *kwds) { char *path; LIBSSH2_CHANNEL *channel; struct stat sb; PyObject* get_stat = NULL; int get_stat_is_true = 0; PyObject* chan; static char *kwlist[] = {"path", "get_stat", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|O:scp_recv", kwlist, &path, &get_stat)) return NULL; if (get_stat && (get_stat_is_true = PyObject_IsTrue(get_stat)) < 0) return NULL; Py_BEGIN_ALLOW_THREADS channel = libssh2_scp_recv(self->session, path, get_stat_is_true ? &sb : 0); Py_END_ALLOW_THREADS CHECK_RETURN_POINTER(channel, self) /* Return a tuple of the channel and (size, mode, mtime, atime) * of the remote file if the get_stat argument is true else return * a tuple of the channel and None. */ chan = (PyObject *)SSH2_Channel_New(channel, self); if (!get_stat_is_true) return Py_BuildValue("(OO)", chan, Py_None); return Py_BuildValue("(O(LlLL))", chan, (PY_LONG_LONG)sb.st_size, (long)sb.st_mode, (PY_LONG_LONG)sb.st_mtime, (PY_LONG_LONG)sb.st_atime); }
static t_link *_t_lm__get(t_lm *self, PyObject *key, int load, int noError) { PyObject *link = PyDict_GetItem(self->dict, key); if (link == NULL) { if (load && self->flags & LM_LOAD) { PyObject *loaded = PyObject_CallMethodObjArgs((PyObject *) self, _load_NAME, key, NULL); if (!loaded) return NULL; if (PyObject_IsTrue(loaded)) link = PyDict_GetItem(self->dict, key); Py_DECREF(loaded); } if (link == NULL) { if (!noError) PyErr_SetObject(PyExc_KeyError, key); return NULL; } } if (!PyObject_TypeCheck(link, &LinkType)) { PyErr_SetObject(PyExc_TypeError, link); return NULL; } return (t_link *) link; }
/* Python function to set the enabled state of a breakpoint. */ static int bppy_set_enabled (PyObject *self, PyObject *newvalue, void *closure) { gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self; int cmp; BPPY_SET_REQUIRE_VALID (self_bp); if (newvalue == NULL) { PyErr_SetString (PyExc_TypeError, _("Cannot delete `enabled' attribute.")); return -1; } else if (! PyBool_Check (newvalue)) { PyErr_SetString (PyExc_TypeError, _("The value of `enabled' must be a boolean.")); return -1; } cmp = PyObject_IsTrue (newvalue); if (cmp < 0) return -1; TRY { if (cmp == 1) enable_breakpoint (self_bp->bp); else disable_breakpoint (self_bp->bp); } CATCH (except, RETURN_MASK_ALL) { GDB_PY_SET_HANDLE_EXCEPTION (except); }
/** * Python any * * @param t Prolog term with a previously constructed Python iterator * * @return the Python boolean `True` if any element of the iterator is `True`, * `False` if all of them are false. */ static PyObject *bip_any(term_t t) { PyObject *it, *item, *v; PyObject *(*iternext)(PyObject *); int cmp; if (!PL_get_arg(1, t, t)) return NULL; v = term_to_python(t, true); it = PyObject_GetIter(v); if (it == NULL) return NULL; iternext = *Py_TYPE(it)->tp_iternext; for (;;) { item = iternext(it); if (item == NULL) break; cmp = PyObject_IsTrue(item); Py_DECREF(item); if (cmp < 0) { Py_DECREF(it); return NULL; } if (cmp == 1) { Py_DECREF(it); Py_RETURN_TRUE; } } Py_DECREF(it); if (PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_StopIteration)) PyErr_Clear(); else return NULL; } Py_RETURN_FALSE; }
/** * \ingroup python_interface_edgqseq * \brief Selects a single edge from the edge sequence based on some criteria */ PyObject* igraphmodule_EdgeSeq_find(igraphmodule_EdgeSeqObject *self, PyObject *args) { PyObject *item; long int i, n; if (!PyArg_ParseTuple(args, "O", &item)) return NULL; if (PyCallable_Check(item)) { /* Call the callable for every edge in the current sequence and return * the first one for which it evaluates to True */ n = PySequence_Size((PyObject*)self); for (i=0; i<n; i++) { PyObject *edge = PySequence_GetItem((PyObject*)self, i); PyObject *call_result; if (edge == 0) return NULL; call_result = PyObject_CallFunctionObjArgs(item, edge, NULL); if (call_result == 0) { Py_DECREF(edge); return NULL; } if (PyObject_IsTrue(call_result)) { Py_DECREF(call_result); return edge; /* reference passed to caller */ } Py_DECREF(call_result); Py_DECREF(edge); } } else if (PyInt_Check(item)) { /* Integers are interpreted as indices on the edge set and NOT on the * original, untouched edge sequence of the graph */ return PySequence_GetItem((PyObject*)self, PyInt_AsLong(item)); } PyErr_SetString(PyExc_IndexError, "no such edge"); return NULL; }
static PyObject *Py_convert_to_svg(PyObject *self, PyObject *args, PyObject *kwds) { py::PathIterator path; agg::trans_affine trans; agg::rect_d cliprect; PyObject *simplifyobj; bool simplify = false; int precision; if (!PyArg_ParseTuple(args, "O&O&O&Oi:convert_to_svg", &convert_path, &path, &convert_trans_affine, &trans, &convert_rect, &cliprect, &simplifyobj, &precision)) { return NULL; } if (simplifyobj == Py_None) { simplify = path.should_simplify(); } else if (PyObject_IsTrue(simplifyobj)) { simplify = true; } size_t buffersize = path.total_vertices() * (precision + 5) * 4; std::string buffer; buffer.reserve(buffersize); CALL_CPP("convert_to_svg", (convert_to_svg(path, trans, cliprect, simplify, precision, &buffer[0], &buffersize))); return PyUnicode_DecodeASCII(&buffer[0], buffersize, ""); }
static int already_warned(PyObject *registry, PyObject *key, int should_set) { PyObject *version_obj, *already_warned; _Py_IDENTIFIER(version); if (key == NULL) return -1; version_obj = _PyDict_GetItemId(registry, &PyId_version); if (version_obj == NULL || !PyLong_CheckExact(version_obj) || PyLong_AsLong(version_obj) != _filters_version) { PyDict_Clear(registry); version_obj = PyLong_FromLong(_filters_version); if (version_obj == NULL) return -1; if (_PyDict_SetItemId(registry, &PyId_version, version_obj) < 0) { Py_DECREF(version_obj); return -1; } Py_DECREF(version_obj); } else { already_warned = PyDict_GetItem(registry, key); if (already_warned != NULL) { int rc = PyObject_IsTrue(already_warned); if (rc != 0) return rc; } } /* This warning wasn't found in the registry, set it. */ if (should_set) return PyDict_SetItem(registry, key, Py_True); return 0; }
static PyObject* ConditionObject_is_owned(ConditionObject *self, PyObject *args) { PyObject *res, *res2; DEBUG("self:%p", self); res = call_method_args1(self->lock, "acquire", Py_False); if (res == NULL) { return NULL; } if (PyObject_IsTrue(res)) { Py_DECREF(res); res2 = call_method(self->lock, "release"); if (res2 == NULL) { return NULL; } Py_DECREF(res2); Py_RETURN_FALSE; } else { Py_DECREF(res); Py_RETURN_TRUE; } }
/** * APPisUserFeasible callback * * Called by DIP, we interface with Python */ bool DippyDecompApp::APPisUserFeasible(const double* x, const int n_cols, const double tolZero) { assert(n_cols == m_modelCore.getModel()->getColNames().size()); PyObject* pSolutionList = pyTupleList_FromDoubleArray(x, m_colList); PyObject* pTolZero = PyFloat_FromDouble(tolZero); if (!m_pyIsUserFeasible) { return true; } PyObject* pResult = PyObject_CallMethod(m_pProb, "isUserFeasible", "Od", pSolutionList, pTolZero); if (pResult == NULL) { throw UtilException("Error calling method prob.isUserFeasible()", "APPisUserFeasible", "DippyDecompApp"); } // This should not happen as having isUserFeasible present but not returning a boolean is not good if (pResult == Py_None) { // method exists, but not implemented, return true return true; } return (bool)PyObject_IsTrue(pResult); }
/* Implementation of behnel3 */ static struct PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; static void __pyx_init_filenames(void); /*proto*/ PyMODINIT_FUNC initbehnel3(void); /*proto*/ PyMODINIT_FUNC initbehnel3(void) { PyObject *__pyx_1 = 0; int __pyx_2; __pyx_init_filenames(); __pyx_m = Py_InitModule4("behnel3", __pyx_methods, 0, 0, PYTHON_API_VERSION); if (!__pyx_m) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;}; Py_INCREF(__pyx_m); __pyx_b = PyImport_AddModule("__builtin__"); if (!__pyx_b) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;}; if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;}; if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;}; __pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_y); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;} __pyx_2 = PyObject_IsTrue(__pyx_1); if (__pyx_2 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;} if (!__pyx_2) { Py_DECREF(__pyx_1); __pyx_1 = 0; __pyx_1 = PyDict_New(); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;} } if (PyObject_SetAttr(__pyx_m, __pyx_n_x, __pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;} Py_DECREF(__pyx_1); __pyx_1 = 0; return; __pyx_L1:; Py_XDECREF(__pyx_1); __Pyx_AddTraceback("behnel3"); }
static PyObject * PySfImage_Copy(PySfImage* self, PyObject *args, PyObject *kwds) { const char *kwlist[] = {"Source", "DestX", "DestY", "SourceRect", "ApplyAlpha", NULL}; PySfIntRect *SourceRect = NULL; PySfImage *Source = NULL; unsigned int DestX, DestY; PyObject *PyApplyAlpha = NULL; bool ApplyAlpha = false; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!II|O!O:Image.Copy", (char **)kwlist, &PySfImageType, &Source, &DestX, &DestY, &PySfIntRectType, &SourceRect, &PyApplyAlpha)) return NULL; if (PyApplyAlpha) if (PyObject_IsTrue(PyApplyAlpha)) ApplyAlpha = true; if (SourceRect) self->obj->Copy(*(Source->obj), DestX, DestY, *(SourceRect->obj), ApplyAlpha); else self->obj->Copy(*(Source->obj), DestX, DestY, sf::IntRect(0, 0, 0, 0), ApplyAlpha); Py_RETURN_NONE; }
static PyObject *eer_threshold(PyObject *, PyObject *args, PyObject *kwds) { BOB_TRY char **kwlist = eer_threshold_doc.kwlist(); PyBlitzArrayObject *neg; PyBlitzArrayObject *pos; PyObject *is_sorted = Py_False; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&O&|O", kwlist, &double1d_converter, &neg, &double1d_converter, &pos, &is_sorted)) return 0; // protects acquired resources through this scope auto neg_ = make_safe(neg); auto pos_ = make_safe(pos); double result = bob::measure::eerThreshold( *PyBlitzArrayCxx_AsBlitz<double, 1>(neg), *PyBlitzArrayCxx_AsBlitz<double, 1>(pos), PyObject_IsTrue(is_sorted)); return Py_BuildValue("d", result); BOB_CATCH_FUNCTION("eer_threshold", 0) }
PyObject* objToJSON(PyObject* self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "obj", "ensure_ascii", NULL}; char buffer[65536]; char *ret; PyObject *newobj; PyObject *oinput = NULL; PyObject *oensureAscii = NULL; JSONObjectEncoder encoder = { Object_beginTypeContext, //void (*beginTypeContext)(JSOBJ obj, JSONTypeContext *tc); Object_endTypeContext, //void (*endTypeContext)(JSOBJ obj, JSONTypeContext *tc); Object_getStringValue, //const char *(*getStringValue)(JSOBJ obj, JSONTypeContext *tc, size_t *_outLen); Object_getLongValue, //JSLONG (*getLongValue)(JSOBJ obj, JSONTypeContext *tc); Object_getIntValue, //JSLONG (*getLongValue)(JSOBJ obj, JSONTypeContext *tc); Object_getDoubleValue, //double (*getDoubleValue)(JSOBJ obj, JSONTypeContext *tc); Object_iterBegin, //JSPFN_ITERBEGIN iterBegin; Object_iterNext, //JSPFN_ITERNEXT iterNext; Object_iterEnd, //JSPFN_ITEREND iterEnd; Object_iterGetValue, //JSPFN_ITERGETVALUE iterGetValue; Object_iterGetName, //JSPFN_ITERGETNAME iterGetName; Object_releaseObject, //void (*releaseValue)(JSONTypeContext *ti); PyObject_Malloc, //JSPFN_MALLOC malloc; PyObject_Realloc, //JSPFN_REALLOC realloc; PyObject_Free, //JSPFN_FREE free; -1, //recursionMax 5, //default decimal precision 1, //forceAscii }; PRINTMARK(); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O", kwlist, &oinput, &oensureAscii)) { return NULL; } if (oensureAscii != NULL && !PyObject_IsTrue(oensureAscii)) { encoder.forceASCII = 0; } PRINTMARK(); ret = JSON_EncodeObject (oinput, &encoder, buffer, sizeof (buffer)); PRINTMARK(); if (PyErr_Occurred()) { return NULL; } if (encoder.errorMsg) { if (ret != buffer) { encoder.free (ret); } PyErr_Format (PyExc_OverflowError, "%s", encoder.errorMsg); return NULL; } newobj = PyString_FromString (ret); if (ret != buffer) { encoder.free (ret); } PRINTMARK(); return newobj; }
static PyObject * Rules_match( PyObject *self, PyObject *args, PyObject *keywords) { static char *kwlist[] = { "filepath", "pid", "data", "externals", "callback", "fast", "timeout", NULL }; char* filepath = NULL; char* data = NULL; int pid = 0; int timeout = 0; int length; int error; int fast_mode = FALSE; PyObject *externals = NULL; PyObject *fast = NULL; Rules* object = (Rules*) self; CALLBACK_DATA callback_data; callback_data.matches = NULL; callback_data.callback = NULL; if (PyArg_ParseTupleAndKeywords( args, keywords, "|sis#OOOi", kwlist, &filepath, &pid, &data, &length, &externals, &callback_data.callback, &fast, &timeout)) { if (externals != NULL) { if (PyDict_Check(externals)) { if (!process_match_externals(externals, object->rules)) { return PyErr_Format( PyExc_TypeError, "external values must be of type integer, boolean or string"); } } else { return PyErr_Format( PyExc_TypeError, "'externals' must be a dictionary"); } } if (callback_data.callback != NULL) { if (!PyCallable_Check(callback_data.callback)) { return PyErr_Format( YaraError, "callback must be callable"); } } if (fast != NULL) { fast_mode = (PyObject_IsTrue(fast) == 1); } if (filepath != NULL) { callback_data.matches = PyList_New(0); Py_BEGIN_ALLOW_THREADS error = yr_rules_scan_file( object->rules, filepath, yara_callback, &callback_data, fast_mode, timeout); Py_END_ALLOW_THREADS if (error != ERROR_SUCCESS) { Py_DECREF(callback_data.matches); if (error == ERROR_CALLBACK_ERROR) return NULL; else return handle_error(error, filepath); } } else if (data != NULL)
/* Returns 0 on error (no new refs), 1 on success */ static int setup_context(Py_ssize_t stack_level, PyObject **filename, int *lineno, PyObject **module, PyObject **registry) { PyObject *globals; /* Setup globals and lineno. */ PyFrameObject *f = PyThreadState_GET()->frame; // Stack level comparisons to Python code is off by one as there is no // warnings-related stack level to avoid. if (stack_level <= 0 || is_internal_frame(f)) { while (--stack_level > 0 && f != NULL) { f = f->f_back; } } else { while (--stack_level > 0 && f != NULL) { f = next_external_frame(f); } } if (f == NULL) { globals = PyThreadState_Get()->interp->sysdict; *lineno = 1; } else { globals = f->f_globals; *lineno = PyFrame_GetLineNumber(f); } *module = NULL; /* Setup registry. */ assert(globals != NULL); assert(PyDict_Check(globals)); *registry = PyDict_GetItemString(globals, "__warningregistry__"); if (*registry == NULL) { int rc; *registry = PyDict_New(); if (*registry == NULL) return 0; rc = PyDict_SetItemString(globals, "__warningregistry__", *registry); if (rc < 0) goto handle_error; } else Py_INCREF(*registry); /* Setup module. */ *module = PyDict_GetItemString(globals, "__name__"); if (*module == NULL) { *module = PyUnicode_FromString("<string>"); if (*module == NULL) goto handle_error; } else Py_INCREF(*module); /* Setup filename. */ *filename = PyDict_GetItemString(globals, "__file__"); if (*filename != NULL && PyUnicode_Check(*filename)) { Py_ssize_t len; int kind; void *data; if (PyUnicode_READY(*filename)) goto handle_error; len = PyUnicode_GetLength(*filename); kind = PyUnicode_KIND(*filename); data = PyUnicode_DATA(*filename); #define ascii_lower(c) ((c <= 127) ? Py_TOLOWER(c) : 0) /* if filename.lower().endswith(".pyc"): */ if (len >= 4 && PyUnicode_READ(kind, data, len-4) == '.' && ascii_lower(PyUnicode_READ(kind, data, len-3)) == 'p' && ascii_lower(PyUnicode_READ(kind, data, len-2)) == 'y' && ascii_lower(PyUnicode_READ(kind, data, len-1)) == 'c') { *filename = PyUnicode_Substring(*filename, 0, PyUnicode_GET_LENGTH(*filename)-1); if (*filename == NULL) goto handle_error; } else Py_INCREF(*filename); } else { *filename = NULL; if (*module != Py_None && PyUnicode_CompareWithASCIIString(*module, "__main__") == 0) { PyObject *argv = _PySys_GetObjectId(&PyId_argv); /* PyList_Check() is needed because sys.argv is set to None during Python finalization */ if (argv != NULL && PyList_Check(argv) && PyList_Size(argv) > 0) { int is_true; *filename = PyList_GetItem(argv, 0); Py_INCREF(*filename); /* If sys.argv[0] is false, then use '__main__'. */ is_true = PyObject_IsTrue(*filename); if (is_true < 0) { Py_DECREF(*filename); goto handle_error; } else if (!is_true) { Py_XSETREF(*filename, PyUnicode_FromString("__main__")); if (*filename == NULL) goto handle_error; } } else { /* embedded interpreters don't have sys.argv, see bug #839151 */ *filename = PyUnicode_FromString("__main__"); if (*filename == NULL) goto handle_error; } } if (*filename == NULL) { *filename = *module; Py_INCREF(*filename); } } return 1; handle_error: /* filename not XDECREF'ed here as there is no way to jump here with a dangling reference. */ Py_XDECREF(*registry); Py_XDECREF(*module); return 0; }
static PyObject *builder_parse(PyObject *inputSource, ParseFlags flags, PyObject *entity_factory, int asEntity, PyObject *namespaces, PyObject *rule_handler) { ParserState *state; PyObject *result; int gc_enabled; ExpatStatus status; #ifdef DEBUG_PARSER FILE *stream = PySys_GetFile("stderr", stderr); PySys_WriteStderr("builder_parse(source="); PyObject_Print(inputSource, stream, 0); PySys_WriteStderr(", flags=%d, entity_factory=", flags); PyObject_Print(entity_factory, stream, 0); PySys_WriteStderr(", asEntity=%d, namespaces=", asEntity); PyObject_Print(namespaces, stream, 0); PySys_WriteStderr("\n"); #endif state = ParserState_New(entity_factory); if (state == NULL) return NULL; state->reader = create_reader(state); if (state->reader == NULL) { ParserState_Del(state); return NULL; } if (rule_handler) { state->rule_matcher = RuleMatchObject_New(rule_handler); } /* Disable GC (if enabled) while building the DOM tree */ result = PyObject_Call(gc_isenabled_function, empty_args_tuple, NULL); if (result == NULL) goto finally; gc_enabled = PyObject_IsTrue(result); Py_DECREF(result); if (gc_enabled) { result = PyObject_Call(gc_disable_function, empty_args_tuple, NULL); if (result == NULL) goto finally; Py_DECREF(result); } Expat_SetValidation(state->reader, flags == PARSE_FLAGS_VALIDATE); Expat_SetParamEntityParsing(state->reader, flags != PARSE_FLAGS_STANDALONE); if (asEntity) status = ExpatReader_ParseEntity(state->reader, inputSource, namespaces); else status = ExpatReader_Parse(state->reader, inputSource); if (gc_enabled) { result = PyObject_Call(gc_enable_function, empty_args_tuple, NULL); if (result == NULL) goto finally; Py_DECREF(result); } /* save off the created document */ if (status == EXPAT_STATUS_OK) result = (PyObject *)state->owner_document; else result = NULL; finally: ExpatReader_Del(state->reader); ParserState_Del(state); #ifdef DEBUG_PARSER PySys_WriteStderr("builder_parse() => "); PyObject_Print(result, PySys_GetFile("stderr", stderr), 0); PySys_WriteStderr("\n"); #endif return result; }
static PyObject * observe_common(pycbc_Connection *self, PyObject *args, PyObject *kwargs, int argopts) { int rv; int ii; Py_ssize_t ncmds; PyObject *kobj = NULL; pycbc_seqtype_t seqtype; lcb_error_t err; int master_only = 0; PyObject *master_only_O = NULL; struct pycbc_common_vars cv = PYCBC_COMMON_VARS_STATIC_INIT; static char *kwlist[] = { "keys", "master_only", NULL }; rv = PyArg_ParseTupleAndKeywords(args, kwargs, "O|O", kwlist, &kobj, &master_only_O); if (!rv) { PYCBC_EXCTHROW_ARGS(); return NULL; } if (argopts & PYCBC_ARGOPT_MULTI) { rv = pycbc_oputil_check_sequence(kobj, 1, &ncmds, &seqtype); if (rv < 0) { return NULL; } } else { ncmds = 1; } master_only = master_only_O && PyObject_IsTrue(master_only_O); rv = pycbc_common_vars_init(&cv, self, argopts, ncmds, sizeof(lcb_observe_cmd_t), 0); if (rv < 0) { return NULL; } if (argopts & PYCBC_ARGOPT_MULTI) { Py_ssize_t dictpos; PyObject *curseq, *iter = NULL; curseq = pycbc_oputil_iter_prepare(seqtype, kobj, &iter, &dictpos); if (!curseq) { goto GT_DONE; } for (ii = 0; ii < ncmds; ii++) { PyObject *curkey = NULL, *curvalue = NULL; rv = pycbc_oputil_sequence_next(seqtype, curseq, &dictpos, ii, &curkey, &curvalue); if (rv < 0) { goto GT_ITER_DONE; } rv = handle_single_observe(self, curkey, ii, master_only, &cv); GT_ITER_DONE: Py_XDECREF(curkey); Py_XDECREF(curvalue); if (rv < 0) { goto GT_DONE; } } } else { rv = handle_single_observe(self, kobj, 0, master_only, &cv); if (rv < 0) { goto GT_DONE; } } err = lcb_observe(self->instance, cv.mres, ncmds, cv.cmdlist.obs); if (err != LCB_SUCCESS) { PYCBC_EXCTHROW_SCHED(err); goto GT_DONE; } cv.is_seqcmd = 1; if (-1 == pycbc_common_vars_wait(&cv, self)) { goto GT_DONE; } GT_DONE: pycbc_common_vars_finalize(&cv, self); return cv.ret; }
inline bool AsBool(PyObject* obj) { int result = PyObject_IsTrue(obj); PYTHON_CHECK(result != -1, "PyObject_IsTrue failed"); return result != 0; }
PyObject* objToJSON(PyObject* self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "obj", "ensure_ascii", "double_precision", "encode_html_chars", NULL}; char buffer[65536]; char *ret; PyObject *newobj; PyObject *oinput = NULL; PyObject *oensureAscii = NULL; static const int idoublePrecision = 10; // default double precision setting PyObject *oencodeHTMLChars = NULL; JSONObjectEncoder encoder = { Object_beginTypeContext, Object_endTypeContext, Object_getStringValue, Object_getLongValue, Object_getIntValue, Object_getDoubleValue, Object_iterBegin, Object_iterNext, Object_iterEnd, Object_iterGetValue, Object_iterGetName, Object_releaseObject, PyObject_Malloc, PyObject_Realloc, PyObject_Free, -1, //recursionMax idoublePrecision, 1, //forceAscii #if HAS_JSON_ENCODE_HTML_CHARS_DEFAULT_TRUE 1, //encodeHTMLChars #else 0, //encodeHTMLChars #endif }; PRINTMARK(); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OiO", kwlist, &oinput, &oensureAscii, &idoublePrecision, &oencodeHTMLChars)) { return NULL; } if (oensureAscii != NULL && !PyObject_IsTrue(oensureAscii)) { encoder.forceASCII = 0; } if (oencodeHTMLChars != NULL && PyObject_IsTrue(oencodeHTMLChars)) { encoder.encodeHTMLChars = 1; } encoder.doublePrecision = idoublePrecision; PRINTMARK(); ret = JSON_EncodeObject (oinput, &encoder, buffer, sizeof (buffer)); PRINTMARK(); if (PyErr_Occurred()) { return NULL; } if (encoder.errorMsg) { if (ret != buffer) { encoder.free (ret); } PyErr_Format (PyExc_OverflowError, "%s", encoder.errorMsg); return NULL; } newobj = PyString_FromString (ret); if (ret != buffer) { encoder.free (ret); } PRINTMARK(); return newobj; }
static PyObject * SaneDev_snap(SaneDevObject *self, PyObject *args) { SANE_Status st; /* The buffer should be a multiple of 3 in size, so each sane_read operation will return an integral number of RGB triples. */ SANE_Byte buffer[READSIZE]; /* XXX how big should the buffer be? */ SANE_Int len, lastlen; Imaging im; SANE_Parameters p; int px, py, remain, cplen, bufpos, padbytes; long L; char errmsg[80]; union { char c[2]; INT16 i16; } endian; PyObject *pyNoCancel = NULL; int noCancel = 0; endian.i16 = 1; if (!PyArg_ParseTuple(args, "l|O", &L, &pyNoCancel)) return NULL; if (self->h==NULL) { PyErr_SetString(ErrorObject, "SaneDev object is closed"); return NULL; } im=(Imaging)L; if (pyNoCancel) noCancel = PyObject_IsTrue(pyNoCancel); st=SANE_STATUS_GOOD; px=py=0; /* xxx not yet implemented - handscanner support (i.e., unknown image length during start) - generally: move the functionality from method snap in sane.py down here -- I don't like this cross-dependency. we need to call sane_get_parameters here, and we can create the result Image object here. */ Py_UNBLOCK_THREADS sane_get_parameters(self->h, &p); if (p.format == SANE_FRAME_GRAY) { switch (p.depth) { case 1: remain = p.bytes_per_line * im->ysize; padbytes = p.bytes_per_line - (im->xsize+7)/8; bufpos = 0; lastlen = len = 0; while (st!=SANE_STATUS_EOF && py < im->ysize) { while (len > 0 && py < im->ysize) { int i, j, k; j = buffer[bufpos++]; k = 0x80; for (i = 0; i < 8 && px < im->xsize; i++) { im->image8[py][px++] = (k&j) ? 0 : 0xFF; k = k >> 1; } len--; if (px >= im->xsize) { bufpos += padbytes; len -= padbytes; py++; px = 0; } } st=sane_read(self->h, buffer, remain<READSIZE ? remain : READSIZE, &len); if (st && (st!=SANE_STATUS_EOF)) { sane_cancel(self->h); Py_BLOCK_THREADS return PySane_Error(st); } bufpos -= lastlen; lastlen = len; remain -= len; /* skip possible pad bytes at the start of the buffer */ len -= bufpos; } break; case 8: remain = p.bytes_per_line * im->ysize; padbytes = p.bytes_per_line - im->xsize; bufpos = 0; len = 0; while (st!=SANE_STATUS_EOF && py < im->ysize) { while (len > 0 && py < im->ysize) { cplen = len; if (px + cplen >= im->xsize) cplen = im->xsize - px; memcpy(&im->image8[py][px], &buffer[bufpos], cplen); len -= cplen; bufpos += cplen; px += cplen; if (px >= im->xsize) { px = 0; py++; bufpos += padbytes; len -= padbytes; } } bufpos = -len; st=sane_read(self->h, buffer, remain<READSIZE ? remain : READSIZE, &len); if (st && (st!=SANE_STATUS_EOF)) { sane_cancel(self->h); Py_BLOCK_THREADS return PySane_Error(st); } remain -= len; len -= bufpos; } break; case 16: remain = p.bytes_per_line * im->ysize; padbytes = p.bytes_per_line - 2 * im->xsize; bufpos = endian.c[0]; lastlen = len = 0; while (st!=SANE_STATUS_EOF && py < im->ysize) { while (len > 0 && py < im->ysize) { im->image8[py][px++] = buffer[bufpos]; bufpos += 2; len -= 2; if (px >= im->xsize) { bufpos += padbytes; len -= padbytes; py++; px = 0; } } st=sane_read(self->h, buffer, remain<READSIZE ? remain : READSIZE, &len); if (st && (st!=SANE_STATUS_EOF)) { sane_cancel(self->h); Py_BLOCK_THREADS return PySane_Error(st); } remain -= len; bufpos -= lastlen; lastlen = len; len -= bufpos; }
static PyObject * subprocess_fork_exec(PyObject* self, PyObject *args) { PyObject *gc_module = NULL; PyObject *executable_list, *py_fds_to_keep; PyObject *env_list, *preexec_fn; PyObject *process_args, *converted_args = NULL, *fast_args = NULL; PyObject *preexec_fn_args_tuple = NULL; int p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite; int errpipe_read, errpipe_write, close_fds, restore_signals; int call_setsid; PyObject *cwd_obj, *cwd_obj2; const char *cwd; pid_t pid; int need_to_reenable_gc = 0; char *const *exec_array, *const *argv = NULL, *const *envp = NULL; Py_ssize_t arg_num; if (!PyArg_ParseTuple( args, "OOpOOOiiiiiiiiiiO:fork_exec", &process_args, &executable_list, &close_fds, &py_fds_to_keep, &cwd_obj, &env_list, &p2cread, &p2cwrite, &c2pread, &c2pwrite, &errread, &errwrite, &errpipe_read, &errpipe_write, &restore_signals, &call_setsid, &preexec_fn)) return NULL; if (close_fds && errpipe_write < 3) { /* precondition */ PyErr_SetString(PyExc_ValueError, "errpipe_write must be >= 3"); return NULL; } if (PySequence_Length(py_fds_to_keep) < 0) { PyErr_SetString(PyExc_ValueError, "cannot get length of fds_to_keep"); return NULL; } if (_sanity_check_python_fd_sequence(py_fds_to_keep)) { PyErr_SetString(PyExc_ValueError, "bad value(s) in fds_to_keep"); return NULL; } /* We need to call gc.disable() when we'll be calling preexec_fn */ if (preexec_fn != Py_None) { PyObject *result; _Py_IDENTIFIER(isenabled); _Py_IDENTIFIER(disable); gc_module = PyImport_ImportModule("gc"); if (gc_module == NULL) return NULL; result = _PyObject_CallMethodId(gc_module, &PyId_isenabled, NULL); if (result == NULL) { Py_DECREF(gc_module); return NULL; } need_to_reenable_gc = PyObject_IsTrue(result); Py_DECREF(result); if (need_to_reenable_gc == -1) { Py_DECREF(gc_module); return NULL; } result = _PyObject_CallMethodId(gc_module, &PyId_disable, NULL); if (result == NULL) { Py_DECREF(gc_module); return NULL; } Py_DECREF(result); } exec_array = _PySequence_BytesToCharpArray(executable_list); if (!exec_array) { Py_XDECREF(gc_module); return NULL; } /* Convert args and env into appropriate arguments for exec() */ /* These conversions are done in the parent process to avoid allocating or freeing memory in the child process. */ if (process_args != Py_None) { Py_ssize_t num_args; /* Equivalent to: */ /* tuple(PyUnicode_FSConverter(arg) for arg in process_args) */ fast_args = PySequence_Fast(process_args, "argv must be a tuple"); if (fast_args == NULL) goto cleanup; num_args = PySequence_Fast_GET_SIZE(fast_args); converted_args = PyTuple_New(num_args); if (converted_args == NULL) goto cleanup; for (arg_num = 0; arg_num < num_args; ++arg_num) { PyObject *borrowed_arg, *converted_arg; borrowed_arg = PySequence_Fast_GET_ITEM(fast_args, arg_num); if (PyUnicode_FSConverter(borrowed_arg, &converted_arg) == 0) goto cleanup; PyTuple_SET_ITEM(converted_args, arg_num, converted_arg); } argv = _PySequence_BytesToCharpArray(converted_args); Py_CLEAR(converted_args); Py_CLEAR(fast_args); if (!argv) goto cleanup; } if (env_list != Py_None) { envp = _PySequence_BytesToCharpArray(env_list); if (!envp) goto cleanup; } if (preexec_fn != Py_None) { preexec_fn_args_tuple = PyTuple_New(0); if (!preexec_fn_args_tuple) goto cleanup; _PyImport_AcquireLock(); } if (cwd_obj != Py_None) { if (PyUnicode_FSConverter(cwd_obj, &cwd_obj2) == 0) goto cleanup; cwd = PyBytes_AsString(cwd_obj2); } else { cwd = NULL; cwd_obj2 = NULL; } pid = fork(); if (pid == 0) { /* Child process */ /* * Code from here to _exit() must only use async-signal-safe functions, * listed at `man 7 signal` or * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html. */ if (preexec_fn != Py_None) { /* We'll be calling back into Python later so we need to do this. * This call may not be async-signal-safe but neither is calling * back into Python. The user asked us to use hope as a strategy * to avoid deadlock... */ PyOS_AfterFork(); } child_exec(exec_array, argv, envp, cwd, p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite, errpipe_read, errpipe_write, close_fds, restore_signals, call_setsid, py_fds_to_keep, preexec_fn, preexec_fn_args_tuple); _exit(255); return NULL; /* Dead code to avoid a potential compiler warning. */ } Py_XDECREF(cwd_obj2); if (pid == -1) { /* Capture the errno exception before errno can be clobbered. */ PyErr_SetFromErrno(PyExc_OSError); } if (preexec_fn != Py_None && _PyImport_ReleaseLock() < 0 && !PyErr_Occurred()) { PyErr_SetString(PyExc_RuntimeError, "not holding the import lock"); } /* Parent process */ if (envp) _Py_FreeCharPArray(envp); if (argv) _Py_FreeCharPArray(argv); _Py_FreeCharPArray(exec_array); /* Reenable gc in the parent process (or if fork failed). */ if (need_to_reenable_gc && _enable_gc(gc_module)) { Py_XDECREF(gc_module); return NULL; } Py_XDECREF(preexec_fn_args_tuple); Py_XDECREF(gc_module); if (pid == -1) return NULL; /* fork() failed. Exception set earlier. */ return PyLong_FromPid(pid); cleanup: if (envp) _Py_FreeCharPArray(envp); if (argv) _Py_FreeCharPArray(argv); _Py_FreeCharPArray(exec_array); Py_XDECREF(converted_args); Py_XDECREF(fast_args); Py_XDECREF(preexec_fn_args_tuple); /* Reenable gc if it was disabled. */ if (need_to_reenable_gc) _enable_gc(gc_module); Py_XDECREF(gc_module); return NULL; }
static PyObject* mod_connect(PyObject* self, PyObject* args, PyObject* kwargs) { UNUSED(self); Object pConnectString; int fAutoCommit = 0; int fAnsi = 0; // force ansi int fReadOnly = 0; long timeout = 0; Object encoding; Object attrs_before; // Optional connect attrs set before connecting Py_ssize_t size = args ? PyTuple_Size(args) : 0; if (size > 1) { PyErr_SetString(PyExc_TypeError, "function takes at most 1 non-keyword argument"); return 0; } if (size == 1) { if (!PyString_Check(PyTuple_GET_ITEM(args, 0)) && !PyUnicode_Check(PyTuple_GET_ITEM(args, 0))) return PyErr_Format(PyExc_TypeError, "argument 1 must be a string or unicode object"); pConnectString.Attach(PyUnicode_FromObject(PyTuple_GetItem(args, 0))); if (!pConnectString.IsValid()) return 0; } if (kwargs && PyDict_Size(kwargs) > 0) { Object partsdict(PyDict_New()); if (!partsdict.IsValid()) return 0; Py_ssize_t pos = 0; PyObject* key = 0; PyObject* value = 0; Object okey; // in case we need to allocate a new key while (PyDict_Next(kwargs, &pos, &key, &value)) { if (!Text_Check(key)) return PyErr_Format(PyExc_TypeError, "Dictionary keys passed to connect must be strings"); // // Note: key and value are *borrowed*. // // // Check for the two non-connection string keywords we accept. (If we get many more of these, create something // // table driven. Are we sure there isn't a Python function to parse keywords but leave those it doesn't know?) // const char* szKey = PyString_AsString(key); if (Text_EqualsI(key, "autocommit")) { fAutoCommit = PyObject_IsTrue(value); continue; } if (Text_EqualsI(key, "ansi")) { fAnsi = PyObject_IsTrue(value); continue; } if (Text_EqualsI(key, "timeout")) { timeout = PyInt_AsLong(value); if (PyErr_Occurred()) return 0; continue; } if (Text_EqualsI(key, "readonly")) { fReadOnly = PyObject_IsTrue(value); continue; } if (Text_EqualsI(key, "attrs_before")) { attrs_before = _CheckAttrsDict(value); if (PyErr_Occurred()) return 0; continue; } if (Text_EqualsI(key, "encoding")) { #if PY_MAJOR_VERSION < 3 if (!PyString_Check(value) || !PyUnicode_Check(value)) return PyErr_Format(PyExc_TypeError, "encoding must be a string or unicode object"); #else if (!PyUnicode_Check(value)) return PyErr_Format(PyExc_TypeError, "encoding must be a string"); #endif encoding = value; continue; } // Map DB API recommended names to ODBC names (e.g. user --> uid). for (size_t i = 0; i < _countof(keywordmaps); i++) { if (Text_EqualsI(key, keywordmaps[i].oldname)) { if (keywordmaps[i].newnameObject == 0) { keywordmaps[i].newnameObject = PyString_FromString(keywordmaps[i].newname); if (keywordmaps[i].newnameObject == 0) return 0; } key = keywordmaps[i].newnameObject; break; } } PyObject* str = PyObject_Str(value); // convert if necessary if (!str) return 0; if (PyDict_SetItem(partsdict.Get(), key, str) == -1) { Py_XDECREF(str); return 0; } Py_XDECREF(str); } if (PyDict_Size(partsdict.Get())) pConnectString.Attach(MakeConnectionString(pConnectString.Get(), partsdict)); } if (!pConnectString.IsValid()) return PyErr_Format(PyExc_TypeError, "no connection information was passed"); if (henv == SQL_NULL_HANDLE) { if (!AllocateEnv()) return 0; } return (PyObject*)Connection_New(pConnectString.Get(), fAutoCommit != 0, fAnsi != 0, timeout, fReadOnly != 0, attrs_before, encoding); }
/* inspect a message, update the seen set * return 1 if we should pass this message on to the caller * return 0 if we should drop it * return -1 on internal error (exception has been raised) */ static int filter_message(modesreader *self, PyObject *o) { modesmessage *message = (modesmessage *)o; if (message->df == DF_MODEAC) { return self->want_modeac_messages; /* no address in mode a/c, no further filtering possible */ } if (!message->valid) { return self->want_invalid_messages; /* don't process further, contents are dubious */ } if (self->seen != NULL && self->seen != Py_None) { if (message->df == 11 || message->df == 17 || message->df == 18) { /* note that we saw this aircraft, even if the message is filtered. * only do this for CRC-checked messages as we get a lot of noise * otherwise. */ if (PySet_Add(self->seen, message->address) < 0) { return -1; } } } if (message->timestamp == 0 && !self->want_zero_timestamps) { return 0; } if (message->timestamp == MAGIC_MLAT_TIMESTAMP && !self->want_mlat_messages) { return 0; } if ((self->default_filter == NULL || self->default_filter == Py_None) && (self->specific_filter == NULL || self->specific_filter == Py_None)) { /* no filters installed, match everything */ return 1; } /* check per-type filters */ if (self->default_filter != NULL && self->default_filter != Py_None) { int rv; PyObject *entry = PySequence_GetItem(self->default_filter, message->df); if (entry == NULL) return -1; rv = PyObject_IsTrue(entry); Py_DECREF(entry); if (rv != 0) return rv; } if (self->specific_filter != NULL && self->specific_filter != Py_None) { int rv; PyObject *entry = PySequence_GetItem(self->specific_filter, message->df); if (entry == NULL) return -1; if (entry == Py_None) { rv = 0; } else { rv = PySequence_Contains(entry, message->address); } Py_DECREF(entry); if (rv != 0) return rv; } return 0; }
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); }
static int FH_consolidate(FibonacciHeap *fh) { FH_node *p, *f, *s, *tmp, *next; PyObject *pr_obj; int i, pr; int degree; degree = fh->size; FH_node *d2n[degree]; for (i=0; i<degree; i++) d2n[i] = NULL; f = fh->root_min; do { next = f->right; while ((s = d2n[f->degree]) != NULL) { if (f == s) break; pr_obj = PyObject_CallFunctionObjArgs(fh->cmp, f->key, s->key, NULL); if (pr_obj == NULL) return -1; pr = PyObject_IsTrue(pr_obj); if (pr == -1) return -1; if (!pr) { tmp = f; f = s; s = tmp; } if (fh->root_min == s) fh->root_min = f; s->right->left = s->left; s->left->right = s->right; if (f->children == NULL) { f->children = s; s->right = s->left = s; s->parent = f; } else { tmp = f->children->right; f->children->right = s; s->left = f->children; s->right = tmp; tmp->left = s; s->parent = f; } if (next == s) next = f->right; d2n[f->degree] = NULL; f->degree++; s->mark = 1; } d2n[f->degree] = f; f = next; } while(f != fh->root_min); fh->root_min = NULL; for (i=0; i<degree; i++) { p = d2n[i]; if (p != NULL) { if (fh->root_min == NULL) { p->left = p->right = p; fh->root_min = p; } else { tmp = fh->root_min->right; fh->root_min->right = p; p->left = fh->root_min; p->right = tmp; tmp->left = p; pr_obj = PyObject_CallFunctionObjArgs(fh->cmp, p->key, fh->root_min->key, NULL); if (pr_obj == NULL) return -1; pr = PyObject_IsTrue(pr_obj); if (pr == -1) return -1; if (pr) fh->root_min = p; } } } return 0; }