PyObject *asObject0() const
{
assert( this->storage );
if ( this->storage->object == NULL )
{
PyErr_Format(
PyExc_UnboundLocalError,
"free variable '%s' referenced before assignment in enclosing scope",
Nuitka_String_AsString( this->storage->getVarName() )
);
throw PythonException();
}
if ( Py_REFCNT( this->storage->object ) == 0 )
{
PyErr_Format(
PyExc_UnboundLocalError,
"free variable '%s' referenced after its finalization in enclosing scope",
Nuitka_String_AsString( this->storage->getVarName() )
);
throw PythonException();
}
return this->storage->object;
}
// tp_repr slot, decide how a function shall be output
static PyObject *Nuitka_Method_tp_repr( Nuitka_MethodObject *method )
{
if ( method->m_object == NULL )
{
#if PYTHON_VERSION < 300
return PyString_FromFormat(
"<unbound compiled_method %s.%s>",
GET_CLASS_NAME( method->m_class ),
Nuitka_String_AsString( method->m_function->m_name )
);
#else
return PyUnicode_FromFormat(
"<compiled function %s at %p>",
Nuitka_String_AsString( method->m_function->m_name ),
method->m_function
);
#endif
}
else
{
// Note: CPython uses repr ob the object, although a comment despises
// it, we do it for compatibility.
PyObject *object_repr = PyObject_Repr( method->m_object );
if ( object_repr == NULL )
{
return NULL;
}
#if PYTHON_VERSION < 300
else if ( !PyString_Check( object_repr ) )
{
Py_DECREF( object_repr );
return NULL;
}
#else
else if ( !PyUnicode_Check( object_repr ) )
{
Py_DECREF( object_repr );
return NULL;
}
#endif
#if PYTHON_VERSION < 300
PyObject *result = PyString_FromFormat(
#else
PyObject *result = PyUnicode_FromFormat(
#endif
"<bound compiled_method %s.%s of %s>",
GET_CLASS_NAME( method->m_class ),
Nuitka_String_AsString( method->m_function->m_name ),
Nuitka_String_AsString_Unchecked( object_repr )
);
Py_DECREF( object_repr );
return result;
}
}
// Note: Python3 uses TO_INT2 function.
NUITKA_MAY_BE_UNUSED static PyObject *TO_LONG2( PyObject *value, PyObject *base )
{
long base_int = PyInt_AsLong( base );
if (unlikely( base_int == -1 ))
{
if (likely( ERROR_OCCURRED() ))
{
return NULL;
}
}
if (unlikely( !Nuitka_String_Check( value ) && !PyUnicode_Check( value ) ))
{
PyErr_Format( PyExc_TypeError, "long() can't convert non-string with explicit base" );
return NULL;
}
char *value_str = Nuitka_String_AsString( value );
if (unlikely( value_str == NULL ))
{
return NULL;
}
PyObject *result = PyLong_FromString( value_str, NULL, base_int );
if (unlikely( result == NULL ))
{
return NULL;
}
return result;
}
// tp_repr slot, decide how a function shall be output
static PyObject *Nuitka_Function_tp_repr( Nuitka_FunctionObject *function )
{
#if PYTHON_VERSION < 300
return PyString_FromFormat(
#else
return PyUnicode_FromFormat(
#endif
"<compiled function %s at %p>",
#if PYTHON_VERSION < 330
Nuitka_String_AsString( function->m_name ),
#else
Nuitka_String_AsString( function->m_qualname ),
#endif
function
);
}
void ERROR_TOO_FEW_ARGUMENTS( Nuitka_FunctionObject *function,
#if PYTHON_VERSION < 270
Py_ssize_t kw_size,
#endif
Py_ssize_t given )
{
Py_ssize_t required_parameter_count =
function->m_code_object->co_argcount;
if ( function->m_defaults != Py_None )
{
required_parameter_count -= PyTuple_GET_SIZE( function->m_defaults );
}
char const *function_name =
Nuitka_String_AsString( function->m_name );
char const *violation =
( function->m_defaults != Py_None || function->m_code_object->co_flags & CO_VARARGS ) ? "at least" : "exactly";
char const *plural =
required_parameter_count == 1 ? "" : "s";
#if PYTHON_VERSION < 270
if ( kw_size > 0 )
{
PyErr_Format(
PyExc_TypeError,
"%s() takes %s %zd non-keyword argument%s (%zd given)",
function_name,
violation,
required_parameter_count,
plural,
given - function->m_defaults_given
);
}
else
{
PyErr_Format(
PyExc_TypeError,
"%s() takes %s %zd argument%s (%zd given)",
function_name,
violation,
required_parameter_count,
plural,
given
);
}
#else
PyErr_Format(
PyExc_TypeError,
"%s() takes %s %zd argument%s (%zd given)",
function_name,
violation,
required_parameter_count,
plural,
given
);
#endif
}
void del( bool tolerant ) const
{
int status = PyDict_DelItem( (PyObject *)_moduledict_django__core__management, (PyObject *)*this->var_name );
if (unlikely( status == -1 && tolerant == false ))
{
PyErr_Format( PyExc_NameError, "global name '%s' is not defined", Nuitka_String_AsString( (PyObject *)*this->var_name ) );
throw PythonException();
}
}
static PyObject *Nuitka_Generator_tp_repr( struct Nuitka_GeneratorObject *generator )
{
#if PYTHON_VERSION < 300
return PyString_FromFormat(
"<compiled_generator object %s at %p>",
Nuitka_String_AsString( generator->m_name ),
generator
);
#else
return PyUnicode_FromFormat(
"<compiled_generator object %s at %p>",
#if PYTHON_VERSION < 350
Nuitka_String_AsString( generator->m_name ),
#else
Nuitka_String_AsString( generator->m_qualname ),
#endif
generator
);
#endif
}
void ERROR_NO_ARGUMENTS_ALLOWED( Nuitka_FunctionObject *function,
#if PYTHON_VERSION >= 330
PyObject *kw,
#endif
Py_ssize_t given )
{
char const *function_name =
Nuitka_String_AsString( function->m_name );
#if PYTHON_VERSION < 330
PyErr_Format(
PyExc_TypeError,
"%s() takes no arguments (%zd given)",
function_name,
given );
#else
if ( kw == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s() takes 0 positional arguments but %zd was given",
function_name,
given
);
}
else
{
PyObject *tmp_iter = PyObject_GetIter( kw );
PyObject *tmp_arg_name = PyIter_Next( tmp_iter );
Py_DECREF( tmp_iter );
PyErr_Format( PyExc_TypeError,
"%s() got an unexpected keyword argument '%s'",
function_name,
Nuitka_String_AsString( tmp_arg_name )
);
Py_DECREF( tmp_arg_name );
}
#endif
}
void ERROR_MULTIPLE_VALUES( Nuitka_FunctionObject *function, Py_ssize_t index )
{
char const *function_name =
Nuitka_String_AsString( function->m_name );
PyErr_Format(
PyExc_TypeError,
#if PYTHON_VERSION < 330
"%s() got multiple values for keyword argument '%s'",
#else
"%s() got multiple values for argument '%s'",
#endif
function_name,
Nuitka_String_AsString(
PyTuple_GET_ITEM(
function->m_code_object->co_varnames,
index
)
)
);
}
static PyObject *Nuitka_Generator_tp_repr( Nuitka_GeneratorObject *generator )
{
#if PYTHON_VERSION < 300
return PyString_FromFormat(
#else
return PyUnicode_FromFormat(
#endif
"<compiled generator object %s at %p>",
Nuitka_String_AsString( generator->m_name ),
generator
);
}
NUITKA_MAY_BE_UNUSED static PyObject *IMPORT_NAME( PyObject *module, PyObject *import_name )
{
CHECK_OBJECT( module );
CHECK_OBJECT( import_name );
PyObject *result = PyObject_GetAttr( module, import_name );
if (unlikely( result == NULL ))
{
if ( EXCEPTION_MATCH_BOOL_SINGLE( GET_ERROR_OCCURRED(), PyExc_AttributeError ) )
{
#if PYTHON_VERSION < 340
PyErr_Format( PyExc_ImportError, "cannot import name %s", Nuitka_String_AsString( import_name ));
#else
PyErr_Format( PyExc_ImportError, "cannot import name '%s'", Nuitka_String_AsString( import_name ));
#endif
}
return NULL;
}
return result;
}
static char const *GET_CALLABLE_NAME( PyObject *object )
{
if ( Nuitka_Function_Check( object ) )
{
return Nuitka_String_AsString( Nuitka_Function_GetName( object ) );
}
else if ( Nuitka_Generator_Check( object ) )
{
return Nuitka_String_AsString( Nuitka_Generator_GetName( object ) );
}
else if ( PyMethod_Check( object ) )
{
return PyEval_GetFuncName( PyMethod_GET_FUNCTION( object ) );
}
else if ( PyFunction_Check( object ) )
{
return Nuitka_String_AsString( ((PyFunctionObject*)object)->func_name );
}
#if PYTHON_VERSION < 300
else if ( PyInstance_Check( object ) )
{
return Nuitka_String_AsString( ((PyInstanceObject*)object)->in_class->cl_name );
}
else if ( PyClass_Check( object ) )
{
return Nuitka_String_AsString( ((PyClassObject*)object)->cl_name );
}
#endif
else if ( PyCFunction_Check( object ) )
{
return ((PyCFunctionObject*)object)->m_ml->ml_name;
}
else
{
return Py_TYPE( object )->tp_name;
}
}
// tp_repr slot, decide how a function shall be output
static PyObject *Nuitka_Frame_tp_repr( Nuitka_FrameObject *nuitka_frame )
{
#if PYTHON_VERSION < 300
return PyString_FromFormat(
#else
return PyUnicode_FromFormat(
#endif
#if _DEBUG_FRAME || _DEBUG_REFRAME || _DEBUG_EXCEPTIONS
"<compiled_frame object for %s at %p>",
Nuitka_String_AsString( nuitka_frame->m_frame.f_code->co_name ),
nuitka_frame
#else
"<compiled_frame object at %p>",
nuitka_frame
#endif
);
}
// tp_repr slot, decide how a function shall be output
static PyObject *Nuitka_Frame_tp_repr(struct Nuitka_FrameObject *nuitka_frame) {
#if PYTHON_VERSION < 300
return PyString_FromFormat(
#else
return PyUnicode_FromFormat(
#endif
#if PYTHON_VERSION >= 370
"<compiled_frame at %p, file %R, line %d, code %S>", nuitka_frame, nuitka_frame->m_frame.f_code->co_filename,
nuitka_frame->m_frame.f_lineno, nuitka_frame->m_frame.f_code->co_name
#elif _DEBUG_FRAME || _DEBUG_REFRAME || _DEBUG_EXCEPTIONS
"<compiled_frame object for %s at %p>", Nuitka_String_AsString(nuitka_frame->m_frame.f_code->co_name),
nuitka_frame
#else
"<compiled_frame object at %p>",
nuitka_frame
#endif
);
}
PyObject *Nuitka_Generator_New( yielder_func code, PyObject *name, PyCodeObject *code_object, void *context, releaser cleanup )
{
Nuitka_GeneratorObject *result = PyObject_GC_New( Nuitka_GeneratorObject, &Nuitka_Generator_Type );
if (unlikely( result == NULL ))
{
PyErr_Format(
PyExc_RuntimeError,
"cannot create genexpr %s",
Nuitka_String_AsString( name )
);
return NULL;
}
result->m_code = (void *)code;
result->m_name = INCREASE_REFCOUNT( name );
result->m_context = context;
result->m_cleanup = cleanup;
result->m_weakrefs = NULL;
result->m_status = status_Unused;
result->m_running = false;
result->m_exception_type = NULL;
result->m_exception_value = NULL;
result->m_exception_tb = NULL;
result->m_yielded = NULL;
result->m_frame = NULL;
result->m_code_object = code_object;
initFiber( &result->m_yielder_context );
Nuitka_GC_Track( result );
return (PyObject *)result;
}
PyObject *Nuitka_Method_New( struct Nuitka_FunctionObject *function, PyObject *object, PyObject *klass )
{
struct Nuitka_MethodObject *result = method_cache_head;
if ( result != NULL )
{
method_cache_head = (struct Nuitka_MethodObject *)method_cache_head->m_object;
method_cache_size -= 1;
Py_TYPE( result ) = &Nuitka_Method_Type;
_Py_NewReference( (PyObject *)result );
}
else
{
result = PyObject_GC_New(struct Nuitka_MethodObject, &Nuitka_Method_Type);
}
if (unlikely( result == NULL ))
{
PyErr_Format(
PyExc_RuntimeError,
"cannot create method %s",
Nuitka_String_AsString( function->m_name )
);
return NULL;
}
result->m_function = (struct Nuitka_FunctionObject *)INCREASE_REFCOUNT( (PyObject *)function );
result->m_object = object;
Py_XINCREF( object );
result->m_class = klass;
Py_XINCREF( klass );
result->m_weakrefs = NULL;
Nuitka_GC_Track( result );
return (PyObject *)result;
}
PyObject *asObject0() const
{
PyObject *result = GET_STRING_DICT_VALUE( _moduledict_django__core__management, *this->var_name );
if (likely( result != NULL ))
{
assertObject( result );
return result;
}
result = GET_STRING_DICT_VALUE( dict_builtin, *this->var_name );
if (likely( result != NULL ))
{
assertObject( result );
return result;
}
PyErr_Format( PyExc_NameError, "global name '%s' is not defined", Nuitka_String_AsString( (PyObject *)*this->var_name ) );
throw PythonException();
}
static char const *GET_CLASS_NAME( PyObject *klass )
{
if ( klass == NULL )
{
return "?";
}
else
{
#if PYTHON_VERSION < 300
if ( PyClass_Check( klass ) )
{
return Nuitka_String_AsString( ((PyClassObject *)klass)->cl_name );
}
#endif
if ( !PyType_Check( klass ) )
{
klass = (PyObject *)Py_TYPE( klass );
}
return ((PyTypeObject *)klass)->tp_name;
}
}
void del( bool tolerant )
{
if ( this->object )
{
Py_DECREF( this->object );
}
else if ( !tolerant )
{
PyErr_Format( PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", Nuitka_String_AsString( this->var_name ) );
throw PythonException();
}
this->object = NULL;
}
static PyObject *fparse_function_1_permalink_of_module_django__db__models( Nuitka_FunctionObject *self, PyObject **args, Py_ssize_t args_size, PyObject *kw )
{
assert( kw == NULL || PyDict_Check( kw ) );
NUITKA_MAY_BE_UNUSED Py_ssize_t kw_size = kw ? PyDict_Size( kw ) : 0;
NUITKA_MAY_BE_UNUSED Py_ssize_t kw_found = 0;
NUITKA_MAY_BE_UNUSED Py_ssize_t kw_only_found = 0;
Py_ssize_t args_given = args_size;
PyObject *_python_par_func = NULL;
Py_ssize_t args_usable_count;
// Copy given dictionary values to the the respective variables:
if ( kw_size > 0 )
{
Py_ssize_t ppos = 0;
PyObject *key, *value;
while( PyDict_Next( kw, &ppos, &key, &value ) )
{
#if PYTHON_VERSION < 300
if (unlikely( !PyString_Check( key ) && !PyUnicode_Check( key ) ))
#else
if (unlikely( !PyUnicode_Check( key ) ))
#endif
{
PyErr_Format( PyExc_TypeError, "permalink() keywords must be strings" );
goto error_exit;
}
NUITKA_MAY_BE_UNUSED bool found = false;
Py_INCREF( key );
Py_INCREF( value );
// Quick path, could be our value.
if ( found == false && _python_str_plain_func == key )
{
if (unlikely( _python_par_func ))
{
PyErr_Format( PyExc_TypeError, "permalink() got multiple values for keyword argument 'func'" );
goto error_exit;
}
_python_par_func = value;
found = true;
kw_found += 1;
}
// Slow path, compare against all parameter names.
if ( found == false && RICH_COMPARE_BOOL_EQ_PARAMETERS( _python_str_plain_func, key ) )
{
if (unlikely( _python_par_func ))
{
PyErr_Format( PyExc_TypeError, "permalink() got multiple values for keyword argument 'func'" );
goto error_exit;
}
_python_par_func = value;
found = true;
kw_found += 1;
}
Py_DECREF( key );
if ( found == false )
{
Py_DECREF( value );
PyErr_Format(
PyExc_TypeError,
"permalink() got an unexpected keyword argument '%s'",
Nuitka_String_Check( key ) ? Nuitka_String_AsString( key ) : "<non-string>"
);
goto error_exit;
}
}
#if PYTHON_VERSION < 300
assert( kw_found == kw_size );
assert( kw_only_found == 0 );
#endif
}
// Check if too many arguments were given in case of non star args
if (unlikely( args_given > 1 ))
{
if ( 1 == 1 )
{
#if PYTHON_VERSION < 300
PyErr_Format( PyExc_TypeError, "permalink() takes exactly 1 argument (%zd given)", args_given + kw_found );
#elif PYTHON_VERSION < 330
PyErr_Format( PyExc_TypeError, "permalink() takes exactly 1 positional argument (%zd given)", args_given + kw_only_found );
#else
PyErr_Format( PyExc_TypeError, "permalink() takes 1 positional argument but %zd were given", args_given + kw_only_found );
#endif
}
else
{
#if PYTHON_VERSION < 300
PyErr_Format( PyExc_TypeError, "permalink() takes exactly %d arguments (%zd given)", 1, args_given + kw_size );
#elif PYTHON_VERSION < 330
if ( 1 == 1 )
{
PyErr_Format( PyExc_TypeError, "permalink() takes exactly %d positional arguments (%zd given)", 1, args_given + kw_only_found );
}
else
{
PyErr_Format( PyExc_TypeError, "permalink() takes at most %d positional arguments (%zd given)", 1, args_given + kw_only_found );
}
#else
if ( 1 == 1 )
{
PyErr_Format( PyExc_TypeError, "permalink() takes %d positional arguments but %zd were given", 1, args_given + kw_only_found );
}
else
{
PyErr_Format( PyExc_TypeError, "permalink() takes at most %d positional arguments (%zd given)", 1, args_given + kw_only_found );
}
#endif
}
goto error_exit;
}
// Check if too little arguments were given.
if (unlikely( args_given + kw_found - kw_only_found < 1 ))
{
if ( 1 == 1 )
{
PyErr_Format( PyExc_TypeError, "permalink() takes exactly 1 argument (%zd given)", args_given + kw_found - kw_only_found );
}
else
{
#if PYTHON_VERSION < 270
if ( kw_size > 0 )
{
PyErr_Format( PyExc_TypeError, "permalink() takes exactly %d non-keyword arguments (%zd given)", 1, args_given + kw_found );
}
else
#endif
{
if ( 1 == 1 )
{
PyErr_Format( PyExc_TypeError, "permalink() takes exactly %d arguments (%zd given)", 1, args_given + kw_found - kw_only_found );
}
else
{
PyErr_Format( PyExc_TypeError, "permalink() takes at least %d arguments (%zd given)", 1, args_given + kw_found - kw_only_found );
}
}
}
goto error_exit;
}
// Copy normal parameter values given as part of the args list to the respective variables:
args_usable_count = args_given < 1 ? args_given : 1;
if (likely( 0 < args_usable_count ))
{
if (unlikely( _python_par_func != NULL ))
{
PyErr_Format( PyExc_TypeError, "permalink() got multiple values for keyword argument 'func'" );
goto error_exit;
}
_python_par_func = INCREASE_REFCOUNT( args[ 0 ] );
}
return impl_function_1_permalink_of_module_django__db__models( self, _python_par_func );
error_exit:;
Py_XDECREF( _python_par_func );
return NULL;
}
void del( bool tolerant )
{
if ( this->object == NULL )
{
if ( tolerant == false )
{
PyErr_Format( PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", Nuitka_String_AsString( this->var_name ) );
throw PythonException();
}
}
else
{
PyObject *old_object = this->object;
this->object = NULL;
Py_DECREF( old_object );
}
}
void ERROR_TOO_FEW_KWONLY( struct Nuitka_FunctionObject *function,
PyObject **kw_vars )
{
char const *function_name =
Nuitka_String_AsString( function->m_name );
PyCodeObject *code_object = function->m_code_object;
Py_ssize_t max_missing = 0;
for( Py_ssize_t i = code_object->co_kwonlyargcount-1; i >= 0; --i )
{
if ( kw_vars[ i ] == NULL )
{
max_missing += 1;
}
}
PyObject *list_str = PyUnicode_FromString( "" );
PyObject *comma_str = PyUnicode_FromString( ", " );
PyObject *and_str = PyUnicode_FromString(
max_missing == 2 ? " and " : ", and "
);
Py_ssize_t missing = 0;
for( Py_ssize_t i = code_object->co_kwonlyargcount-1; i >= 0; --i )
{
if ( kw_vars[ i ] == NULL )
{
PyObject *current_str = PyTuple_GET_ITEM(
code_object->co_varnames,
code_object->co_argcount + i
);
PyObject *current = PyObject_Repr( current_str );
if ( missing == 0 )
{
PyObject *old = list_str;
list_str = PyUnicode_Concat(
list_str,
current
);
Py_DECREF( old );
}
else if ( missing == 1 )
{
PyObject *old = list_str;
list_str = PyUnicode_Concat(
and_str,
list_str
);
Py_DECREF( old );
old = list_str;
list_str = PyUnicode_Concat(
current,
list_str
);
Py_DECREF( old );
}
else
{
PyObject *old = list_str;
list_str = PyUnicode_Concat(
comma_str,
list_str
);
Py_DECREF( old );
old = list_str;
list_str = PyUnicode_Concat(
current,
list_str
);
Py_DECREF( old );
}
Py_DECREF( current );
missing += 1;
}
}
Py_DECREF( comma_str );
Py_DECREF( and_str );
PyErr_Format(
PyExc_TypeError,
"%s() missing %zd required keyword-only argument%s: %s",
function_name,
max_missing,
max_missing > 1 ? "s" : "",
Nuitka_String_AsString( list_str )
);
Py_DECREF( list_str );
}
void ERROR_TOO_MANY_ARGUMENTS( Nuitka_FunctionObject *function,
Py_ssize_t given
#if PYTHON_VERSION < 270
, Py_ssize_t kw_size
#endif
#if PYTHON_VERSION >= 330
, Py_ssize_t kw_only
#endif
)
{
Py_ssize_t top_level_parameter_count = function->m_code_object->co_argcount;
char const *function_name =
Nuitka_String_AsString( function->m_name );
#if PYTHON_VERSION < 330
char const *violation =
function->m_defaults != Py_None ? "at most" : "exactly";
#endif
char const *plural =
top_level_parameter_count == 1 ? "" : "s";
#if PYTHON_VERSION < 270
PyErr_Format(
PyExc_TypeError,
"%s() takes %s %zd %sargument%s (%zd given)",
function_name,
violation,
top_level_parameter_count,
kw_size > 0 ? "non-keyword " : "",
plural,
given
);
#elif PYTHON_VERSION < 300
PyErr_Format(
PyExc_TypeError,
"%s() takes %s %zd argument%s (%zd given)",
function_name,
violation,
top_level_parameter_count,
plural,
given
);
#elif PYTHON_VERSION < 330
PyErr_Format(
PyExc_TypeError,
"%s() takes %s %zd positional argument%s (%zd given)",
function_name,
violation,
top_level_parameter_count,
plural,
given
);
#else
char keyword_only_part[100];
if ( kw_only > 0 )
{
sprintf(
keyword_only_part,
" positional argument%s (and %" PY_FORMAT_SIZE_T "d keyword-only argument%s)",
given != 1 ? "s" : "",
kw_only,
kw_only != 1 ? "s" : ""
);
}
else
{
keyword_only_part[0] = 0;
}
if ( function->m_defaults_given == 0 )
{
PyErr_Format(
PyExc_TypeError,
"%s() takes %zd positional argument%s but %zd%s were given",
function_name,
top_level_parameter_count,
plural,
given,
keyword_only_part
);
}
else
{
PyErr_Format(
PyExc_TypeError,
"%s() takes from %zd to %zd positional argument%s but %zd%s were given",
function_name,
top_level_parameter_count - function->m_defaults_given,
top_level_parameter_count,
plural,
given,
keyword_only_part
);
}
#endif
}
static PyObject *fparse_function_1_get_wsgi_application_of_module_django__core__wsgi( Nuitka_FunctionObject *self, PyObject **args, Py_ssize_t args_size, PyObject *kw )
{
assert( kw == NULL || PyDict_Check( kw ) );
NUITKA_MAY_BE_UNUSED Py_ssize_t kw_size = kw ? PyDict_Size( kw ) : 0;
NUITKA_MAY_BE_UNUSED Py_ssize_t kw_found = 0;
NUITKA_MAY_BE_UNUSED Py_ssize_t kw_only_found = 0;
Py_ssize_t args_given = args_size;
if (unlikely( args_given + kw_size > 0 ))
{
#if PYTHON_VERSION < 330
PyErr_Format( PyExc_TypeError, "get_wsgi_application() takes no arguments (%zd given)", args_given + kw_size );
#else
if ( kw_size == 0 )
{
PyErr_Format( PyExc_TypeError, "get_wsgi_application() takes 0 positional arguments but %zd was given", args_given );
}
else
{
PyObject *tmp_iter = PyObject_GetIter( kw );
PyObject *tmp_arg_name = PyIter_Next( tmp_iter );
Py_DECREF( tmp_iter );
PyErr_Format( PyExc_TypeError, "get_wsgi_application() got an unexpected keyword argument '%s'", Nuitka_String_AsString( tmp_arg_name ) );
Py_DECREF( tmp_arg_name );
}
#endif
goto error_exit;
}
return impl_function_1_get_wsgi_application_of_module_django__core__wsgi( self );
error_exit:;
return NULL;
}
PyObject *asObject0() const
{
if ( this->object == NULL && this->var_name != NULL )
{
PyErr_Format( PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", Nuitka_String_AsString( this->var_name ) );
throw PythonException();
}
assertObject( this->object );
return this->object;
}
NUITKA_MAY_BE_UNUSED static PyObject *TO_INT2( PyObject *value, PyObject *base )
{
// TODO: Need to check if 3.4 is really the first version to do this.
#if PYTHON_VERSION < 340
long base_int = PyInt_AsLong( base );
#else
Py_ssize_t base_int = PyNumber_AsSsize_t( base, NULL );
#endif
if (unlikely( base_int == -1 ))
{
PyObject *error = GET_ERROR_OCCURRED();
if (likely( error ))
{
#if PYTHON_VERSION >= 300
if ( EXCEPTION_MATCH_BOOL_SINGLE( error, PyExc_OverflowError ) )
{
PyErr_Format(
PyExc_ValueError,
#if PYTHON_VERSION < 324
"int() arg 2 must be >= 2 and <= 36"
#else
"int() base must be >= 2 and <= 36"
#endif
);
}
#endif
return NULL;
}
}
#if PYTHON_VERSION >= 300
if (unlikely( ( base_int != 0 && base_int < 2 ) || base_int > 36 ))
{
PyErr_Format(
PyExc_ValueError,
#if PYTHON_VERSION < 324
"int() arg 2 must be >= 2 and <= 36"
#else
"int() base must be >= 2 and <= 36"
#endif
);
return NULL;
}
#endif
#if PYTHON_VERSION < 300
if (unlikely( !Nuitka_String_Check( value ) && !PyUnicode_Check( value ) ))
{
PyErr_Format(
PyExc_TypeError,
"int() can't convert non-string with explicit base"
);
return NULL;
}
char *value_str = Nuitka_String_AsString( value );
if (unlikely( value_str == NULL ))
{
return NULL;
}
PyObject *result = PyInt_FromString( value_str, NULL, base_int );
if (unlikely( result == NULL ))
{
return NULL;
}
return result;
#else
if ( PyUnicode_Check( value ) )
{
#if PYTHON_VERSION < 330
char *value_str = Nuitka_String_AsString( value );
if (unlikely( value_str == NULL ))
{
return NULL;
}
PyObject *result = PyInt_FromString( value_str, NULL, base_int );
if (unlikely( result == NULL ))
{
return NULL;
}
return result;
#else
return PyLong_FromUnicodeObject( value, (int)base_int );
#endif
}
else if ( PyBytes_Check( value ) || PyByteArray_Check( value ) )
{
// Check for "NUL" as PyLong_FromString has no length parameter,
Py_ssize_t size = Py_SIZE( value );
char *value_str;
if ( PyByteArray_Check( value ) )
{
value_str = PyByteArray_AS_STRING( value );
}
else
{
value_str = PyBytes_AS_STRING( value );
}
PyObject *result = NULL;
if ( size != 0 && strlen( value_str ) == (size_t)size )
{
result = PyInt_FromString( value_str, NULL, (int)base_int );
}
if (unlikely( result == NULL ))
{
PyErr_Format(
PyExc_ValueError,
"invalid literal for int() with base %d: %R",
base_int,
value
);
return NULL;
}
return result;
}
else
{
PyErr_Format(
PyExc_TypeError,
"int() can't convert non-string with explicit base"
);
return NULL;
}
#endif
}
