void init_uwsgi_embedded_module() {
PyObject *new_uwsgi_module, *zero;
int i;
PyType_Ready(&uwsgi_InputType);
/* initialize for stats */
up.workers_tuple = PyTuple_New(uwsgi.numproc);
for (i = 0; i < uwsgi.numproc; i++) {
zero = PyDict_New();
Py_INCREF(zero);
PyTuple_SetItem(up.workers_tuple, i, zero);
}
#ifdef PYTHREE
PyImport_AppendInittab("uwsgi", init_uwsgi3);
new_uwsgi_module = PyImport_AddModule("uwsgi");
#else
new_uwsgi_module = Py_InitModule3("uwsgi", NULL, uwsgi_py_doc);
#endif
if (new_uwsgi_module == NULL) {
uwsgi_log("could not initialize the uwsgi python module\n");
exit(1);
}
Py_INCREF((PyObject *) &uwsgi_InputType);
up.embedded_dict = PyModule_GetDict(new_uwsgi_module);
if (!up.embedded_dict) {
uwsgi_log("could not get uwsgi module __dict__\n");
exit(1);
}
// just for safety
Py_INCREF(up.embedded_dict);
if (PyDict_SetItemString(up.embedded_dict, "version", PyString_FromString(UWSGI_VERSION))) {
PyErr_Print();
exit(1);
}
PyObject *uwsgi_py_version_info = PyTuple_New(5);
PyTuple_SetItem(uwsgi_py_version_info, 0, PyInt_FromLong(UWSGI_VERSION_BASE));
PyTuple_SetItem(uwsgi_py_version_info, 1, PyInt_FromLong(UWSGI_VERSION_MAJOR));
PyTuple_SetItem(uwsgi_py_version_info, 2, PyInt_FromLong(UWSGI_VERSION_MINOR));
PyTuple_SetItem(uwsgi_py_version_info, 3, PyInt_FromLong(UWSGI_VERSION_REVISION));
PyTuple_SetItem(uwsgi_py_version_info, 4, PyString_FromString(UWSGI_VERSION_CUSTOM));
if (PyDict_SetItemString(up.embedded_dict, "version_info", uwsgi_py_version_info)) {
PyErr_Print();
exit(1);
}
if (PyDict_SetItemString(up.embedded_dict, "hostname", PyString_FromStringAndSize(uwsgi.hostname, uwsgi.hostname_len))) {
PyErr_Print();
exit(1);
}
if (uwsgi.mode) {
if (PyDict_SetItemString(up.embedded_dict, "mode", PyString_FromString(uwsgi.mode))) {
PyErr_Print();
exit(1);
}
}
if (uwsgi.pidfile) {
if (PyDict_SetItemString(up.embedded_dict, "pidfile", PyString_FromString(uwsgi.pidfile))) {
PyErr_Print();
exit(1);
}
}
#ifdef UWSGI_SPOOLER
if (uwsgi.spoolers) {
int sc = 0;
struct uwsgi_spooler *uspool = uwsgi.spoolers;
while(uspool) { sc++; uspool = uspool->next;}
PyObject *py_spooler_tuple = PyTuple_New(sc);
uspool = uwsgi.spoolers;
sc = 0;
while(uspool) {
PyTuple_SetItem(py_spooler_tuple, sc, PyString_FromString(uspool->dir));
sc++;
uspool = uspool->next;
}
if (PyDict_SetItemString(up.embedded_dict, "spoolers", py_spooler_tuple)) {
PyErr_Print();
exit(1);
}
}
#endif
if (PyDict_SetItemString(up.embedded_dict, "SPOOL_RETRY", PyInt_FromLong(-1))) {
PyErr_Print();
exit(1);
}
if (PyDict_SetItemString(up.embedded_dict, "SPOOL_OK", PyInt_FromLong(-2))) {
PyErr_Print();
exit(1);
}
if (PyDict_SetItemString(up.embedded_dict, "SPOOL_IGNORE", PyInt_FromLong(0))) {
PyErr_Print();
exit(1);
}
if (PyDict_SetItemString(up.embedded_dict, "numproc", PyInt_FromLong(uwsgi.numproc))) {
PyErr_Print();
exit(1);
}
if (PyDict_SetItemString(up.embedded_dict, "has_threads", PyInt_FromLong(uwsgi.has_threads))) {
PyErr_Print();
exit(1);
}
if (PyDict_SetItemString(up.embedded_dict, "cores", PyInt_FromLong(uwsgi.cores))) {
PyErr_Print();
exit(1);
}
if (uwsgi.loop) {
if (PyDict_SetItemString(up.embedded_dict, "loop", PyString_FromString(uwsgi.loop))) {
PyErr_Print();
exit(1);
}
}
else {
PyDict_SetItemString(up.embedded_dict, "loop", Py_None);
}
PyObject *py_opt_dict = PyDict_New();
for (i = 0; i < uwsgi.exported_opts_cnt; i++) {
if (PyDict_Contains(py_opt_dict, PyString_FromString(uwsgi.exported_opts[i]->key))) {
PyObject *py_opt_item = PyDict_GetItemString(py_opt_dict, uwsgi.exported_opts[i]->key);
if (PyList_Check(py_opt_item)) {
if (uwsgi.exported_opts[i]->value == NULL) {
PyList_Append(py_opt_item, Py_True);
}
else {
PyList_Append(py_opt_item, PyString_FromString(uwsgi.exported_opts[i]->value));
}
}
else {
PyObject *py_opt_list = PyList_New(0);
PyList_Append(py_opt_list, py_opt_item);
if (uwsgi.exported_opts[i]->value == NULL) {
PyList_Append(py_opt_list, Py_True);
}
else {
PyList_Append(py_opt_list, PyString_FromString(uwsgi.exported_opts[i]->value));
}
PyDict_SetItemString(py_opt_dict, uwsgi.exported_opts[i]->key, py_opt_list);
}
}
else {
if (uwsgi.exported_opts[i]->value == NULL) {
PyDict_SetItemString(py_opt_dict, uwsgi.exported_opts[i]->key, Py_True);
}
else {
PyDict_SetItemString(py_opt_dict, uwsgi.exported_opts[i]->key, PyString_FromString(uwsgi.exported_opts[i]->value));
}
}
}
if (PyDict_SetItemString(up.embedded_dict, "opt", py_opt_dict)) {
PyErr_Print();
exit(1);
}
PyObject *py_magic_table = PyDict_New();
uint8_t mtk;
for (i = 0; i <= 0xff; i++) {
// a bit of magic :P
mtk = i;
if (uwsgi.magic_table[i]) {
if (uwsgi.magic_table[i][0] != 0) {
PyDict_SetItem(py_magic_table, PyString_FromStringAndSize((char *) &mtk, 1), PyString_FromString(uwsgi.magic_table[i]));
}
}
}
if (PyDict_SetItemString(up.embedded_dict, "magic_table", py_magic_table)) {
PyErr_Print();
exit(1);
}
#ifdef UNBIT
if (PyDict_SetItemString(up.embedded_dict, "unbit", Py_True)) {
#else
if (PyDict_SetItemString(up.embedded_dict, "unbit", Py_None)) {
#endif
PyErr_Print();
exit(1);
}
if (PyDict_SetItemString(up.embedded_dict, "buffer_size", PyInt_FromLong(uwsgi.buffer_size))) {
PyErr_Print();
exit(1);
}
if (PyDict_SetItemString(up.embedded_dict, "started_on", PyInt_FromLong(uwsgi.start_tv.tv_sec))) {
PyErr_Print();
exit(1);
}
if (PyDict_SetItemString(up.embedded_dict, "start_response", up.wsgi_spitout)) {
PyErr_Print();
exit(1);
}
if (PyDict_SetItemString(up.embedded_dict, "applications", Py_None)) {
PyErr_Print();
exit(1);
}
if (uwsgi.is_a_reload) {
if (PyDict_SetItemString(up.embedded_dict, "is_a_reload", Py_True)) {
PyErr_Print();
exit(1);
}
}
else {
if (PyDict_SetItemString(up.embedded_dict, "is_a_reload", Py_False)) {
PyErr_Print();
exit(1);
}
}
up.embedded_args = PyTuple_New(2);
if (!up.embedded_args) {
PyErr_Print();
exit(1);
}
if (PyDict_SetItemString(up.embedded_dict, "message_manager_marshal", Py_None)) {
PyErr_Print();
exit(1);
}
init_uwsgi_module_advanced(new_uwsgi_module);
#ifdef UWSGI_SPOOLER
if (uwsgi.spoolers) {
init_uwsgi_module_spooler(new_uwsgi_module);
}
#endif
if (uwsgi.sharedareasize > 0 && uwsgi.sharedarea) {
init_uwsgi_module_sharedarea(new_uwsgi_module);
}
if (uwsgi.cache_max_items > 0) {
init_uwsgi_module_cache(new_uwsgi_module);
}
if (uwsgi.queue_size > 0) {
init_uwsgi_module_queue(new_uwsgi_module);
}
#ifdef UWSGI_SNMP
if (uwsgi.snmp) {
init_uwsgi_module_snmp(new_uwsgi_module);
}
#endif
if (up.extension) {
up.extension();
}
}
#endif
int uwsgi_python_magic(char *mountpoint, char *lazy) {
char *qc = strchr(lazy, ':');
if (qc) {
qc[0] = 0;
up.callable = qc + 1;
}
if (!strcmp(lazy + strlen(lazy) - 3, ".py")) {
up.file_config = lazy;
return 1;
}
else if (!strcmp(lazy + strlen(lazy) - 5, ".wsgi")) {
up.file_config = lazy;
return 1;
}
else if (qc && strchr(lazy, '.')) {
up.wsgi_config = lazy;
return 1;
}
// reset lazy
if (qc) {
qc[0] = ':';
}
return 0;
}
int
main(int argc, char *argv[])
{
PyObject *pName, *pModule, *pDict, *pFunc;
PyObject *pArgs, *pValue;
int i;
if (argc < 3) {
fprintf(stderr,"Usage: call pythonfile funcname [args]\n");
return 1;
}
Py_Initialize();
pName = PyString_FromString(argv[1]);
/* Error checking of pName left out */
pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (pModule != NULL) {
pFunc = PyObject_GetAttrString(pModule, argv[2]);
/* pFunc is a new reference */
if (pFunc && PyCallable_Check(pFunc)) {
pArgs = PyTuple_New(argc - 3);
for (i = 0; i < argc - 3; ++i) {
pValue = PyInt_FromLong(atoi(argv[i + 3]));
if (!pValue) {
Py_DECREF(pArgs);
Py_DECREF(pModule);
fprintf(stderr, "Cannot convert argument\n");
return 1;
}
/* pValue reference stolen here: */
PyTuple_SetItem(pArgs, i, pValue);
}
pValue = PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pArgs);
if (pValue != NULL) {
printf("Result of call: %ld\n", PyInt_AsLong(pValue));
Py_DECREF(pValue);
}
else {
Py_DECREF(pFunc);
Py_DECREF(pModule);
PyErr_Print();
fprintf(stderr,"Call failed\n");
return 1;
}
}
else {
if (PyErr_Occurred())
PyErr_Print();
fprintf(stderr, "Cannot find function \"%s\"\n", argv[2]);
}
Py_XDECREF(pFunc);
Py_DECREF(pModule);
}
else {
PyErr_Print();
fprintf(stderr, "Failed to load \"%s\"\n", argv[1]);
return 1;
}
Py_Finalize();
return 0;
}
int assimilate_handler(WORKUNIT& wu, std::vector<RESULT>& results, RESULT& canonical_result)
{
PyObject *retval;
initialize_python();
#if 0// OLD
retval = py_user_code_on_workunit(results, &canonical_result, "assimilators");
if(retval == NULL)
{
fprintf(stderr,"[%s:%d] There was a python error when assimilating %s.\nExiting.\n",__FILE__,__LINE__,canonical_result.name);
finalize_python();
exit(1);
}
Py_DECREF(retval);
if(PyErr_Occurred())
{
printf("Assimilation failed\n");
PyErr_Print();
finalize_python();
return 1;
}
#else // New
std::string command;
if(PyRun_SimpleString("import boinctools;results = []"))
{
fprintf(stderr,"Could not import boinctools python module.\n");
if(PyErr_Occurred())
PyErr_Print();
finalize_python();
exit(1);
}
// Create Result Class
command = "canonical = " + result_init_string(canonical_result);
if(PyRun_SimpleString(command.c_str()))
{
fprintf(stderr,"Could not create result object.\n");
fprintf(stderr,"Python command: %s",command.c_str());
if(PyErr_Occurred())
PyErr_Print();
finalize_python();
exit(1);
}
for(std::vector<RESULT>::const_iterator result = results.begin();result != results.end();result++)
{
command = "results.append(" + result_init_string(*result) + ")";
if(PyRun_SimpleString(command.c_str()))
{
fprintf(stderr,"Could not add result object to assimilation result list.\n");
fprintf(stderr,"Python command: %s",command.c_str());
if(PyErr_Occurred())
PyErr_Print();
finalize_python();
exit(1);
}
}
command = "boinctools.assimilator(results,canonical)";
if(PyRun_SimpleString(command.c_str()))
{
fprintf(stderr,"Could not assimilate result objects.\n");
fprintf(stderr,"Python command: %s",command.c_str());
if(PyErr_Occurred())
PyErr_Print();
finalize_python();
exit(1);
}
#endif
return 0;
}
void PythonScriptInterface::HandleEvent(int event_id, void *user, void *extra) {
ClientInfoTable *tbl = findClient(user, true);
mp_current_info_table = tbl;
PyObject* sys_mod_dict = PyImport_GetModuleDict();
PyObject* main_mod = PyMapping_GetItemString(sys_mod_dict, "__main__");
switch(event_id) {
case CHCGS_ClientConnectEvent: {
tbl->connection_object = PyObject_CallMethod(main_mod, mp_connection_handler->tp_name, "");
PyErr_Print();
printf("Client connect %p | %p (%s)\n", tbl->connection_object, mp_connection_handler, mp_connection_handler->tp_name);
break;
}
case CHCGS_ClientDisconnectEvent: {
Py_XDECREF(tbl->connection_object);
printf("Client disconnect\n");
break;
}
case CHCGS_EnterWorld: {
if(tbl->entity)
PyObject_CallMethod(tbl->entity, "OnEnterWorld", "");
break;
}
case CHCGS_ClientCommand: {
HandleClientCommand(user, (const char *)extra);
break;
}
case CHCGS_DialogResponse: {
DialogEvent *devent = (DialogEvent *)extra;
if(tbl->last_dialog_callback) {
PyObject *arglist = Py_BuildValue("iis",(int)devent->list_index, (int)devent->button_id,devent->input);
PyObject *ret = PyObject_CallObject(tbl->last_dialog_callback, arglist);
Py_DECREF(tbl->last_dialog_callback);
tbl->last_dialog_callback = NULL;
PyErr_Print();
Py_XDECREF(arglist);
Py_XDECREF(ret);
}
break;
}
case CHCGS_SpawnSelect: {
if(tbl->entity) {
PyObject_CallMethod(tbl->connection_object, "OnSpawnSelect", "i", extra);
}
break;
}
case CHCGS_ChatMessage: {
PyObject_CallMethod(tbl->connection_object, "OnChatMessage", "s", extra);
break;
}
case CHCGS_UIClick: {
if(tbl->mouse_callback) {
PyObject *arglist;
if(extra == (void *)-1) {
arglist = Py_BuildValue("Os", tbl->connection_object, NULL);
} else {
arglist = Py_BuildValue("Oi", tbl->connection_object,extra);
}
PyObject *ret = PyObject_CallObject(tbl->mouse_callback, arglist);
PyErr_Print();
Py_XDECREF(arglist);
Py_XDECREF(ret);
}
break;
}
case CHCGS_PlayerDeath: {
SAMPDeathInfo *death_info = (SAMPDeathInfo *)extra;
SAMPDriver *driver = this->getGameServer()->getSAMPDriver();
printf("Send death: %d %d\n", ((SAMPPlayer *)user)->GetPlayerID(), death_info->killer_id);
driver->BroadcastDeath((SAMPPlayer *)user, (SAMPPlayer *)driver->findPlayerByID(death_info->killer_id), 0);
break;
}
}
}
ZenController *zen_controller_new(const char *zendir, const char *profiles_dir)
{
ZenController *result;
char zen_path[PATH_MAX + 20] = { 0 };
PyObject *module, *cls;
result = malloc(sizeof(ZenController));
result->editor = NULL;
result->run_action = NULL;
result->set_context = NULL;
result->set_active_profile = NULL;
zen_controller_init_python();
PyRun_SimpleString("import sys");
snprintf(zen_path, PATH_MAX + 20 - 1, "sys.path.append('%s')", zendir);
PyRun_SimpleString(zen_path);
module = PyImport_ImportModule("zencoding");
if (module == NULL)
{
if (PyErr_Occurred())
PyErr_Print();
free(result);
return NULL;
}
/*
* For some reason on Python 2.7.0+ "pre-importing" these prevents a
* segfault below in zen_controller_run_action() where it calls the
* Zen Coding run_action() function.
*
* I would *LOVE* to know what's going on, I've spent far too long trying
* to debug this :)
*/
PyRun_SimpleString("import zencoding.actions");
PyRun_SimpleString("import zencoding.filters");
PyRun_SimpleString("import zencoding.utils");
result->run_action = PyObject_GetAttrString(module, "run_action");
if (result->run_action == NULL)
{
if (PyErr_Occurred())
PyErr_Print();
Py_XDECREF(module);
free(result);
return NULL;
}
if (!PyCallable_Check(result->run_action))
{
Py_XDECREF(result->run_action);
Py_XDECREF(module);
free(result);
return NULL;
}
Py_XDECREF(module);
module = zen_editor_module_init();
if (module == NULL)
{
if (PyErr_Occurred())
PyErr_Print();
Py_XDECREF(result->run_action);
free(result);
return NULL;
}
cls = PyObject_GetAttrString(module, "ZenEditor");
if (cls == NULL)
{
if (PyErr_Occurred())
PyErr_Print();
Py_XDECREF(module);
Py_XDECREF(result->run_action);
free(result);
return NULL;
}
Py_XDECREF(module);
result->editor = PyObject_CallObject(cls, NULL);
if (result->editor == NULL)
{
if (PyErr_Occurred())
PyErr_Print();
Py_XDECREF(cls);
Py_XDECREF(result->run_action);
free(result);
return NULL;
}
Py_XDECREF(cls);
result->set_context = PyObject_GetAttrString(result->editor, "set_context");
if (result->set_context == NULL)
{
if (PyErr_Occurred())
PyErr_Print();
Py_XDECREF(result->editor);
Py_XDECREF(result->run_action);
free(result);
return NULL;
}
else if (!PyCallable_Check(result->set_context))
{
Py_XDECREF(result->editor);
Py_XDECREF(result->run_action);
Py_XDECREF(result->set_context);
free(result);
return NULL;
}
result->set_active_profile = PyObject_GetAttrString(result->editor, "set_profile_name");
if (result->set_active_profile == NULL)
{
if (PyErr_Occurred())
PyErr_Print();
Py_XDECREF(result->editor);
Py_XDECREF(result->run_action);
Py_XDECREF(result->set_context);
free(result);
return NULL;
}
else if (!PyCallable_Check(result->set_active_profile))
{
Py_XDECREF(result->editor);
Py_XDECREF(result->run_action);
Py_XDECREF(result->set_context);
Py_XDECREF(result->set_active_profile);
free(result);
return NULL;
}
/* Initialize/setup profiles */
PyObject *res;
res = PyObject_CallMethod(result->editor, "init_profiles", "(s)", profiles_dir);
if (res == NULL)
{
if (PyErr_Occurred())
PyErr_Print();
g_warning("Unable to initialize profiles");
}
else
Py_XDECREF(res);
return result;
}
Bool eval_intermediate_callback(Index alg_mod, /* 0 is regular, 1 is resto */
Index iter_count, Number obj_value,
Number inf_pr, Number inf_du,
Number mu, Number d_norm,
Number regularization_size,
Number alpha_du, Number alpha_pr,
Index ls_trials, UserDataPtr data)
{
logger("[Callback:E]intermediate_callback");
DispatchData *myowndata = (DispatchData *) data;
UserDataPtr user_data = (UserDataPtr) myowndata->userdata;
long result_as_long;
Bool result_as_bool;
PyObject *python_algmod = Py_BuildValue("i", alg_mod);
PyObject *python_iter_count = Py_BuildValue("i", iter_count);
PyObject *python_obj_value = Py_BuildValue("d", obj_value);
PyObject *python_inf_pr = Py_BuildValue("d", inf_pr);
PyObject *python_inf_du = Py_BuildValue("d", inf_du);
PyObject *python_mu = Py_BuildValue("d", mu);
PyObject *python_d_norm = Py_BuildValue("d", d_norm);
PyObject *python_regularization_size =
Py_BuildValue("d", regularization_size);
PyObject *python_alpha_du = Py_BuildValue("d", alpha_du);
PyObject *python_alpha_pr = Py_BuildValue("d", alpha_pr);
PyObject *python_ls_trials = Py_BuildValue("i", ls_trials);
PyObject *arglist = NULL;
if (user_data != NULL)
arglist = Py_BuildValue("(OOOOOOOOOOOO)",
python_algmod,
python_iter_count,
python_obj_value,
python_inf_pr,
python_inf_du,
python_mu,
python_d_norm,
python_regularization_size,
python_alpha_du,
python_alpha_pr,
python_ls_trials,
(PyObject *) user_data);
else
arglist = Py_BuildValue("(OOOOOOOOOOO)",
python_algmod,
python_iter_count,
python_obj_value,
python_inf_pr,
python_inf_du,
python_mu,
python_d_norm,
python_regularization_size,
python_alpha_du,
python_alpha_pr, python_ls_trials);
PyObject *result =
PyObject_CallObject(myowndata->eval_intermediate_callback_python,
arglist);
if (!result)
PyErr_Print();
result_as_long = PyInt_AsLong(result);
result_as_bool = (Bool) result_as_long;
Py_DECREF(result);
Py_CLEAR(arglist);
logger("[Callback:R] intermediate_callback");
return result_as_bool;
}
void XBPyThread::Process()
{
CLog::Log(LOGDEBUG,"Python thread: start processing");
char path[1024];
char sourcedir[1024];
// get the global lock
PyEval_AcquireLock();
m_threadState = Py_NewInterpreter();
PyEval_ReleaseLock();
if (!m_threadState) {
CLog::Log(LOGERROR,"Python thread: FAILED to get thread state!");
return;
}
PyEval_AcquireLock();
// swap in my thread state
PyThreadState_Swap(m_threadState);
m_pExecuter->InitializeInterpreter();
// 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
strcpy(sourcedir, source);
#ifndef _LINUX
strcpy(strrchr(sourcedir, PATH_SEPARATOR_CHAR), ";");
#else
strcpy(strrchr(sourcedir, PATH_SEPARATOR_CHAR), ":");
#endif
strcpy(path, sourcedir);
#ifndef _LINUX
strcat(path, dll_getenv("PYTHONPATH"));
#else
#ifdef __APPLE__
strcat(path, _P("Q:\\system\\python\\python24.zlib:"));
strcat(path, _P("Q:\\system\\python\\lib-osx"));
#else
strcat(path, Py_GetPath());
#endif
#endif
// set current directory and python's path.
if (argv != NULL)
{
PySys_SetArgv(argc, argv);
}
PySys_SetPath(path);
#ifdef _LINUX
// Replace the : at the end with ; so it will be EXACTLY like the xbox version
strcpy(strrchr(sourcedir, ':'), ";");
#endif
xbp_chdir(sourcedir); // XXX, there is a ';' at the end
if (type == 'F')
{
// run script from file
FILE *fp = fopen(source, "r");
if (fp)
{
if (PyRun_SimpleFile(fp, source) == -1)
{
CLog::Log(LOGERROR, "Scriptresult: Error\n");
if (PyErr_Occurred()) PyErr_Print();
}
else CLog::Log(LOGINFO, "Scriptresult: Succes\n");
fclose(fp);
}
else CLog::Log(LOGERROR, "%s not found!\n", source);
}
else
{
//run script
if (PyRun_SimpleString(source) == -1)
{
CLog::Log(LOGERROR, "Scriptresult: Error\n");
if (PyErr_Occurred()) PyErr_Print();
}
else CLog::Log(LOGINFO, "Scriptresult: Success\n");
}
PyEval_ReleaseLock();
// when a script uses threads or timers - we have to wait for them to be over before we terminate the interpreter.
// so first - release the lock and allow the threads to terminate.
::Sleep(500);
PyEval_AcquireLock();
PyThreadState_Swap(m_threadState);
// look waiting for the running threads to end
PyRun_SimpleString(
"import threading\n"
"import sys\n"
"try:\n"
"\tthreads = list(threading.enumerate())\n"
"except:\n"
"\tprint 'error listing threads'\n"
"while threading.activeCount() > 1:\n"
"\tfor thread in threads:\n"
"\t\tif thread <> threading.currentThread():\n"
"\t\t\tprint 'waiting for thread - ' + thread.getName()\n"
"\t\t\tthread.join(1000)\n"
);
m_pExecuter->DeInitializeInterpreter();
Py_EndInterpreter(m_threadState);
m_threadState = NULL;
PyEval_ReleaseLock();
}
/* move_player
*
* called each tick, updating the player's position
*/
int
monster_move(PyObject *monster)
{
int x1, y1; /* current position */
int x2, y2; /* target position */
int speed;
node_t *active_path;
/* Check if we have an active path */
active_path = (node_t*)py_getattr_int(monster, ATTR_INT_ACTIVE_PATH);
if (active_path == 0)
return 0;
x1 = py_getattr_int(monster, ATTR_X);
y1 = py_getattr_int(monster, ATTR_Y);
x2 = active_path->x;
y2 = active_path->y;
speed = py_getattr_int(monster, ATTR_INT_SPEED);
/* monster-move-int
* ----------------
*/
int dx = 0, dy = 0;
int sx, sy;
int err;
int x, y;
int i;
dx = abs(x2-x1);
dy = abs(y2-y1);
if (x1 < x2) sx = 1; else sx = -1;
if (y1 < y2) sy = 1; else sy = -1;
err = dx-dy;
x = x1;
y = y1;
for(i = 0;i < speed; i++) {
if (x == x2 && y == y2)
break;
int e2 = 2 * err;
if (e2 > -dy) {
err = err - dy;
x += sx;
}
if (x == x2 && y == y2) {
break;
}
if (e2 < dx) {
err = err + dx;
y += sy;
}
}
py_setattr_int(monster, ATTR_X, x);
py_setattr_int(monster, ATTR_Y, y);
/* We've reached our target */
if (x == x2 && y == y2) {
active_path = active_path->child;
py_setattr_int(monster, ATTR_INT_ACTIVE_PATH, (long)active_path);
}
return 0;
#if 0
/* FIXME! Call playerExit-method on tile we're leaving*/
tmp = PyObject_CallMethod(
p->map->tiles[prev_tile_x + prev_tile_y * p->map->width]->py_obj,
"playerExit", "", NULL);
if (tmp == NULL) { PyErr_Print(); return -1; }
Py_DECREF(tmp);
/* FIXME! Call playerEnter-method on tile we're entering*/
tmp = PyObject_CallMethod(p->map->tiles[p->tile_x + p->tile_y * p->map->width]->py_obj,
"playerEnter", "", NULL);
if (tmp == NULL) { PyErr_Print(); return -1; }
Py_DECREF(tmp);
p->is_dirty = 1;
#endif
}
CompiledPythonFragment * getCompiledCode( Table * table, int pkey, const QString & pCode, const QString & codeName )
{
CompiledPythonFragment * ret = 0;
ensurePythonInitialized();
// Create the key for looking up the code fragment in the cache
QPair<Table*,int> codeKey = qMakePair(table,pkey);
// Return the cached code fragment, if the code still matches
if( codeCache.contains( codeKey ) ) {
CompiledPythonFragment * frag = &codeCache[codeKey];
// This should actually be very fast because of QString's
// implicit sharing, should usually just be a pointer comparison
if( frag->codeString == pCode )
return frag;
// Remove from cache if the fragment is out of date
// TODO: This should free any references and remove the module
// this isn't a big deal though, since code fragments won't
// change very often during program execution
codeCache.remove( codeKey );
}
if( pCode.isEmpty() )
return 0;
// Compile the code
CompiledPythonFragment frag;
frag.codeString = pCode;
SIP_BLOCK_THREADS
frag.code = (PyCodeObject*)Py_CompileString( pCode.toLatin1(), codeName.toLatin1(), Py_file_input );
SIP_UNBLOCK_THREADS
if( !frag.code )
{
PyErr_Print();
LOG_5( "PathTemplate:getCompiledCode: Error Compiling Python code for: " + table->schema()->tableName() + " " + QString::number( pkey ) + " " + codeName );
return 0;
}
// Load the code into a module
// This is the only way i could figure out how to make the globals work properly
// before i was using PyEval_EvalCode, passing the __main__ dict as the globals
// but this wasn't working properly when calling the functions later, because
// the import statements were lost.
// This method works great and takes less code.
// Generate a unique module name
QString moduleName = "__" + table->schema()->tableName() + "__" + QString::number(pkey) + "__";
// Returns a NEW ref
SIP_BLOCK_THREADS
PyObject * module = PyImport_ExecCodeModule(moduleName.toLatin1().data(),(PyObject*)frag.code);
if( !module ) {
PyErr_Print();
LOG_3( "Unable to execute code module" );
}
// Save the modules dict, so we can lookup the function later
else {
frag.locals = PyModule_GetDict(module);
Py_INCREF(frag.locals);
codeCache[codeKey] = frag;
ret = &codeCache[codeKey];
}
SIP_UNBLOCK_THREADS
return ret;
}
int main(int argc, char *argv[])
{
// Use UTF-8, ignoring any LANG settings in the environment
QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
{ // Set the default OpenGL version to be 2.1 with sample buffers
QSurfaceFormat format;
format.setVersion(2, 1);
QSurfaceFormat::setDefaultFormat(format);
}
// Create the Application object
App app(argc, argv);
// Initialize various Python modules and the interpreter itself
fab::preInit();
Graph::preInit();
AppHooks::preInit();
Py_Initialize();
// Set locale to C to make atof correctly parse floats
setlocale(LC_NUMERIC, "C");
{ // Modify Python's default search path to include the application's
// directory (as this doesn't happen on Linux by default)
#if defined Q_OS_MAC
QStringList path = QCoreApplication::applicationDirPath().split("/");
path.removeLast();
path << "Resources";
fab::postInit({path.join("/").toStdString()});
#elif defined Q_OS_LINUX
auto dir = QCoreApplication::applicationDirPath();
std::vector<std::string> fab_paths =
{(dir + "/sb").toStdString(),
(dir + "/../share/antimony/").toStdString()};
for (auto p : QStandardPaths::standardLocations(
QStandardPaths::AppDataLocation))
{
fab_paths.push_back(p.toStdString());
}
fab::postInit(fab_paths);
#else
#error "Unknown OS!"
#endif
}
{ // Install operator.or_ as a reducer for shapes
auto op = PyImport_ImportModule("operator");
Datum::installReducer(fab::ShapeType, PyObject_GetAttrString(op, "or_"));
Py_DECREF(op);
}
{ // Check to make sure that the fab module exists
PyObject* fab = PyImport_ImportModule("fab");
if (!fab)
{
PyErr_Print();
QMessageBox::critical(NULL, "Import error",
"Import Error:<br><br>"
"Could not find <tt>fab</tt> Python module.<br>"
"Antimony will now exit.");
exit(1);
}
Py_DECREF(fab);
}
{ // Parse command-line arguments
QCommandLineParser parser;
parser.setApplicationDescription("CAD from a parallel universe");
parser.addHelpOption();
QCommandLineOption forceHeightmap("heightmap",
"Open 3D windows in heightmap mode");
parser.addOption(forceHeightmap);
parser.addPositionalArgument("file", "File to open", "[file]");
parser.process(app);
auto args = parser.positionalArguments();
if (args.length() > 1)
{
qCritical("Too many command-line arguments");
exit(1);
}
else if (args.length() == 1)
{
app.loadFile(args[0]);
}
}
app.makeDefaultWindows();
return app.exec();
}
void PythonHostEnvironment::printError()
{
PyErr_Print();
PyErr_Clear();
}
PyMODINIT_FUNC initnumpy_quaternion(void)
{
PyObject *m;
int quaternionNum;
PyObject* numpy = PyImport_ImportModule("numpy");
PyObject* numpy_dict = PyModule_GetDict(numpy);
int arg_types[3];
m = Py_InitModule("numpy_quaternion", QuaternionMethods);
if (m == NULL) {
return;
}
/* Make sure NumPy is initialized */
import_array();
import_umath();
/* Register the quaternion array scalar type */
#if defined(NPY_PY3K)
PyQuaternionArrType_Type.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
#else
PyQuaternionArrType_Type.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_CHECKTYPES;
#endif
PyQuaternionArrType_Type.tp_new = quaternion_arrtype_new;
PyQuaternionArrType_Type.tp_richcompare = gentype_richcompare;
PyQuaternionArrType_Type.tp_hash = quaternion_arrtype_hash;
PyQuaternionArrType_Type.tp_repr = quaternion_arrtype_repr;
PyQuaternionArrType_Type.tp_str = quaternion_arrtype_str;
PyQuaternionArrType_Type.tp_base = &PyGenericArrType_Type;
if (PyType_Ready(&PyQuaternionArrType_Type) < 0) {
PyErr_Print();
PyErr_SetString(PyExc_SystemError, "could not initialize PyQuaternionArrType_Type");
return;
}
/* The array functions */
PyArray_InitArrFuncs(&_PyQuaternion_ArrFuncs);
_PyQuaternion_ArrFuncs.getitem = (PyArray_GetItemFunc*)QUATERNION_getitem;
_PyQuaternion_ArrFuncs.setitem = (PyArray_SetItemFunc*)QUATERNION_setitem;
_PyQuaternion_ArrFuncs.copyswap = (PyArray_CopySwapFunc*)QUATERNION_copyswap;
_PyQuaternion_ArrFuncs.copyswapn = (PyArray_CopySwapNFunc*)QUATERNION_copyswapn;
_PyQuaternion_ArrFuncs.compare = (PyArray_CompareFunc*)QUATERNION_compare;
_PyQuaternion_ArrFuncs.argmax = (PyArray_ArgFunc*)QUATERNION_argmax;
_PyQuaternion_ArrFuncs.nonzero = (PyArray_NonzeroFunc*)QUATERNION_nonzero;
_PyQuaternion_ArrFuncs.fillwithscalar = (PyArray_FillWithScalarFunc*)QUATERNION_fillwithscalar;
/* The quaternion array descr */
quaternion_descr = PyObject_New(PyArray_Descr, &PyArrayDescr_Type);
quaternion_descr->typeobj = &PyQuaternionArrType_Type;
quaternion_descr->kind = 'q';
quaternion_descr->type = 'j';
quaternion_descr->byteorder = '=';
quaternion_descr->type_num = 0; /* assigned at registration */
quaternion_descr->elsize = 8*4;
quaternion_descr->alignment = 8;
quaternion_descr->subarray = NULL;
quaternion_descr->fields = NULL;
quaternion_descr->names = NULL;
quaternion_descr->f = &_PyQuaternion_ArrFuncs;
Py_INCREF(&PyQuaternionArrType_Type);
quaternionNum = PyArray_RegisterDataType(quaternion_descr);
if (quaternionNum < 0)
return;
register_cast_function(NPY_BOOL, quaternionNum, (PyArray_VectorUnaryFunc*)BOOL_to_quaternion);
register_cast_function(NPY_BYTE, quaternionNum, (PyArray_VectorUnaryFunc*)BYTE_to_quaternion);
register_cast_function(NPY_UBYTE, quaternionNum, (PyArray_VectorUnaryFunc*)UBYTE_to_quaternion);
register_cast_function(NPY_SHORT, quaternionNum, (PyArray_VectorUnaryFunc*)SHORT_to_quaternion);
register_cast_function(NPY_USHORT, quaternionNum, (PyArray_VectorUnaryFunc*)USHORT_to_quaternion);
register_cast_function(NPY_INT, quaternionNum, (PyArray_VectorUnaryFunc*)INT_to_quaternion);
register_cast_function(NPY_UINT, quaternionNum, (PyArray_VectorUnaryFunc*)UINT_to_quaternion);
register_cast_function(NPY_LONG, quaternionNum, (PyArray_VectorUnaryFunc*)LONG_to_quaternion);
register_cast_function(NPY_ULONG, quaternionNum, (PyArray_VectorUnaryFunc*)ULONG_to_quaternion);
register_cast_function(NPY_LONGLONG, quaternionNum, (PyArray_VectorUnaryFunc*)LONGLONG_to_quaternion);
register_cast_function(NPY_ULONGLONG, quaternionNum, (PyArray_VectorUnaryFunc*)ULONGLONG_to_quaternion);
register_cast_function(NPY_FLOAT, quaternionNum, (PyArray_VectorUnaryFunc*)FLOAT_to_quaternion);
register_cast_function(NPY_DOUBLE, quaternionNum, (PyArray_VectorUnaryFunc*)DOUBLE_to_quaternion);
register_cast_function(NPY_LONGDOUBLE, quaternionNum, (PyArray_VectorUnaryFunc*)LONGDOUBLE_to_quaternion);
register_cast_function(NPY_CFLOAT, quaternionNum, (PyArray_VectorUnaryFunc*)CFLOAT_to_quaternion);
register_cast_function(NPY_CDOUBLE, quaternionNum, (PyArray_VectorUnaryFunc*)CDOUBLE_to_quaternion);
register_cast_function(NPY_CLONGDOUBLE, quaternionNum, (PyArray_VectorUnaryFunc*)CLONGDOUBLE_to_quaternion);
#define REGISTER_UFUNC(name)\
PyUFunc_RegisterLoopForType((PyUFuncObject *)PyDict_GetItemString(numpy_dict, #name),\
quaternion_descr->type_num, quaternion_##name##_ufunc, arg_types, NULL)
#define REGISTER_SCALAR_UFUNC(name)\
PyUFunc_RegisterLoopForType((PyUFuncObject *)PyDict_GetItemString(numpy_dict, #name),\
quaternion_descr->type_num, quaternion_##name##_scalar_ufunc, arg_types, NULL)
/* quat -> bool */
arg_types[0] = quaternion_descr->type_num;
arg_types[1] = NPY_BOOL;
REGISTER_UFUNC(isnan);
REGISTER_UFUNC(isinf);
REGISTER_UFUNC(isfinite);
/* quat -> double */
arg_types[1] = NPY_DOUBLE;
REGISTER_UFUNC(absolute);
/* quat -> quat */
arg_types[1] = quaternion_descr->type_num;
REGISTER_UFUNC(log);
REGISTER_UFUNC(exp);
REGISTER_UFUNC(negative);
REGISTER_UFUNC(conjugate);
/* quat, quat -> bool */
arg_types[2] = NPY_BOOL;
REGISTER_UFUNC(equal);
REGISTER_UFUNC(not_equal);
REGISTER_UFUNC(less);
REGISTER_UFUNC(less_equal);
/* quat, double -> quat */
arg_types[1] = NPY_DOUBLE;
arg_types[2] = quaternion_descr->type_num;
REGISTER_SCALAR_UFUNC(multiply);
REGISTER_SCALAR_UFUNC(divide);
REGISTER_SCALAR_UFUNC(power);
/* quat, quat -> quat */
arg_types[1] = quaternion_descr->type_num;
REGISTER_UFUNC(add);
REGISTER_UFUNC(subtract);
REGISTER_UFUNC(multiply);
REGISTER_UFUNC(divide);
REGISTER_UFUNC(power);
REGISTER_UFUNC(copysign);
PyModule_AddObject(m, "quaternion", (PyObject *)&PyQuaternionArrType_Type);
}
static int
CPyStreamWrapper_Read (CPyStreamWrapper *wrapper, void *buf, pguint32 offset,
pguint32 count, pguint32 *read_)
{
PyObject *result;
pguint32 off, _read = 0;
int retval = 1;
char *tmp;
char *ptr = (char*) buf;
if (!wrapper->read || !wrapper->seek || !read_)
return 0;
if (offset != 0)
{
/* Move to the correct offset. */
result = PyObject_CallFunction (wrapper->seek, "li", offset, SEEK_SET);
if (!result)
{
PyErr_Print();
retval = 0;
goto end;
}
Py_DECREF (result);
}
if (count == 0)
{
/* Just a seek was wanted */
goto end;
}
result = PyObject_CallFunction (wrapper->read, "l", count);
if (!result)
{
PyErr_Print ();
retval = 0;
goto end;
}
if (!Bytes_Check (result))
{
Py_DECREF (result);
PyErr_Print ();
retval = 0;
goto end;
}
_read = (pguint32) Bytes_GET_SIZE (result);
tmp = Bytes_AS_STRING (result);
off = 0;
while ((_read - off) > SIZE_MAX)
{
memcpy (ptr + off, tmp + off, SIZE_MAX);
off += SIZE_MAX;
}
memcpy (ptr + off, tmp + off, (size_t) (_read - off));
Py_DECREF (result);
end:
*read_ = _read;
return retval;
}
int AppMain()
{
std::wstring exe_dir;
// Get exe's directory
{
wchar_t exe_path_buf[MAX_PATH + 1];
GetModuleFileName(NULL, exe_path_buf, MAX_PATH);
exe_dir = exe_path_buf;
size_t last_backslash_pos = exe_dir.find_last_of(L"\\/");
if (last_backslash_pos >= 0)
{
exe_dir = exe_dir.substr(0, last_backslash_pos);
}
else
{
exe_dir = L"";
}
}
// Setup environment variable "PATH"
{
std::wstring env_path;
wchar_t tmp_buf[1];
DWORD ret = GetEnvironmentVariable(L"PATH", tmp_buf, 0);
if (ret > 0)
{
DWORD len = ret;
wchar_t * buf = (wchar_t*)malloc((len + 1) * sizeof(wchar_t));
GetEnvironmentVariable(L"PATH", buf, (len + 1) * sizeof(wchar_t));
env_path = buf;
free(buf);
}
env_path = exe_dir + L"/lib;" + env_path;
SetEnvironmentVariable(L"PATH", env_path.c_str());
}
// Python home
{
#if defined(_DEBUG)
Py_SetPythonHome(PYTHON_INSTALL_PATH);
#else
Py_SetPythonHome(const_cast<wchar_t*>(exe_dir.c_str()));
#endif //_DEBUG
}
// Python module search path
{
std::wstring python_path;
python_path += exe_dir + L"/extension;";
#if defined(_DEBUG)
python_path += exe_dir + L";";
python_path += exe_dir + L"/..;";
python_path += std::wstring(PYTHON_INSTALL_PATH) + L"\\Lib;";
python_path += std::wstring(PYTHON_INSTALL_PATH) + L"\\Lib\\site-packages;";
python_path += std::wstring(PYTHON_INSTALL_PATH) + L"\\DLLs;";
#else
python_path += exe_dir + L"/library.zip;";
python_path += exe_dir + L"/lib;";
#endif
Py_SetPath(python_path.c_str());
}
// Initialization
Py_Initialize();
// Setup sys.argv
{
wchar_t * cmdline = GetCommandLine();
int argc;
wchar_t ** argv = CommandLineToArgvW(cmdline, &argc);
PySys_SetArgv(argc, argv);
LocalFree(argv);
}
// Execute python side main script
{
PyObject * module = PyImport_ImportModule("keyhac_main");
if (module == NULL)
{
PyErr_Print();
}
Py_XDECREF(module);
module = NULL;
}
// Termination
Py_Finalize();
return 0;
}
Bool
eval_jac_g(Index n, Number * x, Bool new_x,
Index m, Index nele_jac,
Index * iRow, Index * jCol, Number * values, UserDataPtr data)
{
logger("[Callback:E] eval_jac_g");
DispatchData *myowndata = (DispatchData *) data;
UserDataPtr user_data = (UserDataPtr) myowndata->userdata;
int i;
long *rowd = NULL;
long *cold = NULL;
/* int dims[1]; */
npy_intp dims[1];
dims[0] = n;
double *tempdata;
if (myowndata->eval_grad_f_python == NULL) /* Why??? */
PyErr_Print();
if (values == NULL) {
/* import_array (); */
import_array1(FALSE);
PyObject *arrayx =
PyArray_SimpleNewFromData(1, dims, PyArray_DOUBLE,
(char *)x);
if (!arrayx)
return FALSE;
PyObject *arglist;
if (user_data != NULL)
arglist = Py_BuildValue("(OOO)",
arrayx, Py_True,
(PyObject *) user_data);
else
arglist = Py_BuildValue("(OO)", arrayx, Py_True);
PyObject *result =
PyObject_CallObject(myowndata->eval_jac_g_python, arglist);
if (!result) {
logger("[PyIPOPT] return from eval_jac_g is null\n");
/* TODO: need to deal with reference counting here */
return FALSE;
}
if (!PyTuple_Check(result)) {
PyErr_Print();
}
PyArrayObject *row =
(PyArrayObject *) PyTuple_GetItem(result, 0);
PyArrayObject *col =
(PyArrayObject *) PyTuple_GetItem(result, 1);
if (!row || !col || !PyArray_Check(row) || !PyArray_Check(col)) {
logger
("[Error] there are problems with row or col in eval_jac_g.\n");
PyErr_Print();
}
rowd = (long *)row->data;
cold = (long *)col->data;
for (i = 0; i < nele_jac; i++) {
iRow[i] = (Index) rowd[i];
jCol[i] = (Index) cold[i];
}
Py_CLEAR(arrayx);
Py_DECREF(result);
Py_CLEAR(arglist);
logger("[Callback:R] eval_jac_g(1)");
} else {
PyObject *arrayx =
PyArray_SimpleNewFromData(1, dims, PyArray_DOUBLE,
(char *)x);
if (!arrayx)
return FALSE;
if (new_x && myowndata->apply_new_python) {
/* Call the python function to applynew */
PyObject *arg1 = Py_BuildValue("(O)", arrayx);
PyObject *tempresult =
PyObject_CallObject(myowndata->apply_new_python,
arg1);
if (tempresult == NULL) {
logger("[Error] Python function apply_new returns NULL");
Py_DECREF(arg1);
return FALSE;
}
Py_DECREF(arg1);
Py_DECREF(tempresult);
}
PyObject *arglist;
if (user_data != NULL)
arglist = Py_BuildValue("(OOO)",
arrayx, Py_False,
(PyObject *) user_data);
else
arglist = Py_BuildValue("(OO)", arrayx, Py_False);
PyArrayObject *result = (PyArrayObject *) PyObject_CallObject(
myowndata->eval_jac_g_python, arglist);
if (result == NULL) {
logger("[Error] Python function eval_jac_g returns NULL");
PyErr_Print();
return FALSE;
}
if (!PyArray_Check(result)) {
logger("[Error] Python function eval_jac_g returns non-PyArray");
Py_DECREF(result);
return FALSE;
}
/*
* Code is buggy here. We assume that result is a double
* array
*/
assert(result->descr->type == 'd');
tempdata = (double *)result->data;
for (i = 0; i < nele_jac; i++)
values[i] = tempdata[i];
Py_DECREF(result);
Py_CLEAR(arrayx);
Py_CLEAR(arglist);
logger("[Callback:R] eval_jac_g(2)");
}
logger("[Callback:R] eval_jac_g");
return TRUE;
}
PyObject * sipWrapRecord( Record * r, bool makeCopy, TableSchema * defaultType )
{
PyObject * ret = 0;
// First we convert to Record using sip methods
static sipTypeDef * recordType = getRecordType( "blur.Stone", "Record" );
sipTypeDef * type = recordType;
if( type ) {
if( makeCopy )
ret = getSipAPI()->api_convert_from_new_type( new Record(*r), type, NULL );
else {
ret = getSipAPI()->api_convert_from_type( r, type, Py_None );
}
} else {
LOG_1( "Stone.Record not found" );
return 0;
}
Table * table = r->table();
TableSchema * tableSchema = 0;
if( table )
tableSchema = table->schema();
else if( defaultType )
tableSchema = defaultType;
else
return ret;
bool isErr = false;
if( tableSchema ) {
QString className = tableSchema->className();
// Then we try to find the python class for the particular schema class type
// from the desired module set using addSchemaCastModule
// BORROWED ref
PyObject * dict = getSchemaCastModule( tableSchema->schema() );
if( dict ) {
SIP_BLOCK_THREADS
// BORROWED ref
PyObject * klass = PyDict_GetItemString( dict, className.toLatin1().constData() );
if( klass ) {
PyObject * tuple = PyTuple_New(1);
// Tuple now holds only ref to ret
PyTuple_SET_ITEM( tuple, 0, ret );
PyObject * result = PyObject_CallObject( klass, tuple );
if( result ) {
if( PyObject_IsInstance( result, klass ) == 1 ) {
ret = result;
} else {
LOG_1( "Cast Ctor Result is not a subclass of " + className );
Py_INCREF( ret );
Py_DECREF( result );
}
} else {
LOG_1( "runPythonFunction: Execution Failed, Error Was:\n" );
PyErr_Print();
isErr = true;
}
Py_DECREF( tuple );
}
SIP_UNBLOCK_THREADS
if( isErr ) return 0;
} else LOG_1( "No cast module set for schema" );
} else LOG_1( "Table has no schema" );
Bool
eval_h(Index n, Number * x, Bool new_x, Number obj_factor,
Index m, Number * lambda, Bool new_lambda,
Index nele_hess, Index * iRow, Index * jCol,
Number * values, UserDataPtr data)
{
logger("[Callback:E] eval_h");
DispatchData *myowndata = (DispatchData *) data;
UserDataPtr user_data = (UserDataPtr) myowndata->userdata;
int i;
npy_intp dims[1];
npy_intp dims2[1];
if (myowndata->eval_h_python == NULL) {
logger("[Error] There is no eval_h assigned");
return FALSE;
}
if (values == NULL) {
logger("[Callback:E] eval_h (1a)");
PyObject *newx = Py_True;
PyObject *objfactor = Py_BuildValue("d", obj_factor);
PyObject *lagrange = Py_True;
PyObject *arglist;
if (user_data != NULL) {
arglist = Py_BuildValue(
"(OOOOO)", newx, lagrange, objfactor, Py_True,
(PyObject *) user_data);
} else {
arglist = Py_BuildValue(
"(OOOO)", newx, lagrange, objfactor, Py_True);
}
if (arglist == NULL) {
logger("[Error] failed to build arglist for eval_h");
PyErr_Print();
return FALSE;
} else {
logger("[Logspam] built arglist for eval_h");
}
PyObject *result = PyObject_CallObject(myowndata->eval_h_python, arglist);
if (result == NULL) {
logger("[Error] Python function eval_h returns NULL");
PyErr_Print();
return FALSE;
} else {
logger("[Logspam] Python function eval_h returns non-NULL");
}
int result_size = PyTuple_Size(result);
if (result_size == -1) {
logger("[Error] Python function eval_h returns non-PyTuple");
Py_DECREF(result);
return FALSE;
}
if (result_size != 2) {
logger("[Error] Python function eval_h returns a tuple whose len != 2");
Py_DECREF(result);
return FALSE;
}
logger("[Callback:E] eval_h (tuple is the right length)");
PyArrayObject *row = (PyArrayObject *) PyTuple_GetItem(result, 0);
PyArrayObject *col = (PyArrayObject *) PyTuple_GetItem(result, 1);
long *rdata = (long *)row->data;
long *cdata = (long *)col->data;
for (i = 0; i < nele_hess; i++) {
iRow[i] = (Index) rdata[i];
jCol[i] = (Index) cdata[i];
/*
* logger("PyIPOPT_DEBUG %d, %d\n", iRow[i],
* jCol[i]);
*/
}
logger("[Callback:E] eval_h (clearing stuff now)");
Py_DECREF(objfactor);
Py_DECREF(result);
Py_CLEAR(arglist);
logger("[Callback:R] eval_h (1b)");
} else {
logger("[Callback:R] eval_h (2a)");
PyObject *objfactor = Py_BuildValue("d", obj_factor);
dims[0] = n;
PyObject *arrayx =
PyArray_SimpleNewFromData(1, dims, PyArray_DOUBLE,
(char *)x);
if (!arrayx)
return FALSE;
if (new_x && myowndata->apply_new_python) {
/* Call the python function to applynew */
PyObject *arg1 = Py_BuildValue("(O)", arrayx);
PyObject *tempresult = PyObject_CallObject(
myowndata->apply_new_python, arg1);
if (tempresult == NULL) {
logger("[Error] Python function apply_new returns NULL");
PyErr_Print();
Py_DECREF(arg1);
return FALSE;
}
Py_DECREF(arg1);
Py_DECREF(tempresult);
}
dims2[0] = m;
PyObject *lagrangex = PyArray_SimpleNewFromData(
1, dims2, PyArray_DOUBLE, (char *)lambda);
if (!lagrangex)
return FALSE;
PyObject *arglist;
if (user_data != NULL) {
arglist = Py_BuildValue(
"(OOOOO)", arrayx, lagrangex, objfactor, Py_False,
(PyObject *) user_data);
} else {
arglist = Py_BuildValue(
"(OOOO)", arrayx, lagrangex, objfactor, Py_False);
}
PyArrayObject *result = (PyArrayObject *) PyObject_CallObject(
myowndata->eval_h_python, arglist);
if (result == NULL) {
logger("[Error] Python function eval_h returns NULL");
PyErr_Print();
return FALSE;
}
if (!PyArray_Check(result)) {
logger("[Error] Python function eval_h returns non-PyArray");
Py_DECREF(result);
return FALSE;
}
double *tempdata = (double *)result->data;
for (i = 0; i < nele_hess; i++) {
values[i] = tempdata[i];
logger("PyDebug %lf", values[i]);
}
Py_CLEAR(arrayx);
Py_CLEAR(lagrangex);
Py_CLEAR(objfactor);
Py_DECREF(result);
Py_CLEAR(arglist);
logger("[Callback:R] eval_h (2b)");
}
return TRUE;
}
static int
TargetCall(WsXmlDocH doc, PyObject* instance,
const char* opname, int nargs, ...)
{
va_list vargs;
PyObject *pyargs = NULL;
PyObject *pyfunc = NULL;
PyObject *result = NULL;
WsmanStatus status;
wsman_status_init(&status);
pyargs = PyTuple_New(nargs);
pyfunc = PyObject_GetAttrString(instance, opname);
if (pyfunc == NULL)
{
PyErr_Print();
PyErr_Clear();
char* str = fmtstr("Python module does not contain \"%s\"", opname);
debug("%s", str);
status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
status.fault_detail_code = 0;
free(str);
goto cleanup;
}
if (! PyCallable_Check(pyfunc))
{
char* str = fmtstr("Python module attribute \"%s\" is not callable",
opname);
debug("%s", str);
status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
status.fault_detail_code = 0;
free(str);
goto cleanup;
}
va_start(vargs, nargs);
int i;
for (i = 0; i < nargs; ++i)
{
PyObject* arg = va_arg(vargs, PyObject*);
if (arg == NULL)
{
arg = Py_None;
Py_IncRef(arg);
}
PyTuple_SET_ITEM(pyargs, i, arg);
}
va_end(vargs);
result = PyObject_CallObject(pyfunc, pyargs);
if (PyErr_Occurred())
{
status.fault_code = WSMAN_INTERNAL_ERROR;
status.fault_detail_code = 0;
PyErr_Clear();
goto cleanup;
}
if (! PyTuple_Check(result) ||
(PyTuple_Size(result) != 2 && PyTuple_Size(result) != 1))
{
TARGET_THREAD_BEGIN_ALLOW;
status.fault_msg = fmtstr("Python function \"%s\" didn't return a two-tuple", opname);
status.fault_code = WSMAN_INTERNAL_ERROR;
status.fault_detail_code = 0;
TARGET_THREAD_END_ALLOW;
goto cleanup;
}
PyObject* code = PyTuple_GetItem(result, 0);
PyObject* detail = Py_None;
if (PyTuple_Size(result) == 2)
{
detail = PyTuple_GetItem(result, 1);
}
if (! PyInt_Check(code) || (! PyInt_Check(detail) && detail != Py_None))
{
TARGET_THREAD_BEGIN_ALLOW;
status.fault_msg = fmtstr("Python function \"%s\" didn't return a {<int>, <int>) two-tuple", opname);
status.fault_code = WSMAN_INTERNAL_ERROR;
status.fault_detail_code = 0;
TARGET_THREAD_END_ALLOW;
goto cleanup;
}
status.fault_code = PyInt_AsLong(code);
if (detail == Py_None)
{
status.fault_code = WSMAN_INTERNAL_ERROR;
status.fault_detail_code = 0;
}
else
{
status.fault_detail_code = PyInt_AsLong(detail);
}
cleanup:
if (status.fault_code != WSMAN_RC_OK)
wsman_generate_fault( doc, status.fault_code, status.fault_detail_code, status.fault_msg );
Py_DecRef(pyargs);
Py_DecRef(pyfunc);
Py_DecRef(result);
return status.fault_code != WSMAN_RC_OK;
}
// this should be equivalent to running
// python run_integrated.py 1999 700 715 --q1_window=1.0 --q3_window=1.0 --ssrcalc_window=10 -p hroest.srmpeptides_yeast --max_uis 5
//
int main(int argc, const char ** argv)
{
python::list precursors_to_evaluate;
double isotope_correction;
python::object par; // parameter object
SRMCollider::ExtendedRangetree::Rangetree_Q1_RT rangetree;
SRMParameters params;
std::string table_name = "hroest.srmPeptides_yeast";
std::string mysql_config = "~/.my.cnf";
double min_q1 = 700;
double max_q1 = 715;
double q1_window = 1.0/2.0;
double q3_window = 1.0/2.0;
double ssrcalc_window = 10/2.0;
int max_uis = 5;
int max_nr_isotopes = 3;
bool ppm = false;
double q3_lower = 400;
double q3_upper = 1400;
try {
Py_Initialize();
// now time to insert the current working directory into the Python search
// path so module search can take advantage. This must happen after Python
// has been initialised
boost::filesystem::path workingDir = boost::filesystem::complete("./").normalize();
// TODO use filesystem or filesystem3
PyObject* sysPath = PySys_GetObject("path");
PyList_Insert( sysPath, 0, PyString_FromString(workingDir.string().c_str()));
workingDir = boost::filesystem::complete("../").normalize();
PyList_Insert( sysPath, 0, PyString_FromString(workingDir.string().c_str()));
python::object ignored;
std::cout << "Will try to import all the modules" << std::endl;
python::object mMainModule = python::import("__main__");
python::object precursor = boost::python::import("precursor");
python::object collider = boost::python::import("collider");
python::object MySQLdb = boost::python::import("MySQLdb");
par = collider.attr("SRM_parameters")();
std::cout << "Imported all the modules successfully, trying to get a db cusor..." << std::endl;
ignored = par.attr("set_single_peptide_table")(table_name);
ignored = par.attr("set_q3_range")(q3_lower, q3_upper);
ignored = par.attr("set_default_vars")();
ignored = par.attr("set_mysql_config")(mysql_config);
python::object db = par.attr("get_db")();
python::object cursor = db.attr("cursor")();
std::cout << "Got a db cursor, trying to get precursors from the db..." << std::endl;
python::object myprecursors = precursor.attr("Precursors")();
myprecursors.attr("getFromDB")(par, cursor, min_q1 - q1_window, max_q1 + q1_window);
std::cout << "Got all precursors from the db, trying to build a rangetree..." << std::endl;
precursors_to_evaluate = python::extract<python::list>(myprecursors.attr("getPrecursorsToEvaluate")(min_q1, max_q1));
isotope_correction = python::extract<double>(par.attr("calculate_isotope_correction")());
//python::object r_tree = myprecursors.attr("build_extended_rangetree")();
python::tuple alltuples = python::extract<python::tuple>(myprecursors.attr("get_alltuples_extended_rangetree")());
rangetree.create_tree(alltuples);
std::cout << "Built a rangetree, starting calculations..." << std::endl;
SRMCollider::pyToC::initialize_param_obj(par, params);
params.q3_window = q3_window;
params.ppm = false;
}
// Catch any Python errors during set up and print them ...
catch (python::error_already_set) {
PyErr_Print();
}
for (int i = 0; i < precursors_to_evaluate.attr("__len__")(); i++)
{
python::object precursor = precursors_to_evaluate[i];
if (i % 1000 == 0) std::cout << "doing " << i << std::endl;
double ssrcalc= python::extract<double>(precursor.attr("ssrcalc"));
double q1= python::extract<double>(precursor.attr("q1"));
python::object o_transition_group = precursor.attr("get_tr")();
long transition_group = python::extract<long>(o_transition_group);
//python::object o_transition_group = precursor.attr("transition_group ");
//long transition_group = python::extract<long>(precursor.attr("transition_group "));
double ssrcalc_low = ssrcalc - ssrcalc_window + 0.001;
double ssrcalc_high = ssrcalc + ssrcalc_window - 0.001;
python::tuple py_transitions = python::extract<python::tuple>(precursor.attr("calculate_transitions_from_param")(par));
//python::object transitions = precursor.attr("calculate_transitions_from_param")(par);
#if 0
SRMCollider::IntegratedRun::_py_wrap_all_bitwise(py_transitions,
q1 - q1_window, ssrcalc_low, q1 + q1_window, ssrcalc_high,
transition_group, max_uis, q3_window, ppm, max_nr_isotopes,
isotope_correction, par, rangetree);
#else
double transitions_length = python::extract<double>(py_transitions.attr("__len__")());
std::vector<SRMCollider::Common::SRMTransition> mytransitions(transitions_length);
SRMCollider::IntegratedRun::_pyToC_integratedrunTransitions(py_transitions, mytransitions);
std::vector<COMBINT> collisions_per_peptide;
SRMCollider::IntegratedRun::wrap_all_bitwise(mytransitions,
q1 - q1_window, ssrcalc_low, q1 + q1_window, ssrcalc_high,
transition_group, max_uis, q3_window, ppm, max_nr_isotopes, isotope_correction,
params, rangetree, collisions_per_peptide);
// Use the collisions_per_peptide vector (bitwise vector) to compute the non-UIS combinations
std::vector<int> c_result;
for(int i =1; i<= max_uis; i++) {
std::set<COMBINT> combinations;
SRMCollider::Combinatorics::get_non_uis_bitwise(collisions_per_peptide, transitions_length, i, combinations);
c_result.push_back(combinations.size());
}
#endif
/*
precursor.q1 - par.q1_window, ssrcalc_low, precursor.q1 + par.q1_window, ssrcalc_high,
precursor.transition_group, min(par.max_uis,len(transitions)), par.q3_window, par.ppm,
par.isotopes_up_to, isotope_correction, par, r_tree)
// Python wrapper for wrap_all
python::list _py_wrap_all_bitwise(python::tuple py_transitions, double a, double b,
double c, double d, long thistransitiongr, int max_uis, double q3window,
bool ppm, int max_nr_isotopes, double isotope_correction, python::object par,
SRMCollider::ExtendedRangetree::Rangetree_Q1_RT& rtree)
{
*/
}
/*
# python::exec( "for order in range(1,6):
# sum_all = sum([p[0]*1.0/p[1] for p in prepare if p[3] == order])
# nr_peptides = len([p for p in prepare if p[3] == order])
# if not par.quiet and not nr_peptides ==0: print 'Order %s, Average non useable UIS %s' % (order, sum_all *1.0/ nr_peptides)")
*/
/*
*
*
*
*
void wrap_all_bitwise(std::vector<Transition> mytransitions, double a, double b,
double c, double d, long thistransitiongr, int max_uis, double q3window,
bool ppm, int max_nr_isotopes, double isotope_correction, SRMParameters params,
SRMCollider::ExtendedRangetree::Rangetree_Q1_RT& rtree, std::vector<COMBINT>& newcollperpep)
*
*
python::list _py_wrap_all_bitwise(python::tuple py_transitions, double a, double b,
double c, double d, long thistransitiongr, int max_uis, double q3window,
bool ppm, int max_nr_isotopes, double isotope_correction, python::object par,
SRMCollider::ExtendedRangetree::Rangetree_Q1_RT& rtree)
*
progressm = progress.ProgressMeter(total=len(precursors_to_evaluate), unit='peptides')
prepare = []
for precursor in precursors_to_evaluate:
transitions = precursor.calculate_transitions_from_param(par)
#correct rounding errors, s.t. we get the same results as before!
ssrcalc_low = precursor.ssrcalc - par.ssrcalc_window + 0.001
ssrcalc_high = precursor.ssrcalc + par.ssrcalc_window - 0.001
try:
result = c_integrated.wrap_all_bitwise(transitions,
precursor.q1 - par.q1_window, ssrcalc_low, precursor.q1 + par.q1_window, ssrcalc_high,
precursor.transition_group, min(par.max_uis,len(transitions)), par.q3_window, par.ppm,
par.isotopes_up_to, isotope_correction, par, r_tree)
except ValueError:
print "Too many transitions for", precursor.modification
continue
for order in range(1,min(par.max_uis+1, len(transitions)+1)):
prepare.append( (result[order-1], collider.choose(len(transitions),
order), precursor.parent_id , order, exp_key) )
#//break;
progressm.update(1)
*/
/*
db = par.get_db()
cursor = db.cursor()
mycollider = collider.SRMcollider()
par = collider.SRM_parameters()
*/
/*
myprecursors = Precursors()
myprecursors.getFromDB(par, db.cursor(), min_q1 - par.q1_window, max_q1 + par.q1_window)
precursors_to_evaluate = myprecursors.getPrecursorsToEvaluate(min_q1, max_q1)
isotope_correction = par.calculate_isotope_correction()
r_tree = myprecursors.build_extended_rangetree ()
bp::object ignored = bp::exec("hello = file('hello.txt', 'w')\n"
"hello.write('Hello world!')\n"
"hello.close()", mMainNamespace);
*/
}
static list_t *
TargetEndpoints( void *self, void *data )
{
int len, i;
PyObject *instance = (PyObject *)data;
PyObject *pyfunc, *pynamespaces = NULL;
WsmanStatus status;
wsman_status_init(&status);
debug("TargetEndpoints(Python), data %p, instance %p", data, instance);
/*
* Get namespaces
*/
list_t *namespaces = list_create(LISTCOUNT_T_MAX);
pyfunc = PyObject_GetAttrString(instance, "namespaces");
if (pyfunc == NULL)
{
PyErr_Print();
PyErr_Clear();
debug("Python module does not contain \"namespaces\"");
status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
status.fault_detail_code = 0;
goto cleanup;
}
if (! PyCallable_Check(pyfunc))
{
debug("Python module attribute \"namespaces\" is not callable");
status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
status.fault_detail_code = 0;
goto cleanup;
}
pynamespaces = PyObject_CallObject(pyfunc, NULL);
if (PyErr_Occurred())
{
status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
status.fault_detail_code = 0;
PyErr_Clear();
goto cleanup;
}
if (! PyTuple_Check(pynamespaces))
{
TARGET_THREAD_BEGIN_ALLOW;
debug("Python function \"namespaces\" didn't return a two-tuple");
status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
status.fault_detail_code = 0;
TARGET_THREAD_END_ALLOW;
goto cleanup;
}
len = PyTuple_Size(pynamespaces);
for (i = 0; i < len; ++i) {
lnode_t *node;
PyObject *ns, *prefix;
PyObject* elem = PyTuple_GetItem(pynamespaces, i);
if (! PyTuple_Check(elem)
|| ! (PyTuple_Size(elem) == 2)) {
TARGET_THREAD_BEGIN_ALLOW;
debug("Python function \"namespaces\" didn't return a list of two-tuple");
status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
status.fault_detail_code = 0;
TARGET_THREAD_END_ALLOW;
goto cleanup;
}
ns = PyTuple_GetItem(elem, 0);
prefix = PyTuple_GetItem(elem, 1);
if (!PyString_Check(ns)
|| !PyString_Check(prefix)) {
TARGET_THREAD_BEGIN_ALLOW;
debug("Python function \"namespaces\" didn't return a list of [<string>,<string>] tuples");
status.fault_code = WSA_ENDPOINT_UNAVAILABLE;
status.fault_detail_code = 0;
TARGET_THREAD_END_ALLOW;
goto cleanup;
}
WsSupportedNamespaces *sup_ns = (WsSupportedNamespaces *)u_malloc(sizeof(WsSupportedNamespaces));
sup_ns->ns = PyString_AsString(ns);
sup_ns->class_prefix = PyString_AsString(prefix);
node = lnode_create(ns);
list_append(namespaces, node);
}
cleanup:
if (pyfunc) Py_DecRef(pyfunc);
if (pynamespaces) Py_DecRef(pynamespaces);
return namespaces;
}
/*
* Import modules embedded in the archive - return 0 on success
*/
int importModules()
{
PyObject *marshal;
PyObject *marshaldict;
PyObject *loadfunc;
PyObject *pyfile;
TOC *ptoc;
PyObject *co;
PyObject *mod;
PyObject *res;
char buf[32];
VS("importing modules from CArchive\n");
/* Get the Python function marshall.load
* Here we collect some reference to PyObject that we don't dereference
* Doesn't matter because the objects won't be going away anyway.
*/
marshal = PyImport_ImportModule("marshal");
marshaldict = PyModule_GetDict(marshal);
loadfunc = PyDict_GetItemString(marshaldict, "loads");
/* Iterate through toc looking for module entries (type 'm')
* this is normally just bootstrap stuff (archive and iu)
*/
ptoc = f_tocbuff;
while (ptoc < f_tocend) {
if (ptoc->typcd == 'm' || ptoc->typcd == 'M')
{
unsigned char *modbuf = extract(ptoc);
/* .pyc/.pyo files have 8 bytes header. Skip it and get a Python
* string directly pointing at the marshalled code.
*/
PyObject *mods = PyString_FromStringAndSize(modbuf + 8,
ntohl(ptoc->ulen) - 8);
VS(ptoc->name);
VS("\n");
co = PyObject_CallFunction(loadfunc, "O", mods);
mod = PyImport_ExecCodeModule(ptoc->name, co);
/* Check for errors in loading */
if (mod == NULL) {
FATALERROR("mod is NULL - ");
FATALERROR(ptoc->name);
}
if (PyErr_Occurred())
{
PyErr_Print();
PyErr_Clear();
}
Py_DECREF(mods);
free(modbuf);
}
ptoc = incrementTocPtr(ptoc);
}
return 0;
}
static char *
get_exc_trace()
{
char *tbstr = NULL;
PyObject *iostrmod = NULL;
PyObject *tbmod = NULL;
PyObject *iostr = NULL;
PyObject *obstr = NULL;
PyObject *args = NULL;
PyObject *newstr = NULL;
PyObject *func = NULL;
char* rv = NULL;
PyObject *type, *value, *traceback;
TARGET_THREAD_BEGIN_BLOCK;
PyErr_Fetch(&type, &value, &traceback);
debug("** type %p, value %p, traceback %p", type, value, traceback);
PyErr_Print();
PyErr_Clear();
PyErr_NormalizeException(&type, &value, &traceback);
debug("** type %p, value %p, traceback %p", type, value, traceback);
iostrmod = PyImport_ImportModule("StringIO");
if (iostrmod==NULL)
TB_ERROR("can't import StringIO");
iostr = PyObject_CallMethod(iostrmod, "StringIO", NULL);
if (iostr==NULL)
TB_ERROR("cStringIO.StringIO() failed");
tbmod = PyImport_ImportModule("traceback");
if (tbmod==NULL)
TB_ERROR("can't import traceback");
obstr = PyObject_CallMethod(tbmod, "print_exception",
"(OOOOO)",
type ? type : Py_None,
value ? value : Py_None,
traceback ? traceback : Py_None,
Py_None,
iostr);
if (obstr==NULL)
{
PyErr_Print();
TB_ERROR("traceback.print_exception() failed");
}
Py_DecRef(obstr);
obstr = PyObject_CallMethod(iostr, "getvalue", NULL);
if (obstr==NULL)
TB_ERROR("getvalue() failed.");
if (!PyString_Check(obstr))
TB_ERROR("getvalue() did not return a string");
debug("%s", PyString_AsString(obstr));
args = PyTuple_New(2);
PyTuple_SetItem(args, 0, string2target("\n"));
PyTuple_SetItem(args, 1, string2target("<br>"));
func = PyObject_GetAttrString(obstr, "replace");
//newstr = PyObject_CallMethod(obstr, "replace", args);
newstr = PyObject_CallObject(func, args);
tbstr = PyString_AsString(newstr);
rv = fmtstr("plugin:%s", tbstr);
cleanup:
PyErr_Restore(type, value, traceback);
if (rv == NULL)
{
rv = tbstr ? tbstr : "";
}
Py_DecRef(func);
Py_DecRef(args);
Py_DecRef(newstr);
Py_DecRef(iostr);
Py_DecRef(obstr);
Py_DecRef(iostrmod);
Py_DecRef(tbmod);
TARGET_THREAD_END_BLOCK;
return rv;
}
int embed_sim_init(gpi_sim_info_t *info)
{
FENTER
int i;
int ret = 0;
/* Check that we are not already initialised */
if (pEventFn)
return ret;
// Find the simulation root
const char *dut = getenv("TOPLEVEL");
if (dut != NULL) {
if (!strcmp("", dut)) {
/* Empty string passed in, treat as NULL */
dut = NULL;
} else {
// Skip any library component of the toplevel
char *dot = strchr(dut, '.');
if (dot != NULL) {
dut += (dot - dut + 1);
}
}
}
PyObject *cocotb_module, *cocotb_init, *cocotb_args, *cocotb_retval;
PyObject *simlog_obj, *simlog_func;
PyObject *argv_list, *argc, *arg_dict, *arg_value;
cocotb_module = NULL;
arg_dict = NULL;
//Ensure that the current thread is ready to callthe Python C API
PyGILState_STATE gstate = PyGILState_Ensure();
if (get_module_ref(COCOTB_MODULE, &cocotb_module))
goto cleanup;
// Obtain the loggpi logger object
simlog_obj = PyObject_GetAttrString(cocotb_module, "loggpi");
if (simlog_obj == NULL) {
PyErr_Print();
fprintf(stderr, "Failed to to get simlog object\n");
}
simlog_func = PyObject_GetAttrString(simlog_obj, "_printRecord");
if (simlog_func == NULL) {
PyErr_Print();
fprintf(stderr, "Failed to get the _printRecord method");
goto cleanup;
}
if (!PyCallable_Check(simlog_func)) {
PyErr_Print();
fprintf(stderr, "_printRecord is not callable");
goto cleanup;
}
set_log_handler(simlog_func);
Py_DECREF(simlog_func);
simlog_func = PyObject_GetAttrString(simlog_obj, "_willLog");
if (simlog_func == NULL) {
PyErr_Print();
fprintf(stderr, "Failed to get the _willLog method");
goto cleanup;
}
if (!PyCallable_Check(simlog_func)) {
PyErr_Print();
fprintf(stderr, "_willLog is not callable");
goto cleanup;
}
set_log_filter(simlog_func);
argv_list = PyList_New(0);
for (i = 0; i < info->argc; i++) {
arg_value = PyString_FromString(info->argv[i]);
PyList_Append(argv_list, arg_value);
}
arg_dict = PyModule_GetDict(cocotb_module);
PyDict_SetItemString(arg_dict, "argv", argv_list);
argc = PyInt_FromLong(info->argc);
PyDict_SetItemString(arg_dict, "argc", argc);
if (!PyCallable_Check(simlog_func)) {
PyErr_Print();
fprintf(stderr, "_printRecord is not callable");
goto cleanup;
}
LOG_INFO("Running on %s version %s", info->product, info->version);
LOG_INFO("Python interpreter initialised and cocotb loaded!");
// Now that logging has been set up ok we initialise the testbench
if (-1 == PyObject_SetAttrString(cocotb_module, "SIM_NAME", PyString_FromString(info->product))) {
PyErr_Print();
fprintf(stderr, "Unable to set SIM_NAME");
goto cleanup;
}
// Set language in use as an attribute to cocotb module, or None if not provided
const char *lang = getenv("TOPLEVEL_LANG");
PyObject* PyLang;
if (lang)
PyLang = PyString_FromString(lang);
else
PyLang = Py_None;
if (-1 == PyObject_SetAttrString(cocotb_module, "LANGUAGE", PyLang)) {
fprintf(stderr, "Unable to set LANGUAGE");
goto cleanup;
}
// Hold onto a reference to our _fail_test function
pEventFn = PyObject_GetAttrString(cocotb_module, "_sim_event");
if (!PyCallable_Check(pEventFn)) {
PyErr_Print();
fprintf(stderr, "cocotb._sim_event is not callable");
goto cleanup;
}
Py_INCREF(pEventFn);
cocotb_init = PyObject_GetAttrString(cocotb_module, "_initialise_testbench"); // New reference
if (cocotb_init == NULL || !PyCallable_Check(cocotb_init)) {
if (PyErr_Occurred())
PyErr_Print();
fprintf(stderr, "Cannot find function \"%s\"\n", "_initialise_testbench");
goto cleanup;
}
cocotb_args = PyTuple_New(1);
if (dut == NULL)
PyTuple_SetItem(cocotb_args, 0, Py_BuildValue("")); // Note: This function “steals” a reference to o.
else
PyTuple_SetItem(cocotb_args, 0, PyString_FromString(dut)); // Note: This function “steals” a reference to o.
cocotb_retval = PyObject_CallObject(cocotb_init, cocotb_args);
if (cocotb_retval != NULL) {
LOG_DEBUG("_initialise_testbench successful");
Py_DECREF(cocotb_retval);
} else {
PyErr_Print();
fprintf(stderr,"Cocotb initialisation failed - exiting\n");
}
FEXIT
goto ok;
cleanup:
ret = -1;
ok:
if (cocotb_module) {
Py_DECREF(cocotb_module);
}
if (arg_dict) {
Py_DECREF(arg_dict);
}
PyGILState_Release(gstate);
return ret;
}
void WritePythonFile(const plFileName &fileName, const plFileName &path, hsStream *s)
{
hsUNIXStream pyStream, glueStream;
plFileName filePath;
ST_ssize_t filestart = fileName.AsString().find_last('.');
if (filestart >= 0)
filePath = fileName.AsString().substr(filestart+1);
else
filePath = fileName;
filePath = plFileName::Join(path, filePath + ".py");
if (!pyStream.Open(filePath) || !glueStream.Open(glueFile))
{
ST::printf("Unable to open path {}, ", filePath);
return;
}
ST::printf("==Packing {}, ", fileName);
pyStream.FastFwd();
uint32_t pyFileSize = pyStream.GetPosition();
pyStream.Rewind();
glueStream.FastFwd();
uint32_t glueFileSize = glueStream.GetPosition();
glueStream.Rewind();
uint32_t totalSize = pyFileSize + glueFileSize + 2;
char *code = new char[totalSize];
uint32_t amountRead = pyStream.Read(pyFileSize, code);
hsAssert(amountRead == pyFileSize, "Bad read");
code[pyFileSize] = '\n';
amountRead = glueStream.Read(glueFileSize, code+pyFileSize+1);
hsAssert(amountRead == glueFileSize, "Bad read");
code[totalSize-1] = '\0';
// remove the CRs, they seem to give Python heartburn
int k = 0;
for (int i = 0; i < totalSize; i++)
{
if (code[i] != '\r') // is it not a CR?
code[k++] = code[i];
// else
// skip the CRs
}
// import the module first, to make packages work correctly
PyImport_ImportModule(fileName.AsString().c_str());
PyObject* pythonCode = PythonInterface::CompileString(code, fileName);
if (pythonCode)
{
// we need to find out if this is PythonFile module
// create a module name... with the '.' as an X
// and create a python file name that is without the ".py"
PyObject* fModule = PythonInterface::CreateModule(fileName.AsString().c_str());
// run the code
if (PythonInterface::RunPYC(pythonCode, fModule) )
{
// set the name of the file (in the global dictionary of the module)
PyObject* dict = PyModule_GetDict(fModule);
PyObject* pfilename = PyString_FromString(fileName.AsString().c_str());
PyDict_SetItemString(dict, "glue_name", pfilename);
// next we need to:
// - create instance of class
PyObject* getID = PythonInterface::GetModuleItem("glue_getBlockID",fModule);
bool foundID = false;
if ( getID!=nil && PyCallable_Check(getID) )
{
PyObject* id = PyObject_CallFunction(getID,nil);
if ( id && PyInt_Check(id) )
foundID = true;
}
if ( foundID == false ) // then there was an error or no ID or somethin'
{
// oops, this is not a PythonFile modifier
// re-read the source and compile it without the glue code this time
pyStream.Rewind();
amountRead = pyStream.Read(pyFileSize, code);
hsAssert(amountRead == pyFileSize, "Bad read");
code[amountRead] = '\n';
code[amountRead+1] = '\0';
k = 0;
int len = strlen(code)+1;
for (int i = 0; i < len; i++)
{
if (code[i] != '\r') // is it not a CR?
code[k++] = code[i];
// else
// skip the CRs
}
pythonCode = PythonInterface::CompileString(code, fileName);
hsAssert(pythonCode,"Not sure why this didn't compile the second time???");
fputs("an import file ", stdout);
}
else
fputs("a PythonFile modifier(tm) ", stdout);
}
else
{
fputs("......blast! Error during run-code!\n", stdout);
char* errmsg;
int chars_read = PythonInterface::getOutputAndReset(&errmsg);
if (chars_read > 0)
{
puts(errmsg);
}
}
}
// make sure that we have code to save
if (pythonCode)
{
int32_t size;
char* pycode;
PythonInterface::DumpObject(pythonCode,&pycode,&size);
fputc('\n', stdout);
// print any message after each module
char* errmsg;
int chars_read = PythonInterface::getOutputAndReset(&errmsg);
if (chars_read > 0)
{
puts(errmsg);
}
s->WriteLE32(size);
s->Write(size, pycode);
}
else
{
fputs("......blast! Compile error!\n", stdout);
s->WriteLE32(0);
PyErr_Print();
PyErr_Clear();
char* errmsg;
int chars_read = PythonInterface::getOutputAndReset(&errmsg);
if (chars_read > 0)
{
puts(errmsg);
}
}
delete [] code;
pyStream.Close();
glueStream.Close();
}
int main(int argc, char *argv[])
{
PyObject *pName, *pModule, *pArgs, *pFunc, *pValue;
int i;
if (argc < 3) {
printf("Usage: call_function python_source function_name\n");
return 1;
}
/* Initialize the Python Interpreter */
Py_Initialize();
PyRun_SimpleString("import sys\n"
"sys.path.append('.')");
/* Build the name object */
pName = PyString_FromString(argv[1]);
/* Load the module object */
pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (pModule != NULL) {
/* pFunc is a borrowed reference */
pFunc = PyObject_GetAttrString(pModule, argv[2]);
if (pFunc && PyCallable_Check(pFunc)) {
/* Prepare the argument list for the call */
if( argc > 3 ) {
pArgs = PyTuple_New(argc - 3);
for (i = 0; i < argc - 3; ++i) {
pValue = PyInt_FromLong(atoi(argv[i + 3]));
if (!pValue) {
Py_DECREF(pArgs);
Py_DECREF(pModule);
fprintf(stderr, "Cannot convert argument\n");
return 1;
}
/* pValue reference stolen here: */
PyTuple_SetItem(pArgs, i, pValue);
}
pValue = PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pArgs);
if (pValue != NULL) {
printf("Result of call: %ld\n", PyInt_AsLong(pValue));
Py_DECREF(pValue);
}
else {
Py_DECREF(pFunc);
Py_DECREF(pModule);
PyErr_Print();
fprintf(stderr,"Call failed\n");
return 1;
}
}
else {
pValue = PyObject_CallObject(pFunc, NULL);
}
}
else {
if (PyErr_Occurred())
PyErr_Print();
fprintf(stderr, "Cannot find function \"%s\"\n", argv[2]);
}
/* Clean up */
Py_XDECREF(pFunc);
Py_DECREF(pModule);
}
else {
PyErr_Print();
fprintf(stderr, "Failed to load \"%s\"\n", argv[1]);
return 1;
}
/* Finish the Python Interpreter */
Py_Finalize();
return 0;
}
Bool
eval_f(Index n, Number * x, Bool new_x, Number * obj_value, UserDataPtr data)
{
logger("[Callback:E] eval_f");
npy_intp dims[1];
dims[0] = n;
DispatchData *myowndata = (DispatchData *) data;
UserDataPtr user_data = (UserDataPtr) myowndata->userdata;
// import_array ();
import_array1(FALSE);
PyObject *arrayx =
PyArray_SimpleNewFromData(1, dims, PyArray_DOUBLE, (char *)x);
if (!arrayx)
return FALSE;
if (new_x && myowndata->apply_new_python) {
/* Call the python function to applynew */
PyObject *arg1;
arg1 = Py_BuildValue("(O)", arrayx);
PyObject *tempresult = PyObject_CallObject(
myowndata->apply_new_python, arg1);
if (tempresult == NULL) {
logger("[Error] Python function apply_new returns NULL");
PyErr_Print();
Py_DECREF(arg1);
return FALSE;
}
Py_DECREF(arg1);
Py_DECREF(tempresult);
}
PyObject *arglist;
if (user_data != NULL) {
arglist = Py_BuildValue("(OO)", arrayx, (PyObject *) user_data);
} else {
arglist = Py_BuildValue("(O)", arrayx);
}
PyObject *result = PyObject_CallObject(myowndata->eval_f_python, arglist);
if (result == NULL) {
logger("[Error] Python function eval_f returns NULL");
PyErr_Print();
Py_DECREF(arrayx);
Py_CLEAR(arglist);
return FALSE;
}
*obj_value = PyFloat_AsDouble(result);
if (PyErr_Occurred()) {
logger("[Error] Python function eval_f returns non-PyFloat");
PyErr_Print();
Py_DECREF(result);
Py_DECREF(arrayx);
Py_CLEAR(arglist);
return FALSE;
}
Py_DECREF(result);
Py_DECREF(arrayx);
Py_CLEAR(arglist);
logger("[Callback:R] eval_f");
return TRUE;
}
void
_Py_InitializeEx_Private(int install_sigs, int install_importlib)
{
PyInterpreterState *interp;
PyThreadState *tstate;
PyObject *bimod, *sysmod, *pstderr;
char *p;
extern void _Py_ReadyTypes(void);
if (initialized)
return;
initialized = 1;
_Py_Finalizing = NULL;
#if defined(HAVE_LANGINFO_H) && defined(HAVE_SETLOCALE)
/* Set up the LC_CTYPE locale, so we can obtain
the locale's charset without having to switch
locales. */
setlocale(LC_CTYPE, "");
#endif
if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
Py_DebugFlag = add_flag(Py_DebugFlag, p);
if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0')
Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);
/* The variable is only tested for existence here; _PyRandom_Init will
check its value further. */
if ((p = Py_GETENV("PYTHONHASHSEED")) && *p != '\0')
Py_HashRandomizationFlag = add_flag(Py_HashRandomizationFlag, p);
_PyRandom_Init();
interp = PyInterpreterState_New();
if (interp == NULL)
Py_FatalError("Py_Initialize: can't make first interpreter");
tstate = PyThreadState_New(interp);
if (tstate == NULL)
Py_FatalError("Py_Initialize: can't make first thread");
(void) PyThreadState_Swap(tstate);
#ifdef WITH_THREAD
/* We can't call _PyEval_FiniThreads() in Py_Finalize because
destroying the GIL might fail when it is being referenced from
another running thread (see issue #9901).
Instead we destroy the previously created GIL here, which ensures
that we can call Py_Initialize / Py_Finalize multiple times. */
_PyEval_FiniThreads();
/* Auto-thread-state API */
_PyGILState_Init(interp, tstate);
#endif /* WITH_THREAD */
_Py_ReadyTypes();
if (!_PyFrame_Init())
Py_FatalError("Py_Initialize: can't init frames");
if (!_PyLong_Init())
Py_FatalError("Py_Initialize: can't init longs");
if (!PyByteArray_Init())
Py_FatalError("Py_Initialize: can't init bytearray");
if (!_PyFloat_Init())
Py_FatalError("Py_Initialize: can't init float");
interp->modules = PyDict_New();
if (interp->modules == NULL)
Py_FatalError("Py_Initialize: can't make modules dictionary");
/* Init Unicode implementation; relies on the codec registry */
if (_PyUnicode_Init() < 0)
Py_FatalError("Py_Initialize: can't initialize unicode");
if (_PyStructSequence_Init() < 0)
Py_FatalError("Py_Initialize: can't initialize structseq");
bimod = _PyBuiltin_Init();
if (bimod == NULL)
Py_FatalError("Py_Initialize: can't initialize builtins modules");
_PyImport_FixupBuiltin(bimod, "builtins");
interp->builtins = PyModule_GetDict(bimod);
if (interp->builtins == NULL)
Py_FatalError("Py_Initialize: can't initialize builtins dict");
Py_INCREF(interp->builtins);
/* initialize builtin exceptions */
_PyExc_Init(bimod);
sysmod = _PySys_Init();
if (sysmod == NULL)
Py_FatalError("Py_Initialize: can't initialize sys");
interp->sysdict = PyModule_GetDict(sysmod);
if (interp->sysdict == NULL)
Py_FatalError("Py_Initialize: can't initialize sys dict");
Py_INCREF(interp->sysdict);
_PyImport_FixupBuiltin(sysmod, "sys");
PySys_SetPath(Py_GetPath());
PyDict_SetItemString(interp->sysdict, "modules",
interp->modules);
/* Set up a preliminary stderr printer until we have enough
infrastructure for the io module in place. */
pstderr = PyFile_NewStdPrinter(fileno(stderr));
if (pstderr == NULL)
Py_FatalError("Py_Initialize: can't set preliminary stderr");
_PySys_SetObjectId(&PyId_stderr, pstderr);
PySys_SetObject("__stderr__", pstderr);
Py_DECREF(pstderr);
_PyImport_Init();
_PyImportHooks_Init();
/* Initialize _warnings. */
_PyWarnings_Init();
if (!install_importlib)
return;
import_init(interp, sysmod);
/* initialize the faulthandler module */
if (_PyFaulthandler_Init())
Py_FatalError("Py_Initialize: can't initialize faulthandler");
if (_PyTime_Init() < 0)
Py_FatalError("Py_Initialize: can't initialize time");
if (initfsencoding(interp) < 0)
Py_FatalError("Py_Initialize: unable to load the file system codec");
if (install_sigs)
initsigs(); /* Signal handling stuff, including initintr() */
if (_PyTraceMalloc_Init() < 0)
Py_FatalError("Py_Initialize: can't initialize tracemalloc");
initmain(interp); /* Module __main__ */
if (initstdio() < 0)
Py_FatalError(
"Py_Initialize: can't initialize sys standard streams");
/* Initialize warnings. */
if (PySys_HasWarnOptions()) {
PyObject *warnings_module = PyImport_ImportModule("warnings");
if (warnings_module == NULL) {
fprintf(stderr, "'import warnings' failed; traceback:\n");
PyErr_Print();
}
Py_XDECREF(warnings_module);
}
if (!Py_NoSiteFlag)
initsite(); /* Module site */
}
Bool
eval_g(Index n, Number * x, Bool new_x, Index m, Number * g, UserDataPtr data)
{
logger("[Callback:E] eval_g");
DispatchData *myowndata = (DispatchData *) data;
UserDataPtr user_data = (UserDataPtr) myowndata->userdata;
if (myowndata->eval_g_python == NULL)
PyErr_Print();
/* int dims[1]; */
npy_intp dims[1];
int i;
double *tempdata;
dims[0] = n;
// import_array ();
import_array1(FALSE);
/*
* PyObject *arrayx = PyArray_FromDimsAndData(1, dims, PyArray_DOUBLE
* , (char*) x);
*/
PyObject *arrayx =
PyArray_SimpleNewFromData(1, dims, PyArray_DOUBLE, (char *)x);
if (!arrayx)
return FALSE;
if (new_x && myowndata->apply_new_python) {
/* Call the python function to applynew */
PyObject *arg1 = Py_BuildValue("(O)", arrayx);
PyObject *tempresult = PyObject_CallObject(
myowndata->apply_new_python, arg1);
if (tempresult == NULL) {
logger("[Error] Python function apply_new returns NULL");
PyErr_Print();
Py_DECREF(arg1);
return FALSE;
}
Py_DECREF(arg1);
Py_DECREF(tempresult);
}
PyObject *arglist;
if (user_data != NULL)
arglist = Py_BuildValue("(OO)", arrayx, (PyObject *) user_data);
else
arglist = Py_BuildValue("(O)", arrayx);
PyArrayObject *result = (PyArrayObject *) PyObject_CallObject(
myowndata->eval_g_python, arglist);
if (result == NULL) {
logger("[Error] Python function eval_g returns NULL");
PyErr_Print();
return FALSE;
}
if (!PyArray_Check(result)) {
logger("[Error] Python function eval_g returns non-PyArray");
Py_DECREF(result);
return FALSE;
}
tempdata = (double *)result->data;
for (i = 0; i < m; i++) {
g[i] = tempdata[i];
}
Py_DECREF(result);
Py_CLEAR(arrayx);
Py_CLEAR(arglist);
logger("[Callback:R] eval_g");
return TRUE;
}
PythonScripting::PythonScripting(ApplicationWindow *parent)
: ScriptingEnv(parent, langName)
{
PyObject *mainmod=NULL, *qtimod=NULL, *sysmod=NULL;
math = NULL;
sys = NULL;
if (Py_IsInitialized())
{
PyEval_AcquireLock();
mainmod = PyImport_ImportModule("__main__");
if (!mainmod)
{
PyErr_Print();
PyEval_ReleaseLock();
return;
}
globals = PyModule_GetDict(mainmod);
Py_DECREF(mainmod);
} else {
PyEval_InitThreads ();
Py_Initialize ();
if (!Py_IsInitialized ())
return;
initqti();
mainmod = PyImport_AddModule("__main__");
if (!mainmod)
{
PyEval_ReleaseLock();
PyErr_Print();
return;
}
globals = PyModule_GetDict(mainmod);
}
if (!globals)
{
PyErr_Print();
PyEval_ReleaseLock();
return;
}
Py_INCREF(globals);
math = PyDict_New();
if (!math)
PyErr_Print();
qtimod = PyImport_ImportModule("qti");
if (qtimod)
{
PyDict_SetItemString(globals, "qti", qtimod);
PyObject *qtiDict = PyModule_GetDict(qtimod);
setQObject(Parent, "app", qtiDict);
PyDict_SetItemString(qtiDict, "mathFunctions", math);
Py_DECREF(qtimod);
} else
PyErr_Print();
sysmod = PyImport_ImportModule("sys");
if (sysmod)
{
sys = PyModule_GetDict(sysmod);
Py_INCREF(sys);
} else
PyErr_Print();
PyEval_ReleaseLock();
#ifdef Q_WS_WIN
loadInitFile(QDir::homeDirPath()+"qtiplotrc") ||
loadInitFile(qApp->applicationDirPath()+"qtiplotrc") ||
#else
loadInitFile(QDir::homeDirPath()+"/.qtiplotrc") ||
loadInitFile(QDir::rootDirPath()+"etc/qtiplotrc") ||
#endif
loadInitFile("qtiplotrc");
initialized=true;
}
void init_uwsgi_vars() {
PyObject *pysys, *pysys_dict, *pypath;
PyObject *modules = PyImport_GetModuleDict();
PyObject *tmp_module;
/* add cwd to pythonpath */
pysys = PyImport_ImportModule("sys");
if (!pysys) {
PyErr_Print();
exit(1);
}
pysys_dict = PyModule_GetDict(pysys);
#ifdef PYTHREE
// fix stdout and stderr
PyObject *new_stdprint = PyFile_NewStdPrinter(2);
PyDict_SetItemString(pysys_dict, "stdout", new_stdprint);
PyDict_SetItemString(pysys_dict, "__stdout__", new_stdprint);
PyDict_SetItemString(pysys_dict, "stderr", new_stdprint);
PyDict_SetItemString(pysys_dict, "__stderr__", new_stdprint);
#endif
pypath = PyDict_GetItemString(pysys_dict, "path");
if (!pypath) {
PyErr_Print();
exit(1);
}
if (PyList_Insert(pypath, 0, UWSGI_PYFROMSTRING(".")) != 0) {
PyErr_Print();
}
struct uwsgi_string_list *uppp = up.python_path;
while(uppp) {
if (PyList_Insert(pypath, 0, UWSGI_PYFROMSTRING(uppp->value)) != 0) {
PyErr_Print();
}
else {
uwsgi_log("added %s to pythonpath.\n", uppp->value);
}
uppp = uppp->next;
}
struct uwsgi_string_list *uppma = up.pymodule_alias;
while(uppma) {
// split key=value
char *value = strchr(uppma->value, '=');
if (!value) {
uwsgi_log("invalid pymodule-alias syntax\n");
goto next;
}
value[0] = 0;
if (!strchr(value + 1, '/')) {
// this is a standard pymodule
tmp_module = PyImport_ImportModule(value + 1);
if (!tmp_module) {
PyErr_Print();
exit(1);
}
PyDict_SetItemString(modules, uppma->value, tmp_module);
}
else {
// this is a filepath that need to be mapped
tmp_module = uwsgi_pyimport_by_filename(uppma->value, value + 1);
if (!tmp_module) {
PyErr_Print();
exit(1);
}
}
uwsgi_log("mapped virtual pymodule \"%s\" to real pymodule \"%s\"\n", uppma->value, value + 1);
// reset original value
value[0] = '=';
next:
uppma = uppma->next;
}
}
