void XBPyThread::Process() { CLog::Log(LOGDEBUG,"Python thread: start processing"); int m_Py_file_input = Py_file_input; // get the global lock PyEval_AcquireLock(); PyThreadState* state = Py_NewInterpreter(); if (!state) { PyEval_ReleaseLock(); CLog::Log(LOGERROR,"Python thread: FAILED to get thread state!"); return; } // swap in my thread state PyThreadState_Swap(state); m_pExecuter->InitializeInterpreter(addon); CLog::Log(LOGDEBUG, "%s - The source file to load is %s", __FUNCTION__, m_source); // get path from script file name and add python path's // this is used for python so it will search modules from script path first CStdString scriptDir; URIUtils::GetDirectory(CSpecialProtocol::TranslatePath(m_source), scriptDir); URIUtils::RemoveSlashAtEnd(scriptDir); CStdString path = scriptDir; // add on any addon modules the user has installed ADDON::VECADDONS addons; ADDON::CAddonMgr::Get().GetAddons(ADDON::ADDON_SCRIPT_MODULE, addons); for (unsigned int i = 0; i < addons.size(); ++i) #ifdef TARGET_WINDOWS { CStdString strTmp(CSpecialProtocol::TranslatePath(addons[i]->LibPath())); g_charsetConverter.utf8ToSystem(strTmp); path += PY_PATH_SEP + strTmp; } #else path += PY_PATH_SEP + CSpecialProtocol::TranslatePath(addons[i]->LibPath()); #endif // and add on whatever our default path is path += PY_PATH_SEP; // we want to use sys.path so it includes site-packages // if this fails, default to using Py_GetPath PyObject *sysMod(PyImport_ImportModule((char*)"sys")); // must call Py_DECREF when finished PyObject *sysModDict(PyModule_GetDict(sysMod)); // borrowed ref, no need to delete PyObject *pathObj(PyDict_GetItemString(sysModDict, "path")); // borrowed ref, no need to delete if( pathObj && PyList_Check(pathObj) ) { for( int i = 0; i < PyList_Size(pathObj); i++ ) { PyObject *e = PyList_GetItem(pathObj, i); // borrowed ref, no need to delete if( e && PyString_Check(e) ) { path += PyString_AsString(e); // returns internal data, don't delete or modify path += PY_PATH_SEP; } } } else { path += Py_GetPath(); } Py_DECREF(sysMod); // release ref to sysMod // set current directory and python's path. if (m_argv != NULL) PySys_SetArgv(m_argc, m_argv); CLog::Log(LOGDEBUG, "%s - Setting the Python path to %s", __FUNCTION__, path.c_str()); PySys_SetPath((char *)path.c_str()); CLog::Log(LOGDEBUG, "%s - Entering source directory %s", __FUNCTION__, scriptDir.c_str()); PyObject* module = PyImport_AddModule((char*)"__main__"); PyObject* moduleDict = PyModule_GetDict(module); // when we are done initing we store thread state so we can be aborted PyThreadState_Swap(NULL); PyEval_ReleaseLock(); // we need to check if we was asked to abort before we had inited bool stopping = false; { CSingleLock lock(m_pExecuter->m_critSection); m_threadState = state; stopping = m_stopping; } PyEval_AcquireLock(); PyThreadState_Swap(state); if (!stopping) { if (m_type == 'F') { // run script from file // We need to have python open the file because on Windows the DLL that python // is linked against may not be the DLL that xbmc is linked against so // passing a FILE* to python from an fopen has the potential to crash. PyObject* file = PyFile_FromString((char *) CSpecialProtocol::TranslatePath(m_source).c_str(), (char*)"r"); FILE *fp = PyFile_AsFile(file); if (fp) { PyObject *f = PyString_FromString(CSpecialProtocol::TranslatePath(m_source).c_str()); PyDict_SetItemString(moduleDict, "__file__", f); if (addon.get() != NULL) { PyObject *pyaddonid = PyString_FromString(addon->ID().c_str()); PyDict_SetItemString(moduleDict, "__xbmcaddonid__", pyaddonid); CStdString version = ADDON::GetXbmcApiVersionDependency(addon); PyObject *pyxbmcapiversion = PyString_FromString(version.c_str()); PyDict_SetItemString(moduleDict, "__xbmcapiversion__", pyxbmcapiversion); CLog::Log(LOGDEBUG,"Instantiating addon using automatically obtained id of \"%s\" dependent on version %s of the xbmc.python api",addon->ID().c_str(),version.c_str()); } Py_DECREF(f); PyRun_FileExFlags(fp, CSpecialProtocol::TranslatePath(m_source).c_str(), m_Py_file_input, moduleDict, moduleDict,1,NULL); } else CLog::Log(LOGERROR, "%s not found!", m_source); } else { //run script PyRun_String(m_source, m_Py_file_input, moduleDict, moduleDict); } } if (!PyErr_Occurred()) CLog::Log(LOGINFO, "Scriptresult: Success"); else if (PyErr_ExceptionMatches(PyExc_SystemExit)) CLog::Log(LOGINFO, "Scriptresult: Aborted"); else { PyObject* exc_type; PyObject* exc_value; PyObject* exc_traceback; PyObject* pystring; pystring = NULL; PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); if (exc_type == 0 && exc_value == 0 && exc_traceback == 0) { CLog::Log(LOGINFO, "Strange: No Python exception occured"); } else { if (exc_type != NULL && (pystring = PyObject_Str(exc_type)) != NULL && (PyString_Check(pystring))) { PyObject *tracebackModule; CLog::Log(LOGINFO, "-->Python script returned the following error<--"); CLog::Log(LOGERROR, "Error Type: %s", PyString_AsString(PyObject_Str(exc_type))); if (PyObject_Str(exc_value)) CLog::Log(LOGERROR, "Error Contents: %s", PyString_AsString(PyObject_Str(exc_value))); tracebackModule = PyImport_ImportModule((char*)"traceback"); if (tracebackModule != NULL) { PyObject *tbList, *emptyString, *strRetval; tbList = PyObject_CallMethod(tracebackModule, (char*)"format_exception", (char*)"OOO", exc_type, exc_value == NULL ? Py_None : exc_value, exc_traceback == NULL ? Py_None : exc_traceback); emptyString = PyString_FromString(""); strRetval = PyObject_CallMethod(emptyString, (char*)"join", (char*)"O", tbList); CLog::Log(LOGERROR, "%s", PyString_AsString(strRetval)); Py_DECREF(tbList); Py_DECREF(emptyString); Py_DECREF(strRetval); Py_DECREF(tracebackModule); } CLog::Log(LOGINFO, "-->End of Python script error report<--"); } else { pystring = NULL; CLog::Log(LOGINFO, "<unknown exception type>"); } PYXBMC::PyXBMCGUILock(); CGUIDialogKaiToast *pDlgToast = (CGUIDialogKaiToast*)g_windowManager.GetWindow(WINDOW_DIALOG_KAI_TOAST); if (pDlgToast) { CStdString desc; CStdString path; CStdString script; URIUtils::Split(m_source, path, script); if (script.Equals("default.py")) { CStdString path2; URIUtils::RemoveSlashAtEnd(path); URIUtils::Split(path, path2, script); } desc.Format(g_localizeStrings.Get(2100), script); pDlgToast->QueueNotification(CGUIDialogKaiToast::Error, g_localizeStrings.Get(257), desc); } PYXBMC::PyXBMCGUIUnlock(); } Py_XDECREF(exc_type); Py_XDECREF(exc_value); // caller owns all 3 Py_XDECREF(exc_traceback); // already NULL'd out Py_XDECREF(pystring); } //tell xbmc.Monitor to call onAbortRequested() g_pythonParser.OnAbortRequested(); PyObject *m = PyImport_AddModule((char*)"xbmc"); if(!m || PyObject_SetAttrString(m, (char*)"abortRequested", PyBool_FromLong(1))) CLog::Log(LOGERROR, "Scriptresult: failed to set abortRequested"); // make sure all sub threads have finished for(PyThreadState* s = state->interp->tstate_head, *old = NULL; s;) { if(s == state) { s = s->next; continue; } if(old != s) { CLog::Log(LOGINFO, "Scriptresult: Waiting on thread %"PRIu64, (uint64_t)s->thread_id); old = s; } CPyThreadState pyState; Sleep(100); pyState.Restore(); s = state->interp->tstate_head; } // pending calls must be cleared out PyXBMC_ClearPendingCalls(state); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); //set stopped event - this allows ::stop to run and kill remaining threads //this event has to be fired without holding m_pExecuter->m_critSection //before //Also the GIL (PyEval_AcquireLock) must not be held //if not obeyed there is still no deadlock because ::stop waits with timeout (smart one!) stoppedEvent.Set(); { CSingleLock lock(m_pExecuter->m_critSection); m_threadState = NULL; } PyEval_AcquireLock(); PyThreadState_Swap(state); m_pExecuter->DeInitializeInterpreter(); Py_EndInterpreter(state); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); }
static void PyCArg_dealloc(PyCArgObject *self) { Py_XDECREF(self->obj); PyObject_Del(self); }
static void bpy_lib_dealloc(BPy_Library *self) { Py_XDECREF(self->dict); Py_TYPE(self)->tp_free(self); }
static PyObject * pwd_getpwall(PyObject *self) { PyObject *d; struct passwd *p; if ((d = PyList_New(0)) == NULL) return NULL; #if defined(PYOS_OS2) && defined(PYCC_GCC) if ((p = getpwuid(0)) != NULL) { #elif !defined(AMITCP) && !defined(INET225) setpwent(); while ((p = getpwent()) != NULL) { PyObject *v = mkpwent(p); if (v == NULL || PyList_Append(d, v) != 0) { Py_XDECREF(v); Py_DECREF(d); return NULL; } Py_DECREF(v); } return d; #else #ifdef AMITCP setpwent(); #else setpwent(1); /* INET225 wants argument XXX correct? - I.J. */ #endif while ((p = getpwent()) != NULL) { PyObject *v = mkpwent(p); if (v == NULL || PyList_Append(d, v) != 0) { Py_XDECREF(v); Py_DECREF(d); endpwent(); return NULL; } Py_DECREF(v); } endpwent(); return d; #endif /* AMITCP or INET225 */ } #endif static PyMethodDef pwd_methods[] = { {"getpwuid", pwd_getpwuid, METH_VARARGS, pwd_getpwuid__doc__}, {"getpwnam", pwd_getpwnam, METH_VARARGS, pwd_getpwnam__doc__}, #ifdef HAVE_GETPWENT {"getpwall", (PyCFunction)pwd_getpwall, METH_NOARGS, pwd_getpwall__doc__}, #endif {NULL, NULL} /* sentinel */ }; PyMODINIT_FUNC initpwd(void) { PyObject *m; m = Py_InitModule3("pwd", pwd_methods, pwd__doc__); PyStructSequence_InitType(&StructPwdType, &struct_pwd_type_desc); Py_INCREF((PyObject *) &StructPwdType); PyModule_AddObject(m, "struct_pwent", (PyObject *) &StructPwdType); }
static int convertTo_QList_0111QTouchDevice(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj) { QList<const QTouchDevice*> **sipCppPtr = reinterpret_cast<QList<const QTouchDevice*> **>(sipCppPtrV); #line 175 "sip/QtCore/qpycore_qlist.sip" PyObject *iter = PyObject_GetIter(sipPy); if (!sipIsErr) { Py_XDECREF(iter); return (iter #if PY_MAJOR_VERSION < 3 && !PyString_Check(sipPy) #endif && !PyUnicode_Check(sipPy)); } if (!iter) { *sipIsErr = 1; return 0; } QList<const QTouchDevice *> *ql = new QList<const QTouchDevice *>; for (SIP_SSIZE_T i = 0; ; ++i) { PyErr_Clear(); PyObject *itm = PyIter_Next(iter); if (!itm) { if (PyErr_Occurred()) { delete ql; Py_DECREF(iter); *sipIsErr = 1; return 0; } break; } const QTouchDevice *t = reinterpret_cast<const QTouchDevice *>( sipForceConvertToType(itm, sipType_QTouchDevice, sipTransferObj, 0, 0, sipIsErr)); if (*sipIsErr) { PyErr_Format(PyExc_TypeError, "index " SIP_SSIZE_T_FORMAT " has type '%s' but 'const QTouchDevice' is expected", i, Py_TYPE(itm)->tp_name); Py_DECREF(itm); delete ql; Py_DECREF(iter); return 0; } ql->append(t); Py_DECREF(itm); } Py_DECREF(iter); *sipCppPtr = ql; return sipGetState(sipTransferObj); #line 140 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQList0111QTouchDevice.cpp" }
/* Opens a connection to the LDAP server. Initializes LDAP structure. If TLS is true, starts TLS session. */ static int connecting(LDAPConnection *self) { int rc = -1; int tls_option = -1; char *binddn = NULL; char *pswstr = NULL; char *mech = NULL; char *authzid = ""; char *realm = NULL; char *authcid = NULL; PyObject *url = NULL; PyObject *tls = NULL; PyObject *tmp = NULL; PyObject *creds = NULL; url = PyObject_GetAttrString(self->client, "_LDAPClient__url"); if (url == NULL) return -1; tmp = PyObject_GetAttrString(self->client, "_LDAPClient__cert_policy"); tls_option = (int)PyLong_AsLong(tmp); Py_DECREF(tmp); rc = _LDAP_initialization(&(self->ld), url, tls_option); Py_DECREF(url); if (rc != LDAP_SUCCESS) { PyObject *ldaperror = get_error_by_code(rc); PyErr_SetString(ldaperror, ldap_err2string(rc)); Py_DECREF(ldaperror); return -1; } tls = PyObject_GetAttrString(self->client, "_LDAPClient__tls"); if (tls == NULL) return -1; /* Start TLS, if it necessary. */ if (PyObject_IsTrue(tls)) { #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) rc = ldap_start_tls_sA(self->ld, NULL, NULL, NULL, NULL); #else rc = ldap_start_tls_s(self->ld, NULL, NULL); #endif if (rc != LDAP_SUCCESS) { //TODO Proper errors PyObject *ldaperror = get_error_by_code(rc); PyErr_SetString(ldaperror, ldap_err2string(rc)); Py_DECREF(ldaperror); Py_DECREF(tls); return -1; } } Py_DECREF(tls); creds = PyObject_GetAttrString(self->client, "_LDAPClient__credentials"); if (creds == NULL) return -1; tmp = PyObject_GetAttrString(self->client, "_LDAPClient__mechanism"); if (tmp == NULL) return -1; mech = PyObject2char(tmp); Py_XDECREF(tmp); /* Get credential information, if it's given. */ if (PyTuple_Check(creds) && PyTuple_Size(creds) > 1) { if (strcmp(mech, "SIMPLE") == 0) { tmp = PyTuple_GetItem(creds, 0); binddn = PyObject2char(tmp); } else { tmp = PyTuple_GetItem(creds, 0); authcid = PyObject2char(tmp); tmp = PyDict_GetItemString(creds, "realm"); realm = PyObject2char(tmp); } tmp = PyTuple_GetItem(creds, 1); pswstr = PyObject2char(tmp); } if (authzid == NULL) authzid = ""; rc = _LDAP_bind_s(self->ld, mech, binddn, pswstr, authcid, realm, authzid); free(mech); free(binddn); free(pswstr); free(authcid); free(realm); if (strcmp(authzid, "") != 0) free(authzid); if (rc != LDAP_SUCCESS) { PyObject *ldaperror = get_error_by_code(rc); PyErr_SetString(ldaperror, ldap_err2string(rc)); Py_DECREF(ldaperror); Py_DECREF(creds); return -1; } Py_DECREF(creds); return 0; }
static PySTEntryObject * ste_new(struct symtable *st, identifier name, _Py_block_ty block, void *key, int lineno) { PySTEntryObject *ste = NULL; PyObject *k; k = PyLong_FromVoidPtr(key); if (k == NULL) goto fail; ste = PyObject_New(PySTEntryObject, &PySTEntry_Type); if (ste == NULL) goto fail; ste->ste_table = st; ste->ste_id = k; ste->ste_tmpname = 0; ste->ste_name = name; Py_INCREF(name); ste->ste_symbols = NULL; ste->ste_varnames = NULL; ste->ste_children = NULL; ste->ste_symbols = PyDict_New(); if (ste->ste_symbols == NULL) goto fail; ste->ste_varnames = PyList_New(0); if (ste->ste_varnames == NULL) goto fail; ste->ste_children = PyList_New(0); if (ste->ste_children == NULL) goto fail; ste->ste_type = block; ste->ste_unoptimized = 0; ste->ste_nested = 0; ste->ste_free = 0; ste->ste_varargs = 0; ste->ste_varkeywords = 0; ste->ste_opt_lineno = 0; ste->ste_tmpname = 0; ste->ste_lineno = lineno; if (st->st_cur != NULL && (st->st_cur->ste_nested || st->st_cur->ste_type == FunctionBlock)) ste->ste_nested = 1; ste->ste_child_free = 0; ste->ste_generator = 0; ste->ste_blockstack = 0; ste->ste_returns_value = 0; if (PyDict_SetItem(st->st_symbols, ste->ste_id, (PyObject *)ste) < 0) goto fail; return ste; fail: Py_XDECREF(ste); return NULL; }
static PyObject* PyMangleMask_polyid_and_weight(struct PyMangleMask* self, PyObject* args) { int status=1; struct Point pt; PyObject* ra_obj=NULL; PyObject* dec_obj=NULL; PyObject* poly_id_obj=NULL; PyObject* weight_obj=NULL; double* ra_ptr=NULL; double* dec_ptr=NULL; double* weight_ptr=NULL; npy_intp* poly_id_ptr=NULL; npy_intp nra=0, ndec=0, i=0; PyObject* tuple=NULL; if (!PyArg_ParseTuple(args, (char*)"OO", &ra_obj, &dec_obj)) { return NULL; } if (!check_ra_dec_arrays(ra_obj,dec_obj,&ra_ptr,&nra,&dec_ptr,&ndec)) { return NULL; } if (!(poly_id_obj=make_intp_array(nra, "polyid", &poly_id_ptr))) { status=0; goto _poly_id_and_weight_cleanup; } if (!(weight_obj=make_double_array(nra, "weight", &weight_ptr))) { status=0; goto _poly_id_and_weight_cleanup; } for (i=0; i<nra; i++) { point_set_from_radec(&pt, *ra_ptr, *dec_ptr); if (self->pixelres == -1) { status=polyid_and_weight(self, &pt, poly_id_ptr, weight_ptr); } else { status=polyid_and_weight_pixelized(self, &pt, poly_id_ptr, weight_ptr); } if (status != 1) { goto _poly_id_and_weight_cleanup; } ra_ptr++; dec_ptr++; poly_id_ptr++; weight_ptr++; } _poly_id_and_weight_cleanup: if (status != 1) { Py_XDECREF(poly_id_obj); Py_XDECREF(weight_obj); Py_XDECREF(tuple); return NULL; } tuple=PyTuple_New(2); PyTuple_SetItem(tuple, 0, poly_id_obj); PyTuple_SetItem(tuple, 1, weight_obj); return tuple; }
static PyObject* PyMangleMask_genrand(struct PyMangleMask* self, PyObject* args) { int status=1; PY_LONG_LONG nrand=0; struct Point pt; PyObject* ra_obj=NULL; PyObject* dec_obj=NULL; PyObject* tuple=NULL; double* ra_ptr=NULL; double* dec_ptr=NULL; double weight=0; npy_intp poly_id=0; npy_intp ngood=0; double theta=0, phi=0; if (!PyArg_ParseTuple(args, (char*)"L", &nrand)) { return NULL; } if (nrand <= 0) { PyErr_Format(PyExc_ValueError, "nrand should be > 0, got (%ld)",(npy_intp)nrand); status=0; goto _genrand_cleanup; } if (!(ra_obj=make_double_array(nrand, "ra", &ra_ptr))) { status=0; goto _genrand_cleanup; } if (!(dec_obj=make_double_array(nrand, "dec", &dec_ptr))) { status=0; goto _genrand_cleanup; } seed_random(); while (ngood < nrand) { genrand_theta_phi_allsky(&theta, &phi); point_set_from_thetaphi(&pt, theta, phi); if (self->pixelres == -1) { status=polyid_and_weight(self, &pt, &poly_id, &weight); } else { status=polyid_and_weight_pixelized(self, &pt, &poly_id, &weight); } if (status != 1) { goto _genrand_cleanup; } if (poly_id >= 0) { // rely on short circuiting if (weight < 1.0 || drand48() < weight) { ngood++; radec_from_point(&pt, ra_ptr, dec_ptr); ra_ptr++; dec_ptr++; } } } _genrand_cleanup: if (status != 1) { Py_XDECREF(ra_obj); Py_XDECREF(dec_obj); Py_XDECREF(tuple); return NULL; } tuple=PyTuple_New(2); PyTuple_SetItem(tuple, 0, ra_obj); PyTuple_SetItem(tuple, 1, dec_obj); return tuple; }
static PyObject *Py_FindObjects(PyObject *obj, PyObject *args) { PyArrayObject *input = NULL; PyObject *result = NULL, *tuple = NULL, *start = NULL, *end = NULL; PyObject *slc = NULL; int jj; npy_intp max_label; npy_intp ii, *regions = NULL; if (!PyArg_ParseTuple(args, "O&n", NI_ObjectToInputArray, &input, &max_label)) goto exit; if (max_label < 0) max_label = 0; if (max_label > 0) { if (PyArray_NDIM(input) > 0) { regions = (npy_intp*)malloc(2 * max_label * PyArray_NDIM(input) * sizeof(npy_intp)); } else { regions = (npy_intp*)malloc(max_label * sizeof(npy_intp)); } if (!regions) { PyErr_NoMemory(); goto exit; } } if (!NI_FindObjects(input, max_label, regions)) goto exit; result = PyList_New(max_label); if (!result) { PyErr_NoMemory(); goto exit; } for(ii = 0; ii < max_label; ii++) { npy_intp idx = PyArray_NDIM(input) > 0 ? 2 * PyArray_NDIM(input) * ii : ii; if (regions[idx] >= 0) { PyObject *tuple = PyTuple_New(PyArray_NDIM(input)); if (!tuple) { PyErr_NoMemory(); goto exit; } for(jj = 0; jj < PyArray_NDIM(input); jj++) { start = PyLong_FromSsize_t(regions[idx + jj]); end = PyLong_FromSsize_t(regions[idx + jj + PyArray_NDIM(input)]); if (!start || !end) { PyErr_NoMemory(); goto exit; } slc = PySlice_New(start, end, NULL); if (!slc) { PyErr_NoMemory(); goto exit; } Py_XDECREF(start); Py_XDECREF(end); start = end = NULL; PyTuple_SetItem(tuple, jj, slc); slc = NULL; } PyList_SetItem(result, ii, tuple); tuple = NULL; } else { Py_INCREF(Py_None); PyList_SetItem(result, ii, Py_None); } } Py_INCREF(result); exit: Py_XDECREF(input); Py_XDECREF(result); Py_XDECREF(tuple); Py_XDECREF(start); Py_XDECREF(end); Py_XDECREF(slc); free(regions); if (PyErr_Occurred()) { Py_XDECREF(result); return NULL; } else { return result; } }
//------------------------------------------------------------------------- //<code(py_idp)> //------------------------------------------------------------------------- int idaapi IDP_Callback(void *ud, int notification_code, va_list va) { // This hook gets called from the kernel. Ensure we hold the GIL. PYW_GIL_GET; IDP_Hooks *proxy = (IDP_Hooks *)ud; int ret = 0; try { switch ( notification_code ) { case processor_t::custom_ana: ret = proxy->custom_ana() ? 1 + cmd.size : 0; break; case processor_t::custom_out: ret = proxy->custom_out() ? 2 : 0; break; case processor_t::custom_emu: ret = proxy->custom_emu() ? 2 : 0; break; case processor_t::custom_outop: { op_t *op = va_arg(va, op_t *); ref_t py_obj(create_idaapi_linked_class_instance(S_PY_OP_T_CLSNAME, op)); if ( py_obj == NULL ) break; ret = proxy->custom_outop(py_obj.o) ? 2 : 0; break; } case processor_t::custom_mnem: { PYW_GIL_CHECK_LOCKED_SCOPE(); PyObject *py_ret = proxy->custom_mnem(); if ( py_ret != NULL && PyString_Check(py_ret) ) { char *outbuffer = va_arg(va, char *); size_t bufsize = va_arg(va, size_t); qstrncpy(outbuffer, PyString_AS_STRING(py_ret), bufsize); ret = 2; } else { ret = 0; } Py_XDECREF(py_ret); break; } case processor_t::is_sane_insn: { int no_crefs = va_arg(va, int); ret = proxy->is_sane_insn(no_crefs); break; } case processor_t::may_be_func: { int state = va_arg(va, int); ret = proxy->may_be_func(state); break; } case processor_t::closebase: { proxy->closebase(); break; } case processor_t::savebase: { proxy->savebase(); break; } case processor_t::auto_empty_finally: { proxy->auto_empty_finally(); break; } case processor_t::rename: { ea_t ea = va_arg(va, ea_t); const char *new_name = va_arg(va, const char *); ret = proxy->rename(ea, new_name); break; } case processor_t::renamed: { ea_t ea = va_arg(va, ea_t); const char *new_name = va_arg(va, const char *); bool local_name = va_argi(va, bool); proxy->renamed(ea, new_name, local_name); break; } case processor_t::undefine: { ea_t ea = va_arg(va, ea_t); ret = proxy->undefine(ea); break; } case processor_t::make_code: { ea_t ea = va_arg(va, ea_t); asize_t size = va_arg(va, asize_t); ret = proxy->make_code(ea, size); break; } case processor_t::make_data: { ea_t ea = va_arg(va, ea_t); flags_t flags = va_arg(va, flags_t); tid_t tid = va_arg(va, tid_t); asize_t len = va_arg(va, asize_t); ret = proxy->make_data(ea, flags, tid, len); break; } case processor_t::load_idasgn: { const char *short_sig_name = va_arg(va, const char *); proxy->load_idasgn(short_sig_name); break; } case processor_t::auto_empty: { proxy->auto_empty(); break; } case processor_t::auto_queue_empty: { atype_t type = va_arg(va, atype_t); ret = proxy->auto_queue_empty(type); break; } case processor_t::add_func: { func_t *func = va_arg(va, func_t *); proxy->add_func(func); break; } case processor_t::del_func: { func_t *func = va_arg(va, func_t *); ret = proxy->del_func(func); break; } case processor_t::is_call_insn: { ea_t ea = va_arg(va, ea_t); ret = proxy->is_call_insn(ea); break; } case processor_t::is_ret_insn: { ea_t ea = va_arg(va, ea_t); bool strict = va_argi(va, bool); ret = proxy->is_ret_insn(ea, strict); break; } case processor_t::assemble: { ea_t ea = va_arg(va, ea_t); ea_t cs = va_arg(va, ea_t); ea_t ip = va_arg(va, ea_t); bool use32 = va_argi(va, bool); const char *line = va_arg(va, const char *); // Extract user buffer (we hardcode the MAXSTR size limit) uchar *bin = va_arg(va, uchar *); // Call python PYW_GIL_CHECK_LOCKED_SCOPE(); PyObject *py_buffer = proxy->assemble(ea, cs, ip, use32, line); if ( py_buffer != NULL && PyString_Check(py_buffer) ) { char *s; Py_ssize_t len; if ( PyString_AsStringAndSize(py_buffer, &s, &len) != -1 ) { if ( len > MAXSTR ) len = MAXSTR; memcpy(bin, s, len); ret = len; } } // ret = 0 otherwise Py_XDECREF(py_buffer); break; } // validate_flirt_func, // flirt has recognized a library function // // this callback can be used by a plugin or proc module // // to intercept it and validate such a function // // args: ea_t start_ea // // const char *funcname // // returns: -1-do not create a function, // // 1-function is validated // // the idp module is allowed to modify 'cmd' // set_func_start, // Function chunk start address will be changed // // args: func_t *pfn // // ea_t new_start // // Returns: 1-ok,<=0-do not change // set_func_end, // Function chunk end address will be changed // // args: func_t *pfn // // ea_t new_end // // Returns: 1-ok,<=0-do not change // outlabel, // The kernel is going to generate an instruction // // label line or a function header // // args: // // ea_t ea - // // const char *colored_name - // // If returns value <=0, then the kernel should // // not generate the label // may_show_sreg, // The kernel wants to display the segment registers // // in the messages window. // // arg - ea_t current_ea // // if this function returns 0 // // then the kernel will not show // // the segment registers. // // (assuming that the module have done it) // coagulate, // Try to define some unexplored bytes // // This notification will be called if the // // kernel tried all possibilities and could // // not find anything more useful than to // // convert to array of bytes. // // The module can help the kernel and convert // // the bytes into something more useful. // // arg: // // ea_t start_ea // // returns: number of converted bytes + 1 // auto_empty, // Info: all analysis queues are empty // // args: none // // returns: none // // This callback is called once when the // // initial analysis is finished. If the queue is // // not empty upon the return from this callback, // // it will be called later again. // // See also auto_empty_finally. // auto_queue_empty, // One analysis queue is empty // // args: atype_t type // // returns: 1-yes, keep the queue empty // // <=0-no, the queue is not empty anymore // // This callback can be called many times, so // // only the autoMark() functions can be used from it // // (other functions may work but it is not tested) // func_bounds, // find_func_bounds() finished its work // // The module may fine tune the function bounds // // args: int *possible_return_code // // func_t *pfn // // ea_t max_func_end_ea (from the kernel's point of view) // // returns: none // is_jump_func, // is the function a trivial "jump" function? // // args: func_t *pfn // // ea_t *jump_target // // ea_t *func_pointer // // returns: 0-no, 1-don't know, 2-yes, see jump_target // // and func_pointer // gen_regvar_def, // generate register variable definition line // // args: regvar_t *v // // returns: 0-ok // setsgr, // The kernel has changed a segment register value // // args: ea_t startEA // // ea_t endEA // // int regnum // // sel_t value // // sel_t old_value // // uchar tag (SR_... values) // // returns: 1-ok, 0-error // set_compiler, // The kernel has changed the compiler information // // (inf.cc structure) // is_basic_block_end, // Is the current instruction end of a basic block? // // This function should be defined for processors // // with delayed jump slots. The current instruction // // is stored in 'cmd' // // args: bool call_insn_stops_block // // returns: 1-unknown, 0-no, 2-yes // reglink, // IBM PC only, ignore it // get_vxd_name, // IBM PC only, ignore it // // Get Vxd function name // // args: int vxdnum // // int funcnum // // char *outbuf // // returns: nothing // // // moving_segm, // May the kernel move the segment? // // args: segment_t - segment to move // // ea_t to - new segment start address // // returns: 1-yes, <=0-the kernel should stop // move_segm, // A segment is moved // // Fix processor dependent address sensitive information // // args: ea_t from - old segment address // // segment_t* - moved segment // // returns: nothing // // // get_stkvar_scale_factor,// Should stack variable references be multiplied by // // a coefficient before being used in the stack frame? // // Currently used by TMS320C55 because the references into // // the stack should be multiplied by 2 // // Returns: scaling factor // // Note: PR_SCALE_STKVARS should be set to use this callback // // create_flat_group, // Create special segment representing the flat group // // (to use for PC mainly) // // args - ea_t image_base, int bitness, sel_t dataseg_sel // // kernel_config_loaded, // This callback is called when ida.cfg is parsed // // args - none, returns - nothing // // might_change_sp, // Does the instruction at 'ea' modify the stack pointer? // // args: ea_t ea // // returns: 1-yes, 0-false // // (not used yet) // // is_alloca_probe, // Does the function at 'ea' behave as __alloca_probe? // // args: ea_t ea // // returns: 2-yes, 1-false // // out_3byte, // Generate text representation of 3byte data // // init_out_buffer() is called before this function // // and all Out... function can be used. // // uFlag contains the flags. // // This callback might be implemented by the processor // // module to generate custom representation of 3byte data. // // args: // // ea_t dataea - address of the data item // // uint32 value - value to output // // bool analyze_only - only create xrefs if necessary // // do not generate text representation // // returns: 2-yes, 1-false // // get_reg_name, // Generate text representation of a register // // int reg - internal register number as defined in the processor module // // size_t width - register width in bytes // // char *buf - output buffer // // size_t bufsize - size of output buffer // // int reghi - if not -1 then this function will return the register pair // // returns: -1 if error, strlen(buf)+2 otherwise // // Most processor modules do not need to implement this callback // // It is useful only if ph.regNames[reg] does not provide // // the correct register names // // save its local data // out_src_file_lnnum, // Callback: generate analog of // // #line "file.c" 123 // // directive. // // const char *file - source file (may be NULL) // // size_t lnnum - line number // // returns: 2-directive has been generated // get_autocmt, // Callback: get dynamic auto comment // // Will be called if the autocomments are enabled // // and the comment retrieved from ida.int starts with // // '$!'. 'cmd' is contains valid info. // // char *buf - output buffer // // size_t bufsize - output buffer size // // returns: 2-new comment has been generated // // 1-callback has not been handled // // the buffer must not be changed in this case // is_insn_table_jump, // Callback: determine if instruction is a table jump or call // // If CF_JUMP bit can not describe all kinds of table // // jumps, please define this callback. // // It will be called for insns with CF_JUMP bit set. // // input: cmd structure contains the current instruction // // returns: 1-yes, 0-no // auto_empty_finally, // Info: all analysis queues are empty definitively // // args: none // // returns: none // // This callback is called only once. // // See also auto_empty. // loader_finished, // Event: external file loader finished its work // // linput_t *li // // uint16 neflags // // const char *filetypename // // Use this event to augment the existing loader functionality // loader_elf_machine, // Event: ELF loader machine type checkpoint // // linput_t *li // // int machine_type // // const char **p_procname // // proc_def **p_pd (see ldr\elf.h) // // set_elf_reloc_t *set_reloc // // A plugin check the machine_type. If it is the desired one, // // the the plugin fills p_procname with the processor name. // // p_pd is used to handle relocations, otherwise can be left untouched // // set_reloc can be later used by the plugin to specify relocations // // returns: e_machine value (if it is different from the // // original e_machine value, procname and p_pd will be ignored // // and the new value will be used) // // This event occurs for each loaded ELF file // is_indirect_jump, // Callback: determine if instruction is an indrect jump // // If CF_JUMP bit can not describe all jump types // // jumps, please define this callback. // // input: cmd structure contains the current instruction // // returns: 1-use CF_JUMP, 2-no, 3-yes // verify_noreturn, // The kernel wants to set 'noreturn' flags for a function // // func_t *pfn // // Returns: 1-ok, any other value-do not set 'noreturn' flag // verify_sp, // All function instructions have been analyzed // // Now the processor module can analyze the stack pointer // // for the whole function // // input: func_t *pfn // // Returns: 1-ok, 0-bad stack pointer // treat_hindering_item, // An item hinders creation of another item // // args: ea_t hindering_item_ea // // flags_t new_item_flags (0 for code) // // ea_t new_item_ea // // asize_t new_item_length // // Returns: 1-no reaction, <=0-the kernel may delete the hindering item // str2reg, // Convert a register name to a register number // // args: const char *regname // // Returns: register number + 2 // // The register number is the register index in the regNames array // // Most processor modules do not need to implement this callback // // It is useful only if ph.regNames[reg] does not provide // // the correct register names // create_switch_xrefs, // Create xrefs for a custom jump table // // in: ea_t jumpea; - address of the jump insn // // switch_info_ex_t *; - switch information // // returns: must return 2 // calc_switch_cases, // Calculate case values and targets for a custom jump table // // in: ea_t insn_ea - address of the 'indirect jump' instruction // // switch_info_ex_t *si - switch information // // casevec_t *casevec - vector of case values... // // evec_t *targets - ...and corresponding target addresses // // casevec and targets may be NULL // // returns: 2-ok, 1-failed // determined_main, // The main() function has been determined // // in: ea_t main - address of the main() function // // returns: none // preprocess_chart, // gui has retrieved a function flow chart // // in: qflow_chart_t *fc // // returns: none // // Plugins may modify the flow chart in this callback // get_bg_color, // Get item background color // // in: ea_t ea, bgcolor_t *color // // Returns: 1-not implemented, 2-color set // // Plugins can hook this callback to color disassembly lines // // dynamically // get_operand_string, // Request text string for operand (cli, java, ...) // // args: int opnum // // char *buf // // size_t buflen // // (cmd structure must contain info for the desired insn) // // opnum is the operand number; -1 means any string operand // // returns: 1 - no string (or empty string) // // >1 - original string length with terminating zero // // // the following 5 events are very low level // // take care of possible recursion // add_cref, // a code reference is being created // // args: ea_t from, ea_t to, cref_t type // // returns: <0 - cancel cref creation // add_dref, // a data reference is being created // // args: ea_t from, ea_t to, dref_t type // // returns: <0 - cancel dref creation // del_cref, // a code reference is being deleted // // args: ea_t from, ea_t to, bool expand // // returns: <0 - cancel cref deletion // del_dref, // a data reference is being deleted // // args: ea_t from, ea_t to // // returns: <0 - cancel dref deletion // coagulate_dref, // data reference is being analyzed // // args: ea_t from, ea_t to, bool may_define, ea_t *code_ea // // plugin may correct code_ea (e.g. for thumb mode refs, we clear the last bit) // // returns: <0 - cancel dref analysis // custom_fixup, // mutipurpose notification for FIXUP_CUSTOM // // args: cust_fix oper, ea_t ea, const fixup_data_t*, ... (see cust_fix) // // returns: 1 - no accepted (fixup ignored by ida) // // >1 - accepted (see cust_fix) // off_preproc, // called from get_offset_expr, when refinfo_t // // contain flag REFINFO_PREPROC. Normally this // // notification used in a combination with custom_fixup // // args: ea_t ea, int numop, ea_t* opval, const refinfo_t* ri, // // char* buf, size_t bufsize, ea_t* target, // // ea_t* fullvalue, ea_t from, int getn_flags // // returns: 2 - buf filled as simple expression // // 3 - buf filled as complex expression // // 4 - apply standard processing (with - possible - changed values) // // others - can't convert to offset expression // // set_proc_options, // called if the user specified an option string in the command line: // // -p<processor name>:<options> // // can be used for e.g. setting a processor subtype // // also called if option string is passed to set_processor_type() // // and IDC's SetProcessorType() // // args: const char * options // // returns: <0 - bad option string // }
static PyObject *Py_GeometricTransform(PyObject *obj, PyObject *args) { PyArrayObject *input = NULL, *output = NULL; PyArrayObject *coordinates = NULL, *matrix = NULL, *shift = NULL; PyObject *fnc = NULL, *extra_arguments = NULL, *extra_keywords = NULL; int mode, order; double cval; void *func = NULL, *data = NULL; NI_PythonCallbackData cbdata; ccallback_t callback; static ccallback_signature_t callback_signatures[] = { {"int (intptr_t *, double *, int, int, void *)"}, {"int (npy_intp *, double *, int, int, void *)"}, #if NPY_SIZEOF_INTP == NPY_SIZEOF_SHORT {"int (short *, double *, int, int, void *)"}, #endif #if NPY_SIZEOF_INTP == NPY_SIZEOF_INT {"int (int *, double *, int, int, void *)"}, #endif #if NPY_SIZEOF_INTP == NPY_SIZEOF_LONG {"int (long *, double *, int, int, void *)"}, #endif #if NPY_SIZEOF_INTP == NPY_SIZEOF_LONGLONG {"int (long long *, double *, int, int, void *)"}, #endif {NULL} }; callback.py_function = NULL; callback.c_function = NULL; if (!PyArg_ParseTuple(args, "O&OO&O&O&O&iidOO", NI_ObjectToInputArray, &input, &fnc, NI_ObjectToOptionalInputArray, &coordinates, NI_ObjectToOptionalInputArray, &matrix, NI_ObjectToOptionalInputArray, &shift, NI_ObjectToOutputArray, &output, &order, &mode, &cval, &extra_arguments, &extra_keywords)) goto exit; if (fnc != Py_None) { if (!PyTuple_Check(extra_arguments)) { PyErr_SetString(PyExc_RuntimeError, "extra_arguments must be a tuple"); goto exit; } if (!PyDict_Check(extra_keywords)) { PyErr_SetString(PyExc_RuntimeError, "extra_keywords must be a dictionary"); goto exit; } if (PyCapsule_CheckExact(fnc) && PyCapsule_GetName(fnc) == NULL) { func = PyCapsule_GetPointer(fnc, NULL); data = PyCapsule_GetContext(fnc); #if PY_VERSION_HEX < 0x03000000 } else if (PyCObject_Check(fnc)) { /* 'Legacy' low-level callable on Py2 */ func = PyCObject_AsVoidPtr(fnc); data = PyCObject_GetDesc(fnc); #endif } else { int ret; ret = ccallback_prepare(&callback, callback_signatures, fnc, CCALLBACK_DEFAULTS); if (ret == -1) { goto exit; } if (callback.py_function != NULL) { cbdata.extra_arguments = extra_arguments; cbdata.extra_keywords = extra_keywords; callback.info_p = (void*)&cbdata; func = Py_Map; data = (void*)&callback; } else { func = callback.c_function; data = callback.user_data; } } } NI_GeometricTransform(input, func, data, matrix, shift, coordinates, output, order, (NI_ExtendMode)mode, cval); #ifdef HAVE_WRITEBACKIFCOPY PyArray_ResolveWritebackIfCopy(output); #endif exit: if (callback.py_function != NULL || callback.c_function != NULL) { ccallback_release(&callback); } Py_XDECREF(input); Py_XDECREF(output); Py_XDECREF(coordinates); Py_XDECREF(matrix); Py_XDECREF(shift); return PyErr_Occurred() ? NULL : Py_BuildValue(""); }
static PyObject *Py_GenericFilter(PyObject *obj, PyObject *args) { PyArrayObject *input = NULL, *output = NULL, *footprint = NULL; PyObject *fnc = NULL, *extra_arguments = NULL, *extra_keywords = NULL; void *func = NULL, *data = NULL; NI_PythonCallbackData cbdata; int mode; PyArray_Dims origin = {NULL, 0}; double cval; ccallback_t callback; static ccallback_signature_t callback_signatures[] = { {"int (double *, intptr_t, double *, void *)"}, {"int (double *, npy_intp, double *, void *)"}, #if NPY_SIZEOF_INTP == NPY_SIZEOF_SHORT {"int (double *, short, double *, void *)"}, #endif #if NPY_SIZEOF_INTP == NPY_SIZEOF_INT {"int (double *, int, double *, void *)"}, #endif #if NPY_SIZEOF_INTP == NPY_SIZEOF_LONG {"int (double *, long, double *, void *)"}, #endif #if NPY_SIZEOF_INTP == NPY_SIZEOF_LONGLONG {"int (double *, long long, double *, void *)"}, #endif {NULL} }; callback.py_function = NULL; callback.c_function = NULL; if (!PyArg_ParseTuple(args, "O&OO&O&idO&OO", NI_ObjectToInputArray, &input, &fnc, NI_ObjectToInputArray, &footprint, NI_ObjectToOutputArray, &output, &mode, &cval, PyArray_IntpConverter, &origin, &extra_arguments, &extra_keywords)) { goto exit; } if (!_validate_origin(input, origin)) { goto exit; } if (!PyTuple_Check(extra_arguments)) { PyErr_SetString(PyExc_RuntimeError, "extra_arguments must be a tuple"); goto exit; } if (!PyDict_Check(extra_keywords)) { PyErr_SetString(PyExc_RuntimeError, "extra_keywords must be a dictionary"); goto exit; } if (PyCapsule_CheckExact(fnc) && PyCapsule_GetName(fnc) == NULL) { func = PyCapsule_GetPointer(fnc, NULL); data = PyCapsule_GetContext(fnc); #if PY_VERSION_HEX < 0x03000000 } else if (PyCObject_Check(fnc)) { /* 'Legacy' low-level callable on Py2 */ func = PyCObject_AsVoidPtr(fnc); data = PyCObject_GetDesc(fnc); #endif } else { int ret; ret = ccallback_prepare(&callback, callback_signatures, fnc, CCALLBACK_DEFAULTS); if (ret == -1) { goto exit; } if (callback.py_function != NULL) { cbdata.extra_arguments = extra_arguments; cbdata.extra_keywords = extra_keywords; callback.info_p = (void*)&cbdata; func = Py_FilterFunc; data = (void*)&callback; } else { func = callback.c_function; data = callback.user_data; } } NI_GenericFilter(input, func, data, footprint, output, (NI_ExtendMode)mode, cval, origin.ptr); #ifdef HAVE_WRITEBACKIFCOPY PyArray_ResolveWritebackIfCopy(output); #endif exit: if (callback.py_function != NULL || callback.c_function != NULL) { ccallback_release(&callback); } Py_XDECREF(input); Py_XDECREF(output); Py_XDECREF(footprint); PyDimMem_FREE(origin.ptr); return PyErr_Occurred() ? NULL : Py_BuildValue(""); }
void run_script(PyObject *dict, const char *script, const char *locale) { PyObject *code = run_script_forcode(dict, script, locale); Py_XDECREF(code); }
static PyObject * subprocess_fork_exec(PyObject* self, PyObject *args) { PyObject *gc_module = NULL; PyObject *executable_list, *py_close_fds, *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, "OOOOOOiiiiiiiiiiO:fork_exec", &process_args, &executable_list, &py_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; close_fds = PyObject_IsTrue(py_close_fds); if (close_fds < 0) 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; gc_module = PyImport_ImportModule("gc"); if (gc_module == NULL) return NULL; result = PyObject_CallMethod(gc_module, "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_CallMethod(gc_module, "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 = PyString_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; }
bool obs_module_load() { blog(LOG_INFO, "obs_module_load"); //Need to init python here //load the swig Py_Initialize(); PyEval_InitThreads(); /*Must set arguments for guis to work*/ wchar_t* argv[] = { L"", NULL }; int argc = sizeof(argv) / sizeof(wchar_t*) - 1; //SWIG_init(); PySys_SetArgv(argc, argv); //need to add to directory PyRun_SimpleString("import os"); PyRun_SimpleString("import sys"); PyRun_SimpleString("os.environ['PYTHONUNBUFFERED'] = '1'"); PyRun_SimpleString("sys.stdout = open('/dev/shm/stdOut.txt','w',1)"); PyRun_SimpleString("sys.stderr = open('/dev/shm/stdErr.txt','w',1)"); PyRun_SimpleString("print(sys.version)"); /*Load a file*/ PyObject* pName, *pModule, *pFunc,*argList; pName = PyUnicode_FromString("source"); char script[] = "/scripts"; const char *data_path = obs_get_module_data_path(obs_current_module()); char *scripts_path = bzalloc(strlen(data_path)+strlen(script)); strcpy(scripts_path,data_path); strcat(scripts_path,script); //Add the path to env add_to_python_path(scripts_path); bfree(scripts_path); //PyImport_AppendInittab("_libobs", PyInit_libobs); /*Import libobs*/ //Py_XDECREF(main_module); //Add our custom stuff to libobs //import the script pModule = PyImport_Import(pName); pyHasError(); //get the function by name if(pModule != NULL) { PyObject *ns = PyModule_GetDict(pModule); Py_INCREF(ns); PyObject *py_libobs = PyImport_ImportModuleEx("obspython",ns,ns,NULL); Py_INCREF(py_libobs); extend_swig_libobs(py_libobs); PyModule_AddObject(pModule,"obspython",py_libobs); pFunc = PyObject_GetAttr(pModule, PyUnicode_FromString("register")); if(pFunc != NULL) { argList = Py_BuildValue("()"); PyObject_CallObject(pFunc,argList); pyHasError(); Py_XDECREF(pFunc); Py_XDECREF(argList); } Py_XDECREF(pModule); } Py_XDECREF(pName); //Not implemented yet? //obs_register_modal_ui(&myui); //Register this base class here obs_register_source(&python_source_info); //Release the thread gill PyThreadState* pts = PyGILState_GetThisThreadState(); PyEval_ReleaseThread(pts); return true; }
/* LDAP search function for internal use. Returns a Python list of LDAPEntries. The `basestr` is the base DN of the searching, `scope` is the search scope (BASE|ONELEVEL|SUB), `filterstr` is the LDAP search filter string, `attrs` is a null-terminated string list of attributes' names to get only the selected attributes. If `attrsonly` is 1 get only attributes' name without values. If `firstonly` is 1, get only the first LDAP entry of the messages. The `timeout` is an integer of seconds for timelimit, `sizelimit` is a limit for size. */ PyObject * LDAPConnection_Searching(LDAPConnection *self, PyObject *iterator) { int rc; int num_of_ctrls = 0; LDAPMessage *res, *entry; PyObject *entrylist = NULL; LDAPEntry *entryobj = NULL; LDAPControl *page_ctrl = NULL; LDAPControl *sort_ctrl = NULL; LDAPControl **server_ctrls = NULL; LDAPControl **returned_ctrls = NULL; LDAPSearchIter *search_iter = (LDAPSearchIter *)iterator; entrylist = PyList_New(0); if (entrylist == NULL) { return PyErr_NoMemory(); } /* Check the number of server controls and allocate it. */ if (self->page_size > 1) num_of_ctrls++; if (self->sort_list != NULL) num_of_ctrls++; if (num_of_ctrls > 0) { server_ctrls = (LDAPControl **)malloc(sizeof(LDAPControl *) * (num_of_ctrls + 1)); if (server_ctrls == NULL) return PyErr_NoMemory(); num_of_ctrls = 0; } if (self->page_size > 1) { /* Create page control and add to the server controls. */ rc = ldap_create_page_control(self->ld, (ber_int_t)(self->page_size), search_iter->cookie, 0, &page_ctrl); if (rc != LDAP_SUCCESS) { PyErr_BadInternalCall(); return NULL; } server_ctrls[num_of_ctrls++] = page_ctrl; server_ctrls[num_of_ctrls] = NULL; } if (self->sort_list != NULL) { rc = ldap_create_sort_control(self->ld, self->sort_list, 0, &sort_ctrl); if (rc != LDAP_SUCCESS) { PyErr_BadInternalCall(); return NULL; } server_ctrls[num_of_ctrls++] = sort_ctrl; server_ctrls[num_of_ctrls] = NULL; } rc = ldap_search_ext_s(self->ld, search_iter->base, search_iter->scope, search_iter->filter, search_iter->attrs, search_iter->attrsonly, server_ctrls, NULL, search_iter->timeout, search_iter->sizelimit, &res); if (rc == LDAP_NO_SUCH_OBJECT) { return entrylist; } if (rc != LDAP_SUCCESS && rc != LDAP_PARTIAL_RESULTS) { Py_DECREF(entrylist); PyObject *ldaperror = get_error_by_code(rc); PyErr_SetString(ldaperror, ldap_err2string(rc)); Py_DECREF(ldaperror); return NULL; } rc = ldap_parse_result(self->ld, res, NULL, NULL, NULL, NULL, &returned_ctrls, 0); #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) if (search_iter->cookie != NULL && search_iter->cookie->bv_val != NULL) { ber_bvfree(search_iter->cookie); search_iter->cookie = NULL; } rc = ldap_parse_page_control(self->ld, returned_ctrls, NULL, &(search_iter->cookie)); #else rc = ldap_parse_pageresponse_control(self->ld, ldap_control_find(LDAP_CONTROL_PAGEDRESULTS, returned_ctrls, NULL), NULL, search_iter->cookie); #endif /* Iterate over the response LDAP messages. */ for (entry = ldap_first_entry(self->ld, res); entry != NULL; entry = ldap_next_entry(self->ld, entry)) { entryobj = LDAPEntry_FromLDAPMessage(entry, self); if (entryobj == NULL) { Py_DECREF(entrylist); return NULL; } if ((entryobj == NULL) || (PyList_Append(entrylist, (PyObject *)entryobj)) != 0) { Py_XDECREF(entryobj); Py_DECREF(entrylist); return PyErr_NoMemory(); } Py_DECREF(entryobj); } /* Cleanup. */ if (returned_ctrls != NULL) ldap_controls_free(returned_ctrls); if (page_ctrl != NULL) ldap_control_free(page_ctrl); if (sort_ctrl != NULL) ldap_control_free(sort_ctrl); if (server_ctrls != NULL) free(server_ctrls); ldap_msgfree(res); return entrylist; }
/* * Extract a Python traceback from the given exception data. * * The exception error message is returned in xmsg, the traceback in * tbmsg (both as palloc'd strings) and the traceback depth in * tb_depth. * * We release refcounts on all the Python objects in the traceback stack, * but not on e or v. */ static void PLy_traceback(PyObject *e, PyObject *v, PyObject *tb, char **xmsg, char **tbmsg, int *tb_depth) { PyObject *e_type_o; PyObject *e_module_o; char *e_type_s = NULL; char *e_module_s = NULL; PyObject *vob = NULL; char *vstr; StringInfoData xstr; StringInfoData tbstr; /* * if no exception, return nulls */ if (e == NULL) { *xmsg = NULL; *tbmsg = NULL; *tb_depth = 0; return; } /* * Format the exception and its value and put it in xmsg. */ e_type_o = PyObject_GetAttrString(e, "__name__"); e_module_o = PyObject_GetAttrString(e, "__module__"); if (e_type_o) e_type_s = PyString_AsString(e_type_o); if (e_type_s) e_module_s = PyString_AsString(e_module_o); if (v && ((vob = PyObject_Str(v)) != NULL)) vstr = PyString_AsString(vob); else vstr = "unknown"; initStringInfo(&xstr); if (!e_type_s || !e_module_s) { if (PyString_Check(e)) /* deprecated string exceptions */ appendStringInfoString(&xstr, PyString_AsString(e)); else /* shouldn't happen */ appendStringInfoString(&xstr, "unrecognized exception"); } /* mimics behavior of traceback.format_exception_only */ else if (strcmp(e_module_s, "builtins") == 0 || strcmp(e_module_s, "__main__") == 0 || strcmp(e_module_s, "exceptions") == 0) appendStringInfo(&xstr, "%s", e_type_s); else appendStringInfo(&xstr, "%s.%s", e_module_s, e_type_s); appendStringInfo(&xstr, ": %s", vstr); *xmsg = xstr.data; /* * Now format the traceback and put it in tbmsg. */ *tb_depth = 0; initStringInfo(&tbstr); /* Mimick Python traceback reporting as close as possible. */ appendStringInfoString(&tbstr, "Traceback (most recent call last):"); while (tb != NULL && tb != Py_None) { PyObject *volatile tb_prev = NULL; PyObject *volatile frame = NULL; PyObject *volatile code = NULL; PyObject *volatile name = NULL; PyObject *volatile lineno = NULL; PyObject *volatile filename = NULL; PG_TRY(); { /* * Ancient versions of Python (circa 2.3) contain a bug whereby * the fetches below can fail if the error indicator is set. */ PyErr_Clear(); lineno = PyObject_GetAttrString(tb, "tb_lineno"); if (lineno == NULL) elog(ERROR, "could not get line number from Python traceback"); frame = PyObject_GetAttrString(tb, "tb_frame"); if (frame == NULL) elog(ERROR, "could not get frame from Python traceback"); code = PyObject_GetAttrString(frame, "f_code"); if (code == NULL) elog(ERROR, "could not get code object from Python frame"); name = PyObject_GetAttrString(code, "co_name"); if (name == NULL) elog(ERROR, "could not get function name from Python code object"); filename = PyObject_GetAttrString(code, "co_filename"); if (filename == NULL) elog(ERROR, "could not get file name from Python code object"); } PG_CATCH(); { Py_XDECREF(frame); Py_XDECREF(code); Py_XDECREF(name); Py_XDECREF(lineno); Py_XDECREF(filename); PG_RE_THROW(); } PG_END_TRY(); /* The first frame always points at <module>, skip it. */ if (*tb_depth > 0) { PLyExecutionContext *exec_ctx = PLy_current_execution_context(); char *proname; char *fname; char *line; char *plain_filename; long plain_lineno; /* * The second frame points at the internal function, but to mimick * Python error reporting we want to say <module>. */ if (*tb_depth == 1) fname = "<module>"; else fname = PyString_AsString(name); proname = PLy_procedure_name(exec_ctx->curr_proc); plain_filename = PyString_AsString(filename); plain_lineno = PyInt_AsLong(lineno); if (proname == NULL) appendStringInfo( &tbstr, "\n PL/Python anonymous code block, line %ld, in %s", plain_lineno - 1, fname); else appendStringInfo( &tbstr, "\n PL/Python function \"%s\", line %ld, in %s", proname, plain_lineno - 1, fname); /* * function code object was compiled with "<string>" as the * filename */ if (exec_ctx->curr_proc && plain_filename != NULL && strcmp(plain_filename, "<string>") == 0) { /* * If we know the current procedure, append the exact line * from the source, again mimicking Python's traceback.py * module behavior. We could store the already line-split * source to avoid splitting it every time, but producing a * traceback is not the most important scenario to optimize * for. But we do not go as far as traceback.py in reading * the source of imported modules. */ line = get_source_line(exec_ctx->curr_proc->src, plain_lineno); if (line) { appendStringInfo(&tbstr, "\n %s", line); pfree(line); } } } Py_DECREF(frame); Py_DECREF(code); Py_DECREF(name); Py_DECREF(lineno); Py_DECREF(filename); /* Release the current frame and go to the next one. */ tb_prev = tb; tb = PyObject_GetAttrString(tb, "tb_next"); Assert(tb_prev != Py_None); Py_DECREF(tb_prev); if (tb == NULL) elog(ERROR, "could not traverse Python traceback"); (*tb_depth)++; } /* Return the traceback. */ *tbmsg = tbstr.data; Py_XDECREF(e_type_o); Py_XDECREF(e_module_o); Py_XDECREF(vob); }
static void PyVar_Assign(PyObject **v, PyObject *e) { Py_XDECREF(*v); *v=e;}
/* * Emit a PG error or notice, together with any available info about * the current Python error, previously set by PLy_exception_set(). * This should be used to propagate Python errors into PG. If fmt is * NULL, the Python error becomes the primary error message, otherwise * it becomes the detail. If there is a Python traceback, it is put * in the context. */ void PLy_elog(int elevel, const char *fmt,...) { char *xmsg; char *tbmsg; int tb_depth; StringInfoData emsg; PyObject *exc, *val, *tb; const char *primary = NULL; int sqlerrcode = 0; char *detail = NULL; char *hint = NULL; char *query = NULL; int position = 0; PyErr_Fetch(&exc, &val, &tb); if (exc != NULL) { PyErr_NormalizeException(&exc, &val, &tb); if (PyErr_GivenExceptionMatches(val, PLy_exc_spi_error)) PLy_get_spi_error_data(val, &sqlerrcode, &detail, &hint, &query, &position); else if (PyErr_GivenExceptionMatches(val, PLy_exc_fatal)) elevel = FATAL; } /* this releases our refcount on tb! */ PLy_traceback(exc, val, tb, &xmsg, &tbmsg, &tb_depth); if (fmt) { initStringInfo(&emsg); for (;;) { va_list ap; int needed; va_start(ap, fmt); needed = appendStringInfoVA(&emsg, dgettext(TEXTDOMAIN, fmt), ap); va_end(ap); if (needed == 0) break; enlargeStringInfo(&emsg, needed); } primary = emsg.data; /* Since we have a format string, we cannot have a SPI detail. */ Assert(detail == NULL); /* If there's an exception message, it goes in the detail. */ if (xmsg) detail = xmsg; } else { if (xmsg) primary = xmsg; } PG_TRY(); { ereport(elevel, (errcode(sqlerrcode ? sqlerrcode : ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg_internal("%s", primary ? primary : "no exception data"), (detail) ? errdetail_internal("%s", detail) : 0, (tb_depth > 0 && tbmsg) ? errcontext("%s", tbmsg) : 0, (hint) ? errhint("%s", hint) : 0, (query) ? internalerrquery(query) : 0, (position) ? internalerrposition(position) : 0)); } PG_CATCH(); { if (fmt) pfree(emsg.data); if (xmsg) pfree(xmsg); if (tbmsg) pfree(tbmsg); Py_XDECREF(exc); Py_XDECREF(val); PG_RE_THROW(); } PG_END_TRY(); if (fmt) pfree(emsg.data); if (xmsg) pfree(xmsg); if (tbmsg) pfree(tbmsg); Py_XDECREF(exc); Py_XDECREF(val); }
static int analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free, PyObject *global) { PyObject *name, *v, *local = NULL, *scope = NULL, *newbound = NULL; PyObject *newglobal = NULL, *newfree = NULL; int i, success = 0; Py_ssize_t pos = 0; local = PyDict_New(); if (!local) goto error; scope = PyDict_New(); if (!scope) goto error; newglobal = PyDict_New(); if (!newglobal) goto error; newfree = PyDict_New(); if (!newfree) goto error; newbound = PyDict_New(); if (!newbound) goto error; if (ste->ste_type == ClassBlock) { /* make a copy of globals before calling analyze_name(), because global statements in the class have no effect on nested functions. */ if (PyDict_Update(newglobal, global) < 0) goto error; if (bound) if (PyDict_Update(newbound, bound) < 0) goto error; } assert(PySTEntry_Check(ste)); assert(PyDict_Check(ste->ste_symbols)); while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) { long flags = PyInt_AS_LONG(v); if (!analyze_name(ste, scope, name, flags, bound, local, free, global)) goto error; } if (ste->ste_type != ClassBlock) { if (ste->ste_type == FunctionBlock) { if (PyDict_Update(newbound, local) < 0) goto error; } if (bound) { if (PyDict_Update(newbound, bound) < 0) goto error; } if (PyDict_Update(newglobal, global) < 0) goto error; } /* Recursively call analyze_block() on each child block */ for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) { PyObject *c = PyList_GET_ITEM(ste->ste_children, i); PySTEntryObject* entry; assert(c && PySTEntry_Check(c)); entry = (PySTEntryObject*)c; if (!analyze_block(entry, newbound, newfree, newglobal)) goto error; if (entry->ste_free || entry->ste_child_free) ste->ste_child_free = 1; } if (ste->ste_type == FunctionBlock && !analyze_cells(scope, newfree)) goto error; if (!update_symbols(ste->ste_symbols, scope, bound, newfree, ste->ste_type == ClassBlock)) goto error; if (!check_unoptimized(ste)) goto error; if (PyDict_Update(free, newfree) < 0) goto error; success = 1; error: Py_XDECREF(local); Py_XDECREF(scope); Py_XDECREF(newbound); Py_XDECREF(newglobal); Py_XDECREF(newfree); if (!success) assert(PyErr_Occurred()); return success; }
static void pepy_import_dealloc(pepy_import *self) { Py_XDECREF(self->name); Py_XDECREF(self->sym); Py_XDECREF(self->addr); self->ob_type->tp_free((PyObject *) self); }
void setEncodingAndErrors() { // Adapted from pythonrun.c in CPython, with modifications for Pyston. char* p; char* icodeset = nullptr; char* codeset = nullptr; char* errors = nullptr; int free_codeset = 0; int overridden = 0; PyObject* sys_stream, *sys_isatty; char* saved_locale, *loc_codeset; if ((p = Py_GETENV("PYTHONIOENCODING")) && *p != '\0') { p = icodeset = codeset = strdup(p); free_codeset = 1; errors = strchr(p, ':'); if (errors) { *errors = '\0'; errors++; } overridden = 1; } #if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET) /* On Unix, set the file system encoding according to the user's preference, if the CODESET names a well-known Python codec, and Py_FileSystemDefaultEncoding isn't initialized by other means. Also set the encoding of stdin and stdout if these are terminals, unless overridden. */ if (!overridden || !Py_FileSystemDefaultEncoding) { saved_locale = strdup(setlocale(LC_CTYPE, NULL)); setlocale(LC_CTYPE, ""); loc_codeset = nl_langinfo(CODESET); if (loc_codeset && *loc_codeset) { PyObject* enc = PyCodec_Encoder(loc_codeset); if (enc) { loc_codeset = strdup(loc_codeset); Py_DECREF(enc); } else { if (PyErr_ExceptionMatches(PyExc_LookupError)) { PyErr_Clear(); loc_codeset = NULL; } else { PyErr_Print(); exit(1); } } } else loc_codeset = NULL; setlocale(LC_CTYPE, saved_locale); free(saved_locale); if (!overridden) { codeset = icodeset = loc_codeset; free_codeset = 1; } /* Initialize Py_FileSystemDefaultEncoding from locale even if PYTHONIOENCODING is set. */ if (!Py_FileSystemDefaultEncoding) { Py_FileSystemDefaultEncoding = loc_codeset; if (!overridden) free_codeset = 0; } } #endif #ifdef MS_WINDOWS if (!overridden) { icodeset = ibuf; codeset = buf; sprintf(ibuf, "cp%d", GetConsoleCP()); sprintf(buf, "cp%d", GetConsoleOutputCP()); } #endif if (codeset) { sys_stream = PySys_GetObject("stdin"); sys_isatty = PyObject_CallMethod(sys_stream, "isatty", ""); if (!sys_isatty) PyErr_Clear(); if ((overridden || (sys_isatty && PyObject_IsTrue(sys_isatty))) && PyFile_Check(sys_stream)) { if (!PyFile_SetEncodingAndErrors(sys_stream, icodeset, errors)) Py_FatalError("Cannot set codeset of stdin"); } Py_XDECREF(sys_isatty); sys_stream = PySys_GetObject("stdout"); sys_isatty = PyObject_CallMethod(sys_stream, "isatty", ""); if (!sys_isatty) PyErr_Clear(); if ((overridden || (sys_isatty && PyObject_IsTrue(sys_isatty))) && PyFile_Check(sys_stream)) { if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors)) Py_FatalError("Cannot set codeset of stdout"); } Py_XDECREF(sys_isatty); sys_stream = PySys_GetObject("stderr"); sys_isatty = PyObject_CallMethod(sys_stream, "isatty", ""); if (!sys_isatty) PyErr_Clear(); if ((overridden || (sys_isatty && PyObject_IsTrue(sys_isatty))) && PyFile_Check(sys_stream)) { if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors)) Py_FatalError("Cannot set codeset of stderr"); } Py_XDECREF(sys_isatty); if (free_codeset) free(codeset); } }
static void pepy_export_dealloc(pepy_export *self) { Py_XDECREF(self->mod); Py_XDECREF(self->func); Py_XDECREF(self->addr); self->ob_type->tp_free((PyObject *) self); }
static void run_interpreter(FILE *input, FILE *output) { PyThreadState *tstate; PyObject *new_stdin, *new_stdout; PyObject *mainmod, *globals; char buffer[1000]; char *p, *q; int n, end; PyEval_AcquireLock(); tstate = Py_NewInterpreter(); if (tstate == NULL) { fprintf(output, "Sorry -- can't create an interpreter\n"); return; } mainmod = PyImport_AddModule("__main__"); globals = PyModule_GetDict(mainmod); Py_INCREF(globals); new_stdin = PyFile_FromFile(input, "<socket-in>", "r", NULL); new_stdout = PyFile_FromFile(output, "<socket-out>", "w", NULL); PySys_SetObject("stdin", new_stdin); PySys_SetObject("stdout", new_stdout); PySys_SetObject("stderr", new_stdout); for (n = 1; !PyErr_Occurred(); n++) { Py_BEGIN_ALLOW_THREADS fprintf(output, "%d> ", n); p = fgets(buffer, sizeof buffer, input); Py_END_ALLOW_THREADS if (p == NULL) break; if (p[0] == '\377' && p[1] == '\354') break; q = strrchr(p, '\r'); if (q && q[1] == '\n' && q[2] == '\0') { *q++ = '\n'; *q++ = '\0'; } while (*p && isspace(*p)) p++; if (p[0] == '#' || p[0] == '\0') continue; end = run_command(buffer, globals); if (end < 0) PyErr_Print(); if (end) break; } Py_XDECREF(globals); Py_XDECREF(new_stdin); Py_XDECREF(new_stdout); Py_EndInterpreter(tstate); PyEval_ReleaseLock(); fprintf(output, "Goodbye!\n"); }
static void pepy_relocation_dealloc(pepy_relocation *self) { Py_XDECREF(self->type); Py_XDECREF(self->addr); self->ob_type->tp_free((PyObject *) self); }
pyVaultNode::pyVaultNodeOperationCallback::~pyVaultNodeOperationCallback() { Py_XDECREF( fCbObject ); }
static void CD_callback(void *arg, CDDATATYPES type, void *data) { PyObject *result, *args, *v = NULL; char *p; int i; cdparserobject *self; self = (cdparserobject *) arg; args = PyTuple_New(3); if (args == NULL) return; Py_INCREF(self->ob_cdcallbacks[type].ob_cdcallbackarg); PyTuple_SetItem(args, 0, self->ob_cdcallbacks[type].ob_cdcallbackarg); PyTuple_SetItem(args, 1, PyInt_FromLong((long) type)); switch (type) { case cd_audio: v = PyString_FromStringAndSize(data, CDDA_DATASIZE); break; case cd_pnum: case cd_index: v = PyInt_FromLong(((CDPROGNUM *) data)->value); break; case cd_ptime: case cd_atime: #define ptr ((struct cdtimecode *) data) v = Py_BuildValue("(iii)", ptr->mhi * 10 + ptr->mlo, ptr->shi * 10 + ptr->slo, ptr->fhi * 10 + ptr->flo); #undef ptr break; case cd_catalog: v = PyString_FromStringAndSize(NULL, 13); p = PyString_AsString(v); for (i = 0; i < 13; i++) *p++ = ((char *) data)[i] + '0'; break; case cd_ident: #define ptr ((struct cdident *) data) v = PyString_FromStringAndSize(NULL, 12); p = PyString_AsString(v); CDsbtoa(p, ptr->country, 2); p += 2; CDsbtoa(p, ptr->owner, 3); p += 3; *p++ = ptr->year[0] + '0'; *p++ = ptr->year[1] + '0'; *p++ = ptr->serial[0] + '0'; *p++ = ptr->serial[1] + '0'; *p++ = ptr->serial[2] + '0'; *p++ = ptr->serial[3] + '0'; *p++ = ptr->serial[4] + '0'; #undef ptr break; case cd_control: v = PyInt_FromLong((long) *((unchar *) data)); break; } PyTuple_SetItem(args, 2, v); if (PyErr_Occurred()) { Py_DECREF(args); return; } result = PyEval_CallObject(self->ob_cdcallbacks[type].ob_cdcallback, args); Py_DECREF(args); Py_XDECREF(result); }
static PyObject *pywrapper_solver(PyObject *self,PyObject *args) { int checkder,inform,iprint,m,n,ncomp; double cnorm,f,nlpsupn,epsfeas,epsopt,snorm; int coded[10]; int *equatn,*linear; double *l,*lambda,*u,*x; return_value = Py_None; setbuf(stderr,(char *) malloc(BUFSIZ)); if (!PyArg_ParseTuple(args,"O!O!O!O!O!O!O!O!O!O!O!O!O!:solver", &PyFunction_Type,&evalf_py, &PyFunction_Type,&evalg_py, &PyFunction_Type,&evalh_py, &PyFunction_Type,&evalc_py, &PyFunction_Type,&evaljac_py, &PyFunction_Type,&evalhc_py, &PyFunction_Type,&evalfc_py, &PyFunction_Type,&evalgjac_py, &PyFunction_Type,&evalhl_py, &PyFunction_Type,&evalhlp_py, &PyFunction_Type,&inip_py, &PyFunction_Type,&endp_py, &PyDict_Type,¶m_py)) goto cleanup; Py_INCREF(evalf_py ); Py_INCREF(evalg_py ); Py_INCREF(evalh_py ); Py_INCREF(evalc_py ); Py_INCREF(evaljac_py ); Py_INCREF(evalhc_py ); Py_INCREF(evalfc_py ); Py_INCREF(evalgjac_py); Py_INCREF(evalhl_py ); Py_INCREF(evalhlp_py ); Py_INCREF(inip_py ); Py_INCREF(endp_py ); Py_INCREF(param_py ); param(&epsfeas,&epsopt,&iprint,&ncomp); if (return_value == NULL) goto cleanup; inip(&n,&x,&l,&u,&m,&lambda,&equatn,&linear,coded,&checkder); if (return_value == NULL) goto cleanup; C2FLOGICALV(equatn,m); C2FLOGICALV(linear,m); C2FLOGICALV(coded,10); Algencan(epsfeas,epsopt,iprint,ncomp,n,x,l,u,m,lambda,equatn, linear,coded,checkder,f,cnorm,snorm,nlpsupn,inform); if (return_value == NULL) goto cleanup; endp(n,x,l,u,m,lambda,equatn,linear); if (return_value == NULL) goto cleanup; cleanup: Py_XDECREF(evalf_py ); Py_XDECREF(evalg_py ); Py_XDECREF(evalh_py ); Py_XDECREF(evalc_py ); Py_XDECREF(evaljac_py ); Py_XDECREF(evalhc_py ); Py_XDECREF(evalfc_py ); Py_XDECREF(evalgjac_py); Py_XDECREF(evalhl_py ); Py_XDECREF(evalhlp_py ); Py_XDECREF(inip_py ); Py_XDECREF(endp_py ); Py_XDECREF(param_py ); fflush(stdout); fflush(stderr); Py_XINCREF(return_value); return return_value; }
static void DragObj_dealloc(DragObjObject *self) { Py_XDECREF(self->sendproc); self->ob_type->tp_free((PyObject *)self); }