static PyObject *Nuitka_Function_get_globals( Nuitka_FunctionObject *object )
{
return INCREASE_REFCOUNT( PyModule_GetDict( object->m_module ) );
}
static PyObject *Nuitka_Function_get_kwdefaults( Nuitka_FunctionObject *object )
{
return INCREASE_REFCOUNT( (PyObject *)object->m_kwdefaults );
}
static PyObject *Nuitka_Function_get_annotations( Nuitka_FunctionObject *object )
{
return INCREASE_REFCOUNT( (PyObject *)object->m_annotations );
}
PyObject *getValue() const
{
return INCREASE_REFCOUNT( this->value );
}
static PyObject *Nuitka_Function_get_code( Nuitka_FunctionObject *object )
{
return INCREASE_REFCOUNT( (PyObject *)object->m_code_object );
}
NUITKA_NO_RETURN NUITKA_MAY_BE_UNUSED static void RAISE_EXCEPTION_WITH_CAUSE( PyObject *exception_type, PyObject *exception_cause, PyObject *exception_tb )
{
PyTracebackObject *traceback = (PyTracebackObject *)exception_tb;
assertObject( exception_type );
assertObject( exception_cause );
#if PYTHON_VERSION >= 330
// None is not a cause.
if ( exception_cause == Py_None )
{
exception_cause = NULL;
}
else
#endif
if ( PyExceptionClass_Check( exception_cause ) )
{
exception_cause = PyObject_CallObject( exception_cause, NULL );
if (unlikely( exception_cause == NULL ))
{
throw PythonException();
}
}
else
{
Py_INCREF( exception_cause );
}
#if PYTHON_VERSION >= 330
if (unlikely( exception_cause != NULL && !PyExceptionInstance_Check( exception_cause ) ))
#else
if (unlikely( !PyExceptionInstance_Check( exception_cause ) ))
#endif
{
Py_XDECREF( exception_cause );
PyErr_Format( PyExc_TypeError, "exception causes must derive from BaseException" );
throw PythonException();
}
if ( PyExceptionClass_Check( exception_type ) )
{
PyObject *value = NULL;
Py_INCREF( exception_type );
Py_INCREF( traceback );
NORMALIZE_EXCEPTION( &exception_type, &value, &traceback );
if (unlikely( !PyExceptionInstance_Check( value ) ))
{
Py_DECREF( exception_type );
Py_XDECREF( value );
Py_DECREF( traceback );
Py_XDECREF( exception_cause );
PyErr_Format(
PyExc_TypeError,
"calling %s() should have returned an instance of BaseException, not '%s'",
((PyTypeObject *)exception_type)->tp_name,
Py_TYPE( value )->tp_name
);
throw PythonException();
}
PythonException to_throw( exception_type, value, traceback );
to_throw.setCause( exception_cause );
throw to_throw;
}
else if ( PyExceptionInstance_Check( exception_type ) )
{
Py_XDECREF( exception_cause );
throw PythonException(
INCREASE_REFCOUNT( PyExceptionInstance_Class( exception_type ) ),
INCREASE_REFCOUNT( exception_type ),
INCREASE_REFCOUNT( traceback )
);
}
else
{
Py_XDECREF( exception_cause );
PyErr_Format( PyExc_TypeError, WRONG_EXCEPTION_TYPE_ERROR_MESSAGE, Py_TYPE( exception_type )->tp_name );
PythonException to_throw;
to_throw.setTraceback( INCREASE_REFCOUNT( traceback ) );
throw to_throw;
}
}
NUITKA_NO_RETURN NUITKA_MAY_BE_UNUSED static void RAISE_EXCEPTION_WITH_TYPE( PyObject *exception_type, PyObject *exception_tb )
{
PyTracebackObject *traceback = (PyTracebackObject *)exception_tb;
assertObject( traceback );
assert( PyTraceBack_Check( traceback ) );
assertObject( exception_type );
if ( PyExceptionClass_Check( exception_type ) )
{
PyObject *value = NULL;
Py_INCREF( exception_type );
Py_XINCREF( traceback );
NORMALIZE_EXCEPTION( &exception_type, &value, &traceback );
#if PYTHON_VERSION >= 270
if (unlikely( !PyExceptionInstance_Check( value ) ))
{
Py_DECREF( exception_type );
Py_DECREF( value );
Py_XDECREF( traceback );
PyErr_Format(
PyExc_TypeError,
"calling %s() should have returned an instance of BaseException, not '%s'",
((PyTypeObject *)exception_type)->tp_name,
Py_TYPE( value )->tp_name
);
throw PythonException();
}
#endif
#if PYTHON_VERSION >= 300
CHAIN_EXCEPTION( exception_type, value );
#endif
throw PythonException(
exception_type,
value,
traceback
);
}
else if ( PyExceptionInstance_Check( exception_type ) )
{
PyObject *value = exception_type;
exception_type = PyExceptionInstance_Class( exception_type );
#if PYTHON_VERSION >= 300
CHAIN_EXCEPTION( exception_type, value );
PyTracebackObject *prev = (PyTracebackObject *)PyException_GetTraceback( value );
if ( prev != NULL )
{
assert( traceback->tb_next == NULL );
traceback->tb_next = prev;
}
PyException_SetTraceback( value, (PyObject *)traceback );
#endif
throw PythonException(
INCREASE_REFCOUNT( exception_type ),
INCREASE_REFCOUNT( value ),
INCREASE_REFCOUNT( traceback )
);
}
else
{
PyErr_Format( PyExc_TypeError, WRONG_EXCEPTION_TYPE_ERROR_MESSAGE, Py_TYPE( exception_type )->tp_name );
PythonException to_throw;
to_throw.setTraceback( INCREASE_REFCOUNT( traceback ) );
throw to_throw;
}
}
static PyObject *Nuitka_Generator_get_name( Nuitka_GeneratorObject *generator )
{
return INCREASE_REFCOUNT( generator->m_name );
}
static PyObject *Nuitka_Generator_get_code( Nuitka_GeneratorObject *object )
{
return INCREASE_REFCOUNT( (PyObject *)object->m_code_object );
}
// The module function definitions.
static PyObject *impl_function_1_new_of_module_Crypto$Random( Nuitka_FunctionObject *self, PyObject *_python_par_args, PyObject *_python_par_kwargs )
{
// No context is used.
// Local variable declarations.
PyObjectLocalVariable par_args; par_args.object = _python_par_args;
PyObjectLocalVariable par_kwargs; par_kwargs.object = _python_par_kwargs;
PyObject *exception_type = NULL, *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
PyObject *tmp_dircall_arg1_1;
PyObject *tmp_dircall_arg2_1;
PyObject *tmp_dircall_arg3_1;
PyObject *tmp_frame_locals;
PyObject *tmp_return_value;
PyObject *tmp_source_name_1;
tmp_return_value = NULL;
// Actual function code.
static PyFrameObject *cache_frame_function = NULL;
MAKE_OR_REUSE_FRAME( cache_frame_function, codeobj_133c4414c20d7de5bf4cbf02f8208534, module_Crypto$Random );
PyFrameObject *frame_function = cache_frame_function;
// Push the new frame as the currently active one.
pushFrameStack( frame_function );
// Mark the frame object as in use, ref count 1 will be up for reuse.
Py_INCREF( frame_function );
assert( Py_REFCNT( frame_function ) == 2 ); // Frame stack
#if PYTHON_VERSION >= 340
frame_function->f_executing += 1;
#endif
// Framed code:
tmp_source_name_1 = GET_STRING_DICT_VALUE( moduledict_Crypto$Random, (Nuitka_StringObject *)const_str_plain__UserFriendlyRNG );
if (unlikely( tmp_source_name_1 == NULL ))
{
tmp_source_name_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__UserFriendlyRNG );
}
if ( tmp_source_name_1 == NULL )
{
exception_type = INCREASE_REFCOUNT( PyExc_NameError );
exception_value = UNSTREAM_STRING( &constant_bin[ 6196 ], 45, 0 );
exception_tb = NULL;
frame_function->f_lineno = 33;
goto frame_exception_exit_1;
}
tmp_dircall_arg1_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_new );
if ( tmp_dircall_arg1_1 == NULL )
{
assert( ERROR_OCCURED() );
PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb );
frame_function->f_lineno = 33;
goto frame_exception_exit_1;
}
tmp_dircall_arg2_1 = par_args.object;
if ( tmp_dircall_arg2_1 == NULL )
{
Py_DECREF( tmp_dircall_arg1_1 );
exception_type = INCREASE_REFCOUNT( PyExc_UnboundLocalError );
exception_value = UNSTREAM_STRING( &constant_bin[ 201 ], 50, 0 );
exception_tb = NULL;
frame_function->f_lineno = 33;
goto frame_exception_exit_1;
}
tmp_dircall_arg3_1 = par_kwargs.object;
if ( tmp_dircall_arg3_1 == NULL )
{
Py_DECREF( tmp_dircall_arg1_1 );
exception_type = INCREASE_REFCOUNT( PyExc_UnboundLocalError );
exception_value = UNSTREAM_STRING( &constant_bin[ 251 ], 52, 0 );
exception_tb = NULL;
frame_function->f_lineno = 33;
goto frame_exception_exit_1;
}
tmp_return_value = impl_function_3_complex_call_helper_star_list_star_dict_of_module___internal__( tmp_dircall_arg1_1, INCREASE_REFCOUNT( tmp_dircall_arg2_1 ), INCREASE_REFCOUNT( tmp_dircall_arg3_1 ) );
if ( tmp_return_value == NULL )
{
assert( ERROR_OCCURED() );
PyErr_Fetch( &exception_type, &exception_value, (PyObject **)&exception_tb );
frame_function->f_lineno = 33;
goto frame_exception_exit_1;
}
goto frame_return_exit_1;
#if 0
RESTORE_FRAME_EXCEPTION( frame_function );
#endif
// Put the previous frame back on top.
popFrameStack();
#if PYTHON_VERSION >= 340
frame_function->f_executing -= 1;
#endif
Py_DECREF( frame_function );
goto frame_no_exception_1;
frame_return_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION( frame_function );
#endif
popFrameStack();
#if PYTHON_VERSION >= 340
frame_function->f_executing -= 1;
#endif
Py_DECREF( frame_function );
goto function_return_exit;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION( frame_function );
#endif
if ( exception_tb == NULL )
{
exception_tb = MAKE_TRACEBACK( INCREASE_REFCOUNT( frame_function ) );
}
else if ( exception_tb->tb_frame != frame_function )
{
PyTracebackObject *traceback_new = (PyTracebackObject *)MAKE_TRACEBACK( INCREASE_REFCOUNT( frame_function ) );
traceback_new->tb_next = exception_tb;
exception_tb = traceback_new;
}
tmp_frame_locals = PyDict_New();
if ((par_args.object != NULL))
{
PyDict_SetItem(
tmp_frame_locals,
const_str_plain_args,
par_args.object
);
}
if ((par_kwargs.object != NULL))
{
PyDict_SetItem(
tmp_frame_locals,
const_str_plain_kwargs,
par_kwargs.object
);
}
detachFrame( exception_tb, tmp_frame_locals );
popFrameStack();
#if PYTHON_VERSION >= 340
frame_function->f_executing -= 1;
#endif
Py_DECREF( frame_function );
// Return the error.
goto function_exception_exit;
frame_no_exception_1:;
// Return statement must be present.
assert(false);
function_exception_exit:
assert( exception_type );
PyErr_Restore( exception_type, exception_value, (PyObject *)exception_tb );
return NULL;
function_return_exit:
return tmp_return_value;
}
PyObject *asObject()
{
assertObject( this->object );
return INCREASE_REFCOUNT( this->object );
}
PyObject *asObject1() const
{
return INCREASE_REFCOUNT( this->object );
}
inline PyObject *asObject1() const
{
assertObject( this->object );
return INCREASE_REFCOUNT( this->object );
}
static PyObject *Nuitka_Method_get__doc__( Nuitka_MethodObject *method, void *closure )
{
return INCREASE_REFCOUNT( method->m_function->m_doc );
}
static PyObject *Nuitka_Function_reduce( Nuitka_FunctionObject *function )
{
return INCREASE_REFCOUNT( function->m_name );
}
// This is for CPython iterator objects, the respective code is not exported as
// API, so we need to redo it. This is an re-implementation that closely follows
// what it does. It's unrelated to compiled generators.
PyObject *PyGen_Send( PyGenObject *generator, PyObject *arg )
{
if (unlikely( generator->gi_running ))
{
PyErr_SetString( PyExc_ValueError, "generator already executing" );
return NULL;
}
PyFrameObject *frame = generator->gi_frame;
if ( frame == NULL || frame->f_stacktop == NULL )
{
// Set exception if called from send()
if ( arg != NULL )
{
PyErr_SetNone( PyExc_StopIteration );
}
return NULL;
}
if ( frame->f_lasti == -1 )
{
if (unlikely( arg && arg != Py_None ))
{
PyErr_SetString(
PyExc_TypeError,
"can't send non-None value to a just-started generator"
);
return NULL;
}
}
else
{
// Put arg on top of the value stack
PyObject *tmp = arg ? arg : Py_None;
*(frame->f_stacktop++) = INCREASE_REFCOUNT( tmp );
}
// Generators always return to their most recent caller, not necessarily
// their creator.
PyThreadState *tstate = PyThreadState_GET();
Py_XINCREF( tstate->frame );
assert( frame->f_back == NULL );
frame->f_back = tstate->frame;
generator->gi_running = 1;
PyObject *result = PyEval_EvalFrameEx( frame, 0 );
generator->gi_running = 0;
// Don't keep the reference to f_back any longer than necessary. It
// may keep a chain of frames alive or it could create a reference
// cycle.
assert( frame->f_back == tstate->frame );
Py_CLEAR( frame->f_back );
// If the generator just returned (as opposed to yielding), signal that the
// generator is exhausted.
if ( result && frame->f_stacktop == NULL )
{
if ( result == Py_None )
{
PyErr_SetNone( PyExc_StopIteration );
}
else {
PyObject *e = PyObject_CallFunctionObjArgs(
PyExc_StopIteration,
result,
NULL
);
if ( e != NULL )
{
PyErr_SetObject( PyExc_StopIteration, e );
Py_DECREF( e );
}
}
Py_CLEAR( result );
}
if ( result == NULL || frame->f_stacktop == NULL )
{
// Generator is finished, remove exception from frame before releasing
// it.
PyObject *type = frame->f_exc_type;
PyObject *value = frame->f_exc_value;
PyObject *traceback = frame->f_exc_traceback;
frame->f_exc_type = NULL;
frame->f_exc_value = NULL;
frame->f_exc_traceback = NULL;
Py_XDECREF( type );
Py_XDECREF( value );
Py_XDECREF( traceback );
// Now release frame.
generator->gi_frame = NULL;
Py_DECREF( frame );
}
return result;
}
NUITKA_MAY_BE_UNUSED static PyObject *fast_python_call( PyObject *func, PyObject **args, int count )
{
PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE( func );
PyObject *globals = PyFunction_GET_GLOBALS( func );
PyObject *argdefs = PyFunction_GET_DEFAULTS( func );
#if PYTHON_VERSION >= 300
PyObject *kwdefs = PyFunction_GET_KW_DEFAULTS( func );
if ( kwdefs == NULL && argdefs == NULL && co->co_argcount == count &&
co->co_flags == ( CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ))
#else
if ( argdefs == NULL && co->co_argcount == count &&
co->co_flags == ( CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ))
#endif
{
PyThreadState *tstate = PyThreadState_GET();
assertObject( globals );
PyFrameObject *frame = PyFrame_New( tstate, co, globals, NULL );
if (unlikely( frame == NULL ))
{
return NULL;
};
for ( int i = 0; i < count; i++ )
{
frame->f_localsplus[i] = INCREASE_REFCOUNT( args[i] );
}
PyObject *result = PyEval_EvalFrameEx( frame, 0 );
// Frame release protects against recursion as it may lead to variable
// destruction.
++tstate->recursion_depth;
Py_DECREF( frame );
--tstate->recursion_depth;
return result;
}
PyObject **defaults = NULL;
int nd = 0;
if ( argdefs != NULL )
{
defaults = &PyTuple_GET_ITEM( argdefs, 0 );
nd = int( Py_SIZE( argdefs ) );
}
PyObject *result = PyEval_EvalCodeEx(
#if PYTHON_VERSION >= 300
(PyObject *)co,
#else
co, // code object
#endif
globals, // globals
NULL, // no locals
args, // args
count, // argcount
NULL, // kwds
0, // kwcount
defaults, // defaults
nd, // defcount
#if PYTHON_VERSION >= 300
kwdefs,
#endif
PyFunction_GET_CLOSURE( func )
);
return result;
}
static PyObject *Nuitka_Function_get_qualname( Nuitka_FunctionObject *object )
{
return INCREASE_REFCOUNT( object->m_qualname );
}
NUITKA_NO_RETURN NUITKA_MAY_BE_UNUSED static void RAISE_EXCEPTION_WITH_VALUE( PyObject *exception_type, PyObject *value, PyObject *exception_tb )
{
assertObject( exception_type );
PyTracebackObject *traceback = (PyTracebackObject *)exception_tb;
// Non-empty tuple exceptions are the first element.
while (unlikely( PyTuple_Check( exception_type ) && PyTuple_Size( exception_type ) > 0 ))
{
exception_type = PyTuple_GET_ITEM( exception_type, 0 );
}
if ( PyExceptionClass_Check( exception_type ) )
{
Py_INCREF( exception_type );
Py_XINCREF( value );
Py_XINCREF( traceback );
NORMALIZE_EXCEPTION( &exception_type, &value, &traceback );
#if PYTHON_VERSION >= 270
if (unlikely( !PyExceptionInstance_Check( value ) ))
{
PyErr_Format(
PyExc_TypeError,
"calling %s() should have returned an instance of BaseException, not '%s'",
((PyTypeObject *)exception_type)->tp_name,
Py_TYPE( value )->tp_name
);
Py_DECREF( exception_type );
Py_XDECREF( value );
Py_XDECREF( traceback );
throw PythonException();
}
#endif
throw PythonException(
exception_type,
value,
traceback
);
}
else if ( PyExceptionInstance_Check( exception_type ) )
{
if (unlikely( value != NULL && value != Py_None ))
{
PyErr_Format(
PyExc_TypeError,
"instance exception may not have a separate value"
);
throw PythonException();
}
// The type is rather a value, so we are overriding it here.
value = exception_type;
exception_type = PyExceptionInstance_Class( exception_type );
throw PythonException(
INCREASE_REFCOUNT( exception_type ),
INCREASE_REFCOUNT( value ),
INCREASE_REFCOUNT_X( traceback )
);
}
else
{
PyErr_Format( PyExc_TypeError, WRONG_EXCEPTION_TYPE_ERROR_MESSAGE, Py_TYPE( exception_type )->tp_name );
throw PythonException();
}
}
static PyObject *Nuitka_Function_get_doc( Nuitka_FunctionObject *object )
{
return INCREASE_REFCOUNT( object->m_doc );
}
PyObject *asObject() const
{
return INCREASE_REFCOUNT( this->asObject0() );
}
static PyObject *Nuitka_Generator_throw( Nuitka_GeneratorObject *generator, PyObject *args )
{
generator->m_exception_value = NULL;
generator->m_exception_tb = NULL;
int res = PyArg_UnpackTuple( args, "throw", 1, 3, &generator->m_exception_type, &generator->m_exception_value, (PyObject **)&generator->m_exception_tb );
if ( (PyObject *)generator->m_exception_tb == Py_None )
{
generator->m_exception_tb = NULL;
}
else if ( generator->m_exception_tb != NULL && !PyTraceBack_Check( generator->m_exception_tb ) )
{
PyErr_Format( PyExc_TypeError, "throw() third argument must be a traceback object" );
return NULL;
}
if (unlikely( res == 0 ))
{
generator->m_exception_type = NULL;
generator->m_exception_value = NULL;
generator->m_exception_tb = NULL;
return NULL;
}
Py_INCREF( generator->m_exception_type );
Py_XINCREF( generator->m_exception_value );
Py_XINCREF( generator->m_exception_tb );
if ( PyExceptionClass_Check( generator->m_exception_type ))
{
NORMALIZE_EXCEPTION( &generator->m_exception_type, &generator->m_exception_value, &generator->m_exception_tb );
}
else if ( PyExceptionInstance_Check( generator->m_exception_type ) )
{
if ( generator->m_exception_value && generator->m_exception_value != Py_None )
{
PyErr_Format( PyExc_TypeError, "instance exception may not have a separate value" );
return NULL;
}
Py_XDECREF( generator->m_exception_value );
generator->m_exception_value = generator->m_exception_type;
generator->m_exception_type = INCREASE_REFCOUNT( PyExceptionInstance_Class( generator->m_exception_type ) );
}
else
{
PyErr_Format(
PyExc_TypeError,
#if PYTHON_VERSION < 300
"exceptions must be classes, or instances, not %s",
#else
"exceptions must be classes or instances deriving from BaseException, not %s",
#endif
Py_TYPE( generator->m_exception_type )->tp_name
);
return NULL;
}
if ( ( generator->m_exception_tb != NULL ) && ( (PyObject *)generator->m_exception_tb != Py_None ) && ( !PyTraceBack_Check( generator->m_exception_tb ) ) )
{
PyErr_Format( PyExc_TypeError, "throw() third argument must be a traceback object" );
return NULL;
}
PyObject *exception_type = generator->m_exception_type;
PyObject *exception_value = generator->m_exception_value;
PyTracebackObject *exception_tb = generator->m_exception_tb;
if ( generator->m_status != status_Finished )
{
PyObject *result = Nuitka_Generator_send( generator, Py_None );
Py_DECREF( exception_type );
Py_XDECREF( exception_value );
Py_XDECREF( exception_tb );
return result;
}
else
{
PyErr_Restore( generator->m_exception_type, generator->m_exception_value, (PyObject *)generator->m_exception_tb );
return NULL;
}
}
