/*
* Build a tuple from the given args and kw using the TupleDesc to
* create an appropriately ordered PyTupleObject of arguments and
* keywords.
*
* The output of this can then be casted as needed.
*/
PyObj
PyTuple_FromTupleDescAndParameters(TupleDesc td, PyObj args, PyObj kw)
{
PyObj rob;
Py_ssize_t args_len, kw_len;
Assert(td != NULL);
Assert(args != NULL);
/*
* Python allows NULL kw parameters to be given,
* so compensate below.
*
* Note that abstract interfaces are being used:
* args can be any sequence and kw can be any mapping.
*/
args_len = PyObject_Length(args);
kw_len = kw != NULL ? PyObject_Length(kw) : 0;
if (args_len == -1 || kw_len == -1)
return(NULL);
if ((args_len + kw_len) != td->natts)
{
PyErr_Format(PyExc_TypeError,
"requires exactly %d arguments, given %d",
td->natts, (args_len + kw_len));
return(NULL);
}
rob = PyTuple_New(td->natts);
/*
* There are a few ways this could be implemented,
* but it seems the most reasonable is to first set
* any available keywords and fill in the gaps with
* the positional args.
*/
if (kw_len > 0)
{
PyObj ob_key, kw_iter;
kw_iter = PyObject_GetIter(kw);
if (kw_iter == NULL)
{
Py_DECREF(rob);
return(NULL);
}
while ((ob_key = PyIter_Next(kw_iter)) != NULL)
{
PyObj ob, ob_str;
char *obstr;
int i;
ob_str = ob_key;
Py_INCREF(ob_str);
PyObject_StrBytes(&ob_str);
if (ob_str == NULL)
{
Py_DECREF(kw_iter);
Py_DECREF(rob);
return(NULL);
}
obstr = PyBytes_AS_STRING(ob_str);
/*
* Scan TupleDesc for attribute number. O(NM) :(
*/
for (i = 0; i < td->natts; ++i)
{
if (!strcmp(NameStr(td->attrs[i]->attname), obstr))
break;
}
Py_DECREF(ob_str);
/*
* No such attribute.
*/
if (i == td->natts)
{
PyObj invalid_kw_param;
Py_DECREF(rob);
Py_DECREF(kw_iter);
invalid_kw_param = PyUnicode_FromFormat(
"invalid keyword parameter %R", ob_key);
if (invalid_kw_param != NULL)
{
PyErr_SetObject(PyExc_TypeError, invalid_kw_param);
Py_DECREF(invalid_kw_param);
}
Py_DECREF(ob_key);
return(NULL);
}
ob = PyObject_GetItem(kw, ob_key);
Py_DECREF(ob_key);
PyTuple_SET_ITEM(rob, i, ob);
}
}
if (args_len > 0)
{
int i, ai;
for (i = 0, ai = 0; i < td->natts && ai < args_len; ++i)
{
PyObj ob;
if (PyTuple_GET_ITEM(rob, i) != NULL)
continue;
ob = PySequence_GetItem(args, ai);
if (ob == NULL)
{
Py_DECREF(rob);
return(NULL);
}
PyTuple_SET_ITEM(rob, i, ob);
++ai;
}
}
return(rob);
}
/******************************************************************************
*
* Call the python object with all arguments
*
*/
static void _CallPythonObject(void *mem,
ffi_type *restype,
SETFUNC setfunc,
PyObject *callable,
PyObject *converters,
int flags,
void **pArgs)
{
Py_ssize_t i;
PyObject *result;
PyObject *arglist = NULL;
Py_ssize_t nArgs;
PyObject *error_object = NULL;
int *space;
#ifdef WITH_THREAD
PyGILState_STATE state = PyGILState_Ensure();
#endif
nArgs = PySequence_Length(converters);
/* Hm. What to return in case of error?
For COM, 0xFFFFFFFF seems better than 0.
*/
if (nArgs < 0) {
PrintError("BUG: PySequence_Length");
goto Done;
}
arglist = PyTuple_New(nArgs);
if (!arglist) {
PrintError("PyTuple_New()");
goto Done;
}
for (i = 0; i < nArgs; ++i) {
/* Note: new reference! */
PyObject *cnv = PySequence_GetItem(converters, i);
StgDictObject *dict;
if (cnv)
dict = PyType_stgdict(cnv);
else {
PrintError("Getting argument converter %d\n", i);
goto Done;
}
if (dict && dict->getfunc && !_ctypes_simple_instance(cnv)) {
PyObject *v = dict->getfunc(*pArgs, dict->size);
if (!v) {
PrintError("create argument %d:\n", i);
Py_DECREF(cnv);
goto Done;
}
PyTuple_SET_ITEM(arglist, i, v);
/* XXX XXX XX
We have the problem that c_byte or c_short have dict->size of
1 resp. 4, but these parameters are pushed as sizeof(int) bytes.
BTW, the same problem occurs when they are pushed as parameters
*/
} else if (dict) {
/* Hm, shouldn't we use PyCData_AtAddress() or something like that instead? */
CDataObject *obj = (CDataObject *)PyObject_CallFunctionObjArgs(cnv, NULL);
if (!obj) {
PrintError("create argument %d:\n", i);
Py_DECREF(cnv);
goto Done;
}
if (!CDataObject_Check(obj)) {
Py_DECREF(obj);
Py_DECREF(cnv);
PrintError("unexpected result of create argument %d:\n", i);
goto Done;
}
memcpy(obj->b_ptr, *pArgs, dict->size);
PyTuple_SET_ITEM(arglist, i, (PyObject *)obj);
#ifdef MS_WIN32
TryAddRef(dict, obj);
#endif
} else {
PyErr_SetString(PyExc_TypeError,
"cannot build parameter");
PrintError("Parsing argument %d\n", i);
Py_DECREF(cnv);
goto Done;
}
Py_DECREF(cnv);
/* XXX error handling! */
pArgs++;
}
#define CHECK(what, x) \
if (x == NULL) _ctypes_add_traceback(what, "_ctypes/callbacks.c", __LINE__ - 1), PyErr_Print()
if (flags & (FUNCFLAG_USE_ERRNO | FUNCFLAG_USE_LASTERROR)) {
error_object = _ctypes_get_errobj(&space);
if (error_object == NULL)
goto Done;
if (flags & FUNCFLAG_USE_ERRNO) {
int temp = space[0];
space[0] = errno;
errno = temp;
}
#ifdef MS_WIN32
if (flags & FUNCFLAG_USE_LASTERROR) {
int temp = space[1];
space[1] = GetLastError();
SetLastError(temp);
}
#endif
}
result = PyObject_CallObject(callable, arglist);
CHECK("'calling callback function'", result);
#ifdef MS_WIN32
if (flags & FUNCFLAG_USE_LASTERROR) {
int temp = space[1];
space[1] = GetLastError();
SetLastError(temp);
}
#endif
if (flags & FUNCFLAG_USE_ERRNO) {
int temp = space[0];
space[0] = errno;
errno = temp;
}
Py_XDECREF(error_object);
if ((restype != &ffi_type_void) && result) {
PyObject *keep;
assert(setfunc);
#ifdef WORDS_BIGENDIAN
/* See the corresponding code in callproc.c, around line 961 */
if (restype->type != FFI_TYPE_FLOAT && restype->size < sizeof(ffi_arg))
mem = (char *)mem + sizeof(ffi_arg) - restype->size;
#endif
keep = setfunc(mem, result, 0);
CHECK("'converting callback result'", keep);
/* keep is an object we have to keep alive so that the result
stays valid. If there is no such object, the setfunc will
have returned Py_None.
If there is such an object, we have no choice than to keep
it alive forever - but a refcount and/or memory leak will
be the result. EXCEPT when restype is py_object - Python
itself knows how to manage the refcount of these objects.
*/
if (keep == NULL) /* Could not convert callback result. */
PyErr_WriteUnraisable(callable);
else if (keep == Py_None) /* Nothing to keep */
Py_DECREF(keep);
else if (setfunc != _ctypes_get_fielddesc("O")->setfunc) {
if (-1 == PyErr_Warn(PyExc_RuntimeWarning,
"memory leak in callback function."))
PyErr_WriteUnraisable(callable);
}
}
Py_XDECREF(result);
Done:
Py_XDECREF(arglist);
#ifdef WITH_THREAD
PyGILState_Release(state);
#endif
}
PyObject* EntityApp<E>::__py_listPathRes(PyObject* self, PyObject* args)
{
int argCount = PyTuple_Size(args);
if(argCount < 1 || argCount > 2)
{
PyErr_Format(PyExc_TypeError, "KBEngine::listPathRes(): args[path, pathargs=\'*.*\'] is error!");
PyErr_PrintEx(0);
return 0;
}
std::wstring wExtendName = L"*";
PyObject* pathobj = NULL;
PyObject* path_argsobj = NULL;
if(argCount == 1)
{
if(PyArg_ParseTuple(args, "O", &pathobj) == -1)
{
PyErr_Format(PyExc_TypeError, "KBEngine::listPathRes(): args[path] is error!");
PyErr_PrintEx(0);
return 0;
}
}
else
{
if(PyArg_ParseTuple(args, "O|O", &pathobj, &path_argsobj) == -1)
{
PyErr_Format(PyExc_TypeError, "KBEngine::listPathRes(): args[path, pathargs=\'*.*\'] is error!");
PyErr_PrintEx(0);
return 0;
}
if(PyUnicode_Check(path_argsobj))
{
wchar_t* fargs = NULL;
fargs = PyUnicode_AsWideCharString(path_argsobj, NULL);
wExtendName = fargs;
PyMem_Free(fargs);
}
else
{
if(PySequence_Check(path_argsobj))
{
wExtendName = L"";
Py_ssize_t size = PySequence_Size(path_argsobj);
for(int i=0; i<size; i++)
{
PyObject* pyobj = PySequence_GetItem(path_argsobj, i);
if(!PyUnicode_Check(pyobj))
{
PyErr_Format(PyExc_TypeError, "KBEngine::listPathRes(): args[path, pathargs=\'*.*\'] is error!");
PyErr_PrintEx(0);
return 0;
}
wchar_t* wtemp = NULL;
wtemp = PyUnicode_AsWideCharString(pyobj, NULL);
wExtendName += wtemp;
wExtendName += L"|";
PyMem_Free(wtemp);
}
}
else
{
PyErr_Format(PyExc_TypeError, "KBEngine::listPathRes(): args[pathargs] is error!");
PyErr_PrintEx(0);
return 0;
}
}
}
if(!PyUnicode_Check(pathobj))
{
PyErr_Format(PyExc_TypeError, "KBEngine::listPathRes(): args[path] is error!");
PyErr_PrintEx(0);
return 0;
}
if(wExtendName.size() == 0)
{
PyErr_Format(PyExc_TypeError, "KBEngine::listPathRes(): args[pathargs] is NULL!");
PyErr_PrintEx(0);
return 0;
}
if(wExtendName[0] == '.')
wExtendName.erase(wExtendName.begin());
if(wExtendName.size() == 0)
wExtendName = L"*";
wchar_t* respath = PyUnicode_AsWideCharString(pathobj, NULL);
if(respath == NULL)
{
PyErr_Format(PyExc_TypeError, "KBEngine::listPathRes(): args[path] is NULL!");
PyErr_PrintEx(0);
return 0;
}
char* cpath = strutil::wchar2char(respath);
std::string foundPath = Resmgr::getSingleton().matchPath(cpath);
free(cpath);
PyMem_Free(respath);
respath = strutil::char2wchar(foundPath.c_str());
std::vector<std::wstring> results;
Resmgr::getSingleton().listPathRes(respath, wExtendName, results);
PyObject* pyresults = PyTuple_New(results.size());
std::vector<std::wstring>::iterator iter = results.begin();
int i = 0;
for(; iter != results.end(); iter++)
{
PyTuple_SET_ITEM(pyresults, i++, PyUnicode_FromWideChar((*iter).c_str(), (*iter).size()));
}
free(respath);
return pyresults;
}
static
PyObject *call_python_function(PyObject *func, npy_intp n, double *x,
PyObject *args, PyObject *error_obj)
{
/*
This is a generic function to call a python function that takes a 1-D
sequence as a first argument and optional extra_arguments (should be a
zero-length tuple if none desired). The result of the function is
returned in a multiarray object.
-- build sequence object from values in x.
-- add extra arguments (if any) to an argument list.
-- call Python callable object
-- check if error occurred:
if so return NULL
-- if no error, place result of Python code into multiarray object.
*/
PyArrayObject *sequence = NULL;
PyObject *arglist = NULL;
PyObject *arg1 = NULL;
PyObject *result = NULL;
PyArrayObject *result_array = NULL;
/* Build sequence argument from inputs */
sequence = (PyArrayObject *) PyArray_SimpleNewFromData(1, &n, NPY_DOUBLE,
(char *) x);
if (sequence == NULL) {
goto fail;
}
/* Build argument list */
if ((arg1 = PyTuple_New(1)) == NULL) {
Py_DECREF(sequence);
return NULL;
}
PyTuple_SET_ITEM(arg1, 0, (PyObject *)sequence);
/* arg1 now owns sequence reference */
if ((arglist = PySequence_Concat(arg1, args)) == NULL) {
goto fail;
}
Py_DECREF(arg1); /* arglist has a reference to sequence, now. */
arg1 = NULL;
/*
* Call function object --- variable passed to routine. Extra
* arguments are in another passed variable.
*/
if ((result = PyEval_CallObject(func, arglist))==NULL) {
goto fail;
}
result_array = (PyArrayObject *) PyArray_ContiguousFromObject(result,
NPY_DOUBLE, 0, 0);
if (result_array == NULL) {
goto fail;
}
Py_DECREF(result);
Py_DECREF(arglist);
return (PyObject *) result_array;
fail:
Py_XDECREF(arglist);
Py_XDECREF(result);
Py_XDECREF(arg1);
return NULL;
}
/**
* _py_args_combine_and_check_length:
* @cache: PyGICallableCache
* @py_args: the tuple of positional arguments.
* @py_kwargs: the dict of keyword arguments to be merged with py_args.
*
* Returns: New value reference to the combined py_args and py_kwargs.
*/
static PyObject *
_py_args_combine_and_check_length (PyGICallableCache *cache,
PyObject *py_args,
PyObject *py_kwargs)
{
PyObject *combined_py_args = NULL;
Py_ssize_t n_py_args, n_py_kwargs, i;
guint n_expected_args = cache->n_py_args;
GSList *l;
n_py_args = PyTuple_GET_SIZE (py_args);
if (py_kwargs == NULL)
n_py_kwargs = 0;
else
n_py_kwargs = PyDict_Size (py_kwargs);
/* Fast path, we already have the exact number of args and not kwargs. */
if (n_py_kwargs == 0 && n_py_args == n_expected_args && cache->user_data_varargs_index < 0) {
Py_INCREF (py_args);
return py_args;
}
if (cache->user_data_varargs_index < 0 && n_expected_args < n_py_args) {
char *full_name = pygi_callable_cache_get_full_name (cache);
PyErr_Format (PyExc_TypeError,
"%.200s() takes exactly %d %sargument%s (%zd given)",
full_name,
n_expected_args,
n_py_kwargs > 0 ? "non-keyword " : "",
n_expected_args == 1 ? "" : "s",
n_py_args);
g_free (full_name);
return NULL;
}
if (cache->user_data_varargs_index >= 0 && n_py_kwargs > 0 && n_expected_args < n_py_args) {
char *full_name = pygi_callable_cache_get_full_name (cache);
PyErr_Format (PyExc_TypeError,
"%.200s() cannot use variable user data arguments with keyword arguments",
full_name);
g_free (full_name);
return NULL;
}
if (n_py_kwargs > 0 && !_check_for_unexpected_kwargs (cache,
cache->arg_name_hash,
py_kwargs)) {
return NULL;
}
/* will hold arguments from both py_args and py_kwargs
* when they are combined into a single tuple */
combined_py_args = PyTuple_New (n_expected_args);
for (i = 0, l = cache->arg_name_list; i < n_expected_args && l; i++, l = l->next) {
PyObject *py_arg_item = NULL;
PyObject *kw_arg_item = NULL;
const gchar *arg_name = l->data;
int arg_cache_index = -1;
gboolean is_varargs_user_data = FALSE;
if (arg_name != NULL)
arg_cache_index = GPOINTER_TO_INT (g_hash_table_lookup (cache->arg_name_hash, arg_name));
is_varargs_user_data = cache->user_data_varargs_index >= 0 &&
arg_cache_index == cache->user_data_varargs_index;
if (n_py_kwargs > 0 && arg_name != NULL) {
/* NULL means this argument has no keyword name */
/* ex. the first argument to a method or constructor */
kw_arg_item = PyDict_GetItemString (py_kwargs, arg_name);
}
/* use a bounded retrieval of the original input */
if (i < n_py_args)
py_arg_item = PyTuple_GET_ITEM (py_args, i);
if (kw_arg_item == NULL && py_arg_item != NULL) {
if (is_varargs_user_data) {
/* For tail end user_data varargs, pull a slice off and we are done. */
PyObject *user_data = PyTuple_GetSlice (py_args, i, PY_SSIZE_T_MAX);
PyTuple_SET_ITEM (combined_py_args, i, user_data);
return combined_py_args;
} else {
Py_INCREF (py_arg_item);
PyTuple_SET_ITEM (combined_py_args, i, py_arg_item);
}
} else if (kw_arg_item != NULL && py_arg_item == NULL) {
if (is_varargs_user_data) {
/* Special case where user_data is passed as a keyword argument (user_data=foo)
* Wrap the value in a tuple to represent variable args for marshaling later on.
*/
PyObject *user_data = Py_BuildValue("(O)", kw_arg_item, NULL);
PyTuple_SET_ITEM (combined_py_args, i, user_data);
} else {
Py_INCREF (kw_arg_item);
PyTuple_SET_ITEM (combined_py_args, i, kw_arg_item);
}
} else if (kw_arg_item == NULL && py_arg_item == NULL) {
if (is_varargs_user_data) {
/* For varargs user_data, pass an empty tuple when nothing is given. */
PyTuple_SET_ITEM (combined_py_args, i, PyTuple_New (0));
} else if (arg_cache_index >= 0 && _pygi_callable_cache_get_arg (cache, arg_cache_index)->has_default) {
/* If the argument supports a default, use a place holder in the
* argument tuple, this will be checked later during marshaling.
*/
Py_INCREF (_PyGIDefaultArgPlaceholder);
PyTuple_SET_ITEM (combined_py_args, i, _PyGIDefaultArgPlaceholder);
} else {
char *full_name = pygi_callable_cache_get_full_name (cache);
PyErr_Format (PyExc_TypeError,
"%.200s() takes exactly %d %sargument%s (%zd given)",
full_name,
n_expected_args,
n_py_kwargs > 0 ? "non-keyword " : "",
n_expected_args == 1 ? "" : "s",
n_py_args);
g_free (full_name);
Py_DECREF (combined_py_args);
return NULL;
}
} else if (kw_arg_item != NULL && py_arg_item != NULL) {
char *full_name = pygi_callable_cache_get_full_name (cache);
PyErr_Format (PyExc_TypeError,
"%.200s() got multiple values for keyword argument '%.200s'",
full_name,
arg_name);
Py_DECREF (combined_py_args);
g_free (full_name);
return NULL;
}
}
return combined_py_args;
}
static PyObject *
subprocess_fork_exec(PyObject* self, PyObject *args)
{
PyObject *gc_module = NULL;
PyObject *executable_list, *py_fds_to_keep;
PyObject *env_list, *preexec_fn;
PyObject *process_args, *converted_args = NULL, *fast_args = NULL;
PyObject *preexec_fn_args_tuple = NULL;
int p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite;
int errpipe_read, errpipe_write, close_fds, restore_signals;
int call_setsid;
PyObject *cwd_obj, *cwd_obj2;
const char *cwd;
pid_t pid;
int need_to_reenable_gc = 0;
char *const *exec_array, *const *argv = NULL, *const *envp = NULL;
Py_ssize_t arg_num;
int import_lock_held = 0;
if (!PyArg_ParseTuple(
args, "OOpOOOiiiiiiiiiiO:fork_exec",
&process_args, &executable_list, &close_fds, &py_fds_to_keep,
&cwd_obj, &env_list,
&p2cread, &p2cwrite, &c2pread, &c2pwrite,
&errread, &errwrite, &errpipe_read, &errpipe_write,
&restore_signals, &call_setsid, &preexec_fn))
return NULL;
if (close_fds && errpipe_write < 3) { /* precondition */
PyErr_SetString(PyExc_ValueError, "errpipe_write must be >= 3");
return NULL;
}
if (PySequence_Length(py_fds_to_keep) < 0) {
PyErr_SetString(PyExc_ValueError, "cannot get length of fds_to_keep");
return NULL;
}
if (_sanity_check_python_fd_sequence(py_fds_to_keep)) {
PyErr_SetString(PyExc_ValueError, "bad value(s) in fds_to_keep");
return NULL;
}
/* We need to call gc.disable() when we'll be calling preexec_fn */
if (preexec_fn != Py_None) {
PyObject *result;
_Py_IDENTIFIER(isenabled);
_Py_IDENTIFIER(disable);
gc_module = PyImport_ImportModule("gc");
if (gc_module == NULL)
return NULL;
result = _PyObject_CallMethodId(gc_module, &PyId_isenabled, NULL);
if (result == NULL) {
Py_DECREF(gc_module);
return NULL;
}
need_to_reenable_gc = PyObject_IsTrue(result);
Py_DECREF(result);
if (need_to_reenable_gc == -1) {
Py_DECREF(gc_module);
return NULL;
}
result = _PyObject_CallMethodId(gc_module, &PyId_disable, NULL);
if (result == NULL) {
Py_DECREF(gc_module);
return NULL;
}
Py_DECREF(result);
}
exec_array = _PySequence_BytesToCharpArray(executable_list);
if (!exec_array)
goto cleanup;
/* Convert args and env into appropriate arguments for exec() */
/* These conversions are done in the parent process to avoid allocating
or freeing memory in the child process. */
if (process_args != Py_None) {
Py_ssize_t num_args;
/* Equivalent to: */
/* tuple(PyUnicode_FSConverter(arg) for arg in process_args) */
fast_args = PySequence_Fast(process_args, "argv must be a tuple");
if (fast_args == NULL)
goto cleanup;
num_args = PySequence_Fast_GET_SIZE(fast_args);
converted_args = PyTuple_New(num_args);
if (converted_args == NULL)
goto cleanup;
for (arg_num = 0; arg_num < num_args; ++arg_num) {
PyObject *borrowed_arg, *converted_arg;
borrowed_arg = PySequence_Fast_GET_ITEM(fast_args, arg_num);
if (PyUnicode_FSConverter(borrowed_arg, &converted_arg) == 0)
goto cleanup;
PyTuple_SET_ITEM(converted_args, arg_num, converted_arg);
}
argv = _PySequence_BytesToCharpArray(converted_args);
Py_CLEAR(converted_args);
Py_CLEAR(fast_args);
if (!argv)
goto cleanup;
}
if (env_list != Py_None) {
envp = _PySequence_BytesToCharpArray(env_list);
if (!envp)
goto cleanup;
}
if (preexec_fn != Py_None) {
preexec_fn_args_tuple = PyTuple_New(0);
if (!preexec_fn_args_tuple)
goto cleanup;
_PyImport_AcquireLock();
import_lock_held = 1;
}
if (cwd_obj != Py_None) {
if (PyUnicode_FSConverter(cwd_obj, &cwd_obj2) == 0)
goto cleanup;
cwd = PyBytes_AsString(cwd_obj2);
} else {
cwd = NULL;
cwd_obj2 = NULL;
}
pid = fork();
if (pid == 0) {
/* Child process */
/*
* Code from here to _exit() must only use async-signal-safe functions,
* listed at `man 7 signal` or
* http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html.
*/
if (preexec_fn != Py_None) {
/* We'll be calling back into Python later so we need to do this.
* This call may not be async-signal-safe but neither is calling
* back into Python. The user asked us to use hope as a strategy
* to avoid deadlock... */
PyOS_AfterFork();
}
child_exec(exec_array, argv, envp, cwd,
p2cread, p2cwrite, c2pread, c2pwrite,
errread, errwrite, errpipe_read, errpipe_write,
close_fds, restore_signals, call_setsid,
py_fds_to_keep, preexec_fn, preexec_fn_args_tuple);
_exit(255);
return NULL; /* Dead code to avoid a potential compiler warning. */
}
Py_XDECREF(cwd_obj2);
if (pid == -1) {
/* Capture the errno exception before errno can be clobbered. */
PyErr_SetFromErrno(PyExc_OSError);
}
if (preexec_fn != Py_None &&
_PyImport_ReleaseLock() < 0 && !PyErr_Occurred()) {
PyErr_SetString(PyExc_RuntimeError,
"not holding the import lock");
}
import_lock_held = 0;
/* Parent process */
if (envp)
_Py_FreeCharPArray(envp);
if (argv)
_Py_FreeCharPArray(argv);
_Py_FreeCharPArray(exec_array);
/* Reenable gc in the parent process (or if fork failed). */
if (need_to_reenable_gc && _enable_gc(gc_module)) {
Py_XDECREF(gc_module);
return NULL;
}
Py_XDECREF(preexec_fn_args_tuple);
Py_XDECREF(gc_module);
if (pid == -1)
return NULL; /* fork() failed. Exception set earlier. */
return PyLong_FromPid(pid);
cleanup:
if (import_lock_held)
_PyImport_ReleaseLock();
if (envp)
_Py_FreeCharPArray(envp);
if (argv)
_Py_FreeCharPArray(argv);
if (exec_array)
_Py_FreeCharPArray(exec_array);
Py_XDECREF(converted_args);
Py_XDECREF(fast_args);
Py_XDECREF(preexec_fn_args_tuple);
/* Reenable gc if it was disabled. */
if (need_to_reenable_gc) {
PyObject *exctype, *val, *tb;
PyErr_Fetch(&exctype, &val, &tb);
_enable_gc(gc_module);
PyErr_Restore(exctype, val, tb);
}
Py_XDECREF(gc_module);
return NULL;
}
void
ode_function(int *n, double *t, double *y, double *ydot)
{
/*
This is the function called from the Fortran code it should
-- use call_python_function to get a multiarrayobject result
-- check for errors and set *n to -1 if any
-- otherwise place result of calculation in ydot
*/
PyArrayObject *result_array = NULL;
PyObject *arg1, *arglist;
/* Append t to argument list */
if ((arg1 = PyTuple_New(1)) == NULL) {
*n = -1;
return;
}
PyTuple_SET_ITEM(arg1, 0, PyFloat_FromDouble(*t));
/* arg1 now owns newly created reference */
if ((arglist = PySequence_Concat(arg1, global_params.extra_arguments)) == NULL) {
*n = -1;
Py_DECREF(arg1);
return;
}
Py_DECREF(arg1); /* arglist has reference */
result_array = (PyArrayObject *)call_python_function(global_params.python_function,
*n, y, arglist, odepack_error);
if (result_array == NULL) {
*n = -1;
Py_DECREF(arglist);
return;
}
if (PyArray_NDIM(result_array) > 1) {
*n = -1;
PyErr_Format(PyExc_RuntimeError,
"The array return by func must be one-dimensional, but got ndim=%d.",
PyArray_NDIM(result_array));
Py_DECREF(arglist);
Py_DECREF(result_array);
return;
}
if (PyArray_Size((PyObject *)result_array) != *n) {
PyErr_Format(PyExc_RuntimeError,
"The size of the array returned by func (%ld) does not match "
"the size of y0 (%d).",
PyArray_Size((PyObject *)result_array), *n);
*n = -1;
Py_DECREF(arglist);
Py_DECREF(result_array);
return;
}
memcpy(ydot, PyArray_DATA(result_array), (*n)*sizeof(double));
Py_DECREF(result_array);
Py_DECREF(arglist);
return;
}
static PyObject *next(PyObject *self)
{
ligolw_RowDumper *rowdumper = (ligolw_RowDumper *) self;
const Py_ssize_t n = PyTuple_GET_SIZE(rowdumper->attributes);
PyObject *tokens;
PyObject *row;
PyObject *result;
Py_ssize_t i;
/*
* retrieve the next row object
*/
if(!PyIter_Check(rowdumper->iter)) {
PyErr_SetObject(PyExc_TypeError, rowdumper->iter);
return NULL;
}
row = PyIter_Next(rowdumper->iter);
if(!row) {
if(!PyErr_Occurred()) {
Py_DECREF(rowdumper->iter);
rowdumper->iter = Py_None;
Py_INCREF(rowdumper->iter);
PyErr_SetNone(PyExc_StopIteration);
}
return NULL;
}
/*
* wipe out the tuple of tokens from the previous row, and start a
* new tuple
*/
Py_DECREF(rowdumper->tokens);
rowdumper->tokens = Py_None;
Py_INCREF(rowdumper->tokens);
tokens = PyTuple_New(n);
if(!tokens) {
Py_DECREF(row);
return NULL;
}
/*
* retrieve attributes from the row object one-by-one, convert to
* strings, and insert into new token tuple
*/
for(i = 0; i < n; i++) {
PyObject *val = PyObject_GetAttr(row, PyTuple_GET_ITEM(rowdumper->attributes, i));
PyObject *token;
if(!val) {
Py_DECREF(tokens);
Py_DECREF(row);
return NULL;
}
if(val == Py_None)
token = PyUnicode_FromUnicode(NULL, 0); /* u"" */
else
token = PyObject_CallFunctionObjArgs(PyTuple_GET_ITEM(rowdumper->formats, i), val, NULL);
Py_DECREF(val);
if(!token) {
Py_DECREF(tokens);
Py_DECREF(row);
return NULL;
}
PyTuple_SET_ITEM(tokens, i, token);
}
Py_DECREF(row);
/*
* that worked, so expose the new token tuple
*/
Py_DECREF(rowdumper->tokens);
rowdumper->tokens = tokens;
/*
* return tokens concatenated into a single string using the
* delimiter
*/
result = PyUnicode_Join(rowdumper->delimiter, rowdumper->tokens);
rowdumper->rows_converted += result != NULL;
return result;
}
/* This function is called by the tp_dealloc handler to clear weak references.
*
* This iterates through the weak references for 'object' and calls callbacks
* for those references which have one. It returns when all callbacks have
* been attempted.
*/
void
PyObject_ClearWeakRefs(PyObject *object)
{
PyWeakReference **list;
if (object == NULL
|| !PyType_SUPPORTS_WEAKREFS(Py_TYPE(object))
|| object->ob_refcnt != 0) {
PyErr_BadInternalCall();
return;
}
list = GET_WEAKREFS_LISTPTR(object);
/* Remove the callback-less basic and proxy references */
if (*list != NULL && (*list)->wr_callback == NULL) {
clear_weakref(*list);
if (*list != NULL && (*list)->wr_callback == NULL)
clear_weakref(*list);
}
if (*list != NULL) {
PyWeakReference *current = *list;
Py_ssize_t count = _PyWeakref_GetWeakrefCount(current);
int restore_error = PyErr_Occurred() ? 1 : 0;
PyObject *err_type, *err_value, *err_tb;
if (restore_error)
PyErr_Fetch(&err_type, &err_value, &err_tb);
if (count == 1) {
PyObject *callback = current->wr_callback;
current->wr_callback = NULL;
clear_weakref(current);
if (callback != NULL) {
if (((PyObject *)current)->ob_refcnt > 0)
handle_callback(current, callback);
Py_DECREF(callback);
}
}
else {
PyObject *tuple;
Py_ssize_t i = 0;
tuple = PyTuple_New(count * 2);
if (tuple == NULL) {
if (restore_error)
PyErr_Fetch(&err_type, &err_value, &err_tb);
return;
}
for (i = 0; i < count; ++i) {
PyWeakReference *next = current->wr_next;
if (((PyObject *)current)->ob_refcnt > 0)
{
Py_INCREF(current);
PyTuple_SET_ITEM(tuple, i * 2, (PyObject *) current);
PyTuple_SET_ITEM(tuple, i * 2 + 1, current->wr_callback);
}
else {
Py_DECREF(current->wr_callback);
}
current->wr_callback = NULL;
clear_weakref(current);
current = next;
}
for (i = 0; i < count; ++i) {
PyObject *callback = PyTuple_GET_ITEM(tuple, i * 2 + 1);
/* The tuple may have slots left to NULL */
if (callback != NULL) {
PyObject *item = PyTuple_GET_ITEM(tuple, i * 2);
handle_callback((PyWeakReference *)item, callback);
}
}
Py_DECREF(tuple);
}
if (restore_error)
PyErr_Restore(err_type, err_value, err_tb);
}
}
/*@null@*/
static PyObject *
rpmfi_iternext(rpmfiObject * s)
/*@globals _Py_NoneStruct @*/
/*@modifies s, _Py_NoneStruct @*/
{
PyObject * result = NULL;
/* Reset loop indices on 1st entry. */
if (!s->active) {
s->fi = rpmfiInit(s->fi, 0);
s->active = 1;
}
/* If more to do, return the file tuple. */
if (rpmfiNext(s->fi) >= 0) {
const char * FN = rpmfiFN(s->fi);
int FSize = rpmfiFSize(s->fi);
int FMode = rpmfiFMode(s->fi);
int FMtime = rpmfiFMtime(s->fi);
int FFlags = rpmfiFFlags(s->fi);
int FRdev = rpmfiFRdev(s->fi);
int FInode = rpmfiFInode(s->fi);
int FNlink = rpmfiFNlink(s->fi);
int FState = rpmfiFState(s->fi);
int VFlags = rpmfiVFlags(s->fi);
const char * FUser = rpmfiFUser(s->fi);
const char * FGroup = rpmfiFGroup(s->fi);
result = PyTuple_New(13);
if (FN == NULL) {
Py_INCREF(Py_None);
PyTuple_SET_ITEM(result, 0, Py_None);
} else
PyTuple_SET_ITEM(result, 0, Py_BuildValue("s", FN));
PyTuple_SET_ITEM(result, 1, PyInt_FromLong(FSize));
PyTuple_SET_ITEM(result, 2, PyInt_FromLong(FMode));
PyTuple_SET_ITEM(result, 3, PyInt_FromLong(FMtime));
PyTuple_SET_ITEM(result, 4, PyInt_FromLong(FFlags));
PyTuple_SET_ITEM(result, 5, PyInt_FromLong(FRdev));
PyTuple_SET_ITEM(result, 6, PyInt_FromLong(FInode));
PyTuple_SET_ITEM(result, 7, PyInt_FromLong(FNlink));
PyTuple_SET_ITEM(result, 8, PyInt_FromLong(FState));
PyTuple_SET_ITEM(result, 9, PyInt_FromLong(VFlags));
if (FUser == NULL) {
Py_INCREF(Py_None);
PyTuple_SET_ITEM(result, 10, Py_None);
} else
PyTuple_SET_ITEM(result, 10, Py_BuildValue("s", FUser));
if (FGroup == NULL) {
Py_INCREF(Py_None);
PyTuple_SET_ITEM(result, 11, Py_None);
} else
PyTuple_SET_ITEM(result, 11, Py_BuildValue("s", FGroup));
PyTuple_SET_ITEM(result, 12, rpmfi_Digest(s));
} else
s->active = 0;
return result;
}
PY_GETSET_GETTER_DECL(TempVertex, weights) {
PyObject* list = PyTuple_New(3);
for (size_t i = 0; i < 3; ++i)
PyTuple_SET_ITEM(list, i, pyPlasma_convert(self->fThis->fWeights[i]));
return list;
}
/*
def __adapt__(self, obj):
"""Adapt an object to the reciever
"""
if self.providedBy(obj):
return obj
for hook in adapter_hooks:
adapter = hook(self, obj)
if adapter is not None:
return adapter
*/
static PyObject *
__adapt__(PyObject *self, PyObject *obj)
{
PyObject *decl, *args, *adapter;
int implements, i, l;
decl = providedBy(NULL, obj);
if (decl == NULL)
return NULL;
if (PyObject_TypeCheck(decl, &SpecType))
{
PyObject *implied;
implied = inst_attr(decl, str_implied);
if (implied == NULL)
{
Py_DECREF(decl);
return NULL;
}
implements = PyDict_GetItem(implied, self) != NULL;
Py_DECREF(decl);
}
else
{
/* decl is probably a security proxy. We have to go the long way
around.
*/
PyObject *r;
r = PyObject_CallFunctionObjArgs(decl, self, NULL);
Py_DECREF(decl);
if (r == NULL)
return NULL;
implements = PyObject_IsTrue(r);
Py_DECREF(r);
}
if (implements)
{
Py_INCREF(obj);
return obj;
}
l = PyList_GET_SIZE(adapter_hooks);
args = PyTuple_New(2);
if (args == NULL)
return NULL;
Py_INCREF(self);
PyTuple_SET_ITEM(args, 0, self);
Py_INCREF(obj);
PyTuple_SET_ITEM(args, 1, obj);
for (i = 0; i < l; i++)
{
adapter = PyObject_CallObject(PyList_GET_ITEM(adapter_hooks, i), args);
if (adapter == NULL || adapter != Py_None)
{
Py_DECREF(args);
return adapter;
}
Py_DECREF(adapter);
}
Py_DECREF(args);
Py_INCREF(Py_None);
return Py_None;
}
PyObject * PyPreprocessor_scanHeaders( PyPreprocessor * self, PyObject * args, PyObject * kwds )
{
static char * kwlist[] = { "pp_ctx", "filename", NULL };
PyObject * pObject = 0;
PyObject * filename = 0;
assert( self->pp );
if ( !PyArg_ParseTupleAndKeywords( args, kwds, "OO", kwlist, &pObject, &filename ) )
return NULL;
if ( !pObject || ( (PyTypeObject *)PyObject_Type( pObject ) != &PyPreprocessingContextType ) )
{
PyErr_SetString( PyExc_Exception, "Invalid preprocessing context parameter." );
return NULL;
}
PyPreprocessingContext const * ppContext( reinterpret_cast<PyPreprocessingContext *>( pObject ) );
if ( filename && !PyUnicode_Check( filename ) )
{
PyErr_SetString( PyExc_Exception, "Expected a string as 'filename' parameter." );
return NULL;
}
Headers headers;
HeaderList missing;
PyThreadState * _save;
bool result;
try
{
Py_UNBLOCK_THREADS
result = self->pp->scanHeaders( *ppContext->ppContext, PyUnicode_AsUTF8( filename ), headers, missing );
}
catch ( std::runtime_error const & error )
{
Py_BLOCK_THREADS
PyErr_SetString( PyExc_RuntimeError, error.what() );
return NULL;
}
catch ( std::exception const & error )
{
Py_BLOCK_THREADS
PyErr_SetString( PyExc_Exception, error.what() );
return NULL;
}
catch ( ... )
{
Py_BLOCK_THREADS
PyErr_SetString( PyExc_Exception, "Unhandled exception" );
return NULL;
}
if ( !result )
{
Py_BLOCK_THREADS
PyErr_SetString( PyExc_Exception, "Failed to preprocess file." );
return NULL;
}
// Group result by dir.
typedef std::vector<Header const *> HeaderPtrList;
typedef std::unordered_map<Dir, HeaderPtrList> DirsAndHeaders;
DirsAndHeaders dirsAndHeaders;
for ( Header const & header : headers )
dirsAndHeaders[ header.dir ].push_back( &header );
Py_BLOCK_THREADS
PyObject * dirsTuple = PyTuple_New( dirsAndHeaders.size() );
std::size_t dirIndex( 0 );
for ( DirsAndHeaders::value_type const & dirAndHeaders : dirsAndHeaders )
{
PyObject * headersInDirTuple = PyTuple_New( dirAndHeaders.second.size() );
std::size_t headersInDirTupleIndex( 0 );
for ( Header const * header : dirAndHeaders.second )
{
PyObject * headerEntry = PyTuple_New( 3 );
PyTuple_SET_ITEM( headerEntry, 0, PyUnicode_FromStringAndSize( header->name.get().data(), header->name.get().size() ) );
PyObject * const isRelative( header->relative ? Py_True : Py_False );
Py_INCREF( isRelative );
PyTuple_SET_ITEM( headerEntry, 1, isRelative );
PyContentEntry * contentEntry( (PyContentEntry *)_PyObject_New( &PyContentEntryType ) );
contentEntry->ptr = header->contentEntry.get();
intrusive_ptr_add_ref( contentEntry->ptr );
PyTuple_SET_ITEM( headerEntry, 2, (PyObject *)contentEntry );
PyTuple_SET_ITEM( headersInDirTuple, headersInDirTupleIndex++, headerEntry );
}
PyObject * dirTuple = PyTuple_New( 2 );
llvm::StringRef const dirStr( dirAndHeaders.first.get() );
PyObject * dir = PyUnicode_FromStringAndSize( dirStr.data(), dirStr.size() );
PyTuple_SET_ITEM( dirTuple, 0, dir );
PyTuple_SET_ITEM( dirTuple, 1, headersInDirTuple );
PyTuple_SET_ITEM( dirsTuple, dirIndex++, dirTuple );
}
PyObject * missingHeadersTuple = PyTuple_New( missing.size() );
std::size_t missingIndex( 0 );
for ( HeaderList::value_type const & missingHeader : missing )
{
PyObject * val = PyUnicode_FromStringAndSize( missingHeader.data(), missingHeader.size() );
PyTuple_SET_ITEM( missingHeadersTuple, missingIndex++, val );
}
PyObject * resultTuple = PyTuple_New( 2 );
PyTuple_SET_ITEM( resultTuple, 0, dirsTuple );
PyTuple_SET_ITEM( resultTuple, 1, missingHeadersTuple );
return resultTuple;
}
static rlm_rcode_t do_python(rlm_python_t *inst, REQUEST *request, PyObject *pFunc, char const *funcname, bool worker)
{
vp_cursor_t cursor;
VALUE_PAIR *vp;
PyObject *pRet = NULL;
PyObject *pArgs = NULL;
int tuplelen;
int ret;
PyGILState_STATE gstate;
PyThreadState *prev_thread_state = NULL; /* -Wuninitialized */
memset(&gstate, 0, sizeof(gstate)); /* -Wuninitialized */
/* Return with "OK, continue" if the function is not defined. */
if (!pFunc)
return RLM_MODULE_NOOP;
#ifdef HAVE_PTHREAD_H
gstate = PyGILState_Ensure();
if (worker) {
PyThreadState *my_thread_state;
my_thread_state = fr_thread_local_init(local_thread_state, do_python_cleanup);
if (!my_thread_state) {
my_thread_state = PyThreadState_New(inst->main_thread_state->interp);
if (!my_thread_state) {
REDEBUG("Failed initialising local PyThreadState on first run");
PyGILState_Release(gstate);
return RLM_MODULE_FAIL;
}
ret = fr_thread_local_set(local_thread_state, my_thread_state);
if (ret != 0) {
REDEBUG("Failed storing PyThreadState in TLS: %s", fr_syserror(ret));
PyThreadState_Clear(my_thread_state);
PyThreadState_Delete(my_thread_state);
PyGILState_Release(gstate);
return RLM_MODULE_FAIL;
}
}
prev_thread_state = PyThreadState_Swap(my_thread_state); /* Swap in our local thread state */
}
#endif
/* Default return value is "OK, continue" */
ret = RLM_MODULE_OK;
/*
* We will pass a tuple containing (name, value) tuples
* We can safely use the Python function to build up a
* tuple, since the tuple is not used elsewhere.
*
* Determine the size of our tuple by walking through the packet.
* If request is NULL, pass None.
*/
tuplelen = 0;
if (request != NULL) {
for (vp = paircursor(&cursor, &request->packet->vps);
vp;
vp = pairnext(&cursor)) {
tuplelen++;
}
}
if (tuplelen == 0) {
Py_INCREF(Py_None);
pArgs = Py_None;
} else {
int i = 0;
if ((pArgs = PyTuple_New(tuplelen)) == NULL) {
ret = RLM_MODULE_FAIL;
goto finish;
}
for (vp = paircursor(&cursor, &request->packet->vps);
vp;
vp = pairnext(&cursor), i++) {
PyObject *pPair;
/* The inside tuple has two only: */
if ((pPair = PyTuple_New(2)) == NULL) {
ret = RLM_MODULE_FAIL;
goto finish;
}
if (mod_populate_vptuple(pPair, vp) == 0) {
/* Put the tuple inside the container */
PyTuple_SET_ITEM(pArgs, i, pPair);
} else {
Py_INCREF(Py_None);
PyTuple_SET_ITEM(pArgs, i, Py_None);
Py_DECREF(pPair);
}
}
}
/* Call Python function. */
pRet = PyObject_CallFunctionObjArgs(pFunc, pArgs, NULL);
if (!pRet) {
ret = RLM_MODULE_FAIL;
goto finish;
}
if (!request)
goto finish;
/*
* The function returns either:
* 1. (returnvalue, replyTuple, configTuple), where
* - returnvalue is one of the constants RLM_*
* - replyTuple and configTuple are tuples of string
* tuples of size 2
*
* 2. the function return value alone
*
* 3. None - default return value is set
*
* xxx This code is messy!
*/
if (PyTuple_CheckExact(pRet)) {
PyObject *pTupleInt;
if (PyTuple_GET_SIZE(pRet) != 3) {
ERROR("rlm_python:%s: tuple must be (return, replyTuple, configTuple)", funcname);
ret = RLM_MODULE_FAIL;
goto finish;
}
pTupleInt = PyTuple_GET_ITEM(pRet, 0);
if (!PyInt_CheckExact(pTupleInt)) {
ERROR("rlm_python:%s: first tuple element not an integer", funcname);
ret = RLM_MODULE_FAIL;
goto finish;
}
/* Now have the return value */
ret = PyInt_AsLong(pTupleInt);
/* Reply item tuple */
mod_vptuple(request->reply, &request->reply->vps,
PyTuple_GET_ITEM(pRet, 1), funcname);
/* Config item tuple */
mod_vptuple(request, &request->config_items,
PyTuple_GET_ITEM(pRet, 2), funcname);
} else if (PyInt_CheckExact(pRet)) {
/* Just an integer */
ret = PyInt_AsLong(pRet);
} else if (pRet == Py_None) {
/* returned 'None', return value defaults to "OK, continue." */
ret = RLM_MODULE_OK;
} else {
/* Not tuple or None */
ERROR("rlm_python:%s: function did not return a tuple or None", funcname);
ret = RLM_MODULE_FAIL;
goto finish;
}
finish:
if (pArgs) {
Py_DECREF(pArgs);
}
if (pRet) {
Py_DECREF(pRet);
}
#ifdef HAVE_PTHREAD_H
if (worker) {
PyThreadState_Swap(prev_thread_state);
}
PyGILState_Release(gstate);
#endif
return ret;
}
static int
find_named_args(DispatcherObject *self, PyObject **pargs, PyObject **pkws)
{
PyObject *oldargs = *pargs, *newargs;
PyObject *kws = *pkws;
Py_ssize_t pos_args = PyTuple_GET_SIZE(oldargs);
Py_ssize_t named_args, total_args, i;
Py_ssize_t func_args = PyTuple_GET_SIZE(self->argnames);
Py_ssize_t defaults = PyTuple_GET_SIZE(self->defargs);
/* Last parameter with a default value */
Py_ssize_t last_def = (self->has_stararg)
? func_args - 2
: func_args - 1;
/* First parameter with a default value */
Py_ssize_t first_def = last_def - defaults + 1;
/* Minimum number of required arguments */
Py_ssize_t minargs = first_def;
if (kws != NULL)
named_args = PyDict_Size(kws);
else
named_args = 0;
total_args = pos_args + named_args;
if (!self->has_stararg && total_args > func_args) {
PyErr_Format(PyExc_TypeError,
"too many arguments: expected %d, got %d",
(int) func_args, (int) total_args);
return -1;
}
else if (total_args < minargs) {
if (minargs == func_args)
PyErr_Format(PyExc_TypeError,
"not enough arguments: expected %d, got %d",
(int) minargs, (int) total_args);
else
PyErr_Format(PyExc_TypeError,
"not enough arguments: expected at least %d, got %d",
(int) minargs, (int) total_args);
return -1;
}
newargs = PyTuple_New(func_args);
if (!newargs)
return -1;
/* First pack the stararg */
if (self->has_stararg) {
Py_ssize_t stararg_size = Py_MAX(0, pos_args - func_args + 1);
PyObject *stararg = PyTuple_New(stararg_size);
if (!stararg) {
Py_DECREF(newargs);
return -1;
}
for (i = 0; i < stararg_size; i++) {
PyObject *value = PyTuple_GET_ITEM(oldargs, func_args - 1 + i);
Py_INCREF(value);
PyTuple_SET_ITEM(stararg, i, value);
}
/* Put it in last position */
PyTuple_SET_ITEM(newargs, func_args - 1, stararg);
}
for (i = 0; i < pos_args; i++) {
PyObject *value = PyTuple_GET_ITEM(oldargs, i);
if (self->has_stararg && i >= func_args - 1) {
/* Skip stararg */
break;
}
Py_INCREF(value);
PyTuple_SET_ITEM(newargs, i, value);
}
/* Iterate over missing positional arguments, try to find them in
named arguments or default values. */
for (i = pos_args; i < func_args; i++) {
PyObject *name = PyTuple_GET_ITEM(self->argnames, i);
if (self->has_stararg && i >= func_args - 1) {
/* Skip stararg */
break;
}
if (kws != NULL) {
/* Named argument? */
PyObject *value = PyDict_GetItem(kws, name);
if (value != NULL) {
Py_INCREF(value);
PyTuple_SET_ITEM(newargs, i, value);
named_args--;
continue;
}
}
if (i >= first_def && i <= last_def) {
/* Argument has a default value? */
PyObject *value = PyTuple_GET_ITEM(self->defargs, i - first_def);
Py_INCREF(value);
PyTuple_SET_ITEM(newargs, i, value);
continue;
}
else if (i < func_args - 1 || !self->has_stararg) {
PyErr_Format(PyExc_TypeError,
"missing argument '%s'",
PyString_AsString(name));
Py_DECREF(newargs);
return -1;
}
}
if (named_args) {
PyErr_Format(PyExc_TypeError,
"some keyword arguments unexpected");
Py_DECREF(newargs);
return -1;
}
*pargs = newargs;
*pkws = NULL;
return 0;
}
// @pymethod string/tuple|win32wnet|WNetGetUniversalName|Takes a drive-based path for a network resource and returns an information structure that contains a more universal form of the name.
static
PyObject *
PyWNetGetUniversalName(PyObject *self, PyObject *args)
{
int level = UNIVERSAL_NAME_INFO_LEVEL;
TCHAR *szLocalPath = NULL;
PyObject *obLocalPath;
void *buf = NULL;
DWORD length = 0;
PyObject *ret = NULL;
DWORD errcode;
if (!PyArg_ParseTuple(args, "O|i:WNetGetUniversalName", &obLocalPath, &level))
return NULL;
if (!PyWinObject_AsTCHAR(obLocalPath, &szLocalPath, FALSE))
return NULL;
// @pyparm string|localPath||A string that is a drive-based path for a network resource.
// <nl>For example, if drive H has been mapped to a network drive share, and the network
// resource of interest is a file named SAMPLE.DOC in the directory \WIN32\EXAMPLES on
// that share, the drive-based path is H:\WIN32\EXAMPLES\SAMPLE.DOC.
// @pyparm int|infoLevel|UNIVERSAL_NAME_INFO_LEVEL|Specifies the type of structure that the function stores in the buffer pointed to by the lpBuffer parameter.
// This parameter can be one of the following values.
// @flagh Value|Meaning
// @flag UNIVERSAL_NAME_INFO_LEVEL (=1)|The function returns a simple string with the UNC name.
// @flag REMOTE_NAME_INFO_LEVEL (=2)|The function returns a tuple based in the Win32 REMOTE_NAME_INFO data structure.
// @rdesc If the infoLevel parameter is REMOTE_NAME_INFO_LEVEL, the result is a tuple of 3 strings: (UNCName, connectionName, remainingPath)
// First get the buffer size.
{
Py_BEGIN_ALLOW_THREADS
char temp_buf[] = ""; // doesnt appear to like NULL!!
errcode = WNetGetUniversalName( szLocalPath, level, &temp_buf, &length);
Py_END_ALLOW_THREADS
}
if (errcode != ERROR_MORE_DATA || length == 0) {
ReturnNetError("WNetGetUniversalName (for buffer size)", errcode);
goto done;
}
buf = malloc(length);
if (buf==NULL) goto done;
errcode = WNetGetUniversalName( szLocalPath, level, buf, &length);
if (errcode != 0) {
ReturnNetError("WNetGetUniversalName", errcode);
goto done;
}
switch (level) {
case UNIVERSAL_NAME_INFO_LEVEL:
ret = PyWinObject_FromTCHAR( ((UNIVERSAL_NAME_INFO *)buf)->lpUniversalName );
break;
case REMOTE_NAME_INFO_LEVEL: {
REMOTE_NAME_INFO *r = (REMOTE_NAME_INFO *)buf;
ret = PyTuple_New(3);
if (ret==NULL) goto done;
PyTuple_SET_ITEM(ret, 0, PyWinObject_FromTCHAR( r->lpUniversalName) );
PyTuple_SET_ITEM(ret, 1, PyWinObject_FromTCHAR( r->lpConnectionName) );
PyTuple_SET_ITEM(ret, 2, PyWinObject_FromTCHAR( r->lpRemainingPath) );
break;
}
default:
PyErr_SetString(PyExc_TypeError, "Unsupported infoLevel");
}
done:
PyWinObject_FreeTCHAR(szLocalPath);
if (buf) free(buf);
return ret;
}
// Returns a new reference.
static PyObject*
decode_val(DecodeBuffer* input, TType type, PyObject* typeargs, long string_limit, long container_limit) {
switch (type) {
case T_BOOL: {
int8_t v = readByte(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
switch (v) {
case 0:
Py_RETURN_FALSE;
case 1:
Py_RETURN_TRUE;
// Don't laugh. This is a potentially serious issue.
default:
PyErr_SetString(PyExc_TypeError, "boolean out of range");
return NULL;
}
break;
}
case T_I08: {
int8_t v = readByte(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
return PyInt_FromLong(v);
}
case T_I16: {
int16_t v = readI16(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
return PyInt_FromLong(v);
}
case T_I32: {
int32_t v = readI32(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
return PyInt_FromLong(v);
}
case T_I64: {
int64_t v = readI64(input);
if (INT_CONV_ERROR_OCCURRED(v)) {
return NULL;
}
// TODO(dreiss): Find out if we can take this fastpath always when
// sizeof(long) == sizeof(long long).
if (CHECK_RANGE(v, LONG_MIN, LONG_MAX)) {
return PyInt_FromLong((long) v);
}
return PyLong_FromLongLong(v);
}
case T_DOUBLE: {
double v = readDouble(input);
if (v == -1.0 && PyErr_Occurred()) {
return false;
}
return PyFloat_FromDouble(v);
}
case T_STRING: {
Py_ssize_t len = readI32(input);
char* buf;
if (!readBytes(input, &buf, len)) {
return NULL;
}
if (!check_length_limit(len, string_limit)) {
return NULL;
}
if (is_utf8(typeargs))
return PyUnicode_DecodeUTF8(buf, len, 0);
else
return PyString_FromStringAndSize(buf, len);
}
case T_LIST:
case T_SET: {
SetListTypeArgs parsedargs;
int32_t len;
PyObject* ret = NULL;
int i;
bool use_tuple = false;
if (!parse_set_list_args(&parsedargs, typeargs)) {
return NULL;
}
if (!checkTypeByte(input, parsedargs.element_type)) {
return NULL;
}
len = readI32(input);
if (!check_length_limit(len, container_limit)) {
return NULL;
}
use_tuple = type == T_LIST && parsedargs.immutable;
ret = use_tuple ? PyTuple_New(len) : PyList_New(len);
if (!ret) {
return NULL;
}
for (i = 0; i < len; i++) {
PyObject* item = decode_val(input, parsedargs.element_type, parsedargs.typeargs, string_limit, container_limit);
if (!item) {
Py_DECREF(ret);
return NULL;
}
if (use_tuple) {
PyTuple_SET_ITEM(ret, i, item);
} else {
PyList_SET_ITEM(ret, i, item);
}
}
// TODO(dreiss): Consider biting the bullet and making two separate cases
// for list and set, avoiding this post facto conversion.
if (type == T_SET) {
PyObject* setret;
setret = parsedargs.immutable ? PyFrozenSet_New(ret) : PySet_New(ret);
Py_DECREF(ret);
return setret;
}
return ret;
}
case T_MAP: {
int32_t len;
int i;
MapTypeArgs parsedargs;
PyObject* ret = NULL;
if (!parse_map_args(&parsedargs, typeargs)) {
return NULL;
}
if (!checkTypeByte(input, parsedargs.ktag)) {
return NULL;
}
if (!checkTypeByte(input, parsedargs.vtag)) {
return NULL;
}
len = readI32(input);
if (!check_length_limit(len, container_limit)) {
return NULL;
}
ret = PyDict_New();
if (!ret) {
goto error;
}
for (i = 0; i < len; i++) {
PyObject* k = NULL;
PyObject* v = NULL;
k = decode_val(input, parsedargs.ktag, parsedargs.ktypeargs, string_limit, container_limit);
if (k == NULL) {
goto loop_error;
}
v = decode_val(input, parsedargs.vtag, parsedargs.vtypeargs, string_limit, container_limit);
if (v == NULL) {
goto loop_error;
}
if (PyDict_SetItem(ret, k, v) == -1) {
goto loop_error;
}
Py_DECREF(k);
Py_DECREF(v);
continue;
// Yuck! Destructors, anyone?
loop_error:
Py_XDECREF(k);
Py_XDECREF(v);
goto error;
}
if (parsedargs.immutable) {
PyObject* thrift = PyImport_ImportModule("thrift.Thrift");
PyObject* cls = NULL;
PyObject* arg = NULL;
if (!thrift) {
goto error;
}
cls = PyObject_GetAttrString(thrift, "TFrozenDict");
if (!cls) {
goto error;
}
arg = PyTuple_New(1);
PyTuple_SET_ITEM(arg, 0, ret);
return PyObject_CallObject(cls, arg);
}
return ret;
error:
Py_XDECREF(ret);
return NULL;
}
case T_STRUCT: {
StructTypeArgs parsedargs;
if (!parse_struct_args(&parsedargs, typeargs)) {
return NULL;
}
return decode_struct(input, Py_None, parsedargs.klass, parsedargs.spec, string_limit, container_limit);
}
case T_STOP:
case T_VOID:
case T_UTF16:
case T_UTF8:
case T_U64:
default:
PyErr_SetString(PyExc_TypeError, "Unexpected TType");
return NULL;
}
}
PyObject *ServiceType_UpOnce(PyObject *self, PyObject *ignore) {
PyObject *args = PyTuple_New(1);
PyTuple_SET_ITEM(args, 0, PyString_FromString("o"));
return ServiceType_Control(self, args);
}
static PyObject *
slice_richcompare(PyObject *v, PyObject *w, int op)
{
PyObject *t1;
PyObject *t2;
PyObject *res;
if (!PySlice_Check(v) || !PySlice_Check(w)) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
if (v == w) {
/* XXX Do we really need this shortcut?
There's a unit test for it, but is that fair? */
switch (op) {
case Py_EQ:
case Py_LE:
case Py_GE:
res = Py_True;
break;
default:
res = Py_False;
break;
}
Py_INCREF(res);
return res;
}
t1 = PyTuple_New(3);
t2 = PyTuple_New(3);
if (t1 == NULL || t2 == NULL)
return NULL;
PyTuple_SET_ITEM(t1, 0, ((PySliceObject *)v)->start);
PyTuple_SET_ITEM(t1, 1, ((PySliceObject *)v)->stop);
PyTuple_SET_ITEM(t1, 2, ((PySliceObject *)v)->step);
PyTuple_SET_ITEM(t2, 0, ((PySliceObject *)w)->start);
PyTuple_SET_ITEM(t2, 1, ((PySliceObject *)w)->stop);
PyTuple_SET_ITEM(t2, 2, ((PySliceObject *)w)->step);
res = PyObject_RichCompare(t1, t2, op);
PyTuple_SET_ITEM(t1, 0, NULL);
PyTuple_SET_ITEM(t1, 1, NULL);
PyTuple_SET_ITEM(t1, 2, NULL);
PyTuple_SET_ITEM(t2, 0, NULL);
PyTuple_SET_ITEM(t2, 1, NULL);
PyTuple_SET_ITEM(t2, 2, NULL);
Py_DECREF(t1);
Py_DECREF(t2);
return res;
}
PyObject*
_PyCode_ConstantKey(PyObject *op)
{
PyObject *key;
/* Py_None and Py_Ellipsis are singletons. */
if (op == Py_None || op == Py_Ellipsis
|| PyLong_CheckExact(op)
|| PyUnicode_CheckExact(op)
/* code_richcompare() uses _PyCode_ConstantKey() internally */
|| PyCode_Check(op))
{
/* Objects of these types are always different from object of other
* type and from tuples. */
Py_INCREF(op);
key = op;
}
else if (PyBool_Check(op) || PyBytes_CheckExact(op)) {
/* Make booleans different from integers 0 and 1.
* Avoid BytesWarning from comparing bytes with strings. */
key = PyTuple_Pack(2, Py_TYPE(op), op);
}
else if (PyFloat_CheckExact(op)) {
double d = PyFloat_AS_DOUBLE(op);
/* all we need is to make the tuple different in either the 0.0
* or -0.0 case from all others, just to avoid the "coercion".
*/
if (d == 0.0 && copysign(1.0, d) < 0.0)
key = PyTuple_Pack(3, Py_TYPE(op), op, Py_None);
else
key = PyTuple_Pack(2, Py_TYPE(op), op);
}
else if (PyComplex_CheckExact(op)) {
Py_complex z;
int real_negzero, imag_negzero;
/* For the complex case we must make complex(x, 0.)
different from complex(x, -0.) and complex(0., y)
different from complex(-0., y), for any x and y.
All four complex zeros must be distinguished.*/
z = PyComplex_AsCComplex(op);
real_negzero = z.real == 0.0 && copysign(1.0, z.real) < 0.0;
imag_negzero = z.imag == 0.0 && copysign(1.0, z.imag) < 0.0;
/* use True, False and None singleton as tags for the real and imag
* sign, to make tuples different */
if (real_negzero && imag_negzero) {
key = PyTuple_Pack(3, Py_TYPE(op), op, Py_True);
}
else if (imag_negzero) {
key = PyTuple_Pack(3, Py_TYPE(op), op, Py_False);
}
else if (real_negzero) {
key = PyTuple_Pack(3, Py_TYPE(op), op, Py_None);
}
else {
key = PyTuple_Pack(2, Py_TYPE(op), op);
}
}
else if (PyTuple_CheckExact(op)) {
Py_ssize_t i, len;
PyObject *tuple;
len = PyTuple_GET_SIZE(op);
tuple = PyTuple_New(len);
if (tuple == NULL)
return NULL;
for (i=0; i < len; i++) {
PyObject *item, *item_key;
item = PyTuple_GET_ITEM(op, i);
item_key = _PyCode_ConstantKey(item);
if (item_key == NULL) {
Py_DECREF(tuple);
return NULL;
}
PyTuple_SET_ITEM(tuple, i, item_key);
}
key = PyTuple_Pack(2, tuple, op);
Py_DECREF(tuple);
}
else if (PyFrozenSet_CheckExact(op)) {
Py_ssize_t pos = 0;
PyObject *item;
Py_hash_t hash;
Py_ssize_t i, len;
PyObject *tuple, *set;
len = PySet_GET_SIZE(op);
tuple = PyTuple_New(len);
if (tuple == NULL)
return NULL;
i = 0;
while (_PySet_NextEntry(op, &pos, &item, &hash)) {
PyObject *item_key;
item_key = _PyCode_ConstantKey(item);
if (item_key == NULL) {
Py_DECREF(tuple);
return NULL;
}
assert(i < len);
PyTuple_SET_ITEM(tuple, i, item_key);
i++;
}
set = PyFrozenSet_New(tuple);
Py_DECREF(tuple);
if (set == NULL)
return NULL;
key = PyTuple_Pack(2, set, op);
Py_DECREF(set);
return key;
}
else {
/* for other types, use the object identifier as a unique identifier
* to ensure that they are seen as unequal. */
PyObject *obj_id = PyLong_FromVoidPtr(op);
if (obj_id == NULL)
return NULL;
key = PyTuple_Pack(2, obj_id, op);
Py_DECREF(obj_id);
}
return key;
}
int
ode_jacobian_function(int *n, double *t, double *y, int *ml, int *mu,
double *pd, int *nrowpd)
{
/*
This is the function called from the Fortran code it should
-- use call_python_function to get a multiarrayobject result
-- check for errors and return -1 if any (though this is ignored
by calling program).
-- otherwise place result of calculation in pd
*/
PyArrayObject *result_array;
PyObject *arglist, *arg1;
int ndim, nrows, ncols, dim_error;
npy_intp *dims;
/* Append t to argument list */
if ((arg1 = PyTuple_New(1)) == NULL) {
*n = -1;
return -1;
}
PyTuple_SET_ITEM(arg1, 0, PyFloat_FromDouble(*t));
/* arg1 now owns newly created reference */
if ((arglist = PySequence_Concat(arg1, global_params.extra_arguments)) == NULL) {
*n = -1;
Py_DECREF(arg1);
return -1;
}
Py_DECREF(arg1); /* arglist has reference */
result_array = (PyArrayObject *)call_python_function(global_params.python_jacobian,
*n, y, arglist, odepack_error);
if (result_array == NULL) {
*n = -1;
Py_DECREF(arglist);
return -1;
}
ncols = *n;
if (global_params.jac_type == 4) {
nrows = *ml + *mu + 1;
}
else {
nrows = *n;
}
if (!global_params.jac_transpose) {
int tmp;
tmp = nrows;
nrows = ncols;
ncols = tmp;
}
ndim = PyArray_NDIM(result_array);
if (ndim > 2) {
PyErr_Format(PyExc_RuntimeError,
"The Jacobian array must be two dimensional, but got ndim=%d.",
ndim);
*n = -1;
Py_DECREF(arglist);
Py_DECREF(result_array);
return -1;
}
dims = PyArray_DIMS(result_array);
dim_error = 0;
if (ndim == 0) {
if ((nrows != 1) || (ncols != 1)) {
dim_error = 1;
}
}
if (ndim == 1) {
if ((nrows != 1) || (dims[0] != ncols)) {
dim_error = 1;
}
}
if (ndim == 2) {
if ((dims[0] != nrows) || (dims[1] != ncols)) {
dim_error = 1;
}
}
if (dim_error) {
char *b = "";
if (global_params.jac_type == 4) {
b = "banded ";
}
PyErr_Format(PyExc_RuntimeError,
"Expected a %sJacobian array with shape (%d, %d)",
b, nrows, ncols);
*n = -1;
Py_DECREF(arglist);
Py_DECREF(result_array);
return -1;
}
/*
* global_params.jac_type is either 1 (full Jacobian) or 4 (banded Jacobian).
* global_params.jac_transpose is !col_deriv, so if global_params.jac_transpose
* is 0, the array created by the user is already in Fortran order, and
* a transpose is not needed when it is copied to pd.
*/
if ((global_params.jac_type == 1) && !global_params.jac_transpose) {
/* Full Jacobian, no transpose needed, so we can use memcpy. */
memcpy(pd, PyArray_DATA(result_array), (*n)*(*nrowpd)*sizeof(double));
}
else {
/*
* global_params.jac_type == 4 (banded Jacobian), or
* global_params.jac_type == 1 and global_params.jac_transpose == 1.
*
* We can't use memcpy when global_params.jac_type is 4 because the leading
* dimension of pd doesn't necessarily equal the number of rows of the
* matrix.
*/
int m; /* Number of rows in the (full or packed banded) Jacobian. */
if (global_params.jac_type == 4) {
m = *ml + *mu + 1;
}
else {
m = *n;
}
copy_array_to_fortran(pd, *nrowpd, m, *n,
(double *) PyArray_DATA(result_array),
!global_params.jac_transpose);
}
Py_DECREF(arglist);
Py_DECREF(result_array);
return 0;
}
NRT_adapt_ndarray_to_python(arystruct_t* arystruct, int ndim,
int writeable, PyArray_Descr *descr)
{
PyArrayObject *array;
MemInfoObject *miobj = NULL;
PyObject *args;
npy_intp *shape, *strides;
int flags = 0;
if (!PyArray_DescrCheck(descr)) {
PyErr_Format(PyExc_TypeError,
"expected dtype object, got '%.200s'",
Py_TYPE(descr)->tp_name);
return NULL;
}
if (arystruct->parent) {
PyObject *obj = try_to_return_parent(arystruct, ndim, descr);
if (obj) {
/* Release NRT reference to the numpy array */
NRT_MemInfo_release(arystruct->meminfo);
return obj;
}
}
if (arystruct->meminfo) {
/* wrap into MemInfoObject */
miobj = PyObject_New(MemInfoObject, &MemInfoType);
args = PyTuple_New(1);
/* SETITEM steals reference */
PyTuple_SET_ITEM(args, 0, PyLong_FromVoidPtr(arystruct->meminfo));
/* Note: MemInfo_init() does not incref. This function steals the
* NRT reference.
*/
if (MemInfo_init(miobj, args, NULL)) {
return NULL;
}
Py_DECREF(args);
}
shape = arystruct->shape_and_strides;
strides = shape + ndim;
Py_INCREF((PyObject *) descr);
array = (PyArrayObject *) PyArray_NewFromDescr(&PyArray_Type, descr, ndim,
shape, strides, arystruct->data,
flags, (PyObject *) miobj);
if (array == NULL)
return NULL;
/* Set writable */
#if NPY_API_VERSION >= 0x00000007
if (writeable) {
PyArray_ENABLEFLAGS(array, NPY_ARRAY_WRITEABLE);
}
else {
PyArray_CLEARFLAGS(array, NPY_ARRAY_WRITEABLE);
}
#else
if (writeable) {
array->flags |= NPY_WRITEABLE;
}
else {
array->flags &= ~NPY_WRITEABLE;
}
#endif
if (miobj) {
/* Set the MemInfoObject as the base object */
#if NPY_API_VERSION >= 0x00000007
if (-1 == PyArray_SetBaseObject(array,
(PyObject *) miobj))
{
Py_DECREF(array);
Py_DECREF(miobj);
return NULL;
}
#else
PyArray_BASE(array) = (PyObject *) miobj;
#endif
}
return (PyObject *) array;
}
static PyObject *
_invoke_marshal_out_args (PyGIInvokeState *state, PyGIFunctionCache *function_cache)
{
PyGICallableCache *cache = (PyGICallableCache *) function_cache;
PyObject *py_out = NULL;
PyObject *py_return = NULL;
gssize n_out_args = cache->n_to_py_args - cache->n_to_py_child_args;
if (cache->return_cache) {
if (!cache->return_cache->is_skipped) {
py_return = cache->return_cache->to_py_marshaller ( state,
cache,
cache->return_cache,
&state->return_arg);
if (py_return == NULL) {
pygi_marshal_cleanup_args_return_fail (state,
cache);
return NULL;
}
} else {
if (cache->return_cache->transfer == GI_TRANSFER_EVERYTHING) {
PyGIMarshalCleanupFunc to_py_cleanup =
cache->return_cache->to_py_cleanup;
if (to_py_cleanup != NULL)
to_py_cleanup ( state,
cache->return_cache,
NULL,
&state->return_arg,
FALSE);
}
}
}
if (n_out_args == 0) {
if (cache->return_cache->is_skipped && state->error == NULL) {
/* we skip the return value and have no (out) arguments to return,
* so py_return should be NULL. But we must not return NULL,
* otherwise Python will expect an exception.
*/
g_assert (py_return == NULL);
Py_INCREF(Py_None);
py_return = Py_None;
}
py_out = py_return;
} else if (!cache->has_return && n_out_args == 1) {
/* if we get here there is one out arg an no return */
PyGIArgCache *arg_cache = (PyGIArgCache *)cache->to_py_args->data;
py_out = arg_cache->to_py_marshaller (state,
cache,
arg_cache,
state->args[arg_cache->c_arg_index].arg_pointer.v_pointer);
if (py_out == NULL) {
pygi_marshal_cleanup_args_to_py_parameter_fail (state,
cache,
0);
return NULL;
}
} else {
/* return a tuple */
gssize py_arg_index = 0;
GSList *cache_item = cache->to_py_args;
gssize tuple_len = cache->has_return + n_out_args;
py_out = pygi_resulttuple_new (cache->resulttuple_type, tuple_len);
if (py_out == NULL) {
pygi_marshal_cleanup_args_to_py_parameter_fail (state,
cache,
py_arg_index);
return NULL;
}
if (cache->has_return) {
PyTuple_SET_ITEM (py_out, py_arg_index, py_return);
py_arg_index++;
}
for (; py_arg_index < tuple_len; py_arg_index++) {
PyGIArgCache *arg_cache = (PyGIArgCache *)cache_item->data;
PyObject *py_obj = arg_cache->to_py_marshaller (state,
cache,
arg_cache,
state->args[arg_cache->c_arg_index].arg_pointer.v_pointer);
if (py_obj == NULL) {
if (cache->has_return)
py_arg_index--;
pygi_marshal_cleanup_args_to_py_parameter_fail (state,
cache,
py_arg_index);
Py_DECREF (py_out);
return NULL;
}
PyTuple_SET_ITEM (py_out, py_arg_index, py_obj);
cache_item = cache_item->next;
}
}
return py_out;
}
static PyObject*
_sources_getprop (PyObject *self, PyObject *args)
{
long bufnum;
ALenum param;
char *type;
int size = 0, cnt;
PropType ptype = INVALID;
if (!CONTEXT_IS_CURRENT (((PySources*)self)->context))
{
PyErr_SetString (PyExc_PyGameError, "source context is not current");
return NULL;
}
if (!PyArg_ParseTuple (args, "lls:get_prop", &bufnum, ¶m, &type))
{
PyErr_Clear ();
if (!PyArg_ParseTuple (args, "lls|i:get_prop", &bufnum, ¶m, &type,
&size))
return NULL;
if (size <= 0)
{
PyErr_SetString (PyExc_ValueError, "size must not smaller than 0");
return NULL;
}
}
ptype = GetPropTypeFromStr (type);
CLEAR_ALERROR_STATE ();
switch (ptype)
{
case INT:
{
ALint val;
alGetSourcei ((ALuint)bufnum, param, &val);
if (SetALErrorException (alGetError (), 0))
return NULL;
return PyLong_FromLong ((long)val);
}
case FLOAT:
{
ALfloat val;
alGetSourcef ((ALuint)bufnum, param, &val);
if (SetALErrorException (alGetError (), 0))
return NULL;
return PyFloat_FromDouble ((double)val);
}
case INT3:
{
ALint val[3];
alGetSource3i ((ALuint)bufnum, param, &val[0], &val[1], &val[2]);
if (SetALErrorException (alGetError (), 0))
return NULL;
return Py_BuildValue ("(lll)", (long)val[0], (long)val[1],
(long)val[2]);
}
case FLOAT3:
{
ALfloat val[3];
alGetSource3f ((ALuint)bufnum, param, &val[0], &val[1], &val[2]);
if (SetALErrorException (alGetError (), 0))
return NULL;
return Py_BuildValue ("(ddd)", (double)val[0], (double)val[1],
(double)val[2]);
}
case INTARRAY:
{
PyObject *tuple, *item;
ALint* val = PyMem_New (ALint, size);
if (!val)
return NULL;
alGetSourceiv ((ALuint)bufnum, param, val);
if (SetALErrorException (alGetError (), 0))
{
PyMem_Free (val);
return NULL;
}
tuple = PyTuple_New ((Py_ssize_t) size);
if (!tuple)
return NULL;
for (cnt = 0; cnt < size; cnt++)
{
item = PyLong_FromLong ((long)val[cnt]);
if (!item)
{
PyMem_Free (val);
Py_DECREF (tuple);
return NULL;
}
PyTuple_SET_ITEM (tuple, (Py_ssize_t) cnt, item);
}
return tuple;
}
case FLOATARRAY:
{
PyObject *tuple, *item;
ALfloat* val = PyMem_New (ALfloat, size);
if (!val)
return NULL;
alGetSourcefv ((ALuint)bufnum, param, val);
if (SetALErrorException (alGetError (), 0))
{
PyMem_Free (val);
return NULL;
}
tuple = PyTuple_New ((Py_ssize_t) size);
if (!tuple)
return NULL;
for (cnt = 0; cnt < size; cnt++)
{
item = PyFloat_FromDouble ((double)val[cnt]);
if (!item || PyTuple_SET_ITEM (tuple, (Py_ssize_t) cnt, item) != 0)
{
PyMem_Free (val);
Py_XDECREF (item);
Py_DECREF (tuple);
return NULL;
}
}
return tuple;
}
default:
PyErr_SetString (PyExc_ValueError, "invalid type specifier");
return NULL;
}
}
PyObject *wsgi_convert_headers_to_bytes(PyObject *headers)
{
PyObject *result = NULL;
int i;
long size;
if (!PyList_Check(headers)) {
PyErr_Format(PyExc_TypeError, "expected list object for headers, "
"value of type %.200s found", headers->ob_type->tp_name);
return 0;
}
size = PyList_Size(headers);
result = PyList_New(size);
for (i = 0; i < size; i++) {
PyObject *header = NULL;
PyObject *header_name = NULL;
PyObject *header_value = NULL;
PyObject *header_name_as_bytes = NULL;
PyObject *header_value_as_bytes = NULL;
PyObject *result_tuple = NULL;
header = PyList_GetItem(headers, i);
if (!PyTuple_Check(header)) {
PyErr_Format(PyExc_TypeError, "list of tuple values "
"expected for headers, value of type %.200s found",
header->ob_type->tp_name);
Py_DECREF(result);
return 0;
}
if (PyTuple_Size(header) != 2) {
PyErr_Format(PyExc_ValueError, "tuple of length 2 "
"expected for header, length is %d",
(int)PyTuple_Size(header));
Py_DECREF(result);
return 0;
}
result_tuple = PyTuple_New(2);
PyList_SET_ITEM(result, i, result_tuple);
header_name = PyTuple_GetItem(header, 0);
header_value = PyTuple_GetItem(header, 1);
header_name_as_bytes = wsgi_convert_string_to_bytes(header_name);
if (!header_name_as_bytes)
goto failure;
PyTuple_SET_ITEM(result_tuple, 0, header_name_as_bytes);
if (!wsgi_validate_header_name(header_name_as_bytes))
goto failure;
header_value_as_bytes = wsgi_convert_string_to_bytes(header_value);
if (!header_value_as_bytes)
goto failure;
PyTuple_SET_ITEM(result_tuple, 1, header_value_as_bytes);
if (!wsgi_validate_header_value(header_value_as_bytes))
goto failure;
}
return result;
failure:
Py_DECREF(result);
return NULL;
}
static EnumPropertyItem *bpy_props_enum_itemf(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, int *free)
{
PyGILState_STATE gilstate;
PyObject *py_func= RNA_property_enum_py_data_get(prop);
PyObject *self= NULL;
PyObject *args;
PyObject *items; /* returned from the function call */
EnumPropertyItem *eitems= NULL;
int err= 0;
bpy_context_set(C, &gilstate);
args= PyTuple_New(2);
self= pyrna_struct_as_instance(ptr);
PyTuple_SET_ITEM(args, 0, self);
/* now get the context */
PyTuple_SET_ITEM(args, 1, (PyObject *)bpy_context_module);
Py_INCREF(bpy_context_module);
items= PyObject_CallObject(py_func, args);
Py_DECREF(args);
if(items==NULL) {
err= -1;
}
else {
PyObject *items_fast;
int defvalue_dummy=0;
if(!(items_fast= PySequence_Fast(items, "EnumProperty(...): return value from the callback was not a sequence"))) {
err= -1;
}
else {
eitems= enum_items_from_py(items_fast, NULL, &defvalue_dummy, (RNA_property_flag(prop) & PROP_ENUM_FLAG)!=0);
Py_DECREF(items_fast);
if(!eitems) {
err= -1;
}
}
Py_DECREF(items);
}
if(err != -1) { /* worked */
*free= 1;
}
else {
printf_func_error(py_func);
eitems= DummyRNA_NULL_items;
}
bpy_context_clear(C, &gilstate);
return eitems;
}
static PyObject* pySpaceTreeNode_getChildren(pySpaceTreeNode* self) {
PyObject* children = PyTuple_New(2);
PyTuple_SET_ITEM(children, 0, PyInt_FromLong(self->fThis->getLChild()));
PyTuple_SET_ITEM(children, 1, PyInt_FromLong(self->fThis->getRChild()));
return children;
}
/* This function is called by the tp_dealloc handler to clear weak references.
*
* This iterates through the weak references for 'object' and calls callbacks
* for those references which have one. It returns when all callbacks have
* been attempted.
*/
void
PyObject_ClearWeakRefs(PyObject *object)
{
PyWeakReference **list;
if (object == NULL
|| !PyType_SUPPORTS_WEAKREFS(Py_TYPE(object))
//|| object->ob_refcnt != 0
) {
PyErr_BadInternalCall();
return;
}
list = GET_WEAKREFS_LISTPTR(object);
/* Remove the callback-less basic and proxy references */
if (*list != NULL && (*list)->wr_callback == NULL) {
clear_weakref(*list);
if (*list != NULL && (*list)->wr_callback == NULL)
clear_weakref(*list);
}
if (*list != NULL) {
PyWeakReference *current = *list;
Py_ssize_t count = _PyWeakref_GetWeakrefCount(current);
int restore_error = PyErr_Occurred() ? 1 : 0;
PyObject *err_type, *err_value, *err_tb;
if (restore_error)
PyErr_Fetch(&err_type, &err_value, &err_tb);
if (count == 1) {
PyObject *callback = current->wr_callback;
current->wr_callback = NULL;
clear_weakref(current);
if (callback != NULL) {
// Pyston change:
// current is a stack reference to a GC allocated object. If it wasn't null when we fetched it from *list, it won't
// be collected, and we can trust that it's still valid here.
if (true /*current->ob_refcnt > 0*/)
handle_callback(current, callback);
Py_DECREF(callback);
}
}
else {
PyObject *tuple;
Py_ssize_t i = 0;
tuple = PyTuple_New(count * 2);
if (tuple == NULL) {
if (restore_error)
PyErr_Fetch(&err_type, &err_value, &err_tb);
return;
}
for (i = 0; i < count; ++i) {
PyWeakReference *next = current->wr_next;
// Pyston change:
// current is a stack reference to a GC allocated object. If it wasn't null when we fetched it from *list, it won't
// be collected, and we can trust that it's still valid here.
if (true /*current->ob_refcnt > 0*/)
{
Py_INCREF(current);
PyTuple_SET_ITEM(tuple, i * 2, (PyObject *) current);
PyTuple_SET_ITEM(tuple, i * 2 + 1, current->wr_callback);
}
else {
Py_DECREF(current->wr_callback);
}
current->wr_callback = NULL;
clear_weakref(current);
current = next;
}
for (i = 0; i < count; ++i) {
PyObject *callback = PyTuple_GET_ITEM(tuple, i * 2 + 1);
/* The tuple may have slots left to NULL */
if (callback != NULL) {
PyObject *item = PyTuple_GET_ITEM(tuple, i * 2);
handle_callback((PyWeakReference *)item, callback);
}
}
Py_DECREF(tuple);
}
if (restore_error)
PyErr_Restore(err_type, err_value, err_tb);
}
}
void SCA_PythonController::Trigger(SCA_LogicManager* logicmgr)
{
m_sCurrentController = this;
m_sCurrentLogicManager = logicmgr;
PyObject *excdict= NULL;
PyObject* resultobj= NULL;
switch(m_mode) {
case SCA_PYEXEC_SCRIPT:
{
if (m_bModified)
if (Compile()==false) // sets m_bModified to false
return;
if (!m_bytecode)
return;
/*
* This part here with excdict is a temporary patch
* to avoid python/gameengine crashes when python
* inadvertently holds references to game objects
* in global variables.
*
* The idea is always make a fresh dictionary, and
* destroy it right after it is used to make sure
* python won't hold any gameobject references.
*
* Note that the PyDict_Clear _is_ necessary before
* the Py_DECREF() because it is possible for the
* variables inside the dictionary to hold references
* to the dictionary (ie. generate a cycle), so we
* break it by hand, then DECREF (which in this case
* should always ensure excdict is cleared).
*/
excdict= PyDict_Copy(m_pythondictionary);
#if PY_VERSION_HEX >= 0x03020000
resultobj = PyEval_EvalCode((PyObject *)m_bytecode, excdict, excdict);
#else
resultobj = PyEval_EvalCode((PyCodeObject *)m_bytecode, excdict, excdict);
#endif
/* PyRun_SimpleString(m_scriptText.Ptr()); */
break;
}
case SCA_PYEXEC_MODULE:
{
if (m_bModified || m_debug)
if (Import()==false) // sets m_bModified to false
return;
if (!m_function)
return;
PyObject *args= NULL;
if(m_function_argc==1) {
args = PyTuple_New(1);
PyTuple_SET_ITEM(args, 0, GetProxy());
}
resultobj = PyObject_CallObject(m_function, args);
Py_XDECREF(args);
break;
}
} /* end switch */
/* Free the return value and print the error */
if (resultobj)
{
Py_DECREF(resultobj);
}
else
{
// something is wrong, tell the user what went wrong
printf("Python script error from controller \"%s\":\n", GetName().Ptr());
PyErr_Print();
/* Added in 2.48a, the last_traceback can reference Objects for example, increasing
* their user count. Not to mention holding references to wrapped data.
* This is especially bad when the PyObject for the wrapped data is free'd, after blender
* has already dealocated the pointer */
PySys_SetObject( (char *)"last_traceback", NULL);
PyErr_Clear(); /* just to be sure */
}
if(excdict) /* Only for SCA_PYEXEC_SCRIPT types */
{
/* clear after PyErrPrint - seems it can be using
* something in this dictionary and crash? */
// This doesn't appear to be needed anymore
//PyDict_Clear(excdict);
Py_DECREF(excdict);
}
m_triggeredSensors.clear();
m_sCurrentController = NULL;
}
//-------------------------------------------------------------------------------------
PyObject* ScriptVector2::seq_slice(PyObject* self, Py_ssize_t startIndex, Py_ssize_t endIndex)
{
if(startIndex < 0)
startIndex = 0;
if(endIndex > VECTOR_SIZE)
endIndex = VECTOR_SIZE;
if(endIndex < startIndex)
endIndex = startIndex;
ScriptVector2* sv = static_cast<ScriptVector2*>(self);
Vector2& my_v = sv->getVector();
PyObject* pyResult = NULL;
int length = endIndex - startIndex;
if (length == VECTOR_SIZE)
{
pyResult = sv;
Py_INCREF(pyResult);
}
else
switch(length)
{
case 0:
pyResult = PyTuple_New(0);
break;
case 1:
pyResult = PyTuple_New(1);
PyTuple_SET_ITEM(pyResult, 0, PyFloat_FromDouble(sv->getVector()[static_cast<int>(startIndex)]));
break;
case 2:
{
Vector2 v;
for(int i = startIndex; i < endIndex; ++i){
v[i - static_cast<int>(startIndex)] = my_v[i];
}
pyResult = new ScriptVector2(v);
break;
}
case 3:
{
Vector3 v;
for (int i = startIndex; i < endIndex; ++i){
v[i - static_cast<int>(startIndex)] = my_v[i];
}
pyResult = new ScriptVector3(v);
break;
}
default:
PyErr_Format(PyExc_IndexError, "Bad slice indexes [%d, %d] for Vector%d", startIndex, endIndex, VECTOR_SIZE);
PyErr_PrintEx(0);
break;
}
return pyResult;
}
