static void Nuitka_Generator_tp_del( struct Nuitka_GeneratorObject *generator )
{
if ( generator->m_status != status_Running )
{
return;
}
PyObject *error_type, *error_value;
PyTracebackObject *error_traceback;
FETCH_ERROR_OCCURRED( &error_type, &error_value, &error_traceback );
PyObject *close_result = Nuitka_Generator_close( generator, NULL );
if (unlikely( close_result == NULL ))
{
PyErr_WriteUnraisable( (PyObject *)generator );
}
else
{
Py_DECREF( close_result );
}
/* Restore the saved exception if any. */
RESTORE_ERROR_OCCURRED( error_type, error_value, error_traceback );
}
static void Nuitka_Function_tp_dealloc( Nuitka_FunctionObject *function )
{
#ifndef __NUITKA_NO_ASSERT__
// Save the current exception, if any, we must to not corrupt it.
PyObject *save_exception_type, *save_exception_value;
PyTracebackObject *save_exception_tb;
FETCH_ERROR_OCCURRED( &save_exception_type, &save_exception_value, &save_exception_tb );
RESTORE_ERROR_OCCURRED( save_exception_type, save_exception_value, save_exception_tb );
#endif
Nuitka_GC_UnTrack( function );
if ( function->m_weakrefs != NULL )
{
PyObject_ClearWeakRefs( (PyObject *)function );
}
Py_DECREF( function->m_name );
#if PYTHON_VERSION >= 330
Py_DECREF( function->m_qualname );
#endif
// These may actually re-surrect the object, not?
Py_XDECREF( function->m_dict );
Py_DECREF( function->m_defaults );
Py_DECREF( function->m_doc );
#if PYTHON_VERSION >= 300
Py_DECREF( function->m_kwdefaults );
Py_DECREF( function->m_annotations );
#endif
if ( function->m_closure )
{
for( Py_ssize_t i = 0; i < function->m_closure_given; i++ )
{
Py_DECREF( function->m_closure[i] );
}
free( function->m_closure );
}
PyObject_GC_Del( function );
#ifndef __NUITKA_NO_ASSERT__
PyThreadState *tstate = PyThreadState_GET();
assert( tstate->curexc_type == save_exception_type );
assert( tstate->curexc_value == save_exception_value );
assert( (PyTracebackObject *)tstate->curexc_traceback == save_exception_tb );
#endif
}
static void Nuitka_Generator_tp_dealloc( struct Nuitka_GeneratorObject *generator )
{
// Revive temporarily.
assert( Py_REFCNT( generator ) == 0 );
Py_REFCNT( generator ) = 1;
// Save the current exception, if any, we must preserve it.
PyObject *save_exception_type, *save_exception_value;
PyTracebackObject *save_exception_tb;
FETCH_ERROR_OCCURRED( &save_exception_type, &save_exception_value, &save_exception_tb );
if ( generator->m_status == status_Running )
{
PyObject *close_result = Nuitka_Generator_close( generator, NULL );
if (unlikely( close_result == NULL ))
{
PyErr_WriteUnraisable( (PyObject *)generator );
}
else
{
Py_DECREF( close_result );
}
}
Nuitka_Generator_release_closure( generator );
Py_XDECREF( generator->m_frame );
assert( Py_REFCNT( generator ) == 1 );
Py_REFCNT( generator ) = 0;
releaseFiber( &generator->m_yielder_context );
// Now it is safe to release references and memory for it.
Nuitka_GC_UnTrack( generator );
if ( generator->m_weakrefs != NULL )
{
PyObject_ClearWeakRefs( (PyObject *)generator );
assert( !ERROR_OCCURRED() );
}
Py_DECREF( generator->m_name );
#if PYTHON_VERSION >= 350
Py_DECREF( generator->m_qualname );
#endif
PyObject_GC_Del( generator );
RESTORE_ERROR_OCCURRED( save_exception_type, save_exception_value, save_exception_tb );
}
static void RAISE_GENERATOR_EXCEPTION( struct Nuitka_GeneratorObject *generator )
{
CHECK_OBJECT( generator->m_exception_type );
RESTORE_ERROR_OCCURRED(
generator->m_exception_type,
generator->m_exception_value,
generator->m_exception_tb
);
generator->m_exception_type = NULL;
generator->m_exception_value = NULL;
generator->m_exception_tb = NULL;
}
static void Nuitka_Frame_tp_dealloc( Nuitka_FrameObject *nuitka_frame )
{
#ifndef __NUITKA_NO_ASSERT__
// Save the current exception, if any, we must to not corrupt it.
PyObject *save_exception_type, *save_exception_value;
PyTracebackObject *save_exception_tb;
FETCH_ERROR_OCCURRED( &save_exception_type, &save_exception_value, &save_exception_tb );
RESTORE_ERROR_OCCURRED( save_exception_type, save_exception_value, save_exception_tb );
#endif
Nuitka_GC_UnTrack( nuitka_frame );
PyFrameObject *frame = &nuitka_frame->m_frame;
// locals
PyObject **valuestack = frame->f_valuestack;
for ( PyObject **p = frame->f_localsplus; p < valuestack; p++ )
{
Py_CLEAR( *p );
}
// stack if any
if ( frame->f_stacktop != NULL )
{
for ( PyObject **p = valuestack; p < frame->f_stacktop; p++ )
{
Py_XDECREF( *p );
}
}
Py_XDECREF( frame->f_back );
Py_DECREF( frame->f_builtins );
Py_DECREF( frame->f_globals );
Py_XDECREF( frame->f_locals );
Py_DECREF( frame->f_trace );
Py_XDECREF( frame->f_exc_type );
Py_XDECREF( frame->f_exc_value );
Py_XDECREF( frame->f_exc_traceback );
PyObject_GC_Del( nuitka_frame );
#ifndef __NUITKA_NO_ASSERT__
PyThreadState *tstate = PyThreadState_GET();
assert( tstate->curexc_type == save_exception_type );
assert( tstate->curexc_value == save_exception_value );
assert( (PyTracebackObject *)tstate->curexc_traceback == save_exception_tb );
#endif
}
NUITKA_MAY_BE_UNUSED static bool EXCEPTION_MATCH_GENERATOR( PyObject *exception_value )
{
CHECK_OBJECT( exception_value );
// We need to check the class.
if ( PyExceptionInstance_Check( exception_value ) )
{
exception_value = PyExceptionInstance_Class( exception_value );
}
// Lets be optimistic. If it matches, we would be wasting our time.
if ( exception_value == PyExc_GeneratorExit || exception_value == PyExc_StopIteration )
{
return true;
}
if ( PyExceptionClass_Check( exception_value ) )
{
// Save the current exception, if any, we must preserve it.
PyObject *save_exception_type, *save_exception_value;
PyTracebackObject *save_exception_tb;
FETCH_ERROR_OCCURRED( &save_exception_type, &save_exception_value, &save_exception_tb );
int res = PyObject_IsSubclass( exception_value, PyExc_GeneratorExit );
// This function must not fail, so print the error here */
if (unlikely( res == -1 ))
{
PyErr_WriteUnraisable( exception_value );
}
if (res == 1) return true;
res = PyObject_IsSubclass( exception_value, PyExc_StopIteration );
// This function must not fail, so print the error here */
if (unlikely( res == -1 ))
{
PyErr_WriteUnraisable( exception_value );
}
RESTORE_ERROR_OCCURRED( save_exception_type, save_exception_value, save_exception_tb );
return res == 1;
}
return false;
}
static void Nuitka_Method_tp_dealloc( struct Nuitka_MethodObject *method )
{
#ifndef __NUITKA_NO_ASSERT__
// Save the current exception, if any, we must to not corrupt it.
PyObject *save_exception_type, *save_exception_value;
PyTracebackObject *save_exception_tb;
FETCH_ERROR_OCCURRED( &save_exception_type, &save_exception_value, &save_exception_tb );
RESTORE_ERROR_OCCURRED( save_exception_type, save_exception_value, save_exception_tb );
#endif
Nuitka_GC_UnTrack( method );
if ( method->m_weakrefs != NULL )
{
PyObject_ClearWeakRefs( (PyObject *)method );
}
Py_XDECREF( method->m_object );
Py_XDECREF( method->m_class );
Py_DECREF( (PyObject *)method->m_function );
if (likely( method_cache_size < max_method_cache_size ))
{
method->m_object = (PyObject *)method_cache_head;
method_cache_head = method;
method_cache_size += 1;
}
else {
PyObject_GC_Del( method );
}
#ifndef __NUITKA_NO_ASSERT__
PyThreadState *tstate = PyThreadState_GET();
assert( tstate->curexc_type == save_exception_type );
assert( tstate->curexc_value == save_exception_value );
assert( (PyTracebackObject *)tstate->curexc_traceback == save_exception_tb );
#endif
}
static void Nuitka_Frame_tp_dealloc(struct Nuitka_FrameObject *nuitka_frame) {
#ifndef __NUITKA_NO_ASSERT__
// Save the current exception, if any, we must to not corrupt it.
PyObject *save_exception_type, *save_exception_value;
PyTracebackObject *save_exception_tb;
FETCH_ERROR_OCCURRED(&save_exception_type, &save_exception_value, &save_exception_tb);
RESTORE_ERROR_OCCURRED(save_exception_type, save_exception_value, save_exception_tb);
#endif
Nuitka_GC_UnTrack(nuitka_frame);
PyFrameObject *frame = &nuitka_frame->m_frame;
Py_XDECREF(frame->f_back);
Py_DECREF(frame->f_builtins);
Py_DECREF(frame->f_globals);
Py_XDECREF(frame->f_locals);
#if PYTHON_VERSION < 370
Py_XDECREF(frame->f_exc_type);
Py_XDECREF(frame->f_exc_value);
Py_XDECREF(frame->f_exc_traceback);
#endif
Nuitka_Frame_tp_clear(nuitka_frame);
releaseToFreeList(free_list_frames, nuitka_frame, MAX_FRAME_FREE_LIST_COUNT);
#ifndef __NUITKA_NO_ASSERT__
PyThreadState *tstate = PyThreadState_GET();
assert(tstate->curexc_type == save_exception_type);
assert(tstate->curexc_value == save_exception_value);
assert((PyTracebackObject *)tstate->curexc_traceback == save_exception_tb);
#endif
}
MOD_INIT_DECL( pip$_vendor$requests$packages$urllib3$packages )
{
#if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300
static bool _init_done = false;
// Modules might be imported repeatedly, which is to be ignored.
if ( _init_done )
{
return MOD_RETURN_VALUE( module_pip$_vendor$requests$packages$urllib3$packages );
}
else
{
_init_done = true;
}
#endif
#ifdef _NUITKA_MODULE
// In case of a stand alone extension module, need to call initialization
// the init here because that's the first and only time we are going to get
// called here.
// Initialize the constant values used.
_initBuiltinModule();
createGlobalConstants();
// Initialize the compiled types of Nuitka.
PyType_Ready( &Nuitka_Generator_Type );
PyType_Ready( &Nuitka_Function_Type );
PyType_Ready( &Nuitka_Method_Type );
PyType_Ready( &Nuitka_Frame_Type );
#if PYTHON_VERSION >= 350
PyType_Ready( &Nuitka_Coroutine_Type );
PyType_Ready( &Nuitka_CoroutineWrapper_Type );
#endif
#if PYTHON_VERSION < 300
_initSlotCompare();
#endif
#if PYTHON_VERSION >= 270
_initSlotIternext();
#endif
patchBuiltinModule();
patchTypeComparison();
// Enable meta path based loader if not already done.
setupMetaPathBasedLoader();
#if PYTHON_VERSION >= 300
patchInspectModule();
#endif
#endif
createModuleConstants();
createModuleCodeObjects();
// puts( "in initpip$_vendor$requests$packages$urllib3$packages" );
// Create the module object first. There are no methods initially, all are
// added dynamically in actual code only. Also no "__doc__" is initially
// set at this time, as it could not contain NUL characters this way, they
// are instead set in early module code. No "self" for modules, we have no
// use for it.
#if PYTHON_VERSION < 300
module_pip$_vendor$requests$packages$urllib3$packages = Py_InitModule4(
"pip._vendor.requests.packages.urllib3.packages", // Module Name
NULL, // No methods initially, all are added
// dynamically in actual module code only.
NULL, // No __doc__ is initially set, as it could
// not contain NUL this way, added early in
// actual code.
NULL, // No self for modules, we don't use it.
PYTHON_API_VERSION
);
#else
module_pip$_vendor$requests$packages$urllib3$packages = PyModule_Create( &mdef_pip$_vendor$requests$packages$urllib3$packages );
#endif
moduledict_pip$_vendor$requests$packages$urllib3$packages = (PyDictObject *)((PyModuleObject *)module_pip$_vendor$requests$packages$urllib3$packages)->md_dict;
CHECK_OBJECT( module_pip$_vendor$requests$packages$urllib3$packages );
// Seems to work for Python2.7 out of the box, but for Python3, the module
// doesn't automatically enter "sys.modules", so do it manually.
#if PYTHON_VERSION >= 300
{
int r = PyObject_SetItem( PySys_GetObject( (char *)"modules" ), const_str_digest_717e0aa5e359f200231896bcbab797ab, module_pip$_vendor$requests$packages$urllib3$packages );
assert( r != -1 );
}
#endif
// For deep importing of a module we need to have "__builtins__", so we set
// it ourselves in the same way than CPython does. Note: This must be done
// before the frame object is allocated, or else it may fail.
PyObject *module_dict = PyModule_GetDict( module_pip$_vendor$requests$packages$urllib3$packages );
if ( PyDict_GetItem( module_dict, const_str_plain___builtins__ ) == NULL )
{
PyObject *value = (PyObject *)builtin_module;
// Check if main module, not a dict then.
#if !defined(_NUITKA_EXE) || !0
value = PyModule_GetDict( value );
#endif
#ifndef __NUITKA_NO_ASSERT__
int res =
#endif
PyDict_SetItem( module_dict, const_str_plain___builtins__, value );
assert( res == 0 );
}
#if PYTHON_VERSION >= 330
PyDict_SetItem( module_dict, const_str_plain___loader__, metapath_based_loader );
#endif
// Temp variables if any
PyObject *exception_type = NULL, *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = -1;
PyObject *tmp_assign_source_1;
PyObject *tmp_assign_source_2;
PyObject *tmp_assign_source_3;
PyObject *tmp_assign_source_4;
PyObject *tmp_assign_source_5;
PyObject *tmp_assign_source_6;
PyObject *tmp_assign_source_7;
PyObject *tmp_assign_source_8;
PyObject *tmp_import_globals_1;
PyObject *tmp_import_name_from_1;
PyFrameObject *frame_module;
// Module code.
tmp_assign_source_1 = Py_None;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 );
tmp_assign_source_2 = const_str_digest_2fda06de9b427b74c9496097feae88ce;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 );
tmp_assign_source_3 = LIST_COPY( const_list_str_digest_d3e5a07139fdaf41b1ccc2e249a03040_list );
UPDATE_STRING_DICT1( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 );
tmp_assign_source_4 = Py_None;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_4 );
tmp_assign_source_5 = const_str_digest_717e0aa5e359f200231896bcbab797ab;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___package__, tmp_assign_source_5 );
tmp_assign_source_6 = PyObject_GetAttrString(PyImport_ImportModule("__future__"), "absolute_import");
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain_absolute_import, tmp_assign_source_6 );
// Frame without reuse.
frame_module = MAKE_MODULE_FRAME( codeobj_690c45c406de567b9656102a490ecf48, module_pip$_vendor$requests$packages$urllib3$packages );
// Push the new frame as the currently active one, and we should be exclusively
// owning it.
pushFrameStack( frame_module );
assert( Py_REFCNT( frame_module ) == 1 );
#if PYTHON_VERSION >= 340
frame_module->f_executing += 1;
#endif
// Framed code:
tmp_import_globals_1 = ((PyModuleObject *)module_pip$_vendor$requests$packages$urllib3$packages)->md_dict;
frame_module->f_lineno = 3;
tmp_import_name_from_1 = IMPORT_MODULE( const_str_empty, tmp_import_globals_1, tmp_import_globals_1, const_tuple_str_plain_ssl_match_hostname_tuple, const_int_pos_1 );
if ( tmp_import_name_from_1 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 3;
goto frame_exception_exit_1;
}
tmp_assign_source_7 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_ssl_match_hostname );
Py_DECREF( tmp_import_name_from_1 );
if ( tmp_assign_source_7 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 3;
goto frame_exception_exit_1;
}
UPDATE_STRING_DICT1( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain_ssl_match_hostname, tmp_assign_source_7 );
// Restore frame exception if necessary.
#if 0
RESTORE_FRAME_EXCEPTION( frame_module );
#endif
popFrameStack();
assertFrameObject( frame_module );
Py_DECREF( frame_module );
goto frame_no_exception_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION( frame_module );
#endif
if ( exception_tb == NULL )
{
exception_tb = MAKE_TRACEBACK( frame_module, exception_lineno );
}
else if ( exception_tb->tb_frame != frame_module )
{
PyTracebackObject *traceback_new = MAKE_TRACEBACK( frame_module, exception_lineno );
traceback_new->tb_next = exception_tb;
exception_tb = traceback_new;
}
// Put the previous frame back on top.
popFrameStack();
#if PYTHON_VERSION >= 340
frame_module->f_executing -= 1;
#endif
Py_DECREF( frame_module );
// Return the error.
goto module_exception_exit;
frame_no_exception_1:;
tmp_assign_source_8 = const_tuple_str_plain_ssl_match_hostname_tuple;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$packages$urllib3$packages, (Nuitka_StringObject *)const_str_plain___all__, tmp_assign_source_8 );
return MOD_RETURN_VALUE( module_pip$_vendor$requests$packages$urllib3$packages );
module_exception_exit:
RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb );
return MOD_RETURN_VALUE( NULL );
}
MOD_INIT_DECL( pip$_vendor$requests$status_codes )
{
#if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300
static bool _init_done = false;
// Modules might be imported repeatedly, which is to be ignored.
if ( _init_done )
{
return MOD_RETURN_VALUE( module_pip$_vendor$requests$status_codes );
}
else
{
_init_done = true;
}
#endif
#ifdef _NUITKA_MODULE
// In case of a stand alone extension module, need to call initialization
// the init here because that's the first and only time we are going to get
// called here.
// Initialize the constant values used.
_initBuiltinModule();
createGlobalConstants();
// Initialize the compiled types of Nuitka.
PyType_Ready( &Nuitka_Generator_Type );
PyType_Ready( &Nuitka_Function_Type );
PyType_Ready( &Nuitka_Method_Type );
PyType_Ready( &Nuitka_Frame_Type );
#if PYTHON_VERSION >= 350
PyType_Ready( &Nuitka_Coroutine_Type );
PyType_Ready( &Nuitka_CoroutineWrapper_Type );
#endif
#if PYTHON_VERSION < 300
_initSlotCompare();
#endif
#if PYTHON_VERSION >= 270
_initSlotIternext();
#endif
patchBuiltinModule();
patchTypeComparison();
// Enable meta path based loader if not already done.
setupMetaPathBasedLoader();
#if PYTHON_VERSION >= 300
patchInspectModule();
#endif
#endif
createModuleConstants();
createModuleCodeObjects();
// puts( "in initpip$_vendor$requests$status_codes" );
// Create the module object first. There are no methods initially, all are
// added dynamically in actual code only. Also no "__doc__" is initially
// set at this time, as it could not contain NUL characters this way, they
// are instead set in early module code. No "self" for modules, we have no
// use for it.
#if PYTHON_VERSION < 300
module_pip$_vendor$requests$status_codes = Py_InitModule4(
"pip._vendor.requests.status_codes", // Module Name
NULL, // No methods initially, all are added
// dynamically in actual module code only.
NULL, // No __doc__ is initially set, as it could
// not contain NUL this way, added early in
// actual code.
NULL, // No self for modules, we don't use it.
PYTHON_API_VERSION
);
#else
module_pip$_vendor$requests$status_codes = PyModule_Create( &mdef_pip$_vendor$requests$status_codes );
#endif
moduledict_pip$_vendor$requests$status_codes = (PyDictObject *)((PyModuleObject *)module_pip$_vendor$requests$status_codes)->md_dict;
CHECK_OBJECT( module_pip$_vendor$requests$status_codes );
// Seems to work for Python2.7 out of the box, but for Python3, the module
// doesn't automatically enter "sys.modules", so do it manually.
#if PYTHON_VERSION >= 300
{
int r = PyObject_SetItem( PySys_GetObject( (char *)"modules" ), const_str_digest_7407a472cb7f92da9dfbd02c8e685bfe, module_pip$_vendor$requests$status_codes );
assert( r != -1 );
}
#endif
// For deep importing of a module we need to have "__builtins__", so we set
// it ourselves in the same way than CPython does. Note: This must be done
// before the frame object is allocated, or else it may fail.
PyObject *module_dict = PyModule_GetDict( module_pip$_vendor$requests$status_codes );
if ( PyDict_GetItem( module_dict, const_str_plain___builtins__ ) == NULL )
{
PyObject *value = (PyObject *)builtin_module;
// Check if main module, not a dict then.
#if !defined(_NUITKA_EXE) || !0
value = PyModule_GetDict( value );
#endif
#ifndef __NUITKA_NO_ASSERT__
int res =
#endif
PyDict_SetItem( module_dict, const_str_plain___builtins__, value );
assert( res == 0 );
}
#if PYTHON_VERSION >= 330
PyDict_SetItem( module_dict, const_str_plain___loader__, metapath_based_loader );
#endif
// Temp variables if any
PyObject *tmp_for_loop_1__for_iterator = NULL;
PyObject *tmp_for_loop_1__iter_value = NULL;
PyObject *tmp_tuple_unpack_1__source_iter = NULL;
PyObject *tmp_tuple_unpack_1__element_1 = NULL;
PyObject *tmp_tuple_unpack_1__element_2 = NULL;
PyObject *tmp_for_loop_2__for_iterator = NULL;
PyObject *tmp_for_loop_2__iter_value = NULL;
PyObject *exception_type = NULL, *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = -1;
PyObject *exception_keeper_type_1;
PyObject *exception_keeper_value_1;
PyTracebackObject *exception_keeper_tb_1;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
PyObject *exception_keeper_type_2;
PyObject *exception_keeper_value_2;
PyTracebackObject *exception_keeper_tb_2;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2;
PyObject *exception_keeper_type_3;
PyObject *exception_keeper_value_3;
PyTracebackObject *exception_keeper_tb_3;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3;
PyObject *tmp_assign_source_1;
PyObject *tmp_assign_source_2;
PyObject *tmp_assign_source_3;
PyObject *tmp_assign_source_4;
PyObject *tmp_assign_source_5;
PyObject *tmp_assign_source_6;
PyObject *tmp_assign_source_7;
PyObject *tmp_assign_source_8;
PyObject *tmp_assign_source_9;
PyObject *tmp_assign_source_10;
PyObject *tmp_assign_source_11;
PyObject *tmp_assign_source_12;
PyObject *tmp_assign_source_13;
PyObject *tmp_assign_source_14;
PyObject *tmp_assign_source_15;
PyObject *tmp_assign_source_16;
PyObject *tmp_assign_source_17;
PyObject *tmp_called_name_1;
PyObject *tmp_called_name_2;
PyObject *tmp_called_name_3;
PyObject *tmp_called_name_4;
int tmp_cond_truth_1;
PyObject *tmp_cond_value_1;
PyObject *tmp_import_globals_1;
PyObject *tmp_import_name_from_1;
PyObject *tmp_iter_arg_1;
PyObject *tmp_iter_arg_2;
PyObject *tmp_iter_arg_3;
PyObject *tmp_iterator_attempt;
PyObject *tmp_iterator_name_1;
PyObject *tmp_kw_name_1;
PyObject *tmp_next_source_1;
PyObject *tmp_next_source_2;
PyObject *tmp_setattr_attr_1;
PyObject *tmp_setattr_attr_2;
PyObject *tmp_setattr_target_1;
PyObject *tmp_setattr_target_2;
PyObject *tmp_setattr_value_1;
PyObject *tmp_setattr_value_2;
PyObject *tmp_source_name_1;
PyObject *tmp_source_name_2;
PyObject *tmp_source_name_3;
PyObject *tmp_unpack_1;
PyObject *tmp_unpack_2;
NUITKA_MAY_BE_UNUSED PyObject *tmp_unused;
PyFrameObject *frame_module;
// Module code.
tmp_assign_source_1 = Py_None;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 );
tmp_assign_source_2 = const_str_digest_edc503ce8640402b515eac9b4be2e49c;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 );
tmp_assign_source_3 = Py_None;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 );
tmp_assign_source_4 = const_str_digest_92068ee7fa29014ac06ffc664a1b4b4e;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain___package__, tmp_assign_source_4 );
// Frame without reuse.
frame_module = MAKE_MODULE_FRAME( codeobj_fc398c3ce42402f17822919035abca66, module_pip$_vendor$requests$status_codes );
// Push the new frame as the currently active one, and we should be exclusively
// owning it.
pushFrameStack( frame_module );
assert( Py_REFCNT( frame_module ) == 1 );
#if PYTHON_VERSION >= 340
frame_module->f_executing += 1;
#endif
// Framed code:
tmp_import_globals_1 = ((PyModuleObject *)module_pip$_vendor$requests$status_codes)->md_dict;
frame_module->f_lineno = 3;
tmp_import_name_from_1 = IMPORT_MODULE( const_str_plain_structures, tmp_import_globals_1, tmp_import_globals_1, const_tuple_str_plain_LookupDict_tuple, const_int_pos_1 );
if ( tmp_import_name_from_1 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 3;
goto frame_exception_exit_1;
}
tmp_assign_source_5 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_LookupDict );
Py_DECREF( tmp_import_name_from_1 );
if ( tmp_assign_source_5 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 3;
goto frame_exception_exit_1;
}
UPDATE_STRING_DICT1( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_LookupDict, tmp_assign_source_5 );
tmp_assign_source_6 = PyDict_Copy( const_dict_19730b058f28080932defca1165e072e );
UPDATE_STRING_DICT1( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain__codes, tmp_assign_source_6 );
tmp_called_name_1 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_LookupDict );
if (unlikely( tmp_called_name_1 == NULL ))
{
tmp_called_name_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_LookupDict );
}
if ( tmp_called_name_1 == NULL )
{
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "LookupDict" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 84;
goto frame_exception_exit_1;
}
tmp_kw_name_1 = PyDict_Copy( const_dict_38252060f20256dc080a28c7e1fb8512 );
frame_module->f_lineno = 84;
tmp_assign_source_7 = CALL_FUNCTION_WITH_KEYARGS( tmp_called_name_1, tmp_kw_name_1 );
Py_DECREF( tmp_kw_name_1 );
if ( tmp_assign_source_7 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 84;
goto frame_exception_exit_1;
}
UPDATE_STRING_DICT1( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_codes, tmp_assign_source_7 );
tmp_source_name_1 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain__codes );
if (unlikely( tmp_source_name_1 == NULL ))
{
tmp_source_name_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__codes );
}
if ( tmp_source_name_1 == NULL )
{
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_codes" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 86;
goto frame_exception_exit_1;
}
tmp_called_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_items );
if ( tmp_called_name_2 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 86;
goto frame_exception_exit_1;
}
frame_module->f_lineno = 86;
tmp_iter_arg_1 = CALL_FUNCTION_NO_ARGS( tmp_called_name_2 );
Py_DECREF( tmp_called_name_2 );
if ( tmp_iter_arg_1 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 86;
goto frame_exception_exit_1;
}
tmp_assign_source_8 = MAKE_ITERATOR( tmp_iter_arg_1 );
Py_DECREF( tmp_iter_arg_1 );
if ( tmp_assign_source_8 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 86;
goto frame_exception_exit_1;
}
assert( tmp_for_loop_1__for_iterator == NULL );
tmp_for_loop_1__for_iterator = tmp_assign_source_8;
// Tried code:
loop_start_1:;
tmp_next_source_1 = tmp_for_loop_1__for_iterator;
tmp_assign_source_9 = ITERATOR_NEXT( tmp_next_source_1 );
if ( tmp_assign_source_9 == NULL )
{
if ( CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED() )
{
goto loop_end_1;
}
else
{
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
frame_module->f_lineno = 86;
goto try_except_handler_1;
}
}
{
PyObject *old = tmp_for_loop_1__iter_value;
tmp_for_loop_1__iter_value = tmp_assign_source_9;
Py_XDECREF( old );
}
// Tried code:
tmp_iter_arg_2 = tmp_for_loop_1__iter_value;
tmp_assign_source_10 = MAKE_ITERATOR( tmp_iter_arg_2 );
if ( tmp_assign_source_10 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 86;
goto try_except_handler_2;
}
{
PyObject *old = tmp_tuple_unpack_1__source_iter;
tmp_tuple_unpack_1__source_iter = tmp_assign_source_10;
Py_XDECREF( old );
}
tmp_unpack_1 = tmp_tuple_unpack_1__source_iter;
tmp_assign_source_11 = UNPACK_NEXT( tmp_unpack_1, 0, 2 );
if ( tmp_assign_source_11 == NULL )
{
if ( !ERROR_OCCURRED() )
{
exception_type = PyExc_StopIteration;
Py_INCREF( exception_type );
exception_value = NULL;
exception_tb = NULL;
}
else
{
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
}
exception_lineno = 86;
goto try_except_handler_2;
}
{
PyObject *old = tmp_tuple_unpack_1__element_1;
tmp_tuple_unpack_1__element_1 = tmp_assign_source_11;
Py_XDECREF( old );
}
tmp_unpack_2 = tmp_tuple_unpack_1__source_iter;
tmp_assign_source_12 = UNPACK_NEXT( tmp_unpack_2, 1, 2 );
if ( tmp_assign_source_12 == NULL )
{
if ( !ERROR_OCCURRED() )
{
exception_type = PyExc_StopIteration;
Py_INCREF( exception_type );
exception_value = NULL;
exception_tb = NULL;
}
else
{
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
}
exception_lineno = 86;
goto try_except_handler_2;
}
{
PyObject *old = tmp_tuple_unpack_1__element_2;
tmp_tuple_unpack_1__element_2 = tmp_assign_source_12;
Py_XDECREF( old );
}
tmp_iterator_name_1 = tmp_tuple_unpack_1__source_iter;
// Check if iterator has left-over elements.
CHECK_OBJECT( tmp_iterator_name_1 ); assert( HAS_ITERNEXT( tmp_iterator_name_1 ) );
tmp_iterator_attempt = (*Py_TYPE( tmp_iterator_name_1 )->tp_iternext)( tmp_iterator_name_1 );
if (likely( tmp_iterator_attempt == NULL ))
{
PyObject *error = GET_ERROR_OCCURRED();
if ( error != NULL )
{
if ( EXCEPTION_MATCH_BOOL_SINGLE( error, PyExc_StopIteration ))
{
CLEAR_ERROR_OCCURRED();
}
else
{
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
goto try_except_handler_2;
}
}
}
else
{
Py_DECREF( tmp_iterator_attempt );
// TODO: Could avoid PyErr_Format.
#if PYTHON_VERSION < 300
PyErr_Format( PyExc_ValueError, "too many values to unpack" );
#else
PyErr_Format( PyExc_ValueError, "too many values to unpack (expected 2)" );
#endif
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
goto try_except_handler_2;
}
goto try_end_1;
// Exception handler code:
try_except_handler_2:;
exception_keeper_type_1 = exception_type;
exception_keeper_value_1 = exception_value;
exception_keeper_tb_1 = exception_tb;
exception_keeper_lineno_1 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = -1;
Py_XDECREF( tmp_tuple_unpack_1__source_iter );
tmp_tuple_unpack_1__source_iter = NULL;
Py_XDECREF( tmp_tuple_unpack_1__element_1 );
tmp_tuple_unpack_1__element_1 = NULL;
Py_XDECREF( tmp_tuple_unpack_1__element_2 );
tmp_tuple_unpack_1__element_2 = NULL;
// Re-raise.
exception_type = exception_keeper_type_1;
exception_value = exception_keeper_value_1;
exception_tb = exception_keeper_tb_1;
exception_lineno = exception_keeper_lineno_1;
goto try_except_handler_1;
// End of try:
try_end_1:;
tmp_assign_source_13 = tmp_tuple_unpack_1__element_1;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_code, tmp_assign_source_13 );
tmp_assign_source_14 = tmp_tuple_unpack_1__element_2;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_titles, tmp_assign_source_14 );
CHECK_OBJECT( (PyObject *)tmp_tuple_unpack_1__source_iter );
Py_DECREF( tmp_tuple_unpack_1__source_iter );
tmp_tuple_unpack_1__source_iter = NULL;
Py_XDECREF( tmp_tuple_unpack_1__element_1 );
tmp_tuple_unpack_1__element_1 = NULL;
Py_XDECREF( tmp_tuple_unpack_1__element_2 );
tmp_tuple_unpack_1__element_2 = NULL;
tmp_iter_arg_3 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_titles );
if (unlikely( tmp_iter_arg_3 == NULL ))
{
tmp_iter_arg_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_titles );
}
if ( tmp_iter_arg_3 == NULL )
{
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "titles" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 87;
goto try_except_handler_1;
}
tmp_assign_source_15 = MAKE_ITERATOR( tmp_iter_arg_3 );
if ( tmp_assign_source_15 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 87;
goto try_except_handler_1;
}
{
PyObject *old = tmp_for_loop_2__for_iterator;
tmp_for_loop_2__for_iterator = tmp_assign_source_15;
Py_XDECREF( old );
}
// Tried code:
loop_start_2:;
tmp_next_source_2 = tmp_for_loop_2__for_iterator;
tmp_assign_source_16 = ITERATOR_NEXT( tmp_next_source_2 );
if ( tmp_assign_source_16 == NULL )
{
if ( CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED() )
{
goto loop_end_2;
}
else
{
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
frame_module->f_lineno = 87;
goto try_except_handler_3;
}
}
{
PyObject *old = tmp_for_loop_2__iter_value;
tmp_for_loop_2__iter_value = tmp_assign_source_16;
Py_XDECREF( old );
}
tmp_assign_source_17 = tmp_for_loop_2__iter_value;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_title, tmp_assign_source_17 );
tmp_setattr_target_1 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_codes );
if (unlikely( tmp_setattr_target_1 == NULL ))
{
tmp_setattr_target_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_codes );
}
if ( tmp_setattr_target_1 == NULL )
{
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "codes" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 88;
goto try_except_handler_3;
}
tmp_setattr_attr_1 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_title );
if (unlikely( tmp_setattr_attr_1 == NULL ))
{
tmp_setattr_attr_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_title );
}
if ( tmp_setattr_attr_1 == NULL )
{
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "title" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 88;
goto try_except_handler_3;
}
tmp_setattr_value_1 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_code );
if (unlikely( tmp_setattr_value_1 == NULL ))
{
tmp_setattr_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_code );
}
if ( tmp_setattr_value_1 == NULL )
{
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "code" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 88;
goto try_except_handler_3;
}
tmp_unused = BUILTIN_SETATTR( tmp_setattr_target_1, tmp_setattr_attr_1, tmp_setattr_value_1 );
if ( tmp_unused == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 88;
goto try_except_handler_3;
}
tmp_source_name_2 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_title );
if (unlikely( tmp_source_name_2 == NULL ))
{
tmp_source_name_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_title );
}
if ( tmp_source_name_2 == NULL )
{
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "title" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 89;
goto try_except_handler_3;
}
tmp_called_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_startswith );
if ( tmp_called_name_3 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 89;
goto try_except_handler_3;
}
frame_module->f_lineno = 89;
tmp_cond_value_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_3, &PyTuple_GET_ITEM( const_tuple_str_chr_92_tuple, 0 ) );
Py_DECREF( tmp_called_name_3 );
if ( tmp_cond_value_1 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 89;
goto try_except_handler_3;
}
tmp_cond_truth_1 = CHECK_IF_TRUE( tmp_cond_value_1 );
if ( tmp_cond_truth_1 == -1 )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
Py_DECREF( tmp_cond_value_1 );
exception_lineno = 89;
goto try_except_handler_3;
}
Py_DECREF( tmp_cond_value_1 );
if ( tmp_cond_truth_1 == 1 )
{
goto branch_no_1;
}
else
{
goto branch_yes_1;
}
branch_yes_1:;
tmp_setattr_target_2 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_codes );
if (unlikely( tmp_setattr_target_2 == NULL ))
{
tmp_setattr_target_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_codes );
}
if ( tmp_setattr_target_2 == NULL )
{
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "codes" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 90;
goto try_except_handler_3;
}
tmp_source_name_3 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_title );
if (unlikely( tmp_source_name_3 == NULL ))
{
tmp_source_name_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_title );
}
if ( tmp_source_name_3 == NULL )
{
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "title" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 90;
goto try_except_handler_3;
}
tmp_called_name_4 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_upper );
if ( tmp_called_name_4 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 90;
goto try_except_handler_3;
}
frame_module->f_lineno = 90;
tmp_setattr_attr_2 = CALL_FUNCTION_NO_ARGS( tmp_called_name_4 );
Py_DECREF( tmp_called_name_4 );
if ( tmp_setattr_attr_2 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 90;
goto try_except_handler_3;
}
tmp_setattr_value_2 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$requests$status_codes, (Nuitka_StringObject *)const_str_plain_code );
if (unlikely( tmp_setattr_value_2 == NULL ))
{
tmp_setattr_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_code );
}
if ( tmp_setattr_value_2 == NULL )
{
Py_DECREF( tmp_setattr_attr_2 );
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "code" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 90;
goto try_except_handler_3;
}
tmp_unused = BUILTIN_SETATTR( tmp_setattr_target_2, tmp_setattr_attr_2, tmp_setattr_value_2 );
Py_DECREF( tmp_setattr_attr_2 );
if ( tmp_unused == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 90;
goto try_except_handler_3;
}
branch_no_1:;
if ( CONSIDER_THREADING() == false )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 87;
goto try_except_handler_3;
}
goto loop_start_2;
loop_end_2:;
goto try_end_2;
// Exception handler code:
try_except_handler_3:;
exception_keeper_type_2 = exception_type;
exception_keeper_value_2 = exception_value;
exception_keeper_tb_2 = exception_tb;
exception_keeper_lineno_2 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = -1;
Py_XDECREF( tmp_for_loop_2__iter_value );
tmp_for_loop_2__iter_value = NULL;
Py_XDECREF( tmp_for_loop_2__for_iterator );
tmp_for_loop_2__for_iterator = NULL;
// Re-raise.
exception_type = exception_keeper_type_2;
exception_value = exception_keeper_value_2;
exception_tb = exception_keeper_tb_2;
exception_lineno = exception_keeper_lineno_2;
goto try_except_handler_1;
// End of try:
try_end_2:;
Py_XDECREF( tmp_for_loop_2__iter_value );
tmp_for_loop_2__iter_value = NULL;
Py_XDECREF( tmp_for_loop_2__for_iterator );
tmp_for_loop_2__for_iterator = NULL;
if ( CONSIDER_THREADING() == false )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 86;
goto try_except_handler_1;
}
goto loop_start_1;
loop_end_1:;
goto try_end_3;
// Exception handler code:
try_except_handler_1:;
exception_keeper_type_3 = exception_type;
exception_keeper_value_3 = exception_value;
exception_keeper_tb_3 = exception_tb;
exception_keeper_lineno_3 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = -1;
Py_XDECREF( tmp_for_loop_1__iter_value );
tmp_for_loop_1__iter_value = NULL;
Py_XDECREF( tmp_for_loop_1__for_iterator );
tmp_for_loop_1__for_iterator = NULL;
// Re-raise.
exception_type = exception_keeper_type_3;
exception_value = exception_keeper_value_3;
exception_tb = exception_keeper_tb_3;
exception_lineno = exception_keeper_lineno_3;
goto frame_exception_exit_1;
// End of try:
try_end_3:;
// Restore frame exception if necessary.
#if 0
RESTORE_FRAME_EXCEPTION( frame_module );
#endif
popFrameStack();
assertFrameObject( frame_module );
Py_DECREF( frame_module );
goto frame_no_exception_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION( frame_module );
#endif
if ( exception_tb == NULL )
{
exception_tb = MAKE_TRACEBACK( frame_module, exception_lineno );
}
else if ( exception_tb->tb_frame != frame_module )
{
PyTracebackObject *traceback_new = MAKE_TRACEBACK( frame_module, exception_lineno );
traceback_new->tb_next = exception_tb;
exception_tb = traceback_new;
}
// Put the previous frame back on top.
popFrameStack();
#if PYTHON_VERSION >= 340
frame_module->f_executing -= 1;
#endif
Py_DECREF( frame_module );
// Return the error.
goto module_exception_exit;
frame_no_exception_1:;
Py_XDECREF( tmp_for_loop_1__iter_value );
tmp_for_loop_1__iter_value = NULL;
Py_XDECREF( tmp_for_loop_1__for_iterator );
tmp_for_loop_1__for_iterator = NULL;
return MOD_RETURN_VALUE( module_pip$_vendor$requests$status_codes );
module_exception_exit:
RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb );
return MOD_RETURN_VALUE( NULL );
}
static PyObject *Nuitka_Generator_send( struct Nuitka_GeneratorObject *generator, PyObject *value )
{
if ( generator->m_status == status_Unused && value != NULL && value != Py_None )
{
PyErr_Format( PyExc_TypeError, "can't send non-None value to a just-started generator" );
return NULL;
}
if ( generator->m_status != status_Finished )
{
PyThreadState *thread_state = PyThreadState_GET();
#if PYTHON_VERSION < 300
PyObject *saved_exception_type = thread_state->exc_type;
Py_XINCREF( saved_exception_type );
PyObject *saved_exception_value = thread_state->exc_value;
Py_XINCREF( saved_exception_value );
PyTracebackObject *saved_exception_traceback = (PyTracebackObject *)thread_state->exc_traceback;
Py_XINCREF( saved_exception_traceback );
#endif
if ( generator->m_running )
{
PyErr_Format( PyExc_ValueError, "generator already executing" );
return NULL;
}
if ( generator->m_status == status_Unused )
{
// Prepare the generator context to run.
int res = prepareFiber( &generator->m_yielder_context, (void *)Nuitka_Generator_entry_point, (uintptr_t)generator );
if ( res != 0 )
{
PyErr_Format( PyExc_MemoryError, "generator cannot be allocated" );
return NULL;
}
generator->m_status = status_Running;
}
generator->m_yielded = value;
// Put the generator back on the frame stack.
PyFrameObject *return_frame = thread_state->frame;
#ifndef __NUITKA_NO_ASSERT__
if ( return_frame )
{
assertFrameObject( return_frame );
}
#endif
if ( generator->m_frame )
{
// It would be nice if our frame were still alive. Nobody had the
// right to release it.
assertFrameObject( generator->m_frame );
// It's not supposed to be on the top right now.
assert( return_frame != generator->m_frame );
Py_XINCREF( return_frame );
generator->m_frame->f_back = return_frame;
thread_state->frame = generator->m_frame;
}
// Continue the yielder function while preventing recursion.
generator->m_running = true;
swapFiber( &generator->m_caller_context, &generator->m_yielder_context );
generator->m_running = false;
thread_state = PyThreadState_GET();
// Remove the generator from the frame stack.
if ( generator->m_frame )
{
assert( thread_state->frame == generator->m_frame );
assertFrameObject( generator->m_frame );
Py_CLEAR( generator->m_frame->f_back );
}
thread_state->frame = return_frame;
if ( generator->m_yielded == NULL )
{
assert( ERROR_OCCURRED() );
generator->m_status = status_Finished;
Py_XDECREF( generator->m_frame );
generator->m_frame = NULL;
Nuitka_Generator_release_closure( generator );
assert( ERROR_OCCURRED() );
#if PYTHON_VERSION < 300
Py_XDECREF( saved_exception_type );
Py_XDECREF( saved_exception_value );
Py_XDECREF( saved_exception_traceback );
#endif
#if PYTHON_VERSION >= 350
if ( generator->m_code_object->co_flags & CO_FUTURE_GENERATOR_STOP &&
GET_ERROR_OCCURRED() == PyExc_StopIteration )
{
PyObject *saved_exception_type, *saved_exception_value;
PyTracebackObject *saved_exception_tb;
FETCH_ERROR_OCCURRED( &saved_exception_type, &saved_exception_value, &saved_exception_tb );
NORMALIZE_EXCEPTION( &saved_exception_type, &saved_exception_value, &saved_exception_tb );
PyErr_Format(
PyExc_RuntimeError,
"generator raised StopIteration"
);
PyObject *exception_type, *exception_value;
PyTracebackObject *exception_tb;
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
RAISE_EXCEPTION_WITH_CAUSE(
&exception_type,
&exception_value,
&exception_tb,
saved_exception_value
);
CHECK_OBJECT( exception_value );
CHECK_OBJECT( saved_exception_value );
Py_INCREF( saved_exception_value );
PyException_SetContext( exception_value, saved_exception_value );
Py_DECREF( saved_exception_type );
Py_XDECREF( saved_exception_tb );
RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb );
}
#endif
return NULL;
}
else
{
#if PYTHON_VERSION < 300
SET_CURRENT_EXCEPTION( saved_exception_type, saved_exception_value, saved_exception_traceback );
#endif
return generator->m_yielded;
}
}
else
{
PyErr_SetObject( PyExc_StopIteration, (PyObject *)NULL );
return NULL;
}
}
static PyObject *Nuitka_Generator_throw( struct Nuitka_GeneratorObject *generator, PyObject *args )
{
assert( generator->m_exception_type == NULL );
assert( generator->m_exception_value == NULL );
assert( 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 (unlikely( res == 0 ))
{
generator->m_exception_type = NULL;
generator->m_exception_value = NULL;
generator->m_exception_tb = NULL;
return NULL;
}
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 ) )
{
generator->m_exception_type = NULL;
generator->m_exception_value = NULL;
generator->m_exception_tb = NULL;
PyErr_Format( PyExc_TypeError, "throw() third argument must be a traceback object" );
return NULL;
}
if ( PyExceptionClass_Check( generator->m_exception_type ))
{
Py_INCREF( generator->m_exception_type );
Py_XINCREF( generator->m_exception_value );
Py_XINCREF( generator->m_exception_tb );
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 )
{
generator->m_exception_type = NULL;
generator->m_exception_value = NULL;
generator->m_exception_tb = NULL;
PyErr_Format( PyExc_TypeError, "instance exception may not have a separate value" );
return NULL;
}
generator->m_exception_value = generator->m_exception_type;
Py_INCREF( generator->m_exception_value );
generator->m_exception_type = PyExceptionInstance_Class( generator->m_exception_type );
Py_INCREF( generator->m_exception_type );
Py_XINCREF( generator->m_exception_tb );
}
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
);
generator->m_exception_type = NULL;
generator->m_exception_value = NULL;
generator->m_exception_tb = NULL;
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;
}
if ( generator->m_status != status_Finished )
{
PyObject *result = Nuitka_Generator_send( generator, Py_None );
return result;
}
else
{
RESTORE_ERROR_OCCURRED( generator->m_exception_type, generator->m_exception_value, generator->m_exception_tb );
generator->m_exception_type = NULL;
generator->m_exception_value = NULL;
generator->m_exception_tb = NULL;
return NULL;
}
}
MOD_INIT_DECL( pip$_vendor$cachecontrol$wrapper )
{
#if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300
static bool _init_done = false;
// Modules might be imported repeatedly, which is to be ignored.
if ( _init_done )
{
return MOD_RETURN_VALUE( module_pip$_vendor$cachecontrol$wrapper );
}
else
{
_init_done = true;
}
#endif
#ifdef _NUITKA_MODULE
// In case of a stand alone extension module, need to call initialization
// the init here because that's the first and only time we are going to get
// called here.
// Initialize the constant values used.
_initBuiltinModule();
createGlobalConstants();
// Initialize the compiled types of Nuitka.
PyType_Ready( &Nuitka_Generator_Type );
PyType_Ready( &Nuitka_Function_Type );
PyType_Ready( &Nuitka_Method_Type );
PyType_Ready( &Nuitka_Frame_Type );
#if PYTHON_VERSION >= 350
PyType_Ready( &Nuitka_Coroutine_Type );
PyType_Ready( &Nuitka_CoroutineWrapper_Type );
#endif
#if PYTHON_VERSION < 300
_initSlotCompare();
#endif
#if PYTHON_VERSION >= 270
_initSlotIternext();
#endif
patchBuiltinModule();
patchTypeComparison();
// Enable meta path based loader if not already done.
setupMetaPathBasedLoader();
#if PYTHON_VERSION >= 300
patchInspectModule();
#endif
#endif
createModuleConstants();
createModuleCodeObjects();
// puts( "in initpip$_vendor$cachecontrol$wrapper" );
// Create the module object first. There are no methods initially, all are
// added dynamically in actual code only. Also no "__doc__" is initially
// set at this time, as it could not contain NUL characters this way, they
// are instead set in early module code. No "self" for modules, we have no
// use for it.
#if PYTHON_VERSION < 300
module_pip$_vendor$cachecontrol$wrapper = Py_InitModule4(
"pip._vendor.cachecontrol.wrapper", // Module Name
NULL, // No methods initially, all are added
// dynamically in actual module code only.
NULL, // No __doc__ is initially set, as it could
// not contain NUL this way, added early in
// actual code.
NULL, // No self for modules, we don't use it.
PYTHON_API_VERSION
);
#else
module_pip$_vendor$cachecontrol$wrapper = PyModule_Create( &mdef_pip$_vendor$cachecontrol$wrapper );
#endif
moduledict_pip$_vendor$cachecontrol$wrapper = (PyDictObject *)((PyModuleObject *)module_pip$_vendor$cachecontrol$wrapper)->md_dict;
CHECK_OBJECT( module_pip$_vendor$cachecontrol$wrapper );
// Seems to work for Python2.7 out of the box, but for Python3, the module
// doesn't automatically enter "sys.modules", so do it manually.
#if PYTHON_VERSION >= 300
{
int r = PyObject_SetItem( PySys_GetObject( (char *)"modules" ), const_str_digest_752ad0551f1bf40ca5b6a8cda161ccf4, module_pip$_vendor$cachecontrol$wrapper );
assert( r != -1 );
}
#endif
// For deep importing of a module we need to have "__builtins__", so we set
// it ourselves in the same way than CPython does. Note: This must be done
// before the frame object is allocated, or else it may fail.
PyObject *module_dict = PyModule_GetDict( module_pip$_vendor$cachecontrol$wrapper );
if ( PyDict_GetItem( module_dict, const_str_plain___builtins__ ) == NULL )
{
PyObject *value = (PyObject *)builtin_module;
// Check if main module, not a dict then.
#if !defined(_NUITKA_EXE) || !0
value = PyModule_GetDict( value );
#endif
#ifndef __NUITKA_NO_ASSERT__
int res =
#endif
PyDict_SetItem( module_dict, const_str_plain___builtins__, value );
assert( res == 0 );
}
#if PYTHON_VERSION >= 330
PyDict_SetItem( module_dict, const_str_plain___loader__, metapath_based_loader );
#endif
// Temp variables if any
PyObject *exception_type = NULL, *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = -1;
PyObject *tmp_assign_source_1;
PyObject *tmp_assign_source_2;
PyObject *tmp_assign_source_3;
PyObject *tmp_assign_source_4;
PyObject *tmp_assign_source_5;
PyObject *tmp_assign_source_6;
PyObject *tmp_assign_source_7;
PyObject *tmp_defaults_1;
PyObject *tmp_import_globals_1;
PyObject *tmp_import_globals_2;
PyObject *tmp_import_name_from_1;
PyObject *tmp_import_name_from_2;
PyFrameObject *frame_module;
// Module code.
tmp_assign_source_1 = Py_None;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$cachecontrol$wrapper, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 );
tmp_assign_source_2 = const_str_digest_b31e0a7d9885533032515f63a652cb9c;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$cachecontrol$wrapper, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 );
tmp_assign_source_3 = Py_None;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$cachecontrol$wrapper, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 );
tmp_assign_source_4 = const_str_digest_cf6ad67e1fcab184ae3b2b70b1bd41c1;
UPDATE_STRING_DICT0( moduledict_pip$_vendor$cachecontrol$wrapper, (Nuitka_StringObject *)const_str_plain___package__, tmp_assign_source_4 );
// Frame without reuse.
frame_module = MAKE_MODULE_FRAME( codeobj_22e6269ebd4aca7f4dc21ac4b8656728, module_pip$_vendor$cachecontrol$wrapper );
// Push the new frame as the currently active one, and we should be exclusively
// owning it.
pushFrameStack( frame_module );
assert( Py_REFCNT( frame_module ) == 1 );
#if PYTHON_VERSION >= 340
frame_module->f_executing += 1;
#endif
// Framed code:
tmp_import_globals_1 = ((PyModuleObject *)module_pip$_vendor$cachecontrol$wrapper)->md_dict;
frame_module->f_lineno = 1;
tmp_import_name_from_1 = IMPORT_MODULE( const_str_plain_adapter, tmp_import_globals_1, tmp_import_globals_1, const_tuple_str_plain_CacheControlAdapter_tuple, const_int_pos_1 );
if ( tmp_import_name_from_1 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 1;
goto frame_exception_exit_1;
}
tmp_assign_source_5 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_CacheControlAdapter );
Py_DECREF( tmp_import_name_from_1 );
if ( tmp_assign_source_5 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 1;
goto frame_exception_exit_1;
}
UPDATE_STRING_DICT1( moduledict_pip$_vendor$cachecontrol$wrapper, (Nuitka_StringObject *)const_str_plain_CacheControlAdapter, tmp_assign_source_5 );
tmp_import_globals_2 = ((PyModuleObject *)module_pip$_vendor$cachecontrol$wrapper)->md_dict;
frame_module->f_lineno = 2;
tmp_import_name_from_2 = IMPORT_MODULE( const_str_plain_cache, tmp_import_globals_2, tmp_import_globals_2, const_tuple_str_plain_DictCache_tuple, const_int_pos_1 );
if ( tmp_import_name_from_2 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 2;
goto frame_exception_exit_1;
}
tmp_assign_source_6 = IMPORT_NAME( tmp_import_name_from_2, const_str_plain_DictCache );
Py_DECREF( tmp_import_name_from_2 );
if ( tmp_assign_source_6 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 2;
goto frame_exception_exit_1;
}
UPDATE_STRING_DICT1( moduledict_pip$_vendor$cachecontrol$wrapper, (Nuitka_StringObject *)const_str_plain_DictCache, tmp_assign_source_6 );
// Restore frame exception if necessary.
#if 0
RESTORE_FRAME_EXCEPTION( frame_module );
#endif
popFrameStack();
assertFrameObject( frame_module );
Py_DECREF( frame_module );
goto frame_no_exception_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION( frame_module );
#endif
if ( exception_tb == NULL )
{
exception_tb = MAKE_TRACEBACK( frame_module, exception_lineno );
}
else if ( exception_tb->tb_frame != frame_module )
{
PyTracebackObject *traceback_new = MAKE_TRACEBACK( frame_module, exception_lineno );
traceback_new->tb_next = exception_tb;
exception_tb = traceback_new;
}
// Put the previous frame back on top.
popFrameStack();
#if PYTHON_VERSION >= 340
frame_module->f_executing -= 1;
#endif
Py_DECREF( frame_module );
// Return the error.
goto module_exception_exit;
frame_no_exception_1:;
tmp_defaults_1 = const_tuple_none_true_none_none_tuple;
tmp_assign_source_7 = MAKE_FUNCTION_function_1_CacheControl_of_pip$_vendor$cachecontrol$wrapper( INCREASE_REFCOUNT( tmp_defaults_1 ) );
UPDATE_STRING_DICT1( moduledict_pip$_vendor$cachecontrol$wrapper, (Nuitka_StringObject *)const_str_plain_CacheControl, tmp_assign_source_7 );
return MOD_RETURN_VALUE( module_pip$_vendor$cachecontrol$wrapper );
module_exception_exit:
RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb );
return MOD_RETURN_VALUE( NULL );
}
// The module function definitions.
static PyObject *impl_function_1_CacheControl_of_pip$_vendor$cachecontrol$wrapper( Nuitka_FunctionObject const *self, PyObject **python_pars )
{
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
PyObject *par_sess = python_pars[ 0 ];
PyObject *par_cache = python_pars[ 1 ];
PyObject *par_cache_etags = python_pars[ 2 ];
PyObject *par_serializer = python_pars[ 3 ];
PyObject *par_heuristic = python_pars[ 4 ];
PyObject *var_adapter = NULL;
PyObject *exception_type = NULL, *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = -1;
PyObject *exception_keeper_type_1;
PyObject *exception_keeper_value_1;
PyTracebackObject *exception_keeper_tb_1;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
PyObject *tmp_args_element_name_1;
PyObject *tmp_args_element_name_2;
PyObject *tmp_args_element_name_3;
PyObject *tmp_args_element_name_4;
PyObject *tmp_args_name_1;
PyObject *tmp_assign_source_1;
PyObject *tmp_assign_source_2;
PyObject *tmp_called_name_1;
PyObject *tmp_called_name_2;
PyObject *tmp_called_name_3;
PyObject *tmp_called_name_4;
PyObject *tmp_dict_key_1;
PyObject *tmp_dict_key_2;
PyObject *tmp_dict_key_3;
PyObject *tmp_dict_value_1;
PyObject *tmp_dict_value_2;
PyObject *tmp_dict_value_3;
PyObject *tmp_frame_locals;
PyObject *tmp_kw_name_1;
int tmp_or_left_truth_1;
PyObject *tmp_or_left_value_1;
PyObject *tmp_or_right_value_1;
PyObject *tmp_return_value;
PyObject *tmp_source_name_1;
PyObject *tmp_source_name_2;
PyObject *tmp_tuple_element_1;
NUITKA_MAY_BE_UNUSED PyObject *tmp_unused;
static PyFrameObject *cache_frame_function = NULL;
PyFrameObject *frame_function;
tmp_return_value = NULL;
// Actual function code.
// Tried code:
MAKE_OR_REUSE_FRAME( cache_frame_function, codeobj_079a8ba6ceda22079d731bf3f2f28ee9, module_pip$_vendor$cachecontrol$wrapper );
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_or_left_value_1 = par_cache;
tmp_or_left_truth_1 = CHECK_IF_TRUE( tmp_or_left_value_1 );
if ( tmp_or_left_truth_1 == -1 )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 11;
goto frame_exception_exit_1;
}
if ( tmp_or_left_truth_1 == 1 )
{
goto or_left_1;
}
else
{
goto or_right_1;
}
or_right_1:;
tmp_called_name_1 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$cachecontrol$wrapper, (Nuitka_StringObject *)const_str_plain_DictCache );
if (unlikely( tmp_called_name_1 == NULL ))
{
tmp_called_name_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_DictCache );
}
if ( tmp_called_name_1 == NULL )
{
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "DictCache" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 11;
goto frame_exception_exit_1;
}
frame_function->f_lineno = 11;
tmp_or_right_value_1 = CALL_FUNCTION_NO_ARGS( tmp_called_name_1 );
if ( tmp_or_right_value_1 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 11;
goto frame_exception_exit_1;
}
tmp_assign_source_1 = tmp_or_right_value_1;
goto or_end_1;
or_left_1:;
Py_INCREF( tmp_or_left_value_1 );
tmp_assign_source_1 = tmp_or_left_value_1;
or_end_1:;
{
PyObject *old = par_cache;
par_cache = tmp_assign_source_1;
Py_XDECREF( old );
}
tmp_called_name_2 = GET_STRING_DICT_VALUE( moduledict_pip$_vendor$cachecontrol$wrapper, (Nuitka_StringObject *)const_str_plain_CacheControlAdapter );
if (unlikely( tmp_called_name_2 == NULL ))
{
tmp_called_name_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_CacheControlAdapter );
}
if ( tmp_called_name_2 == NULL )
{
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "CacheControlAdapter" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 12;
goto frame_exception_exit_1;
}
tmp_args_name_1 = PyTuple_New( 1 );
tmp_tuple_element_1 = par_cache;
Py_INCREF( tmp_tuple_element_1 );
PyTuple_SET_ITEM( tmp_args_name_1, 0, tmp_tuple_element_1 );
tmp_kw_name_1 = _PyDict_NewPresized( 3 );
tmp_dict_key_1 = const_str_plain_cache_etags;
tmp_dict_value_1 = par_cache_etags;
PyDict_SetItem( tmp_kw_name_1, tmp_dict_key_1, tmp_dict_value_1 );
tmp_dict_key_2 = const_str_plain_serializer;
tmp_dict_value_2 = par_serializer;
PyDict_SetItem( tmp_kw_name_1, tmp_dict_key_2, tmp_dict_value_2 );
tmp_dict_key_3 = const_str_plain_heuristic;
tmp_dict_value_3 = par_heuristic;
PyDict_SetItem( tmp_kw_name_1, tmp_dict_key_3, tmp_dict_value_3 );
frame_function->f_lineno = 16;
tmp_assign_source_2 = CALL_FUNCTION( tmp_called_name_2, tmp_args_name_1, tmp_kw_name_1 );
Py_DECREF( tmp_args_name_1 );
Py_DECREF( tmp_kw_name_1 );
if ( tmp_assign_source_2 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 16;
goto frame_exception_exit_1;
}
assert( var_adapter == NULL );
var_adapter = tmp_assign_source_2;
tmp_source_name_1 = par_sess;
tmp_called_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_mount );
if ( tmp_called_name_3 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 18;
goto frame_exception_exit_1;
}
tmp_args_element_name_1 = const_str_digest_7c06a402579f6f9d9db7f3e04da983fc;
tmp_args_element_name_2 = var_adapter;
if ( tmp_args_element_name_2 == NULL )
{
Py_DECREF( tmp_called_name_3 );
exception_type = PyExc_UnboundLocalError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "local variable '%s' referenced before assignment", "adapter" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 18;
goto frame_exception_exit_1;
}
frame_function->f_lineno = 18;
{
PyObject *call_args[] = { tmp_args_element_name_1, tmp_args_element_name_2 };
tmp_unused = CALL_FUNCTION_WITH_ARGS2( tmp_called_name_3, call_args );
}
Py_DECREF( tmp_called_name_3 );
if ( tmp_unused == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 18;
goto frame_exception_exit_1;
}
Py_DECREF( tmp_unused );
tmp_source_name_2 = par_sess;
if ( tmp_source_name_2 == NULL )
{
exception_type = PyExc_UnboundLocalError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "local variable '%s' referenced before assignment", "sess" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 19;
goto frame_exception_exit_1;
}
tmp_called_name_4 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_mount );
if ( tmp_called_name_4 == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 19;
goto frame_exception_exit_1;
}
tmp_args_element_name_3 = const_str_digest_504b77692b694460b8c25198a52c83ba;
tmp_args_element_name_4 = var_adapter;
if ( tmp_args_element_name_4 == NULL )
{
Py_DECREF( tmp_called_name_4 );
exception_type = PyExc_UnboundLocalError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "local variable '%s' referenced before assignment", "adapter" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 19;
goto frame_exception_exit_1;
}
frame_function->f_lineno = 19;
{
PyObject *call_args[] = { tmp_args_element_name_3, tmp_args_element_name_4 };
tmp_unused = CALL_FUNCTION_WITH_ARGS2( tmp_called_name_4, call_args );
}
Py_DECREF( tmp_called_name_4 );
if ( tmp_unused == NULL )
{
assert( ERROR_OCCURRED() );
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
exception_lineno = 19;
goto frame_exception_exit_1;
}
Py_DECREF( tmp_unused );
tmp_return_value = par_sess;
if ( tmp_return_value == NULL )
{
exception_type = PyExc_UnboundLocalError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "local variable '%s' referenced before assignment", "sess" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 21;
goto frame_exception_exit_1;
}
Py_INCREF( tmp_return_value );
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 try_return_handler_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION( frame_function );
#endif
{
bool needs_detach = false;
if ( exception_tb == NULL )
{
exception_tb = MAKE_TRACEBACK( frame_function, exception_lineno );
needs_detach = true;
}
else if ( exception_lineno != -1 )
{
PyTracebackObject *traceback_new = MAKE_TRACEBACK( frame_function, exception_lineno );
traceback_new->tb_next = exception_tb;
exception_tb = traceback_new;
needs_detach = true;
}
if (needs_detach)
{
tmp_frame_locals = PyDict_New();
if ( par_sess )
{
int res = PyDict_SetItem(
tmp_frame_locals,
const_str_plain_sess,
par_sess
);
assert( res == 0 );
}
if ( par_cache )
{
int res = PyDict_SetItem(
tmp_frame_locals,
const_str_plain_cache,
par_cache
);
assert( res == 0 );
}
if ( par_cache_etags )
{
int res = PyDict_SetItem(
tmp_frame_locals,
const_str_plain_cache_etags,
par_cache_etags
);
assert( res == 0 );
}
if ( par_serializer )
{
int res = PyDict_SetItem(
tmp_frame_locals,
const_str_plain_serializer,
par_serializer
);
assert( res == 0 );
}
if ( par_heuristic )
{
int res = PyDict_SetItem(
tmp_frame_locals,
const_str_plain_heuristic,
par_heuristic
);
assert( res == 0 );
}
if ( var_adapter )
{
int res = PyDict_SetItem(
tmp_frame_locals,
const_str_plain_adapter,
var_adapter
);
assert( res == 0 );
}
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 try_except_handler_1;
frame_no_exception_1:;
// tried codes exits in all cases
NUITKA_CANNOT_GET_HERE( function_1_CacheControl_of_pip$_vendor$cachecontrol$wrapper );
return NULL;
// Return handler code:
try_return_handler_1:;
Py_XDECREF( par_sess );
par_sess = NULL;
Py_XDECREF( par_cache );
par_cache = NULL;
Py_XDECREF( par_cache_etags );
par_cache_etags = NULL;
Py_XDECREF( par_serializer );
par_serializer = NULL;
Py_XDECREF( par_heuristic );
par_heuristic = NULL;
Py_XDECREF( var_adapter );
var_adapter = NULL;
goto function_return_exit;
// Exception handler code:
try_except_handler_1:;
exception_keeper_type_1 = exception_type;
exception_keeper_value_1 = exception_value;
exception_keeper_tb_1 = exception_tb;
exception_keeper_lineno_1 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = -1;
Py_XDECREF( par_sess );
par_sess = NULL;
Py_XDECREF( par_cache );
par_cache = NULL;
Py_XDECREF( par_cache_etags );
par_cache_etags = NULL;
Py_XDECREF( par_serializer );
par_serializer = NULL;
Py_XDECREF( par_heuristic );
par_heuristic = NULL;
Py_XDECREF( var_adapter );
var_adapter = NULL;
// Re-raise.
exception_type = exception_keeper_type_1;
exception_value = exception_keeper_value_1;
exception_tb = exception_keeper_tb_1;
exception_lineno = exception_keeper_lineno_1;
goto function_exception_exit;
// End of try:
// Return statement must have exited already.
NUITKA_CANNOT_GET_HERE( function_1_CacheControl_of_pip$_vendor$cachecontrol$wrapper );
return NULL;
function_exception_exit:
assert( exception_type );
RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb );
return NULL;
function_return_exit:
CHECK_OBJECT( tmp_return_value );
assert( had_error || !ERROR_OCCURRED() );
return tmp_return_value;
}
MOD_INIT_DECL( chardet$langthaimodel )
{
#if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300
static bool _init_done = false;
// Modules might be imported repeatedly, which is to be ignored.
if ( _init_done )
{
return MOD_RETURN_VALUE( module_chardet$langthaimodel );
}
else
{
_init_done = true;
}
#endif
#ifdef _NUITKA_MODULE
// In case of a stand alone extension module, need to call initialization
// the init here because that's the first and only time we are going to get
// called here.
// Initialize the constant values used.
_initBuiltinModule();
createGlobalConstants();
// Initialize the compiled types of Nuitka.
PyType_Ready( &Nuitka_Generator_Type );
PyType_Ready( &Nuitka_Function_Type );
PyType_Ready( &Nuitka_Method_Type );
PyType_Ready( &Nuitka_Frame_Type );
#if PYTHON_VERSION >= 350
PyType_Ready( &Nuitka_Coroutine_Type );
PyType_Ready( &Nuitka_CoroutineWrapper_Type );
#endif
#if PYTHON_VERSION < 300
_initSlotCompare();
#endif
#if PYTHON_VERSION >= 270
_initSlotIternext();
#endif
patchBuiltinModule();
patchTypeComparison();
// Enable meta path based loader if not already done.
setupMetaPathBasedLoader();
#if PYTHON_VERSION >= 300
patchInspectModule();
#endif
#endif
createModuleConstants();
createModuleCodeObjects();
// puts( "in initchardet$langthaimodel" );
// Create the module object first. There are no methods initially, all are
// added dynamically in actual code only. Also no "__doc__" is initially
// set at this time, as it could not contain NUL characters this way, they
// are instead set in early module code. No "self" for modules, we have no
// use for it.
#if PYTHON_VERSION < 300
module_chardet$langthaimodel = Py_InitModule4(
"chardet.langthaimodel", // Module Name
NULL, // No methods initially, all are added
// dynamically in actual module code only.
NULL, // No __doc__ is initially set, as it could
// not contain NUL this way, added early in
// actual code.
NULL, // No self for modules, we don't use it.
PYTHON_API_VERSION
);
#else
module_chardet$langthaimodel = PyModule_Create( &mdef_chardet$langthaimodel );
#endif
moduledict_chardet$langthaimodel = (PyDictObject *)((PyModuleObject *)module_chardet$langthaimodel)->md_dict;
CHECK_OBJECT( module_chardet$langthaimodel );
// Seems to work for Python2.7 out of the box, but for Python3, the module
// doesn't automatically enter "sys.modules", so do it manually.
#if PYTHON_VERSION >= 300
{
int r = PyObject_SetItem( PySys_GetObject( (char *)"modules" ), const_str_digest_dc79ec5cbcd38530b7ee96bca471ee48, module_chardet$langthaimodel );
assert( r != -1 );
}
#endif
// For deep importing of a module we need to have "__builtins__", so we set
// it ourselves in the same way than CPython does. Note: This must be done
// before the frame object is allocated, or else it may fail.
PyObject *module_dict = PyModule_GetDict( module_chardet$langthaimodel );
if ( PyDict_GetItem( module_dict, const_str_plain___builtins__ ) == NULL )
{
PyObject *value = (PyObject *)builtin_module;
// Check if main module, not a dict then.
#if !defined(_NUITKA_EXE) || !0
value = PyModule_GetDict( value );
#endif
#ifndef __NUITKA_NO_ASSERT__
int res =
#endif
PyDict_SetItem( module_dict, const_str_plain___builtins__, value );
assert( res == 0 );
}
#if PYTHON_VERSION >= 330
PyDict_SetItem( module_dict, const_str_plain___loader__, metapath_based_loader );
#endif
// Temp variables if any
PyObject *exception_type = NULL, *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = -1;
PyObject *tmp_assign_source_1;
PyObject *tmp_assign_source_2;
PyObject *tmp_assign_source_3;
PyObject *tmp_assign_source_4;
PyObject *tmp_assign_source_5;
PyObject *tmp_assign_source_6;
PyObject *tmp_assign_source_7;
PyObject *tmp_dict_key_1;
PyObject *tmp_dict_key_2;
PyObject *tmp_dict_key_3;
PyObject *tmp_dict_key_4;
PyObject *tmp_dict_key_5;
PyObject *tmp_dict_value_1;
PyObject *tmp_dict_value_2;
PyObject *tmp_dict_value_3;
PyObject *tmp_dict_value_4;
PyObject *tmp_dict_value_5;
PyFrameObject *frame_module;
// Module code.
tmp_assign_source_1 = Py_None;
UPDATE_STRING_DICT0( moduledict_chardet$langthaimodel, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 );
tmp_assign_source_2 = const_str_digest_fab0ff0cfd28ba77212ac4129d2d6d3f;
UPDATE_STRING_DICT0( moduledict_chardet$langthaimodel, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 );
tmp_assign_source_3 = Py_None;
UPDATE_STRING_DICT0( moduledict_chardet$langthaimodel, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 );
tmp_assign_source_4 = const_str_plain_chardet;
UPDATE_STRING_DICT0( moduledict_chardet$langthaimodel, (Nuitka_StringObject *)const_str_plain___package__, tmp_assign_source_4 );
tmp_assign_source_5 = const_tuple_7d72fee6787d507d887d69cdea35a4a9_tuple;
UPDATE_STRING_DICT0( moduledict_chardet$langthaimodel, (Nuitka_StringObject *)const_str_plain_TIS620CharToOrderMap, tmp_assign_source_5 );
tmp_assign_source_6 = const_tuple_d3af699605e5a0a7fd9bffcfaf0dd97e_tuple;
UPDATE_STRING_DICT0( moduledict_chardet$langthaimodel, (Nuitka_StringObject *)const_str_plain_ThaiLangModel, tmp_assign_source_6 );
// Frame without reuse.
frame_module = MAKE_MODULE_FRAME( codeobj_2c0e8ffc754dbed723c12963ef7fcab5, module_chardet$langthaimodel );
// Push the new frame as the currently active one, and we should be exclusively
// owning it.
pushFrameStack( frame_module );
assert( Py_REFCNT( frame_module ) == 1 );
#if PYTHON_VERSION >= 340
frame_module->f_executing += 1;
#endif
// Framed code:
tmp_assign_source_7 = _PyDict_NewPresized( 5 );
tmp_dict_key_1 = const_str_plain_charToOrderMap;
tmp_dict_value_1 = GET_STRING_DICT_VALUE( moduledict_chardet$langthaimodel, (Nuitka_StringObject *)const_str_plain_TIS620CharToOrderMap );
if (unlikely( tmp_dict_value_1 == NULL ))
{
tmp_dict_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_TIS620CharToOrderMap );
}
if ( tmp_dict_value_1 == NULL )
{
Py_DECREF( tmp_assign_source_7 );
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "TIS620CharToOrderMap" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 193;
goto frame_exception_exit_1;
}
PyDict_SetItem( tmp_assign_source_7, tmp_dict_key_1, tmp_dict_value_1 );
tmp_dict_key_2 = const_str_plain_precedenceMatrix;
tmp_dict_value_2 = GET_STRING_DICT_VALUE( moduledict_chardet$langthaimodel, (Nuitka_StringObject *)const_str_plain_ThaiLangModel );
if (unlikely( tmp_dict_value_2 == NULL ))
{
tmp_dict_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_ThaiLangModel );
}
if ( tmp_dict_value_2 == NULL )
{
Py_DECREF( tmp_assign_source_7 );
exception_type = PyExc_NameError;
Py_INCREF( exception_type );
exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "ThaiLangModel" );
exception_tb = NULL;
NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb );
CHAIN_EXCEPTION( exception_value );
exception_lineno = 194;
goto frame_exception_exit_1;
}
PyDict_SetItem( tmp_assign_source_7, tmp_dict_key_2, tmp_dict_value_2 );
tmp_dict_key_3 = const_str_plain_mTypicalPositiveRatio;
tmp_dict_value_3 = const_float_0_926386;
PyDict_SetItem( tmp_assign_source_7, tmp_dict_key_3, tmp_dict_value_3 );
tmp_dict_key_4 = const_str_plain_keepEnglishLetter;
tmp_dict_value_4 = Py_False;
PyDict_SetItem( tmp_assign_source_7, tmp_dict_key_4, tmp_dict_value_4 );
tmp_dict_key_5 = const_str_plain_charsetName;
tmp_dict_value_5 = const_str_digest_81abb6a16c2b4c1510e4bf593a6a3c99;
PyDict_SetItem( tmp_assign_source_7, tmp_dict_key_5, tmp_dict_value_5 );
UPDATE_STRING_DICT1( moduledict_chardet$langthaimodel, (Nuitka_StringObject *)const_str_plain_TIS620ThaiModel, tmp_assign_source_7 );
// Restore frame exception if necessary.
#if 0
RESTORE_FRAME_EXCEPTION( frame_module );
#endif
popFrameStack();
assertFrameObject( frame_module );
Py_DECREF( frame_module );
goto frame_no_exception_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION( frame_module );
#endif
if ( exception_tb == NULL )
{
exception_tb = MAKE_TRACEBACK( frame_module, exception_lineno );
}
else if ( exception_tb->tb_frame != frame_module )
{
PyTracebackObject *traceback_new = MAKE_TRACEBACK( frame_module, exception_lineno );
traceback_new->tb_next = exception_tb;
exception_tb = traceback_new;
}
// Put the previous frame back on top.
popFrameStack();
#if PYTHON_VERSION >= 340
frame_module->f_executing -= 1;
#endif
Py_DECREF( frame_module );
// Return the error.
goto module_exception_exit;
frame_no_exception_1:;
return MOD_RETURN_VALUE( module_chardet$langthaimodel );
module_exception_exit:
RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb );
return MOD_RETURN_VALUE( NULL );
}
