static PyObject *bpy_lib_load(PyObject *UNUSED(self), PyObject *args, PyObject *kw) { Main *bmain = CTX_data_main(BPy_GetContext()); BPy_Library *ret; const char *filename = NULL; bool is_rel = false, is_link = false; static const char *_keywords[] = {"filepath", "link", "relative", NULL}; static _PyArg_Parser _parser = {"s|O&O&:load", _keywords, 0}; if (!_PyArg_ParseTupleAndKeywordsFast( args, kw, &_parser, &filename, PyC_ParseBool, &is_link, PyC_ParseBool, &is_rel)) { return NULL; } ret = PyObject_New(BPy_Library, &bpy_lib_Type); BLI_strncpy(ret->relpath, filename, sizeof(ret->relpath)); BLI_strncpy(ret->abspath, filename, sizeof(ret->abspath)); BLI_path_abs(ret->abspath, BKE_main_blendfile_path(bmain)); ret->blo_handle = NULL; ret->flag = ((is_link ? FILE_LINK : 0) | (is_rel ? FILE_RELPATH : 0)); ret->dict = _PyDict_NewPresized(MAX_LIBARRAY); return (PyObject *)ret; }
static PyObject *app_translations_new(PyTypeObject *type, PyObject *UNUSED(args), PyObject *UNUSED(kw)) { /* printf("%s (%p)\n", __func__, _translations); */ if (!_translations) { _translations = (BlenderAppTranslations *)type->tp_alloc(type, 0); if (_translations) { PyObject *py_ctxts; BLT_i18n_contexts_descriptor *ctxt; _translations->contexts = app_translations_contexts_make(); py_ctxts = _PyDict_NewPresized(ARRAY_SIZE(_contexts)); for (ctxt = _contexts; ctxt->c_id; ctxt++) { PyObject *val = PyUnicode_FromString(ctxt->py_id); PyDict_SetItemString(py_ctxts, ctxt->c_id, val); Py_DECREF(val); } _translations->contexts_C_to_py = PyDictProxy_New(py_ctxts); Py_DECREF(py_ctxts); /* The actual dict is only owned by its proxy */ _translations->py_messages = PyDict_New(); } } return (PyObject *)_translations; }
static PyObject *bpy_lib_enter(BPy_Library *self) { PyObject *ret; BPy_Library *self_from; PyObject *from_dict = _PyDict_NewPresized(MAX_LIBARRAY); ReportList reports; BKE_reports_init(&reports, RPT_STORE); self->blo_handle = BLO_blendhandle_from_file(self->abspath, &reports); if (self->blo_handle == NULL) { if (BPy_reports_to_error(&reports, PyExc_IOError, true) != -1) { PyErr_Format(PyExc_IOError, "load: %s failed to open blend file", self->abspath); } return NULL; } else { int i = 0, code; while ((code = BKE_idcode_iter_step(&i))) { if (BKE_idcode_is_linkable(code)) { const char *name_plural = BKE_idcode_to_name_plural(code); PyObject *str = PyUnicode_FromString(name_plural); PyObject *item; PyDict_SetItem(self->dict, str, item = PyList_New(0)); Py_DECREF(item); PyDict_SetItem(from_dict, str, item = _bpy_names(self, code)); Py_DECREF(item); Py_DECREF(str); } } } /* create a dummy */ self_from = PyObject_New(BPy_Library, &bpy_lib_Type); BLI_strncpy(self_from->relpath, self->relpath, sizeof(self_from->relpath)); BLI_strncpy(self_from->abspath, self->abspath, sizeof(self_from->abspath)); self_from->blo_handle = NULL; self_from->flag = 0; self_from->dict = from_dict; /* owns the dict */ /* return pair */ ret = PyTuple_New(2); PyTuple_SET_ITEMS(ret, (PyObject *)self_from, (PyObject *)self); Py_INCREF(self); BKE_reports_clear(&reports); return ret; }
static void _initModuleConstants(void) { const_str_plain_stacklevel = UNSTREAM_STRING( &constant_bin[ 246387 ], 10, 1 ); const_str_plain_use_simplejson = UNSTREAM_STRING( &constant_bin[ 27083 ], 14, 1 ); const_str_plain_stdlib_json_version = UNSTREAM_STRING( &constant_bin[ 27042 ], 19, 1 ); const_dict_f154c9a58c9419d7e391901d7b7fe49e = _PyDict_NewPresized( 1 ); PyDict_SetItem( const_dict_f154c9a58c9419d7e391901d7b7fe49e, const_str_plain_stacklevel, const_int_pos_2 ); const_str_digest_7169b7e65e78489e48321bf243165725 = UNSTREAM_STRING( &constant_bin[ 246397 ], 56, 0 ); const_str_digest_8e395302c5225c24e16f9edd8dd95062 = UNSTREAM_STRING( &constant_bin[ 246397 ], 23, 0 ); const_str_digest_b263340febec452f7ce0d23d319dd69a = UNSTREAM_STRING( &constant_bin[ 246453 ], 59, 0 ); }
static void createModuleConstants( void ) { const_tuple_str_plain_LookupDict_tuple = PyTuple_New( 1 ); PyTuple_SET_ITEM( const_tuple_str_plain_LookupDict_tuple, 0, const_str_plain_LookupDict ); Py_INCREF( const_str_plain_LookupDict ); const_str_plain__codes = UNSTREAM_STRING( &constant_bin[ 201532 ], 6, 1 ); const_dict_19730b058f28080932defca1165e072e = PyMarshal_ReadObjectFromString( (char *)&constant_bin[ 495296 ], 2320 ); const_str_digest_edc503ce8640402b515eac9b4be2e49c = UNSTREAM_STRING( &constant_bin[ 497616 ], 69, 0 ); const_str_digest_7407a472cb7f92da9dfbd02c8e685bfe = UNSTREAM_STRING( &constant_bin[ 497685 ], 33, 0 ); const_dict_38252060f20256dc080a28c7e1fb8512 = _PyDict_NewPresized( 1 ); PyDict_SetItem( const_dict_38252060f20256dc080a28c7e1fb8512, const_str_plain_name, const_str_plain_status_codes ); assert( PyDict_Size( const_dict_38252060f20256dc080a28c7e1fb8512 ) == 1 ); const_str_plain_titles = UNSTREAM_STRING( &constant_bin[ 497718 ], 6, 1 ); constants_created = true; }
static PyObject *bpy_user_map(PyObject *UNUSED(self), PyObject *args, PyObject *kwds) { #if 0 /* If someone knows how to get a proper 'self' in that case... */ BPy_StructRNA *pyrna = (BPy_StructRNA *)self; Main *bmain = pyrna->ptr.data; #else Main *bmain = G.main; /* XXX Ugly, but should work! */ #endif static const char *kwlist[] = {"subset", "key_types", "value_types", NULL}; PyObject *subset = NULL; PyObject *key_types = NULL; PyObject *val_types = NULL; BLI_bitmap *key_types_bitmap = NULL; BLI_bitmap *val_types_bitmap = NULL; PyObject *ret = NULL; if (!PyArg_ParseTupleAndKeywords( args, kwds, "|O$O!O!:user_map", (char **)kwlist, &subset, &PySet_Type, &key_types, &PySet_Type, &val_types)) { return NULL; } if (key_types) { key_types_bitmap = pyrna_set_to_enum_bitmap( rna_enum_id_type_items, key_types, sizeof(short), true, USHRT_MAX, "key types"); if (key_types_bitmap == NULL) { goto error; } } if (val_types) { val_types_bitmap = pyrna_set_to_enum_bitmap( rna_enum_id_type_items, val_types, sizeof(short), true, USHRT_MAX, "value types"); if (val_types_bitmap == NULL) { goto error; } } IDUserMapData data_cb = {NULL}; if (subset) { PyObject *subset_fast = PySequence_Fast(subset, "user_map"); if (subset_fast == NULL) { goto error; } PyObject **subset_array = PySequence_Fast_ITEMS(subset_fast); Py_ssize_t subset_len = PySequence_Fast_GET_SIZE(subset_fast); data_cb.user_map = _PyDict_NewPresized(subset_len); data_cb.is_subset = true; for (; subset_len; subset_array++, subset_len--) { PyObject *set = PySet_New(NULL); PyDict_SetItem(data_cb.user_map, *subset_array, set); Py_DECREF(set); } Py_DECREF(subset_fast); } else { data_cb.user_map = PyDict_New(); } data_cb.types_bitmap = key_types_bitmap; ListBase *lb_array[MAX_LIBARRAY]; int lb_index; lb_index = set_listbasepointers(bmain, lb_array); while (lb_index--) { if (val_types_bitmap && lb_array[lb_index]->first) { if (!id_check_type(lb_array[lb_index]->first, val_types_bitmap)) { continue; } } for (ID *id = lb_array[lb_index]->first; id; id = id->next) { /* One-time init, ID is just used as placeholder here, we abuse this in iterator callback * to avoid having to rebuild a complete bpyrna object each time for the key searching * (where only ID pointer value is used). */ if (data_cb.py_id_key_lookup_only == NULL) { data_cb.py_id_key_lookup_only = pyrna_id_CreatePyObject(id); } if (!data_cb.is_subset) { PyObject *key = data_cb.py_id_key_lookup_only; PyObject *set; RNA_id_pointer_create(id, &((BPy_StructRNA *)key)->ptr); /* We have to insert the key now, otherwise ID unused would be missing from final dict... */ if ((set = PyDict_GetItem(data_cb.user_map, key)) == NULL) { /* Cannot use our placeholder key here! */ key = pyrna_id_CreatePyObject(id); set = PySet_New(NULL); PyDict_SetItem(data_cb.user_map, key, set); Py_DECREF(set); Py_DECREF(key); } } data_cb.id_curr = id; BKE_library_foreach_ID_link(id, foreach_libblock_id_user_map_callback, &data_cb, IDWALK_NOP); if (data_cb.py_id_curr) { Py_DECREF(data_cb.py_id_curr); data_cb.py_id_curr = NULL; } } } ret = data_cb.user_map; error: Py_XDECREF(data_cb.py_id_key_lookup_only); if (key_types_bitmap) { MEM_freeN(key_types_bitmap); } if (val_types_bitmap) { MEM_freeN(val_types_bitmap); } return ret; }
static PyObject *fparse_function_1_inner_of_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_args = NULL; PyObject *_python_par_kwargs = NULL; if ( kw == NULL ) { _python_par_kwargs = PyDict_New(); } else { if ( ((PyDictObject *)kw)->ma_used > 0 ) { #if PYTHON_VERSION < 330 _python_par_kwargs = _PyDict_NewPresized( ((PyDictObject *)kw)->ma_used ); for ( int i = 0; i <= ((PyDictObject *)kw)->ma_mask; i++ ) { PyDictEntry *entry = &((PyDictObject *)kw)->ma_table[ i ]; if ( entry->me_value != NULL ) { #if PYTHON_VERSION < 300 if (unlikely( !PyString_Check( entry->me_key ) && !PyUnicode_Check( entry->me_key ) )) #else if (unlikely( !PyUnicode_Check( entry->me_key ) )) #endif { PyErr_Format( PyExc_TypeError, "inner() keywords must be strings" ); goto error_exit; } int res = PyDict_SetItem( _python_par_kwargs, entry->me_key, entry->me_value ); if (unlikely( res == -1 )) { goto error_exit; } } } #else if ( _PyDict_HasSplitTable( ((PyDictObject *)kw) ) ) { PyDictObject *mp = (PyDictObject *)kw; PyObject **newvalues = PyMem_NEW( PyObject *, mp->ma_keys->dk_size ); assert (newvalues != NULL); PyDictObject *split_copy = PyObject_GC_New( PyDictObject, &PyDict_Type ); assert( split_copy != NULL ); split_copy->ma_values = newvalues; split_copy->ma_keys = mp->ma_keys; split_copy->ma_used = mp->ma_used; mp->ma_keys->dk_refcnt += 1; Nuitka_GC_Track( split_copy ); int size = mp->ma_keys->dk_size; for ( int i = 0; i < size; i++ ) { PyDictKeyEntry *entry = &split_copy->ma_keys->dk_entries[ i ]; if (unlikely( !PyUnicode_Check( entry->me_key ) )) { PyErr_Format( PyExc_TypeError, "inner() keywords must be strings" ); goto error_exit; } split_copy->ma_values[ i ] = INCREASE_REFCOUNT_X( mp->ma_values[ i ] ); } _python_par_kwargs = (PyObject *)split_copy; } else {
// 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 ); }
/* for simple, non nested types this is the same as BPy_IDGroup_WrapData */ static PyObject *BPy_IDGroup_MapDataToPy(IDProperty *prop) { switch (prop->type) { case IDP_STRING: return idprop_py_from_idp_string(prop); case IDP_INT: return idprop_py_from_idp_int(prop); case IDP_FLOAT: return idprop_py_from_idp_float(prop); case IDP_DOUBLE: return idprop_py_from_idp_double(prop); case IDP_ID: return idprop_py_from_idp_id(prop); case IDP_ARRAY: { PyObject *seq = PyList_New(prop->len); int i; if (!seq) { PyErr_Format(PyExc_RuntimeError, "%s: IDP_ARRAY: PyList_New(%d) failed", __func__, prop->len); return NULL; } switch (prop->subtype) { case IDP_FLOAT: { const float *array = (float *)IDP_Array(prop); for (i = 0; i < prop->len; i++) { PyList_SET_ITEM(seq, i, PyFloat_FromDouble(array[i])); } break; } case IDP_DOUBLE: { const double *array = (double *)IDP_Array(prop); for (i = 0; i < prop->len; i++) { PyList_SET_ITEM(seq, i, PyFloat_FromDouble(array[i])); } break; } case IDP_INT: { const int *array = (int *)IDP_Array(prop); for (i = 0; i < prop->len; i++) { PyList_SET_ITEM(seq, i, PyLong_FromLong(array[i])); } break; } default: PyErr_Format(PyExc_RuntimeError, "%s: invalid/corrupt array type '%d'!", __func__, prop->subtype); Py_DECREF(seq); return NULL; } return seq; } case IDP_IDPARRAY: { PyObject *seq = PyList_New(prop->len); IDProperty *array = IDP_IDPArray(prop); int i; if (!seq) { PyErr_Format(PyExc_RuntimeError, "%s: IDP_IDPARRAY: PyList_New(%d) failed", __func__, prop->len); return NULL; } for (i = 0; i < prop->len; i++) { PyObject *wrap = BPy_IDGroup_MapDataToPy(array++); /* BPy_IDGroup_MapDataToPy sets the error */ if (UNLIKELY(wrap == NULL)) { Py_DECREF(seq); return NULL; } PyList_SET_ITEM(seq, i, wrap); } return seq; } case IDP_GROUP: { PyObject *dict = _PyDict_NewPresized(prop->len); IDProperty *loop; for (loop = prop->data.group.first; loop; loop = loop->next) { PyObject *wrap = BPy_IDGroup_MapDataToPy(loop); /* BPy_IDGroup_MapDataToPy sets the error */ if (UNLIKELY(wrap == NULL)) { Py_DECREF(dict); return NULL; } PyDict_SetItemString(dict, loop->name, wrap); Py_DECREF(wrap); } return dict; } } PyErr_Format(PyExc_RuntimeError, "%s ERROR: '%s' property exists with a bad type code '%d'!", __func__, prop->name, prop->type); return NULL; }