/// Return the log buffer up to limit as a python list. Called by management agent. PyObject *qd_log_recent_py(long limit) { if (PyErr_Occurred()) return NULL; PyObject *list = PyList_New(0); PyObject *py_entry = NULL; if (!list) goto error; qd_log_entry_t *entry = DEQ_TAIL(entries); while (entry && limit) { const int ENTRY_SIZE=6; py_entry = PyList_New(ENTRY_SIZE); if (!py_entry) goto error; int i = 0; // NOTE: PyList_SetItem steals a reference so no leak here. PyList_SetItem(py_entry, i++, PyString_FromString(entry->module)); const char* level = level_name(entry->level); PyList_SetItem(py_entry, i++, level ? PyString_FromString(level) : inc_none()); PyList_SetItem(py_entry, i++, PyString_FromString(entry->text)); PyList_SetItem(py_entry, i++, entry->file ? PyString_FromString(entry->file) : inc_none()); PyList_SetItem(py_entry, i++, entry->file ? PyLong_FromLong(entry->line) : inc_none()); PyList_SetItem(py_entry, i++, PyLong_FromLongLong((PY_LONG_LONG)entry->time)); assert(i == ENTRY_SIZE); if (PyErr_Occurred()) goto error; PyList_Insert(list, 0, py_entry); Py_DECREF(py_entry); if (limit > 0) --limit; entry = DEQ_PREV(entry); } return list; error: Py_XDECREF(list); Py_XDECREF(py_entry); return NULL; }
static void PyListInsertString( PyObject *list, int index, std::string string) { PyObject* s = PyString_FromString(string.c_str()); PyList_Insert(list, 0, s); Py_XDECREF(s); }
static void setupPyPath(void) { PyObject *mod, *path = NULL; mod = PyImport_ImportModule("sys"); if(mod) path = PyObject_GetAttrString(mod, "path"); Py_XDECREF(mod); if(path) { PyObject *cur; char cwd[PATH_MAX]; insertDefaultPath(path); /* prepend current directory */ if(getcwd(cwd, sizeof(cwd)-1)) { cwd[sizeof(cwd)-1] = '\0'; cur = PyString_FromString(cwd); if(cur) PyList_Insert(path, 0, cur); Py_XDECREF(cur); } } Py_XDECREF(path); }
static int proxenet_python_append_path() { PyObject *pPath, *pAddPath; int retcode = 0; pPath = PySys_GetObject("path"); if (!pPath) { xlog_python(LOG_ERROR, "%s\n", "Failed to find `sys.path'"); return -1; } if (!PyList_Check(pPath)) { return -1; } pAddPath = PYTHON_FROMSTRING(cfg->plugins_path); if (!pAddPath) { return -1; } if (PyList_Insert(pPath, 0, pAddPath) < 0) { retcode = -1; } Py_DECREF(pAddPath); return retcode; }
/** * 关闭连接 * args[0] 连接对象 * args[1] 连接池对象 **/ static PyObject* connect_close(PyObject *self, PyObject *args) { PyConnectPoolObject *pool = (PyConnectPoolObject*)PySequence_GetItem(args, 1); PyConnectObject *con = (PyConnectObject*)PySequence_GetItem(args, 0); int index; if(!pool || !con || !PyConnectPool_CheckExact(pool) || !PyConnect_CheckExact(con)) { PyErr_SetString(PyExc_RuntimeError, "参数错误"); return NULL; } //从busy连接队列中删除掉 index = PySequence_Index(pool->cons_busy, (PyObject*)con); if(index != -1) PySequence_DelItem(pool->cons_busy, index); //检查空闲的连接池数量 //如果空闲的连接过多,则关闭多余的连接 if(PySequence_Length(pool->cons_free) > pool->free_max) { connect_dealloc(con); } else { PyList_Insert((PyObject*)(pool->cons_free), 0, (PyObject*)con); } return Py_True; }
/** * Add an additional search directory for the protocol decoders. * * The specified directory is prepended (not appended!) to Python's sys.path, * in order to search for sigrok protocol decoders in the specified * directories first, and in the generic Python module directories (and in * the current working directory) last. This avoids conflicts if there are * Python modules which have the same name as a sigrok protocol decoder in * sys.path or in the current working directory. * * @param path Path to the directory containing protocol decoders which shall * be added to the Python sys.path, or NULL. * * @return SRD_OK upon success, a (negative) error code otherwise. * * @private * * @since 0.1.0 */ SRD_PRIV int srd_decoder_searchpath_add(const char *path) { PyObject *py_cur_path, *py_item; srd_dbg("Adding '%s' to module path.", path); py_cur_path = PySys_GetObject("path"); if (!py_cur_path) return SRD_ERR_PYTHON; py_item = PyUnicode_FromString(path); if (!py_item) { srd_exception_catch(NULL, "Failed to create Unicode object"); return SRD_ERR_PYTHON; } if (PyList_Insert(py_cur_path, 0, py_item) < 0) { srd_exception_catch(NULL, "Failed to insert path element"); Py_DECREF(py_item); return SRD_ERR_PYTHON; } Py_DECREF(py_item); searchpaths = g_slist_prepend(searchpaths, g_strdup(path)); return SRD_OK; }
/** * 从连接池中获得一个连接 * args的第一个参数是一个连接池对象 **/ static PyObject* getconnection(PyObject *self, PyObject *args) { PyConnectPoolObject *pool = PySequence_GetItem(args, 0); PyListObject *conns; PyConnectObject *con; if(!PyConnectPool_CheckExact(pool)) { PyErr_SetString(PyExc_RuntimeError, "参数类型不是connectPool"); return NULL; } conns = pool->cons_free; //空闲缓冲池里面可以获得到空闲的连接 if(PySequence_Length(conns)) { con = (PyConnectObject*)PySequence_GetItem(conns, 0); //删除第一个元素 PyList_SetSlice(conns, 0, 1, NULL); } else { con = (PyConnectObject*)PyConnect_New(pool->host, pool->user, pool->passwd, pool->db, pool->port); } if(con == NULL) { return PyErr_NoMemory(); } conns = pool->cons_busy; PyList_Insert((PyObject*)conns, 0, (PyObject*)con); return (PyObject*)con; }
/** * @free_max 最多的空闲连接数 * @begin_conn 开始时打开的连接数 **/ static PyConnectPoolObject* init(int free_max, int begin_conn, char *host, char *user, char *passwd, char *db, int port) { PyConnectPoolObject *pool; PyConnectObject *con; int i = 0; //参数检查 begin_conn = (begin_conn < 1) ? 1 : begin_conn; begin_conn = (begin_conn > BEGIN_CONN_MAX) ? BEGIN_CONN_MAX : begin_conn; //printf("1\n"); // pool = (PyConnectPoolObject*)PyConnectPool_New(free_max, host, user, passwd, db, port); if(!pool) { return NULL; } //printf("2\n"); for(i = 0; i < begin_conn; i ++) { con = (PyConnectObject*)PyConnect_New(pool->host, pool->user, pool->passwd, pool->db, pool->port); PyList_Insert(pool->cons_free, 0, (PyObject*)con); } //printf("3\n"); return pool; }
void QPython::addImportPath(QString path) { ENSURE_GIL_STATE; // Strip leading "file://" (for use with Qt.resolvedUrl()) if (path.startsWith("file://")) { #ifdef WIN32 // On Windows, path would be "file:///C:\...", so strip 8 chars to get // a Windows-compatible absolute filename to be used as import path path = path.mid(8); #else path = path.mid(7); #endif } if (SINCE_API_VERSION(1, 3) && path.startsWith("qrc:")) { const char *module = "pyotherside.qrc_importer"; QString filename = "/io/thp/pyotherside/qrc_importer.py"; QString errorMessage = priv->importFromQRC(module, filename); if (!errorMessage.isNull()) { emitError(errorMessage); } } QByteArray utf8bytes = path.toUtf8(); PyObject *sys_path = PySys_GetObject((char*)"path"); PyObjectRef cwd(PyUnicode_FromString(utf8bytes.constData()), true); PyList_Insert(sys_path, 0, cwd.borrow()); }
void Plugins::loadFromPath(const ppl6::CString &Path) { #ifdef HAVE_PYTHON ppl6::CDir Dir; if (!Dir.Open(Path)) return; PyObject *sysPath = PySys_GetObject("path"); PyObject *path = PyString_FromString(Path); int result = PyList_Insert(sysPath, 0, path); Py_DECREF(path); Dir.Reset(); const ppl6::CDirEntry *entry; while ((entry=Dir.GetNextPattern("*.py"))) { ppl6::CArray matches; if (entry->Filename.PregMatch("/^(.*?)\\.py$/i",matches)) { ppl6::CString ModuleName=matches.GetString(1); printf ("Loading Plugin: %s\n",(const char*)ModuleName); python_modules.push_back(ModuleName); PyRun_SimpleString("import "+ModuleName+"\n"); } } #endif }
void TraCIServer::runEmbedded(std::string pyFile) { PyObject* pName, *pModule; Py_Initialize(); Py_InitModule("traciemb", EmbMethods); if (pyFile.length() > 3 && !pyFile.compare(pyFile.length() - 3, 3, ".py")) { PyObject* sys_path, *path; char pathstr[] = "path"; sys_path = PySys_GetObject(pathstr); if (sys_path == NULL || !PyList_Check(sys_path)) { throw ProcessError("Could not access python sys.path!"); } path = PyString_FromString(FileHelpers::getFilePath(pyFile).c_str()); PyList_Insert(sys_path, 0, path); Py_DECREF(path); FILE* pFile = fopen(pyFile.c_str(), "r"); if (pFile == NULL) { throw ProcessError("Failed to load \"" + pyFile + "\"!"); } PyRun_SimpleFile(pFile, pyFile.c_str()); fclose(pFile); } else { pName = PyString_FromString(pyFile.c_str()); /* Error checking of pName left out */ pModule = PyImport_Import(pName); Py_DECREF(pName); if (pModule == NULL) { PyErr_Print(); throw ProcessError("Failed to load \"" + pyFile + "\"!"); } } Py_Finalize(); }
//----------------------------------------------------------------------------- // SetPathToSearch() // Set the path to search. This includes the file (for those situations where // a zip file is attached to the executable itself), the directory where the // executable is found (to search for extensions), the exclusive zip file // name and the shared zip file name. //----------------------------------------------------------------------------- static int SetPathToSearch(void) { PyObject *pathList; pathList = PySys_GetObject("path"); if (!pathList) return FatalError("cannot acquire sys.path"); if (PyList_Insert(pathList, 0, g_FileName) < 0) return FatalError("cannot insert file name into sys.path"); if (PyList_Insert(pathList, 1, g_DirName) < 0) return FatalError("cannot insert directory name into sys.path"); if (PyList_Insert(pathList, 2, g_ExclusiveZipFileName) < 0) return FatalError("cannot insert exclusive zip name into sys.path"); if (PyList_Insert(pathList, 3, g_SharedZipFileName) < 0) return FatalError("cannot insert shared zip name into sys.path"); return 0; }
static gboolean eom_python_module_load (GTypeModule *gmodule) { EomPythonModulePrivate *priv = EOM_PYTHON_MODULE_GET_PRIVATE (gmodule); PyObject *main_module, *main_locals, *locals, *key, *value; PyObject *module, *fromlist; Py_ssize_t pos = 0; g_return_val_if_fail (Py_IsInitialized (), FALSE); main_module = PyImport_AddModule ("__main__"); if (main_module == NULL) { g_warning ("Could not get __main__."); return FALSE; } /* If we have a special path, we register it */ if (priv->path != NULL) { PyObject *sys_path = PySys_GetObject ("path"); PyObject *path = PyString_FromString (priv->path); if (PySequence_Contains(sys_path, path) == 0) PyList_Insert (sys_path, 0, path); Py_DECREF(path); } main_locals = PyModule_GetDict (main_module); /* We need a fromlist to be able to import modules with * a '.' in the name. */ fromlist = PyTuple_New(0); module = PyImport_ImportModuleEx (priv->module, main_locals, main_locals, fromlist); Py_DECREF(fromlist); if (!module) { PyErr_Print (); return FALSE; } locals = PyModule_GetDict (module); while (PyDict_Next (locals, &pos, &key, &value)) { if (!PyType_Check(value)) continue; if (PyObject_IsSubclass (value, (PyObject*) PyEomPlugin_Type)) { priv->type = eom_python_plugin_get_type (gmodule, value); return TRUE; } } return FALSE; }
static PyObject *pair_repr(PyObject *self) { PyObject *tmp = NULL; PyObject *col = PyList_New(0); PyObject *found = PyDict_New(); size_t index = 0; PyObject *rest = self; PyObject *rest_id; PyList_Append(col, _str_cons_paren); while (rest->ob_type == &SibPairType) { rest_id = PyLong_FromVoidPtr(rest); if (PyDict_Contains(found, rest_id)) { /* recursive pair detected */ PyList_Append(col, _str_recursive_true); if (rest != self) { tmp = PyDict_GetItem(found, rest_id); PyList_Insert(col, PyLong_AsSize_t(tmp) - 1, _str_cons_paren); PyList_Append(col, _str_close_paren); } Py_DECREF(rest_id); rest = NULL; break; } else { index += 2; tmp = PyLong_FromSize_t(index); PyDict_SetItem(found, rest_id, tmp); Py_DECREF(tmp); tmp = PyObject_Repr(SibPair_CAR(rest)); PyList_Append(col, tmp); PyList_Append(col, _str_comma_space); Py_DECREF(tmp); rest = SibPair_CDR(rest); Py_DECREF(rest_id); } } if (rest) { PyList_Append(col, PyObject_Repr(rest)); } PyList_Append(col, _str_close_paren); tmp = PyUnicode_Join(_str_empty, col); Py_DECREF(col); Py_DECREF(found); return tmp; }
static PyObject * table_subscript(tableobject *self, register PyObject *key) { char *k; const apr_array_header_t *ah; apr_table_entry_t *elts; register int i; PyObject *list; if (key && !PyString_Check(key)) { PyErr_SetString(PyExc_TypeError, "table keys must be strings"); return NULL; } k = PyString_AsString(key); /* it's possible that we have duplicate keys, so we can't simply use apr_table_get since that just returns the first match. */ list = PyList_New(0); if (!list) return NULL; ah = apr_table_elts (self->table); elts = (apr_table_entry_t *) ah->elts; i = ah->nelts; while (i--) if (elts[i].key) { if (apr_strnatcasecmp(elts[i].key, k) == 0) { PyObject *v = PyString_FromString(elts[i].val); PyList_Insert(list, 0, v); Py_DECREF(v); } } /* if no mach */ if (PyList_Size(list) == 0) { PyErr_SetObject(PyExc_KeyError, key); return NULL; } /* if we got one match */ if (PyList_Size(list) == 1) { PyObject *v = PyList_GetItem(list, 0); Py_INCREF(v); Py_DECREF(list); return v; } /* else we return a list */ return list; }
void AddPath(const char * path) { PyObject * pName = PyUnicode_FromString(path), *syspath; // reference to Python search path syspath = PySys_GetObject("path"); // add path to syspath if (PyList_Insert(syspath, 0, pName)) printf("Error inserting extra path into sys.path list\n"); // reset sys.path object if (PySys_SetObject("path", syspath)) printf("Error setting sys.path object\n"); }
void PythonModule::add_to_pythonpath(std::string path) { if(!initialised) { return; } block_threads(); PyObject *path_py = PyString_FromString(path.c_str()); if(PyList_Insert(sys_path, 0, path_py) < 0) { PyErr_Print(); } Py_XDECREF(path_py); unblock_threads(); }
void list_base::insert(ssize_t index, object_cref item) { if (PyList_CheckExact(this->ptr())) { if (PyList_Insert(this->ptr(), index, item.ptr()) == -1) throw_error_already_set(); } else { this->attr("insert")(index, item); } }
PyTempleImporter::PyTempleImporter() { if (PyType_Ready(&PyTempleImporterType) < 0) throw TempleException("Python type has not yet been registered"); CreateSearchOrder(); mFinder = PyObject_New(PyObject, &PyTempleImporterType); // Insert into python meta_path system auto path_hooks = PySys_GetObject("meta_path"); PyList_Insert(path_hooks, 0, mFinder); }
/** * \brief User defined constructor for PyAlgo. * \param[in] file_path The path of the algorithm python script/module. * \param[in] class_name Name of the algorithm class. */ PyAlgo( const std::string file_path, const std::string &class_name ) : base_t() , mFilePath( file_path ) , mClassName( class_name ) , m_module( nullptr ) , m_class( nullptr ) , m_instance( nullptr ) { if ( !IsFile(mFilePath.c_str()) ) throw e_file_not_found; std::string modulePath = dir_from_filepath( file_path ); std::string moduleName = basename_from_path( file_path ); // Add the directory (with module) to the python sys.path PyObject *sysPath = PySys_GetObject("path"); //TODO Py_DECREF sysPath??? PyObject *path = PyUnicode_FromString( modulePath.c_str() ); //TODO Py_DECREF path??? if ( PyList_Insert(sysPath, 0, path)) throw e_error_add_module_dir_syspath; // Build the name object and load the module object PyObject *pName = PyUnicode_FromString( moduleName.c_str() ); m_module = PyImport_Import(pName); Py_DECREF(pName); if (PyErr_Occurred()){ PyErr_Print(); throw e_error_loading_module; } std::cout << "- Loaded python Module object " + moduleName + " at " << m_module << std::endl; // Build the name of a callable class m_class = PyObject_GetAttrString( m_module, mClassName.c_str() ); // Create an instance of the class if (m_class && PyCallable_Check(m_class)) { m_instance = PyObject_CallObject(m_class, NULL); std::cout << "-- Loaded a python Class object " + mClassName + " at " << m_class << std::endl; } else { if (PyErr_Occurred()) PyErr_Print(); throw e_class_not_found; } }
PyObject* cyAccountManagement::GetPlayerList() { const ARRAY(NetCommPlayer)& playerList = NetCommGetPlayerList(); int numPlayers = NetCommGetPlayerCount(); PyObject* pList = PyList_New(0); PyObject* visitor = nil; for (int i = 0; i < numPlayers; ++i) { PyObject* playerTuple = PyTuple_New(3); PyObject* playerName = PyUnicode_FromStringEx(playerList[i].playerName); PyObject* playerId = PyInt_FromLong(playerList[i].playerInt); PyObject* avatarShape = PyString_FromPlString(playerList[i].avatarDatasetName); PyTuple_SetItem(playerTuple, 0, playerName); PyTuple_SetItem(playerTuple, 1, playerId); PyTuple_SetItem(playerTuple, 2, avatarShape); if (visitor || playerList[i].explorer) PyList_Append(pList, playerTuple); else visitor = playerTuple; } if (visitor) { PyList_Insert(pList, 0, visitor); } else { Py_INCREF(Py_None); PyList_Insert(pList, 0, Py_None); } return pList; }
/* Insert new unique item to the `where` position in UniqueList. */ int UniqueList_Insert(UniqueList *self, Py_ssize_t where, PyObject *newitem) { if (PyDict_Check(newitem) || PyList_Check(newitem) || PyTuple_Check(newitem)) { PyErr_SetString(PyExc_ValueError, "This type of list can not contain instances of Python tuple, list or dict."); return -1; } if (UniqueList_Contains(self, newitem) == 1) { PyErr_Format(PyExc_ValueError, "%R is already in the list.", newitem); return -1; } return PyList_Insert((PyObject *)self, where, newitem); }
int main (int argc, char *argv[] ){ const char *scriptDirectoryName = "./pyutils"; Py_SetProgramName(argv[0]); PyObject *pName, *pModule, *pDict, *pFunc, *pValue, *presult; // Initialize the Python Interpreter Py_Initialize(); PyObject *sysPath = PySys_GetObject("path"); PyObject *path = PyString_FromString(scriptDirectoryName); int result = PyList_Insert(sysPath, 0, path); pModule = PyImport_ImportModule("arbName"); if (PyErr_Occurred()) PyErr_Print(); // printf("%p\n", pModule); // pDict is a borrowed reference pDict = PyModule_GetDict(pModule); // pFunc is also a borrowed reference pFunc = PyDict_GetItemString(pDict, (char*)"someFunction"); if (PyCallable_Check(pFunc)) { pValue=Py_BuildValue("(z)",(char*)"something"); PyErr_Print(); printf("Let's give this a shot!\n"); presult=PyObject_CallObject(pFunc,pValue); PyErr_Print(); } else { PyErr_Print(); } printf("Result is %ld\n", PyInt_AsLong(presult)); Py_DECREF(pValue); // Clean up Py_DECREF(pModule); // Finish the Python Interpreter Py_Finalize(); return 0; }
void addModuleSearchPath(const std::string& path) { std::string pathString("path"); auto syspath = PySys_GetObject(&pathString[0]); // Borrowed reference PythonObject pypath(PythonObject::owning {}, PyString_FromString(path.c_str())); if (!pypath) { throw WrappyError("Wrappy: Can't allocate memory for string."); } auto pos = PyList_Insert(syspath, 0, pypath.get()); if (pos < 0) { throw WrappyError("Wrappy: Couldn't add " + path + " to sys.path"); } }
/* Write a token to the current token stack. */ int Tokenizer_emit_token(Tokenizer* self, PyObject* token, int first) { PyObject* instance; if (Tokenizer_push_textbuffer(self)) return -1; instance = PyObject_CallObject(token, NULL); if (!instance) return -1; if (first ? PyList_Insert(self->topstack->stack, 0, instance) : PyList_Append(self->topstack->stack, instance)) { Py_DECREF(instance); return -1; } Py_DECREF(instance); return 0; }
/*! Starts the python interpreter */ void startPython( int argc, char* argv[] ) { Py_SetProgramName( argv[0] ); Py_NoSiteFlag = 1; // No import because we need to set the search path first Py_Initialize(); PySys_SetArgv( argc, argv ); // Modify our search-path PyObject* searchpath = PySys_GetObject( "path" ); QStringList elements = QStringList::split( ";", Config::instance()->getString( "General", "Python Searchpath", "./scripts;.", true ) ); // Prepend our items to the searchpath for ( int i = elements.count() - 1; i >= 0; --i ) { PyList_Insert( searchpath, 0, PyString_FromString( elements[i].latin1() ) ); } // Import site now PyObject* m = PyImport_ImportModule( "site" ); Py_XDECREF( m ); // Try changing the stderr + stdout pointers PyObject* file = PyFile_FromString( "python.log", "w" ); if ( file ) { Py_INCREF( file ); PySys_SetObject( "stderr", file ); Py_INCREF( file ); PySys_SetObject( "stdout", file ); Py_DECREF( file ); } try { init_wolfpack_globals(); } catch ( ... ) { Console::instance()->send( "Failed to initialize the python extension modules\n" ); } }
void set_dyn_pyhome(char *home, uint16_t pyhome_len) { char venv_version[15]; PyObject *site_module; PyObject *pysys_dict = get_uwsgi_pydict("sys"); PyObject *pypath = PyDict_GetItemString(pysys_dict, "path"); if (!pypath) { PyErr_Print(); exit(1); } // simulate a pythonhome directive if (uwsgi.wsgi_req->home_len > 0) { PyObject *venv_path = UWSGI_PYFROMSTRINGSIZE(uwsgi.wsgi_req->home, uwsgi.wsgi_req->home_len); #ifdef UWSGI_DEBUG uwsgi_debug("setting dynamic virtualenv to %.*s\n", uwsgi.wsgi_req->home_len, uwsgi.wsgi_req->home); #endif PyDict_SetItemString(pysys_dict, "prefix", venv_path); PyDict_SetItemString(pysys_dict, "exec_prefix", venv_path); venv_version[14] = 0; if (snprintf(venv_version, 15, "/lib/python%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION) == -1) { return; } // check here PyString_Concat(&venv_path, PyString_FromString(venv_version)); if (PyList_Insert(pypath, 0, venv_path)) { PyErr_Print(); } site_module = PyImport_ImportModule("site"); if (site_module) { PyImport_ReloadModule(site_module); } } }
/* Expose the notices received as Python objects. * * The function should be called with the connection lock and the GIL. */ void conn_notice_process(connectionObject *self) { struct connectionObject_notice *notice; Py_ssize_t nnotices; if (NULL == self->notice_pending) { return; } notice = self->notice_pending; nnotices = PyList_GET_SIZE(self->notice_list); while (notice != NULL) { PyObject *msg; msg = conn_text_from_chars(self, notice->message); Dprintf("conn_notice_process: %s", notice->message); /* Respect the order in which notices were produced, because in notice_list they are reversed (see ticket #9) */ if (msg) { PyList_Insert(self->notice_list, nnotices, msg); Py_DECREF(msg); } else { /* We don't really have a way to report errors, so gulp it. * The function should only fail for out of memory, so we are * likely going to die anyway. */ PyErr_Clear(); } notice = notice->next; } /* Remove the oldest item if the queue is getting too long. */ nnotices = PyList_GET_SIZE(self->notice_list); if (nnotices > CONN_NOTICES_LIMIT) { PySequence_DelSlice(self->notice_list, 0, nnotices - CONN_NOTICES_LIMIT); } conn_notice_clean(self); }
bool CPythonEngine::AddToPythonPath(LPCTSTR pPathName) { PyObject *obPathList = PySys_GetObject("path"); if (obPathList==NULL) { return false; } // Some pathnames have a leading '\\?\', which tells allows Unicode // win32 functions to avoid MAX_PATH limitations. Notably, // GetModulePath for our extension DLL may - presumably as such a // path was specified by IIS when loading the DLL. // Current Python versions handle neither this, nor Unicode on // sys.path, so correct this here. size_t len = _tcslen(pPathName); if (len > 4 && _tcsncmp(pPathName, _T("\\\\?\\"), 4)==0) { pPathName += 4; len -= 4; } #if (PY_VERSION_HEX < 0x03000000) PyObject *obNew = PyString_FromStringAndSize(pPathName, len); #else PyObject *obNew = PyUnicode_FromWideChar(pPathName, len); #endif if (obNew==NULL) { return false; } bool bFnd=false; for (int i=0; i<PyList_Size(obPathList); i++){ PyObject * obItem = PyList_GetItem(obPathList, i); if(PyObject_RichCompare(obNew, obItem, Py_EQ) == Py_True){ bFnd = true; break; } } if (!bFnd) PyList_Insert(obPathList, 0, obNew); Py_XDECREF(obNew); return true; }
static PyObject *Scopeable_push(PyObject *self, PyObject *args) { PyObject *newDict, *dictList; if (!PyArg_ParseTuple(args, "OO", &self, &newDict)) { return NULL; } if (!PyDict_Check(newDict)) { PyErr_SetString(PyExc_TypeError, "push() requires a dictionary argument"); return NULL; } dictList=PyMapping_GetItemString(((PyInstanceObject *)self)->in_dict, DICTLIST); if (!PyList_Check(dictList)) { PyErr_SetString(PyExc_TypeError, "expected list for dictList!"); Py_XDECREF(dictList); return NULL; } PyList_Insert(dictList, 0, newDict); Py_DECREF(dictList); Py_INCREF(Py_None); return Py_None; }