PyCodeObject *MAKE_CODEOBJ( PyObject *filename, PyObject *function_name, int line, PyObject *argnames, int arg_count, int kw_only_count, int flags )
#endif
{
CHECK_OBJECT( filename );
assert( Nuitka_String_Check( filename ) );
CHECK_OBJECT( function_name );
assert( Nuitka_String_Check( function_name ) );
CHECK_OBJECT( argnames );
assert( PyTuple_Check( argnames ) );
// The PyCode_New has funny code that interns, mutating the tuple that owns
// it. Really serious non-immutable shit. We have triggered that changes
// behind our back in the past.
#ifndef __NUITKA_NO_ASSERT__
Py_hash_t hash = DEEP_HASH( argnames );
#endif
// TODO: Consider using PyCode_NewEmpty
PyCodeObject *result = PyCode_New(
arg_count, // argcount
#if PYTHON_VERSION >= 300
kw_only_count, // kw-only count
#endif
0, // nlocals
0, // stacksize
flags, // flags
#if PYTHON_VERSION < 300
const_str_empty, // code (bytecode)
#else
const_bytes_empty, // code (bytecode)
#endif
const_tuple_empty, // consts (we are not going to be compatible)
const_tuple_empty, // names (we are not going to be compatible)
argnames, // varnames (we are not going to be compatible)
const_tuple_empty, // freevars (we are not going to be compatible)
const_tuple_empty, // cellvars (we are not going to be compatible)
filename, // filename
function_name, // name
line, // firstlineno (offset of the code object)
#if PYTHON_VERSION < 300
const_str_empty // lnotab (table to translate code object)
#else
const_bytes_empty // lnotab (table to translate code object)
#endif
);
assert( DEEP_HASH( argnames ) == hash );
if (unlikely( result == NULL ))
{
return NULL;
}
return result;
}
static PyDictEntry *GET_STRING_DICT_ENTRY( PyDictObject *dict, Nuitka_StringObject *key )
{
assert( PyDict_CheckExact( dict ) );
assert( Nuitka_String_Check( key ) );
#if PYTHON_VERSION < 300
Py_hash_t hash = key->ob_shash;
#else
Py_hash_t hash = key->hash;
#endif
// Only improvement would be to identify how to ensure that the hash is
// computed already. Calling hash early on could do that potentially.
if ( hash == -1 )
{
#if PYTHON_VERSION < 300
hash = PyString_Type.tp_hash( (PyObject *)key );
key->ob_shash = hash;
#else
hash = PyUnicode_Type.tp_hash( (PyObject *)key );
key->hash = hash;
#endif
}
PyDictEntry *entry = dict->ma_lookup( dict, (PyObject *)key, hash );
// The "entry" cannot be NULL, it can only be empty for a string dict
// lookup, but at least assert it.
assert( entry != NULL );
return entry;
}
static Nuitka_DictEntryHandle GET_STRING_DICT_ENTRY( PyDictObject *dict, Nuitka_StringObject *key )
{
assert( PyDict_CheckExact( dict ) );
assert( Nuitka_String_Check( key ) );
Py_hash_t hash = key->_base._base.hash;
// Only improvement would be to identify how to ensure that the hash is computed
// already. Calling hash early on could do that potentially.
if ( hash == -1 )
{
hash = PyUnicode_Type.tp_hash( (PyObject *)key );
key->_base._base.hash = hash;
}
PyObject **value_addr;
PyDictKeyEntry *entry = dict->ma_keys->dk_lookup( dict, (PyObject *)key, hash, &value_addr );
// The "entry" cannot be NULL, it can only be empty for a string dict lookup, but at
// least assert it.
assert( entry != NULL );
return value_addr;
}
// 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;
}
NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_BUILTIN( PyObject *name )
{
assertObject( (PyObject *)dict_builtin );
assertObject( name );
assert( Nuitka_String_Check( name ) );
PyObject *result = GET_STRING_DICT_VALUE(
dict_builtin,
(Nuitka_StringObject *)name
);
assertObject( result );
return result;
}
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;
}
NUITKA_MAY_BE_UNUSED static PyObject *TO_UNICODE3( PyObject *value, PyObject *encoding, PyObject *errors )
{
CHECK_OBJECT( value );
if ( encoding ) CHECK_OBJECT( encoding );
if ( errors ) CHECK_OBJECT( errors );
char *encoding_str;
if ( encoding == NULL )
{
encoding_str = NULL;
}
else if ( Nuitka_String_Check( encoding ) )
{
encoding_str = Nuitka_String_AsString_Unchecked( encoding );
}
#if PYTHON_VERSION < 300
else if ( PyUnicode_Check( encoding ) )
{
PyObject *uarg2 = _PyUnicode_AsDefaultEncodedString( encoding, NULL );
CHECK_OBJECT( uarg2 );
encoding_str = Nuitka_String_AsString_Unchecked( uarg2 );
}
#endif
else
{
PyErr_Format( PyExc_TypeError, "unicode() argument 2 must be string, not %s", Py_TYPE( encoding )->tp_name );
return NULL;
}
char *errors_str;
if ( errors == NULL )
{
errors_str = NULL;
}
else if ( Nuitka_String_Check( errors ) )
{
errors_str = Nuitka_String_AsString_Unchecked( errors );
}
#if PYTHON_VERSION < 300
else if ( PyUnicode_Check( errors ) )
{
PyObject *uarg3 = _PyUnicode_AsDefaultEncodedString( errors, NULL );
CHECK_OBJECT( uarg3 );
errors_str = Nuitka_String_AsString_Unchecked( uarg3 );
}
#endif
else
{
PyErr_Format( PyExc_TypeError, "unicode() argument 3 must be string, not %s", Py_TYPE( errors )->tp_name );
return NULL;
}
PyObject *result = PyUnicode_FromEncodedObject( value, encoding_str, errors_str );
if (unlikely( result == NULL ))
{
return NULL;
}
assert( PyUnicode_Check( result ) );
return result;
}
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
}
