static int Per_set_estimated_size(cPersistentObject *self, PyObject *v) { if (v) { if (INT_CHECK(v)) { long lv = INT_AS_LONG(v); if (lv < 0) { PyErr_SetString(PyExc_ValueError, "_p_estimated_size must not be negative"); return -1; } self->estimated_size = _estimated_size_in_24_bits(lv); } else { PyErr_SetString(PyExc_TypeError, "_p_estimated_size must be an integer"); return -1; } } else self->estimated_size = 0; return 0; }
static int set_void_ptr(void **vpp, PyObject *o, const char *name) { void *vp = 0; if (check_value(o, name)) { return -1; } if (INT_CHECK(o)) { vp = PyLong_AsVoidPtr(o); if (PyErr_Occurred()) { return -1; } } else if (o == Py_None) { vp = 0; } else { PyErr_Format(PyExc_TypeError, "property %400s must be a Python integer, not '%400s'", name, Py_TYPE(o)->tp_name); return -1; } *vpp = vp; return 0; }
static int longlong_check(PyObject *ob) { if (INT_CHECK(ob)) return 1; if (PyLong_Check(ob)) { /* check magnitude */ PY_LONG_LONG val = PyLong_AsLongLong(ob); if (val == -1 && PyErr_Occurred()) return 0; return 1; } return 0; }
static int set_py_ssize_t(Py_ssize_t *ip, PyObject *o, const char *name) { Py_ssize_t i; if (check_value(o, name)) { return -1; } if (!INT_CHECK(o)) { PyErr_Format(PyExc_TypeError, "property %100s must be a Python integer, not '%400s'", name, Py_TYPE(o)->tp_name); return -1; } i = INT_AS_PY_SSIZE_T(o); if (PyErr_Occurred()) { return -1; } *ip = i; return 0; }
static int buffer_init(BufferObject *self, PyObject *args, PyObject *kwds) { PyObject *py_address = 0; int filled = 0; int preserve = 0; Py_buffer *view_p = 0; char *keywords[] = {"buffer_address", "filled", "preserve", 0}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oii:Py_buffer", keywords, &py_address, &filled, &preserve)) { return -1; } if (py_address == Py_None) { py_address = 0; } if (py_address) { if (INT_CHECK(py_address)) { view_p = (Py_buffer *)PyLong_AsVoidPtr(py_address); if (PyErr_Occurred()) { return -1; } } else { PyErr_Format(PyExc_TypeError, "argument %400s must be an integer, not '%400s'", keywords[0], Py_TYPE(py_address)->tp_name); return -1; } } if (!view_p) { if (filled) { PyErr_Format(PyExc_ValueError, "argument %400s cannot be True for a NULL %400s", keywords[1], keywords[0]); return -1; } else if (preserve) { PyErr_Format(PyExc_ValueError, "argument %400s cannot be True for a NULL %400s", keywords[2], keywords[0]); return -1; } } Buffer_Reset(self); self->view_p = view_p; if (preserve) { /* remove mutable flag */ self->flags &= ~BUFOBJ_MUTABLE; } if (filled) { /* add filled flag */ self->flags |= BUFOBJ_FILLED; } else if (view_p) { view_p->obj = 0; view_p->buf = 0; view_p->len = 0; view_p->itemsize = 0; view_p->readonly = 1; view_p->format = 0; view_p->ndim = 0; view_p->shape = 0; view_p->strides = 0; view_p->suboffsets = 0; view_p->internal = 0; } return 0; }
/** * Evaluate the code and return the value * @return */ QVariant PythonScript::evaluateImpl() { ScopedPythonGIL lock; PyObject *compiledCode = this->compileToByteCode(true); if (!compiledCode) { return QVariant(""); } PyObject *pyret; beginStdoutRedirect(); if (PyCallable_Check(compiledCode)) { PyObject *empty_tuple = PyTuple_New(0); pyret = PyObject_Call(compiledCode, empty_tuple, localDict); Py_DECREF(empty_tuple); } else { pyret = PyEval_EvalCode(CODE_OBJECT(compiledCode), localDict, localDict); } endStdoutRedirect(); if (!pyret) { if (PyErr_ExceptionMatches(PyExc_ValueError) || PyErr_ExceptionMatches(PyExc_ZeroDivisionError)) { PyErr_Clear(); // silently ignore errors return QVariant(""); } else { emit_error(); return QVariant(); } } QVariant qret = QVariant(); /* None */ if (pyret == Py_None) { qret = QVariant(""); } /* numeric types */ else if (PyFloat_Check(pyret)) { qret = QVariant(PyFloat_AS_DOUBLE(pyret)); } else if (INT_CHECK(pyret)) { qret = QVariant((qlonglong)TO_LONG(pyret)); } #if !defined(IS_PY3K) else if (PyLong_Check(pyret)) { qret = QVariant((qlonglong)PyLong_AsLongLong(pyret)); } #endif else if (PyNumber_Check(pyret)) { PyObject *number = PyNumber_Float(pyret); if (number) { qret = QVariant(PyFloat_AS_DOUBLE(number)); Py_DECREF(number); } } /* bool */ else if (PyBool_Check(pyret)) { qret = QVariant(pyret == Py_True); } // could handle advanced types (such as PyList->QValueList) here if needed /* fallback: try to convert to (unicode) string */ if (!qret.isValid()) { #if defined(IS_PY3K) // In 3 everything is unicode PyObject *pystring = PyObject_Str(pyret); if (pystring) { qret = QVariant(QString::fromUtf8(_PyUnicode_AsString(pystring))); } #else PyObject *pystring = PyObject_Unicode(pyret); if (pystring) { PyObject *asUTF8 = PyUnicode_EncodeUTF8(PyUnicode_AS_UNICODE(pystring), (int)PyUnicode_GET_DATA_SIZE(pystring), nullptr); Py_DECREF(pystring); if (asUTF8) { qret = QVariant(QString::fromUtf8(PyString_AS_STRING(asUTF8))); Py_DECREF(asUTF8); } else if ((pystring = PyObject_Str(pyret))) { qret = QVariant(QString(PyString_AS_STRING(pystring))); Py_DECREF(pystring); } } #endif } Py_DECREF(pyret); if (PyErr_Occurred()) { if (PyErr_ExceptionMatches(PyExc_ValueError) || PyErr_ExceptionMatches(PyExc_ZeroDivisionError)) { PyErr_Clear(); // silently ignore errors return QVariant(""); } else { emit_error(); } return QVariant(); } return qret; }
/** * This emits the error signal and resets the error state * of the python interpreter. */ void PythonScript::emit_error() { // gil is necessary so other things don't continue ScopedPythonGIL lock; // return early if nothing happened if (!PyErr_Occurred()) { emit finished(MSG_FINISHED); return; } // get the error information out PyObject *exception(nullptr), *value(nullptr), *traceback(nullptr); PyErr_Fetch(&exception, &value, &traceback); // special check for system exceptions if (bool(exception) && PyErr_GivenExceptionMatches(exception, PyExc_SystemExit) && PyObject_HasAttrString(exception, "code")) { // value is the return code handed to sys.exit long code = 0; if (bool(value) && INT_CHECK(value)) { code = TO_LONG(value); } // if we are returning 0 then cleanup and return if (code == 0) { // maybe shouldn't clear the error, but for now this // is the agreed upon behavior PyErr_Clear(); Py_XDECREF(traceback); Py_XDECREF(exception); Py_XDECREF(value); emit finished(MSG_FINISHED); return; } } // prework on the exception handling PyErr_NormalizeException(&exception, &value, &traceback); PyErr_Clear(); // convert the traceback into something useful int lineNumber = 0; QString filename; if (traceback) { PyTracebackObject *tb = (PyTracebackObject *)traceback; lineNumber = tb->tb_lineno; filename = TO_CSTRING(tb->tb_frame->f_code->co_filename); } // the error message is the full (formated) traceback PyObject *str_repr = PyObject_Str(value); QString message; QTextStream msgStream(&message); if (value && str_repr) { if (exception == PyExc_SyntaxError) { msgStream << constructSyntaxErrorStr(value); } else { QString excTypeName( value->ob_type ->tp_name); // This is fully qualified with the module name excTypeName = excTypeName.section(".", -1); msgStream << excTypeName << ": " << TO_CSTRING(str_repr); } } else { msgStream << "Unknown exception has occurred."; } tracebackToMsg(msgStream, (PyTracebackObject *)(traceback)); msgStream << "\n"; Py_XDECREF(traceback); Py_XDECREF(exception); Py_XDECREF(value); emit error(msgStream.readAll(), filename, lineNumber); }
static CajaOperationResult caja_python_object_update_file_info (CajaInfoProvider *provider, CajaFile *file, GClosure *update_complete, CajaOperationHandle **handle) { CajaPythonObject *object = (CajaPythonObject*)provider; CajaOperationResult ret = CAJA_OPERATION_COMPLETE; PyObject *py_ret = NULL; PyGILState_STATE state = pyg_gil_state_ensure(); static volatile gssize handle_generator = 1; debug_enter(); CHECK_OBJECT(object); *handle = NULL; if (PyObject_HasAttrString(object->instance, "update_file_info_full")) { PyObject *py_handle; void *h; /* Generate a new handle with a default value. */ do { h = (CajaOperationHandle *) g_atomic_pointer_add (&handle_generator, 1); } while (!h); py_handle = caja_python_boxed_new (_PyCajaOperationHandle_Type, h, FALSE); py_ret = PyObject_CallMethod(object->instance, METHOD_PREFIX "update_file_info_full", "(NNNN)", pygobject_new((GObject*)provider), py_handle, pyg_boxed_new(G_TYPE_CLOSURE, update_complete, TRUE, TRUE), pygobject_new((GObject*)file)); *handle = (void *) ((PyGBoxed *) py_handle)->boxed; } else if (PyObject_HasAttrString(object->instance, "update_file_info")) { py_ret = PyObject_CallMethod(object->instance, METHOD_PREFIX METHOD_NAME, "(N)", pygobject_new((GObject*)file)); } else { goto beach; } HANDLE_RETVAL(py_ret); if (!INT_CHECK(py_ret)) { PyErr_SetString(PyExc_TypeError, METHOD_NAME " must return None or a int"); goto beach; } ret = INT_ASLONG(py_ret); if (!*handle && ret == CAJA_OPERATION_IN_PROGRESS) ret = CAJA_OPERATION_FAILED; beach: free_pygobject_data(file, NULL); Py_XDECREF(py_ret); pyg_gil_state_release(state); return ret; }