inline bool matches( PyObject *exception ) const
{
#if PYTHON_VERSION >= 300
if ( PyTuple_Check( exception ))
{
Py_ssize_t length = PyTuple_Size( exception );
for ( Py_ssize_t i = 0; i < length; i += 1 )
{
PyObject *element = PyTuple_GET_ITEM( exception, i );
if (unlikely( !PyExceptionClass_Check( element ) ))
{
PyErr_Format( PyExc_TypeError, "catching classes that do not inherit from BaseException is not allowed" );
throw PythonException();
}
}
}
else if (unlikely( !PyExceptionClass_Check( exception ) ))
{
PyErr_Format( PyExc_TypeError, "catching classes that do not inherit from BaseException is not allowed" );
throw PythonException();
}
#endif
return
PyErr_GivenExceptionMatches( this->exception_type, exception ) ||
PyErr_GivenExceptionMatches( this->exception_value, exception );
}
/**
* @param code A lump of python code
* @return True if the code forms a complete statment
*/
bool PythonScript::compilesToCompleteStatement(const QString & code) const
{
bool result(false);
GlobalInterpreterLock gil;
PyObject *compiledCode = Py_CompileString(code.toAscii(), "", Py_file_input);
if( PyObject *exception = PyErr_Occurred() )
{
// Certain exceptions still mean the code is complete
if(PyErr_GivenExceptionMatches(exception, PyExc_SyntaxError) ||
PyErr_GivenExceptionMatches(exception, PyExc_OverflowError) ||
PyErr_GivenExceptionMatches(exception, PyExc_ValueError) ||
PyErr_GivenExceptionMatches(exception, PyExc_TypeError) ||
PyErr_GivenExceptionMatches(exception, PyExc_MemoryError))
{
result = true;
}
else
{
result = false;
}
PyErr_Clear();
}
else
{
result = true;
}
Py_XDECREF(compiledCode);
return result;
}
/*
* PyArray_IntpFromIndexSequence
* Returns the number of dimensions or -1 if an error occurred.
* vals must be large enough to hold maxvals.
* Opposed to PyArray_IntpFromSequence it uses and returns npy_intp
* for the number of values.
*/
NPY_NO_EXPORT npy_intp
PyArray_IntpFromIndexSequence(PyObject *seq, npy_intp *vals, npy_intp maxvals)
{
Py_ssize_t nd;
npy_intp i;
PyObject *op, *err;
/*
* Check to see if sequence is a single integer first.
* or, can be made into one
*/
nd = PySequence_Length(seq);
if (nd == -1) {
if (PyErr_Occurred()) {
PyErr_Clear();
}
vals[0] = PyArray_PyIntAsIntp(seq);
if(vals[0] == -1) {
err = PyErr_Occurred();
if (err &&
PyErr_GivenExceptionMatches(err, PyExc_OverflowError)) {
PyErr_SetString(PyExc_ValueError,
"Maximum allowed dimension exceeded");
}
if(err != NULL) {
return -1;
}
}
nd = 1;
}
else {
for (i = 0; i < PyArray_MIN(nd,maxvals); i++) {
op = PySequence_GetItem(seq, i);
if (op == NULL) {
return -1;
}
vals[i] = PyArray_PyIntAsIntp(op);
Py_DECREF(op);
if(vals[i] == -1) {
err = PyErr_Occurred();
if (err &&
PyErr_GivenExceptionMatches(err, PyExc_OverflowError)) {
PyErr_SetString(PyExc_ValueError,
"Maximum allowed dimension exceeded");
}
if(err != NULL) {
return -1;
}
}
}
}
return nd;
}
bool
rpcError_Extract(PyObject *error, int *errorCode, char **errorString)
{
PyObject *pyErrorCode,
*pyErrorString;
assert(PyErr_GivenExceptionMatches(error, rpcError));
pyErrorCode = PyObject_GetAttrString(error, "errorCode");
if (errorCode && PyInt_Check(pyErrorCode))
*errorCode = (int)PyInt_AS_LONG(pyErrorCode);
else {
fprintf(rpcLogger, "invalid error code... deerror to -1\n");
*errorCode = -1;
}
pyErrorString = PyObject_GetAttrString(error, "errorString");
if (errorString && PyString_Check(pyErrorString)) {
*errorString = alloc(PyString_GET_SIZE(pyErrorString) + 1);
if (*errorString == NULL)
return false;
strcpy(*errorString, PyString_AS_STRING(pyErrorString));
} else {
fprintf(rpcLogger, "invalid error string... deerror to 'unknown error'\n");
*errorString = alloc(strlen("unknown error") + 1);
if (*errorString == NULL)
return false;
strcpy(*errorString, "unknown error");
}
return true;
}
boost::python::object
EventIterator::next_nostop()
{
boost::python::object stopIteration = py_import("exceptions").attr("StopIteration");
boost::python::object result = boost::python::object();
try
{
result = boost::python::object(next());
}
catch (const boost::python::error_already_set &)
{
PyObject *e, *v, *t;
PyErr_Fetch(&e, &v, &t);
if (!e) {throw;}
if (PyErr_GivenExceptionMatches(stopIteration.ptr(), e))
{
boost::python::object pyE(boost::python::handle<>(boost::python::allow_null(e)));
if (v) {boost::python::object pyV(boost::python::handle<>(boost::python::allow_null(v)));}
if (t) {boost::python::object pyT(boost::python::handle<>(boost::python::allow_null(t)));}
}
else
{
PyErr_Restore(e, v, t);
throw;
}
}
return result;
}
PyObject *ERROR_GET_STOP_ITERATION_VALUE()
{
assert ( PyErr_ExceptionMatches( PyExc_StopIteration ));
PyObject *et, *ev, *tb;
PyErr_Fetch( &et, &ev, &tb );
Py_XDECREF(et);
Py_XDECREF(tb);
PyObject *value = NULL;
if ( ev )
{
if ( PyErr_GivenExceptionMatches( ev, PyExc_StopIteration ) )
{
value = ((PyStopIterationObject *)ev)->value;
Py_DECREF( ev );
}
else
{
value = ev;
}
}
if ( value == NULL )
{
value = INCREASE_REFCOUNT( Py_None );
}
return value;
}
PyObject *ERROR_GET_STOP_ITERATION_VALUE()
{
assert( PyErr_ExceptionMatches( PyExc_StopIteration ) );
PyObject *exception_type, *exception_value, *exception_tb;
PyErr_Fetch( &exception_type, &exception_value, &exception_tb );
Py_DECREF( exception_type );
Py_XDECREF( exception_tb );
PyObject *value = NULL;
if ( exception_value )
{
if ( PyErr_GivenExceptionMatches( exception_value, PyExc_StopIteration ) )
{
value = ((PyStopIterationObject *)exception_value)->value;
Py_XINCREF( value );
Py_DECREF( exception_value );
}
else
{
value = exception_value;
}
}
if ( value == NULL )
{
value = INCREASE_REFCOUNT( Py_None );
}
return value;
}
/**
* pygi_gerror_exception_check:
* @error: a standard GLib GError ** output parameter
*
* Checks to see if a GError exception has been raised, and if so
* translates the python exception to a standard GLib GError. If the
* raised exception is not a GError then PyErr_Print() is called.
*
* Returns: 0 if no exception has been raised, -1 if it is a
* valid glib.GError, -2 otherwise.
*/
gboolean
pygi_gerror_exception_check (GError **error)
{
int res = -1;
PyObject *type, *value, *traceback;
PyErr_Fetch(&type, &value, &traceback);
if (type == NULL)
return 0;
PyErr_NormalizeException(&type, &value, &traceback);
if (value == NULL) {
PyErr_Restore(type, value, traceback);
PyErr_Print();
return -2;
}
if (!value ||
!PyErr_GivenExceptionMatches(type,
(PyObject *) PyGError)) {
PyErr_Restore(type, value, traceback);
PyErr_Print();
return -2;
}
Py_DECREF(type);
Py_XDECREF(traceback);
if (!pygi_error_marshal_from_py (value, error)) {
PyErr_Print();
res = -2;
}
Py_DECREF(value);
return res;
}
int
PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
{
if (err == NULL || exc == NULL) {
/* maybe caused by "import exceptions" that failed early on */
return 0;
}
if (PyTuple_Check(exc)) {
Py_ssize_t i, n;
n = PyTuple_Size(exc);
for (i = 0; i < n; i++) {
/* Test recursively */
if (PyErr_GivenExceptionMatches(
err, PyTuple_GET_ITEM(exc, i)))
{
return 1;
}
}
return 0;
}
/* err might be an instance, so check its class. */
if (PyExceptionInstance_Check(err))
err = PyExceptionInstance_Class(err);
if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
return PyType_IsSubtype((PyTypeObject *)err, (PyTypeObject *)exc);
}
return err == exc;
}
// This is for the actual comparison operation that is being done in the
// node tree, no other code should use it. TODO: Then it's probably not
// properly located here, and it could still in-line the code of
// "PyErr_GivenExceptionMatches" to save on Python3 doing two tuple checks
// and iterations.
NUITKA_MAY_BE_UNUSED static inline int EXCEPTION_MATCH_BOOL( PyObject *exception_value, PyObject *exception_checked )
{
CHECK_OBJECT( exception_value );
CHECK_OBJECT( exception_checked );
#if PYTHON_VERSION >= 300
if ( PyTuple_Check( exception_checked ))
{
Py_ssize_t length = PyTuple_Size( exception_checked );
for ( Py_ssize_t i = 0; i < length; i += 1 )
{
PyObject *element = PyTuple_GET_ITEM( exception_checked, i );
if (unlikely( !PyExceptionClass_Check( element ) ))
{
PyErr_Format( PyExc_TypeError, "catching classes that do not inherit from BaseException is not allowed" );
return -1;
}
}
}
else if (unlikely( !PyExceptionClass_Check( exception_checked ) ))
{
PyErr_Format( PyExc_TypeError, "catching classes that do not inherit from BaseException is not allowed" );
return -1;
}
#endif
return PyErr_GivenExceptionMatches( exception_value, exception_checked );
}
int
PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
{
if (err == NULL || exc == NULL) {
/* maybe caused by "import exceptions" that failed early on */
return 0;
}
if (PyTuple_Check(exc)) {
Py_ssize_t i, n;
n = PyTuple_Size(exc);
for (i = 0; i < n; i++) {
/* Test recursively */
if (PyErr_GivenExceptionMatches(
err, PyTuple_GET_ITEM(exc, i)))
{
return 1;
}
}
return 0;
}
/* err might be an instance, so check its class. */
if (PyExceptionInstance_Check(err))
err = PyExceptionInstance_Class(err);
if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
/* problems here!? not sure PyObject_IsSubclass expects to
be called with an exception pending... */
return PyObject_IsSubclass(err, exc);
}
return err == exc;
}
void python_script_error_jump(const char *filepath, int *lineno, int *offset)
{
PyObject *exception, *value;
PyTracebackObject *tb;
*lineno = -1;
*offset = 0;
PyErr_Fetch(&exception, &value, (PyObject **)&tb);
if (exception && PyErr_GivenExceptionMatches(exception, PyExc_SyntaxError)) {
/* no traceback available when SyntaxError.
* python has no api's to this. reference parse_syntax_error() from pythonrun.c */
PyErr_NormalizeException(&exception, &value, (PyObject **)&tb);
PyErr_Restore(exception, value, (PyObject *)tb); /* takes away reference! */
if (value) { /* should always be true */
PyObject *message;
PyObject *filename_py, *text_py;
if (parse_syntax_error(value, &message, &filename_py, lineno, offset, &text_py)) {
const char *filename = _PyUnicode_AsString(filename_py);
/* python adds a '/', prefix, so check for both */
if ((BLI_path_cmp(filename, filepath) == 0) ||
((filename[0] == '\\' || filename[0] == '/') &&
BLI_path_cmp(filename + 1, filepath) == 0)) {
/* good */
}
else {
*lineno = -1;
}
}
else {
*lineno = -1;
}
}
}
else {
PyErr_NormalizeException(&exception, &value, (PyObject **)&tb);
PyErr_Restore(exception, value, (PyObject *)tb); /* takes away reference! */
PyErr_Print();
for (tb = (PyTracebackObject *)PySys_GetObject("last_traceback");
tb && (PyObject *)tb != Py_None;
tb = tb->tb_next) {
PyObject *coerce;
const char *tb_filepath = traceback_filepath(tb, &coerce);
const int match = ((BLI_path_cmp(tb_filepath, filepath) == 0) ||
((tb_filepath[0] == '\\' || tb_filepath[0] == '/') &&
BLI_path_cmp(tb_filepath + 1, filepath) == 0));
Py_DECREF(coerce);
if (match) {
*lineno = tb->tb_lineno;
/* used to break here, but better find the inner most line */
}
}
}
}
std::string formatPythonException( bool withStacktrace, int *lineNumber )
{
PyObject *exceptionPyObject, *valuePyObject, *tracebackPyObject;
PyErr_Fetch( &exceptionPyObject, &valuePyObject, &tracebackPyObject );
if( !exceptionPyObject )
{
throw IECore::Exception( "No Python exception set" );
}
PyErr_NormalizeException( &exceptionPyObject, &valuePyObject, &tracebackPyObject );
object exception( ( handle<>( exceptionPyObject ) ) );
// valuePyObject and tracebackPyObject may be NULL.
object value;
if( valuePyObject )
{
value = object( handle<>( valuePyObject ) );
}
object traceback;
if( tracebackPyObject )
{
traceback = object( handle<>( tracebackPyObject ) );
}
if( lineNumber )
{
if( PyErr_GivenExceptionMatches( value.ptr(), PyExc_SyntaxError ) )
{
*lineNumber = extract<int>( value.attr( "lineno" ) );
}
else if( traceback )
{
*lineNumber = extract<int>( traceback.attr( "tb_lineno" ) );
}
}
object tracebackModule( import( "traceback" ) );
object formattedList;
if( withStacktrace )
{
formattedList = tracebackModule.attr( "format_exception" )( exception, value, traceback );
}
else
{
formattedList = tracebackModule.attr( "format_exception_only" )( exception, value );
}
object formatted = str( "" ).join( formattedList );
std::string s = extract<std::string>( formatted );
return s;
}
static PyObject *__Pyx_Generator_Throw(PyObject *self, PyObject *args) {
__pyx_GeneratorObject *gen = (__pyx_GeneratorObject *) self;
PyObject *typ;
PyObject *tb = NULL;
PyObject *val = NULL;
PyObject *yf = gen->yieldfrom;
if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb))
return NULL;
if (unlikely(__Pyx_Generator_CheckRunning(gen)))
return NULL;
if (yf) {
PyObject *ret;
Py_INCREF(yf);
#if PY_VERSION_HEX >= 0x02050000
if (PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit)) {
int err = __Pyx_Generator_CloseIter(gen, yf);
Py_DECREF(yf);
__Pyx_Generator_Undelegate(gen);
if (err < 0)
return __Pyx_Generator_SendEx(gen, NULL);
goto throw_here;
}
#endif
gen->is_running = 1;
if (__Pyx_Generator_CheckExact(yf)) {
ret = __Pyx_Generator_Throw(yf, args);
} else {
PyObject *meth = PyObject_GetAttrString(yf, "throw");
if (unlikely(!meth)) {
Py_DECREF(yf);
if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
gen->is_running = 0;
return NULL;
}
PyErr_Clear();
__Pyx_Generator_Undelegate(gen);
gen->is_running = 0;
goto throw_here;
}
ret = PyObject_CallObject(meth, args);
Py_DECREF(meth);
}
gen->is_running = 0;
Py_DECREF(yf);
if (!ret) {
ret = __Pyx_Generator_FinishDelegation(gen);
}
return ret;
}
throw_here:
__Pyx_Raise(typ, val, tb, NULL);
return __Pyx_Generator_SendEx(gen, NULL);
}
static PyObject *__Pyx_Generator_Close(PyObject *self) {
__pyx_GeneratorObject *gen = (__pyx_GeneratorObject *) self;
PyObject *retval, *raised_exception;
PyObject *yf = gen->yieldfrom;
int err = 0;
if (unlikely(__Pyx_Generator_CheckRunning(gen)))
return NULL;
if (yf) {
Py_INCREF(yf);
err = __Pyx_Generator_CloseIter(gen, yf);
__Pyx_Generator_Undelegate(gen);
Py_DECREF(yf);
}
if (err == 0)
#if PY_VERSION_HEX < 0x02050000
PyErr_SetNone(PyExc_StopIteration);
#else
PyErr_SetNone(PyExc_GeneratorExit);
#endif
retval = __Pyx_Generator_SendEx(gen, NULL);
if (retval) {
Py_DECREF(retval);
PyErr_SetString(PyExc_RuntimeError,
"generator ignored GeneratorExit");
return NULL;
}
raised_exception = PyErr_Occurred();
if (!raised_exception
|| raised_exception == PyExc_StopIteration
#if PY_VERSION_HEX >= 0x02050000
|| raised_exception == PyExc_GeneratorExit
|| PyErr_GivenExceptionMatches(raised_exception, PyExc_GeneratorExit)
#endif
|| PyErr_GivenExceptionMatches(raised_exception, PyExc_StopIteration))
{
if (raised_exception) PyErr_Clear(); /* ignore these errors */
Py_INCREF(Py_None);
return Py_None;
}
return NULL;
}
// Is the current exception a "server" exception? - ie, one explicitly
// thrown by Python code to indicate an error. This is defined as
// any exception whose type is a subclass of com_error (a plain
// com_error probably means an unhandled exception from someone
// calling an interface)
BOOL IsServerErrorCurrent() {
BOOL rc = FALSE;
PyObject *exc_typ = NULL, *exc_val = NULL, *exc_tb = NULL;
PyErr_Fetch( &exc_typ, &exc_val, &exc_tb);
assert(exc_typ); // we should only be called with an exception current.
if (exc_typ) {
PyErr_NormalizeException( &exc_typ, &exc_val, &exc_tb);
// so it must "match" a com_error, but not be *exactly* a COM error.
rc = PyErr_GivenExceptionMatches(exc_val, PyWinExc_COMError) && exc_typ != PyWinExc_COMError;
}
PyErr_Restore(exc_typ, exc_val, exc_tb);
return rc;
}
QString PythonScripting::errorMsg()
{
PyObject *exception=0, *value=0, *traceback=0;
PyTracebackObject *excit=0;
PyFrameObject *frame;
char *fname;
QString msg;
if (!PyErr_Occurred()) return "";
PyErr_Fetch(&exception, &value, &traceback);
PyErr_NormalizeException(&exception, &value, &traceback);
if(PyErr_GivenExceptionMatches(exception, PyExc_SyntaxError))
{
msg.append(toString(PyObject_GetAttrString(value, "text"), true) + "\n");
PyObject *offset = PyObject_GetAttrString(value, "offset");
for (int i=1; i<PyInt_AsLong(offset); i++)
msg.append(" ");
msg.append("^\n");
Py_DECREF(offset);
msg.append("SyntaxError: ");
msg.append(toString(PyObject_GetAttrString(value, "msg"), true) + "\n");
msg.append("at ").append(toString(PyObject_GetAttrString(value, "filename"), true));
msg.append(":").append(toString(PyObject_GetAttrString(value, "lineno"), true));
msg.append("\n");
Py_DECREF(exception);
Py_DECREF(value);
} else {
msg.append(toString(exception,true)).remove("exceptions.").append(": ");
msg.append(toString(value,true));
msg.append("\n");
}
if (traceback) {
excit = (PyTracebackObject*)traceback;
while (excit && (PyObject*)excit != Py_None)
{
frame = excit->tb_frame;
msg.append("at ").append(PyString_AsString(frame->f_code->co_filename));
msg.append(":").append(QString::number(excit->tb_lineno));
if (frame->f_code->co_name && *(fname = PyString_AsString(frame->f_code->co_name)) != '?')
msg.append(" in ").append(fname);
msg.append("\n");
excit = excit->tb_next;
}
Py_DECREF(traceback);
}
return msg;
}
void python_script_error_jump(const char *filepath, int *lineno, int *offset)
{
PyObject *exception, *value;
PyTracebackObject *tb;
*lineno= -1;
*offset= 0;
PyErr_Fetch(&exception, &value, (PyObject **)&tb);
if(exception && PyErr_GivenExceptionMatches(exception, PyExc_SyntaxError)) {
/* no traceback available when SyntaxError.
* python has no api's to this. reference parse_syntax_error() from pythonrun.c */
PyErr_NormalizeException(&exception, &value, (PyObject **)&tb);
PyErr_Restore(exception, value, (PyObject *)tb); /* takes away reference! */
if(value) { /* should always be true */
PyObject *message;
const char *filename, *text;
if(parse_syntax_error(value, &message, &filename, lineno, offset, &text)) {
/* python adds a '/', prefix, so check for both */
if( (strcmp(filename, filepath) == 0) ||
((filename[0] == '\\' || filename[0] == '/') && strcmp(filename + 1, filepath) == 0)
) {
/* good */
}
else {
*lineno= -1;
}
}
else {
*lineno= -1;
}
}
}
else {
PyErr_NormalizeException(&exception, &value, (PyObject **)&tb);
PyErr_Restore(exception, value, (PyObject *)tb); /* takes away reference! */
PyErr_Print();
for(tb= (PyTracebackObject *)PySys_GetObject("last_traceback"); tb && (PyObject *)tb != Py_None; tb= tb->tb_next) {
if(strcmp(traceback_filepath(tb), filepath) != 0) {
*lineno= tb->tb_lineno;
break;
}
}
}
}
Py_off_t
PyNumber_AsOff_t(PyObject *item, PyObject *err)
{
Py_off_t result;
PyObject *runerr;
PyObject *value = PyNumber_Index(item);
if (value == NULL)
return -1;
if (PyInt_Check(value)) {
/* We assume a long always fits in a Py_off_t... */
result = (Py_off_t) PyInt_AS_LONG(value);
goto finish;
}
/* We're done if PyLong_AsSsize_t() returns without error. */
result = PyLong_AsOff_t(value);
if (result != -1 || !(runerr = PyErr_Occurred()))
goto finish;
/* Error handling code -- only manage OverflowError differently */
if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError))
goto finish;
PyErr_Clear();
/* If no error-handling desired then the default clipping
is sufficient.
*/
if (!err) {
assert(PyLong_Check(value));
/* Whether or not it is less than or equal to
zero is determined by the sign of ob_size
*/
if (_PyLong_Sign(value) < 0)
result = PY_OFF_T_MIN;
else
result = PY_OFF_T_MAX;
}
else {
/* Otherwise replace the error with caller's error object. */
PyErr_Format(err,
"cannot fit '%.200s' into an offset-sized integer",
item->ob_type->tp_name);
}
finish:
Py_DECREF(value);
return result;
}
int
PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
{
if (err == NULL || exc == NULL) {
/* maybe caused by "import exceptions" that failed early on */
return 0;
}
if (PyTuple_Check(exc)) {
Py_ssize_t i, n;
n = PyTuple_Size(exc);
for (i = 0; i < n; i++) {
/* Test recursively */
if (PyErr_GivenExceptionMatches(
err, PyTuple_GET_ITEM(exc, i)))
{
return 1;
}
}
return 0;
}
/* err might be an instance, so check its class. */
if (PyExceptionInstance_Check(err))
err = PyExceptionInstance_Class(err);
if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
int res = 0, reclimit;
PyObject *exception, *value, *tb;
PyErr_Fetch(&exception, &value, &tb);
/* Temporarily bump the recursion limit, so that in the most
common case PyObject_IsSubclass will not raise a recursion
error we have to ignore anyway. Don't do it when the limit
is already insanely high, to avoid overflow */
reclimit = Py_GetRecursionLimit();
if (reclimit < (1 << 30))
Py_SetRecursionLimit(reclimit + 5);
res = PyObject_IsSubclass(err, exc);
Py_SetRecursionLimit(reclimit);
/* This function must not fail, so print the error here */
if (res == -1) {
PyErr_WriteUnraisable(err);
res = 0;
}
PyErr_Restore(exception, value, tb);
return res;
}
return err == exc;
}
static PyObject *
pygpgme_context_genkey(PyGpgmeContext *self, PyObject *args)
{
PyObject *py_pubkey = Py_None, *py_seckey = Py_None;
const char *parms;
gpgme_data_t pubkey = NULL, seckey = NULL;
PyObject *result;
gpgme_error_t err;
if (!PyArg_ParseTuple(args, "z|OO", &parms, &py_pubkey, &py_seckey))
return NULL;
if (pygpgme_data_new(&pubkey, py_pubkey))
return NULL;
if (pygpgme_data_new(&seckey, py_seckey)) {
gpgme_data_release(pubkey);
return NULL;
}
Py_BEGIN_ALLOW_THREADS;
err = gpgme_op_genkey(self->ctx, parms, pubkey, seckey);
Py_END_ALLOW_THREADS;
gpgme_data_release(seckey);
gpgme_data_release(pubkey);
result = pygpgme_genkey_result(self->ctx);
if (pygpgme_check_error(err)) {
PyObject *err_type, *err_value, *err_traceback;
PyErr_Fetch(&err_type, &err_value, &err_traceback);
PyErr_NormalizeException(&err_type, &err_value, &err_traceback);
if (!PyErr_GivenExceptionMatches(err_type, pygpgme_error))
goto end;
if (result != NULL) {
PyObject_SetAttrString(err_value, "result", result);
Py_DECREF(result);
}
end:
PyErr_Restore(err_type, err_value, err_traceback);
return NULL;
}
return (PyObject *) result;
}
JSBool
get_prop(JSContext* jscx, JSObject* jsobj, jsval key, jsval* rval)
{
Context* pycx = NULL;
PyObject* pykey = NULL;
PyObject* pyval = NULL;
JSBool ret = JS_FALSE;
pycx = (Context*) JS_GetContextPrivate(jscx);
if(pycx == NULL)
{
JS_ReportError(jscx, "Failed to get Python context.");
goto done;
}
// Bail if there's no registered global handler.
if(pycx->global == NULL)
{
ret = JS_TRUE;
goto done;
}
pykey = js2py(pycx, key);
if(pykey == NULL) goto done;
if(Context_has_access(pycx, jscx, pycx->global, pykey) <= 0) goto done;
pyval = PyObject_GetItem(pycx->global, pykey);
if(pyval == NULL)
{
if(PyErr_GivenExceptionMatches(PyErr_Occurred(), PyExc_KeyError))
{
PyErr_Clear();
ret = JS_TRUE;
}
goto done;
}
*rval = py2js(pycx, pyval);
if(*rval == JSVAL_VOID) goto done;
ret = JS_TRUE;
done:
Py_XDECREF(pykey);
Py_XDECREF(pyval);
return ret;
}
// Generically fills an EXCEP_INFO. The scode in the EXCEPINFO
// is the HRESULT as nominated by the user.
void PyCom_ExcepInfoFromPyException(EXCEPINFO *pExcepInfo)
{
// If the caller did not provide a valid exception info, get out now!
if (pExcepInfo==NULL) {
PyErr_Clear(); // must leave Python in a clean state.
return;
}
PyObject *exception, *v, *tb;
PyErr_Fetch(&exception, &v, &tb);
if (PyCom_ExcepInfoFromPyObject(v, pExcepInfo, NULL))
{
// done.
}
else
{
memset(pExcepInfo, 0, sizeof(EXCEPINFO));
// Clear the exception raised by PyCom_ExcepInfoFromPyObject,
// not the one we are interested in!
PyErr_Clear();
// Not a special exception object - do the best we can.
char *szBaseMessage = "Unexpected Python Error: ";
char *szException = GetPythonTraceback(exception, v, tb);
size_t len = strlen(szBaseMessage) + strlen(szException) + 1;
char *tempBuf = new char[len];
if (tempBuf) {
snprintf(tempBuf, len, "%s%s", szBaseMessage, szException);
pExcepInfo->bstrDescription = PyWin_String_AsBstr(tempBuf);
delete [] tempBuf;
} else
pExcepInfo->bstrDescription = SysAllocString(L"memory error allocating exception buffer!");
pExcepInfo->bstrSource = SysAllocString(L"Python COM Server Internal Error");
// Map some well known exceptions to specific HRESULTs
// Note: v can be NULL. This can happen via PyErr_SetNone().
// e.g.: KeyboardInterrupt
if (PyErr_GivenExceptionMatches(exception, PyExc_MemoryError))
pExcepInfo->scode = E_OUTOFMEMORY;
else
// Any other common Python exceptions we should map?
pExcepInfo->scode = E_FAIL;
}
Py_XDECREF(exception);
Py_XDECREF(v);
Py_XDECREF(tb);
PyErr_Clear();
}
static void
atexit_callfuncs(PyObject *module)
{
PyObject *exc_type = NULL, *exc_value, *exc_tb, *r;
atexit_callback *cb;
atexitmodule_state *modstate;
int i;
if (module == NULL)
return;
modstate = GET_ATEXIT_STATE(module);
if (modstate->ncallbacks == 0)
return;
for (i = modstate->ncallbacks - 1; i >= 0; i--)
{
cb = modstate->atexit_callbacks[i];
if (cb == NULL)
continue;
r = PyObject_Call(cb->func, cb->args, cb->kwargs);
Py_XDECREF(r);
if (r == NULL) {
/* Maintain the last exception, but don't leak if there are
multiple exceptions. */
if (exc_type) {
Py_DECREF(exc_type);
Py_XDECREF(exc_value);
Py_XDECREF(exc_tb);
}
PyErr_Fetch(&exc_type, &exc_value, &exc_tb);
if (!PyErr_GivenExceptionMatches(exc_type, PyExc_SystemExit)) {
PySys_WriteStderr("Error in atexit._run_exitfuncs:\n");
PyErr_NormalizeException(&exc_type, &exc_value, &exc_tb);
PyErr_Display(exc_type, exc_value, exc_tb);
}
}
}
atexit_cleanup(modstate);
if (exc_type)
PyErr_Restore(exc_type, exc_value, exc_tb);
}
int
PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
{
if (err == NULL || exc == NULL) {
/* maybe caused by "import exceptions" that failed early on */
return 0;
}
if (PyTuple_Check(exc)) {
Py_ssize_t i, n;
n = PyTuple_Size(exc);
for (i = 0; i < n; i++) {
/* Test recursively */
if (PyErr_GivenExceptionMatches(
err, PyTuple_GET_ITEM(exc, i)))
{
return 1;
}
}
return 0;
}
/* err might be an instance, so check its class. */
if (PyExceptionInstance_Check(err))
err = PyExceptionInstance_Class(err);
if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
int res = 0;
PyObject *exception, *value, *tb;
PyErr_Fetch(&exception, &value, &tb);
/* PyObject_IsSubclass() can recurse and therefore is
not safe (see test_bad_getattr in test.pickletester). */
res = PyType_IsSubtype((PyTypeObject *)err, (PyTypeObject *)exc);
/* This function must not fail, so print the error here */
if (res == -1) {
PyErr_WriteUnraisable(err);
res = 0;
}
PyErr_Restore(exception, value, tb);
return res;
}
return err == exc;
}
/* annotate exception with encrypt_result data */
static void
decode_encrypt_result(PyGpgmeContext *self)
{
PyObject *err_type, *err_value, *err_traceback;
gpgme_encrypt_result_t res;
gpgme_invalid_key_t key;
PyObject *list;
PyErr_Fetch(&err_type, &err_value, &err_traceback);
PyErr_NormalizeException(&err_type, &err_value, &err_traceback);
if (!PyErr_GivenExceptionMatches(err_type, pygpgme_error))
goto end;
res = gpgme_op_encrypt_result(self->ctx);
if (res == NULL)
goto end;
list = PyList_New(0);
for (key = res->invalid_recipients; key != NULL; key = key->next) {
PyObject *item, *py_fpr, *err;
if (key->fpr)
py_fpr = PyUnicode_DecodeASCII(key->fpr, strlen(key->fpr),
"replace");
else {
py_fpr = Py_None;
Py_INCREF(py_fpr);
}
err = pygpgme_error_object(key->reason);
item = Py_BuildValue("(NN)", py_fpr, err);
PyList_Append(list, item);
Py_DECREF(item);
}
PyObject_SetAttrString(err_value, "invalid_recipients", list);
Py_DECREF(list);
end:
PyErr_Restore(err_type, err_value, err_traceback);
}
static void
decode_decrypt_result(PyGpgmeContext *self)
{
PyObject *err_type, *err_value, *err_traceback;
PyObject *value;
gpgme_decrypt_result_t res;
PyErr_Fetch(&err_type, &err_value, &err_traceback);
PyErr_NormalizeException(&err_type, &err_value, &err_traceback);
if (!PyErr_GivenExceptionMatches(err_type, pygpgme_error))
goto end;
res = gpgme_op_decrypt_result(self->ctx);
if (res == NULL)
goto end;
if (res->unsupported_algorithm) {
value = PyUnicode_DecodeUTF8(res->unsupported_algorithm,
strlen(res->unsupported_algorithm),
"replace");
} else {
Py_INCREF(Py_None);
value = Py_None;
}
if (value) {
PyObject_SetAttrString(err_value, "unsupported_algorithm", value);
Py_DECREF(value);
}
value = PyBool_FromLong(res->wrong_key_usage);
if (value) {
PyObject_SetAttrString(err_value, "wrong_key_usage", value);
Py_DECREF(value);
}
end:
PyErr_Restore(err_type, err_value, err_traceback);
}
static PyObject *
pygpgme_context_import(PyGpgmeContext *self, PyObject *args)
{
PyObject *py_keydata, *result;
gpgme_data_t keydata;
gpgme_error_t err;
if (!PyArg_ParseTuple(args, "O", &py_keydata))
return NULL;
if (pygpgme_data_new(&keydata, py_keydata))
return NULL;
Py_BEGIN_ALLOW_THREADS;
err = gpgme_op_import(self->ctx, keydata);
Py_END_ALLOW_THREADS;
gpgme_data_release(keydata);
result = pygpgme_import_result(self->ctx);
if (pygpgme_check_error(err)) {
PyObject *err_type, *err_value, *err_traceback;
PyErr_Fetch(&err_type, &err_value, &err_traceback);
PyErr_NormalizeException(&err_type, &err_value, &err_traceback);
if (!PyErr_GivenExceptionMatches(err_type, pygpgme_error))
goto end;
if (result != NULL) {
PyObject_SetAttrString(err_value, "result", result);
Py_DECREF(result);
}
end:
PyErr_Restore(err_type, err_value, err_traceback);
return NULL;
}
return result;
}
// originally copied from Py3's builtin_next()
static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) {
PyObject* next;
iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
#if CYTHON_COMPILING_IN_CPYTHON
if (unlikely(!iternext)) {
#else
if (unlikely(!iternext) || unlikely(!PyIter_Check(iterator))) {
#endif
PyErr_Format(PyExc_TypeError,
"%.200s object is not an iterator", Py_TYPE(iterator)->tp_name);
return NULL;
}
next = iternext(iterator);
if (likely(next))
return next;
#if CYTHON_COMPILING_IN_CPYTHON
#if PY_VERSION_HEX >= 0x03010000 || (PY_MAJOR_VERSION < 3 && PY_VERSION_HEX >= 0x02070000)
if (unlikely(iternext == &_PyObject_NextNotImplemented))
return NULL;
#endif
#endif
if (defval) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (unlikely(exc_type != PyExc_StopIteration) &&
!PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))
return NULL;
PyErr_Clear();
}
Py_INCREF(defval);
return defval;
}
if (!PyErr_Occurred())
PyErr_SetNone(PyExc_StopIteration);
return NULL;
}
/////////////// IterFinish.proto ///////////////
static CYTHON_INLINE int __Pyx_IterFinish(void); /*proto*/
/////////////// IterFinish ///////////////
// When PyIter_Next(iter) has returned NULL in order to signal termination,
// this function does the right cleanup and returns 0 on success. If it
// detects an error that occurred in the iterator, it returns -1.
static CYTHON_INLINE int __Pyx_IterFinish(void) {
#if CYTHON_COMPILING_IN_CPYTHON
PyThreadState *tstate = PyThreadState_GET();
PyObject* exc_type = tstate->curexc_type;
if (unlikely(exc_type)) {
if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) {
PyObject *exc_value, *exc_tb;
exc_value = tstate->curexc_value;
exc_tb = tstate->curexc_traceback;
tstate->curexc_type = 0;
tstate->curexc_value = 0;
tstate->curexc_traceback = 0;
Py_DECREF(exc_type);
Py_XDECREF(exc_value);
Py_XDECREF(exc_tb);
return 0;
} else {
return -1;
}
}
return 0;
#else
if (unlikely(PyErr_Occurred())) {
if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
PyErr_Clear();
return 0;
} else {
return -1;
}
}
return 0;
#endif
}
int
PyErr_ExceptionMatches(PyObject *exc)
{
return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
}
