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;
}
