A small python script to help synchronizing the inventory of a local storage facility and the Amazon FBA storage.
List of commits:
| Subject | Hash | Author | Date (UTC) |
|---|---|---|---|
| Combined with the picklist creation project | 4e5023c3c2bebc53794fe29edbcf9a7be93c826a | Sebastian | 2019-05-03 11:40:35 |
| Created a building script for Linux based systems and made it possible to use the script from anywhere inside the filesystem | e97b391d7b1cda885c99b6b483d414c75b288b75 | Sebastian | 2019-04-15 15:00:47 |
| Added a working Linux executable Version, together with a different workspace creation process | c84d49cf0f99fd3dcb7faabe82c125c8adc970cb | Sebastian | 2019-04-12 16:53:29 |
| removed unnecessary files from the report and upload folder | 94af82cbd9fd7f592fb6b421986c3d900f1bf532 | Sebastian | 2019-04-05 12:51:43 |
| Added 2 options: a new order import to plenty and a fba shipment creation | db5b9c168dabe3d6524b5674dd977044be286e0a | Sebastian | 2019-04-05 12:48:53 |
| adjusted to another sync format and added a new export format that includes the sale price | d33a1909c4f1ff88569509ad4510a5419e323136 | Basti | 2019-03-22 10:27:22 |
| first Version of the Sync Upload | de9ea87dff9ced84f635dd05d5ae039be870ae8a | Basti | 2019-03-19 16:32:44 |
| First commit including Readme and folder structure | 7e77aa7abd6013ce56d6878c7004973e32011a13 | Basti | 2019-03-19 10:44:36 |
Commit 4e5023c3c2bebc53794fe29edbcf9a7be93c826a
- Combined with the picklist creation project
Author: Sebastian
Author date (UTC): 2019-05-03 11:40
Committer name: Sebastian
Committer date (UTC): 2019-05-03 11:40
Parent(s): e97b391d7b1cda885c99b6b483d414c75b288b75
Signer:
Signing key:
Signing status: N
Tree: 91cb3bba43817e88167eca011d05613d1f605c30
Author: Sebastian
Author date (UTC): 2019-05-03 11:40
Committer name: Sebastian
Committer date (UTC): 2019-05-03 11:40
Parent(s): e97b391d7b1cda885c99b6b483d414c75b288b75
Signer:
Signing key:
Signing status: N
Tree: 91cb3bba43817e88167eca011d05613d1f605c30
| File .gitignore changed (mode: 100644) (index a31ef3f..047db8a) | |||
| ... | ... | config.txt | |
| 2 | 2 | producer_list_april_2019.csv | producer_list_april_2019.csv |
| 3 | 3 | /Report | /Report |
| 4 | 4 | /Upload | /Upload |
| 5 | /Linux_Version | ||
| File Linux_Version/inventory_synchronisation.build/.sconsign.dblite deleted (index 0792708..0000000) |
| File Linux_Version/inventory_synchronisation.build/CompiledAsyncgenType.c deleted (index 21b9d25..0000000) | |||
| 1 | /home/basti/.local/lib/python3.7/site-packages/nuitka/build/static_src/CompiledAsyncgenType.c | ||
| File Linux_Version/inventory_synchronisation.build/CompiledAsyncgenType.o deleted (index e6d0ac6..0000000) |
| File Linux_Version/inventory_synchronisation.build/CompiledCellType.c deleted (index 2d4df4c..0000000) | |||
| 1 | /home/basti/.local/lib/python3.7/site-packages/nuitka/build/static_src/CompiledCellType.c | ||
| File Linux_Version/inventory_synchronisation.build/CompiledCellType.o deleted (index ee7d128..0000000) |
| File Linux_Version/inventory_synchronisation.build/CompiledCodeHelpers.c deleted (index 9f3a247..0000000) | |||
| 1 | /home/basti/.local/lib/python3.7/site-packages/nuitka/build/static_src/CompiledCodeHelpers.c | ||
| File Linux_Version/inventory_synchronisation.build/CompiledCodeHelpers.o deleted (index 3b338c7..0000000) |
| File Linux_Version/inventory_synchronisation.build/CompiledCoroutineType.c deleted (index b4d68b1..0000000) | |||
| 1 | /home/basti/.local/lib/python3.7/site-packages/nuitka/build/static_src/CompiledCoroutineType.c | ||
| File Linux_Version/inventory_synchronisation.build/CompiledCoroutineType.o deleted (index 96f6fcd..0000000) |
| File Linux_Version/inventory_synchronisation.build/CompiledFrameType.c deleted (index efef5cc..0000000) | |||
| 1 | /home/basti/.local/lib/python3.7/site-packages/nuitka/build/static_src/CompiledFrameType.c | ||
| File Linux_Version/inventory_synchronisation.build/CompiledFrameType.o deleted (index 78f2739..0000000) |
| File Linux_Version/inventory_synchronisation.build/CompiledFunctionType.c deleted (index de0d7dc..0000000) | |||
| 1 | /home/basti/.local/lib/python3.7/site-packages/nuitka/build/static_src/CompiledFunctionType.c | ||
| File Linux_Version/inventory_synchronisation.build/CompiledFunctionType.o deleted (index ce230fc..0000000) |
| File Linux_Version/inventory_synchronisation.build/CompiledGeneratorType.c deleted (index 7df1ebb..0000000) | |||
| 1 | /home/basti/.local/lib/python3.7/site-packages/nuitka/build/static_src/CompiledGeneratorType.c | ||
| File Linux_Version/inventory_synchronisation.build/CompiledGeneratorType.o deleted (index f3ad7a6..0000000) |
| File Linux_Version/inventory_synchronisation.build/CompiledMethodType.c deleted (index bb6061e..0000000) | |||
| 1 | /home/basti/.local/lib/python3.7/site-packages/nuitka/build/static_src/CompiledMethodType.c | ||
| File Linux_Version/inventory_synchronisation.build/CompiledMethodType.o deleted (index 6362396..0000000) |
| File Linux_Version/inventory_synchronisation.build/InspectPatcher.c deleted (index 6a4793a..0000000) | |||
| 1 | /home/basti/.local/lib/python3.7/site-packages/nuitka/build/static_src/InspectPatcher.c | ||
| File Linux_Version/inventory_synchronisation.build/InspectPatcher.o deleted (index 944cbc6..0000000) |
| File Linux_Version/inventory_synchronisation.build/MainProgram.c deleted (index 989b124..0000000) | |||
| 1 | /home/basti/.local/lib/python3.7/site-packages/nuitka/build/static_src/MainProgram.c | ||
| File Linux_Version/inventory_synchronisation.build/MainProgram.o deleted (index e7b72b9..0000000) |
| File Linux_Version/inventory_synchronisation.build/MetaPathBasedLoader.c deleted (index 5a12519..0000000) | |||
| 1 | /home/basti/.local/lib/python3.7/site-packages/nuitka/build/static_src/MetaPathBasedLoader.c | ||
| File Linux_Version/inventory_synchronisation.build/MetaPathBasedLoader.o deleted (index b7fa12f..0000000) |
| File Linux_Version/inventory_synchronisation.build/__constants.bin deleted (index 556f6a0..0000000) |
| File Linux_Version/inventory_synchronisation.build/__constants.c deleted (index 3e0e744..0000000) | |||
| 1 | |||
| 2 | #include "nuitka/prelude.h" | ||
| 3 | #include "structseq.h" | ||
| 4 | |||
| 5 | // Sentinel PyObject to be used for all our call iterator endings. It will | ||
| 6 | // become a PyCObject pointing to NULL. It's address is unique, and that's | ||
| 7 | // enough for us to use it as sentinel value. | ||
| 8 | PyObject *_sentinel_value = NULL; | ||
| 9 | |||
| 10 | PyObject *Nuitka_dunder_compiled_value = NULL; | ||
| 11 | |||
| 12 | PyObject *const_int_0; | ||
| 13 | PyObject *const_str_dot; | ||
| 14 | PyObject *const_int_neg_1; | ||
| 15 | PyObject *const_int_pos_1; | ||
| 16 | PyObject *const_int_pos_2; | ||
| 17 | PyObject *const_int_pos_3; | ||
| 18 | PyObject *const_int_pos_4; | ||
| 19 | PyObject *const_int_pos_5; | ||
| 20 | PyObject *const_int_pos_7; | ||
| 21 | PyObject *const_int_pos_8; | ||
| 22 | PyObject *const_str_empty; | ||
| 23 | PyObject *const_str_space; | ||
| 24 | PyObject *const_dict_empty; | ||
| 25 | PyObject *const_str_chr_42; | ||
| 26 | PyObject *const_str_chr_45; | ||
| 27 | PyObject *const_str_chr_58; | ||
| 28 | PyObject *const_str_chr_59; | ||
| 29 | PyObject *const_str_chr_61; | ||
| 30 | PyObject *const_bytes_empty; | ||
| 31 | PyObject *const_int_pos_256; | ||
| 32 | PyObject *const_str_newline; | ||
| 33 | PyObject *const_str_plain__; | ||
| 34 | PyObject *const_str_plain_a; | ||
| 35 | PyObject *const_str_plain_e; | ||
| 36 | PyObject *const_str_plain_i; | ||
| 37 | PyObject *const_str_plain_m; | ||
| 38 | PyObject *const_str_plain_n; | ||
| 39 | PyObject *const_str_plain_r; | ||
| 40 | PyObject *const_str_plain_s; | ||
| 41 | PyObject *const_str_plain_t; | ||
| 42 | PyObject *const_str_plain_x; | ||
| 43 | PyObject *const_str_plain_y; | ||
| 44 | PyObject *const_tuple_empty; | ||
| 45 | PyObject *const_str_plain_cb; | ||
| 46 | PyObject *const_str_plain_ex; | ||
| 47 | PyObject *const_str_plain_gi; | ||
| 48 | PyObject *const_str_plain_id; | ||
| 49 | PyObject *const_str_plain_io; | ||
| 50 | PyObject *const_str_plain_os; | ||
| 51 | PyObject *const_str_plain_rb; | ||
| 52 | PyObject *const_str_plain_re; | ||
| 53 | PyObject *const_str_plain_tb; | ||
| 54 | PyObject *const_str_plain_Bus; | ||
| 55 | PyObject *const_str_plain__gi; | ||
| 56 | PyObject *const_str_plain_add; | ||
| 57 | PyObject *const_str_plain_arg; | ||
| 58 | PyObject *const_str_plain_buf; | ||
| 59 | PyObject *const_str_plain_bus; | ||
| 60 | PyObject *const_str_plain_cls; | ||
| 61 | PyObject *const_str_plain_do_; | ||
| 62 | PyObject *const_str_plain_doc; | ||
| 63 | PyObject *const_str_plain_end; | ||
| 64 | PyObject *const_str_plain_exc; | ||
| 65 | PyObject *const_str_plain_fun; | ||
| 66 | PyObject *const_str_plain_get; | ||
| 67 | PyObject *const_str_plain_gid; | ||
| 68 | PyObject *const_str_plain_int; | ||
| 69 | PyObject *const_str_plain_key; | ||
| 70 | PyObject *const_str_plain_len; | ||
| 71 | PyObject *const_str_plain_map; | ||
| 72 | PyObject *const_str_plain_msg; | ||
| 73 | PyObject *const_str_plain_new; | ||
| 74 | PyObject *const_str_plain_pop; | ||
| 75 | PyObject *const_str_plain_ret; | ||
| 76 | PyObject *const_str_plain_row; | ||
| 77 | PyObject *const_str_plain_str; | ||
| 78 | PyObject *const_str_plain_sum; | ||
| 79 | PyObject *const_str_plain_sys; | ||
| 80 | PyObject *const_str_plain_typ; | ||
| 81 | PyObject *const_str_plain_uid; | ||
| 82 | PyObject *const_str_plain_val; | ||
| 83 | PyObject *const_str_plain_zip; | ||
| 84 | PyObject *const_str_plain_Byte; | ||
| 85 | PyObject *const_str_plain_None; | ||
| 86 | PyObject *const_str_plain_UUID; | ||
| 87 | PyObject *const_str_plain_args; | ||
| 88 | PyObject *const_str_plain_argv; | ||
| 89 | PyObject *const_str_plain_attr; | ||
| 90 | PyObject *const_str_plain_auth; | ||
| 91 | PyObject *const_str_plain_bool; | ||
| 92 | PyObject *const_str_plain_conn; | ||
| 93 | PyObject *const_str_plain_copy; | ||
| 94 | PyObject *const_str_plain_data; | ||
| 95 | PyObject *const_str_plain_dbus; | ||
| 96 | PyObject *const_str_plain_ddir; | ||
| 97 | PyObject *const_str_plain_dict; | ||
| 98 | PyObject *const_str_plain_emit; | ||
| 99 | PyObject *const_str_plain_exit; | ||
| 100 | PyObject *const_str_plain_file; | ||
| 101 | PyObject *const_str_plain_func; | ||
| 102 | PyObject *const_str_plain_glib; | ||
| 103 | PyObject *const_str_plain_info; | ||
| 104 | PyObject *const_str_plain_is_a; | ||
| 105 | PyObject *const_str_plain_item; | ||
| 106 | PyObject *const_str_plain_iter; | ||
| 107 | PyObject *const_str_plain_join; | ||
| 108 | PyObject *const_str_plain_keys; | ||
| 109 | PyObject *const_str_plain_list; | ||
| 110 | PyObject *const_str_plain_name; | ||
| 111 | PyObject *const_str_plain_open; | ||
| 112 | PyObject *const_str_plain_path; | ||
| 113 | PyObject *const_str_plain_prob; | ||
| 114 | PyObject *const_str_plain_read; | ||
| 115 | PyObject *const_str_plain_recv; | ||
| 116 | PyObject *const_str_plain_repr; | ||
| 117 | PyObject *const_str_plain_rule; | ||
| 118 | PyObject *const_str_plain_self; | ||
| 119 | PyObject *const_str_plain_send; | ||
| 120 | PyObject *const_str_plain_site; | ||
| 121 | PyObject *const_str_plain_type; | ||
| 122 | PyObject *const_str_plain_uuid; | ||
| 123 | PyObject *const_str_plain_void; | ||
| 124 | PyObject *const_str_plain_warn; | ||
| 125 | PyObject *const_str_plain_Array; | ||
| 126 | PyObject *const_str_plain_ERROR; | ||
| 127 | PyObject *const_str_plain_False; | ||
| 128 | PyObject *const_str_plain_GEnum; | ||
| 129 | PyObject *const_str_plain_GTKIO; | ||
| 130 | PyObject *const_str_plain_GType; | ||
| 131 | PyObject *const_str_plain_Int16; | ||
| 132 | PyObject *const_str_plain_Int32; | ||
| 133 | PyObject *const_str_plain_Int64; | ||
| 134 | PyObject *const_str_plain_bases; | ||
| 135 | PyObject *const_str_plain_bytes; | ||
| 136 | PyObject *const_str_plain_chown; | ||
| 137 | PyObject *const_str_plain_close; | ||
| 138 | PyObject *const_str_plain_debug; | ||
| 139 | PyObject *const_str_plain_dict_; | ||
| 140 | PyObject *const_str_plain_entry; | ||
| 141 | PyObject *const_str_plain_error; | ||
| 142 | PyObject *const_str_plain_field; | ||
| 143 | PyObject *const_str_plain_flags; | ||
| 144 | PyObject *const_str_plain_float; | ||
| 145 | PyObject *const_str_plain_iface; | ||
| 146 | PyObject *const_str_plain_index; | ||
| 147 | PyObject *const_str_plain_items; | ||
| 148 | PyObject *const_str_plain_klass; | ||
| 149 | PyObject *const_str_plain_level; | ||
| 150 | PyObject *const_str_plain_limit; | ||
| 151 | PyObject *const_str_plain_long_; | ||
| 152 | PyObject *const_str_plain_lower; | ||
| 153 | PyObject *const_str_plain_match; | ||
| 154 | PyObject *const_str_plain_owner; | ||
| 155 | PyObject *const_str_plain_print; | ||
| 156 | PyObject *const_str_plain_proxy; | ||
| 157 | PyObject *const_str_plain_range; | ||
| 158 | PyObject *const_str_plain_split; | ||
| 159 | PyObject *const_str_plain_strip; | ||
| 160 | PyObject *const_str_plain_throw; | ||
| 161 | PyObject *const_str_plain_tools; | ||
| 162 | PyObject *const_str_plain_tuple; | ||
| 163 | PyObject *const_str_plain_type_; | ||
| 164 | PyObject *const_str_plain_types; | ||
| 165 | PyObject *const_str_plain_value; | ||
| 166 | PyObject *const_str_plain_watch; | ||
| 167 | PyObject *const_str_angle_lambda; | ||
| 168 | PyObject *const_str_plain_Double; | ||
| 169 | PyObject *const_str_plain_GBoxed; | ||
| 170 | PyObject *const_str_plain_GFlags; | ||
| 171 | PyObject *const_str_plain_NewtIO; | ||
| 172 | PyObject *const_str_plain_String; | ||
| 173 | PyObject *const_str_plain_Struct; | ||
| 174 | PyObject *const_str_plain_TextIO; | ||
| 175 | PyObject *const_str_plain_UInt16; | ||
| 176 | PyObject *const_str_plain_UInt32; | ||
| 177 | PyObject *const_str_plain_UInt64; | ||
| 178 | PyObject *const_str_plain__proxy; | ||
| 179 | PyObject *const_str_plain_append; | ||
| 180 | PyObject *const_str_plain_config; | ||
| 181 | PyObject *const_str_plain_create; | ||
| 182 | PyObject *const_str_plain_decode; | ||
| 183 | PyObject *const_str_plain_delete; | ||
| 184 | PyObject *const_str_plain_encode; | ||
| 185 | PyObject *const_str_plain_exists; | ||
| 186 | PyObject *const_str_plain_extend; | ||
| 187 | PyObject *const_str_plain_format; | ||
| 188 | PyObject *const_str_plain_g_type; | ||
| 189 | PyObject *const_str_plain_getpid; | ||
| 190 | PyObject *const_str_plain_getter; | ||
| 191 | PyObject *const_str_plain_getuid; | ||
| 192 | PyObject *const_str_plain_header; | ||
| 193 | PyObject *const_str_plain_ignore; | ||
| 194 | PyObject *const_str_plain_is_py2; | ||
| 195 | PyObject *const_str_plain_is_py3; | ||
| 196 | PyObject *const_str_plain_isfile; | ||
| 197 | PyObject *const_str_plain_kwargs; | ||
| 198 | PyObject *const_str_plain_locals; | ||
| 199 | PyObject *const_str_plain_member; | ||
| 200 | PyObject *const_str_plain_method; | ||
| 201 | PyObject *const_str_plain_module; | ||
| 202 | PyObject *const_str_plain_object; | ||
| 203 | PyObject *const_str_plain_origin; | ||
| 204 | PyObject *const_str_plain_pytype; | ||
| 205 | PyObject *const_str_plain_reason; | ||
| 206 | PyObject *const_str_plain_remove; | ||
| 207 | PyObject *const_str_plain_report; | ||
| 208 | PyObject *const_str_plain_result; | ||
| 209 | PyObject *const_str_plain_rsplit; | ||
| 210 | PyObject *const_str_plain_screen; | ||
| 211 | PyObject *const_str_plain_setter; | ||
| 212 | PyObject *const_str_plain_socket; | ||
| 213 | PyObject *const_str_plain_syslog; | ||
| 214 | PyObject *const_str_plain_update; | ||
| 215 | PyObject *const_tuple_none_tuple; | ||
| 216 | PyObject *const_str_angle_genexpr; | ||
| 217 | PyObject *const_str_plain_AF_UNIX; | ||
| 218 | PyObject *const_str_plain_Boolean; | ||
| 219 | PyObject *const_str_plain_GObject; | ||
| 220 | PyObject *const_str_plain_SHUT_WR; | ||
| 221 | PyObject *const_str_plain_Unknown; | ||
| 222 | PyObject *const_str_plain___all__; | ||
| 223 | PyObject *const_str_plain___cmp__; | ||
| 224 | PyObject *const_str_plain___dir__; | ||
| 225 | PyObject *const_str_plain___doc__; | ||
| 226 | PyObject *const_str_plain___get__; | ||
| 227 | PyObject *const_str_plain___new__; | ||
| 228 | PyObject *const_str_plain___set__; | ||
| 229 | PyObject *const_str_plain___str__; | ||
| 230 | PyObject *const_str_plain__compat; | ||
| 231 | PyObject *const_str_plain__logger; | ||
| 232 | PyObject *const_str_plain_abspath; | ||
| 233 | PyObject *const_str_plain_acquire; | ||
| 234 | PyObject *const_str_plain_compile; | ||
| 235 | PyObject *const_str_plain_connect; | ||
| 236 | PyObject *const_str_plain_delattr; | ||
| 237 | PyObject *const_str_plain_dirname; | ||
| 238 | PyObject *const_str_plain_duphash; | ||
| 239 | PyObject *const_str_plain_environ; | ||
| 240 | PyObject *const_str_plain_globals; | ||
| 241 | PyObject *const_str_plain_gobject; | ||
| 242 | PyObject *const_str_plain_inspect; | ||
| 243 | PyObject *const_str_plain_isdigit; | ||
| 244 | PyObject *const_str_plain_logging; | ||
| 245 | PyObject *const_str_plain_matches; | ||
| 246 | PyObject *const_str_plain_message; | ||
| 247 | PyObject *const_str_plain_modules; | ||
| 248 | PyObject *const_str_plain_orderid; | ||
| 249 | PyObject *const_str_plain_pkgutil; | ||
| 250 | PyObject *const_str_plain_private; | ||
| 251 | PyObject *const_str_plain_problem; | ||
| 252 | PyObject *const_str_plain_proxies; | ||
| 253 | PyObject *const_str_plain_rawhide; | ||
| 254 | PyObject *const_str_plain_release; | ||
| 255 | PyObject *const_str_plain_replace; | ||
| 256 | PyObject *const_str_plain_sendall; | ||
| 257 | PyObject *const_str_plain_systemd; | ||
| 258 | PyObject *const_str_plain_timeout; | ||
| 259 | PyObject *const_str_plain_unicode; | ||
| 260 | PyObject *const_str_plain_version; | ||
| 261 | PyObject *const_str_plain_weakref; | ||
| 262 | PyObject *const_str_plain_wrapper; | ||
| 263 | PyObject *const_tuple_false_tuple; | ||
| 264 | PyObject *const_str_angle_listcomp; | ||
| 265 | PyObject *const_str_plain_TYPE_INT; | ||
| 266 | PyObject *const_str_plain___call__; | ||
| 267 | PyObject *const_str_plain___dict__; | ||
| 268 | PyObject *const_str_plain___exit__; | ||
| 269 | PyObject *const_str_plain___file__; | ||
| 270 | PyObject *const_str_plain___info__; | ||
| 271 | PyObject *const_str_plain___init__; | ||
| 272 | PyObject *const_str_plain___iter__; | ||
| 273 | PyObject *const_str_plain___main__; | ||
| 274 | PyObject *const_str_plain___name__; | ||
| 275 | PyObject *const_str_plain___path__; | ||
| 276 | PyObject *const_str_plain___repr__; | ||
| 277 | PyObject *const_str_plain___spec__; | ||
| 278 | PyObject *const_str_plain__probdir; | ||
| 279 | PyObject *const_str_plain_anaconda; | ||
| 280 | PyObject *const_str_plain_bus_name; | ||
| 281 | PyObject *const_str_plain_callable; | ||
| 282 | PyObject *const_str_plain_callback; | ||
| 283 | PyObject *const_str_plain_datetime; | ||
| 284 | PyObject *const_str_plain_del_item; | ||
| 285 | PyObject *const_str_plain_endswith; | ||
| 286 | PyObject *const_str_plain_exc_info; | ||
| 287 | PyObject *const_str_plain_fromlist; | ||
| 288 | PyObject *const_str_plain_funcName; | ||
| 289 | PyObject *const_str_plain_get_item; | ||
| 290 | PyObject *const_str_plain_get_name; | ||
| 291 | PyObject *const_str_plain_get_size; | ||
| 292 | PyObject *const_str_plain_importer; | ||
| 293 | PyObject *const_str_plain_instance; | ||
| 294 | PyObject *const_str_plain_keywords; | ||
| 295 | PyObject *const_str_plain_list_all; | ||
| 296 | PyObject *const_str_plain_mainloop; | ||
| 297 | PyObject *const_str_plain_override; | ||
| 298 | PyObject *const_str_plain_producer; | ||
| 299 | PyObject *const_str_plain_property; | ||
| 300 | PyObject *const_str_plain_set_item; | ||
| 301 | PyObject *const_str_plain_shutdown; | ||
| 302 | PyObject *const_str_plain_strftime; | ||
| 303 | PyObject *const_str_plain_warnings; | ||
| 304 | PyObject *const_str_angle_metaclass; | ||
| 305 | PyObject *const_str_plain_ByteArray; | ||
| 306 | PyObject *const_str_plain_Interface; | ||
| 307 | PyObject *const_str_plain_Signature; | ||
| 308 | PyObject *const_str_plain_SystemBus; | ||
| 309 | PyObject *const_str_plain_TYPE_CHAR; | ||
| 310 | PyObject *const_str_plain_TYPE_ENUM; | ||
| 311 | PyObject *const_str_plain_TYPE_LONG; | ||
| 312 | PyObject *const_str_plain_TYPE_NONE; | ||
| 313 | PyObject *const_str_plain_TYPE_STRV; | ||
| 314 | PyObject *const_str_plain_TYPE_UINT; | ||
| 315 | PyObject *const_str_plain_VFuncInfo; | ||
| 316 | PyObject *const_str_plain___class__; | ||
| 317 | PyObject *const_str_plain___debug__; | ||
| 318 | PyObject *const_str_plain___enter__; | ||
| 319 | PyObject *const_str_plain___gtype__; | ||
| 320 | PyObject *const_str_plain___slots__; | ||
| 321 | PyObject *const_str_plain_bytearray; | ||
| 322 | PyObject *const_str_plain_enumerate; | ||
| 323 | PyObject *const_str_plain_exception; | ||
| 324 | PyObject *const_str_plain_getLogger; | ||
| 325 | PyObject *const_str_plain_get_proxy; | ||
| 326 | PyObject *const_str_plain_get_value; | ||
| 327 | PyObject *const_str_plain_importlib; | ||
| 328 | PyObject *const_str_plain_interface; | ||
| 329 | PyObject *const_str_plain_metaclass; | ||
| 330 | PyObject *const_str_plain_namespace; | ||
| 331 | PyObject *const_str_plain_overrides; | ||
| 332 | PyObject *const_str_plain_signature; | ||
| 333 | PyObject *const_str_plain_threading; | ||
| 334 | PyObject *const_str_plain_traceback; | ||
| 335 | PyObject *const_tuple_str_dot_tuple; | ||
| 336 | PyObject *const_slice_none_none_none; | ||
| 337 | PyObject *const_str_plain_BUS_SYSTEM; | ||
| 338 | PyObject *const_str_plain_Connection; | ||
| 339 | PyObject *const_str_plain_Dictionary; | ||
| 340 | PyObject *const_str_plain_GInterface; | ||
| 341 | PyObject *const_str_plain_LOCAL_PATH; | ||
| 342 | PyObject *const_str_plain_ModuleType; | ||
| 343 | PyObject *const_str_plain_ObjectInfo; | ||
| 344 | PyObject *const_str_plain_ObjectPath; | ||
| 345 | PyObject *const_str_plain_Repository; | ||
| 346 | PyObject *const_str_plain_SessionBus; | ||
| 347 | PyObject *const_str_plain_StarterBus; | ||
| 348 | PyObject *const_str_plain_StructInfo; | ||
| 349 | PyObject *const_str_plain_StructMeta; | ||
| 350 | PyObject *const_str_plain_TYPE_BOXED; | ||
| 351 | PyObject *const_str_plain_TYPE_FLAGS; | ||
| 352 | PyObject *const_str_plain_TYPE_FLOAT; | ||
| 353 | PyObject *const_str_plain_TYPE_GTYPE; | ||
| 354 | PyObject *const_str_plain_TYPE_INT64; | ||
| 355 | PyObject *const_str_plain_TYPE_PARAM; | ||
| 356 | PyObject *const_str_plain_TYPE_UCHAR; | ||
| 357 | PyObject *const_str_plain_TYPE_ULONG; | ||
| 358 | PyObject *const_str_plain_UTF8String; | ||
| 359 | PyObject *const_str_plain___cached__; | ||
| 360 | PyObject *const_str_plain___import__; | ||
| 361 | PyObject *const_str_plain___loader__; | ||
| 362 | PyObject *const_str_plain___module__; | ||
| 363 | PyObject *const_str_plain__constants; | ||
| 364 | PyObject *const_str_plain__persisted; | ||
| 365 | PyObject *const_str_plain_call_async; | ||
| 366 | PyObject *const_str_plain_exceptions; | ||
| 367 | PyObject *const_str_plain_executable; | ||
| 368 | PyObject *const_str_plain_get_g_type; | ||
| 369 | PyObject *const_str_plain_get_object; | ||
| 370 | PyObject *const_str_plain_identifier; | ||
| 371 | PyObject *const_str_plain_introspect; | ||
| 372 | PyObject *const_str_plain_isinstance; | ||
| 373 | PyObject *const_str_plain_issubclass; | ||
| 374 | PyObject *const_str_plain_problemify; | ||
| 375 | PyObject *const_str_plain_pyanaconda; | ||
| 376 | PyObject *const_str_plain_repository; | ||
| 377 | PyObject *const_str_plain_setdefault; | ||
| 378 | PyObject *const_str_plain_settimeout; | ||
| 379 | PyObject *const_str_plain_stacklevel; | ||
| 380 | PyObject *const_str_plain_startswith; | ||
| 381 | PyObject *const_tuple_type_str_tuple; | ||
| 382 | PyObject *const_str_plain_AuthFailure; | ||
| 383 | PyObject *const_str_plain_BUS_SESSION; | ||
| 384 | PyObject *const_str_plain_BUS_STARTER; | ||
| 385 | PyObject *const_str_plain_GObjectMeta; | ||
| 386 | PyObject *const_str_plain_ImportError; | ||
| 387 | PyObject *const_str_plain_LOCAL_IFACE; | ||
| 388 | PyObject *const_str_plain_ProxyObject; | ||
| 389 | PyObject *const_str_plain_PyGIWarning; | ||
| 390 | PyObject *const_str_plain_SOCK_STREAM; | ||
| 391 | PyObject *const_str_plain_TYPE_DOUBLE; | ||
| 392 | PyObject *const_str_plain_TYPE_OBJECT; | ||
| 393 | PyObject *const_str_plain_TYPE_STRING; | ||
| 394 | PyObject *const_str_plain_TYPE_SYSTEM; | ||
| 395 | PyObject *const_str_plain_TYPE_UINT64; | ||
| 396 | PyObject *const_str_plain___getattr__; | ||
| 397 | PyObject *const_str_plain___getitem__; | ||
| 398 | PyObject *const_str_plain___package__; | ||
| 399 | PyObject *const_str_plain___prepare__; | ||
| 400 | PyObject *const_str_plain___version__; | ||
| 401 | PyObject *const_str_plain__connection; | ||
| 402 | PyObject *const_str_plain_basicConfig; | ||
| 403 | PyObject *const_str_plain_classmethod; | ||
| 404 | PyObject *const_str_plain_collections; | ||
| 405 | PyObject *const_str_plain_extend_path; | ||
| 406 | PyObject *const_str_plain_get_default; | ||
| 407 | PyObject *const_str_plain_get_methods; | ||
| 408 | PyObject *const_str_plain_get_version; | ||
| 409 | PyObject *const_str_plain_method_info; | ||
| 410 | PyObject *const_str_plain_object_path; | ||
| 411 | PyObject *const_str_plain_productName; | ||
| 412 | PyObject *const_str_plain_signal_name; | ||
| 413 | PyObject *const_tuple_int_pos_5_tuple; | ||
| 414 | PyObject *const_tuple_str_empty_tuple; | ||
| 415 | PyObject *const_str_plain_CallableInfo; | ||
| 416 | PyObject *const_str_plain_ErrorMessage; | ||
| 417 | PyObject *const_str_plain_FunctionInfo; | ||
| 418 | PyObject *const_str_plain_TYPE_BOOLEAN; | ||
| 419 | PyObject *const_str_plain_TYPE_INVALID; | ||
| 420 | PyObject *const_str_plain_TYPE_POINTER; | ||
| 421 | PyObject *const_str_plain_TYPE_SESSION; | ||
| 422 | PyObject *const_str_plain_TYPE_STARTER; | ||
| 423 | PyObject *const_str_plain_TYPE_VARIANT; | ||
| 424 | PyObject *const_str_plain___builtins__; | ||
| 425 | PyObject *const_str_plain___compiled__; | ||
| 426 | PyObject *const_str_plain___internal__; | ||
| 427 | PyObject *const_str_plain___qualname__; | ||
| 428 | PyObject *const_str_plain_has_location; | ||
| 429 | PyObject *const_str_plain_problem_data; | ||
| 430 | PyObject *const_str_plain_staticmethod; | ||
| 431 | PyObject *const_str_plain_string_types; | ||
| 432 | PyObject *const_str_plain_threads_init; | ||
| 433 | PyObject *const_str_plain_utf8_strings; | ||
| 434 | PyObject *const_str_plain_version_info; | ||
| 435 | PyObject *const_tuple_str_chr_42_tuple; | ||
| 436 | PyObject *const_tuple_str_chr_61_tuple; | ||
| 437 | PyObject *const_tuple_true_false_tuple; | ||
| 438 | PyObject *const_str_plain_BusConnection; | ||
| 439 | PyObject *const_str_plain_DBusException; | ||
| 440 | PyObject *const_str_plain_DBusGMainLoop; | ||
| 441 | PyObject *const_str_plain_InterfaceInfo; | ||
| 442 | PyObject *const_str_plain_PROBLEM_TYPES; | ||
| 443 | PyObject *const_str_plain_SignalMessage; | ||
| 444 | PyObject *const_str_plain_TYPE_PYOBJECT; | ||
| 445 | PyObject *const_str_plain___docformat__; | ||
| 446 | PyObject *const_str_plain___metaclass__; | ||
| 447 | PyObject *const_str_plain__initializing; | ||
| 448 | PyObject *const_str_plain_call_blocking; | ||
| 449 | PyObject *const_str_plain_error_handler; | ||
| 450 | PyObject *const_str_plain_fromtimestamp; | ||
| 451 | PyObject *const_str_plain_get_arguments; | ||
| 452 | PyObject *const_str_plain_get_dbus_name; | ||
| 453 | PyObject *const_str_plain_get_interface; | ||
| 454 | PyObject *const_str_plain_get_namespace; | ||
| 455 | PyObject *const_str_plain_import_module; | ||
| 456 | PyObject *const_str_plain_named_service; | ||
| 457 | PyObject *const_str_plain_reply_handler; | ||
| 458 | PyObject *const_tuple_int_pos_256_tuple; | ||
| 459 | PyObject *const_tuple_str_newline_tuple; | ||
| 460 | PyObject *const_tuple_str_plain_x_tuple; | ||
| 461 | PyObject *const_tuple_type_object_tuple; | ||
| 462 | PyObject *const_str_plain_AttributeError; | ||
| 463 | PyObject *const_str_plain_InvalidProblem; | ||
| 464 | PyObject *const_str_plain_ProblemWatcher; | ||
| 465 | PyObject *const_str_plain_TYPE_INTERFACE; | ||
| 466 | PyObject *const_str_plain___orig_bases__; | ||
| 467 | PyObject *const_str_plain__dbus_bindings; | ||
| 468 | PyObject *const_str_plain_dbus_interface; | ||
| 469 | PyObject *const_str_plain_importNewOrder; | ||
| 470 | PyObject *const_str_plain_is_constructor; | ||
| 471 | PyObject *const_str_plain_load_overrides; | ||
| 472 | PyObject *const_str_plain_productVersion; | ||
| 473 | PyObject *const_slice_int_pos_1_none_none; | ||
| 474 | PyObject *const_slice_int_pos_3_none_none; | ||
| 475 | PyObject *const_slice_none_int_pos_3_none; | ||
| 476 | PyObject *const_str_plain_BUS_DAEMON_NAME; | ||
| 477 | PyObject *const_str_plain_BUS_DAEMON_PATH; | ||
| 478 | PyObject *const_str_plain_DynamicImporter; | ||
| 479 | PyObject *const_str_plain_ValidationError; | ||
| 480 | PyObject *const_str_plain___annotations__; | ||
| 481 | PyObject *const_str_plain___mro_entries__; | ||
| 482 | PyObject *const_str_plain_absolute_import; | ||
| 483 | PyObject *const_str_plain_install_signals; | ||
| 484 | PyObject *const_tuple_str_plain__gi_tuple; | ||
| 485 | PyObject *const_str_plain_BUS_DAEMON_IFACE; | ||
| 486 | PyObject *const_str_plain_ProxyObjectClass; | ||
| 487 | PyObject *const_str_plain_handler_function; | ||
| 488 | PyObject *const_str_plain_reStructuredText; | ||
| 489 | PyObject *const_str_plain_restructuredtext; | ||
| 490 | PyObject *const_tuple_none_none_none_tuple; | ||
| 491 | PyObject *const_tuple_str_plain_self_tuple; | ||
| 492 | PyObject *const_tuple_str_plain_void_tuple; | ||
| 493 | PyObject *const_tuple_str_plain_warn_tuple; | ||
| 494 | PyObject *const_tuple_type_Exception_tuple; | ||
| 495 | PyObject *const_str_plain_MethodCallMessage; | ||
| 496 | PyObject *const_str_plain_NUITKA_PACKAGE_gi; | ||
| 497 | PyObject *const_str_plain___class_getitem__; | ||
| 498 | PyObject *const_str_plain_importAmazonOrder; | ||
| 499 | PyObject *const_str_plain_require_main_loop; | ||
| 500 | PyObject *const_str_plain_validate_bus_name; | ||
| 501 | PyObject *const_str_plain_DeprecationWarning; | ||
| 502 | PyObject *const_str_plain__require_main_loop; | ||
| 503 | PyObject *const_str_plain_enumerate_versions; | ||
| 504 | PyObject *const_str_plain_install_properties; | ||
| 505 | PyObject *const_tuple_str_plain_is_py2_tuple; | ||
| 506 | PyObject *const_str_plain_MethodReturnMessage; | ||
| 507 | PyObject *const_str_plain_NUITKA_PACKAGE_dbus; | ||
| 508 | PyObject *const_str_plain_NameExistsException; | ||
| 509 | PyObject *const_str_plain_ValidationException; | ||
| 510 | PyObject *const_str_plain_activate_name_owner; | ||
| 511 | PyObject *const_str_plain_add_signal_receiver; | ||
| 512 | PyObject *const_str_plain_generate_doc_string; | ||
| 513 | PyObject *const_str_plain_get_problem_watcher; | ||
| 514 | PyObject *const_str_plain_validate_error_name; | ||
| 515 | PyObject *const_tuple_str_dot_int_pos_1_tuple; | ||
| 516 | PyObject *const_tuple_str_plain_GObject_tuple; | ||
| 517 | PyObject *const_str_plain_INTROSPECTABLE_IFACE; | ||
| 518 | PyObject *const_str_plain_get_required_version; | ||
| 519 | PyObject *const_str_plain_introspection_module; | ||
| 520 | PyObject *const_str_plain_validate_member_name; | ||
| 521 | PyObject *const_str_plain_validate_object_path; | ||
| 522 | PyObject *const_str_plain_DEFAULT_DUMP_LOCATION; | ||
| 523 | PyObject *const_str_plain_NUITKA_PACKAGE_report; | ||
| 524 | PyObject *const_str_plain_set_sender_name_owner; | ||
| 525 | PyObject *const_tuple_int_pos_3_int_pos_3_tuple; | ||
| 526 | PyObject *const_tuple_none_none_none_none_tuple; | ||
| 527 | PyObject *const_tuple_str_plain___class___tuple; | ||
| 528 | PyObject *const_str_plain_PyGIDeprecationWarning; | ||
| 529 | PyObject *const_str_plain_UnknownMethodException; | ||
| 530 | PyObject *const_str_plain__clean_up_signal_match; | ||
| 531 | PyObject *const_tuple_str_plain_UTF8String_tuple; | ||
| 532 | PyObject *const_str_plain_abrt_exception_handler3; | ||
| 533 | PyObject *const_str_plain_validate_interface_name; | ||
| 534 | PyObject *const_tuple_str_plain_PyGIWarning_tuple; | ||
| 535 | PyObject *const_tuple_str_plain_extend_path_tuple; | ||
| 536 | PyObject *const_str_plain_DBUS_START_REPLY_SUCCESS; | ||
| 537 | PyObject *const_str_plain_get_introspection_module; | ||
| 538 | PyObject *const_tuple_str_chr_45_str_plain___tuple; | ||
| 539 | PyObject *const_str_plain_NUITKA_PACKAGE_pyanaconda; | ||
| 540 | PyObject *const_str_plain_follow_name_owner_changes; | ||
| 541 | PyObject *const_tuple_str_plain_BusConnection_tuple; | ||
| 542 | PyObject *const_tuple_str_plain_DBusException_tuple; | ||
| 543 | PyObject *const_str_plain_process_introspection_data; | ||
| 544 | PyObject *const_str_plain_submodule_search_locations; | ||
| 545 | PyObject *const_dict_f154c9a58c9419d7e391901d7b7fe49e; | ||
| 546 | PyObject *const_str_plain_IntrospectionParserException; | ||
| 547 | PyObject *const_str_plain_MissingErrorHandlerException; | ||
| 548 | PyObject *const_str_plain_MissingReplyHandlerException; | ||
| 549 | PyObject *const_str_plain_HANDLER_RESULT_NOT_YET_HANDLED; | ||
| 550 | PyObject *const_tuple_str_plain_named_service_none_tuple; | ||
| 551 | PyObject *const_tuple_str_plain_self_str_plain_name_tuple; | ||
| 552 | PyObject *const_tuple_str_plain_self_str_plain_path_tuple; | ||
| 553 | PyObject *const_str_plain_DBUS_START_REPLY_ALREADY_RUNNING; | ||
| 554 | PyObject *const_str_digest_0292066d9880d6d47806594c17fae043; | ||
| 555 | PyObject *const_str_digest_0b385b2a67f6700b8faf677cdd479207; | ||
| 556 | PyObject *const_str_digest_168dabde1c45fe2c6a98ec9eae56b3f0; | ||
| 557 | PyObject *const_str_digest_176045277faffdb215e36349ee6bf75e; | ||
| 558 | PyObject *const_str_digest_18c67c412066bef703396d613a159b4d; | ||
| 559 | PyObject *const_str_digest_1abd3647207b34d013514bc0c6956d0b; | ||
| 560 | PyObject *const_str_digest_1b131d6ac44490cf7b663211212d8dfa; | ||
| 561 | PyObject *const_str_digest_25731c733fd74e8333aa29126ce85686; | ||
| 562 | PyObject *const_str_digest_286d73d90a388265c9abc0d24ef29c6f; | ||
| 563 | PyObject *const_str_digest_2dddc6e15ab2dcfb5a2b2205b5654fb4; | ||
| 564 | PyObject *const_str_digest_3aa5bee4de9b0149ae46ffed8a38c6b4; | ||
| 565 | PyObject *const_str_digest_3cc8fcb05b60f7b9437930cdc441ce30; | ||
| 566 | PyObject *const_str_digest_4289e46f026bf0dd92edd4764f9ca580; | ||
| 567 | PyObject *const_str_digest_45e4dde2057b0bf276d6a84f4c917d27; | ||
| 568 | PyObject *const_str_digest_5bfaf90dbd407b4fc29090c8f6415242; | ||
| 569 | PyObject *const_str_digest_6090a95f7b926ecd6061b143b7cad52f; | ||
| 570 | PyObject *const_str_digest_62223e4c0fc7bcb5885146e43f1fb665; | ||
| 571 | PyObject *const_str_digest_66f7aeb02c13e91a30a18f0ea911888b; | ||
| 572 | PyObject *const_str_digest_6807157bfb6aeb31712b82d637fd949a; | ||
| 573 | PyObject *const_str_digest_6b7875a4f8a36dd7de7a8976a2d1d45e; | ||
| 574 | PyObject *const_str_digest_6f576c460435f45aaedb10ae95808089; | ||
| 575 | PyObject *const_str_digest_71b716a2e5991dc1dd383ac4073f8ceb; | ||
| 576 | PyObject *const_str_digest_72035249113faa63f8939ea70bf6ef12; | ||
| 577 | PyObject *const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 578 | PyObject *const_str_digest_79ed2cac4e638f0656fd263c1190bdb0; | ||
| 579 | PyObject *const_str_digest_8e2db9d493d0360a27a3bf19583a3201; | ||
| 580 | PyObject *const_str_digest_9816e8d1552296af90d250823c964059; | ||
| 581 | PyObject *const_str_digest_a70d2bed936523093700e5558854519a; | ||
| 582 | PyObject *const_str_digest_adc474dd61fbd736d69c1bac5d9712e0; | ||
| 583 | PyObject *const_str_digest_b0cc034d9177fde48a3b44ac122139d9; | ||
| 584 | PyObject *const_str_digest_b45a3c6f685a3991de51197626bab5ca; | ||
| 585 | PyObject *const_str_digest_b9c4baf879ebd882d40843df3a4dead7; | ||
| 586 | PyObject *const_str_digest_c075052d723d6707083e869a0e3659bb; | ||
| 587 | PyObject *const_str_digest_d7a2d3682b691f7fb6d75512d991b529; | ||
| 588 | PyObject *const_str_digest_db35ab94a03c3cbeb13cbe2a1d728b77; | ||
| 589 | PyObject *const_str_digest_e48610c30fffad33f2054d9dca0792b3; | ||
| 590 | PyObject *const_str_digest_ec911d7d8aa19d9c1e00a67b34952d6e; | ||
| 591 | PyObject *const_str_digest_f4d333e44bfac310ff46328bad2521a0; | ||
| 592 | PyObject *const_str_digest_f570069e0d46f80dd06443468800a290; | ||
| 593 | PyObject *const_str_digest_fdd1f239b4f3ffd6efcccf00e4a637e0; | ||
| 594 | PyObject *const_tuple_str_plain_args_str_plain_kwargs_tuple; | ||
| 595 | PyObject *const_tuple_0bb929f2f11716c81953a0b7b206d455_tuple; | ||
| 596 | PyObject *const_tuple_259a9893e45702189ab930fb0b217a08_tuple; | ||
| 597 | PyObject *const_tuple_76ee81f3638eaf5a352e7276367934cb_tuple; | ||
| 598 | PyObject *const_tuple_c05661dc311559e0338d3f9170078d6a_tuple; | ||
| 599 | PyObject *const_tuple_c715d881e41895e419fdbff3ad722aae_tuple; | ||
| 600 | PyObject *const_tuple_str_plain_PyGIDeprecationWarning_tuple; | ||
| 601 | PyObject *const_tuple_str_plain_self_str_plain_bus_name_tuple; | ||
| 602 | PyObject *const_tuple_str_plain_self_str_plain_instance_tuple; | ||
| 603 | PyObject *const_tuple_str_digest_71b716a2e5991dc1dd383ac4073f8ceb_tuple; | ||
| 604 | PyObject *const_tuple_str_digest_c075052d723d6707083e869a0e3659bb_tuple; | ||
| 605 | PyObject *const_tuple_anon_function_anon_builtin_function_or_method_tuple; | ||
| 606 | PyObject *const_tuple_str_plain_self_str_plain_instance_str_plain_owner_tuple; | ||
| 607 | |||
| 608 | static void _createGlobalConstants( void ) | ||
| 609 | { | ||
| 610 | NUITKA_MAY_BE_UNUSED PyObject *exception_type, *exception_value; | ||
| 611 | NUITKA_MAY_BE_UNUSED PyTracebackObject *exception_tb; | ||
| 612 | |||
| 613 | #ifdef _MSC_VER | ||
| 614 | // Prevent unused warnings in case of simple programs, the attribute | ||
| 615 | // NUITKA_MAY_BE_UNUSED doesn't work for MSVC. | ||
| 616 | (void *)exception_type; (void *)exception_value; (void *)exception_tb; | ||
| 617 | #endif | ||
| 618 | |||
| 619 | const_int_0 = PyLong_FromUnsignedLong( 0ul ); | ||
| 620 | const_str_dot = UNSTREAM_STRING_ASCII( &constant_bin[ 181 ], 1, 0 ); | ||
| 621 | const_int_neg_1 = PyLong_FromLong( -1l ); | ||
| 622 | const_int_pos_1 = PyLong_FromUnsignedLong( 1ul ); | ||
| 623 | const_int_pos_2 = PyLong_FromUnsignedLong( 2ul ); | ||
| 624 | const_int_pos_3 = PyLong_FromUnsignedLong( 3ul ); | ||
| 625 | const_int_pos_4 = PyLong_FromUnsignedLong( 4ul ); | ||
| 626 | const_int_pos_5 = PyLong_FromUnsignedLong( 5ul ); | ||
| 627 | const_int_pos_7 = PyLong_FromUnsignedLong( 7ul ); | ||
| 628 | const_int_pos_8 = PyLong_FromUnsignedLong( 8ul ); | ||
| 629 | const_str_empty = UNSTREAM_STRING_ASCII( &constant_bin[ 0 ], 0, 0 ); | ||
| 630 | const_str_space = UNSTREAM_STRING_ASCII( &constant_bin[ 13 ], 1, 0 ); | ||
| 631 | const_dict_empty = _PyDict_NewPresized( 0 ); | ||
| 632 | assert( PyDict_Size( const_dict_empty ) == 0 ); | ||
| 633 | const_str_chr_42 = UNSTREAM_STRING_ASCII( &constant_bin[ 1088 ], 1, 0 ); | ||
| 634 | const_str_chr_45 = UNSTREAM_STRING_ASCII( &constant_bin[ 520 ], 1, 0 ); | ||
| 635 | const_str_chr_58 = UNSTREAM_STRING_ASCII( &constant_bin[ 387 ], 1, 0 ); | ||
| 636 | const_str_chr_59 = UNSTREAM_STRING_ASCII( &constant_bin[ 16 ], 1, 0 ); | ||
| 637 | const_str_chr_61 = UNSTREAM_STRING_ASCII( &constant_bin[ 14 ], 1, 0 ); | ||
| 638 | const_bytes_empty = UNSTREAM_BYTES( &constant_bin[ 0 ], 0 ); | ||
| 639 | const_int_pos_256 = PyLong_FromUnsignedLong( 256ul ); | ||
| 640 | const_str_newline = UNSTREAM_STRING_ASCII( &constant_bin[ 17 ], 1, 0 ); | ||
| 641 | const_str_plain__ = UNSTREAM_STRING_ASCII( &constant_bin[ 8 ], 1, 1 ); | ||
| 642 | const_str_plain_a = UNSTREAM_STRING_ASCII( &constant_bin[ 27 ], 1, 1 ); | ||
| 643 | const_str_plain_e = UNSTREAM_STRING_ASCII( &constant_bin[ 6 ], 1, 1 ); | ||
| 644 | const_str_plain_i = UNSTREAM_STRING_ASCII( &constant_bin[ 10 ], 1, 1 ); | ||
| 645 | const_str_plain_m = UNSTREAM_STRING_ASCII( &constant_bin[ 146 ], 1, 1 ); | ||
| 646 | const_str_plain_n = UNSTREAM_STRING_ASCII( &constant_bin[ 20 ], 1, 1 ); | ||
| 647 | const_str_plain_r = UNSTREAM_STRING_ASCII( &constant_bin[ 1 ], 1, 1 ); | ||
| 648 | const_str_plain_s = UNSTREAM_STRING_ASCII( &constant_bin[ 11 ], 1, 1 ); | ||
| 649 | const_str_plain_t = UNSTREAM_STRING_ASCII( &constant_bin[ 12 ], 1, 1 ); | ||
| 650 | const_str_plain_x = UNSTREAM_STRING_ASCII( &constant_bin[ 206 ], 1, 1 ); | ||
| 651 | const_str_plain_y = UNSTREAM_STRING_ASCII( &constant_bin[ 48 ], 1, 1 ); | ||
| 652 | const_tuple_empty = PyTuple_New( 0 ); | ||
| 653 | const_str_plain_cb = UNSTREAM_STRING_ASCII( &constant_bin[ 9250 ], 2, 1 ); | ||
| 654 | const_str_plain_ex = UNSTREAM_STRING_ASCII( &constant_bin[ 205 ], 2, 1 ); | ||
| 655 | const_str_plain_gi = UNSTREAM_STRING_ASCII( &constant_bin[ 1135 ], 2, 1 ); | ||
| 656 | const_str_plain_id = UNSTREAM_STRING_ASCII( &constant_bin[ 50 ], 2, 1 ); | ||
| 657 | const_str_plain_io = UNSTREAM_STRING_ASCII( &constant_bin[ 283 ], 2, 1 ); | ||
| 658 | const_str_plain_os = UNSTREAM_STRING_ASCII( &constant_bin[ 279 ], 2, 1 ); | ||
| 659 | const_str_plain_rb = UNSTREAM_STRING_ASCII( &constant_bin[ 12034 ], 2, 1 ); | ||
| 660 | const_str_plain_re = UNSTREAM_STRING_ASCII( &constant_bin[ 25 ], 2, 1 ); | ||
| 661 | const_str_plain_tb = UNSTREAM_STRING_ASCII( &constant_bin[ 1840 ], 2, 1 ); | ||
| 662 | const_str_plain_Bus = UNSTREAM_STRING_ASCII( &constant_bin[ 3096 ], 3, 1 ); | ||
| 663 | const_str_plain__gi = UNSTREAM_STRING_ASCII( &constant_bin[ 46635 ], 3, 1 ); | ||
| 664 | const_str_plain_add = UNSTREAM_STRING_ASCII( &constant_bin[ 9141 ], 3, 1 ); | ||
| 665 | const_str_plain_arg = UNSTREAM_STRING_ASCII( &constant_bin[ 8989 ], 3, 1 ); | ||
| 666 | const_str_plain_buf = UNSTREAM_STRING_ASCII( &constant_bin[ 8025 ], 3, 1 ); | ||
| 667 | const_str_plain_bus = UNSTREAM_STRING_ASCII( &constant_bin[ 3042 ], 3, 1 ); | ||
| 668 | const_str_plain_cls = UNSTREAM_STRING_ASCII( &constant_bin[ 4158 ], 3, 1 ); | ||
| 669 | const_str_plain_do_ = UNSTREAM_STRING_ASCII( &constant_bin[ 39648 ], 3, 1 ); | ||
| 670 | const_str_plain_doc = UNSTREAM_STRING_ASCII( &constant_bin[ 41745 ], 3, 1 ); | ||
| 671 | const_str_plain_end = UNSTREAM_STRING_ASCII( &constant_bin[ 2372 ], 3, 1 ); | ||
| 672 | const_str_plain_exc = UNSTREAM_STRING_ASCII( &constant_bin[ 1823 ], 3, 1 ); | ||
| 673 | const_str_plain_fun = UNSTREAM_STRING_ASCII( &constant_bin[ 1930 ], 3, 1 ); | ||
| 674 | const_str_plain_get = UNSTREAM_STRING_ASCII( &constant_bin[ 491 ], 3, 1 ); | ||
| 675 | const_str_plain_gid = UNSTREAM_STRING_ASCII( &constant_bin[ 1280 ], 3, 1 ); | ||
| 676 | const_str_plain_int = UNSTREAM_STRING_ASCII( &constant_bin[ 1738 ], 3, 1 ); | ||
| 677 | const_str_plain_key = UNSTREAM_STRING_ASCII( &constant_bin[ 9811 ], 3, 1 ); | ||
| 678 | const_str_plain_len = UNSTREAM_STRING_ASCII( &constant_bin[ 44 ], 3, 1 ); | ||
| 679 | const_str_plain_map = UNSTREAM_STRING_ASCII( &constant_bin[ 8088 ], 3, 1 ); | ||
| 680 | const_str_plain_msg = UNSTREAM_STRING_ASCII( &constant_bin[ 20841 ], 3, 1 ); | ||
| 681 | const_str_plain_new = UNSTREAM_STRING_ASCII( &constant_bin[ 668 ], 3, 1 ); | ||
| 682 | const_str_plain_pop = UNSTREAM_STRING_ASCII( &constant_bin[ 75647 ], 3, 1 ); | ||
| 683 | const_str_plain_ret = UNSTREAM_STRING_ASCII( &constant_bin[ 3945 ], 3, 1 ); | ||
| 684 | const_str_plain_row = UNSTREAM_STRING_ASCII( &constant_bin[ 1221 ], 3, 1 ); | ||
| 685 | const_str_plain_str = UNSTREAM_STRING_ASCII( &constant_bin[ 3935 ], 3, 1 ); | ||
| 686 | const_str_plain_sum = UNSTREAM_STRING_ASCII( &constant_bin[ 19905 ], 3, 1 ); | ||
| 687 | const_str_plain_sys = UNSTREAM_STRING_ASCII( &constant_bin[ 2825 ], 3, 1 ); | ||
| 688 | const_str_plain_typ = UNSTREAM_STRING_ASCII( &constant_bin[ 1366 ], 3, 1 ); | ||
| 689 | const_str_plain_uid = UNSTREAM_STRING_ASCII( &constant_bin[ 14554 ], 3, 1 ); | ||
| 690 | const_str_plain_val = UNSTREAM_STRING_ASCII( &constant_bin[ 57 ], 3, 1 ); | ||
| 691 | const_str_plain_zip = UNSTREAM_STRING_ASCII( &constant_bin[ 75650 ], 3, 1 ); | ||
| 692 | const_str_plain_Byte = UNSTREAM_STRING_ASCII( &constant_bin[ 3551 ], 4, 1 ); | ||
| 693 | const_str_plain_None = UNSTREAM_STRING_ASCII( &constant_bin[ 16405 ], 4, 1 ); | ||
| 694 | const_str_plain_UUID = UNSTREAM_STRING_ASCII( &constant_bin[ 63202 ], 4, 1 ); | ||
| 695 | const_str_plain_args = UNSTREAM_STRING_ASCII( &constant_bin[ 15857 ], 4, 1 ); | ||
| 696 | const_str_plain_argv = UNSTREAM_STRING_ASCII( &constant_bin[ 65573 ], 4, 1 ); | ||
| 697 | const_str_plain_attr = UNSTREAM_STRING_ASCII( &constant_bin[ 8562 ], 4, 1 ); | ||
| 698 | const_str_plain_auth = UNSTREAM_STRING_ASCII( &constant_bin[ 28946 ], 4, 1 ); | ||
| 699 | const_str_plain_bool = UNSTREAM_STRING_ASCII( &constant_bin[ 4283 ], 4, 1 ); | ||
| 700 | const_str_plain_conn = UNSTREAM_STRING_ASCII( &constant_bin[ 4400 ], 4, 1 ); | ||
| 701 | const_str_plain_copy = UNSTREAM_STRING_ASCII( &constant_bin[ 36406 ], 4, 1 ); | ||
| 702 | const_str_plain_data = UNSTREAM_STRING_ASCII( &constant_bin[ 2376 ], 4, 1 ); | ||
| 703 | const_str_plain_dbus = UNSTREAM_STRING_ASCII( &constant_bin[ 3041 ], 4, 1 ); | ||
| 704 | const_str_plain_ddir = UNSTREAM_STRING_ASCII( &constant_bin[ 58743 ], 4, 1 ); | ||
| 705 | const_str_plain_dict = UNSTREAM_STRING_ASCII( &constant_bin[ 8083 ], 4, 1 ); | ||
| 706 | const_str_plain_emit = UNSTREAM_STRING_ASCII( &constant_bin[ 16907 ], 4, 1 ); | ||
| 707 | const_str_plain_exit = UNSTREAM_STRING_ASCII( &constant_bin[ 74979 ], 4, 1 ); | ||
| 708 | const_str_plain_file = UNSTREAM_STRING_ASCII( &constant_bin[ 80 ], 4, 1 ); | ||
| 709 | const_str_plain_func = UNSTREAM_STRING_ASCII( &constant_bin[ 1930 ], 4, 1 ); | ||
| 710 | const_str_plain_glib = UNSTREAM_STRING_ASCII( &constant_bin[ 24443 ], 4, 1 ); | ||
| 711 | const_str_plain_info = UNSTREAM_STRING_ASCII( &constant_bin[ 2084 ], 4, 1 ); | ||
| 712 | const_str_plain_is_a = UNSTREAM_STRING_ASCII( &constant_bin[ 75653 ], 4, 1 ); | ||
| 713 | const_str_plain_item = UNSTREAM_STRING_ASCII( &constant_bin[ 155 ], 4, 1 ); | ||
| 714 | const_str_plain_iter = UNSTREAM_STRING_ASCII( &constant_bin[ 21018 ], 4, 1 ); | ||
| 715 | const_str_plain_join = UNSTREAM_STRING_ASCII( &constant_bin[ 75657 ], 4, 1 ); | ||
| 716 | const_str_plain_keys = UNSTREAM_STRING_ASCII( &constant_bin[ 19980 ], 4, 1 ); | ||
| 717 | const_str_plain_list = UNSTREAM_STRING_ASCII( &constant_bin[ 9 ], 4, 1 ); | ||
| 718 | const_str_plain_name = UNSTREAM_STRING_ASCII( &constant_bin[ 433 ], 4, 1 ); | ||
| 719 | const_str_plain_open = UNSTREAM_STRING_ASCII( &constant_bin[ 1778 ], 4, 1 ); | ||
| 720 | const_str_plain_path = UNSTREAM_STRING_ASCII( &constant_bin[ 1013 ], 4, 1 ); | ||
| 721 | const_str_plain_prob = UNSTREAM_STRING_ASCII( &constant_bin[ 29211 ], 4, 1 ); | ||
| 722 | const_str_plain_read = UNSTREAM_STRING_ASCII( &constant_bin[ 25 ], 4, 1 ); | ||
| 723 | const_str_plain_recv = UNSTREAM_STRING_ASCII( &constant_bin[ 75661 ], 4, 1 ); | ||
| 724 | const_str_plain_repr = UNSTREAM_STRING_ASCII( &constant_bin[ 6524 ], 4, 1 ); | ||
| 725 | const_str_plain_rule = UNSTREAM_STRING_ASCII( &constant_bin[ 11499 ], 4, 1 ); | ||
| 726 | const_str_plain_self = UNSTREAM_STRING_ASCII( &constant_bin[ 6530 ], 4, 1 ); | ||
| 727 | const_str_plain_send = UNSTREAM_STRING_ASCII( &constant_bin[ 2494 ], 4, 1 ); | ||
| 728 | const_str_plain_site = UNSTREAM_STRING_ASCII( &constant_bin[ 75665 ], 4, 1 ); | ||
| 729 | const_str_plain_type = UNSTREAM_STRING_ASCII( &constant_bin[ 1366 ], 4, 1 ); | ||
| 730 | const_str_plain_uuid = UNSTREAM_STRING_ASCII( &constant_bin[ 56139 ], 4, 1 ); | ||
| 731 | const_str_plain_void = UNSTREAM_STRING_ASCII( &constant_bin[ 75669 ], 4, 1 ); | ||
| 732 | const_str_plain_warn = UNSTREAM_STRING_ASCII( &constant_bin[ 45385 ], 4, 1 ); | ||
| 733 | const_str_plain_Array = UNSTREAM_STRING_ASCII( &constant_bin[ 3555 ], 5, 1 ); | ||
| 734 | const_str_plain_ERROR = UNSTREAM_STRING_ASCII( &constant_bin[ 24015 ], 5, 1 ); | ||
| 735 | const_str_plain_False = UNSTREAM_STRING_ASCII( &constant_bin[ 17225 ], 5, 1 ); | ||
| 736 | const_str_plain_GEnum = UNSTREAM_STRING_ASCII( &constant_bin[ 75673 ], 5, 1 ); | ||
| 737 | const_str_plain_GTKIO = UNSTREAM_STRING_ASCII( &constant_bin[ 62732 ], 5, 1 ); | ||
| 738 | const_str_plain_GType = UNSTREAM_STRING_ASCII( &constant_bin[ 40304 ], 5, 1 ); | ||
| 739 | const_str_plain_Int16 = UNSTREAM_STRING_ASCII( &constant_bin[ 3588 ], 5, 1 ); | ||
| 740 | const_str_plain_Int32 = UNSTREAM_STRING_ASCII( &constant_bin[ 3603 ], 5, 1 ); | ||
| 741 | const_str_plain_Int64 = UNSTREAM_STRING_ASCII( &constant_bin[ 3618 ], 5, 1 ); | ||
| 742 | const_str_plain_bases = UNSTREAM_STRING_ASCII( &constant_bin[ 36095 ], 5, 1 ); | ||
| 743 | const_str_plain_bytes = UNSTREAM_STRING_ASCII( &constant_bin[ 66734 ], 5, 1 ); | ||
| 744 | const_str_plain_chown = UNSTREAM_STRING_ASCII( &constant_bin[ 57640 ], 5, 1 ); | ||
| 745 | const_str_plain_close = UNSTREAM_STRING_ASCII( &constant_bin[ 7180 ], 5, 1 ); | ||
| 746 | const_str_plain_debug = UNSTREAM_STRING_ASCII( &constant_bin[ 75678 ], 5, 1 ); | ||
| 747 | const_str_plain_dict_ = UNSTREAM_STRING_ASCII( &constant_bin[ 75683 ], 5, 1 ); | ||
| 748 | const_str_plain_entry = UNSTREAM_STRING_ASCII( &constant_bin[ 54530 ], 5, 1 ); | ||
| 749 | const_str_plain_error = UNSTREAM_STRING_ASCII( &constant_bin[ 2488 ], 5, 1 ); | ||
| 750 | const_str_plain_field = UNSTREAM_STRING_ASCII( &constant_bin[ 52861 ], 5, 1 ); | ||
| 751 | const_str_plain_flags = UNSTREAM_STRING_ASCII( &constant_bin[ 12278 ], 5, 1 ); | ||
| 752 | const_str_plain_float = UNSTREAM_STRING_ASCII( &constant_bin[ 36297 ], 5, 1 ); | ||
| 753 | const_str_plain_iface = UNSTREAM_STRING_ASCII( &constant_bin[ 7995 ], 5, 1 ); | ||
| 754 | const_str_plain_index = UNSTREAM_STRING_ASCII( &constant_bin[ 19772 ], 5, 1 ); | ||
| 755 | const_str_plain_items = UNSTREAM_STRING_ASCII( &constant_bin[ 155 ], 5, 1 ); | ||
| 756 | const_str_plain_klass = UNSTREAM_STRING_ASCII( &constant_bin[ 52300 ], 5, 1 ); | ||
| 757 | const_str_plain_level = UNSTREAM_STRING_ASCII( &constant_bin[ 3869 ], 5, 1 ); | ||
| 758 | const_str_plain_limit = UNSTREAM_STRING_ASCII( &constant_bin[ 54308 ], 5, 1 ); | ||
| 759 | const_str_plain_long_ = UNSTREAM_STRING_ASCII( &constant_bin[ 75688 ], 5, 1 ); | ||
| 760 | const_str_plain_lower = UNSTREAM_STRING_ASCII( &constant_bin[ 40031 ], 5, 1 ); | ||
| 761 | const_str_plain_match = UNSTREAM_STRING_ASCII( &constant_bin[ 8757 ], 5, 1 ); | ||
| 762 | const_str_plain_owner = UNSTREAM_STRING_ASCII( &constant_bin[ 9122 ], 5, 1 ); | ||
| 763 | const_str_plain_print = UNSTREAM_STRING_ASCII( &constant_bin[ 42600 ], 5, 1 ); | ||
| 764 | const_str_plain_proxy = UNSTREAM_STRING_ASCII( &constant_bin[ 9496 ], 5, 1 ); | ||
| 765 | const_str_plain_range = UNSTREAM_STRING_ASCII( &constant_bin[ 11412 ], 5, 1 ); | ||
| 766 | const_str_plain_split = UNSTREAM_STRING_ASCII( &constant_bin[ 1161 ], 5, 1 ); | ||
| 767 | const_str_plain_strip = UNSTREAM_STRING_ASCII( &constant_bin[ 48543 ], 5, 1 ); | ||
| 768 | const_str_plain_throw = UNSTREAM_STRING_ASCII( &constant_bin[ 75693 ], 5, 1 ); | ||
| 769 | const_str_plain_tools = UNSTREAM_STRING_ASCII( &constant_bin[ 59485 ], 5, 1 ); | ||
| 770 | const_str_plain_tuple = UNSTREAM_STRING_ASCII( &constant_bin[ 12417 ], 5, 1 ); | ||
| 771 | const_str_plain_type_ = UNSTREAM_STRING_ASCII( &constant_bin[ 39358 ], 5, 1 ); | ||
| 772 | const_str_plain_types = UNSTREAM_STRING_ASCII( &constant_bin[ 1366 ], 5, 1 ); | ||
| 773 | const_str_plain_value = UNSTREAM_STRING_ASCII( &constant_bin[ 1185 ], 5, 1 ); | ||
| 774 | const_str_plain_watch = UNSTREAM_STRING_ASCII( &constant_bin[ 12010 ], 5, 1 ); | ||
| 775 | const_str_angle_lambda = UNSTREAM_STRING_ASCII( &constant_bin[ 2421 ], 8, 0 ); | ||
| 776 | const_str_plain_Double = UNSTREAM_STRING_ASCII( &constant_bin[ 3633 ], 6, 1 ); | ||
| 777 | const_str_plain_GBoxed = UNSTREAM_STRING_ASCII( &constant_bin[ 75698 ], 6, 1 ); | ||
| 778 | const_str_plain_GFlags = UNSTREAM_STRING_ASCII( &constant_bin[ 75704 ], 6, 1 ); | ||
| 779 | const_str_plain_NewtIO = UNSTREAM_STRING_ASCII( &constant_bin[ 62818 ], 6, 1 ); | ||
| 780 | const_str_plain_String = UNSTREAM_STRING_ASCII( &constant_bin[ 3641 ], 6, 1 ); | ||
| 781 | const_str_plain_Struct = UNSTREAM_STRING_ASCII( &constant_bin[ 3656 ], 6, 1 ); | ||
| 782 | const_str_plain_TextIO = UNSTREAM_STRING_ASCII( &constant_bin[ 62869 ], 6, 1 ); | ||
| 783 | const_str_plain_UInt16 = UNSTREAM_STRING_ASCII( &constant_bin[ 3595 ], 6, 1 ); | ||
| 784 | const_str_plain_UInt32 = UNSTREAM_STRING_ASCII( &constant_bin[ 3610 ], 6, 1 ); | ||
| 785 | const_str_plain_UInt64 = UNSTREAM_STRING_ASCII( &constant_bin[ 3625 ], 6, 1 ); | ||
| 786 | const_str_plain__proxy = UNSTREAM_STRING_ASCII( &constant_bin[ 29392 ], 6, 1 ); | ||
| 787 | const_str_plain_append = UNSTREAM_STRING_ASCII( &constant_bin[ 33578 ], 6, 1 ); | ||
| 788 | const_str_plain_config = UNSTREAM_STRING_ASCII( &constant_bin[ 18 ], 6, 1 ); | ||
| 789 | const_str_plain_create = UNSTREAM_STRING_ASCII( &constant_bin[ 659 ], 6, 1 ); | ||
| 790 | const_str_plain_decode = UNSTREAM_STRING_ASCII( &constant_bin[ 75710 ], 6, 1 ); | ||
| 791 | const_str_plain_delete = UNSTREAM_STRING_ASCII( &constant_bin[ 47764 ], 6, 1 ); | ||
| 792 | const_str_plain_encode = UNSTREAM_STRING_ASCII( &constant_bin[ 75716 ], 6, 1 ); | ||
| 793 | const_str_plain_exists = UNSTREAM_STRING_ASCII( &constant_bin[ 21490 ], 6, 1 ); | ||
| 794 | const_str_plain_extend = UNSTREAM_STRING_ASCII( &constant_bin[ 75722 ], 6, 1 ); | ||
| 795 | const_str_plain_format = UNSTREAM_STRING_ASCII( &constant_bin[ 320 ], 6, 1 ); | ||
| 796 | const_str_plain_g_type = UNSTREAM_STRING_ASCII( &constant_bin[ 20075 ], 6, 1 ); | ||
| 797 | const_str_plain_getpid = UNSTREAM_STRING_ASCII( &constant_bin[ 75728 ], 6, 1 ); | ||
| 798 | const_str_plain_getter = UNSTREAM_STRING_ASCII( &constant_bin[ 37518 ], 6, 1 ); | ||
| 799 | const_str_plain_getuid = UNSTREAM_STRING_ASCII( &constant_bin[ 75734 ], 6, 1 ); | ||
| 800 | const_str_plain_header = UNSTREAM_STRING_ASCII( &constant_bin[ 381 ], 6, 1 ); | ||
| 801 | const_str_plain_ignore = UNSTREAM_STRING_ASCII( &constant_bin[ 11565 ], 6, 1 ); | ||
| 802 | const_str_plain_is_py2 = UNSTREAM_STRING_ASCII( &constant_bin[ 75740 ], 6, 1 ); | ||
| 803 | const_str_plain_is_py3 = UNSTREAM_STRING_ASCII( &constant_bin[ 75746 ], 6, 1 ); | ||
| 804 | const_str_plain_isfile = UNSTREAM_STRING_ASCII( &constant_bin[ 75752 ], 6, 1 ); | ||
| 805 | const_str_plain_kwargs = UNSTREAM_STRING_ASCII( &constant_bin[ 48591 ], 6, 1 ); | ||
| 806 | const_str_plain_locals = UNSTREAM_STRING_ASCII( &constant_bin[ 193 ], 6, 1 ); | ||
| 807 | const_str_plain_member = UNSTREAM_STRING_ASCII( &constant_bin[ 3335 ], 6, 1 ); | ||
| 808 | const_str_plain_method = UNSTREAM_STRING_ASCII( &constant_bin[ 4910 ], 6, 1 ); | ||
| 809 | const_str_plain_module = UNSTREAM_STRING_ASCII( &constant_bin[ 1760 ], 6, 1 ); | ||
| 810 | const_str_plain_object = UNSTREAM_STRING_ASCII( &constant_bin[ 3146 ], 6, 1 ); | ||
| 811 | const_str_plain_origin = UNSTREAM_STRING_ASCII( &constant_bin[ 10537 ], 6, 1 ); | ||
| 812 | const_str_plain_pytype = UNSTREAM_STRING_ASCII( &constant_bin[ 39499 ], 6, 1 ); | ||
| 813 | const_str_plain_reason = UNSTREAM_STRING_ASCII( &constant_bin[ 2360 ], 6, 1 ); | ||
| 814 | const_str_plain_remove = UNSTREAM_STRING_ASCII( &constant_bin[ 9384 ], 6, 1 ); | ||
| 815 | const_str_plain_report = UNSTREAM_STRING_ASCII( &constant_bin[ 73 ], 6, 1 ); | ||
| 816 | const_str_plain_result = UNSTREAM_STRING_ASCII( &constant_bin[ 45054 ], 6, 1 ); | ||
| 817 | const_str_plain_rsplit = UNSTREAM_STRING_ASCII( &constant_bin[ 75758 ], 6, 1 ); | ||
| 818 | const_str_plain_screen = UNSTREAM_STRING_ASCII( &constant_bin[ 75764 ], 6, 1 ); | ||
| 819 | const_str_plain_setter = UNSTREAM_STRING_ASCII( &constant_bin[ 36640 ], 6, 1 ); | ||
| 820 | const_str_plain_socket = UNSTREAM_STRING_ASCII( &constant_bin[ 75770 ], 6, 1 ); | ||
| 821 | const_str_plain_syslog = UNSTREAM_STRING_ASCII( &constant_bin[ 65893 ], 6, 1 ); | ||
| 822 | const_str_plain_update = UNSTREAM_STRING_ASCII( &constant_bin[ 51120 ], 6, 1 ); | ||
| 823 | const_tuple_none_tuple = PyTuple_New( 1 ); | ||
| 824 | PyTuple_SET_ITEM( const_tuple_none_tuple, 0, Py_None ); Py_INCREF( Py_None ); | ||
| 825 | const_str_angle_genexpr = UNSTREAM_STRING_ASCII( &constant_bin[ 201 ], 9, 0 ); | ||
| 826 | const_str_plain_AF_UNIX = UNSTREAM_STRING_ASCII( &constant_bin[ 75776 ], 7, 1 ); | ||
| 827 | const_str_plain_Boolean = UNSTREAM_STRING_ASCII( &constant_bin[ 3579 ], 7, 1 ); | ||
| 828 | const_str_plain_GObject = UNSTREAM_STRING_ASCII( &constant_bin[ 35231 ], 7, 1 ); | ||
| 829 | const_str_plain_SHUT_WR = UNSTREAM_STRING_ASCII( &constant_bin[ 75783 ], 7, 1 ); | ||
| 830 | const_str_plain_Unknown = UNSTREAM_STRING_ASCII( &constant_bin[ 3802 ], 7, 1 ); | ||
| 831 | const_str_plain___all__ = UNSTREAM_STRING_ASCII( &constant_bin[ 49953 ], 7, 1 ); | ||
| 832 | const_str_plain___cmp__ = UNSTREAM_STRING_ASCII( &constant_bin[ 75790 ], 7, 1 ); | ||
| 833 | const_str_plain___dir__ = UNSTREAM_STRING_ASCII( &constant_bin[ 46917 ], 7, 1 ); | ||
| 834 | const_str_plain___doc__ = UNSTREAM_STRING_ASCII( &constant_bin[ 52996 ], 7, 1 ); | ||
| 835 | const_str_plain___get__ = UNSTREAM_STRING_ASCII( &constant_bin[ 40253 ], 7, 1 ); | ||
| 836 | const_str_plain___new__ = UNSTREAM_STRING_ASCII( &constant_bin[ 7169 ], 7, 1 ); | ||
| 837 | const_str_plain___set__ = UNSTREAM_STRING_ASCII( &constant_bin[ 39227 ], 7, 1 ); | ||
| 838 | const_str_plain___str__ = UNSTREAM_STRING_ASCII( &constant_bin[ 22554 ], 7, 1 ); | ||
| 839 | const_str_plain__compat = UNSTREAM_STRING_ASCII( &constant_bin[ 3892 ], 7, 1 ); | ||
| 840 | const_str_plain__logger = UNSTREAM_STRING_ASCII( &constant_bin[ 69393 ], 7, 1 ); | ||
| 841 | const_str_plain_abspath = UNSTREAM_STRING_ASCII( &constant_bin[ 75797 ], 7, 1 ); | ||
| 842 | const_str_plain_acquire = UNSTREAM_STRING_ASCII( &constant_bin[ 75804 ], 7, 1 ); | ||
| 843 | const_str_plain_compile = UNSTREAM_STRING_ASCII( &constant_bin[ 75811 ], 7, 1 ); | ||
| 844 | const_str_plain_connect = UNSTREAM_STRING_ASCII( &constant_bin[ 4400 ], 7, 1 ); | ||
| 845 | const_str_plain_delattr = UNSTREAM_STRING_ASCII( &constant_bin[ 57496 ], 7, 1 ); | ||
| 846 | const_str_plain_dirname = UNSTREAM_STRING_ASCII( &constant_bin[ 75818 ], 7, 1 ); | ||
| 847 | const_str_plain_duphash = UNSTREAM_STRING_ASCII( &constant_bin[ 75825 ], 7, 1 ); | ||
| 848 | const_str_plain_environ = UNSTREAM_STRING_ASCII( &constant_bin[ 55641 ], 7, 1 ); | ||
| 849 | const_str_plain_globals = UNSTREAM_STRING_ASCII( &constant_bin[ 75832 ], 7, 1 ); | ||
| 850 | const_str_plain_gobject = UNSTREAM_STRING_ASCII( &constant_bin[ 34100 ], 7, 1 ); | ||
| 851 | const_str_plain_inspect = UNSTREAM_STRING_ASCII( &constant_bin[ 75839 ], 7, 1 ); | ||
| 852 | const_str_plain_isdigit = UNSTREAM_STRING_ASCII( &constant_bin[ 75846 ], 7, 1 ); | ||
| 853 | const_str_plain_logging = UNSTREAM_STRING_ASCII( &constant_bin[ 67002 ], 7, 1 ); | ||
| 854 | const_str_plain_matches = UNSTREAM_STRING_ASCII( &constant_bin[ 12743 ], 7, 1 ); | ||
| 855 | const_str_plain_message = UNSTREAM_STRING_ASCII( &constant_bin[ 2814 ], 7, 1 ); | ||
| 856 | const_str_plain_modules = UNSTREAM_STRING_ASCII( &constant_bin[ 34238 ], 7, 1 ); | ||
| 857 | const_str_plain_orderid = UNSTREAM_STRING_ASCII( &constant_bin[ 54585 ], 7, 1 ); | ||
| 858 | const_str_plain_pkgutil = UNSTREAM_STRING_ASCII( &constant_bin[ 75853 ], 7, 1 ); | ||
| 859 | const_str_plain_private = UNSTREAM_STRING_ASCII( &constant_bin[ 4272 ], 7, 1 ); | ||
| 860 | const_str_plain_problem = UNSTREAM_STRING_ASCII( &constant_bin[ 29211 ], 7, 1 ); | ||
| 861 | const_str_plain_proxies = UNSTREAM_STRING_ASCII( &constant_bin[ 10961 ], 7, 1 ); | ||
| 862 | const_str_plain_rawhide = UNSTREAM_STRING_ASCII( &constant_bin[ 75860 ], 7, 1 ); | ||
| 863 | const_str_plain_release = UNSTREAM_STRING_ASCII( &constant_bin[ 12677 ], 7, 1 ); | ||
| 864 | const_str_plain_replace = UNSTREAM_STRING_ASCII( &constant_bin[ 48143 ], 7, 1 ); | ||
| 865 | const_str_plain_sendall = UNSTREAM_STRING_ASCII( &constant_bin[ 75867 ], 7, 1 ); | ||
| 866 | const_str_plain_systemd = UNSTREAM_STRING_ASCII( &constant_bin[ 62934 ], 7, 1 ); | ||
| 867 | const_str_plain_timeout = UNSTREAM_STRING_ASCII( &constant_bin[ 64557 ], 7, 1 ); | ||
| 868 | const_str_plain_unicode = UNSTREAM_STRING_ASCII( &constant_bin[ 17348 ], 7, 1 ); | ||
| 869 | const_str_plain_version = UNSTREAM_STRING_ASCII( &constant_bin[ 1988 ], 7, 1 ); | ||
| 870 | const_str_plain_weakref = UNSTREAM_STRING_ASCII( &constant_bin[ 19552 ], 7, 1 ); | ||
| 871 | const_str_plain_wrapper = UNSTREAM_STRING_ASCII( &constant_bin[ 4829 ], 7, 1 ); | ||
| 872 | const_tuple_false_tuple = PyTuple_New( 1 ); | ||
| 873 | PyTuple_SET_ITEM( const_tuple_false_tuple, 0, Py_False ); Py_INCREF( Py_False ); | ||
| 874 | const_str_angle_listcomp = UNSTREAM_STRING_ASCII( &constant_bin[ 75874 ], 10, 0 ); | ||
| 875 | const_str_plain_TYPE_INT = UNSTREAM_STRING_ASCII( &constant_bin[ 36995 ], 8, 1 ); | ||
| 876 | const_str_plain___call__ = UNSTREAM_STRING_ASCII( &constant_bin[ 28408 ], 8, 1 ); | ||
| 877 | const_str_plain___dict__ = UNSTREAM_STRING_ASCII( &constant_bin[ 75884 ], 8, 1 ); | ||
| 878 | const_str_plain___exit__ = UNSTREAM_STRING_ASCII( &constant_bin[ 75892 ], 8, 1 ); | ||
| 879 | const_str_plain___file__ = UNSTREAM_STRING_ASCII( &constant_bin[ 75900 ], 8, 1 ); | ||
| 880 | const_str_plain___info__ = UNSTREAM_STRING_ASCII( &constant_bin[ 75908 ], 8, 1 ); | ||
| 881 | const_str_plain___init__ = UNSTREAM_STRING_ASCII( &constant_bin[ 3186 ], 8, 1 ); | ||
| 882 | const_str_plain___iter__ = UNSTREAM_STRING_ASCII( &constant_bin[ 68673 ], 8, 1 ); | ||
| 883 | const_str_plain___main__ = UNSTREAM_STRING_ASCII( &constant_bin[ 75916 ], 8, 1 ); | ||
| 884 | const_str_plain___name__ = UNSTREAM_STRING_ASCII( &constant_bin[ 75924 ], 8, 1 ); | ||
| 885 | const_str_plain___path__ = UNSTREAM_STRING_ASCII( &constant_bin[ 75932 ], 8, 1 ); | ||
| 886 | const_str_plain___repr__ = UNSTREAM_STRING_ASCII( &constant_bin[ 6522 ], 8, 1 ); | ||
| 887 | const_str_plain___spec__ = UNSTREAM_STRING_ASCII( &constant_bin[ 75940 ], 8, 1 ); | ||
| 888 | const_str_plain__probdir = UNSTREAM_STRING_ASCII( &constant_bin[ 75948 ], 8, 1 ); | ||
| 889 | const_str_plain_anaconda = UNSTREAM_STRING_ASCII( &constant_bin[ 60248 ], 8, 1 ); | ||
| 890 | const_str_plain_bus_name = UNSTREAM_STRING_ASCII( &constant_bin[ 3357 ], 8, 1 ); | ||
| 891 | const_str_plain_callable = UNSTREAM_STRING_ASCII( &constant_bin[ 16064 ], 8, 1 ); | ||
| 892 | const_str_plain_callback = UNSTREAM_STRING_ASCII( &constant_bin[ 11170 ], 8, 1 ); | ||
| 893 | const_str_plain_datetime = UNSTREAM_STRING_ASCII( &constant_bin[ 64146 ], 8, 1 ); | ||
| 894 | const_str_plain_del_item = UNSTREAM_STRING_ASCII( &constant_bin[ 58799 ], 8, 1 ); | ||
| 895 | const_str_plain_endswith = UNSTREAM_STRING_ASCII( &constant_bin[ 75956 ], 8, 1 ); | ||
| 896 | const_str_plain_exc_info = UNSTREAM_STRING_ASCII( &constant_bin[ 75964 ], 8, 1 ); | ||
| 897 | const_str_plain_fromlist = UNSTREAM_STRING_ASCII( &constant_bin[ 75972 ], 8, 1 ); | ||
| 898 | const_str_plain_funcName = UNSTREAM_STRING_ASCII( &constant_bin[ 75980 ], 8, 1 ); | ||
| 899 | const_str_plain_get_item = UNSTREAM_STRING_ASCII( &constant_bin[ 59020 ], 8, 1 ); | ||
| 900 | const_str_plain_get_name = UNSTREAM_STRING_ASCII( &constant_bin[ 9113 ], 8, 1 ); | ||
| 901 | const_str_plain_get_size = UNSTREAM_STRING_ASCII( &constant_bin[ 75988 ], 8, 1 ); | ||
| 902 | const_str_plain_importer = UNSTREAM_STRING_ASCII( &constant_bin[ 45296 ], 8, 1 ); | ||
| 903 | const_str_plain_instance = UNSTREAM_STRING_ASCII( &constant_bin[ 3923 ], 8, 1 ); | ||
| 904 | const_str_plain_keywords = UNSTREAM_STRING_ASCII( &constant_bin[ 75996 ], 8, 1 ); | ||
| 905 | const_str_plain_list_all = UNSTREAM_STRING_ASCII( &constant_bin[ 58669 ], 8, 1 ); | ||
| 906 | const_str_plain_mainloop = UNSTREAM_STRING_ASCII( &constant_bin[ 3856 ], 8, 1 ); | ||
| 907 | const_str_plain_override = UNSTREAM_STRING_ASCII( &constant_bin[ 35556 ], 8, 1 ); | ||
| 908 | const_str_plain_producer = UNSTREAM_STRING_ASCII( &constant_bin[ 0 ], 8, 1 ); | ||
| 909 | const_str_plain_property = UNSTREAM_STRING_ASCII( &constant_bin[ 27779 ], 8, 1 ); | ||
| 910 | const_str_plain_set_item = UNSTREAM_STRING_ASCII( &constant_bin[ 58647 ], 8, 1 ); | ||
| 911 | const_str_plain_shutdown = UNSTREAM_STRING_ASCII( &constant_bin[ 76004 ], 8, 1 ); | ||
| 912 | const_str_plain_strftime = UNSTREAM_STRING_ASCII( &constant_bin[ 76012 ], 8, 1 ); | ||
| 913 | const_str_plain_warnings = UNSTREAM_STRING_ASCII( &constant_bin[ 45385 ], 8, 1 ); | ||
| 914 | const_str_angle_metaclass = UNSTREAM_STRING_ASCII( &constant_bin[ 76020 ], 11, 0 ); | ||
| 915 | const_str_plain_ByteArray = UNSTREAM_STRING_ASCII( &constant_bin[ 3551 ], 9, 1 ); | ||
| 916 | const_str_plain_Interface = UNSTREAM_STRING_ASCII( &constant_bin[ 3244 ], 9, 1 ); | ||
| 917 | const_str_plain_Signature = UNSTREAM_STRING_ASCII( &constant_bin[ 3562 ], 9, 1 ); | ||
| 918 | const_str_plain_SystemBus = UNSTREAM_STRING_ASCII( &constant_bin[ 3209 ], 9, 1 ); | ||
| 919 | const_str_plain_TYPE_CHAR = UNSTREAM_STRING_ASCII( &constant_bin[ 37011 ], 9, 1 ); | ||
| 920 | const_str_plain_TYPE_ENUM = UNSTREAM_STRING_ASCII( &constant_bin[ 37117 ], 9, 1 ); | ||
| 921 | const_str_plain_TYPE_LONG = UNSTREAM_STRING_ASCII( &constant_bin[ 37069 ], 9, 1 ); | ||
| 922 | const_str_plain_TYPE_NONE = UNSTREAM_STRING_ASCII( &constant_bin[ 36984 ], 9, 1 ); | ||
| 923 | const_str_plain_TYPE_STRV = UNSTREAM_STRING_ASCII( &constant_bin[ 37256 ], 9, 1 ); | ||
| 924 | const_str_plain_TYPE_UINT = UNSTREAM_STRING_ASCII( &constant_bin[ 37058 ], 9, 1 ); | ||
| 925 | const_str_plain_VFuncInfo = UNSTREAM_STRING_ASCII( &constant_bin[ 76031 ], 9, 1 ); | ||
| 926 | const_str_plain___class__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76040 ], 9, 1 ); | ||
| 927 | const_str_plain___debug__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76049 ], 9, 1 ); | ||
| 928 | const_str_plain___enter__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76058 ], 9, 1 ); | ||
| 929 | const_str_plain___gtype__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76067 ], 9, 1 ); | ||
| 930 | const_str_plain___slots__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76076 ], 9, 1 ); | ||
| 931 | const_str_plain_bytearray = UNSTREAM_STRING_ASCII( &constant_bin[ 76085 ], 9, 1 ); | ||
| 932 | const_str_plain_enumerate = UNSTREAM_STRING_ASCII( &constant_bin[ 76094 ], 9, 1 ); | ||
| 933 | const_str_plain_exception = UNSTREAM_STRING_ASCII( &constant_bin[ 1823 ], 9, 1 ); | ||
| 934 | const_str_plain_getLogger = UNSTREAM_STRING_ASCII( &constant_bin[ 69376 ], 9, 1 ); | ||
| 935 | const_str_plain_get_proxy = UNSTREAM_STRING_ASCII( &constant_bin[ 76103 ], 9, 1 ); | ||
| 936 | const_str_plain_get_value = UNSTREAM_STRING_ASCII( &constant_bin[ 46521 ], 9, 1 ); | ||
| 937 | const_str_plain_importlib = UNSTREAM_STRING_ASCII( &constant_bin[ 54099 ], 9, 1 ); | ||
| 938 | const_str_plain_interface = UNSTREAM_STRING_ASCII( &constant_bin[ 3310 ], 9, 1 ); | ||
| 939 | const_str_plain_metaclass = UNSTREAM_STRING_ASCII( &constant_bin[ 39560 ], 9, 1 ); | ||
| 940 | const_str_plain_namespace = UNSTREAM_STRING_ASCII( &constant_bin[ 34576 ], 9, 1 ); | ||
| 941 | const_str_plain_overrides = UNSTREAM_STRING_ASCII( &constant_bin[ 35556 ], 9, 1 ); | ||
| 942 | const_str_plain_signature = UNSTREAM_STRING_ASCII( &constant_bin[ 10139 ], 9, 1 ); | ||
| 943 | const_str_plain_threading = UNSTREAM_STRING_ASCII( &constant_bin[ 33959 ], 9, 1 ); | ||
| 944 | const_str_plain_traceback = UNSTREAM_STRING_ASCII( &constant_bin[ 23222 ], 9, 1 ); | ||
| 945 | const_tuple_str_dot_tuple = PyTuple_New( 1 ); | ||
| 946 | PyTuple_SET_ITEM( const_tuple_str_dot_tuple, 0, const_str_dot ); Py_INCREF( const_str_dot ); | ||
| 947 | const_slice_none_none_none = PySlice_New( Py_None, Py_None, Py_None ); | ||
| 948 | const_str_plain_BUS_SYSTEM = UNSTREAM_STRING_ASCII( &constant_bin[ 13661 ], 10, 1 ); | ||
| 949 | const_str_plain_Connection = UNSTREAM_STRING_ASCII( &constant_bin[ 4472 ], 10, 1 ); | ||
| 950 | const_str_plain_Dictionary = UNSTREAM_STRING_ASCII( &constant_bin[ 3664 ], 10, 1 ); | ||
| 951 | const_str_plain_GInterface = UNSTREAM_STRING_ASCII( &constant_bin[ 76112 ], 10, 1 ); | ||
| 952 | const_str_plain_LOCAL_PATH = UNSTREAM_STRING_ASCII( &constant_bin[ 3462 ], 10, 1 ); | ||
| 953 | const_str_plain_ModuleType = UNSTREAM_STRING_ASCII( &constant_bin[ 76122 ], 10, 1 ); | ||
| 954 | const_str_plain_ObjectInfo = UNSTREAM_STRING_ASCII( &constant_bin[ 76132 ], 10, 1 ); | ||
| 955 | const_str_plain_ObjectPath = UNSTREAM_STRING_ASCII( &constant_bin[ 3539 ], 10, 1 ); | ||
| 956 | const_str_plain_Repository = UNSTREAM_STRING_ASCII( &constant_bin[ 45807 ], 10, 1 ); | ||
| 957 | const_str_plain_SessionBus = UNSTREAM_STRING_ASCII( &constant_bin[ 3220 ], 10, 1 ); | ||
| 958 | const_str_plain_StarterBus = UNSTREAM_STRING_ASCII( &constant_bin[ 3232 ], 10, 1 ); | ||
| 959 | const_str_plain_StructInfo = UNSTREAM_STRING_ASCII( &constant_bin[ 76142 ], 10, 1 ); | ||
| 960 | const_str_plain_StructMeta = UNSTREAM_STRING_ASCII( &constant_bin[ 52985 ], 10, 1 ); | ||
| 961 | const_str_plain_TYPE_BOXED = UNSTREAM_STRING_ASCII( &constant_bin[ 37192 ], 10, 1 ); | ||
| 962 | const_str_plain_TYPE_FLAGS = UNSTREAM_STRING_ASCII( &constant_bin[ 37128 ], 10, 1 ); | ||
| 963 | const_str_plain_TYPE_FLOAT = UNSTREAM_STRING_ASCII( &constant_bin[ 37140 ], 10, 1 ); | ||
| 964 | const_str_plain_TYPE_GTYPE = UNSTREAM_STRING_ASCII( &constant_bin[ 37244 ], 10, 1 ); | ||
| 965 | const_str_plain_TYPE_INT64 = UNSTREAM_STRING_ASCII( &constant_bin[ 37092 ], 10, 1 ); | ||
| 966 | const_str_plain_TYPE_PARAM = UNSTREAM_STRING_ASCII( &constant_bin[ 37204 ], 10, 1 ); | ||
| 967 | const_str_plain_TYPE_UCHAR = UNSTREAM_STRING_ASCII( &constant_bin[ 37022 ], 10, 1 ); | ||
| 968 | const_str_plain_TYPE_ULONG = UNSTREAM_STRING_ASCII( &constant_bin[ 37080 ], 10, 1 ); | ||
| 969 | const_str_plain_UTF8String = UNSTREAM_STRING_ASCII( &constant_bin[ 12851 ], 10, 1 ); | ||
| 970 | const_str_plain___cached__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76152 ], 10, 1 ); | ||
| 971 | const_str_plain___import__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76162 ], 10, 1 ); | ||
| 972 | const_str_plain___loader__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76172 ], 10, 1 ); | ||
| 973 | const_str_plain___module__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76182 ], 10, 1 ); | ||
| 974 | const_str_plain__constants = UNSTREAM_STRING_ASCII( &constant_bin[ 36263 ], 10, 1 ); | ||
| 975 | const_str_plain__persisted = UNSTREAM_STRING_ASCII( &constant_bin[ 76192 ], 10, 1 ); | ||
| 976 | const_str_plain_call_async = UNSTREAM_STRING_ASCII( &constant_bin[ 21196 ], 10, 1 ); | ||
| 977 | const_str_plain_exceptions = UNSTREAM_STRING_ASCII( &constant_bin[ 23533 ], 10, 1 ); | ||
| 978 | const_str_plain_executable = UNSTREAM_STRING_ASCII( &constant_bin[ 1792 ], 10, 1 ); | ||
| 979 | const_str_plain_get_g_type = UNSTREAM_STRING_ASCII( &constant_bin[ 76202 ], 10, 1 ); | ||
| 980 | const_str_plain_get_object = UNSTREAM_STRING_ASCII( &constant_bin[ 15734 ], 10, 1 ); | ||
| 981 | const_str_plain_identifier = UNSTREAM_STRING_ASCII( &constant_bin[ 56534 ], 10, 1 ); | ||
| 982 | const_str_plain_introspect = UNSTREAM_STRING_ASCII( &constant_bin[ 7972 ], 10, 1 ); | ||
| 983 | const_str_plain_isinstance = UNSTREAM_STRING_ASCII( &constant_bin[ 76212 ], 10, 1 ); | ||
| 984 | const_str_plain_issubclass = UNSTREAM_STRING_ASCII( &constant_bin[ 76222 ], 10, 1 ); | ||
| 985 | const_str_plain_problemify = UNSTREAM_STRING_ASCII( &constant_bin[ 76232 ], 10, 1 ); | ||
| 986 | const_str_plain_pyanaconda = UNSTREAM_STRING_ASCII( &constant_bin[ 60246 ], 10, 1 ); | ||
| 987 | const_str_plain_repository = UNSTREAM_STRING_ASCII( &constant_bin[ 35089 ], 10, 1 ); | ||
| 988 | const_str_plain_setdefault = UNSTREAM_STRING_ASCII( &constant_bin[ 76242 ], 10, 1 ); | ||
| 989 | const_str_plain_settimeout = UNSTREAM_STRING_ASCII( &constant_bin[ 76252 ], 10, 1 ); | ||
| 990 | const_str_plain_stacklevel = UNSTREAM_STRING_ASCII( &constant_bin[ 45275 ], 10, 1 ); | ||
| 991 | const_str_plain_startswith = UNSTREAM_STRING_ASCII( &constant_bin[ 76262 ], 10, 1 ); | ||
| 992 | const_tuple_type_str_tuple = PyTuple_New( 1 ); | ||
| 993 | PyTuple_SET_ITEM( const_tuple_type_str_tuple, 0, (PyObject *)&PyUnicode_Type ); Py_INCREF( (PyObject *)&PyUnicode_Type ); | ||
| 994 | const_str_plain_AuthFailure = UNSTREAM_STRING_ASCII( &constant_bin[ 59299 ], 11, 1 ); | ||
| 995 | const_str_plain_BUS_SESSION = UNSTREAM_STRING_ASCII( &constant_bin[ 13635 ], 11, 1 ); | ||
| 996 | const_str_plain_BUS_STARTER = UNSTREAM_STRING_ASCII( &constant_bin[ 13648 ], 11, 1 ); | ||
| 997 | const_str_plain_GObjectMeta = UNSTREAM_STRING_ASCII( &constant_bin[ 52908 ], 11, 1 ); | ||
| 998 | const_str_plain_ImportError = UNSTREAM_STRING_ASCII( &constant_bin[ 35857 ], 11, 1 ); | ||
| 999 | const_str_plain_LOCAL_IFACE = UNSTREAM_STRING_ASCII( &constant_bin[ 3474 ], 11, 1 ); | ||
| 1000 | const_str_plain_ProxyObject = UNSTREAM_STRING_ASCII( &constant_bin[ 10969 ], 11, 1 ); | ||
| 1001 | const_str_plain_PyGIWarning = UNSTREAM_STRING_ASCII( &constant_bin[ 76272 ], 11, 1 ); | ||
| 1002 | const_str_plain_SOCK_STREAM = UNSTREAM_STRING_ASCII( &constant_bin[ 76283 ], 11, 1 ); | ||
| 1003 | const_str_plain_TYPE_DOUBLE = UNSTREAM_STRING_ASCII( &constant_bin[ 37152 ], 11, 1 ); | ||
| 1004 | const_str_plain_TYPE_OBJECT = UNSTREAM_STRING_ASCII( &constant_bin[ 37216 ], 11, 1 ); | ||
| 1005 | const_str_plain_TYPE_STRING = UNSTREAM_STRING_ASCII( &constant_bin[ 37165 ], 11, 1 ); | ||
| 1006 | const_str_plain_TYPE_SYSTEM = UNSTREAM_STRING_ASCII( &constant_bin[ 4180 ], 11, 1 ); | ||
| 1007 | const_str_plain_TYPE_UINT64 = UNSTREAM_STRING_ASCII( &constant_bin[ 37104 ], 11, 1 ); | ||
| 1008 | const_str_plain___getattr__ = UNSTREAM_STRING_ASCII( &constant_bin[ 29041 ], 11, 1 ); | ||
| 1009 | const_str_plain___getitem__ = UNSTREAM_STRING_ASCII( &constant_bin[ 56757 ], 11, 1 ); | ||
| 1010 | const_str_plain___package__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76294 ], 11, 1 ); | ||
| 1011 | const_str_plain___prepare__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76305 ], 11, 1 ); | ||
| 1012 | const_str_plain___version__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76316 ], 11, 1 ); | ||
| 1013 | const_str_plain__connection = UNSTREAM_STRING_ASCII( &constant_bin[ 5850 ], 11, 1 ); | ||
| 1014 | const_str_plain_basicConfig = UNSTREAM_STRING_ASCII( &constant_bin[ 76327 ], 11, 1 ); | ||
| 1015 | const_str_plain_classmethod = UNSTREAM_STRING_ASCII( &constant_bin[ 76338 ], 11, 1 ); | ||
| 1016 | const_str_plain_collections = UNSTREAM_STRING_ASCII( &constant_bin[ 76349 ], 11, 1 ); | ||
| 1017 | const_str_plain_extend_path = UNSTREAM_STRING_ASCII( &constant_bin[ 76360 ], 11, 1 ); | ||
| 1018 | const_str_plain_get_default = UNSTREAM_STRING_ASCII( &constant_bin[ 2991 ], 11, 1 ); | ||
| 1019 | const_str_plain_get_methods = UNSTREAM_STRING_ASCII( &constant_bin[ 76371 ], 11, 1 ); | ||
| 1020 | const_str_plain_get_version = UNSTREAM_STRING_ASCII( &constant_bin[ 76382 ], 11, 1 ); | ||
| 1021 | const_str_plain_method_info = UNSTREAM_STRING_ASCII( &constant_bin[ 76393 ], 11, 1 ); | ||
| 1022 | const_str_plain_object_path = UNSTREAM_STRING_ASCII( &constant_bin[ 3376 ], 11, 1 ); | ||
| 1023 | const_str_plain_productName = UNSTREAM_STRING_ASCII( &constant_bin[ 60723 ], 11, 1 ); | ||
| 1024 | const_str_plain_signal_name = UNSTREAM_STRING_ASCII( &constant_bin[ 16353 ], 11, 1 ); | ||
| 1025 | const_tuple_int_pos_5_tuple = PyTuple_New( 1 ); | ||
| 1026 | PyTuple_SET_ITEM( const_tuple_int_pos_5_tuple, 0, const_int_pos_5 ); Py_INCREF( const_int_pos_5 ); | ||
| 1027 | const_tuple_str_empty_tuple = PyTuple_New( 1 ); | ||
| 1028 | PyTuple_SET_ITEM( const_tuple_str_empty_tuple, 0, const_str_empty ); Py_INCREF( const_str_empty ); | ||
| 1029 | const_str_plain_CallableInfo = UNSTREAM_STRING_ASCII( &constant_bin[ 76404 ], 12, 1 ); | ||
| 1030 | const_str_plain_ErrorMessage = UNSTREAM_STRING_ASCII( &constant_bin[ 76416 ], 12, 1 ); | ||
| 1031 | const_str_plain_FunctionInfo = UNSTREAM_STRING_ASCII( &constant_bin[ 76428 ], 12, 1 ); | ||
| 1032 | const_str_plain_TYPE_BOOLEAN = UNSTREAM_STRING_ASCII( &constant_bin[ 37034 ], 12, 1 ); | ||
| 1033 | const_str_plain_TYPE_INVALID = UNSTREAM_STRING_ASCII( &constant_bin[ 24050 ], 12, 1 ); | ||
| 1034 | const_str_plain_TYPE_POINTER = UNSTREAM_STRING_ASCII( &constant_bin[ 37178 ], 12, 1 ); | ||
| 1035 | const_str_plain_TYPE_SESSION = UNSTREAM_STRING_ASCII( &constant_bin[ 4162 ], 12, 1 ); | ||
| 1036 | const_str_plain_TYPE_STARTER = UNSTREAM_STRING_ASCII( &constant_bin[ 4199 ], 12, 1 ); | ||
| 1037 | const_str_plain_TYPE_VARIANT = UNSTREAM_STRING_ASCII( &constant_bin[ 37267 ], 12, 1 ); | ||
| 1038 | const_str_plain___builtins__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76440 ], 12, 1 ); | ||
| 1039 | const_str_plain___compiled__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76452 ], 12, 1 ); | ||
| 1040 | const_str_plain___internal__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76464 ], 12, 1 ); | ||
| 1041 | const_str_plain___qualname__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76476 ], 12, 1 ); | ||
| 1042 | const_str_plain_has_location = UNSTREAM_STRING_ASCII( &constant_bin[ 76488 ], 12, 1 ); | ||
| 1043 | const_str_plain_problem_data = UNSTREAM_STRING_ASCII( &constant_bin[ 76500 ], 12, 1 ); | ||
| 1044 | const_str_plain_staticmethod = UNSTREAM_STRING_ASCII( &constant_bin[ 76512 ], 12, 1 ); | ||
| 1045 | const_str_plain_string_types = UNSTREAM_STRING_ASCII( &constant_bin[ 76524 ], 12, 1 ); | ||
| 1046 | const_str_plain_threads_init = UNSTREAM_STRING_ASCII( &constant_bin[ 24390 ], 12, 1 ); | ||
| 1047 | const_str_plain_utf8_strings = UNSTREAM_STRING_ASCII( &constant_bin[ 15800 ], 12, 1 ); | ||
| 1048 | const_str_plain_version_info = UNSTREAM_STRING_ASCII( &constant_bin[ 76536 ], 12, 1 ); | ||
| 1049 | const_tuple_str_chr_42_tuple = PyTuple_New( 1 ); | ||
| 1050 | PyTuple_SET_ITEM( const_tuple_str_chr_42_tuple, 0, const_str_chr_42 ); Py_INCREF( const_str_chr_42 ); | ||
| 1051 | const_tuple_str_chr_61_tuple = PyTuple_New( 1 ); | ||
| 1052 | PyTuple_SET_ITEM( const_tuple_str_chr_61_tuple, 0, const_str_chr_61 ); Py_INCREF( const_str_chr_61 ); | ||
| 1053 | const_tuple_true_false_tuple = PyTuple_New( 2 ); | ||
| 1054 | PyTuple_SET_ITEM( const_tuple_true_false_tuple, 0, Py_True ); Py_INCREF( Py_True ); | ||
| 1055 | PyTuple_SET_ITEM( const_tuple_true_false_tuple, 1, Py_False ); Py_INCREF( Py_False ); | ||
| 1056 | const_str_plain_BusConnection = UNSTREAM_STRING_ASCII( &constant_bin[ 4469 ], 13, 1 ); | ||
| 1057 | const_str_plain_DBusException = UNSTREAM_STRING_ASCII( &constant_bin[ 3676 ], 13, 1 ); | ||
| 1058 | const_str_plain_DBusGMainLoop = UNSTREAM_STRING_ASCII( &constant_bin[ 76548 ], 13, 1 ); | ||
| 1059 | const_str_plain_InterfaceInfo = UNSTREAM_STRING_ASCII( &constant_bin[ 76561 ], 13, 1 ); | ||
| 1060 | const_str_plain_PROBLEM_TYPES = UNSTREAM_STRING_ASCII( &constant_bin[ 76574 ], 13, 1 ); | ||
| 1061 | const_str_plain_SignalMessage = UNSTREAM_STRING_ASCII( &constant_bin[ 18939 ], 13, 1 ); | ||
| 1062 | const_str_plain_TYPE_PYOBJECT = UNSTREAM_STRING_ASCII( &constant_bin[ 37229 ], 13, 1 ); | ||
| 1063 | const_str_plain___docformat__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76587 ], 13, 1 ); | ||
| 1064 | const_str_plain___metaclass__ = UNSTREAM_STRING_ASCII( &constant_bin[ 39558 ], 13, 1 ); | ||
| 1065 | const_str_plain__initializing = UNSTREAM_STRING_ASCII( &constant_bin[ 76600 ], 13, 1 ); | ||
| 1066 | const_str_plain_call_blocking = UNSTREAM_STRING_ASCII( &constant_bin[ 22529 ], 13, 1 ); | ||
| 1067 | const_str_plain_error_handler = UNSTREAM_STRING_ASCII( &constant_bin[ 22700 ], 13, 1 ); | ||
| 1068 | const_str_plain_fromtimestamp = UNSTREAM_STRING_ASCII( &constant_bin[ 76613 ], 13, 1 ); | ||
| 1069 | const_str_plain_get_arguments = UNSTREAM_STRING_ASCII( &constant_bin[ 76626 ], 13, 1 ); | ||
| 1070 | const_str_plain_get_dbus_name = UNSTREAM_STRING_ASCII( &constant_bin[ 23784 ], 13, 1 ); | ||
| 1071 | const_str_plain_get_interface = UNSTREAM_STRING_ASCII( &constant_bin[ 46443 ], 13, 1 ); | ||
| 1072 | const_str_plain_get_namespace = UNSTREAM_STRING_ASCII( &constant_bin[ 76639 ], 13, 1 ); | ||
| 1073 | const_str_plain_import_module = UNSTREAM_STRING_ASCII( &constant_bin[ 76652 ], 13, 1 ); | ||
| 1074 | const_str_plain_named_service = UNSTREAM_STRING_ASCII( &constant_bin[ 9844 ], 13, 1 ); | ||
| 1075 | const_str_plain_reply_handler = UNSTREAM_STRING_ASCII( &constant_bin[ 20845 ], 13, 1 ); | ||
| 1076 | const_tuple_int_pos_256_tuple = PyTuple_New( 1 ); | ||
| 1077 | PyTuple_SET_ITEM( const_tuple_int_pos_256_tuple, 0, const_int_pos_256 ); Py_INCREF( const_int_pos_256 ); | ||
| 1078 | const_tuple_str_newline_tuple = PyTuple_New( 1 ); | ||
| 1079 | PyTuple_SET_ITEM( const_tuple_str_newline_tuple, 0, const_str_newline ); Py_INCREF( const_str_newline ); | ||
| 1080 | const_tuple_str_plain_x_tuple = PyTuple_New( 1 ); | ||
| 1081 | PyTuple_SET_ITEM( const_tuple_str_plain_x_tuple, 0, const_str_plain_x ); Py_INCREF( const_str_plain_x ); | ||
| 1082 | const_tuple_type_object_tuple = PyTuple_New( 1 ); | ||
| 1083 | PyTuple_SET_ITEM( const_tuple_type_object_tuple, 0, (PyObject *)&PyBaseObject_Type ); Py_INCREF( (PyObject *)&PyBaseObject_Type ); | ||
| 1084 | const_str_plain_AttributeError = UNSTREAM_STRING_ASCII( &constant_bin[ 76665 ], 14, 1 ); | ||
| 1085 | const_str_plain_InvalidProblem = UNSTREAM_STRING_ASCII( &constant_bin[ 58712 ], 14, 1 ); | ||
| 1086 | const_str_plain_ProblemWatcher = UNSTREAM_STRING_ASCII( &constant_bin[ 55662 ], 14, 1 ); | ||
| 1087 | const_str_plain_TYPE_INTERFACE = UNSTREAM_STRING_ASCII( &constant_bin[ 36995 ], 14, 1 ); | ||
| 1088 | const_str_plain___orig_bases__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76679 ], 14, 1 ); | ||
| 1089 | const_str_plain__dbus_bindings = UNSTREAM_STRING_ASCII( &constant_bin[ 76693 ], 14, 1 ); | ||
| 1090 | const_str_plain_dbus_interface = UNSTREAM_STRING_ASCII( &constant_bin[ 16455 ], 14, 1 ); | ||
| 1091 | const_str_plain_importNewOrder = UNSTREAM_STRING_ASCII( &constant_bin[ 76707 ], 14, 1 ); | ||
| 1092 | const_str_plain_is_constructor = UNSTREAM_STRING_ASCII( &constant_bin[ 76721 ], 14, 1 ); | ||
| 1093 | const_str_plain_load_overrides = UNSTREAM_STRING_ASCII( &constant_bin[ 76735 ], 14, 1 ); | ||
| 1094 | const_str_plain_productVersion = UNSTREAM_STRING_ASCII( &constant_bin[ 60739 ], 14, 1 ); | ||
| 1095 | const_slice_int_pos_1_none_none = PySlice_New( const_int_pos_1, Py_None, Py_None ); | ||
| 1096 | const_slice_int_pos_3_none_none = PySlice_New( const_int_pos_3, Py_None, Py_None ); | ||
| 1097 | const_slice_none_int_pos_3_none = PySlice_New( Py_None, const_int_pos_3, Py_None ); | ||
| 1098 | const_str_plain_BUS_DAEMON_NAME = UNSTREAM_STRING_ASCII( &constant_bin[ 3410 ], 15, 1 ); | ||
| 1099 | const_str_plain_BUS_DAEMON_PATH = UNSTREAM_STRING_ASCII( &constant_bin[ 3427 ], 15, 1 ); | ||
| 1100 | const_str_plain_DynamicImporter = UNSTREAM_STRING_ASCII( &constant_bin[ 45305 ], 15, 1 ); | ||
| 1101 | const_str_plain_ValidationError = UNSTREAM_STRING_ASCII( &constant_bin[ 76749 ], 15, 1 ); | ||
| 1102 | const_str_plain___annotations__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76764 ], 15, 1 ); | ||
| 1103 | const_str_plain___mro_entries__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76779 ], 15, 1 ); | ||
| 1104 | const_str_plain_absolute_import = UNSTREAM_STRING_ASCII( &constant_bin[ 76794 ], 15, 1 ); | ||
| 1105 | const_str_plain_install_signals = UNSTREAM_STRING_ASCII( &constant_bin[ 76809 ], 15, 1 ); | ||
| 1106 | const_tuple_str_plain__gi_tuple = PyTuple_New( 1 ); | ||
| 1107 | PyTuple_SET_ITEM( const_tuple_str_plain__gi_tuple, 0, const_str_plain__gi ); Py_INCREF( const_str_plain__gi ); | ||
| 1108 | const_str_plain_BUS_DAEMON_IFACE = UNSTREAM_STRING_ASCII( &constant_bin[ 3444 ], 16, 1 ); | ||
| 1109 | const_str_plain_ProxyObjectClass = UNSTREAM_STRING_ASCII( &constant_bin[ 76824 ], 16, 1 ); | ||
| 1110 | const_str_plain_handler_function = UNSTREAM_STRING_ASCII( &constant_bin[ 16044 ], 16, 1 ); | ||
| 1111 | const_str_plain_reStructuredText = UNSTREAM_STRING_ASCII( &constant_bin[ 76840 ], 16, 1 ); | ||
| 1112 | const_str_plain_restructuredtext = UNSTREAM_STRING_ASCII( &constant_bin[ 76856 ], 16, 1 ); | ||
| 1113 | const_tuple_none_none_none_tuple = PyTuple_New( 3 ); | ||
| 1114 | PyTuple_SET_ITEM( const_tuple_none_none_none_tuple, 0, Py_None ); Py_INCREF( Py_None ); | ||
| 1115 | PyTuple_SET_ITEM( const_tuple_none_none_none_tuple, 1, Py_None ); Py_INCREF( Py_None ); | ||
| 1116 | PyTuple_SET_ITEM( const_tuple_none_none_none_tuple, 2, Py_None ); Py_INCREF( Py_None ); | ||
| 1117 | const_tuple_str_plain_self_tuple = PyTuple_New( 1 ); | ||
| 1118 | PyTuple_SET_ITEM( const_tuple_str_plain_self_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 1119 | const_tuple_str_plain_void_tuple = PyTuple_New( 1 ); | ||
| 1120 | PyTuple_SET_ITEM( const_tuple_str_plain_void_tuple, 0, const_str_plain_void ); Py_INCREF( const_str_plain_void ); | ||
| 1121 | const_tuple_str_plain_warn_tuple = PyTuple_New( 1 ); | ||
| 1122 | PyTuple_SET_ITEM( const_tuple_str_plain_warn_tuple, 0, const_str_plain_warn ); Py_INCREF( const_str_plain_warn ); | ||
| 1123 | const_tuple_type_Exception_tuple = PyTuple_New( 1 ); | ||
| 1124 | PyTuple_SET_ITEM( const_tuple_type_Exception_tuple, 0, (PyObject *)PyExc_Exception ); Py_INCREF( (PyObject *)PyExc_Exception ); | ||
| 1125 | const_str_plain_MethodCallMessage = UNSTREAM_STRING_ASCII( &constant_bin[ 76872 ], 17, 1 ); | ||
| 1126 | const_str_plain_NUITKA_PACKAGE_gi = UNSTREAM_STRING_ASCII( &constant_bin[ 47953 ], 17, 1 ); | ||
| 1127 | const_str_plain___class_getitem__ = UNSTREAM_STRING_ASCII( &constant_bin[ 76889 ], 17, 1 ); | ||
| 1128 | const_str_plain_importAmazonOrder = UNSTREAM_STRING_ASCII( &constant_bin[ 76906 ], 17, 1 ); | ||
| 1129 | const_str_plain_require_main_loop = UNSTREAM_STRING_ASCII( &constant_bin[ 76923 ], 17, 1 ); | ||
| 1130 | const_str_plain_validate_bus_name = UNSTREAM_STRING_ASCII( &constant_bin[ 3348 ], 17, 1 ); | ||
| 1131 | const_str_plain_DeprecationWarning = UNSTREAM_STRING_ASCII( &constant_bin[ 50345 ], 18, 1 ); | ||
| 1132 | const_str_plain__require_main_loop = UNSTREAM_STRING_ASCII( &constant_bin[ 76940 ], 18, 1 ); | ||
| 1133 | const_str_plain_enumerate_versions = UNSTREAM_STRING_ASCII( &constant_bin[ 76958 ], 18, 1 ); | ||
| 1134 | const_str_plain_install_properties = UNSTREAM_STRING_ASCII( &constant_bin[ 38926 ], 18, 1 ); | ||
| 1135 | const_tuple_str_plain_is_py2_tuple = PyTuple_New( 1 ); | ||
| 1136 | PyTuple_SET_ITEM( const_tuple_str_plain_is_py2_tuple, 0, const_str_plain_is_py2 ); Py_INCREF( const_str_plain_is_py2 ); | ||
| 1137 | const_str_plain_MethodReturnMessage = UNSTREAM_STRING_ASCII( &constant_bin[ 76976 ], 19, 1 ); | ||
| 1138 | const_str_plain_NUITKA_PACKAGE_dbus = UNSTREAM_STRING_ASCII( &constant_bin[ 24237 ], 19, 1 ); | ||
| 1139 | const_str_plain_NameExistsException = UNSTREAM_STRING_ASCII( &constant_bin[ 3826 ], 19, 1 ); | ||
| 1140 | const_str_plain_ValidationException = UNSTREAM_STRING_ASCII( &constant_bin[ 3751 ], 19, 1 ); | ||
| 1141 | const_str_plain_activate_name_owner = UNSTREAM_STRING_ASCII( &constant_bin[ 14365 ], 19, 1 ); | ||
| 1142 | const_str_plain_add_signal_receiver = UNSTREAM_STRING_ASCII( &constant_bin[ 9141 ], 19, 1 ); | ||
| 1143 | const_str_plain_generate_doc_string = UNSTREAM_STRING_ASCII( &constant_bin[ 44447 ], 19, 1 ); | ||
| 1144 | const_str_plain_get_problem_watcher = UNSTREAM_STRING_ASCII( &constant_bin[ 58309 ], 19, 1 ); | ||
| 1145 | const_str_plain_validate_error_name = UNSTREAM_STRING_ASCII( &constant_bin[ 3389 ], 19, 1 ); | ||
| 1146 | const_tuple_str_dot_int_pos_1_tuple = PyTuple_New( 2 ); | ||
| 1147 | PyTuple_SET_ITEM( const_tuple_str_dot_int_pos_1_tuple, 0, const_str_dot ); Py_INCREF( const_str_dot ); | ||
| 1148 | PyTuple_SET_ITEM( const_tuple_str_dot_int_pos_1_tuple, 1, const_int_pos_1 ); Py_INCREF( const_int_pos_1 ); | ||
| 1149 | const_tuple_str_plain_GObject_tuple = PyTuple_New( 1 ); | ||
| 1150 | PyTuple_SET_ITEM( const_tuple_str_plain_GObject_tuple, 0, const_str_plain_GObject ); Py_INCREF( const_str_plain_GObject ); | ||
| 1151 | const_str_plain_INTROSPECTABLE_IFACE = UNSTREAM_STRING_ASCII( &constant_bin[ 3499 ], 20, 1 ); | ||
| 1152 | const_str_plain_get_required_version = UNSTREAM_STRING_ASCII( &constant_bin[ 76995 ], 20, 1 ); | ||
| 1153 | const_str_plain_introspection_module = UNSTREAM_STRING_ASCII( &constant_bin[ 46726 ], 20, 1 ); | ||
| 1154 | const_str_plain_validate_member_name = UNSTREAM_STRING_ASCII( &constant_bin[ 3326 ], 20, 1 ); | ||
| 1155 | const_str_plain_validate_object_path = UNSTREAM_STRING_ASCII( &constant_bin[ 3367 ], 20, 1 ); | ||
| 1156 | const_str_plain_DEFAULT_DUMP_LOCATION = UNSTREAM_STRING_ASCII( &constant_bin[ 77015 ], 21, 1 ); | ||
| 1157 | const_str_plain_NUITKA_PACKAGE_report = UNSTREAM_STRING_ASCII( &constant_bin[ 62669 ], 21, 1 ); | ||
| 1158 | const_str_plain_set_sender_name_owner = UNSTREAM_STRING_ASCII( &constant_bin[ 15885 ], 21, 1 ); | ||
| 1159 | const_tuple_int_pos_3_int_pos_3_tuple = PyTuple_New( 2 ); | ||
| 1160 | PyTuple_SET_ITEM( const_tuple_int_pos_3_int_pos_3_tuple, 0, const_int_pos_3 ); Py_INCREF( const_int_pos_3 ); | ||
| 1161 | PyTuple_SET_ITEM( const_tuple_int_pos_3_int_pos_3_tuple, 1, const_int_pos_3 ); Py_INCREF( const_int_pos_3 ); | ||
| 1162 | const_tuple_none_none_none_none_tuple = PyTuple_New( 4 ); | ||
| 1163 | PyTuple_SET_ITEM( const_tuple_none_none_none_none_tuple, 0, Py_None ); Py_INCREF( Py_None ); | ||
| 1164 | PyTuple_SET_ITEM( const_tuple_none_none_none_none_tuple, 1, Py_None ); Py_INCREF( Py_None ); | ||
| 1165 | PyTuple_SET_ITEM( const_tuple_none_none_none_none_tuple, 2, Py_None ); Py_INCREF( Py_None ); | ||
| 1166 | PyTuple_SET_ITEM( const_tuple_none_none_none_none_tuple, 3, Py_None ); Py_INCREF( Py_None ); | ||
| 1167 | const_tuple_str_plain___class___tuple = PyTuple_New( 1 ); | ||
| 1168 | PyTuple_SET_ITEM( const_tuple_str_plain___class___tuple, 0, const_str_plain___class__ ); Py_INCREF( const_str_plain___class__ ); | ||
| 1169 | const_str_plain_PyGIDeprecationWarning = UNSTREAM_STRING_ASCII( &constant_bin[ 50341 ], 22, 1 ); | ||
| 1170 | const_str_plain_UnknownMethodException = UNSTREAM_STRING_ASCII( &constant_bin[ 3802 ], 22, 1 ); | ||
| 1171 | const_str_plain__clean_up_signal_match = UNSTREAM_STRING_ASCII( &constant_bin[ 8740 ], 22, 1 ); | ||
| 1172 | const_tuple_str_plain_UTF8String_tuple = PyTuple_New( 1 ); | ||
| 1173 | PyTuple_SET_ITEM( const_tuple_str_plain_UTF8String_tuple, 0, const_str_plain_UTF8String ); Py_INCREF( const_str_plain_UTF8String ); | ||
| 1174 | const_str_plain_abrt_exception_handler3 = UNSTREAM_STRING_ASCII( &constant_bin[ 2153 ], 23, 1 ); | ||
| 1175 | const_str_plain_validate_interface_name = UNSTREAM_STRING_ASCII( &constant_bin[ 3301 ], 23, 1 ); | ||
| 1176 | const_tuple_str_plain_PyGIWarning_tuple = PyTuple_New( 1 ); | ||
| 1177 | PyTuple_SET_ITEM( const_tuple_str_plain_PyGIWarning_tuple, 0, const_str_plain_PyGIWarning ); Py_INCREF( const_str_plain_PyGIWarning ); | ||
| 1178 | const_tuple_str_plain_extend_path_tuple = PyTuple_New( 1 ); | ||
| 1179 | PyTuple_SET_ITEM( const_tuple_str_plain_extend_path_tuple, 0, const_str_plain_extend_path ); Py_INCREF( const_str_plain_extend_path ); | ||
| 1180 | const_str_plain_DBUS_START_REPLY_SUCCESS = UNSTREAM_STRING_ASCII( &constant_bin[ 13707 ], 24, 1 ); | ||
| 1181 | const_str_plain_get_introspection_module = UNSTREAM_STRING_ASCII( &constant_bin[ 77036 ], 24, 1 ); | ||
| 1182 | const_tuple_str_chr_45_str_plain___tuple = PyTuple_New( 2 ); | ||
| 1183 | PyTuple_SET_ITEM( const_tuple_str_chr_45_str_plain___tuple, 0, const_str_chr_45 ); Py_INCREF( const_str_chr_45 ); | ||
| 1184 | PyTuple_SET_ITEM( const_tuple_str_chr_45_str_plain___tuple, 1, const_str_plain__ ); Py_INCREF( const_str_plain__ ); | ||
| 1185 | const_str_plain_NUITKA_PACKAGE_pyanaconda = UNSTREAM_STRING_ASCII( &constant_bin[ 60279 ], 25, 1 ); | ||
| 1186 | const_str_plain_follow_name_owner_changes = UNSTREAM_STRING_ASCII( &constant_bin[ 10163 ], 25, 1 ); | ||
| 1187 | const_tuple_str_plain_BusConnection_tuple = PyTuple_New( 1 ); | ||
| 1188 | PyTuple_SET_ITEM( const_tuple_str_plain_BusConnection_tuple, 0, const_str_plain_BusConnection ); Py_INCREF( const_str_plain_BusConnection ); | ||
| 1189 | const_tuple_str_plain_DBusException_tuple = PyTuple_New( 1 ); | ||
| 1190 | PyTuple_SET_ITEM( const_tuple_str_plain_DBusException_tuple, 0, const_str_plain_DBusException ); Py_INCREF( const_str_plain_DBusException ); | ||
| 1191 | const_str_plain_process_introspection_data = UNSTREAM_STRING_ASCII( &constant_bin[ 77060 ], 26, 1 ); | ||
| 1192 | const_str_plain_submodule_search_locations = UNSTREAM_STRING_ASCII( &constant_bin[ 77086 ], 26, 1 ); | ||
| 1193 | const_dict_f154c9a58c9419d7e391901d7b7fe49e = _PyDict_NewPresized( 1 ); | ||
| 1194 | PyDict_SetItem( const_dict_f154c9a58c9419d7e391901d7b7fe49e, const_str_plain_stacklevel, const_int_pos_2 ); | ||
| 1195 | assert( PyDict_Size( const_dict_f154c9a58c9419d7e391901d7b7fe49e ) == 1 ); | ||
| 1196 | const_str_plain_IntrospectionParserException = UNSTREAM_STRING_ASCII( &constant_bin[ 3772 ], 28, 1 ); | ||
| 1197 | const_str_plain_MissingErrorHandlerException = UNSTREAM_STRING_ASCII( &constant_bin[ 3691 ], 28, 1 ); | ||
| 1198 | const_str_plain_MissingReplyHandlerException = UNSTREAM_STRING_ASCII( &constant_bin[ 3721 ], 28, 1 ); | ||
| 1199 | const_str_plain_HANDLER_RESULT_NOT_YET_HANDLED = UNSTREAM_STRING_ASCII( &constant_bin[ 77112 ], 30, 1 ); | ||
| 1200 | const_tuple_str_plain_named_service_none_tuple = PyTuple_New( 2 ); | ||
| 1201 | PyTuple_SET_ITEM( const_tuple_str_plain_named_service_none_tuple, 0, const_str_plain_named_service ); Py_INCREF( const_str_plain_named_service ); | ||
| 1202 | PyTuple_SET_ITEM( const_tuple_str_plain_named_service_none_tuple, 1, Py_None ); Py_INCREF( Py_None ); | ||
| 1203 | const_tuple_str_plain_self_str_plain_name_tuple = PyTuple_New( 2 ); | ||
| 1204 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_name_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 1205 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_name_tuple, 1, const_str_plain_name ); Py_INCREF( const_str_plain_name ); | ||
| 1206 | const_tuple_str_plain_self_str_plain_path_tuple = PyTuple_New( 2 ); | ||
| 1207 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_path_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 1208 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_path_tuple, 1, const_str_plain_path ); Py_INCREF( const_str_plain_path ); | ||
| 1209 | const_str_plain_DBUS_START_REPLY_ALREADY_RUNNING = UNSTREAM_STRING_ASCII( &constant_bin[ 13673 ], 32, 1 ); | ||
| 1210 | const_str_digest_0292066d9880d6d47806594c17fae043 = UNSTREAM_STRING_ASCII( &constant_bin[ 54512 ], 17, 0 ); | ||
| 1211 | const_str_digest_0b385b2a67f6700b8faf677cdd479207 = UNSTREAM_STRING_ASCII( &constant_bin[ 19680 ], 15, 0 ); | ||
| 1212 | const_str_digest_168dabde1c45fe2c6a98ec9eae56b3f0 = UNSTREAM_STRING_ASCII( &constant_bin[ 24665 ], 18, 0 ); | ||
| 1213 | const_str_digest_176045277faffdb215e36349ee6bf75e = UNSTREAM_STRING_ASCII( &constant_bin[ 77142 ], 39, 0 ); | ||
| 1214 | const_str_digest_18c67c412066bef703396d613a159b4d = UNSTREAM_STRING_ASCII( &constant_bin[ 77181 ], 114, 0 ); | ||
| 1215 | const_str_digest_1abd3647207b34d013514bc0c6956d0b = UNSTREAM_STRING_ASCII( &constant_bin[ 34013 ], 10, 0 ); | ||
| 1216 | const_str_digest_1b131d6ac44490cf7b663211212d8dfa = UNSTREAM_STRING_ASCII( &constant_bin[ 77295 ], 49, 0 ); | ||
| 1217 | const_str_digest_25731c733fd74e8333aa29126ce85686 = UNSTREAM_STRING_ASCII( &constant_bin[ 34179 ], 2, 0 ); | ||
| 1218 | const_str_digest_286d73d90a388265c9abc0d24ef29c6f = UNSTREAM_STRING_ASCII( &constant_bin[ 8044 ], 29, 0 ); | ||
| 1219 | const_str_digest_2dddc6e15ab2dcfb5a2b2205b5654fb4 = UNSTREAM_STRING_ASCII( &constant_bin[ 52768 ], 14, 0 ); | ||
| 1220 | const_str_digest_3aa5bee4de9b0149ae46ffed8a38c6b4 = UNSTREAM_STRING_ASCII( &constant_bin[ 3887 ], 12, 0 ); | ||
| 1221 | const_str_digest_3cc8fcb05b60f7b9437930cdc441ce30 = UNSTREAM_STRING_ASCII( &constant_bin[ 77344 ], 52, 0 ); | ||
| 1222 | const_str_digest_4289e46f026bf0dd92edd4764f9ca580 = UNSTREAM_STRING_ASCII( &constant_bin[ 77396 ], 105, 0 ); | ||
| 1223 | const_str_digest_45e4dde2057b0bf276d6a84f4c917d27 = UNSTREAM_STRING_ASCII( &constant_bin[ 3145 ], 7, 0 ); | ||
| 1224 | const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 = UNSTREAM_STRING_ASCII( &constant_bin[ 77501 ], 9, 0 ); | ||
| 1225 | const_str_digest_6090a95f7b926ecd6061b143b7cad52f = UNSTREAM_STRING_ASCII( &constant_bin[ 77510 ], 51, 0 ); | ||
| 1226 | const_str_digest_62223e4c0fc7bcb5885146e43f1fb665 = UNSTREAM_STRING_ASCII( &constant_bin[ 7239 ], 10, 0 ); | ||
| 1227 | const_str_digest_66f7aeb02c13e91a30a18f0ea911888b = UNSTREAM_STRING_ASCII( &constant_bin[ 35086 ], 13, 0 ); | ||
| 1228 | const_str_digest_6807157bfb6aeb31712b82d637fd949a = UNSTREAM_STRING_ASCII( &constant_bin[ 60383 ], 20, 0 ); | ||
| 1229 | const_str_digest_6b7875a4f8a36dd7de7a8976a2d1d45e = UNSTREAM_STRING_ASCII( &constant_bin[ 58144 ], 14, 0 ); | ||
| 1230 | const_str_digest_6f576c460435f45aaedb10ae95808089 = UNSTREAM_STRING_ASCII( &constant_bin[ 62701 ], 9, 0 ); | ||
| 1231 | const_str_digest_71b716a2e5991dc1dd383ac4073f8ceb = UNSTREAM_STRING_ASCII( &constant_bin[ 77561 ], 25, 0 ); | ||
| 1232 | const_str_digest_72035249113faa63f8939ea70bf6ef12 = UNSTREAM_STRING_ASCII( &constant_bin[ 77586 ], 16, 0 ); | ||
| 1233 | const_str_digest_75fd71b1edada749c2ef7ac810062295 = UNSTREAM_STRING_ASCII( &constant_bin[ 77602 ], 46, 0 ); | ||
| 1234 | const_str_digest_79ed2cac4e638f0656fd263c1190bdb0 = UNSTREAM_STRING_ASCII( &constant_bin[ 4460 ], 8, 0 ); | ||
| 1235 | const_str_digest_8e2db9d493d0360a27a3bf19583a3201 = UNSTREAM_STRING_ASCII( &constant_bin[ 10956 ], 12, 0 ); | ||
| 1236 | const_str_digest_9816e8d1552296af90d250823c964059 = UNSTREAM_STRING_ASCII( &constant_bin[ 77648 ], 46, 0 ); | ||
| 1237 | const_str_digest_a70d2bed936523093700e5558854519a = UNSTREAM_STRING_ASCII( &constant_bin[ 77694 ], 25, 0 ); | ||
| 1238 | const_str_digest_adc474dd61fbd736d69c1bac5d9712e0 = UNSTREAM_STRING_ASCII( &constant_bin[ 77719 ], 47, 0 ); | ||
| 1239 | const_str_digest_b0cc034d9177fde48a3b44ac122139d9 = UNSTREAM_STRING_ASCII( &constant_bin[ 19661 ], 6, 0 ); | ||
| 1240 | const_str_digest_b45a3c6f685a3991de51197626bab5ca = UNSTREAM_STRING_ASCII( &constant_bin[ 18925 ], 13, 0 ); | ||
| 1241 | const_str_digest_b9c4baf879ebd882d40843df3a4dead7 = UNSTREAM_STRING_ASCII( &constant_bin[ 6900 ], 2, 1 ); | ||
| 1242 | const_str_digest_c075052d723d6707083e869a0e3659bb = UNSTREAM_STRING_ASCII( &constant_bin[ 77766 ], 5, 0 ); | ||
| 1243 | const_str_digest_d7a2d3682b691f7fb6d75512d991b529 = UNSTREAM_STRING_ASCII( &constant_bin[ 77771 ], 13, 0 ); | ||
| 1244 | const_str_digest_db35ab94a03c3cbeb13cbe2a1d728b77 = UNSTREAM_STRING_ASCII( &constant_bin[ 399 ], 2, 0 ); | ||
| 1245 | const_str_digest_e48610c30fffad33f2054d9dca0792b3 = UNSTREAM_STRING_ASCII( &constant_bin[ 23554 ], 15, 0 ); | ||
| 1246 | const_str_digest_ec911d7d8aa19d9c1e00a67b34952d6e = UNSTREAM_STRING_ASCII( &constant_bin[ 50152 ], 12, 0 ); | ||
| 1247 | const_str_digest_f4d333e44bfac310ff46328bad2521a0 = UNSTREAM_STRING_ASCII( &constant_bin[ 36260 ], 13, 0 ); | ||
| 1248 | const_str_digest_f570069e0d46f80dd06443468800a290 = UNSTREAM_STRING_ASCII( &constant_bin[ 77586 ], 4, 0 ); | ||
| 1249 | const_str_digest_fdd1f239b4f3ffd6efcccf00e4a637e0 = UNSTREAM_STRING_ASCII( &constant_bin[ 77784 ], 48, 0 ); | ||
| 1250 | const_tuple_str_plain_args_str_plain_kwargs_tuple = PyTuple_New( 2 ); | ||
| 1251 | PyTuple_SET_ITEM( const_tuple_str_plain_args_str_plain_kwargs_tuple, 0, const_str_plain_args ); Py_INCREF( const_str_plain_args ); | ||
| 1252 | PyTuple_SET_ITEM( const_tuple_str_plain_args_str_plain_kwargs_tuple, 1, const_str_plain_kwargs ); Py_INCREF( const_str_plain_kwargs ); | ||
| 1253 | const_tuple_0bb929f2f11716c81953a0b7b206d455_tuple = PyTuple_New( 2 ); | ||
| 1254 | PyTuple_SET_ITEM( const_tuple_0bb929f2f11716c81953a0b7b206d455_tuple, 0, const_str_plain_NUITKA_PACKAGE_gi ); Py_INCREF( const_str_plain_NUITKA_PACKAGE_gi ); | ||
| 1255 | PyTuple_SET_ITEM( const_tuple_0bb929f2f11716c81953a0b7b206d455_tuple, 1, const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); Py_INCREF( const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); | ||
| 1256 | const_tuple_259a9893e45702189ab930fb0b217a08_tuple = PyTuple_New( 2 ); | ||
| 1257 | PyTuple_SET_ITEM( const_tuple_259a9893e45702189ab930fb0b217a08_tuple, 0, const_str_plain_NUITKA_PACKAGE_pyanaconda ); Py_INCREF( const_str_plain_NUITKA_PACKAGE_pyanaconda ); | ||
| 1258 | PyTuple_SET_ITEM( const_tuple_259a9893e45702189ab930fb0b217a08_tuple, 1, const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); Py_INCREF( const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); | ||
| 1259 | const_tuple_76ee81f3638eaf5a352e7276367934cb_tuple = PyTuple_New( 4 ); | ||
| 1260 | PyTuple_SET_ITEM( const_tuple_76ee81f3638eaf5a352e7276367934cb_tuple, 0, const_str_plain_Bus ); Py_INCREF( const_str_plain_Bus ); | ||
| 1261 | PyTuple_SET_ITEM( const_tuple_76ee81f3638eaf5a352e7276367934cb_tuple, 1, const_str_plain_SystemBus ); Py_INCREF( const_str_plain_SystemBus ); | ||
| 1262 | PyTuple_SET_ITEM( const_tuple_76ee81f3638eaf5a352e7276367934cb_tuple, 2, const_str_plain_SessionBus ); Py_INCREF( const_str_plain_SessionBus ); | ||
| 1263 | PyTuple_SET_ITEM( const_tuple_76ee81f3638eaf5a352e7276367934cb_tuple, 3, const_str_plain_StarterBus ); Py_INCREF( const_str_plain_StarterBus ); | ||
| 1264 | const_tuple_c05661dc311559e0338d3f9170078d6a_tuple = PyTuple_New( 2 ); | ||
| 1265 | PyTuple_SET_ITEM( const_tuple_c05661dc311559e0338d3f9170078d6a_tuple, 0, const_str_plain_NUITKA_PACKAGE_dbus ); Py_INCREF( const_str_plain_NUITKA_PACKAGE_dbus ); | ||
| 1266 | PyTuple_SET_ITEM( const_tuple_c05661dc311559e0338d3f9170078d6a_tuple, 1, const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); Py_INCREF( const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); | ||
| 1267 | const_tuple_c715d881e41895e419fdbff3ad722aae_tuple = PyTuple_New( 2 ); | ||
| 1268 | PyTuple_SET_ITEM( const_tuple_c715d881e41895e419fdbff3ad722aae_tuple, 0, const_str_plain_NUITKA_PACKAGE_report ); Py_INCREF( const_str_plain_NUITKA_PACKAGE_report ); | ||
| 1269 | PyTuple_SET_ITEM( const_tuple_c715d881e41895e419fdbff3ad722aae_tuple, 1, const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); Py_INCREF( const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); | ||
| 1270 | const_tuple_str_plain_PyGIDeprecationWarning_tuple = PyTuple_New( 1 ); | ||
| 1271 | PyTuple_SET_ITEM( const_tuple_str_plain_PyGIDeprecationWarning_tuple, 0, const_str_plain_PyGIDeprecationWarning ); Py_INCREF( const_str_plain_PyGIDeprecationWarning ); | ||
| 1272 | const_tuple_str_plain_self_str_plain_bus_name_tuple = PyTuple_New( 2 ); | ||
| 1273 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_bus_name_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 1274 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_bus_name_tuple, 1, const_str_plain_bus_name ); Py_INCREF( const_str_plain_bus_name ); | ||
| 1275 | const_tuple_str_plain_self_str_plain_instance_tuple = PyTuple_New( 2 ); | ||
| 1276 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_instance_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 1277 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_instance_tuple, 1, const_str_plain_instance ); Py_INCREF( const_str_plain_instance ); | ||
| 1278 | const_tuple_str_digest_71b716a2e5991dc1dd383ac4073f8ceb_tuple = PyTuple_New( 1 ); | ||
| 1279 | PyTuple_SET_ITEM( const_tuple_str_digest_71b716a2e5991dc1dd383ac4073f8ceb_tuple, 0, const_str_digest_71b716a2e5991dc1dd383ac4073f8ceb ); Py_INCREF( const_str_digest_71b716a2e5991dc1dd383ac4073f8ceb ); | ||
| 1280 | const_tuple_str_digest_c075052d723d6707083e869a0e3659bb_tuple = PyTuple_New( 1 ); | ||
| 1281 | PyTuple_SET_ITEM( const_tuple_str_digest_c075052d723d6707083e869a0e3659bb_tuple, 0, const_str_digest_c075052d723d6707083e869a0e3659bb ); Py_INCREF( const_str_digest_c075052d723d6707083e869a0e3659bb ); | ||
| 1282 | const_tuple_anon_function_anon_builtin_function_or_method_tuple = PyTuple_New( 2 ); | ||
| 1283 | PyTuple_SET_ITEM( const_tuple_anon_function_anon_builtin_function_or_method_tuple, 0, (PyObject *)&PyFunction_Type ); Py_INCREF( (PyObject *)&PyFunction_Type ); | ||
| 1284 | PyTuple_SET_ITEM( const_tuple_anon_function_anon_builtin_function_or_method_tuple, 1, (PyObject *)&PyCFunction_Type ); Py_INCREF( (PyObject *)&PyCFunction_Type ); | ||
| 1285 | const_tuple_str_plain_self_str_plain_instance_str_plain_owner_tuple = PyTuple_New( 3 ); | ||
| 1286 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_instance_str_plain_owner_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 1287 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_instance_str_plain_owner_tuple, 1, const_str_plain_instance ); Py_INCREF( const_str_plain_instance ); | ||
| 1288 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_instance_str_plain_owner_tuple, 2, const_str_plain_owner ); Py_INCREF( const_str_plain_owner ); | ||
| 1289 | |||
| 1290 | #if _NUITKA_EXE | ||
| 1291 | /* Set the "sys.executable" path to the original CPython executable. */ | ||
| 1292 | PySys_SetObject( | ||
| 1293 | (char *)"executable", | ||
| 1294 | const_str_digest_72035249113faa63f8939ea70bf6ef12 | ||
| 1295 | ); | ||
| 1296 | |||
| 1297 | #ifndef _NUITKA_STANDALONE | ||
| 1298 | /* Set the "sys.prefix" path to the original one. */ | ||
| 1299 | PySys_SetObject( | ||
| 1300 | (char *)"prefix", | ||
| 1301 | const_str_digest_f570069e0d46f80dd06443468800a290 | ||
| 1302 | ); | ||
| 1303 | |||
| 1304 | /* Set the "sys.prefix" path to the original one. */ | ||
| 1305 | PySys_SetObject( | ||
| 1306 | (char *)"exec_prefix", | ||
| 1307 | const_str_digest_f570069e0d46f80dd06443468800a290 | ||
| 1308 | ); | ||
| 1309 | |||
| 1310 | |||
| 1311 | #if PYTHON_VERSION >= 300 | ||
| 1312 | /* Set the "sys.base_prefix" path to the original one. */ | ||
| 1313 | PySys_SetObject( | ||
| 1314 | (char *)"base_prefix", | ||
| 1315 | const_str_digest_f570069e0d46f80dd06443468800a290 | ||
| 1316 | ); | ||
| 1317 | |||
| 1318 | /* Set the "sys.exec_base_prefix" path to the original one. */ | ||
| 1319 | PySys_SetObject( | ||
| 1320 | (char *)"base_exec_prefix", | ||
| 1321 | const_str_digest_f570069e0d46f80dd06443468800a290 | ||
| 1322 | ); | ||
| 1323 | |||
| 1324 | #endif | ||
| 1325 | #endif | ||
| 1326 | #endif | ||
| 1327 | |||
| 1328 | static PyTypeObject Nuitka_VersionInfoType; | ||
| 1329 | |||
| 1330 | // Same fields as "sys.version_info" except no serial number. | ||
| 1331 | static PyStructSequence_Field Nuitka_VersionInfoFields[] = { | ||
| 1332 | {(char *)"major", (char *)"Major release number"}, | ||
| 1333 | {(char *)"minor", (char *)"Minor release number"}, | ||
| 1334 | {(char *)"micro", (char *)"Micro release number"}, | ||
| 1335 | {(char *)"releaselevel", (char *)"'alpha', 'beta', 'candidate', or 'release'"}, | ||
| 1336 | {0} | ||
| 1337 | }; | ||
| 1338 | |||
| 1339 | static PyStructSequence_Desc Nuitka_VersionInfoDesc = { | ||
| 1340 | (char *)"__nuitka_version__", /* name */ | ||
| 1341 | (char *)"__compiled__\n\nVersion information as a named tuple.", /* doc */ | ||
| 1342 | Nuitka_VersionInfoFields, /* fields */ | ||
| 1343 | 4 | ||
| 1344 | }; | ||
| 1345 | |||
| 1346 | PyStructSequence_InitType(&Nuitka_VersionInfoType, &Nuitka_VersionInfoDesc); | ||
| 1347 | |||
| 1348 | Nuitka_dunder_compiled_value = PyStructSequence_New(&Nuitka_VersionInfoType); | ||
| 1349 | assert(Nuitka_dunder_compiled_value != NULL); | ||
| 1350 | |||
| 1351 | PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 0, PyInt_FromLong(0)); | ||
| 1352 | PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 1, PyInt_FromLong(6)); | ||
| 1353 | PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 2, PyInt_FromLong(3)); | ||
| 1354 | |||
| 1355 | #if PYTHON_VERSION < 300 | ||
| 1356 | PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 3, PyString_FromString("release")); | ||
| 1357 | #else | ||
| 1358 | PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 3, PyUnicode_FromString("release")); | ||
| 1359 | #endif | ||
| 1360 | // Prevent users from creating the Nuitka version type object. | ||
| 1361 | Nuitka_VersionInfoType.tp_init = NULL; | ||
| 1362 | Nuitka_VersionInfoType.tp_new = NULL; | ||
| 1363 | |||
| 1364 | |||
| 1365 | } | ||
| 1366 | |||
| 1367 | // In debug mode we can check that the constants were not tampered with in any | ||
| 1368 | // given moment. We typically do it at program exit, but we can add extra calls | ||
| 1369 | // for sanity. | ||
| 1370 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1371 | void checkGlobalConstants( void ) | ||
| 1372 | { | ||
| 1373 | |||
| 1374 | } | ||
| 1375 | #endif | ||
| 1376 | |||
| 1377 | void createGlobalConstants( void ) | ||
| 1378 | { | ||
| 1379 | if ( _sentinel_value == NULL ) | ||
| 1380 | { | ||
| 1381 | #if PYTHON_VERSION < 300 | ||
| 1382 | _sentinel_value = PyCObject_FromVoidPtr( NULL, NULL ); | ||
| 1383 | #else | ||
| 1384 | // The NULL value is not allowed for a capsule, so use something else. | ||
| 1385 | _sentinel_value = PyCapsule_New( (void *)27, "sentinel", NULL ); | ||
| 1386 | #endif | ||
| 1387 | assert( _sentinel_value ); | ||
| 1388 | |||
| 1389 | _createGlobalConstants(); | ||
| 1390 | } | ||
| 1391 | } | ||
| File Linux_Version/inventory_synchronisation.build/__constants.o deleted (index 39966fe..0000000) |
| File Linux_Version/inventory_synchronisation.build/__frozen.c deleted (index d1a27fa..0000000) | |||
| 1 | // This provides the frozen (compiled bytecode) files that are included if | ||
| 2 | // any. | ||
| 3 | #include <Python.h> | ||
| 4 | |||
| 5 | #include "nuitka/constants_blob.h" | ||
| 6 | |||
| 7 | // Blob from which modules are unstreamed. | ||
| 8 | #define stream_data constant_bin | ||
| 9 | |||
| 10 | // These modules should be loaded as bytecode. They may e.g. have to be loadable | ||
| 11 | // during "Py_Initialize" already, or for irrelevance, they are only included | ||
| 12 | // in this un-optimized form. These are not compiled by Nuitka, and therefore | ||
| 13 | // are not accelerated at all, merely bundled with the binary or module, so | ||
| 14 | // that CPython library can start out finding them. | ||
| 15 | |||
| 16 | struct frozen_desc { | ||
| 17 | char const *name; | ||
| 18 | ssize_t start; | ||
| 19 | int size; | ||
| 20 | }; | ||
| 21 | |||
| 22 | void copyFrozenModulesTo( struct _frozen *destination ) | ||
| 23 | { | ||
| 24 | struct frozen_desc frozen_modules[] = { | ||
| 25 | { "_collections_abc", 6453374, 28910 }, | ||
| 26 | { "_compression", 6482284, 4092 }, | ||
| 27 | { "_weakrefset", 6486376, 7430 }, | ||
| 28 | { "abc", 6493806, 6419 }, | ||
| 29 | { "base64", 6500225, 16956 }, | ||
| 30 | { "bz2", 6517181, 11149 }, | ||
| 31 | { "codecs", 6528330, 33866 }, | ||
| 32 | { "collections", 77832, -46578 }, | ||
| 33 | { "collections.abc", 6453374, 28910 }, | ||
| 34 | { "copyreg", 6562196, 4212 }, | ||
| 35 | { "dis", 6566408, 15173 }, | ||
| 36 | { "encodings", 6581581, -3915 }, | ||
| 37 | { "encodings.aliases", 6585496, 6264 }, | ||
| 38 | { "encodings.ascii", 6591760, 1852 }, | ||
| 39 | { "encodings.base64_codec", 6593612, 2391 }, | ||
| 40 | { "encodings.big5", 6596003, 1412 }, | ||
| 41 | { "encodings.big5hkscs", 6597415, 1422 }, | ||
| 42 | { "encodings.bz2_codec", 6598837, 3253 }, | ||
| 43 | { "encodings.charmap", 6602090, 2905 }, | ||
| 44 | { "encodings.cp037", 6604995, 2397 }, | ||
| 45 | { "encodings.cp1006", 6607392, 2473 }, | ||
| 46 | { "encodings.cp1026", 6609865, 2401 }, | ||
| 47 | { "encodings.cp1125", 6612266, 8094 }, | ||
| 48 | { "encodings.cp1140", 6620360, 2387 }, | ||
| 49 | { "encodings.cp1250", 6622747, 2424 }, | ||
| 50 | { "encodings.cp1251", 6625171, 2421 }, | ||
| 51 | { "encodings.cp1252", 6627592, 2424 }, | ||
| 52 | { "encodings.cp1253", 6630016, 2437 }, | ||
| 53 | { "encodings.cp1254", 6632453, 2426 }, | ||
| 54 | { "encodings.cp1255", 6634879, 2445 }, | ||
| 55 | { "encodings.cp1256", 6637324, 2423 }, | ||
| 56 | { "encodings.cp1257", 6639747, 2431 }, | ||
| 57 | { "encodings.cp1258", 6642178, 2429 }, | ||
| 58 | { "encodings.cp273", 6644607, 2383 }, | ||
| 59 | { "encodings.cp424", 6646990, 2427 }, | ||
| 60 | { "encodings.cp437", 6649417, 7811 }, | ||
| 61 | { "encodings.cp500", 6657228, 2397 }, | ||
| 62 | { "encodings.cp720", 6659625, 2494 }, | ||
| 63 | { "encodings.cp737", 6662119, 8133 }, | ||
| 64 | { "encodings.cp775", 6670252, 7841 }, | ||
| 65 | { "encodings.cp850", 6678093, 7472 }, | ||
| 66 | { "encodings.cp852", 6685565, 7849 }, | ||
| 67 | { "encodings.cp855", 6693414, 8102 }, | ||
| 68 | { "encodings.cp856", 6701516, 2459 }, | ||
| 69 | { "encodings.cp857", 6703975, 7454 }, | ||
| 70 | { "encodings.cp858", 6711429, 7442 }, | ||
| 71 | { "encodings.cp860", 6718871, 7790 }, | ||
| 72 | { "encodings.cp861", 6726661, 7805 }, | ||
| 73 | { "encodings.cp862", 6734466, 7994 }, | ||
| 74 | { "encodings.cp863", 6742460, 7805 }, | ||
| 75 | { "encodings.cp864", 6750265, 7951 }, | ||
| 76 | { "encodings.cp865", 6758216, 7805 }, | ||
| 77 | { "encodings.cp866", 6766021, 8138 }, | ||
| 78 | { "encodings.cp869", 6774159, 7831 }, | ||
| 79 | { "encodings.cp874", 6781990, 2525 }, | ||
| 80 | { "encodings.cp875", 6784515, 2394 }, | ||
| 81 | { "encodings.cp932", 6786909, 1414 }, | ||
| 82 | { "encodings.cp949", 6788323, 1414 }, | ||
| 83 | { "encodings.cp950", 6789737, 1414 }, | ||
| 84 | { "encodings.euc_jis_2004", 6791151, 1428 }, | ||
| 85 | { "encodings.euc_jisx0213", 6792579, 1428 }, | ||
| 86 | { "encodings.euc_jp", 6794007, 1416 }, | ||
| 87 | { "encodings.euc_kr", 6795423, 1416 }, | ||
| 88 | { "encodings.gb18030", 6796839, 1418 }, | ||
| 89 | { "encodings.gb2312", 6798257, 1416 }, | ||
| 90 | { "encodings.gbk", 6799673, 1410 }, | ||
| 91 | { "encodings.hex_codec", 6801083, 2378 }, | ||
| 92 | { "encodings.hp_roman8", 6803461, 2598 }, | ||
| 93 | { "encodings.hz", 6806059, 1408 }, | ||
| 94 | { "encodings.idna", 6807467, 5692 }, | ||
| 95 | { "encodings.iso2022_jp", 6813159, 1429 }, | ||
| 96 | { "encodings.iso2022_jp_1", 6814588, 1433 }, | ||
| 97 | { "encodings.iso2022_jp_2", 6816021, 1433 }, | ||
| 98 | { "encodings.iso2022_jp_2004", 6817454, 1439 }, | ||
| 99 | { "encodings.iso2022_jp_3", 6818893, 1433 }, | ||
| 100 | { "encodings.iso2022_jp_ext", 6820326, 1437 }, | ||
| 101 | { "encodings.iso2022_kr", 6821763, 1429 }, | ||
| 102 | { "encodings.iso8859_1", 6823192, 2396 }, | ||
| 103 | { "encodings.iso8859_10", 6825588, 2401 }, | ||
| 104 | { "encodings.iso8859_11", 6827989, 2495 }, | ||
| 105 | { "encodings.iso8859_13", 6830484, 2404 }, | ||
| 106 | { "encodings.iso8859_14", 6832888, 2422 }, | ||
| 107 | { "encodings.iso8859_15", 6835310, 2401 }, | ||
| 108 | { "encodings.iso8859_16", 6837711, 2403 }, | ||
| 109 | { "encodings.iso8859_2", 6840114, 2396 }, | ||
| 110 | { "encodings.iso8859_3", 6842510, 2403 }, | ||
| 111 | { "encodings.iso8859_4", 6844913, 2396 }, | ||
| 112 | { "encodings.iso8859_5", 6847309, 2397 }, | ||
| 113 | { "encodings.iso8859_6", 6849706, 2441 }, | ||
| 114 | { "encodings.iso8859_7", 6852147, 2404 }, | ||
| 115 | { "encodings.iso8859_8", 6854551, 2435 }, | ||
| 116 | { "encodings.iso8859_9", 6856986, 2396 }, | ||
| 117 | { "encodings.johab", 6859382, 1414 }, | ||
| 118 | { "encodings.koi8_r", 6860796, 2448 }, | ||
| 119 | { "encodings.koi8_t", 6863244, 2359 }, | ||
| 120 | { "encodings.koi8_u", 6865603, 2434 }, | ||
| 121 | { "encodings.kz1048", 6868037, 2411 }, | ||
| 122 | { "encodings.latin_1", 6870448, 1864 }, | ||
| 123 | { "encodings.mac_arabic", 6872312, 7705 }, | ||
| 124 | { "encodings.mac_centeuro", 6880017, 2435 }, | ||
| 125 | { "encodings.mac_croatian", 6882452, 2443 }, | ||
| 126 | { "encodings.mac_cyrillic", 6884895, 2433 }, | ||
| 127 | { "encodings.mac_farsi", 6887328, 2377 }, | ||
| 128 | { "encodings.mac_greek", 6889705, 2417 }, | ||
| 129 | { "encodings.mac_iceland", 6892122, 2436 }, | ||
| 130 | { "encodings.mac_latin2", 6894558, 2577 }, | ||
| 131 | { "encodings.mac_roman", 6897135, 2434 }, | ||
| 132 | { "encodings.mac_romanian", 6899569, 2444 }, | ||
| 133 | { "encodings.mac_turkish", 6902013, 2437 }, | ||
| 134 | { "encodings.palmos", 6904450, 2424 }, | ||
| 135 | { "encodings.ptcp154", 6906874, 2518 }, | ||
| 136 | { "encodings.punycode", 6909392, 6385 }, | ||
| 137 | { "encodings.quopri_codec", 6915777, 2411 }, | ||
| 138 | { "encodings.raw_unicode_escape", 6918188, 1737 }, | ||
| 139 | { "encodings.rot_13", 6919925, 2997 }, | ||
| 140 | { "encodings.shift_jis", 6922922, 1422 }, | ||
| 141 | { "encodings.shift_jis_2004", 6924344, 1432 }, | ||
| 142 | { "encodings.shift_jisx0213", 6925776, 1432 }, | ||
| 143 | { "encodings.tis_620", 6927208, 2486 }, | ||
| 144 | { "encodings.undefined", 6929694, 2131 }, | ||
| 145 | { "encodings.unicode_escape", 6931825, 1717 }, | ||
| 146 | { "encodings.unicode_internal", 6933542, 1727 }, | ||
| 147 | { "encodings.utf_16", 6935269, 4801 }, | ||
| 148 | { "encodings.utf_16_be", 6940070, 1602 }, | ||
| 149 | { "encodings.utf_16_le", 6941672, 1602 }, | ||
| 150 | { "encodings.utf_32", 6943274, 4694 }, | ||
| 151 | { "encodings.utf_32_be", 6947968, 1495 }, | ||
| 152 | { "encodings.utf_32_le", 6949463, 1495 }, | ||
| 153 | { "encodings.utf_7", 6950958, 1523 }, | ||
| 154 | { "encodings.utf_8", 6952481, 1582 }, | ||
| 155 | { "encodings.utf_8_sig", 6954063, 4484 }, | ||
| 156 | { "encodings.uu_codec", 6958547, 3193 }, | ||
| 157 | { "encodings.zlib_codec", 6961740, 3091 }, | ||
| 158 | { "enum", 6964831, 24230 }, | ||
| 159 | { "functools", 6989061, 23917 }, | ||
| 160 | { "genericpath", 7012978, 3716 }, | ||
| 161 | { "heapq", 7016694, 14330 }, | ||
| 162 | { "importlib", 280930, -3700 }, | ||
| 163 | { "importlib._bootstrap", 7031024, 29146 }, | ||
| 164 | { "importlib._bootstrap_external", 7060170, 41786 }, | ||
| 165 | { "importlib.machinery", 7101956, 940 }, | ||
| 166 | { "inspect", 284630, 80000 }, | ||
| 167 | { "io", 364630, 3377 }, | ||
| 168 | { "keyword", 7102896, 1777 }, | ||
| 169 | { "linecache", 7104673, 3757 }, | ||
| 170 | { "locale", 7108430, 34523 }, | ||
| 171 | { "opcode", 7142953, 5346 }, | ||
| 172 | { "operator", 7148299, 13868 }, | ||
| 173 | { "os", 430533, 29661 }, | ||
| 174 | { "posixpath", 476522, 10398 }, | ||
| 175 | { "quopri", 7162167, 5739 }, | ||
| 176 | { "re", 486920, 13772 }, | ||
| 177 | { "reprlib", 7167906, 5318 }, | ||
| 178 | { "sre_compile", 7173224, 15171 }, | ||
| 179 | { "sre_constants", 7188395, 6259 }, | ||
| 180 | { "sre_parse", 7194654, 21325 }, | ||
| 181 | { "stat", 7215979, 3841 }, | ||
| 182 | { "stringprep", 7219820, 10000 }, | ||
| 183 | { "struct", 7229820, 302 }, | ||
| 184 | { "threading", 536087, 37303 }, | ||
| 185 | { "token", 7230122, 3567 }, | ||
| 186 | { "tokenize", 7233689, 17799 }, | ||
| 187 | { "traceback", 764771, 19591 }, | ||
| 188 | { "types", 784362, 8942 }, | ||
| 189 | { "warnings", 816471, 13917 }, | ||
| 190 | { NULL, 0, 0 } | ||
| 191 | }; | ||
| 192 | |||
| 193 | struct frozen_desc *current = frozen_modules; | ||
| 194 | |||
| 195 | for(;;) | ||
| 196 | { | ||
| 197 | destination->name = (char *)current->name; | ||
| 198 | destination->code = (unsigned char *)&constant_bin[ current->start ]; | ||
| 199 | destination->size = current->size; | ||
| 200 | |||
| 201 | if (destination->name == NULL) break; | ||
| 202 | |||
| 203 | current += 1; | ||
| 204 | destination += 1; | ||
| 205 | }; | ||
| 206 | } | ||
| File Linux_Version/inventory_synchronisation.build/__frozen.o deleted (index a29d215..0000000) |
| File Linux_Version/inventory_synchronisation.build/__helpers.c deleted (index 70b0956..0000000) | |||
| 1 | // This file contains helper functions that are automatically created from | ||
| 2 | // templates. | ||
| 3 | |||
| 4 | #include "nuitka/prelude.h" | ||
| 5 | |||
| 6 | extern PyObject *callPythonFunction( PyObject *func, PyObject **args, int count ); | ||
| 7 | |||
| 8 | |||
| 9 | PyObject *CALL_FUNCTION_WITH_ARGS1( PyObject *called, PyObject **args ) | ||
| 10 | { | ||
| 11 | CHECK_OBJECT( called ); | ||
| 12 | |||
| 13 | // Check if arguments are valid objects in debug mode. | ||
| 14 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 15 | for( size_t i = 0; i < 1; i++ ) | ||
| 16 | { | ||
| 17 | CHECK_OBJECT( args[ i ] ); | ||
| 18 | } | ||
| 19 | #endif | ||
| 20 | |||
| 21 | if ( Nuitka_Function_Check( called ) ) | ||
| 22 | { | ||
| 23 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 24 | { | ||
| 25 | return NULL; | ||
| 26 | } | ||
| 27 | |||
| 28 | struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)called; | ||
| 29 | PyObject *result; | ||
| 30 | |||
| 31 | if ( function->m_args_simple && 1 == function->m_args_positional_count ) | ||
| 32 | { | ||
| 33 | for( Py_ssize_t i = 0; i < 1; i++ ) | ||
| 34 | { | ||
| 35 | Py_INCREF( args[ i ] ); | ||
| 36 | } | ||
| 37 | |||
| 38 | result = function->m_c_code( function, args ); | ||
| 39 | } | ||
| 40 | else if ( function->m_args_simple && 1 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 41 | { | ||
| 42 | #ifdef _MSC_VER | ||
| 43 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 44 | #else | ||
| 45 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 46 | #endif | ||
| 47 | memcpy( python_pars, args, 1 * sizeof(PyObject *) ); | ||
| 48 | memcpy( python_pars + 1, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 49 | |||
| 50 | for( Py_ssize_t i = 0; i < function->m_args_positional_count; i++ ) | ||
| 51 | { | ||
| 52 | Py_INCREF( python_pars[ i ] ); | ||
| 53 | } | ||
| 54 | |||
| 55 | result = function->m_c_code( function, python_pars ); | ||
| 56 | } | ||
| 57 | else | ||
| 58 | { | ||
| 59 | #ifdef _MSC_VER | ||
| 60 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 61 | #else | ||
| 62 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 63 | #endif | ||
| 64 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 65 | |||
| 66 | if ( parseArgumentsPos( function, python_pars, args, 1 )) | ||
| 67 | { | ||
| 68 | result = function->m_c_code( function, python_pars ); | ||
| 69 | } | ||
| 70 | else | ||
| 71 | { | ||
| 72 | result = NULL; | ||
| 73 | } | ||
| 74 | } | ||
| 75 | |||
| 76 | Py_LeaveRecursiveCall(); | ||
| 77 | |||
| 78 | return result; | ||
| 79 | } | ||
| 80 | else if ( Nuitka_Method_Check( called ) ) | ||
| 81 | { | ||
| 82 | struct Nuitka_MethodObject *method = (struct Nuitka_MethodObject *)called; | ||
| 83 | |||
| 84 | // Unbound method without arguments, let the error path be slow. | ||
| 85 | if ( method->m_object != NULL ) | ||
| 86 | { | ||
| 87 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 88 | { | ||
| 89 | return NULL; | ||
| 90 | } | ||
| 91 | |||
| 92 | struct Nuitka_FunctionObject *function = method->m_function; | ||
| 93 | |||
| 94 | PyObject *result; | ||
| 95 | |||
| 96 | if ( function->m_args_simple && 1 + 1 == function->m_args_positional_count ) | ||
| 97 | { | ||
| 98 | #ifdef _MSC_VER | ||
| 99 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 100 | #else | ||
| 101 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 102 | #endif | ||
| 103 | python_pars[ 0 ] = method->m_object; | ||
| 104 | Py_INCREF( method->m_object ); | ||
| 105 | |||
| 106 | for( Py_ssize_t i = 0; i < 1; i++ ) | ||
| 107 | { | ||
| 108 | python_pars[ i + 1 ] = args[ i ]; | ||
| 109 | Py_INCREF( args[ i ] ); | ||
| 110 | } | ||
| 111 | |||
| 112 | result = function->m_c_code( function, python_pars ); | ||
| 113 | } | ||
| 114 | else if ( function->m_args_simple && 1 + 1 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 115 | { | ||
| 116 | #ifdef _MSC_VER | ||
| 117 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 118 | #else | ||
| 119 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 120 | #endif | ||
| 121 | python_pars[ 0 ] = method->m_object; | ||
| 122 | Py_INCREF( method->m_object ); | ||
| 123 | |||
| 124 | memcpy( python_pars+1, args, 1 * sizeof(PyObject *) ); | ||
| 125 | memcpy( python_pars+1 + 1, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 126 | |||
| 127 | for( Py_ssize_t i = 1; i < function->m_args_overall_count; i++ ) | ||
| 128 | { | ||
| 129 | Py_INCREF( python_pars[ i ] ); | ||
| 130 | } | ||
| 131 | |||
| 132 | result = function->m_c_code( function, python_pars ); | ||
| 133 | } | ||
| 134 | else | ||
| 135 | { | ||
| 136 | #ifdef _MSC_VER | ||
| 137 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 138 | #else | ||
| 139 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 140 | #endif | ||
| 141 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 142 | |||
| 143 | if ( parseArgumentsMethodPos( function, python_pars, method->m_object, args, 1 ) ) | ||
| 144 | { | ||
| 145 | result = function->m_c_code( function, python_pars ); | ||
| 146 | } | ||
| 147 | else | ||
| 148 | { | ||
| 149 | result = NULL; | ||
| 150 | } | ||
| 151 | } | ||
| 152 | |||
| 153 | Py_LeaveRecursiveCall(); | ||
| 154 | |||
| 155 | return result; | ||
| 156 | } | ||
| 157 | } | ||
| 158 | else if ( PyCFunction_Check( called ) ) | ||
| 159 | { | ||
| 160 | // Try to be fast about wrapping the arguments. | ||
| 161 | int flags = PyCFunction_GET_FLAGS( called ) & ~(METH_CLASS | METH_STATIC | METH_COEXIST); | ||
| 162 | |||
| 163 | if ( flags & METH_NOARGS ) | ||
| 164 | { | ||
| 165 | #if 1 == 0 | ||
| 166 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 167 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 168 | |||
| 169 | // Recursion guard is not strictly necessary, as we already have | ||
| 170 | // one on our way to here. | ||
| 171 | #ifdef _NUITKA_FULL_COMPAT | ||
| 172 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 173 | { | ||
| 174 | return NULL; | ||
| 175 | } | ||
| 176 | #endif | ||
| 177 | |||
| 178 | PyObject *result = (*method)( self, NULL ); | ||
| 179 | |||
| 180 | #ifdef _NUITKA_FULL_COMPAT | ||
| 181 | Py_LeaveRecursiveCall(); | ||
| 182 | #endif | ||
| 183 | |||
| 184 | if ( result != NULL ) | ||
| 185 | { | ||
| 186 | // Some buggy C functions do set an error, but do not indicate it | ||
| 187 | // and Nuitka inner workings can get upset/confused from it. | ||
| 188 | DROP_ERROR_OCCURRED(); | ||
| 189 | |||
| 190 | return result; | ||
| 191 | } | ||
| 192 | else | ||
| 193 | { | ||
| 194 | // Other buggy C functions do this, return NULL, but with | ||
| 195 | // no error set, not allowed. | ||
| 196 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 197 | { | ||
| 198 | PyErr_Format( | ||
| 199 | PyExc_SystemError, | ||
| 200 | "NULL result without error in PyObject_Call" | ||
| 201 | ); | ||
| 202 | } | ||
| 203 | |||
| 204 | return NULL; | ||
| 205 | } | ||
| 206 | #else | ||
| 207 | PyErr_Format( | ||
| 208 | PyExc_TypeError, | ||
| 209 | "%s() takes no arguments (1 given)", | ||
| 210 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 211 | ); | ||
| 212 | return NULL; | ||
| 213 | #endif | ||
| 214 | } | ||
| 215 | else if ( flags & METH_O ) | ||
| 216 | { | ||
| 217 | #if 1 == 1 | ||
| 218 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 219 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 220 | |||
| 221 | // Recursion guard is not strictly necessary, as we already have | ||
| 222 | // one on our way to here. | ||
| 223 | #ifdef _NUITKA_FULL_COMPAT | ||
| 224 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 225 | { | ||
| 226 | return NULL; | ||
| 227 | } | ||
| 228 | #endif | ||
| 229 | |||
| 230 | PyObject *result = (*method)( self, args[0] ); | ||
| 231 | |||
| 232 | #ifdef _NUITKA_FULL_COMPAT | ||
| 233 | Py_LeaveRecursiveCall(); | ||
| 234 | #endif | ||
| 235 | |||
| 236 | if ( result != NULL ) | ||
| 237 | { | ||
| 238 | // Some buggy C functions do set an error, but do not indicate it | ||
| 239 | // and Nuitka inner workings can get upset/confused from it. | ||
| 240 | DROP_ERROR_OCCURRED(); | ||
| 241 | |||
| 242 | return result; | ||
| 243 | } | ||
| 244 | else | ||
| 245 | { | ||
| 246 | // Other buggy C functions do this, return NULL, but with | ||
| 247 | // no error set, not allowed. | ||
| 248 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 249 | { | ||
| 250 | PyErr_Format( | ||
| 251 | PyExc_SystemError, | ||
| 252 | "NULL result without error in PyObject_Call" | ||
| 253 | ); | ||
| 254 | } | ||
| 255 | |||
| 256 | return NULL; | ||
| 257 | } | ||
| 258 | #else | ||
| 259 | PyErr_Format(PyExc_TypeError, | ||
| 260 | "%s() takes exactly one argument (1 given)", | ||
| 261 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 262 | ); | ||
| 263 | return NULL; | ||
| 264 | #endif | ||
| 265 | } | ||
| 266 | else if ( flags & METH_VARARGS ) | ||
| 267 | { | ||
| 268 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 269 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 270 | |||
| 271 | PyObject *pos_args = MAKE_TUPLE( args, 1 ); | ||
| 272 | |||
| 273 | PyObject *result; | ||
| 274 | |||
| 275 | // Recursion guard is not strictly necessary, as we already have | ||
| 276 | // one on our way to here. | ||
| 277 | #ifdef _NUITKA_FULL_COMPAT | ||
| 278 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 279 | { | ||
| 280 | return NULL; | ||
| 281 | } | ||
| 282 | #endif | ||
| 283 | |||
| 284 | #if PYTHON_VERSION < 360 | ||
| 285 | if ( flags & METH_KEYWORDS ) | ||
| 286 | { | ||
| 287 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 288 | } | ||
| 289 | else | ||
| 290 | { | ||
| 291 | result = (*method)( self, pos_args ); | ||
| 292 | } | ||
| 293 | #else | ||
| 294 | if ( flags == ( METH_VARARGS | METH_KEYWORDS ) ) | ||
| 295 | { | ||
| 296 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 297 | } | ||
| 298 | else if ( flags == METH_FASTCALL ) | ||
| 299 | { | ||
| 300 | #if PYTHON_VERSION < 370 | ||
| 301 | result = (*(_PyCFunctionFast)method)( self, &PyTuple_GET_ITEM( pos_args, 0 ), 1, NULL );; | ||
| 302 | #else | ||
| 303 | result = (*(_PyCFunctionFast)method)( self, &pos_args, 1 );; | ||
| 304 | #endif | ||
| 305 | } | ||
| 306 | else | ||
| 307 | { | ||
| 308 | result = (*method)( self, pos_args ); | ||
| 309 | } | ||
| 310 | #endif | ||
| 311 | |||
| 312 | #ifdef _NUITKA_FULL_COMPAT | ||
| 313 | Py_LeaveRecursiveCall(); | ||
| 314 | #endif | ||
| 315 | |||
| 316 | if ( result != NULL ) | ||
| 317 | { | ||
| 318 | // Some buggy C functions do set an error, but do not indicate it | ||
| 319 | // and Nuitka inner workings can get upset/confused from it. | ||
| 320 | DROP_ERROR_OCCURRED(); | ||
| 321 | |||
| 322 | Py_DECREF( pos_args ); | ||
| 323 | return result; | ||
| 324 | } | ||
| 325 | else | ||
| 326 | { | ||
| 327 | // Other buggy C functions do this, return NULL, but with | ||
| 328 | // no error set, not allowed. | ||
| 329 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 330 | { | ||
| 331 | PyErr_Format( | ||
| 332 | PyExc_SystemError, | ||
| 333 | "NULL result without error in PyObject_Call" | ||
| 334 | ); | ||
| 335 | } | ||
| 336 | |||
| 337 | Py_DECREF( pos_args ); | ||
| 338 | return NULL; | ||
| 339 | } | ||
| 340 | } | ||
| 341 | } | ||
| 342 | else if ( PyFunction_Check( called ) ) | ||
| 343 | { | ||
| 344 | return callPythonFunction( | ||
| 345 | called, | ||
| 346 | args, | ||
| 347 | 1 | ||
| 348 | ); | ||
| 349 | } | ||
| 350 | |||
| 351 | PyObject *pos_args = MAKE_TUPLE( args, 1 ); | ||
| 352 | |||
| 353 | PyObject *result = CALL_FUNCTION( | ||
| 354 | called, | ||
| 355 | pos_args, | ||
| 356 | NULL | ||
| 357 | ); | ||
| 358 | |||
| 359 | Py_DECREF( pos_args ); | ||
| 360 | |||
| 361 | return result; | ||
| 362 | } | ||
| 363 | |||
| 364 | PyObject *CALL_FUNCTION_WITH_ARGS2( PyObject *called, PyObject **args ) | ||
| 365 | { | ||
| 366 | CHECK_OBJECT( called ); | ||
| 367 | |||
| 368 | // Check if arguments are valid objects in debug mode. | ||
| 369 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 370 | for( size_t i = 0; i < 2; i++ ) | ||
| 371 | { | ||
| 372 | CHECK_OBJECT( args[ i ] ); | ||
| 373 | } | ||
| 374 | #endif | ||
| 375 | |||
| 376 | if ( Nuitka_Function_Check( called ) ) | ||
| 377 | { | ||
| 378 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 379 | { | ||
| 380 | return NULL; | ||
| 381 | } | ||
| 382 | |||
| 383 | struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)called; | ||
| 384 | PyObject *result; | ||
| 385 | |||
| 386 | if ( function->m_args_simple && 2 == function->m_args_positional_count ) | ||
| 387 | { | ||
| 388 | for( Py_ssize_t i = 0; i < 2; i++ ) | ||
| 389 | { | ||
| 390 | Py_INCREF( args[ i ] ); | ||
| 391 | } | ||
| 392 | |||
| 393 | result = function->m_c_code( function, args ); | ||
| 394 | } | ||
| 395 | else if ( function->m_args_simple && 2 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 396 | { | ||
| 397 | #ifdef _MSC_VER | ||
| 398 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 399 | #else | ||
| 400 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 401 | #endif | ||
| 402 | memcpy( python_pars, args, 2 * sizeof(PyObject *) ); | ||
| 403 | memcpy( python_pars + 2, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 404 | |||
| 405 | for( Py_ssize_t i = 0; i < function->m_args_positional_count; i++ ) | ||
| 406 | { | ||
| 407 | Py_INCREF( python_pars[ i ] ); | ||
| 408 | } | ||
| 409 | |||
| 410 | result = function->m_c_code( function, python_pars ); | ||
| 411 | } | ||
| 412 | else | ||
| 413 | { | ||
| 414 | #ifdef _MSC_VER | ||
| 415 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 416 | #else | ||
| 417 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 418 | #endif | ||
| 419 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 420 | |||
| 421 | if ( parseArgumentsPos( function, python_pars, args, 2 )) | ||
| 422 | { | ||
| 423 | result = function->m_c_code( function, python_pars ); | ||
| 424 | } | ||
| 425 | else | ||
| 426 | { | ||
| 427 | result = NULL; | ||
| 428 | } | ||
| 429 | } | ||
| 430 | |||
| 431 | Py_LeaveRecursiveCall(); | ||
| 432 | |||
| 433 | return result; | ||
| 434 | } | ||
| 435 | else if ( Nuitka_Method_Check( called ) ) | ||
| 436 | { | ||
| 437 | struct Nuitka_MethodObject *method = (struct Nuitka_MethodObject *)called; | ||
| 438 | |||
| 439 | // Unbound method without arguments, let the error path be slow. | ||
| 440 | if ( method->m_object != NULL ) | ||
| 441 | { | ||
| 442 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 443 | { | ||
| 444 | return NULL; | ||
| 445 | } | ||
| 446 | |||
| 447 | struct Nuitka_FunctionObject *function = method->m_function; | ||
| 448 | |||
| 449 | PyObject *result; | ||
| 450 | |||
| 451 | if ( function->m_args_simple && 2 + 1 == function->m_args_positional_count ) | ||
| 452 | { | ||
| 453 | #ifdef _MSC_VER | ||
| 454 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 455 | #else | ||
| 456 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 457 | #endif | ||
| 458 | python_pars[ 0 ] = method->m_object; | ||
| 459 | Py_INCREF( method->m_object ); | ||
| 460 | |||
| 461 | for( Py_ssize_t i = 0; i < 2; i++ ) | ||
| 462 | { | ||
| 463 | python_pars[ i + 1 ] = args[ i ]; | ||
| 464 | Py_INCREF( args[ i ] ); | ||
| 465 | } | ||
| 466 | |||
| 467 | result = function->m_c_code( function, python_pars ); | ||
| 468 | } | ||
| 469 | else if ( function->m_args_simple && 2 + 1 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 470 | { | ||
| 471 | #ifdef _MSC_VER | ||
| 472 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 473 | #else | ||
| 474 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 475 | #endif | ||
| 476 | python_pars[ 0 ] = method->m_object; | ||
| 477 | Py_INCREF( method->m_object ); | ||
| 478 | |||
| 479 | memcpy( python_pars+1, args, 2 * sizeof(PyObject *) ); | ||
| 480 | memcpy( python_pars+1 + 2, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 481 | |||
| 482 | for( Py_ssize_t i = 1; i < function->m_args_overall_count; i++ ) | ||
| 483 | { | ||
| 484 | Py_INCREF( python_pars[ i ] ); | ||
| 485 | } | ||
| 486 | |||
| 487 | result = function->m_c_code( function, python_pars ); | ||
| 488 | } | ||
| 489 | else | ||
| 490 | { | ||
| 491 | #ifdef _MSC_VER | ||
| 492 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 493 | #else | ||
| 494 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 495 | #endif | ||
| 496 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 497 | |||
| 498 | if ( parseArgumentsMethodPos( function, python_pars, method->m_object, args, 2 ) ) | ||
| 499 | { | ||
| 500 | result = function->m_c_code( function, python_pars ); | ||
| 501 | } | ||
| 502 | else | ||
| 503 | { | ||
| 504 | result = NULL; | ||
| 505 | } | ||
| 506 | } | ||
| 507 | |||
| 508 | Py_LeaveRecursiveCall(); | ||
| 509 | |||
| 510 | return result; | ||
| 511 | } | ||
| 512 | } | ||
| 513 | else if ( PyCFunction_Check( called ) ) | ||
| 514 | { | ||
| 515 | // Try to be fast about wrapping the arguments. | ||
| 516 | int flags = PyCFunction_GET_FLAGS( called ) & ~(METH_CLASS | METH_STATIC | METH_COEXIST); | ||
| 517 | |||
| 518 | if ( flags & METH_NOARGS ) | ||
| 519 | { | ||
| 520 | #if 2 == 0 | ||
| 521 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 522 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 523 | |||
| 524 | // Recursion guard is not strictly necessary, as we already have | ||
| 525 | // one on our way to here. | ||
| 526 | #ifdef _NUITKA_FULL_COMPAT | ||
| 527 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 528 | { | ||
| 529 | return NULL; | ||
| 530 | } | ||
| 531 | #endif | ||
| 532 | |||
| 533 | PyObject *result = (*method)( self, NULL ); | ||
| 534 | |||
| 535 | #ifdef _NUITKA_FULL_COMPAT | ||
| 536 | Py_LeaveRecursiveCall(); | ||
| 537 | #endif | ||
| 538 | |||
| 539 | if ( result != NULL ) | ||
| 540 | { | ||
| 541 | // Some buggy C functions do set an error, but do not indicate it | ||
| 542 | // and Nuitka inner workings can get upset/confused from it. | ||
| 543 | DROP_ERROR_OCCURRED(); | ||
| 544 | |||
| 545 | return result; | ||
| 546 | } | ||
| 547 | else | ||
| 548 | { | ||
| 549 | // Other buggy C functions do this, return NULL, but with | ||
| 550 | // no error set, not allowed. | ||
| 551 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 552 | { | ||
| 553 | PyErr_Format( | ||
| 554 | PyExc_SystemError, | ||
| 555 | "NULL result without error in PyObject_Call" | ||
| 556 | ); | ||
| 557 | } | ||
| 558 | |||
| 559 | return NULL; | ||
| 560 | } | ||
| 561 | #else | ||
| 562 | PyErr_Format( | ||
| 563 | PyExc_TypeError, | ||
| 564 | "%s() takes no arguments (2 given)", | ||
| 565 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 566 | ); | ||
| 567 | return NULL; | ||
| 568 | #endif | ||
| 569 | } | ||
| 570 | else if ( flags & METH_O ) | ||
| 571 | { | ||
| 572 | #if 2 == 1 | ||
| 573 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 574 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 575 | |||
| 576 | // Recursion guard is not strictly necessary, as we already have | ||
| 577 | // one on our way to here. | ||
| 578 | #ifdef _NUITKA_FULL_COMPAT | ||
| 579 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 580 | { | ||
| 581 | return NULL; | ||
| 582 | } | ||
| 583 | #endif | ||
| 584 | |||
| 585 | PyObject *result = (*method)( self, args[0] ); | ||
| 586 | |||
| 587 | #ifdef _NUITKA_FULL_COMPAT | ||
| 588 | Py_LeaveRecursiveCall(); | ||
| 589 | #endif | ||
| 590 | |||
| 591 | if ( result != NULL ) | ||
| 592 | { | ||
| 593 | // Some buggy C functions do set an error, but do not indicate it | ||
| 594 | // and Nuitka inner workings can get upset/confused from it. | ||
| 595 | DROP_ERROR_OCCURRED(); | ||
| 596 | |||
| 597 | return result; | ||
| 598 | } | ||
| 599 | else | ||
| 600 | { | ||
| 601 | // Other buggy C functions do this, return NULL, but with | ||
| 602 | // no error set, not allowed. | ||
| 603 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 604 | { | ||
| 605 | PyErr_Format( | ||
| 606 | PyExc_SystemError, | ||
| 607 | "NULL result without error in PyObject_Call" | ||
| 608 | ); | ||
| 609 | } | ||
| 610 | |||
| 611 | return NULL; | ||
| 612 | } | ||
| 613 | #else | ||
| 614 | PyErr_Format(PyExc_TypeError, | ||
| 615 | "%s() takes exactly one argument (2 given)", | ||
| 616 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 617 | ); | ||
| 618 | return NULL; | ||
| 619 | #endif | ||
| 620 | } | ||
| 621 | else if ( flags & METH_VARARGS ) | ||
| 622 | { | ||
| 623 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 624 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 625 | |||
| 626 | PyObject *pos_args = MAKE_TUPLE( args, 2 ); | ||
| 627 | |||
| 628 | PyObject *result; | ||
| 629 | |||
| 630 | // Recursion guard is not strictly necessary, as we already have | ||
| 631 | // one on our way to here. | ||
| 632 | #ifdef _NUITKA_FULL_COMPAT | ||
| 633 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 634 | { | ||
| 635 | return NULL; | ||
| 636 | } | ||
| 637 | #endif | ||
| 638 | |||
| 639 | #if PYTHON_VERSION < 360 | ||
| 640 | if ( flags & METH_KEYWORDS ) | ||
| 641 | { | ||
| 642 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 643 | } | ||
| 644 | else | ||
| 645 | { | ||
| 646 | result = (*method)( self, pos_args ); | ||
| 647 | } | ||
| 648 | #else | ||
| 649 | if ( flags == ( METH_VARARGS | METH_KEYWORDS ) ) | ||
| 650 | { | ||
| 651 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 652 | } | ||
| 653 | else if ( flags == METH_FASTCALL ) | ||
| 654 | { | ||
| 655 | #if PYTHON_VERSION < 370 | ||
| 656 | result = (*(_PyCFunctionFast)method)( self, &PyTuple_GET_ITEM( pos_args, 0 ), 2, NULL );; | ||
| 657 | #else | ||
| 658 | result = (*(_PyCFunctionFast)method)( self, &pos_args, 2 );; | ||
| 659 | #endif | ||
| 660 | } | ||
| 661 | else | ||
| 662 | { | ||
| 663 | result = (*method)( self, pos_args ); | ||
| 664 | } | ||
| 665 | #endif | ||
| 666 | |||
| 667 | #ifdef _NUITKA_FULL_COMPAT | ||
| 668 | Py_LeaveRecursiveCall(); | ||
| 669 | #endif | ||
| 670 | |||
| 671 | if ( result != NULL ) | ||
| 672 | { | ||
| 673 | // Some buggy C functions do set an error, but do not indicate it | ||
| 674 | // and Nuitka inner workings can get upset/confused from it. | ||
| 675 | DROP_ERROR_OCCURRED(); | ||
| 676 | |||
| 677 | Py_DECREF( pos_args ); | ||
| 678 | return result; | ||
| 679 | } | ||
| 680 | else | ||
| 681 | { | ||
| 682 | // Other buggy C functions do this, return NULL, but with | ||
| 683 | // no error set, not allowed. | ||
| 684 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 685 | { | ||
| 686 | PyErr_Format( | ||
| 687 | PyExc_SystemError, | ||
| 688 | "NULL result without error in PyObject_Call" | ||
| 689 | ); | ||
| 690 | } | ||
| 691 | |||
| 692 | Py_DECREF( pos_args ); | ||
| 693 | return NULL; | ||
| 694 | } | ||
| 695 | } | ||
| 696 | } | ||
| 697 | else if ( PyFunction_Check( called ) ) | ||
| 698 | { | ||
| 699 | return callPythonFunction( | ||
| 700 | called, | ||
| 701 | args, | ||
| 702 | 2 | ||
| 703 | ); | ||
| 704 | } | ||
| 705 | |||
| 706 | PyObject *pos_args = MAKE_TUPLE( args, 2 ); | ||
| 707 | |||
| 708 | PyObject *result = CALL_FUNCTION( | ||
| 709 | called, | ||
| 710 | pos_args, | ||
| 711 | NULL | ||
| 712 | ); | ||
| 713 | |||
| 714 | Py_DECREF( pos_args ); | ||
| 715 | |||
| 716 | return result; | ||
| 717 | } | ||
| 718 | |||
| 719 | PyObject *CALL_FUNCTION_WITH_ARGS3( PyObject *called, PyObject **args ) | ||
| 720 | { | ||
| 721 | CHECK_OBJECT( called ); | ||
| 722 | |||
| 723 | // Check if arguments are valid objects in debug mode. | ||
| 724 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 725 | for( size_t i = 0; i < 3; i++ ) | ||
| 726 | { | ||
| 727 | CHECK_OBJECT( args[ i ] ); | ||
| 728 | } | ||
| 729 | #endif | ||
| 730 | |||
| 731 | if ( Nuitka_Function_Check( called ) ) | ||
| 732 | { | ||
| 733 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 734 | { | ||
| 735 | return NULL; | ||
| 736 | } | ||
| 737 | |||
| 738 | struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)called; | ||
| 739 | PyObject *result; | ||
| 740 | |||
| 741 | if ( function->m_args_simple && 3 == function->m_args_positional_count ) | ||
| 742 | { | ||
| 743 | for( Py_ssize_t i = 0; i < 3; i++ ) | ||
| 744 | { | ||
| 745 | Py_INCREF( args[ i ] ); | ||
| 746 | } | ||
| 747 | |||
| 748 | result = function->m_c_code( function, args ); | ||
| 749 | } | ||
| 750 | else if ( function->m_args_simple && 3 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 751 | { | ||
| 752 | #ifdef _MSC_VER | ||
| 753 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 754 | #else | ||
| 755 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 756 | #endif | ||
| 757 | memcpy( python_pars, args, 3 * sizeof(PyObject *) ); | ||
| 758 | memcpy( python_pars + 3, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 759 | |||
| 760 | for( Py_ssize_t i = 0; i < function->m_args_positional_count; i++ ) | ||
| 761 | { | ||
| 762 | Py_INCREF( python_pars[ i ] ); | ||
| 763 | } | ||
| 764 | |||
| 765 | result = function->m_c_code( function, python_pars ); | ||
| 766 | } | ||
| 767 | else | ||
| 768 | { | ||
| 769 | #ifdef _MSC_VER | ||
| 770 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 771 | #else | ||
| 772 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 773 | #endif | ||
| 774 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 775 | |||
| 776 | if ( parseArgumentsPos( function, python_pars, args, 3 )) | ||
| 777 | { | ||
| 778 | result = function->m_c_code( function, python_pars ); | ||
| 779 | } | ||
| 780 | else | ||
| 781 | { | ||
| 782 | result = NULL; | ||
| 783 | } | ||
| 784 | } | ||
| 785 | |||
| 786 | Py_LeaveRecursiveCall(); | ||
| 787 | |||
| 788 | return result; | ||
| 789 | } | ||
| 790 | else if ( Nuitka_Method_Check( called ) ) | ||
| 791 | { | ||
| 792 | struct Nuitka_MethodObject *method = (struct Nuitka_MethodObject *)called; | ||
| 793 | |||
| 794 | // Unbound method without arguments, let the error path be slow. | ||
| 795 | if ( method->m_object != NULL ) | ||
| 796 | { | ||
| 797 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 798 | { | ||
| 799 | return NULL; | ||
| 800 | } | ||
| 801 | |||
| 802 | struct Nuitka_FunctionObject *function = method->m_function; | ||
| 803 | |||
| 804 | PyObject *result; | ||
| 805 | |||
| 806 | if ( function->m_args_simple && 3 + 1 == function->m_args_positional_count ) | ||
| 807 | { | ||
| 808 | #ifdef _MSC_VER | ||
| 809 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 810 | #else | ||
| 811 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 812 | #endif | ||
| 813 | python_pars[ 0 ] = method->m_object; | ||
| 814 | Py_INCREF( method->m_object ); | ||
| 815 | |||
| 816 | for( Py_ssize_t i = 0; i < 3; i++ ) | ||
| 817 | { | ||
| 818 | python_pars[ i + 1 ] = args[ i ]; | ||
| 819 | Py_INCREF( args[ i ] ); | ||
| 820 | } | ||
| 821 | |||
| 822 | result = function->m_c_code( function, python_pars ); | ||
| 823 | } | ||
| 824 | else if ( function->m_args_simple && 3 + 1 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 825 | { | ||
| 826 | #ifdef _MSC_VER | ||
| 827 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 828 | #else | ||
| 829 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 830 | #endif | ||
| 831 | python_pars[ 0 ] = method->m_object; | ||
| 832 | Py_INCREF( method->m_object ); | ||
| 833 | |||
| 834 | memcpy( python_pars+1, args, 3 * sizeof(PyObject *) ); | ||
| 835 | memcpy( python_pars+1 + 3, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 836 | |||
| 837 | for( Py_ssize_t i = 1; i < function->m_args_overall_count; i++ ) | ||
| 838 | { | ||
| 839 | Py_INCREF( python_pars[ i ] ); | ||
| 840 | } | ||
| 841 | |||
| 842 | result = function->m_c_code( function, python_pars ); | ||
| 843 | } | ||
| 844 | else | ||
| 845 | { | ||
| 846 | #ifdef _MSC_VER | ||
| 847 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 848 | #else | ||
| 849 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 850 | #endif | ||
| 851 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 852 | |||
| 853 | if ( parseArgumentsMethodPos( function, python_pars, method->m_object, args, 3 ) ) | ||
| 854 | { | ||
| 855 | result = function->m_c_code( function, python_pars ); | ||
| 856 | } | ||
| 857 | else | ||
| 858 | { | ||
| 859 | result = NULL; | ||
| 860 | } | ||
| 861 | } | ||
| 862 | |||
| 863 | Py_LeaveRecursiveCall(); | ||
| 864 | |||
| 865 | return result; | ||
| 866 | } | ||
| 867 | } | ||
| 868 | else if ( PyCFunction_Check( called ) ) | ||
| 869 | { | ||
| 870 | // Try to be fast about wrapping the arguments. | ||
| 871 | int flags = PyCFunction_GET_FLAGS( called ) & ~(METH_CLASS | METH_STATIC | METH_COEXIST); | ||
| 872 | |||
| 873 | if ( flags & METH_NOARGS ) | ||
| 874 | { | ||
| 875 | #if 3 == 0 | ||
| 876 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 877 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 878 | |||
| 879 | // Recursion guard is not strictly necessary, as we already have | ||
| 880 | // one on our way to here. | ||
| 881 | #ifdef _NUITKA_FULL_COMPAT | ||
| 882 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 883 | { | ||
| 884 | return NULL; | ||
| 885 | } | ||
| 886 | #endif | ||
| 887 | |||
| 888 | PyObject *result = (*method)( self, NULL ); | ||
| 889 | |||
| 890 | #ifdef _NUITKA_FULL_COMPAT | ||
| 891 | Py_LeaveRecursiveCall(); | ||
| 892 | #endif | ||
| 893 | |||
| 894 | if ( result != NULL ) | ||
| 895 | { | ||
| 896 | // Some buggy C functions do set an error, but do not indicate it | ||
| 897 | // and Nuitka inner workings can get upset/confused from it. | ||
| 898 | DROP_ERROR_OCCURRED(); | ||
| 899 | |||
| 900 | return result; | ||
| 901 | } | ||
| 902 | else | ||
| 903 | { | ||
| 904 | // Other buggy C functions do this, return NULL, but with | ||
| 905 | // no error set, not allowed. | ||
| 906 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 907 | { | ||
| 908 | PyErr_Format( | ||
| 909 | PyExc_SystemError, | ||
| 910 | "NULL result without error in PyObject_Call" | ||
| 911 | ); | ||
| 912 | } | ||
| 913 | |||
| 914 | return NULL; | ||
| 915 | } | ||
| 916 | #else | ||
| 917 | PyErr_Format( | ||
| 918 | PyExc_TypeError, | ||
| 919 | "%s() takes no arguments (3 given)", | ||
| 920 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 921 | ); | ||
| 922 | return NULL; | ||
| 923 | #endif | ||
| 924 | } | ||
| 925 | else if ( flags & METH_O ) | ||
| 926 | { | ||
| 927 | #if 3 == 1 | ||
| 928 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 929 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 930 | |||
| 931 | // Recursion guard is not strictly necessary, as we already have | ||
| 932 | // one on our way to here. | ||
| 933 | #ifdef _NUITKA_FULL_COMPAT | ||
| 934 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 935 | { | ||
| 936 | return NULL; | ||
| 937 | } | ||
| 938 | #endif | ||
| 939 | |||
| 940 | PyObject *result = (*method)( self, args[0] ); | ||
| 941 | |||
| 942 | #ifdef _NUITKA_FULL_COMPAT | ||
| 943 | Py_LeaveRecursiveCall(); | ||
| 944 | #endif | ||
| 945 | |||
| 946 | if ( result != NULL ) | ||
| 947 | { | ||
| 948 | // Some buggy C functions do set an error, but do not indicate it | ||
| 949 | // and Nuitka inner workings can get upset/confused from it. | ||
| 950 | DROP_ERROR_OCCURRED(); | ||
| 951 | |||
| 952 | return result; | ||
| 953 | } | ||
| 954 | else | ||
| 955 | { | ||
| 956 | // Other buggy C functions do this, return NULL, but with | ||
| 957 | // no error set, not allowed. | ||
| 958 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 959 | { | ||
| 960 | PyErr_Format( | ||
| 961 | PyExc_SystemError, | ||
| 962 | "NULL result without error in PyObject_Call" | ||
| 963 | ); | ||
| 964 | } | ||
| 965 | |||
| 966 | return NULL; | ||
| 967 | } | ||
| 968 | #else | ||
| 969 | PyErr_Format(PyExc_TypeError, | ||
| 970 | "%s() takes exactly one argument (3 given)", | ||
| 971 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 972 | ); | ||
| 973 | return NULL; | ||
| 974 | #endif | ||
| 975 | } | ||
| 976 | else if ( flags & METH_VARARGS ) | ||
| 977 | { | ||
| 978 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 979 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 980 | |||
| 981 | PyObject *pos_args = MAKE_TUPLE( args, 3 ); | ||
| 982 | |||
| 983 | PyObject *result; | ||
| 984 | |||
| 985 | // Recursion guard is not strictly necessary, as we already have | ||
| 986 | // one on our way to here. | ||
| 987 | #ifdef _NUITKA_FULL_COMPAT | ||
| 988 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 989 | { | ||
| 990 | return NULL; | ||
| 991 | } | ||
| 992 | #endif | ||
| 993 | |||
| 994 | #if PYTHON_VERSION < 360 | ||
| 995 | if ( flags & METH_KEYWORDS ) | ||
| 996 | { | ||
| 997 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 998 | } | ||
| 999 | else | ||
| 1000 | { | ||
| 1001 | result = (*method)( self, pos_args ); | ||
| 1002 | } | ||
| 1003 | #else | ||
| 1004 | if ( flags == ( METH_VARARGS | METH_KEYWORDS ) ) | ||
| 1005 | { | ||
| 1006 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 1007 | } | ||
| 1008 | else if ( flags == METH_FASTCALL ) | ||
| 1009 | { | ||
| 1010 | #if PYTHON_VERSION < 370 | ||
| 1011 | result = (*(_PyCFunctionFast)method)( self, &PyTuple_GET_ITEM( pos_args, 0 ), 3, NULL );; | ||
| 1012 | #else | ||
| 1013 | result = (*(_PyCFunctionFast)method)( self, &pos_args, 3 );; | ||
| 1014 | #endif | ||
| 1015 | } | ||
| 1016 | else | ||
| 1017 | { | ||
| 1018 | result = (*method)( self, pos_args ); | ||
| 1019 | } | ||
| 1020 | #endif | ||
| 1021 | |||
| 1022 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1023 | Py_LeaveRecursiveCall(); | ||
| 1024 | #endif | ||
| 1025 | |||
| 1026 | if ( result != NULL ) | ||
| 1027 | { | ||
| 1028 | // Some buggy C functions do set an error, but do not indicate it | ||
| 1029 | // and Nuitka inner workings can get upset/confused from it. | ||
| 1030 | DROP_ERROR_OCCURRED(); | ||
| 1031 | |||
| 1032 | Py_DECREF( pos_args ); | ||
| 1033 | return result; | ||
| 1034 | } | ||
| 1035 | else | ||
| 1036 | { | ||
| 1037 | // Other buggy C functions do this, return NULL, but with | ||
| 1038 | // no error set, not allowed. | ||
| 1039 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 1040 | { | ||
| 1041 | PyErr_Format( | ||
| 1042 | PyExc_SystemError, | ||
| 1043 | "NULL result without error in PyObject_Call" | ||
| 1044 | ); | ||
| 1045 | } | ||
| 1046 | |||
| 1047 | Py_DECREF( pos_args ); | ||
| 1048 | return NULL; | ||
| 1049 | } | ||
| 1050 | } | ||
| 1051 | } | ||
| 1052 | else if ( PyFunction_Check( called ) ) | ||
| 1053 | { | ||
| 1054 | return callPythonFunction( | ||
| 1055 | called, | ||
| 1056 | args, | ||
| 1057 | 3 | ||
| 1058 | ); | ||
| 1059 | } | ||
| 1060 | |||
| 1061 | PyObject *pos_args = MAKE_TUPLE( args, 3 ); | ||
| 1062 | |||
| 1063 | PyObject *result = CALL_FUNCTION( | ||
| 1064 | called, | ||
| 1065 | pos_args, | ||
| 1066 | NULL | ||
| 1067 | ); | ||
| 1068 | |||
| 1069 | Py_DECREF( pos_args ); | ||
| 1070 | |||
| 1071 | return result; | ||
| 1072 | } | ||
| 1073 | |||
| 1074 | PyObject *CALL_FUNCTION_WITH_ARGS4( PyObject *called, PyObject **args ) | ||
| 1075 | { | ||
| 1076 | CHECK_OBJECT( called ); | ||
| 1077 | |||
| 1078 | // Check if arguments are valid objects in debug mode. | ||
| 1079 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1080 | for( size_t i = 0; i < 4; i++ ) | ||
| 1081 | { | ||
| 1082 | CHECK_OBJECT( args[ i ] ); | ||
| 1083 | } | ||
| 1084 | #endif | ||
| 1085 | |||
| 1086 | if ( Nuitka_Function_Check( called ) ) | ||
| 1087 | { | ||
| 1088 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1089 | { | ||
| 1090 | return NULL; | ||
| 1091 | } | ||
| 1092 | |||
| 1093 | struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)called; | ||
| 1094 | PyObject *result; | ||
| 1095 | |||
| 1096 | if ( function->m_args_simple && 4 == function->m_args_positional_count ) | ||
| 1097 | { | ||
| 1098 | for( Py_ssize_t i = 0; i < 4; i++ ) | ||
| 1099 | { | ||
| 1100 | Py_INCREF( args[ i ] ); | ||
| 1101 | } | ||
| 1102 | |||
| 1103 | result = function->m_c_code( function, args ); | ||
| 1104 | } | ||
| 1105 | else if ( function->m_args_simple && 4 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 1106 | { | ||
| 1107 | #ifdef _MSC_VER | ||
| 1108 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 1109 | #else | ||
| 1110 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 1111 | #endif | ||
| 1112 | memcpy( python_pars, args, 4 * sizeof(PyObject *) ); | ||
| 1113 | memcpy( python_pars + 4, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 1114 | |||
| 1115 | for( Py_ssize_t i = 0; i < function->m_args_positional_count; i++ ) | ||
| 1116 | { | ||
| 1117 | Py_INCREF( python_pars[ i ] ); | ||
| 1118 | } | ||
| 1119 | |||
| 1120 | result = function->m_c_code( function, python_pars ); | ||
| 1121 | } | ||
| 1122 | else | ||
| 1123 | { | ||
| 1124 | #ifdef _MSC_VER | ||
| 1125 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 1126 | #else | ||
| 1127 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 1128 | #endif | ||
| 1129 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 1130 | |||
| 1131 | if ( parseArgumentsPos( function, python_pars, args, 4 )) | ||
| 1132 | { | ||
| 1133 | result = function->m_c_code( function, python_pars ); | ||
| 1134 | } | ||
| 1135 | else | ||
| 1136 | { | ||
| 1137 | result = NULL; | ||
| 1138 | } | ||
| 1139 | } | ||
| 1140 | |||
| 1141 | Py_LeaveRecursiveCall(); | ||
| 1142 | |||
| 1143 | return result; | ||
| 1144 | } | ||
| 1145 | else if ( Nuitka_Method_Check( called ) ) | ||
| 1146 | { | ||
| 1147 | struct Nuitka_MethodObject *method = (struct Nuitka_MethodObject *)called; | ||
| 1148 | |||
| 1149 | // Unbound method without arguments, let the error path be slow. | ||
| 1150 | if ( method->m_object != NULL ) | ||
| 1151 | { | ||
| 1152 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1153 | { | ||
| 1154 | return NULL; | ||
| 1155 | } | ||
| 1156 | |||
| 1157 | struct Nuitka_FunctionObject *function = method->m_function; | ||
| 1158 | |||
| 1159 | PyObject *result; | ||
| 1160 | |||
| 1161 | if ( function->m_args_simple && 4 + 1 == function->m_args_positional_count ) | ||
| 1162 | { | ||
| 1163 | #ifdef _MSC_VER | ||
| 1164 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 1165 | #else | ||
| 1166 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 1167 | #endif | ||
| 1168 | python_pars[ 0 ] = method->m_object; | ||
| 1169 | Py_INCREF( method->m_object ); | ||
| 1170 | |||
| 1171 | for( Py_ssize_t i = 0; i < 4; i++ ) | ||
| 1172 | { | ||
| 1173 | python_pars[ i + 1 ] = args[ i ]; | ||
| 1174 | Py_INCREF( args[ i ] ); | ||
| 1175 | } | ||
| 1176 | |||
| 1177 | result = function->m_c_code( function, python_pars ); | ||
| 1178 | } | ||
| 1179 | else if ( function->m_args_simple && 4 + 1 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 1180 | { | ||
| 1181 | #ifdef _MSC_VER | ||
| 1182 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 1183 | #else | ||
| 1184 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 1185 | #endif | ||
| 1186 | python_pars[ 0 ] = method->m_object; | ||
| 1187 | Py_INCREF( method->m_object ); | ||
| 1188 | |||
| 1189 | memcpy( python_pars+1, args, 4 * sizeof(PyObject *) ); | ||
| 1190 | memcpy( python_pars+1 + 4, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 1191 | |||
| 1192 | for( Py_ssize_t i = 1; i < function->m_args_overall_count; i++ ) | ||
| 1193 | { | ||
| 1194 | Py_INCREF( python_pars[ i ] ); | ||
| 1195 | } | ||
| 1196 | |||
| 1197 | result = function->m_c_code( function, python_pars ); | ||
| 1198 | } | ||
| 1199 | else | ||
| 1200 | { | ||
| 1201 | #ifdef _MSC_VER | ||
| 1202 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 1203 | #else | ||
| 1204 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 1205 | #endif | ||
| 1206 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 1207 | |||
| 1208 | if ( parseArgumentsMethodPos( function, python_pars, method->m_object, args, 4 ) ) | ||
| 1209 | { | ||
| 1210 | result = function->m_c_code( function, python_pars ); | ||
| 1211 | } | ||
| 1212 | else | ||
| 1213 | { | ||
| 1214 | result = NULL; | ||
| 1215 | } | ||
| 1216 | } | ||
| 1217 | |||
| 1218 | Py_LeaveRecursiveCall(); | ||
| 1219 | |||
| 1220 | return result; | ||
| 1221 | } | ||
| 1222 | } | ||
| 1223 | else if ( PyCFunction_Check( called ) ) | ||
| 1224 | { | ||
| 1225 | // Try to be fast about wrapping the arguments. | ||
| 1226 | int flags = PyCFunction_GET_FLAGS( called ) & ~(METH_CLASS | METH_STATIC | METH_COEXIST); | ||
| 1227 | |||
| 1228 | if ( flags & METH_NOARGS ) | ||
| 1229 | { | ||
| 1230 | #if 4 == 0 | ||
| 1231 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 1232 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 1233 | |||
| 1234 | // Recursion guard is not strictly necessary, as we already have | ||
| 1235 | // one on our way to here. | ||
| 1236 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1237 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1238 | { | ||
| 1239 | return NULL; | ||
| 1240 | } | ||
| 1241 | #endif | ||
| 1242 | |||
| 1243 | PyObject *result = (*method)( self, NULL ); | ||
| 1244 | |||
| 1245 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1246 | Py_LeaveRecursiveCall(); | ||
| 1247 | #endif | ||
| 1248 | |||
| 1249 | if ( result != NULL ) | ||
| 1250 | { | ||
| 1251 | // Some buggy C functions do set an error, but do not indicate it | ||
| 1252 | // and Nuitka inner workings can get upset/confused from it. | ||
| 1253 | DROP_ERROR_OCCURRED(); | ||
| 1254 | |||
| 1255 | return result; | ||
| 1256 | } | ||
| 1257 | else | ||
| 1258 | { | ||
| 1259 | // Other buggy C functions do this, return NULL, but with | ||
| 1260 | // no error set, not allowed. | ||
| 1261 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 1262 | { | ||
| 1263 | PyErr_Format( | ||
| 1264 | PyExc_SystemError, | ||
| 1265 | "NULL result without error in PyObject_Call" | ||
| 1266 | ); | ||
| 1267 | } | ||
| 1268 | |||
| 1269 | return NULL; | ||
| 1270 | } | ||
| 1271 | #else | ||
| 1272 | PyErr_Format( | ||
| 1273 | PyExc_TypeError, | ||
| 1274 | "%s() takes no arguments (4 given)", | ||
| 1275 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 1276 | ); | ||
| 1277 | return NULL; | ||
| 1278 | #endif | ||
| 1279 | } | ||
| 1280 | else if ( flags & METH_O ) | ||
| 1281 | { | ||
| 1282 | #if 4 == 1 | ||
| 1283 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 1284 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 1285 | |||
| 1286 | // Recursion guard is not strictly necessary, as we already have | ||
| 1287 | // one on our way to here. | ||
| 1288 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1289 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1290 | { | ||
| 1291 | return NULL; | ||
| 1292 | } | ||
| 1293 | #endif | ||
| 1294 | |||
| 1295 | PyObject *result = (*method)( self, args[0] ); | ||
| 1296 | |||
| 1297 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1298 | Py_LeaveRecursiveCall(); | ||
| 1299 | #endif | ||
| 1300 | |||
| 1301 | if ( result != NULL ) | ||
| 1302 | { | ||
| 1303 | // Some buggy C functions do set an error, but do not indicate it | ||
| 1304 | // and Nuitka inner workings can get upset/confused from it. | ||
| 1305 | DROP_ERROR_OCCURRED(); | ||
| 1306 | |||
| 1307 | return result; | ||
| 1308 | } | ||
| 1309 | else | ||
| 1310 | { | ||
| 1311 | // Other buggy C functions do this, return NULL, but with | ||
| 1312 | // no error set, not allowed. | ||
| 1313 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 1314 | { | ||
| 1315 | PyErr_Format( | ||
| 1316 | PyExc_SystemError, | ||
| 1317 | "NULL result without error in PyObject_Call" | ||
| 1318 | ); | ||
| 1319 | } | ||
| 1320 | |||
| 1321 | return NULL; | ||
| 1322 | } | ||
| 1323 | #else | ||
| 1324 | PyErr_Format(PyExc_TypeError, | ||
| 1325 | "%s() takes exactly one argument (4 given)", | ||
| 1326 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 1327 | ); | ||
| 1328 | return NULL; | ||
| 1329 | #endif | ||
| 1330 | } | ||
| 1331 | else if ( flags & METH_VARARGS ) | ||
| 1332 | { | ||
| 1333 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 1334 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 1335 | |||
| 1336 | PyObject *pos_args = MAKE_TUPLE( args, 4 ); | ||
| 1337 | |||
| 1338 | PyObject *result; | ||
| 1339 | |||
| 1340 | // Recursion guard is not strictly necessary, as we already have | ||
| 1341 | // one on our way to here. | ||
| 1342 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1343 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1344 | { | ||
| 1345 | return NULL; | ||
| 1346 | } | ||
| 1347 | #endif | ||
| 1348 | |||
| 1349 | #if PYTHON_VERSION < 360 | ||
| 1350 | if ( flags & METH_KEYWORDS ) | ||
| 1351 | { | ||
| 1352 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 1353 | } | ||
| 1354 | else | ||
| 1355 | { | ||
| 1356 | result = (*method)( self, pos_args ); | ||
| 1357 | } | ||
| 1358 | #else | ||
| 1359 | if ( flags == ( METH_VARARGS | METH_KEYWORDS ) ) | ||
| 1360 | { | ||
| 1361 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 1362 | } | ||
| 1363 | else if ( flags == METH_FASTCALL ) | ||
| 1364 | { | ||
| 1365 | #if PYTHON_VERSION < 370 | ||
| 1366 | result = (*(_PyCFunctionFast)method)( self, &PyTuple_GET_ITEM( pos_args, 0 ), 4, NULL );; | ||
| 1367 | #else | ||
| 1368 | result = (*(_PyCFunctionFast)method)( self, &pos_args, 4 );; | ||
| 1369 | #endif | ||
| 1370 | } | ||
| 1371 | else | ||
| 1372 | { | ||
| 1373 | result = (*method)( self, pos_args ); | ||
| 1374 | } | ||
| 1375 | #endif | ||
| 1376 | |||
| 1377 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1378 | Py_LeaveRecursiveCall(); | ||
| 1379 | #endif | ||
| 1380 | |||
| 1381 | if ( result != NULL ) | ||
| 1382 | { | ||
| 1383 | // Some buggy C functions do set an error, but do not indicate it | ||
| 1384 | // and Nuitka inner workings can get upset/confused from it. | ||
| 1385 | DROP_ERROR_OCCURRED(); | ||
| 1386 | |||
| 1387 | Py_DECREF( pos_args ); | ||
| 1388 | return result; | ||
| 1389 | } | ||
| 1390 | else | ||
| 1391 | { | ||
| 1392 | // Other buggy C functions do this, return NULL, but with | ||
| 1393 | // no error set, not allowed. | ||
| 1394 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 1395 | { | ||
| 1396 | PyErr_Format( | ||
| 1397 | PyExc_SystemError, | ||
| 1398 | "NULL result without error in PyObject_Call" | ||
| 1399 | ); | ||
| 1400 | } | ||
| 1401 | |||
| 1402 | Py_DECREF( pos_args ); | ||
| 1403 | return NULL; | ||
| 1404 | } | ||
| 1405 | } | ||
| 1406 | } | ||
| 1407 | else if ( PyFunction_Check( called ) ) | ||
| 1408 | { | ||
| 1409 | return callPythonFunction( | ||
| 1410 | called, | ||
| 1411 | args, | ||
| 1412 | 4 | ||
| 1413 | ); | ||
| 1414 | } | ||
| 1415 | |||
| 1416 | PyObject *pos_args = MAKE_TUPLE( args, 4 ); | ||
| 1417 | |||
| 1418 | PyObject *result = CALL_FUNCTION( | ||
| 1419 | called, | ||
| 1420 | pos_args, | ||
| 1421 | NULL | ||
| 1422 | ); | ||
| 1423 | |||
| 1424 | Py_DECREF( pos_args ); | ||
| 1425 | |||
| 1426 | return result; | ||
| 1427 | } | ||
| 1428 | |||
| 1429 | PyObject *CALL_FUNCTION_WITH_ARGS5( PyObject *called, PyObject **args ) | ||
| 1430 | { | ||
| 1431 | CHECK_OBJECT( called ); | ||
| 1432 | |||
| 1433 | // Check if arguments are valid objects in debug mode. | ||
| 1434 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1435 | for( size_t i = 0; i < 5; i++ ) | ||
| 1436 | { | ||
| 1437 | CHECK_OBJECT( args[ i ] ); | ||
| 1438 | } | ||
| 1439 | #endif | ||
| 1440 | |||
| 1441 | if ( Nuitka_Function_Check( called ) ) | ||
| 1442 | { | ||
| 1443 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1444 | { | ||
| 1445 | return NULL; | ||
| 1446 | } | ||
| 1447 | |||
| 1448 | struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)called; | ||
| 1449 | PyObject *result; | ||
| 1450 | |||
| 1451 | if ( function->m_args_simple && 5 == function->m_args_positional_count ) | ||
| 1452 | { | ||
| 1453 | for( Py_ssize_t i = 0; i < 5; i++ ) | ||
| 1454 | { | ||
| 1455 | Py_INCREF( args[ i ] ); | ||
| 1456 | } | ||
| 1457 | |||
| 1458 | result = function->m_c_code( function, args ); | ||
| 1459 | } | ||
| 1460 | else if ( function->m_args_simple && 5 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 1461 | { | ||
| 1462 | #ifdef _MSC_VER | ||
| 1463 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 1464 | #else | ||
| 1465 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 1466 | #endif | ||
| 1467 | memcpy( python_pars, args, 5 * sizeof(PyObject *) ); | ||
| 1468 | memcpy( python_pars + 5, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 1469 | |||
| 1470 | for( Py_ssize_t i = 0; i < function->m_args_positional_count; i++ ) | ||
| 1471 | { | ||
| 1472 | Py_INCREF( python_pars[ i ] ); | ||
| 1473 | } | ||
| 1474 | |||
| 1475 | result = function->m_c_code( function, python_pars ); | ||
| 1476 | } | ||
| 1477 | else | ||
| 1478 | { | ||
| 1479 | #ifdef _MSC_VER | ||
| 1480 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 1481 | #else | ||
| 1482 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 1483 | #endif | ||
| 1484 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 1485 | |||
| 1486 | if ( parseArgumentsPos( function, python_pars, args, 5 )) | ||
| 1487 | { | ||
| 1488 | result = function->m_c_code( function, python_pars ); | ||
| 1489 | } | ||
| 1490 | else | ||
| 1491 | { | ||
| 1492 | result = NULL; | ||
| 1493 | } | ||
| 1494 | } | ||
| 1495 | |||
| 1496 | Py_LeaveRecursiveCall(); | ||
| 1497 | |||
| 1498 | return result; | ||
| 1499 | } | ||
| 1500 | else if ( Nuitka_Method_Check( called ) ) | ||
| 1501 | { | ||
| 1502 | struct Nuitka_MethodObject *method = (struct Nuitka_MethodObject *)called; | ||
| 1503 | |||
| 1504 | // Unbound method without arguments, let the error path be slow. | ||
| 1505 | if ( method->m_object != NULL ) | ||
| 1506 | { | ||
| 1507 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1508 | { | ||
| 1509 | return NULL; | ||
| 1510 | } | ||
| 1511 | |||
| 1512 | struct Nuitka_FunctionObject *function = method->m_function; | ||
| 1513 | |||
| 1514 | PyObject *result; | ||
| 1515 | |||
| 1516 | if ( function->m_args_simple && 5 + 1 == function->m_args_positional_count ) | ||
| 1517 | { | ||
| 1518 | #ifdef _MSC_VER | ||
| 1519 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 1520 | #else | ||
| 1521 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 1522 | #endif | ||
| 1523 | python_pars[ 0 ] = method->m_object; | ||
| 1524 | Py_INCREF( method->m_object ); | ||
| 1525 | |||
| 1526 | for( Py_ssize_t i = 0; i < 5; i++ ) | ||
| 1527 | { | ||
| 1528 | python_pars[ i + 1 ] = args[ i ]; | ||
| 1529 | Py_INCREF( args[ i ] ); | ||
| 1530 | } | ||
| 1531 | |||
| 1532 | result = function->m_c_code( function, python_pars ); | ||
| 1533 | } | ||
| 1534 | else if ( function->m_args_simple && 5 + 1 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 1535 | { | ||
| 1536 | #ifdef _MSC_VER | ||
| 1537 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 1538 | #else | ||
| 1539 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 1540 | #endif | ||
| 1541 | python_pars[ 0 ] = method->m_object; | ||
| 1542 | Py_INCREF( method->m_object ); | ||
| 1543 | |||
| 1544 | memcpy( python_pars+1, args, 5 * sizeof(PyObject *) ); | ||
| 1545 | memcpy( python_pars+1 + 5, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 1546 | |||
| 1547 | for( Py_ssize_t i = 1; i < function->m_args_overall_count; i++ ) | ||
| 1548 | { | ||
| 1549 | Py_INCREF( python_pars[ i ] ); | ||
| 1550 | } | ||
| 1551 | |||
| 1552 | result = function->m_c_code( function, python_pars ); | ||
| 1553 | } | ||
| 1554 | else | ||
| 1555 | { | ||
| 1556 | #ifdef _MSC_VER | ||
| 1557 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 1558 | #else | ||
| 1559 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 1560 | #endif | ||
| 1561 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 1562 | |||
| 1563 | if ( parseArgumentsMethodPos( function, python_pars, method->m_object, args, 5 ) ) | ||
| 1564 | { | ||
| 1565 | result = function->m_c_code( function, python_pars ); | ||
| 1566 | } | ||
| 1567 | else | ||
| 1568 | { | ||
| 1569 | result = NULL; | ||
| 1570 | } | ||
| 1571 | } | ||
| 1572 | |||
| 1573 | Py_LeaveRecursiveCall(); | ||
| 1574 | |||
| 1575 | return result; | ||
| 1576 | } | ||
| 1577 | } | ||
| 1578 | else if ( PyCFunction_Check( called ) ) | ||
| 1579 | { | ||
| 1580 | // Try to be fast about wrapping the arguments. | ||
| 1581 | int flags = PyCFunction_GET_FLAGS( called ) & ~(METH_CLASS | METH_STATIC | METH_COEXIST); | ||
| 1582 | |||
| 1583 | if ( flags & METH_NOARGS ) | ||
| 1584 | { | ||
| 1585 | #if 5 == 0 | ||
| 1586 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 1587 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 1588 | |||
| 1589 | // Recursion guard is not strictly necessary, as we already have | ||
| 1590 | // one on our way to here. | ||
| 1591 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1592 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1593 | { | ||
| 1594 | return NULL; | ||
| 1595 | } | ||
| 1596 | #endif | ||
| 1597 | |||
| 1598 | PyObject *result = (*method)( self, NULL ); | ||
| 1599 | |||
| 1600 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1601 | Py_LeaveRecursiveCall(); | ||
| 1602 | #endif | ||
| 1603 | |||
| 1604 | if ( result != NULL ) | ||
| 1605 | { | ||
| 1606 | // Some buggy C functions do set an error, but do not indicate it | ||
| 1607 | // and Nuitka inner workings can get upset/confused from it. | ||
| 1608 | DROP_ERROR_OCCURRED(); | ||
| 1609 | |||
| 1610 | return result; | ||
| 1611 | } | ||
| 1612 | else | ||
| 1613 | { | ||
| 1614 | // Other buggy C functions do this, return NULL, but with | ||
| 1615 | // no error set, not allowed. | ||
| 1616 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 1617 | { | ||
| 1618 | PyErr_Format( | ||
| 1619 | PyExc_SystemError, | ||
| 1620 | "NULL result without error in PyObject_Call" | ||
| 1621 | ); | ||
| 1622 | } | ||
| 1623 | |||
| 1624 | return NULL; | ||
| 1625 | } | ||
| 1626 | #else | ||
| 1627 | PyErr_Format( | ||
| 1628 | PyExc_TypeError, | ||
| 1629 | "%s() takes no arguments (5 given)", | ||
| 1630 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 1631 | ); | ||
| 1632 | return NULL; | ||
| 1633 | #endif | ||
| 1634 | } | ||
| 1635 | else if ( flags & METH_O ) | ||
| 1636 | { | ||
| 1637 | #if 5 == 1 | ||
| 1638 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 1639 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 1640 | |||
| 1641 | // Recursion guard is not strictly necessary, as we already have | ||
| 1642 | // one on our way to here. | ||
| 1643 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1644 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1645 | { | ||
| 1646 | return NULL; | ||
| 1647 | } | ||
| 1648 | #endif | ||
| 1649 | |||
| 1650 | PyObject *result = (*method)( self, args[0] ); | ||
| 1651 | |||
| 1652 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1653 | Py_LeaveRecursiveCall(); | ||
| 1654 | #endif | ||
| 1655 | |||
| 1656 | if ( result != NULL ) | ||
| 1657 | { | ||
| 1658 | // Some buggy C functions do set an error, but do not indicate it | ||
| 1659 | // and Nuitka inner workings can get upset/confused from it. | ||
| 1660 | DROP_ERROR_OCCURRED(); | ||
| 1661 | |||
| 1662 | return result; | ||
| 1663 | } | ||
| 1664 | else | ||
| 1665 | { | ||
| 1666 | // Other buggy C functions do this, return NULL, but with | ||
| 1667 | // no error set, not allowed. | ||
| 1668 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 1669 | { | ||
| 1670 | PyErr_Format( | ||
| 1671 | PyExc_SystemError, | ||
| 1672 | "NULL result without error in PyObject_Call" | ||
| 1673 | ); | ||
| 1674 | } | ||
| 1675 | |||
| 1676 | return NULL; | ||
| 1677 | } | ||
| 1678 | #else | ||
| 1679 | PyErr_Format(PyExc_TypeError, | ||
| 1680 | "%s() takes exactly one argument (5 given)", | ||
| 1681 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 1682 | ); | ||
| 1683 | return NULL; | ||
| 1684 | #endif | ||
| 1685 | } | ||
| 1686 | else if ( flags & METH_VARARGS ) | ||
| 1687 | { | ||
| 1688 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 1689 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 1690 | |||
| 1691 | PyObject *pos_args = MAKE_TUPLE( args, 5 ); | ||
| 1692 | |||
| 1693 | PyObject *result; | ||
| 1694 | |||
| 1695 | // Recursion guard is not strictly necessary, as we already have | ||
| 1696 | // one on our way to here. | ||
| 1697 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1698 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1699 | { | ||
| 1700 | return NULL; | ||
| 1701 | } | ||
| 1702 | #endif | ||
| 1703 | |||
| 1704 | #if PYTHON_VERSION < 360 | ||
| 1705 | if ( flags & METH_KEYWORDS ) | ||
| 1706 | { | ||
| 1707 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 1708 | } | ||
| 1709 | else | ||
| 1710 | { | ||
| 1711 | result = (*method)( self, pos_args ); | ||
| 1712 | } | ||
| 1713 | #else | ||
| 1714 | if ( flags == ( METH_VARARGS | METH_KEYWORDS ) ) | ||
| 1715 | { | ||
| 1716 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 1717 | } | ||
| 1718 | else if ( flags == METH_FASTCALL ) | ||
| 1719 | { | ||
| 1720 | #if PYTHON_VERSION < 370 | ||
| 1721 | result = (*(_PyCFunctionFast)method)( self, &PyTuple_GET_ITEM( pos_args, 0 ), 5, NULL );; | ||
| 1722 | #else | ||
| 1723 | result = (*(_PyCFunctionFast)method)( self, &pos_args, 5 );; | ||
| 1724 | #endif | ||
| 1725 | } | ||
| 1726 | else | ||
| 1727 | { | ||
| 1728 | result = (*method)( self, pos_args ); | ||
| 1729 | } | ||
| 1730 | #endif | ||
| 1731 | |||
| 1732 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1733 | Py_LeaveRecursiveCall(); | ||
| 1734 | #endif | ||
| 1735 | |||
| 1736 | if ( result != NULL ) | ||
| 1737 | { | ||
| 1738 | // Some buggy C functions do set an error, but do not indicate it | ||
| 1739 | // and Nuitka inner workings can get upset/confused from it. | ||
| 1740 | DROP_ERROR_OCCURRED(); | ||
| 1741 | |||
| 1742 | Py_DECREF( pos_args ); | ||
| 1743 | return result; | ||
| 1744 | } | ||
| 1745 | else | ||
| 1746 | { | ||
| 1747 | // Other buggy C functions do this, return NULL, but with | ||
| 1748 | // no error set, not allowed. | ||
| 1749 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 1750 | { | ||
| 1751 | PyErr_Format( | ||
| 1752 | PyExc_SystemError, | ||
| 1753 | "NULL result without error in PyObject_Call" | ||
| 1754 | ); | ||
| 1755 | } | ||
| 1756 | |||
| 1757 | Py_DECREF( pos_args ); | ||
| 1758 | return NULL; | ||
| 1759 | } | ||
| 1760 | } | ||
| 1761 | } | ||
| 1762 | else if ( PyFunction_Check( called ) ) | ||
| 1763 | { | ||
| 1764 | return callPythonFunction( | ||
| 1765 | called, | ||
| 1766 | args, | ||
| 1767 | 5 | ||
| 1768 | ); | ||
| 1769 | } | ||
| 1770 | |||
| 1771 | PyObject *pos_args = MAKE_TUPLE( args, 5 ); | ||
| 1772 | |||
| 1773 | PyObject *result = CALL_FUNCTION( | ||
| 1774 | called, | ||
| 1775 | pos_args, | ||
| 1776 | NULL | ||
| 1777 | ); | ||
| 1778 | |||
| 1779 | Py_DECREF( pos_args ); | ||
| 1780 | |||
| 1781 | return result; | ||
| 1782 | } | ||
| 1783 | |||
| 1784 | PyObject *CALL_FUNCTION_WITH_ARGS6( PyObject *called, PyObject **args ) | ||
| 1785 | { | ||
| 1786 | CHECK_OBJECT( called ); | ||
| 1787 | |||
| 1788 | // Check if arguments are valid objects in debug mode. | ||
| 1789 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1790 | for( size_t i = 0; i < 6; i++ ) | ||
| 1791 | { | ||
| 1792 | CHECK_OBJECT( args[ i ] ); | ||
| 1793 | } | ||
| 1794 | #endif | ||
| 1795 | |||
| 1796 | if ( Nuitka_Function_Check( called ) ) | ||
| 1797 | { | ||
| 1798 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1799 | { | ||
| 1800 | return NULL; | ||
| 1801 | } | ||
| 1802 | |||
| 1803 | struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)called; | ||
| 1804 | PyObject *result; | ||
| 1805 | |||
| 1806 | if ( function->m_args_simple && 6 == function->m_args_positional_count ) | ||
| 1807 | { | ||
| 1808 | for( Py_ssize_t i = 0; i < 6; i++ ) | ||
| 1809 | { | ||
| 1810 | Py_INCREF( args[ i ] ); | ||
| 1811 | } | ||
| 1812 | |||
| 1813 | result = function->m_c_code( function, args ); | ||
| 1814 | } | ||
| 1815 | else if ( function->m_args_simple && 6 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 1816 | { | ||
| 1817 | #ifdef _MSC_VER | ||
| 1818 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 1819 | #else | ||
| 1820 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 1821 | #endif | ||
| 1822 | memcpy( python_pars, args, 6 * sizeof(PyObject *) ); | ||
| 1823 | memcpy( python_pars + 6, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 1824 | |||
| 1825 | for( Py_ssize_t i = 0; i < function->m_args_positional_count; i++ ) | ||
| 1826 | { | ||
| 1827 | Py_INCREF( python_pars[ i ] ); | ||
| 1828 | } | ||
| 1829 | |||
| 1830 | result = function->m_c_code( function, python_pars ); | ||
| 1831 | } | ||
| 1832 | else | ||
| 1833 | { | ||
| 1834 | #ifdef _MSC_VER | ||
| 1835 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 1836 | #else | ||
| 1837 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 1838 | #endif | ||
| 1839 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 1840 | |||
| 1841 | if ( parseArgumentsPos( function, python_pars, args, 6 )) | ||
| 1842 | { | ||
| 1843 | result = function->m_c_code( function, python_pars ); | ||
| 1844 | } | ||
| 1845 | else | ||
| 1846 | { | ||
| 1847 | result = NULL; | ||
| 1848 | } | ||
| 1849 | } | ||
| 1850 | |||
| 1851 | Py_LeaveRecursiveCall(); | ||
| 1852 | |||
| 1853 | return result; | ||
| 1854 | } | ||
| 1855 | else if ( Nuitka_Method_Check( called ) ) | ||
| 1856 | { | ||
| 1857 | struct Nuitka_MethodObject *method = (struct Nuitka_MethodObject *)called; | ||
| 1858 | |||
| 1859 | // Unbound method without arguments, let the error path be slow. | ||
| 1860 | if ( method->m_object != NULL ) | ||
| 1861 | { | ||
| 1862 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1863 | { | ||
| 1864 | return NULL; | ||
| 1865 | } | ||
| 1866 | |||
| 1867 | struct Nuitka_FunctionObject *function = method->m_function; | ||
| 1868 | |||
| 1869 | PyObject *result; | ||
| 1870 | |||
| 1871 | if ( function->m_args_simple && 6 + 1 == function->m_args_positional_count ) | ||
| 1872 | { | ||
| 1873 | #ifdef _MSC_VER | ||
| 1874 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 1875 | #else | ||
| 1876 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 1877 | #endif | ||
| 1878 | python_pars[ 0 ] = method->m_object; | ||
| 1879 | Py_INCREF( method->m_object ); | ||
| 1880 | |||
| 1881 | for( Py_ssize_t i = 0; i < 6; i++ ) | ||
| 1882 | { | ||
| 1883 | python_pars[ i + 1 ] = args[ i ]; | ||
| 1884 | Py_INCREF( args[ i ] ); | ||
| 1885 | } | ||
| 1886 | |||
| 1887 | result = function->m_c_code( function, python_pars ); | ||
| 1888 | } | ||
| 1889 | else if ( function->m_args_simple && 6 + 1 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 1890 | { | ||
| 1891 | #ifdef _MSC_VER | ||
| 1892 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 1893 | #else | ||
| 1894 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 1895 | #endif | ||
| 1896 | python_pars[ 0 ] = method->m_object; | ||
| 1897 | Py_INCREF( method->m_object ); | ||
| 1898 | |||
| 1899 | memcpy( python_pars+1, args, 6 * sizeof(PyObject *) ); | ||
| 1900 | memcpy( python_pars+1 + 6, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 1901 | |||
| 1902 | for( Py_ssize_t i = 1; i < function->m_args_overall_count; i++ ) | ||
| 1903 | { | ||
| 1904 | Py_INCREF( python_pars[ i ] ); | ||
| 1905 | } | ||
| 1906 | |||
| 1907 | result = function->m_c_code( function, python_pars ); | ||
| 1908 | } | ||
| 1909 | else | ||
| 1910 | { | ||
| 1911 | #ifdef _MSC_VER | ||
| 1912 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 1913 | #else | ||
| 1914 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 1915 | #endif | ||
| 1916 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 1917 | |||
| 1918 | if ( parseArgumentsMethodPos( function, python_pars, method->m_object, args, 6 ) ) | ||
| 1919 | { | ||
| 1920 | result = function->m_c_code( function, python_pars ); | ||
| 1921 | } | ||
| 1922 | else | ||
| 1923 | { | ||
| 1924 | result = NULL; | ||
| 1925 | } | ||
| 1926 | } | ||
| 1927 | |||
| 1928 | Py_LeaveRecursiveCall(); | ||
| 1929 | |||
| 1930 | return result; | ||
| 1931 | } | ||
| 1932 | } | ||
| 1933 | else if ( PyCFunction_Check( called ) ) | ||
| 1934 | { | ||
| 1935 | // Try to be fast about wrapping the arguments. | ||
| 1936 | int flags = PyCFunction_GET_FLAGS( called ) & ~(METH_CLASS | METH_STATIC | METH_COEXIST); | ||
| 1937 | |||
| 1938 | if ( flags & METH_NOARGS ) | ||
| 1939 | { | ||
| 1940 | #if 6 == 0 | ||
| 1941 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 1942 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 1943 | |||
| 1944 | // Recursion guard is not strictly necessary, as we already have | ||
| 1945 | // one on our way to here. | ||
| 1946 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1947 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 1948 | { | ||
| 1949 | return NULL; | ||
| 1950 | } | ||
| 1951 | #endif | ||
| 1952 | |||
| 1953 | PyObject *result = (*method)( self, NULL ); | ||
| 1954 | |||
| 1955 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1956 | Py_LeaveRecursiveCall(); | ||
| 1957 | #endif | ||
| 1958 | |||
| 1959 | if ( result != NULL ) | ||
| 1960 | { | ||
| 1961 | // Some buggy C functions do set an error, but do not indicate it | ||
| 1962 | // and Nuitka inner workings can get upset/confused from it. | ||
| 1963 | DROP_ERROR_OCCURRED(); | ||
| 1964 | |||
| 1965 | return result; | ||
| 1966 | } | ||
| 1967 | else | ||
| 1968 | { | ||
| 1969 | // Other buggy C functions do this, return NULL, but with | ||
| 1970 | // no error set, not allowed. | ||
| 1971 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 1972 | { | ||
| 1973 | PyErr_Format( | ||
| 1974 | PyExc_SystemError, | ||
| 1975 | "NULL result without error in PyObject_Call" | ||
| 1976 | ); | ||
| 1977 | } | ||
| 1978 | |||
| 1979 | return NULL; | ||
| 1980 | } | ||
| 1981 | #else | ||
| 1982 | PyErr_Format( | ||
| 1983 | PyExc_TypeError, | ||
| 1984 | "%s() takes no arguments (6 given)", | ||
| 1985 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 1986 | ); | ||
| 1987 | return NULL; | ||
| 1988 | #endif | ||
| 1989 | } | ||
| 1990 | else if ( flags & METH_O ) | ||
| 1991 | { | ||
| 1992 | #if 6 == 1 | ||
| 1993 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 1994 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 1995 | |||
| 1996 | // Recursion guard is not strictly necessary, as we already have | ||
| 1997 | // one on our way to here. | ||
| 1998 | #ifdef _NUITKA_FULL_COMPAT | ||
| 1999 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 2000 | { | ||
| 2001 | return NULL; | ||
| 2002 | } | ||
| 2003 | #endif | ||
| 2004 | |||
| 2005 | PyObject *result = (*method)( self, args[0] ); | ||
| 2006 | |||
| 2007 | #ifdef _NUITKA_FULL_COMPAT | ||
| 2008 | Py_LeaveRecursiveCall(); | ||
| 2009 | #endif | ||
| 2010 | |||
| 2011 | if ( result != NULL ) | ||
| 2012 | { | ||
| 2013 | // Some buggy C functions do set an error, but do not indicate it | ||
| 2014 | // and Nuitka inner workings can get upset/confused from it. | ||
| 2015 | DROP_ERROR_OCCURRED(); | ||
| 2016 | |||
| 2017 | return result; | ||
| 2018 | } | ||
| 2019 | else | ||
| 2020 | { | ||
| 2021 | // Other buggy C functions do this, return NULL, but with | ||
| 2022 | // no error set, not allowed. | ||
| 2023 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 2024 | { | ||
| 2025 | PyErr_Format( | ||
| 2026 | PyExc_SystemError, | ||
| 2027 | "NULL result without error in PyObject_Call" | ||
| 2028 | ); | ||
| 2029 | } | ||
| 2030 | |||
| 2031 | return NULL; | ||
| 2032 | } | ||
| 2033 | #else | ||
| 2034 | PyErr_Format(PyExc_TypeError, | ||
| 2035 | "%s() takes exactly one argument (6 given)", | ||
| 2036 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 2037 | ); | ||
| 2038 | return NULL; | ||
| 2039 | #endif | ||
| 2040 | } | ||
| 2041 | else if ( flags & METH_VARARGS ) | ||
| 2042 | { | ||
| 2043 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 2044 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 2045 | |||
| 2046 | PyObject *pos_args = MAKE_TUPLE( args, 6 ); | ||
| 2047 | |||
| 2048 | PyObject *result; | ||
| 2049 | |||
| 2050 | // Recursion guard is not strictly necessary, as we already have | ||
| 2051 | // one on our way to here. | ||
| 2052 | #ifdef _NUITKA_FULL_COMPAT | ||
| 2053 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 2054 | { | ||
| 2055 | return NULL; | ||
| 2056 | } | ||
| 2057 | #endif | ||
| 2058 | |||
| 2059 | #if PYTHON_VERSION < 360 | ||
| 2060 | if ( flags & METH_KEYWORDS ) | ||
| 2061 | { | ||
| 2062 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 2063 | } | ||
| 2064 | else | ||
| 2065 | { | ||
| 2066 | result = (*method)( self, pos_args ); | ||
| 2067 | } | ||
| 2068 | #else | ||
| 2069 | if ( flags == ( METH_VARARGS | METH_KEYWORDS ) ) | ||
| 2070 | { | ||
| 2071 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 2072 | } | ||
| 2073 | else if ( flags == METH_FASTCALL ) | ||
| 2074 | { | ||
| 2075 | #if PYTHON_VERSION < 370 | ||
| 2076 | result = (*(_PyCFunctionFast)method)( self, &PyTuple_GET_ITEM( pos_args, 0 ), 6, NULL );; | ||
| 2077 | #else | ||
| 2078 | result = (*(_PyCFunctionFast)method)( self, &pos_args, 6 );; | ||
| 2079 | #endif | ||
| 2080 | } | ||
| 2081 | else | ||
| 2082 | { | ||
| 2083 | result = (*method)( self, pos_args ); | ||
| 2084 | } | ||
| 2085 | #endif | ||
| 2086 | |||
| 2087 | #ifdef _NUITKA_FULL_COMPAT | ||
| 2088 | Py_LeaveRecursiveCall(); | ||
| 2089 | #endif | ||
| 2090 | |||
| 2091 | if ( result != NULL ) | ||
| 2092 | { | ||
| 2093 | // Some buggy C functions do set an error, but do not indicate it | ||
| 2094 | // and Nuitka inner workings can get upset/confused from it. | ||
| 2095 | DROP_ERROR_OCCURRED(); | ||
| 2096 | |||
| 2097 | Py_DECREF( pos_args ); | ||
| 2098 | return result; | ||
| 2099 | } | ||
| 2100 | else | ||
| 2101 | { | ||
| 2102 | // Other buggy C functions do this, return NULL, but with | ||
| 2103 | // no error set, not allowed. | ||
| 2104 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 2105 | { | ||
| 2106 | PyErr_Format( | ||
| 2107 | PyExc_SystemError, | ||
| 2108 | "NULL result without error in PyObject_Call" | ||
| 2109 | ); | ||
| 2110 | } | ||
| 2111 | |||
| 2112 | Py_DECREF( pos_args ); | ||
| 2113 | return NULL; | ||
| 2114 | } | ||
| 2115 | } | ||
| 2116 | } | ||
| 2117 | else if ( PyFunction_Check( called ) ) | ||
| 2118 | { | ||
| 2119 | return callPythonFunction( | ||
| 2120 | called, | ||
| 2121 | args, | ||
| 2122 | 6 | ||
| 2123 | ); | ||
| 2124 | } | ||
| 2125 | |||
| 2126 | PyObject *pos_args = MAKE_TUPLE( args, 6 ); | ||
| 2127 | |||
| 2128 | PyObject *result = CALL_FUNCTION( | ||
| 2129 | called, | ||
| 2130 | pos_args, | ||
| 2131 | NULL | ||
| 2132 | ); | ||
| 2133 | |||
| 2134 | Py_DECREF( pos_args ); | ||
| 2135 | |||
| 2136 | return result; | ||
| 2137 | } | ||
| 2138 | |||
| 2139 | PyObject *CALL_FUNCTION_WITH_ARGS8( PyObject *called, PyObject **args ) | ||
| 2140 | { | ||
| 2141 | CHECK_OBJECT( called ); | ||
| 2142 | |||
| 2143 | // Check if arguments are valid objects in debug mode. | ||
| 2144 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 2145 | for( size_t i = 0; i < 8; i++ ) | ||
| 2146 | { | ||
| 2147 | CHECK_OBJECT( args[ i ] ); | ||
| 2148 | } | ||
| 2149 | #endif | ||
| 2150 | |||
| 2151 | if ( Nuitka_Function_Check( called ) ) | ||
| 2152 | { | ||
| 2153 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 2154 | { | ||
| 2155 | return NULL; | ||
| 2156 | } | ||
| 2157 | |||
| 2158 | struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)called; | ||
| 2159 | PyObject *result; | ||
| 2160 | |||
| 2161 | if ( function->m_args_simple && 8 == function->m_args_positional_count ) | ||
| 2162 | { | ||
| 2163 | for( Py_ssize_t i = 0; i < 8; i++ ) | ||
| 2164 | { | ||
| 2165 | Py_INCREF( args[ i ] ); | ||
| 2166 | } | ||
| 2167 | |||
| 2168 | result = function->m_c_code( function, args ); | ||
| 2169 | } | ||
| 2170 | else if ( function->m_args_simple && 8 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 2171 | { | ||
| 2172 | #ifdef _MSC_VER | ||
| 2173 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 2174 | #else | ||
| 2175 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 2176 | #endif | ||
| 2177 | memcpy( python_pars, args, 8 * sizeof(PyObject *) ); | ||
| 2178 | memcpy( python_pars + 8, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 2179 | |||
| 2180 | for( Py_ssize_t i = 0; i < function->m_args_positional_count; i++ ) | ||
| 2181 | { | ||
| 2182 | Py_INCREF( python_pars[ i ] ); | ||
| 2183 | } | ||
| 2184 | |||
| 2185 | result = function->m_c_code( function, python_pars ); | ||
| 2186 | } | ||
| 2187 | else | ||
| 2188 | { | ||
| 2189 | #ifdef _MSC_VER | ||
| 2190 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 2191 | #else | ||
| 2192 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 2193 | #endif | ||
| 2194 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 2195 | |||
| 2196 | if ( parseArgumentsPos( function, python_pars, args, 8 )) | ||
| 2197 | { | ||
| 2198 | result = function->m_c_code( function, python_pars ); | ||
| 2199 | } | ||
| 2200 | else | ||
| 2201 | { | ||
| 2202 | result = NULL; | ||
| 2203 | } | ||
| 2204 | } | ||
| 2205 | |||
| 2206 | Py_LeaveRecursiveCall(); | ||
| 2207 | |||
| 2208 | return result; | ||
| 2209 | } | ||
| 2210 | else if ( Nuitka_Method_Check( called ) ) | ||
| 2211 | { | ||
| 2212 | struct Nuitka_MethodObject *method = (struct Nuitka_MethodObject *)called; | ||
| 2213 | |||
| 2214 | // Unbound method without arguments, let the error path be slow. | ||
| 2215 | if ( method->m_object != NULL ) | ||
| 2216 | { | ||
| 2217 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 2218 | { | ||
| 2219 | return NULL; | ||
| 2220 | } | ||
| 2221 | |||
| 2222 | struct Nuitka_FunctionObject *function = method->m_function; | ||
| 2223 | |||
| 2224 | PyObject *result; | ||
| 2225 | |||
| 2226 | if ( function->m_args_simple && 8 + 1 == function->m_args_positional_count ) | ||
| 2227 | { | ||
| 2228 | #ifdef _MSC_VER | ||
| 2229 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 2230 | #else | ||
| 2231 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 2232 | #endif | ||
| 2233 | python_pars[ 0 ] = method->m_object; | ||
| 2234 | Py_INCREF( method->m_object ); | ||
| 2235 | |||
| 2236 | for( Py_ssize_t i = 0; i < 8; i++ ) | ||
| 2237 | { | ||
| 2238 | python_pars[ i + 1 ] = args[ i ]; | ||
| 2239 | Py_INCREF( args[ i ] ); | ||
| 2240 | } | ||
| 2241 | |||
| 2242 | result = function->m_c_code( function, python_pars ); | ||
| 2243 | } | ||
| 2244 | else if ( function->m_args_simple && 8 + 1 + function->m_defaults_given == function->m_args_positional_count ) | ||
| 2245 | { | ||
| 2246 | #ifdef _MSC_VER | ||
| 2247 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_positional_count ); | ||
| 2248 | #else | ||
| 2249 | PyObject *python_pars[ function->m_args_positional_count ]; | ||
| 2250 | #endif | ||
| 2251 | python_pars[ 0 ] = method->m_object; | ||
| 2252 | Py_INCREF( method->m_object ); | ||
| 2253 | |||
| 2254 | memcpy( python_pars+1, args, 8 * sizeof(PyObject *) ); | ||
| 2255 | memcpy( python_pars+1 + 8, &PyTuple_GET_ITEM( function->m_defaults, 0 ), function->m_defaults_given * sizeof(PyObject *) ); | ||
| 2256 | |||
| 2257 | for( Py_ssize_t i = 1; i < function->m_args_overall_count; i++ ) | ||
| 2258 | { | ||
| 2259 | Py_INCREF( python_pars[ i ] ); | ||
| 2260 | } | ||
| 2261 | |||
| 2262 | result = function->m_c_code( function, python_pars ); | ||
| 2263 | } | ||
| 2264 | else | ||
| 2265 | { | ||
| 2266 | #ifdef _MSC_VER | ||
| 2267 | PyObject **python_pars = (PyObject **)_alloca( sizeof( PyObject * ) * function->m_args_overall_count ); | ||
| 2268 | #else | ||
| 2269 | PyObject *python_pars[ function->m_args_overall_count ]; | ||
| 2270 | #endif | ||
| 2271 | memset( python_pars, 0, function->m_args_overall_count * sizeof(PyObject *) ); | ||
| 2272 | |||
| 2273 | if ( parseArgumentsMethodPos( function, python_pars, method->m_object, args, 8 ) ) | ||
| 2274 | { | ||
| 2275 | result = function->m_c_code( function, python_pars ); | ||
| 2276 | } | ||
| 2277 | else | ||
| 2278 | { | ||
| 2279 | result = NULL; | ||
| 2280 | } | ||
| 2281 | } | ||
| 2282 | |||
| 2283 | Py_LeaveRecursiveCall(); | ||
| 2284 | |||
| 2285 | return result; | ||
| 2286 | } | ||
| 2287 | } | ||
| 2288 | else if ( PyCFunction_Check( called ) ) | ||
| 2289 | { | ||
| 2290 | // Try to be fast about wrapping the arguments. | ||
| 2291 | int flags = PyCFunction_GET_FLAGS( called ) & ~(METH_CLASS | METH_STATIC | METH_COEXIST); | ||
| 2292 | |||
| 2293 | if ( flags & METH_NOARGS ) | ||
| 2294 | { | ||
| 2295 | #if 8 == 0 | ||
| 2296 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 2297 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 2298 | |||
| 2299 | // Recursion guard is not strictly necessary, as we already have | ||
| 2300 | // one on our way to here. | ||
| 2301 | #ifdef _NUITKA_FULL_COMPAT | ||
| 2302 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 2303 | { | ||
| 2304 | return NULL; | ||
| 2305 | } | ||
| 2306 | #endif | ||
| 2307 | |||
| 2308 | PyObject *result = (*method)( self, NULL ); | ||
| 2309 | |||
| 2310 | #ifdef _NUITKA_FULL_COMPAT | ||
| 2311 | Py_LeaveRecursiveCall(); | ||
| 2312 | #endif | ||
| 2313 | |||
| 2314 | if ( result != NULL ) | ||
| 2315 | { | ||
| 2316 | // Some buggy C functions do set an error, but do not indicate it | ||
| 2317 | // and Nuitka inner workings can get upset/confused from it. | ||
| 2318 | DROP_ERROR_OCCURRED(); | ||
| 2319 | |||
| 2320 | return result; | ||
| 2321 | } | ||
| 2322 | else | ||
| 2323 | { | ||
| 2324 | // Other buggy C functions do this, return NULL, but with | ||
| 2325 | // no error set, not allowed. | ||
| 2326 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 2327 | { | ||
| 2328 | PyErr_Format( | ||
| 2329 | PyExc_SystemError, | ||
| 2330 | "NULL result without error in PyObject_Call" | ||
| 2331 | ); | ||
| 2332 | } | ||
| 2333 | |||
| 2334 | return NULL; | ||
| 2335 | } | ||
| 2336 | #else | ||
| 2337 | PyErr_Format( | ||
| 2338 | PyExc_TypeError, | ||
| 2339 | "%s() takes no arguments (8 given)", | ||
| 2340 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 2341 | ); | ||
| 2342 | return NULL; | ||
| 2343 | #endif | ||
| 2344 | } | ||
| 2345 | else if ( flags & METH_O ) | ||
| 2346 | { | ||
| 2347 | #if 8 == 1 | ||
| 2348 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 2349 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 2350 | |||
| 2351 | // Recursion guard is not strictly necessary, as we already have | ||
| 2352 | // one on our way to here. | ||
| 2353 | #ifdef _NUITKA_FULL_COMPAT | ||
| 2354 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 2355 | { | ||
| 2356 | return NULL; | ||
| 2357 | } | ||
| 2358 | #endif | ||
| 2359 | |||
| 2360 | PyObject *result = (*method)( self, args[0] ); | ||
| 2361 | |||
| 2362 | #ifdef _NUITKA_FULL_COMPAT | ||
| 2363 | Py_LeaveRecursiveCall(); | ||
| 2364 | #endif | ||
| 2365 | |||
| 2366 | if ( result != NULL ) | ||
| 2367 | { | ||
| 2368 | // Some buggy C functions do set an error, but do not indicate it | ||
| 2369 | // and Nuitka inner workings can get upset/confused from it. | ||
| 2370 | DROP_ERROR_OCCURRED(); | ||
| 2371 | |||
| 2372 | return result; | ||
| 2373 | } | ||
| 2374 | else | ||
| 2375 | { | ||
| 2376 | // Other buggy C functions do this, return NULL, but with | ||
| 2377 | // no error set, not allowed. | ||
| 2378 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 2379 | { | ||
| 2380 | PyErr_Format( | ||
| 2381 | PyExc_SystemError, | ||
| 2382 | "NULL result without error in PyObject_Call" | ||
| 2383 | ); | ||
| 2384 | } | ||
| 2385 | |||
| 2386 | return NULL; | ||
| 2387 | } | ||
| 2388 | #else | ||
| 2389 | PyErr_Format(PyExc_TypeError, | ||
| 2390 | "%s() takes exactly one argument (8 given)", | ||
| 2391 | ((PyCFunctionObject *)called)->m_ml->ml_name | ||
| 2392 | ); | ||
| 2393 | return NULL; | ||
| 2394 | #endif | ||
| 2395 | } | ||
| 2396 | else if ( flags & METH_VARARGS ) | ||
| 2397 | { | ||
| 2398 | PyCFunction method = PyCFunction_GET_FUNCTION( called ); | ||
| 2399 | PyObject *self = PyCFunction_GET_SELF( called ); | ||
| 2400 | |||
| 2401 | PyObject *pos_args = MAKE_TUPLE( args, 8 ); | ||
| 2402 | |||
| 2403 | PyObject *result; | ||
| 2404 | |||
| 2405 | // Recursion guard is not strictly necessary, as we already have | ||
| 2406 | // one on our way to here. | ||
| 2407 | #ifdef _NUITKA_FULL_COMPAT | ||
| 2408 | if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) )) | ||
| 2409 | { | ||
| 2410 | return NULL; | ||
| 2411 | } | ||
| 2412 | #endif | ||
| 2413 | |||
| 2414 | #if PYTHON_VERSION < 360 | ||
| 2415 | if ( flags & METH_KEYWORDS ) | ||
| 2416 | { | ||
| 2417 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 2418 | } | ||
| 2419 | else | ||
| 2420 | { | ||
| 2421 | result = (*method)( self, pos_args ); | ||
| 2422 | } | ||
| 2423 | #else | ||
| 2424 | if ( flags == ( METH_VARARGS | METH_KEYWORDS ) ) | ||
| 2425 | { | ||
| 2426 | result = (*(PyCFunctionWithKeywords)method)( self, pos_args, NULL ); | ||
| 2427 | } | ||
| 2428 | else if ( flags == METH_FASTCALL ) | ||
| 2429 | { | ||
| 2430 | #if PYTHON_VERSION < 370 | ||
| 2431 | result = (*(_PyCFunctionFast)method)( self, &PyTuple_GET_ITEM( pos_args, 0 ), 8, NULL );; | ||
| 2432 | #else | ||
| 2433 | result = (*(_PyCFunctionFast)method)( self, &pos_args, 8 );; | ||
| 2434 | #endif | ||
| 2435 | } | ||
| 2436 | else | ||
| 2437 | { | ||
| 2438 | result = (*method)( self, pos_args ); | ||
| 2439 | } | ||
| 2440 | #endif | ||
| 2441 | |||
| 2442 | #ifdef _NUITKA_FULL_COMPAT | ||
| 2443 | Py_LeaveRecursiveCall(); | ||
| 2444 | #endif | ||
| 2445 | |||
| 2446 | if ( result != NULL ) | ||
| 2447 | { | ||
| 2448 | // Some buggy C functions do set an error, but do not indicate it | ||
| 2449 | // and Nuitka inner workings can get upset/confused from it. | ||
| 2450 | DROP_ERROR_OCCURRED(); | ||
| 2451 | |||
| 2452 | Py_DECREF( pos_args ); | ||
| 2453 | return result; | ||
| 2454 | } | ||
| 2455 | else | ||
| 2456 | { | ||
| 2457 | // Other buggy C functions do this, return NULL, but with | ||
| 2458 | // no error set, not allowed. | ||
| 2459 | if (unlikely( !ERROR_OCCURRED() )) | ||
| 2460 | { | ||
| 2461 | PyErr_Format( | ||
| 2462 | PyExc_SystemError, | ||
| 2463 | "NULL result without error in PyObject_Call" | ||
| 2464 | ); | ||
| 2465 | } | ||
| 2466 | |||
| 2467 | Py_DECREF( pos_args ); | ||
| 2468 | return NULL; | ||
| 2469 | } | ||
| 2470 | } | ||
| 2471 | } | ||
| 2472 | else if ( PyFunction_Check( called ) ) | ||
| 2473 | { | ||
| 2474 | return callPythonFunction( | ||
| 2475 | called, | ||
| 2476 | args, | ||
| 2477 | 8 | ||
| 2478 | ); | ||
| 2479 | } | ||
| 2480 | |||
| 2481 | PyObject *pos_args = MAKE_TUPLE( args, 8 ); | ||
| 2482 | |||
| 2483 | PyObject *result = CALL_FUNCTION( | ||
| 2484 | called, | ||
| 2485 | pos_args, | ||
| 2486 | NULL | ||
| 2487 | ); | ||
| 2488 | |||
| 2489 | Py_DECREF( pos_args ); | ||
| 2490 | |||
| 2491 | return result; | ||
| 2492 | } | ||
| 2493 | |||
| 2494 | PyObject *CALL_METHOD_WITH_ARGS1( PyObject *source, PyObject *attr_name, PyObject **args ) | ||
| 2495 | { | ||
| 2496 | CHECK_OBJECT( source ); | ||
| 2497 | CHECK_OBJECT( attr_name ); | ||
| 2498 | |||
| 2499 | // Check if arguments are valid objects in debug mode. | ||
| 2500 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 2501 | for( size_t i = 0; i < 1; i++ ) | ||
| 2502 | { | ||
| 2503 | CHECK_OBJECT( args[ i ] ); | ||
| 2504 | } | ||
| 2505 | #endif | ||
| 2506 | |||
| 2507 | PyTypeObject *type = Py_TYPE( source ); | ||
| 2508 | |||
| 2509 | if ( type->tp_getattro == PyObject_GenericGetAttr ) | ||
| 2510 | { | ||
| 2511 | // Unfortunately this is required, although of cause rarely necessary. | ||
| 2512 | if (unlikely( type->tp_dict == NULL )) | ||
| 2513 | { | ||
| 2514 | if (unlikely( PyType_Ready( type ) < 0 )) | ||
| 2515 | { | ||
| 2516 | return NULL; | ||
| 2517 | } | ||
| 2518 | } | ||
| 2519 | |||
| 2520 | PyObject *descr = _PyType_Lookup( type, attr_name ); | ||
| 2521 | descrgetfunc func = NULL; | ||
| 2522 | |||
| 2523 | if ( descr != NULL ) | ||
| 2524 | { | ||
| 2525 | Py_INCREF( descr ); | ||
| 2526 | |||
| 2527 | #if PYTHON_VERSION < 300 | ||
| 2528 | if ( PyType_HasFeature( Py_TYPE( descr ), Py_TPFLAGS_HAVE_CLASS ) ) | ||
| 2529 | { | ||
| 2530 | #endif | ||
| 2531 | func = Py_TYPE( descr )->tp_descr_get; | ||
| 2532 | |||
| 2533 | if ( func != NULL && PyDescr_IsData( descr ) ) | ||
| 2534 | { | ||
| 2535 | PyObject *called_object = func( descr, source, (PyObject *)type ); | ||
| 2536 | Py_DECREF( descr ); | ||
| 2537 | |||
| 2538 | PyObject *result = CALL_FUNCTION_WITH_ARGS1( | ||
| 2539 | called_object, | ||
| 2540 | args | ||
| 2541 | ); | ||
| 2542 | Py_DECREF( called_object ); | ||
| 2543 | return result; | ||
| 2544 | } | ||
| 2545 | #if PYTHON_VERSION < 300 | ||
| 2546 | } | ||
| 2547 | #endif | ||
| 2548 | } | ||
| 2549 | |||
| 2550 | Py_ssize_t dictoffset = type->tp_dictoffset; | ||
| 2551 | PyObject *dict = NULL; | ||
| 2552 | |||
| 2553 | if ( dictoffset != 0 ) | ||
| 2554 | { | ||
| 2555 | // Negative dictionary offsets have special meaning. | ||
| 2556 | if ( dictoffset < 0 ) | ||
| 2557 | { | ||
| 2558 | Py_ssize_t tsize; | ||
| 2559 | size_t size; | ||
| 2560 | |||
| 2561 | tsize = ((PyVarObject *)source)->ob_size; | ||
| 2562 | if (tsize < 0) | ||
| 2563 | tsize = -tsize; | ||
| 2564 | size = _PyObject_VAR_SIZE( type, tsize ); | ||
| 2565 | |||
| 2566 | dictoffset += (long)size; | ||
| 2567 | } | ||
| 2568 | |||
| 2569 | PyObject **dictptr = (PyObject **) ((char *)source + dictoffset); | ||
| 2570 | dict = *dictptr; | ||
| 2571 | } | ||
| 2572 | |||
| 2573 | if ( dict != NULL ) | ||
| 2574 | { | ||
| 2575 | CHECK_OBJECT( dict ); | ||
| 2576 | |||
| 2577 | Py_INCREF( dict ); | ||
| 2578 | |||
| 2579 | PyObject *called_object = PyDict_GetItem( dict, attr_name ); | ||
| 2580 | |||
| 2581 | if ( called_object != NULL ) | ||
| 2582 | { | ||
| 2583 | Py_INCREF( called_object ); | ||
| 2584 | Py_XDECREF( descr ); | ||
| 2585 | Py_DECREF( dict ); | ||
| 2586 | |||
| 2587 | PyObject *result = CALL_FUNCTION_WITH_ARGS1( | ||
| 2588 | called_object, | ||
| 2589 | args | ||
| 2590 | ); | ||
| 2591 | Py_DECREF( called_object ); | ||
| 2592 | return result; | ||
| 2593 | } | ||
| 2594 | |||
| 2595 | Py_DECREF( dict ); | ||
| 2596 | } | ||
| 2597 | |||
| 2598 | if ( func != NULL ) | ||
| 2599 | { | ||
| 2600 | if ( func == Nuitka_Function_Type.tp_descr_get ) | ||
| 2601 | { | ||
| 2602 | PyObject *result = Nuitka_CallMethodFunctionPosArgs( | ||
| 2603 | (struct Nuitka_FunctionObject const *)descr, | ||
| 2604 | source, | ||
| 2605 | args, | ||
| 2606 | 1 | ||
| 2607 | ); | ||
| 2608 | |||
| 2609 | Py_DECREF( descr ); | ||
| 2610 | |||
| 2611 | return result; | ||
| 2612 | } | ||
| 2613 | else | ||
| 2614 | { | ||
| 2615 | PyObject *called_object = func( descr, source, (PyObject *)type ); | ||
| 2616 | CHECK_OBJECT( called_object ); | ||
| 2617 | |||
| 2618 | Py_DECREF( descr ); | ||
| 2619 | |||
| 2620 | PyObject *result = CALL_FUNCTION_WITH_ARGS1( | ||
| 2621 | called_object, | ||
| 2622 | args | ||
| 2623 | ); | ||
| 2624 | Py_DECREF( called_object ); | ||
| 2625 | |||
| 2626 | return result; | ||
| 2627 | } | ||
| 2628 | } | ||
| 2629 | |||
| 2630 | if ( descr != NULL ) | ||
| 2631 | { | ||
| 2632 | CHECK_OBJECT( descr ); | ||
| 2633 | |||
| 2634 | PyObject *result = CALL_FUNCTION_WITH_ARGS1( | ||
| 2635 | descr, | ||
| 2636 | args | ||
| 2637 | ); | ||
| 2638 | Py_DECREF( descr ); | ||
| 2639 | |||
| 2640 | return result; | ||
| 2641 | } | ||
| 2642 | |||
| 2643 | #if PYTHON_VERSION < 300 | ||
| 2644 | PyErr_Format( | ||
| 2645 | PyExc_AttributeError, | ||
| 2646 | "'%s' object has no attribute '%s'", | ||
| 2647 | type->tp_name, | ||
| 2648 | PyString_AS_STRING( attr_name ) | ||
| 2649 | ); | ||
| 2650 | #else | ||
| 2651 | PyErr_Format( | ||
| 2652 | PyExc_AttributeError, | ||
| 2653 | "'%s' object has no attribute '%U'", | ||
| 2654 | type->tp_name, | ||
| 2655 | attr_name | ||
| 2656 | ); | ||
| 2657 | #endif | ||
| 2658 | return NULL; | ||
| 2659 | } | ||
| 2660 | #if PYTHON_VERSION < 300 | ||
| 2661 | else if ( type == &PyInstance_Type ) | ||
| 2662 | { | ||
| 2663 | PyInstanceObject *source_instance = (PyInstanceObject *)source; | ||
| 2664 | |||
| 2665 | // The special cases have their own variant on the code generation level | ||
| 2666 | // as we are called with constants only. | ||
| 2667 | assert( attr_name != const_str_plain___dict__ ); | ||
| 2668 | assert( attr_name != const_str_plain___class__ ); | ||
| 2669 | |||
| 2670 | // Try the instance dict first. | ||
| 2671 | PyObject *called_object = GET_STRING_DICT_VALUE( | ||
| 2672 | (PyDictObject *)source_instance->in_dict, | ||
| 2673 | (PyStringObject *)attr_name | ||
| 2674 | ); | ||
| 2675 | |||
| 2676 | // Note: The "called_object" was found without taking a reference, | ||
| 2677 | // so we need not release it in this branch. | ||
| 2678 | if ( called_object != NULL ) | ||
| 2679 | { | ||
| 2680 | return CALL_FUNCTION_WITH_ARGS1( called_object, args ); | ||
| 2681 | } | ||
| 2682 | |||
| 2683 | // Then check the class dictionaries. | ||
| 2684 | called_object = FIND_ATTRIBUTE_IN_CLASS( | ||
| 2685 | source_instance->in_class, | ||
| 2686 | attr_name | ||
| 2687 | ); | ||
| 2688 | |||
| 2689 | // Note: The "called_object" was found without taking a reference, | ||
| 2690 | // so we need not release it in this branch. | ||
| 2691 | if ( called_object != NULL ) | ||
| 2692 | { | ||
| 2693 | descrgetfunc descr_get = Py_TYPE( called_object )->tp_descr_get; | ||
| 2694 | |||
| 2695 | if ( descr_get == Nuitka_Function_Type.tp_descr_get ) | ||
| 2696 | { | ||
| 2697 | return Nuitka_CallMethodFunctionPosArgs( | ||
| 2698 | (struct Nuitka_FunctionObject const *)called_object, | ||
| 2699 | source, | ||
| 2700 | args, | ||
| 2701 | 1 | ||
| 2702 | ); | ||
| 2703 | } | ||
| 2704 | else if ( descr_get != NULL ) | ||
| 2705 | { | ||
| 2706 | PyObject *method = descr_get( | ||
| 2707 | called_object, | ||
| 2708 | source, | ||
| 2709 | (PyObject *)source_instance->in_class | ||
| 2710 | ); | ||
| 2711 | |||
| 2712 | if (unlikely( method == NULL )) | ||
| 2713 | { | ||
| 2714 | return NULL; | ||
| 2715 | } | ||
| 2716 | |||
| 2717 | PyObject *result = CALL_FUNCTION_WITH_ARGS1( method, args ); | ||
| 2718 | Py_DECREF( method ); | ||
| 2719 | return result; | ||
| 2720 | } | ||
| 2721 | else | ||
| 2722 | { | ||
| 2723 | return CALL_FUNCTION_WITH_ARGS1( called_object, args ); | ||
| 2724 | } | ||
| 2725 | |||
| 2726 | } | ||
| 2727 | else if (unlikely( source_instance->in_class->cl_getattr == NULL )) | ||
| 2728 | { | ||
| 2729 | PyErr_Format( | ||
| 2730 | PyExc_AttributeError, | ||
| 2731 | "%s instance has no attribute '%s'", | ||
| 2732 | PyString_AS_STRING( source_instance->in_class->cl_name ), | ||
| 2733 | PyString_AS_STRING( attr_name ) | ||
| 2734 | ); | ||
| 2735 | |||
| 2736 | return NULL; | ||
| 2737 | } | ||
| 2738 | else | ||
| 2739 | { | ||
| 2740 | // Finally allow the "__getattr__" override to provide it or else | ||
| 2741 | // it's an error. | ||
| 2742 | |||
| 2743 | PyObject *args2[] = { | ||
| 2744 | source, | ||
| 2745 | attr_name | ||
| 2746 | }; | ||
| 2747 | |||
| 2748 | called_object = CALL_FUNCTION_WITH_ARGS2( | ||
| 2749 | source_instance->in_class->cl_getattr, | ||
| 2750 | args2 | ||
| 2751 | ); | ||
| 2752 | |||
| 2753 | if (unlikely( called_object == NULL )) | ||
| 2754 | { | ||
| 2755 | return NULL; | ||
| 2756 | } | ||
| 2757 | |||
| 2758 | PyObject *result = CALL_FUNCTION_WITH_ARGS1( | ||
| 2759 | called_object, | ||
| 2760 | args | ||
| 2761 | ); | ||
| 2762 | Py_DECREF( called_object ); | ||
| 2763 | return result; | ||
| 2764 | } | ||
| 2765 | } | ||
| 2766 | #endif | ||
| 2767 | else if ( type->tp_getattro != NULL ) | ||
| 2768 | { | ||
| 2769 | PyObject *called_object = (*type->tp_getattro)( | ||
| 2770 | source, | ||
| 2771 | attr_name | ||
| 2772 | ); | ||
| 2773 | |||
| 2774 | if (unlikely( called_object == NULL )) | ||
| 2775 | { | ||
| 2776 | return NULL; | ||
| 2777 | } | ||
| 2778 | |||
| 2779 | PyObject *result = CALL_FUNCTION_WITH_ARGS1( | ||
| 2780 | called_object, | ||
| 2781 | args | ||
| 2782 | ); | ||
| 2783 | Py_DECREF( called_object ); | ||
| 2784 | return result; | ||
| 2785 | } | ||
| 2786 | else if ( type->tp_getattr != NULL ) | ||
| 2787 | { | ||
| 2788 | PyObject *called_object = (*type->tp_getattr)( | ||
| 2789 | source, | ||
| 2790 | (char *)Nuitka_String_AsString_Unchecked( attr_name ) | ||
| 2791 | ); | ||
| 2792 | |||
| 2793 | if (unlikely( called_object == NULL )) | ||
| 2794 | { | ||
| 2795 | return NULL; | ||
| 2796 | } | ||
| 2797 | |||
| 2798 | PyObject *result = CALL_FUNCTION_WITH_ARGS1( | ||
| 2799 | called_object, | ||
| 2800 | args | ||
| 2801 | ); | ||
| 2802 | Py_DECREF( called_object ); | ||
| 2803 | return result; | ||
| 2804 | } | ||
| 2805 | else | ||
| 2806 | { | ||
| 2807 | PyErr_Format( | ||
| 2808 | PyExc_AttributeError, | ||
| 2809 | "'%s' object has no attribute '%s'", | ||
| 2810 | type->tp_name, | ||
| 2811 | Nuitka_String_AsString_Unchecked( attr_name ) | ||
| 2812 | ); | ||
| 2813 | |||
| 2814 | return NULL; | ||
| 2815 | } | ||
| 2816 | } | ||
| 2817 | |||
| 2818 | PyObject *CALL_METHOD_WITH_ARGS2( PyObject *source, PyObject *attr_name, PyObject **args ) | ||
| 2819 | { | ||
| 2820 | CHECK_OBJECT( source ); | ||
| 2821 | CHECK_OBJECT( attr_name ); | ||
| 2822 | |||
| 2823 | // Check if arguments are valid objects in debug mode. | ||
| 2824 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 2825 | for( size_t i = 0; i < 2; i++ ) | ||
| 2826 | { | ||
| 2827 | CHECK_OBJECT( args[ i ] ); | ||
| 2828 | } | ||
| 2829 | #endif | ||
| 2830 | |||
| 2831 | PyTypeObject *type = Py_TYPE( source ); | ||
| 2832 | |||
| 2833 | if ( type->tp_getattro == PyObject_GenericGetAttr ) | ||
| 2834 | { | ||
| 2835 | // Unfortunately this is required, although of cause rarely necessary. | ||
| 2836 | if (unlikely( type->tp_dict == NULL )) | ||
| 2837 | { | ||
| 2838 | if (unlikely( PyType_Ready( type ) < 0 )) | ||
| 2839 | { | ||
| 2840 | return NULL; | ||
| 2841 | } | ||
| 2842 | } | ||
| 2843 | |||
| 2844 | PyObject *descr = _PyType_Lookup( type, attr_name ); | ||
| 2845 | descrgetfunc func = NULL; | ||
| 2846 | |||
| 2847 | if ( descr != NULL ) | ||
| 2848 | { | ||
| 2849 | Py_INCREF( descr ); | ||
| 2850 | |||
| 2851 | #if PYTHON_VERSION < 300 | ||
| 2852 | if ( PyType_HasFeature( Py_TYPE( descr ), Py_TPFLAGS_HAVE_CLASS ) ) | ||
| 2853 | { | ||
| 2854 | #endif | ||
| 2855 | func = Py_TYPE( descr )->tp_descr_get; | ||
| 2856 | |||
| 2857 | if ( func != NULL && PyDescr_IsData( descr ) ) | ||
| 2858 | { | ||
| 2859 | PyObject *called_object = func( descr, source, (PyObject *)type ); | ||
| 2860 | Py_DECREF( descr ); | ||
| 2861 | |||
| 2862 | PyObject *result = CALL_FUNCTION_WITH_ARGS2( | ||
| 2863 | called_object, | ||
| 2864 | args | ||
| 2865 | ); | ||
| 2866 | Py_DECREF( called_object ); | ||
| 2867 | return result; | ||
| 2868 | } | ||
| 2869 | #if PYTHON_VERSION < 300 | ||
| 2870 | } | ||
| 2871 | #endif | ||
| 2872 | } | ||
| 2873 | |||
| 2874 | Py_ssize_t dictoffset = type->tp_dictoffset; | ||
| 2875 | PyObject *dict = NULL; | ||
| 2876 | |||
| 2877 | if ( dictoffset != 0 ) | ||
| 2878 | { | ||
| 2879 | // Negative dictionary offsets have special meaning. | ||
| 2880 | if ( dictoffset < 0 ) | ||
| 2881 | { | ||
| 2882 | Py_ssize_t tsize; | ||
| 2883 | size_t size; | ||
| 2884 | |||
| 2885 | tsize = ((PyVarObject *)source)->ob_size; | ||
| 2886 | if (tsize < 0) | ||
| 2887 | tsize = -tsize; | ||
| 2888 | size = _PyObject_VAR_SIZE( type, tsize ); | ||
| 2889 | |||
| 2890 | dictoffset += (long)size; | ||
| 2891 | } | ||
| 2892 | |||
| 2893 | PyObject **dictptr = (PyObject **) ((char *)source + dictoffset); | ||
| 2894 | dict = *dictptr; | ||
| 2895 | } | ||
| 2896 | |||
| 2897 | if ( dict != NULL ) | ||
| 2898 | { | ||
| 2899 | CHECK_OBJECT( dict ); | ||
| 2900 | |||
| 2901 | Py_INCREF( dict ); | ||
| 2902 | |||
| 2903 | PyObject *called_object = PyDict_GetItem( dict, attr_name ); | ||
| 2904 | |||
| 2905 | if ( called_object != NULL ) | ||
| 2906 | { | ||
| 2907 | Py_INCREF( called_object ); | ||
| 2908 | Py_XDECREF( descr ); | ||
| 2909 | Py_DECREF( dict ); | ||
| 2910 | |||
| 2911 | PyObject *result = CALL_FUNCTION_WITH_ARGS2( | ||
| 2912 | called_object, | ||
| 2913 | args | ||
| 2914 | ); | ||
| 2915 | Py_DECREF( called_object ); | ||
| 2916 | return result; | ||
| 2917 | } | ||
| 2918 | |||
| 2919 | Py_DECREF( dict ); | ||
| 2920 | } | ||
| 2921 | |||
| 2922 | if ( func != NULL ) | ||
| 2923 | { | ||
| 2924 | if ( func == Nuitka_Function_Type.tp_descr_get ) | ||
| 2925 | { | ||
| 2926 | PyObject *result = Nuitka_CallMethodFunctionPosArgs( | ||
| 2927 | (struct Nuitka_FunctionObject const *)descr, | ||
| 2928 | source, | ||
| 2929 | args, | ||
| 2930 | 2 | ||
| 2931 | ); | ||
| 2932 | |||
| 2933 | Py_DECREF( descr ); | ||
| 2934 | |||
| 2935 | return result; | ||
| 2936 | } | ||
| 2937 | else | ||
| 2938 | { | ||
| 2939 | PyObject *called_object = func( descr, source, (PyObject *)type ); | ||
| 2940 | CHECK_OBJECT( called_object ); | ||
| 2941 | |||
| 2942 | Py_DECREF( descr ); | ||
| 2943 | |||
| 2944 | PyObject *result = CALL_FUNCTION_WITH_ARGS2( | ||
| 2945 | called_object, | ||
| 2946 | args | ||
| 2947 | ); | ||
| 2948 | Py_DECREF( called_object ); | ||
| 2949 | |||
| 2950 | return result; | ||
| 2951 | } | ||
| 2952 | } | ||
| 2953 | |||
| 2954 | if ( descr != NULL ) | ||
| 2955 | { | ||
| 2956 | CHECK_OBJECT( descr ); | ||
| 2957 | |||
| 2958 | PyObject *result = CALL_FUNCTION_WITH_ARGS2( | ||
| 2959 | descr, | ||
| 2960 | args | ||
| 2961 | ); | ||
| 2962 | Py_DECREF( descr ); | ||
| 2963 | |||
| 2964 | return result; | ||
| 2965 | } | ||
| 2966 | |||
| 2967 | #if PYTHON_VERSION < 300 | ||
| 2968 | PyErr_Format( | ||
| 2969 | PyExc_AttributeError, | ||
| 2970 | "'%s' object has no attribute '%s'", | ||
| 2971 | type->tp_name, | ||
| 2972 | PyString_AS_STRING( attr_name ) | ||
| 2973 | ); | ||
| 2974 | #else | ||
| 2975 | PyErr_Format( | ||
| 2976 | PyExc_AttributeError, | ||
| 2977 | "'%s' object has no attribute '%U'", | ||
| 2978 | type->tp_name, | ||
| 2979 | attr_name | ||
| 2980 | ); | ||
| 2981 | #endif | ||
| 2982 | return NULL; | ||
| 2983 | } | ||
| 2984 | #if PYTHON_VERSION < 300 | ||
| 2985 | else if ( type == &PyInstance_Type ) | ||
| 2986 | { | ||
| 2987 | PyInstanceObject *source_instance = (PyInstanceObject *)source; | ||
| 2988 | |||
| 2989 | // The special cases have their own variant on the code generation level | ||
| 2990 | // as we are called with constants only. | ||
| 2991 | assert( attr_name != const_str_plain___dict__ ); | ||
| 2992 | assert( attr_name != const_str_plain___class__ ); | ||
| 2993 | |||
| 2994 | // Try the instance dict first. | ||
| 2995 | PyObject *called_object = GET_STRING_DICT_VALUE( | ||
| 2996 | (PyDictObject *)source_instance->in_dict, | ||
| 2997 | (PyStringObject *)attr_name | ||
| 2998 | ); | ||
| 2999 | |||
| 3000 | // Note: The "called_object" was found without taking a reference, | ||
| 3001 | // so we need not release it in this branch. | ||
| 3002 | if ( called_object != NULL ) | ||
| 3003 | { | ||
| 3004 | return CALL_FUNCTION_WITH_ARGS2( called_object, args ); | ||
| 3005 | } | ||
| 3006 | |||
| 3007 | // Then check the class dictionaries. | ||
| 3008 | called_object = FIND_ATTRIBUTE_IN_CLASS( | ||
| 3009 | source_instance->in_class, | ||
| 3010 | attr_name | ||
| 3011 | ); | ||
| 3012 | |||
| 3013 | // Note: The "called_object" was found without taking a reference, | ||
| 3014 | // so we need not release it in this branch. | ||
| 3015 | if ( called_object != NULL ) | ||
| 3016 | { | ||
| 3017 | descrgetfunc descr_get = Py_TYPE( called_object )->tp_descr_get; | ||
| 3018 | |||
| 3019 | if ( descr_get == Nuitka_Function_Type.tp_descr_get ) | ||
| 3020 | { | ||
| 3021 | return Nuitka_CallMethodFunctionPosArgs( | ||
| 3022 | (struct Nuitka_FunctionObject const *)called_object, | ||
| 3023 | source, | ||
| 3024 | args, | ||
| 3025 | 2 | ||
| 3026 | ); | ||
| 3027 | } | ||
| 3028 | else if ( descr_get != NULL ) | ||
| 3029 | { | ||
| 3030 | PyObject *method = descr_get( | ||
| 3031 | called_object, | ||
| 3032 | source, | ||
| 3033 | (PyObject *)source_instance->in_class | ||
| 3034 | ); | ||
| 3035 | |||
| 3036 | if (unlikely( method == NULL )) | ||
| 3037 | { | ||
| 3038 | return NULL; | ||
| 3039 | } | ||
| 3040 | |||
| 3041 | PyObject *result = CALL_FUNCTION_WITH_ARGS2( method, args ); | ||
| 3042 | Py_DECREF( method ); | ||
| 3043 | return result; | ||
| 3044 | } | ||
| 3045 | else | ||
| 3046 | { | ||
| 3047 | return CALL_FUNCTION_WITH_ARGS2( called_object, args ); | ||
| 3048 | } | ||
| 3049 | |||
| 3050 | } | ||
| 3051 | else if (unlikely( source_instance->in_class->cl_getattr == NULL )) | ||
| 3052 | { | ||
| 3053 | PyErr_Format( | ||
| 3054 | PyExc_AttributeError, | ||
| 3055 | "%s instance has no attribute '%s'", | ||
| 3056 | PyString_AS_STRING( source_instance->in_class->cl_name ), | ||
| 3057 | PyString_AS_STRING( attr_name ) | ||
| 3058 | ); | ||
| 3059 | |||
| 3060 | return NULL; | ||
| 3061 | } | ||
| 3062 | else | ||
| 3063 | { | ||
| 3064 | // Finally allow the "__getattr__" override to provide it or else | ||
| 3065 | // it's an error. | ||
| 3066 | |||
| 3067 | PyObject *args2[] = { | ||
| 3068 | source, | ||
| 3069 | attr_name | ||
| 3070 | }; | ||
| 3071 | |||
| 3072 | called_object = CALL_FUNCTION_WITH_ARGS2( | ||
| 3073 | source_instance->in_class->cl_getattr, | ||
| 3074 | args2 | ||
| 3075 | ); | ||
| 3076 | |||
| 3077 | if (unlikely( called_object == NULL )) | ||
| 3078 | { | ||
| 3079 | return NULL; | ||
| 3080 | } | ||
| 3081 | |||
| 3082 | PyObject *result = CALL_FUNCTION_WITH_ARGS2( | ||
| 3083 | called_object, | ||
| 3084 | args | ||
| 3085 | ); | ||
| 3086 | Py_DECREF( called_object ); | ||
| 3087 | return result; | ||
| 3088 | } | ||
| 3089 | } | ||
| 3090 | #endif | ||
| 3091 | else if ( type->tp_getattro != NULL ) | ||
| 3092 | { | ||
| 3093 | PyObject *called_object = (*type->tp_getattro)( | ||
| 3094 | source, | ||
| 3095 | attr_name | ||
| 3096 | ); | ||
| 3097 | |||
| 3098 | if (unlikely( called_object == NULL )) | ||
| 3099 | { | ||
| 3100 | return NULL; | ||
| 3101 | } | ||
| 3102 | |||
| 3103 | PyObject *result = CALL_FUNCTION_WITH_ARGS2( | ||
| 3104 | called_object, | ||
| 3105 | args | ||
| 3106 | ); | ||
| 3107 | Py_DECREF( called_object ); | ||
| 3108 | return result; | ||
| 3109 | } | ||
| 3110 | else if ( type->tp_getattr != NULL ) | ||
| 3111 | { | ||
| 3112 | PyObject *called_object = (*type->tp_getattr)( | ||
| 3113 | source, | ||
| 3114 | (char *)Nuitka_String_AsString_Unchecked( attr_name ) | ||
| 3115 | ); | ||
| 3116 | |||
| 3117 | if (unlikely( called_object == NULL )) | ||
| 3118 | { | ||
| 3119 | return NULL; | ||
| 3120 | } | ||
| 3121 | |||
| 3122 | PyObject *result = CALL_FUNCTION_WITH_ARGS2( | ||
| 3123 | called_object, | ||
| 3124 | args | ||
| 3125 | ); | ||
| 3126 | Py_DECREF( called_object ); | ||
| 3127 | return result; | ||
| 3128 | } | ||
| 3129 | else | ||
| 3130 | { | ||
| 3131 | PyErr_Format( | ||
| 3132 | PyExc_AttributeError, | ||
| 3133 | "'%s' object has no attribute '%s'", | ||
| 3134 | type->tp_name, | ||
| 3135 | Nuitka_String_AsString_Unchecked( attr_name ) | ||
| 3136 | ); | ||
| 3137 | |||
| 3138 | return NULL; | ||
| 3139 | } | ||
| 3140 | } | ||
| 3141 | |||
| 3142 | PyObject *CALL_METHOD_WITH_ARGS3( PyObject *source, PyObject *attr_name, PyObject **args ) | ||
| 3143 | { | ||
| 3144 | CHECK_OBJECT( source ); | ||
| 3145 | CHECK_OBJECT( attr_name ); | ||
| 3146 | |||
| 3147 | // Check if arguments are valid objects in debug mode. | ||
| 3148 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 3149 | for( size_t i = 0; i < 3; i++ ) | ||
| 3150 | { | ||
| 3151 | CHECK_OBJECT( args[ i ] ); | ||
| 3152 | } | ||
| 3153 | #endif | ||
| 3154 | |||
| 3155 | PyTypeObject *type = Py_TYPE( source ); | ||
| 3156 | |||
| 3157 | if ( type->tp_getattro == PyObject_GenericGetAttr ) | ||
| 3158 | { | ||
| 3159 | // Unfortunately this is required, although of cause rarely necessary. | ||
| 3160 | if (unlikely( type->tp_dict == NULL )) | ||
| 3161 | { | ||
| 3162 | if (unlikely( PyType_Ready( type ) < 0 )) | ||
| 3163 | { | ||
| 3164 | return NULL; | ||
| 3165 | } | ||
| 3166 | } | ||
| 3167 | |||
| 3168 | PyObject *descr = _PyType_Lookup( type, attr_name ); | ||
| 3169 | descrgetfunc func = NULL; | ||
| 3170 | |||
| 3171 | if ( descr != NULL ) | ||
| 3172 | { | ||
| 3173 | Py_INCREF( descr ); | ||
| 3174 | |||
| 3175 | #if PYTHON_VERSION < 300 | ||
| 3176 | if ( PyType_HasFeature( Py_TYPE( descr ), Py_TPFLAGS_HAVE_CLASS ) ) | ||
| 3177 | { | ||
| 3178 | #endif | ||
| 3179 | func = Py_TYPE( descr )->tp_descr_get; | ||
| 3180 | |||
| 3181 | if ( func != NULL && PyDescr_IsData( descr ) ) | ||
| 3182 | { | ||
| 3183 | PyObject *called_object = func( descr, source, (PyObject *)type ); | ||
| 3184 | Py_DECREF( descr ); | ||
| 3185 | |||
| 3186 | PyObject *result = CALL_FUNCTION_WITH_ARGS3( | ||
| 3187 | called_object, | ||
| 3188 | args | ||
| 3189 | ); | ||
| 3190 | Py_DECREF( called_object ); | ||
| 3191 | return result; | ||
| 3192 | } | ||
| 3193 | #if PYTHON_VERSION < 300 | ||
| 3194 | } | ||
| 3195 | #endif | ||
| 3196 | } | ||
| 3197 | |||
| 3198 | Py_ssize_t dictoffset = type->tp_dictoffset; | ||
| 3199 | PyObject *dict = NULL; | ||
| 3200 | |||
| 3201 | if ( dictoffset != 0 ) | ||
| 3202 | { | ||
| 3203 | // Negative dictionary offsets have special meaning. | ||
| 3204 | if ( dictoffset < 0 ) | ||
| 3205 | { | ||
| 3206 | Py_ssize_t tsize; | ||
| 3207 | size_t size; | ||
| 3208 | |||
| 3209 | tsize = ((PyVarObject *)source)->ob_size; | ||
| 3210 | if (tsize < 0) | ||
| 3211 | tsize = -tsize; | ||
| 3212 | size = _PyObject_VAR_SIZE( type, tsize ); | ||
| 3213 | |||
| 3214 | dictoffset += (long)size; | ||
| 3215 | } | ||
| 3216 | |||
| 3217 | PyObject **dictptr = (PyObject **) ((char *)source + dictoffset); | ||
| 3218 | dict = *dictptr; | ||
| 3219 | } | ||
| 3220 | |||
| 3221 | if ( dict != NULL ) | ||
| 3222 | { | ||
| 3223 | CHECK_OBJECT( dict ); | ||
| 3224 | |||
| 3225 | Py_INCREF( dict ); | ||
| 3226 | |||
| 3227 | PyObject *called_object = PyDict_GetItem( dict, attr_name ); | ||
| 3228 | |||
| 3229 | if ( called_object != NULL ) | ||
| 3230 | { | ||
| 3231 | Py_INCREF( called_object ); | ||
| 3232 | Py_XDECREF( descr ); | ||
| 3233 | Py_DECREF( dict ); | ||
| 3234 | |||
| 3235 | PyObject *result = CALL_FUNCTION_WITH_ARGS3( | ||
| 3236 | called_object, | ||
| 3237 | args | ||
| 3238 | ); | ||
| 3239 | Py_DECREF( called_object ); | ||
| 3240 | return result; | ||
| 3241 | } | ||
| 3242 | |||
| 3243 | Py_DECREF( dict ); | ||
| 3244 | } | ||
| 3245 | |||
| 3246 | if ( func != NULL ) | ||
| 3247 | { | ||
| 3248 | if ( func == Nuitka_Function_Type.tp_descr_get ) | ||
| 3249 | { | ||
| 3250 | PyObject *result = Nuitka_CallMethodFunctionPosArgs( | ||
| 3251 | (struct Nuitka_FunctionObject const *)descr, | ||
| 3252 | source, | ||
| 3253 | args, | ||
| 3254 | 3 | ||
| 3255 | ); | ||
| 3256 | |||
| 3257 | Py_DECREF( descr ); | ||
| 3258 | |||
| 3259 | return result; | ||
| 3260 | } | ||
| 3261 | else | ||
| 3262 | { | ||
| 3263 | PyObject *called_object = func( descr, source, (PyObject *)type ); | ||
| 3264 | CHECK_OBJECT( called_object ); | ||
| 3265 | |||
| 3266 | Py_DECREF( descr ); | ||
| 3267 | |||
| 3268 | PyObject *result = CALL_FUNCTION_WITH_ARGS3( | ||
| 3269 | called_object, | ||
| 3270 | args | ||
| 3271 | ); | ||
| 3272 | Py_DECREF( called_object ); | ||
| 3273 | |||
| 3274 | return result; | ||
| 3275 | } | ||
| 3276 | } | ||
| 3277 | |||
| 3278 | if ( descr != NULL ) | ||
| 3279 | { | ||
| 3280 | CHECK_OBJECT( descr ); | ||
| 3281 | |||
| 3282 | PyObject *result = CALL_FUNCTION_WITH_ARGS3( | ||
| 3283 | descr, | ||
| 3284 | args | ||
| 3285 | ); | ||
| 3286 | Py_DECREF( descr ); | ||
| 3287 | |||
| 3288 | return result; | ||
| 3289 | } | ||
| 3290 | |||
| 3291 | #if PYTHON_VERSION < 300 | ||
| 3292 | PyErr_Format( | ||
| 3293 | PyExc_AttributeError, | ||
| 3294 | "'%s' object has no attribute '%s'", | ||
| 3295 | type->tp_name, | ||
| 3296 | PyString_AS_STRING( attr_name ) | ||
| 3297 | ); | ||
| 3298 | #else | ||
| 3299 | PyErr_Format( | ||
| 3300 | PyExc_AttributeError, | ||
| 3301 | "'%s' object has no attribute '%U'", | ||
| 3302 | type->tp_name, | ||
| 3303 | attr_name | ||
| 3304 | ); | ||
| 3305 | #endif | ||
| 3306 | return NULL; | ||
| 3307 | } | ||
| 3308 | #if PYTHON_VERSION < 300 | ||
| 3309 | else if ( type == &PyInstance_Type ) | ||
| 3310 | { | ||
| 3311 | PyInstanceObject *source_instance = (PyInstanceObject *)source; | ||
| 3312 | |||
| 3313 | // The special cases have their own variant on the code generation level | ||
| 3314 | // as we are called with constants only. | ||
| 3315 | assert( attr_name != const_str_plain___dict__ ); | ||
| 3316 | assert( attr_name != const_str_plain___class__ ); | ||
| 3317 | |||
| 3318 | // Try the instance dict first. | ||
| 3319 | PyObject *called_object = GET_STRING_DICT_VALUE( | ||
| 3320 | (PyDictObject *)source_instance->in_dict, | ||
| 3321 | (PyStringObject *)attr_name | ||
| 3322 | ); | ||
| 3323 | |||
| 3324 | // Note: The "called_object" was found without taking a reference, | ||
| 3325 | // so we need not release it in this branch. | ||
| 3326 | if ( called_object != NULL ) | ||
| 3327 | { | ||
| 3328 | return CALL_FUNCTION_WITH_ARGS3( called_object, args ); | ||
| 3329 | } | ||
| 3330 | |||
| 3331 | // Then check the class dictionaries. | ||
| 3332 | called_object = FIND_ATTRIBUTE_IN_CLASS( | ||
| 3333 | source_instance->in_class, | ||
| 3334 | attr_name | ||
| 3335 | ); | ||
| 3336 | |||
| 3337 | // Note: The "called_object" was found without taking a reference, | ||
| 3338 | // so we need not release it in this branch. | ||
| 3339 | if ( called_object != NULL ) | ||
| 3340 | { | ||
| 3341 | descrgetfunc descr_get = Py_TYPE( called_object )->tp_descr_get; | ||
| 3342 | |||
| 3343 | if ( descr_get == Nuitka_Function_Type.tp_descr_get ) | ||
| 3344 | { | ||
| 3345 | return Nuitka_CallMethodFunctionPosArgs( | ||
| 3346 | (struct Nuitka_FunctionObject const *)called_object, | ||
| 3347 | source, | ||
| 3348 | args, | ||
| 3349 | 3 | ||
| 3350 | ); | ||
| 3351 | } | ||
| 3352 | else if ( descr_get != NULL ) | ||
| 3353 | { | ||
| 3354 | PyObject *method = descr_get( | ||
| 3355 | called_object, | ||
| 3356 | source, | ||
| 3357 | (PyObject *)source_instance->in_class | ||
| 3358 | ); | ||
| 3359 | |||
| 3360 | if (unlikely( method == NULL )) | ||
| 3361 | { | ||
| 3362 | return NULL; | ||
| 3363 | } | ||
| 3364 | |||
| 3365 | PyObject *result = CALL_FUNCTION_WITH_ARGS3( method, args ); | ||
| 3366 | Py_DECREF( method ); | ||
| 3367 | return result; | ||
| 3368 | } | ||
| 3369 | else | ||
| 3370 | { | ||
| 3371 | return CALL_FUNCTION_WITH_ARGS3( called_object, args ); | ||
| 3372 | } | ||
| 3373 | |||
| 3374 | } | ||
| 3375 | else if (unlikely( source_instance->in_class->cl_getattr == NULL )) | ||
| 3376 | { | ||
| 3377 | PyErr_Format( | ||
| 3378 | PyExc_AttributeError, | ||
| 3379 | "%s instance has no attribute '%s'", | ||
| 3380 | PyString_AS_STRING( source_instance->in_class->cl_name ), | ||
| 3381 | PyString_AS_STRING( attr_name ) | ||
| 3382 | ); | ||
| 3383 | |||
| 3384 | return NULL; | ||
| 3385 | } | ||
| 3386 | else | ||
| 3387 | { | ||
| 3388 | // Finally allow the "__getattr__" override to provide it or else | ||
| 3389 | // it's an error. | ||
| 3390 | |||
| 3391 | PyObject *args2[] = { | ||
| 3392 | source, | ||
| 3393 | attr_name | ||
| 3394 | }; | ||
| 3395 | |||
| 3396 | called_object = CALL_FUNCTION_WITH_ARGS2( | ||
| 3397 | source_instance->in_class->cl_getattr, | ||
| 3398 | args2 | ||
| 3399 | ); | ||
| 3400 | |||
| 3401 | if (unlikely( called_object == NULL )) | ||
| 3402 | { | ||
| 3403 | return NULL; | ||
| 3404 | } | ||
| 3405 | |||
| 3406 | PyObject *result = CALL_FUNCTION_WITH_ARGS3( | ||
| 3407 | called_object, | ||
| 3408 | args | ||
| 3409 | ); | ||
| 3410 | Py_DECREF( called_object ); | ||
| 3411 | return result; | ||
| 3412 | } | ||
| 3413 | } | ||
| 3414 | #endif | ||
| 3415 | else if ( type->tp_getattro != NULL ) | ||
| 3416 | { | ||
| 3417 | PyObject *called_object = (*type->tp_getattro)( | ||
| 3418 | source, | ||
| 3419 | attr_name | ||
| 3420 | ); | ||
| 3421 | |||
| 3422 | if (unlikely( called_object == NULL )) | ||
| 3423 | { | ||
| 3424 | return NULL; | ||
| 3425 | } | ||
| 3426 | |||
| 3427 | PyObject *result = CALL_FUNCTION_WITH_ARGS3( | ||
| 3428 | called_object, | ||
| 3429 | args | ||
| 3430 | ); | ||
| 3431 | Py_DECREF( called_object ); | ||
| 3432 | return result; | ||
| 3433 | } | ||
| 3434 | else if ( type->tp_getattr != NULL ) | ||
| 3435 | { | ||
| 3436 | PyObject *called_object = (*type->tp_getattr)( | ||
| 3437 | source, | ||
| 3438 | (char *)Nuitka_String_AsString_Unchecked( attr_name ) | ||
| 3439 | ); | ||
| 3440 | |||
| 3441 | if (unlikely( called_object == NULL )) | ||
| 3442 | { | ||
| 3443 | return NULL; | ||
| 3444 | } | ||
| 3445 | |||
| 3446 | PyObject *result = CALL_FUNCTION_WITH_ARGS3( | ||
| 3447 | called_object, | ||
| 3448 | args | ||
| 3449 | ); | ||
| 3450 | Py_DECREF( called_object ); | ||
| 3451 | return result; | ||
| 3452 | } | ||
| 3453 | else | ||
| 3454 | { | ||
| 3455 | PyErr_Format( | ||
| 3456 | PyExc_AttributeError, | ||
| 3457 | "'%s' object has no attribute '%s'", | ||
| 3458 | type->tp_name, | ||
| 3459 | Nuitka_String_AsString_Unchecked( attr_name ) | ||
| 3460 | ); | ||
| 3461 | |||
| 3462 | return NULL; | ||
| 3463 | } | ||
| 3464 | } | ||
| 3465 | |||
| 3466 | PyObject *CALL_METHOD_WITH_ARGS4( PyObject *source, PyObject *attr_name, PyObject **args ) | ||
| 3467 | { | ||
| 3468 | CHECK_OBJECT( source ); | ||
| 3469 | CHECK_OBJECT( attr_name ); | ||
| 3470 | |||
| 3471 | // Check if arguments are valid objects in debug mode. | ||
| 3472 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 3473 | for( size_t i = 0; i < 4; i++ ) | ||
| 3474 | { | ||
| 3475 | CHECK_OBJECT( args[ i ] ); | ||
| 3476 | } | ||
| 3477 | #endif | ||
| 3478 | |||
| 3479 | PyTypeObject *type = Py_TYPE( source ); | ||
| 3480 | |||
| 3481 | if ( type->tp_getattro == PyObject_GenericGetAttr ) | ||
| 3482 | { | ||
| 3483 | // Unfortunately this is required, although of cause rarely necessary. | ||
| 3484 | if (unlikely( type->tp_dict == NULL )) | ||
| 3485 | { | ||
| 3486 | if (unlikely( PyType_Ready( type ) < 0 )) | ||
| 3487 | { | ||
| 3488 | return NULL; | ||
| 3489 | } | ||
| 3490 | } | ||
| 3491 | |||
| 3492 | PyObject *descr = _PyType_Lookup( type, attr_name ); | ||
| 3493 | descrgetfunc func = NULL; | ||
| 3494 | |||
| 3495 | if ( descr != NULL ) | ||
| 3496 | { | ||
| 3497 | Py_INCREF( descr ); | ||
| 3498 | |||
| 3499 | #if PYTHON_VERSION < 300 | ||
| 3500 | if ( PyType_HasFeature( Py_TYPE( descr ), Py_TPFLAGS_HAVE_CLASS ) ) | ||
| 3501 | { | ||
| 3502 | #endif | ||
| 3503 | func = Py_TYPE( descr )->tp_descr_get; | ||
| 3504 | |||
| 3505 | if ( func != NULL && PyDescr_IsData( descr ) ) | ||
| 3506 | { | ||
| 3507 | PyObject *called_object = func( descr, source, (PyObject *)type ); | ||
| 3508 | Py_DECREF( descr ); | ||
| 3509 | |||
| 3510 | PyObject *result = CALL_FUNCTION_WITH_ARGS4( | ||
| 3511 | called_object, | ||
| 3512 | args | ||
| 3513 | ); | ||
| 3514 | Py_DECREF( called_object ); | ||
| 3515 | return result; | ||
| 3516 | } | ||
| 3517 | #if PYTHON_VERSION < 300 | ||
| 3518 | } | ||
| 3519 | #endif | ||
| 3520 | } | ||
| 3521 | |||
| 3522 | Py_ssize_t dictoffset = type->tp_dictoffset; | ||
| 3523 | PyObject *dict = NULL; | ||
| 3524 | |||
| 3525 | if ( dictoffset != 0 ) | ||
| 3526 | { | ||
| 3527 | // Negative dictionary offsets have special meaning. | ||
| 3528 | if ( dictoffset < 0 ) | ||
| 3529 | { | ||
| 3530 | Py_ssize_t tsize; | ||
| 3531 | size_t size; | ||
| 3532 | |||
| 3533 | tsize = ((PyVarObject *)source)->ob_size; | ||
| 3534 | if (tsize < 0) | ||
| 3535 | tsize = -tsize; | ||
| 3536 | size = _PyObject_VAR_SIZE( type, tsize ); | ||
| 3537 | |||
| 3538 | dictoffset += (long)size; | ||
| 3539 | } | ||
| 3540 | |||
| 3541 | PyObject **dictptr = (PyObject **) ((char *)source + dictoffset); | ||
| 3542 | dict = *dictptr; | ||
| 3543 | } | ||
| 3544 | |||
| 3545 | if ( dict != NULL ) | ||
| 3546 | { | ||
| 3547 | CHECK_OBJECT( dict ); | ||
| 3548 | |||
| 3549 | Py_INCREF( dict ); | ||
| 3550 | |||
| 3551 | PyObject *called_object = PyDict_GetItem( dict, attr_name ); | ||
| 3552 | |||
| 3553 | if ( called_object != NULL ) | ||
| 3554 | { | ||
| 3555 | Py_INCREF( called_object ); | ||
| 3556 | Py_XDECREF( descr ); | ||
| 3557 | Py_DECREF( dict ); | ||
| 3558 | |||
| 3559 | PyObject *result = CALL_FUNCTION_WITH_ARGS4( | ||
| 3560 | called_object, | ||
| 3561 | args | ||
| 3562 | ); | ||
| 3563 | Py_DECREF( called_object ); | ||
| 3564 | return result; | ||
| 3565 | } | ||
| 3566 | |||
| 3567 | Py_DECREF( dict ); | ||
| 3568 | } | ||
| 3569 | |||
| 3570 | if ( func != NULL ) | ||
| 3571 | { | ||
| 3572 | if ( func == Nuitka_Function_Type.tp_descr_get ) | ||
| 3573 | { | ||
| 3574 | PyObject *result = Nuitka_CallMethodFunctionPosArgs( | ||
| 3575 | (struct Nuitka_FunctionObject const *)descr, | ||
| 3576 | source, | ||
| 3577 | args, | ||
| 3578 | 4 | ||
| 3579 | ); | ||
| 3580 | |||
| 3581 | Py_DECREF( descr ); | ||
| 3582 | |||
| 3583 | return result; | ||
| 3584 | } | ||
| 3585 | else | ||
| 3586 | { | ||
| 3587 | PyObject *called_object = func( descr, source, (PyObject *)type ); | ||
| 3588 | CHECK_OBJECT( called_object ); | ||
| 3589 | |||
| 3590 | Py_DECREF( descr ); | ||
| 3591 | |||
| 3592 | PyObject *result = CALL_FUNCTION_WITH_ARGS4( | ||
| 3593 | called_object, | ||
| 3594 | args | ||
| 3595 | ); | ||
| 3596 | Py_DECREF( called_object ); | ||
| 3597 | |||
| 3598 | return result; | ||
| 3599 | } | ||
| 3600 | } | ||
| 3601 | |||
| 3602 | if ( descr != NULL ) | ||
| 3603 | { | ||
| 3604 | CHECK_OBJECT( descr ); | ||
| 3605 | |||
| 3606 | PyObject *result = CALL_FUNCTION_WITH_ARGS4( | ||
| 3607 | descr, | ||
| 3608 | args | ||
| 3609 | ); | ||
| 3610 | Py_DECREF( descr ); | ||
| 3611 | |||
| 3612 | return result; | ||
| 3613 | } | ||
| 3614 | |||
| 3615 | #if PYTHON_VERSION < 300 | ||
| 3616 | PyErr_Format( | ||
| 3617 | PyExc_AttributeError, | ||
| 3618 | "'%s' object has no attribute '%s'", | ||
| 3619 | type->tp_name, | ||
| 3620 | PyString_AS_STRING( attr_name ) | ||
| 3621 | ); | ||
| 3622 | #else | ||
| 3623 | PyErr_Format( | ||
| 3624 | PyExc_AttributeError, | ||
| 3625 | "'%s' object has no attribute '%U'", | ||
| 3626 | type->tp_name, | ||
| 3627 | attr_name | ||
| 3628 | ); | ||
| 3629 | #endif | ||
| 3630 | return NULL; | ||
| 3631 | } | ||
| 3632 | #if PYTHON_VERSION < 300 | ||
| 3633 | else if ( type == &PyInstance_Type ) | ||
| 3634 | { | ||
| 3635 | PyInstanceObject *source_instance = (PyInstanceObject *)source; | ||
| 3636 | |||
| 3637 | // The special cases have their own variant on the code generation level | ||
| 3638 | // as we are called with constants only. | ||
| 3639 | assert( attr_name != const_str_plain___dict__ ); | ||
| 3640 | assert( attr_name != const_str_plain___class__ ); | ||
| 3641 | |||
| 3642 | // Try the instance dict first. | ||
| 3643 | PyObject *called_object = GET_STRING_DICT_VALUE( | ||
| 3644 | (PyDictObject *)source_instance->in_dict, | ||
| 3645 | (PyStringObject *)attr_name | ||
| 3646 | ); | ||
| 3647 | |||
| 3648 | // Note: The "called_object" was found without taking a reference, | ||
| 3649 | // so we need not release it in this branch. | ||
| 3650 | if ( called_object != NULL ) | ||
| 3651 | { | ||
| 3652 | return CALL_FUNCTION_WITH_ARGS4( called_object, args ); | ||
| 3653 | } | ||
| 3654 | |||
| 3655 | // Then check the class dictionaries. | ||
| 3656 | called_object = FIND_ATTRIBUTE_IN_CLASS( | ||
| 3657 | source_instance->in_class, | ||
| 3658 | attr_name | ||
| 3659 | ); | ||
| 3660 | |||
| 3661 | // Note: The "called_object" was found without taking a reference, | ||
| 3662 | // so we need not release it in this branch. | ||
| 3663 | if ( called_object != NULL ) | ||
| 3664 | { | ||
| 3665 | descrgetfunc descr_get = Py_TYPE( called_object )->tp_descr_get; | ||
| 3666 | |||
| 3667 | if ( descr_get == Nuitka_Function_Type.tp_descr_get ) | ||
| 3668 | { | ||
| 3669 | return Nuitka_CallMethodFunctionPosArgs( | ||
| 3670 | (struct Nuitka_FunctionObject const *)called_object, | ||
| 3671 | source, | ||
| 3672 | args, | ||
| 3673 | 4 | ||
| 3674 | ); | ||
| 3675 | } | ||
| 3676 | else if ( descr_get != NULL ) | ||
| 3677 | { | ||
| 3678 | PyObject *method = descr_get( | ||
| 3679 | called_object, | ||
| 3680 | source, | ||
| 3681 | (PyObject *)source_instance->in_class | ||
| 3682 | ); | ||
| 3683 | |||
| 3684 | if (unlikely( method == NULL )) | ||
| 3685 | { | ||
| 3686 | return NULL; | ||
| 3687 | } | ||
| 3688 | |||
| 3689 | PyObject *result = CALL_FUNCTION_WITH_ARGS4( method, args ); | ||
| 3690 | Py_DECREF( method ); | ||
| 3691 | return result; | ||
| 3692 | } | ||
| 3693 | else | ||
| 3694 | { | ||
| 3695 | return CALL_FUNCTION_WITH_ARGS4( called_object, args ); | ||
| 3696 | } | ||
| 3697 | |||
| 3698 | } | ||
| 3699 | else if (unlikely( source_instance->in_class->cl_getattr == NULL )) | ||
| 3700 | { | ||
| 3701 | PyErr_Format( | ||
| 3702 | PyExc_AttributeError, | ||
| 3703 | "%s instance has no attribute '%s'", | ||
| 3704 | PyString_AS_STRING( source_instance->in_class->cl_name ), | ||
| 3705 | PyString_AS_STRING( attr_name ) | ||
| 3706 | ); | ||
| 3707 | |||
| 3708 | return NULL; | ||
| 3709 | } | ||
| 3710 | else | ||
| 3711 | { | ||
| 3712 | // Finally allow the "__getattr__" override to provide it or else | ||
| 3713 | // it's an error. | ||
| 3714 | |||
| 3715 | PyObject *args2[] = { | ||
| 3716 | source, | ||
| 3717 | attr_name | ||
| 3718 | }; | ||
| 3719 | |||
| 3720 | called_object = CALL_FUNCTION_WITH_ARGS2( | ||
| 3721 | source_instance->in_class->cl_getattr, | ||
| 3722 | args2 | ||
| 3723 | ); | ||
| 3724 | |||
| 3725 | if (unlikely( called_object == NULL )) | ||
| 3726 | { | ||
| 3727 | return NULL; | ||
| 3728 | } | ||
| 3729 | |||
| 3730 | PyObject *result = CALL_FUNCTION_WITH_ARGS4( | ||
| 3731 | called_object, | ||
| 3732 | args | ||
| 3733 | ); | ||
| 3734 | Py_DECREF( called_object ); | ||
| 3735 | return result; | ||
| 3736 | } | ||
| 3737 | } | ||
| 3738 | #endif | ||
| 3739 | else if ( type->tp_getattro != NULL ) | ||
| 3740 | { | ||
| 3741 | PyObject *called_object = (*type->tp_getattro)( | ||
| 3742 | source, | ||
| 3743 | attr_name | ||
| 3744 | ); | ||
| 3745 | |||
| 3746 | if (unlikely( called_object == NULL )) | ||
| 3747 | { | ||
| 3748 | return NULL; | ||
| 3749 | } | ||
| 3750 | |||
| 3751 | PyObject *result = CALL_FUNCTION_WITH_ARGS4( | ||
| 3752 | called_object, | ||
| 3753 | args | ||
| 3754 | ); | ||
| 3755 | Py_DECREF( called_object ); | ||
| 3756 | return result; | ||
| 3757 | } | ||
| 3758 | else if ( type->tp_getattr != NULL ) | ||
| 3759 | { | ||
| 3760 | PyObject *called_object = (*type->tp_getattr)( | ||
| 3761 | source, | ||
| 3762 | (char *)Nuitka_String_AsString_Unchecked( attr_name ) | ||
| 3763 | ); | ||
| 3764 | |||
| 3765 | if (unlikely( called_object == NULL )) | ||
| 3766 | { | ||
| 3767 | return NULL; | ||
| 3768 | } | ||
| 3769 | |||
| 3770 | PyObject *result = CALL_FUNCTION_WITH_ARGS4( | ||
| 3771 | called_object, | ||
| 3772 | args | ||
| 3773 | ); | ||
| 3774 | Py_DECREF( called_object ); | ||
| 3775 | return result; | ||
| 3776 | } | ||
| 3777 | else | ||
| 3778 | { | ||
| 3779 | PyErr_Format( | ||
| 3780 | PyExc_AttributeError, | ||
| 3781 | "'%s' object has no attribute '%s'", | ||
| 3782 | type->tp_name, | ||
| 3783 | Nuitka_String_AsString_Unchecked( attr_name ) | ||
| 3784 | ); | ||
| 3785 | |||
| 3786 | return NULL; | ||
| 3787 | } | ||
| 3788 | } | ||
| 3789 | /* Code to register embedded modules for meta path based loading if any. */ | ||
| 3790 | |||
| 3791 | #include "nuitka/unfreezing.h" | ||
| 3792 | |||
| 3793 | /* Table for lookup to find compiled or bytecode modules included in this | ||
| 3794 | * binary or module, or put along this binary as extension modules. We do | ||
| 3795 | * our own loading for each of these. | ||
| 3796 | */ | ||
| 3797 | MOD_INIT_DECL( __main__ ); | ||
| 3798 | MOD_INIT_DECL( abrt_exception_handler3 ); | ||
| 3799 | MOD_INIT_DECL( dbus ); | ||
| 3800 | MOD_INIT_DECL( dbus$_compat ); | ||
| 3801 | MOD_INIT_DECL( dbus$_dbus ); | ||
| 3802 | MOD_INIT_DECL( dbus$_expat_introspect_parser ); | ||
| 3803 | MOD_INIT_DECL( dbus$bus ); | ||
| 3804 | MOD_INIT_DECL( dbus$connection ); | ||
| 3805 | MOD_INIT_DECL( dbus$exceptions ); | ||
| 3806 | MOD_INIT_DECL( dbus$lowlevel ); | ||
| 3807 | MOD_INIT_DECL( dbus$mainloop ); | ||
| 3808 | MOD_INIT_DECL( dbus$mainloop$glib ); | ||
| 3809 | MOD_INIT_DECL( dbus$proxies ); | ||
| 3810 | MOD_INIT_DECL( dbus$types ); | ||
| 3811 | MOD_INIT_DECL( gi ); | ||
| 3812 | MOD_INIT_DECL( gi$_compat ); | ||
| 3813 | MOD_INIT_DECL( gi$_constants ); | ||
| 3814 | MOD_INIT_DECL( gi$_error ); | ||
| 3815 | MOD_INIT_DECL( gi$_propertyhelper ); | ||
| 3816 | MOD_INIT_DECL( gi$_signalhelper ); | ||
| 3817 | MOD_INIT_DECL( gi$docstring ); | ||
| 3818 | MOD_INIT_DECL( gi$importer ); | ||
| 3819 | MOD_INIT_DECL( gi$module ); | ||
| 3820 | MOD_INIT_DECL( gi$overrides ); | ||
| 3821 | MOD_INIT_DECL( gi$repository ); | ||
| 3822 | MOD_INIT_DECL( gi$types ); | ||
| 3823 | MOD_INIT_DECL( packages ); | ||
| 3824 | MOD_INIT_DECL( packages$syncfile ); | ||
| 3825 | MOD_INIT_DECL( problem ); | ||
| 3826 | MOD_INIT_DECL( problem$config ); | ||
| 3827 | MOD_INIT_DECL( problem$exception ); | ||
| 3828 | MOD_INIT_DECL( problem$proxies ); | ||
| 3829 | MOD_INIT_DECL( problem$tools ); | ||
| 3830 | MOD_INIT_DECL( problem$watch ); | ||
| 3831 | MOD_INIT_DECL( pyanaconda ); | ||
| 3832 | MOD_INIT_DECL( pyanaconda$core ); | ||
| 3833 | MOD_INIT_DECL( pyanaconda$core$i18n ); | ||
| 3834 | MOD_INIT_DECL( pyanaconda$product ); | ||
| 3835 | MOD_INIT_DECL( report ); | ||
| 3836 | MOD_INIT_DECL( report$io ); | ||
| 3837 | MOD_INIT_DECL( report$io$GTKIO ); | ||
| 3838 | MOD_INIT_DECL( report$io$NewtIO ); | ||
| 3839 | MOD_INIT_DECL( report$io$TextIO ); | ||
| 3840 | MOD_INIT_DECL( systemd ); | ||
| 3841 | MOD_INIT_DECL( systemd$journal ); | ||
| 3842 | static struct Nuitka_MetaPathBasedLoaderEntry meta_path_loader_entries[] = | ||
| 3843 | { | ||
| 3844 | { "__main__", MOD_INIT_NAME( __main__ ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3845 | { "_asyncio", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3846 | { "_bisect", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3847 | { "_blake2", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3848 | { "_bz2", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3849 | { "_codecs_cn", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3850 | { "_codecs_hk", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3851 | { "_codecs_iso2022", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3852 | { "_codecs_jp", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3853 | { "_codecs_kr", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3854 | { "_codecs_tw", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3855 | { "_contextvars", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3856 | { "_crypt", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3857 | { "_csv", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3858 | { "_ctypes", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3859 | { "_curses", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3860 | { "_curses_panel", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3861 | { "_datetime", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3862 | { "_dbm", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3863 | { "_dbus_bindings", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3864 | { "_dbus_glib_bindings", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3865 | { "_decimal", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3866 | { "_elementtree", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3867 | { "_gdbm", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3868 | { "_hashlib", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3869 | { "_heapq", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3870 | { "_json", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3871 | { "_lsprof", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3872 | { "_lzma", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3873 | { "_multibytecodec", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3874 | { "_multiprocessing", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3875 | { "_opcode", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3876 | { "_pickle", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3877 | { "_posixsubprocess", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3878 | { "_queue", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3879 | { "_random", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3880 | { "_sha3", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3881 | { "_socket", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3882 | { "_sqlite3", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3883 | { "_ssl", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3884 | { "_struct", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3885 | { "_tkinter", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3886 | { "_uuid", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3887 | { "abrt_exception_handler3", MOD_INIT_NAME( abrt_exception_handler3 ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3888 | { "array", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3889 | { "audioop", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3890 | { "binascii", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3891 | { "collections", NULL, 77832, 46578, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 3892 | { "configparser", NULL, 124410, 45848, NUITKA_BYTECODE_FLAG }, | ||
| 3893 | { "contextlib", NULL, 170258, 19868, NUITKA_BYTECODE_FLAG }, | ||
| 3894 | { "csv", NULL, 190126, 11800, NUITKA_BYTECODE_FLAG }, | ||
| 3895 | { "datetime", NULL, 201926, 57217, NUITKA_BYTECODE_FLAG }, | ||
| 3896 | { "dbus", MOD_INIT_NAME( dbus ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3897 | { "dbus._compat", MOD_INIT_NAME( dbus$_compat ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3898 | { "dbus._dbus", MOD_INIT_NAME( dbus$_dbus ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3899 | { "dbus._expat_introspect_parser", MOD_INIT_NAME( dbus$_expat_introspect_parser ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3900 | { "dbus.bus", MOD_INIT_NAME( dbus$bus ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3901 | { "dbus.connection", MOD_INIT_NAME( dbus$connection ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3902 | { "dbus.exceptions", MOD_INIT_NAME( dbus$exceptions ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3903 | { "dbus.lowlevel", MOD_INIT_NAME( dbus$lowlevel ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3904 | { "dbus.mainloop", MOD_INIT_NAME( dbus$mainloop ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3905 | { "dbus.mainloop.glib", MOD_INIT_NAME( dbus$mainloop$glib ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3906 | { "dbus.proxies", MOD_INIT_NAME( dbus$proxies ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3907 | { "dbus.types", MOD_INIT_NAME( dbus$types ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3908 | { "dummy_threading", NULL, 259143, 1092, NUITKA_BYTECODE_FLAG }, | ||
| 3909 | { "fcntl", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3910 | { "gettext", NULL, 260235, 14136, NUITKA_BYTECODE_FLAG }, | ||
| 3911 | { "gi", MOD_INIT_NAME( gi ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3912 | { "gi._compat", MOD_INIT_NAME( gi$_compat ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3913 | { "gi._constants", MOD_INIT_NAME( gi$_constants ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3914 | { "gi._error", MOD_INIT_NAME( gi$_error ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3915 | { "gi._gi", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3916 | { "gi._propertyhelper", MOD_INIT_NAME( gi$_propertyhelper ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3917 | { "gi._signalhelper", MOD_INIT_NAME( gi$_signalhelper ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3918 | { "gi.docstring", MOD_INIT_NAME( gi$docstring ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3919 | { "gi.importer", MOD_INIT_NAME( gi$importer ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3920 | { "gi.module", MOD_INIT_NAME( gi$module ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3921 | { "gi.overrides", MOD_INIT_NAME( gi$overrides ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3922 | { "gi.repository", MOD_INIT_NAME( gi$repository ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3923 | { "gi.types", MOD_INIT_NAME( gi$types ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3924 | { "grp", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3925 | { "hashlib", NULL, 274371, 6559, NUITKA_BYTECODE_FLAG }, | ||
| 3926 | { "importlib", NULL, 280930, 3700, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 3927 | { "inspect", NULL, 284630, 80000, NUITKA_BYTECODE_FLAG }, | ||
| 3928 | { "io", NULL, 364630, 3377, NUITKA_BYTECODE_FLAG }, | ||
| 3929 | { "logging", NULL, 368007, 62526, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 3930 | { "math", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3931 | { "mmap", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3932 | { "os", NULL, 430533, 29661, NUITKA_BYTECODE_FLAG }, | ||
| 3933 | { "packages", MOD_INIT_NAME( packages ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3934 | { "packages.syncfile", MOD_INIT_NAME( packages$syncfile ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3935 | { "pkgutil", NULL, 460194, 16328, NUITKA_BYTECODE_FLAG }, | ||
| 3936 | { "posixpath", NULL, 476522, 10398, NUITKA_BYTECODE_FLAG }, | ||
| 3937 | { "problem", MOD_INIT_NAME( problem ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3938 | { "problem._py3abrt", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3939 | { "problem.config", MOD_INIT_NAME( problem$config ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3940 | { "problem.exception", MOD_INIT_NAME( problem$exception ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3941 | { "problem.proxies", MOD_INIT_NAME( problem$proxies ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3942 | { "problem.tools", MOD_INIT_NAME( problem$tools ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3943 | { "problem.watch", MOD_INIT_NAME( problem$watch ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3944 | { "pyanaconda", MOD_INIT_NAME( pyanaconda ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3945 | { "pyanaconda.core", MOD_INIT_NAME( pyanaconda$core ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3946 | { "pyanaconda.core.i18n", MOD_INIT_NAME( pyanaconda$core$i18n ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3947 | { "pyanaconda.product", MOD_INIT_NAME( pyanaconda$product ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3948 | { "pyexpat", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3949 | { "re", NULL, 486920, 13772, NUITKA_BYTECODE_FLAG }, | ||
| 3950 | { "readline", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3951 | { "report", MOD_INIT_NAME( report ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3952 | { "report._py3report", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3953 | { "report.io", MOD_INIT_NAME( report$io ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3954 | { "report.io.GTKIO", MOD_INIT_NAME( report$io$GTKIO ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3955 | { "report.io.NewtIO", MOD_INIT_NAME( report$io$NewtIO ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3956 | { "report.io.TextIO", MOD_INIT_NAME( report$io$TextIO ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3957 | { "select", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3958 | { "site", NULL, 500692, 13406, NUITKA_BYTECODE_FLAG }, | ||
| 3959 | { "socket", NULL, 514098, 21989, NUITKA_BYTECODE_FLAG }, | ||
| 3960 | { "syslog", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3961 | { "systemd", MOD_INIT_NAME( systemd ), 0, 0, NUITKA_PACKAGE_FLAG }, | ||
| 3962 | { "systemd._journal", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3963 | { "systemd._reader", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3964 | { "systemd.id128", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3965 | { "systemd.journal", MOD_INIT_NAME( systemd$journal ), 0, 0, NUITKA_COMPILED_MODULE }, | ||
| 3966 | { "termios", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3967 | { "threading", NULL, 536087, 37303, NUITKA_BYTECODE_FLAG }, | ||
| 3968 | { "tkinter", NULL, 573390, 179143, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 3969 | { "tkinter.filedialog", NULL, 752533, 12238, NUITKA_BYTECODE_FLAG }, | ||
| 3970 | { "traceback", NULL, 764771, 19591, NUITKA_BYTECODE_FLAG }, | ||
| 3971 | { "types", NULL, 784362, 8942, NUITKA_BYTECODE_FLAG }, | ||
| 3972 | { "unicodedata", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3973 | { "uuid", NULL, 793304, 23167, NUITKA_BYTECODE_FLAG }, | ||
| 3974 | { "warnings", NULL, 816471, 13917, NUITKA_BYTECODE_FLAG }, | ||
| 3975 | { "weakref", NULL, 830388, 19078, NUITKA_BYTECODE_FLAG }, | ||
| 3976 | { "xml", NULL, 849466, 674, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 3977 | { "xml.parsers", NULL, 850140, 287, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 3978 | { "xml.parsers.expat", NULL, 850427, 316, NUITKA_BYTECODE_FLAG }, | ||
| 3979 | { "zlib", NULL, 0, 0, NUITKA_SHLIB_FLAG }, | ||
| 3980 | { "__future__", NULL, 850743, 4100, NUITKA_BYTECODE_FLAG }, | ||
| 3981 | { "_bootlocale", NULL, 854843, 1217, NUITKA_BYTECODE_FLAG }, | ||
| 3982 | { "_compat_pickle", NULL, 856060, 5776, NUITKA_BYTECODE_FLAG }, | ||
| 3983 | { "_dummy_thread", NULL, 861836, 4821, NUITKA_BYTECODE_FLAG }, | ||
| 3984 | { "_markupbase", NULL, 866657, 7753, NUITKA_BYTECODE_FLAG }, | ||
| 3985 | { "_osx_support", NULL, 874410, 9563, NUITKA_BYTECODE_FLAG }, | ||
| 3986 | { "_py_abc", NULL, 883973, 4622, NUITKA_BYTECODE_FLAG }, | ||
| 3987 | { "_pyio", NULL, 888595, 72786, NUITKA_BYTECODE_FLAG }, | ||
| 3988 | { "_sitebuiltins", NULL, 961381, 3433, NUITKA_BYTECODE_FLAG }, | ||
| 3989 | { "_strptime", NULL, 964814, 16072, NUITKA_BYTECODE_FLAG }, | ||
| 3990 | { "_sysconfigdata_dm_linux_x86_64-linux-gnu", NULL, 980886, 23837, NUITKA_BYTECODE_FLAG }, | ||
| 3991 | { "_sysconfigdata_m_linux_x86_64-linux-gnu", NULL, 1004723, 22755, NUITKA_BYTECODE_FLAG }, | ||
| 3992 | { "_threading_local", NULL, 1027478, 6380, NUITKA_BYTECODE_FLAG }, | ||
| 3993 | { "aifc", NULL, 1033858, 26111, NUITKA_BYTECODE_FLAG }, | ||
| 3994 | { "argparse", NULL, 1059969, 61881, NUITKA_BYTECODE_FLAG }, | ||
| 3995 | { "ast", NULL, 1121850, 12048, NUITKA_BYTECODE_FLAG }, | ||
| 3996 | { "asynchat", NULL, 1133898, 6802, NUITKA_BYTECODE_FLAG }, | ||
| 3997 | { "asyncio", NULL, 1140700, 658, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 3998 | { "asyncio.base_events", NULL, 1141358, 48084, NUITKA_BYTECODE_FLAG }, | ||
| 3999 | { "asyncio.base_futures", NULL, 1189442, 2070, NUITKA_BYTECODE_FLAG }, | ||
| 4000 | { "asyncio.base_subprocess", NULL, 1191512, 9159, NUITKA_BYTECODE_FLAG }, | ||
| 4001 | { "asyncio.base_tasks", NULL, 1200671, 1834, NUITKA_BYTECODE_FLAG }, | ||
| 4002 | { "asyncio.constants", NULL, 1202505, 559, NUITKA_BYTECODE_FLAG }, | ||
| 4003 | { "asyncio.coroutines", NULL, 1203064, 6346, NUITKA_BYTECODE_FLAG }, | ||
| 4004 | { "asyncio.events", NULL, 1209410, 27823, NUITKA_BYTECODE_FLAG }, | ||
| 4005 | { "asyncio.format_helpers", NULL, 1237233, 2285, NUITKA_BYTECODE_FLAG }, | ||
| 4006 | { "asyncio.futures", NULL, 1239518, 10713, NUITKA_BYTECODE_FLAG }, | ||
| 4007 | { "asyncio.locks", NULL, 1250231, 15881, NUITKA_BYTECODE_FLAG }, | ||
| 4008 | { "asyncio.log", NULL, 1266112, 208, NUITKA_BYTECODE_FLAG }, | ||
| 4009 | { "asyncio.proactor_events", NULL, 1266320, 19927, NUITKA_BYTECODE_FLAG }, | ||
| 4010 | { "asyncio.protocols", NULL, 1286247, 8696, NUITKA_BYTECODE_FLAG }, | ||
| 4011 | { "asyncio.queues", NULL, 1294943, 8141, NUITKA_BYTECODE_FLAG }, | ||
| 4012 | { "asyncio.runners", NULL, 1303084, 1882, NUITKA_BYTECODE_FLAG }, | ||
| 4013 | { "asyncio.selector_events", NULL, 1304966, 28091, NUITKA_BYTECODE_FLAG }, | ||
| 4014 | { "asyncio.sslproto", NULL, 1333057, 21179, NUITKA_BYTECODE_FLAG }, | ||
| 4015 | { "asyncio.streams", NULL, 1354236, 20256, NUITKA_BYTECODE_FLAG }, | ||
| 4016 | { "asyncio.subprocess", NULL, 1374492, 6720, NUITKA_BYTECODE_FLAG }, | ||
| 4017 | { "asyncio.tasks", NULL, 1381212, 21834, NUITKA_BYTECODE_FLAG }, | ||
| 4018 | { "asyncio.transports", NULL, 1403046, 12179, NUITKA_BYTECODE_FLAG }, | ||
| 4019 | { "asyncio.unix_events", NULL, 1415225, 32074, NUITKA_BYTECODE_FLAG }, | ||
| 4020 | { "asyncore", NULL, 1447299, 15812, NUITKA_BYTECODE_FLAG }, | ||
| 4021 | { "bdb", NULL, 1463111, 24362, NUITKA_BYTECODE_FLAG }, | ||
| 4022 | { "binhex", NULL, 1487473, 12027, NUITKA_BYTECODE_FLAG }, | ||
| 4023 | { "bisect", NULL, 1499500, 2666, NUITKA_BYTECODE_FLAG }, | ||
| 4024 | { "cProfile", NULL, 1502166, 4519, NUITKA_BYTECODE_FLAG }, | ||
| 4025 | { "calendar", NULL, 1506685, 27392, NUITKA_BYTECODE_FLAG }, | ||
| 4026 | { "cgi", NULL, 1534077, 27159, NUITKA_BYTECODE_FLAG }, | ||
| 4027 | { "cgitb", NULL, 1561236, 10080, NUITKA_BYTECODE_FLAG }, | ||
| 4028 | { "chunk", NULL, 1571316, 4887, NUITKA_BYTECODE_FLAG }, | ||
| 4029 | { "cmd", NULL, 1576203, 12558, NUITKA_BYTECODE_FLAG }, | ||
| 4030 | { "code", NULL, 1588761, 9826, NUITKA_BYTECODE_FLAG }, | ||
| 4031 | { "codeop", NULL, 1598587, 6258, NUITKA_BYTECODE_FLAG }, | ||
| 4032 | { "colorsys", NULL, 1604845, 3265, NUITKA_BYTECODE_FLAG }, | ||
| 4033 | { "compileall", NULL, 1608110, 9074, NUITKA_BYTECODE_FLAG }, | ||
| 4034 | { "concurrent", NULL, 1617184, 114, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4035 | { "concurrent.futures", NULL, 1617298, 1054, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4036 | { "concurrent.futures._base", NULL, 1618352, 20851, NUITKA_BYTECODE_FLAG }, | ||
| 4037 | { "concurrent.futures.process", NULL, 1639203, 19529, NUITKA_BYTECODE_FLAG }, | ||
| 4038 | { "concurrent.futures.thread", NULL, 1658732, 5142, NUITKA_BYTECODE_FLAG }, | ||
| 4039 | { "configparser", NULL, 124410, 45848, NUITKA_BYTECODE_FLAG }, | ||
| 4040 | { "contextlib", NULL, 170258, 19868, NUITKA_BYTECODE_FLAG }, | ||
| 4041 | { "contextvars", NULL, 1663874, 225, NUITKA_BYTECODE_FLAG }, | ||
| 4042 | { "copy", NULL, 1664099, 7069, NUITKA_BYTECODE_FLAG }, | ||
| 4043 | { "crypt", NULL, 1671168, 3102, NUITKA_BYTECODE_FLAG }, | ||
| 4044 | { "csv", NULL, 190126, 11800, NUITKA_BYTECODE_FLAG }, | ||
| 4045 | { "ctypes", NULL, 1674270, 15980, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4046 | { "ctypes._aix", NULL, 1690250, 9791, NUITKA_BYTECODE_FLAG }, | ||
| 4047 | { "ctypes._endian", NULL, 1700041, 1924, NUITKA_BYTECODE_FLAG }, | ||
| 4048 | { "ctypes.macholib", NULL, 1701965, 281, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4049 | { "ctypes.macholib.dyld", NULL, 1702246, 4314, NUITKA_BYTECODE_FLAG }, | ||
| 4050 | { "ctypes.macholib.dylib", NULL, 1706560, 1908, NUITKA_BYTECODE_FLAG }, | ||
| 4051 | { "ctypes.macholib.framework", NULL, 1708468, 2188, NUITKA_BYTECODE_FLAG }, | ||
| 4052 | { "ctypes.util", NULL, 1710656, 7717, NUITKA_BYTECODE_FLAG }, | ||
| 4053 | { "curses", NULL, 1718373, 1763, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4054 | { "curses.ascii", NULL, 1720136, 3871, NUITKA_BYTECODE_FLAG }, | ||
| 4055 | { "curses.has_key", NULL, 1724007, 4235, NUITKA_BYTECODE_FLAG }, | ||
| 4056 | { "curses.panel", NULL, 1728242, 205, NUITKA_BYTECODE_FLAG }, | ||
| 4057 | { "curses.textpad", NULL, 1728447, 5874, NUITKA_BYTECODE_FLAG }, | ||
| 4058 | { "dataclasses", NULL, 1734321, 22455, NUITKA_BYTECODE_FLAG }, | ||
| 4059 | { "datetime", NULL, 201926, 57217, NUITKA_BYTECODE_FLAG }, | ||
| 4060 | { "dbm", NULL, 1756776, 4134, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4061 | { "dbm.dumb", NULL, 1760910, 8368, NUITKA_BYTECODE_FLAG }, | ||
| 4062 | { "dbm.gnu", NULL, 1769278, 185, NUITKA_BYTECODE_FLAG }, | ||
| 4063 | { "dbm.ndbm", NULL, 1769463, 184, NUITKA_BYTECODE_FLAG }, | ||
| 4064 | { "decimal", NULL, 1769647, 162140, NUITKA_BYTECODE_FLAG }, | ||
| 4065 | { "difflib", NULL, 1931787, 59406, NUITKA_BYTECODE_FLAG }, | ||
| 4066 | { "distutils", NULL, 1991193, 366, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4067 | { "distutils.archive_util", NULL, 1991559, 6500, NUITKA_BYTECODE_FLAG }, | ||
| 4068 | { "distutils.bcppcompiler", NULL, 1998059, 6469, NUITKA_BYTECODE_FLAG }, | ||
| 4069 | { "distutils.ccompiler", NULL, 2004528, 33184, NUITKA_BYTECODE_FLAG }, | ||
| 4070 | { "distutils.cmd", NULL, 2037712, 13876, NUITKA_BYTECODE_FLAG }, | ||
| 4071 | { "distutils.command", NULL, 2051588, 523, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4072 | { "distutils.command.bdist", NULL, 2052111, 3622, NUITKA_BYTECODE_FLAG }, | ||
| 4073 | { "distutils.command.bdist_dumb", NULL, 2055733, 3537, NUITKA_BYTECODE_FLAG }, | ||
| 4074 | { "distutils.command.bdist_rpm", NULL, 2059270, 12462, NUITKA_BYTECODE_FLAG }, | ||
| 4075 | { "distutils.command.bdist_wininst", NULL, 2071732, 7998, NUITKA_BYTECODE_FLAG }, | ||
| 4076 | { "distutils.command.build", NULL, 2079730, 3803, NUITKA_BYTECODE_FLAG }, | ||
| 4077 | { "distutils.command.build_clib", NULL, 2083533, 4853, NUITKA_BYTECODE_FLAG }, | ||
| 4078 | { "distutils.command.build_ext", NULL, 2088386, 15731, NUITKA_BYTECODE_FLAG }, | ||
| 4079 | { "distutils.command.build_py", NULL, 2104117, 10359, NUITKA_BYTECODE_FLAG }, | ||
| 4080 | { "distutils.command.build_scripts", NULL, 2114476, 4258, NUITKA_BYTECODE_FLAG }, | ||
| 4081 | { "distutils.command.check", NULL, 2118734, 4778, NUITKA_BYTECODE_FLAG }, | ||
| 4082 | { "distutils.command.clean", NULL, 2123512, 2060, NUITKA_BYTECODE_FLAG }, | ||
| 4083 | { "distutils.command.config", NULL, 2125572, 10164, NUITKA_BYTECODE_FLAG }, | ||
| 4084 | { "distutils.command.install", NULL, 2135736, 13654, NUITKA_BYTECODE_FLAG }, | ||
| 4085 | { "distutils.command.install_data", NULL, 2149390, 2253, NUITKA_BYTECODE_FLAG }, | ||
| 4086 | { "distutils.command.install_egg_info", NULL, 2151643, 2951, NUITKA_BYTECODE_FLAG }, | ||
| 4087 | { "distutils.command.install_headers", NULL, 2154594, 1668, NUITKA_BYTECODE_FLAG }, | ||
| 4088 | { "distutils.command.install_lib", NULL, 2156262, 5046, NUITKA_BYTECODE_FLAG }, | ||
| 4089 | { "distutils.command.install_scripts", NULL, 2161308, 2110, NUITKA_BYTECODE_FLAG }, | ||
| 4090 | { "distutils.command.register", NULL, 2163418, 8445, NUITKA_BYTECODE_FLAG }, | ||
| 4091 | { "distutils.command.sdist", NULL, 2171863, 14476, NUITKA_BYTECODE_FLAG }, | ||
| 4092 | { "distutils.command.upload", NULL, 2186339, 5058, NUITKA_BYTECODE_FLAG }, | ||
| 4093 | { "distutils.config", NULL, 2191397, 3453, NUITKA_BYTECODE_FLAG }, | ||
| 4094 | { "distutils.core", NULL, 2194850, 6578, NUITKA_BYTECODE_FLAG }, | ||
| 4095 | { "distutils.cygwinccompiler", NULL, 2201428, 8496, NUITKA_BYTECODE_FLAG }, | ||
| 4096 | { "distutils.debug", NULL, 2209924, 176, NUITKA_BYTECODE_FLAG }, | ||
| 4097 | { "distutils.dep_util", NULL, 2210100, 2692, NUITKA_BYTECODE_FLAG }, | ||
| 4098 | { "distutils.dir_util", NULL, 2212792, 5786, NUITKA_BYTECODE_FLAG }, | ||
| 4099 | { "distutils.dist", NULL, 2218578, 34407, NUITKA_BYTECODE_FLAG }, | ||
| 4100 | { "distutils.errors", NULL, 2252985, 5462, NUITKA_BYTECODE_FLAG }, | ||
| 4101 | { "distutils.extension", NULL, 2258447, 6873, NUITKA_BYTECODE_FLAG }, | ||
| 4102 | { "distutils.fancy_getopt", NULL, 2265320, 10585, NUITKA_BYTECODE_FLAG }, | ||
| 4103 | { "distutils.file_util", NULL, 2275905, 5871, NUITKA_BYTECODE_FLAG }, | ||
| 4104 | { "distutils.filelist", NULL, 2281776, 9806, NUITKA_BYTECODE_FLAG }, | ||
| 4105 | { "distutils.log", NULL, 2291582, 2287, NUITKA_BYTECODE_FLAG }, | ||
| 4106 | { "distutils.msvccompiler", NULL, 2293869, 14539, NUITKA_BYTECODE_FLAG }, | ||
| 4107 | { "distutils.spawn", NULL, 2308408, 4977, NUITKA_BYTECODE_FLAG }, | ||
| 4108 | { "distutils.sysconfig", NULL, 2313385, 11893, NUITKA_BYTECODE_FLAG }, | ||
| 4109 | { "distutils.text_file", NULL, 2325278, 8413, NUITKA_BYTECODE_FLAG }, | ||
| 4110 | { "distutils.unixccompiler", NULL, 2333691, 6768, NUITKA_BYTECODE_FLAG }, | ||
| 4111 | { "distutils.util", NULL, 2340459, 15023, NUITKA_BYTECODE_FLAG }, | ||
| 4112 | { "distutils.version", NULL, 2355482, 7324, NUITKA_BYTECODE_FLAG }, | ||
| 4113 | { "distutils.versionpredicate", NULL, 2362806, 5071, NUITKA_BYTECODE_FLAG }, | ||
| 4114 | { "doctest", NULL, 2367877, 75578, NUITKA_BYTECODE_FLAG }, | ||
| 4115 | { "dummy_threading", NULL, 259143, 1092, NUITKA_BYTECODE_FLAG }, | ||
| 4116 | { "email", NULL, 2443455, 1659, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4117 | { "email._encoded_words", NULL, 2445114, 5576, NUITKA_BYTECODE_FLAG }, | ||
| 4118 | { "email._header_value_parser", NULL, 2450690, 75598, NUITKA_BYTECODE_FLAG }, | ||
| 4119 | { "email._parseaddr", NULL, 2526288, 12316, NUITKA_BYTECODE_FLAG }, | ||
| 4120 | { "email._policybase", NULL, 2538604, 14818, NUITKA_BYTECODE_FLAG }, | ||
| 4121 | { "email.base64mime", NULL, 2553422, 3203, NUITKA_BYTECODE_FLAG }, | ||
| 4122 | { "email.charset", NULL, 2556625, 11497, NUITKA_BYTECODE_FLAG }, | ||
| 4123 | { "email.contentmanager", NULL, 2568122, 7263, NUITKA_BYTECODE_FLAG }, | ||
| 4124 | { "email.encoders", NULL, 2575385, 1632, NUITKA_BYTECODE_FLAG }, | ||
| 4125 | { "email.errors", NULL, 2577017, 6159, NUITKA_BYTECODE_FLAG }, | ||
| 4126 | { "email.feedparser", NULL, 2583176, 10593, NUITKA_BYTECODE_FLAG }, | ||
| 4127 | { "email.generator", NULL, 2593769, 12468, NUITKA_BYTECODE_FLAG }, | ||
| 4128 | { "email.header", NULL, 2606237, 16348, NUITKA_BYTECODE_FLAG }, | ||
| 4129 | { "email.headerregistry", NULL, 2622585, 21265, NUITKA_BYTECODE_FLAG }, | ||
| 4130 | { "email.iterators", NULL, 2643850, 1900, NUITKA_BYTECODE_FLAG }, | ||
| 4131 | { "email.message", NULL, 2645750, 37908, NUITKA_BYTECODE_FLAG }, | ||
| 4132 | { "email.mime", NULL, 2683658, 114, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4133 | { "email.mime.application", NULL, 2683772, 1425, NUITKA_BYTECODE_FLAG }, | ||
| 4134 | { "email.mime.audio", NULL, 2685197, 2584, NUITKA_BYTECODE_FLAG }, | ||
| 4135 | { "email.mime.base", NULL, 2687781, 1050, NUITKA_BYTECODE_FLAG }, | ||
| 4136 | { "email.mime.image", NULL, 2688831, 1870, NUITKA_BYTECODE_FLAG }, | ||
| 4137 | { "email.mime.message", NULL, 2690701, 1299, NUITKA_BYTECODE_FLAG }, | ||
| 4138 | { "email.mime.multipart", NULL, 2692000, 1521, NUITKA_BYTECODE_FLAG }, | ||
| 4139 | { "email.mime.nonmultipart", NULL, 2693521, 736, NUITKA_BYTECODE_FLAG }, | ||
| 4140 | { "email.mime.text", NULL, 2694257, 1283, NUITKA_BYTECODE_FLAG }, | ||
| 4141 | { "email.parser", NULL, 2695540, 5715, NUITKA_BYTECODE_FLAG }, | ||
| 4142 | { "email.policy", NULL, 2701255, 9608, NUITKA_BYTECODE_FLAG }, | ||
| 4143 | { "email.quoprimime", NULL, 2710863, 7632, NUITKA_BYTECODE_FLAG }, | ||
| 4144 | { "email.utils", NULL, 2718495, 9435, NUITKA_BYTECODE_FLAG }, | ||
| 4145 | { "filecmp", NULL, 2727930, 8275, NUITKA_BYTECODE_FLAG }, | ||
| 4146 | { "fileinput", NULL, 2736205, 13166, NUITKA_BYTECODE_FLAG }, | ||
| 4147 | { "fnmatch", NULL, 2749371, 3305, NUITKA_BYTECODE_FLAG }, | ||
| 4148 | { "formatter", NULL, 2752676, 17521, NUITKA_BYTECODE_FLAG }, | ||
| 4149 | { "fractions", NULL, 2770197, 18396, NUITKA_BYTECODE_FLAG }, | ||
| 4150 | { "ftplib", NULL, 2788593, 28035, NUITKA_BYTECODE_FLAG }, | ||
| 4151 | { "getopt", NULL, 2816628, 6207, NUITKA_BYTECODE_FLAG }, | ||
| 4152 | { "getpass", NULL, 2822835, 4132, NUITKA_BYTECODE_FLAG }, | ||
| 4153 | { "gettext", NULL, 260235, 14136, NUITKA_BYTECODE_FLAG }, | ||
| 4154 | { "glob", NULL, 2826967, 4227, NUITKA_BYTECODE_FLAG }, | ||
| 4155 | { "gzip", NULL, 2831194, 17153, NUITKA_BYTECODE_FLAG }, | ||
| 4156 | { "hashlib", NULL, 274371, 6559, NUITKA_BYTECODE_FLAG }, | ||
| 4157 | { "hmac", NULL, 2848347, 6081, NUITKA_BYTECODE_FLAG }, | ||
| 4158 | { "html", NULL, 2854428, 3365, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4159 | { "html.entities", NULL, 2857793, 50437, NUITKA_BYTECODE_FLAG }, | ||
| 4160 | { "html.parser", NULL, 2908230, 11075, NUITKA_BYTECODE_FLAG }, | ||
| 4161 | { "http", NULL, 2919305, 5890, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4162 | { "http.client", NULL, 2925195, 34016, NUITKA_BYTECODE_FLAG }, | ||
| 4163 | { "http.cookiejar", NULL, 2959211, 53375, NUITKA_BYTECODE_FLAG }, | ||
| 4164 | { "http.cookies", NULL, 3012586, 15212, NUITKA_BYTECODE_FLAG }, | ||
| 4165 | { "http.server", NULL, 3027798, 33335, NUITKA_BYTECODE_FLAG }, | ||
| 4166 | { "imaplib", NULL, 3061133, 41398, NUITKA_BYTECODE_FLAG }, | ||
| 4167 | { "imghdr", NULL, 3102531, 4110, NUITKA_BYTECODE_FLAG }, | ||
| 4168 | { "imp", NULL, 3106641, 9721, NUITKA_BYTECODE_FLAG }, | ||
| 4169 | { "importlib.abc", NULL, 3116362, 13455, NUITKA_BYTECODE_FLAG }, | ||
| 4170 | { "importlib.resources", NULL, 3129817, 8307, NUITKA_BYTECODE_FLAG }, | ||
| 4171 | { "importlib.util", NULL, 3138124, 9324, NUITKA_BYTECODE_FLAG }, | ||
| 4172 | { "ipaddress", NULL, 3147448, 62962, NUITKA_BYTECODE_FLAG }, | ||
| 4173 | { "json", NULL, 3210410, 12306, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4174 | { "json.decoder", NULL, 3222716, 9792, NUITKA_BYTECODE_FLAG }, | ||
| 4175 | { "json.encoder", NULL, 3232508, 11274, NUITKA_BYTECODE_FLAG }, | ||
| 4176 | { "json.scanner", NULL, 3243782, 1964, NUITKA_BYTECODE_FLAG }, | ||
| 4177 | { "json.tool", NULL, 3245746, 1445, NUITKA_BYTECODE_FLAG }, | ||
| 4178 | { "lib2to3", NULL, 3247191, 111, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4179 | { "lib2to3.btm_matcher", NULL, 3247302, 4861, NUITKA_BYTECODE_FLAG }, | ||
| 4180 | { "lib2to3.btm_utils", NULL, 3252163, 6111, NUITKA_BYTECODE_FLAG }, | ||
| 4181 | { "lib2to3.fixer_base", NULL, 3258274, 6203, NUITKA_BYTECODE_FLAG }, | ||
| 4182 | { "lib2to3.fixer_util", NULL, 3264477, 12014, NUITKA_BYTECODE_FLAG }, | ||
| 4183 | { "lib2to3.fixes", NULL, 3276491, 117, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4184 | { "lib2to3.fixes.fix_apply", NULL, 3276608, 1655, NUITKA_BYTECODE_FLAG }, | ||
| 4185 | { "lib2to3.fixes.fix_asserts", NULL, 3278263, 1240, NUITKA_BYTECODE_FLAG }, | ||
| 4186 | { "lib2to3.fixes.fix_basestring", NULL, 3279503, 630, NUITKA_BYTECODE_FLAG }, | ||
| 4187 | { "lib2to3.fixes.fix_buffer", NULL, 3280133, 775, NUITKA_BYTECODE_FLAG }, | ||
| 4188 | { "lib2to3.fixes.fix_dict", NULL, 3280908, 3283, NUITKA_BYTECODE_FLAG }, | ||
| 4189 | { "lib2to3.fixes.fix_except", NULL, 3284191, 2785, NUITKA_BYTECODE_FLAG }, | ||
| 4190 | { "lib2to3.fixes.fix_exec", NULL, 3286976, 1116, NUITKA_BYTECODE_FLAG }, | ||
| 4191 | { "lib2to3.fixes.fix_execfile", NULL, 3288092, 1660, NUITKA_BYTECODE_FLAG }, | ||
| 4192 | { "lib2to3.fixes.fix_exitfunc", NULL, 3289752, 2263, NUITKA_BYTECODE_FLAG }, | ||
| 4193 | { "lib2to3.fixes.fix_filter", NULL, 3292015, 2328, NUITKA_BYTECODE_FLAG }, | ||
| 4194 | { "lib2to3.fixes.fix_funcattrs", NULL, 3294343, 941, NUITKA_BYTECODE_FLAG }, | ||
| 4195 | { "lib2to3.fixes.fix_future", NULL, 3295284, 751, NUITKA_BYTECODE_FLAG }, | ||
| 4196 | { "lib2to3.fixes.fix_getcwdu", NULL, 3296035, 755, NUITKA_BYTECODE_FLAG }, | ||
| 4197 | { "lib2to3.fixes.fix_has_key", NULL, 3296790, 2885, NUITKA_BYTECODE_FLAG }, | ||
| 4198 | { "lib2to3.fixes.fix_idioms", NULL, 3299675, 3870, NUITKA_BYTECODE_FLAG }, | ||
| 4199 | { "lib2to3.fixes.fix_import", NULL, 3303545, 2752, NUITKA_BYTECODE_FLAG }, | ||
| 4200 | { "lib2to3.fixes.fix_imports", NULL, 3306297, 4316, NUITKA_BYTECODE_FLAG }, | ||
| 4201 | { "lib2to3.fixes.fix_imports2", NULL, 3310613, 515, NUITKA_BYTECODE_FLAG }, | ||
| 4202 | { "lib2to3.fixes.fix_input", NULL, 3311128, 917, NUITKA_BYTECODE_FLAG }, | ||
| 4203 | { "lib2to3.fixes.fix_intern", NULL, 3312045, 1124, NUITKA_BYTECODE_FLAG }, | ||
| 4204 | { "lib2to3.fixes.fix_isinstance", NULL, 3313169, 1522, NUITKA_BYTECODE_FLAG }, | ||
| 4205 | { "lib2to3.fixes.fix_itertools", NULL, 3314691, 1511, NUITKA_BYTECODE_FLAG }, | ||
| 4206 | { "lib2to3.fixes.fix_itertools_imports", NULL, 3316202, 1547, NUITKA_BYTECODE_FLAG }, | ||
| 4207 | { "lib2to3.fixes.fix_long", NULL, 3317749, 672, NUITKA_BYTECODE_FLAG }, | ||
| 4208 | { "lib2to3.fixes.fix_map", NULL, 3318421, 3060, NUITKA_BYTECODE_FLAG }, | ||
| 4209 | { "lib2to3.fixes.fix_metaclass", NULL, 3321481, 5313, NUITKA_BYTECODE_FLAG }, | ||
| 4210 | { "lib2to3.fixes.fix_methodattrs", NULL, 3326794, 903, NUITKA_BYTECODE_FLAG }, | ||
| 4211 | { "lib2to3.fixes.fix_ne", NULL, 3327697, 774, NUITKA_BYTECODE_FLAG }, | ||
| 4212 | { "lib2to3.fixes.fix_next", NULL, 3328471, 3027, NUITKA_BYTECODE_FLAG }, | ||
| 4213 | { "lib2to3.fixes.fix_nonzero", NULL, 3331498, 890, NUITKA_BYTECODE_FLAG }, | ||
| 4214 | { "lib2to3.fixes.fix_numliterals", NULL, 3332388, 986, NUITKA_BYTECODE_FLAG }, | ||
| 4215 | { "lib2to3.fixes.fix_operator", NULL, 3333374, 4203, NUITKA_BYTECODE_FLAG }, | ||
| 4216 | { "lib2to3.fixes.fix_paren", NULL, 3337577, 1357, NUITKA_BYTECODE_FLAG }, | ||
| 4217 | { "lib2to3.fixes.fix_print", NULL, 3338934, 2292, NUITKA_BYTECODE_FLAG }, | ||
| 4218 | { "lib2to3.fixes.fix_raise", NULL, 3341226, 2216, NUITKA_BYTECODE_FLAG }, | ||
| 4219 | { "lib2to3.fixes.fix_raw_input", NULL, 3343442, 762, NUITKA_BYTECODE_FLAG }, | ||
| 4220 | { "lib2to3.fixes.fix_reduce", NULL, 3344204, 1097, NUITKA_BYTECODE_FLAG }, | ||
| 4221 | { "lib2to3.fixes.fix_reload", NULL, 3345301, 1136, NUITKA_BYTECODE_FLAG }, | ||
| 4222 | { "lib2to3.fixes.fix_renames", NULL, 3346437, 1960, NUITKA_BYTECODE_FLAG }, | ||
| 4223 | { "lib2to3.fixes.fix_repr", NULL, 3348397, 812, NUITKA_BYTECODE_FLAG }, | ||
| 4224 | { "lib2to3.fixes.fix_set_literal", NULL, 3349209, 1644, NUITKA_BYTECODE_FLAG }, | ||
| 4225 | { "lib2to3.fixes.fix_standarderror", NULL, 3350853, 687, NUITKA_BYTECODE_FLAG }, | ||
| 4226 | { "lib2to3.fixes.fix_sys_exc", NULL, 3351540, 1368, NUITKA_BYTECODE_FLAG }, | ||
| 4227 | { "lib2to3.fixes.fix_throw", NULL, 3352908, 1769, NUITKA_BYTECODE_FLAG }, | ||
| 4228 | { "lib2to3.fixes.fix_tuple_params", NULL, 3354677, 4563, NUITKA_BYTECODE_FLAG }, | ||
| 4229 | { "lib2to3.fixes.fix_types", NULL, 3359240, 1796, NUITKA_BYTECODE_FLAG }, | ||
| 4230 | { "lib2to3.fixes.fix_unicode", NULL, 3361036, 1508, NUITKA_BYTECODE_FLAG }, | ||
| 4231 | { "lib2to3.fixes.fix_urllib", NULL, 3362544, 5928, NUITKA_BYTECODE_FLAG }, | ||
| 4232 | { "lib2to3.fixes.fix_ws_comma", NULL, 3368472, 1090, NUITKA_BYTECODE_FLAG }, | ||
| 4233 | { "lib2to3.fixes.fix_xrange", NULL, 3369562, 2503, NUITKA_BYTECODE_FLAG }, | ||
| 4234 | { "lib2to3.fixes.fix_xreadlines", NULL, 3372065, 1084, NUITKA_BYTECODE_FLAG }, | ||
| 4235 | { "lib2to3.fixes.fix_zip", NULL, 3373149, 1548, NUITKA_BYTECODE_FLAG }, | ||
| 4236 | { "lib2to3.main", NULL, 3374697, 8504, NUITKA_BYTECODE_FLAG }, | ||
| 4237 | { "lib2to3.patcomp", NULL, 3383201, 5579, NUITKA_BYTECODE_FLAG }, | ||
| 4238 | { "lib2to3.pgen2", NULL, 3388780, 147, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4239 | { "lib2to3.pgen2.driver", NULL, 3388927, 5108, NUITKA_BYTECODE_FLAG }, | ||
| 4240 | { "lib2to3.pgen2.grammar", NULL, 3394035, 6984, NUITKA_BYTECODE_FLAG }, | ||
| 4241 | { "lib2to3.pgen2.literals", NULL, 3401019, 1526, NUITKA_BYTECODE_FLAG }, | ||
| 4242 | { "lib2to3.pgen2.parse", NULL, 3402545, 6272, NUITKA_BYTECODE_FLAG }, | ||
| 4243 | { "lib2to3.pgen2.pgen", NULL, 3408817, 9748, NUITKA_BYTECODE_FLAG }, | ||
| 4244 | { "lib2to3.pgen2.token", NULL, 3418565, 1840, NUITKA_BYTECODE_FLAG }, | ||
| 4245 | { "lib2to3.pgen2.tokenize", NULL, 3420405, 15108, NUITKA_BYTECODE_FLAG }, | ||
| 4246 | { "lib2to3.pygram", NULL, 3435513, 1166, NUITKA_BYTECODE_FLAG }, | ||
| 4247 | { "lib2to3.pytree", NULL, 3436679, 24971, NUITKA_BYTECODE_FLAG }, | ||
| 4248 | { "lib2to3.refactor", NULL, 3461650, 20372, NUITKA_BYTECODE_FLAG }, | ||
| 4249 | { "logging", NULL, 368007, 62526, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4250 | { "logging.config", NULL, 3482022, 22983, NUITKA_BYTECODE_FLAG }, | ||
| 4251 | { "logging.handlers", NULL, 3505005, 42951, NUITKA_BYTECODE_FLAG }, | ||
| 4252 | { "lzma", NULL, 3547956, 11907, NUITKA_BYTECODE_FLAG }, | ||
| 4253 | { "macpath", NULL, 3559863, 5775, NUITKA_BYTECODE_FLAG }, | ||
| 4254 | { "mailbox", NULL, 3565638, 63616, NUITKA_BYTECODE_FLAG }, | ||
| 4255 | { "mailcap", NULL, 3629254, 6452, NUITKA_BYTECODE_FLAG }, | ||
| 4256 | { "mimetypes", NULL, 3635706, 15446, NUITKA_BYTECODE_FLAG }, | ||
| 4257 | { "modulefinder", NULL, 3651152, 15320, NUITKA_BYTECODE_FLAG }, | ||
| 4258 | { "multiprocessing", NULL, 3666472, 495, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4259 | { "multiprocessing.connection", NULL, 3666967, 24900, NUITKA_BYTECODE_FLAG }, | ||
| 4260 | { "multiprocessing.context", NULL, 3691867, 13081, NUITKA_BYTECODE_FLAG }, | ||
| 4261 | { "multiprocessing.dummy", NULL, 3704948, 3773, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4262 | { "multiprocessing.dummy.connection", NULL, 3708721, 2481, NUITKA_BYTECODE_FLAG }, | ||
| 4263 | { "multiprocessing.forkserver", NULL, 3711202, 7732, NUITKA_BYTECODE_FLAG }, | ||
| 4264 | { "multiprocessing.heap", NULL, 3718934, 6392, NUITKA_BYTECODE_FLAG }, | ||
| 4265 | { "multiprocessing.managers", NULL, 3725326, 33981, NUITKA_BYTECODE_FLAG }, | ||
| 4266 | { "multiprocessing.pool", NULL, 3759307, 21204, NUITKA_BYTECODE_FLAG }, | ||
| 4267 | { "multiprocessing.popen_fork", NULL, 3780511, 2494, NUITKA_BYTECODE_FLAG }, | ||
| 4268 | { "multiprocessing.popen_forkserver", NULL, 3783005, 2327, NUITKA_BYTECODE_FLAG }, | ||
| 4269 | { "multiprocessing.popen_spawn_posix", NULL, 3785332, 2109, NUITKA_BYTECODE_FLAG }, | ||
| 4270 | { "multiprocessing.process", NULL, 3787441, 9394, NUITKA_BYTECODE_FLAG }, | ||
| 4271 | { "multiprocessing.queues", NULL, 3796835, 9405, NUITKA_BYTECODE_FLAG }, | ||
| 4272 | { "multiprocessing.reduction", NULL, 3806240, 7986, NUITKA_BYTECODE_FLAG }, | ||
| 4273 | { "multiprocessing.resource_sharer", NULL, 3814226, 5171, NUITKA_BYTECODE_FLAG }, | ||
| 4274 | { "multiprocessing.semaphore_tracker", NULL, 3819397, 3708, NUITKA_BYTECODE_FLAG }, | ||
| 4275 | { "multiprocessing.sharedctypes", NULL, 3823105, 6885, NUITKA_BYTECODE_FLAG }, | ||
| 4276 | { "multiprocessing.spawn", NULL, 3829990, 6446, NUITKA_BYTECODE_FLAG }, | ||
| 4277 | { "multiprocessing.synchronize", NULL, 3836436, 11151, NUITKA_BYTECODE_FLAG }, | ||
| 4278 | { "multiprocessing.util", NULL, 3847587, 9915, NUITKA_BYTECODE_FLAG }, | ||
| 4279 | { "netrc", NULL, 3857502, 3731, NUITKA_BYTECODE_FLAG }, | ||
| 4280 | { "nntplib", NULL, 3861233, 33719, NUITKA_BYTECODE_FLAG }, | ||
| 4281 | { "ntpath", NULL, 3894952, 12972, NUITKA_BYTECODE_FLAG }, | ||
| 4282 | { "nturl2path", NULL, 3907924, 1583, NUITKA_BYTECODE_FLAG }, | ||
| 4283 | { "numbers", NULL, 3909507, 12160, NUITKA_BYTECODE_FLAG }, | ||
| 4284 | { "optparse", NULL, 3921667, 47861, NUITKA_BYTECODE_FLAG }, | ||
| 4285 | { "pathlib", NULL, 3969528, 41431, NUITKA_BYTECODE_FLAG }, | ||
| 4286 | { "pdb", NULL, 4010959, 46730, NUITKA_BYTECODE_FLAG }, | ||
| 4287 | { "pickle", NULL, 4057689, 42934, NUITKA_BYTECODE_FLAG }, | ||
| 4288 | { "pickletools", NULL, 4100623, 65299, NUITKA_BYTECODE_FLAG }, | ||
| 4289 | { "pipes", NULL, 4165922, 7771, NUITKA_BYTECODE_FLAG }, | ||
| 4290 | { "pkgutil", NULL, 460194, 16328, NUITKA_BYTECODE_FLAG }, | ||
| 4291 | { "platform", NULL, 4173693, 28188, NUITKA_BYTECODE_FLAG }, | ||
| 4292 | { "plistlib", NULL, 4201881, 25063, NUITKA_BYTECODE_FLAG }, | ||
| 4293 | { "poplib", NULL, 4226944, 13304, NUITKA_BYTECODE_FLAG }, | ||
| 4294 | { "pprint", NULL, 4240248, 15787, NUITKA_BYTECODE_FLAG }, | ||
| 4295 | { "profile", NULL, 4256035, 13809, NUITKA_BYTECODE_FLAG }, | ||
| 4296 | { "pstats", NULL, 4269844, 22262, NUITKA_BYTECODE_FLAG }, | ||
| 4297 | { "pty", NULL, 4292106, 3851, NUITKA_BYTECODE_FLAG }, | ||
| 4298 | { "py_compile", NULL, 4295957, 7159, NUITKA_BYTECODE_FLAG }, | ||
| 4299 | { "pyclbr", NULL, 4303116, 10341, NUITKA_BYTECODE_FLAG }, | ||
| 4300 | { "pydoc", NULL, 4313457, 84388, NUITKA_BYTECODE_FLAG }, | ||
| 4301 | { "pydoc_data", NULL, 4397845, 114, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4302 | { "pydoc_data.topics", NULL, 4397959, 411302, NUITKA_BYTECODE_FLAG }, | ||
| 4303 | { "queue", NULL, 4809261, 11440, NUITKA_BYTECODE_FLAG }, | ||
| 4304 | { "random", NULL, 4820701, 19362, NUITKA_BYTECODE_FLAG }, | ||
| 4305 | { "rlcompleter", NULL, 4840063, 5715, NUITKA_BYTECODE_FLAG }, | ||
| 4306 | { "runpy", NULL, 4845778, 7913, NUITKA_BYTECODE_FLAG }, | ||
| 4307 | { "sched", NULL, 4853691, 6489, NUITKA_BYTECODE_FLAG }, | ||
| 4308 | { "secrets", NULL, 4860180, 2152, NUITKA_BYTECODE_FLAG }, | ||
| 4309 | { "selectors", NULL, 4862332, 16916, NUITKA_BYTECODE_FLAG }, | ||
| 4310 | { "shelve", NULL, 4879248, 9474, NUITKA_BYTECODE_FLAG }, | ||
| 4311 | { "shlex", NULL, 4888722, 6958, NUITKA_BYTECODE_FLAG }, | ||
| 4312 | { "shutil", NULL, 4895680, 30832, NUITKA_BYTECODE_FLAG }, | ||
| 4313 | { "signal", NULL, 4926512, 2480, NUITKA_BYTECODE_FLAG }, | ||
| 4314 | { "site", NULL, 500692, 13406, NUITKA_BYTECODE_FLAG }, | ||
| 4315 | { "smtpd", NULL, 4928992, 26572, NUITKA_BYTECODE_FLAG }, | ||
| 4316 | { "smtplib", NULL, 4955564, 35318, NUITKA_BYTECODE_FLAG }, | ||
| 4317 | { "sndhdr", NULL, 4990882, 6871, NUITKA_BYTECODE_FLAG }, | ||
| 4318 | { "socket", NULL, 514098, 21989, NUITKA_BYTECODE_FLAG }, | ||
| 4319 | { "socketserver", NULL, 4997753, 24166, NUITKA_BYTECODE_FLAG }, | ||
| 4320 | { "sqlite3", NULL, 5021919, 142, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4321 | { "sqlite3.dbapi2", NULL, 5022061, 2461, NUITKA_BYTECODE_FLAG }, | ||
| 4322 | { "sqlite3.dump", NULL, 5024522, 1904, NUITKA_BYTECODE_FLAG }, | ||
| 4323 | { "ssl", NULL, 5026426, 39739, NUITKA_BYTECODE_FLAG }, | ||
| 4324 | { "statistics", NULL, 5066165, 18132, NUITKA_BYTECODE_FLAG }, | ||
| 4325 | { "string", NULL, 5084297, 7803, NUITKA_BYTECODE_FLAG }, | ||
| 4326 | { "subprocess", NULL, 5092100, 38733, NUITKA_BYTECODE_FLAG }, | ||
| 4327 | { "sunau", NULL, 5130833, 17179, NUITKA_BYTECODE_FLAG }, | ||
| 4328 | { "symbol", NULL, 5148012, 2533, NUITKA_BYTECODE_FLAG }, | ||
| 4329 | { "symtable", NULL, 5150545, 10413, NUITKA_BYTECODE_FLAG }, | ||
| 4330 | { "sysconfig", NULL, 5160958, 15338, NUITKA_BYTECODE_FLAG }, | ||
| 4331 | { "tabnanny", NULL, 5176296, 6946, NUITKA_BYTECODE_FLAG }, | ||
| 4332 | { "tarfile", NULL, 5183242, 61809, NUITKA_BYTECODE_FLAG }, | ||
| 4333 | { "telnetlib", NULL, 5245051, 18070, NUITKA_BYTECODE_FLAG }, | ||
| 4334 | { "tempfile", NULL, 5263121, 22113, NUITKA_BYTECODE_FLAG }, | ||
| 4335 | { "textwrap", NULL, 5285234, 13580, NUITKA_BYTECODE_FLAG }, | ||
| 4336 | { "this", NULL, 5298814, 1245, NUITKA_BYTECODE_FLAG }, | ||
| 4337 | { "timeit", NULL, 5300059, 11615, NUITKA_BYTECODE_FLAG }, | ||
| 4338 | { "tkinter", NULL, 573390, 179143, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4339 | { "tkinter.colorchooser", NULL, 5311674, 1103, NUITKA_BYTECODE_FLAG }, | ||
| 4340 | { "tkinter.commondialog", NULL, 5312777, 1084, NUITKA_BYTECODE_FLAG }, | ||
| 4341 | { "tkinter.constants", NULL, 5313861, 1636, NUITKA_BYTECODE_FLAG }, | ||
| 4342 | { "tkinter.dialog", NULL, 5315497, 1412, NUITKA_BYTECODE_FLAG }, | ||
| 4343 | { "tkinter.dnd", NULL, 5316909, 11154, NUITKA_BYTECODE_FLAG }, | ||
| 4344 | { "tkinter.filedialog", NULL, 752533, 12238, NUITKA_BYTECODE_FLAG }, | ||
| 4345 | { "tkinter.font", NULL, 5328063, 6155, NUITKA_BYTECODE_FLAG }, | ||
| 4346 | { "tkinter.messagebox", NULL, 5334218, 3020, NUITKA_BYTECODE_FLAG }, | ||
| 4347 | { "tkinter.scrolledtext", NULL, 5337238, 2147, NUITKA_BYTECODE_FLAG }, | ||
| 4348 | { "tkinter.simpledialog", NULL, 5339385, 10514, NUITKA_BYTECODE_FLAG }, | ||
| 4349 | { "tkinter.tix", NULL, 5349899, 83634, NUITKA_BYTECODE_FLAG }, | ||
| 4350 | { "tkinter.ttk", NULL, 5433533, 57818, NUITKA_BYTECODE_FLAG }, | ||
| 4351 | { "trace", NULL, 5491351, 19115, NUITKA_BYTECODE_FLAG }, | ||
| 4352 | { "tracemalloc", NULL, 5510466, 17244, NUITKA_BYTECODE_FLAG }, | ||
| 4353 | { "tty", NULL, 5527710, 1062, NUITKA_BYTECODE_FLAG }, | ||
| 4354 | { "turtle", NULL, 5528772, 130759, NUITKA_BYTECODE_FLAG }, | ||
| 4355 | { "typing", NULL, 5659531, 49926, NUITKA_BYTECODE_FLAG }, | ||
| 4356 | { "unittest", NULL, 5709457, 3005, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4357 | { "unittest.case", NULL, 5712462, 48522, NUITKA_BYTECODE_FLAG }, | ||
| 4358 | { "unittest.loader", NULL, 5760984, 14237, NUITKA_BYTECODE_FLAG }, | ||
| 4359 | { "unittest.main", NULL, 5775221, 7406, NUITKA_BYTECODE_FLAG }, | ||
| 4360 | { "unittest.mock", NULL, 5782627, 63022, NUITKA_BYTECODE_FLAG }, | ||
| 4361 | { "unittest.result", NULL, 5845649, 7220, NUITKA_BYTECODE_FLAG }, | ||
| 4362 | { "unittest.runner", NULL, 5852869, 6949, NUITKA_BYTECODE_FLAG }, | ||
| 4363 | { "unittest.signals", NULL, 5859818, 2162, NUITKA_BYTECODE_FLAG }, | ||
| 4364 | { "unittest.suite", NULL, 5861980, 9171, NUITKA_BYTECODE_FLAG }, | ||
| 4365 | { "unittest.util", NULL, 5871151, 4489, NUITKA_BYTECODE_FLAG }, | ||
| 4366 | { "urllib", NULL, 5875640, 110, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4367 | { "urllib.error", NULL, 5875750, 2744, NUITKA_BYTECODE_FLAG }, | ||
| 4368 | { "urllib.parse", NULL, 5878494, 30398, NUITKA_BYTECODE_FLAG }, | ||
| 4369 | { "urllib.request", NULL, 5908892, 72272, NUITKA_BYTECODE_FLAG }, | ||
| 4370 | { "urllib.response", NULL, 5981164, 3217, NUITKA_BYTECODE_FLAG }, | ||
| 4371 | { "urllib.robotparser", NULL, 5984381, 7029, NUITKA_BYTECODE_FLAG }, | ||
| 4372 | { "uu", NULL, 5991410, 3581, NUITKA_BYTECODE_FLAG }, | ||
| 4373 | { "uuid", NULL, 793304, 23167, NUITKA_BYTECODE_FLAG }, | ||
| 4374 | { "venv", NULL, 5994991, 13090, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4375 | { "wave", NULL, 6008081, 18256, NUITKA_BYTECODE_FLAG }, | ||
| 4376 | { "weakref", NULL, 830388, 19078, NUITKA_BYTECODE_FLAG }, | ||
| 4377 | { "webbrowser", NULL, 6026337, 16342, NUITKA_BYTECODE_FLAG }, | ||
| 4378 | { "wsgiref", NULL, 6042679, 706, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4379 | { "wsgiref.handlers", NULL, 6043385, 16115, NUITKA_BYTECODE_FLAG }, | ||
| 4380 | { "wsgiref.headers", NULL, 6059500, 7727, NUITKA_BYTECODE_FLAG }, | ||
| 4381 | { "wsgiref.simple_server", NULL, 6067227, 5173, NUITKA_BYTECODE_FLAG }, | ||
| 4382 | { "wsgiref.util", NULL, 6072400, 5148, NUITKA_BYTECODE_FLAG }, | ||
| 4383 | { "wsgiref.validate", NULL, 6077548, 14644, NUITKA_BYTECODE_FLAG }, | ||
| 4384 | { "xdrlib", NULL, 6092192, 8292, NUITKA_BYTECODE_FLAG }, | ||
| 4385 | { "xml", NULL, 849466, 674, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4386 | { "xml.dom", NULL, 6100484, 5426, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4387 | { "xml.dom.NodeFilter", NULL, 6105910, 941, NUITKA_BYTECODE_FLAG }, | ||
| 4388 | { "xml.dom.domreg", NULL, 6106851, 2818, NUITKA_BYTECODE_FLAG }, | ||
| 4389 | { "xml.dom.expatbuilder", NULL, 6109669, 26988, NUITKA_BYTECODE_FLAG }, | ||
| 4390 | { "xml.dom.minicompat", NULL, 6136657, 2787, NUITKA_BYTECODE_FLAG }, | ||
| 4391 | { "xml.dom.minidom", NULL, 6139444, 55587, NUITKA_BYTECODE_FLAG }, | ||
| 4392 | { "xml.dom.pulldom", NULL, 6195031, 10460, NUITKA_BYTECODE_FLAG }, | ||
| 4393 | { "xml.dom.xmlbuilder", NULL, 6205491, 12407, NUITKA_BYTECODE_FLAG }, | ||
| 4394 | { "xml.etree", NULL, 6217898, 113, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4395 | { "xml.etree.ElementInclude", NULL, 6218011, 1549, NUITKA_BYTECODE_FLAG }, | ||
| 4396 | { "xml.etree.ElementPath", NULL, 6219560, 6317, NUITKA_BYTECODE_FLAG }, | ||
| 4397 | { "xml.etree.ElementTree", NULL, 6225877, 44781, NUITKA_BYTECODE_FLAG }, | ||
| 4398 | { "xml.etree.cElementTree", NULL, 6270658, 155, NUITKA_BYTECODE_FLAG }, | ||
| 4399 | { "xml.parsers", NULL, 850140, 287, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4400 | { "xml.parsers.expat", NULL, 850427, 316, NUITKA_BYTECODE_FLAG }, | ||
| 4401 | { "xml.sax", NULL, 6270813, 3146, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4402 | { "xml.sax._exceptions", NULL, 6273959, 5455, NUITKA_BYTECODE_FLAG }, | ||
| 4403 | { "xml.sax.expatreader", NULL, 6279414, 12358, NUITKA_BYTECODE_FLAG }, | ||
| 4404 | { "xml.sax.handler", NULL, 6291772, 12331, NUITKA_BYTECODE_FLAG }, | ||
| 4405 | { "xml.sax.saxutils", NULL, 6304103, 12784, NUITKA_BYTECODE_FLAG }, | ||
| 4406 | { "xml.sax.xmlreader", NULL, 6316887, 16892, NUITKA_BYTECODE_FLAG }, | ||
| 4407 | { "xmlrpc", NULL, 6333779, 110, NUITKA_BYTECODE_FLAG | NUITKA_PACKAGE_FLAG }, | ||
| 4408 | { "xmlrpc.client", NULL, 6333889, 34516, NUITKA_BYTECODE_FLAG }, | ||
| 4409 | { "xmlrpc.server", NULL, 6368405, 29358, NUITKA_BYTECODE_FLAG }, | ||
| 4410 | { "zipapp", NULL, 6397763, 5771, NUITKA_BYTECODE_FLAG }, | ||
| 4411 | { "zipfile", NULL, 6403534, 49840, NUITKA_BYTECODE_FLAG }, | ||
| 4412 | { NULL, NULL, 0, 0, 0 } | ||
| 4413 | }; | ||
| 4414 | |||
| 4415 | void setupMetaPathBasedLoader( void ) | ||
| 4416 | { | ||
| 4417 | static bool init_done = false; | ||
| 4418 | |||
| 4419 | if ( init_done == false ) | ||
| 4420 | { | ||
| 4421 | registerMetaPathBasedUnfreezer( meta_path_loader_entries ); | ||
| 4422 | init_done = true; | ||
| 4423 | } | ||
| 4424 | } | ||
| File Linux_Version/inventory_synchronisation.build/__helpers.h deleted (index 8f8c453..0000000) | |||
| 1 | #ifndef __NUITKA_CALLS_H__ | ||
| 2 | #define __NUITKA_CALLS_H__ | ||
| 3 | |||
| 4 | extern PyObject *CALL_FUNCTION_WITH_ARGS1( PyObject *called, PyObject **args ); | ||
| 5 | extern PyObject *CALL_FUNCTION_WITH_ARGS2( PyObject *called, PyObject **args ); | ||
| 6 | extern PyObject *CALL_FUNCTION_WITH_ARGS3( PyObject *called, PyObject **args ); | ||
| 7 | extern PyObject *CALL_FUNCTION_WITH_ARGS4( PyObject *called, PyObject **args ); | ||
| 8 | extern PyObject *CALL_FUNCTION_WITH_ARGS5( PyObject *called, PyObject **args ); | ||
| 9 | extern PyObject *CALL_FUNCTION_WITH_ARGS6( PyObject *called, PyObject **args ); | ||
| 10 | extern PyObject *CALL_FUNCTION_WITH_ARGS8( PyObject *called, PyObject **args ); | ||
| 11 | extern PyObject *CALL_METHOD_WITH_ARGS1( PyObject *source, PyObject *attr_name, PyObject **args ); | ||
| 12 | extern PyObject *CALL_METHOD_WITH_ARGS2( PyObject *source, PyObject *attr_name, PyObject **args ); | ||
| 13 | extern PyObject *CALL_METHOD_WITH_ARGS3( PyObject *source, PyObject *attr_name, PyObject **args ); | ||
| 14 | extern PyObject *CALL_METHOD_WITH_ARGS4( PyObject *source, PyObject *attr_name, PyObject **args ); | ||
| 15 | #endif | ||
| File Linux_Version/inventory_synchronisation.build/__helpers.o deleted (index fbedf80..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/__internal__.c is too big (5147 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/__internal__.o deleted (index e448fba..0000000) |
| File Linux_Version/inventory_synchronisation.build/build_definitions.h deleted (index e69de29..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.__main__.c is too big (7320 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.__main__.o deleted (index 6da3312..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.abrt_exception_handler3.c is too big (7301 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.abrt_exception_handler3.o deleted (index 3a08aeb..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.dbus._compat.c deleted (index bd0667e..0000000) | |||
| 1 | /* Generated code for Python module 'dbus._compat' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_dbus$_compat" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_dbus$_compat; | ||
| 31 | PyDictObject *moduledict_dbus$_compat; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain___file__; | ||
| 35 | extern PyObject *const_str_plain_is_py3; | ||
| 36 | static PyObject *const_str_plain_major; | ||
| 37 | extern PyObject *const_str_plain_origin; | ||
| 38 | extern PyObject *const_str_plain_version_info; | ||
| 39 | extern PyObject *const_str_digest_3aa5bee4de9b0149ae46ffed8a38c6b4; | ||
| 40 | extern PyObject *const_str_plain___spec__; | ||
| 41 | extern PyObject *const_int_0; | ||
| 42 | extern PyObject *const_str_plain_sys; | ||
| 43 | extern PyObject *const_str_plain_is_py2; | ||
| 44 | static PyObject *const_str_digest_8ef93c92c5f75aac441373814f070057; | ||
| 45 | static PyObject *const_str_digest_d8149cec598d6e8431a7f48a34231c2d; | ||
| 46 | extern PyObject *const_int_pos_3; | ||
| 47 | extern PyObject *const_str_plain___doc__; | ||
| 48 | extern PyObject *const_str_plain___cached__; | ||
| 49 | extern PyObject *const_tuple_empty; | ||
| 50 | extern PyObject *const_str_plain_has_location; | ||
| 51 | static PyObject *module_filename_obj; | ||
| 52 | |||
| 53 | /* Indicator if this modules private constants were created yet. */ | ||
| 54 | static bool constants_created = false; | ||
| 55 | |||
| 56 | /* Function to create module private constants. */ | ||
| 57 | static void createModuleConstants( void ) | ||
| 58 | { | ||
| 59 | const_str_plain_major = UNSTREAM_STRING_ASCII( &constant_bin[ 3874 ], 5, 1 ); | ||
| 60 | const_str_digest_8ef93c92c5f75aac441373814f070057 = UNSTREAM_STRING_ASCII( &constant_bin[ 3879 ], 21, 0 ); | ||
| 61 | const_str_digest_d8149cec598d6e8431a7f48a34231c2d = UNSTREAM_STRING_ASCII( &constant_bin[ 3900 ], 15, 0 ); | ||
| 62 | |||
| 63 | constants_created = true; | ||
| 64 | } | ||
| 65 | |||
| 66 | /* Function to verify module private constants for non-corruption. */ | ||
| 67 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 68 | void checkModuleConstants_dbus$_compat( void ) | ||
| 69 | { | ||
| 70 | // The module may not have been used at all, then ignore this. | ||
| 71 | if (constants_created == false) return; | ||
| 72 | |||
| 73 | |||
| 74 | } | ||
| 75 | #endif | ||
| 76 | |||
| 77 | // The module code objects. | ||
| 78 | static PyCodeObject *codeobj_65ee25e6d530c4d4bd4bd2f7c7c8e6b5; | ||
| 79 | |||
| 80 | static void createModuleCodeObjects(void) | ||
| 81 | { | ||
| 82 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_d8149cec598d6e8431a7f48a34231c2d ); | ||
| 83 | codeobj_65ee25e6d530c4d4bd4bd2f7c7c8e6b5 = MAKE_CODEOBJ( module_filename_obj, const_str_digest_8ef93c92c5f75aac441373814f070057, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 84 | } | ||
| 85 | |||
| 86 | // The module function declarations. | ||
| 87 | |||
| 88 | |||
| 89 | // The module function definitions. | ||
| 90 | |||
| 91 | |||
| 92 | |||
| 93 | #if PYTHON_VERSION >= 300 | ||
| 94 | static struct PyModuleDef mdef_dbus$_compat = | ||
| 95 | { | ||
| 96 | PyModuleDef_HEAD_INIT, | ||
| 97 | "dbus._compat", | ||
| 98 | NULL, /* m_doc */ | ||
| 99 | -1, /* m_size */ | ||
| 100 | NULL, /* m_methods */ | ||
| 101 | NULL, /* m_reload */ | ||
| 102 | NULL, /* m_traverse */ | ||
| 103 | NULL, /* m_clear */ | ||
| 104 | NULL, /* m_free */ | ||
| 105 | }; | ||
| 106 | #endif | ||
| 107 | |||
| 108 | extern PyObject *const_str_plain___compiled__; | ||
| 109 | |||
| 110 | extern PyObject *const_str_plain___package__; | ||
| 111 | |||
| 112 | #if PYTHON_VERSION >= 300 | ||
| 113 | extern PyObject *const_str_dot; | ||
| 114 | extern PyObject *const_str_plain___loader__; | ||
| 115 | #endif | ||
| 116 | |||
| 117 | #if PYTHON_VERSION >= 340 | ||
| 118 | extern PyObject *const_str_plain___spec__; | ||
| 119 | extern PyObject *const_str_plain__initializing; | ||
| 120 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 121 | #endif | ||
| 122 | |||
| 123 | extern void _initCompiledCellType(); | ||
| 124 | extern void _initCompiledGeneratorType(); | ||
| 125 | extern void _initCompiledFunctionType(); | ||
| 126 | extern void _initCompiledMethodType(); | ||
| 127 | extern void _initCompiledFrameType(); | ||
| 128 | #if PYTHON_VERSION >= 350 | ||
| 129 | extern void _initCompiledCoroutineTypes(); | ||
| 130 | #endif | ||
| 131 | #if PYTHON_VERSION >= 360 | ||
| 132 | extern void _initCompiledAsyncgenTypes(); | ||
| 133 | #endif | ||
| 134 | |||
| 135 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 136 | |||
| 137 | // The exported interface to CPython. On import of the module, this function | ||
| 138 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 139 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 140 | |||
| 141 | MOD_INIT_DECL( dbus$_compat ) | ||
| 142 | { | ||
| 143 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 144 | static bool _init_done = false; | ||
| 145 | |||
| 146 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 147 | if ( _init_done ) | ||
| 148 | { | ||
| 149 | return MOD_RETURN_VALUE( module_dbus$_compat ); | ||
| 150 | } | ||
| 151 | else | ||
| 152 | { | ||
| 153 | _init_done = true; | ||
| 154 | } | ||
| 155 | #endif | ||
| 156 | |||
| 157 | #ifdef _NUITKA_MODULE | ||
| 158 | // In case of a stand alone extension module, need to call initialization | ||
| 159 | // the init here because that's the first and only time we are going to get | ||
| 160 | // called here. | ||
| 161 | |||
| 162 | // Initialize the constant values used. | ||
| 163 | _initBuiltinModule(); | ||
| 164 | createGlobalConstants(); | ||
| 165 | |||
| 166 | /* Initialize the compiled types of Nuitka. */ | ||
| 167 | _initCompiledCellType(); | ||
| 168 | _initCompiledGeneratorType(); | ||
| 169 | _initCompiledFunctionType(); | ||
| 170 | _initCompiledMethodType(); | ||
| 171 | _initCompiledFrameType(); | ||
| 172 | #if PYTHON_VERSION >= 350 | ||
| 173 | _initCompiledCoroutineTypes(); | ||
| 174 | #endif | ||
| 175 | #if PYTHON_VERSION >= 360 | ||
| 176 | _initCompiledAsyncgenTypes(); | ||
| 177 | #endif | ||
| 178 | |||
| 179 | #if PYTHON_VERSION < 300 | ||
| 180 | _initSlotCompare(); | ||
| 181 | #endif | ||
| 182 | #if PYTHON_VERSION >= 270 | ||
| 183 | _initSlotIternext(); | ||
| 184 | #endif | ||
| 185 | |||
| 186 | patchBuiltinModule(); | ||
| 187 | patchTypeComparison(); | ||
| 188 | |||
| 189 | // Enable meta path based loader if not already done. | ||
| 190 | #ifdef _NUITKA_TRACE | ||
| 191 | puts("dbus._compat: Calling setupMetaPathBasedLoader()."); | ||
| 192 | #endif | ||
| 193 | setupMetaPathBasedLoader(); | ||
| 194 | |||
| 195 | #if PYTHON_VERSION >= 300 | ||
| 196 | patchInspectModule(); | ||
| 197 | #endif | ||
| 198 | |||
| 199 | #endif | ||
| 200 | |||
| 201 | /* The constants only used by this module are created now. */ | ||
| 202 | #ifdef _NUITKA_TRACE | ||
| 203 | puts("dbus._compat: Calling createModuleConstants()."); | ||
| 204 | #endif | ||
| 205 | createModuleConstants(); | ||
| 206 | |||
| 207 | /* The code objects used by this module are created now. */ | ||
| 208 | #ifdef _NUITKA_TRACE | ||
| 209 | puts("dbus._compat: Calling createModuleCodeObjects()."); | ||
| 210 | #endif | ||
| 211 | createModuleCodeObjects(); | ||
| 212 | |||
| 213 | // puts( "in initdbus$_compat" ); | ||
| 214 | |||
| 215 | // Create the module object first. There are no methods initially, all are | ||
| 216 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 217 | // set at this time, as it could not contain NUL characters this way, they | ||
| 218 | // are instead set in early module code. No "self" for modules, we have no | ||
| 219 | // use for it. | ||
| 220 | #if PYTHON_VERSION < 300 | ||
| 221 | module_dbus$_compat = Py_InitModule4( | ||
| 222 | "dbus._compat", // Module Name | ||
| 223 | NULL, // No methods initially, all are added | ||
| 224 | // dynamically in actual module code only. | ||
| 225 | NULL, // No "__doc__" is initially set, as it could | ||
| 226 | // not contain NUL this way, added early in | ||
| 227 | // actual code. | ||
| 228 | NULL, // No self for modules, we don't use it. | ||
| 229 | PYTHON_API_VERSION | ||
| 230 | ); | ||
| 231 | #else | ||
| 232 | |||
| 233 | module_dbus$_compat = PyModule_Create( &mdef_dbus$_compat ); | ||
| 234 | #endif | ||
| 235 | |||
| 236 | moduledict_dbus$_compat = MODULE_DICT( module_dbus$_compat ); | ||
| 237 | |||
| 238 | // Set __compiled__ to what it we know. | ||
| 239 | UPDATE_STRING_DICT1( | ||
| 240 | moduledict_dbus$_compat, | ||
| 241 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 242 | Nuitka_dunder_compiled_value | ||
| 243 | ); | ||
| 244 | |||
| 245 | // Update "__package__" value to what it ought to be. | ||
| 246 | { | ||
| 247 | #if 0 | ||
| 248 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 249 | |||
| 250 | UPDATE_STRING_DICT1( | ||
| 251 | moduledict_dbus$_compat, | ||
| 252 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 253 | module_name | ||
| 254 | ); | ||
| 255 | #else | ||
| 256 | |||
| 257 | #if PYTHON_VERSION < 300 | ||
| 258 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 259 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 260 | |||
| 261 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 262 | |||
| 263 | if ( last_dot != NULL ) | ||
| 264 | { | ||
| 265 | UPDATE_STRING_DICT1( | ||
| 266 | moduledict_dbus$_compat, | ||
| 267 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 268 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 269 | ); | ||
| 270 | } | ||
| 271 | #else | ||
| 272 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 273 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 274 | |||
| 275 | if ( dot_index != -1 ) | ||
| 276 | { | ||
| 277 | UPDATE_STRING_DICT1( | ||
| 278 | moduledict_dbus$_compat, | ||
| 279 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 280 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 281 | ); | ||
| 282 | } | ||
| 283 | #endif | ||
| 284 | #endif | ||
| 285 | } | ||
| 286 | |||
| 287 | CHECK_OBJECT( module_dbus$_compat ); | ||
| 288 | |||
| 289 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 290 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 291 | #if PYTHON_VERSION >= 300 | ||
| 292 | { | ||
| 293 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_3aa5bee4de9b0149ae46ffed8a38c6b4, module_dbus$_compat ); | ||
| 294 | |||
| 295 | assert( r != -1 ); | ||
| 296 | } | ||
| 297 | #endif | ||
| 298 | |||
| 299 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 300 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 301 | // before the frame object is allocated, or else it may fail. | ||
| 302 | |||
| 303 | if ( GET_STRING_DICT_VALUE( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 304 | { | ||
| 305 | PyObject *value = (PyObject *)builtin_module; | ||
| 306 | |||
| 307 | // Check if main module, not a dict then but the module itself. | ||
| 308 | #if !defined(_NUITKA_EXE) || !0 | ||
| 309 | value = PyModule_GetDict( value ); | ||
| 310 | #endif | ||
| 311 | |||
| 312 | UPDATE_STRING_DICT0( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 313 | } | ||
| 314 | |||
| 315 | #if PYTHON_VERSION >= 300 | ||
| 316 | UPDATE_STRING_DICT0( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 317 | #endif | ||
| 318 | |||
| 319 | #if PYTHON_VERSION >= 340 | ||
| 320 | // Set the "__spec__" value | ||
| 321 | |||
| 322 | #if 0 | ||
| 323 | // Main modules just get "None" as spec. | ||
| 324 | UPDATE_STRING_DICT0( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 325 | #else | ||
| 326 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 327 | { | ||
| 328 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 329 | CHECK_OBJECT( bootstrap_module ); | ||
| 330 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 331 | Py_DECREF( bootstrap_module ); | ||
| 332 | |||
| 333 | PyObject *args[] = { | ||
| 334 | GET_STRING_DICT_VALUE( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 335 | (PyObject *)&Nuitka_Loader_Type | ||
| 336 | }; | ||
| 337 | |||
| 338 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 339 | module_spec_class, | ||
| 340 | args | ||
| 341 | ); | ||
| 342 | Py_DECREF( module_spec_class ); | ||
| 343 | |||
| 344 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 345 | CHECK_OBJECT( spec_value ); | ||
| 346 | |||
| 347 | // For packages set the submodule search locations as well, even if to empty | ||
| 348 | // list, so investigating code will consider it a package. | ||
| 349 | #if 0 | ||
| 350 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 351 | #endif | ||
| 352 | |||
| 353 | // Mark the execution in the "__spec__" value. | ||
| 354 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 355 | |||
| 356 | UPDATE_STRING_DICT1( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 357 | } | ||
| 358 | #endif | ||
| 359 | #endif | ||
| 360 | |||
| 361 | // Temp variables if any | ||
| 362 | struct Nuitka_FrameObject *frame_65ee25e6d530c4d4bd4bd2f7c7c8e6b5; | ||
| 363 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 364 | bool tmp_result; | ||
| 365 | PyObject *exception_type = NULL; | ||
| 366 | PyObject *exception_value = NULL; | ||
| 367 | PyTracebackObject *exception_tb = NULL; | ||
| 368 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 369 | int tmp_res; | ||
| 370 | |||
| 371 | // Module code. | ||
| 372 | { | ||
| 373 | PyObject *tmp_assign_source_1; | ||
| 374 | tmp_assign_source_1 = Py_None; | ||
| 375 | UPDATE_STRING_DICT0( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 376 | } | ||
| 377 | { | ||
| 378 | PyObject *tmp_assign_source_2; | ||
| 379 | tmp_assign_source_2 = module_filename_obj; | ||
| 380 | UPDATE_STRING_DICT0( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 381 | } | ||
| 382 | // Frame without reuse. | ||
| 383 | frame_65ee25e6d530c4d4bd4bd2f7c7c8e6b5 = MAKE_MODULE_FRAME( codeobj_65ee25e6d530c4d4bd4bd2f7c7c8e6b5, module_dbus$_compat ); | ||
| 384 | |||
| 385 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 386 | // owning it. | ||
| 387 | pushFrameStack( frame_65ee25e6d530c4d4bd4bd2f7c7c8e6b5 ); | ||
| 388 | assert( Py_REFCNT( frame_65ee25e6d530c4d4bd4bd2f7c7c8e6b5 ) == 2 ); | ||
| 389 | |||
| 390 | // Framed code: | ||
| 391 | { | ||
| 392 | PyObject *tmp_assattr_name_1; | ||
| 393 | PyObject *tmp_assattr_target_1; | ||
| 394 | PyObject *tmp_mvar_value_1; | ||
| 395 | tmp_assattr_name_1 = module_filename_obj; | ||
| 396 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 397 | |||
| 398 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 399 | { | ||
| 400 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 401 | } | ||
| 402 | |||
| 403 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 404 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 405 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 406 | if ( tmp_result == false ) | ||
| 407 | { | ||
| 408 | assert( ERROR_OCCURRED() ); | ||
| 409 | |||
| 410 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 411 | |||
| 412 | |||
| 413 | exception_lineno = 1; | ||
| 414 | |||
| 415 | goto frame_exception_exit_1; | ||
| 416 | } | ||
| 417 | } | ||
| 418 | { | ||
| 419 | PyObject *tmp_assattr_name_2; | ||
| 420 | PyObject *tmp_assattr_target_2; | ||
| 421 | PyObject *tmp_mvar_value_2; | ||
| 422 | tmp_assattr_name_2 = Py_True; | ||
| 423 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 424 | |||
| 425 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 426 | { | ||
| 427 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 428 | } | ||
| 429 | |||
| 430 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 431 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 432 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 433 | if ( tmp_result == false ) | ||
| 434 | { | ||
| 435 | assert( ERROR_OCCURRED() ); | ||
| 436 | |||
| 437 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 438 | |||
| 439 | |||
| 440 | exception_lineno = 1; | ||
| 441 | |||
| 442 | goto frame_exception_exit_1; | ||
| 443 | } | ||
| 444 | } | ||
| 445 | { | ||
| 446 | PyObject *tmp_assign_source_3; | ||
| 447 | tmp_assign_source_3 = Py_None; | ||
| 448 | UPDATE_STRING_DICT0( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 449 | } | ||
| 450 | { | ||
| 451 | PyObject *tmp_assign_source_4; | ||
| 452 | PyObject *tmp_name_name_1; | ||
| 453 | PyObject *tmp_globals_name_1; | ||
| 454 | PyObject *tmp_locals_name_1; | ||
| 455 | PyObject *tmp_fromlist_name_1; | ||
| 456 | PyObject *tmp_level_name_1; | ||
| 457 | tmp_name_name_1 = const_str_plain_sys; | ||
| 458 | tmp_globals_name_1 = (PyObject *)moduledict_dbus$_compat; | ||
| 459 | tmp_locals_name_1 = Py_None; | ||
| 460 | tmp_fromlist_name_1 = Py_None; | ||
| 461 | tmp_level_name_1 = const_int_0; | ||
| 462 | frame_65ee25e6d530c4d4bd4bd2f7c7c8e6b5->m_frame.f_lineno = 3; | ||
| 463 | tmp_assign_source_4 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 464 | assert( !(tmp_assign_source_4 == NULL) ); | ||
| 465 | UPDATE_STRING_DICT1( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain_sys, tmp_assign_source_4 ); | ||
| 466 | } | ||
| 467 | { | ||
| 468 | PyObject *tmp_assign_source_5; | ||
| 469 | PyObject *tmp_compexpr_left_1; | ||
| 470 | PyObject *tmp_compexpr_right_1; | ||
| 471 | PyObject *tmp_source_name_1; | ||
| 472 | PyObject *tmp_source_name_2; | ||
| 473 | PyObject *tmp_mvar_value_3; | ||
| 474 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain_sys ); | ||
| 475 | |||
| 476 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 477 | { | ||
| 478 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_sys ); | ||
| 479 | } | ||
| 480 | |||
| 481 | CHECK_OBJECT( tmp_mvar_value_3 ); | ||
| 482 | tmp_source_name_2 = tmp_mvar_value_3; | ||
| 483 | tmp_source_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_version_info ); | ||
| 484 | if ( tmp_source_name_1 == NULL ) | ||
| 485 | { | ||
| 486 | assert( ERROR_OCCURRED() ); | ||
| 487 | |||
| 488 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 489 | |||
| 490 | |||
| 491 | exception_lineno = 5; | ||
| 492 | |||
| 493 | goto frame_exception_exit_1; | ||
| 494 | } | ||
| 495 | tmp_compexpr_left_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_major ); | ||
| 496 | Py_DECREF( tmp_source_name_1 ); | ||
| 497 | if ( tmp_compexpr_left_1 == NULL ) | ||
| 498 | { | ||
| 499 | assert( ERROR_OCCURRED() ); | ||
| 500 | |||
| 501 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 502 | |||
| 503 | |||
| 504 | exception_lineno = 5; | ||
| 505 | |||
| 506 | goto frame_exception_exit_1; | ||
| 507 | } | ||
| 508 | tmp_compexpr_right_1 = const_int_pos_3; | ||
| 509 | tmp_assign_source_5 = RICH_COMPARE_EQ_OBJECT_OBJECT_NORECURSE( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 510 | Py_DECREF( tmp_compexpr_left_1 ); | ||
| 511 | if ( tmp_assign_source_5 == NULL ) | ||
| 512 | { | ||
| 513 | assert( ERROR_OCCURRED() ); | ||
| 514 | |||
| 515 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 516 | |||
| 517 | |||
| 518 | exception_lineno = 5; | ||
| 519 | |||
| 520 | goto frame_exception_exit_1; | ||
| 521 | } | ||
| 522 | UPDATE_STRING_DICT1( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain_is_py3, tmp_assign_source_5 ); | ||
| 523 | } | ||
| 524 | { | ||
| 525 | PyObject *tmp_assign_source_6; | ||
| 526 | PyObject *tmp_operand_name_1; | ||
| 527 | PyObject *tmp_mvar_value_4; | ||
| 528 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain_is_py3 ); | ||
| 529 | |||
| 530 | if (unlikely( tmp_mvar_value_4 == NULL )) | ||
| 531 | { | ||
| 532 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_is_py3 ); | ||
| 533 | } | ||
| 534 | |||
| 535 | CHECK_OBJECT( tmp_mvar_value_4 ); | ||
| 536 | tmp_operand_name_1 = tmp_mvar_value_4; | ||
| 537 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 538 | if ( tmp_res == -1 ) | ||
| 539 | { | ||
| 540 | assert( ERROR_OCCURRED() ); | ||
| 541 | |||
| 542 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 543 | |||
| 544 | |||
| 545 | exception_lineno = 6; | ||
| 546 | |||
| 547 | goto frame_exception_exit_1; | ||
| 548 | } | ||
| 549 | tmp_assign_source_6 = ( tmp_res == 0 ) ? Py_True : Py_False; | ||
| 550 | UPDATE_STRING_DICT0( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain_is_py2, tmp_assign_source_6 ); | ||
| 551 | } | ||
| 552 | |||
| 553 | // Restore frame exception if necessary. | ||
| 554 | #if 0 | ||
| 555 | RESTORE_FRAME_EXCEPTION( frame_65ee25e6d530c4d4bd4bd2f7c7c8e6b5 ); | ||
| 556 | #endif | ||
| 557 | popFrameStack(); | ||
| 558 | |||
| 559 | assertFrameObject( frame_65ee25e6d530c4d4bd4bd2f7c7c8e6b5 ); | ||
| 560 | |||
| 561 | goto frame_no_exception_1; | ||
| 562 | |||
| 563 | frame_exception_exit_1:; | ||
| 564 | #if 0 | ||
| 565 | RESTORE_FRAME_EXCEPTION( frame_65ee25e6d530c4d4bd4bd2f7c7c8e6b5 ); | ||
| 566 | #endif | ||
| 567 | |||
| 568 | if ( exception_tb == NULL ) | ||
| 569 | { | ||
| 570 | exception_tb = MAKE_TRACEBACK( frame_65ee25e6d530c4d4bd4bd2f7c7c8e6b5, exception_lineno ); | ||
| 571 | } | ||
| 572 | else if ( exception_tb->tb_frame != &frame_65ee25e6d530c4d4bd4bd2f7c7c8e6b5->m_frame ) | ||
| 573 | { | ||
| 574 | exception_tb = ADD_TRACEBACK( exception_tb, frame_65ee25e6d530c4d4bd4bd2f7c7c8e6b5, exception_lineno ); | ||
| 575 | } | ||
| 576 | |||
| 577 | // Put the previous frame back on top. | ||
| 578 | popFrameStack(); | ||
| 579 | |||
| 580 | // Return the error. | ||
| 581 | goto module_exception_exit; | ||
| 582 | |||
| 583 | frame_no_exception_1:; | ||
| 584 | |||
| 585 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 586 | #if 0 && 0 | ||
| 587 | { | ||
| 588 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_dbus$_compat, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 589 | |||
| 590 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 591 | { | ||
| 592 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 593 | |||
| 594 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 595 | CHECK_OBJECT( path_importer_cache ); | ||
| 596 | |||
| 597 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 598 | assert( res == 0 ); | ||
| 599 | } | ||
| 600 | } | ||
| 601 | #endif | ||
| 602 | #endif | ||
| 603 | |||
| 604 | return MOD_RETURN_VALUE( module_dbus$_compat ); | ||
| 605 | module_exception_exit: | ||
| 606 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 607 | return MOD_RETURN_VALUE( NULL ); | ||
| 608 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.dbus._compat.o deleted (index e3336da..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.dbus._dbus.c is too big (8759 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.dbus._dbus.o deleted (index ec19261..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.dbus._expat_introspect_parser.c deleted (index 55a7357..0000000) | |||
| 1 | /* Generated code for Python module 'dbus._expat_introspect_parser' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_dbus$_expat_introspect_parser" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_dbus$_expat_introspect_parser; | ||
| 31 | PyDictObject *moduledict_dbus$_expat_introspect_parser; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | static PyObject *const_str_digest_4ced22b65a2ea3042260a0ce3d5ed36c; | ||
| 35 | static PyObject *const_tuple_92ddbf2d41688100fa7fa4af74cc5357_tuple; | ||
| 36 | extern PyObject *const_str_plain_metaclass; | ||
| 37 | extern PyObject *const_str_plain___spec__; | ||
| 38 | extern PyObject *const_str_plain___name__; | ||
| 39 | extern PyObject *const_tuple_str_plain___class___tuple; | ||
| 40 | extern PyObject *const_str_angle_metaclass; | ||
| 41 | extern PyObject *const_str_plain_object; | ||
| 42 | extern PyObject *const_str_plain___file__; | ||
| 43 | extern PyObject *const_str_plain_arg; | ||
| 44 | static PyObject *const_str_digest_9aafd5147413fd54ddfc2afb0d6e3081; | ||
| 45 | static PyObject *const_str_plain_buffer_text; | ||
| 46 | static PyObject *const_tuple_str_plain_data_str_plain_e_tuple; | ||
| 47 | static PyObject *const_str_digest_5c6cab9b128e97656eac49f6d79bcb14; | ||
| 48 | static PyObject *const_str_digest_3f318ff1b6f012cbecede2926bf2b070; | ||
| 49 | static PyObject *const_tuple_str_plain_self_str_plain_data_str_plain_parser_tuple; | ||
| 50 | extern PyObject *const_str_digest_b0cc034d9177fde48a3b44ac122139d9; | ||
| 51 | extern PyObject *const_str_plain_interface; | ||
| 52 | extern PyObject *const_str_plain___doc__; | ||
| 53 | extern PyObject *const_str_dot; | ||
| 54 | static PyObject *const_str_plain_in_iface; | ||
| 55 | extern PyObject *const_str_plain___orig_bases__; | ||
| 56 | extern PyObject *const_str_plain_data; | ||
| 57 | static PyObject *const_str_plain_Parse; | ||
| 58 | extern PyObject *const_str_plain___qualname__; | ||
| 59 | static PyObject *const_str_plain__Parser; | ||
| 60 | static PyObject *const_str_plain_direction; | ||
| 61 | static PyObject *const_str_plain_in; | ||
| 62 | extern PyObject *const_tuple_str_plain_self_tuple; | ||
| 63 | extern PyObject *const_str_plain_e; | ||
| 64 | static PyObject *const_tuple_str_plain_self_str_plain_name_str_plain_attributes_tuple; | ||
| 65 | extern PyObject *const_tuple_empty; | ||
| 66 | extern PyObject *const_str_space; | ||
| 67 | static PyObject *const_str_digest_d7908dd66617c9f5e7c68a06d1603722; | ||
| 68 | extern PyObject *const_str_plain_name; | ||
| 69 | static PyObject *const_str_plain_StartElementHandler; | ||
| 70 | static PyObject *const_str_plain_in_method; | ||
| 71 | static PyObject *const_str_plain_parser; | ||
| 72 | extern PyObject *const_str_plain_map; | ||
| 73 | extern PyObject *const_str_plain_process_introspection_data; | ||
| 74 | extern PyObject *const_str_plain___getitem__; | ||
| 75 | static PyObject *const_tuple_str_digest_d80d8945c1075596a484c18b20ab6235_str_space_tuple; | ||
| 76 | static PyObject *const_tuple_str_plain_direction_str_plain_in_tuple; | ||
| 77 | static PyObject *const_str_plain_EndElementHandler; | ||
| 78 | extern PyObject *const_str_plain_IntrospectionParserException; | ||
| 79 | static PyObject *const_str_digest_9e791634659cef76ab4e135031893f31; | ||
| 80 | extern PyObject *const_int_0; | ||
| 81 | static PyObject *const_str_digest_d80d8945c1075596a484c18b20ab6235; | ||
| 82 | static PyObject *const_str_plain_sig; | ||
| 83 | extern PyObject *const_str_plain___slots__; | ||
| 84 | static PyObject *const_str_digest_98664ef00f574ec08b1cfc4be9e5a5de; | ||
| 85 | extern PyObject *const_str_plain_origin; | ||
| 86 | extern PyObject *const_tuple_str_plain_self_str_plain_name_tuple; | ||
| 87 | extern PyObject *const_str_digest_286d73d90a388265c9abc0d24ef29c6f; | ||
| 88 | extern PyObject *const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 89 | extern PyObject *const_str_plain_type; | ||
| 90 | static PyObject *const_tuple_str_plain_IntrospectionParserException_tuple; | ||
| 91 | static PyObject *const_str_digest_29704eec445aa0f422f31f45e9aa157f; | ||
| 92 | extern PyObject *const_str_plain___cached__; | ||
| 93 | extern PyObject *const_str_plain___class__; | ||
| 94 | extern PyObject *const_tuple_type_object_tuple; | ||
| 95 | extern PyObject *const_str_plain___module__; | ||
| 96 | static PyObject *const_str_plain_ParserCreate; | ||
| 97 | extern PyObject *const_str_plain___prepare__; | ||
| 98 | extern PyObject *const_str_plain___init__; | ||
| 99 | static PyObject *const_str_plain_parse; | ||
| 100 | extern PyObject *const_str_plain_self; | ||
| 101 | extern PyObject *const_str_plain_method; | ||
| 102 | extern PyObject *const_str_plain_get; | ||
| 103 | extern PyObject *const_str_plain_has_location; | ||
| 104 | extern PyObject *const_str_digest_e48610c30fffad33f2054d9dca0792b3; | ||
| 105 | static PyObject *const_str_plain_attributes; | ||
| 106 | extern PyObject *const_str_empty; | ||
| 107 | static PyObject *const_tuple_str_plain_ParserCreate_tuple; | ||
| 108 | static PyObject *module_filename_obj; | ||
| 109 | |||
| 110 | /* Indicator if this modules private constants were created yet. */ | ||
| 111 | static bool constants_created = false; | ||
| 112 | |||
| 113 | /* Function to create module private constants. */ | ||
| 114 | static void createModuleConstants( void ) | ||
| 115 | { | ||
| 116 | const_str_digest_4ced22b65a2ea3042260a0ce3d5ed36c = UNSTREAM_STRING_ASCII( &constant_bin[ 7960 ], 32, 0 ); | ||
| 117 | const_tuple_92ddbf2d41688100fa7fa4af74cc5357_tuple = PyTuple_New( 4 ); | ||
| 118 | PyTuple_SET_ITEM( const_tuple_92ddbf2d41688100fa7fa4af74cc5357_tuple, 0, const_str_plain_map ); Py_INCREF( const_str_plain_map ); | ||
| 119 | const_str_plain_in_iface = UNSTREAM_STRING_ASCII( &constant_bin[ 7992 ], 8, 1 ); | ||
| 120 | PyTuple_SET_ITEM( const_tuple_92ddbf2d41688100fa7fa4af74cc5357_tuple, 1, const_str_plain_in_iface ); Py_INCREF( const_str_plain_in_iface ); | ||
| 121 | const_str_plain_in_method = UNSTREAM_STRING_ASCII( &constant_bin[ 8000 ], 9, 1 ); | ||
| 122 | PyTuple_SET_ITEM( const_tuple_92ddbf2d41688100fa7fa4af74cc5357_tuple, 2, const_str_plain_in_method ); Py_INCREF( const_str_plain_in_method ); | ||
| 123 | const_str_plain_sig = UNSTREAM_STRING_ASCII( &constant_bin[ 8009 ], 3, 1 ); | ||
| 124 | PyTuple_SET_ITEM( const_tuple_92ddbf2d41688100fa7fa4af74cc5357_tuple, 3, const_str_plain_sig ); Py_INCREF( const_str_plain_sig ); | ||
| 125 | const_str_digest_9aafd5147413fd54ddfc2afb0d6e3081 = UNSTREAM_STRING_ASCII( &constant_bin[ 8012 ], 13, 0 ); | ||
| 126 | const_str_plain_buffer_text = UNSTREAM_STRING_ASCII( &constant_bin[ 8025 ], 11, 1 ); | ||
| 127 | const_tuple_str_plain_data_str_plain_e_tuple = PyTuple_New( 2 ); | ||
| 128 | PyTuple_SET_ITEM( const_tuple_str_plain_data_str_plain_e_tuple, 0, const_str_plain_data ); Py_INCREF( const_str_plain_data ); | ||
| 129 | PyTuple_SET_ITEM( const_tuple_str_plain_data_str_plain_e_tuple, 1, const_str_plain_e ); Py_INCREF( const_str_plain_e ); | ||
| 130 | const_str_digest_5c6cab9b128e97656eac49f6d79bcb14 = UNSTREAM_STRING_ASCII( &constant_bin[ 8036 ], 38, 0 ); | ||
| 131 | const_str_digest_3f318ff1b6f012cbecede2926bf2b070 = UNSTREAM_STRING_ASCII( &constant_bin[ 8074 ], 479, 0 ); | ||
| 132 | const_tuple_str_plain_self_str_plain_data_str_plain_parser_tuple = PyTuple_New( 3 ); | ||
| 133 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_data_str_plain_parser_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 134 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_data_str_plain_parser_tuple, 1, const_str_plain_data ); Py_INCREF( const_str_plain_data ); | ||
| 135 | const_str_plain_parser = UNSTREAM_STRING_ASCII( &constant_bin[ 7983 ], 6, 1 ); | ||
| 136 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_data_str_plain_parser_tuple, 2, const_str_plain_parser ); Py_INCREF( const_str_plain_parser ); | ||
| 137 | const_str_plain_Parse = UNSTREAM_STRING_ASCII( &constant_bin[ 3785 ], 5, 1 ); | ||
| 138 | const_str_plain__Parser = UNSTREAM_STRING_ASCII( &constant_bin[ 8012 ], 7, 1 ); | ||
| 139 | const_str_plain_direction = UNSTREAM_STRING_ASCII( &constant_bin[ 8553 ], 9, 1 ); | ||
| 140 | const_str_plain_in = UNSTREAM_STRING_ASCII( &constant_bin[ 29 ], 2, 1 ); | ||
| 141 | const_tuple_str_plain_self_str_plain_name_str_plain_attributes_tuple = PyTuple_New( 3 ); | ||
| 142 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_name_str_plain_attributes_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 143 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_name_str_plain_attributes_tuple, 1, const_str_plain_name ); Py_INCREF( const_str_plain_name ); | ||
| 144 | const_str_plain_attributes = UNSTREAM_STRING_ASCII( &constant_bin[ 8562 ], 10, 1 ); | ||
| 145 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_name_str_plain_attributes_tuple, 2, const_str_plain_attributes ); Py_INCREF( const_str_plain_attributes ); | ||
| 146 | const_str_digest_d7908dd66617c9f5e7c68a06d1603722 = UNSTREAM_STRING_ASCII( &constant_bin[ 8572 ], 17, 0 ); | ||
| 147 | const_str_plain_StartElementHandler = UNSTREAM_STRING_ASCII( &constant_bin[ 8589 ], 19, 1 ); | ||
| 148 | const_tuple_str_digest_d80d8945c1075596a484c18b20ab6235_str_space_tuple = PyTuple_New( 2 ); | ||
| 149 | const_str_digest_d80d8945c1075596a484c18b20ab6235 = UNSTREAM_STRING_ASCII( &constant_bin[ 8542 ], 5, 0 ); | ||
| 150 | PyTuple_SET_ITEM( const_tuple_str_digest_d80d8945c1075596a484c18b20ab6235_str_space_tuple, 0, const_str_digest_d80d8945c1075596a484c18b20ab6235 ); Py_INCREF( const_str_digest_d80d8945c1075596a484c18b20ab6235 ); | ||
| 151 | PyTuple_SET_ITEM( const_tuple_str_digest_d80d8945c1075596a484c18b20ab6235_str_space_tuple, 1, const_str_space ); Py_INCREF( const_str_space ); | ||
| 152 | const_tuple_str_plain_direction_str_plain_in_tuple = PyTuple_New( 2 ); | ||
| 153 | PyTuple_SET_ITEM( const_tuple_str_plain_direction_str_plain_in_tuple, 0, const_str_plain_direction ); Py_INCREF( const_str_plain_direction ); | ||
| 154 | PyTuple_SET_ITEM( const_tuple_str_plain_direction_str_plain_in_tuple, 1, const_str_plain_in ); Py_INCREF( const_str_plain_in ); | ||
| 155 | const_str_plain_EndElementHandler = UNSTREAM_STRING_ASCII( &constant_bin[ 8608 ], 17, 1 ); | ||
| 156 | const_str_digest_9e791634659cef76ab4e135031893f31 = UNSTREAM_STRING_ASCII( &constant_bin[ 8625 ], 16, 0 ); | ||
| 157 | const_str_digest_98664ef00f574ec08b1cfc4be9e5a5de = UNSTREAM_STRING_ASCII( &constant_bin[ 8641 ], 27, 0 ); | ||
| 158 | const_tuple_str_plain_IntrospectionParserException_tuple = PyTuple_New( 1 ); | ||
| 159 | PyTuple_SET_ITEM( const_tuple_str_plain_IntrospectionParserException_tuple, 0, const_str_plain_IntrospectionParserException ); Py_INCREF( const_str_plain_IntrospectionParserException ); | ||
| 160 | const_str_digest_29704eec445aa0f422f31f45e9aa157f = UNSTREAM_STRING_ASCII( &constant_bin[ 8668 ], 25, 0 ); | ||
| 161 | const_str_plain_ParserCreate = UNSTREAM_STRING_ASCII( &constant_bin[ 8693 ], 12, 1 ); | ||
| 162 | const_str_plain_parse = UNSTREAM_STRING_ASCII( &constant_bin[ 7983 ], 5, 1 ); | ||
| 163 | const_tuple_str_plain_ParserCreate_tuple = PyTuple_New( 1 ); | ||
| 164 | PyTuple_SET_ITEM( const_tuple_str_plain_ParserCreate_tuple, 0, const_str_plain_ParserCreate ); Py_INCREF( const_str_plain_ParserCreate ); | ||
| 165 | |||
| 166 | constants_created = true; | ||
| 167 | } | ||
| 168 | |||
| 169 | /* Function to verify module private constants for non-corruption. */ | ||
| 170 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 171 | void checkModuleConstants_dbus$_expat_introspect_parser( void ) | ||
| 172 | { | ||
| 173 | // The module may not have been used at all, then ignore this. | ||
| 174 | if (constants_created == false) return; | ||
| 175 | |||
| 176 | |||
| 177 | } | ||
| 178 | #endif | ||
| 179 | |||
| 180 | // The module code objects. | ||
| 181 | static PyCodeObject *codeobj_d985cb2edde0f12e6088a207de5f7222; | ||
| 182 | static PyCodeObject *codeobj_899d0693dc9e2c566d398b72bff1ac02; | ||
| 183 | static PyCodeObject *codeobj_bf482f59396a00033f1561c8ab09ee10; | ||
| 184 | static PyCodeObject *codeobj_8bb09954d222fbbc2e8769926c9d0187; | ||
| 185 | static PyCodeObject *codeobj_1cc2da2dd3c6a227a185e01f5454f5b6; | ||
| 186 | static PyCodeObject *codeobj_72136d6021e6c4b7e1af2fddb7da8e06; | ||
| 187 | static PyCodeObject *codeobj_dbb49e89a876483f119ad43743fc242b; | ||
| 188 | |||
| 189 | static void createModuleCodeObjects(void) | ||
| 190 | { | ||
| 191 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_4ced22b65a2ea3042260a0ce3d5ed36c ); | ||
| 192 | codeobj_d985cb2edde0f12e6088a207de5f7222 = MAKE_CODEOBJ( module_filename_obj, const_str_digest_5c6cab9b128e97656eac49f6d79bcb14, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 193 | codeobj_899d0693dc9e2c566d398b72bff1ac02 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_EndElementHandler, 56, const_tuple_str_plain_self_str_plain_name_tuple, 2, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 194 | codeobj_bf482f59396a00033f1561c8ab09ee10 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_StartElementHandler, 45, const_tuple_str_plain_self_str_plain_name_str_plain_attributes_tuple, 3, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 195 | codeobj_8bb09954d222fbbc2e8769926c9d0187 = MAKE_CODEOBJ( module_filename_obj, const_str_plain__Parser, 29, const_tuple_str_plain___class___tuple, 0, 0, CO_NOFREE ); | ||
| 196 | codeobj_1cc2da2dd3c6a227a185e01f5454f5b6 = MAKE_CODEOBJ( module_filename_obj, const_str_plain___init__, 31, const_tuple_str_plain_self_tuple, 1, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 197 | codeobj_72136d6021e6c4b7e1af2fddb7da8e06 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_parse, 37, const_tuple_str_plain_self_str_plain_data_str_plain_parser_tuple, 2, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 198 | codeobj_dbb49e89a876483f119ad43743fc242b = MAKE_CODEOBJ( module_filename_obj, const_str_plain_process_introspection_data, 65, const_tuple_str_plain_data_str_plain_e_tuple, 1, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 199 | } | ||
| 200 | |||
| 201 | // The module function declarations. | ||
| 202 | NUITKA_CROSS_MODULE PyObject *impl___internal__$$$function_2__mro_entries_conversion( PyObject **python_pars ); | ||
| 203 | |||
| 204 | |||
| 205 | static PyObject *MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_1___init__( ); | ||
| 206 | |||
| 207 | |||
| 208 | static PyObject *MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_2_parse( ); | ||
| 209 | |||
| 210 | |||
| 211 | static PyObject *MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_3_StartElementHandler( ); | ||
| 212 | |||
| 213 | |||
| 214 | static PyObject *MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_4_EndElementHandler( ); | ||
| 215 | |||
| 216 | |||
| 217 | static PyObject *MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_5_process_introspection_data( ); | ||
| 218 | |||
| 219 | |||
| 220 | // The module function definitions. | ||
| 221 | static PyObject *impl_dbus$_expat_introspect_parser$$$function_1___init__( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 222 | { | ||
| 223 | // Preserve error status for checks | ||
| 224 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 225 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 226 | #endif | ||
| 227 | |||
| 228 | // Local variable declarations. | ||
| 229 | PyObject *par_self = python_pars[ 0 ]; | ||
| 230 | struct Nuitka_FrameObject *frame_1cc2da2dd3c6a227a185e01f5454f5b6; | ||
| 231 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 232 | bool tmp_result; | ||
| 233 | PyObject *exception_type = NULL; | ||
| 234 | PyObject *exception_value = NULL; | ||
| 235 | PyTracebackObject *exception_tb = NULL; | ||
| 236 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 237 | static struct Nuitka_FrameObject *cache_frame_1cc2da2dd3c6a227a185e01f5454f5b6 = NULL; | ||
| 238 | PyObject *tmp_return_value = NULL; | ||
| 239 | PyObject *exception_keeper_type_1; | ||
| 240 | PyObject *exception_keeper_value_1; | ||
| 241 | PyTracebackObject *exception_keeper_tb_1; | ||
| 242 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 243 | |||
| 244 | // Actual function body. | ||
| 245 | // Tried code: | ||
| 246 | MAKE_OR_REUSE_FRAME( cache_frame_1cc2da2dd3c6a227a185e01f5454f5b6, codeobj_1cc2da2dd3c6a227a185e01f5454f5b6, module_dbus$_expat_introspect_parser, sizeof(void *) ); | ||
| 247 | frame_1cc2da2dd3c6a227a185e01f5454f5b6 = cache_frame_1cc2da2dd3c6a227a185e01f5454f5b6; | ||
| 248 | |||
| 249 | // Push the new frame as the currently active one. | ||
| 250 | pushFrameStack( frame_1cc2da2dd3c6a227a185e01f5454f5b6 ); | ||
| 251 | |||
| 252 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 253 | assert( Py_REFCNT( frame_1cc2da2dd3c6a227a185e01f5454f5b6 ) == 2 ); // Frame stack | ||
| 254 | |||
| 255 | // Framed code: | ||
| 256 | { | ||
| 257 | PyObject *tmp_assattr_name_1; | ||
| 258 | PyObject *tmp_assattr_target_1; | ||
| 259 | tmp_assattr_name_1 = PyDict_New(); | ||
| 260 | CHECK_OBJECT( par_self ); | ||
| 261 | tmp_assattr_target_1 = par_self; | ||
| 262 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_map, tmp_assattr_name_1 ); | ||
| 263 | Py_DECREF( tmp_assattr_name_1 ); | ||
| 264 | if ( tmp_result == false ) | ||
| 265 | { | ||
| 266 | assert( ERROR_OCCURRED() ); | ||
| 267 | |||
| 268 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 269 | |||
| 270 | |||
| 271 | exception_lineno = 32; | ||
| 272 | type_description_1 = "o"; | ||
| 273 | goto frame_exception_exit_1; | ||
| 274 | } | ||
| 275 | } | ||
| 276 | { | ||
| 277 | PyObject *tmp_assattr_name_2; | ||
| 278 | PyObject *tmp_assattr_target_2; | ||
| 279 | tmp_assattr_name_2 = const_str_empty; | ||
| 280 | CHECK_OBJECT( par_self ); | ||
| 281 | tmp_assattr_target_2 = par_self; | ||
| 282 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_in_iface, tmp_assattr_name_2 ); | ||
| 283 | if ( tmp_result == false ) | ||
| 284 | { | ||
| 285 | assert( ERROR_OCCURRED() ); | ||
| 286 | |||
| 287 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 288 | |||
| 289 | |||
| 290 | exception_lineno = 33; | ||
| 291 | type_description_1 = "o"; | ||
| 292 | goto frame_exception_exit_1; | ||
| 293 | } | ||
| 294 | } | ||
| 295 | { | ||
| 296 | PyObject *tmp_assattr_name_3; | ||
| 297 | PyObject *tmp_assattr_target_3; | ||
| 298 | tmp_assattr_name_3 = const_str_empty; | ||
| 299 | CHECK_OBJECT( par_self ); | ||
| 300 | tmp_assattr_target_3 = par_self; | ||
| 301 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_3, const_str_plain_in_method, tmp_assattr_name_3 ); | ||
| 302 | if ( tmp_result == false ) | ||
| 303 | { | ||
| 304 | assert( ERROR_OCCURRED() ); | ||
| 305 | |||
| 306 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 307 | |||
| 308 | |||
| 309 | exception_lineno = 34; | ||
| 310 | type_description_1 = "o"; | ||
| 311 | goto frame_exception_exit_1; | ||
| 312 | } | ||
| 313 | } | ||
| 314 | { | ||
| 315 | PyObject *tmp_assattr_name_4; | ||
| 316 | PyObject *tmp_assattr_target_4; | ||
| 317 | tmp_assattr_name_4 = const_str_empty; | ||
| 318 | CHECK_OBJECT( par_self ); | ||
| 319 | tmp_assattr_target_4 = par_self; | ||
| 320 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_4, const_str_plain_sig, tmp_assattr_name_4 ); | ||
| 321 | if ( tmp_result == false ) | ||
| 322 | { | ||
| 323 | assert( ERROR_OCCURRED() ); | ||
| 324 | |||
| 325 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 326 | |||
| 327 | |||
| 328 | exception_lineno = 35; | ||
| 329 | type_description_1 = "o"; | ||
| 330 | goto frame_exception_exit_1; | ||
| 331 | } | ||
| 332 | } | ||
| 333 | |||
| 334 | #if 0 | ||
| 335 | RESTORE_FRAME_EXCEPTION( frame_1cc2da2dd3c6a227a185e01f5454f5b6 ); | ||
| 336 | #endif | ||
| 337 | |||
| 338 | // Put the previous frame back on top. | ||
| 339 | popFrameStack(); | ||
| 340 | |||
| 341 | goto frame_no_exception_1; | ||
| 342 | |||
| 343 | frame_exception_exit_1:; | ||
| 344 | |||
| 345 | #if 0 | ||
| 346 | RESTORE_FRAME_EXCEPTION( frame_1cc2da2dd3c6a227a185e01f5454f5b6 ); | ||
| 347 | #endif | ||
| 348 | |||
| 349 | if ( exception_tb == NULL ) | ||
| 350 | { | ||
| 351 | exception_tb = MAKE_TRACEBACK( frame_1cc2da2dd3c6a227a185e01f5454f5b6, exception_lineno ); | ||
| 352 | } | ||
| 353 | else if ( exception_tb->tb_frame != &frame_1cc2da2dd3c6a227a185e01f5454f5b6->m_frame ) | ||
| 354 | { | ||
| 355 | exception_tb = ADD_TRACEBACK( exception_tb, frame_1cc2da2dd3c6a227a185e01f5454f5b6, exception_lineno ); | ||
| 356 | } | ||
| 357 | |||
| 358 | // Attachs locals to frame if any. | ||
| 359 | Nuitka_Frame_AttachLocals( | ||
| 360 | (struct Nuitka_FrameObject *)frame_1cc2da2dd3c6a227a185e01f5454f5b6, | ||
| 361 | type_description_1, | ||
| 362 | par_self | ||
| 363 | ); | ||
| 364 | |||
| 365 | |||
| 366 | // Release cached frame. | ||
| 367 | if ( frame_1cc2da2dd3c6a227a185e01f5454f5b6 == cache_frame_1cc2da2dd3c6a227a185e01f5454f5b6 ) | ||
| 368 | { | ||
| 369 | Py_DECREF( frame_1cc2da2dd3c6a227a185e01f5454f5b6 ); | ||
| 370 | } | ||
| 371 | cache_frame_1cc2da2dd3c6a227a185e01f5454f5b6 = NULL; | ||
| 372 | |||
| 373 | assertFrameObject( frame_1cc2da2dd3c6a227a185e01f5454f5b6 ); | ||
| 374 | |||
| 375 | // Put the previous frame back on top. | ||
| 376 | popFrameStack(); | ||
| 377 | |||
| 378 | // Return the error. | ||
| 379 | goto try_except_handler_1; | ||
| 380 | |||
| 381 | frame_no_exception_1:; | ||
| 382 | tmp_return_value = Py_None; | ||
| 383 | Py_INCREF( tmp_return_value ); | ||
| 384 | goto try_return_handler_1; | ||
| 385 | // tried codes exits in all cases | ||
| 386 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_1___init__ ); | ||
| 387 | return NULL; | ||
| 388 | // Return handler code: | ||
| 389 | try_return_handler_1:; | ||
| 390 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 391 | Py_DECREF( par_self ); | ||
| 392 | par_self = NULL; | ||
| 393 | |||
| 394 | goto function_return_exit; | ||
| 395 | // Exception handler code: | ||
| 396 | try_except_handler_1:; | ||
| 397 | exception_keeper_type_1 = exception_type; | ||
| 398 | exception_keeper_value_1 = exception_value; | ||
| 399 | exception_keeper_tb_1 = exception_tb; | ||
| 400 | exception_keeper_lineno_1 = exception_lineno; | ||
| 401 | exception_type = NULL; | ||
| 402 | exception_value = NULL; | ||
| 403 | exception_tb = NULL; | ||
| 404 | exception_lineno = 0; | ||
| 405 | |||
| 406 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 407 | Py_DECREF( par_self ); | ||
| 408 | par_self = NULL; | ||
| 409 | |||
| 410 | // Re-raise. | ||
| 411 | exception_type = exception_keeper_type_1; | ||
| 412 | exception_value = exception_keeper_value_1; | ||
| 413 | exception_tb = exception_keeper_tb_1; | ||
| 414 | exception_lineno = exception_keeper_lineno_1; | ||
| 415 | |||
| 416 | goto function_exception_exit; | ||
| 417 | // End of try: | ||
| 418 | |||
| 419 | // Return statement must have exited already. | ||
| 420 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_1___init__ ); | ||
| 421 | return NULL; | ||
| 422 | |||
| 423 | function_exception_exit: | ||
| 424 | assert( exception_type ); | ||
| 425 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 426 | |||
| 427 | return NULL; | ||
| 428 | |||
| 429 | function_return_exit: | ||
| 430 | // Function cleanup code if any. | ||
| 431 | |||
| 432 | |||
| 433 | // Actual function exit with return value, making sure we did not make | ||
| 434 | // the error status worse despite non-NULL return. | ||
| 435 | CHECK_OBJECT( tmp_return_value ); | ||
| 436 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 437 | return tmp_return_value; | ||
| 438 | } | ||
| 439 | |||
| 440 | |||
| 441 | static PyObject *impl_dbus$_expat_introspect_parser$$$function_2_parse( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 442 | { | ||
| 443 | // Preserve error status for checks | ||
| 444 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 445 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 446 | #endif | ||
| 447 | |||
| 448 | // Local variable declarations. | ||
| 449 | PyObject *par_self = python_pars[ 0 ]; | ||
| 450 | PyObject *par_data = python_pars[ 1 ]; | ||
| 451 | PyObject *var_parser = NULL; | ||
| 452 | struct Nuitka_FrameObject *frame_72136d6021e6c4b7e1af2fddb7da8e06; | ||
| 453 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 454 | PyObject *exception_type = NULL; | ||
| 455 | PyObject *exception_value = NULL; | ||
| 456 | PyTracebackObject *exception_tb = NULL; | ||
| 457 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 458 | bool tmp_result; | ||
| 459 | PyObject *tmp_return_value = NULL; | ||
| 460 | static struct Nuitka_FrameObject *cache_frame_72136d6021e6c4b7e1af2fddb7da8e06 = NULL; | ||
| 461 | PyObject *exception_keeper_type_1; | ||
| 462 | PyObject *exception_keeper_value_1; | ||
| 463 | PyTracebackObject *exception_keeper_tb_1; | ||
| 464 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 465 | |||
| 466 | // Actual function body. | ||
| 467 | // Tried code: | ||
| 468 | MAKE_OR_REUSE_FRAME( cache_frame_72136d6021e6c4b7e1af2fddb7da8e06, codeobj_72136d6021e6c4b7e1af2fddb7da8e06, module_dbus$_expat_introspect_parser, sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 469 | frame_72136d6021e6c4b7e1af2fddb7da8e06 = cache_frame_72136d6021e6c4b7e1af2fddb7da8e06; | ||
| 470 | |||
| 471 | // Push the new frame as the currently active one. | ||
| 472 | pushFrameStack( frame_72136d6021e6c4b7e1af2fddb7da8e06 ); | ||
| 473 | |||
| 474 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 475 | assert( Py_REFCNT( frame_72136d6021e6c4b7e1af2fddb7da8e06 ) == 2 ); // Frame stack | ||
| 476 | |||
| 477 | // Framed code: | ||
| 478 | { | ||
| 479 | PyObject *tmp_assign_source_1; | ||
| 480 | PyObject *tmp_called_name_1; | ||
| 481 | PyObject *tmp_mvar_value_1; | ||
| 482 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain_ParserCreate ); | ||
| 483 | |||
| 484 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 485 | { | ||
| 486 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_ParserCreate ); | ||
| 487 | } | ||
| 488 | |||
| 489 | if ( tmp_mvar_value_1 == NULL ) | ||
| 490 | { | ||
| 491 | |||
| 492 | exception_type = PyExc_NameError; | ||
| 493 | Py_INCREF( exception_type ); | ||
| 494 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "ParserCreate" ); | ||
| 495 | exception_tb = NULL; | ||
| 496 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 497 | CHAIN_EXCEPTION( exception_value ); | ||
| 498 | |||
| 499 | exception_lineno = 38; | ||
| 500 | type_description_1 = "ooo"; | ||
| 501 | goto frame_exception_exit_1; | ||
| 502 | } | ||
| 503 | |||
| 504 | tmp_called_name_1 = tmp_mvar_value_1; | ||
| 505 | frame_72136d6021e6c4b7e1af2fddb7da8e06->m_frame.f_lineno = 38; | ||
| 506 | tmp_assign_source_1 = CALL_FUNCTION_WITH_ARGS2( tmp_called_name_1, &PyTuple_GET_ITEM( const_tuple_str_digest_d80d8945c1075596a484c18b20ab6235_str_space_tuple, 0 ) ); | ||
| 507 | |||
| 508 | if ( tmp_assign_source_1 == NULL ) | ||
| 509 | { | ||
| 510 | assert( ERROR_OCCURRED() ); | ||
| 511 | |||
| 512 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 513 | |||
| 514 | |||
| 515 | exception_lineno = 38; | ||
| 516 | type_description_1 = "ooo"; | ||
| 517 | goto frame_exception_exit_1; | ||
| 518 | } | ||
| 519 | assert( var_parser == NULL ); | ||
| 520 | var_parser = tmp_assign_source_1; | ||
| 521 | } | ||
| 522 | { | ||
| 523 | PyObject *tmp_assattr_name_1; | ||
| 524 | PyObject *tmp_assattr_target_1; | ||
| 525 | tmp_assattr_name_1 = Py_True; | ||
| 526 | CHECK_OBJECT( var_parser ); | ||
| 527 | tmp_assattr_target_1 = var_parser; | ||
| 528 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_buffer_text, tmp_assattr_name_1 ); | ||
| 529 | if ( tmp_result == false ) | ||
| 530 | { | ||
| 531 | assert( ERROR_OCCURRED() ); | ||
| 532 | |||
| 533 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 534 | |||
| 535 | |||
| 536 | exception_lineno = 39; | ||
| 537 | type_description_1 = "ooo"; | ||
| 538 | goto frame_exception_exit_1; | ||
| 539 | } | ||
| 540 | } | ||
| 541 | { | ||
| 542 | PyObject *tmp_assattr_name_2; | ||
| 543 | PyObject *tmp_source_name_1; | ||
| 544 | PyObject *tmp_assattr_target_2; | ||
| 545 | CHECK_OBJECT( par_self ); | ||
| 546 | tmp_source_name_1 = par_self; | ||
| 547 | tmp_assattr_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_StartElementHandler ); | ||
| 548 | if ( tmp_assattr_name_2 == NULL ) | ||
| 549 | { | ||
| 550 | assert( ERROR_OCCURRED() ); | ||
| 551 | |||
| 552 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 553 | |||
| 554 | |||
| 555 | exception_lineno = 40; | ||
| 556 | type_description_1 = "ooo"; | ||
| 557 | goto frame_exception_exit_1; | ||
| 558 | } | ||
| 559 | CHECK_OBJECT( var_parser ); | ||
| 560 | tmp_assattr_target_2 = var_parser; | ||
| 561 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_StartElementHandler, tmp_assattr_name_2 ); | ||
| 562 | Py_DECREF( tmp_assattr_name_2 ); | ||
| 563 | if ( tmp_result == false ) | ||
| 564 | { | ||
| 565 | assert( ERROR_OCCURRED() ); | ||
| 566 | |||
| 567 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 568 | |||
| 569 | |||
| 570 | exception_lineno = 40; | ||
| 571 | type_description_1 = "ooo"; | ||
| 572 | goto frame_exception_exit_1; | ||
| 573 | } | ||
| 574 | } | ||
| 575 | { | ||
| 576 | PyObject *tmp_assattr_name_3; | ||
| 577 | PyObject *tmp_source_name_2; | ||
| 578 | PyObject *tmp_assattr_target_3; | ||
| 579 | CHECK_OBJECT( par_self ); | ||
| 580 | tmp_source_name_2 = par_self; | ||
| 581 | tmp_assattr_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_EndElementHandler ); | ||
| 582 | if ( tmp_assattr_name_3 == NULL ) | ||
| 583 | { | ||
| 584 | assert( ERROR_OCCURRED() ); | ||
| 585 | |||
| 586 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 587 | |||
| 588 | |||
| 589 | exception_lineno = 41; | ||
| 590 | type_description_1 = "ooo"; | ||
| 591 | goto frame_exception_exit_1; | ||
| 592 | } | ||
| 593 | CHECK_OBJECT( var_parser ); | ||
| 594 | tmp_assattr_target_3 = var_parser; | ||
| 595 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_3, const_str_plain_EndElementHandler, tmp_assattr_name_3 ); | ||
| 596 | Py_DECREF( tmp_assattr_name_3 ); | ||
| 597 | if ( tmp_result == false ) | ||
| 598 | { | ||
| 599 | assert( ERROR_OCCURRED() ); | ||
| 600 | |||
| 601 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 602 | |||
| 603 | |||
| 604 | exception_lineno = 41; | ||
| 605 | type_description_1 = "ooo"; | ||
| 606 | goto frame_exception_exit_1; | ||
| 607 | } | ||
| 608 | } | ||
| 609 | { | ||
| 610 | PyObject *tmp_called_instance_1; | ||
| 611 | PyObject *tmp_call_result_1; | ||
| 612 | PyObject *tmp_args_element_name_1; | ||
| 613 | CHECK_OBJECT( var_parser ); | ||
| 614 | tmp_called_instance_1 = var_parser; | ||
| 615 | CHECK_OBJECT( par_data ); | ||
| 616 | tmp_args_element_name_1 = par_data; | ||
| 617 | frame_72136d6021e6c4b7e1af2fddb7da8e06->m_frame.f_lineno = 42; | ||
| 618 | { | ||
| 619 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 620 | tmp_call_result_1 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_1, const_str_plain_Parse, call_args ); | ||
| 621 | } | ||
| 622 | |||
| 623 | if ( tmp_call_result_1 == NULL ) | ||
| 624 | { | ||
| 625 | assert( ERROR_OCCURRED() ); | ||
| 626 | |||
| 627 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 628 | |||
| 629 | |||
| 630 | exception_lineno = 42; | ||
| 631 | type_description_1 = "ooo"; | ||
| 632 | goto frame_exception_exit_1; | ||
| 633 | } | ||
| 634 | Py_DECREF( tmp_call_result_1 ); | ||
| 635 | } | ||
| 636 | { | ||
| 637 | PyObject *tmp_source_name_3; | ||
| 638 | CHECK_OBJECT( par_self ); | ||
| 639 | tmp_source_name_3 = par_self; | ||
| 640 | tmp_return_value = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_map ); | ||
| 641 | if ( tmp_return_value == NULL ) | ||
| 642 | { | ||
| 643 | assert( ERROR_OCCURRED() ); | ||
| 644 | |||
| 645 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 646 | |||
| 647 | |||
| 648 | exception_lineno = 43; | ||
| 649 | type_description_1 = "ooo"; | ||
| 650 | goto frame_exception_exit_1; | ||
| 651 | } | ||
| 652 | goto frame_return_exit_1; | ||
| 653 | } | ||
| 654 | |||
| 655 | #if 0 | ||
| 656 | RESTORE_FRAME_EXCEPTION( frame_72136d6021e6c4b7e1af2fddb7da8e06 ); | ||
| 657 | #endif | ||
| 658 | |||
| 659 | // Put the previous frame back on top. | ||
| 660 | popFrameStack(); | ||
| 661 | |||
| 662 | goto frame_no_exception_1; | ||
| 663 | |||
| 664 | frame_return_exit_1:; | ||
| 665 | #if 0 | ||
| 666 | RESTORE_FRAME_EXCEPTION( frame_72136d6021e6c4b7e1af2fddb7da8e06 ); | ||
| 667 | #endif | ||
| 668 | |||
| 669 | // Put the previous frame back on top. | ||
| 670 | popFrameStack(); | ||
| 671 | |||
| 672 | goto try_return_handler_1; | ||
| 673 | |||
| 674 | frame_exception_exit_1:; | ||
| 675 | |||
| 676 | #if 0 | ||
| 677 | RESTORE_FRAME_EXCEPTION( frame_72136d6021e6c4b7e1af2fddb7da8e06 ); | ||
| 678 | #endif | ||
| 679 | |||
| 680 | if ( exception_tb == NULL ) | ||
| 681 | { | ||
| 682 | exception_tb = MAKE_TRACEBACK( frame_72136d6021e6c4b7e1af2fddb7da8e06, exception_lineno ); | ||
| 683 | } | ||
| 684 | else if ( exception_tb->tb_frame != &frame_72136d6021e6c4b7e1af2fddb7da8e06->m_frame ) | ||
| 685 | { | ||
| 686 | exception_tb = ADD_TRACEBACK( exception_tb, frame_72136d6021e6c4b7e1af2fddb7da8e06, exception_lineno ); | ||
| 687 | } | ||
| 688 | |||
| 689 | // Attachs locals to frame if any. | ||
| 690 | Nuitka_Frame_AttachLocals( | ||
| 691 | (struct Nuitka_FrameObject *)frame_72136d6021e6c4b7e1af2fddb7da8e06, | ||
| 692 | type_description_1, | ||
| 693 | par_self, | ||
| 694 | par_data, | ||
| 695 | var_parser | ||
| 696 | ); | ||
| 697 | |||
| 698 | |||
| 699 | // Release cached frame. | ||
| 700 | if ( frame_72136d6021e6c4b7e1af2fddb7da8e06 == cache_frame_72136d6021e6c4b7e1af2fddb7da8e06 ) | ||
| 701 | { | ||
| 702 | Py_DECREF( frame_72136d6021e6c4b7e1af2fddb7da8e06 ); | ||
| 703 | } | ||
| 704 | cache_frame_72136d6021e6c4b7e1af2fddb7da8e06 = NULL; | ||
| 705 | |||
| 706 | assertFrameObject( frame_72136d6021e6c4b7e1af2fddb7da8e06 ); | ||
| 707 | |||
| 708 | // Put the previous frame back on top. | ||
| 709 | popFrameStack(); | ||
| 710 | |||
| 711 | // Return the error. | ||
| 712 | goto try_except_handler_1; | ||
| 713 | |||
| 714 | frame_no_exception_1:; | ||
| 715 | // tried codes exits in all cases | ||
| 716 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_2_parse ); | ||
| 717 | return NULL; | ||
| 718 | // Return handler code: | ||
| 719 | try_return_handler_1:; | ||
| 720 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 721 | Py_DECREF( par_self ); | ||
| 722 | par_self = NULL; | ||
| 723 | |||
| 724 | CHECK_OBJECT( (PyObject *)par_data ); | ||
| 725 | Py_DECREF( par_data ); | ||
| 726 | par_data = NULL; | ||
| 727 | |||
| 728 | CHECK_OBJECT( (PyObject *)var_parser ); | ||
| 729 | Py_DECREF( var_parser ); | ||
| 730 | var_parser = NULL; | ||
| 731 | |||
| 732 | goto function_return_exit; | ||
| 733 | // Exception handler code: | ||
| 734 | try_except_handler_1:; | ||
| 735 | exception_keeper_type_1 = exception_type; | ||
| 736 | exception_keeper_value_1 = exception_value; | ||
| 737 | exception_keeper_tb_1 = exception_tb; | ||
| 738 | exception_keeper_lineno_1 = exception_lineno; | ||
| 739 | exception_type = NULL; | ||
| 740 | exception_value = NULL; | ||
| 741 | exception_tb = NULL; | ||
| 742 | exception_lineno = 0; | ||
| 743 | |||
| 744 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 745 | Py_DECREF( par_self ); | ||
| 746 | par_self = NULL; | ||
| 747 | |||
| 748 | CHECK_OBJECT( (PyObject *)par_data ); | ||
| 749 | Py_DECREF( par_data ); | ||
| 750 | par_data = NULL; | ||
| 751 | |||
| 752 | Py_XDECREF( var_parser ); | ||
| 753 | var_parser = NULL; | ||
| 754 | |||
| 755 | // Re-raise. | ||
| 756 | exception_type = exception_keeper_type_1; | ||
| 757 | exception_value = exception_keeper_value_1; | ||
| 758 | exception_tb = exception_keeper_tb_1; | ||
| 759 | exception_lineno = exception_keeper_lineno_1; | ||
| 760 | |||
| 761 | goto function_exception_exit; | ||
| 762 | // End of try: | ||
| 763 | |||
| 764 | // Return statement must have exited already. | ||
| 765 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_2_parse ); | ||
| 766 | return NULL; | ||
| 767 | |||
| 768 | function_exception_exit: | ||
| 769 | assert( exception_type ); | ||
| 770 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 771 | |||
| 772 | return NULL; | ||
| 773 | |||
| 774 | function_return_exit: | ||
| 775 | // Function cleanup code if any. | ||
| 776 | |||
| 777 | |||
| 778 | // Actual function exit with return value, making sure we did not make | ||
| 779 | // the error status worse despite non-NULL return. | ||
| 780 | CHECK_OBJECT( tmp_return_value ); | ||
| 781 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 782 | return tmp_return_value; | ||
| 783 | } | ||
| 784 | |||
| 785 | |||
| 786 | static PyObject *impl_dbus$_expat_introspect_parser$$$function_3_StartElementHandler( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 787 | { | ||
| 788 | // Preserve error status for checks | ||
| 789 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 790 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 791 | #endif | ||
| 792 | |||
| 793 | // Local variable declarations. | ||
| 794 | PyObject *par_self = python_pars[ 0 ]; | ||
| 795 | PyObject *par_name = python_pars[ 1 ]; | ||
| 796 | PyObject *par_attributes = python_pars[ 2 ]; | ||
| 797 | PyObject *tmp_inplace_assign_attr_1__end = NULL; | ||
| 798 | PyObject *tmp_inplace_assign_attr_1__start = NULL; | ||
| 799 | struct Nuitka_FrameObject *frame_bf482f59396a00033f1561c8ab09ee10; | ||
| 800 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 801 | PyObject *exception_type = NULL; | ||
| 802 | PyObject *exception_value = NULL; | ||
| 803 | PyTracebackObject *exception_tb = NULL; | ||
| 804 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 805 | int tmp_res; | ||
| 806 | bool tmp_result; | ||
| 807 | PyObject *exception_keeper_type_1; | ||
| 808 | PyObject *exception_keeper_value_1; | ||
| 809 | PyTracebackObject *exception_keeper_tb_1; | ||
| 810 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 811 | PyObject *exception_keeper_type_2; | ||
| 812 | PyObject *exception_keeper_value_2; | ||
| 813 | PyTracebackObject *exception_keeper_tb_2; | ||
| 814 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 815 | static struct Nuitka_FrameObject *cache_frame_bf482f59396a00033f1561c8ab09ee10 = NULL; | ||
| 816 | PyObject *tmp_return_value = NULL; | ||
| 817 | PyObject *exception_keeper_type_3; | ||
| 818 | PyObject *exception_keeper_value_3; | ||
| 819 | PyTracebackObject *exception_keeper_tb_3; | ||
| 820 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; | ||
| 821 | |||
| 822 | // Actual function body. | ||
| 823 | // Tried code: | ||
| 824 | MAKE_OR_REUSE_FRAME( cache_frame_bf482f59396a00033f1561c8ab09ee10, codeobj_bf482f59396a00033f1561c8ab09ee10, module_dbus$_expat_introspect_parser, sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 825 | frame_bf482f59396a00033f1561c8ab09ee10 = cache_frame_bf482f59396a00033f1561c8ab09ee10; | ||
| 826 | |||
| 827 | // Push the new frame as the currently active one. | ||
| 828 | pushFrameStack( frame_bf482f59396a00033f1561c8ab09ee10 ); | ||
| 829 | |||
| 830 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 831 | assert( Py_REFCNT( frame_bf482f59396a00033f1561c8ab09ee10 ) == 2 ); // Frame stack | ||
| 832 | |||
| 833 | // Framed code: | ||
| 834 | { | ||
| 835 | nuitka_bool tmp_condition_result_1; | ||
| 836 | PyObject *tmp_operand_name_1; | ||
| 837 | PyObject *tmp_source_name_1; | ||
| 838 | CHECK_OBJECT( par_self ); | ||
| 839 | tmp_source_name_1 = par_self; | ||
| 840 | tmp_operand_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_in_iface ); | ||
| 841 | if ( tmp_operand_name_1 == NULL ) | ||
| 842 | { | ||
| 843 | assert( ERROR_OCCURRED() ); | ||
| 844 | |||
| 845 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 846 | |||
| 847 | |||
| 848 | exception_lineno = 46; | ||
| 849 | type_description_1 = "ooo"; | ||
| 850 | goto frame_exception_exit_1; | ||
| 851 | } | ||
| 852 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 853 | Py_DECREF( tmp_operand_name_1 ); | ||
| 854 | if ( tmp_res == -1 ) | ||
| 855 | { | ||
| 856 | assert( ERROR_OCCURRED() ); | ||
| 857 | |||
| 858 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 859 | |||
| 860 | |||
| 861 | exception_lineno = 46; | ||
| 862 | type_description_1 = "ooo"; | ||
| 863 | goto frame_exception_exit_1; | ||
| 864 | } | ||
| 865 | tmp_condition_result_1 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 866 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 867 | { | ||
| 868 | goto branch_yes_1; | ||
| 869 | } | ||
| 870 | else | ||
| 871 | { | ||
| 872 | goto branch_no_1; | ||
| 873 | } | ||
| 874 | branch_yes_1:; | ||
| 875 | { | ||
| 876 | nuitka_bool tmp_condition_result_2; | ||
| 877 | int tmp_and_left_truth_1; | ||
| 878 | nuitka_bool tmp_and_left_value_1; | ||
| 879 | nuitka_bool tmp_and_right_value_1; | ||
| 880 | PyObject *tmp_operand_name_2; | ||
| 881 | PyObject *tmp_source_name_2; | ||
| 882 | PyObject *tmp_compexpr_left_1; | ||
| 883 | PyObject *tmp_compexpr_right_1; | ||
| 884 | CHECK_OBJECT( par_self ); | ||
| 885 | tmp_source_name_2 = par_self; | ||
| 886 | tmp_operand_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_in_method ); | ||
| 887 | if ( tmp_operand_name_2 == NULL ) | ||
| 888 | { | ||
| 889 | assert( ERROR_OCCURRED() ); | ||
| 890 | |||
| 891 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 892 | |||
| 893 | |||
| 894 | exception_lineno = 47; | ||
| 895 | type_description_1 = "ooo"; | ||
| 896 | goto frame_exception_exit_1; | ||
| 897 | } | ||
| 898 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_2 ); | ||
| 899 | Py_DECREF( tmp_operand_name_2 ); | ||
| 900 | if ( tmp_res == -1 ) | ||
| 901 | { | ||
| 902 | assert( ERROR_OCCURRED() ); | ||
| 903 | |||
| 904 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 905 | |||
| 906 | |||
| 907 | exception_lineno = 47; | ||
| 908 | type_description_1 = "ooo"; | ||
| 909 | goto frame_exception_exit_1; | ||
| 910 | } | ||
| 911 | tmp_and_left_value_1 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 912 | tmp_and_left_truth_1 = tmp_and_left_value_1 == NUITKA_BOOL_TRUE ? 1 : 0; | ||
| 913 | if ( tmp_and_left_truth_1 == 1 ) | ||
| 914 | { | ||
| 915 | goto and_right_1; | ||
| 916 | } | ||
| 917 | else | ||
| 918 | { | ||
| 919 | goto and_left_1; | ||
| 920 | } | ||
| 921 | and_right_1:; | ||
| 922 | CHECK_OBJECT( par_name ); | ||
| 923 | tmp_compexpr_left_1 = par_name; | ||
| 924 | tmp_compexpr_right_1 = const_str_plain_interface; | ||
| 925 | tmp_res = RICH_COMPARE_BOOL_EQ_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 926 | if ( tmp_res == -1 ) | ||
| 927 | { | ||
| 928 | assert( ERROR_OCCURRED() ); | ||
| 929 | |||
| 930 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 931 | |||
| 932 | |||
| 933 | exception_lineno = 47; | ||
| 934 | type_description_1 = "ooo"; | ||
| 935 | goto frame_exception_exit_1; | ||
| 936 | } | ||
| 937 | tmp_and_right_value_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 938 | tmp_condition_result_2 = tmp_and_right_value_1; | ||
| 939 | goto and_end_1; | ||
| 940 | and_left_1:; | ||
| 941 | tmp_condition_result_2 = tmp_and_left_value_1; | ||
| 942 | and_end_1:; | ||
| 943 | if ( tmp_condition_result_2 == NUITKA_BOOL_TRUE ) | ||
| 944 | { | ||
| 945 | goto branch_yes_2; | ||
| 946 | } | ||
| 947 | else | ||
| 948 | { | ||
| 949 | goto branch_no_2; | ||
| 950 | } | ||
| 951 | branch_yes_2:; | ||
| 952 | { | ||
| 953 | PyObject *tmp_assattr_name_1; | ||
| 954 | PyObject *tmp_subscribed_name_1; | ||
| 955 | PyObject *tmp_subscript_name_1; | ||
| 956 | PyObject *tmp_assattr_target_1; | ||
| 957 | CHECK_OBJECT( par_attributes ); | ||
| 958 | tmp_subscribed_name_1 = par_attributes; | ||
| 959 | tmp_subscript_name_1 = const_str_plain_name; | ||
| 960 | tmp_assattr_name_1 = LOOKUP_SUBSCRIPT( tmp_subscribed_name_1, tmp_subscript_name_1 ); | ||
| 961 | if ( tmp_assattr_name_1 == NULL ) | ||
| 962 | { | ||
| 963 | assert( ERROR_OCCURRED() ); | ||
| 964 | |||
| 965 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 966 | |||
| 967 | |||
| 968 | exception_lineno = 48; | ||
| 969 | type_description_1 = "ooo"; | ||
| 970 | goto frame_exception_exit_1; | ||
| 971 | } | ||
| 972 | CHECK_OBJECT( par_self ); | ||
| 973 | tmp_assattr_target_1 = par_self; | ||
| 974 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_in_iface, tmp_assattr_name_1 ); | ||
| 975 | Py_DECREF( tmp_assattr_name_1 ); | ||
| 976 | if ( tmp_result == false ) | ||
| 977 | { | ||
| 978 | assert( ERROR_OCCURRED() ); | ||
| 979 | |||
| 980 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 981 | |||
| 982 | |||
| 983 | exception_lineno = 48; | ||
| 984 | type_description_1 = "ooo"; | ||
| 985 | goto frame_exception_exit_1; | ||
| 986 | } | ||
| 987 | } | ||
| 988 | branch_no_2:; | ||
| 989 | } | ||
| 990 | goto branch_end_1; | ||
| 991 | branch_no_1:; | ||
| 992 | { | ||
| 993 | nuitka_bool tmp_condition_result_3; | ||
| 994 | int tmp_and_left_truth_2; | ||
| 995 | nuitka_bool tmp_and_left_value_2; | ||
| 996 | nuitka_bool tmp_and_right_value_2; | ||
| 997 | PyObject *tmp_operand_name_3; | ||
| 998 | PyObject *tmp_source_name_3; | ||
| 999 | PyObject *tmp_compexpr_left_2; | ||
| 1000 | PyObject *tmp_compexpr_right_2; | ||
| 1001 | CHECK_OBJECT( par_self ); | ||
| 1002 | tmp_source_name_3 = par_self; | ||
| 1003 | tmp_operand_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_in_method ); | ||
| 1004 | if ( tmp_operand_name_3 == NULL ) | ||
| 1005 | { | ||
| 1006 | assert( ERROR_OCCURRED() ); | ||
| 1007 | |||
| 1008 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1009 | |||
| 1010 | |||
| 1011 | exception_lineno = 50; | ||
| 1012 | type_description_1 = "ooo"; | ||
| 1013 | goto frame_exception_exit_1; | ||
| 1014 | } | ||
| 1015 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_3 ); | ||
| 1016 | Py_DECREF( tmp_operand_name_3 ); | ||
| 1017 | if ( tmp_res == -1 ) | ||
| 1018 | { | ||
| 1019 | assert( ERROR_OCCURRED() ); | ||
| 1020 | |||
| 1021 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1022 | |||
| 1023 | |||
| 1024 | exception_lineno = 50; | ||
| 1025 | type_description_1 = "ooo"; | ||
| 1026 | goto frame_exception_exit_1; | ||
| 1027 | } | ||
| 1028 | tmp_and_left_value_2 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1029 | tmp_and_left_truth_2 = tmp_and_left_value_2 == NUITKA_BOOL_TRUE ? 1 : 0; | ||
| 1030 | if ( tmp_and_left_truth_2 == 1 ) | ||
| 1031 | { | ||
| 1032 | goto and_right_2; | ||
| 1033 | } | ||
| 1034 | else | ||
| 1035 | { | ||
| 1036 | goto and_left_2; | ||
| 1037 | } | ||
| 1038 | and_right_2:; | ||
| 1039 | CHECK_OBJECT( par_name ); | ||
| 1040 | tmp_compexpr_left_2 = par_name; | ||
| 1041 | tmp_compexpr_right_2 = const_str_plain_method; | ||
| 1042 | tmp_res = RICH_COMPARE_BOOL_EQ_OBJECT_OBJECT( tmp_compexpr_left_2, tmp_compexpr_right_2 ); | ||
| 1043 | if ( tmp_res == -1 ) | ||
| 1044 | { | ||
| 1045 | assert( ERROR_OCCURRED() ); | ||
| 1046 | |||
| 1047 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1048 | |||
| 1049 | |||
| 1050 | exception_lineno = 50; | ||
| 1051 | type_description_1 = "ooo"; | ||
| 1052 | goto frame_exception_exit_1; | ||
| 1053 | } | ||
| 1054 | tmp_and_right_value_2 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1055 | tmp_condition_result_3 = tmp_and_right_value_2; | ||
| 1056 | goto and_end_2; | ||
| 1057 | and_left_2:; | ||
| 1058 | tmp_condition_result_3 = tmp_and_left_value_2; | ||
| 1059 | and_end_2:; | ||
| 1060 | if ( tmp_condition_result_3 == NUITKA_BOOL_TRUE ) | ||
| 1061 | { | ||
| 1062 | goto branch_yes_3; | ||
| 1063 | } | ||
| 1064 | else | ||
| 1065 | { | ||
| 1066 | goto branch_no_3; | ||
| 1067 | } | ||
| 1068 | branch_yes_3:; | ||
| 1069 | { | ||
| 1070 | PyObject *tmp_assattr_name_2; | ||
| 1071 | PyObject *tmp_subscribed_name_2; | ||
| 1072 | PyObject *tmp_subscript_name_2; | ||
| 1073 | PyObject *tmp_assattr_target_2; | ||
| 1074 | CHECK_OBJECT( par_attributes ); | ||
| 1075 | tmp_subscribed_name_2 = par_attributes; | ||
| 1076 | tmp_subscript_name_2 = const_str_plain_name; | ||
| 1077 | tmp_assattr_name_2 = LOOKUP_SUBSCRIPT( tmp_subscribed_name_2, tmp_subscript_name_2 ); | ||
| 1078 | if ( tmp_assattr_name_2 == NULL ) | ||
| 1079 | { | ||
| 1080 | assert( ERROR_OCCURRED() ); | ||
| 1081 | |||
| 1082 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1083 | |||
| 1084 | |||
| 1085 | exception_lineno = 51; | ||
| 1086 | type_description_1 = "ooo"; | ||
| 1087 | goto frame_exception_exit_1; | ||
| 1088 | } | ||
| 1089 | CHECK_OBJECT( par_self ); | ||
| 1090 | tmp_assattr_target_2 = par_self; | ||
| 1091 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_in_method, tmp_assattr_name_2 ); | ||
| 1092 | Py_DECREF( tmp_assattr_name_2 ); | ||
| 1093 | if ( tmp_result == false ) | ||
| 1094 | { | ||
| 1095 | assert( ERROR_OCCURRED() ); | ||
| 1096 | |||
| 1097 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1098 | |||
| 1099 | |||
| 1100 | exception_lineno = 51; | ||
| 1101 | type_description_1 = "ooo"; | ||
| 1102 | goto frame_exception_exit_1; | ||
| 1103 | } | ||
| 1104 | } | ||
| 1105 | goto branch_end_3; | ||
| 1106 | branch_no_3:; | ||
| 1107 | { | ||
| 1108 | nuitka_bool tmp_condition_result_4; | ||
| 1109 | int tmp_and_left_truth_3; | ||
| 1110 | nuitka_bool tmp_and_left_value_3; | ||
| 1111 | nuitka_bool tmp_and_right_value_3; | ||
| 1112 | PyObject *tmp_source_name_4; | ||
| 1113 | PyObject *tmp_attribute_value_1; | ||
| 1114 | int tmp_truth_name_1; | ||
| 1115 | PyObject *tmp_compexpr_left_3; | ||
| 1116 | PyObject *tmp_compexpr_right_3; | ||
| 1117 | CHECK_OBJECT( par_self ); | ||
| 1118 | tmp_source_name_4 = par_self; | ||
| 1119 | tmp_attribute_value_1 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain_in_method ); | ||
| 1120 | if ( tmp_attribute_value_1 == NULL ) | ||
| 1121 | { | ||
| 1122 | assert( ERROR_OCCURRED() ); | ||
| 1123 | |||
| 1124 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1125 | |||
| 1126 | |||
| 1127 | exception_lineno = 52; | ||
| 1128 | type_description_1 = "ooo"; | ||
| 1129 | goto frame_exception_exit_1; | ||
| 1130 | } | ||
| 1131 | tmp_truth_name_1 = CHECK_IF_TRUE( tmp_attribute_value_1 ); | ||
| 1132 | if ( tmp_truth_name_1 == -1 ) | ||
| 1133 | { | ||
| 1134 | assert( ERROR_OCCURRED() ); | ||
| 1135 | |||
| 1136 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1137 | Py_DECREF( tmp_attribute_value_1 ); | ||
| 1138 | |||
| 1139 | exception_lineno = 52; | ||
| 1140 | type_description_1 = "ooo"; | ||
| 1141 | goto frame_exception_exit_1; | ||
| 1142 | } | ||
| 1143 | tmp_and_left_value_3 = tmp_truth_name_1 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1144 | Py_DECREF( tmp_attribute_value_1 ); | ||
| 1145 | tmp_and_left_truth_3 = tmp_and_left_value_3 == NUITKA_BOOL_TRUE ? 1 : 0; | ||
| 1146 | if ( tmp_and_left_truth_3 == 1 ) | ||
| 1147 | { | ||
| 1148 | goto and_right_3; | ||
| 1149 | } | ||
| 1150 | else | ||
| 1151 | { | ||
| 1152 | goto and_left_3; | ||
| 1153 | } | ||
| 1154 | and_right_3:; | ||
| 1155 | CHECK_OBJECT( par_name ); | ||
| 1156 | tmp_compexpr_left_3 = par_name; | ||
| 1157 | tmp_compexpr_right_3 = const_str_plain_arg; | ||
| 1158 | tmp_res = RICH_COMPARE_BOOL_EQ_OBJECT_OBJECT( tmp_compexpr_left_3, tmp_compexpr_right_3 ); | ||
| 1159 | if ( tmp_res == -1 ) | ||
| 1160 | { | ||
| 1161 | assert( ERROR_OCCURRED() ); | ||
| 1162 | |||
| 1163 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1164 | |||
| 1165 | |||
| 1166 | exception_lineno = 52; | ||
| 1167 | type_description_1 = "ooo"; | ||
| 1168 | goto frame_exception_exit_1; | ||
| 1169 | } | ||
| 1170 | tmp_and_right_value_3 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1171 | tmp_condition_result_4 = tmp_and_right_value_3; | ||
| 1172 | goto and_end_3; | ||
| 1173 | and_left_3:; | ||
| 1174 | tmp_condition_result_4 = tmp_and_left_value_3; | ||
| 1175 | and_end_3:; | ||
| 1176 | if ( tmp_condition_result_4 == NUITKA_BOOL_TRUE ) | ||
| 1177 | { | ||
| 1178 | goto branch_yes_4; | ||
| 1179 | } | ||
| 1180 | else | ||
| 1181 | { | ||
| 1182 | goto branch_no_4; | ||
| 1183 | } | ||
| 1184 | branch_yes_4:; | ||
| 1185 | { | ||
| 1186 | nuitka_bool tmp_condition_result_5; | ||
| 1187 | PyObject *tmp_compexpr_left_4; | ||
| 1188 | PyObject *tmp_compexpr_right_4; | ||
| 1189 | PyObject *tmp_called_instance_1; | ||
| 1190 | CHECK_OBJECT( par_attributes ); | ||
| 1191 | tmp_called_instance_1 = par_attributes; | ||
| 1192 | frame_bf482f59396a00033f1561c8ab09ee10->m_frame.f_lineno = 53; | ||
| 1193 | tmp_compexpr_left_4 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_1, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_direction_str_plain_in_tuple, 0 ) ); | ||
| 1194 | |||
| 1195 | if ( tmp_compexpr_left_4 == NULL ) | ||
| 1196 | { | ||
| 1197 | assert( ERROR_OCCURRED() ); | ||
| 1198 | |||
| 1199 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1200 | |||
| 1201 | |||
| 1202 | exception_lineno = 53; | ||
| 1203 | type_description_1 = "ooo"; | ||
| 1204 | goto frame_exception_exit_1; | ||
| 1205 | } | ||
| 1206 | tmp_compexpr_right_4 = const_str_plain_in; | ||
| 1207 | tmp_res = RICH_COMPARE_BOOL_EQ_OBJECT_OBJECT( tmp_compexpr_left_4, tmp_compexpr_right_4 ); | ||
| 1208 | Py_DECREF( tmp_compexpr_left_4 ); | ||
| 1209 | if ( tmp_res == -1 ) | ||
| 1210 | { | ||
| 1211 | assert( ERROR_OCCURRED() ); | ||
| 1212 | |||
| 1213 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1214 | |||
| 1215 | |||
| 1216 | exception_lineno = 53; | ||
| 1217 | type_description_1 = "ooo"; | ||
| 1218 | goto frame_exception_exit_1; | ||
| 1219 | } | ||
| 1220 | tmp_condition_result_5 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1221 | if ( tmp_condition_result_5 == NUITKA_BOOL_TRUE ) | ||
| 1222 | { | ||
| 1223 | goto branch_yes_5; | ||
| 1224 | } | ||
| 1225 | else | ||
| 1226 | { | ||
| 1227 | goto branch_no_5; | ||
| 1228 | } | ||
| 1229 | branch_yes_5:; | ||
| 1230 | { | ||
| 1231 | PyObject *tmp_assign_source_1; | ||
| 1232 | PyObject *tmp_source_name_5; | ||
| 1233 | CHECK_OBJECT( par_self ); | ||
| 1234 | tmp_source_name_5 = par_self; | ||
| 1235 | tmp_assign_source_1 = LOOKUP_ATTRIBUTE( tmp_source_name_5, const_str_plain_sig ); | ||
| 1236 | if ( tmp_assign_source_1 == NULL ) | ||
| 1237 | { | ||
| 1238 | assert( ERROR_OCCURRED() ); | ||
| 1239 | |||
| 1240 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1241 | |||
| 1242 | |||
| 1243 | exception_lineno = 54; | ||
| 1244 | type_description_1 = "ooo"; | ||
| 1245 | goto frame_exception_exit_1; | ||
| 1246 | } | ||
| 1247 | assert( tmp_inplace_assign_attr_1__start == NULL ); | ||
| 1248 | tmp_inplace_assign_attr_1__start = tmp_assign_source_1; | ||
| 1249 | } | ||
| 1250 | // Tried code: | ||
| 1251 | { | ||
| 1252 | PyObject *tmp_assign_source_2; | ||
| 1253 | PyObject *tmp_left_name_1; | ||
| 1254 | PyObject *tmp_right_name_1; | ||
| 1255 | PyObject *tmp_subscribed_name_3; | ||
| 1256 | PyObject *tmp_subscript_name_3; | ||
| 1257 | CHECK_OBJECT( tmp_inplace_assign_attr_1__start ); | ||
| 1258 | tmp_left_name_1 = tmp_inplace_assign_attr_1__start; | ||
| 1259 | CHECK_OBJECT( par_attributes ); | ||
| 1260 | tmp_subscribed_name_3 = par_attributes; | ||
| 1261 | tmp_subscript_name_3 = const_str_plain_type; | ||
| 1262 | tmp_right_name_1 = LOOKUP_SUBSCRIPT( tmp_subscribed_name_3, tmp_subscript_name_3 ); | ||
| 1263 | if ( tmp_right_name_1 == NULL ) | ||
| 1264 | { | ||
| 1265 | assert( ERROR_OCCURRED() ); | ||
| 1266 | |||
| 1267 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1268 | |||
| 1269 | |||
| 1270 | exception_lineno = 54; | ||
| 1271 | type_description_1 = "ooo"; | ||
| 1272 | goto try_except_handler_2; | ||
| 1273 | } | ||
| 1274 | tmp_assign_source_2 = BINARY_OPERATION( PyNumber_InPlaceAdd, tmp_left_name_1, tmp_right_name_1 ); | ||
| 1275 | Py_DECREF( tmp_right_name_1 ); | ||
| 1276 | if ( tmp_assign_source_2 == NULL ) | ||
| 1277 | { | ||
| 1278 | assert( ERROR_OCCURRED() ); | ||
| 1279 | |||
| 1280 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1281 | |||
| 1282 | |||
| 1283 | exception_lineno = 54; | ||
| 1284 | type_description_1 = "ooo"; | ||
| 1285 | goto try_except_handler_2; | ||
| 1286 | } | ||
| 1287 | assert( tmp_inplace_assign_attr_1__end == NULL ); | ||
| 1288 | tmp_inplace_assign_attr_1__end = tmp_assign_source_2; | ||
| 1289 | } | ||
| 1290 | // Tried code: | ||
| 1291 | { | ||
| 1292 | PyObject *tmp_assattr_name_3; | ||
| 1293 | PyObject *tmp_assattr_target_3; | ||
| 1294 | CHECK_OBJECT( tmp_inplace_assign_attr_1__end ); | ||
| 1295 | tmp_assattr_name_3 = tmp_inplace_assign_attr_1__end; | ||
| 1296 | CHECK_OBJECT( par_self ); | ||
| 1297 | tmp_assattr_target_3 = par_self; | ||
| 1298 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_3, const_str_plain_sig, tmp_assattr_name_3 ); | ||
| 1299 | if ( tmp_result == false ) | ||
| 1300 | { | ||
| 1301 | assert( ERROR_OCCURRED() ); | ||
| 1302 | |||
| 1303 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1304 | |||
| 1305 | |||
| 1306 | exception_lineno = 54; | ||
| 1307 | type_description_1 = "ooo"; | ||
| 1308 | goto try_except_handler_3; | ||
| 1309 | } | ||
| 1310 | } | ||
| 1311 | goto try_end_1; | ||
| 1312 | // Exception handler code: | ||
| 1313 | try_except_handler_3:; | ||
| 1314 | exception_keeper_type_1 = exception_type; | ||
| 1315 | exception_keeper_value_1 = exception_value; | ||
| 1316 | exception_keeper_tb_1 = exception_tb; | ||
| 1317 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1318 | exception_type = NULL; | ||
| 1319 | exception_value = NULL; | ||
| 1320 | exception_tb = NULL; | ||
| 1321 | exception_lineno = 0; | ||
| 1322 | |||
| 1323 | CHECK_OBJECT( (PyObject *)tmp_inplace_assign_attr_1__end ); | ||
| 1324 | Py_DECREF( tmp_inplace_assign_attr_1__end ); | ||
| 1325 | tmp_inplace_assign_attr_1__end = NULL; | ||
| 1326 | |||
| 1327 | // Re-raise. | ||
| 1328 | exception_type = exception_keeper_type_1; | ||
| 1329 | exception_value = exception_keeper_value_1; | ||
| 1330 | exception_tb = exception_keeper_tb_1; | ||
| 1331 | exception_lineno = exception_keeper_lineno_1; | ||
| 1332 | |||
| 1333 | goto try_except_handler_2; | ||
| 1334 | // End of try: | ||
| 1335 | try_end_1:; | ||
| 1336 | goto try_end_2; | ||
| 1337 | // Exception handler code: | ||
| 1338 | try_except_handler_2:; | ||
| 1339 | exception_keeper_type_2 = exception_type; | ||
| 1340 | exception_keeper_value_2 = exception_value; | ||
| 1341 | exception_keeper_tb_2 = exception_tb; | ||
| 1342 | exception_keeper_lineno_2 = exception_lineno; | ||
| 1343 | exception_type = NULL; | ||
| 1344 | exception_value = NULL; | ||
| 1345 | exception_tb = NULL; | ||
| 1346 | exception_lineno = 0; | ||
| 1347 | |||
| 1348 | CHECK_OBJECT( (PyObject *)tmp_inplace_assign_attr_1__start ); | ||
| 1349 | Py_DECREF( tmp_inplace_assign_attr_1__start ); | ||
| 1350 | tmp_inplace_assign_attr_1__start = NULL; | ||
| 1351 | |||
| 1352 | // Re-raise. | ||
| 1353 | exception_type = exception_keeper_type_2; | ||
| 1354 | exception_value = exception_keeper_value_2; | ||
| 1355 | exception_tb = exception_keeper_tb_2; | ||
| 1356 | exception_lineno = exception_keeper_lineno_2; | ||
| 1357 | |||
| 1358 | goto frame_exception_exit_1; | ||
| 1359 | // End of try: | ||
| 1360 | try_end_2:; | ||
| 1361 | CHECK_OBJECT( (PyObject *)tmp_inplace_assign_attr_1__end ); | ||
| 1362 | Py_DECREF( tmp_inplace_assign_attr_1__end ); | ||
| 1363 | tmp_inplace_assign_attr_1__end = NULL; | ||
| 1364 | |||
| 1365 | CHECK_OBJECT( (PyObject *)tmp_inplace_assign_attr_1__start ); | ||
| 1366 | Py_DECREF( tmp_inplace_assign_attr_1__start ); | ||
| 1367 | tmp_inplace_assign_attr_1__start = NULL; | ||
| 1368 | |||
| 1369 | branch_no_5:; | ||
| 1370 | } | ||
| 1371 | branch_no_4:; | ||
| 1372 | } | ||
| 1373 | branch_end_3:; | ||
| 1374 | } | ||
| 1375 | branch_end_1:; | ||
| 1376 | } | ||
| 1377 | |||
| 1378 | #if 0 | ||
| 1379 | RESTORE_FRAME_EXCEPTION( frame_bf482f59396a00033f1561c8ab09ee10 ); | ||
| 1380 | #endif | ||
| 1381 | |||
| 1382 | // Put the previous frame back on top. | ||
| 1383 | popFrameStack(); | ||
| 1384 | |||
| 1385 | goto frame_no_exception_1; | ||
| 1386 | |||
| 1387 | frame_exception_exit_1:; | ||
| 1388 | |||
| 1389 | #if 0 | ||
| 1390 | RESTORE_FRAME_EXCEPTION( frame_bf482f59396a00033f1561c8ab09ee10 ); | ||
| 1391 | #endif | ||
| 1392 | |||
| 1393 | if ( exception_tb == NULL ) | ||
| 1394 | { | ||
| 1395 | exception_tb = MAKE_TRACEBACK( frame_bf482f59396a00033f1561c8ab09ee10, exception_lineno ); | ||
| 1396 | } | ||
| 1397 | else if ( exception_tb->tb_frame != &frame_bf482f59396a00033f1561c8ab09ee10->m_frame ) | ||
| 1398 | { | ||
| 1399 | exception_tb = ADD_TRACEBACK( exception_tb, frame_bf482f59396a00033f1561c8ab09ee10, exception_lineno ); | ||
| 1400 | } | ||
| 1401 | |||
| 1402 | // Attachs locals to frame if any. | ||
| 1403 | Nuitka_Frame_AttachLocals( | ||
| 1404 | (struct Nuitka_FrameObject *)frame_bf482f59396a00033f1561c8ab09ee10, | ||
| 1405 | type_description_1, | ||
| 1406 | par_self, | ||
| 1407 | par_name, | ||
| 1408 | par_attributes | ||
| 1409 | ); | ||
| 1410 | |||
| 1411 | |||
| 1412 | // Release cached frame. | ||
| 1413 | if ( frame_bf482f59396a00033f1561c8ab09ee10 == cache_frame_bf482f59396a00033f1561c8ab09ee10 ) | ||
| 1414 | { | ||
| 1415 | Py_DECREF( frame_bf482f59396a00033f1561c8ab09ee10 ); | ||
| 1416 | } | ||
| 1417 | cache_frame_bf482f59396a00033f1561c8ab09ee10 = NULL; | ||
| 1418 | |||
| 1419 | assertFrameObject( frame_bf482f59396a00033f1561c8ab09ee10 ); | ||
| 1420 | |||
| 1421 | // Put the previous frame back on top. | ||
| 1422 | popFrameStack(); | ||
| 1423 | |||
| 1424 | // Return the error. | ||
| 1425 | goto try_except_handler_1; | ||
| 1426 | |||
| 1427 | frame_no_exception_1:; | ||
| 1428 | tmp_return_value = Py_None; | ||
| 1429 | Py_INCREF( tmp_return_value ); | ||
| 1430 | goto try_return_handler_1; | ||
| 1431 | // tried codes exits in all cases | ||
| 1432 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_3_StartElementHandler ); | ||
| 1433 | return NULL; | ||
| 1434 | // Return handler code: | ||
| 1435 | try_return_handler_1:; | ||
| 1436 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1437 | Py_DECREF( par_self ); | ||
| 1438 | par_self = NULL; | ||
| 1439 | |||
| 1440 | CHECK_OBJECT( (PyObject *)par_name ); | ||
| 1441 | Py_DECREF( par_name ); | ||
| 1442 | par_name = NULL; | ||
| 1443 | |||
| 1444 | CHECK_OBJECT( (PyObject *)par_attributes ); | ||
| 1445 | Py_DECREF( par_attributes ); | ||
| 1446 | par_attributes = NULL; | ||
| 1447 | |||
| 1448 | goto function_return_exit; | ||
| 1449 | // Exception handler code: | ||
| 1450 | try_except_handler_1:; | ||
| 1451 | exception_keeper_type_3 = exception_type; | ||
| 1452 | exception_keeper_value_3 = exception_value; | ||
| 1453 | exception_keeper_tb_3 = exception_tb; | ||
| 1454 | exception_keeper_lineno_3 = exception_lineno; | ||
| 1455 | exception_type = NULL; | ||
| 1456 | exception_value = NULL; | ||
| 1457 | exception_tb = NULL; | ||
| 1458 | exception_lineno = 0; | ||
| 1459 | |||
| 1460 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1461 | Py_DECREF( par_self ); | ||
| 1462 | par_self = NULL; | ||
| 1463 | |||
| 1464 | CHECK_OBJECT( (PyObject *)par_name ); | ||
| 1465 | Py_DECREF( par_name ); | ||
| 1466 | par_name = NULL; | ||
| 1467 | |||
| 1468 | CHECK_OBJECT( (PyObject *)par_attributes ); | ||
| 1469 | Py_DECREF( par_attributes ); | ||
| 1470 | par_attributes = NULL; | ||
| 1471 | |||
| 1472 | // Re-raise. | ||
| 1473 | exception_type = exception_keeper_type_3; | ||
| 1474 | exception_value = exception_keeper_value_3; | ||
| 1475 | exception_tb = exception_keeper_tb_3; | ||
| 1476 | exception_lineno = exception_keeper_lineno_3; | ||
| 1477 | |||
| 1478 | goto function_exception_exit; | ||
| 1479 | // End of try: | ||
| 1480 | |||
| 1481 | // Return statement must have exited already. | ||
| 1482 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_3_StartElementHandler ); | ||
| 1483 | return NULL; | ||
| 1484 | |||
| 1485 | function_exception_exit: | ||
| 1486 | assert( exception_type ); | ||
| 1487 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1488 | |||
| 1489 | return NULL; | ||
| 1490 | |||
| 1491 | function_return_exit: | ||
| 1492 | // Function cleanup code if any. | ||
| 1493 | |||
| 1494 | |||
| 1495 | // Actual function exit with return value, making sure we did not make | ||
| 1496 | // the error status worse despite non-NULL return. | ||
| 1497 | CHECK_OBJECT( tmp_return_value ); | ||
| 1498 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 1499 | return tmp_return_value; | ||
| 1500 | } | ||
| 1501 | |||
| 1502 | |||
| 1503 | static PyObject *impl_dbus$_expat_introspect_parser$$$function_4_EndElementHandler( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 1504 | { | ||
| 1505 | // Preserve error status for checks | ||
| 1506 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1507 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 1508 | #endif | ||
| 1509 | |||
| 1510 | // Local variable declarations. | ||
| 1511 | PyObject *par_self = python_pars[ 0 ]; | ||
| 1512 | PyObject *par_name = python_pars[ 1 ]; | ||
| 1513 | struct Nuitka_FrameObject *frame_899d0693dc9e2c566d398b72bff1ac02; | ||
| 1514 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 1515 | PyObject *exception_type = NULL; | ||
| 1516 | PyObject *exception_value = NULL; | ||
| 1517 | PyTracebackObject *exception_tb = NULL; | ||
| 1518 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 1519 | int tmp_res; | ||
| 1520 | bool tmp_result; | ||
| 1521 | static struct Nuitka_FrameObject *cache_frame_899d0693dc9e2c566d398b72bff1ac02 = NULL; | ||
| 1522 | PyObject *tmp_return_value = NULL; | ||
| 1523 | PyObject *exception_keeper_type_1; | ||
| 1524 | PyObject *exception_keeper_value_1; | ||
| 1525 | PyTracebackObject *exception_keeper_tb_1; | ||
| 1526 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 1527 | |||
| 1528 | // Actual function body. | ||
| 1529 | // Tried code: | ||
| 1530 | MAKE_OR_REUSE_FRAME( cache_frame_899d0693dc9e2c566d398b72bff1ac02, codeobj_899d0693dc9e2c566d398b72bff1ac02, module_dbus$_expat_introspect_parser, sizeof(void *)+sizeof(void *) ); | ||
| 1531 | frame_899d0693dc9e2c566d398b72bff1ac02 = cache_frame_899d0693dc9e2c566d398b72bff1ac02; | ||
| 1532 | |||
| 1533 | // Push the new frame as the currently active one. | ||
| 1534 | pushFrameStack( frame_899d0693dc9e2c566d398b72bff1ac02 ); | ||
| 1535 | |||
| 1536 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 1537 | assert( Py_REFCNT( frame_899d0693dc9e2c566d398b72bff1ac02 ) == 2 ); // Frame stack | ||
| 1538 | |||
| 1539 | // Framed code: | ||
| 1540 | { | ||
| 1541 | nuitka_bool tmp_condition_result_1; | ||
| 1542 | PyObject *tmp_source_name_1; | ||
| 1543 | PyObject *tmp_attribute_value_1; | ||
| 1544 | int tmp_truth_name_1; | ||
| 1545 | CHECK_OBJECT( par_self ); | ||
| 1546 | tmp_source_name_1 = par_self; | ||
| 1547 | tmp_attribute_value_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_in_iface ); | ||
| 1548 | if ( tmp_attribute_value_1 == NULL ) | ||
| 1549 | { | ||
| 1550 | assert( ERROR_OCCURRED() ); | ||
| 1551 | |||
| 1552 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1553 | |||
| 1554 | |||
| 1555 | exception_lineno = 57; | ||
| 1556 | type_description_1 = "oo"; | ||
| 1557 | goto frame_exception_exit_1; | ||
| 1558 | } | ||
| 1559 | tmp_truth_name_1 = CHECK_IF_TRUE( tmp_attribute_value_1 ); | ||
| 1560 | if ( tmp_truth_name_1 == -1 ) | ||
| 1561 | { | ||
| 1562 | assert( ERROR_OCCURRED() ); | ||
| 1563 | |||
| 1564 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1565 | Py_DECREF( tmp_attribute_value_1 ); | ||
| 1566 | |||
| 1567 | exception_lineno = 57; | ||
| 1568 | type_description_1 = "oo"; | ||
| 1569 | goto frame_exception_exit_1; | ||
| 1570 | } | ||
| 1571 | tmp_condition_result_1 = tmp_truth_name_1 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1572 | Py_DECREF( tmp_attribute_value_1 ); | ||
| 1573 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 1574 | { | ||
| 1575 | goto branch_yes_1; | ||
| 1576 | } | ||
| 1577 | else | ||
| 1578 | { | ||
| 1579 | goto branch_no_1; | ||
| 1580 | } | ||
| 1581 | branch_yes_1:; | ||
| 1582 | { | ||
| 1583 | nuitka_bool tmp_condition_result_2; | ||
| 1584 | int tmp_and_left_truth_1; | ||
| 1585 | nuitka_bool tmp_and_left_value_1; | ||
| 1586 | nuitka_bool tmp_and_right_value_1; | ||
| 1587 | PyObject *tmp_operand_name_1; | ||
| 1588 | PyObject *tmp_source_name_2; | ||
| 1589 | PyObject *tmp_compexpr_left_1; | ||
| 1590 | PyObject *tmp_compexpr_right_1; | ||
| 1591 | CHECK_OBJECT( par_self ); | ||
| 1592 | tmp_source_name_2 = par_self; | ||
| 1593 | tmp_operand_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_in_method ); | ||
| 1594 | if ( tmp_operand_name_1 == NULL ) | ||
| 1595 | { | ||
| 1596 | assert( ERROR_OCCURRED() ); | ||
| 1597 | |||
| 1598 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1599 | |||
| 1600 | |||
| 1601 | exception_lineno = 58; | ||
| 1602 | type_description_1 = "oo"; | ||
| 1603 | goto frame_exception_exit_1; | ||
| 1604 | } | ||
| 1605 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 1606 | Py_DECREF( tmp_operand_name_1 ); | ||
| 1607 | if ( tmp_res == -1 ) | ||
| 1608 | { | ||
| 1609 | assert( ERROR_OCCURRED() ); | ||
| 1610 | |||
| 1611 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1612 | |||
| 1613 | |||
| 1614 | exception_lineno = 58; | ||
| 1615 | type_description_1 = "oo"; | ||
| 1616 | goto frame_exception_exit_1; | ||
| 1617 | } | ||
| 1618 | tmp_and_left_value_1 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1619 | tmp_and_left_truth_1 = tmp_and_left_value_1 == NUITKA_BOOL_TRUE ? 1 : 0; | ||
| 1620 | if ( tmp_and_left_truth_1 == 1 ) | ||
| 1621 | { | ||
| 1622 | goto and_right_1; | ||
| 1623 | } | ||
| 1624 | else | ||
| 1625 | { | ||
| 1626 | goto and_left_1; | ||
| 1627 | } | ||
| 1628 | and_right_1:; | ||
| 1629 | CHECK_OBJECT( par_name ); | ||
| 1630 | tmp_compexpr_left_1 = par_name; | ||
| 1631 | tmp_compexpr_right_1 = const_str_plain_interface; | ||
| 1632 | tmp_res = RICH_COMPARE_BOOL_EQ_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 1633 | if ( tmp_res == -1 ) | ||
| 1634 | { | ||
| 1635 | assert( ERROR_OCCURRED() ); | ||
| 1636 | |||
| 1637 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1638 | |||
| 1639 | |||
| 1640 | exception_lineno = 58; | ||
| 1641 | type_description_1 = "oo"; | ||
| 1642 | goto frame_exception_exit_1; | ||
| 1643 | } | ||
| 1644 | tmp_and_right_value_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1645 | tmp_condition_result_2 = tmp_and_right_value_1; | ||
| 1646 | goto and_end_1; | ||
| 1647 | and_left_1:; | ||
| 1648 | tmp_condition_result_2 = tmp_and_left_value_1; | ||
| 1649 | and_end_1:; | ||
| 1650 | if ( tmp_condition_result_2 == NUITKA_BOOL_TRUE ) | ||
| 1651 | { | ||
| 1652 | goto branch_yes_2; | ||
| 1653 | } | ||
| 1654 | else | ||
| 1655 | { | ||
| 1656 | goto branch_no_2; | ||
| 1657 | } | ||
| 1658 | branch_yes_2:; | ||
| 1659 | { | ||
| 1660 | PyObject *tmp_assattr_name_1; | ||
| 1661 | PyObject *tmp_assattr_target_1; | ||
| 1662 | tmp_assattr_name_1 = const_str_empty; | ||
| 1663 | CHECK_OBJECT( par_self ); | ||
| 1664 | tmp_assattr_target_1 = par_self; | ||
| 1665 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_in_iface, tmp_assattr_name_1 ); | ||
| 1666 | if ( tmp_result == false ) | ||
| 1667 | { | ||
| 1668 | assert( ERROR_OCCURRED() ); | ||
| 1669 | |||
| 1670 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1671 | |||
| 1672 | |||
| 1673 | exception_lineno = 59; | ||
| 1674 | type_description_1 = "oo"; | ||
| 1675 | goto frame_exception_exit_1; | ||
| 1676 | } | ||
| 1677 | } | ||
| 1678 | goto branch_end_2; | ||
| 1679 | branch_no_2:; | ||
| 1680 | { | ||
| 1681 | nuitka_bool tmp_condition_result_3; | ||
| 1682 | int tmp_and_left_truth_2; | ||
| 1683 | nuitka_bool tmp_and_left_value_2; | ||
| 1684 | nuitka_bool tmp_and_right_value_2; | ||
| 1685 | PyObject *tmp_source_name_3; | ||
| 1686 | PyObject *tmp_attribute_value_2; | ||
| 1687 | int tmp_truth_name_2; | ||
| 1688 | PyObject *tmp_compexpr_left_2; | ||
| 1689 | PyObject *tmp_compexpr_right_2; | ||
| 1690 | CHECK_OBJECT( par_self ); | ||
| 1691 | tmp_source_name_3 = par_self; | ||
| 1692 | tmp_attribute_value_2 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_in_method ); | ||
| 1693 | if ( tmp_attribute_value_2 == NULL ) | ||
| 1694 | { | ||
| 1695 | assert( ERROR_OCCURRED() ); | ||
| 1696 | |||
| 1697 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1698 | |||
| 1699 | |||
| 1700 | exception_lineno = 60; | ||
| 1701 | type_description_1 = "oo"; | ||
| 1702 | goto frame_exception_exit_1; | ||
| 1703 | } | ||
| 1704 | tmp_truth_name_2 = CHECK_IF_TRUE( tmp_attribute_value_2 ); | ||
| 1705 | if ( tmp_truth_name_2 == -1 ) | ||
| 1706 | { | ||
| 1707 | assert( ERROR_OCCURRED() ); | ||
| 1708 | |||
| 1709 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1710 | Py_DECREF( tmp_attribute_value_2 ); | ||
| 1711 | |||
| 1712 | exception_lineno = 60; | ||
| 1713 | type_description_1 = "oo"; | ||
| 1714 | goto frame_exception_exit_1; | ||
| 1715 | } | ||
| 1716 | tmp_and_left_value_2 = tmp_truth_name_2 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1717 | Py_DECREF( tmp_attribute_value_2 ); | ||
| 1718 | tmp_and_left_truth_2 = tmp_and_left_value_2 == NUITKA_BOOL_TRUE ? 1 : 0; | ||
| 1719 | if ( tmp_and_left_truth_2 == 1 ) | ||
| 1720 | { | ||
| 1721 | goto and_right_2; | ||
| 1722 | } | ||
| 1723 | else | ||
| 1724 | { | ||
| 1725 | goto and_left_2; | ||
| 1726 | } | ||
| 1727 | and_right_2:; | ||
| 1728 | CHECK_OBJECT( par_name ); | ||
| 1729 | tmp_compexpr_left_2 = par_name; | ||
| 1730 | tmp_compexpr_right_2 = const_str_plain_method; | ||
| 1731 | tmp_res = RICH_COMPARE_BOOL_EQ_OBJECT_OBJECT( tmp_compexpr_left_2, tmp_compexpr_right_2 ); | ||
| 1732 | if ( tmp_res == -1 ) | ||
| 1733 | { | ||
| 1734 | assert( ERROR_OCCURRED() ); | ||
| 1735 | |||
| 1736 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1737 | |||
| 1738 | |||
| 1739 | exception_lineno = 60; | ||
| 1740 | type_description_1 = "oo"; | ||
| 1741 | goto frame_exception_exit_1; | ||
| 1742 | } | ||
| 1743 | tmp_and_right_value_2 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1744 | tmp_condition_result_3 = tmp_and_right_value_2; | ||
| 1745 | goto and_end_2; | ||
| 1746 | and_left_2:; | ||
| 1747 | tmp_condition_result_3 = tmp_and_left_value_2; | ||
| 1748 | and_end_2:; | ||
| 1749 | if ( tmp_condition_result_3 == NUITKA_BOOL_TRUE ) | ||
| 1750 | { | ||
| 1751 | goto branch_yes_3; | ||
| 1752 | } | ||
| 1753 | else | ||
| 1754 | { | ||
| 1755 | goto branch_no_3; | ||
| 1756 | } | ||
| 1757 | branch_yes_3:; | ||
| 1758 | { | ||
| 1759 | PyObject *tmp_ass_subvalue_1; | ||
| 1760 | PyObject *tmp_source_name_4; | ||
| 1761 | PyObject *tmp_ass_subscribed_1; | ||
| 1762 | PyObject *tmp_source_name_5; | ||
| 1763 | PyObject *tmp_ass_subscript_1; | ||
| 1764 | PyObject *tmp_left_name_1; | ||
| 1765 | PyObject *tmp_left_name_2; | ||
| 1766 | PyObject *tmp_source_name_6; | ||
| 1767 | PyObject *tmp_right_name_1; | ||
| 1768 | PyObject *tmp_right_name_2; | ||
| 1769 | PyObject *tmp_source_name_7; | ||
| 1770 | CHECK_OBJECT( par_self ); | ||
| 1771 | tmp_source_name_4 = par_self; | ||
| 1772 | tmp_ass_subvalue_1 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain_sig ); | ||
| 1773 | if ( tmp_ass_subvalue_1 == NULL ) | ||
| 1774 | { | ||
| 1775 | assert( ERROR_OCCURRED() ); | ||
| 1776 | |||
| 1777 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1778 | |||
| 1779 | |||
| 1780 | exception_lineno = 61; | ||
| 1781 | type_description_1 = "oo"; | ||
| 1782 | goto frame_exception_exit_1; | ||
| 1783 | } | ||
| 1784 | CHECK_OBJECT( par_self ); | ||
| 1785 | tmp_source_name_5 = par_self; | ||
| 1786 | tmp_ass_subscribed_1 = LOOKUP_ATTRIBUTE( tmp_source_name_5, const_str_plain_map ); | ||
| 1787 | if ( tmp_ass_subscribed_1 == NULL ) | ||
| 1788 | { | ||
| 1789 | assert( ERROR_OCCURRED() ); | ||
| 1790 | |||
| 1791 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1792 | Py_DECREF( tmp_ass_subvalue_1 ); | ||
| 1793 | |||
| 1794 | exception_lineno = 61; | ||
| 1795 | type_description_1 = "oo"; | ||
| 1796 | goto frame_exception_exit_1; | ||
| 1797 | } | ||
| 1798 | CHECK_OBJECT( par_self ); | ||
| 1799 | tmp_source_name_6 = par_self; | ||
| 1800 | tmp_left_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_6, const_str_plain_in_iface ); | ||
| 1801 | if ( tmp_left_name_2 == NULL ) | ||
| 1802 | { | ||
| 1803 | assert( ERROR_OCCURRED() ); | ||
| 1804 | |||
| 1805 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1806 | Py_DECREF( tmp_ass_subvalue_1 ); | ||
| 1807 | Py_DECREF( tmp_ass_subscribed_1 ); | ||
| 1808 | |||
| 1809 | exception_lineno = 61; | ||
| 1810 | type_description_1 = "oo"; | ||
| 1811 | goto frame_exception_exit_1; | ||
| 1812 | } | ||
| 1813 | tmp_right_name_1 = const_str_dot; | ||
| 1814 | tmp_left_name_1 = BINARY_OPERATION_ADD_OBJECT_UNICODE( tmp_left_name_2, tmp_right_name_1 ); | ||
| 1815 | Py_DECREF( tmp_left_name_2 ); | ||
| 1816 | if ( tmp_left_name_1 == NULL ) | ||
| 1817 | { | ||
| 1818 | assert( ERROR_OCCURRED() ); | ||
| 1819 | |||
| 1820 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1821 | Py_DECREF( tmp_ass_subvalue_1 ); | ||
| 1822 | Py_DECREF( tmp_ass_subscribed_1 ); | ||
| 1823 | |||
| 1824 | exception_lineno = 61; | ||
| 1825 | type_description_1 = "oo"; | ||
| 1826 | goto frame_exception_exit_1; | ||
| 1827 | } | ||
| 1828 | CHECK_OBJECT( par_self ); | ||
| 1829 | tmp_source_name_7 = par_self; | ||
| 1830 | tmp_right_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_7, const_str_plain_in_method ); | ||
| 1831 | if ( tmp_right_name_2 == NULL ) | ||
| 1832 | { | ||
| 1833 | assert( ERROR_OCCURRED() ); | ||
| 1834 | |||
| 1835 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1836 | Py_DECREF( tmp_ass_subvalue_1 ); | ||
| 1837 | Py_DECREF( tmp_ass_subscribed_1 ); | ||
| 1838 | Py_DECREF( tmp_left_name_1 ); | ||
| 1839 | |||
| 1840 | exception_lineno = 61; | ||
| 1841 | type_description_1 = "oo"; | ||
| 1842 | goto frame_exception_exit_1; | ||
| 1843 | } | ||
| 1844 | tmp_ass_subscript_1 = BINARY_OPERATION_ADD_OBJECT_OBJECT( tmp_left_name_1, tmp_right_name_2 ); | ||
| 1845 | Py_DECREF( tmp_left_name_1 ); | ||
| 1846 | Py_DECREF( tmp_right_name_2 ); | ||
| 1847 | if ( tmp_ass_subscript_1 == NULL ) | ||
| 1848 | { | ||
| 1849 | assert( ERROR_OCCURRED() ); | ||
| 1850 | |||
| 1851 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1852 | Py_DECREF( tmp_ass_subvalue_1 ); | ||
| 1853 | Py_DECREF( tmp_ass_subscribed_1 ); | ||
| 1854 | |||
| 1855 | exception_lineno = 61; | ||
| 1856 | type_description_1 = "oo"; | ||
| 1857 | goto frame_exception_exit_1; | ||
| 1858 | } | ||
| 1859 | tmp_result = SET_SUBSCRIPT( tmp_ass_subscribed_1, tmp_ass_subscript_1, tmp_ass_subvalue_1 ); | ||
| 1860 | Py_DECREF( tmp_ass_subscribed_1 ); | ||
| 1861 | Py_DECREF( tmp_ass_subscript_1 ); | ||
| 1862 | Py_DECREF( tmp_ass_subvalue_1 ); | ||
| 1863 | if ( tmp_result == false ) | ||
| 1864 | { | ||
| 1865 | assert( ERROR_OCCURRED() ); | ||
| 1866 | |||
| 1867 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1868 | |||
| 1869 | |||
| 1870 | exception_lineno = 61; | ||
| 1871 | type_description_1 = "oo"; | ||
| 1872 | goto frame_exception_exit_1; | ||
| 1873 | } | ||
| 1874 | } | ||
| 1875 | { | ||
| 1876 | PyObject *tmp_assattr_name_2; | ||
| 1877 | PyObject *tmp_assattr_target_2; | ||
| 1878 | tmp_assattr_name_2 = const_str_empty; | ||
| 1879 | CHECK_OBJECT( par_self ); | ||
| 1880 | tmp_assattr_target_2 = par_self; | ||
| 1881 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_in_method, tmp_assattr_name_2 ); | ||
| 1882 | if ( tmp_result == false ) | ||
| 1883 | { | ||
| 1884 | assert( ERROR_OCCURRED() ); | ||
| 1885 | |||
| 1886 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1887 | |||
| 1888 | |||
| 1889 | exception_lineno = 62; | ||
| 1890 | type_description_1 = "oo"; | ||
| 1891 | goto frame_exception_exit_1; | ||
| 1892 | } | ||
| 1893 | } | ||
| 1894 | { | ||
| 1895 | PyObject *tmp_assattr_name_3; | ||
| 1896 | PyObject *tmp_assattr_target_3; | ||
| 1897 | tmp_assattr_name_3 = const_str_empty; | ||
| 1898 | CHECK_OBJECT( par_self ); | ||
| 1899 | tmp_assattr_target_3 = par_self; | ||
| 1900 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_3, const_str_plain_sig, tmp_assattr_name_3 ); | ||
| 1901 | if ( tmp_result == false ) | ||
| 1902 | { | ||
| 1903 | assert( ERROR_OCCURRED() ); | ||
| 1904 | |||
| 1905 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1906 | |||
| 1907 | |||
| 1908 | exception_lineno = 63; | ||
| 1909 | type_description_1 = "oo"; | ||
| 1910 | goto frame_exception_exit_1; | ||
| 1911 | } | ||
| 1912 | } | ||
| 1913 | branch_no_3:; | ||
| 1914 | } | ||
| 1915 | branch_end_2:; | ||
| 1916 | } | ||
| 1917 | branch_no_1:; | ||
| 1918 | } | ||
| 1919 | |||
| 1920 | #if 0 | ||
| 1921 | RESTORE_FRAME_EXCEPTION( frame_899d0693dc9e2c566d398b72bff1ac02 ); | ||
| 1922 | #endif | ||
| 1923 | |||
| 1924 | // Put the previous frame back on top. | ||
| 1925 | popFrameStack(); | ||
| 1926 | |||
| 1927 | goto frame_no_exception_1; | ||
| 1928 | |||
| 1929 | frame_exception_exit_1:; | ||
| 1930 | |||
| 1931 | #if 0 | ||
| 1932 | RESTORE_FRAME_EXCEPTION( frame_899d0693dc9e2c566d398b72bff1ac02 ); | ||
| 1933 | #endif | ||
| 1934 | |||
| 1935 | if ( exception_tb == NULL ) | ||
| 1936 | { | ||
| 1937 | exception_tb = MAKE_TRACEBACK( frame_899d0693dc9e2c566d398b72bff1ac02, exception_lineno ); | ||
| 1938 | } | ||
| 1939 | else if ( exception_tb->tb_frame != &frame_899d0693dc9e2c566d398b72bff1ac02->m_frame ) | ||
| 1940 | { | ||
| 1941 | exception_tb = ADD_TRACEBACK( exception_tb, frame_899d0693dc9e2c566d398b72bff1ac02, exception_lineno ); | ||
| 1942 | } | ||
| 1943 | |||
| 1944 | // Attachs locals to frame if any. | ||
| 1945 | Nuitka_Frame_AttachLocals( | ||
| 1946 | (struct Nuitka_FrameObject *)frame_899d0693dc9e2c566d398b72bff1ac02, | ||
| 1947 | type_description_1, | ||
| 1948 | par_self, | ||
| 1949 | par_name | ||
| 1950 | ); | ||
| 1951 | |||
| 1952 | |||
| 1953 | // Release cached frame. | ||
| 1954 | if ( frame_899d0693dc9e2c566d398b72bff1ac02 == cache_frame_899d0693dc9e2c566d398b72bff1ac02 ) | ||
| 1955 | { | ||
| 1956 | Py_DECREF( frame_899d0693dc9e2c566d398b72bff1ac02 ); | ||
| 1957 | } | ||
| 1958 | cache_frame_899d0693dc9e2c566d398b72bff1ac02 = NULL; | ||
| 1959 | |||
| 1960 | assertFrameObject( frame_899d0693dc9e2c566d398b72bff1ac02 ); | ||
| 1961 | |||
| 1962 | // Put the previous frame back on top. | ||
| 1963 | popFrameStack(); | ||
| 1964 | |||
| 1965 | // Return the error. | ||
| 1966 | goto try_except_handler_1; | ||
| 1967 | |||
| 1968 | frame_no_exception_1:; | ||
| 1969 | tmp_return_value = Py_None; | ||
| 1970 | Py_INCREF( tmp_return_value ); | ||
| 1971 | goto try_return_handler_1; | ||
| 1972 | // tried codes exits in all cases | ||
| 1973 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_4_EndElementHandler ); | ||
| 1974 | return NULL; | ||
| 1975 | // Return handler code: | ||
| 1976 | try_return_handler_1:; | ||
| 1977 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1978 | Py_DECREF( par_self ); | ||
| 1979 | par_self = NULL; | ||
| 1980 | |||
| 1981 | CHECK_OBJECT( (PyObject *)par_name ); | ||
| 1982 | Py_DECREF( par_name ); | ||
| 1983 | par_name = NULL; | ||
| 1984 | |||
| 1985 | goto function_return_exit; | ||
| 1986 | // Exception handler code: | ||
| 1987 | try_except_handler_1:; | ||
| 1988 | exception_keeper_type_1 = exception_type; | ||
| 1989 | exception_keeper_value_1 = exception_value; | ||
| 1990 | exception_keeper_tb_1 = exception_tb; | ||
| 1991 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1992 | exception_type = NULL; | ||
| 1993 | exception_value = NULL; | ||
| 1994 | exception_tb = NULL; | ||
| 1995 | exception_lineno = 0; | ||
| 1996 | |||
| 1997 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1998 | Py_DECREF( par_self ); | ||
| 1999 | par_self = NULL; | ||
| 2000 | |||
| 2001 | CHECK_OBJECT( (PyObject *)par_name ); | ||
| 2002 | Py_DECREF( par_name ); | ||
| 2003 | par_name = NULL; | ||
| 2004 | |||
| 2005 | // Re-raise. | ||
| 2006 | exception_type = exception_keeper_type_1; | ||
| 2007 | exception_value = exception_keeper_value_1; | ||
| 2008 | exception_tb = exception_keeper_tb_1; | ||
| 2009 | exception_lineno = exception_keeper_lineno_1; | ||
| 2010 | |||
| 2011 | goto function_exception_exit; | ||
| 2012 | // End of try: | ||
| 2013 | |||
| 2014 | // Return statement must have exited already. | ||
| 2015 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_4_EndElementHandler ); | ||
| 2016 | return NULL; | ||
| 2017 | |||
| 2018 | function_exception_exit: | ||
| 2019 | assert( exception_type ); | ||
| 2020 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 2021 | |||
| 2022 | return NULL; | ||
| 2023 | |||
| 2024 | function_return_exit: | ||
| 2025 | // Function cleanup code if any. | ||
| 2026 | |||
| 2027 | |||
| 2028 | // Actual function exit with return value, making sure we did not make | ||
| 2029 | // the error status worse despite non-NULL return. | ||
| 2030 | CHECK_OBJECT( tmp_return_value ); | ||
| 2031 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 2032 | return tmp_return_value; | ||
| 2033 | } | ||
| 2034 | |||
| 2035 | |||
| 2036 | static PyObject *impl_dbus$_expat_introspect_parser$$$function_5_process_introspection_data( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 2037 | { | ||
| 2038 | // Preserve error status for checks | ||
| 2039 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 2040 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 2041 | #endif | ||
| 2042 | |||
| 2043 | // Local variable declarations. | ||
| 2044 | PyObject *par_data = python_pars[ 0 ]; | ||
| 2045 | PyObject *var_e = NULL; | ||
| 2046 | struct Nuitka_FrameObject *frame_dbb49e89a876483f119ad43743fc242b; | ||
| 2047 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 2048 | PyObject *tmp_return_value = NULL; | ||
| 2049 | PyObject *exception_type = NULL; | ||
| 2050 | PyObject *exception_value = NULL; | ||
| 2051 | PyTracebackObject *exception_tb = NULL; | ||
| 2052 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 2053 | PyObject *exception_keeper_type_1; | ||
| 2054 | PyObject *exception_keeper_value_1; | ||
| 2055 | PyTracebackObject *exception_keeper_tb_1; | ||
| 2056 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 2057 | PyObject *exception_preserved_type_1; | ||
| 2058 | PyObject *exception_preserved_value_1; | ||
| 2059 | PyTracebackObject *exception_preserved_tb_1; | ||
| 2060 | int tmp_res; | ||
| 2061 | PyObject *exception_keeper_type_2; | ||
| 2062 | PyObject *exception_keeper_value_2; | ||
| 2063 | PyTracebackObject *exception_keeper_tb_2; | ||
| 2064 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 2065 | bool tmp_result; | ||
| 2066 | PyObject *exception_keeper_type_3; | ||
| 2067 | PyObject *exception_keeper_value_3; | ||
| 2068 | PyTracebackObject *exception_keeper_tb_3; | ||
| 2069 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; | ||
| 2070 | static struct Nuitka_FrameObject *cache_frame_dbb49e89a876483f119ad43743fc242b = NULL; | ||
| 2071 | PyObject *exception_keeper_type_4; | ||
| 2072 | PyObject *exception_keeper_value_4; | ||
| 2073 | PyTracebackObject *exception_keeper_tb_4; | ||
| 2074 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_4; | ||
| 2075 | |||
| 2076 | // Actual function body. | ||
| 2077 | // Tried code: | ||
| 2078 | MAKE_OR_REUSE_FRAME( cache_frame_dbb49e89a876483f119ad43743fc242b, codeobj_dbb49e89a876483f119ad43743fc242b, module_dbus$_expat_introspect_parser, sizeof(void *)+sizeof(void *) ); | ||
| 2079 | frame_dbb49e89a876483f119ad43743fc242b = cache_frame_dbb49e89a876483f119ad43743fc242b; | ||
| 2080 | |||
| 2081 | // Push the new frame as the currently active one. | ||
| 2082 | pushFrameStack( frame_dbb49e89a876483f119ad43743fc242b ); | ||
| 2083 | |||
| 2084 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 2085 | assert( Py_REFCNT( frame_dbb49e89a876483f119ad43743fc242b ) == 2 ); // Frame stack | ||
| 2086 | |||
| 2087 | // Framed code: | ||
| 2088 | // Tried code: | ||
| 2089 | { | ||
| 2090 | PyObject *tmp_called_instance_1; | ||
| 2091 | PyObject *tmp_called_name_1; | ||
| 2092 | PyObject *tmp_mvar_value_1; | ||
| 2093 | PyObject *tmp_args_element_name_1; | ||
| 2094 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain__Parser ); | ||
| 2095 | |||
| 2096 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 2097 | { | ||
| 2098 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__Parser ); | ||
| 2099 | } | ||
| 2100 | |||
| 2101 | if ( tmp_mvar_value_1 == NULL ) | ||
| 2102 | { | ||
| 2103 | |||
| 2104 | exception_type = PyExc_NameError; | ||
| 2105 | Py_INCREF( exception_type ); | ||
| 2106 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_Parser" ); | ||
| 2107 | exception_tb = NULL; | ||
| 2108 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2109 | CHAIN_EXCEPTION( exception_value ); | ||
| 2110 | |||
| 2111 | exception_lineno = 83; | ||
| 2112 | type_description_1 = "oo"; | ||
| 2113 | goto try_except_handler_2; | ||
| 2114 | } | ||
| 2115 | |||
| 2116 | tmp_called_name_1 = tmp_mvar_value_1; | ||
| 2117 | frame_dbb49e89a876483f119ad43743fc242b->m_frame.f_lineno = 83; | ||
| 2118 | tmp_called_instance_1 = CALL_FUNCTION_NO_ARGS( tmp_called_name_1 ); | ||
| 2119 | if ( tmp_called_instance_1 == NULL ) | ||
| 2120 | { | ||
| 2121 | assert( ERROR_OCCURRED() ); | ||
| 2122 | |||
| 2123 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2124 | |||
| 2125 | |||
| 2126 | exception_lineno = 83; | ||
| 2127 | type_description_1 = "oo"; | ||
| 2128 | goto try_except_handler_2; | ||
| 2129 | } | ||
| 2130 | CHECK_OBJECT( par_data ); | ||
| 2131 | tmp_args_element_name_1 = par_data; | ||
| 2132 | frame_dbb49e89a876483f119ad43743fc242b->m_frame.f_lineno = 83; | ||
| 2133 | { | ||
| 2134 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 2135 | tmp_return_value = CALL_METHOD_WITH_ARGS1( tmp_called_instance_1, const_str_plain_parse, call_args ); | ||
| 2136 | } | ||
| 2137 | |||
| 2138 | Py_DECREF( tmp_called_instance_1 ); | ||
| 2139 | if ( tmp_return_value == NULL ) | ||
| 2140 | { | ||
| 2141 | assert( ERROR_OCCURRED() ); | ||
| 2142 | |||
| 2143 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2144 | |||
| 2145 | |||
| 2146 | exception_lineno = 83; | ||
| 2147 | type_description_1 = "oo"; | ||
| 2148 | goto try_except_handler_2; | ||
| 2149 | } | ||
| 2150 | goto frame_return_exit_1; | ||
| 2151 | } | ||
| 2152 | // tried codes exits in all cases | ||
| 2153 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_5_process_introspection_data ); | ||
| 2154 | return NULL; | ||
| 2155 | // Exception handler code: | ||
| 2156 | try_except_handler_2:; | ||
| 2157 | exception_keeper_type_1 = exception_type; | ||
| 2158 | exception_keeper_value_1 = exception_value; | ||
| 2159 | exception_keeper_tb_1 = exception_tb; | ||
| 2160 | exception_keeper_lineno_1 = exception_lineno; | ||
| 2161 | exception_type = NULL; | ||
| 2162 | exception_value = NULL; | ||
| 2163 | exception_tb = NULL; | ||
| 2164 | exception_lineno = 0; | ||
| 2165 | |||
| 2166 | // Preserve existing published exception. | ||
| 2167 | exception_preserved_type_1 = EXC_TYPE(PyThreadState_GET()); | ||
| 2168 | Py_XINCREF( exception_preserved_type_1 ); | ||
| 2169 | exception_preserved_value_1 = EXC_VALUE(PyThreadState_GET()); | ||
| 2170 | Py_XINCREF( exception_preserved_value_1 ); | ||
| 2171 | exception_preserved_tb_1 = (PyTracebackObject *)EXC_TRACEBACK(PyThreadState_GET()); | ||
| 2172 | Py_XINCREF( exception_preserved_tb_1 ); | ||
| 2173 | |||
| 2174 | if ( exception_keeper_tb_1 == NULL ) | ||
| 2175 | { | ||
| 2176 | exception_keeper_tb_1 = MAKE_TRACEBACK( frame_dbb49e89a876483f119ad43743fc242b, exception_keeper_lineno_1 ); | ||
| 2177 | } | ||
| 2178 | else if ( exception_keeper_lineno_1 != 0 ) | ||
| 2179 | { | ||
| 2180 | exception_keeper_tb_1 = ADD_TRACEBACK( exception_keeper_tb_1, frame_dbb49e89a876483f119ad43743fc242b, exception_keeper_lineno_1 ); | ||
| 2181 | } | ||
| 2182 | |||
| 2183 | NORMALIZE_EXCEPTION( &exception_keeper_type_1, &exception_keeper_value_1, &exception_keeper_tb_1 ); | ||
| 2184 | PyException_SetTraceback( exception_keeper_value_1, (PyObject *)exception_keeper_tb_1 ); | ||
| 2185 | PUBLISH_EXCEPTION( &exception_keeper_type_1, &exception_keeper_value_1, &exception_keeper_tb_1 ); | ||
| 2186 | // Tried code: | ||
| 2187 | { | ||
| 2188 | nuitka_bool tmp_condition_result_1; | ||
| 2189 | PyObject *tmp_compexpr_left_1; | ||
| 2190 | PyObject *tmp_compexpr_right_1; | ||
| 2191 | tmp_compexpr_left_1 = EXC_TYPE(PyThreadState_GET()); | ||
| 2192 | tmp_compexpr_right_1 = PyExc_Exception; | ||
| 2193 | tmp_res = EXCEPTION_MATCH_BOOL( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 2194 | if ( tmp_res == -1 ) | ||
| 2195 | { | ||
| 2196 | assert( ERROR_OCCURRED() ); | ||
| 2197 | |||
| 2198 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2199 | |||
| 2200 | |||
| 2201 | exception_lineno = 84; | ||
| 2202 | type_description_1 = "oo"; | ||
| 2203 | goto try_except_handler_3; | ||
| 2204 | } | ||
| 2205 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2206 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 2207 | { | ||
| 2208 | goto branch_yes_1; | ||
| 2209 | } | ||
| 2210 | else | ||
| 2211 | { | ||
| 2212 | goto branch_no_1; | ||
| 2213 | } | ||
| 2214 | branch_yes_1:; | ||
| 2215 | { | ||
| 2216 | PyObject *tmp_assign_source_1; | ||
| 2217 | tmp_assign_source_1 = EXC_VALUE(PyThreadState_GET()); | ||
| 2218 | assert( var_e == NULL ); | ||
| 2219 | Py_INCREF( tmp_assign_source_1 ); | ||
| 2220 | var_e = tmp_assign_source_1; | ||
| 2221 | } | ||
| 2222 | // Tried code: | ||
| 2223 | { | ||
| 2224 | PyObject *tmp_raise_type_1; | ||
| 2225 | PyObject *tmp_called_name_2; | ||
| 2226 | PyObject *tmp_mvar_value_2; | ||
| 2227 | PyObject *tmp_args_element_name_2; | ||
| 2228 | PyObject *tmp_left_name_1; | ||
| 2229 | PyObject *tmp_right_name_1; | ||
| 2230 | PyObject *tmp_tuple_element_1; | ||
| 2231 | PyObject *tmp_source_name_1; | ||
| 2232 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain_IntrospectionParserException ); | ||
| 2233 | |||
| 2234 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 2235 | { | ||
| 2236 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_IntrospectionParserException ); | ||
| 2237 | } | ||
| 2238 | |||
| 2239 | if ( tmp_mvar_value_2 == NULL ) | ||
| 2240 | { | ||
| 2241 | |||
| 2242 | exception_type = PyExc_NameError; | ||
| 2243 | Py_INCREF( exception_type ); | ||
| 2244 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "IntrospectionParserException" ); | ||
| 2245 | exception_tb = NULL; | ||
| 2246 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2247 | CHAIN_EXCEPTION( exception_value ); | ||
| 2248 | |||
| 2249 | exception_lineno = 85; | ||
| 2250 | type_description_1 = "oo"; | ||
| 2251 | goto try_except_handler_4; | ||
| 2252 | } | ||
| 2253 | |||
| 2254 | tmp_called_name_2 = tmp_mvar_value_2; | ||
| 2255 | tmp_left_name_1 = const_str_digest_b0cc034d9177fde48a3b44ac122139d9; | ||
| 2256 | CHECK_OBJECT( var_e ); | ||
| 2257 | tmp_source_name_1 = var_e; | ||
| 2258 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE_CLASS_SLOT( tmp_source_name_1 ); | ||
| 2259 | if ( tmp_tuple_element_1 == NULL ) | ||
| 2260 | { | ||
| 2261 | assert( ERROR_OCCURRED() ); | ||
| 2262 | |||
| 2263 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2264 | |||
| 2265 | |||
| 2266 | exception_lineno = 85; | ||
| 2267 | type_description_1 = "oo"; | ||
| 2268 | goto try_except_handler_4; | ||
| 2269 | } | ||
| 2270 | tmp_right_name_1 = PyTuple_New( 2 ); | ||
| 2271 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_1 ); | ||
| 2272 | CHECK_OBJECT( var_e ); | ||
| 2273 | tmp_tuple_element_1 = var_e; | ||
| 2274 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 2275 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_1 ); | ||
| 2276 | tmp_args_element_name_2 = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 2277 | Py_DECREF( tmp_right_name_1 ); | ||
| 2278 | if ( tmp_args_element_name_2 == NULL ) | ||
| 2279 | { | ||
| 2280 | assert( ERROR_OCCURRED() ); | ||
| 2281 | |||
| 2282 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2283 | |||
| 2284 | |||
| 2285 | exception_lineno = 85; | ||
| 2286 | type_description_1 = "oo"; | ||
| 2287 | goto try_except_handler_4; | ||
| 2288 | } | ||
| 2289 | frame_dbb49e89a876483f119ad43743fc242b->m_frame.f_lineno = 85; | ||
| 2290 | { | ||
| 2291 | PyObject *call_args[] = { tmp_args_element_name_2 }; | ||
| 2292 | tmp_raise_type_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_2, call_args ); | ||
| 2293 | } | ||
| 2294 | |||
| 2295 | Py_DECREF( tmp_args_element_name_2 ); | ||
| 2296 | if ( tmp_raise_type_1 == NULL ) | ||
| 2297 | { | ||
| 2298 | assert( ERROR_OCCURRED() ); | ||
| 2299 | |||
| 2300 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2301 | |||
| 2302 | |||
| 2303 | exception_lineno = 85; | ||
| 2304 | type_description_1 = "oo"; | ||
| 2305 | goto try_except_handler_4; | ||
| 2306 | } | ||
| 2307 | exception_type = tmp_raise_type_1; | ||
| 2308 | exception_lineno = 85; | ||
| 2309 | RAISE_EXCEPTION_WITH_TYPE( &exception_type, &exception_value, &exception_tb ); | ||
| 2310 | type_description_1 = "oo"; | ||
| 2311 | goto try_except_handler_4; | ||
| 2312 | } | ||
| 2313 | // tried codes exits in all cases | ||
| 2314 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_5_process_introspection_data ); | ||
| 2315 | return NULL; | ||
| 2316 | // Exception handler code: | ||
| 2317 | try_except_handler_4:; | ||
| 2318 | exception_keeper_type_2 = exception_type; | ||
| 2319 | exception_keeper_value_2 = exception_value; | ||
| 2320 | exception_keeper_tb_2 = exception_tb; | ||
| 2321 | exception_keeper_lineno_2 = exception_lineno; | ||
| 2322 | exception_type = NULL; | ||
| 2323 | exception_value = NULL; | ||
| 2324 | exception_tb = NULL; | ||
| 2325 | exception_lineno = 0; | ||
| 2326 | |||
| 2327 | Py_XDECREF( var_e ); | ||
| 2328 | var_e = NULL; | ||
| 2329 | |||
| 2330 | // Re-raise. | ||
| 2331 | exception_type = exception_keeper_type_2; | ||
| 2332 | exception_value = exception_keeper_value_2; | ||
| 2333 | exception_tb = exception_keeper_tb_2; | ||
| 2334 | exception_lineno = exception_keeper_lineno_2; | ||
| 2335 | |||
| 2336 | goto try_except_handler_3; | ||
| 2337 | // End of try: | ||
| 2338 | goto branch_end_1; | ||
| 2339 | branch_no_1:; | ||
| 2340 | tmp_result = RERAISE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2341 | if (unlikely( tmp_result == false )) | ||
| 2342 | { | ||
| 2343 | exception_lineno = 82; | ||
| 2344 | } | ||
| 2345 | |||
| 2346 | if (exception_tb && exception_tb->tb_frame == &frame_dbb49e89a876483f119ad43743fc242b->m_frame) frame_dbb49e89a876483f119ad43743fc242b->m_frame.f_lineno = exception_tb->tb_lineno; | ||
| 2347 | type_description_1 = "oo"; | ||
| 2348 | goto try_except_handler_3; | ||
| 2349 | branch_end_1:; | ||
| 2350 | } | ||
| 2351 | // tried codes exits in all cases | ||
| 2352 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_5_process_introspection_data ); | ||
| 2353 | return NULL; | ||
| 2354 | // Exception handler code: | ||
| 2355 | try_except_handler_3:; | ||
| 2356 | exception_keeper_type_3 = exception_type; | ||
| 2357 | exception_keeper_value_3 = exception_value; | ||
| 2358 | exception_keeper_tb_3 = exception_tb; | ||
| 2359 | exception_keeper_lineno_3 = exception_lineno; | ||
| 2360 | exception_type = NULL; | ||
| 2361 | exception_value = NULL; | ||
| 2362 | exception_tb = NULL; | ||
| 2363 | exception_lineno = 0; | ||
| 2364 | |||
| 2365 | // Restore previous exception. | ||
| 2366 | SET_CURRENT_EXCEPTION( exception_preserved_type_1, exception_preserved_value_1, exception_preserved_tb_1 ); | ||
| 2367 | // Re-raise. | ||
| 2368 | exception_type = exception_keeper_type_3; | ||
| 2369 | exception_value = exception_keeper_value_3; | ||
| 2370 | exception_tb = exception_keeper_tb_3; | ||
| 2371 | exception_lineno = exception_keeper_lineno_3; | ||
| 2372 | |||
| 2373 | goto frame_exception_exit_1; | ||
| 2374 | // End of try: | ||
| 2375 | // End of try: | ||
| 2376 | |||
| 2377 | #if 0 | ||
| 2378 | RESTORE_FRAME_EXCEPTION( frame_dbb49e89a876483f119ad43743fc242b ); | ||
| 2379 | #endif | ||
| 2380 | |||
| 2381 | // Put the previous frame back on top. | ||
| 2382 | popFrameStack(); | ||
| 2383 | |||
| 2384 | goto frame_no_exception_1; | ||
| 2385 | |||
| 2386 | frame_return_exit_1:; | ||
| 2387 | #if 0 | ||
| 2388 | RESTORE_FRAME_EXCEPTION( frame_dbb49e89a876483f119ad43743fc242b ); | ||
| 2389 | #endif | ||
| 2390 | |||
| 2391 | // Put the previous frame back on top. | ||
| 2392 | popFrameStack(); | ||
| 2393 | |||
| 2394 | goto try_return_handler_1; | ||
| 2395 | |||
| 2396 | frame_exception_exit_1:; | ||
| 2397 | |||
| 2398 | #if 0 | ||
| 2399 | RESTORE_FRAME_EXCEPTION( frame_dbb49e89a876483f119ad43743fc242b ); | ||
| 2400 | #endif | ||
| 2401 | |||
| 2402 | if ( exception_tb == NULL ) | ||
| 2403 | { | ||
| 2404 | exception_tb = MAKE_TRACEBACK( frame_dbb49e89a876483f119ad43743fc242b, exception_lineno ); | ||
| 2405 | } | ||
| 2406 | else if ( exception_tb->tb_frame != &frame_dbb49e89a876483f119ad43743fc242b->m_frame ) | ||
| 2407 | { | ||
| 2408 | exception_tb = ADD_TRACEBACK( exception_tb, frame_dbb49e89a876483f119ad43743fc242b, exception_lineno ); | ||
| 2409 | } | ||
| 2410 | |||
| 2411 | // Attachs locals to frame if any. | ||
| 2412 | Nuitka_Frame_AttachLocals( | ||
| 2413 | (struct Nuitka_FrameObject *)frame_dbb49e89a876483f119ad43743fc242b, | ||
| 2414 | type_description_1, | ||
| 2415 | par_data, | ||
| 2416 | var_e | ||
| 2417 | ); | ||
| 2418 | |||
| 2419 | |||
| 2420 | // Release cached frame. | ||
| 2421 | if ( frame_dbb49e89a876483f119ad43743fc242b == cache_frame_dbb49e89a876483f119ad43743fc242b ) | ||
| 2422 | { | ||
| 2423 | Py_DECREF( frame_dbb49e89a876483f119ad43743fc242b ); | ||
| 2424 | } | ||
| 2425 | cache_frame_dbb49e89a876483f119ad43743fc242b = NULL; | ||
| 2426 | |||
| 2427 | assertFrameObject( frame_dbb49e89a876483f119ad43743fc242b ); | ||
| 2428 | |||
| 2429 | // Put the previous frame back on top. | ||
| 2430 | popFrameStack(); | ||
| 2431 | |||
| 2432 | // Return the error. | ||
| 2433 | goto try_except_handler_1; | ||
| 2434 | |||
| 2435 | frame_no_exception_1:; | ||
| 2436 | // tried codes exits in all cases | ||
| 2437 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_5_process_introspection_data ); | ||
| 2438 | return NULL; | ||
| 2439 | // Return handler code: | ||
| 2440 | try_return_handler_1:; | ||
| 2441 | CHECK_OBJECT( (PyObject *)par_data ); | ||
| 2442 | Py_DECREF( par_data ); | ||
| 2443 | par_data = NULL; | ||
| 2444 | |||
| 2445 | goto function_return_exit; | ||
| 2446 | // Exception handler code: | ||
| 2447 | try_except_handler_1:; | ||
| 2448 | exception_keeper_type_4 = exception_type; | ||
| 2449 | exception_keeper_value_4 = exception_value; | ||
| 2450 | exception_keeper_tb_4 = exception_tb; | ||
| 2451 | exception_keeper_lineno_4 = exception_lineno; | ||
| 2452 | exception_type = NULL; | ||
| 2453 | exception_value = NULL; | ||
| 2454 | exception_tb = NULL; | ||
| 2455 | exception_lineno = 0; | ||
| 2456 | |||
| 2457 | CHECK_OBJECT( (PyObject *)par_data ); | ||
| 2458 | Py_DECREF( par_data ); | ||
| 2459 | par_data = NULL; | ||
| 2460 | |||
| 2461 | Py_XDECREF( var_e ); | ||
| 2462 | var_e = NULL; | ||
| 2463 | |||
| 2464 | // Re-raise. | ||
| 2465 | exception_type = exception_keeper_type_4; | ||
| 2466 | exception_value = exception_keeper_value_4; | ||
| 2467 | exception_tb = exception_keeper_tb_4; | ||
| 2468 | exception_lineno = exception_keeper_lineno_4; | ||
| 2469 | |||
| 2470 | goto function_exception_exit; | ||
| 2471 | // End of try: | ||
| 2472 | |||
| 2473 | // Return statement must have exited already. | ||
| 2474 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser$$$function_5_process_introspection_data ); | ||
| 2475 | return NULL; | ||
| 2476 | |||
| 2477 | function_exception_exit: | ||
| 2478 | assert( exception_type ); | ||
| 2479 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 2480 | |||
| 2481 | return NULL; | ||
| 2482 | |||
| 2483 | function_return_exit: | ||
| 2484 | // Function cleanup code if any. | ||
| 2485 | |||
| 2486 | |||
| 2487 | // Actual function exit with return value, making sure we did not make | ||
| 2488 | // the error status worse despite non-NULL return. | ||
| 2489 | CHECK_OBJECT( tmp_return_value ); | ||
| 2490 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 2491 | return tmp_return_value; | ||
| 2492 | } | ||
| 2493 | |||
| 2494 | |||
| 2495 | |||
| 2496 | static PyObject *MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_1___init__( ) | ||
| 2497 | { | ||
| 2498 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 2499 | impl_dbus$_expat_introspect_parser$$$function_1___init__, | ||
| 2500 | const_str_plain___init__, | ||
| 2501 | #if PYTHON_VERSION >= 300 | ||
| 2502 | const_str_digest_9e791634659cef76ab4e135031893f31, | ||
| 2503 | #endif | ||
| 2504 | codeobj_1cc2da2dd3c6a227a185e01f5454f5b6, | ||
| 2505 | NULL, | ||
| 2506 | #if PYTHON_VERSION >= 300 | ||
| 2507 | NULL, | ||
| 2508 | NULL, | ||
| 2509 | #endif | ||
| 2510 | module_dbus$_expat_introspect_parser, | ||
| 2511 | NULL, | ||
| 2512 | 0 | ||
| 2513 | ); | ||
| 2514 | |||
| 2515 | return (PyObject *)result; | ||
| 2516 | } | ||
| 2517 | |||
| 2518 | |||
| 2519 | |||
| 2520 | static PyObject *MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_2_parse( ) | ||
| 2521 | { | ||
| 2522 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 2523 | impl_dbus$_expat_introspect_parser$$$function_2_parse, | ||
| 2524 | const_str_plain_parse, | ||
| 2525 | #if PYTHON_VERSION >= 300 | ||
| 2526 | const_str_digest_9aafd5147413fd54ddfc2afb0d6e3081, | ||
| 2527 | #endif | ||
| 2528 | codeobj_72136d6021e6c4b7e1af2fddb7da8e06, | ||
| 2529 | NULL, | ||
| 2530 | #if PYTHON_VERSION >= 300 | ||
| 2531 | NULL, | ||
| 2532 | NULL, | ||
| 2533 | #endif | ||
| 2534 | module_dbus$_expat_introspect_parser, | ||
| 2535 | NULL, | ||
| 2536 | 0 | ||
| 2537 | ); | ||
| 2538 | |||
| 2539 | return (PyObject *)result; | ||
| 2540 | } | ||
| 2541 | |||
| 2542 | |||
| 2543 | |||
| 2544 | static PyObject *MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_3_StartElementHandler( ) | ||
| 2545 | { | ||
| 2546 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 2547 | impl_dbus$_expat_introspect_parser$$$function_3_StartElementHandler, | ||
| 2548 | const_str_plain_StartElementHandler, | ||
| 2549 | #if PYTHON_VERSION >= 300 | ||
| 2550 | const_str_digest_98664ef00f574ec08b1cfc4be9e5a5de, | ||
| 2551 | #endif | ||
| 2552 | codeobj_bf482f59396a00033f1561c8ab09ee10, | ||
| 2553 | NULL, | ||
| 2554 | #if PYTHON_VERSION >= 300 | ||
| 2555 | NULL, | ||
| 2556 | NULL, | ||
| 2557 | #endif | ||
| 2558 | module_dbus$_expat_introspect_parser, | ||
| 2559 | NULL, | ||
| 2560 | 0 | ||
| 2561 | ); | ||
| 2562 | |||
| 2563 | return (PyObject *)result; | ||
| 2564 | } | ||
| 2565 | |||
| 2566 | |||
| 2567 | |||
| 2568 | static PyObject *MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_4_EndElementHandler( ) | ||
| 2569 | { | ||
| 2570 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 2571 | impl_dbus$_expat_introspect_parser$$$function_4_EndElementHandler, | ||
| 2572 | const_str_plain_EndElementHandler, | ||
| 2573 | #if PYTHON_VERSION >= 300 | ||
| 2574 | const_str_digest_29704eec445aa0f422f31f45e9aa157f, | ||
| 2575 | #endif | ||
| 2576 | codeobj_899d0693dc9e2c566d398b72bff1ac02, | ||
| 2577 | NULL, | ||
| 2578 | #if PYTHON_VERSION >= 300 | ||
| 2579 | NULL, | ||
| 2580 | NULL, | ||
| 2581 | #endif | ||
| 2582 | module_dbus$_expat_introspect_parser, | ||
| 2583 | NULL, | ||
| 2584 | 0 | ||
| 2585 | ); | ||
| 2586 | |||
| 2587 | return (PyObject *)result; | ||
| 2588 | } | ||
| 2589 | |||
| 2590 | |||
| 2591 | |||
| 2592 | static PyObject *MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_5_process_introspection_data( ) | ||
| 2593 | { | ||
| 2594 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 2595 | impl_dbus$_expat_introspect_parser$$$function_5_process_introspection_data, | ||
| 2596 | const_str_plain_process_introspection_data, | ||
| 2597 | #if PYTHON_VERSION >= 300 | ||
| 2598 | NULL, | ||
| 2599 | #endif | ||
| 2600 | codeobj_dbb49e89a876483f119ad43743fc242b, | ||
| 2601 | NULL, | ||
| 2602 | #if PYTHON_VERSION >= 300 | ||
| 2603 | NULL, | ||
| 2604 | NULL, | ||
| 2605 | #endif | ||
| 2606 | module_dbus$_expat_introspect_parser, | ||
| 2607 | const_str_digest_3f318ff1b6f012cbecede2926bf2b070, | ||
| 2608 | 0 | ||
| 2609 | ); | ||
| 2610 | |||
| 2611 | return (PyObject *)result; | ||
| 2612 | } | ||
| 2613 | |||
| 2614 | |||
| 2615 | |||
| 2616 | #if PYTHON_VERSION >= 300 | ||
| 2617 | static struct PyModuleDef mdef_dbus$_expat_introspect_parser = | ||
| 2618 | { | ||
| 2619 | PyModuleDef_HEAD_INIT, | ||
| 2620 | "dbus._expat_introspect_parser", | ||
| 2621 | NULL, /* m_doc */ | ||
| 2622 | -1, /* m_size */ | ||
| 2623 | NULL, /* m_methods */ | ||
| 2624 | NULL, /* m_reload */ | ||
| 2625 | NULL, /* m_traverse */ | ||
| 2626 | NULL, /* m_clear */ | ||
| 2627 | NULL, /* m_free */ | ||
| 2628 | }; | ||
| 2629 | #endif | ||
| 2630 | |||
| 2631 | extern PyObject *const_str_plain___compiled__; | ||
| 2632 | |||
| 2633 | extern PyObject *const_str_plain___package__; | ||
| 2634 | |||
| 2635 | #if PYTHON_VERSION >= 300 | ||
| 2636 | extern PyObject *const_str_dot; | ||
| 2637 | extern PyObject *const_str_plain___loader__; | ||
| 2638 | #endif | ||
| 2639 | |||
| 2640 | #if PYTHON_VERSION >= 340 | ||
| 2641 | extern PyObject *const_str_plain___spec__; | ||
| 2642 | extern PyObject *const_str_plain__initializing; | ||
| 2643 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 2644 | #endif | ||
| 2645 | |||
| 2646 | extern void _initCompiledCellType(); | ||
| 2647 | extern void _initCompiledGeneratorType(); | ||
| 2648 | extern void _initCompiledFunctionType(); | ||
| 2649 | extern void _initCompiledMethodType(); | ||
| 2650 | extern void _initCompiledFrameType(); | ||
| 2651 | #if PYTHON_VERSION >= 350 | ||
| 2652 | extern void _initCompiledCoroutineTypes(); | ||
| 2653 | #endif | ||
| 2654 | #if PYTHON_VERSION >= 360 | ||
| 2655 | extern void _initCompiledAsyncgenTypes(); | ||
| 2656 | #endif | ||
| 2657 | |||
| 2658 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 2659 | |||
| 2660 | // The exported interface to CPython. On import of the module, this function | ||
| 2661 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 2662 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 2663 | |||
| 2664 | MOD_INIT_DECL( dbus$_expat_introspect_parser ) | ||
| 2665 | { | ||
| 2666 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 2667 | static bool _init_done = false; | ||
| 2668 | |||
| 2669 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 2670 | if ( _init_done ) | ||
| 2671 | { | ||
| 2672 | return MOD_RETURN_VALUE( module_dbus$_expat_introspect_parser ); | ||
| 2673 | } | ||
| 2674 | else | ||
| 2675 | { | ||
| 2676 | _init_done = true; | ||
| 2677 | } | ||
| 2678 | #endif | ||
| 2679 | |||
| 2680 | #ifdef _NUITKA_MODULE | ||
| 2681 | // In case of a stand alone extension module, need to call initialization | ||
| 2682 | // the init here because that's the first and only time we are going to get | ||
| 2683 | // called here. | ||
| 2684 | |||
| 2685 | // Initialize the constant values used. | ||
| 2686 | _initBuiltinModule(); | ||
| 2687 | createGlobalConstants(); | ||
| 2688 | |||
| 2689 | /* Initialize the compiled types of Nuitka. */ | ||
| 2690 | _initCompiledCellType(); | ||
| 2691 | _initCompiledGeneratorType(); | ||
| 2692 | _initCompiledFunctionType(); | ||
| 2693 | _initCompiledMethodType(); | ||
| 2694 | _initCompiledFrameType(); | ||
| 2695 | #if PYTHON_VERSION >= 350 | ||
| 2696 | _initCompiledCoroutineTypes(); | ||
| 2697 | #endif | ||
| 2698 | #if PYTHON_VERSION >= 360 | ||
| 2699 | _initCompiledAsyncgenTypes(); | ||
| 2700 | #endif | ||
| 2701 | |||
| 2702 | #if PYTHON_VERSION < 300 | ||
| 2703 | _initSlotCompare(); | ||
| 2704 | #endif | ||
| 2705 | #if PYTHON_VERSION >= 270 | ||
| 2706 | _initSlotIternext(); | ||
| 2707 | #endif | ||
| 2708 | |||
| 2709 | patchBuiltinModule(); | ||
| 2710 | patchTypeComparison(); | ||
| 2711 | |||
| 2712 | // Enable meta path based loader if not already done. | ||
| 2713 | #ifdef _NUITKA_TRACE | ||
| 2714 | puts("dbus._expat_introspect_parser: Calling setupMetaPathBasedLoader()."); | ||
| 2715 | #endif | ||
| 2716 | setupMetaPathBasedLoader(); | ||
| 2717 | |||
| 2718 | #if PYTHON_VERSION >= 300 | ||
| 2719 | patchInspectModule(); | ||
| 2720 | #endif | ||
| 2721 | |||
| 2722 | #endif | ||
| 2723 | |||
| 2724 | /* The constants only used by this module are created now. */ | ||
| 2725 | #ifdef _NUITKA_TRACE | ||
| 2726 | puts("dbus._expat_introspect_parser: Calling createModuleConstants()."); | ||
| 2727 | #endif | ||
| 2728 | createModuleConstants(); | ||
| 2729 | |||
| 2730 | /* The code objects used by this module are created now. */ | ||
| 2731 | #ifdef _NUITKA_TRACE | ||
| 2732 | puts("dbus._expat_introspect_parser: Calling createModuleCodeObjects()."); | ||
| 2733 | #endif | ||
| 2734 | createModuleCodeObjects(); | ||
| 2735 | |||
| 2736 | // puts( "in initdbus$_expat_introspect_parser" ); | ||
| 2737 | |||
| 2738 | // Create the module object first. There are no methods initially, all are | ||
| 2739 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 2740 | // set at this time, as it could not contain NUL characters this way, they | ||
| 2741 | // are instead set in early module code. No "self" for modules, we have no | ||
| 2742 | // use for it. | ||
| 2743 | #if PYTHON_VERSION < 300 | ||
| 2744 | module_dbus$_expat_introspect_parser = Py_InitModule4( | ||
| 2745 | "dbus._expat_introspect_parser", // Module Name | ||
| 2746 | NULL, // No methods initially, all are added | ||
| 2747 | // dynamically in actual module code only. | ||
| 2748 | NULL, // No "__doc__" is initially set, as it could | ||
| 2749 | // not contain NUL this way, added early in | ||
| 2750 | // actual code. | ||
| 2751 | NULL, // No self for modules, we don't use it. | ||
| 2752 | PYTHON_API_VERSION | ||
| 2753 | ); | ||
| 2754 | #else | ||
| 2755 | |||
| 2756 | module_dbus$_expat_introspect_parser = PyModule_Create( &mdef_dbus$_expat_introspect_parser ); | ||
| 2757 | #endif | ||
| 2758 | |||
| 2759 | moduledict_dbus$_expat_introspect_parser = MODULE_DICT( module_dbus$_expat_introspect_parser ); | ||
| 2760 | |||
| 2761 | // Set __compiled__ to what it we know. | ||
| 2762 | UPDATE_STRING_DICT1( | ||
| 2763 | moduledict_dbus$_expat_introspect_parser, | ||
| 2764 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 2765 | Nuitka_dunder_compiled_value | ||
| 2766 | ); | ||
| 2767 | |||
| 2768 | // Update "__package__" value to what it ought to be. | ||
| 2769 | { | ||
| 2770 | #if 0 | ||
| 2771 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 2772 | |||
| 2773 | UPDATE_STRING_DICT1( | ||
| 2774 | moduledict_dbus$_expat_introspect_parser, | ||
| 2775 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 2776 | module_name | ||
| 2777 | ); | ||
| 2778 | #else | ||
| 2779 | |||
| 2780 | #if PYTHON_VERSION < 300 | ||
| 2781 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 2782 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 2783 | |||
| 2784 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 2785 | |||
| 2786 | if ( last_dot != NULL ) | ||
| 2787 | { | ||
| 2788 | UPDATE_STRING_DICT1( | ||
| 2789 | moduledict_dbus$_expat_introspect_parser, | ||
| 2790 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 2791 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 2792 | ); | ||
| 2793 | } | ||
| 2794 | #else | ||
| 2795 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 2796 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 2797 | |||
| 2798 | if ( dot_index != -1 ) | ||
| 2799 | { | ||
| 2800 | UPDATE_STRING_DICT1( | ||
| 2801 | moduledict_dbus$_expat_introspect_parser, | ||
| 2802 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 2803 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 2804 | ); | ||
| 2805 | } | ||
| 2806 | #endif | ||
| 2807 | #endif | ||
| 2808 | } | ||
| 2809 | |||
| 2810 | CHECK_OBJECT( module_dbus$_expat_introspect_parser ); | ||
| 2811 | |||
| 2812 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 2813 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 2814 | #if PYTHON_VERSION >= 300 | ||
| 2815 | { | ||
| 2816 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_286d73d90a388265c9abc0d24ef29c6f, module_dbus$_expat_introspect_parser ); | ||
| 2817 | |||
| 2818 | assert( r != -1 ); | ||
| 2819 | } | ||
| 2820 | #endif | ||
| 2821 | |||
| 2822 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 2823 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 2824 | // before the frame object is allocated, or else it may fail. | ||
| 2825 | |||
| 2826 | if ( GET_STRING_DICT_VALUE( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 2827 | { | ||
| 2828 | PyObject *value = (PyObject *)builtin_module; | ||
| 2829 | |||
| 2830 | // Check if main module, not a dict then but the module itself. | ||
| 2831 | #if !defined(_NUITKA_EXE) || !0 | ||
| 2832 | value = PyModule_GetDict( value ); | ||
| 2833 | #endif | ||
| 2834 | |||
| 2835 | UPDATE_STRING_DICT0( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 2836 | } | ||
| 2837 | |||
| 2838 | #if PYTHON_VERSION >= 300 | ||
| 2839 | UPDATE_STRING_DICT0( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 2840 | #endif | ||
| 2841 | |||
| 2842 | #if PYTHON_VERSION >= 340 | ||
| 2843 | // Set the "__spec__" value | ||
| 2844 | |||
| 2845 | #if 0 | ||
| 2846 | // Main modules just get "None" as spec. | ||
| 2847 | UPDATE_STRING_DICT0( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 2848 | #else | ||
| 2849 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 2850 | { | ||
| 2851 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 2852 | CHECK_OBJECT( bootstrap_module ); | ||
| 2853 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 2854 | Py_DECREF( bootstrap_module ); | ||
| 2855 | |||
| 2856 | PyObject *args[] = { | ||
| 2857 | GET_STRING_DICT_VALUE( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 2858 | (PyObject *)&Nuitka_Loader_Type | ||
| 2859 | }; | ||
| 2860 | |||
| 2861 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 2862 | module_spec_class, | ||
| 2863 | args | ||
| 2864 | ); | ||
| 2865 | Py_DECREF( module_spec_class ); | ||
| 2866 | |||
| 2867 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 2868 | CHECK_OBJECT( spec_value ); | ||
| 2869 | |||
| 2870 | // For packages set the submodule search locations as well, even if to empty | ||
| 2871 | // list, so investigating code will consider it a package. | ||
| 2872 | #if 0 | ||
| 2873 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 2874 | #endif | ||
| 2875 | |||
| 2876 | // Mark the execution in the "__spec__" value. | ||
| 2877 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 2878 | |||
| 2879 | UPDATE_STRING_DICT1( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 2880 | } | ||
| 2881 | #endif | ||
| 2882 | #endif | ||
| 2883 | |||
| 2884 | // Temp variables if any | ||
| 2885 | PyObject *outline_0_var___class__ = NULL; | ||
| 2886 | PyObject *tmp_class_creation_1__bases = NULL; | ||
| 2887 | PyObject *tmp_class_creation_1__class_decl_dict = NULL; | ||
| 2888 | PyObject *tmp_class_creation_1__metaclass = NULL; | ||
| 2889 | PyObject *tmp_class_creation_1__prepared = NULL; | ||
| 2890 | struct Nuitka_FrameObject *frame_d985cb2edde0f12e6088a207de5f7222; | ||
| 2891 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 2892 | bool tmp_result; | ||
| 2893 | PyObject *exception_type = NULL; | ||
| 2894 | PyObject *exception_value = NULL; | ||
| 2895 | PyTracebackObject *exception_tb = NULL; | ||
| 2896 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 2897 | int tmp_res; | ||
| 2898 | PyObject *tmp_dictdel_dict; | ||
| 2899 | PyObject *tmp_dictdel_key; | ||
| 2900 | PyObject *locals_dbus$_expat_introspect_parser_29 = NULL; | ||
| 2901 | PyObject *tmp_dictset_value; | ||
| 2902 | struct Nuitka_FrameObject *frame_8bb09954d222fbbc2e8769926c9d0187_2; | ||
| 2903 | NUITKA_MAY_BE_UNUSED char const *type_description_2 = NULL; | ||
| 2904 | static struct Nuitka_FrameObject *cache_frame_8bb09954d222fbbc2e8769926c9d0187_2 = NULL; | ||
| 2905 | PyObject *exception_keeper_type_1; | ||
| 2906 | PyObject *exception_keeper_value_1; | ||
| 2907 | PyTracebackObject *exception_keeper_tb_1; | ||
| 2908 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 2909 | PyObject *exception_keeper_type_2; | ||
| 2910 | PyObject *exception_keeper_value_2; | ||
| 2911 | PyTracebackObject *exception_keeper_tb_2; | ||
| 2912 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 2913 | PyObject *exception_keeper_type_3; | ||
| 2914 | PyObject *exception_keeper_value_3; | ||
| 2915 | PyTracebackObject *exception_keeper_tb_3; | ||
| 2916 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; | ||
| 2917 | |||
| 2918 | // Module code. | ||
| 2919 | { | ||
| 2920 | PyObject *tmp_assign_source_1; | ||
| 2921 | tmp_assign_source_1 = Py_None; | ||
| 2922 | UPDATE_STRING_DICT0( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 2923 | } | ||
| 2924 | { | ||
| 2925 | PyObject *tmp_assign_source_2; | ||
| 2926 | tmp_assign_source_2 = module_filename_obj; | ||
| 2927 | UPDATE_STRING_DICT0( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 2928 | } | ||
| 2929 | // Frame without reuse. | ||
| 2930 | frame_d985cb2edde0f12e6088a207de5f7222 = MAKE_MODULE_FRAME( codeobj_d985cb2edde0f12e6088a207de5f7222, module_dbus$_expat_introspect_parser ); | ||
| 2931 | |||
| 2932 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 2933 | // owning it. | ||
| 2934 | pushFrameStack( frame_d985cb2edde0f12e6088a207de5f7222 ); | ||
| 2935 | assert( Py_REFCNT( frame_d985cb2edde0f12e6088a207de5f7222 ) == 2 ); | ||
| 2936 | |||
| 2937 | // Framed code: | ||
| 2938 | { | ||
| 2939 | PyObject *tmp_assattr_name_1; | ||
| 2940 | PyObject *tmp_assattr_target_1; | ||
| 2941 | PyObject *tmp_mvar_value_1; | ||
| 2942 | tmp_assattr_name_1 = module_filename_obj; | ||
| 2943 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2944 | |||
| 2945 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 2946 | { | ||
| 2947 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2948 | } | ||
| 2949 | |||
| 2950 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 2951 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 2952 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 2953 | if ( tmp_result == false ) | ||
| 2954 | { | ||
| 2955 | assert( ERROR_OCCURRED() ); | ||
| 2956 | |||
| 2957 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2958 | |||
| 2959 | |||
| 2960 | exception_lineno = 1; | ||
| 2961 | |||
| 2962 | goto frame_exception_exit_1; | ||
| 2963 | } | ||
| 2964 | } | ||
| 2965 | { | ||
| 2966 | PyObject *tmp_assattr_name_2; | ||
| 2967 | PyObject *tmp_assattr_target_2; | ||
| 2968 | PyObject *tmp_mvar_value_2; | ||
| 2969 | tmp_assattr_name_2 = Py_True; | ||
| 2970 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2971 | |||
| 2972 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 2973 | { | ||
| 2974 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2975 | } | ||
| 2976 | |||
| 2977 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 2978 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 2979 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 2980 | if ( tmp_result == false ) | ||
| 2981 | { | ||
| 2982 | assert( ERROR_OCCURRED() ); | ||
| 2983 | |||
| 2984 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2985 | |||
| 2986 | |||
| 2987 | exception_lineno = 1; | ||
| 2988 | |||
| 2989 | goto frame_exception_exit_1; | ||
| 2990 | } | ||
| 2991 | } | ||
| 2992 | { | ||
| 2993 | PyObject *tmp_assign_source_3; | ||
| 2994 | tmp_assign_source_3 = Py_None; | ||
| 2995 | UPDATE_STRING_DICT0( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 2996 | } | ||
| 2997 | { | ||
| 2998 | PyObject *tmp_assign_source_4; | ||
| 2999 | PyObject *tmp_import_name_from_1; | ||
| 3000 | PyObject *tmp_name_name_1; | ||
| 3001 | PyObject *tmp_globals_name_1; | ||
| 3002 | PyObject *tmp_locals_name_1; | ||
| 3003 | PyObject *tmp_fromlist_name_1; | ||
| 3004 | PyObject *tmp_level_name_1; | ||
| 3005 | tmp_name_name_1 = const_str_digest_d7908dd66617c9f5e7c68a06d1603722; | ||
| 3006 | tmp_globals_name_1 = (PyObject *)moduledict_dbus$_expat_introspect_parser; | ||
| 3007 | tmp_locals_name_1 = Py_None; | ||
| 3008 | tmp_fromlist_name_1 = const_tuple_str_plain_ParserCreate_tuple; | ||
| 3009 | tmp_level_name_1 = const_int_0; | ||
| 3010 | frame_d985cb2edde0f12e6088a207de5f7222->m_frame.f_lineno = 26; | ||
| 3011 | tmp_import_name_from_1 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 3012 | if ( tmp_import_name_from_1 == NULL ) | ||
| 3013 | { | ||
| 3014 | assert( ERROR_OCCURRED() ); | ||
| 3015 | |||
| 3016 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3017 | |||
| 3018 | |||
| 3019 | exception_lineno = 26; | ||
| 3020 | |||
| 3021 | goto frame_exception_exit_1; | ||
| 3022 | } | ||
| 3023 | tmp_assign_source_4 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_ParserCreate ); | ||
| 3024 | Py_DECREF( tmp_import_name_from_1 ); | ||
| 3025 | if ( tmp_assign_source_4 == NULL ) | ||
| 3026 | { | ||
| 3027 | assert( ERROR_OCCURRED() ); | ||
| 3028 | |||
| 3029 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3030 | |||
| 3031 | |||
| 3032 | exception_lineno = 26; | ||
| 3033 | |||
| 3034 | goto frame_exception_exit_1; | ||
| 3035 | } | ||
| 3036 | UPDATE_STRING_DICT1( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain_ParserCreate, tmp_assign_source_4 ); | ||
| 3037 | } | ||
| 3038 | { | ||
| 3039 | PyObject *tmp_assign_source_5; | ||
| 3040 | PyObject *tmp_import_name_from_2; | ||
| 3041 | PyObject *tmp_name_name_2; | ||
| 3042 | PyObject *tmp_globals_name_2; | ||
| 3043 | PyObject *tmp_locals_name_2; | ||
| 3044 | PyObject *tmp_fromlist_name_2; | ||
| 3045 | PyObject *tmp_level_name_2; | ||
| 3046 | tmp_name_name_2 = const_str_digest_e48610c30fffad33f2054d9dca0792b3; | ||
| 3047 | tmp_globals_name_2 = (PyObject *)moduledict_dbus$_expat_introspect_parser; | ||
| 3048 | tmp_locals_name_2 = Py_None; | ||
| 3049 | tmp_fromlist_name_2 = const_tuple_str_plain_IntrospectionParserException_tuple; | ||
| 3050 | tmp_level_name_2 = const_int_0; | ||
| 3051 | frame_d985cb2edde0f12e6088a207de5f7222->m_frame.f_lineno = 27; | ||
| 3052 | tmp_import_name_from_2 = IMPORT_MODULE5( tmp_name_name_2, tmp_globals_name_2, tmp_locals_name_2, tmp_fromlist_name_2, tmp_level_name_2 ); | ||
| 3053 | if ( tmp_import_name_from_2 == NULL ) | ||
| 3054 | { | ||
| 3055 | assert( ERROR_OCCURRED() ); | ||
| 3056 | |||
| 3057 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3058 | |||
| 3059 | |||
| 3060 | exception_lineno = 27; | ||
| 3061 | |||
| 3062 | goto frame_exception_exit_1; | ||
| 3063 | } | ||
| 3064 | tmp_assign_source_5 = IMPORT_NAME( tmp_import_name_from_2, const_str_plain_IntrospectionParserException ); | ||
| 3065 | Py_DECREF( tmp_import_name_from_2 ); | ||
| 3066 | if ( tmp_assign_source_5 == NULL ) | ||
| 3067 | { | ||
| 3068 | assert( ERROR_OCCURRED() ); | ||
| 3069 | |||
| 3070 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3071 | |||
| 3072 | |||
| 3073 | exception_lineno = 27; | ||
| 3074 | |||
| 3075 | goto frame_exception_exit_1; | ||
| 3076 | } | ||
| 3077 | UPDATE_STRING_DICT1( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain_IntrospectionParserException, tmp_assign_source_5 ); | ||
| 3078 | } | ||
| 3079 | // Tried code: | ||
| 3080 | { | ||
| 3081 | PyObject *tmp_assign_source_6; | ||
| 3082 | PyObject *tmp_dircall_arg1_1; | ||
| 3083 | tmp_dircall_arg1_1 = const_tuple_type_object_tuple; | ||
| 3084 | Py_INCREF( tmp_dircall_arg1_1 ); | ||
| 3085 | |||
| 3086 | { | ||
| 3087 | PyObject *dir_call_args[] = {tmp_dircall_arg1_1}; | ||
| 3088 | tmp_assign_source_6 = impl___internal__$$$function_2__mro_entries_conversion( dir_call_args ); | ||
| 3089 | } | ||
| 3090 | if ( tmp_assign_source_6 == NULL ) | ||
| 3091 | { | ||
| 3092 | assert( ERROR_OCCURRED() ); | ||
| 3093 | |||
| 3094 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3095 | |||
| 3096 | |||
| 3097 | exception_lineno = 29; | ||
| 3098 | |||
| 3099 | goto try_except_handler_1; | ||
| 3100 | } | ||
| 3101 | assert( tmp_class_creation_1__bases == NULL ); | ||
| 3102 | tmp_class_creation_1__bases = tmp_assign_source_6; | ||
| 3103 | } | ||
| 3104 | { | ||
| 3105 | PyObject *tmp_assign_source_7; | ||
| 3106 | tmp_assign_source_7 = PyDict_New(); | ||
| 3107 | assert( tmp_class_creation_1__class_decl_dict == NULL ); | ||
| 3108 | tmp_class_creation_1__class_decl_dict = tmp_assign_source_7; | ||
| 3109 | } | ||
| 3110 | { | ||
| 3111 | PyObject *tmp_assign_source_8; | ||
| 3112 | PyObject *tmp_metaclass_name_1; | ||
| 3113 | nuitka_bool tmp_condition_result_1; | ||
| 3114 | PyObject *tmp_key_name_1; | ||
| 3115 | PyObject *tmp_dict_name_1; | ||
| 3116 | PyObject *tmp_dict_name_2; | ||
| 3117 | PyObject *tmp_key_name_2; | ||
| 3118 | nuitka_bool tmp_condition_result_2; | ||
| 3119 | int tmp_truth_name_1; | ||
| 3120 | PyObject *tmp_type_arg_1; | ||
| 3121 | PyObject *tmp_subscribed_name_1; | ||
| 3122 | PyObject *tmp_subscript_name_1; | ||
| 3123 | PyObject *tmp_bases_name_1; | ||
| 3124 | tmp_key_name_1 = const_str_plain_metaclass; | ||
| 3125 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 3126 | tmp_dict_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 3127 | tmp_res = PyDict_Contains( tmp_dict_name_1, tmp_key_name_1 ); | ||
| 3128 | if ( tmp_res == -1 ) | ||
| 3129 | { | ||
| 3130 | assert( ERROR_OCCURRED() ); | ||
| 3131 | |||
| 3132 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3133 | |||
| 3134 | |||
| 3135 | exception_lineno = 29; | ||
| 3136 | |||
| 3137 | goto try_except_handler_1; | ||
| 3138 | } | ||
| 3139 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 3140 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 3141 | { | ||
| 3142 | goto condexpr_true_1; | ||
| 3143 | } | ||
| 3144 | else | ||
| 3145 | { | ||
| 3146 | goto condexpr_false_1; | ||
| 3147 | } | ||
| 3148 | condexpr_true_1:; | ||
| 3149 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 3150 | tmp_dict_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 3151 | tmp_key_name_2 = const_str_plain_metaclass; | ||
| 3152 | tmp_metaclass_name_1 = DICT_GET_ITEM( tmp_dict_name_2, tmp_key_name_2 ); | ||
| 3153 | if ( tmp_metaclass_name_1 == NULL ) | ||
| 3154 | { | ||
| 3155 | assert( ERROR_OCCURRED() ); | ||
| 3156 | |||
| 3157 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3158 | |||
| 3159 | |||
| 3160 | exception_lineno = 29; | ||
| 3161 | |||
| 3162 | goto try_except_handler_1; | ||
| 3163 | } | ||
| 3164 | goto condexpr_end_1; | ||
| 3165 | condexpr_false_1:; | ||
| 3166 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 3167 | tmp_truth_name_1 = CHECK_IF_TRUE( tmp_class_creation_1__bases ); | ||
| 3168 | if ( tmp_truth_name_1 == -1 ) | ||
| 3169 | { | ||
| 3170 | assert( ERROR_OCCURRED() ); | ||
| 3171 | |||
| 3172 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3173 | |||
| 3174 | |||
| 3175 | exception_lineno = 29; | ||
| 3176 | |||
| 3177 | goto try_except_handler_1; | ||
| 3178 | } | ||
| 3179 | tmp_condition_result_2 = tmp_truth_name_1 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 3180 | if ( tmp_condition_result_2 == NUITKA_BOOL_TRUE ) | ||
| 3181 | { | ||
| 3182 | goto condexpr_true_2; | ||
| 3183 | } | ||
| 3184 | else | ||
| 3185 | { | ||
| 3186 | goto condexpr_false_2; | ||
| 3187 | } | ||
| 3188 | condexpr_true_2:; | ||
| 3189 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 3190 | tmp_subscribed_name_1 = tmp_class_creation_1__bases; | ||
| 3191 | tmp_subscript_name_1 = const_int_0; | ||
| 3192 | tmp_type_arg_1 = LOOKUP_SUBSCRIPT_CONST( tmp_subscribed_name_1, tmp_subscript_name_1, 0 ); | ||
| 3193 | if ( tmp_type_arg_1 == NULL ) | ||
| 3194 | { | ||
| 3195 | assert( ERROR_OCCURRED() ); | ||
| 3196 | |||
| 3197 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3198 | |||
| 3199 | |||
| 3200 | exception_lineno = 29; | ||
| 3201 | |||
| 3202 | goto try_except_handler_1; | ||
| 3203 | } | ||
| 3204 | tmp_metaclass_name_1 = BUILTIN_TYPE1( tmp_type_arg_1 ); | ||
| 3205 | Py_DECREF( tmp_type_arg_1 ); | ||
| 3206 | if ( tmp_metaclass_name_1 == NULL ) | ||
| 3207 | { | ||
| 3208 | assert( ERROR_OCCURRED() ); | ||
| 3209 | |||
| 3210 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3211 | |||
| 3212 | |||
| 3213 | exception_lineno = 29; | ||
| 3214 | |||
| 3215 | goto try_except_handler_1; | ||
| 3216 | } | ||
| 3217 | goto condexpr_end_2; | ||
| 3218 | condexpr_false_2:; | ||
| 3219 | tmp_metaclass_name_1 = (PyObject *)&PyType_Type; | ||
| 3220 | Py_INCREF( tmp_metaclass_name_1 ); | ||
| 3221 | condexpr_end_2:; | ||
| 3222 | condexpr_end_1:; | ||
| 3223 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 3224 | tmp_bases_name_1 = tmp_class_creation_1__bases; | ||
| 3225 | tmp_assign_source_8 = SELECT_METACLASS( tmp_metaclass_name_1, tmp_bases_name_1 ); | ||
| 3226 | Py_DECREF( tmp_metaclass_name_1 ); | ||
| 3227 | if ( tmp_assign_source_8 == NULL ) | ||
| 3228 | { | ||
| 3229 | assert( ERROR_OCCURRED() ); | ||
| 3230 | |||
| 3231 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3232 | |||
| 3233 | |||
| 3234 | exception_lineno = 29; | ||
| 3235 | |||
| 3236 | goto try_except_handler_1; | ||
| 3237 | } | ||
| 3238 | assert( tmp_class_creation_1__metaclass == NULL ); | ||
| 3239 | tmp_class_creation_1__metaclass = tmp_assign_source_8; | ||
| 3240 | } | ||
| 3241 | { | ||
| 3242 | nuitka_bool tmp_condition_result_3; | ||
| 3243 | PyObject *tmp_key_name_3; | ||
| 3244 | PyObject *tmp_dict_name_3; | ||
| 3245 | tmp_key_name_3 = const_str_plain_metaclass; | ||
| 3246 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 3247 | tmp_dict_name_3 = tmp_class_creation_1__class_decl_dict; | ||
| 3248 | tmp_res = PyDict_Contains( tmp_dict_name_3, tmp_key_name_3 ); | ||
| 3249 | if ( tmp_res == -1 ) | ||
| 3250 | { | ||
| 3251 | assert( ERROR_OCCURRED() ); | ||
| 3252 | |||
| 3253 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3254 | |||
| 3255 | |||
| 3256 | exception_lineno = 29; | ||
| 3257 | |||
| 3258 | goto try_except_handler_1; | ||
| 3259 | } | ||
| 3260 | tmp_condition_result_3 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 3261 | if ( tmp_condition_result_3 == NUITKA_BOOL_TRUE ) | ||
| 3262 | { | ||
| 3263 | goto branch_yes_1; | ||
| 3264 | } | ||
| 3265 | else | ||
| 3266 | { | ||
| 3267 | goto branch_no_1; | ||
| 3268 | } | ||
| 3269 | branch_yes_1:; | ||
| 3270 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 3271 | tmp_dictdel_dict = tmp_class_creation_1__class_decl_dict; | ||
| 3272 | tmp_dictdel_key = const_str_plain_metaclass; | ||
| 3273 | tmp_result = DICT_REMOVE_ITEM( tmp_dictdel_dict, tmp_dictdel_key ); | ||
| 3274 | if ( tmp_result == false ) | ||
| 3275 | { | ||
| 3276 | assert( ERROR_OCCURRED() ); | ||
| 3277 | |||
| 3278 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3279 | |||
| 3280 | |||
| 3281 | exception_lineno = 29; | ||
| 3282 | |||
| 3283 | goto try_except_handler_1; | ||
| 3284 | } | ||
| 3285 | branch_no_1:; | ||
| 3286 | } | ||
| 3287 | { | ||
| 3288 | nuitka_bool tmp_condition_result_4; | ||
| 3289 | PyObject *tmp_source_name_1; | ||
| 3290 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 3291 | tmp_source_name_1 = tmp_class_creation_1__metaclass; | ||
| 3292 | tmp_res = PyObject_HasAttr( tmp_source_name_1, const_str_plain___prepare__ ); | ||
| 3293 | tmp_condition_result_4 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 3294 | if ( tmp_condition_result_4 == NUITKA_BOOL_TRUE ) | ||
| 3295 | { | ||
| 3296 | goto branch_yes_2; | ||
| 3297 | } | ||
| 3298 | else | ||
| 3299 | { | ||
| 3300 | goto branch_no_2; | ||
| 3301 | } | ||
| 3302 | branch_yes_2:; | ||
| 3303 | { | ||
| 3304 | PyObject *tmp_assign_source_9; | ||
| 3305 | PyObject *tmp_called_name_1; | ||
| 3306 | PyObject *tmp_source_name_2; | ||
| 3307 | PyObject *tmp_args_name_1; | ||
| 3308 | PyObject *tmp_tuple_element_1; | ||
| 3309 | PyObject *tmp_kw_name_1; | ||
| 3310 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 3311 | tmp_source_name_2 = tmp_class_creation_1__metaclass; | ||
| 3312 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain___prepare__ ); | ||
| 3313 | if ( tmp_called_name_1 == NULL ) | ||
| 3314 | { | ||
| 3315 | assert( ERROR_OCCURRED() ); | ||
| 3316 | |||
| 3317 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3318 | |||
| 3319 | |||
| 3320 | exception_lineno = 29; | ||
| 3321 | |||
| 3322 | goto try_except_handler_1; | ||
| 3323 | } | ||
| 3324 | tmp_tuple_element_1 = const_str_plain__Parser; | ||
| 3325 | tmp_args_name_1 = PyTuple_New( 2 ); | ||
| 3326 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 3327 | PyTuple_SET_ITEM( tmp_args_name_1, 0, tmp_tuple_element_1 ); | ||
| 3328 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 3329 | tmp_tuple_element_1 = tmp_class_creation_1__bases; | ||
| 3330 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 3331 | PyTuple_SET_ITEM( tmp_args_name_1, 1, tmp_tuple_element_1 ); | ||
| 3332 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 3333 | tmp_kw_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 3334 | frame_d985cb2edde0f12e6088a207de5f7222->m_frame.f_lineno = 29; | ||
| 3335 | tmp_assign_source_9 = CALL_FUNCTION( tmp_called_name_1, tmp_args_name_1, tmp_kw_name_1 ); | ||
| 3336 | Py_DECREF( tmp_called_name_1 ); | ||
| 3337 | Py_DECREF( tmp_args_name_1 ); | ||
| 3338 | if ( tmp_assign_source_9 == NULL ) | ||
| 3339 | { | ||
| 3340 | assert( ERROR_OCCURRED() ); | ||
| 3341 | |||
| 3342 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3343 | |||
| 3344 | |||
| 3345 | exception_lineno = 29; | ||
| 3346 | |||
| 3347 | goto try_except_handler_1; | ||
| 3348 | } | ||
| 3349 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 3350 | tmp_class_creation_1__prepared = tmp_assign_source_9; | ||
| 3351 | } | ||
| 3352 | { | ||
| 3353 | nuitka_bool tmp_condition_result_5; | ||
| 3354 | PyObject *tmp_operand_name_1; | ||
| 3355 | PyObject *tmp_source_name_3; | ||
| 3356 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 3357 | tmp_source_name_3 = tmp_class_creation_1__prepared; | ||
| 3358 | tmp_res = PyObject_HasAttr( tmp_source_name_3, const_str_plain___getitem__ ); | ||
| 3359 | tmp_operand_name_1 = ( tmp_res != 0 ) ? Py_True : Py_False; | ||
| 3360 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 3361 | if ( tmp_res == -1 ) | ||
| 3362 | { | ||
| 3363 | assert( ERROR_OCCURRED() ); | ||
| 3364 | |||
| 3365 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3366 | |||
| 3367 | |||
| 3368 | exception_lineno = 29; | ||
| 3369 | |||
| 3370 | goto try_except_handler_1; | ||
| 3371 | } | ||
| 3372 | tmp_condition_result_5 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 3373 | if ( tmp_condition_result_5 == NUITKA_BOOL_TRUE ) | ||
| 3374 | { | ||
| 3375 | goto branch_yes_3; | ||
| 3376 | } | ||
| 3377 | else | ||
| 3378 | { | ||
| 3379 | goto branch_no_3; | ||
| 3380 | } | ||
| 3381 | branch_yes_3:; | ||
| 3382 | { | ||
| 3383 | PyObject *tmp_raise_type_1; | ||
| 3384 | PyObject *tmp_raise_value_1; | ||
| 3385 | PyObject *tmp_left_name_1; | ||
| 3386 | PyObject *tmp_right_name_1; | ||
| 3387 | PyObject *tmp_tuple_element_2; | ||
| 3388 | PyObject *tmp_getattr_target_1; | ||
| 3389 | PyObject *tmp_getattr_attr_1; | ||
| 3390 | PyObject *tmp_getattr_default_1; | ||
| 3391 | PyObject *tmp_source_name_4; | ||
| 3392 | PyObject *tmp_type_arg_2; | ||
| 3393 | tmp_raise_type_1 = PyExc_TypeError; | ||
| 3394 | tmp_left_name_1 = const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 3395 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 3396 | tmp_getattr_target_1 = tmp_class_creation_1__metaclass; | ||
| 3397 | tmp_getattr_attr_1 = const_str_plain___name__; | ||
| 3398 | tmp_getattr_default_1 = const_str_angle_metaclass; | ||
| 3399 | tmp_tuple_element_2 = BUILTIN_GETATTR( tmp_getattr_target_1, tmp_getattr_attr_1, tmp_getattr_default_1 ); | ||
| 3400 | if ( tmp_tuple_element_2 == NULL ) | ||
| 3401 | { | ||
| 3402 | assert( ERROR_OCCURRED() ); | ||
| 3403 | |||
| 3404 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3405 | |||
| 3406 | |||
| 3407 | exception_lineno = 29; | ||
| 3408 | |||
| 3409 | goto try_except_handler_1; | ||
| 3410 | } | ||
| 3411 | tmp_right_name_1 = PyTuple_New( 2 ); | ||
| 3412 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_2 ); | ||
| 3413 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 3414 | tmp_type_arg_2 = tmp_class_creation_1__prepared; | ||
| 3415 | tmp_source_name_4 = BUILTIN_TYPE1( tmp_type_arg_2 ); | ||
| 3416 | assert( !(tmp_source_name_4 == NULL) ); | ||
| 3417 | tmp_tuple_element_2 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain___name__ ); | ||
| 3418 | Py_DECREF( tmp_source_name_4 ); | ||
| 3419 | if ( tmp_tuple_element_2 == NULL ) | ||
| 3420 | { | ||
| 3421 | assert( ERROR_OCCURRED() ); | ||
| 3422 | |||
| 3423 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3424 | Py_DECREF( tmp_right_name_1 ); | ||
| 3425 | |||
| 3426 | exception_lineno = 29; | ||
| 3427 | |||
| 3428 | goto try_except_handler_1; | ||
| 3429 | } | ||
| 3430 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_2 ); | ||
| 3431 | tmp_raise_value_1 = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 3432 | Py_DECREF( tmp_right_name_1 ); | ||
| 3433 | if ( tmp_raise_value_1 == NULL ) | ||
| 3434 | { | ||
| 3435 | assert( ERROR_OCCURRED() ); | ||
| 3436 | |||
| 3437 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3438 | |||
| 3439 | |||
| 3440 | exception_lineno = 29; | ||
| 3441 | |||
| 3442 | goto try_except_handler_1; | ||
| 3443 | } | ||
| 3444 | exception_type = tmp_raise_type_1; | ||
| 3445 | Py_INCREF( tmp_raise_type_1 ); | ||
| 3446 | exception_value = tmp_raise_value_1; | ||
| 3447 | exception_lineno = 29; | ||
| 3448 | RAISE_EXCEPTION_IMPLICIT( &exception_type, &exception_value, &exception_tb ); | ||
| 3449 | |||
| 3450 | goto try_except_handler_1; | ||
| 3451 | } | ||
| 3452 | branch_no_3:; | ||
| 3453 | } | ||
| 3454 | goto branch_end_2; | ||
| 3455 | branch_no_2:; | ||
| 3456 | { | ||
| 3457 | PyObject *tmp_assign_source_10; | ||
| 3458 | tmp_assign_source_10 = PyDict_New(); | ||
| 3459 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 3460 | tmp_class_creation_1__prepared = tmp_assign_source_10; | ||
| 3461 | } | ||
| 3462 | branch_end_2:; | ||
| 3463 | } | ||
| 3464 | { | ||
| 3465 | PyObject *tmp_assign_source_11; | ||
| 3466 | { | ||
| 3467 | PyObject *tmp_set_locals_1; | ||
| 3468 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 3469 | tmp_set_locals_1 = tmp_class_creation_1__prepared; | ||
| 3470 | locals_dbus$_expat_introspect_parser_29 = tmp_set_locals_1; | ||
| 3471 | Py_INCREF( tmp_set_locals_1 ); | ||
| 3472 | } | ||
| 3473 | // Tried code: | ||
| 3474 | // Tried code: | ||
| 3475 | tmp_dictset_value = const_str_digest_286d73d90a388265c9abc0d24ef29c6f; | ||
| 3476 | tmp_res = PyObject_SetItem( locals_dbus$_expat_introspect_parser_29, const_str_plain___module__, tmp_dictset_value ); | ||
| 3477 | if ( tmp_res != 0 ) | ||
| 3478 | { | ||
| 3479 | assert( ERROR_OCCURRED() ); | ||
| 3480 | |||
| 3481 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3482 | |||
| 3483 | |||
| 3484 | exception_lineno = 29; | ||
| 3485 | |||
| 3486 | goto try_except_handler_3; | ||
| 3487 | } | ||
| 3488 | tmp_dictset_value = const_str_plain__Parser; | ||
| 3489 | tmp_res = PyObject_SetItem( locals_dbus$_expat_introspect_parser_29, const_str_plain___qualname__, tmp_dictset_value ); | ||
| 3490 | if ( tmp_res != 0 ) | ||
| 3491 | { | ||
| 3492 | assert( ERROR_OCCURRED() ); | ||
| 3493 | |||
| 3494 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3495 | |||
| 3496 | |||
| 3497 | exception_lineno = 29; | ||
| 3498 | |||
| 3499 | goto try_except_handler_3; | ||
| 3500 | } | ||
| 3501 | MAKE_OR_REUSE_FRAME( cache_frame_8bb09954d222fbbc2e8769926c9d0187_2, codeobj_8bb09954d222fbbc2e8769926c9d0187, module_dbus$_expat_introspect_parser, sizeof(void *) ); | ||
| 3502 | frame_8bb09954d222fbbc2e8769926c9d0187_2 = cache_frame_8bb09954d222fbbc2e8769926c9d0187_2; | ||
| 3503 | |||
| 3504 | // Push the new frame as the currently active one. | ||
| 3505 | pushFrameStack( frame_8bb09954d222fbbc2e8769926c9d0187_2 ); | ||
| 3506 | |||
| 3507 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 3508 | assert( Py_REFCNT( frame_8bb09954d222fbbc2e8769926c9d0187_2 ) == 2 ); // Frame stack | ||
| 3509 | |||
| 3510 | // Framed code: | ||
| 3511 | tmp_dictset_value = const_tuple_92ddbf2d41688100fa7fa4af74cc5357_tuple; | ||
| 3512 | tmp_res = PyObject_SetItem( locals_dbus$_expat_introspect_parser_29, const_str_plain___slots__, tmp_dictset_value ); | ||
| 3513 | if ( tmp_res != 0 ) | ||
| 3514 | { | ||
| 3515 | assert( ERROR_OCCURRED() ); | ||
| 3516 | |||
| 3517 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3518 | |||
| 3519 | |||
| 3520 | exception_lineno = 30; | ||
| 3521 | type_description_2 = "o"; | ||
| 3522 | goto frame_exception_exit_2; | ||
| 3523 | } | ||
| 3524 | tmp_dictset_value = MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_1___init__( ); | ||
| 3525 | |||
| 3526 | |||
| 3527 | |||
| 3528 | tmp_res = PyObject_SetItem( locals_dbus$_expat_introspect_parser_29, const_str_plain___init__, tmp_dictset_value ); | ||
| 3529 | Py_DECREF( tmp_dictset_value ); | ||
| 3530 | if ( tmp_res != 0 ) | ||
| 3531 | { | ||
| 3532 | assert( ERROR_OCCURRED() ); | ||
| 3533 | |||
| 3534 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3535 | |||
| 3536 | |||
| 3537 | exception_lineno = 31; | ||
| 3538 | type_description_2 = "o"; | ||
| 3539 | goto frame_exception_exit_2; | ||
| 3540 | } | ||
| 3541 | tmp_dictset_value = MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_2_parse( ); | ||
| 3542 | |||
| 3543 | |||
| 3544 | |||
| 3545 | tmp_res = PyObject_SetItem( locals_dbus$_expat_introspect_parser_29, const_str_plain_parse, tmp_dictset_value ); | ||
| 3546 | Py_DECREF( tmp_dictset_value ); | ||
| 3547 | if ( tmp_res != 0 ) | ||
| 3548 | { | ||
| 3549 | assert( ERROR_OCCURRED() ); | ||
| 3550 | |||
| 3551 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3552 | |||
| 3553 | |||
| 3554 | exception_lineno = 37; | ||
| 3555 | type_description_2 = "o"; | ||
| 3556 | goto frame_exception_exit_2; | ||
| 3557 | } | ||
| 3558 | tmp_dictset_value = MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_3_StartElementHandler( ); | ||
| 3559 | |||
| 3560 | |||
| 3561 | |||
| 3562 | tmp_res = PyObject_SetItem( locals_dbus$_expat_introspect_parser_29, const_str_plain_StartElementHandler, tmp_dictset_value ); | ||
| 3563 | Py_DECREF( tmp_dictset_value ); | ||
| 3564 | if ( tmp_res != 0 ) | ||
| 3565 | { | ||
| 3566 | assert( ERROR_OCCURRED() ); | ||
| 3567 | |||
| 3568 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3569 | |||
| 3570 | |||
| 3571 | exception_lineno = 45; | ||
| 3572 | type_description_2 = "o"; | ||
| 3573 | goto frame_exception_exit_2; | ||
| 3574 | } | ||
| 3575 | tmp_dictset_value = MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_4_EndElementHandler( ); | ||
| 3576 | |||
| 3577 | |||
| 3578 | |||
| 3579 | tmp_res = PyObject_SetItem( locals_dbus$_expat_introspect_parser_29, const_str_plain_EndElementHandler, tmp_dictset_value ); | ||
| 3580 | Py_DECREF( tmp_dictset_value ); | ||
| 3581 | if ( tmp_res != 0 ) | ||
| 3582 | { | ||
| 3583 | assert( ERROR_OCCURRED() ); | ||
| 3584 | |||
| 3585 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3586 | |||
| 3587 | |||
| 3588 | exception_lineno = 56; | ||
| 3589 | type_description_2 = "o"; | ||
| 3590 | goto frame_exception_exit_2; | ||
| 3591 | } | ||
| 3592 | |||
| 3593 | #if 0 | ||
| 3594 | RESTORE_FRAME_EXCEPTION( frame_8bb09954d222fbbc2e8769926c9d0187_2 ); | ||
| 3595 | #endif | ||
| 3596 | |||
| 3597 | // Put the previous frame back on top. | ||
| 3598 | popFrameStack(); | ||
| 3599 | |||
| 3600 | goto frame_no_exception_1; | ||
| 3601 | |||
| 3602 | frame_exception_exit_2:; | ||
| 3603 | |||
| 3604 | #if 0 | ||
| 3605 | RESTORE_FRAME_EXCEPTION( frame_8bb09954d222fbbc2e8769926c9d0187_2 ); | ||
| 3606 | #endif | ||
| 3607 | |||
| 3608 | if ( exception_tb == NULL ) | ||
| 3609 | { | ||
| 3610 | exception_tb = MAKE_TRACEBACK( frame_8bb09954d222fbbc2e8769926c9d0187_2, exception_lineno ); | ||
| 3611 | } | ||
| 3612 | else if ( exception_tb->tb_frame != &frame_8bb09954d222fbbc2e8769926c9d0187_2->m_frame ) | ||
| 3613 | { | ||
| 3614 | exception_tb = ADD_TRACEBACK( exception_tb, frame_8bb09954d222fbbc2e8769926c9d0187_2, exception_lineno ); | ||
| 3615 | } | ||
| 3616 | |||
| 3617 | // Attachs locals to frame if any. | ||
| 3618 | Nuitka_Frame_AttachLocals( | ||
| 3619 | (struct Nuitka_FrameObject *)frame_8bb09954d222fbbc2e8769926c9d0187_2, | ||
| 3620 | type_description_2, | ||
| 3621 | outline_0_var___class__ | ||
| 3622 | ); | ||
| 3623 | |||
| 3624 | |||
| 3625 | // Release cached frame. | ||
| 3626 | if ( frame_8bb09954d222fbbc2e8769926c9d0187_2 == cache_frame_8bb09954d222fbbc2e8769926c9d0187_2 ) | ||
| 3627 | { | ||
| 3628 | Py_DECREF( frame_8bb09954d222fbbc2e8769926c9d0187_2 ); | ||
| 3629 | } | ||
| 3630 | cache_frame_8bb09954d222fbbc2e8769926c9d0187_2 = NULL; | ||
| 3631 | |||
| 3632 | assertFrameObject( frame_8bb09954d222fbbc2e8769926c9d0187_2 ); | ||
| 3633 | |||
| 3634 | // Put the previous frame back on top. | ||
| 3635 | popFrameStack(); | ||
| 3636 | |||
| 3637 | // Return the error. | ||
| 3638 | goto nested_frame_exit_1; | ||
| 3639 | |||
| 3640 | frame_no_exception_1:; | ||
| 3641 | goto skip_nested_handling_1; | ||
| 3642 | nested_frame_exit_1:; | ||
| 3643 | |||
| 3644 | goto try_except_handler_3; | ||
| 3645 | skip_nested_handling_1:; | ||
| 3646 | { | ||
| 3647 | nuitka_bool tmp_condition_result_6; | ||
| 3648 | PyObject *tmp_compexpr_left_1; | ||
| 3649 | PyObject *tmp_compexpr_right_1; | ||
| 3650 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 3651 | tmp_compexpr_left_1 = tmp_class_creation_1__bases; | ||
| 3652 | tmp_compexpr_right_1 = const_tuple_type_object_tuple; | ||
| 3653 | tmp_res = RICH_COMPARE_BOOL_NOTEQ_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 3654 | if ( tmp_res == -1 ) | ||
| 3655 | { | ||
| 3656 | assert( ERROR_OCCURRED() ); | ||
| 3657 | |||
| 3658 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3659 | |||
| 3660 | |||
| 3661 | exception_lineno = 29; | ||
| 3662 | |||
| 3663 | goto try_except_handler_3; | ||
| 3664 | } | ||
| 3665 | tmp_condition_result_6 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 3666 | if ( tmp_condition_result_6 == NUITKA_BOOL_TRUE ) | ||
| 3667 | { | ||
| 3668 | goto branch_yes_4; | ||
| 3669 | } | ||
| 3670 | else | ||
| 3671 | { | ||
| 3672 | goto branch_no_4; | ||
| 3673 | } | ||
| 3674 | branch_yes_4:; | ||
| 3675 | tmp_dictset_value = const_tuple_type_object_tuple; | ||
| 3676 | tmp_res = PyObject_SetItem( locals_dbus$_expat_introspect_parser_29, const_str_plain___orig_bases__, tmp_dictset_value ); | ||
| 3677 | if ( tmp_res != 0 ) | ||
| 3678 | { | ||
| 3679 | assert( ERROR_OCCURRED() ); | ||
| 3680 | |||
| 3681 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3682 | |||
| 3683 | |||
| 3684 | exception_lineno = 29; | ||
| 3685 | |||
| 3686 | goto try_except_handler_3; | ||
| 3687 | } | ||
| 3688 | branch_no_4:; | ||
| 3689 | } | ||
| 3690 | { | ||
| 3691 | PyObject *tmp_assign_source_12; | ||
| 3692 | PyObject *tmp_called_name_2; | ||
| 3693 | PyObject *tmp_args_name_2; | ||
| 3694 | PyObject *tmp_tuple_element_3; | ||
| 3695 | PyObject *tmp_kw_name_2; | ||
| 3696 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 3697 | tmp_called_name_2 = tmp_class_creation_1__metaclass; | ||
| 3698 | tmp_tuple_element_3 = const_str_plain__Parser; | ||
| 3699 | tmp_args_name_2 = PyTuple_New( 3 ); | ||
| 3700 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 3701 | PyTuple_SET_ITEM( tmp_args_name_2, 0, tmp_tuple_element_3 ); | ||
| 3702 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 3703 | tmp_tuple_element_3 = tmp_class_creation_1__bases; | ||
| 3704 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 3705 | PyTuple_SET_ITEM( tmp_args_name_2, 1, tmp_tuple_element_3 ); | ||
| 3706 | tmp_tuple_element_3 = locals_dbus$_expat_introspect_parser_29; | ||
| 3707 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 3708 | PyTuple_SET_ITEM( tmp_args_name_2, 2, tmp_tuple_element_3 ); | ||
| 3709 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 3710 | tmp_kw_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 3711 | frame_d985cb2edde0f12e6088a207de5f7222->m_frame.f_lineno = 29; | ||
| 3712 | tmp_assign_source_12 = CALL_FUNCTION( tmp_called_name_2, tmp_args_name_2, tmp_kw_name_2 ); | ||
| 3713 | Py_DECREF( tmp_args_name_2 ); | ||
| 3714 | if ( tmp_assign_source_12 == NULL ) | ||
| 3715 | { | ||
| 3716 | assert( ERROR_OCCURRED() ); | ||
| 3717 | |||
| 3718 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3719 | |||
| 3720 | |||
| 3721 | exception_lineno = 29; | ||
| 3722 | |||
| 3723 | goto try_except_handler_3; | ||
| 3724 | } | ||
| 3725 | assert( outline_0_var___class__ == NULL ); | ||
| 3726 | outline_0_var___class__ = tmp_assign_source_12; | ||
| 3727 | } | ||
| 3728 | CHECK_OBJECT( outline_0_var___class__ ); | ||
| 3729 | tmp_assign_source_11 = outline_0_var___class__; | ||
| 3730 | Py_INCREF( tmp_assign_source_11 ); | ||
| 3731 | goto try_return_handler_3; | ||
| 3732 | // tried codes exits in all cases | ||
| 3733 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser ); | ||
| 3734 | return MOD_RETURN_VALUE( NULL ); | ||
| 3735 | // Return handler code: | ||
| 3736 | try_return_handler_3:; | ||
| 3737 | Py_DECREF( locals_dbus$_expat_introspect_parser_29 ); | ||
| 3738 | locals_dbus$_expat_introspect_parser_29 = NULL; | ||
| 3739 | goto try_return_handler_2; | ||
| 3740 | // Exception handler code: | ||
| 3741 | try_except_handler_3:; | ||
| 3742 | exception_keeper_type_1 = exception_type; | ||
| 3743 | exception_keeper_value_1 = exception_value; | ||
| 3744 | exception_keeper_tb_1 = exception_tb; | ||
| 3745 | exception_keeper_lineno_1 = exception_lineno; | ||
| 3746 | exception_type = NULL; | ||
| 3747 | exception_value = NULL; | ||
| 3748 | exception_tb = NULL; | ||
| 3749 | exception_lineno = 0; | ||
| 3750 | |||
| 3751 | Py_DECREF( locals_dbus$_expat_introspect_parser_29 ); | ||
| 3752 | locals_dbus$_expat_introspect_parser_29 = NULL; | ||
| 3753 | // Re-raise. | ||
| 3754 | exception_type = exception_keeper_type_1; | ||
| 3755 | exception_value = exception_keeper_value_1; | ||
| 3756 | exception_tb = exception_keeper_tb_1; | ||
| 3757 | exception_lineno = exception_keeper_lineno_1; | ||
| 3758 | |||
| 3759 | goto try_except_handler_2; | ||
| 3760 | // End of try: | ||
| 3761 | // tried codes exits in all cases | ||
| 3762 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser ); | ||
| 3763 | return MOD_RETURN_VALUE( NULL ); | ||
| 3764 | // Return handler code: | ||
| 3765 | try_return_handler_2:; | ||
| 3766 | CHECK_OBJECT( (PyObject *)outline_0_var___class__ ); | ||
| 3767 | Py_DECREF( outline_0_var___class__ ); | ||
| 3768 | outline_0_var___class__ = NULL; | ||
| 3769 | |||
| 3770 | goto outline_result_1; | ||
| 3771 | // Exception handler code: | ||
| 3772 | try_except_handler_2:; | ||
| 3773 | exception_keeper_type_2 = exception_type; | ||
| 3774 | exception_keeper_value_2 = exception_value; | ||
| 3775 | exception_keeper_tb_2 = exception_tb; | ||
| 3776 | exception_keeper_lineno_2 = exception_lineno; | ||
| 3777 | exception_type = NULL; | ||
| 3778 | exception_value = NULL; | ||
| 3779 | exception_tb = NULL; | ||
| 3780 | exception_lineno = 0; | ||
| 3781 | |||
| 3782 | // Re-raise. | ||
| 3783 | exception_type = exception_keeper_type_2; | ||
| 3784 | exception_value = exception_keeper_value_2; | ||
| 3785 | exception_tb = exception_keeper_tb_2; | ||
| 3786 | exception_lineno = exception_keeper_lineno_2; | ||
| 3787 | |||
| 3788 | goto outline_exception_1; | ||
| 3789 | // End of try: | ||
| 3790 | // Return statement must have exited already. | ||
| 3791 | NUITKA_CANNOT_GET_HERE( dbus$_expat_introspect_parser ); | ||
| 3792 | return MOD_RETURN_VALUE( NULL ); | ||
| 3793 | outline_exception_1:; | ||
| 3794 | exception_lineno = 29; | ||
| 3795 | goto try_except_handler_1; | ||
| 3796 | outline_result_1:; | ||
| 3797 | UPDATE_STRING_DICT1( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain__Parser, tmp_assign_source_11 ); | ||
| 3798 | } | ||
| 3799 | goto try_end_1; | ||
| 3800 | // Exception handler code: | ||
| 3801 | try_except_handler_1:; | ||
| 3802 | exception_keeper_type_3 = exception_type; | ||
| 3803 | exception_keeper_value_3 = exception_value; | ||
| 3804 | exception_keeper_tb_3 = exception_tb; | ||
| 3805 | exception_keeper_lineno_3 = exception_lineno; | ||
| 3806 | exception_type = NULL; | ||
| 3807 | exception_value = NULL; | ||
| 3808 | exception_tb = NULL; | ||
| 3809 | exception_lineno = 0; | ||
| 3810 | |||
| 3811 | Py_XDECREF( tmp_class_creation_1__bases ); | ||
| 3812 | tmp_class_creation_1__bases = NULL; | ||
| 3813 | |||
| 3814 | Py_XDECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 3815 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 3816 | |||
| 3817 | Py_XDECREF( tmp_class_creation_1__metaclass ); | ||
| 3818 | tmp_class_creation_1__metaclass = NULL; | ||
| 3819 | |||
| 3820 | Py_XDECREF( tmp_class_creation_1__prepared ); | ||
| 3821 | tmp_class_creation_1__prepared = NULL; | ||
| 3822 | |||
| 3823 | // Re-raise. | ||
| 3824 | exception_type = exception_keeper_type_3; | ||
| 3825 | exception_value = exception_keeper_value_3; | ||
| 3826 | exception_tb = exception_keeper_tb_3; | ||
| 3827 | exception_lineno = exception_keeper_lineno_3; | ||
| 3828 | |||
| 3829 | goto frame_exception_exit_1; | ||
| 3830 | // End of try: | ||
| 3831 | try_end_1:; | ||
| 3832 | |||
| 3833 | // Restore frame exception if necessary. | ||
| 3834 | #if 0 | ||
| 3835 | RESTORE_FRAME_EXCEPTION( frame_d985cb2edde0f12e6088a207de5f7222 ); | ||
| 3836 | #endif | ||
| 3837 | popFrameStack(); | ||
| 3838 | |||
| 3839 | assertFrameObject( frame_d985cb2edde0f12e6088a207de5f7222 ); | ||
| 3840 | |||
| 3841 | goto frame_no_exception_2; | ||
| 3842 | |||
| 3843 | frame_exception_exit_1:; | ||
| 3844 | #if 0 | ||
| 3845 | RESTORE_FRAME_EXCEPTION( frame_d985cb2edde0f12e6088a207de5f7222 ); | ||
| 3846 | #endif | ||
| 3847 | |||
| 3848 | if ( exception_tb == NULL ) | ||
| 3849 | { | ||
| 3850 | exception_tb = MAKE_TRACEBACK( frame_d985cb2edde0f12e6088a207de5f7222, exception_lineno ); | ||
| 3851 | } | ||
| 3852 | else if ( exception_tb->tb_frame != &frame_d985cb2edde0f12e6088a207de5f7222->m_frame ) | ||
| 3853 | { | ||
| 3854 | exception_tb = ADD_TRACEBACK( exception_tb, frame_d985cb2edde0f12e6088a207de5f7222, exception_lineno ); | ||
| 3855 | } | ||
| 3856 | |||
| 3857 | // Put the previous frame back on top. | ||
| 3858 | popFrameStack(); | ||
| 3859 | |||
| 3860 | // Return the error. | ||
| 3861 | goto module_exception_exit; | ||
| 3862 | |||
| 3863 | frame_no_exception_2:; | ||
| 3864 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__bases ); | ||
| 3865 | Py_DECREF( tmp_class_creation_1__bases ); | ||
| 3866 | tmp_class_creation_1__bases = NULL; | ||
| 3867 | |||
| 3868 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__class_decl_dict ); | ||
| 3869 | Py_DECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 3870 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 3871 | |||
| 3872 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__metaclass ); | ||
| 3873 | Py_DECREF( tmp_class_creation_1__metaclass ); | ||
| 3874 | tmp_class_creation_1__metaclass = NULL; | ||
| 3875 | |||
| 3876 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__prepared ); | ||
| 3877 | Py_DECREF( tmp_class_creation_1__prepared ); | ||
| 3878 | tmp_class_creation_1__prepared = NULL; | ||
| 3879 | |||
| 3880 | { | ||
| 3881 | PyObject *tmp_assign_source_13; | ||
| 3882 | tmp_assign_source_13 = MAKE_FUNCTION_dbus$_expat_introspect_parser$$$function_5_process_introspection_data( ); | ||
| 3883 | |||
| 3884 | |||
| 3885 | |||
| 3886 | UPDATE_STRING_DICT1( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain_process_introspection_data, tmp_assign_source_13 ); | ||
| 3887 | } | ||
| 3888 | |||
| 3889 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 3890 | #if 0 && 0 | ||
| 3891 | { | ||
| 3892 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_dbus$_expat_introspect_parser, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 3893 | |||
| 3894 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 3895 | { | ||
| 3896 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 3897 | |||
| 3898 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 3899 | CHECK_OBJECT( path_importer_cache ); | ||
| 3900 | |||
| 3901 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 3902 | assert( res == 0 ); | ||
| 3903 | } | ||
| 3904 | } | ||
| 3905 | #endif | ||
| 3906 | #endif | ||
| 3907 | |||
| 3908 | return MOD_RETURN_VALUE( module_dbus$_expat_introspect_parser ); | ||
| 3909 | module_exception_exit: | ||
| 3910 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 3911 | return MOD_RETURN_VALUE( NULL ); | ||
| 3912 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.dbus._expat_introspect_parser.o deleted (index 80a7cc9..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.dbus.bus.c is too big (13231 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.dbus.bus.o deleted (index bf8bf1d..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.dbus.c deleted (index f9ec7b4..0000000) | |||
| 1 | /* Generated code for Python module 'dbus' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_dbus" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_dbus; | ||
| 31 | PyDictObject *moduledict_dbus; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain___spec__; | ||
| 35 | extern PyObject *const_str_digest_62223e4c0fc7bcb5885146e43f1fb665; | ||
| 36 | extern PyObject *const_tuple_c05661dc311559e0338d3f9170078d6a_tuple; | ||
| 37 | extern PyObject *const_str_plain___file__; | ||
| 38 | static PyObject *const_str_plain_PEER_IFACE; | ||
| 39 | static PyObject *const_str_plain_get_default_main_loop; | ||
| 40 | extern PyObject *const_str_plain_Bus; | ||
| 41 | extern PyObject *const_str_plain_Array; | ||
| 42 | extern PyObject *const_str_plain_UInt64; | ||
| 43 | static PyObject *const_tuple_2c9d1c6863fdd586bfca32d97434ea23_tuple; | ||
| 44 | extern PyObject *const_str_plain_Dictionary; | ||
| 45 | static PyObject *const_tuple_str_plain_Interface_tuple; | ||
| 46 | extern PyObject *const_str_plain___docformat__; | ||
| 47 | extern PyObject *const_str_plain_Interface; | ||
| 48 | static PyObject *const_str_digest_984a814ffe01453f3c0bfa87da4d7872; | ||
| 49 | extern PyObject *const_str_plain_Double; | ||
| 50 | extern PyObject *const_str_plain___doc__; | ||
| 51 | extern PyObject *const_str_plain_MissingReplyHandlerException; | ||
| 52 | extern PyObject *const_str_dot; | ||
| 53 | extern PyObject *const_str_plain_NUITKA_PACKAGE_dbus; | ||
| 54 | extern PyObject *const_str_plain_validate_error_name; | ||
| 55 | extern PyObject *const_str_plain_environ; | ||
| 56 | extern PyObject *const_tuple_str_plain_UTF8String_tuple; | ||
| 57 | extern PyObject *const_str_plain_BUS_DAEMON_PATH; | ||
| 58 | extern PyObject *const_str_plain__dbus_bindings; | ||
| 59 | extern PyObject *const_str_plain_UInt32; | ||
| 60 | extern PyObject *const_str_digest_3aa5bee4de9b0149ae46ffed8a38c6b4; | ||
| 61 | extern PyObject *const_str_plain_int; | ||
| 62 | extern PyObject *const_str_plain_path; | ||
| 63 | extern PyObject *const_str_plain_dbus; | ||
| 64 | extern PyObject *const_str_plain_INTROSPECTABLE_IFACE; | ||
| 65 | extern PyObject *const_str_plain_String; | ||
| 66 | extern PyObject *const_str_plain_UnknownMethodException; | ||
| 67 | extern PyObject *const_str_plain_NameExistsException; | ||
| 68 | extern PyObject *const_tuple_str_dot_tuple; | ||
| 69 | extern PyObject *const_str_plain___path__; | ||
| 70 | extern PyObject *const_tuple_empty; | ||
| 71 | extern PyObject *const_str_plain_append; | ||
| 72 | static PyObject *const_tuple_str_plain___version___tuple; | ||
| 73 | extern PyObject *const_str_plain_validate_interface_name; | ||
| 74 | extern PyObject *const_str_plain_exceptions; | ||
| 75 | extern PyObject *const_str_plain_Struct; | ||
| 76 | extern PyObject *const_str_plain_split; | ||
| 77 | extern PyObject *const_str_plain_restructuredtext; | ||
| 78 | static PyObject *const_tuple_11fa090efaf7d01dd8418473997afcd0_tuple; | ||
| 79 | static PyObject *const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple; | ||
| 80 | extern PyObject *const_str_plain_Int16; | ||
| 81 | extern PyObject *const_str_plain_map; | ||
| 82 | static PyObject *const_tuple_a42d09975d91c391fbb7668332a8328b_tuple; | ||
| 83 | static PyObject *const_str_digest_d28ba98cdd0dea211f5951fcb5d3e7b2; | ||
| 84 | extern PyObject *const_str_plain___all__; | ||
| 85 | extern PyObject *const_str_plain_IntrospectionParserException; | ||
| 86 | extern PyObject *const_str_plain_Byte; | ||
| 87 | extern PyObject *const_str_plain___version__; | ||
| 88 | extern PyObject *const_int_0; | ||
| 89 | extern PyObject *const_str_plain_DBusException; | ||
| 90 | extern PyObject *const_str_plain_BUS_DAEMON_NAME; | ||
| 91 | extern PyObject *const_str_plain_Int32; | ||
| 92 | extern PyObject *const_tuple_str_plain_is_py2_tuple; | ||
| 93 | extern PyObject *const_str_plain_origin; | ||
| 94 | extern PyObject *const_str_plain_StarterBus; | ||
| 95 | extern PyObject *const_tuple_76ee81f3638eaf5a352e7276367934cb_tuple; | ||
| 96 | extern PyObject *const_str_plain_validate_member_name; | ||
| 97 | extern PyObject *const_str_plain_Boolean; | ||
| 98 | extern PyObject *const_str_plain_validate_object_path; | ||
| 99 | extern PyObject *const_str_plain_dirname; | ||
| 100 | static PyObject *const_str_plain_set_default_main_loop; | ||
| 101 | static PyObject *const_str_digest_e06d6869a10758f0e3d79f8f7b50582f; | ||
| 102 | extern PyObject *const_str_plain___cached__; | ||
| 103 | extern PyObject *const_str_plain_Signature; | ||
| 104 | extern PyObject *const_str_digest_8e2db9d493d0360a27a3bf19583a3201; | ||
| 105 | extern PyObject *const_str_plain_MissingErrorHandlerException; | ||
| 106 | extern PyObject *const_str_plain_validate_bus_name; | ||
| 107 | extern PyObject *const_str_plain_LOCAL_IFACE; | ||
| 108 | extern PyObject *const_str_plain_ByteArray; | ||
| 109 | extern PyObject *const_str_plain_UInt16; | ||
| 110 | static PyObject *const_list_c00e43f6c89f1bff4b3c8c15fedd441c_list; | ||
| 111 | extern PyObject *const_str_plain_types; | ||
| 112 | extern PyObject *const_str_plain_ValidationException; | ||
| 113 | extern PyObject *const_str_digest_1abd3647207b34d013514bc0c6956d0b; | ||
| 114 | extern PyObject *const_str_plain_SessionBus; | ||
| 115 | extern PyObject *const_str_digest_5bfaf90dbd407b4fc29090c8f6415242; | ||
| 116 | extern PyObject *const_str_plain_get; | ||
| 117 | extern PyObject *const_str_plain_has_location; | ||
| 118 | extern PyObject *const_str_plain_ObjectPath; | ||
| 119 | extern PyObject *const_str_plain_version; | ||
| 120 | extern PyObject *const_str_plain_BUS_DAEMON_IFACE; | ||
| 121 | extern PyObject *const_str_plain_UTF8String; | ||
| 122 | extern PyObject *const_str_digest_e48610c30fffad33f2054d9dca0792b3; | ||
| 123 | extern PyObject *const_str_plain_Int64; | ||
| 124 | extern PyObject *const_str_plain_SystemBus; | ||
| 125 | static PyObject *const_str_plain_PROPERTIES_IFACE; | ||
| 126 | extern PyObject *const_str_plain_is_py2; | ||
| 127 | extern PyObject *const_str_plain_LOCAL_PATH; | ||
| 128 | static PyObject *module_filename_obj; | ||
| 129 | |||
| 130 | /* Indicator if this modules private constants were created yet. */ | ||
| 131 | static bool constants_created = false; | ||
| 132 | |||
| 133 | /* Function to create module private constants. */ | ||
| 134 | static void createModuleConstants( void ) | ||
| 135 | { | ||
| 136 | const_str_plain_PEER_IFACE = UNSTREAM_STRING_ASCII( &constant_bin[ 2981 ], 10, 1 ); | ||
| 137 | const_str_plain_get_default_main_loop = UNSTREAM_STRING_ASCII( &constant_bin[ 2991 ], 21, 1 ); | ||
| 138 | const_tuple_2c9d1c6863fdd586bfca32d97434ea23_tuple = PyTuple_New( 7 ); | ||
| 139 | PyTuple_SET_ITEM( const_tuple_2c9d1c6863fdd586bfca32d97434ea23_tuple, 0, const_str_plain_get_default_main_loop ); Py_INCREF( const_str_plain_get_default_main_loop ); | ||
| 140 | const_str_plain_set_default_main_loop = UNSTREAM_STRING_ASCII( &constant_bin[ 3012 ], 21, 1 ); | ||
| 141 | PyTuple_SET_ITEM( const_tuple_2c9d1c6863fdd586bfca32d97434ea23_tuple, 1, const_str_plain_set_default_main_loop ); Py_INCREF( const_str_plain_set_default_main_loop ); | ||
| 142 | PyTuple_SET_ITEM( const_tuple_2c9d1c6863fdd586bfca32d97434ea23_tuple, 2, const_str_plain_validate_bus_name ); Py_INCREF( const_str_plain_validate_bus_name ); | ||
| 143 | PyTuple_SET_ITEM( const_tuple_2c9d1c6863fdd586bfca32d97434ea23_tuple, 3, const_str_plain_validate_error_name ); Py_INCREF( const_str_plain_validate_error_name ); | ||
| 144 | PyTuple_SET_ITEM( const_tuple_2c9d1c6863fdd586bfca32d97434ea23_tuple, 4, const_str_plain_validate_interface_name ); Py_INCREF( const_str_plain_validate_interface_name ); | ||
| 145 | PyTuple_SET_ITEM( const_tuple_2c9d1c6863fdd586bfca32d97434ea23_tuple, 5, const_str_plain_validate_member_name ); Py_INCREF( const_str_plain_validate_member_name ); | ||
| 146 | PyTuple_SET_ITEM( const_tuple_2c9d1c6863fdd586bfca32d97434ea23_tuple, 6, const_str_plain_validate_object_path ); Py_INCREF( const_str_plain_validate_object_path ); | ||
| 147 | const_tuple_str_plain_Interface_tuple = PyTuple_New( 1 ); | ||
| 148 | PyTuple_SET_ITEM( const_tuple_str_plain_Interface_tuple, 0, const_str_plain_Interface ); Py_INCREF( const_str_plain_Interface ); | ||
| 149 | const_str_digest_984a814ffe01453f3c0bfa87da4d7872 = UNSTREAM_STRING_ASCII( &constant_bin[ 3033 ], 13, 0 ); | ||
| 150 | const_tuple_str_plain___version___tuple = PyTuple_New( 1 ); | ||
| 151 | PyTuple_SET_ITEM( const_tuple_str_plain___version___tuple, 0, const_str_plain___version__ ); Py_INCREF( const_str_plain___version__ ); | ||
| 152 | const_tuple_11fa090efaf7d01dd8418473997afcd0_tuple = PyTuple_New( 7 ); | ||
| 153 | PyTuple_SET_ITEM( const_tuple_11fa090efaf7d01dd8418473997afcd0_tuple, 0, const_str_plain_DBusException ); Py_INCREF( const_str_plain_DBusException ); | ||
| 154 | PyTuple_SET_ITEM( const_tuple_11fa090efaf7d01dd8418473997afcd0_tuple, 1, const_str_plain_IntrospectionParserException ); Py_INCREF( const_str_plain_IntrospectionParserException ); | ||
| 155 | PyTuple_SET_ITEM( const_tuple_11fa090efaf7d01dd8418473997afcd0_tuple, 2, const_str_plain_MissingErrorHandlerException ); Py_INCREF( const_str_plain_MissingErrorHandlerException ); | ||
| 156 | PyTuple_SET_ITEM( const_tuple_11fa090efaf7d01dd8418473997afcd0_tuple, 3, const_str_plain_MissingReplyHandlerException ); Py_INCREF( const_str_plain_MissingReplyHandlerException ); | ||
| 157 | PyTuple_SET_ITEM( const_tuple_11fa090efaf7d01dd8418473997afcd0_tuple, 4, const_str_plain_NameExistsException ); Py_INCREF( const_str_plain_NameExistsException ); | ||
| 158 | PyTuple_SET_ITEM( const_tuple_11fa090efaf7d01dd8418473997afcd0_tuple, 5, const_str_plain_UnknownMethodException ); Py_INCREF( const_str_plain_UnknownMethodException ); | ||
| 159 | PyTuple_SET_ITEM( const_tuple_11fa090efaf7d01dd8418473997afcd0_tuple, 6, const_str_plain_ValidationException ); Py_INCREF( const_str_plain_ValidationException ); | ||
| 160 | const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple = PyTuple_New( 16 ); | ||
| 161 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 0, const_str_plain_Array ); Py_INCREF( const_str_plain_Array ); | ||
| 162 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 1, const_str_plain_Boolean ); Py_INCREF( const_str_plain_Boolean ); | ||
| 163 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 2, const_str_plain_Byte ); Py_INCREF( const_str_plain_Byte ); | ||
| 164 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 3, const_str_plain_ByteArray ); Py_INCREF( const_str_plain_ByteArray ); | ||
| 165 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 4, const_str_plain_Dictionary ); Py_INCREF( const_str_plain_Dictionary ); | ||
| 166 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 5, const_str_plain_Double ); Py_INCREF( const_str_plain_Double ); | ||
| 167 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 6, const_str_plain_Int16 ); Py_INCREF( const_str_plain_Int16 ); | ||
| 168 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 7, const_str_plain_Int32 ); Py_INCREF( const_str_plain_Int32 ); | ||
| 169 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 8, const_str_plain_Int64 ); Py_INCREF( const_str_plain_Int64 ); | ||
| 170 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 9, const_str_plain_ObjectPath ); Py_INCREF( const_str_plain_ObjectPath ); | ||
| 171 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 10, const_str_plain_Signature ); Py_INCREF( const_str_plain_Signature ); | ||
| 172 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 11, const_str_plain_String ); Py_INCREF( const_str_plain_String ); | ||
| 173 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 12, const_str_plain_Struct ); Py_INCREF( const_str_plain_Struct ); | ||
| 174 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 13, const_str_plain_UInt16 ); Py_INCREF( const_str_plain_UInt16 ); | ||
| 175 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 14, const_str_plain_UInt32 ); Py_INCREF( const_str_plain_UInt32 ); | ||
| 176 | PyTuple_SET_ITEM( const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple, 15, const_str_plain_UInt64 ); Py_INCREF( const_str_plain_UInt64 ); | ||
| 177 | const_tuple_a42d09975d91c391fbb7668332a8328b_tuple = PyTuple_New( 8 ); | ||
| 178 | PyTuple_SET_ITEM( const_tuple_a42d09975d91c391fbb7668332a8328b_tuple, 0, const_str_plain_BUS_DAEMON_IFACE ); Py_INCREF( const_str_plain_BUS_DAEMON_IFACE ); | ||
| 179 | PyTuple_SET_ITEM( const_tuple_a42d09975d91c391fbb7668332a8328b_tuple, 1, const_str_plain_BUS_DAEMON_NAME ); Py_INCREF( const_str_plain_BUS_DAEMON_NAME ); | ||
| 180 | PyTuple_SET_ITEM( const_tuple_a42d09975d91c391fbb7668332a8328b_tuple, 2, const_str_plain_BUS_DAEMON_PATH ); Py_INCREF( const_str_plain_BUS_DAEMON_PATH ); | ||
| 181 | PyTuple_SET_ITEM( const_tuple_a42d09975d91c391fbb7668332a8328b_tuple, 3, const_str_plain_INTROSPECTABLE_IFACE ); Py_INCREF( const_str_plain_INTROSPECTABLE_IFACE ); | ||
| 182 | PyTuple_SET_ITEM( const_tuple_a42d09975d91c391fbb7668332a8328b_tuple, 4, const_str_plain_LOCAL_IFACE ); Py_INCREF( const_str_plain_LOCAL_IFACE ); | ||
| 183 | PyTuple_SET_ITEM( const_tuple_a42d09975d91c391fbb7668332a8328b_tuple, 5, const_str_plain_LOCAL_PATH ); Py_INCREF( const_str_plain_LOCAL_PATH ); | ||
| 184 | PyTuple_SET_ITEM( const_tuple_a42d09975d91c391fbb7668332a8328b_tuple, 6, const_str_plain_PEER_IFACE ); Py_INCREF( const_str_plain_PEER_IFACE ); | ||
| 185 | const_str_plain_PROPERTIES_IFACE = UNSTREAM_STRING_ASCII( &constant_bin[ 3046 ], 16, 1 ); | ||
| 186 | PyTuple_SET_ITEM( const_tuple_a42d09975d91c391fbb7668332a8328b_tuple, 7, const_str_plain_PROPERTIES_IFACE ); Py_INCREF( const_str_plain_PROPERTIES_IFACE ); | ||
| 187 | const_str_digest_d28ba98cdd0dea211f5951fcb5d3e7b2 = UNSTREAM_STRING_ASCII( &constant_bin[ 3062 ], 119, 0 ); | ||
| 188 | const_str_digest_e06d6869a10758f0e3d79f8f7b50582f = UNSTREAM_STRING_ASCII( &constant_bin[ 3181 ], 16, 0 ); | ||
| 189 | const_list_c00e43f6c89f1bff4b3c8c15fedd441c_list = PyMarshal_ReadObjectFromString( (char *)&constant_bin[ 3197 ], 677 ); | ||
| 190 | |||
| 191 | constants_created = true; | ||
| 192 | } | ||
| 193 | |||
| 194 | /* Function to verify module private constants for non-corruption. */ | ||
| 195 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 196 | void checkModuleConstants_dbus( void ) | ||
| 197 | { | ||
| 198 | // The module may not have been used at all, then ignore this. | ||
| 199 | if (constants_created == false) return; | ||
| 200 | |||
| 201 | |||
| 202 | } | ||
| 203 | #endif | ||
| 204 | |||
| 205 | // The module code objects. | ||
| 206 | static PyCodeObject *codeobj_d676880cece0dacbdc685c3346c3b838; | ||
| 207 | |||
| 208 | static void createModuleCodeObjects(void) | ||
| 209 | { | ||
| 210 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_e06d6869a10758f0e3d79f8f7b50582f ); | ||
| 211 | codeobj_d676880cece0dacbdc685c3346c3b838 = MAKE_CODEOBJ( module_filename_obj, const_str_digest_984a814ffe01453f3c0bfa87da4d7872, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 212 | } | ||
| 213 | |||
| 214 | // The module function declarations. | ||
| 215 | |||
| 216 | |||
| 217 | // The module function definitions. | ||
| 218 | |||
| 219 | |||
| 220 | |||
| 221 | #if PYTHON_VERSION >= 300 | ||
| 222 | static struct PyModuleDef mdef_dbus = | ||
| 223 | { | ||
| 224 | PyModuleDef_HEAD_INIT, | ||
| 225 | "dbus", | ||
| 226 | NULL, /* m_doc */ | ||
| 227 | -1, /* m_size */ | ||
| 228 | NULL, /* m_methods */ | ||
| 229 | NULL, /* m_reload */ | ||
| 230 | NULL, /* m_traverse */ | ||
| 231 | NULL, /* m_clear */ | ||
| 232 | NULL, /* m_free */ | ||
| 233 | }; | ||
| 234 | #endif | ||
| 235 | |||
| 236 | extern PyObject *const_str_plain___compiled__; | ||
| 237 | |||
| 238 | extern PyObject *const_str_plain___package__; | ||
| 239 | |||
| 240 | #if PYTHON_VERSION >= 300 | ||
| 241 | extern PyObject *const_str_dot; | ||
| 242 | extern PyObject *const_str_plain___loader__; | ||
| 243 | #endif | ||
| 244 | |||
| 245 | #if PYTHON_VERSION >= 340 | ||
| 246 | extern PyObject *const_str_plain___spec__; | ||
| 247 | extern PyObject *const_str_plain__initializing; | ||
| 248 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 249 | #endif | ||
| 250 | |||
| 251 | extern void _initCompiledCellType(); | ||
| 252 | extern void _initCompiledGeneratorType(); | ||
| 253 | extern void _initCompiledFunctionType(); | ||
| 254 | extern void _initCompiledMethodType(); | ||
| 255 | extern void _initCompiledFrameType(); | ||
| 256 | #if PYTHON_VERSION >= 350 | ||
| 257 | extern void _initCompiledCoroutineTypes(); | ||
| 258 | #endif | ||
| 259 | #if PYTHON_VERSION >= 360 | ||
| 260 | extern void _initCompiledAsyncgenTypes(); | ||
| 261 | #endif | ||
| 262 | |||
| 263 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 264 | |||
| 265 | // The exported interface to CPython. On import of the module, this function | ||
| 266 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 267 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 268 | |||
| 269 | MOD_INIT_DECL( dbus ) | ||
| 270 | { | ||
| 271 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 272 | static bool _init_done = false; | ||
| 273 | |||
| 274 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 275 | if ( _init_done ) | ||
| 276 | { | ||
| 277 | return MOD_RETURN_VALUE( module_dbus ); | ||
| 278 | } | ||
| 279 | else | ||
| 280 | { | ||
| 281 | _init_done = true; | ||
| 282 | } | ||
| 283 | #endif | ||
| 284 | |||
| 285 | #ifdef _NUITKA_MODULE | ||
| 286 | // In case of a stand alone extension module, need to call initialization | ||
| 287 | // the init here because that's the first and only time we are going to get | ||
| 288 | // called here. | ||
| 289 | |||
| 290 | // Initialize the constant values used. | ||
| 291 | _initBuiltinModule(); | ||
| 292 | createGlobalConstants(); | ||
| 293 | |||
| 294 | /* Initialize the compiled types of Nuitka. */ | ||
| 295 | _initCompiledCellType(); | ||
| 296 | _initCompiledGeneratorType(); | ||
| 297 | _initCompiledFunctionType(); | ||
| 298 | _initCompiledMethodType(); | ||
| 299 | _initCompiledFrameType(); | ||
| 300 | #if PYTHON_VERSION >= 350 | ||
| 301 | _initCompiledCoroutineTypes(); | ||
| 302 | #endif | ||
| 303 | #if PYTHON_VERSION >= 360 | ||
| 304 | _initCompiledAsyncgenTypes(); | ||
| 305 | #endif | ||
| 306 | |||
| 307 | #if PYTHON_VERSION < 300 | ||
| 308 | _initSlotCompare(); | ||
| 309 | #endif | ||
| 310 | #if PYTHON_VERSION >= 270 | ||
| 311 | _initSlotIternext(); | ||
| 312 | #endif | ||
| 313 | |||
| 314 | patchBuiltinModule(); | ||
| 315 | patchTypeComparison(); | ||
| 316 | |||
| 317 | // Enable meta path based loader if not already done. | ||
| 318 | #ifdef _NUITKA_TRACE | ||
| 319 | puts("dbus: Calling setupMetaPathBasedLoader()."); | ||
| 320 | #endif | ||
| 321 | setupMetaPathBasedLoader(); | ||
| 322 | |||
| 323 | #if PYTHON_VERSION >= 300 | ||
| 324 | patchInspectModule(); | ||
| 325 | #endif | ||
| 326 | |||
| 327 | #endif | ||
| 328 | |||
| 329 | /* The constants only used by this module are created now. */ | ||
| 330 | #ifdef _NUITKA_TRACE | ||
| 331 | puts("dbus: Calling createModuleConstants()."); | ||
| 332 | #endif | ||
| 333 | createModuleConstants(); | ||
| 334 | |||
| 335 | /* The code objects used by this module are created now. */ | ||
| 336 | #ifdef _NUITKA_TRACE | ||
| 337 | puts("dbus: Calling createModuleCodeObjects()."); | ||
| 338 | #endif | ||
| 339 | createModuleCodeObjects(); | ||
| 340 | |||
| 341 | // puts( "in initdbus" ); | ||
| 342 | |||
| 343 | // Create the module object first. There are no methods initially, all are | ||
| 344 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 345 | // set at this time, as it could not contain NUL characters this way, they | ||
| 346 | // are instead set in early module code. No "self" for modules, we have no | ||
| 347 | // use for it. | ||
| 348 | #if PYTHON_VERSION < 300 | ||
| 349 | module_dbus = Py_InitModule4( | ||
| 350 | "dbus", // Module Name | ||
| 351 | NULL, // No methods initially, all are added | ||
| 352 | // dynamically in actual module code only. | ||
| 353 | NULL, // No "__doc__" is initially set, as it could | ||
| 354 | // not contain NUL this way, added early in | ||
| 355 | // actual code. | ||
| 356 | NULL, // No self for modules, we don't use it. | ||
| 357 | PYTHON_API_VERSION | ||
| 358 | ); | ||
| 359 | #else | ||
| 360 | |||
| 361 | module_dbus = PyModule_Create( &mdef_dbus ); | ||
| 362 | #endif | ||
| 363 | |||
| 364 | moduledict_dbus = MODULE_DICT( module_dbus ); | ||
| 365 | |||
| 366 | // Set __compiled__ to what it we know. | ||
| 367 | UPDATE_STRING_DICT1( | ||
| 368 | moduledict_dbus, | ||
| 369 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 370 | Nuitka_dunder_compiled_value | ||
| 371 | ); | ||
| 372 | |||
| 373 | // Update "__package__" value to what it ought to be. | ||
| 374 | { | ||
| 375 | #if 1 | ||
| 376 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 377 | |||
| 378 | UPDATE_STRING_DICT1( | ||
| 379 | moduledict_dbus, | ||
| 380 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 381 | module_name | ||
| 382 | ); | ||
| 383 | #else | ||
| 384 | |||
| 385 | #if PYTHON_VERSION < 300 | ||
| 386 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 387 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 388 | |||
| 389 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 390 | |||
| 391 | if ( last_dot != NULL ) | ||
| 392 | { | ||
| 393 | UPDATE_STRING_DICT1( | ||
| 394 | moduledict_dbus, | ||
| 395 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 396 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 397 | ); | ||
| 398 | } | ||
| 399 | #else | ||
| 400 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 401 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 402 | |||
| 403 | if ( dot_index != -1 ) | ||
| 404 | { | ||
| 405 | UPDATE_STRING_DICT1( | ||
| 406 | moduledict_dbus, | ||
| 407 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 408 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 409 | ); | ||
| 410 | } | ||
| 411 | #endif | ||
| 412 | #endif | ||
| 413 | } | ||
| 414 | |||
| 415 | CHECK_OBJECT( module_dbus ); | ||
| 416 | |||
| 417 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 418 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 419 | #if PYTHON_VERSION >= 300 | ||
| 420 | { | ||
| 421 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_plain_dbus, module_dbus ); | ||
| 422 | |||
| 423 | assert( r != -1 ); | ||
| 424 | } | ||
| 425 | #endif | ||
| 426 | |||
| 427 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 428 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 429 | // before the frame object is allocated, or else it may fail. | ||
| 430 | |||
| 431 | if ( GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 432 | { | ||
| 433 | PyObject *value = (PyObject *)builtin_module; | ||
| 434 | |||
| 435 | // Check if main module, not a dict then but the module itself. | ||
| 436 | #if !defined(_NUITKA_EXE) || !0 | ||
| 437 | value = PyModule_GetDict( value ); | ||
| 438 | #endif | ||
| 439 | |||
| 440 | UPDATE_STRING_DICT0( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 441 | } | ||
| 442 | |||
| 443 | #if PYTHON_VERSION >= 300 | ||
| 444 | UPDATE_STRING_DICT0( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 445 | #endif | ||
| 446 | |||
| 447 | #if PYTHON_VERSION >= 340 | ||
| 448 | // Set the "__spec__" value | ||
| 449 | |||
| 450 | #if 0 | ||
| 451 | // Main modules just get "None" as spec. | ||
| 452 | UPDATE_STRING_DICT0( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 453 | #else | ||
| 454 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 455 | { | ||
| 456 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 457 | CHECK_OBJECT( bootstrap_module ); | ||
| 458 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 459 | Py_DECREF( bootstrap_module ); | ||
| 460 | |||
| 461 | PyObject *args[] = { | ||
| 462 | GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 463 | (PyObject *)&Nuitka_Loader_Type | ||
| 464 | }; | ||
| 465 | |||
| 466 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 467 | module_spec_class, | ||
| 468 | args | ||
| 469 | ); | ||
| 470 | Py_DECREF( module_spec_class ); | ||
| 471 | |||
| 472 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 473 | CHECK_OBJECT( spec_value ); | ||
| 474 | |||
| 475 | // For packages set the submodule search locations as well, even if to empty | ||
| 476 | // list, so investigating code will consider it a package. | ||
| 477 | #if 1 | ||
| 478 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 479 | #endif | ||
| 480 | |||
| 481 | // Mark the execution in the "__spec__" value. | ||
| 482 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 483 | |||
| 484 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 485 | } | ||
| 486 | #endif | ||
| 487 | #endif | ||
| 488 | |||
| 489 | // Temp variables if any | ||
| 490 | PyObject *tmp_import_from_1__module = NULL; | ||
| 491 | PyObject *tmp_import_from_2__module = NULL; | ||
| 492 | PyObject *tmp_import_from_3__module = NULL; | ||
| 493 | PyObject *tmp_import_from_4__module = NULL; | ||
| 494 | PyObject *tmp_import_from_5__module = NULL; | ||
| 495 | struct Nuitka_FrameObject *frame_d676880cece0dacbdc685c3346c3b838; | ||
| 496 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 497 | PyObject *exception_type = NULL; | ||
| 498 | PyObject *exception_value = NULL; | ||
| 499 | PyTracebackObject *exception_tb = NULL; | ||
| 500 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 501 | bool tmp_result; | ||
| 502 | PyObject *exception_keeper_type_1; | ||
| 503 | PyObject *exception_keeper_value_1; | ||
| 504 | PyTracebackObject *exception_keeper_tb_1; | ||
| 505 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 506 | PyObject *exception_keeper_type_2; | ||
| 507 | PyObject *exception_keeper_value_2; | ||
| 508 | PyTracebackObject *exception_keeper_tb_2; | ||
| 509 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 510 | PyObject *exception_keeper_type_3; | ||
| 511 | PyObject *exception_keeper_value_3; | ||
| 512 | PyTracebackObject *exception_keeper_tb_3; | ||
| 513 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; | ||
| 514 | PyObject *exception_keeper_type_4; | ||
| 515 | PyObject *exception_keeper_value_4; | ||
| 516 | PyTracebackObject *exception_keeper_tb_4; | ||
| 517 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_4; | ||
| 518 | PyObject *exception_keeper_type_5; | ||
| 519 | PyObject *exception_keeper_value_5; | ||
| 520 | PyTracebackObject *exception_keeper_tb_5; | ||
| 521 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_5; | ||
| 522 | |||
| 523 | // Module code. | ||
| 524 | { | ||
| 525 | PyObject *tmp_assign_source_1; | ||
| 526 | tmp_assign_source_1 = const_str_digest_d28ba98cdd0dea211f5951fcb5d3e7b2; | ||
| 527 | UPDATE_STRING_DICT0( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 528 | } | ||
| 529 | { | ||
| 530 | PyObject *tmp_assign_source_2; | ||
| 531 | tmp_assign_source_2 = module_filename_obj; | ||
| 532 | UPDATE_STRING_DICT0( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 533 | } | ||
| 534 | // Frame without reuse. | ||
| 535 | frame_d676880cece0dacbdc685c3346c3b838 = MAKE_MODULE_FRAME( codeobj_d676880cece0dacbdc685c3346c3b838, module_dbus ); | ||
| 536 | |||
| 537 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 538 | // owning it. | ||
| 539 | pushFrameStack( frame_d676880cece0dacbdc685c3346c3b838 ); | ||
| 540 | assert( Py_REFCNT( frame_d676880cece0dacbdc685c3346c3b838 ) == 2 ); | ||
| 541 | |||
| 542 | // Framed code: | ||
| 543 | { | ||
| 544 | PyObject *tmp_assign_source_3; | ||
| 545 | PyObject *tmp_list_element_1; | ||
| 546 | PyObject *tmp_called_name_1; | ||
| 547 | PyObject *tmp_source_name_1; | ||
| 548 | PyObject *tmp_args_element_name_1; | ||
| 549 | PyObject *tmp_called_instance_1; | ||
| 550 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 1; | ||
| 551 | { | ||
| 552 | PyObject *module = PyImport_ImportModule("os"); | ||
| 553 | if (likely( module != NULL )) | ||
| 554 | { | ||
| 555 | tmp_source_name_1 = PyObject_GetAttr( module, const_str_plain_path ); | ||
| 556 | } | ||
| 557 | else | ||
| 558 | { | ||
| 559 | tmp_source_name_1 = NULL; | ||
| 560 | } | ||
| 561 | } | ||
| 562 | |||
| 563 | if ( tmp_source_name_1 == NULL ) | ||
| 564 | { | ||
| 565 | assert( ERROR_OCCURRED() ); | ||
| 566 | |||
| 567 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 568 | |||
| 569 | |||
| 570 | exception_lineno = 1; | ||
| 571 | |||
| 572 | goto frame_exception_exit_1; | ||
| 573 | } | ||
| 574 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_dirname ); | ||
| 575 | if ( tmp_called_name_1 == NULL ) | ||
| 576 | { | ||
| 577 | assert( ERROR_OCCURRED() ); | ||
| 578 | |||
| 579 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 580 | |||
| 581 | |||
| 582 | exception_lineno = 1; | ||
| 583 | |||
| 584 | goto frame_exception_exit_1; | ||
| 585 | } | ||
| 586 | tmp_args_element_name_1 = module_filename_obj; | ||
| 587 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 1; | ||
| 588 | { | ||
| 589 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 590 | tmp_list_element_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, call_args ); | ||
| 591 | } | ||
| 592 | |||
| 593 | Py_DECREF( tmp_called_name_1 ); | ||
| 594 | if ( tmp_list_element_1 == NULL ) | ||
| 595 | { | ||
| 596 | assert( ERROR_OCCURRED() ); | ||
| 597 | |||
| 598 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 599 | |||
| 600 | |||
| 601 | exception_lineno = 1; | ||
| 602 | |||
| 603 | goto frame_exception_exit_1; | ||
| 604 | } | ||
| 605 | tmp_assign_source_3 = PyList_New( 2 ); | ||
| 606 | PyList_SET_ITEM( tmp_assign_source_3, 0, tmp_list_element_1 ); | ||
| 607 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 1; | ||
| 608 | { | ||
| 609 | PyObject *module = PyImport_ImportModule("os"); | ||
| 610 | if (likely( module != NULL )) | ||
| 611 | { | ||
| 612 | tmp_called_instance_1 = PyObject_GetAttr( module, const_str_plain_environ ); | ||
| 613 | } | ||
| 614 | else | ||
| 615 | { | ||
| 616 | tmp_called_instance_1 = NULL; | ||
| 617 | } | ||
| 618 | } | ||
| 619 | |||
| 620 | if ( tmp_called_instance_1 == NULL ) | ||
| 621 | { | ||
| 622 | assert( ERROR_OCCURRED() ); | ||
| 623 | |||
| 624 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 625 | Py_DECREF( tmp_assign_source_3 ); | ||
| 626 | |||
| 627 | exception_lineno = 1; | ||
| 628 | |||
| 629 | goto frame_exception_exit_1; | ||
| 630 | } | ||
| 631 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 1; | ||
| 632 | tmp_list_element_1 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_1, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_c05661dc311559e0338d3f9170078d6a_tuple, 0 ) ); | ||
| 633 | |||
| 634 | if ( tmp_list_element_1 == NULL ) | ||
| 635 | { | ||
| 636 | assert( ERROR_OCCURRED() ); | ||
| 637 | |||
| 638 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 639 | Py_DECREF( tmp_assign_source_3 ); | ||
| 640 | |||
| 641 | exception_lineno = 1; | ||
| 642 | |||
| 643 | goto frame_exception_exit_1; | ||
| 644 | } | ||
| 645 | PyList_SET_ITEM( tmp_assign_source_3, 1, tmp_list_element_1 ); | ||
| 646 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); | ||
| 647 | } | ||
| 648 | { | ||
| 649 | PyObject *tmp_assattr_name_1; | ||
| 650 | PyObject *tmp_assattr_target_1; | ||
| 651 | PyObject *tmp_mvar_value_1; | ||
| 652 | tmp_assattr_name_1 = module_filename_obj; | ||
| 653 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 654 | |||
| 655 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 656 | { | ||
| 657 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 658 | } | ||
| 659 | |||
| 660 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 661 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 662 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 663 | if ( tmp_result == false ) | ||
| 664 | { | ||
| 665 | assert( ERROR_OCCURRED() ); | ||
| 666 | |||
| 667 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 668 | |||
| 669 | |||
| 670 | exception_lineno = 1; | ||
| 671 | |||
| 672 | goto frame_exception_exit_1; | ||
| 673 | } | ||
| 674 | } | ||
| 675 | { | ||
| 676 | PyObject *tmp_assattr_name_2; | ||
| 677 | PyObject *tmp_assattr_target_2; | ||
| 678 | PyObject *tmp_mvar_value_2; | ||
| 679 | tmp_assattr_name_2 = Py_True; | ||
| 680 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 681 | |||
| 682 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 683 | { | ||
| 684 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 685 | } | ||
| 686 | |||
| 687 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 688 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 689 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 690 | if ( tmp_result == false ) | ||
| 691 | { | ||
| 692 | assert( ERROR_OCCURRED() ); | ||
| 693 | |||
| 694 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 695 | |||
| 696 | |||
| 697 | exception_lineno = 1; | ||
| 698 | |||
| 699 | goto frame_exception_exit_1; | ||
| 700 | } | ||
| 701 | } | ||
| 702 | { | ||
| 703 | PyObject *tmp_assign_source_4; | ||
| 704 | tmp_assign_source_4 = Py_None; | ||
| 705 | UPDATE_STRING_DICT0( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_4 ); | ||
| 706 | } | ||
| 707 | { | ||
| 708 | PyObject *tmp_assign_source_5; | ||
| 709 | tmp_assign_source_5 = LIST_COPY( const_list_c00e43f6c89f1bff4b3c8c15fedd441c_list ); | ||
| 710 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___all__, tmp_assign_source_5 ); | ||
| 711 | } | ||
| 712 | { | ||
| 713 | PyObject *tmp_assign_source_6; | ||
| 714 | PyObject *tmp_import_name_from_1; | ||
| 715 | PyObject *tmp_name_name_1; | ||
| 716 | PyObject *tmp_globals_name_1; | ||
| 717 | PyObject *tmp_locals_name_1; | ||
| 718 | PyObject *tmp_fromlist_name_1; | ||
| 719 | PyObject *tmp_level_name_1; | ||
| 720 | tmp_name_name_1 = const_str_digest_3aa5bee4de9b0149ae46ffed8a38c6b4; | ||
| 721 | tmp_globals_name_1 = (PyObject *)moduledict_dbus; | ||
| 722 | tmp_locals_name_1 = Py_None; | ||
| 723 | tmp_fromlist_name_1 = const_tuple_str_plain_is_py2_tuple; | ||
| 724 | tmp_level_name_1 = const_int_0; | ||
| 725 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 63; | ||
| 726 | tmp_import_name_from_1 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 727 | if ( tmp_import_name_from_1 == NULL ) | ||
| 728 | { | ||
| 729 | assert( ERROR_OCCURRED() ); | ||
| 730 | |||
| 731 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 732 | |||
| 733 | |||
| 734 | exception_lineno = 63; | ||
| 735 | |||
| 736 | goto frame_exception_exit_1; | ||
| 737 | } | ||
| 738 | tmp_assign_source_6 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_is_py2 ); | ||
| 739 | Py_DECREF( tmp_import_name_from_1 ); | ||
| 740 | if ( tmp_assign_source_6 == NULL ) | ||
| 741 | { | ||
| 742 | assert( ERROR_OCCURRED() ); | ||
| 743 | |||
| 744 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 745 | |||
| 746 | |||
| 747 | exception_lineno = 63; | ||
| 748 | |||
| 749 | goto frame_exception_exit_1; | ||
| 750 | } | ||
| 751 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_is_py2, tmp_assign_source_6 ); | ||
| 752 | } | ||
| 753 | { | ||
| 754 | nuitka_bool tmp_condition_result_1; | ||
| 755 | PyObject *tmp_mvar_value_3; | ||
| 756 | int tmp_truth_name_1; | ||
| 757 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_is_py2 ); | ||
| 758 | |||
| 759 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 760 | { | ||
| 761 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_is_py2 ); | ||
| 762 | } | ||
| 763 | |||
| 764 | CHECK_OBJECT( tmp_mvar_value_3 ); | ||
| 765 | tmp_truth_name_1 = CHECK_IF_TRUE( tmp_mvar_value_3 ); | ||
| 766 | if ( tmp_truth_name_1 == -1 ) | ||
| 767 | { | ||
| 768 | assert( ERROR_OCCURRED() ); | ||
| 769 | |||
| 770 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 771 | |||
| 772 | |||
| 773 | exception_lineno = 64; | ||
| 774 | |||
| 775 | goto frame_exception_exit_1; | ||
| 776 | } | ||
| 777 | tmp_condition_result_1 = tmp_truth_name_1 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 778 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 779 | { | ||
| 780 | goto branch_yes_1; | ||
| 781 | } | ||
| 782 | else | ||
| 783 | { | ||
| 784 | goto branch_no_1; | ||
| 785 | } | ||
| 786 | branch_yes_1:; | ||
| 787 | { | ||
| 788 | PyObject *tmp_called_instance_2; | ||
| 789 | PyObject *tmp_mvar_value_4; | ||
| 790 | PyObject *tmp_call_result_1; | ||
| 791 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___all__ ); | ||
| 792 | |||
| 793 | if (unlikely( tmp_mvar_value_4 == NULL )) | ||
| 794 | { | ||
| 795 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___all__ ); | ||
| 796 | } | ||
| 797 | |||
| 798 | if ( tmp_mvar_value_4 == NULL ) | ||
| 799 | { | ||
| 800 | |||
| 801 | exception_type = PyExc_NameError; | ||
| 802 | Py_INCREF( exception_type ); | ||
| 803 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "__all__" ); | ||
| 804 | exception_tb = NULL; | ||
| 805 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 806 | CHAIN_EXCEPTION( exception_value ); | ||
| 807 | |||
| 808 | exception_lineno = 65; | ||
| 809 | |||
| 810 | goto frame_exception_exit_1; | ||
| 811 | } | ||
| 812 | |||
| 813 | tmp_called_instance_2 = tmp_mvar_value_4; | ||
| 814 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 65; | ||
| 815 | tmp_call_result_1 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_2, const_str_plain_append, &PyTuple_GET_ITEM( const_tuple_str_plain_UTF8String_tuple, 0 ) ); | ||
| 816 | |||
| 817 | if ( tmp_call_result_1 == NULL ) | ||
| 818 | { | ||
| 819 | assert( ERROR_OCCURRED() ); | ||
| 820 | |||
| 821 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 822 | |||
| 823 | |||
| 824 | exception_lineno = 65; | ||
| 825 | |||
| 826 | goto frame_exception_exit_1; | ||
| 827 | } | ||
| 828 | Py_DECREF( tmp_call_result_1 ); | ||
| 829 | } | ||
| 830 | branch_no_1:; | ||
| 831 | } | ||
| 832 | { | ||
| 833 | PyObject *tmp_assign_source_7; | ||
| 834 | tmp_assign_source_7 = const_str_plain_restructuredtext; | ||
| 835 | UPDATE_STRING_DICT0( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___docformat__, tmp_assign_source_7 ); | ||
| 836 | } | ||
| 837 | { | ||
| 838 | PyObject *tmp_assign_source_8; | ||
| 839 | PyObject *tmp_import_name_from_2; | ||
| 840 | PyObject *tmp_name_name_2; | ||
| 841 | PyObject *tmp_globals_name_2; | ||
| 842 | PyObject *tmp_locals_name_2; | ||
| 843 | PyObject *tmp_fromlist_name_2; | ||
| 844 | PyObject *tmp_level_name_2; | ||
| 845 | tmp_name_name_2 = const_str_digest_e48610c30fffad33f2054d9dca0792b3; | ||
| 846 | tmp_globals_name_2 = (PyObject *)moduledict_dbus; | ||
| 847 | tmp_locals_name_2 = Py_None; | ||
| 848 | tmp_fromlist_name_2 = Py_None; | ||
| 849 | tmp_level_name_2 = const_int_0; | ||
| 850 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 70; | ||
| 851 | tmp_import_name_from_2 = IMPORT_MODULE5( tmp_name_name_2, tmp_globals_name_2, tmp_locals_name_2, tmp_fromlist_name_2, tmp_level_name_2 ); | ||
| 852 | if ( tmp_import_name_from_2 == NULL ) | ||
| 853 | { | ||
| 854 | assert( ERROR_OCCURRED() ); | ||
| 855 | |||
| 856 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 857 | |||
| 858 | |||
| 859 | exception_lineno = 70; | ||
| 860 | |||
| 861 | goto frame_exception_exit_1; | ||
| 862 | } | ||
| 863 | tmp_assign_source_8 = IMPORT_NAME( tmp_import_name_from_2, const_str_plain_exceptions ); | ||
| 864 | Py_DECREF( tmp_import_name_from_2 ); | ||
| 865 | if ( tmp_assign_source_8 == NULL ) | ||
| 866 | { | ||
| 867 | assert( ERROR_OCCURRED() ); | ||
| 868 | |||
| 869 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 870 | |||
| 871 | |||
| 872 | exception_lineno = 70; | ||
| 873 | |||
| 874 | goto frame_exception_exit_1; | ||
| 875 | } | ||
| 876 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_exceptions, tmp_assign_source_8 ); | ||
| 877 | } | ||
| 878 | { | ||
| 879 | PyObject *tmp_assign_source_9; | ||
| 880 | PyObject *tmp_import_name_from_3; | ||
| 881 | PyObject *tmp_name_name_3; | ||
| 882 | PyObject *tmp_globals_name_3; | ||
| 883 | PyObject *tmp_locals_name_3; | ||
| 884 | PyObject *tmp_fromlist_name_3; | ||
| 885 | PyObject *tmp_level_name_3; | ||
| 886 | tmp_name_name_3 = const_str_digest_1abd3647207b34d013514bc0c6956d0b; | ||
| 887 | tmp_globals_name_3 = (PyObject *)moduledict_dbus; | ||
| 888 | tmp_locals_name_3 = Py_None; | ||
| 889 | tmp_fromlist_name_3 = Py_None; | ||
| 890 | tmp_level_name_3 = const_int_0; | ||
| 891 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 71; | ||
| 892 | tmp_import_name_from_3 = IMPORT_MODULE5( tmp_name_name_3, tmp_globals_name_3, tmp_locals_name_3, tmp_fromlist_name_3, tmp_level_name_3 ); | ||
| 893 | if ( tmp_import_name_from_3 == NULL ) | ||
| 894 | { | ||
| 895 | assert( ERROR_OCCURRED() ); | ||
| 896 | |||
| 897 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 898 | |||
| 899 | |||
| 900 | exception_lineno = 71; | ||
| 901 | |||
| 902 | goto frame_exception_exit_1; | ||
| 903 | } | ||
| 904 | tmp_assign_source_9 = IMPORT_NAME( tmp_import_name_from_3, const_str_plain_types ); | ||
| 905 | Py_DECREF( tmp_import_name_from_3 ); | ||
| 906 | if ( tmp_assign_source_9 == NULL ) | ||
| 907 | { | ||
| 908 | assert( ERROR_OCCURRED() ); | ||
| 909 | |||
| 910 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 911 | |||
| 912 | |||
| 913 | exception_lineno = 71; | ||
| 914 | |||
| 915 | goto frame_exception_exit_1; | ||
| 916 | } | ||
| 917 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_types, tmp_assign_source_9 ); | ||
| 918 | } | ||
| 919 | { | ||
| 920 | PyObject *tmp_assign_source_10; | ||
| 921 | PyObject *tmp_import_name_from_4; | ||
| 922 | PyObject *tmp_name_name_4; | ||
| 923 | PyObject *tmp_globals_name_4; | ||
| 924 | PyObject *tmp_locals_name_4; | ||
| 925 | PyObject *tmp_fromlist_name_4; | ||
| 926 | PyObject *tmp_level_name_4; | ||
| 927 | tmp_name_name_4 = const_str_plain__dbus_bindings; | ||
| 928 | tmp_globals_name_4 = (PyObject *)moduledict_dbus; | ||
| 929 | tmp_locals_name_4 = Py_None; | ||
| 930 | tmp_fromlist_name_4 = const_tuple_str_plain___version___tuple; | ||
| 931 | tmp_level_name_4 = const_int_0; | ||
| 932 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 73; | ||
| 933 | tmp_import_name_from_4 = IMPORT_MODULE5( tmp_name_name_4, tmp_globals_name_4, tmp_locals_name_4, tmp_fromlist_name_4, tmp_level_name_4 ); | ||
| 934 | if ( tmp_import_name_from_4 == NULL ) | ||
| 935 | { | ||
| 936 | assert( ERROR_OCCURRED() ); | ||
| 937 | |||
| 938 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 939 | |||
| 940 | |||
| 941 | exception_lineno = 73; | ||
| 942 | |||
| 943 | goto frame_exception_exit_1; | ||
| 944 | } | ||
| 945 | tmp_assign_source_10 = IMPORT_NAME( tmp_import_name_from_4, const_str_plain___version__ ); | ||
| 946 | Py_DECREF( tmp_import_name_from_4 ); | ||
| 947 | if ( tmp_assign_source_10 == NULL ) | ||
| 948 | { | ||
| 949 | assert( ERROR_OCCURRED() ); | ||
| 950 | |||
| 951 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 952 | |||
| 953 | |||
| 954 | exception_lineno = 73; | ||
| 955 | |||
| 956 | goto frame_exception_exit_1; | ||
| 957 | } | ||
| 958 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___version__, tmp_assign_source_10 ); | ||
| 959 | } | ||
| 960 | { | ||
| 961 | PyObject *tmp_assign_source_11; | ||
| 962 | PyObject *tmp_tuple_arg_1; | ||
| 963 | PyObject *tmp_called_name_2; | ||
| 964 | PyObject *tmp_args_element_name_2; | ||
| 965 | PyObject *tmp_args_element_name_3; | ||
| 966 | PyObject *tmp_called_instance_3; | ||
| 967 | PyObject *tmp_mvar_value_5; | ||
| 968 | tmp_called_name_2 = (PyObject *)&PyMap_Type; | ||
| 969 | tmp_args_element_name_2 = (PyObject *)&PyLong_Type; | ||
| 970 | tmp_mvar_value_5 = GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___version__ ); | ||
| 971 | |||
| 972 | if (unlikely( tmp_mvar_value_5 == NULL )) | ||
| 973 | { | ||
| 974 | tmp_mvar_value_5 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___version__ ); | ||
| 975 | } | ||
| 976 | |||
| 977 | CHECK_OBJECT( tmp_mvar_value_5 ); | ||
| 978 | tmp_called_instance_3 = tmp_mvar_value_5; | ||
| 979 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 74; | ||
| 980 | tmp_args_element_name_3 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_3, const_str_plain_split, &PyTuple_GET_ITEM( const_tuple_str_dot_tuple, 0 ) ); | ||
| 981 | |||
| 982 | if ( tmp_args_element_name_3 == NULL ) | ||
| 983 | { | ||
| 984 | assert( ERROR_OCCURRED() ); | ||
| 985 | |||
| 986 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 987 | |||
| 988 | |||
| 989 | exception_lineno = 74; | ||
| 990 | |||
| 991 | goto frame_exception_exit_1; | ||
| 992 | } | ||
| 993 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 74; | ||
| 994 | { | ||
| 995 | PyObject *call_args[] = { tmp_args_element_name_2, tmp_args_element_name_3 }; | ||
| 996 | tmp_tuple_arg_1 = CALL_FUNCTION_WITH_ARGS2( tmp_called_name_2, call_args ); | ||
| 997 | } | ||
| 998 | |||
| 999 | Py_DECREF( tmp_args_element_name_3 ); | ||
| 1000 | if ( tmp_tuple_arg_1 == NULL ) | ||
| 1001 | { | ||
| 1002 | assert( ERROR_OCCURRED() ); | ||
| 1003 | |||
| 1004 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1005 | |||
| 1006 | |||
| 1007 | exception_lineno = 74; | ||
| 1008 | |||
| 1009 | goto frame_exception_exit_1; | ||
| 1010 | } | ||
| 1011 | tmp_assign_source_11 = PySequence_Tuple( tmp_tuple_arg_1 ); | ||
| 1012 | Py_DECREF( tmp_tuple_arg_1 ); | ||
| 1013 | if ( tmp_assign_source_11 == NULL ) | ||
| 1014 | { | ||
| 1015 | assert( ERROR_OCCURRED() ); | ||
| 1016 | |||
| 1017 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1018 | |||
| 1019 | |||
| 1020 | exception_lineno = 74; | ||
| 1021 | |||
| 1022 | goto frame_exception_exit_1; | ||
| 1023 | } | ||
| 1024 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_version, tmp_assign_source_11 ); | ||
| 1025 | } | ||
| 1026 | { | ||
| 1027 | PyObject *tmp_assign_source_12; | ||
| 1028 | PyObject *tmp_name_name_5; | ||
| 1029 | PyObject *tmp_globals_name_5; | ||
| 1030 | PyObject *tmp_locals_name_5; | ||
| 1031 | PyObject *tmp_fromlist_name_5; | ||
| 1032 | PyObject *tmp_level_name_5; | ||
| 1033 | tmp_name_name_5 = const_str_plain__dbus_bindings; | ||
| 1034 | tmp_globals_name_5 = (PyObject *)moduledict_dbus; | ||
| 1035 | tmp_locals_name_5 = Py_None; | ||
| 1036 | tmp_fromlist_name_5 = const_tuple_2c9d1c6863fdd586bfca32d97434ea23_tuple; | ||
| 1037 | tmp_level_name_5 = const_int_0; | ||
| 1038 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 76; | ||
| 1039 | tmp_assign_source_12 = IMPORT_MODULE5( tmp_name_name_5, tmp_globals_name_5, tmp_locals_name_5, tmp_fromlist_name_5, tmp_level_name_5 ); | ||
| 1040 | if ( tmp_assign_source_12 == NULL ) | ||
| 1041 | { | ||
| 1042 | assert( ERROR_OCCURRED() ); | ||
| 1043 | |||
| 1044 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1045 | |||
| 1046 | |||
| 1047 | exception_lineno = 76; | ||
| 1048 | |||
| 1049 | goto frame_exception_exit_1; | ||
| 1050 | } | ||
| 1051 | assert( tmp_import_from_1__module == NULL ); | ||
| 1052 | tmp_import_from_1__module = tmp_assign_source_12; | ||
| 1053 | } | ||
| 1054 | // Tried code: | ||
| 1055 | { | ||
| 1056 | PyObject *tmp_assign_source_13; | ||
| 1057 | PyObject *tmp_import_name_from_5; | ||
| 1058 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 1059 | tmp_import_name_from_5 = tmp_import_from_1__module; | ||
| 1060 | tmp_assign_source_13 = IMPORT_NAME( tmp_import_name_from_5, const_str_plain_get_default_main_loop ); | ||
| 1061 | if ( tmp_assign_source_13 == NULL ) | ||
| 1062 | { | ||
| 1063 | assert( ERROR_OCCURRED() ); | ||
| 1064 | |||
| 1065 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1066 | |||
| 1067 | |||
| 1068 | exception_lineno = 76; | ||
| 1069 | |||
| 1070 | goto try_except_handler_1; | ||
| 1071 | } | ||
| 1072 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_get_default_main_loop, tmp_assign_source_13 ); | ||
| 1073 | } | ||
| 1074 | { | ||
| 1075 | PyObject *tmp_assign_source_14; | ||
| 1076 | PyObject *tmp_import_name_from_6; | ||
| 1077 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 1078 | tmp_import_name_from_6 = tmp_import_from_1__module; | ||
| 1079 | tmp_assign_source_14 = IMPORT_NAME( tmp_import_name_from_6, const_str_plain_set_default_main_loop ); | ||
| 1080 | if ( tmp_assign_source_14 == NULL ) | ||
| 1081 | { | ||
| 1082 | assert( ERROR_OCCURRED() ); | ||
| 1083 | |||
| 1084 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1085 | |||
| 1086 | |||
| 1087 | exception_lineno = 76; | ||
| 1088 | |||
| 1089 | goto try_except_handler_1; | ||
| 1090 | } | ||
| 1091 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_set_default_main_loop, tmp_assign_source_14 ); | ||
| 1092 | } | ||
| 1093 | { | ||
| 1094 | PyObject *tmp_assign_source_15; | ||
| 1095 | PyObject *tmp_import_name_from_7; | ||
| 1096 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 1097 | tmp_import_name_from_7 = tmp_import_from_1__module; | ||
| 1098 | tmp_assign_source_15 = IMPORT_NAME( tmp_import_name_from_7, const_str_plain_validate_bus_name ); | ||
| 1099 | if ( tmp_assign_source_15 == NULL ) | ||
| 1100 | { | ||
| 1101 | assert( ERROR_OCCURRED() ); | ||
| 1102 | |||
| 1103 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1104 | |||
| 1105 | |||
| 1106 | exception_lineno = 76; | ||
| 1107 | |||
| 1108 | goto try_except_handler_1; | ||
| 1109 | } | ||
| 1110 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_validate_bus_name, tmp_assign_source_15 ); | ||
| 1111 | } | ||
| 1112 | { | ||
| 1113 | PyObject *tmp_assign_source_16; | ||
| 1114 | PyObject *tmp_import_name_from_8; | ||
| 1115 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 1116 | tmp_import_name_from_8 = tmp_import_from_1__module; | ||
| 1117 | tmp_assign_source_16 = IMPORT_NAME( tmp_import_name_from_8, const_str_plain_validate_error_name ); | ||
| 1118 | if ( tmp_assign_source_16 == NULL ) | ||
| 1119 | { | ||
| 1120 | assert( ERROR_OCCURRED() ); | ||
| 1121 | |||
| 1122 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1123 | |||
| 1124 | |||
| 1125 | exception_lineno = 76; | ||
| 1126 | |||
| 1127 | goto try_except_handler_1; | ||
| 1128 | } | ||
| 1129 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_validate_error_name, tmp_assign_source_16 ); | ||
| 1130 | } | ||
| 1131 | { | ||
| 1132 | PyObject *tmp_assign_source_17; | ||
| 1133 | PyObject *tmp_import_name_from_9; | ||
| 1134 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 1135 | tmp_import_name_from_9 = tmp_import_from_1__module; | ||
| 1136 | tmp_assign_source_17 = IMPORT_NAME( tmp_import_name_from_9, const_str_plain_validate_interface_name ); | ||
| 1137 | if ( tmp_assign_source_17 == NULL ) | ||
| 1138 | { | ||
| 1139 | assert( ERROR_OCCURRED() ); | ||
| 1140 | |||
| 1141 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1142 | |||
| 1143 | |||
| 1144 | exception_lineno = 76; | ||
| 1145 | |||
| 1146 | goto try_except_handler_1; | ||
| 1147 | } | ||
| 1148 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_validate_interface_name, tmp_assign_source_17 ); | ||
| 1149 | } | ||
| 1150 | { | ||
| 1151 | PyObject *tmp_assign_source_18; | ||
| 1152 | PyObject *tmp_import_name_from_10; | ||
| 1153 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 1154 | tmp_import_name_from_10 = tmp_import_from_1__module; | ||
| 1155 | tmp_assign_source_18 = IMPORT_NAME( tmp_import_name_from_10, const_str_plain_validate_member_name ); | ||
| 1156 | if ( tmp_assign_source_18 == NULL ) | ||
| 1157 | { | ||
| 1158 | assert( ERROR_OCCURRED() ); | ||
| 1159 | |||
| 1160 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1161 | |||
| 1162 | |||
| 1163 | exception_lineno = 76; | ||
| 1164 | |||
| 1165 | goto try_except_handler_1; | ||
| 1166 | } | ||
| 1167 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_validate_member_name, tmp_assign_source_18 ); | ||
| 1168 | } | ||
| 1169 | { | ||
| 1170 | PyObject *tmp_assign_source_19; | ||
| 1171 | PyObject *tmp_import_name_from_11; | ||
| 1172 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 1173 | tmp_import_name_from_11 = tmp_import_from_1__module; | ||
| 1174 | tmp_assign_source_19 = IMPORT_NAME( tmp_import_name_from_11, const_str_plain_validate_object_path ); | ||
| 1175 | if ( tmp_assign_source_19 == NULL ) | ||
| 1176 | { | ||
| 1177 | assert( ERROR_OCCURRED() ); | ||
| 1178 | |||
| 1179 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1180 | |||
| 1181 | |||
| 1182 | exception_lineno = 76; | ||
| 1183 | |||
| 1184 | goto try_except_handler_1; | ||
| 1185 | } | ||
| 1186 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_validate_object_path, tmp_assign_source_19 ); | ||
| 1187 | } | ||
| 1188 | goto try_end_1; | ||
| 1189 | // Exception handler code: | ||
| 1190 | try_except_handler_1:; | ||
| 1191 | exception_keeper_type_1 = exception_type; | ||
| 1192 | exception_keeper_value_1 = exception_value; | ||
| 1193 | exception_keeper_tb_1 = exception_tb; | ||
| 1194 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1195 | exception_type = NULL; | ||
| 1196 | exception_value = NULL; | ||
| 1197 | exception_tb = NULL; | ||
| 1198 | exception_lineno = 0; | ||
| 1199 | |||
| 1200 | CHECK_OBJECT( (PyObject *)tmp_import_from_1__module ); | ||
| 1201 | Py_DECREF( tmp_import_from_1__module ); | ||
| 1202 | tmp_import_from_1__module = NULL; | ||
| 1203 | |||
| 1204 | // Re-raise. | ||
| 1205 | exception_type = exception_keeper_type_1; | ||
| 1206 | exception_value = exception_keeper_value_1; | ||
| 1207 | exception_tb = exception_keeper_tb_1; | ||
| 1208 | exception_lineno = exception_keeper_lineno_1; | ||
| 1209 | |||
| 1210 | goto frame_exception_exit_1; | ||
| 1211 | // End of try: | ||
| 1212 | try_end_1:; | ||
| 1213 | CHECK_OBJECT( (PyObject *)tmp_import_from_1__module ); | ||
| 1214 | Py_DECREF( tmp_import_from_1__module ); | ||
| 1215 | tmp_import_from_1__module = NULL; | ||
| 1216 | |||
| 1217 | { | ||
| 1218 | PyObject *tmp_assign_source_20; | ||
| 1219 | PyObject *tmp_name_name_6; | ||
| 1220 | PyObject *tmp_globals_name_6; | ||
| 1221 | PyObject *tmp_locals_name_6; | ||
| 1222 | PyObject *tmp_fromlist_name_6; | ||
| 1223 | PyObject *tmp_level_name_6; | ||
| 1224 | tmp_name_name_6 = const_str_plain__dbus_bindings; | ||
| 1225 | tmp_globals_name_6 = (PyObject *)moduledict_dbus; | ||
| 1226 | tmp_locals_name_6 = Py_None; | ||
| 1227 | tmp_fromlist_name_6 = const_tuple_a42d09975d91c391fbb7668332a8328b_tuple; | ||
| 1228 | tmp_level_name_6 = const_int_0; | ||
| 1229 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 80; | ||
| 1230 | tmp_assign_source_20 = IMPORT_MODULE5( tmp_name_name_6, tmp_globals_name_6, tmp_locals_name_6, tmp_fromlist_name_6, tmp_level_name_6 ); | ||
| 1231 | if ( tmp_assign_source_20 == NULL ) | ||
| 1232 | { | ||
| 1233 | assert( ERROR_OCCURRED() ); | ||
| 1234 | |||
| 1235 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1236 | |||
| 1237 | |||
| 1238 | exception_lineno = 80; | ||
| 1239 | |||
| 1240 | goto frame_exception_exit_1; | ||
| 1241 | } | ||
| 1242 | assert( tmp_import_from_2__module == NULL ); | ||
| 1243 | tmp_import_from_2__module = tmp_assign_source_20; | ||
| 1244 | } | ||
| 1245 | // Tried code: | ||
| 1246 | { | ||
| 1247 | PyObject *tmp_assign_source_21; | ||
| 1248 | PyObject *tmp_import_name_from_12; | ||
| 1249 | CHECK_OBJECT( tmp_import_from_2__module ); | ||
| 1250 | tmp_import_name_from_12 = tmp_import_from_2__module; | ||
| 1251 | tmp_assign_source_21 = IMPORT_NAME( tmp_import_name_from_12, const_str_plain_BUS_DAEMON_IFACE ); | ||
| 1252 | if ( tmp_assign_source_21 == NULL ) | ||
| 1253 | { | ||
| 1254 | assert( ERROR_OCCURRED() ); | ||
| 1255 | |||
| 1256 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1257 | |||
| 1258 | |||
| 1259 | exception_lineno = 80; | ||
| 1260 | |||
| 1261 | goto try_except_handler_2; | ||
| 1262 | } | ||
| 1263 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_BUS_DAEMON_IFACE, tmp_assign_source_21 ); | ||
| 1264 | } | ||
| 1265 | { | ||
| 1266 | PyObject *tmp_assign_source_22; | ||
| 1267 | PyObject *tmp_import_name_from_13; | ||
| 1268 | CHECK_OBJECT( tmp_import_from_2__module ); | ||
| 1269 | tmp_import_name_from_13 = tmp_import_from_2__module; | ||
| 1270 | tmp_assign_source_22 = IMPORT_NAME( tmp_import_name_from_13, const_str_plain_BUS_DAEMON_NAME ); | ||
| 1271 | if ( tmp_assign_source_22 == NULL ) | ||
| 1272 | { | ||
| 1273 | assert( ERROR_OCCURRED() ); | ||
| 1274 | |||
| 1275 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1276 | |||
| 1277 | |||
| 1278 | exception_lineno = 80; | ||
| 1279 | |||
| 1280 | goto try_except_handler_2; | ||
| 1281 | } | ||
| 1282 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_BUS_DAEMON_NAME, tmp_assign_source_22 ); | ||
| 1283 | } | ||
| 1284 | { | ||
| 1285 | PyObject *tmp_assign_source_23; | ||
| 1286 | PyObject *tmp_import_name_from_14; | ||
| 1287 | CHECK_OBJECT( tmp_import_from_2__module ); | ||
| 1288 | tmp_import_name_from_14 = tmp_import_from_2__module; | ||
| 1289 | tmp_assign_source_23 = IMPORT_NAME( tmp_import_name_from_14, const_str_plain_BUS_DAEMON_PATH ); | ||
| 1290 | if ( tmp_assign_source_23 == NULL ) | ||
| 1291 | { | ||
| 1292 | assert( ERROR_OCCURRED() ); | ||
| 1293 | |||
| 1294 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1295 | |||
| 1296 | |||
| 1297 | exception_lineno = 80; | ||
| 1298 | |||
| 1299 | goto try_except_handler_2; | ||
| 1300 | } | ||
| 1301 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_BUS_DAEMON_PATH, tmp_assign_source_23 ); | ||
| 1302 | } | ||
| 1303 | { | ||
| 1304 | PyObject *tmp_assign_source_24; | ||
| 1305 | PyObject *tmp_import_name_from_15; | ||
| 1306 | CHECK_OBJECT( tmp_import_from_2__module ); | ||
| 1307 | tmp_import_name_from_15 = tmp_import_from_2__module; | ||
| 1308 | tmp_assign_source_24 = IMPORT_NAME( tmp_import_name_from_15, const_str_plain_INTROSPECTABLE_IFACE ); | ||
| 1309 | if ( tmp_assign_source_24 == NULL ) | ||
| 1310 | { | ||
| 1311 | assert( ERROR_OCCURRED() ); | ||
| 1312 | |||
| 1313 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1314 | |||
| 1315 | |||
| 1316 | exception_lineno = 80; | ||
| 1317 | |||
| 1318 | goto try_except_handler_2; | ||
| 1319 | } | ||
| 1320 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_INTROSPECTABLE_IFACE, tmp_assign_source_24 ); | ||
| 1321 | } | ||
| 1322 | { | ||
| 1323 | PyObject *tmp_assign_source_25; | ||
| 1324 | PyObject *tmp_import_name_from_16; | ||
| 1325 | CHECK_OBJECT( tmp_import_from_2__module ); | ||
| 1326 | tmp_import_name_from_16 = tmp_import_from_2__module; | ||
| 1327 | tmp_assign_source_25 = IMPORT_NAME( tmp_import_name_from_16, const_str_plain_LOCAL_IFACE ); | ||
| 1328 | if ( tmp_assign_source_25 == NULL ) | ||
| 1329 | { | ||
| 1330 | assert( ERROR_OCCURRED() ); | ||
| 1331 | |||
| 1332 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1333 | |||
| 1334 | |||
| 1335 | exception_lineno = 80; | ||
| 1336 | |||
| 1337 | goto try_except_handler_2; | ||
| 1338 | } | ||
| 1339 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_LOCAL_IFACE, tmp_assign_source_25 ); | ||
| 1340 | } | ||
| 1341 | { | ||
| 1342 | PyObject *tmp_assign_source_26; | ||
| 1343 | PyObject *tmp_import_name_from_17; | ||
| 1344 | CHECK_OBJECT( tmp_import_from_2__module ); | ||
| 1345 | tmp_import_name_from_17 = tmp_import_from_2__module; | ||
| 1346 | tmp_assign_source_26 = IMPORT_NAME( tmp_import_name_from_17, const_str_plain_LOCAL_PATH ); | ||
| 1347 | if ( tmp_assign_source_26 == NULL ) | ||
| 1348 | { | ||
| 1349 | assert( ERROR_OCCURRED() ); | ||
| 1350 | |||
| 1351 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1352 | |||
| 1353 | |||
| 1354 | exception_lineno = 80; | ||
| 1355 | |||
| 1356 | goto try_except_handler_2; | ||
| 1357 | } | ||
| 1358 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_LOCAL_PATH, tmp_assign_source_26 ); | ||
| 1359 | } | ||
| 1360 | { | ||
| 1361 | PyObject *tmp_assign_source_27; | ||
| 1362 | PyObject *tmp_import_name_from_18; | ||
| 1363 | CHECK_OBJECT( tmp_import_from_2__module ); | ||
| 1364 | tmp_import_name_from_18 = tmp_import_from_2__module; | ||
| 1365 | tmp_assign_source_27 = IMPORT_NAME( tmp_import_name_from_18, const_str_plain_PEER_IFACE ); | ||
| 1366 | if ( tmp_assign_source_27 == NULL ) | ||
| 1367 | { | ||
| 1368 | assert( ERROR_OCCURRED() ); | ||
| 1369 | |||
| 1370 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1371 | |||
| 1372 | |||
| 1373 | exception_lineno = 80; | ||
| 1374 | |||
| 1375 | goto try_except_handler_2; | ||
| 1376 | } | ||
| 1377 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_PEER_IFACE, tmp_assign_source_27 ); | ||
| 1378 | } | ||
| 1379 | { | ||
| 1380 | PyObject *tmp_assign_source_28; | ||
| 1381 | PyObject *tmp_import_name_from_19; | ||
| 1382 | CHECK_OBJECT( tmp_import_from_2__module ); | ||
| 1383 | tmp_import_name_from_19 = tmp_import_from_2__module; | ||
| 1384 | tmp_assign_source_28 = IMPORT_NAME( tmp_import_name_from_19, const_str_plain_PROPERTIES_IFACE ); | ||
| 1385 | if ( tmp_assign_source_28 == NULL ) | ||
| 1386 | { | ||
| 1387 | assert( ERROR_OCCURRED() ); | ||
| 1388 | |||
| 1389 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1390 | |||
| 1391 | |||
| 1392 | exception_lineno = 80; | ||
| 1393 | |||
| 1394 | goto try_except_handler_2; | ||
| 1395 | } | ||
| 1396 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_PROPERTIES_IFACE, tmp_assign_source_28 ); | ||
| 1397 | } | ||
| 1398 | goto try_end_2; | ||
| 1399 | // Exception handler code: | ||
| 1400 | try_except_handler_2:; | ||
| 1401 | exception_keeper_type_2 = exception_type; | ||
| 1402 | exception_keeper_value_2 = exception_value; | ||
| 1403 | exception_keeper_tb_2 = exception_tb; | ||
| 1404 | exception_keeper_lineno_2 = exception_lineno; | ||
| 1405 | exception_type = NULL; | ||
| 1406 | exception_value = NULL; | ||
| 1407 | exception_tb = NULL; | ||
| 1408 | exception_lineno = 0; | ||
| 1409 | |||
| 1410 | CHECK_OBJECT( (PyObject *)tmp_import_from_2__module ); | ||
| 1411 | Py_DECREF( tmp_import_from_2__module ); | ||
| 1412 | tmp_import_from_2__module = NULL; | ||
| 1413 | |||
| 1414 | // Re-raise. | ||
| 1415 | exception_type = exception_keeper_type_2; | ||
| 1416 | exception_value = exception_keeper_value_2; | ||
| 1417 | exception_tb = exception_keeper_tb_2; | ||
| 1418 | exception_lineno = exception_keeper_lineno_2; | ||
| 1419 | |||
| 1420 | goto frame_exception_exit_1; | ||
| 1421 | // End of try: | ||
| 1422 | try_end_2:; | ||
| 1423 | CHECK_OBJECT( (PyObject *)tmp_import_from_2__module ); | ||
| 1424 | Py_DECREF( tmp_import_from_2__module ); | ||
| 1425 | tmp_import_from_2__module = NULL; | ||
| 1426 | |||
| 1427 | { | ||
| 1428 | PyObject *tmp_assign_source_29; | ||
| 1429 | PyObject *tmp_name_name_7; | ||
| 1430 | PyObject *tmp_globals_name_7; | ||
| 1431 | PyObject *tmp_locals_name_7; | ||
| 1432 | PyObject *tmp_fromlist_name_7; | ||
| 1433 | PyObject *tmp_level_name_7; | ||
| 1434 | tmp_name_name_7 = const_str_digest_e48610c30fffad33f2054d9dca0792b3; | ||
| 1435 | tmp_globals_name_7 = (PyObject *)moduledict_dbus; | ||
| 1436 | tmp_locals_name_7 = Py_None; | ||
| 1437 | tmp_fromlist_name_7 = const_tuple_11fa090efaf7d01dd8418473997afcd0_tuple; | ||
| 1438 | tmp_level_name_7 = const_int_0; | ||
| 1439 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 84; | ||
| 1440 | tmp_assign_source_29 = IMPORT_MODULE5( tmp_name_name_7, tmp_globals_name_7, tmp_locals_name_7, tmp_fromlist_name_7, tmp_level_name_7 ); | ||
| 1441 | if ( tmp_assign_source_29 == NULL ) | ||
| 1442 | { | ||
| 1443 | assert( ERROR_OCCURRED() ); | ||
| 1444 | |||
| 1445 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1446 | |||
| 1447 | |||
| 1448 | exception_lineno = 84; | ||
| 1449 | |||
| 1450 | goto frame_exception_exit_1; | ||
| 1451 | } | ||
| 1452 | assert( tmp_import_from_3__module == NULL ); | ||
| 1453 | tmp_import_from_3__module = tmp_assign_source_29; | ||
| 1454 | } | ||
| 1455 | // Tried code: | ||
| 1456 | { | ||
| 1457 | PyObject *tmp_assign_source_30; | ||
| 1458 | PyObject *tmp_import_name_from_20; | ||
| 1459 | CHECK_OBJECT( tmp_import_from_3__module ); | ||
| 1460 | tmp_import_name_from_20 = tmp_import_from_3__module; | ||
| 1461 | tmp_assign_source_30 = IMPORT_NAME( tmp_import_name_from_20, const_str_plain_DBusException ); | ||
| 1462 | if ( tmp_assign_source_30 == NULL ) | ||
| 1463 | { | ||
| 1464 | assert( ERROR_OCCURRED() ); | ||
| 1465 | |||
| 1466 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1467 | |||
| 1468 | |||
| 1469 | exception_lineno = 84; | ||
| 1470 | |||
| 1471 | goto try_except_handler_3; | ||
| 1472 | } | ||
| 1473 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_DBusException, tmp_assign_source_30 ); | ||
| 1474 | } | ||
| 1475 | { | ||
| 1476 | PyObject *tmp_assign_source_31; | ||
| 1477 | PyObject *tmp_import_name_from_21; | ||
| 1478 | CHECK_OBJECT( tmp_import_from_3__module ); | ||
| 1479 | tmp_import_name_from_21 = tmp_import_from_3__module; | ||
| 1480 | tmp_assign_source_31 = IMPORT_NAME( tmp_import_name_from_21, const_str_plain_IntrospectionParserException ); | ||
| 1481 | if ( tmp_assign_source_31 == NULL ) | ||
| 1482 | { | ||
| 1483 | assert( ERROR_OCCURRED() ); | ||
| 1484 | |||
| 1485 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1486 | |||
| 1487 | |||
| 1488 | exception_lineno = 84; | ||
| 1489 | |||
| 1490 | goto try_except_handler_3; | ||
| 1491 | } | ||
| 1492 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_IntrospectionParserException, tmp_assign_source_31 ); | ||
| 1493 | } | ||
| 1494 | { | ||
| 1495 | PyObject *tmp_assign_source_32; | ||
| 1496 | PyObject *tmp_import_name_from_22; | ||
| 1497 | CHECK_OBJECT( tmp_import_from_3__module ); | ||
| 1498 | tmp_import_name_from_22 = tmp_import_from_3__module; | ||
| 1499 | tmp_assign_source_32 = IMPORT_NAME( tmp_import_name_from_22, const_str_plain_MissingErrorHandlerException ); | ||
| 1500 | if ( tmp_assign_source_32 == NULL ) | ||
| 1501 | { | ||
| 1502 | assert( ERROR_OCCURRED() ); | ||
| 1503 | |||
| 1504 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1505 | |||
| 1506 | |||
| 1507 | exception_lineno = 84; | ||
| 1508 | |||
| 1509 | goto try_except_handler_3; | ||
| 1510 | } | ||
| 1511 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_MissingErrorHandlerException, tmp_assign_source_32 ); | ||
| 1512 | } | ||
| 1513 | { | ||
| 1514 | PyObject *tmp_assign_source_33; | ||
| 1515 | PyObject *tmp_import_name_from_23; | ||
| 1516 | CHECK_OBJECT( tmp_import_from_3__module ); | ||
| 1517 | tmp_import_name_from_23 = tmp_import_from_3__module; | ||
| 1518 | tmp_assign_source_33 = IMPORT_NAME( tmp_import_name_from_23, const_str_plain_MissingReplyHandlerException ); | ||
| 1519 | if ( tmp_assign_source_33 == NULL ) | ||
| 1520 | { | ||
| 1521 | assert( ERROR_OCCURRED() ); | ||
| 1522 | |||
| 1523 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1524 | |||
| 1525 | |||
| 1526 | exception_lineno = 84; | ||
| 1527 | |||
| 1528 | goto try_except_handler_3; | ||
| 1529 | } | ||
| 1530 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_MissingReplyHandlerException, tmp_assign_source_33 ); | ||
| 1531 | } | ||
| 1532 | { | ||
| 1533 | PyObject *tmp_assign_source_34; | ||
| 1534 | PyObject *tmp_import_name_from_24; | ||
| 1535 | CHECK_OBJECT( tmp_import_from_3__module ); | ||
| 1536 | tmp_import_name_from_24 = tmp_import_from_3__module; | ||
| 1537 | tmp_assign_source_34 = IMPORT_NAME( tmp_import_name_from_24, const_str_plain_NameExistsException ); | ||
| 1538 | if ( tmp_assign_source_34 == NULL ) | ||
| 1539 | { | ||
| 1540 | assert( ERROR_OCCURRED() ); | ||
| 1541 | |||
| 1542 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1543 | |||
| 1544 | |||
| 1545 | exception_lineno = 84; | ||
| 1546 | |||
| 1547 | goto try_except_handler_3; | ||
| 1548 | } | ||
| 1549 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_NameExistsException, tmp_assign_source_34 ); | ||
| 1550 | } | ||
| 1551 | { | ||
| 1552 | PyObject *tmp_assign_source_35; | ||
| 1553 | PyObject *tmp_import_name_from_25; | ||
| 1554 | CHECK_OBJECT( tmp_import_from_3__module ); | ||
| 1555 | tmp_import_name_from_25 = tmp_import_from_3__module; | ||
| 1556 | tmp_assign_source_35 = IMPORT_NAME( tmp_import_name_from_25, const_str_plain_UnknownMethodException ); | ||
| 1557 | if ( tmp_assign_source_35 == NULL ) | ||
| 1558 | { | ||
| 1559 | assert( ERROR_OCCURRED() ); | ||
| 1560 | |||
| 1561 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1562 | |||
| 1563 | |||
| 1564 | exception_lineno = 84; | ||
| 1565 | |||
| 1566 | goto try_except_handler_3; | ||
| 1567 | } | ||
| 1568 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_UnknownMethodException, tmp_assign_source_35 ); | ||
| 1569 | } | ||
| 1570 | { | ||
| 1571 | PyObject *tmp_assign_source_36; | ||
| 1572 | PyObject *tmp_import_name_from_26; | ||
| 1573 | CHECK_OBJECT( tmp_import_from_3__module ); | ||
| 1574 | tmp_import_name_from_26 = tmp_import_from_3__module; | ||
| 1575 | tmp_assign_source_36 = IMPORT_NAME( tmp_import_name_from_26, const_str_plain_ValidationException ); | ||
| 1576 | if ( tmp_assign_source_36 == NULL ) | ||
| 1577 | { | ||
| 1578 | assert( ERROR_OCCURRED() ); | ||
| 1579 | |||
| 1580 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1581 | |||
| 1582 | |||
| 1583 | exception_lineno = 84; | ||
| 1584 | |||
| 1585 | goto try_except_handler_3; | ||
| 1586 | } | ||
| 1587 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_ValidationException, tmp_assign_source_36 ); | ||
| 1588 | } | ||
| 1589 | goto try_end_3; | ||
| 1590 | // Exception handler code: | ||
| 1591 | try_except_handler_3:; | ||
| 1592 | exception_keeper_type_3 = exception_type; | ||
| 1593 | exception_keeper_value_3 = exception_value; | ||
| 1594 | exception_keeper_tb_3 = exception_tb; | ||
| 1595 | exception_keeper_lineno_3 = exception_lineno; | ||
| 1596 | exception_type = NULL; | ||
| 1597 | exception_value = NULL; | ||
| 1598 | exception_tb = NULL; | ||
| 1599 | exception_lineno = 0; | ||
| 1600 | |||
| 1601 | CHECK_OBJECT( (PyObject *)tmp_import_from_3__module ); | ||
| 1602 | Py_DECREF( tmp_import_from_3__module ); | ||
| 1603 | tmp_import_from_3__module = NULL; | ||
| 1604 | |||
| 1605 | // Re-raise. | ||
| 1606 | exception_type = exception_keeper_type_3; | ||
| 1607 | exception_value = exception_keeper_value_3; | ||
| 1608 | exception_tb = exception_keeper_tb_3; | ||
| 1609 | exception_lineno = exception_keeper_lineno_3; | ||
| 1610 | |||
| 1611 | goto frame_exception_exit_1; | ||
| 1612 | // End of try: | ||
| 1613 | try_end_3:; | ||
| 1614 | CHECK_OBJECT( (PyObject *)tmp_import_from_3__module ); | ||
| 1615 | Py_DECREF( tmp_import_from_3__module ); | ||
| 1616 | tmp_import_from_3__module = NULL; | ||
| 1617 | |||
| 1618 | { | ||
| 1619 | PyObject *tmp_assign_source_37; | ||
| 1620 | PyObject *tmp_name_name_8; | ||
| 1621 | PyObject *tmp_globals_name_8; | ||
| 1622 | PyObject *tmp_locals_name_8; | ||
| 1623 | PyObject *tmp_fromlist_name_8; | ||
| 1624 | PyObject *tmp_level_name_8; | ||
| 1625 | tmp_name_name_8 = const_str_plain__dbus_bindings; | ||
| 1626 | tmp_globals_name_8 = (PyObject *)moduledict_dbus; | ||
| 1627 | tmp_locals_name_8 = Py_None; | ||
| 1628 | tmp_fromlist_name_8 = const_tuple_e5a705a12efe2e8a6f33d44dc7ceea11_tuple; | ||
| 1629 | tmp_level_name_8 = const_int_0; | ||
| 1630 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 88; | ||
| 1631 | tmp_assign_source_37 = IMPORT_MODULE5( tmp_name_name_8, tmp_globals_name_8, tmp_locals_name_8, tmp_fromlist_name_8, tmp_level_name_8 ); | ||
| 1632 | if ( tmp_assign_source_37 == NULL ) | ||
| 1633 | { | ||
| 1634 | assert( ERROR_OCCURRED() ); | ||
| 1635 | |||
| 1636 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1637 | |||
| 1638 | |||
| 1639 | exception_lineno = 88; | ||
| 1640 | |||
| 1641 | goto frame_exception_exit_1; | ||
| 1642 | } | ||
| 1643 | assert( tmp_import_from_4__module == NULL ); | ||
| 1644 | tmp_import_from_4__module = tmp_assign_source_37; | ||
| 1645 | } | ||
| 1646 | // Tried code: | ||
| 1647 | { | ||
| 1648 | PyObject *tmp_assign_source_38; | ||
| 1649 | PyObject *tmp_import_name_from_27; | ||
| 1650 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1651 | tmp_import_name_from_27 = tmp_import_from_4__module; | ||
| 1652 | tmp_assign_source_38 = IMPORT_NAME( tmp_import_name_from_27, const_str_plain_Array ); | ||
| 1653 | if ( tmp_assign_source_38 == NULL ) | ||
| 1654 | { | ||
| 1655 | assert( ERROR_OCCURRED() ); | ||
| 1656 | |||
| 1657 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1658 | |||
| 1659 | |||
| 1660 | exception_lineno = 88; | ||
| 1661 | |||
| 1662 | goto try_except_handler_4; | ||
| 1663 | } | ||
| 1664 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Array, tmp_assign_source_38 ); | ||
| 1665 | } | ||
| 1666 | { | ||
| 1667 | PyObject *tmp_assign_source_39; | ||
| 1668 | PyObject *tmp_import_name_from_28; | ||
| 1669 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1670 | tmp_import_name_from_28 = tmp_import_from_4__module; | ||
| 1671 | tmp_assign_source_39 = IMPORT_NAME( tmp_import_name_from_28, const_str_plain_Boolean ); | ||
| 1672 | if ( tmp_assign_source_39 == NULL ) | ||
| 1673 | { | ||
| 1674 | assert( ERROR_OCCURRED() ); | ||
| 1675 | |||
| 1676 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1677 | |||
| 1678 | |||
| 1679 | exception_lineno = 88; | ||
| 1680 | |||
| 1681 | goto try_except_handler_4; | ||
| 1682 | } | ||
| 1683 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Boolean, tmp_assign_source_39 ); | ||
| 1684 | } | ||
| 1685 | { | ||
| 1686 | PyObject *tmp_assign_source_40; | ||
| 1687 | PyObject *tmp_import_name_from_29; | ||
| 1688 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1689 | tmp_import_name_from_29 = tmp_import_from_4__module; | ||
| 1690 | tmp_assign_source_40 = IMPORT_NAME( tmp_import_name_from_29, const_str_plain_Byte ); | ||
| 1691 | if ( tmp_assign_source_40 == NULL ) | ||
| 1692 | { | ||
| 1693 | assert( ERROR_OCCURRED() ); | ||
| 1694 | |||
| 1695 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1696 | |||
| 1697 | |||
| 1698 | exception_lineno = 88; | ||
| 1699 | |||
| 1700 | goto try_except_handler_4; | ||
| 1701 | } | ||
| 1702 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Byte, tmp_assign_source_40 ); | ||
| 1703 | } | ||
| 1704 | { | ||
| 1705 | PyObject *tmp_assign_source_41; | ||
| 1706 | PyObject *tmp_import_name_from_30; | ||
| 1707 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1708 | tmp_import_name_from_30 = tmp_import_from_4__module; | ||
| 1709 | tmp_assign_source_41 = IMPORT_NAME( tmp_import_name_from_30, const_str_plain_ByteArray ); | ||
| 1710 | if ( tmp_assign_source_41 == NULL ) | ||
| 1711 | { | ||
| 1712 | assert( ERROR_OCCURRED() ); | ||
| 1713 | |||
| 1714 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1715 | |||
| 1716 | |||
| 1717 | exception_lineno = 88; | ||
| 1718 | |||
| 1719 | goto try_except_handler_4; | ||
| 1720 | } | ||
| 1721 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_ByteArray, tmp_assign_source_41 ); | ||
| 1722 | } | ||
| 1723 | { | ||
| 1724 | PyObject *tmp_assign_source_42; | ||
| 1725 | PyObject *tmp_import_name_from_31; | ||
| 1726 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1727 | tmp_import_name_from_31 = tmp_import_from_4__module; | ||
| 1728 | tmp_assign_source_42 = IMPORT_NAME( tmp_import_name_from_31, const_str_plain_Dictionary ); | ||
| 1729 | if ( tmp_assign_source_42 == NULL ) | ||
| 1730 | { | ||
| 1731 | assert( ERROR_OCCURRED() ); | ||
| 1732 | |||
| 1733 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1734 | |||
| 1735 | |||
| 1736 | exception_lineno = 88; | ||
| 1737 | |||
| 1738 | goto try_except_handler_4; | ||
| 1739 | } | ||
| 1740 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Dictionary, tmp_assign_source_42 ); | ||
| 1741 | } | ||
| 1742 | { | ||
| 1743 | PyObject *tmp_assign_source_43; | ||
| 1744 | PyObject *tmp_import_name_from_32; | ||
| 1745 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1746 | tmp_import_name_from_32 = tmp_import_from_4__module; | ||
| 1747 | tmp_assign_source_43 = IMPORT_NAME( tmp_import_name_from_32, const_str_plain_Double ); | ||
| 1748 | if ( tmp_assign_source_43 == NULL ) | ||
| 1749 | { | ||
| 1750 | assert( ERROR_OCCURRED() ); | ||
| 1751 | |||
| 1752 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1753 | |||
| 1754 | |||
| 1755 | exception_lineno = 88; | ||
| 1756 | |||
| 1757 | goto try_except_handler_4; | ||
| 1758 | } | ||
| 1759 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Double, tmp_assign_source_43 ); | ||
| 1760 | } | ||
| 1761 | { | ||
| 1762 | PyObject *tmp_assign_source_44; | ||
| 1763 | PyObject *tmp_import_name_from_33; | ||
| 1764 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1765 | tmp_import_name_from_33 = tmp_import_from_4__module; | ||
| 1766 | tmp_assign_source_44 = IMPORT_NAME( tmp_import_name_from_33, const_str_plain_Int16 ); | ||
| 1767 | if ( tmp_assign_source_44 == NULL ) | ||
| 1768 | { | ||
| 1769 | assert( ERROR_OCCURRED() ); | ||
| 1770 | |||
| 1771 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1772 | |||
| 1773 | |||
| 1774 | exception_lineno = 88; | ||
| 1775 | |||
| 1776 | goto try_except_handler_4; | ||
| 1777 | } | ||
| 1778 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Int16, tmp_assign_source_44 ); | ||
| 1779 | } | ||
| 1780 | { | ||
| 1781 | PyObject *tmp_assign_source_45; | ||
| 1782 | PyObject *tmp_import_name_from_34; | ||
| 1783 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1784 | tmp_import_name_from_34 = tmp_import_from_4__module; | ||
| 1785 | tmp_assign_source_45 = IMPORT_NAME( tmp_import_name_from_34, const_str_plain_Int32 ); | ||
| 1786 | if ( tmp_assign_source_45 == NULL ) | ||
| 1787 | { | ||
| 1788 | assert( ERROR_OCCURRED() ); | ||
| 1789 | |||
| 1790 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1791 | |||
| 1792 | |||
| 1793 | exception_lineno = 88; | ||
| 1794 | |||
| 1795 | goto try_except_handler_4; | ||
| 1796 | } | ||
| 1797 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Int32, tmp_assign_source_45 ); | ||
| 1798 | } | ||
| 1799 | { | ||
| 1800 | PyObject *tmp_assign_source_46; | ||
| 1801 | PyObject *tmp_import_name_from_35; | ||
| 1802 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1803 | tmp_import_name_from_35 = tmp_import_from_4__module; | ||
| 1804 | tmp_assign_source_46 = IMPORT_NAME( tmp_import_name_from_35, const_str_plain_Int64 ); | ||
| 1805 | if ( tmp_assign_source_46 == NULL ) | ||
| 1806 | { | ||
| 1807 | assert( ERROR_OCCURRED() ); | ||
| 1808 | |||
| 1809 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1810 | |||
| 1811 | |||
| 1812 | exception_lineno = 88; | ||
| 1813 | |||
| 1814 | goto try_except_handler_4; | ||
| 1815 | } | ||
| 1816 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Int64, tmp_assign_source_46 ); | ||
| 1817 | } | ||
| 1818 | { | ||
| 1819 | PyObject *tmp_assign_source_47; | ||
| 1820 | PyObject *tmp_import_name_from_36; | ||
| 1821 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1822 | tmp_import_name_from_36 = tmp_import_from_4__module; | ||
| 1823 | tmp_assign_source_47 = IMPORT_NAME( tmp_import_name_from_36, const_str_plain_ObjectPath ); | ||
| 1824 | if ( tmp_assign_source_47 == NULL ) | ||
| 1825 | { | ||
| 1826 | assert( ERROR_OCCURRED() ); | ||
| 1827 | |||
| 1828 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1829 | |||
| 1830 | |||
| 1831 | exception_lineno = 88; | ||
| 1832 | |||
| 1833 | goto try_except_handler_4; | ||
| 1834 | } | ||
| 1835 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_ObjectPath, tmp_assign_source_47 ); | ||
| 1836 | } | ||
| 1837 | { | ||
| 1838 | PyObject *tmp_assign_source_48; | ||
| 1839 | PyObject *tmp_import_name_from_37; | ||
| 1840 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1841 | tmp_import_name_from_37 = tmp_import_from_4__module; | ||
| 1842 | tmp_assign_source_48 = IMPORT_NAME( tmp_import_name_from_37, const_str_plain_Signature ); | ||
| 1843 | if ( tmp_assign_source_48 == NULL ) | ||
| 1844 | { | ||
| 1845 | assert( ERROR_OCCURRED() ); | ||
| 1846 | |||
| 1847 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1848 | |||
| 1849 | |||
| 1850 | exception_lineno = 88; | ||
| 1851 | |||
| 1852 | goto try_except_handler_4; | ||
| 1853 | } | ||
| 1854 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Signature, tmp_assign_source_48 ); | ||
| 1855 | } | ||
| 1856 | { | ||
| 1857 | PyObject *tmp_assign_source_49; | ||
| 1858 | PyObject *tmp_import_name_from_38; | ||
| 1859 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1860 | tmp_import_name_from_38 = tmp_import_from_4__module; | ||
| 1861 | tmp_assign_source_49 = IMPORT_NAME( tmp_import_name_from_38, const_str_plain_String ); | ||
| 1862 | if ( tmp_assign_source_49 == NULL ) | ||
| 1863 | { | ||
| 1864 | assert( ERROR_OCCURRED() ); | ||
| 1865 | |||
| 1866 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1867 | |||
| 1868 | |||
| 1869 | exception_lineno = 88; | ||
| 1870 | |||
| 1871 | goto try_except_handler_4; | ||
| 1872 | } | ||
| 1873 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_String, tmp_assign_source_49 ); | ||
| 1874 | } | ||
| 1875 | { | ||
| 1876 | PyObject *tmp_assign_source_50; | ||
| 1877 | PyObject *tmp_import_name_from_39; | ||
| 1878 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1879 | tmp_import_name_from_39 = tmp_import_from_4__module; | ||
| 1880 | tmp_assign_source_50 = IMPORT_NAME( tmp_import_name_from_39, const_str_plain_Struct ); | ||
| 1881 | if ( tmp_assign_source_50 == NULL ) | ||
| 1882 | { | ||
| 1883 | assert( ERROR_OCCURRED() ); | ||
| 1884 | |||
| 1885 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1886 | |||
| 1887 | |||
| 1888 | exception_lineno = 88; | ||
| 1889 | |||
| 1890 | goto try_except_handler_4; | ||
| 1891 | } | ||
| 1892 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Struct, tmp_assign_source_50 ); | ||
| 1893 | } | ||
| 1894 | { | ||
| 1895 | PyObject *tmp_assign_source_51; | ||
| 1896 | PyObject *tmp_import_name_from_40; | ||
| 1897 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1898 | tmp_import_name_from_40 = tmp_import_from_4__module; | ||
| 1899 | tmp_assign_source_51 = IMPORT_NAME( tmp_import_name_from_40, const_str_plain_UInt16 ); | ||
| 1900 | if ( tmp_assign_source_51 == NULL ) | ||
| 1901 | { | ||
| 1902 | assert( ERROR_OCCURRED() ); | ||
| 1903 | |||
| 1904 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1905 | |||
| 1906 | |||
| 1907 | exception_lineno = 88; | ||
| 1908 | |||
| 1909 | goto try_except_handler_4; | ||
| 1910 | } | ||
| 1911 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_UInt16, tmp_assign_source_51 ); | ||
| 1912 | } | ||
| 1913 | { | ||
| 1914 | PyObject *tmp_assign_source_52; | ||
| 1915 | PyObject *tmp_import_name_from_41; | ||
| 1916 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1917 | tmp_import_name_from_41 = tmp_import_from_4__module; | ||
| 1918 | tmp_assign_source_52 = IMPORT_NAME( tmp_import_name_from_41, const_str_plain_UInt32 ); | ||
| 1919 | if ( tmp_assign_source_52 == NULL ) | ||
| 1920 | { | ||
| 1921 | assert( ERROR_OCCURRED() ); | ||
| 1922 | |||
| 1923 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1924 | |||
| 1925 | |||
| 1926 | exception_lineno = 88; | ||
| 1927 | |||
| 1928 | goto try_except_handler_4; | ||
| 1929 | } | ||
| 1930 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_UInt32, tmp_assign_source_52 ); | ||
| 1931 | } | ||
| 1932 | { | ||
| 1933 | PyObject *tmp_assign_source_53; | ||
| 1934 | PyObject *tmp_import_name_from_42; | ||
| 1935 | CHECK_OBJECT( tmp_import_from_4__module ); | ||
| 1936 | tmp_import_name_from_42 = tmp_import_from_4__module; | ||
| 1937 | tmp_assign_source_53 = IMPORT_NAME( tmp_import_name_from_42, const_str_plain_UInt64 ); | ||
| 1938 | if ( tmp_assign_source_53 == NULL ) | ||
| 1939 | { | ||
| 1940 | assert( ERROR_OCCURRED() ); | ||
| 1941 | |||
| 1942 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1943 | |||
| 1944 | |||
| 1945 | exception_lineno = 88; | ||
| 1946 | |||
| 1947 | goto try_except_handler_4; | ||
| 1948 | } | ||
| 1949 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_UInt64, tmp_assign_source_53 ); | ||
| 1950 | } | ||
| 1951 | goto try_end_4; | ||
| 1952 | // Exception handler code: | ||
| 1953 | try_except_handler_4:; | ||
| 1954 | exception_keeper_type_4 = exception_type; | ||
| 1955 | exception_keeper_value_4 = exception_value; | ||
| 1956 | exception_keeper_tb_4 = exception_tb; | ||
| 1957 | exception_keeper_lineno_4 = exception_lineno; | ||
| 1958 | exception_type = NULL; | ||
| 1959 | exception_value = NULL; | ||
| 1960 | exception_tb = NULL; | ||
| 1961 | exception_lineno = 0; | ||
| 1962 | |||
| 1963 | CHECK_OBJECT( (PyObject *)tmp_import_from_4__module ); | ||
| 1964 | Py_DECREF( tmp_import_from_4__module ); | ||
| 1965 | tmp_import_from_4__module = NULL; | ||
| 1966 | |||
| 1967 | // Re-raise. | ||
| 1968 | exception_type = exception_keeper_type_4; | ||
| 1969 | exception_value = exception_keeper_value_4; | ||
| 1970 | exception_tb = exception_keeper_tb_4; | ||
| 1971 | exception_lineno = exception_keeper_lineno_4; | ||
| 1972 | |||
| 1973 | goto frame_exception_exit_1; | ||
| 1974 | // End of try: | ||
| 1975 | try_end_4:; | ||
| 1976 | CHECK_OBJECT( (PyObject *)tmp_import_from_4__module ); | ||
| 1977 | Py_DECREF( tmp_import_from_4__module ); | ||
| 1978 | tmp_import_from_4__module = NULL; | ||
| 1979 | |||
| 1980 | { | ||
| 1981 | nuitka_bool tmp_condition_result_2; | ||
| 1982 | PyObject *tmp_mvar_value_6; | ||
| 1983 | int tmp_truth_name_2; | ||
| 1984 | tmp_mvar_value_6 = GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_is_py2 ); | ||
| 1985 | |||
| 1986 | if (unlikely( tmp_mvar_value_6 == NULL )) | ||
| 1987 | { | ||
| 1988 | tmp_mvar_value_6 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_is_py2 ); | ||
| 1989 | } | ||
| 1990 | |||
| 1991 | if ( tmp_mvar_value_6 == NULL ) | ||
| 1992 | { | ||
| 1993 | |||
| 1994 | exception_type = PyExc_NameError; | ||
| 1995 | Py_INCREF( exception_type ); | ||
| 1996 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "is_py2" ); | ||
| 1997 | exception_tb = NULL; | ||
| 1998 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1999 | CHAIN_EXCEPTION( exception_value ); | ||
| 2000 | |||
| 2001 | exception_lineno = 92; | ||
| 2002 | |||
| 2003 | goto frame_exception_exit_1; | ||
| 2004 | } | ||
| 2005 | |||
| 2006 | tmp_truth_name_2 = CHECK_IF_TRUE( tmp_mvar_value_6 ); | ||
| 2007 | if ( tmp_truth_name_2 == -1 ) | ||
| 2008 | { | ||
| 2009 | assert( ERROR_OCCURRED() ); | ||
| 2010 | |||
| 2011 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2012 | |||
| 2013 | |||
| 2014 | exception_lineno = 92; | ||
| 2015 | |||
| 2016 | goto frame_exception_exit_1; | ||
| 2017 | } | ||
| 2018 | tmp_condition_result_2 = tmp_truth_name_2 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2019 | if ( tmp_condition_result_2 == NUITKA_BOOL_TRUE ) | ||
| 2020 | { | ||
| 2021 | goto branch_yes_2; | ||
| 2022 | } | ||
| 2023 | else | ||
| 2024 | { | ||
| 2025 | goto branch_no_2; | ||
| 2026 | } | ||
| 2027 | branch_yes_2:; | ||
| 2028 | { | ||
| 2029 | PyObject *tmp_assign_source_54; | ||
| 2030 | PyObject *tmp_import_name_from_43; | ||
| 2031 | PyObject *tmp_name_name_9; | ||
| 2032 | PyObject *tmp_globals_name_9; | ||
| 2033 | PyObject *tmp_locals_name_9; | ||
| 2034 | PyObject *tmp_fromlist_name_9; | ||
| 2035 | PyObject *tmp_level_name_9; | ||
| 2036 | tmp_name_name_9 = const_str_plain__dbus_bindings; | ||
| 2037 | tmp_globals_name_9 = (PyObject *)moduledict_dbus; | ||
| 2038 | tmp_locals_name_9 = Py_None; | ||
| 2039 | tmp_fromlist_name_9 = const_tuple_str_plain_UTF8String_tuple; | ||
| 2040 | tmp_level_name_9 = const_int_0; | ||
| 2041 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 93; | ||
| 2042 | tmp_import_name_from_43 = IMPORT_MODULE5( tmp_name_name_9, tmp_globals_name_9, tmp_locals_name_9, tmp_fromlist_name_9, tmp_level_name_9 ); | ||
| 2043 | if ( tmp_import_name_from_43 == NULL ) | ||
| 2044 | { | ||
| 2045 | assert( ERROR_OCCURRED() ); | ||
| 2046 | |||
| 2047 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2048 | |||
| 2049 | |||
| 2050 | exception_lineno = 93; | ||
| 2051 | |||
| 2052 | goto frame_exception_exit_1; | ||
| 2053 | } | ||
| 2054 | tmp_assign_source_54 = IMPORT_NAME( tmp_import_name_from_43, const_str_plain_UTF8String ); | ||
| 2055 | Py_DECREF( tmp_import_name_from_43 ); | ||
| 2056 | if ( tmp_assign_source_54 == NULL ) | ||
| 2057 | { | ||
| 2058 | assert( ERROR_OCCURRED() ); | ||
| 2059 | |||
| 2060 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2061 | |||
| 2062 | |||
| 2063 | exception_lineno = 93; | ||
| 2064 | |||
| 2065 | goto frame_exception_exit_1; | ||
| 2066 | } | ||
| 2067 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_UTF8String, tmp_assign_source_54 ); | ||
| 2068 | } | ||
| 2069 | branch_no_2:; | ||
| 2070 | } | ||
| 2071 | { | ||
| 2072 | PyObject *tmp_assign_source_55; | ||
| 2073 | PyObject *tmp_name_name_10; | ||
| 2074 | PyObject *tmp_globals_name_10; | ||
| 2075 | PyObject *tmp_locals_name_10; | ||
| 2076 | PyObject *tmp_fromlist_name_10; | ||
| 2077 | PyObject *tmp_level_name_10; | ||
| 2078 | tmp_name_name_10 = const_str_digest_62223e4c0fc7bcb5885146e43f1fb665; | ||
| 2079 | tmp_globals_name_10 = (PyObject *)moduledict_dbus; | ||
| 2080 | tmp_locals_name_10 = Py_None; | ||
| 2081 | tmp_fromlist_name_10 = const_tuple_76ee81f3638eaf5a352e7276367934cb_tuple; | ||
| 2082 | tmp_level_name_10 = const_int_0; | ||
| 2083 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 95; | ||
| 2084 | tmp_assign_source_55 = IMPORT_MODULE5( tmp_name_name_10, tmp_globals_name_10, tmp_locals_name_10, tmp_fromlist_name_10, tmp_level_name_10 ); | ||
| 2085 | if ( tmp_assign_source_55 == NULL ) | ||
| 2086 | { | ||
| 2087 | assert( ERROR_OCCURRED() ); | ||
| 2088 | |||
| 2089 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2090 | |||
| 2091 | |||
| 2092 | exception_lineno = 95; | ||
| 2093 | |||
| 2094 | goto frame_exception_exit_1; | ||
| 2095 | } | ||
| 2096 | assert( tmp_import_from_5__module == NULL ); | ||
| 2097 | tmp_import_from_5__module = tmp_assign_source_55; | ||
| 2098 | } | ||
| 2099 | // Tried code: | ||
| 2100 | { | ||
| 2101 | PyObject *tmp_assign_source_56; | ||
| 2102 | PyObject *tmp_import_name_from_44; | ||
| 2103 | CHECK_OBJECT( tmp_import_from_5__module ); | ||
| 2104 | tmp_import_name_from_44 = tmp_import_from_5__module; | ||
| 2105 | tmp_assign_source_56 = IMPORT_NAME( tmp_import_name_from_44, const_str_plain_Bus ); | ||
| 2106 | if ( tmp_assign_source_56 == NULL ) | ||
| 2107 | { | ||
| 2108 | assert( ERROR_OCCURRED() ); | ||
| 2109 | |||
| 2110 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2111 | |||
| 2112 | |||
| 2113 | exception_lineno = 95; | ||
| 2114 | |||
| 2115 | goto try_except_handler_5; | ||
| 2116 | } | ||
| 2117 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Bus, tmp_assign_source_56 ); | ||
| 2118 | } | ||
| 2119 | { | ||
| 2120 | PyObject *tmp_assign_source_57; | ||
| 2121 | PyObject *tmp_import_name_from_45; | ||
| 2122 | CHECK_OBJECT( tmp_import_from_5__module ); | ||
| 2123 | tmp_import_name_from_45 = tmp_import_from_5__module; | ||
| 2124 | tmp_assign_source_57 = IMPORT_NAME( tmp_import_name_from_45, const_str_plain_SystemBus ); | ||
| 2125 | if ( tmp_assign_source_57 == NULL ) | ||
| 2126 | { | ||
| 2127 | assert( ERROR_OCCURRED() ); | ||
| 2128 | |||
| 2129 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2130 | |||
| 2131 | |||
| 2132 | exception_lineno = 95; | ||
| 2133 | |||
| 2134 | goto try_except_handler_5; | ||
| 2135 | } | ||
| 2136 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_SystemBus, tmp_assign_source_57 ); | ||
| 2137 | } | ||
| 2138 | { | ||
| 2139 | PyObject *tmp_assign_source_58; | ||
| 2140 | PyObject *tmp_import_name_from_46; | ||
| 2141 | CHECK_OBJECT( tmp_import_from_5__module ); | ||
| 2142 | tmp_import_name_from_46 = tmp_import_from_5__module; | ||
| 2143 | tmp_assign_source_58 = IMPORT_NAME( tmp_import_name_from_46, const_str_plain_SessionBus ); | ||
| 2144 | if ( tmp_assign_source_58 == NULL ) | ||
| 2145 | { | ||
| 2146 | assert( ERROR_OCCURRED() ); | ||
| 2147 | |||
| 2148 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2149 | |||
| 2150 | |||
| 2151 | exception_lineno = 95; | ||
| 2152 | |||
| 2153 | goto try_except_handler_5; | ||
| 2154 | } | ||
| 2155 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_SessionBus, tmp_assign_source_58 ); | ||
| 2156 | } | ||
| 2157 | { | ||
| 2158 | PyObject *tmp_assign_source_59; | ||
| 2159 | PyObject *tmp_import_name_from_47; | ||
| 2160 | CHECK_OBJECT( tmp_import_from_5__module ); | ||
| 2161 | tmp_import_name_from_47 = tmp_import_from_5__module; | ||
| 2162 | tmp_assign_source_59 = IMPORT_NAME( tmp_import_name_from_47, const_str_plain_StarterBus ); | ||
| 2163 | if ( tmp_assign_source_59 == NULL ) | ||
| 2164 | { | ||
| 2165 | assert( ERROR_OCCURRED() ); | ||
| 2166 | |||
| 2167 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2168 | |||
| 2169 | |||
| 2170 | exception_lineno = 95; | ||
| 2171 | |||
| 2172 | goto try_except_handler_5; | ||
| 2173 | } | ||
| 2174 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_StarterBus, tmp_assign_source_59 ); | ||
| 2175 | } | ||
| 2176 | goto try_end_5; | ||
| 2177 | // Exception handler code: | ||
| 2178 | try_except_handler_5:; | ||
| 2179 | exception_keeper_type_5 = exception_type; | ||
| 2180 | exception_keeper_value_5 = exception_value; | ||
| 2181 | exception_keeper_tb_5 = exception_tb; | ||
| 2182 | exception_keeper_lineno_5 = exception_lineno; | ||
| 2183 | exception_type = NULL; | ||
| 2184 | exception_value = NULL; | ||
| 2185 | exception_tb = NULL; | ||
| 2186 | exception_lineno = 0; | ||
| 2187 | |||
| 2188 | CHECK_OBJECT( (PyObject *)tmp_import_from_5__module ); | ||
| 2189 | Py_DECREF( tmp_import_from_5__module ); | ||
| 2190 | tmp_import_from_5__module = NULL; | ||
| 2191 | |||
| 2192 | // Re-raise. | ||
| 2193 | exception_type = exception_keeper_type_5; | ||
| 2194 | exception_value = exception_keeper_value_5; | ||
| 2195 | exception_tb = exception_keeper_tb_5; | ||
| 2196 | exception_lineno = exception_keeper_lineno_5; | ||
| 2197 | |||
| 2198 | goto frame_exception_exit_1; | ||
| 2199 | // End of try: | ||
| 2200 | try_end_5:; | ||
| 2201 | CHECK_OBJECT( (PyObject *)tmp_import_from_5__module ); | ||
| 2202 | Py_DECREF( tmp_import_from_5__module ); | ||
| 2203 | tmp_import_from_5__module = NULL; | ||
| 2204 | |||
| 2205 | { | ||
| 2206 | PyObject *tmp_assign_source_60; | ||
| 2207 | PyObject *tmp_import_name_from_48; | ||
| 2208 | PyObject *tmp_name_name_11; | ||
| 2209 | PyObject *tmp_globals_name_11; | ||
| 2210 | PyObject *tmp_locals_name_11; | ||
| 2211 | PyObject *tmp_fromlist_name_11; | ||
| 2212 | PyObject *tmp_level_name_11; | ||
| 2213 | tmp_name_name_11 = const_str_digest_8e2db9d493d0360a27a3bf19583a3201; | ||
| 2214 | tmp_globals_name_11 = (PyObject *)moduledict_dbus; | ||
| 2215 | tmp_locals_name_11 = Py_None; | ||
| 2216 | tmp_fromlist_name_11 = const_tuple_str_plain_Interface_tuple; | ||
| 2217 | tmp_level_name_11 = const_int_0; | ||
| 2218 | frame_d676880cece0dacbdc685c3346c3b838->m_frame.f_lineno = 96; | ||
| 2219 | tmp_import_name_from_48 = IMPORT_MODULE5( tmp_name_name_11, tmp_globals_name_11, tmp_locals_name_11, tmp_fromlist_name_11, tmp_level_name_11 ); | ||
| 2220 | if ( tmp_import_name_from_48 == NULL ) | ||
| 2221 | { | ||
| 2222 | assert( ERROR_OCCURRED() ); | ||
| 2223 | |||
| 2224 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2225 | |||
| 2226 | |||
| 2227 | exception_lineno = 96; | ||
| 2228 | |||
| 2229 | goto frame_exception_exit_1; | ||
| 2230 | } | ||
| 2231 | tmp_assign_source_60 = IMPORT_NAME( tmp_import_name_from_48, const_str_plain_Interface ); | ||
| 2232 | Py_DECREF( tmp_import_name_from_48 ); | ||
| 2233 | if ( tmp_assign_source_60 == NULL ) | ||
| 2234 | { | ||
| 2235 | assert( ERROR_OCCURRED() ); | ||
| 2236 | |||
| 2237 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2238 | |||
| 2239 | |||
| 2240 | exception_lineno = 96; | ||
| 2241 | |||
| 2242 | goto frame_exception_exit_1; | ||
| 2243 | } | ||
| 2244 | UPDATE_STRING_DICT1( moduledict_dbus, (Nuitka_StringObject *)const_str_plain_Interface, tmp_assign_source_60 ); | ||
| 2245 | } | ||
| 2246 | |||
| 2247 | // Restore frame exception if necessary. | ||
| 2248 | #if 0 | ||
| 2249 | RESTORE_FRAME_EXCEPTION( frame_d676880cece0dacbdc685c3346c3b838 ); | ||
| 2250 | #endif | ||
| 2251 | popFrameStack(); | ||
| 2252 | |||
| 2253 | assertFrameObject( frame_d676880cece0dacbdc685c3346c3b838 ); | ||
| 2254 | |||
| 2255 | goto frame_no_exception_1; | ||
| 2256 | |||
| 2257 | frame_exception_exit_1:; | ||
| 2258 | #if 0 | ||
| 2259 | RESTORE_FRAME_EXCEPTION( frame_d676880cece0dacbdc685c3346c3b838 ); | ||
| 2260 | #endif | ||
| 2261 | |||
| 2262 | if ( exception_tb == NULL ) | ||
| 2263 | { | ||
| 2264 | exception_tb = MAKE_TRACEBACK( frame_d676880cece0dacbdc685c3346c3b838, exception_lineno ); | ||
| 2265 | } | ||
| 2266 | else if ( exception_tb->tb_frame != &frame_d676880cece0dacbdc685c3346c3b838->m_frame ) | ||
| 2267 | { | ||
| 2268 | exception_tb = ADD_TRACEBACK( exception_tb, frame_d676880cece0dacbdc685c3346c3b838, exception_lineno ); | ||
| 2269 | } | ||
| 2270 | |||
| 2271 | // Put the previous frame back on top. | ||
| 2272 | popFrameStack(); | ||
| 2273 | |||
| 2274 | // Return the error. | ||
| 2275 | goto module_exception_exit; | ||
| 2276 | |||
| 2277 | frame_no_exception_1:; | ||
| 2278 | |||
| 2279 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 2280 | #if 1 && 0 | ||
| 2281 | { | ||
| 2282 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_dbus, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 2283 | |||
| 2284 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 2285 | { | ||
| 2286 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 2287 | |||
| 2288 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 2289 | CHECK_OBJECT( path_importer_cache ); | ||
| 2290 | |||
| 2291 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 2292 | assert( res == 0 ); | ||
| 2293 | } | ||
| 2294 | } | ||
| 2295 | #endif | ||
| 2296 | #endif | ||
| 2297 | |||
| 2298 | return MOD_RETURN_VALUE( module_dbus ); | ||
| 2299 | module_exception_exit: | ||
| 2300 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 2301 | return MOD_RETURN_VALUE( NULL ); | ||
| 2302 | } | ||
| The diff for file Linux_Version/inventory_synchronisation.build/module.dbus.connection.c is too big (21239 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.dbus.connection.o deleted (index 8a9223c..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.dbus.exceptions.c is too big (9617 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.dbus.exceptions.o deleted (index 2ce1f5d..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.dbus.lowlevel.c deleted (index be37fb4..0000000) | |||
| 1 | /* Generated code for Python module 'dbus.lowlevel' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_dbus$lowlevel" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_dbus$lowlevel; | ||
| 31 | PyDictObject *moduledict_dbus$lowlevel; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain___spec__; | ||
| 35 | static PyObject *const_str_plain_PendingCall; | ||
| 36 | static PyObject *const_str_plain_MESSAGE_TYPE_ERROR; | ||
| 37 | static PyObject *const_str_plain_Message; | ||
| 38 | extern PyObject *const_str_plain_HANDLER_RESULT_NOT_YET_HANDLED; | ||
| 39 | static PyObject *const_str_plain_HANDLER_RESULT_HANDLED; | ||
| 40 | extern PyObject *const_str_plain___all__; | ||
| 41 | extern PyObject *const_str_plain___file__; | ||
| 42 | static PyObject *const_tuple_491d884195767fc6bbf76933ebfa602c_tuple; | ||
| 43 | extern PyObject *const_str_plain__dbus_bindings; | ||
| 44 | extern PyObject *const_int_0; | ||
| 45 | extern PyObject *const_str_plain_ErrorMessage; | ||
| 46 | static PyObject *const_str_plain_MESSAGE_TYPE_METHOD_RETURN; | ||
| 47 | extern PyObject *const_str_plain___doc__; | ||
| 48 | static PyObject *const_str_digest_afdcdbdc0b31ee1d41f080da9a68df5a; | ||
| 49 | extern PyObject *const_str_digest_b45a3c6f685a3991de51197626bab5ca; | ||
| 50 | extern PyObject *const_str_plain_MethodCallMessage; | ||
| 51 | extern PyObject *const_str_plain_origin; | ||
| 52 | static PyObject *const_str_plain_MESSAGE_TYPE_INVALID; | ||
| 53 | static PyObject *const_str_digest_a2ddffe2dfe813897109cccd49814e19; | ||
| 54 | extern PyObject *const_str_plain_MethodReturnMessage; | ||
| 55 | extern PyObject *const_tuple_empty; | ||
| 56 | static PyObject *const_str_plain_MESSAGE_TYPE_SIGNAL; | ||
| 57 | extern PyObject *const_str_plain_has_location; | ||
| 58 | extern PyObject *const_str_plain_SignalMessage; | ||
| 59 | static PyObject *const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple; | ||
| 60 | extern PyObject *const_str_plain___cached__; | ||
| 61 | static PyObject *const_str_plain_MESSAGE_TYPE_METHOD_CALL; | ||
| 62 | static PyObject *const_str_digest_8f7c3d65be88d740545c0ec6a6afa505; | ||
| 63 | static PyObject *module_filename_obj; | ||
| 64 | |||
| 65 | /* Indicator if this modules private constants were created yet. */ | ||
| 66 | static bool constants_created = false; | ||
| 67 | |||
| 68 | /* Function to create module private constants. */ | ||
| 69 | static void createModuleConstants( void ) | ||
| 70 | { | ||
| 71 | const_str_plain_PendingCall = UNSTREAM_STRING_ASCII( &constant_bin[ 22866 ], 11, 1 ); | ||
| 72 | const_str_plain_MESSAGE_TYPE_ERROR = UNSTREAM_STRING_ASCII( &constant_bin[ 24002 ], 18, 1 ); | ||
| 73 | const_str_plain_Message = UNSTREAM_STRING_ASCII( &constant_bin[ 18945 ], 7, 1 ); | ||
| 74 | const_str_plain_HANDLER_RESULT_HANDLED = UNSTREAM_STRING_ASCII( &constant_bin[ 24020 ], 22, 1 ); | ||
| 75 | const_tuple_491d884195767fc6bbf76933ebfa602c_tuple = PyTuple_New( 13 ); | ||
| 76 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 0, const_str_plain_ErrorMessage ); Py_INCREF( const_str_plain_ErrorMessage ); | ||
| 77 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 1, const_str_plain_HANDLER_RESULT_HANDLED ); Py_INCREF( const_str_plain_HANDLER_RESULT_HANDLED ); | ||
| 78 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 2, const_str_plain_HANDLER_RESULT_NOT_YET_HANDLED ); Py_INCREF( const_str_plain_HANDLER_RESULT_NOT_YET_HANDLED ); | ||
| 79 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 3, const_str_plain_MESSAGE_TYPE_ERROR ); Py_INCREF( const_str_plain_MESSAGE_TYPE_ERROR ); | ||
| 80 | const_str_plain_MESSAGE_TYPE_INVALID = UNSTREAM_STRING_ASCII( &constant_bin[ 24042 ], 20, 1 ); | ||
| 81 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 4, const_str_plain_MESSAGE_TYPE_INVALID ); Py_INCREF( const_str_plain_MESSAGE_TYPE_INVALID ); | ||
| 82 | const_str_plain_MESSAGE_TYPE_METHOD_CALL = UNSTREAM_STRING_ASCII( &constant_bin[ 24062 ], 24, 1 ); | ||
| 83 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 5, const_str_plain_MESSAGE_TYPE_METHOD_CALL ); Py_INCREF( const_str_plain_MESSAGE_TYPE_METHOD_CALL ); | ||
| 84 | const_str_plain_MESSAGE_TYPE_METHOD_RETURN = UNSTREAM_STRING_ASCII( &constant_bin[ 24086 ], 26, 1 ); | ||
| 85 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 6, const_str_plain_MESSAGE_TYPE_METHOD_RETURN ); Py_INCREF( const_str_plain_MESSAGE_TYPE_METHOD_RETURN ); | ||
| 86 | const_str_plain_MESSAGE_TYPE_SIGNAL = UNSTREAM_STRING_ASCII( &constant_bin[ 24112 ], 19, 1 ); | ||
| 87 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 7, const_str_plain_MESSAGE_TYPE_SIGNAL ); Py_INCREF( const_str_plain_MESSAGE_TYPE_SIGNAL ); | ||
| 88 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 8, const_str_plain_Message ); Py_INCREF( const_str_plain_Message ); | ||
| 89 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 9, const_str_plain_MethodCallMessage ); Py_INCREF( const_str_plain_MethodCallMessage ); | ||
| 90 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 10, const_str_plain_MethodReturnMessage ); Py_INCREF( const_str_plain_MethodReturnMessage ); | ||
| 91 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 11, const_str_plain_PendingCall ); Py_INCREF( const_str_plain_PendingCall ); | ||
| 92 | PyTuple_SET_ITEM( const_tuple_491d884195767fc6bbf76933ebfa602c_tuple, 12, const_str_plain_SignalMessage ); Py_INCREF( const_str_plain_SignalMessage ); | ||
| 93 | const_str_digest_afdcdbdc0b31ee1d41f080da9a68df5a = UNSTREAM_STRING_ASCII( &constant_bin[ 24131 ], 29, 0 ); | ||
| 94 | const_str_digest_a2ddffe2dfe813897109cccd49814e19 = UNSTREAM_STRING_ASCII( &constant_bin[ 24160 ], 16, 0 ); | ||
| 95 | const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple = PyTuple_New( 13 ); | ||
| 96 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 0, const_str_plain_PendingCall ); Py_INCREF( const_str_plain_PendingCall ); | ||
| 97 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 1, const_str_plain_Message ); Py_INCREF( const_str_plain_Message ); | ||
| 98 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 2, const_str_plain_MethodCallMessage ); Py_INCREF( const_str_plain_MethodCallMessage ); | ||
| 99 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 3, const_str_plain_MethodReturnMessage ); Py_INCREF( const_str_plain_MethodReturnMessage ); | ||
| 100 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 4, const_str_plain_ErrorMessage ); Py_INCREF( const_str_plain_ErrorMessage ); | ||
| 101 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 5, const_str_plain_SignalMessage ); Py_INCREF( const_str_plain_SignalMessage ); | ||
| 102 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 6, const_str_plain_HANDLER_RESULT_HANDLED ); Py_INCREF( const_str_plain_HANDLER_RESULT_HANDLED ); | ||
| 103 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 7, const_str_plain_HANDLER_RESULT_NOT_YET_HANDLED ); Py_INCREF( const_str_plain_HANDLER_RESULT_NOT_YET_HANDLED ); | ||
| 104 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 8, const_str_plain_MESSAGE_TYPE_INVALID ); Py_INCREF( const_str_plain_MESSAGE_TYPE_INVALID ); | ||
| 105 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 9, const_str_plain_MESSAGE_TYPE_METHOD_CALL ); Py_INCREF( const_str_plain_MESSAGE_TYPE_METHOD_CALL ); | ||
| 106 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 10, const_str_plain_MESSAGE_TYPE_METHOD_RETURN ); Py_INCREF( const_str_plain_MESSAGE_TYPE_METHOD_RETURN ); | ||
| 107 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 11, const_str_plain_MESSAGE_TYPE_ERROR ); Py_INCREF( const_str_plain_MESSAGE_TYPE_ERROR ); | ||
| 108 | PyTuple_SET_ITEM( const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple, 12, const_str_plain_MESSAGE_TYPE_SIGNAL ); Py_INCREF( const_str_plain_MESSAGE_TYPE_SIGNAL ); | ||
| 109 | const_str_digest_8f7c3d65be88d740545c0ec6a6afa505 = UNSTREAM_STRING_ASCII( &constant_bin[ 24176 ], 22, 0 ); | ||
| 110 | |||
| 111 | constants_created = true; | ||
| 112 | } | ||
| 113 | |||
| 114 | /* Function to verify module private constants for non-corruption. */ | ||
| 115 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 116 | void checkModuleConstants_dbus$lowlevel( void ) | ||
| 117 | { | ||
| 118 | // The module may not have been used at all, then ignore this. | ||
| 119 | if (constants_created == false) return; | ||
| 120 | |||
| 121 | |||
| 122 | } | ||
| 123 | #endif | ||
| 124 | |||
| 125 | // The module code objects. | ||
| 126 | static PyCodeObject *codeobj_a34357a8183c3a697a9f3724add4d8df; | ||
| 127 | |||
| 128 | static void createModuleCodeObjects(void) | ||
| 129 | { | ||
| 130 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_a2ddffe2dfe813897109cccd49814e19 ); | ||
| 131 | codeobj_a34357a8183c3a697a9f3724add4d8df = MAKE_CODEOBJ( module_filename_obj, const_str_digest_8f7c3d65be88d740545c0ec6a6afa505, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 132 | } | ||
| 133 | |||
| 134 | // The module function declarations. | ||
| 135 | |||
| 136 | |||
| 137 | // The module function definitions. | ||
| 138 | |||
| 139 | |||
| 140 | |||
| 141 | #if PYTHON_VERSION >= 300 | ||
| 142 | static struct PyModuleDef mdef_dbus$lowlevel = | ||
| 143 | { | ||
| 144 | PyModuleDef_HEAD_INIT, | ||
| 145 | "dbus.lowlevel", | ||
| 146 | NULL, /* m_doc */ | ||
| 147 | -1, /* m_size */ | ||
| 148 | NULL, /* m_methods */ | ||
| 149 | NULL, /* m_reload */ | ||
| 150 | NULL, /* m_traverse */ | ||
| 151 | NULL, /* m_clear */ | ||
| 152 | NULL, /* m_free */ | ||
| 153 | }; | ||
| 154 | #endif | ||
| 155 | |||
| 156 | extern PyObject *const_str_plain___compiled__; | ||
| 157 | |||
| 158 | extern PyObject *const_str_plain___package__; | ||
| 159 | |||
| 160 | #if PYTHON_VERSION >= 300 | ||
| 161 | extern PyObject *const_str_dot; | ||
| 162 | extern PyObject *const_str_plain___loader__; | ||
| 163 | #endif | ||
| 164 | |||
| 165 | #if PYTHON_VERSION >= 340 | ||
| 166 | extern PyObject *const_str_plain___spec__; | ||
| 167 | extern PyObject *const_str_plain__initializing; | ||
| 168 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 169 | #endif | ||
| 170 | |||
| 171 | extern void _initCompiledCellType(); | ||
| 172 | extern void _initCompiledGeneratorType(); | ||
| 173 | extern void _initCompiledFunctionType(); | ||
| 174 | extern void _initCompiledMethodType(); | ||
| 175 | extern void _initCompiledFrameType(); | ||
| 176 | #if PYTHON_VERSION >= 350 | ||
| 177 | extern void _initCompiledCoroutineTypes(); | ||
| 178 | #endif | ||
| 179 | #if PYTHON_VERSION >= 360 | ||
| 180 | extern void _initCompiledAsyncgenTypes(); | ||
| 181 | #endif | ||
| 182 | |||
| 183 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 184 | |||
| 185 | // The exported interface to CPython. On import of the module, this function | ||
| 186 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 187 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 188 | |||
| 189 | MOD_INIT_DECL( dbus$lowlevel ) | ||
| 190 | { | ||
| 191 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 192 | static bool _init_done = false; | ||
| 193 | |||
| 194 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 195 | if ( _init_done ) | ||
| 196 | { | ||
| 197 | return MOD_RETURN_VALUE( module_dbus$lowlevel ); | ||
| 198 | } | ||
| 199 | else | ||
| 200 | { | ||
| 201 | _init_done = true; | ||
| 202 | } | ||
| 203 | #endif | ||
| 204 | |||
| 205 | #ifdef _NUITKA_MODULE | ||
| 206 | // In case of a stand alone extension module, need to call initialization | ||
| 207 | // the init here because that's the first and only time we are going to get | ||
| 208 | // called here. | ||
| 209 | |||
| 210 | // Initialize the constant values used. | ||
| 211 | _initBuiltinModule(); | ||
| 212 | createGlobalConstants(); | ||
| 213 | |||
| 214 | /* Initialize the compiled types of Nuitka. */ | ||
| 215 | _initCompiledCellType(); | ||
| 216 | _initCompiledGeneratorType(); | ||
| 217 | _initCompiledFunctionType(); | ||
| 218 | _initCompiledMethodType(); | ||
| 219 | _initCompiledFrameType(); | ||
| 220 | #if PYTHON_VERSION >= 350 | ||
| 221 | _initCompiledCoroutineTypes(); | ||
| 222 | #endif | ||
| 223 | #if PYTHON_VERSION >= 360 | ||
| 224 | _initCompiledAsyncgenTypes(); | ||
| 225 | #endif | ||
| 226 | |||
| 227 | #if PYTHON_VERSION < 300 | ||
| 228 | _initSlotCompare(); | ||
| 229 | #endif | ||
| 230 | #if PYTHON_VERSION >= 270 | ||
| 231 | _initSlotIternext(); | ||
| 232 | #endif | ||
| 233 | |||
| 234 | patchBuiltinModule(); | ||
| 235 | patchTypeComparison(); | ||
| 236 | |||
| 237 | // Enable meta path based loader if not already done. | ||
| 238 | #ifdef _NUITKA_TRACE | ||
| 239 | puts("dbus.lowlevel: Calling setupMetaPathBasedLoader()."); | ||
| 240 | #endif | ||
| 241 | setupMetaPathBasedLoader(); | ||
| 242 | |||
| 243 | #if PYTHON_VERSION >= 300 | ||
| 244 | patchInspectModule(); | ||
| 245 | #endif | ||
| 246 | |||
| 247 | #endif | ||
| 248 | |||
| 249 | /* The constants only used by this module are created now. */ | ||
| 250 | #ifdef _NUITKA_TRACE | ||
| 251 | puts("dbus.lowlevel: Calling createModuleConstants()."); | ||
| 252 | #endif | ||
| 253 | createModuleConstants(); | ||
| 254 | |||
| 255 | /* The code objects used by this module are created now. */ | ||
| 256 | #ifdef _NUITKA_TRACE | ||
| 257 | puts("dbus.lowlevel: Calling createModuleCodeObjects()."); | ||
| 258 | #endif | ||
| 259 | createModuleCodeObjects(); | ||
| 260 | |||
| 261 | // puts( "in initdbus$lowlevel" ); | ||
| 262 | |||
| 263 | // Create the module object first. There are no methods initially, all are | ||
| 264 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 265 | // set at this time, as it could not contain NUL characters this way, they | ||
| 266 | // are instead set in early module code. No "self" for modules, we have no | ||
| 267 | // use for it. | ||
| 268 | #if PYTHON_VERSION < 300 | ||
| 269 | module_dbus$lowlevel = Py_InitModule4( | ||
| 270 | "dbus.lowlevel", // Module Name | ||
| 271 | NULL, // No methods initially, all are added | ||
| 272 | // dynamically in actual module code only. | ||
| 273 | NULL, // No "__doc__" is initially set, as it could | ||
| 274 | // not contain NUL this way, added early in | ||
| 275 | // actual code. | ||
| 276 | NULL, // No self for modules, we don't use it. | ||
| 277 | PYTHON_API_VERSION | ||
| 278 | ); | ||
| 279 | #else | ||
| 280 | |||
| 281 | module_dbus$lowlevel = PyModule_Create( &mdef_dbus$lowlevel ); | ||
| 282 | #endif | ||
| 283 | |||
| 284 | moduledict_dbus$lowlevel = MODULE_DICT( module_dbus$lowlevel ); | ||
| 285 | |||
| 286 | // Set __compiled__ to what it we know. | ||
| 287 | UPDATE_STRING_DICT1( | ||
| 288 | moduledict_dbus$lowlevel, | ||
| 289 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 290 | Nuitka_dunder_compiled_value | ||
| 291 | ); | ||
| 292 | |||
| 293 | // Update "__package__" value to what it ought to be. | ||
| 294 | { | ||
| 295 | #if 0 | ||
| 296 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 297 | |||
| 298 | UPDATE_STRING_DICT1( | ||
| 299 | moduledict_dbus$lowlevel, | ||
| 300 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 301 | module_name | ||
| 302 | ); | ||
| 303 | #else | ||
| 304 | |||
| 305 | #if PYTHON_VERSION < 300 | ||
| 306 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 307 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 308 | |||
| 309 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 310 | |||
| 311 | if ( last_dot != NULL ) | ||
| 312 | { | ||
| 313 | UPDATE_STRING_DICT1( | ||
| 314 | moduledict_dbus$lowlevel, | ||
| 315 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 316 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 317 | ); | ||
| 318 | } | ||
| 319 | #else | ||
| 320 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 321 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 322 | |||
| 323 | if ( dot_index != -1 ) | ||
| 324 | { | ||
| 325 | UPDATE_STRING_DICT1( | ||
| 326 | moduledict_dbus$lowlevel, | ||
| 327 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 328 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 329 | ); | ||
| 330 | } | ||
| 331 | #endif | ||
| 332 | #endif | ||
| 333 | } | ||
| 334 | |||
| 335 | CHECK_OBJECT( module_dbus$lowlevel ); | ||
| 336 | |||
| 337 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 338 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 339 | #if PYTHON_VERSION >= 300 | ||
| 340 | { | ||
| 341 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_b45a3c6f685a3991de51197626bab5ca, module_dbus$lowlevel ); | ||
| 342 | |||
| 343 | assert( r != -1 ); | ||
| 344 | } | ||
| 345 | #endif | ||
| 346 | |||
| 347 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 348 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 349 | // before the frame object is allocated, or else it may fail. | ||
| 350 | |||
| 351 | if ( GET_STRING_DICT_VALUE( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 352 | { | ||
| 353 | PyObject *value = (PyObject *)builtin_module; | ||
| 354 | |||
| 355 | // Check if main module, not a dict then but the module itself. | ||
| 356 | #if !defined(_NUITKA_EXE) || !0 | ||
| 357 | value = PyModule_GetDict( value ); | ||
| 358 | #endif | ||
| 359 | |||
| 360 | UPDATE_STRING_DICT0( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 361 | } | ||
| 362 | |||
| 363 | #if PYTHON_VERSION >= 300 | ||
| 364 | UPDATE_STRING_DICT0( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 365 | #endif | ||
| 366 | |||
| 367 | #if PYTHON_VERSION >= 340 | ||
| 368 | // Set the "__spec__" value | ||
| 369 | |||
| 370 | #if 0 | ||
| 371 | // Main modules just get "None" as spec. | ||
| 372 | UPDATE_STRING_DICT0( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 373 | #else | ||
| 374 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 375 | { | ||
| 376 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 377 | CHECK_OBJECT( bootstrap_module ); | ||
| 378 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 379 | Py_DECREF( bootstrap_module ); | ||
| 380 | |||
| 381 | PyObject *args[] = { | ||
| 382 | GET_STRING_DICT_VALUE( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 383 | (PyObject *)&Nuitka_Loader_Type | ||
| 384 | }; | ||
| 385 | |||
| 386 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 387 | module_spec_class, | ||
| 388 | args | ||
| 389 | ); | ||
| 390 | Py_DECREF( module_spec_class ); | ||
| 391 | |||
| 392 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 393 | CHECK_OBJECT( spec_value ); | ||
| 394 | |||
| 395 | // For packages set the submodule search locations as well, even if to empty | ||
| 396 | // list, so investigating code will consider it a package. | ||
| 397 | #if 0 | ||
| 398 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 399 | #endif | ||
| 400 | |||
| 401 | // Mark the execution in the "__spec__" value. | ||
| 402 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 403 | |||
| 404 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 405 | } | ||
| 406 | #endif | ||
| 407 | #endif | ||
| 408 | |||
| 409 | // Temp variables if any | ||
| 410 | PyObject *tmp_import_from_1__module = NULL; | ||
| 411 | struct Nuitka_FrameObject *frame_a34357a8183c3a697a9f3724add4d8df; | ||
| 412 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 413 | bool tmp_result; | ||
| 414 | PyObject *exception_type = NULL; | ||
| 415 | PyObject *exception_value = NULL; | ||
| 416 | PyTracebackObject *exception_tb = NULL; | ||
| 417 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 418 | PyObject *exception_keeper_type_1; | ||
| 419 | PyObject *exception_keeper_value_1; | ||
| 420 | PyTracebackObject *exception_keeper_tb_1; | ||
| 421 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 422 | |||
| 423 | // Module code. | ||
| 424 | { | ||
| 425 | PyObject *tmp_assign_source_1; | ||
| 426 | tmp_assign_source_1 = const_str_digest_afdcdbdc0b31ee1d41f080da9a68df5a; | ||
| 427 | UPDATE_STRING_DICT0( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 428 | } | ||
| 429 | { | ||
| 430 | PyObject *tmp_assign_source_2; | ||
| 431 | tmp_assign_source_2 = module_filename_obj; | ||
| 432 | UPDATE_STRING_DICT0( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 433 | } | ||
| 434 | // Frame without reuse. | ||
| 435 | frame_a34357a8183c3a697a9f3724add4d8df = MAKE_MODULE_FRAME( codeobj_a34357a8183c3a697a9f3724add4d8df, module_dbus$lowlevel ); | ||
| 436 | |||
| 437 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 438 | // owning it. | ||
| 439 | pushFrameStack( frame_a34357a8183c3a697a9f3724add4d8df ); | ||
| 440 | assert( Py_REFCNT( frame_a34357a8183c3a697a9f3724add4d8df ) == 2 ); | ||
| 441 | |||
| 442 | // Framed code: | ||
| 443 | { | ||
| 444 | PyObject *tmp_assattr_name_1; | ||
| 445 | PyObject *tmp_assattr_target_1; | ||
| 446 | PyObject *tmp_mvar_value_1; | ||
| 447 | tmp_assattr_name_1 = module_filename_obj; | ||
| 448 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 449 | |||
| 450 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 451 | { | ||
| 452 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 453 | } | ||
| 454 | |||
| 455 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 456 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 457 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 458 | if ( tmp_result == false ) | ||
| 459 | { | ||
| 460 | assert( ERROR_OCCURRED() ); | ||
| 461 | |||
| 462 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 463 | |||
| 464 | |||
| 465 | exception_lineno = 1; | ||
| 466 | |||
| 467 | goto frame_exception_exit_1; | ||
| 468 | } | ||
| 469 | } | ||
| 470 | { | ||
| 471 | PyObject *tmp_assattr_name_2; | ||
| 472 | PyObject *tmp_assattr_target_2; | ||
| 473 | PyObject *tmp_mvar_value_2; | ||
| 474 | tmp_assattr_name_2 = Py_True; | ||
| 475 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 476 | |||
| 477 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 478 | { | ||
| 479 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 480 | } | ||
| 481 | |||
| 482 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 483 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 484 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 485 | if ( tmp_result == false ) | ||
| 486 | { | ||
| 487 | assert( ERROR_OCCURRED() ); | ||
| 488 | |||
| 489 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 490 | |||
| 491 | |||
| 492 | exception_lineno = 1; | ||
| 493 | |||
| 494 | goto frame_exception_exit_1; | ||
| 495 | } | ||
| 496 | } | ||
| 497 | { | ||
| 498 | PyObject *tmp_assign_source_3; | ||
| 499 | tmp_assign_source_3 = Py_None; | ||
| 500 | UPDATE_STRING_DICT0( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 501 | } | ||
| 502 | { | ||
| 503 | PyObject *tmp_assign_source_4; | ||
| 504 | tmp_assign_source_4 = const_tuple_0cc064e892ddbf5073e588da27fc9d13_tuple; | ||
| 505 | UPDATE_STRING_DICT0( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___all__, tmp_assign_source_4 ); | ||
| 506 | } | ||
| 507 | { | ||
| 508 | PyObject *tmp_assign_source_5; | ||
| 509 | PyObject *tmp_name_name_1; | ||
| 510 | PyObject *tmp_globals_name_1; | ||
| 511 | PyObject *tmp_locals_name_1; | ||
| 512 | PyObject *tmp_fromlist_name_1; | ||
| 513 | PyObject *tmp_level_name_1; | ||
| 514 | tmp_name_name_1 = const_str_plain__dbus_bindings; | ||
| 515 | tmp_globals_name_1 = (PyObject *)moduledict_dbus$lowlevel; | ||
| 516 | tmp_locals_name_1 = Py_None; | ||
| 517 | tmp_fromlist_name_1 = const_tuple_491d884195767fc6bbf76933ebfa602c_tuple; | ||
| 518 | tmp_level_name_1 = const_int_0; | ||
| 519 | frame_a34357a8183c3a697a9f3724add4d8df->m_frame.f_lineno = 32; | ||
| 520 | tmp_assign_source_5 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 521 | if ( tmp_assign_source_5 == NULL ) | ||
| 522 | { | ||
| 523 | assert( ERROR_OCCURRED() ); | ||
| 524 | |||
| 525 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 526 | |||
| 527 | |||
| 528 | exception_lineno = 32; | ||
| 529 | |||
| 530 | goto frame_exception_exit_1; | ||
| 531 | } | ||
| 532 | assert( tmp_import_from_1__module == NULL ); | ||
| 533 | tmp_import_from_1__module = tmp_assign_source_5; | ||
| 534 | } | ||
| 535 | // Tried code: | ||
| 536 | { | ||
| 537 | PyObject *tmp_assign_source_6; | ||
| 538 | PyObject *tmp_import_name_from_1; | ||
| 539 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 540 | tmp_import_name_from_1 = tmp_import_from_1__module; | ||
| 541 | tmp_assign_source_6 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_ErrorMessage ); | ||
| 542 | if ( tmp_assign_source_6 == NULL ) | ||
| 543 | { | ||
| 544 | assert( ERROR_OCCURRED() ); | ||
| 545 | |||
| 546 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 547 | |||
| 548 | |||
| 549 | exception_lineno = 32; | ||
| 550 | |||
| 551 | goto try_except_handler_1; | ||
| 552 | } | ||
| 553 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_ErrorMessage, tmp_assign_source_6 ); | ||
| 554 | } | ||
| 555 | { | ||
| 556 | PyObject *tmp_assign_source_7; | ||
| 557 | PyObject *tmp_import_name_from_2; | ||
| 558 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 559 | tmp_import_name_from_2 = tmp_import_from_1__module; | ||
| 560 | tmp_assign_source_7 = IMPORT_NAME( tmp_import_name_from_2, const_str_plain_HANDLER_RESULT_HANDLED ); | ||
| 561 | if ( tmp_assign_source_7 == NULL ) | ||
| 562 | { | ||
| 563 | assert( ERROR_OCCURRED() ); | ||
| 564 | |||
| 565 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 566 | |||
| 567 | |||
| 568 | exception_lineno = 32; | ||
| 569 | |||
| 570 | goto try_except_handler_1; | ||
| 571 | } | ||
| 572 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_HANDLER_RESULT_HANDLED, tmp_assign_source_7 ); | ||
| 573 | } | ||
| 574 | { | ||
| 575 | PyObject *tmp_assign_source_8; | ||
| 576 | PyObject *tmp_import_name_from_3; | ||
| 577 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 578 | tmp_import_name_from_3 = tmp_import_from_1__module; | ||
| 579 | tmp_assign_source_8 = IMPORT_NAME( tmp_import_name_from_3, const_str_plain_HANDLER_RESULT_NOT_YET_HANDLED ); | ||
| 580 | if ( tmp_assign_source_8 == NULL ) | ||
| 581 | { | ||
| 582 | assert( ERROR_OCCURRED() ); | ||
| 583 | |||
| 584 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 585 | |||
| 586 | |||
| 587 | exception_lineno = 32; | ||
| 588 | |||
| 589 | goto try_except_handler_1; | ||
| 590 | } | ||
| 591 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_HANDLER_RESULT_NOT_YET_HANDLED, tmp_assign_source_8 ); | ||
| 592 | } | ||
| 593 | { | ||
| 594 | PyObject *tmp_assign_source_9; | ||
| 595 | PyObject *tmp_import_name_from_4; | ||
| 596 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 597 | tmp_import_name_from_4 = tmp_import_from_1__module; | ||
| 598 | tmp_assign_source_9 = IMPORT_NAME( tmp_import_name_from_4, const_str_plain_MESSAGE_TYPE_ERROR ); | ||
| 599 | if ( tmp_assign_source_9 == NULL ) | ||
| 600 | { | ||
| 601 | assert( ERROR_OCCURRED() ); | ||
| 602 | |||
| 603 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 604 | |||
| 605 | |||
| 606 | exception_lineno = 32; | ||
| 607 | |||
| 608 | goto try_except_handler_1; | ||
| 609 | } | ||
| 610 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_MESSAGE_TYPE_ERROR, tmp_assign_source_9 ); | ||
| 611 | } | ||
| 612 | { | ||
| 613 | PyObject *tmp_assign_source_10; | ||
| 614 | PyObject *tmp_import_name_from_5; | ||
| 615 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 616 | tmp_import_name_from_5 = tmp_import_from_1__module; | ||
| 617 | tmp_assign_source_10 = IMPORT_NAME( tmp_import_name_from_5, const_str_plain_MESSAGE_TYPE_INVALID ); | ||
| 618 | if ( tmp_assign_source_10 == NULL ) | ||
| 619 | { | ||
| 620 | assert( ERROR_OCCURRED() ); | ||
| 621 | |||
| 622 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 623 | |||
| 624 | |||
| 625 | exception_lineno = 32; | ||
| 626 | |||
| 627 | goto try_except_handler_1; | ||
| 628 | } | ||
| 629 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_MESSAGE_TYPE_INVALID, tmp_assign_source_10 ); | ||
| 630 | } | ||
| 631 | { | ||
| 632 | PyObject *tmp_assign_source_11; | ||
| 633 | PyObject *tmp_import_name_from_6; | ||
| 634 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 635 | tmp_import_name_from_6 = tmp_import_from_1__module; | ||
| 636 | tmp_assign_source_11 = IMPORT_NAME( tmp_import_name_from_6, const_str_plain_MESSAGE_TYPE_METHOD_CALL ); | ||
| 637 | if ( tmp_assign_source_11 == NULL ) | ||
| 638 | { | ||
| 639 | assert( ERROR_OCCURRED() ); | ||
| 640 | |||
| 641 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 642 | |||
| 643 | |||
| 644 | exception_lineno = 32; | ||
| 645 | |||
| 646 | goto try_except_handler_1; | ||
| 647 | } | ||
| 648 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_MESSAGE_TYPE_METHOD_CALL, tmp_assign_source_11 ); | ||
| 649 | } | ||
| 650 | { | ||
| 651 | PyObject *tmp_assign_source_12; | ||
| 652 | PyObject *tmp_import_name_from_7; | ||
| 653 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 654 | tmp_import_name_from_7 = tmp_import_from_1__module; | ||
| 655 | tmp_assign_source_12 = IMPORT_NAME( tmp_import_name_from_7, const_str_plain_MESSAGE_TYPE_METHOD_RETURN ); | ||
| 656 | if ( tmp_assign_source_12 == NULL ) | ||
| 657 | { | ||
| 658 | assert( ERROR_OCCURRED() ); | ||
| 659 | |||
| 660 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 661 | |||
| 662 | |||
| 663 | exception_lineno = 32; | ||
| 664 | |||
| 665 | goto try_except_handler_1; | ||
| 666 | } | ||
| 667 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_MESSAGE_TYPE_METHOD_RETURN, tmp_assign_source_12 ); | ||
| 668 | } | ||
| 669 | { | ||
| 670 | PyObject *tmp_assign_source_13; | ||
| 671 | PyObject *tmp_import_name_from_8; | ||
| 672 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 673 | tmp_import_name_from_8 = tmp_import_from_1__module; | ||
| 674 | tmp_assign_source_13 = IMPORT_NAME( tmp_import_name_from_8, const_str_plain_MESSAGE_TYPE_SIGNAL ); | ||
| 675 | if ( tmp_assign_source_13 == NULL ) | ||
| 676 | { | ||
| 677 | assert( ERROR_OCCURRED() ); | ||
| 678 | |||
| 679 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 680 | |||
| 681 | |||
| 682 | exception_lineno = 32; | ||
| 683 | |||
| 684 | goto try_except_handler_1; | ||
| 685 | } | ||
| 686 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_MESSAGE_TYPE_SIGNAL, tmp_assign_source_13 ); | ||
| 687 | } | ||
| 688 | { | ||
| 689 | PyObject *tmp_assign_source_14; | ||
| 690 | PyObject *tmp_import_name_from_9; | ||
| 691 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 692 | tmp_import_name_from_9 = tmp_import_from_1__module; | ||
| 693 | tmp_assign_source_14 = IMPORT_NAME( tmp_import_name_from_9, const_str_plain_Message ); | ||
| 694 | if ( tmp_assign_source_14 == NULL ) | ||
| 695 | { | ||
| 696 | assert( ERROR_OCCURRED() ); | ||
| 697 | |||
| 698 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 699 | |||
| 700 | |||
| 701 | exception_lineno = 32; | ||
| 702 | |||
| 703 | goto try_except_handler_1; | ||
| 704 | } | ||
| 705 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_Message, tmp_assign_source_14 ); | ||
| 706 | } | ||
| 707 | { | ||
| 708 | PyObject *tmp_assign_source_15; | ||
| 709 | PyObject *tmp_import_name_from_10; | ||
| 710 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 711 | tmp_import_name_from_10 = tmp_import_from_1__module; | ||
| 712 | tmp_assign_source_15 = IMPORT_NAME( tmp_import_name_from_10, const_str_plain_MethodCallMessage ); | ||
| 713 | if ( tmp_assign_source_15 == NULL ) | ||
| 714 | { | ||
| 715 | assert( ERROR_OCCURRED() ); | ||
| 716 | |||
| 717 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 718 | |||
| 719 | |||
| 720 | exception_lineno = 32; | ||
| 721 | |||
| 722 | goto try_except_handler_1; | ||
| 723 | } | ||
| 724 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_MethodCallMessage, tmp_assign_source_15 ); | ||
| 725 | } | ||
| 726 | { | ||
| 727 | PyObject *tmp_assign_source_16; | ||
| 728 | PyObject *tmp_import_name_from_11; | ||
| 729 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 730 | tmp_import_name_from_11 = tmp_import_from_1__module; | ||
| 731 | tmp_assign_source_16 = IMPORT_NAME( tmp_import_name_from_11, const_str_plain_MethodReturnMessage ); | ||
| 732 | if ( tmp_assign_source_16 == NULL ) | ||
| 733 | { | ||
| 734 | assert( ERROR_OCCURRED() ); | ||
| 735 | |||
| 736 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 737 | |||
| 738 | |||
| 739 | exception_lineno = 32; | ||
| 740 | |||
| 741 | goto try_except_handler_1; | ||
| 742 | } | ||
| 743 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_MethodReturnMessage, tmp_assign_source_16 ); | ||
| 744 | } | ||
| 745 | { | ||
| 746 | PyObject *tmp_assign_source_17; | ||
| 747 | PyObject *tmp_import_name_from_12; | ||
| 748 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 749 | tmp_import_name_from_12 = tmp_import_from_1__module; | ||
| 750 | tmp_assign_source_17 = IMPORT_NAME( tmp_import_name_from_12, const_str_plain_PendingCall ); | ||
| 751 | if ( tmp_assign_source_17 == NULL ) | ||
| 752 | { | ||
| 753 | assert( ERROR_OCCURRED() ); | ||
| 754 | |||
| 755 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 756 | |||
| 757 | |||
| 758 | exception_lineno = 32; | ||
| 759 | |||
| 760 | goto try_except_handler_1; | ||
| 761 | } | ||
| 762 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_PendingCall, tmp_assign_source_17 ); | ||
| 763 | } | ||
| 764 | { | ||
| 765 | PyObject *tmp_assign_source_18; | ||
| 766 | PyObject *tmp_import_name_from_13; | ||
| 767 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 768 | tmp_import_name_from_13 = tmp_import_from_1__module; | ||
| 769 | tmp_assign_source_18 = IMPORT_NAME( tmp_import_name_from_13, const_str_plain_SignalMessage ); | ||
| 770 | if ( tmp_assign_source_18 == NULL ) | ||
| 771 | { | ||
| 772 | assert( ERROR_OCCURRED() ); | ||
| 773 | |||
| 774 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 775 | |||
| 776 | |||
| 777 | exception_lineno = 32; | ||
| 778 | |||
| 779 | goto try_except_handler_1; | ||
| 780 | } | ||
| 781 | UPDATE_STRING_DICT1( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain_SignalMessage, tmp_assign_source_18 ); | ||
| 782 | } | ||
| 783 | goto try_end_1; | ||
| 784 | // Exception handler code: | ||
| 785 | try_except_handler_1:; | ||
| 786 | exception_keeper_type_1 = exception_type; | ||
| 787 | exception_keeper_value_1 = exception_value; | ||
| 788 | exception_keeper_tb_1 = exception_tb; | ||
| 789 | exception_keeper_lineno_1 = exception_lineno; | ||
| 790 | exception_type = NULL; | ||
| 791 | exception_value = NULL; | ||
| 792 | exception_tb = NULL; | ||
| 793 | exception_lineno = 0; | ||
| 794 | |||
| 795 | CHECK_OBJECT( (PyObject *)tmp_import_from_1__module ); | ||
| 796 | Py_DECREF( tmp_import_from_1__module ); | ||
| 797 | tmp_import_from_1__module = NULL; | ||
| 798 | |||
| 799 | // Re-raise. | ||
| 800 | exception_type = exception_keeper_type_1; | ||
| 801 | exception_value = exception_keeper_value_1; | ||
| 802 | exception_tb = exception_keeper_tb_1; | ||
| 803 | exception_lineno = exception_keeper_lineno_1; | ||
| 804 | |||
| 805 | goto frame_exception_exit_1; | ||
| 806 | // End of try: | ||
| 807 | try_end_1:; | ||
| 808 | |||
| 809 | // Restore frame exception if necessary. | ||
| 810 | #if 0 | ||
| 811 | RESTORE_FRAME_EXCEPTION( frame_a34357a8183c3a697a9f3724add4d8df ); | ||
| 812 | #endif | ||
| 813 | popFrameStack(); | ||
| 814 | |||
| 815 | assertFrameObject( frame_a34357a8183c3a697a9f3724add4d8df ); | ||
| 816 | |||
| 817 | goto frame_no_exception_1; | ||
| 818 | |||
| 819 | frame_exception_exit_1:; | ||
| 820 | #if 0 | ||
| 821 | RESTORE_FRAME_EXCEPTION( frame_a34357a8183c3a697a9f3724add4d8df ); | ||
| 822 | #endif | ||
| 823 | |||
| 824 | if ( exception_tb == NULL ) | ||
| 825 | { | ||
| 826 | exception_tb = MAKE_TRACEBACK( frame_a34357a8183c3a697a9f3724add4d8df, exception_lineno ); | ||
| 827 | } | ||
| 828 | else if ( exception_tb->tb_frame != &frame_a34357a8183c3a697a9f3724add4d8df->m_frame ) | ||
| 829 | { | ||
| 830 | exception_tb = ADD_TRACEBACK( exception_tb, frame_a34357a8183c3a697a9f3724add4d8df, exception_lineno ); | ||
| 831 | } | ||
| 832 | |||
| 833 | // Put the previous frame back on top. | ||
| 834 | popFrameStack(); | ||
| 835 | |||
| 836 | // Return the error. | ||
| 837 | goto module_exception_exit; | ||
| 838 | |||
| 839 | frame_no_exception_1:; | ||
| 840 | CHECK_OBJECT( (PyObject *)tmp_import_from_1__module ); | ||
| 841 | Py_DECREF( tmp_import_from_1__module ); | ||
| 842 | tmp_import_from_1__module = NULL; | ||
| 843 | |||
| 844 | |||
| 845 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 846 | #if 0 && 0 | ||
| 847 | { | ||
| 848 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_dbus$lowlevel, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 849 | |||
| 850 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 851 | { | ||
| 852 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 853 | |||
| 854 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 855 | CHECK_OBJECT( path_importer_cache ); | ||
| 856 | |||
| 857 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 858 | assert( res == 0 ); | ||
| 859 | } | ||
| 860 | } | ||
| 861 | #endif | ||
| 862 | #endif | ||
| 863 | |||
| 864 | return MOD_RETURN_VALUE( module_dbus$lowlevel ); | ||
| 865 | module_exception_exit: | ||
| 866 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 867 | return MOD_RETURN_VALUE( NULL ); | ||
| 868 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.dbus.lowlevel.o deleted (index 983f144..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.dbus.mainloop.c deleted (index 730a051..0000000) | |||
| 1 | /* Generated code for Python module 'dbus.mainloop' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_dbus$mainloop" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_dbus$mainloop; | ||
| 31 | PyDictObject *moduledict_dbus$mainloop; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | static PyObject *const_str_plain_NULL_MAIN_LOOP; | ||
| 35 | extern PyObject *const_str_plain_environ; | ||
| 36 | extern PyObject *const_str_plain___spec__; | ||
| 37 | static PyObject *const_str_digest_92a976c4650920ff5ed374c559207e27; | ||
| 38 | static PyObject *const_tuple_1e0b2627de80cd15cd2a2707b4a50786_tuple; | ||
| 39 | extern PyObject *const_str_plain_glib; | ||
| 40 | extern PyObject *const_str_plain___all__; | ||
| 41 | static PyObject *const_str_plain_NUITKA_PACKAGE_dbus_mainloop; | ||
| 42 | static PyObject *const_str_plain_NativeMainLoop; | ||
| 43 | extern PyObject *const_tuple_c05661dc311559e0338d3f9170078d6a_tuple; | ||
| 44 | extern PyObject *const_str_plain___file__; | ||
| 45 | extern PyObject *const_str_plain__dbus_bindings; | ||
| 46 | extern PyObject *const_str_plain_path; | ||
| 47 | extern PyObject *const_int_0; | ||
| 48 | static PyObject *const_tuple_e491f74580763f43a808aa077c589175_tuple; | ||
| 49 | static PyObject *const_str_plain_WATCH_WRITABLE; | ||
| 50 | static PyObject *const_str_digest_ca885d114683883351fa5ece16bd8151; | ||
| 51 | extern PyObject *const_str_plain_origin; | ||
| 52 | extern PyObject *const_str_digest_5bfaf90dbd407b4fc29090c8f6415242; | ||
| 53 | static PyObject *const_str_plain_WATCH_HANGUP; | ||
| 54 | extern PyObject *const_str_plain___path__; | ||
| 55 | extern PyObject *const_tuple_empty; | ||
| 56 | extern PyObject *const_str_plain_get; | ||
| 57 | static PyObject *const_str_digest_94de7b62cb5a27fd11e76113d9dbc77e; | ||
| 58 | extern PyObject *const_str_plain_has_location; | ||
| 59 | static PyObject *const_str_plain_WATCH_READABLE; | ||
| 60 | extern PyObject *const_str_plain_join; | ||
| 61 | extern PyObject *const_str_plain_dirname; | ||
| 62 | extern PyObject *const_str_plain_mainloop; | ||
| 63 | static PyObject *const_str_digest_2f41de8910a532e6dd306f7ed285a991; | ||
| 64 | extern PyObject *const_str_plain___doc__; | ||
| 65 | extern PyObject *const_str_plain___cached__; | ||
| 66 | extern PyObject *const_str_plain_NUITKA_PACKAGE_dbus; | ||
| 67 | static PyObject *const_str_plain_WATCH_ERROR; | ||
| 68 | static PyObject *module_filename_obj; | ||
| 69 | |||
| 70 | /* Indicator if this modules private constants were created yet. */ | ||
| 71 | static bool constants_created = false; | ||
| 72 | |||
| 73 | /* Function to create module private constants. */ | ||
| 74 | static void createModuleConstants( void ) | ||
| 75 | { | ||
| 76 | const_str_plain_NULL_MAIN_LOOP = UNSTREAM_STRING_ASCII( &constant_bin[ 24198 ], 14, 1 ); | ||
| 77 | const_str_digest_92a976c4650920ff5ed374c559207e27 = UNSTREAM_STRING_ASCII( &constant_bin[ 24212 ], 25, 0 ); | ||
| 78 | const_tuple_1e0b2627de80cd15cd2a2707b4a50786_tuple = PyTuple_New( 2 ); | ||
| 79 | const_str_plain_NUITKA_PACKAGE_dbus_mainloop = UNSTREAM_STRING_ASCII( &constant_bin[ 24237 ], 28, 1 ); | ||
| 80 | PyTuple_SET_ITEM( const_tuple_1e0b2627de80cd15cd2a2707b4a50786_tuple, 0, const_str_plain_NUITKA_PACKAGE_dbus_mainloop ); Py_INCREF( const_str_plain_NUITKA_PACKAGE_dbus_mainloop ); | ||
| 81 | PyTuple_SET_ITEM( const_tuple_1e0b2627de80cd15cd2a2707b4a50786_tuple, 1, const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); Py_INCREF( const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); | ||
| 82 | const_str_plain_NativeMainLoop = UNSTREAM_STRING_ASCII( &constant_bin[ 4568 ], 14, 1 ); | ||
| 83 | const_tuple_e491f74580763f43a808aa077c589175_tuple = PyTuple_New( 7 ); | ||
| 84 | PyTuple_SET_ITEM( const_tuple_e491f74580763f43a808aa077c589175_tuple, 0, const_str_plain_NativeMainLoop ); Py_INCREF( const_str_plain_NativeMainLoop ); | ||
| 85 | const_str_plain_WATCH_READABLE = UNSTREAM_STRING_ASCII( &constant_bin[ 24265 ], 14, 1 ); | ||
| 86 | PyTuple_SET_ITEM( const_tuple_e491f74580763f43a808aa077c589175_tuple, 1, const_str_plain_WATCH_READABLE ); Py_INCREF( const_str_plain_WATCH_READABLE ); | ||
| 87 | const_str_plain_WATCH_WRITABLE = UNSTREAM_STRING_ASCII( &constant_bin[ 24279 ], 14, 1 ); | ||
| 88 | PyTuple_SET_ITEM( const_tuple_e491f74580763f43a808aa077c589175_tuple, 2, const_str_plain_WATCH_WRITABLE ); Py_INCREF( const_str_plain_WATCH_WRITABLE ); | ||
| 89 | const_str_plain_WATCH_HANGUP = UNSTREAM_STRING_ASCII( &constant_bin[ 24293 ], 12, 1 ); | ||
| 90 | PyTuple_SET_ITEM( const_tuple_e491f74580763f43a808aa077c589175_tuple, 3, const_str_plain_WATCH_HANGUP ); Py_INCREF( const_str_plain_WATCH_HANGUP ); | ||
| 91 | const_str_plain_WATCH_ERROR = UNSTREAM_STRING_ASCII( &constant_bin[ 24305 ], 11, 1 ); | ||
| 92 | PyTuple_SET_ITEM( const_tuple_e491f74580763f43a808aa077c589175_tuple, 4, const_str_plain_WATCH_ERROR ); Py_INCREF( const_str_plain_WATCH_ERROR ); | ||
| 93 | PyTuple_SET_ITEM( const_tuple_e491f74580763f43a808aa077c589175_tuple, 5, const_str_plain_NULL_MAIN_LOOP ); Py_INCREF( const_str_plain_NULL_MAIN_LOOP ); | ||
| 94 | PyTuple_SET_ITEM( const_tuple_e491f74580763f43a808aa077c589175_tuple, 6, const_str_plain_glib ); Py_INCREF( const_str_plain_glib ); | ||
| 95 | const_str_digest_ca885d114683883351fa5ece16bd8151 = UNSTREAM_STRING_ASCII( &constant_bin[ 24316 ], 51, 0 ); | ||
| 96 | const_str_digest_94de7b62cb5a27fd11e76113d9dbc77e = UNSTREAM_STRING_ASCII( &constant_bin[ 4554 ], 13, 0 ); | ||
| 97 | const_str_digest_2f41de8910a532e6dd306f7ed285a991 = UNSTREAM_STRING_ASCII( &constant_bin[ 24367 ], 22, 0 ); | ||
| 98 | |||
| 99 | constants_created = true; | ||
| 100 | } | ||
| 101 | |||
| 102 | /* Function to verify module private constants for non-corruption. */ | ||
| 103 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 104 | void checkModuleConstants_dbus$mainloop( void ) | ||
| 105 | { | ||
| 106 | // The module may not have been used at all, then ignore this. | ||
| 107 | if (constants_created == false) return; | ||
| 108 | |||
| 109 | |||
| 110 | } | ||
| 111 | #endif | ||
| 112 | |||
| 113 | // The module code objects. | ||
| 114 | static PyCodeObject *codeobj_f0e529667230d2c7e78349df985d2fda; | ||
| 115 | |||
| 116 | static void createModuleCodeObjects(void) | ||
| 117 | { | ||
| 118 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_92a976c4650920ff5ed374c559207e27 ); | ||
| 119 | codeobj_f0e529667230d2c7e78349df985d2fda = MAKE_CODEOBJ( module_filename_obj, const_str_digest_2f41de8910a532e6dd306f7ed285a991, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 120 | } | ||
| 121 | |||
| 122 | // The module function declarations. | ||
| 123 | |||
| 124 | |||
| 125 | // The module function definitions. | ||
| 126 | |||
| 127 | |||
| 128 | |||
| 129 | #if PYTHON_VERSION >= 300 | ||
| 130 | static struct PyModuleDef mdef_dbus$mainloop = | ||
| 131 | { | ||
| 132 | PyModuleDef_HEAD_INIT, | ||
| 133 | "dbus.mainloop", | ||
| 134 | NULL, /* m_doc */ | ||
| 135 | -1, /* m_size */ | ||
| 136 | NULL, /* m_methods */ | ||
| 137 | NULL, /* m_reload */ | ||
| 138 | NULL, /* m_traverse */ | ||
| 139 | NULL, /* m_clear */ | ||
| 140 | NULL, /* m_free */ | ||
| 141 | }; | ||
| 142 | #endif | ||
| 143 | |||
| 144 | extern PyObject *const_str_plain___compiled__; | ||
| 145 | |||
| 146 | extern PyObject *const_str_plain___package__; | ||
| 147 | |||
| 148 | #if PYTHON_VERSION >= 300 | ||
| 149 | extern PyObject *const_str_dot; | ||
| 150 | extern PyObject *const_str_plain___loader__; | ||
| 151 | #endif | ||
| 152 | |||
| 153 | #if PYTHON_VERSION >= 340 | ||
| 154 | extern PyObject *const_str_plain___spec__; | ||
| 155 | extern PyObject *const_str_plain__initializing; | ||
| 156 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 157 | #endif | ||
| 158 | |||
| 159 | extern void _initCompiledCellType(); | ||
| 160 | extern void _initCompiledGeneratorType(); | ||
| 161 | extern void _initCompiledFunctionType(); | ||
| 162 | extern void _initCompiledMethodType(); | ||
| 163 | extern void _initCompiledFrameType(); | ||
| 164 | #if PYTHON_VERSION >= 350 | ||
| 165 | extern void _initCompiledCoroutineTypes(); | ||
| 166 | #endif | ||
| 167 | #if PYTHON_VERSION >= 360 | ||
| 168 | extern void _initCompiledAsyncgenTypes(); | ||
| 169 | #endif | ||
| 170 | |||
| 171 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 172 | |||
| 173 | // The exported interface to CPython. On import of the module, this function | ||
| 174 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 175 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 176 | |||
| 177 | MOD_INIT_DECL( dbus$mainloop ) | ||
| 178 | { | ||
| 179 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 180 | static bool _init_done = false; | ||
| 181 | |||
| 182 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 183 | if ( _init_done ) | ||
| 184 | { | ||
| 185 | return MOD_RETURN_VALUE( module_dbus$mainloop ); | ||
| 186 | } | ||
| 187 | else | ||
| 188 | { | ||
| 189 | _init_done = true; | ||
| 190 | } | ||
| 191 | #endif | ||
| 192 | |||
| 193 | #ifdef _NUITKA_MODULE | ||
| 194 | // In case of a stand alone extension module, need to call initialization | ||
| 195 | // the init here because that's the first and only time we are going to get | ||
| 196 | // called here. | ||
| 197 | |||
| 198 | // Initialize the constant values used. | ||
| 199 | _initBuiltinModule(); | ||
| 200 | createGlobalConstants(); | ||
| 201 | |||
| 202 | /* Initialize the compiled types of Nuitka. */ | ||
| 203 | _initCompiledCellType(); | ||
| 204 | _initCompiledGeneratorType(); | ||
| 205 | _initCompiledFunctionType(); | ||
| 206 | _initCompiledMethodType(); | ||
| 207 | _initCompiledFrameType(); | ||
| 208 | #if PYTHON_VERSION >= 350 | ||
| 209 | _initCompiledCoroutineTypes(); | ||
| 210 | #endif | ||
| 211 | #if PYTHON_VERSION >= 360 | ||
| 212 | _initCompiledAsyncgenTypes(); | ||
| 213 | #endif | ||
| 214 | |||
| 215 | #if PYTHON_VERSION < 300 | ||
| 216 | _initSlotCompare(); | ||
| 217 | #endif | ||
| 218 | #if PYTHON_VERSION >= 270 | ||
| 219 | _initSlotIternext(); | ||
| 220 | #endif | ||
| 221 | |||
| 222 | patchBuiltinModule(); | ||
| 223 | patchTypeComparison(); | ||
| 224 | |||
| 225 | // Enable meta path based loader if not already done. | ||
| 226 | #ifdef _NUITKA_TRACE | ||
| 227 | puts("dbus.mainloop: Calling setupMetaPathBasedLoader()."); | ||
| 228 | #endif | ||
| 229 | setupMetaPathBasedLoader(); | ||
| 230 | |||
| 231 | #if PYTHON_VERSION >= 300 | ||
| 232 | patchInspectModule(); | ||
| 233 | #endif | ||
| 234 | |||
| 235 | #endif | ||
| 236 | |||
| 237 | /* The constants only used by this module are created now. */ | ||
| 238 | #ifdef _NUITKA_TRACE | ||
| 239 | puts("dbus.mainloop: Calling createModuleConstants()."); | ||
| 240 | #endif | ||
| 241 | createModuleConstants(); | ||
| 242 | |||
| 243 | /* The code objects used by this module are created now. */ | ||
| 244 | #ifdef _NUITKA_TRACE | ||
| 245 | puts("dbus.mainloop: Calling createModuleCodeObjects()."); | ||
| 246 | #endif | ||
| 247 | createModuleCodeObjects(); | ||
| 248 | |||
| 249 | // puts( "in initdbus$mainloop" ); | ||
| 250 | |||
| 251 | // Create the module object first. There are no methods initially, all are | ||
| 252 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 253 | // set at this time, as it could not contain NUL characters this way, they | ||
| 254 | // are instead set in early module code. No "self" for modules, we have no | ||
| 255 | // use for it. | ||
| 256 | #if PYTHON_VERSION < 300 | ||
| 257 | module_dbus$mainloop = Py_InitModule4( | ||
| 258 | "dbus.mainloop", // Module Name | ||
| 259 | NULL, // No methods initially, all are added | ||
| 260 | // dynamically in actual module code only. | ||
| 261 | NULL, // No "__doc__" is initially set, as it could | ||
| 262 | // not contain NUL this way, added early in | ||
| 263 | // actual code. | ||
| 264 | NULL, // No self for modules, we don't use it. | ||
| 265 | PYTHON_API_VERSION | ||
| 266 | ); | ||
| 267 | #else | ||
| 268 | |||
| 269 | module_dbus$mainloop = PyModule_Create( &mdef_dbus$mainloop ); | ||
| 270 | #endif | ||
| 271 | |||
| 272 | moduledict_dbus$mainloop = MODULE_DICT( module_dbus$mainloop ); | ||
| 273 | |||
| 274 | // Set __compiled__ to what it we know. | ||
| 275 | UPDATE_STRING_DICT1( | ||
| 276 | moduledict_dbus$mainloop, | ||
| 277 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 278 | Nuitka_dunder_compiled_value | ||
| 279 | ); | ||
| 280 | |||
| 281 | // Update "__package__" value to what it ought to be. | ||
| 282 | { | ||
| 283 | #if 1 | ||
| 284 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 285 | |||
| 286 | UPDATE_STRING_DICT1( | ||
| 287 | moduledict_dbus$mainloop, | ||
| 288 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 289 | module_name | ||
| 290 | ); | ||
| 291 | #else | ||
| 292 | |||
| 293 | #if PYTHON_VERSION < 300 | ||
| 294 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 295 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 296 | |||
| 297 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 298 | |||
| 299 | if ( last_dot != NULL ) | ||
| 300 | { | ||
| 301 | UPDATE_STRING_DICT1( | ||
| 302 | moduledict_dbus$mainloop, | ||
| 303 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 304 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 305 | ); | ||
| 306 | } | ||
| 307 | #else | ||
| 308 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 309 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 310 | |||
| 311 | if ( dot_index != -1 ) | ||
| 312 | { | ||
| 313 | UPDATE_STRING_DICT1( | ||
| 314 | moduledict_dbus$mainloop, | ||
| 315 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 316 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 317 | ); | ||
| 318 | } | ||
| 319 | #endif | ||
| 320 | #endif | ||
| 321 | } | ||
| 322 | |||
| 323 | CHECK_OBJECT( module_dbus$mainloop ); | ||
| 324 | |||
| 325 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 326 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 327 | #if PYTHON_VERSION >= 300 | ||
| 328 | { | ||
| 329 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_94de7b62cb5a27fd11e76113d9dbc77e, module_dbus$mainloop ); | ||
| 330 | |||
| 331 | assert( r != -1 ); | ||
| 332 | } | ||
| 333 | #endif | ||
| 334 | |||
| 335 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 336 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 337 | // before the frame object is allocated, or else it may fail. | ||
| 338 | |||
| 339 | if ( GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 340 | { | ||
| 341 | PyObject *value = (PyObject *)builtin_module; | ||
| 342 | |||
| 343 | // Check if main module, not a dict then but the module itself. | ||
| 344 | #if !defined(_NUITKA_EXE) || !0 | ||
| 345 | value = PyModule_GetDict( value ); | ||
| 346 | #endif | ||
| 347 | |||
| 348 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 349 | } | ||
| 350 | |||
| 351 | #if PYTHON_VERSION >= 300 | ||
| 352 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 353 | #endif | ||
| 354 | |||
| 355 | #if PYTHON_VERSION >= 340 | ||
| 356 | // Set the "__spec__" value | ||
| 357 | |||
| 358 | #if 0 | ||
| 359 | // Main modules just get "None" as spec. | ||
| 360 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 361 | #else | ||
| 362 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 363 | { | ||
| 364 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 365 | CHECK_OBJECT( bootstrap_module ); | ||
| 366 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 367 | Py_DECREF( bootstrap_module ); | ||
| 368 | |||
| 369 | PyObject *args[] = { | ||
| 370 | GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 371 | (PyObject *)&Nuitka_Loader_Type | ||
| 372 | }; | ||
| 373 | |||
| 374 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 375 | module_spec_class, | ||
| 376 | args | ||
| 377 | ); | ||
| 378 | Py_DECREF( module_spec_class ); | ||
| 379 | |||
| 380 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 381 | CHECK_OBJECT( spec_value ); | ||
| 382 | |||
| 383 | // For packages set the submodule search locations as well, even if to empty | ||
| 384 | // list, so investigating code will consider it a package. | ||
| 385 | #if 1 | ||
| 386 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 387 | #endif | ||
| 388 | |||
| 389 | // Mark the execution in the "__spec__" value. | ||
| 390 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 391 | |||
| 392 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 393 | } | ||
| 394 | #endif | ||
| 395 | #endif | ||
| 396 | |||
| 397 | // Temp variables if any | ||
| 398 | struct Nuitka_FrameObject *frame_f0e529667230d2c7e78349df985d2fda; | ||
| 399 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 400 | PyObject *exception_type = NULL; | ||
| 401 | PyObject *exception_value = NULL; | ||
| 402 | PyTracebackObject *exception_tb = NULL; | ||
| 403 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 404 | bool tmp_result; | ||
| 405 | |||
| 406 | // Module code. | ||
| 407 | { | ||
| 408 | PyObject *tmp_assign_source_1; | ||
| 409 | tmp_assign_source_1 = const_str_digest_ca885d114683883351fa5ece16bd8151; | ||
| 410 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 411 | } | ||
| 412 | { | ||
| 413 | PyObject *tmp_assign_source_2; | ||
| 414 | tmp_assign_source_2 = module_filename_obj; | ||
| 415 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 416 | } | ||
| 417 | // Frame without reuse. | ||
| 418 | frame_f0e529667230d2c7e78349df985d2fda = MAKE_MODULE_FRAME( codeobj_f0e529667230d2c7e78349df985d2fda, module_dbus$mainloop ); | ||
| 419 | |||
| 420 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 421 | // owning it. | ||
| 422 | pushFrameStack( frame_f0e529667230d2c7e78349df985d2fda ); | ||
| 423 | assert( Py_REFCNT( frame_f0e529667230d2c7e78349df985d2fda ) == 2 ); | ||
| 424 | |||
| 425 | // Framed code: | ||
| 426 | { | ||
| 427 | PyObject *tmp_assign_source_3; | ||
| 428 | PyObject *tmp_list_element_1; | ||
| 429 | PyObject *tmp_called_name_1; | ||
| 430 | PyObject *tmp_source_name_1; | ||
| 431 | PyObject *tmp_args_element_name_1; | ||
| 432 | PyObject *tmp_called_name_2; | ||
| 433 | PyObject *tmp_source_name_2; | ||
| 434 | PyObject *tmp_args_element_name_2; | ||
| 435 | PyObject *tmp_called_instance_1; | ||
| 436 | PyObject *tmp_args_element_name_3; | ||
| 437 | PyObject *tmp_called_instance_2; | ||
| 438 | frame_f0e529667230d2c7e78349df985d2fda->m_frame.f_lineno = 1; | ||
| 439 | { | ||
| 440 | PyObject *module = PyImport_ImportModule("os"); | ||
| 441 | if (likely( module != NULL )) | ||
| 442 | { | ||
| 443 | tmp_source_name_1 = PyObject_GetAttr( module, const_str_plain_path ); | ||
| 444 | } | ||
| 445 | else | ||
| 446 | { | ||
| 447 | tmp_source_name_1 = NULL; | ||
| 448 | } | ||
| 449 | } | ||
| 450 | |||
| 451 | if ( tmp_source_name_1 == NULL ) | ||
| 452 | { | ||
| 453 | assert( ERROR_OCCURRED() ); | ||
| 454 | |||
| 455 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 456 | |||
| 457 | |||
| 458 | exception_lineno = 1; | ||
| 459 | |||
| 460 | goto frame_exception_exit_1; | ||
| 461 | } | ||
| 462 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_dirname ); | ||
| 463 | if ( tmp_called_name_1 == NULL ) | ||
| 464 | { | ||
| 465 | assert( ERROR_OCCURRED() ); | ||
| 466 | |||
| 467 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 468 | |||
| 469 | |||
| 470 | exception_lineno = 1; | ||
| 471 | |||
| 472 | goto frame_exception_exit_1; | ||
| 473 | } | ||
| 474 | tmp_args_element_name_1 = module_filename_obj; | ||
| 475 | frame_f0e529667230d2c7e78349df985d2fda->m_frame.f_lineno = 1; | ||
| 476 | { | ||
| 477 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 478 | tmp_list_element_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, call_args ); | ||
| 479 | } | ||
| 480 | |||
| 481 | Py_DECREF( tmp_called_name_1 ); | ||
| 482 | if ( tmp_list_element_1 == NULL ) | ||
| 483 | { | ||
| 484 | assert( ERROR_OCCURRED() ); | ||
| 485 | |||
| 486 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 487 | |||
| 488 | |||
| 489 | exception_lineno = 1; | ||
| 490 | |||
| 491 | goto frame_exception_exit_1; | ||
| 492 | } | ||
| 493 | tmp_assign_source_3 = PyList_New( 3 ); | ||
| 494 | PyList_SET_ITEM( tmp_assign_source_3, 0, tmp_list_element_1 ); | ||
| 495 | frame_f0e529667230d2c7e78349df985d2fda->m_frame.f_lineno = 1; | ||
| 496 | { | ||
| 497 | PyObject *module = PyImport_ImportModule("os"); | ||
| 498 | if (likely( module != NULL )) | ||
| 499 | { | ||
| 500 | tmp_source_name_2 = PyObject_GetAttr( module, const_str_plain_path ); | ||
| 501 | } | ||
| 502 | else | ||
| 503 | { | ||
| 504 | tmp_source_name_2 = NULL; | ||
| 505 | } | ||
| 506 | } | ||
| 507 | |||
| 508 | if ( tmp_source_name_2 == NULL ) | ||
| 509 | { | ||
| 510 | assert( ERROR_OCCURRED() ); | ||
| 511 | |||
| 512 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 513 | Py_DECREF( tmp_assign_source_3 ); | ||
| 514 | |||
| 515 | exception_lineno = 1; | ||
| 516 | |||
| 517 | goto frame_exception_exit_1; | ||
| 518 | } | ||
| 519 | tmp_called_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_join ); | ||
| 520 | if ( tmp_called_name_2 == NULL ) | ||
| 521 | { | ||
| 522 | assert( ERROR_OCCURRED() ); | ||
| 523 | |||
| 524 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 525 | Py_DECREF( tmp_assign_source_3 ); | ||
| 526 | |||
| 527 | exception_lineno = 1; | ||
| 528 | |||
| 529 | goto frame_exception_exit_1; | ||
| 530 | } | ||
| 531 | frame_f0e529667230d2c7e78349df985d2fda->m_frame.f_lineno = 1; | ||
| 532 | { | ||
| 533 | PyObject *module = PyImport_ImportModule("os"); | ||
| 534 | if (likely( module != NULL )) | ||
| 535 | { | ||
| 536 | tmp_called_instance_1 = PyObject_GetAttr( module, const_str_plain_environ ); | ||
| 537 | } | ||
| 538 | else | ||
| 539 | { | ||
| 540 | tmp_called_instance_1 = NULL; | ||
| 541 | } | ||
| 542 | } | ||
| 543 | |||
| 544 | if ( tmp_called_instance_1 == NULL ) | ||
| 545 | { | ||
| 546 | assert( ERROR_OCCURRED() ); | ||
| 547 | |||
| 548 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 549 | Py_DECREF( tmp_assign_source_3 ); | ||
| 550 | Py_DECREF( tmp_called_name_2 ); | ||
| 551 | |||
| 552 | exception_lineno = 1; | ||
| 553 | |||
| 554 | goto frame_exception_exit_1; | ||
| 555 | } | ||
| 556 | frame_f0e529667230d2c7e78349df985d2fda->m_frame.f_lineno = 1; | ||
| 557 | tmp_args_element_name_2 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_1, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_c05661dc311559e0338d3f9170078d6a_tuple, 0 ) ); | ||
| 558 | |||
| 559 | if ( tmp_args_element_name_2 == NULL ) | ||
| 560 | { | ||
| 561 | assert( ERROR_OCCURRED() ); | ||
| 562 | |||
| 563 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 564 | Py_DECREF( tmp_assign_source_3 ); | ||
| 565 | Py_DECREF( tmp_called_name_2 ); | ||
| 566 | |||
| 567 | exception_lineno = 1; | ||
| 568 | |||
| 569 | goto frame_exception_exit_1; | ||
| 570 | } | ||
| 571 | tmp_args_element_name_3 = const_str_plain_mainloop; | ||
| 572 | frame_f0e529667230d2c7e78349df985d2fda->m_frame.f_lineno = 1; | ||
| 573 | { | ||
| 574 | PyObject *call_args[] = { tmp_args_element_name_2, tmp_args_element_name_3 }; | ||
| 575 | tmp_list_element_1 = CALL_FUNCTION_WITH_ARGS2( tmp_called_name_2, call_args ); | ||
| 576 | } | ||
| 577 | |||
| 578 | Py_DECREF( tmp_called_name_2 ); | ||
| 579 | Py_DECREF( tmp_args_element_name_2 ); | ||
| 580 | if ( tmp_list_element_1 == NULL ) | ||
| 581 | { | ||
| 582 | assert( ERROR_OCCURRED() ); | ||
| 583 | |||
| 584 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 585 | Py_DECREF( tmp_assign_source_3 ); | ||
| 586 | |||
| 587 | exception_lineno = 1; | ||
| 588 | |||
| 589 | goto frame_exception_exit_1; | ||
| 590 | } | ||
| 591 | PyList_SET_ITEM( tmp_assign_source_3, 1, tmp_list_element_1 ); | ||
| 592 | frame_f0e529667230d2c7e78349df985d2fda->m_frame.f_lineno = 1; | ||
| 593 | { | ||
| 594 | PyObject *module = PyImport_ImportModule("os"); | ||
| 595 | if (likely( module != NULL )) | ||
| 596 | { | ||
| 597 | tmp_called_instance_2 = PyObject_GetAttr( module, const_str_plain_environ ); | ||
| 598 | } | ||
| 599 | else | ||
| 600 | { | ||
| 601 | tmp_called_instance_2 = NULL; | ||
| 602 | } | ||
| 603 | } | ||
| 604 | |||
| 605 | if ( tmp_called_instance_2 == NULL ) | ||
| 606 | { | ||
| 607 | assert( ERROR_OCCURRED() ); | ||
| 608 | |||
| 609 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 610 | Py_DECREF( tmp_assign_source_3 ); | ||
| 611 | |||
| 612 | exception_lineno = 1; | ||
| 613 | |||
| 614 | goto frame_exception_exit_1; | ||
| 615 | } | ||
| 616 | frame_f0e529667230d2c7e78349df985d2fda->m_frame.f_lineno = 1; | ||
| 617 | tmp_list_element_1 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_2, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_1e0b2627de80cd15cd2a2707b4a50786_tuple, 0 ) ); | ||
| 618 | |||
| 619 | if ( tmp_list_element_1 == NULL ) | ||
| 620 | { | ||
| 621 | assert( ERROR_OCCURRED() ); | ||
| 622 | |||
| 623 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 624 | Py_DECREF( tmp_assign_source_3 ); | ||
| 625 | |||
| 626 | exception_lineno = 1; | ||
| 627 | |||
| 628 | goto frame_exception_exit_1; | ||
| 629 | } | ||
| 630 | PyList_SET_ITEM( tmp_assign_source_3, 2, tmp_list_element_1 ); | ||
| 631 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); | ||
| 632 | } | ||
| 633 | { | ||
| 634 | PyObject *tmp_assattr_name_1; | ||
| 635 | PyObject *tmp_assattr_target_1; | ||
| 636 | PyObject *tmp_mvar_value_1; | ||
| 637 | tmp_assattr_name_1 = module_filename_obj; | ||
| 638 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 639 | |||
| 640 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 641 | { | ||
| 642 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 643 | } | ||
| 644 | |||
| 645 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 646 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 647 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 648 | if ( tmp_result == false ) | ||
| 649 | { | ||
| 650 | assert( ERROR_OCCURRED() ); | ||
| 651 | |||
| 652 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 653 | |||
| 654 | |||
| 655 | exception_lineno = 1; | ||
| 656 | |||
| 657 | goto frame_exception_exit_1; | ||
| 658 | } | ||
| 659 | } | ||
| 660 | { | ||
| 661 | PyObject *tmp_assattr_name_2; | ||
| 662 | PyObject *tmp_assattr_target_2; | ||
| 663 | PyObject *tmp_mvar_value_2; | ||
| 664 | tmp_assattr_name_2 = Py_True; | ||
| 665 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 666 | |||
| 667 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 668 | { | ||
| 669 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 670 | } | ||
| 671 | |||
| 672 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 673 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 674 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 675 | if ( tmp_result == false ) | ||
| 676 | { | ||
| 677 | assert( ERROR_OCCURRED() ); | ||
| 678 | |||
| 679 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 680 | |||
| 681 | |||
| 682 | exception_lineno = 1; | ||
| 683 | |||
| 684 | goto frame_exception_exit_1; | ||
| 685 | } | ||
| 686 | } | ||
| 687 | { | ||
| 688 | PyObject *tmp_assign_source_4; | ||
| 689 | tmp_assign_source_4 = Py_None; | ||
| 690 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_4 ); | ||
| 691 | } | ||
| 692 | { | ||
| 693 | PyObject *tmp_assign_source_5; | ||
| 694 | PyObject *tmp_name_name_1; | ||
| 695 | PyObject *tmp_globals_name_1; | ||
| 696 | PyObject *tmp_locals_name_1; | ||
| 697 | PyObject *tmp_fromlist_name_1; | ||
| 698 | PyObject *tmp_level_name_1; | ||
| 699 | tmp_name_name_1 = const_str_plain__dbus_bindings; | ||
| 700 | tmp_globals_name_1 = (PyObject *)moduledict_dbus$mainloop; | ||
| 701 | tmp_locals_name_1 = Py_None; | ||
| 702 | tmp_fromlist_name_1 = Py_None; | ||
| 703 | tmp_level_name_1 = const_int_0; | ||
| 704 | frame_f0e529667230d2c7e78349df985d2fda->m_frame.f_lineno = 27; | ||
| 705 | tmp_assign_source_5 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 706 | if ( tmp_assign_source_5 == NULL ) | ||
| 707 | { | ||
| 708 | assert( ERROR_OCCURRED() ); | ||
| 709 | |||
| 710 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 711 | |||
| 712 | |||
| 713 | exception_lineno = 27; | ||
| 714 | |||
| 715 | goto frame_exception_exit_1; | ||
| 716 | } | ||
| 717 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain__dbus_bindings, tmp_assign_source_5 ); | ||
| 718 | } | ||
| 719 | { | ||
| 720 | PyObject *tmp_assign_source_6; | ||
| 721 | PyObject *tmp_source_name_3; | ||
| 722 | PyObject *tmp_mvar_value_3; | ||
| 723 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 724 | |||
| 725 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 726 | { | ||
| 727 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 728 | } | ||
| 729 | |||
| 730 | CHECK_OBJECT( tmp_mvar_value_3 ); | ||
| 731 | tmp_source_name_3 = tmp_mvar_value_3; | ||
| 732 | tmp_assign_source_6 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_NativeMainLoop ); | ||
| 733 | if ( tmp_assign_source_6 == NULL ) | ||
| 734 | { | ||
| 735 | assert( ERROR_OCCURRED() ); | ||
| 736 | |||
| 737 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 738 | |||
| 739 | |||
| 740 | exception_lineno = 29; | ||
| 741 | |||
| 742 | goto frame_exception_exit_1; | ||
| 743 | } | ||
| 744 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain_NativeMainLoop, tmp_assign_source_6 ); | ||
| 745 | } | ||
| 746 | { | ||
| 747 | PyObject *tmp_assign_source_7; | ||
| 748 | PyObject *tmp_source_name_4; | ||
| 749 | PyObject *tmp_mvar_value_4; | ||
| 750 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 751 | |||
| 752 | if (unlikely( tmp_mvar_value_4 == NULL )) | ||
| 753 | { | ||
| 754 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 755 | } | ||
| 756 | |||
| 757 | if ( tmp_mvar_value_4 == NULL ) | ||
| 758 | { | ||
| 759 | |||
| 760 | exception_type = PyExc_NameError; | ||
| 761 | Py_INCREF( exception_type ); | ||
| 762 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_dbus_bindings" ); | ||
| 763 | exception_tb = NULL; | ||
| 764 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 765 | CHAIN_EXCEPTION( exception_value ); | ||
| 766 | |||
| 767 | exception_lineno = 31; | ||
| 768 | |||
| 769 | goto frame_exception_exit_1; | ||
| 770 | } | ||
| 771 | |||
| 772 | tmp_source_name_4 = tmp_mvar_value_4; | ||
| 773 | tmp_assign_source_7 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain_NULL_MAIN_LOOP ); | ||
| 774 | if ( tmp_assign_source_7 == NULL ) | ||
| 775 | { | ||
| 776 | assert( ERROR_OCCURRED() ); | ||
| 777 | |||
| 778 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 779 | |||
| 780 | |||
| 781 | exception_lineno = 31; | ||
| 782 | |||
| 783 | goto frame_exception_exit_1; | ||
| 784 | } | ||
| 785 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain_NULL_MAIN_LOOP, tmp_assign_source_7 ); | ||
| 786 | } | ||
| 787 | { | ||
| 788 | PyObject *tmp_assign_source_8; | ||
| 789 | PyObject *tmp_source_name_5; | ||
| 790 | PyObject *tmp_mvar_value_5; | ||
| 791 | tmp_mvar_value_5 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 792 | |||
| 793 | if (unlikely( tmp_mvar_value_5 == NULL )) | ||
| 794 | { | ||
| 795 | tmp_mvar_value_5 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 796 | } | ||
| 797 | |||
| 798 | if ( tmp_mvar_value_5 == NULL ) | ||
| 799 | { | ||
| 800 | |||
| 801 | exception_type = PyExc_NameError; | ||
| 802 | Py_INCREF( exception_type ); | ||
| 803 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_dbus_bindings" ); | ||
| 804 | exception_tb = NULL; | ||
| 805 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 806 | CHAIN_EXCEPTION( exception_value ); | ||
| 807 | |||
| 808 | exception_lineno = 39; | ||
| 809 | |||
| 810 | goto frame_exception_exit_1; | ||
| 811 | } | ||
| 812 | |||
| 813 | tmp_source_name_5 = tmp_mvar_value_5; | ||
| 814 | tmp_assign_source_8 = LOOKUP_ATTRIBUTE( tmp_source_name_5, const_str_plain_WATCH_READABLE ); | ||
| 815 | if ( tmp_assign_source_8 == NULL ) | ||
| 816 | { | ||
| 817 | assert( ERROR_OCCURRED() ); | ||
| 818 | |||
| 819 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 820 | |||
| 821 | |||
| 822 | exception_lineno = 39; | ||
| 823 | |||
| 824 | goto frame_exception_exit_1; | ||
| 825 | } | ||
| 826 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain_WATCH_READABLE, tmp_assign_source_8 ); | ||
| 827 | } | ||
| 828 | { | ||
| 829 | PyObject *tmp_assign_source_9; | ||
| 830 | PyObject *tmp_source_name_6; | ||
| 831 | PyObject *tmp_mvar_value_6; | ||
| 832 | tmp_mvar_value_6 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 833 | |||
| 834 | if (unlikely( tmp_mvar_value_6 == NULL )) | ||
| 835 | { | ||
| 836 | tmp_mvar_value_6 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 837 | } | ||
| 838 | |||
| 839 | if ( tmp_mvar_value_6 == NULL ) | ||
| 840 | { | ||
| 841 | |||
| 842 | exception_type = PyExc_NameError; | ||
| 843 | Py_INCREF( exception_type ); | ||
| 844 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_dbus_bindings" ); | ||
| 845 | exception_tb = NULL; | ||
| 846 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 847 | CHAIN_EXCEPTION( exception_value ); | ||
| 848 | |||
| 849 | exception_lineno = 43; | ||
| 850 | |||
| 851 | goto frame_exception_exit_1; | ||
| 852 | } | ||
| 853 | |||
| 854 | tmp_source_name_6 = tmp_mvar_value_6; | ||
| 855 | tmp_assign_source_9 = LOOKUP_ATTRIBUTE( tmp_source_name_6, const_str_plain_WATCH_WRITABLE ); | ||
| 856 | if ( tmp_assign_source_9 == NULL ) | ||
| 857 | { | ||
| 858 | assert( ERROR_OCCURRED() ); | ||
| 859 | |||
| 860 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 861 | |||
| 862 | |||
| 863 | exception_lineno = 43; | ||
| 864 | |||
| 865 | goto frame_exception_exit_1; | ||
| 866 | } | ||
| 867 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain_WATCH_WRITABLE, tmp_assign_source_9 ); | ||
| 868 | } | ||
| 869 | { | ||
| 870 | PyObject *tmp_assign_source_10; | ||
| 871 | PyObject *tmp_source_name_7; | ||
| 872 | PyObject *tmp_mvar_value_7; | ||
| 873 | tmp_mvar_value_7 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 874 | |||
| 875 | if (unlikely( tmp_mvar_value_7 == NULL )) | ||
| 876 | { | ||
| 877 | tmp_mvar_value_7 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 878 | } | ||
| 879 | |||
| 880 | if ( tmp_mvar_value_7 == NULL ) | ||
| 881 | { | ||
| 882 | |||
| 883 | exception_type = PyExc_NameError; | ||
| 884 | Py_INCREF( exception_type ); | ||
| 885 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_dbus_bindings" ); | ||
| 886 | exception_tb = NULL; | ||
| 887 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 888 | CHAIN_EXCEPTION( exception_value ); | ||
| 889 | |||
| 890 | exception_lineno = 47; | ||
| 891 | |||
| 892 | goto frame_exception_exit_1; | ||
| 893 | } | ||
| 894 | |||
| 895 | tmp_source_name_7 = tmp_mvar_value_7; | ||
| 896 | tmp_assign_source_10 = LOOKUP_ATTRIBUTE( tmp_source_name_7, const_str_plain_WATCH_HANGUP ); | ||
| 897 | if ( tmp_assign_source_10 == NULL ) | ||
| 898 | { | ||
| 899 | assert( ERROR_OCCURRED() ); | ||
| 900 | |||
| 901 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 902 | |||
| 903 | |||
| 904 | exception_lineno = 47; | ||
| 905 | |||
| 906 | goto frame_exception_exit_1; | ||
| 907 | } | ||
| 908 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain_WATCH_HANGUP, tmp_assign_source_10 ); | ||
| 909 | } | ||
| 910 | { | ||
| 911 | PyObject *tmp_assign_source_11; | ||
| 912 | PyObject *tmp_source_name_8; | ||
| 913 | PyObject *tmp_mvar_value_8; | ||
| 914 | tmp_mvar_value_8 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 915 | |||
| 916 | if (unlikely( tmp_mvar_value_8 == NULL )) | ||
| 917 | { | ||
| 918 | tmp_mvar_value_8 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__dbus_bindings ); | ||
| 919 | } | ||
| 920 | |||
| 921 | if ( tmp_mvar_value_8 == NULL ) | ||
| 922 | { | ||
| 923 | |||
| 924 | exception_type = PyExc_NameError; | ||
| 925 | Py_INCREF( exception_type ); | ||
| 926 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_dbus_bindings" ); | ||
| 927 | exception_tb = NULL; | ||
| 928 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 929 | CHAIN_EXCEPTION( exception_value ); | ||
| 930 | |||
| 931 | exception_lineno = 51; | ||
| 932 | |||
| 933 | goto frame_exception_exit_1; | ||
| 934 | } | ||
| 935 | |||
| 936 | tmp_source_name_8 = tmp_mvar_value_8; | ||
| 937 | tmp_assign_source_11 = LOOKUP_ATTRIBUTE( tmp_source_name_8, const_str_plain_WATCH_ERROR ); | ||
| 938 | if ( tmp_assign_source_11 == NULL ) | ||
| 939 | { | ||
| 940 | assert( ERROR_OCCURRED() ); | ||
| 941 | |||
| 942 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 943 | |||
| 944 | |||
| 945 | exception_lineno = 51; | ||
| 946 | |||
| 947 | goto frame_exception_exit_1; | ||
| 948 | } | ||
| 949 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain_WATCH_ERROR, tmp_assign_source_11 ); | ||
| 950 | } | ||
| 951 | |||
| 952 | // Restore frame exception if necessary. | ||
| 953 | #if 0 | ||
| 954 | RESTORE_FRAME_EXCEPTION( frame_f0e529667230d2c7e78349df985d2fda ); | ||
| 955 | #endif | ||
| 956 | popFrameStack(); | ||
| 957 | |||
| 958 | assertFrameObject( frame_f0e529667230d2c7e78349df985d2fda ); | ||
| 959 | |||
| 960 | goto frame_no_exception_1; | ||
| 961 | |||
| 962 | frame_exception_exit_1:; | ||
| 963 | #if 0 | ||
| 964 | RESTORE_FRAME_EXCEPTION( frame_f0e529667230d2c7e78349df985d2fda ); | ||
| 965 | #endif | ||
| 966 | |||
| 967 | if ( exception_tb == NULL ) | ||
| 968 | { | ||
| 969 | exception_tb = MAKE_TRACEBACK( frame_f0e529667230d2c7e78349df985d2fda, exception_lineno ); | ||
| 970 | } | ||
| 971 | else if ( exception_tb->tb_frame != &frame_f0e529667230d2c7e78349df985d2fda->m_frame ) | ||
| 972 | { | ||
| 973 | exception_tb = ADD_TRACEBACK( exception_tb, frame_f0e529667230d2c7e78349df985d2fda, exception_lineno ); | ||
| 974 | } | ||
| 975 | |||
| 976 | // Put the previous frame back on top. | ||
| 977 | popFrameStack(); | ||
| 978 | |||
| 979 | // Return the error. | ||
| 980 | goto module_exception_exit; | ||
| 981 | |||
| 982 | frame_no_exception_1:; | ||
| 983 | { | ||
| 984 | PyObject *tmp_assign_source_12; | ||
| 985 | tmp_assign_source_12 = const_tuple_e491f74580763f43a808aa077c589175_tuple; | ||
| 986 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___all__, tmp_assign_source_12 ); | ||
| 987 | } | ||
| 988 | |||
| 989 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 990 | #if 1 && 0 | ||
| 991 | { | ||
| 992 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 993 | |||
| 994 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 995 | { | ||
| 996 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 997 | |||
| 998 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 999 | CHECK_OBJECT( path_importer_cache ); | ||
| 1000 | |||
| 1001 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 1002 | assert( res == 0 ); | ||
| 1003 | } | ||
| 1004 | } | ||
| 1005 | #endif | ||
| 1006 | #endif | ||
| 1007 | |||
| 1008 | return MOD_RETURN_VALUE( module_dbus$mainloop ); | ||
| 1009 | module_exception_exit: | ||
| 1010 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1011 | return MOD_RETURN_VALUE( NULL ); | ||
| 1012 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.dbus.mainloop.glib.c deleted (index 9ca8ee4..0000000) | |||
| 1 | /* Generated code for Python module 'dbus.mainloop.glib' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_dbus$mainloop$glib" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_dbus$mainloop$glib; | ||
| 31 | PyDictObject *moduledict_dbus$mainloop$glib; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | static PyObject *const_tuple_str_plain_DBusGMainLoop_str_plain_gthreads_init_tuple; | ||
| 35 | extern PyObject *const_str_plain___spec__; | ||
| 36 | static PyObject *const_str_digest_f10e2ec87b7dc4cd78c14bbcc06032c1; | ||
| 37 | extern PyObject *const_str_plain_DBusGMainLoop; | ||
| 38 | static PyObject *const_str_digest_1731cab4002b1018dc1016edf82d774b; | ||
| 39 | extern PyObject *const_str_plain___all__; | ||
| 40 | static PyObject *const_str_plain__dbus_glib_bindings; | ||
| 41 | static PyObject *const_tuple_str_plain_DBusGMainLoop_str_plain_threads_init_tuple; | ||
| 42 | extern PyObject *const_str_plain_threads_init; | ||
| 43 | static PyObject *const_str_plain_gthreads_init; | ||
| 44 | extern PyObject *const_str_digest_168dabde1c45fe2c6a98ec9eae56b3f0; | ||
| 45 | extern PyObject *const_str_plain___file__; | ||
| 46 | extern PyObject *const_int_0; | ||
| 47 | static PyObject *const_str_digest_e440ee50d1c3006574b2b526fb1003e1; | ||
| 48 | extern PyObject *const_str_plain_origin; | ||
| 49 | extern PyObject *const_tuple_empty; | ||
| 50 | static PyObject *const_str_digest_5aab96487d1936ff2c462fb158533f25; | ||
| 51 | extern PyObject *const_str_plain_has_location; | ||
| 52 | static PyObject *const_str_plain__dbus_gthreads_initialized; | ||
| 53 | extern PyObject *const_str_plain___doc__; | ||
| 54 | extern PyObject *const_str_plain___cached__; | ||
| 55 | static PyObject *module_filename_obj; | ||
| 56 | |||
| 57 | /* Indicator if this modules private constants were created yet. */ | ||
| 58 | static bool constants_created = false; | ||
| 59 | |||
| 60 | /* Function to create module private constants. */ | ||
| 61 | static void createModuleConstants( void ) | ||
| 62 | { | ||
| 63 | const_tuple_str_plain_DBusGMainLoop_str_plain_gthreads_init_tuple = PyTuple_New( 2 ); | ||
| 64 | PyTuple_SET_ITEM( const_tuple_str_plain_DBusGMainLoop_str_plain_gthreads_init_tuple, 0, const_str_plain_DBusGMainLoop ); Py_INCREF( const_str_plain_DBusGMainLoop ); | ||
| 65 | const_str_plain_gthreads_init = UNSTREAM_STRING_ASCII( &constant_bin[ 24389 ], 13, 1 ); | ||
| 66 | PyTuple_SET_ITEM( const_tuple_str_plain_DBusGMainLoop_str_plain_gthreads_init_tuple, 1, const_str_plain_gthreads_init ); Py_INCREF( const_str_plain_gthreads_init ); | ||
| 67 | const_str_digest_f10e2ec87b7dc4cd78c14bbcc06032c1 = UNSTREAM_STRING_ASCII( &constant_bin[ 24402 ], 46, 0 ); | ||
| 68 | const_str_digest_1731cab4002b1018dc1016edf82d774b = UNSTREAM_STRING_ASCII( &constant_bin[ 24448 ], 21, 0 ); | ||
| 69 | const_str_plain__dbus_glib_bindings = UNSTREAM_STRING_ASCII( &constant_bin[ 24469 ], 19, 1 ); | ||
| 70 | const_tuple_str_plain_DBusGMainLoop_str_plain_threads_init_tuple = PyTuple_New( 2 ); | ||
| 71 | PyTuple_SET_ITEM( const_tuple_str_plain_DBusGMainLoop_str_plain_threads_init_tuple, 0, const_str_plain_DBusGMainLoop ); Py_INCREF( const_str_plain_DBusGMainLoop ); | ||
| 72 | PyTuple_SET_ITEM( const_tuple_str_plain_DBusGMainLoop_str_plain_threads_init_tuple, 1, const_str_plain_threads_init ); Py_INCREF( const_str_plain_threads_init ); | ||
| 73 | const_str_digest_e440ee50d1c3006574b2b526fb1003e1 = UNSTREAM_STRING_ASCII( &constant_bin[ 24488 ], 169, 0 ); | ||
| 74 | const_str_digest_5aab96487d1936ff2c462fb158533f25 = UNSTREAM_STRING_ASCII( &constant_bin[ 24657 ], 27, 0 ); | ||
| 75 | const_str_plain__dbus_gthreads_initialized = UNSTREAM_STRING_ASCII( &constant_bin[ 24684 ], 26, 1 ); | ||
| 76 | |||
| 77 | constants_created = true; | ||
| 78 | } | ||
| 79 | |||
| 80 | /* Function to verify module private constants for non-corruption. */ | ||
| 81 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 82 | void checkModuleConstants_dbus$mainloop$glib( void ) | ||
| 83 | { | ||
| 84 | // The module may not have been used at all, then ignore this. | ||
| 85 | if (constants_created == false) return; | ||
| 86 | |||
| 87 | |||
| 88 | } | ||
| 89 | #endif | ||
| 90 | |||
| 91 | // The module code objects. | ||
| 92 | static PyCodeObject *codeobj_898fab06db015892e566f047251b199f; | ||
| 93 | static PyCodeObject *codeobj_4dc4afd0ac5180bf6306d95e18c58b06; | ||
| 94 | |||
| 95 | static void createModuleCodeObjects(void) | ||
| 96 | { | ||
| 97 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_1731cab4002b1018dc1016edf82d774b ); | ||
| 98 | codeobj_898fab06db015892e566f047251b199f = MAKE_CODEOBJ( module_filename_obj, const_str_digest_5aab96487d1936ff2c462fb158533f25, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 99 | codeobj_4dc4afd0ac5180bf6306d95e18c58b06 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_threads_init, 32, const_tuple_empty, 0, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 100 | } | ||
| 101 | |||
| 102 | // The module function declarations. | ||
| 103 | static PyObject *MAKE_FUNCTION_dbus$mainloop$glib$$$function_1_threads_init( ); | ||
| 104 | |||
| 105 | |||
| 106 | // The module function definitions. | ||
| 107 | static PyObject *impl_dbus$mainloop$glib$$$function_1_threads_init( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 108 | { | ||
| 109 | // Preserve error status for checks | ||
| 110 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 111 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 112 | #endif | ||
| 113 | |||
| 114 | // Local variable declarations. | ||
| 115 | struct Nuitka_FrameObject *frame_4dc4afd0ac5180bf6306d95e18c58b06; | ||
| 116 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 117 | PyObject *exception_type = NULL; | ||
| 118 | PyObject *exception_value = NULL; | ||
| 119 | PyTracebackObject *exception_tb = NULL; | ||
| 120 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 121 | int tmp_res; | ||
| 122 | static struct Nuitka_FrameObject *cache_frame_4dc4afd0ac5180bf6306d95e18c58b06 = NULL; | ||
| 123 | PyObject *tmp_return_value = NULL; | ||
| 124 | |||
| 125 | // Actual function body. | ||
| 126 | MAKE_OR_REUSE_FRAME( cache_frame_4dc4afd0ac5180bf6306d95e18c58b06, codeobj_4dc4afd0ac5180bf6306d95e18c58b06, module_dbus$mainloop$glib, 0 ); | ||
| 127 | frame_4dc4afd0ac5180bf6306d95e18c58b06 = cache_frame_4dc4afd0ac5180bf6306d95e18c58b06; | ||
| 128 | |||
| 129 | // Push the new frame as the currently active one. | ||
| 130 | pushFrameStack( frame_4dc4afd0ac5180bf6306d95e18c58b06 ); | ||
| 131 | |||
| 132 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 133 | assert( Py_REFCNT( frame_4dc4afd0ac5180bf6306d95e18c58b06 ) == 2 ); // Frame stack | ||
| 134 | |||
| 135 | // Framed code: | ||
| 136 | { | ||
| 137 | nuitka_bool tmp_condition_result_1; | ||
| 138 | PyObject *tmp_operand_name_1; | ||
| 139 | PyObject *tmp_mvar_value_1; | ||
| 140 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain__dbus_gthreads_initialized ); | ||
| 141 | |||
| 142 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 143 | { | ||
| 144 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__dbus_gthreads_initialized ); | ||
| 145 | } | ||
| 146 | |||
| 147 | if ( tmp_mvar_value_1 == NULL ) | ||
| 148 | { | ||
| 149 | |||
| 150 | exception_type = PyExc_NameError; | ||
| 151 | Py_INCREF( exception_type ); | ||
| 152 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_dbus_gthreads_initialized" ); | ||
| 153 | exception_tb = NULL; | ||
| 154 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 155 | CHAIN_EXCEPTION( exception_value ); | ||
| 156 | |||
| 157 | exception_lineno = 39; | ||
| 158 | |||
| 159 | goto frame_exception_exit_1; | ||
| 160 | } | ||
| 161 | |||
| 162 | tmp_operand_name_1 = tmp_mvar_value_1; | ||
| 163 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 164 | if ( tmp_res == -1 ) | ||
| 165 | { | ||
| 166 | assert( ERROR_OCCURRED() ); | ||
| 167 | |||
| 168 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 169 | |||
| 170 | |||
| 171 | exception_lineno = 39; | ||
| 172 | |||
| 173 | goto frame_exception_exit_1; | ||
| 174 | } | ||
| 175 | tmp_condition_result_1 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 176 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 177 | { | ||
| 178 | goto branch_yes_1; | ||
| 179 | } | ||
| 180 | else | ||
| 181 | { | ||
| 182 | goto branch_no_1; | ||
| 183 | } | ||
| 184 | branch_yes_1:; | ||
| 185 | { | ||
| 186 | PyObject *tmp_called_name_1; | ||
| 187 | PyObject *tmp_mvar_value_2; | ||
| 188 | PyObject *tmp_call_result_1; | ||
| 189 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain_gthreads_init ); | ||
| 190 | |||
| 191 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 192 | { | ||
| 193 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_gthreads_init ); | ||
| 194 | } | ||
| 195 | |||
| 196 | if ( tmp_mvar_value_2 == NULL ) | ||
| 197 | { | ||
| 198 | |||
| 199 | exception_type = PyExc_NameError; | ||
| 200 | Py_INCREF( exception_type ); | ||
| 201 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "gthreads_init" ); | ||
| 202 | exception_tb = NULL; | ||
| 203 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 204 | CHAIN_EXCEPTION( exception_value ); | ||
| 205 | |||
| 206 | exception_lineno = 40; | ||
| 207 | |||
| 208 | goto frame_exception_exit_1; | ||
| 209 | } | ||
| 210 | |||
| 211 | tmp_called_name_1 = tmp_mvar_value_2; | ||
| 212 | frame_4dc4afd0ac5180bf6306d95e18c58b06->m_frame.f_lineno = 40; | ||
| 213 | tmp_call_result_1 = CALL_FUNCTION_NO_ARGS( tmp_called_name_1 ); | ||
| 214 | if ( tmp_call_result_1 == NULL ) | ||
| 215 | { | ||
| 216 | assert( ERROR_OCCURRED() ); | ||
| 217 | |||
| 218 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 219 | |||
| 220 | |||
| 221 | exception_lineno = 40; | ||
| 222 | |||
| 223 | goto frame_exception_exit_1; | ||
| 224 | } | ||
| 225 | Py_DECREF( tmp_call_result_1 ); | ||
| 226 | } | ||
| 227 | { | ||
| 228 | PyObject *tmp_assign_source_1; | ||
| 229 | tmp_assign_source_1 = Py_True; | ||
| 230 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain__dbus_gthreads_initialized, tmp_assign_source_1 ); | ||
| 231 | } | ||
| 232 | branch_no_1:; | ||
| 233 | } | ||
| 234 | |||
| 235 | #if 0 | ||
| 236 | RESTORE_FRAME_EXCEPTION( frame_4dc4afd0ac5180bf6306d95e18c58b06 ); | ||
| 237 | #endif | ||
| 238 | |||
| 239 | // Put the previous frame back on top. | ||
| 240 | popFrameStack(); | ||
| 241 | |||
| 242 | goto frame_no_exception_1; | ||
| 243 | |||
| 244 | frame_exception_exit_1:; | ||
| 245 | |||
| 246 | #if 0 | ||
| 247 | RESTORE_FRAME_EXCEPTION( frame_4dc4afd0ac5180bf6306d95e18c58b06 ); | ||
| 248 | #endif | ||
| 249 | |||
| 250 | if ( exception_tb == NULL ) | ||
| 251 | { | ||
| 252 | exception_tb = MAKE_TRACEBACK( frame_4dc4afd0ac5180bf6306d95e18c58b06, exception_lineno ); | ||
| 253 | } | ||
| 254 | else if ( exception_tb->tb_frame != &frame_4dc4afd0ac5180bf6306d95e18c58b06->m_frame ) | ||
| 255 | { | ||
| 256 | exception_tb = ADD_TRACEBACK( exception_tb, frame_4dc4afd0ac5180bf6306d95e18c58b06, exception_lineno ); | ||
| 257 | } | ||
| 258 | |||
| 259 | // Attachs locals to frame if any. | ||
| 260 | Nuitka_Frame_AttachLocals( | ||
| 261 | (struct Nuitka_FrameObject *)frame_4dc4afd0ac5180bf6306d95e18c58b06, | ||
| 262 | type_description_1 | ||
| 263 | ); | ||
| 264 | |||
| 265 | |||
| 266 | // Release cached frame. | ||
| 267 | if ( frame_4dc4afd0ac5180bf6306d95e18c58b06 == cache_frame_4dc4afd0ac5180bf6306d95e18c58b06 ) | ||
| 268 | { | ||
| 269 | Py_DECREF( frame_4dc4afd0ac5180bf6306d95e18c58b06 ); | ||
| 270 | } | ||
| 271 | cache_frame_4dc4afd0ac5180bf6306d95e18c58b06 = NULL; | ||
| 272 | |||
| 273 | assertFrameObject( frame_4dc4afd0ac5180bf6306d95e18c58b06 ); | ||
| 274 | |||
| 275 | // Put the previous frame back on top. | ||
| 276 | popFrameStack(); | ||
| 277 | |||
| 278 | // Return the error. | ||
| 279 | goto function_exception_exit; | ||
| 280 | |||
| 281 | frame_no_exception_1:; | ||
| 282 | tmp_return_value = Py_None; | ||
| 283 | Py_INCREF( tmp_return_value ); | ||
| 284 | goto function_return_exit; | ||
| 285 | |||
| 286 | // Return statement must have exited already. | ||
| 287 | NUITKA_CANNOT_GET_HERE( dbus$mainloop$glib$$$function_1_threads_init ); | ||
| 288 | return NULL; | ||
| 289 | |||
| 290 | function_exception_exit: | ||
| 291 | assert( exception_type ); | ||
| 292 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 293 | |||
| 294 | return NULL; | ||
| 295 | |||
| 296 | function_return_exit: | ||
| 297 | // Function cleanup code if any. | ||
| 298 | |||
| 299 | |||
| 300 | // Actual function exit with return value, making sure we did not make | ||
| 301 | // the error status worse despite non-NULL return. | ||
| 302 | CHECK_OBJECT( tmp_return_value ); | ||
| 303 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 304 | return tmp_return_value; | ||
| 305 | } | ||
| 306 | |||
| 307 | |||
| 308 | |||
| 309 | static PyObject *MAKE_FUNCTION_dbus$mainloop$glib$$$function_1_threads_init( ) | ||
| 310 | { | ||
| 311 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 312 | impl_dbus$mainloop$glib$$$function_1_threads_init, | ||
| 313 | const_str_plain_threads_init, | ||
| 314 | #if PYTHON_VERSION >= 300 | ||
| 315 | NULL, | ||
| 316 | #endif | ||
| 317 | codeobj_4dc4afd0ac5180bf6306d95e18c58b06, | ||
| 318 | NULL, | ||
| 319 | #if PYTHON_VERSION >= 300 | ||
| 320 | NULL, | ||
| 321 | NULL, | ||
| 322 | #endif | ||
| 323 | module_dbus$mainloop$glib, | ||
| 324 | const_str_digest_e440ee50d1c3006574b2b526fb1003e1, | ||
| 325 | 0 | ||
| 326 | ); | ||
| 327 | |||
| 328 | return (PyObject *)result; | ||
| 329 | } | ||
| 330 | |||
| 331 | |||
| 332 | |||
| 333 | #if PYTHON_VERSION >= 300 | ||
| 334 | static struct PyModuleDef mdef_dbus$mainloop$glib = | ||
| 335 | { | ||
| 336 | PyModuleDef_HEAD_INIT, | ||
| 337 | "dbus.mainloop.glib", | ||
| 338 | NULL, /* m_doc */ | ||
| 339 | -1, /* m_size */ | ||
| 340 | NULL, /* m_methods */ | ||
| 341 | NULL, /* m_reload */ | ||
| 342 | NULL, /* m_traverse */ | ||
| 343 | NULL, /* m_clear */ | ||
| 344 | NULL, /* m_free */ | ||
| 345 | }; | ||
| 346 | #endif | ||
| 347 | |||
| 348 | extern PyObject *const_str_plain___compiled__; | ||
| 349 | |||
| 350 | extern PyObject *const_str_plain___package__; | ||
| 351 | |||
| 352 | #if PYTHON_VERSION >= 300 | ||
| 353 | extern PyObject *const_str_dot; | ||
| 354 | extern PyObject *const_str_plain___loader__; | ||
| 355 | #endif | ||
| 356 | |||
| 357 | #if PYTHON_VERSION >= 340 | ||
| 358 | extern PyObject *const_str_plain___spec__; | ||
| 359 | extern PyObject *const_str_plain__initializing; | ||
| 360 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 361 | #endif | ||
| 362 | |||
| 363 | extern void _initCompiledCellType(); | ||
| 364 | extern void _initCompiledGeneratorType(); | ||
| 365 | extern void _initCompiledFunctionType(); | ||
| 366 | extern void _initCompiledMethodType(); | ||
| 367 | extern void _initCompiledFrameType(); | ||
| 368 | #if PYTHON_VERSION >= 350 | ||
| 369 | extern void _initCompiledCoroutineTypes(); | ||
| 370 | #endif | ||
| 371 | #if PYTHON_VERSION >= 360 | ||
| 372 | extern void _initCompiledAsyncgenTypes(); | ||
| 373 | #endif | ||
| 374 | |||
| 375 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 376 | |||
| 377 | // The exported interface to CPython. On import of the module, this function | ||
| 378 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 379 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 380 | |||
| 381 | MOD_INIT_DECL( dbus$mainloop$glib ) | ||
| 382 | { | ||
| 383 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 384 | static bool _init_done = false; | ||
| 385 | |||
| 386 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 387 | if ( _init_done ) | ||
| 388 | { | ||
| 389 | return MOD_RETURN_VALUE( module_dbus$mainloop$glib ); | ||
| 390 | } | ||
| 391 | else | ||
| 392 | { | ||
| 393 | _init_done = true; | ||
| 394 | } | ||
| 395 | #endif | ||
| 396 | |||
| 397 | #ifdef _NUITKA_MODULE | ||
| 398 | // In case of a stand alone extension module, need to call initialization | ||
| 399 | // the init here because that's the first and only time we are going to get | ||
| 400 | // called here. | ||
| 401 | |||
| 402 | // Initialize the constant values used. | ||
| 403 | _initBuiltinModule(); | ||
| 404 | createGlobalConstants(); | ||
| 405 | |||
| 406 | /* Initialize the compiled types of Nuitka. */ | ||
| 407 | _initCompiledCellType(); | ||
| 408 | _initCompiledGeneratorType(); | ||
| 409 | _initCompiledFunctionType(); | ||
| 410 | _initCompiledMethodType(); | ||
| 411 | _initCompiledFrameType(); | ||
| 412 | #if PYTHON_VERSION >= 350 | ||
| 413 | _initCompiledCoroutineTypes(); | ||
| 414 | #endif | ||
| 415 | #if PYTHON_VERSION >= 360 | ||
| 416 | _initCompiledAsyncgenTypes(); | ||
| 417 | #endif | ||
| 418 | |||
| 419 | #if PYTHON_VERSION < 300 | ||
| 420 | _initSlotCompare(); | ||
| 421 | #endif | ||
| 422 | #if PYTHON_VERSION >= 270 | ||
| 423 | _initSlotIternext(); | ||
| 424 | #endif | ||
| 425 | |||
| 426 | patchBuiltinModule(); | ||
| 427 | patchTypeComparison(); | ||
| 428 | |||
| 429 | // Enable meta path based loader if not already done. | ||
| 430 | #ifdef _NUITKA_TRACE | ||
| 431 | puts("dbus.mainloop.glib: Calling setupMetaPathBasedLoader()."); | ||
| 432 | #endif | ||
| 433 | setupMetaPathBasedLoader(); | ||
| 434 | |||
| 435 | #if PYTHON_VERSION >= 300 | ||
| 436 | patchInspectModule(); | ||
| 437 | #endif | ||
| 438 | |||
| 439 | #endif | ||
| 440 | |||
| 441 | /* The constants only used by this module are created now. */ | ||
| 442 | #ifdef _NUITKA_TRACE | ||
| 443 | puts("dbus.mainloop.glib: Calling createModuleConstants()."); | ||
| 444 | #endif | ||
| 445 | createModuleConstants(); | ||
| 446 | |||
| 447 | /* The code objects used by this module are created now. */ | ||
| 448 | #ifdef _NUITKA_TRACE | ||
| 449 | puts("dbus.mainloop.glib: Calling createModuleCodeObjects()."); | ||
| 450 | #endif | ||
| 451 | createModuleCodeObjects(); | ||
| 452 | |||
| 453 | // puts( "in initdbus$mainloop$glib" ); | ||
| 454 | |||
| 455 | // Create the module object first. There are no methods initially, all are | ||
| 456 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 457 | // set at this time, as it could not contain NUL characters this way, they | ||
| 458 | // are instead set in early module code. No "self" for modules, we have no | ||
| 459 | // use for it. | ||
| 460 | #if PYTHON_VERSION < 300 | ||
| 461 | module_dbus$mainloop$glib = Py_InitModule4( | ||
| 462 | "dbus.mainloop.glib", // Module Name | ||
| 463 | NULL, // No methods initially, all are added | ||
| 464 | // dynamically in actual module code only. | ||
| 465 | NULL, // No "__doc__" is initially set, as it could | ||
| 466 | // not contain NUL this way, added early in | ||
| 467 | // actual code. | ||
| 468 | NULL, // No self for modules, we don't use it. | ||
| 469 | PYTHON_API_VERSION | ||
| 470 | ); | ||
| 471 | #else | ||
| 472 | |||
| 473 | module_dbus$mainloop$glib = PyModule_Create( &mdef_dbus$mainloop$glib ); | ||
| 474 | #endif | ||
| 475 | |||
| 476 | moduledict_dbus$mainloop$glib = MODULE_DICT( module_dbus$mainloop$glib ); | ||
| 477 | |||
| 478 | // Set __compiled__ to what it we know. | ||
| 479 | UPDATE_STRING_DICT1( | ||
| 480 | moduledict_dbus$mainloop$glib, | ||
| 481 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 482 | Nuitka_dunder_compiled_value | ||
| 483 | ); | ||
| 484 | |||
| 485 | // Update "__package__" value to what it ought to be. | ||
| 486 | { | ||
| 487 | #if 0 | ||
| 488 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 489 | |||
| 490 | UPDATE_STRING_DICT1( | ||
| 491 | moduledict_dbus$mainloop$glib, | ||
| 492 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 493 | module_name | ||
| 494 | ); | ||
| 495 | #else | ||
| 496 | |||
| 497 | #if PYTHON_VERSION < 300 | ||
| 498 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 499 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 500 | |||
| 501 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 502 | |||
| 503 | if ( last_dot != NULL ) | ||
| 504 | { | ||
| 505 | UPDATE_STRING_DICT1( | ||
| 506 | moduledict_dbus$mainloop$glib, | ||
| 507 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 508 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 509 | ); | ||
| 510 | } | ||
| 511 | #else | ||
| 512 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 513 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 514 | |||
| 515 | if ( dot_index != -1 ) | ||
| 516 | { | ||
| 517 | UPDATE_STRING_DICT1( | ||
| 518 | moduledict_dbus$mainloop$glib, | ||
| 519 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 520 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 521 | ); | ||
| 522 | } | ||
| 523 | #endif | ||
| 524 | #endif | ||
| 525 | } | ||
| 526 | |||
| 527 | CHECK_OBJECT( module_dbus$mainloop$glib ); | ||
| 528 | |||
| 529 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 530 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 531 | #if PYTHON_VERSION >= 300 | ||
| 532 | { | ||
| 533 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_168dabde1c45fe2c6a98ec9eae56b3f0, module_dbus$mainloop$glib ); | ||
| 534 | |||
| 535 | assert( r != -1 ); | ||
| 536 | } | ||
| 537 | #endif | ||
| 538 | |||
| 539 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 540 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 541 | // before the frame object is allocated, or else it may fail. | ||
| 542 | |||
| 543 | if ( GET_STRING_DICT_VALUE( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 544 | { | ||
| 545 | PyObject *value = (PyObject *)builtin_module; | ||
| 546 | |||
| 547 | // Check if main module, not a dict then but the module itself. | ||
| 548 | #if !defined(_NUITKA_EXE) || !0 | ||
| 549 | value = PyModule_GetDict( value ); | ||
| 550 | #endif | ||
| 551 | |||
| 552 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 553 | } | ||
| 554 | |||
| 555 | #if PYTHON_VERSION >= 300 | ||
| 556 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 557 | #endif | ||
| 558 | |||
| 559 | #if PYTHON_VERSION >= 340 | ||
| 560 | // Set the "__spec__" value | ||
| 561 | |||
| 562 | #if 0 | ||
| 563 | // Main modules just get "None" as spec. | ||
| 564 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 565 | #else | ||
| 566 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 567 | { | ||
| 568 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 569 | CHECK_OBJECT( bootstrap_module ); | ||
| 570 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 571 | Py_DECREF( bootstrap_module ); | ||
| 572 | |||
| 573 | PyObject *args[] = { | ||
| 574 | GET_STRING_DICT_VALUE( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 575 | (PyObject *)&Nuitka_Loader_Type | ||
| 576 | }; | ||
| 577 | |||
| 578 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 579 | module_spec_class, | ||
| 580 | args | ||
| 581 | ); | ||
| 582 | Py_DECREF( module_spec_class ); | ||
| 583 | |||
| 584 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 585 | CHECK_OBJECT( spec_value ); | ||
| 586 | |||
| 587 | // For packages set the submodule search locations as well, even if to empty | ||
| 588 | // list, so investigating code will consider it a package. | ||
| 589 | #if 0 | ||
| 590 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 591 | #endif | ||
| 592 | |||
| 593 | // Mark the execution in the "__spec__" value. | ||
| 594 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 595 | |||
| 596 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 597 | } | ||
| 598 | #endif | ||
| 599 | #endif | ||
| 600 | |||
| 601 | // Temp variables if any | ||
| 602 | PyObject *tmp_import_from_1__module = NULL; | ||
| 603 | struct Nuitka_FrameObject *frame_898fab06db015892e566f047251b199f; | ||
| 604 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 605 | bool tmp_result; | ||
| 606 | PyObject *exception_type = NULL; | ||
| 607 | PyObject *exception_value = NULL; | ||
| 608 | PyTracebackObject *exception_tb = NULL; | ||
| 609 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 610 | PyObject *exception_keeper_type_1; | ||
| 611 | PyObject *exception_keeper_value_1; | ||
| 612 | PyTracebackObject *exception_keeper_tb_1; | ||
| 613 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 614 | |||
| 615 | // Module code. | ||
| 616 | { | ||
| 617 | PyObject *tmp_assign_source_1; | ||
| 618 | tmp_assign_source_1 = const_str_digest_f10e2ec87b7dc4cd78c14bbcc06032c1; | ||
| 619 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 620 | } | ||
| 621 | { | ||
| 622 | PyObject *tmp_assign_source_2; | ||
| 623 | tmp_assign_source_2 = module_filename_obj; | ||
| 624 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 625 | } | ||
| 626 | // Frame without reuse. | ||
| 627 | frame_898fab06db015892e566f047251b199f = MAKE_MODULE_FRAME( codeobj_898fab06db015892e566f047251b199f, module_dbus$mainloop$glib ); | ||
| 628 | |||
| 629 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 630 | // owning it. | ||
| 631 | pushFrameStack( frame_898fab06db015892e566f047251b199f ); | ||
| 632 | assert( Py_REFCNT( frame_898fab06db015892e566f047251b199f ) == 2 ); | ||
| 633 | |||
| 634 | // Framed code: | ||
| 635 | { | ||
| 636 | PyObject *tmp_assattr_name_1; | ||
| 637 | PyObject *tmp_assattr_target_1; | ||
| 638 | PyObject *tmp_mvar_value_1; | ||
| 639 | tmp_assattr_name_1 = module_filename_obj; | ||
| 640 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 641 | |||
| 642 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 643 | { | ||
| 644 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 645 | } | ||
| 646 | |||
| 647 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 648 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 649 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 650 | if ( tmp_result == false ) | ||
| 651 | { | ||
| 652 | assert( ERROR_OCCURRED() ); | ||
| 653 | |||
| 654 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 655 | |||
| 656 | |||
| 657 | exception_lineno = 1; | ||
| 658 | |||
| 659 | goto frame_exception_exit_1; | ||
| 660 | } | ||
| 661 | } | ||
| 662 | { | ||
| 663 | PyObject *tmp_assattr_name_2; | ||
| 664 | PyObject *tmp_assattr_target_2; | ||
| 665 | PyObject *tmp_mvar_value_2; | ||
| 666 | tmp_assattr_name_2 = Py_True; | ||
| 667 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 668 | |||
| 669 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 670 | { | ||
| 671 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 672 | } | ||
| 673 | |||
| 674 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 675 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 676 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 677 | if ( tmp_result == false ) | ||
| 678 | { | ||
| 679 | assert( ERROR_OCCURRED() ); | ||
| 680 | |||
| 681 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 682 | |||
| 683 | |||
| 684 | exception_lineno = 1; | ||
| 685 | |||
| 686 | goto frame_exception_exit_1; | ||
| 687 | } | ||
| 688 | } | ||
| 689 | { | ||
| 690 | PyObject *tmp_assign_source_3; | ||
| 691 | tmp_assign_source_3 = Py_None; | ||
| 692 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 693 | } | ||
| 694 | { | ||
| 695 | PyObject *tmp_assign_source_4; | ||
| 696 | tmp_assign_source_4 = const_tuple_str_plain_DBusGMainLoop_str_plain_threads_init_tuple; | ||
| 697 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___all__, tmp_assign_source_4 ); | ||
| 698 | } | ||
| 699 | { | ||
| 700 | PyObject *tmp_assign_source_5; | ||
| 701 | PyObject *tmp_name_name_1; | ||
| 702 | PyObject *tmp_globals_name_1; | ||
| 703 | PyObject *tmp_locals_name_1; | ||
| 704 | PyObject *tmp_fromlist_name_1; | ||
| 705 | PyObject *tmp_level_name_1; | ||
| 706 | tmp_name_name_1 = const_str_plain__dbus_glib_bindings; | ||
| 707 | tmp_globals_name_1 = (PyObject *)moduledict_dbus$mainloop$glib; | ||
| 708 | tmp_locals_name_1 = Py_None; | ||
| 709 | tmp_fromlist_name_1 = const_tuple_str_plain_DBusGMainLoop_str_plain_gthreads_init_tuple; | ||
| 710 | tmp_level_name_1 = const_int_0; | ||
| 711 | frame_898fab06db015892e566f047251b199f->m_frame.f_lineno = 29; | ||
| 712 | tmp_assign_source_5 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 713 | if ( tmp_assign_source_5 == NULL ) | ||
| 714 | { | ||
| 715 | assert( ERROR_OCCURRED() ); | ||
| 716 | |||
| 717 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 718 | |||
| 719 | |||
| 720 | exception_lineno = 29; | ||
| 721 | |||
| 722 | goto frame_exception_exit_1; | ||
| 723 | } | ||
| 724 | assert( tmp_import_from_1__module == NULL ); | ||
| 725 | tmp_import_from_1__module = tmp_assign_source_5; | ||
| 726 | } | ||
| 727 | // Tried code: | ||
| 728 | { | ||
| 729 | PyObject *tmp_assign_source_6; | ||
| 730 | PyObject *tmp_import_name_from_1; | ||
| 731 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 732 | tmp_import_name_from_1 = tmp_import_from_1__module; | ||
| 733 | tmp_assign_source_6 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_DBusGMainLoop ); | ||
| 734 | if ( tmp_assign_source_6 == NULL ) | ||
| 735 | { | ||
| 736 | assert( ERROR_OCCURRED() ); | ||
| 737 | |||
| 738 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 739 | |||
| 740 | |||
| 741 | exception_lineno = 29; | ||
| 742 | |||
| 743 | goto try_except_handler_1; | ||
| 744 | } | ||
| 745 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain_DBusGMainLoop, tmp_assign_source_6 ); | ||
| 746 | } | ||
| 747 | { | ||
| 748 | PyObject *tmp_assign_source_7; | ||
| 749 | PyObject *tmp_import_name_from_2; | ||
| 750 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 751 | tmp_import_name_from_2 = tmp_import_from_1__module; | ||
| 752 | tmp_assign_source_7 = IMPORT_NAME( tmp_import_name_from_2, const_str_plain_gthreads_init ); | ||
| 753 | if ( tmp_assign_source_7 == NULL ) | ||
| 754 | { | ||
| 755 | assert( ERROR_OCCURRED() ); | ||
| 756 | |||
| 757 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 758 | |||
| 759 | |||
| 760 | exception_lineno = 29; | ||
| 761 | |||
| 762 | goto try_except_handler_1; | ||
| 763 | } | ||
| 764 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain_gthreads_init, tmp_assign_source_7 ); | ||
| 765 | } | ||
| 766 | goto try_end_1; | ||
| 767 | // Exception handler code: | ||
| 768 | try_except_handler_1:; | ||
| 769 | exception_keeper_type_1 = exception_type; | ||
| 770 | exception_keeper_value_1 = exception_value; | ||
| 771 | exception_keeper_tb_1 = exception_tb; | ||
| 772 | exception_keeper_lineno_1 = exception_lineno; | ||
| 773 | exception_type = NULL; | ||
| 774 | exception_value = NULL; | ||
| 775 | exception_tb = NULL; | ||
| 776 | exception_lineno = 0; | ||
| 777 | |||
| 778 | CHECK_OBJECT( (PyObject *)tmp_import_from_1__module ); | ||
| 779 | Py_DECREF( tmp_import_from_1__module ); | ||
| 780 | tmp_import_from_1__module = NULL; | ||
| 781 | |||
| 782 | // Re-raise. | ||
| 783 | exception_type = exception_keeper_type_1; | ||
| 784 | exception_value = exception_keeper_value_1; | ||
| 785 | exception_tb = exception_keeper_tb_1; | ||
| 786 | exception_lineno = exception_keeper_lineno_1; | ||
| 787 | |||
| 788 | goto frame_exception_exit_1; | ||
| 789 | // End of try: | ||
| 790 | try_end_1:; | ||
| 791 | |||
| 792 | // Restore frame exception if necessary. | ||
| 793 | #if 0 | ||
| 794 | RESTORE_FRAME_EXCEPTION( frame_898fab06db015892e566f047251b199f ); | ||
| 795 | #endif | ||
| 796 | popFrameStack(); | ||
| 797 | |||
| 798 | assertFrameObject( frame_898fab06db015892e566f047251b199f ); | ||
| 799 | |||
| 800 | goto frame_no_exception_1; | ||
| 801 | |||
| 802 | frame_exception_exit_1:; | ||
| 803 | #if 0 | ||
| 804 | RESTORE_FRAME_EXCEPTION( frame_898fab06db015892e566f047251b199f ); | ||
| 805 | #endif | ||
| 806 | |||
| 807 | if ( exception_tb == NULL ) | ||
| 808 | { | ||
| 809 | exception_tb = MAKE_TRACEBACK( frame_898fab06db015892e566f047251b199f, exception_lineno ); | ||
| 810 | } | ||
| 811 | else if ( exception_tb->tb_frame != &frame_898fab06db015892e566f047251b199f->m_frame ) | ||
| 812 | { | ||
| 813 | exception_tb = ADD_TRACEBACK( exception_tb, frame_898fab06db015892e566f047251b199f, exception_lineno ); | ||
| 814 | } | ||
| 815 | |||
| 816 | // Put the previous frame back on top. | ||
| 817 | popFrameStack(); | ||
| 818 | |||
| 819 | // Return the error. | ||
| 820 | goto module_exception_exit; | ||
| 821 | |||
| 822 | frame_no_exception_1:; | ||
| 823 | CHECK_OBJECT( (PyObject *)tmp_import_from_1__module ); | ||
| 824 | Py_DECREF( tmp_import_from_1__module ); | ||
| 825 | tmp_import_from_1__module = NULL; | ||
| 826 | |||
| 827 | { | ||
| 828 | PyObject *tmp_assign_source_8; | ||
| 829 | tmp_assign_source_8 = Py_False; | ||
| 830 | UPDATE_STRING_DICT0( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain__dbus_gthreads_initialized, tmp_assign_source_8 ); | ||
| 831 | } | ||
| 832 | { | ||
| 833 | PyObject *tmp_assign_source_9; | ||
| 834 | tmp_assign_source_9 = MAKE_FUNCTION_dbus$mainloop$glib$$$function_1_threads_init( ); | ||
| 835 | |||
| 836 | |||
| 837 | |||
| 838 | UPDATE_STRING_DICT1( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain_threads_init, tmp_assign_source_9 ); | ||
| 839 | } | ||
| 840 | |||
| 841 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 842 | #if 0 && 0 | ||
| 843 | { | ||
| 844 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_dbus$mainloop$glib, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 845 | |||
| 846 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 847 | { | ||
| 848 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 849 | |||
| 850 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 851 | CHECK_OBJECT( path_importer_cache ); | ||
| 852 | |||
| 853 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 854 | assert( res == 0 ); | ||
| 855 | } | ||
| 856 | } | ||
| 857 | #endif | ||
| 858 | #endif | ||
| 859 | |||
| 860 | return MOD_RETURN_VALUE( module_dbus$mainloop$glib ); | ||
| 861 | module_exception_exit: | ||
| 862 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 863 | return MOD_RETURN_VALUE( NULL ); | ||
| 864 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.dbus.mainloop.glib.o deleted (index e0fc92f..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.dbus.mainloop.o deleted (index 721ce3a..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.dbus.o deleted (index 1cecb53..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.dbus.proxies.c is too big (18793 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.dbus.proxies.o deleted (index 484f085..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.dbus.types.c deleted (index 52f6afd..0000000) | |||
| 1 | /* Generated code for Python module 'dbus.types' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_dbus$types" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_dbus$types; | ||
| 31 | PyDictObject *moduledict_dbus$types; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain_Signature; | ||
| 35 | extern PyObject *const_str_plain_Struct; | ||
| 36 | static PyObject *const_str_digest_bee3442881305db322ec1ee71f49c522; | ||
| 37 | extern PyObject *const_str_plain___spec__; | ||
| 38 | extern PyObject *const_tuple_str_plain_UTF8String_tuple; | ||
| 39 | extern PyObject *const_str_plain_Int16; | ||
| 40 | extern PyObject *const_str_plain___all__; | ||
| 41 | extern PyObject *const_str_plain_Byte; | ||
| 42 | extern PyObject *const_str_plain___file__; | ||
| 43 | extern PyObject *const_str_plain__dbus_bindings; | ||
| 44 | extern PyObject *const_str_plain_UInt32; | ||
| 45 | static PyObject *const_str_plain_UnixFd; | ||
| 46 | extern PyObject *const_str_digest_3aa5bee4de9b0149ae46ffed8a38c6b4; | ||
| 47 | extern PyObject *const_int_0; | ||
| 48 | extern PyObject *const_str_plain_ByteArray; | ||
| 49 | extern PyObject *const_str_plain_UInt16; | ||
| 50 | static PyObject *const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple; | ||
| 51 | extern PyObject *const_str_digest_1abd3647207b34d013514bc0c6956d0b; | ||
| 52 | extern PyObject *const_str_plain_String; | ||
| 53 | static PyObject *const_list_63dc2697da2db86ddf6a017a29605028_list; | ||
| 54 | extern PyObject *const_str_plain_Int32; | ||
| 55 | extern PyObject *const_tuple_str_plain_is_py2_tuple; | ||
| 56 | extern PyObject *const_str_plain_origin; | ||
| 57 | extern PyObject *const_str_plain_Array; | ||
| 58 | extern PyObject *const_str_plain_Boolean; | ||
| 59 | extern PyObject *const_str_plain_UInt64; | ||
| 60 | extern PyObject *const_tuple_empty; | ||
| 61 | extern PyObject *const_str_plain_has_location; | ||
| 62 | extern PyObject *const_str_plain_ObjectPath; | ||
| 63 | extern PyObject *const_str_plain_UTF8String; | ||
| 64 | extern PyObject *const_str_plain_append; | ||
| 65 | extern PyObject *const_str_plain_Dictionary; | ||
| 66 | extern PyObject *const_str_plain_Int64; | ||
| 67 | extern PyObject *const_str_plain_is_py2; | ||
| 68 | extern PyObject *const_str_plain_Double; | ||
| 69 | static PyObject *const_str_digest_1fb636284d1dc24661eb9fc5aac76a76; | ||
| 70 | extern PyObject *const_str_plain___doc__; | ||
| 71 | extern PyObject *const_str_plain___cached__; | ||
| 72 | static PyObject *module_filename_obj; | ||
| 73 | |||
| 74 | /* Indicator if this modules private constants were created yet. */ | ||
| 75 | static bool constants_created = false; | ||
| 76 | |||
| 77 | /* Function to create module private constants. */ | ||
| 78 | static void createModuleConstants( void ) | ||
| 79 | { | ||
| 80 | const_str_digest_bee3442881305db322ec1ee71f49c522 = UNSTREAM_STRING_ASCII( &constant_bin[ 34005 ], 19, 0 ); | ||
| 81 | const_str_plain_UnixFd = UNSTREAM_STRING_ASCII( &constant_bin[ 34024 ], 6, 1 ); | ||
| 82 | const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple = PyTuple_New( 17 ); | ||
| 83 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 0, const_str_plain_Array ); Py_INCREF( const_str_plain_Array ); | ||
| 84 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 1, const_str_plain_Boolean ); Py_INCREF( const_str_plain_Boolean ); | ||
| 85 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 2, const_str_plain_Byte ); Py_INCREF( const_str_plain_Byte ); | ||
| 86 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 3, const_str_plain_ByteArray ); Py_INCREF( const_str_plain_ByteArray ); | ||
| 87 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 4, const_str_plain_Dictionary ); Py_INCREF( const_str_plain_Dictionary ); | ||
| 88 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 5, const_str_plain_Double ); Py_INCREF( const_str_plain_Double ); | ||
| 89 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 6, const_str_plain_Int16 ); Py_INCREF( const_str_plain_Int16 ); | ||
| 90 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 7, const_str_plain_Int32 ); Py_INCREF( const_str_plain_Int32 ); | ||
| 91 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 8, const_str_plain_Int64 ); Py_INCREF( const_str_plain_Int64 ); | ||
| 92 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 9, const_str_plain_ObjectPath ); Py_INCREF( const_str_plain_ObjectPath ); | ||
| 93 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 10, const_str_plain_Signature ); Py_INCREF( const_str_plain_Signature ); | ||
| 94 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 11, const_str_plain_String ); Py_INCREF( const_str_plain_String ); | ||
| 95 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 12, const_str_plain_Struct ); Py_INCREF( const_str_plain_Struct ); | ||
| 96 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 13, const_str_plain_UInt16 ); Py_INCREF( const_str_plain_UInt16 ); | ||
| 97 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 14, const_str_plain_UInt32 ); Py_INCREF( const_str_plain_UInt32 ); | ||
| 98 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 15, const_str_plain_UInt64 ); Py_INCREF( const_str_plain_UInt64 ); | ||
| 99 | PyTuple_SET_ITEM( const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple, 16, const_str_plain_UnixFd ); Py_INCREF( const_str_plain_UnixFd ); | ||
| 100 | const_list_63dc2697da2db86ddf6a017a29605028_list = PyList_New( 17 ); | ||
| 101 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 0, const_str_plain_ObjectPath ); Py_INCREF( const_str_plain_ObjectPath ); | ||
| 102 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 1, const_str_plain_ByteArray ); Py_INCREF( const_str_plain_ByteArray ); | ||
| 103 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 2, const_str_plain_Signature ); Py_INCREF( const_str_plain_Signature ); | ||
| 104 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 3, const_str_plain_Byte ); Py_INCREF( const_str_plain_Byte ); | ||
| 105 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 4, const_str_plain_Boolean ); Py_INCREF( const_str_plain_Boolean ); | ||
| 106 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 5, const_str_plain_Int16 ); Py_INCREF( const_str_plain_Int16 ); | ||
| 107 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 6, const_str_plain_UInt16 ); Py_INCREF( const_str_plain_UInt16 ); | ||
| 108 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 7, const_str_plain_Int32 ); Py_INCREF( const_str_plain_Int32 ); | ||
| 109 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 8, const_str_plain_UInt32 ); Py_INCREF( const_str_plain_UInt32 ); | ||
| 110 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 9, const_str_plain_Int64 ); Py_INCREF( const_str_plain_Int64 ); | ||
| 111 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 10, const_str_plain_UInt64 ); Py_INCREF( const_str_plain_UInt64 ); | ||
| 112 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 11, const_str_plain_Double ); Py_INCREF( const_str_plain_Double ); | ||
| 113 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 12, const_str_plain_String ); Py_INCREF( const_str_plain_String ); | ||
| 114 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 13, const_str_plain_Array ); Py_INCREF( const_str_plain_Array ); | ||
| 115 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 14, const_str_plain_Struct ); Py_INCREF( const_str_plain_Struct ); | ||
| 116 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 15, const_str_plain_Dictionary ); Py_INCREF( const_str_plain_Dictionary ); | ||
| 117 | PyList_SET_ITEM( const_list_63dc2697da2db86ddf6a017a29605028_list, 16, const_str_plain_UnixFd ); Py_INCREF( const_str_plain_UnixFd ); | ||
| 118 | const_str_digest_1fb636284d1dc24661eb9fc5aac76a76 = UNSTREAM_STRING_ASCII( &constant_bin[ 34030 ], 13, 0 ); | ||
| 119 | |||
| 120 | constants_created = true; | ||
| 121 | } | ||
| 122 | |||
| 123 | /* Function to verify module private constants for non-corruption. */ | ||
| 124 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 125 | void checkModuleConstants_dbus$types( void ) | ||
| 126 | { | ||
| 127 | // The module may not have been used at all, then ignore this. | ||
| 128 | if (constants_created == false) return; | ||
| 129 | |||
| 130 | |||
| 131 | } | ||
| 132 | #endif | ||
| 133 | |||
| 134 | // The module code objects. | ||
| 135 | static PyCodeObject *codeobj_1adf4263eda07e431174fcc04407385b; | ||
| 136 | |||
| 137 | static void createModuleCodeObjects(void) | ||
| 138 | { | ||
| 139 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_1fb636284d1dc24661eb9fc5aac76a76 ); | ||
| 140 | codeobj_1adf4263eda07e431174fcc04407385b = MAKE_CODEOBJ( module_filename_obj, const_str_digest_bee3442881305db322ec1ee71f49c522, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 141 | } | ||
| 142 | |||
| 143 | // The module function declarations. | ||
| 144 | |||
| 145 | |||
| 146 | // The module function definitions. | ||
| 147 | |||
| 148 | |||
| 149 | |||
| 150 | #if PYTHON_VERSION >= 300 | ||
| 151 | static struct PyModuleDef mdef_dbus$types = | ||
| 152 | { | ||
| 153 | PyModuleDef_HEAD_INIT, | ||
| 154 | "dbus.types", | ||
| 155 | NULL, /* m_doc */ | ||
| 156 | -1, /* m_size */ | ||
| 157 | NULL, /* m_methods */ | ||
| 158 | NULL, /* m_reload */ | ||
| 159 | NULL, /* m_traverse */ | ||
| 160 | NULL, /* m_clear */ | ||
| 161 | NULL, /* m_free */ | ||
| 162 | }; | ||
| 163 | #endif | ||
| 164 | |||
| 165 | extern PyObject *const_str_plain___compiled__; | ||
| 166 | |||
| 167 | extern PyObject *const_str_plain___package__; | ||
| 168 | |||
| 169 | #if PYTHON_VERSION >= 300 | ||
| 170 | extern PyObject *const_str_dot; | ||
| 171 | extern PyObject *const_str_plain___loader__; | ||
| 172 | #endif | ||
| 173 | |||
| 174 | #if PYTHON_VERSION >= 340 | ||
| 175 | extern PyObject *const_str_plain___spec__; | ||
| 176 | extern PyObject *const_str_plain__initializing; | ||
| 177 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 178 | #endif | ||
| 179 | |||
| 180 | extern void _initCompiledCellType(); | ||
| 181 | extern void _initCompiledGeneratorType(); | ||
| 182 | extern void _initCompiledFunctionType(); | ||
| 183 | extern void _initCompiledMethodType(); | ||
| 184 | extern void _initCompiledFrameType(); | ||
| 185 | #if PYTHON_VERSION >= 350 | ||
| 186 | extern void _initCompiledCoroutineTypes(); | ||
| 187 | #endif | ||
| 188 | #if PYTHON_VERSION >= 360 | ||
| 189 | extern void _initCompiledAsyncgenTypes(); | ||
| 190 | #endif | ||
| 191 | |||
| 192 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 193 | |||
| 194 | // The exported interface to CPython. On import of the module, this function | ||
| 195 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 196 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 197 | |||
| 198 | MOD_INIT_DECL( dbus$types ) | ||
| 199 | { | ||
| 200 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 201 | static bool _init_done = false; | ||
| 202 | |||
| 203 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 204 | if ( _init_done ) | ||
| 205 | { | ||
| 206 | return MOD_RETURN_VALUE( module_dbus$types ); | ||
| 207 | } | ||
| 208 | else | ||
| 209 | { | ||
| 210 | _init_done = true; | ||
| 211 | } | ||
| 212 | #endif | ||
| 213 | |||
| 214 | #ifdef _NUITKA_MODULE | ||
| 215 | // In case of a stand alone extension module, need to call initialization | ||
| 216 | // the init here because that's the first and only time we are going to get | ||
| 217 | // called here. | ||
| 218 | |||
| 219 | // Initialize the constant values used. | ||
| 220 | _initBuiltinModule(); | ||
| 221 | createGlobalConstants(); | ||
| 222 | |||
| 223 | /* Initialize the compiled types of Nuitka. */ | ||
| 224 | _initCompiledCellType(); | ||
| 225 | _initCompiledGeneratorType(); | ||
| 226 | _initCompiledFunctionType(); | ||
| 227 | _initCompiledMethodType(); | ||
| 228 | _initCompiledFrameType(); | ||
| 229 | #if PYTHON_VERSION >= 350 | ||
| 230 | _initCompiledCoroutineTypes(); | ||
| 231 | #endif | ||
| 232 | #if PYTHON_VERSION >= 360 | ||
| 233 | _initCompiledAsyncgenTypes(); | ||
| 234 | #endif | ||
| 235 | |||
| 236 | #if PYTHON_VERSION < 300 | ||
| 237 | _initSlotCompare(); | ||
| 238 | #endif | ||
| 239 | #if PYTHON_VERSION >= 270 | ||
| 240 | _initSlotIternext(); | ||
| 241 | #endif | ||
| 242 | |||
| 243 | patchBuiltinModule(); | ||
| 244 | patchTypeComparison(); | ||
| 245 | |||
| 246 | // Enable meta path based loader if not already done. | ||
| 247 | #ifdef _NUITKA_TRACE | ||
| 248 | puts("dbus.types: Calling setupMetaPathBasedLoader()."); | ||
| 249 | #endif | ||
| 250 | setupMetaPathBasedLoader(); | ||
| 251 | |||
| 252 | #if PYTHON_VERSION >= 300 | ||
| 253 | patchInspectModule(); | ||
| 254 | #endif | ||
| 255 | |||
| 256 | #endif | ||
| 257 | |||
| 258 | /* The constants only used by this module are created now. */ | ||
| 259 | #ifdef _NUITKA_TRACE | ||
| 260 | puts("dbus.types: Calling createModuleConstants()."); | ||
| 261 | #endif | ||
| 262 | createModuleConstants(); | ||
| 263 | |||
| 264 | /* The code objects used by this module are created now. */ | ||
| 265 | #ifdef _NUITKA_TRACE | ||
| 266 | puts("dbus.types: Calling createModuleCodeObjects()."); | ||
| 267 | #endif | ||
| 268 | createModuleCodeObjects(); | ||
| 269 | |||
| 270 | // puts( "in initdbus$types" ); | ||
| 271 | |||
| 272 | // Create the module object first. There are no methods initially, all are | ||
| 273 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 274 | // set at this time, as it could not contain NUL characters this way, they | ||
| 275 | // are instead set in early module code. No "self" for modules, we have no | ||
| 276 | // use for it. | ||
| 277 | #if PYTHON_VERSION < 300 | ||
| 278 | module_dbus$types = Py_InitModule4( | ||
| 279 | "dbus.types", // Module Name | ||
| 280 | NULL, // No methods initially, all are added | ||
| 281 | // dynamically in actual module code only. | ||
| 282 | NULL, // No "__doc__" is initially set, as it could | ||
| 283 | // not contain NUL this way, added early in | ||
| 284 | // actual code. | ||
| 285 | NULL, // No self for modules, we don't use it. | ||
| 286 | PYTHON_API_VERSION | ||
| 287 | ); | ||
| 288 | #else | ||
| 289 | |||
| 290 | module_dbus$types = PyModule_Create( &mdef_dbus$types ); | ||
| 291 | #endif | ||
| 292 | |||
| 293 | moduledict_dbus$types = MODULE_DICT( module_dbus$types ); | ||
| 294 | |||
| 295 | // Set __compiled__ to what it we know. | ||
| 296 | UPDATE_STRING_DICT1( | ||
| 297 | moduledict_dbus$types, | ||
| 298 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 299 | Nuitka_dunder_compiled_value | ||
| 300 | ); | ||
| 301 | |||
| 302 | // Update "__package__" value to what it ought to be. | ||
| 303 | { | ||
| 304 | #if 0 | ||
| 305 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 306 | |||
| 307 | UPDATE_STRING_DICT1( | ||
| 308 | moduledict_dbus$types, | ||
| 309 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 310 | module_name | ||
| 311 | ); | ||
| 312 | #else | ||
| 313 | |||
| 314 | #if PYTHON_VERSION < 300 | ||
| 315 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 316 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 317 | |||
| 318 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 319 | |||
| 320 | if ( last_dot != NULL ) | ||
| 321 | { | ||
| 322 | UPDATE_STRING_DICT1( | ||
| 323 | moduledict_dbus$types, | ||
| 324 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 325 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 326 | ); | ||
| 327 | } | ||
| 328 | #else | ||
| 329 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 330 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 331 | |||
| 332 | if ( dot_index != -1 ) | ||
| 333 | { | ||
| 334 | UPDATE_STRING_DICT1( | ||
| 335 | moduledict_dbus$types, | ||
| 336 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 337 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 338 | ); | ||
| 339 | } | ||
| 340 | #endif | ||
| 341 | #endif | ||
| 342 | } | ||
| 343 | |||
| 344 | CHECK_OBJECT( module_dbus$types ); | ||
| 345 | |||
| 346 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 347 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 348 | #if PYTHON_VERSION >= 300 | ||
| 349 | { | ||
| 350 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_1abd3647207b34d013514bc0c6956d0b, module_dbus$types ); | ||
| 351 | |||
| 352 | assert( r != -1 ); | ||
| 353 | } | ||
| 354 | #endif | ||
| 355 | |||
| 356 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 357 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 358 | // before the frame object is allocated, or else it may fail. | ||
| 359 | |||
| 360 | if ( GET_STRING_DICT_VALUE( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 361 | { | ||
| 362 | PyObject *value = (PyObject *)builtin_module; | ||
| 363 | |||
| 364 | // Check if main module, not a dict then but the module itself. | ||
| 365 | #if !defined(_NUITKA_EXE) || !0 | ||
| 366 | value = PyModule_GetDict( value ); | ||
| 367 | #endif | ||
| 368 | |||
| 369 | UPDATE_STRING_DICT0( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 370 | } | ||
| 371 | |||
| 372 | #if PYTHON_VERSION >= 300 | ||
| 373 | UPDATE_STRING_DICT0( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 374 | #endif | ||
| 375 | |||
| 376 | #if PYTHON_VERSION >= 340 | ||
| 377 | // Set the "__spec__" value | ||
| 378 | |||
| 379 | #if 0 | ||
| 380 | // Main modules just get "None" as spec. | ||
| 381 | UPDATE_STRING_DICT0( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 382 | #else | ||
| 383 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 384 | { | ||
| 385 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 386 | CHECK_OBJECT( bootstrap_module ); | ||
| 387 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 388 | Py_DECREF( bootstrap_module ); | ||
| 389 | |||
| 390 | PyObject *args[] = { | ||
| 391 | GET_STRING_DICT_VALUE( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 392 | (PyObject *)&Nuitka_Loader_Type | ||
| 393 | }; | ||
| 394 | |||
| 395 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 396 | module_spec_class, | ||
| 397 | args | ||
| 398 | ); | ||
| 399 | Py_DECREF( module_spec_class ); | ||
| 400 | |||
| 401 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 402 | CHECK_OBJECT( spec_value ); | ||
| 403 | |||
| 404 | // For packages set the submodule search locations as well, even if to empty | ||
| 405 | // list, so investigating code will consider it a package. | ||
| 406 | #if 0 | ||
| 407 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 408 | #endif | ||
| 409 | |||
| 410 | // Mark the execution in the "__spec__" value. | ||
| 411 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 412 | |||
| 413 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 414 | } | ||
| 415 | #endif | ||
| 416 | #endif | ||
| 417 | |||
| 418 | // Temp variables if any | ||
| 419 | PyObject *tmp_import_from_1__module = NULL; | ||
| 420 | struct Nuitka_FrameObject *frame_1adf4263eda07e431174fcc04407385b; | ||
| 421 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 422 | bool tmp_result; | ||
| 423 | PyObject *exception_type = NULL; | ||
| 424 | PyObject *exception_value = NULL; | ||
| 425 | PyTracebackObject *exception_tb = NULL; | ||
| 426 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 427 | PyObject *exception_keeper_type_1; | ||
| 428 | PyObject *exception_keeper_value_1; | ||
| 429 | PyTracebackObject *exception_keeper_tb_1; | ||
| 430 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 431 | |||
| 432 | // Module code. | ||
| 433 | { | ||
| 434 | PyObject *tmp_assign_source_1; | ||
| 435 | tmp_assign_source_1 = Py_None; | ||
| 436 | UPDATE_STRING_DICT0( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 437 | } | ||
| 438 | { | ||
| 439 | PyObject *tmp_assign_source_2; | ||
| 440 | tmp_assign_source_2 = module_filename_obj; | ||
| 441 | UPDATE_STRING_DICT0( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 442 | } | ||
| 443 | // Frame without reuse. | ||
| 444 | frame_1adf4263eda07e431174fcc04407385b = MAKE_MODULE_FRAME( codeobj_1adf4263eda07e431174fcc04407385b, module_dbus$types ); | ||
| 445 | |||
| 446 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 447 | // owning it. | ||
| 448 | pushFrameStack( frame_1adf4263eda07e431174fcc04407385b ); | ||
| 449 | assert( Py_REFCNT( frame_1adf4263eda07e431174fcc04407385b ) == 2 ); | ||
| 450 | |||
| 451 | // Framed code: | ||
| 452 | { | ||
| 453 | PyObject *tmp_assattr_name_1; | ||
| 454 | PyObject *tmp_assattr_target_1; | ||
| 455 | PyObject *tmp_mvar_value_1; | ||
| 456 | tmp_assattr_name_1 = module_filename_obj; | ||
| 457 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 458 | |||
| 459 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 460 | { | ||
| 461 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 462 | } | ||
| 463 | |||
| 464 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 465 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 466 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 467 | if ( tmp_result == false ) | ||
| 468 | { | ||
| 469 | assert( ERROR_OCCURRED() ); | ||
| 470 | |||
| 471 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 472 | |||
| 473 | |||
| 474 | exception_lineno = 1; | ||
| 475 | |||
| 476 | goto frame_exception_exit_1; | ||
| 477 | } | ||
| 478 | } | ||
| 479 | { | ||
| 480 | PyObject *tmp_assattr_name_2; | ||
| 481 | PyObject *tmp_assattr_target_2; | ||
| 482 | PyObject *tmp_mvar_value_2; | ||
| 483 | tmp_assattr_name_2 = Py_True; | ||
| 484 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 485 | |||
| 486 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 487 | { | ||
| 488 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 489 | } | ||
| 490 | |||
| 491 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 492 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 493 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 494 | if ( tmp_result == false ) | ||
| 495 | { | ||
| 496 | assert( ERROR_OCCURRED() ); | ||
| 497 | |||
| 498 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 499 | |||
| 500 | |||
| 501 | exception_lineno = 1; | ||
| 502 | |||
| 503 | goto frame_exception_exit_1; | ||
| 504 | } | ||
| 505 | } | ||
| 506 | { | ||
| 507 | PyObject *tmp_assign_source_3; | ||
| 508 | tmp_assign_source_3 = Py_None; | ||
| 509 | UPDATE_STRING_DICT0( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 510 | } | ||
| 511 | { | ||
| 512 | PyObject *tmp_assign_source_4; | ||
| 513 | tmp_assign_source_4 = LIST_COPY( const_list_63dc2697da2db86ddf6a017a29605028_list ); | ||
| 514 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___all__, tmp_assign_source_4 ); | ||
| 515 | } | ||
| 516 | { | ||
| 517 | PyObject *tmp_assign_source_5; | ||
| 518 | PyObject *tmp_name_name_1; | ||
| 519 | PyObject *tmp_globals_name_1; | ||
| 520 | PyObject *tmp_locals_name_1; | ||
| 521 | PyObject *tmp_fromlist_name_1; | ||
| 522 | PyObject *tmp_level_name_1; | ||
| 523 | tmp_name_name_1 = const_str_plain__dbus_bindings; | ||
| 524 | tmp_globals_name_1 = (PyObject *)moduledict_dbus$types; | ||
| 525 | tmp_locals_name_1 = Py_None; | ||
| 526 | tmp_fromlist_name_1 = const_tuple_cde4d3ca5dc75371f7c0953ed8a8aecd_tuple; | ||
| 527 | tmp_level_name_1 = const_int_0; | ||
| 528 | frame_1adf4263eda07e431174fcc04407385b->m_frame.f_lineno = 6; | ||
| 529 | tmp_assign_source_5 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 530 | if ( tmp_assign_source_5 == NULL ) | ||
| 531 | { | ||
| 532 | assert( ERROR_OCCURRED() ); | ||
| 533 | |||
| 534 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 535 | |||
| 536 | |||
| 537 | exception_lineno = 6; | ||
| 538 | |||
| 539 | goto frame_exception_exit_1; | ||
| 540 | } | ||
| 541 | assert( tmp_import_from_1__module == NULL ); | ||
| 542 | tmp_import_from_1__module = tmp_assign_source_5; | ||
| 543 | } | ||
| 544 | // Tried code: | ||
| 545 | { | ||
| 546 | PyObject *tmp_assign_source_6; | ||
| 547 | PyObject *tmp_import_name_from_1; | ||
| 548 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 549 | tmp_import_name_from_1 = tmp_import_from_1__module; | ||
| 550 | tmp_assign_source_6 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_Array ); | ||
| 551 | if ( tmp_assign_source_6 == NULL ) | ||
| 552 | { | ||
| 553 | assert( ERROR_OCCURRED() ); | ||
| 554 | |||
| 555 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 556 | |||
| 557 | |||
| 558 | exception_lineno = 6; | ||
| 559 | |||
| 560 | goto try_except_handler_1; | ||
| 561 | } | ||
| 562 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_Array, tmp_assign_source_6 ); | ||
| 563 | } | ||
| 564 | { | ||
| 565 | PyObject *tmp_assign_source_7; | ||
| 566 | PyObject *tmp_import_name_from_2; | ||
| 567 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 568 | tmp_import_name_from_2 = tmp_import_from_1__module; | ||
| 569 | tmp_assign_source_7 = IMPORT_NAME( tmp_import_name_from_2, const_str_plain_Boolean ); | ||
| 570 | if ( tmp_assign_source_7 == NULL ) | ||
| 571 | { | ||
| 572 | assert( ERROR_OCCURRED() ); | ||
| 573 | |||
| 574 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 575 | |||
| 576 | |||
| 577 | exception_lineno = 6; | ||
| 578 | |||
| 579 | goto try_except_handler_1; | ||
| 580 | } | ||
| 581 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_Boolean, tmp_assign_source_7 ); | ||
| 582 | } | ||
| 583 | { | ||
| 584 | PyObject *tmp_assign_source_8; | ||
| 585 | PyObject *tmp_import_name_from_3; | ||
| 586 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 587 | tmp_import_name_from_3 = tmp_import_from_1__module; | ||
| 588 | tmp_assign_source_8 = IMPORT_NAME( tmp_import_name_from_3, const_str_plain_Byte ); | ||
| 589 | if ( tmp_assign_source_8 == NULL ) | ||
| 590 | { | ||
| 591 | assert( ERROR_OCCURRED() ); | ||
| 592 | |||
| 593 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 594 | |||
| 595 | |||
| 596 | exception_lineno = 6; | ||
| 597 | |||
| 598 | goto try_except_handler_1; | ||
| 599 | } | ||
| 600 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_Byte, tmp_assign_source_8 ); | ||
| 601 | } | ||
| 602 | { | ||
| 603 | PyObject *tmp_assign_source_9; | ||
| 604 | PyObject *tmp_import_name_from_4; | ||
| 605 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 606 | tmp_import_name_from_4 = tmp_import_from_1__module; | ||
| 607 | tmp_assign_source_9 = IMPORT_NAME( tmp_import_name_from_4, const_str_plain_ByteArray ); | ||
| 608 | if ( tmp_assign_source_9 == NULL ) | ||
| 609 | { | ||
| 610 | assert( ERROR_OCCURRED() ); | ||
| 611 | |||
| 612 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 613 | |||
| 614 | |||
| 615 | exception_lineno = 6; | ||
| 616 | |||
| 617 | goto try_except_handler_1; | ||
| 618 | } | ||
| 619 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_ByteArray, tmp_assign_source_9 ); | ||
| 620 | } | ||
| 621 | { | ||
| 622 | PyObject *tmp_assign_source_10; | ||
| 623 | PyObject *tmp_import_name_from_5; | ||
| 624 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 625 | tmp_import_name_from_5 = tmp_import_from_1__module; | ||
| 626 | tmp_assign_source_10 = IMPORT_NAME( tmp_import_name_from_5, const_str_plain_Dictionary ); | ||
| 627 | if ( tmp_assign_source_10 == NULL ) | ||
| 628 | { | ||
| 629 | assert( ERROR_OCCURRED() ); | ||
| 630 | |||
| 631 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 632 | |||
| 633 | |||
| 634 | exception_lineno = 6; | ||
| 635 | |||
| 636 | goto try_except_handler_1; | ||
| 637 | } | ||
| 638 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_Dictionary, tmp_assign_source_10 ); | ||
| 639 | } | ||
| 640 | { | ||
| 641 | PyObject *tmp_assign_source_11; | ||
| 642 | PyObject *tmp_import_name_from_6; | ||
| 643 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 644 | tmp_import_name_from_6 = tmp_import_from_1__module; | ||
| 645 | tmp_assign_source_11 = IMPORT_NAME( tmp_import_name_from_6, const_str_plain_Double ); | ||
| 646 | if ( tmp_assign_source_11 == NULL ) | ||
| 647 | { | ||
| 648 | assert( ERROR_OCCURRED() ); | ||
| 649 | |||
| 650 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 651 | |||
| 652 | |||
| 653 | exception_lineno = 6; | ||
| 654 | |||
| 655 | goto try_except_handler_1; | ||
| 656 | } | ||
| 657 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_Double, tmp_assign_source_11 ); | ||
| 658 | } | ||
| 659 | { | ||
| 660 | PyObject *tmp_assign_source_12; | ||
| 661 | PyObject *tmp_import_name_from_7; | ||
| 662 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 663 | tmp_import_name_from_7 = tmp_import_from_1__module; | ||
| 664 | tmp_assign_source_12 = IMPORT_NAME( tmp_import_name_from_7, const_str_plain_Int16 ); | ||
| 665 | if ( tmp_assign_source_12 == NULL ) | ||
| 666 | { | ||
| 667 | assert( ERROR_OCCURRED() ); | ||
| 668 | |||
| 669 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 670 | |||
| 671 | |||
| 672 | exception_lineno = 6; | ||
| 673 | |||
| 674 | goto try_except_handler_1; | ||
| 675 | } | ||
| 676 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_Int16, tmp_assign_source_12 ); | ||
| 677 | } | ||
| 678 | { | ||
| 679 | PyObject *tmp_assign_source_13; | ||
| 680 | PyObject *tmp_import_name_from_8; | ||
| 681 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 682 | tmp_import_name_from_8 = tmp_import_from_1__module; | ||
| 683 | tmp_assign_source_13 = IMPORT_NAME( tmp_import_name_from_8, const_str_plain_Int32 ); | ||
| 684 | if ( tmp_assign_source_13 == NULL ) | ||
| 685 | { | ||
| 686 | assert( ERROR_OCCURRED() ); | ||
| 687 | |||
| 688 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 689 | |||
| 690 | |||
| 691 | exception_lineno = 6; | ||
| 692 | |||
| 693 | goto try_except_handler_1; | ||
| 694 | } | ||
| 695 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_Int32, tmp_assign_source_13 ); | ||
| 696 | } | ||
| 697 | { | ||
| 698 | PyObject *tmp_assign_source_14; | ||
| 699 | PyObject *tmp_import_name_from_9; | ||
| 700 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 701 | tmp_import_name_from_9 = tmp_import_from_1__module; | ||
| 702 | tmp_assign_source_14 = IMPORT_NAME( tmp_import_name_from_9, const_str_plain_Int64 ); | ||
| 703 | if ( tmp_assign_source_14 == NULL ) | ||
| 704 | { | ||
| 705 | assert( ERROR_OCCURRED() ); | ||
| 706 | |||
| 707 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 708 | |||
| 709 | |||
| 710 | exception_lineno = 6; | ||
| 711 | |||
| 712 | goto try_except_handler_1; | ||
| 713 | } | ||
| 714 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_Int64, tmp_assign_source_14 ); | ||
| 715 | } | ||
| 716 | { | ||
| 717 | PyObject *tmp_assign_source_15; | ||
| 718 | PyObject *tmp_import_name_from_10; | ||
| 719 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 720 | tmp_import_name_from_10 = tmp_import_from_1__module; | ||
| 721 | tmp_assign_source_15 = IMPORT_NAME( tmp_import_name_from_10, const_str_plain_ObjectPath ); | ||
| 722 | if ( tmp_assign_source_15 == NULL ) | ||
| 723 | { | ||
| 724 | assert( ERROR_OCCURRED() ); | ||
| 725 | |||
| 726 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 727 | |||
| 728 | |||
| 729 | exception_lineno = 6; | ||
| 730 | |||
| 731 | goto try_except_handler_1; | ||
| 732 | } | ||
| 733 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_ObjectPath, tmp_assign_source_15 ); | ||
| 734 | } | ||
| 735 | { | ||
| 736 | PyObject *tmp_assign_source_16; | ||
| 737 | PyObject *tmp_import_name_from_11; | ||
| 738 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 739 | tmp_import_name_from_11 = tmp_import_from_1__module; | ||
| 740 | tmp_assign_source_16 = IMPORT_NAME( tmp_import_name_from_11, const_str_plain_Signature ); | ||
| 741 | if ( tmp_assign_source_16 == NULL ) | ||
| 742 | { | ||
| 743 | assert( ERROR_OCCURRED() ); | ||
| 744 | |||
| 745 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 746 | |||
| 747 | |||
| 748 | exception_lineno = 6; | ||
| 749 | |||
| 750 | goto try_except_handler_1; | ||
| 751 | } | ||
| 752 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_Signature, tmp_assign_source_16 ); | ||
| 753 | } | ||
| 754 | { | ||
| 755 | PyObject *tmp_assign_source_17; | ||
| 756 | PyObject *tmp_import_name_from_12; | ||
| 757 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 758 | tmp_import_name_from_12 = tmp_import_from_1__module; | ||
| 759 | tmp_assign_source_17 = IMPORT_NAME( tmp_import_name_from_12, const_str_plain_String ); | ||
| 760 | if ( tmp_assign_source_17 == NULL ) | ||
| 761 | { | ||
| 762 | assert( ERROR_OCCURRED() ); | ||
| 763 | |||
| 764 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 765 | |||
| 766 | |||
| 767 | exception_lineno = 6; | ||
| 768 | |||
| 769 | goto try_except_handler_1; | ||
| 770 | } | ||
| 771 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_String, tmp_assign_source_17 ); | ||
| 772 | } | ||
| 773 | { | ||
| 774 | PyObject *tmp_assign_source_18; | ||
| 775 | PyObject *tmp_import_name_from_13; | ||
| 776 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 777 | tmp_import_name_from_13 = tmp_import_from_1__module; | ||
| 778 | tmp_assign_source_18 = IMPORT_NAME( tmp_import_name_from_13, const_str_plain_Struct ); | ||
| 779 | if ( tmp_assign_source_18 == NULL ) | ||
| 780 | { | ||
| 781 | assert( ERROR_OCCURRED() ); | ||
| 782 | |||
| 783 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 784 | |||
| 785 | |||
| 786 | exception_lineno = 6; | ||
| 787 | |||
| 788 | goto try_except_handler_1; | ||
| 789 | } | ||
| 790 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_Struct, tmp_assign_source_18 ); | ||
| 791 | } | ||
| 792 | { | ||
| 793 | PyObject *tmp_assign_source_19; | ||
| 794 | PyObject *tmp_import_name_from_14; | ||
| 795 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 796 | tmp_import_name_from_14 = tmp_import_from_1__module; | ||
| 797 | tmp_assign_source_19 = IMPORT_NAME( tmp_import_name_from_14, const_str_plain_UInt16 ); | ||
| 798 | if ( tmp_assign_source_19 == NULL ) | ||
| 799 | { | ||
| 800 | assert( ERROR_OCCURRED() ); | ||
| 801 | |||
| 802 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 803 | |||
| 804 | |||
| 805 | exception_lineno = 6; | ||
| 806 | |||
| 807 | goto try_except_handler_1; | ||
| 808 | } | ||
| 809 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_UInt16, tmp_assign_source_19 ); | ||
| 810 | } | ||
| 811 | { | ||
| 812 | PyObject *tmp_assign_source_20; | ||
| 813 | PyObject *tmp_import_name_from_15; | ||
| 814 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 815 | tmp_import_name_from_15 = tmp_import_from_1__module; | ||
| 816 | tmp_assign_source_20 = IMPORT_NAME( tmp_import_name_from_15, const_str_plain_UInt32 ); | ||
| 817 | if ( tmp_assign_source_20 == NULL ) | ||
| 818 | { | ||
| 819 | assert( ERROR_OCCURRED() ); | ||
| 820 | |||
| 821 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 822 | |||
| 823 | |||
| 824 | exception_lineno = 6; | ||
| 825 | |||
| 826 | goto try_except_handler_1; | ||
| 827 | } | ||
| 828 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_UInt32, tmp_assign_source_20 ); | ||
| 829 | } | ||
| 830 | { | ||
| 831 | PyObject *tmp_assign_source_21; | ||
| 832 | PyObject *tmp_import_name_from_16; | ||
| 833 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 834 | tmp_import_name_from_16 = tmp_import_from_1__module; | ||
| 835 | tmp_assign_source_21 = IMPORT_NAME( tmp_import_name_from_16, const_str_plain_UInt64 ); | ||
| 836 | if ( tmp_assign_source_21 == NULL ) | ||
| 837 | { | ||
| 838 | assert( ERROR_OCCURRED() ); | ||
| 839 | |||
| 840 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 841 | |||
| 842 | |||
| 843 | exception_lineno = 6; | ||
| 844 | |||
| 845 | goto try_except_handler_1; | ||
| 846 | } | ||
| 847 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_UInt64, tmp_assign_source_21 ); | ||
| 848 | } | ||
| 849 | { | ||
| 850 | PyObject *tmp_assign_source_22; | ||
| 851 | PyObject *tmp_import_name_from_17; | ||
| 852 | CHECK_OBJECT( tmp_import_from_1__module ); | ||
| 853 | tmp_import_name_from_17 = tmp_import_from_1__module; | ||
| 854 | tmp_assign_source_22 = IMPORT_NAME( tmp_import_name_from_17, const_str_plain_UnixFd ); | ||
| 855 | if ( tmp_assign_source_22 == NULL ) | ||
| 856 | { | ||
| 857 | assert( ERROR_OCCURRED() ); | ||
| 858 | |||
| 859 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 860 | |||
| 861 | |||
| 862 | exception_lineno = 6; | ||
| 863 | |||
| 864 | goto try_except_handler_1; | ||
| 865 | } | ||
| 866 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_UnixFd, tmp_assign_source_22 ); | ||
| 867 | } | ||
| 868 | goto try_end_1; | ||
| 869 | // Exception handler code: | ||
| 870 | try_except_handler_1:; | ||
| 871 | exception_keeper_type_1 = exception_type; | ||
| 872 | exception_keeper_value_1 = exception_value; | ||
| 873 | exception_keeper_tb_1 = exception_tb; | ||
| 874 | exception_keeper_lineno_1 = exception_lineno; | ||
| 875 | exception_type = NULL; | ||
| 876 | exception_value = NULL; | ||
| 877 | exception_tb = NULL; | ||
| 878 | exception_lineno = 0; | ||
| 879 | |||
| 880 | CHECK_OBJECT( (PyObject *)tmp_import_from_1__module ); | ||
| 881 | Py_DECREF( tmp_import_from_1__module ); | ||
| 882 | tmp_import_from_1__module = NULL; | ||
| 883 | |||
| 884 | // Re-raise. | ||
| 885 | exception_type = exception_keeper_type_1; | ||
| 886 | exception_value = exception_keeper_value_1; | ||
| 887 | exception_tb = exception_keeper_tb_1; | ||
| 888 | exception_lineno = exception_keeper_lineno_1; | ||
| 889 | |||
| 890 | goto frame_exception_exit_1; | ||
| 891 | // End of try: | ||
| 892 | try_end_1:; | ||
| 893 | CHECK_OBJECT( (PyObject *)tmp_import_from_1__module ); | ||
| 894 | Py_DECREF( tmp_import_from_1__module ); | ||
| 895 | tmp_import_from_1__module = NULL; | ||
| 896 | |||
| 897 | { | ||
| 898 | PyObject *tmp_assign_source_23; | ||
| 899 | PyObject *tmp_import_name_from_18; | ||
| 900 | PyObject *tmp_name_name_2; | ||
| 901 | PyObject *tmp_globals_name_2; | ||
| 902 | PyObject *tmp_locals_name_2; | ||
| 903 | PyObject *tmp_fromlist_name_2; | ||
| 904 | PyObject *tmp_level_name_2; | ||
| 905 | tmp_name_name_2 = const_str_digest_3aa5bee4de9b0149ae46ffed8a38c6b4; | ||
| 906 | tmp_globals_name_2 = (PyObject *)moduledict_dbus$types; | ||
| 907 | tmp_locals_name_2 = Py_None; | ||
| 908 | tmp_fromlist_name_2 = const_tuple_str_plain_is_py2_tuple; | ||
| 909 | tmp_level_name_2 = const_int_0; | ||
| 910 | frame_1adf4263eda07e431174fcc04407385b->m_frame.f_lineno = 11; | ||
| 911 | tmp_import_name_from_18 = IMPORT_MODULE5( tmp_name_name_2, tmp_globals_name_2, tmp_locals_name_2, tmp_fromlist_name_2, tmp_level_name_2 ); | ||
| 912 | if ( tmp_import_name_from_18 == NULL ) | ||
| 913 | { | ||
| 914 | assert( ERROR_OCCURRED() ); | ||
| 915 | |||
| 916 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 917 | |||
| 918 | |||
| 919 | exception_lineno = 11; | ||
| 920 | |||
| 921 | goto frame_exception_exit_1; | ||
| 922 | } | ||
| 923 | tmp_assign_source_23 = IMPORT_NAME( tmp_import_name_from_18, const_str_plain_is_py2 ); | ||
| 924 | Py_DECREF( tmp_import_name_from_18 ); | ||
| 925 | if ( tmp_assign_source_23 == NULL ) | ||
| 926 | { | ||
| 927 | assert( ERROR_OCCURRED() ); | ||
| 928 | |||
| 929 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 930 | |||
| 931 | |||
| 932 | exception_lineno = 11; | ||
| 933 | |||
| 934 | goto frame_exception_exit_1; | ||
| 935 | } | ||
| 936 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_is_py2, tmp_assign_source_23 ); | ||
| 937 | } | ||
| 938 | { | ||
| 939 | nuitka_bool tmp_condition_result_1; | ||
| 940 | PyObject *tmp_mvar_value_3; | ||
| 941 | int tmp_truth_name_1; | ||
| 942 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_is_py2 ); | ||
| 943 | |||
| 944 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 945 | { | ||
| 946 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_is_py2 ); | ||
| 947 | } | ||
| 948 | |||
| 949 | CHECK_OBJECT( tmp_mvar_value_3 ); | ||
| 950 | tmp_truth_name_1 = CHECK_IF_TRUE( tmp_mvar_value_3 ); | ||
| 951 | if ( tmp_truth_name_1 == -1 ) | ||
| 952 | { | ||
| 953 | assert( ERROR_OCCURRED() ); | ||
| 954 | |||
| 955 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 956 | |||
| 957 | |||
| 958 | exception_lineno = 12; | ||
| 959 | |||
| 960 | goto frame_exception_exit_1; | ||
| 961 | } | ||
| 962 | tmp_condition_result_1 = tmp_truth_name_1 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 963 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 964 | { | ||
| 965 | goto branch_yes_1; | ||
| 966 | } | ||
| 967 | else | ||
| 968 | { | ||
| 969 | goto branch_no_1; | ||
| 970 | } | ||
| 971 | branch_yes_1:; | ||
| 972 | { | ||
| 973 | PyObject *tmp_assign_source_24; | ||
| 974 | PyObject *tmp_import_name_from_19; | ||
| 975 | PyObject *tmp_name_name_3; | ||
| 976 | PyObject *tmp_globals_name_3; | ||
| 977 | PyObject *tmp_locals_name_3; | ||
| 978 | PyObject *tmp_fromlist_name_3; | ||
| 979 | PyObject *tmp_level_name_3; | ||
| 980 | tmp_name_name_3 = const_str_plain__dbus_bindings; | ||
| 981 | tmp_globals_name_3 = (PyObject *)moduledict_dbus$types; | ||
| 982 | tmp_locals_name_3 = Py_None; | ||
| 983 | tmp_fromlist_name_3 = const_tuple_str_plain_UTF8String_tuple; | ||
| 984 | tmp_level_name_3 = const_int_0; | ||
| 985 | frame_1adf4263eda07e431174fcc04407385b->m_frame.f_lineno = 13; | ||
| 986 | tmp_import_name_from_19 = IMPORT_MODULE5( tmp_name_name_3, tmp_globals_name_3, tmp_locals_name_3, tmp_fromlist_name_3, tmp_level_name_3 ); | ||
| 987 | if ( tmp_import_name_from_19 == NULL ) | ||
| 988 | { | ||
| 989 | assert( ERROR_OCCURRED() ); | ||
| 990 | |||
| 991 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 992 | |||
| 993 | |||
| 994 | exception_lineno = 13; | ||
| 995 | |||
| 996 | goto frame_exception_exit_1; | ||
| 997 | } | ||
| 998 | tmp_assign_source_24 = IMPORT_NAME( tmp_import_name_from_19, const_str_plain_UTF8String ); | ||
| 999 | Py_DECREF( tmp_import_name_from_19 ); | ||
| 1000 | if ( tmp_assign_source_24 == NULL ) | ||
| 1001 | { | ||
| 1002 | assert( ERROR_OCCURRED() ); | ||
| 1003 | |||
| 1004 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1005 | |||
| 1006 | |||
| 1007 | exception_lineno = 13; | ||
| 1008 | |||
| 1009 | goto frame_exception_exit_1; | ||
| 1010 | } | ||
| 1011 | UPDATE_STRING_DICT1( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain_UTF8String, tmp_assign_source_24 ); | ||
| 1012 | } | ||
| 1013 | { | ||
| 1014 | PyObject *tmp_called_instance_1; | ||
| 1015 | PyObject *tmp_mvar_value_4; | ||
| 1016 | PyObject *tmp_call_result_1; | ||
| 1017 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___all__ ); | ||
| 1018 | |||
| 1019 | if (unlikely( tmp_mvar_value_4 == NULL )) | ||
| 1020 | { | ||
| 1021 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___all__ ); | ||
| 1022 | } | ||
| 1023 | |||
| 1024 | if ( tmp_mvar_value_4 == NULL ) | ||
| 1025 | { | ||
| 1026 | |||
| 1027 | exception_type = PyExc_NameError; | ||
| 1028 | Py_INCREF( exception_type ); | ||
| 1029 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "__all__" ); | ||
| 1030 | exception_tb = NULL; | ||
| 1031 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1032 | CHAIN_EXCEPTION( exception_value ); | ||
| 1033 | |||
| 1034 | exception_lineno = 14; | ||
| 1035 | |||
| 1036 | goto frame_exception_exit_1; | ||
| 1037 | } | ||
| 1038 | |||
| 1039 | tmp_called_instance_1 = tmp_mvar_value_4; | ||
| 1040 | frame_1adf4263eda07e431174fcc04407385b->m_frame.f_lineno = 14; | ||
| 1041 | tmp_call_result_1 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_1, const_str_plain_append, &PyTuple_GET_ITEM( const_tuple_str_plain_UTF8String_tuple, 0 ) ); | ||
| 1042 | |||
| 1043 | if ( tmp_call_result_1 == NULL ) | ||
| 1044 | { | ||
| 1045 | assert( ERROR_OCCURRED() ); | ||
| 1046 | |||
| 1047 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1048 | |||
| 1049 | |||
| 1050 | exception_lineno = 14; | ||
| 1051 | |||
| 1052 | goto frame_exception_exit_1; | ||
| 1053 | } | ||
| 1054 | Py_DECREF( tmp_call_result_1 ); | ||
| 1055 | } | ||
| 1056 | branch_no_1:; | ||
| 1057 | } | ||
| 1058 | |||
| 1059 | // Restore frame exception if necessary. | ||
| 1060 | #if 0 | ||
| 1061 | RESTORE_FRAME_EXCEPTION( frame_1adf4263eda07e431174fcc04407385b ); | ||
| 1062 | #endif | ||
| 1063 | popFrameStack(); | ||
| 1064 | |||
| 1065 | assertFrameObject( frame_1adf4263eda07e431174fcc04407385b ); | ||
| 1066 | |||
| 1067 | goto frame_no_exception_1; | ||
| 1068 | |||
| 1069 | frame_exception_exit_1:; | ||
| 1070 | #if 0 | ||
| 1071 | RESTORE_FRAME_EXCEPTION( frame_1adf4263eda07e431174fcc04407385b ); | ||
| 1072 | #endif | ||
| 1073 | |||
| 1074 | if ( exception_tb == NULL ) | ||
| 1075 | { | ||
| 1076 | exception_tb = MAKE_TRACEBACK( frame_1adf4263eda07e431174fcc04407385b, exception_lineno ); | ||
| 1077 | } | ||
| 1078 | else if ( exception_tb->tb_frame != &frame_1adf4263eda07e431174fcc04407385b->m_frame ) | ||
| 1079 | { | ||
| 1080 | exception_tb = ADD_TRACEBACK( exception_tb, frame_1adf4263eda07e431174fcc04407385b, exception_lineno ); | ||
| 1081 | } | ||
| 1082 | |||
| 1083 | // Put the previous frame back on top. | ||
| 1084 | popFrameStack(); | ||
| 1085 | |||
| 1086 | // Return the error. | ||
| 1087 | goto module_exception_exit; | ||
| 1088 | |||
| 1089 | frame_no_exception_1:; | ||
| 1090 | |||
| 1091 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 1092 | #if 0 && 0 | ||
| 1093 | { | ||
| 1094 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_dbus$types, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 1095 | |||
| 1096 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 1097 | { | ||
| 1098 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 1099 | |||
| 1100 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 1101 | CHECK_OBJECT( path_importer_cache ); | ||
| 1102 | |||
| 1103 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 1104 | assert( res == 0 ); | ||
| 1105 | } | ||
| 1106 | } | ||
| 1107 | #endif | ||
| 1108 | #endif | ||
| 1109 | |||
| 1110 | return MOD_RETURN_VALUE( module_dbus$types ); | ||
| 1111 | module_exception_exit: | ||
| 1112 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1113 | return MOD_RETURN_VALUE( NULL ); | ||
| 1114 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.dbus.types.o deleted (index adb5fa2..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.gi._compat.c deleted (index ea5e538..0000000) | |||
| 1 | /* Generated code for Python module 'gi._compat' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_gi$_compat" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_gi$_compat; | ||
| 31 | PyDictObject *moduledict_gi$_compat; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | static PyObject *const_str_plain_b; | ||
| 35 | static PyObject *const_str_plain_cmp; | ||
| 36 | static PyObject *const_str_plain_PY2; | ||
| 37 | static PyObject *const_str_digest_58ff6ccfc11c8774c9d298b85af436df; | ||
| 38 | static PyObject *const_str_plain_eval; | ||
| 39 | static PyObject *const_tuple_str_plain_UserList_tuple; | ||
| 40 | extern PyObject *const_str_plain___spec__; | ||
| 41 | static PyObject *const_tuple_str_digest_ac02ab0238280e341b2aff0eed15b128_tuple; | ||
| 42 | extern PyObject *const_str_plain_sys; | ||
| 43 | static PyObject *const_tuple_str_plain_StringIO_tuple; | ||
| 44 | static PyObject *const_str_plain_xrange; | ||
| 45 | extern PyObject *const_str_plain_io; | ||
| 46 | extern PyObject *const_str_plain_str; | ||
| 47 | static PyObject *const_str_plain_StringIO; | ||
| 48 | static PyObject *const_str_plain_text_type; | ||
| 49 | static PyObject *const_str_digest_5671faa48d5f8576f16d769e90b8dbff; | ||
| 50 | static PyObject *const_str_digest_1a6288f59e7208b4832970c7a8e4e197; | ||
| 51 | extern PyObject *const_str_plain_range; | ||
| 52 | static PyObject *const_tuple_str_plain_tp_str_plain_value_str_plain_tb_tuple; | ||
| 53 | extern PyObject *const_str_plain___file__; | ||
| 54 | static PyObject *const_str_plain_with_traceback; | ||
| 55 | static PyObject *const_str_plain_long; | ||
| 56 | extern PyObject *const_str_plain_importlib; | ||
| 57 | extern PyObject *const_str_plain_int; | ||
| 58 | extern PyObject *const_int_0; | ||
| 59 | extern PyObject *const_str_plain_tb; | ||
| 60 | static PyObject *const_str_digest_6179944d8bb339d712b456a36789f415; | ||
| 61 | extern PyObject *const_str_plain_string_types; | ||
| 62 | static PyObject *const_str_plain_UserList; | ||
| 63 | extern PyObject *const_str_plain_value; | ||
| 64 | extern PyObject *const_str_plain_unicode; | ||
| 65 | extern PyObject *const_str_plain_a; | ||
| 66 | extern PyObject *const_str_plain_collections; | ||
| 67 | static PyObject *const_str_digest_44ab03b5bbbd1d928e5f7be94e20c80a; | ||
| 68 | extern PyObject *const_str_plain_origin; | ||
| 69 | extern PyObject *const_str_plain_version_info; | ||
| 70 | static PyObject *const_str_plain_tp; | ||
| 71 | static PyObject *const_str_digest_bc431905b930e533433c92e81a7ea71c; | ||
| 72 | extern PyObject *const_tuple_empty; | ||
| 73 | extern PyObject *const_str_plain_strip; | ||
| 74 | static PyObject *const_str_plain_integer_types; | ||
| 75 | static PyObject *const_str_plain_exec; | ||
| 76 | static PyObject *const_tuple_type_int_tuple; | ||
| 77 | extern PyObject *const_str_plain_has_location; | ||
| 78 | static PyObject *const_tuple_str_plain_reload_tuple; | ||
| 79 | extern PyObject *const_int_pos_2; | ||
| 80 | static PyObject *const_str_digest_ac02ab0238280e341b2aff0eed15b128; | ||
| 81 | static PyObject *const_tuple_str_plain_a_str_plain_b_tuple; | ||
| 82 | extern PyObject *const_str_angle_lambda; | ||
| 83 | static PyObject *const_str_angle_string; | ||
| 84 | extern PyObject *const_tuple_type_str_tuple; | ||
| 85 | static PyObject *const_str_plain_reraise; | ||
| 86 | static PyObject *const_str_plain_PY3; | ||
| 87 | extern PyObject *const_str_plain___doc__; | ||
| 88 | extern PyObject *const_str_plain___cached__; | ||
| 89 | static PyObject *const_str_plain_reload; | ||
| 90 | extern PyObject *const_str_plain_long_; | ||
| 91 | static PyObject *module_filename_obj; | ||
| 92 | |||
| 93 | /* Indicator if this modules private constants were created yet. */ | ||
| 94 | static bool constants_created = false; | ||
| 95 | |||
| 96 | /* Function to create module private constants. */ | ||
| 97 | static void createModuleConstants( void ) | ||
| 98 | { | ||
| 99 | const_str_plain_b = UNSTREAM_STRING_ASCII( &constant_bin[ 242 ], 1, 1 ); | ||
| 100 | const_str_plain_cmp = UNSTREAM_STRING_ASCII( &constant_bin[ 35993 ], 3, 1 ); | ||
| 101 | const_str_plain_PY2 = UNSTREAM_STRING_ASCII( &constant_bin[ 35996 ], 3, 1 ); | ||
| 102 | const_str_digest_58ff6ccfc11c8774c9d298b85af436df = UNSTREAM_STRING_ASCII( &constant_bin[ 35999 ], 48, 0 ); | ||
| 103 | const_str_plain_eval = UNSTREAM_STRING_ASCII( &constant_bin[ 36047 ], 4, 1 ); | ||
| 104 | const_tuple_str_plain_UserList_tuple = PyTuple_New( 1 ); | ||
| 105 | const_str_plain_UserList = UNSTREAM_STRING_ASCII( &constant_bin[ 36051 ], 8, 1 ); | ||
| 106 | PyTuple_SET_ITEM( const_tuple_str_plain_UserList_tuple, 0, const_str_plain_UserList ); Py_INCREF( const_str_plain_UserList ); | ||
| 107 | const_tuple_str_digest_ac02ab0238280e341b2aff0eed15b128_tuple = PyTuple_New( 1 ); | ||
| 108 | const_str_digest_ac02ab0238280e341b2aff0eed15b128 = UNSTREAM_STRING_ASCII( &constant_bin[ 36059 ], 2, 0 ); | ||
| 109 | PyTuple_SET_ITEM( const_tuple_str_digest_ac02ab0238280e341b2aff0eed15b128_tuple, 0, const_str_digest_ac02ab0238280e341b2aff0eed15b128 ); Py_INCREF( const_str_digest_ac02ab0238280e341b2aff0eed15b128 ); | ||
| 110 | const_tuple_str_plain_StringIO_tuple = PyTuple_New( 1 ); | ||
| 111 | const_str_plain_StringIO = UNSTREAM_STRING_ASCII( &constant_bin[ 36061 ], 8, 1 ); | ||
| 112 | PyTuple_SET_ITEM( const_tuple_str_plain_StringIO_tuple, 0, const_str_plain_StringIO ); Py_INCREF( const_str_plain_StringIO ); | ||
| 113 | const_str_plain_xrange = UNSTREAM_STRING_ASCII( &constant_bin[ 36069 ], 6, 1 ); | ||
| 114 | const_str_plain_text_type = UNSTREAM_STRING_ASCII( &constant_bin[ 36075 ], 9, 1 ); | ||
| 115 | const_str_digest_5671faa48d5f8576f16d769e90b8dbff = UNSTREAM_STRING_ASCII( &constant_bin[ 36084 ], 10, 0 ); | ||
| 116 | const_str_digest_1a6288f59e7208b4832970c7a8e4e197 = UNSTREAM_STRING_ASCII( &constant_bin[ 36094 ], 13, 0 ); | ||
| 117 | const_tuple_str_plain_tp_str_plain_value_str_plain_tb_tuple = PyTuple_New( 3 ); | ||
| 118 | const_str_plain_tp = UNSTREAM_STRING_ASCII( &constant_bin[ 1428 ], 2, 1 ); | ||
| 119 | PyTuple_SET_ITEM( const_tuple_str_plain_tp_str_plain_value_str_plain_tb_tuple, 0, const_str_plain_tp ); Py_INCREF( const_str_plain_tp ); | ||
| 120 | PyTuple_SET_ITEM( const_tuple_str_plain_tp_str_plain_value_str_plain_tb_tuple, 1, const_str_plain_value ); Py_INCREF( const_str_plain_value ); | ||
| 121 | PyTuple_SET_ITEM( const_tuple_str_plain_tp_str_plain_value_str_plain_tb_tuple, 2, const_str_plain_tb ); Py_INCREF( const_str_plain_tb ); | ||
| 122 | const_str_plain_with_traceback = UNSTREAM_STRING_ASCII( &constant_bin[ 36107 ], 14, 1 ); | ||
| 123 | const_str_plain_long = UNSTREAM_STRING_ASCII( &constant_bin[ 36121 ], 4, 1 ); | ||
| 124 | const_str_digest_6179944d8bb339d712b456a36789f415 = UNSTREAM_STRING_ASCII( &constant_bin[ 36125 ], 11, 0 ); | ||
| 125 | const_str_digest_44ab03b5bbbd1d928e5f7be94e20c80a = UNSTREAM_STRING_ASCII( &constant_bin[ 36136 ], 13, 0 ); | ||
| 126 | const_str_digest_bc431905b930e533433c92e81a7ea71c = UNSTREAM_STRING_ASCII( &constant_bin[ 36149 ], 19, 0 ); | ||
| 127 | const_str_plain_integer_types = UNSTREAM_STRING_ASCII( &constant_bin[ 36168 ], 13, 1 ); | ||
| 128 | const_str_plain_exec = UNSTREAM_STRING_ASCII( &constant_bin[ 1792 ], 4, 1 ); | ||
| 129 | const_tuple_type_int_tuple = PyTuple_New( 1 ); | ||
| 130 | PyTuple_SET_ITEM( const_tuple_type_int_tuple, 0, (PyObject *)&PyLong_Type ); Py_INCREF( (PyObject *)&PyLong_Type ); | ||
| 131 | const_tuple_str_plain_reload_tuple = PyTuple_New( 1 ); | ||
| 132 | const_str_plain_reload = UNSTREAM_STRING_ASCII( &constant_bin[ 36181 ], 6, 1 ); | ||
| 133 | PyTuple_SET_ITEM( const_tuple_str_plain_reload_tuple, 0, const_str_plain_reload ); Py_INCREF( const_str_plain_reload ); | ||
| 134 | const_tuple_str_plain_a_str_plain_b_tuple = PyTuple_New( 2 ); | ||
| 135 | PyTuple_SET_ITEM( const_tuple_str_plain_a_str_plain_b_tuple, 0, const_str_plain_a ); Py_INCREF( const_str_plain_a ); | ||
| 136 | PyTuple_SET_ITEM( const_tuple_str_plain_a_str_plain_b_tuple, 1, const_str_plain_b ); Py_INCREF( const_str_plain_b ); | ||
| 137 | const_str_angle_string = UNSTREAM_STRING_ASCII( &constant_bin[ 36187 ], 8, 0 ); | ||
| 138 | const_str_plain_reraise = UNSTREAM_STRING_ASCII( &constant_bin[ 36003 ], 7, 1 ); | ||
| 139 | const_str_plain_PY3 = UNSTREAM_STRING_ASCII( &constant_bin[ 36195 ], 3, 1 ); | ||
| 140 | |||
| 141 | constants_created = true; | ||
| 142 | } | ||
| 143 | |||
| 144 | /* Function to verify module private constants for non-corruption. */ | ||
| 145 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 146 | void checkModuleConstants_gi$_compat( void ) | ||
| 147 | { | ||
| 148 | // The module may not have been used at all, then ignore this. | ||
| 149 | if (constants_created == false) return; | ||
| 150 | |||
| 151 | |||
| 152 | } | ||
| 153 | #endif | ||
| 154 | |||
| 155 | // The module code objects. | ||
| 156 | static PyCodeObject *codeobj_a761331b88bfb3002a1931dd2bebeb95; | ||
| 157 | static PyCodeObject *codeobj_158919088c58de14a3074744c1c289e5; | ||
| 158 | static PyCodeObject *codeobj_9429450ca11bae7fa99c84d4ae98ba16; | ||
| 159 | |||
| 160 | static void createModuleCodeObjects(void) | ||
| 161 | { | ||
| 162 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_44ab03b5bbbd1d928e5f7be94e20c80a ); | ||
| 163 | codeobj_a761331b88bfb3002a1931dd2bebeb95 = MAKE_CODEOBJ( module_filename_obj, const_str_angle_lambda, 53, const_tuple_str_plain_a_str_plain_b_tuple, 2, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 164 | codeobj_158919088c58de14a3074744c1c289e5 = MAKE_CODEOBJ( module_filename_obj, const_str_digest_bc431905b930e533433c92e81a7ea71c, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 165 | codeobj_9429450ca11bae7fa99c84d4ae98ba16 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_reraise, 55, const_tuple_str_plain_tp_str_plain_value_str_plain_tb_tuple, 3, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 166 | } | ||
| 167 | |||
| 168 | // The module function declarations. | ||
| 169 | static PyObject *MAKE_FUNCTION_gi$_compat$$$function_1_lambda( ); | ||
| 170 | |||
| 171 | |||
| 172 | static PyObject *MAKE_FUNCTION_gi$_compat$$$function_2_reraise( ); | ||
| 173 | |||
| 174 | |||
| 175 | // The module function definitions. | ||
| 176 | static PyObject *impl_gi$_compat$$$function_1_lambda( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 177 | { | ||
| 178 | // Preserve error status for checks | ||
| 179 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 180 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 181 | #endif | ||
| 182 | |||
| 183 | // Local variable declarations. | ||
| 184 | PyObject *par_a = python_pars[ 0 ]; | ||
| 185 | PyObject *par_b = python_pars[ 1 ]; | ||
| 186 | struct Nuitka_FrameObject *frame_a761331b88bfb3002a1931dd2bebeb95; | ||
| 187 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 188 | PyObject *tmp_return_value = NULL; | ||
| 189 | PyObject *exception_type = NULL; | ||
| 190 | PyObject *exception_value = NULL; | ||
| 191 | PyTracebackObject *exception_tb = NULL; | ||
| 192 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 193 | static struct Nuitka_FrameObject *cache_frame_a761331b88bfb3002a1931dd2bebeb95 = NULL; | ||
| 194 | PyObject *exception_keeper_type_1; | ||
| 195 | PyObject *exception_keeper_value_1; | ||
| 196 | PyTracebackObject *exception_keeper_tb_1; | ||
| 197 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 198 | |||
| 199 | // Actual function body. | ||
| 200 | // Tried code: | ||
| 201 | MAKE_OR_REUSE_FRAME( cache_frame_a761331b88bfb3002a1931dd2bebeb95, codeobj_a761331b88bfb3002a1931dd2bebeb95, module_gi$_compat, sizeof(void *)+sizeof(void *) ); | ||
| 202 | frame_a761331b88bfb3002a1931dd2bebeb95 = cache_frame_a761331b88bfb3002a1931dd2bebeb95; | ||
| 203 | |||
| 204 | // Push the new frame as the currently active one. | ||
| 205 | pushFrameStack( frame_a761331b88bfb3002a1931dd2bebeb95 ); | ||
| 206 | |||
| 207 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 208 | assert( Py_REFCNT( frame_a761331b88bfb3002a1931dd2bebeb95 ) == 2 ); // Frame stack | ||
| 209 | |||
| 210 | // Framed code: | ||
| 211 | { | ||
| 212 | PyObject *tmp_left_name_1; | ||
| 213 | PyObject *tmp_compexpr_left_1; | ||
| 214 | PyObject *tmp_compexpr_right_1; | ||
| 215 | PyObject *tmp_right_name_1; | ||
| 216 | PyObject *tmp_compexpr_left_2; | ||
| 217 | PyObject *tmp_compexpr_right_2; | ||
| 218 | CHECK_OBJECT( par_a ); | ||
| 219 | tmp_compexpr_left_1 = par_a; | ||
| 220 | CHECK_OBJECT( par_b ); | ||
| 221 | tmp_compexpr_right_1 = par_b; | ||
| 222 | tmp_left_name_1 = RICH_COMPARE_GT_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 223 | if ( tmp_left_name_1 == NULL ) | ||
| 224 | { | ||
| 225 | assert( ERROR_OCCURRED() ); | ||
| 226 | |||
| 227 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 228 | |||
| 229 | |||
| 230 | exception_lineno = 53; | ||
| 231 | type_description_1 = "oo"; | ||
| 232 | goto frame_exception_exit_1; | ||
| 233 | } | ||
| 234 | CHECK_OBJECT( par_a ); | ||
| 235 | tmp_compexpr_left_2 = par_a; | ||
| 236 | CHECK_OBJECT( par_b ); | ||
| 237 | tmp_compexpr_right_2 = par_b; | ||
| 238 | tmp_right_name_1 = RICH_COMPARE_LT_OBJECT_OBJECT( tmp_compexpr_left_2, tmp_compexpr_right_2 ); | ||
| 239 | if ( tmp_right_name_1 == NULL ) | ||
| 240 | { | ||
| 241 | assert( ERROR_OCCURRED() ); | ||
| 242 | |||
| 243 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 244 | Py_DECREF( tmp_left_name_1 ); | ||
| 245 | |||
| 246 | exception_lineno = 53; | ||
| 247 | type_description_1 = "oo"; | ||
| 248 | goto frame_exception_exit_1; | ||
| 249 | } | ||
| 250 | tmp_return_value = BINARY_OPERATION_SUB( tmp_left_name_1, tmp_right_name_1 ); | ||
| 251 | Py_DECREF( tmp_left_name_1 ); | ||
| 252 | Py_DECREF( tmp_right_name_1 ); | ||
| 253 | if ( tmp_return_value == NULL ) | ||
| 254 | { | ||
| 255 | assert( ERROR_OCCURRED() ); | ||
| 256 | |||
| 257 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 258 | |||
| 259 | |||
| 260 | exception_lineno = 53; | ||
| 261 | type_description_1 = "oo"; | ||
| 262 | goto frame_exception_exit_1; | ||
| 263 | } | ||
| 264 | goto frame_return_exit_1; | ||
| 265 | } | ||
| 266 | |||
| 267 | #if 0 | ||
| 268 | RESTORE_FRAME_EXCEPTION( frame_a761331b88bfb3002a1931dd2bebeb95 ); | ||
| 269 | #endif | ||
| 270 | |||
| 271 | // Put the previous frame back on top. | ||
| 272 | popFrameStack(); | ||
| 273 | |||
| 274 | goto frame_no_exception_1; | ||
| 275 | |||
| 276 | frame_return_exit_1:; | ||
| 277 | #if 0 | ||
| 278 | RESTORE_FRAME_EXCEPTION( frame_a761331b88bfb3002a1931dd2bebeb95 ); | ||
| 279 | #endif | ||
| 280 | |||
| 281 | // Put the previous frame back on top. | ||
| 282 | popFrameStack(); | ||
| 283 | |||
| 284 | goto try_return_handler_1; | ||
| 285 | |||
| 286 | frame_exception_exit_1:; | ||
| 287 | |||
| 288 | #if 0 | ||
| 289 | RESTORE_FRAME_EXCEPTION( frame_a761331b88bfb3002a1931dd2bebeb95 ); | ||
| 290 | #endif | ||
| 291 | |||
| 292 | if ( exception_tb == NULL ) | ||
| 293 | { | ||
| 294 | exception_tb = MAKE_TRACEBACK( frame_a761331b88bfb3002a1931dd2bebeb95, exception_lineno ); | ||
| 295 | } | ||
| 296 | else if ( exception_tb->tb_frame != &frame_a761331b88bfb3002a1931dd2bebeb95->m_frame ) | ||
| 297 | { | ||
| 298 | exception_tb = ADD_TRACEBACK( exception_tb, frame_a761331b88bfb3002a1931dd2bebeb95, exception_lineno ); | ||
| 299 | } | ||
| 300 | |||
| 301 | // Attachs locals to frame if any. | ||
| 302 | Nuitka_Frame_AttachLocals( | ||
| 303 | (struct Nuitka_FrameObject *)frame_a761331b88bfb3002a1931dd2bebeb95, | ||
| 304 | type_description_1, | ||
| 305 | par_a, | ||
| 306 | par_b | ||
| 307 | ); | ||
| 308 | |||
| 309 | |||
| 310 | // Release cached frame. | ||
| 311 | if ( frame_a761331b88bfb3002a1931dd2bebeb95 == cache_frame_a761331b88bfb3002a1931dd2bebeb95 ) | ||
| 312 | { | ||
| 313 | Py_DECREF( frame_a761331b88bfb3002a1931dd2bebeb95 ); | ||
| 314 | } | ||
| 315 | cache_frame_a761331b88bfb3002a1931dd2bebeb95 = NULL; | ||
| 316 | |||
| 317 | assertFrameObject( frame_a761331b88bfb3002a1931dd2bebeb95 ); | ||
| 318 | |||
| 319 | // Put the previous frame back on top. | ||
| 320 | popFrameStack(); | ||
| 321 | |||
| 322 | // Return the error. | ||
| 323 | goto try_except_handler_1; | ||
| 324 | |||
| 325 | frame_no_exception_1:; | ||
| 326 | // tried codes exits in all cases | ||
| 327 | NUITKA_CANNOT_GET_HERE( gi$_compat$$$function_1_lambda ); | ||
| 328 | return NULL; | ||
| 329 | // Return handler code: | ||
| 330 | try_return_handler_1:; | ||
| 331 | CHECK_OBJECT( (PyObject *)par_a ); | ||
| 332 | Py_DECREF( par_a ); | ||
| 333 | par_a = NULL; | ||
| 334 | |||
| 335 | CHECK_OBJECT( (PyObject *)par_b ); | ||
| 336 | Py_DECREF( par_b ); | ||
| 337 | par_b = NULL; | ||
| 338 | |||
| 339 | goto function_return_exit; | ||
| 340 | // Exception handler code: | ||
| 341 | try_except_handler_1:; | ||
| 342 | exception_keeper_type_1 = exception_type; | ||
| 343 | exception_keeper_value_1 = exception_value; | ||
| 344 | exception_keeper_tb_1 = exception_tb; | ||
| 345 | exception_keeper_lineno_1 = exception_lineno; | ||
| 346 | exception_type = NULL; | ||
| 347 | exception_value = NULL; | ||
| 348 | exception_tb = NULL; | ||
| 349 | exception_lineno = 0; | ||
| 350 | |||
| 351 | CHECK_OBJECT( (PyObject *)par_a ); | ||
| 352 | Py_DECREF( par_a ); | ||
| 353 | par_a = NULL; | ||
| 354 | |||
| 355 | CHECK_OBJECT( (PyObject *)par_b ); | ||
| 356 | Py_DECREF( par_b ); | ||
| 357 | par_b = NULL; | ||
| 358 | |||
| 359 | // Re-raise. | ||
| 360 | exception_type = exception_keeper_type_1; | ||
| 361 | exception_value = exception_keeper_value_1; | ||
| 362 | exception_tb = exception_keeper_tb_1; | ||
| 363 | exception_lineno = exception_keeper_lineno_1; | ||
| 364 | |||
| 365 | goto function_exception_exit; | ||
| 366 | // End of try: | ||
| 367 | |||
| 368 | // Return statement must have exited already. | ||
| 369 | NUITKA_CANNOT_GET_HERE( gi$_compat$$$function_1_lambda ); | ||
| 370 | return NULL; | ||
| 371 | |||
| 372 | function_exception_exit: | ||
| 373 | assert( exception_type ); | ||
| 374 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 375 | |||
| 376 | return NULL; | ||
| 377 | |||
| 378 | function_return_exit: | ||
| 379 | // Function cleanup code if any. | ||
| 380 | |||
| 381 | |||
| 382 | // Actual function exit with return value, making sure we did not make | ||
| 383 | // the error status worse despite non-NULL return. | ||
| 384 | CHECK_OBJECT( tmp_return_value ); | ||
| 385 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 386 | return tmp_return_value; | ||
| 387 | } | ||
| 388 | |||
| 389 | |||
| 390 | static PyObject *impl_gi$_compat$$$function_2_reraise( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 391 | { | ||
| 392 | // Preserve error status for checks | ||
| 393 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 394 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 395 | #endif | ||
| 396 | |||
| 397 | // Local variable declarations. | ||
| 398 | PyObject *par_tp = python_pars[ 0 ]; | ||
| 399 | PyObject *par_value = python_pars[ 1 ]; | ||
| 400 | PyObject *par_tb = python_pars[ 2 ]; | ||
| 401 | struct Nuitka_FrameObject *frame_9429450ca11bae7fa99c84d4ae98ba16; | ||
| 402 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 403 | PyObject *exception_type = NULL; | ||
| 404 | PyObject *exception_value = NULL; | ||
| 405 | PyTracebackObject *exception_tb = NULL; | ||
| 406 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 407 | static struct Nuitka_FrameObject *cache_frame_9429450ca11bae7fa99c84d4ae98ba16 = NULL; | ||
| 408 | PyObject *exception_keeper_type_1; | ||
| 409 | PyObject *exception_keeper_value_1; | ||
| 410 | PyTracebackObject *exception_keeper_tb_1; | ||
| 411 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 412 | |||
| 413 | // Actual function body. | ||
| 414 | // Tried code: | ||
| 415 | MAKE_OR_REUSE_FRAME( cache_frame_9429450ca11bae7fa99c84d4ae98ba16, codeobj_9429450ca11bae7fa99c84d4ae98ba16, module_gi$_compat, sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 416 | frame_9429450ca11bae7fa99c84d4ae98ba16 = cache_frame_9429450ca11bae7fa99c84d4ae98ba16; | ||
| 417 | |||
| 418 | // Push the new frame as the currently active one. | ||
| 419 | pushFrameStack( frame_9429450ca11bae7fa99c84d4ae98ba16 ); | ||
| 420 | |||
| 421 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 422 | assert( Py_REFCNT( frame_9429450ca11bae7fa99c84d4ae98ba16 ) == 2 ); // Frame stack | ||
| 423 | |||
| 424 | // Framed code: | ||
| 425 | { | ||
| 426 | PyObject *tmp_raise_type_1; | ||
| 427 | PyObject *tmp_called_instance_1; | ||
| 428 | PyObject *tmp_called_name_1; | ||
| 429 | PyObject *tmp_args_element_name_1; | ||
| 430 | PyObject *tmp_args_element_name_2; | ||
| 431 | CHECK_OBJECT( par_tp ); | ||
| 432 | tmp_called_name_1 = par_tp; | ||
| 433 | CHECK_OBJECT( par_value ); | ||
| 434 | tmp_args_element_name_1 = par_value; | ||
| 435 | frame_9429450ca11bae7fa99c84d4ae98ba16->m_frame.f_lineno = 56; | ||
| 436 | { | ||
| 437 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 438 | tmp_called_instance_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, call_args ); | ||
| 439 | } | ||
| 440 | |||
| 441 | if ( tmp_called_instance_1 == NULL ) | ||
| 442 | { | ||
| 443 | assert( ERROR_OCCURRED() ); | ||
| 444 | |||
| 445 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 446 | |||
| 447 | |||
| 448 | exception_lineno = 56; | ||
| 449 | type_description_1 = "ooo"; | ||
| 450 | goto frame_exception_exit_1; | ||
| 451 | } | ||
| 452 | CHECK_OBJECT( par_tb ); | ||
| 453 | tmp_args_element_name_2 = par_tb; | ||
| 454 | frame_9429450ca11bae7fa99c84d4ae98ba16->m_frame.f_lineno = 56; | ||
| 455 | { | ||
| 456 | PyObject *call_args[] = { tmp_args_element_name_2 }; | ||
| 457 | tmp_raise_type_1 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_1, const_str_plain_with_traceback, call_args ); | ||
| 458 | } | ||
| 459 | |||
| 460 | Py_DECREF( tmp_called_instance_1 ); | ||
| 461 | if ( tmp_raise_type_1 == NULL ) | ||
| 462 | { | ||
| 463 | assert( ERROR_OCCURRED() ); | ||
| 464 | |||
| 465 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 466 | |||
| 467 | |||
| 468 | exception_lineno = 56; | ||
| 469 | type_description_1 = "ooo"; | ||
| 470 | goto frame_exception_exit_1; | ||
| 471 | } | ||
| 472 | exception_type = tmp_raise_type_1; | ||
| 473 | exception_lineno = 56; | ||
| 474 | RAISE_EXCEPTION_WITH_TYPE( &exception_type, &exception_value, &exception_tb ); | ||
| 475 | type_description_1 = "ooo"; | ||
| 476 | goto frame_exception_exit_1; | ||
| 477 | } | ||
| 478 | |||
| 479 | #if 0 | ||
| 480 | RESTORE_FRAME_EXCEPTION( frame_9429450ca11bae7fa99c84d4ae98ba16 ); | ||
| 481 | #endif | ||
| 482 | |||
| 483 | // Put the previous frame back on top. | ||
| 484 | popFrameStack(); | ||
| 485 | |||
| 486 | goto frame_no_exception_1; | ||
| 487 | |||
| 488 | frame_exception_exit_1:; | ||
| 489 | |||
| 490 | #if 0 | ||
| 491 | RESTORE_FRAME_EXCEPTION( frame_9429450ca11bae7fa99c84d4ae98ba16 ); | ||
| 492 | #endif | ||
| 493 | |||
| 494 | if ( exception_tb == NULL ) | ||
| 495 | { | ||
| 496 | exception_tb = MAKE_TRACEBACK( frame_9429450ca11bae7fa99c84d4ae98ba16, exception_lineno ); | ||
| 497 | } | ||
| 498 | else if ( exception_tb->tb_frame != &frame_9429450ca11bae7fa99c84d4ae98ba16->m_frame ) | ||
| 499 | { | ||
| 500 | exception_tb = ADD_TRACEBACK( exception_tb, frame_9429450ca11bae7fa99c84d4ae98ba16, exception_lineno ); | ||
| 501 | } | ||
| 502 | |||
| 503 | // Attachs locals to frame if any. | ||
| 504 | Nuitka_Frame_AttachLocals( | ||
| 505 | (struct Nuitka_FrameObject *)frame_9429450ca11bae7fa99c84d4ae98ba16, | ||
| 506 | type_description_1, | ||
| 507 | par_tp, | ||
| 508 | par_value, | ||
| 509 | par_tb | ||
| 510 | ); | ||
| 511 | |||
| 512 | |||
| 513 | // Release cached frame. | ||
| 514 | if ( frame_9429450ca11bae7fa99c84d4ae98ba16 == cache_frame_9429450ca11bae7fa99c84d4ae98ba16 ) | ||
| 515 | { | ||
| 516 | Py_DECREF( frame_9429450ca11bae7fa99c84d4ae98ba16 ); | ||
| 517 | } | ||
| 518 | cache_frame_9429450ca11bae7fa99c84d4ae98ba16 = NULL; | ||
| 519 | |||
| 520 | assertFrameObject( frame_9429450ca11bae7fa99c84d4ae98ba16 ); | ||
| 521 | |||
| 522 | // Put the previous frame back on top. | ||
| 523 | popFrameStack(); | ||
| 524 | |||
| 525 | // Return the error. | ||
| 526 | goto try_except_handler_1; | ||
| 527 | |||
| 528 | frame_no_exception_1:; | ||
| 529 | // tried codes exits in all cases | ||
| 530 | NUITKA_CANNOT_GET_HERE( gi$_compat$$$function_2_reraise ); | ||
| 531 | return NULL; | ||
| 532 | // Exception handler code: | ||
| 533 | try_except_handler_1:; | ||
| 534 | exception_keeper_type_1 = exception_type; | ||
| 535 | exception_keeper_value_1 = exception_value; | ||
| 536 | exception_keeper_tb_1 = exception_tb; | ||
| 537 | exception_keeper_lineno_1 = exception_lineno; | ||
| 538 | exception_type = NULL; | ||
| 539 | exception_value = NULL; | ||
| 540 | exception_tb = NULL; | ||
| 541 | exception_lineno = 0; | ||
| 542 | |||
| 543 | CHECK_OBJECT( (PyObject *)par_tp ); | ||
| 544 | Py_DECREF( par_tp ); | ||
| 545 | par_tp = NULL; | ||
| 546 | |||
| 547 | CHECK_OBJECT( (PyObject *)par_value ); | ||
| 548 | Py_DECREF( par_value ); | ||
| 549 | par_value = NULL; | ||
| 550 | |||
| 551 | CHECK_OBJECT( (PyObject *)par_tb ); | ||
| 552 | Py_DECREF( par_tb ); | ||
| 553 | par_tb = NULL; | ||
| 554 | |||
| 555 | // Re-raise. | ||
| 556 | exception_type = exception_keeper_type_1; | ||
| 557 | exception_value = exception_keeper_value_1; | ||
| 558 | exception_tb = exception_keeper_tb_1; | ||
| 559 | exception_lineno = exception_keeper_lineno_1; | ||
| 560 | |||
| 561 | goto function_exception_exit; | ||
| 562 | // End of try: | ||
| 563 | |||
| 564 | // Return statement must have exited already. | ||
| 565 | NUITKA_CANNOT_GET_HERE( gi$_compat$$$function_2_reraise ); | ||
| 566 | return NULL; | ||
| 567 | |||
| 568 | function_exception_exit: | ||
| 569 | assert( exception_type ); | ||
| 570 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 571 | |||
| 572 | return NULL; | ||
| 573 | |||
| 574 | } | ||
| 575 | |||
| 576 | |||
| 577 | |||
| 578 | static PyObject *MAKE_FUNCTION_gi$_compat$$$function_1_lambda( ) | ||
| 579 | { | ||
| 580 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 581 | impl_gi$_compat$$$function_1_lambda, | ||
| 582 | const_str_angle_lambda, | ||
| 583 | #if PYTHON_VERSION >= 300 | ||
| 584 | NULL, | ||
| 585 | #endif | ||
| 586 | codeobj_a761331b88bfb3002a1931dd2bebeb95, | ||
| 587 | NULL, | ||
| 588 | #if PYTHON_VERSION >= 300 | ||
| 589 | NULL, | ||
| 590 | NULL, | ||
| 591 | #endif | ||
| 592 | module_gi$_compat, | ||
| 593 | NULL, | ||
| 594 | 0 | ||
| 595 | ); | ||
| 596 | |||
| 597 | return (PyObject *)result; | ||
| 598 | } | ||
| 599 | |||
| 600 | |||
| 601 | |||
| 602 | static PyObject *MAKE_FUNCTION_gi$_compat$$$function_2_reraise( ) | ||
| 603 | { | ||
| 604 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 605 | impl_gi$_compat$$$function_2_reraise, | ||
| 606 | const_str_plain_reraise, | ||
| 607 | #if PYTHON_VERSION >= 300 | ||
| 608 | NULL, | ||
| 609 | #endif | ||
| 610 | codeobj_9429450ca11bae7fa99c84d4ae98ba16, | ||
| 611 | NULL, | ||
| 612 | #if PYTHON_VERSION >= 300 | ||
| 613 | NULL, | ||
| 614 | NULL, | ||
| 615 | #endif | ||
| 616 | module_gi$_compat, | ||
| 617 | NULL, | ||
| 618 | 0 | ||
| 619 | ); | ||
| 620 | |||
| 621 | return (PyObject *)result; | ||
| 622 | } | ||
| 623 | |||
| 624 | |||
| 625 | |||
| 626 | #if PYTHON_VERSION >= 300 | ||
| 627 | static struct PyModuleDef mdef_gi$_compat = | ||
| 628 | { | ||
| 629 | PyModuleDef_HEAD_INIT, | ||
| 630 | "gi._compat", | ||
| 631 | NULL, /* m_doc */ | ||
| 632 | -1, /* m_size */ | ||
| 633 | NULL, /* m_methods */ | ||
| 634 | NULL, /* m_reload */ | ||
| 635 | NULL, /* m_traverse */ | ||
| 636 | NULL, /* m_clear */ | ||
| 637 | NULL, /* m_free */ | ||
| 638 | }; | ||
| 639 | #endif | ||
| 640 | |||
| 641 | extern PyObject *const_str_plain___compiled__; | ||
| 642 | |||
| 643 | extern PyObject *const_str_plain___package__; | ||
| 644 | |||
| 645 | #if PYTHON_VERSION >= 300 | ||
| 646 | extern PyObject *const_str_dot; | ||
| 647 | extern PyObject *const_str_plain___loader__; | ||
| 648 | #endif | ||
| 649 | |||
| 650 | #if PYTHON_VERSION >= 340 | ||
| 651 | extern PyObject *const_str_plain___spec__; | ||
| 652 | extern PyObject *const_str_plain__initializing; | ||
| 653 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 654 | #endif | ||
| 655 | |||
| 656 | extern void _initCompiledCellType(); | ||
| 657 | extern void _initCompiledGeneratorType(); | ||
| 658 | extern void _initCompiledFunctionType(); | ||
| 659 | extern void _initCompiledMethodType(); | ||
| 660 | extern void _initCompiledFrameType(); | ||
| 661 | #if PYTHON_VERSION >= 350 | ||
| 662 | extern void _initCompiledCoroutineTypes(); | ||
| 663 | #endif | ||
| 664 | #if PYTHON_VERSION >= 360 | ||
| 665 | extern void _initCompiledAsyncgenTypes(); | ||
| 666 | #endif | ||
| 667 | |||
| 668 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 669 | |||
| 670 | // The exported interface to CPython. On import of the module, this function | ||
| 671 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 672 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 673 | |||
| 674 | MOD_INIT_DECL( gi$_compat ) | ||
| 675 | { | ||
| 676 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 677 | static bool _init_done = false; | ||
| 678 | |||
| 679 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 680 | if ( _init_done ) | ||
| 681 | { | ||
| 682 | return MOD_RETURN_VALUE( module_gi$_compat ); | ||
| 683 | } | ||
| 684 | else | ||
| 685 | { | ||
| 686 | _init_done = true; | ||
| 687 | } | ||
| 688 | #endif | ||
| 689 | |||
| 690 | #ifdef _NUITKA_MODULE | ||
| 691 | // In case of a stand alone extension module, need to call initialization | ||
| 692 | // the init here because that's the first and only time we are going to get | ||
| 693 | // called here. | ||
| 694 | |||
| 695 | // Initialize the constant values used. | ||
| 696 | _initBuiltinModule(); | ||
| 697 | createGlobalConstants(); | ||
| 698 | |||
| 699 | /* Initialize the compiled types of Nuitka. */ | ||
| 700 | _initCompiledCellType(); | ||
| 701 | _initCompiledGeneratorType(); | ||
| 702 | _initCompiledFunctionType(); | ||
| 703 | _initCompiledMethodType(); | ||
| 704 | _initCompiledFrameType(); | ||
| 705 | #if PYTHON_VERSION >= 350 | ||
| 706 | _initCompiledCoroutineTypes(); | ||
| 707 | #endif | ||
| 708 | #if PYTHON_VERSION >= 360 | ||
| 709 | _initCompiledAsyncgenTypes(); | ||
| 710 | #endif | ||
| 711 | |||
| 712 | #if PYTHON_VERSION < 300 | ||
| 713 | _initSlotCompare(); | ||
| 714 | #endif | ||
| 715 | #if PYTHON_VERSION >= 270 | ||
| 716 | _initSlotIternext(); | ||
| 717 | #endif | ||
| 718 | |||
| 719 | patchBuiltinModule(); | ||
| 720 | patchTypeComparison(); | ||
| 721 | |||
| 722 | // Enable meta path based loader if not already done. | ||
| 723 | #ifdef _NUITKA_TRACE | ||
| 724 | puts("gi._compat: Calling setupMetaPathBasedLoader()."); | ||
| 725 | #endif | ||
| 726 | setupMetaPathBasedLoader(); | ||
| 727 | |||
| 728 | #if PYTHON_VERSION >= 300 | ||
| 729 | patchInspectModule(); | ||
| 730 | #endif | ||
| 731 | |||
| 732 | #endif | ||
| 733 | |||
| 734 | /* The constants only used by this module are created now. */ | ||
| 735 | #ifdef _NUITKA_TRACE | ||
| 736 | puts("gi._compat: Calling createModuleConstants()."); | ||
| 737 | #endif | ||
| 738 | createModuleConstants(); | ||
| 739 | |||
| 740 | /* The code objects used by this module are created now. */ | ||
| 741 | #ifdef _NUITKA_TRACE | ||
| 742 | puts("gi._compat: Calling createModuleCodeObjects()."); | ||
| 743 | #endif | ||
| 744 | createModuleCodeObjects(); | ||
| 745 | |||
| 746 | // puts( "in initgi$_compat" ); | ||
| 747 | |||
| 748 | // Create the module object first. There are no methods initially, all are | ||
| 749 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 750 | // set at this time, as it could not contain NUL characters this way, they | ||
| 751 | // are instead set in early module code. No "self" for modules, we have no | ||
| 752 | // use for it. | ||
| 753 | #if PYTHON_VERSION < 300 | ||
| 754 | module_gi$_compat = Py_InitModule4( | ||
| 755 | "gi._compat", // Module Name | ||
| 756 | NULL, // No methods initially, all are added | ||
| 757 | // dynamically in actual module code only. | ||
| 758 | NULL, // No "__doc__" is initially set, as it could | ||
| 759 | // not contain NUL this way, added early in | ||
| 760 | // actual code. | ||
| 761 | NULL, // No self for modules, we don't use it. | ||
| 762 | PYTHON_API_VERSION | ||
| 763 | ); | ||
| 764 | #else | ||
| 765 | |||
| 766 | module_gi$_compat = PyModule_Create( &mdef_gi$_compat ); | ||
| 767 | #endif | ||
| 768 | |||
| 769 | moduledict_gi$_compat = MODULE_DICT( module_gi$_compat ); | ||
| 770 | |||
| 771 | // Set __compiled__ to what it we know. | ||
| 772 | UPDATE_STRING_DICT1( | ||
| 773 | moduledict_gi$_compat, | ||
| 774 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 775 | Nuitka_dunder_compiled_value | ||
| 776 | ); | ||
| 777 | |||
| 778 | // Update "__package__" value to what it ought to be. | ||
| 779 | { | ||
| 780 | #if 0 | ||
| 781 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 782 | |||
| 783 | UPDATE_STRING_DICT1( | ||
| 784 | moduledict_gi$_compat, | ||
| 785 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 786 | module_name | ||
| 787 | ); | ||
| 788 | #else | ||
| 789 | |||
| 790 | #if PYTHON_VERSION < 300 | ||
| 791 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 792 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 793 | |||
| 794 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 795 | |||
| 796 | if ( last_dot != NULL ) | ||
| 797 | { | ||
| 798 | UPDATE_STRING_DICT1( | ||
| 799 | moduledict_gi$_compat, | ||
| 800 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 801 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 802 | ); | ||
| 803 | } | ||
| 804 | #else | ||
| 805 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 806 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 807 | |||
| 808 | if ( dot_index != -1 ) | ||
| 809 | { | ||
| 810 | UPDATE_STRING_DICT1( | ||
| 811 | moduledict_gi$_compat, | ||
| 812 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 813 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 814 | ); | ||
| 815 | } | ||
| 816 | #endif | ||
| 817 | #endif | ||
| 818 | } | ||
| 819 | |||
| 820 | CHECK_OBJECT( module_gi$_compat ); | ||
| 821 | |||
| 822 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 823 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 824 | #if PYTHON_VERSION >= 300 | ||
| 825 | { | ||
| 826 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_5671faa48d5f8576f16d769e90b8dbff, module_gi$_compat ); | ||
| 827 | |||
| 828 | assert( r != -1 ); | ||
| 829 | } | ||
| 830 | #endif | ||
| 831 | |||
| 832 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 833 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 834 | // before the frame object is allocated, or else it may fail. | ||
| 835 | |||
| 836 | if ( GET_STRING_DICT_VALUE( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 837 | { | ||
| 838 | PyObject *value = (PyObject *)builtin_module; | ||
| 839 | |||
| 840 | // Check if main module, not a dict then but the module itself. | ||
| 841 | #if !defined(_NUITKA_EXE) || !0 | ||
| 842 | value = PyModule_GetDict( value ); | ||
| 843 | #endif | ||
| 844 | |||
| 845 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 846 | } | ||
| 847 | |||
| 848 | #if PYTHON_VERSION >= 300 | ||
| 849 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 850 | #endif | ||
| 851 | |||
| 852 | #if PYTHON_VERSION >= 340 | ||
| 853 | // Set the "__spec__" value | ||
| 854 | |||
| 855 | #if 0 | ||
| 856 | // Main modules just get "None" as spec. | ||
| 857 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 858 | #else | ||
| 859 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 860 | { | ||
| 861 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 862 | CHECK_OBJECT( bootstrap_module ); | ||
| 863 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 864 | Py_DECREF( bootstrap_module ); | ||
| 865 | |||
| 866 | PyObject *args[] = { | ||
| 867 | GET_STRING_DICT_VALUE( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 868 | (PyObject *)&Nuitka_Loader_Type | ||
| 869 | }; | ||
| 870 | |||
| 871 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 872 | module_spec_class, | ||
| 873 | args | ||
| 874 | ); | ||
| 875 | Py_DECREF( module_spec_class ); | ||
| 876 | |||
| 877 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 878 | CHECK_OBJECT( spec_value ); | ||
| 879 | |||
| 880 | // For packages set the submodule search locations as well, even if to empty | ||
| 881 | // list, so investigating code will consider it a package. | ||
| 882 | #if 0 | ||
| 883 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 884 | #endif | ||
| 885 | |||
| 886 | // Mark the execution in the "__spec__" value. | ||
| 887 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 888 | |||
| 889 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 890 | } | ||
| 891 | #endif | ||
| 892 | #endif | ||
| 893 | |||
| 894 | // Temp variables if any | ||
| 895 | PyObject *tmp_eval_call_1__globals = NULL; | ||
| 896 | PyObject *tmp_eval_call_1__locals = NULL; | ||
| 897 | PyObject *tmp_eval_call_1__source = NULL; | ||
| 898 | PyObject *tmp_eval_call_2__globals = NULL; | ||
| 899 | PyObject *tmp_eval_call_2__locals = NULL; | ||
| 900 | PyObject *tmp_eval_call_2__source = NULL; | ||
| 901 | PyObject *tmp_eval_call_3__globals = NULL; | ||
| 902 | PyObject *tmp_eval_call_3__locals = NULL; | ||
| 903 | PyObject *tmp_eval_call_3__source = NULL; | ||
| 904 | PyObject *tmp_eval_call_4__globals = NULL; | ||
| 905 | PyObject *tmp_eval_call_4__locals = NULL; | ||
| 906 | PyObject *tmp_eval_call_4__source = NULL; | ||
| 907 | PyObject *tmp_eval_call_5__globals = NULL; | ||
| 908 | PyObject *tmp_eval_call_5__locals = NULL; | ||
| 909 | PyObject *tmp_eval_call_5__source = NULL; | ||
| 910 | PyObject *tmp_eval_call_6__globals = NULL; | ||
| 911 | PyObject *tmp_eval_call_6__locals = NULL; | ||
| 912 | PyObject *tmp_eval_call_6__source = NULL; | ||
| 913 | PyObject *tmp_eval_call_7__globals = NULL; | ||
| 914 | PyObject *tmp_eval_call_7__locals = NULL; | ||
| 915 | PyObject *tmp_eval_call_7__source = NULL; | ||
| 916 | PyObject *tmp_exec_call_1__globals = NULL; | ||
| 917 | PyObject *tmp_exec_call_1__locals = NULL; | ||
| 918 | struct Nuitka_FrameObject *frame_158919088c58de14a3074744c1c289e5; | ||
| 919 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 920 | bool tmp_result; | ||
| 921 | PyObject *exception_type = NULL; | ||
| 922 | PyObject *exception_value = NULL; | ||
| 923 | PyTracebackObject *exception_tb = NULL; | ||
| 924 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 925 | int tmp_res; | ||
| 926 | PyObject *exception_keeper_type_1; | ||
| 927 | PyObject *exception_keeper_value_1; | ||
| 928 | PyTracebackObject *exception_keeper_tb_1; | ||
| 929 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 930 | PyObject *exception_keeper_type_2; | ||
| 931 | PyObject *exception_keeper_value_2; | ||
| 932 | PyTracebackObject *exception_keeper_tb_2; | ||
| 933 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 934 | PyObject *exception_keeper_type_3; | ||
| 935 | PyObject *exception_keeper_value_3; | ||
| 936 | PyTracebackObject *exception_keeper_tb_3; | ||
| 937 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; | ||
| 938 | PyObject *exception_keeper_type_4; | ||
| 939 | PyObject *exception_keeper_value_4; | ||
| 940 | PyTracebackObject *exception_keeper_tb_4; | ||
| 941 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_4; | ||
| 942 | PyObject *exception_keeper_type_5; | ||
| 943 | PyObject *exception_keeper_value_5; | ||
| 944 | PyTracebackObject *exception_keeper_tb_5; | ||
| 945 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_5; | ||
| 946 | PyObject *exception_keeper_type_6; | ||
| 947 | PyObject *exception_keeper_value_6; | ||
| 948 | PyTracebackObject *exception_keeper_tb_6; | ||
| 949 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_6; | ||
| 950 | PyObject *exception_keeper_type_7; | ||
| 951 | PyObject *exception_keeper_value_7; | ||
| 952 | PyTracebackObject *exception_keeper_tb_7; | ||
| 953 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_7; | ||
| 954 | PyObject *exception_keeper_type_8; | ||
| 955 | PyObject *exception_keeper_value_8; | ||
| 956 | PyTracebackObject *exception_keeper_tb_8; | ||
| 957 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_8; | ||
| 958 | |||
| 959 | // Module code. | ||
| 960 | { | ||
| 961 | PyObject *tmp_assign_source_1; | ||
| 962 | tmp_assign_source_1 = Py_None; | ||
| 963 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 964 | } | ||
| 965 | { | ||
| 966 | PyObject *tmp_assign_source_2; | ||
| 967 | tmp_assign_source_2 = module_filename_obj; | ||
| 968 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 969 | } | ||
| 970 | // Frame without reuse. | ||
| 971 | frame_158919088c58de14a3074744c1c289e5 = MAKE_MODULE_FRAME( codeobj_158919088c58de14a3074744c1c289e5, module_gi$_compat ); | ||
| 972 | |||
| 973 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 974 | // owning it. | ||
| 975 | pushFrameStack( frame_158919088c58de14a3074744c1c289e5 ); | ||
| 976 | assert( Py_REFCNT( frame_158919088c58de14a3074744c1c289e5 ) == 2 ); | ||
| 977 | |||
| 978 | // Framed code: | ||
| 979 | { | ||
| 980 | PyObject *tmp_assattr_name_1; | ||
| 981 | PyObject *tmp_assattr_target_1; | ||
| 982 | PyObject *tmp_mvar_value_1; | ||
| 983 | tmp_assattr_name_1 = module_filename_obj; | ||
| 984 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 985 | |||
| 986 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 987 | { | ||
| 988 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 989 | } | ||
| 990 | |||
| 991 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 992 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 993 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 994 | if ( tmp_result == false ) | ||
| 995 | { | ||
| 996 | assert( ERROR_OCCURRED() ); | ||
| 997 | |||
| 998 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 999 | |||
| 1000 | |||
| 1001 | exception_lineno = 1; | ||
| 1002 | |||
| 1003 | goto frame_exception_exit_1; | ||
| 1004 | } | ||
| 1005 | } | ||
| 1006 | { | ||
| 1007 | PyObject *tmp_assattr_name_2; | ||
| 1008 | PyObject *tmp_assattr_target_2; | ||
| 1009 | PyObject *tmp_mvar_value_2; | ||
| 1010 | tmp_assattr_name_2 = Py_True; | ||
| 1011 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1012 | |||
| 1013 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 1014 | { | ||
| 1015 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1016 | } | ||
| 1017 | |||
| 1018 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 1019 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 1020 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 1021 | if ( tmp_result == false ) | ||
| 1022 | { | ||
| 1023 | assert( ERROR_OCCURRED() ); | ||
| 1024 | |||
| 1025 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1026 | |||
| 1027 | |||
| 1028 | exception_lineno = 1; | ||
| 1029 | |||
| 1030 | goto frame_exception_exit_1; | ||
| 1031 | } | ||
| 1032 | } | ||
| 1033 | { | ||
| 1034 | PyObject *tmp_assign_source_3; | ||
| 1035 | tmp_assign_source_3 = Py_None; | ||
| 1036 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 1037 | } | ||
| 1038 | { | ||
| 1039 | PyObject *tmp_assign_source_4; | ||
| 1040 | PyObject *tmp_name_name_1; | ||
| 1041 | PyObject *tmp_globals_name_1; | ||
| 1042 | PyObject *tmp_locals_name_1; | ||
| 1043 | PyObject *tmp_fromlist_name_1; | ||
| 1044 | PyObject *tmp_level_name_1; | ||
| 1045 | tmp_name_name_1 = const_str_plain_sys; | ||
| 1046 | tmp_globals_name_1 = (PyObject *)moduledict_gi$_compat; | ||
| 1047 | tmp_locals_name_1 = Py_None; | ||
| 1048 | tmp_fromlist_name_1 = Py_None; | ||
| 1049 | tmp_level_name_1 = const_int_0; | ||
| 1050 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 14; | ||
| 1051 | tmp_assign_source_4 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 1052 | assert( !(tmp_assign_source_4 == NULL) ); | ||
| 1053 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_sys, tmp_assign_source_4 ); | ||
| 1054 | } | ||
| 1055 | { | ||
| 1056 | PyObject *tmp_assign_source_5; | ||
| 1057 | tmp_assign_source_5 = Py_False; | ||
| 1058 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_PY2, tmp_assign_source_5 ); | ||
| 1059 | } | ||
| 1060 | { | ||
| 1061 | PyObject *tmp_assign_source_6; | ||
| 1062 | tmp_assign_source_6 = Py_False; | ||
| 1063 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_PY3, tmp_assign_source_6 ); | ||
| 1064 | } | ||
| 1065 | { | ||
| 1066 | nuitka_bool tmp_condition_result_1; | ||
| 1067 | PyObject *tmp_compexpr_left_1; | ||
| 1068 | PyObject *tmp_compexpr_right_1; | ||
| 1069 | PyObject *tmp_subscribed_name_1; | ||
| 1070 | PyObject *tmp_source_name_1; | ||
| 1071 | PyObject *tmp_mvar_value_3; | ||
| 1072 | PyObject *tmp_subscript_name_1; | ||
| 1073 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_sys ); | ||
| 1074 | |||
| 1075 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 1076 | { | ||
| 1077 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_sys ); | ||
| 1078 | } | ||
| 1079 | |||
| 1080 | CHECK_OBJECT( tmp_mvar_value_3 ); | ||
| 1081 | tmp_source_name_1 = tmp_mvar_value_3; | ||
| 1082 | tmp_subscribed_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_version_info ); | ||
| 1083 | if ( tmp_subscribed_name_1 == NULL ) | ||
| 1084 | { | ||
| 1085 | assert( ERROR_OCCURRED() ); | ||
| 1086 | |||
| 1087 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1088 | |||
| 1089 | |||
| 1090 | exception_lineno = 17; | ||
| 1091 | |||
| 1092 | goto frame_exception_exit_1; | ||
| 1093 | } | ||
| 1094 | tmp_subscript_name_1 = const_int_0; | ||
| 1095 | tmp_compexpr_left_1 = LOOKUP_SUBSCRIPT_CONST( tmp_subscribed_name_1, tmp_subscript_name_1, 0 ); | ||
| 1096 | Py_DECREF( tmp_subscribed_name_1 ); | ||
| 1097 | if ( tmp_compexpr_left_1 == NULL ) | ||
| 1098 | { | ||
| 1099 | assert( ERROR_OCCURRED() ); | ||
| 1100 | |||
| 1101 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1102 | |||
| 1103 | |||
| 1104 | exception_lineno = 17; | ||
| 1105 | |||
| 1106 | goto frame_exception_exit_1; | ||
| 1107 | } | ||
| 1108 | tmp_compexpr_right_1 = const_int_pos_2; | ||
| 1109 | tmp_res = RICH_COMPARE_BOOL_EQ_OBJECT_OBJECT_NORECURSE( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 1110 | Py_DECREF( tmp_compexpr_left_1 ); | ||
| 1111 | if ( tmp_res == -1 ) | ||
| 1112 | { | ||
| 1113 | assert( ERROR_OCCURRED() ); | ||
| 1114 | |||
| 1115 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1116 | |||
| 1117 | |||
| 1118 | exception_lineno = 17; | ||
| 1119 | |||
| 1120 | goto frame_exception_exit_1; | ||
| 1121 | } | ||
| 1122 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1123 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 1124 | { | ||
| 1125 | goto branch_yes_1; | ||
| 1126 | } | ||
| 1127 | else | ||
| 1128 | { | ||
| 1129 | goto branch_no_1; | ||
| 1130 | } | ||
| 1131 | branch_yes_1:; | ||
| 1132 | { | ||
| 1133 | PyObject *tmp_assign_source_7; | ||
| 1134 | tmp_assign_source_7 = Py_True; | ||
| 1135 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_PY2, tmp_assign_source_7 ); | ||
| 1136 | } | ||
| 1137 | { | ||
| 1138 | PyObject *tmp_assign_source_8; | ||
| 1139 | PyObject *tmp_import_name_from_1; | ||
| 1140 | PyObject *tmp_name_name_2; | ||
| 1141 | PyObject *tmp_globals_name_2; | ||
| 1142 | PyObject *tmp_locals_name_2; | ||
| 1143 | PyObject *tmp_fromlist_name_2; | ||
| 1144 | PyObject *tmp_level_name_2; | ||
| 1145 | tmp_name_name_2 = const_str_plain_StringIO; | ||
| 1146 | tmp_globals_name_2 = (PyObject *)moduledict_gi$_compat; | ||
| 1147 | tmp_locals_name_2 = Py_None; | ||
| 1148 | tmp_fromlist_name_2 = const_tuple_str_plain_StringIO_tuple; | ||
| 1149 | tmp_level_name_2 = const_int_0; | ||
| 1150 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 20; | ||
| 1151 | tmp_import_name_from_1 = IMPORT_MODULE5( tmp_name_name_2, tmp_globals_name_2, tmp_locals_name_2, tmp_fromlist_name_2, tmp_level_name_2 ); | ||
| 1152 | if ( tmp_import_name_from_1 == NULL ) | ||
| 1153 | { | ||
| 1154 | assert( ERROR_OCCURRED() ); | ||
| 1155 | |||
| 1156 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1157 | |||
| 1158 | |||
| 1159 | exception_lineno = 20; | ||
| 1160 | |||
| 1161 | goto frame_exception_exit_1; | ||
| 1162 | } | ||
| 1163 | tmp_assign_source_8 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_StringIO ); | ||
| 1164 | Py_DECREF( tmp_import_name_from_1 ); | ||
| 1165 | if ( tmp_assign_source_8 == NULL ) | ||
| 1166 | { | ||
| 1167 | assert( ERROR_OCCURRED() ); | ||
| 1168 | |||
| 1169 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1170 | |||
| 1171 | |||
| 1172 | exception_lineno = 20; | ||
| 1173 | |||
| 1174 | goto frame_exception_exit_1; | ||
| 1175 | } | ||
| 1176 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_StringIO, tmp_assign_source_8 ); | ||
| 1177 | } | ||
| 1178 | { | ||
| 1179 | PyObject *tmp_assign_source_9; | ||
| 1180 | PyObject *tmp_import_name_from_2; | ||
| 1181 | PyObject *tmp_name_name_3; | ||
| 1182 | PyObject *tmp_globals_name_3; | ||
| 1183 | PyObject *tmp_locals_name_3; | ||
| 1184 | PyObject *tmp_fromlist_name_3; | ||
| 1185 | PyObject *tmp_level_name_3; | ||
| 1186 | tmp_name_name_3 = const_str_plain_UserList; | ||
| 1187 | tmp_globals_name_3 = (PyObject *)moduledict_gi$_compat; | ||
| 1188 | tmp_locals_name_3 = Py_None; | ||
| 1189 | tmp_fromlist_name_3 = const_tuple_str_plain_UserList_tuple; | ||
| 1190 | tmp_level_name_3 = const_int_0; | ||
| 1191 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 23; | ||
| 1192 | tmp_import_name_from_2 = IMPORT_MODULE5( tmp_name_name_3, tmp_globals_name_3, tmp_locals_name_3, tmp_fromlist_name_3, tmp_level_name_3 ); | ||
| 1193 | if ( tmp_import_name_from_2 == NULL ) | ||
| 1194 | { | ||
| 1195 | assert( ERROR_OCCURRED() ); | ||
| 1196 | |||
| 1197 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1198 | |||
| 1199 | |||
| 1200 | exception_lineno = 23; | ||
| 1201 | |||
| 1202 | goto frame_exception_exit_1; | ||
| 1203 | } | ||
| 1204 | tmp_assign_source_9 = IMPORT_NAME( tmp_import_name_from_2, const_str_plain_UserList ); | ||
| 1205 | Py_DECREF( tmp_import_name_from_2 ); | ||
| 1206 | if ( tmp_assign_source_9 == NULL ) | ||
| 1207 | { | ||
| 1208 | assert( ERROR_OCCURRED() ); | ||
| 1209 | |||
| 1210 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1211 | |||
| 1212 | |||
| 1213 | exception_lineno = 23; | ||
| 1214 | |||
| 1215 | goto frame_exception_exit_1; | ||
| 1216 | } | ||
| 1217 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_UserList, tmp_assign_source_9 ); | ||
| 1218 | } | ||
| 1219 | { | ||
| 1220 | PyObject *tmp_assign_source_10; | ||
| 1221 | { | ||
| 1222 | PyObject *tmp_assign_source_11; | ||
| 1223 | tmp_assign_source_11 = (PyObject *)moduledict_gi$_compat; | ||
| 1224 | assert( tmp_eval_call_1__locals == NULL ); | ||
| 1225 | Py_INCREF( tmp_assign_source_11 ); | ||
| 1226 | tmp_eval_call_1__locals = tmp_assign_source_11; | ||
| 1227 | } | ||
| 1228 | { | ||
| 1229 | PyObject *tmp_assign_source_12; | ||
| 1230 | tmp_assign_source_12 = (PyObject *)moduledict_gi$_compat; | ||
| 1231 | assert( tmp_eval_call_1__globals == NULL ); | ||
| 1232 | Py_INCREF( tmp_assign_source_12 ); | ||
| 1233 | tmp_eval_call_1__globals = tmp_assign_source_12; | ||
| 1234 | } | ||
| 1235 | { | ||
| 1236 | PyObject *tmp_assign_source_13; | ||
| 1237 | tmp_assign_source_13 = const_str_plain_long; | ||
| 1238 | assert( tmp_eval_call_1__source == NULL ); | ||
| 1239 | Py_INCREF( tmp_assign_source_13 ); | ||
| 1240 | tmp_eval_call_1__source = tmp_assign_source_13; | ||
| 1241 | } | ||
| 1242 | // Tried code: | ||
| 1243 | { | ||
| 1244 | PyObject *tmp_assign_source_14; | ||
| 1245 | PyObject *tmp_called_instance_1; | ||
| 1246 | tmp_called_instance_1 = const_str_plain_long; | ||
| 1247 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 26; | ||
| 1248 | tmp_assign_source_14 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_1, const_str_plain_strip, &PyTuple_GET_ITEM( const_tuple_str_digest_ac02ab0238280e341b2aff0eed15b128_tuple, 0 ) ); | ||
| 1249 | |||
| 1250 | if ( tmp_assign_source_14 == NULL ) | ||
| 1251 | { | ||
| 1252 | assert( ERROR_OCCURRED() ); | ||
| 1253 | |||
| 1254 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1255 | |||
| 1256 | |||
| 1257 | exception_lineno = 26; | ||
| 1258 | |||
| 1259 | goto try_except_handler_1; | ||
| 1260 | } | ||
| 1261 | { | ||
| 1262 | PyObject *old = tmp_eval_call_1__source; | ||
| 1263 | assert( old != NULL ); | ||
| 1264 | tmp_eval_call_1__source = tmp_assign_source_14; | ||
| 1265 | Py_DECREF( old ); | ||
| 1266 | } | ||
| 1267 | |||
| 1268 | } | ||
| 1269 | { | ||
| 1270 | PyObject *tmp_eval_source_1; | ||
| 1271 | PyObject *tmp_eval_globals_1; | ||
| 1272 | PyObject *tmp_eval_locals_1; | ||
| 1273 | PyObject *tmp_eval_compiled_1; | ||
| 1274 | CHECK_OBJECT( tmp_eval_call_1__source ); | ||
| 1275 | tmp_eval_source_1 = tmp_eval_call_1__source; | ||
| 1276 | CHECK_OBJECT( tmp_eval_call_1__globals ); | ||
| 1277 | tmp_eval_globals_1 = tmp_eval_call_1__globals; | ||
| 1278 | CHECK_OBJECT( tmp_eval_call_1__locals ); | ||
| 1279 | tmp_eval_locals_1 = tmp_eval_call_1__locals; | ||
| 1280 | tmp_eval_compiled_1 = COMPILE_CODE( tmp_eval_source_1, const_str_angle_string, const_str_plain_eval, NULL, NULL, NULL ); | ||
| 1281 | if ( tmp_eval_compiled_1 == NULL ) | ||
| 1282 | { | ||
| 1283 | assert( ERROR_OCCURRED() ); | ||
| 1284 | |||
| 1285 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1286 | |||
| 1287 | |||
| 1288 | exception_lineno = 26; | ||
| 1289 | |||
| 1290 | goto try_except_handler_1; | ||
| 1291 | } | ||
| 1292 | tmp_assign_source_10 = EVAL_CODE( tmp_eval_compiled_1, tmp_eval_globals_1, tmp_eval_locals_1 ); | ||
| 1293 | Py_DECREF( tmp_eval_compiled_1 ); | ||
| 1294 | if ( tmp_assign_source_10 == NULL ) | ||
| 1295 | { | ||
| 1296 | assert( ERROR_OCCURRED() ); | ||
| 1297 | |||
| 1298 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1299 | |||
| 1300 | |||
| 1301 | exception_lineno = 26; | ||
| 1302 | |||
| 1303 | goto try_except_handler_1; | ||
| 1304 | } | ||
| 1305 | goto try_return_handler_1; | ||
| 1306 | } | ||
| 1307 | // tried codes exits in all cases | ||
| 1308 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 1309 | return MOD_RETURN_VALUE( NULL ); | ||
| 1310 | // Return handler code: | ||
| 1311 | try_return_handler_1:; | ||
| 1312 | CHECK_OBJECT( (PyObject *)tmp_eval_call_1__globals ); | ||
| 1313 | Py_DECREF( tmp_eval_call_1__globals ); | ||
| 1314 | tmp_eval_call_1__globals = NULL; | ||
| 1315 | |||
| 1316 | CHECK_OBJECT( (PyObject *)tmp_eval_call_1__locals ); | ||
| 1317 | Py_DECREF( tmp_eval_call_1__locals ); | ||
| 1318 | tmp_eval_call_1__locals = NULL; | ||
| 1319 | |||
| 1320 | Py_XDECREF( tmp_eval_call_1__source ); | ||
| 1321 | tmp_eval_call_1__source = NULL; | ||
| 1322 | |||
| 1323 | goto outline_result_1; | ||
| 1324 | // Exception handler code: | ||
| 1325 | try_except_handler_1:; | ||
| 1326 | exception_keeper_type_1 = exception_type; | ||
| 1327 | exception_keeper_value_1 = exception_value; | ||
| 1328 | exception_keeper_tb_1 = exception_tb; | ||
| 1329 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1330 | exception_type = NULL; | ||
| 1331 | exception_value = NULL; | ||
| 1332 | exception_tb = NULL; | ||
| 1333 | exception_lineno = 0; | ||
| 1334 | |||
| 1335 | CHECK_OBJECT( (PyObject *)tmp_eval_call_1__globals ); | ||
| 1336 | Py_DECREF( tmp_eval_call_1__globals ); | ||
| 1337 | tmp_eval_call_1__globals = NULL; | ||
| 1338 | |||
| 1339 | CHECK_OBJECT( (PyObject *)tmp_eval_call_1__locals ); | ||
| 1340 | Py_DECREF( tmp_eval_call_1__locals ); | ||
| 1341 | tmp_eval_call_1__locals = NULL; | ||
| 1342 | |||
| 1343 | Py_XDECREF( tmp_eval_call_1__source ); | ||
| 1344 | tmp_eval_call_1__source = NULL; | ||
| 1345 | |||
| 1346 | // Re-raise. | ||
| 1347 | exception_type = exception_keeper_type_1; | ||
| 1348 | exception_value = exception_keeper_value_1; | ||
| 1349 | exception_tb = exception_keeper_tb_1; | ||
| 1350 | exception_lineno = exception_keeper_lineno_1; | ||
| 1351 | |||
| 1352 | goto frame_exception_exit_1; | ||
| 1353 | // End of try: | ||
| 1354 | // Return statement must have exited already. | ||
| 1355 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 1356 | return MOD_RETURN_VALUE( NULL ); | ||
| 1357 | outline_result_1:; | ||
| 1358 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_long_, tmp_assign_source_10 ); | ||
| 1359 | } | ||
| 1360 | { | ||
| 1361 | PyObject *tmp_assign_source_15; | ||
| 1362 | { | ||
| 1363 | PyObject *tmp_assign_source_16; | ||
| 1364 | tmp_assign_source_16 = (PyObject *)moduledict_gi$_compat; | ||
| 1365 | assert( tmp_eval_call_2__locals == NULL ); | ||
| 1366 | Py_INCREF( tmp_assign_source_16 ); | ||
| 1367 | tmp_eval_call_2__locals = tmp_assign_source_16; | ||
| 1368 | } | ||
| 1369 | { | ||
| 1370 | PyObject *tmp_assign_source_17; | ||
| 1371 | tmp_assign_source_17 = (PyObject *)moduledict_gi$_compat; | ||
| 1372 | assert( tmp_eval_call_2__globals == NULL ); | ||
| 1373 | Py_INCREF( tmp_assign_source_17 ); | ||
| 1374 | tmp_eval_call_2__globals = tmp_assign_source_17; | ||
| 1375 | } | ||
| 1376 | { | ||
| 1377 | PyObject *tmp_assign_source_18; | ||
| 1378 | tmp_assign_source_18 = const_str_digest_6179944d8bb339d712b456a36789f415; | ||
| 1379 | assert( tmp_eval_call_2__source == NULL ); | ||
| 1380 | Py_INCREF( tmp_assign_source_18 ); | ||
| 1381 | tmp_eval_call_2__source = tmp_assign_source_18; | ||
| 1382 | } | ||
| 1383 | // Tried code: | ||
| 1384 | { | ||
| 1385 | PyObject *tmp_assign_source_19; | ||
| 1386 | PyObject *tmp_called_instance_2; | ||
| 1387 | tmp_called_instance_2 = const_str_digest_6179944d8bb339d712b456a36789f415; | ||
| 1388 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 27; | ||
| 1389 | tmp_assign_source_19 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_2, const_str_plain_strip, &PyTuple_GET_ITEM( const_tuple_str_digest_ac02ab0238280e341b2aff0eed15b128_tuple, 0 ) ); | ||
| 1390 | |||
| 1391 | if ( tmp_assign_source_19 == NULL ) | ||
| 1392 | { | ||
| 1393 | assert( ERROR_OCCURRED() ); | ||
| 1394 | |||
| 1395 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1396 | |||
| 1397 | |||
| 1398 | exception_lineno = 27; | ||
| 1399 | |||
| 1400 | goto try_except_handler_2; | ||
| 1401 | } | ||
| 1402 | { | ||
| 1403 | PyObject *old = tmp_eval_call_2__source; | ||
| 1404 | assert( old != NULL ); | ||
| 1405 | tmp_eval_call_2__source = tmp_assign_source_19; | ||
| 1406 | Py_DECREF( old ); | ||
| 1407 | } | ||
| 1408 | |||
| 1409 | } | ||
| 1410 | { | ||
| 1411 | PyObject *tmp_eval_source_2; | ||
| 1412 | PyObject *tmp_eval_globals_2; | ||
| 1413 | PyObject *tmp_eval_locals_2; | ||
| 1414 | PyObject *tmp_eval_compiled_2; | ||
| 1415 | CHECK_OBJECT( tmp_eval_call_2__source ); | ||
| 1416 | tmp_eval_source_2 = tmp_eval_call_2__source; | ||
| 1417 | CHECK_OBJECT( tmp_eval_call_2__globals ); | ||
| 1418 | tmp_eval_globals_2 = tmp_eval_call_2__globals; | ||
| 1419 | CHECK_OBJECT( tmp_eval_call_2__locals ); | ||
| 1420 | tmp_eval_locals_2 = tmp_eval_call_2__locals; | ||
| 1421 | tmp_eval_compiled_2 = COMPILE_CODE( tmp_eval_source_2, const_str_angle_string, const_str_plain_eval, NULL, NULL, NULL ); | ||
| 1422 | if ( tmp_eval_compiled_2 == NULL ) | ||
| 1423 | { | ||
| 1424 | assert( ERROR_OCCURRED() ); | ||
| 1425 | |||
| 1426 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1427 | |||
| 1428 | |||
| 1429 | exception_lineno = 27; | ||
| 1430 | |||
| 1431 | goto try_except_handler_2; | ||
| 1432 | } | ||
| 1433 | tmp_assign_source_15 = EVAL_CODE( tmp_eval_compiled_2, tmp_eval_globals_2, tmp_eval_locals_2 ); | ||
| 1434 | Py_DECREF( tmp_eval_compiled_2 ); | ||
| 1435 | if ( tmp_assign_source_15 == NULL ) | ||
| 1436 | { | ||
| 1437 | assert( ERROR_OCCURRED() ); | ||
| 1438 | |||
| 1439 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1440 | |||
| 1441 | |||
| 1442 | exception_lineno = 27; | ||
| 1443 | |||
| 1444 | goto try_except_handler_2; | ||
| 1445 | } | ||
| 1446 | goto try_return_handler_2; | ||
| 1447 | } | ||
| 1448 | // tried codes exits in all cases | ||
| 1449 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 1450 | return MOD_RETURN_VALUE( NULL ); | ||
| 1451 | // Return handler code: | ||
| 1452 | try_return_handler_2:; | ||
| 1453 | CHECK_OBJECT( (PyObject *)tmp_eval_call_2__globals ); | ||
| 1454 | Py_DECREF( tmp_eval_call_2__globals ); | ||
| 1455 | tmp_eval_call_2__globals = NULL; | ||
| 1456 | |||
| 1457 | CHECK_OBJECT( (PyObject *)tmp_eval_call_2__locals ); | ||
| 1458 | Py_DECREF( tmp_eval_call_2__locals ); | ||
| 1459 | tmp_eval_call_2__locals = NULL; | ||
| 1460 | |||
| 1461 | Py_XDECREF( tmp_eval_call_2__source ); | ||
| 1462 | tmp_eval_call_2__source = NULL; | ||
| 1463 | |||
| 1464 | goto outline_result_2; | ||
| 1465 | // Exception handler code: | ||
| 1466 | try_except_handler_2:; | ||
| 1467 | exception_keeper_type_2 = exception_type; | ||
| 1468 | exception_keeper_value_2 = exception_value; | ||
| 1469 | exception_keeper_tb_2 = exception_tb; | ||
| 1470 | exception_keeper_lineno_2 = exception_lineno; | ||
| 1471 | exception_type = NULL; | ||
| 1472 | exception_value = NULL; | ||
| 1473 | exception_tb = NULL; | ||
| 1474 | exception_lineno = 0; | ||
| 1475 | |||
| 1476 | CHECK_OBJECT( (PyObject *)tmp_eval_call_2__globals ); | ||
| 1477 | Py_DECREF( tmp_eval_call_2__globals ); | ||
| 1478 | tmp_eval_call_2__globals = NULL; | ||
| 1479 | |||
| 1480 | CHECK_OBJECT( (PyObject *)tmp_eval_call_2__locals ); | ||
| 1481 | Py_DECREF( tmp_eval_call_2__locals ); | ||
| 1482 | tmp_eval_call_2__locals = NULL; | ||
| 1483 | |||
| 1484 | Py_XDECREF( tmp_eval_call_2__source ); | ||
| 1485 | tmp_eval_call_2__source = NULL; | ||
| 1486 | |||
| 1487 | // Re-raise. | ||
| 1488 | exception_type = exception_keeper_type_2; | ||
| 1489 | exception_value = exception_keeper_value_2; | ||
| 1490 | exception_tb = exception_keeper_tb_2; | ||
| 1491 | exception_lineno = exception_keeper_lineno_2; | ||
| 1492 | |||
| 1493 | goto frame_exception_exit_1; | ||
| 1494 | // End of try: | ||
| 1495 | // Return statement must have exited already. | ||
| 1496 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 1497 | return MOD_RETURN_VALUE( NULL ); | ||
| 1498 | outline_result_2:; | ||
| 1499 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_integer_types, tmp_assign_source_15 ); | ||
| 1500 | } | ||
| 1501 | { | ||
| 1502 | PyObject *tmp_assign_source_20; | ||
| 1503 | { | ||
| 1504 | PyObject *tmp_assign_source_21; | ||
| 1505 | tmp_assign_source_21 = (PyObject *)moduledict_gi$_compat; | ||
| 1506 | assert( tmp_eval_call_3__locals == NULL ); | ||
| 1507 | Py_INCREF( tmp_assign_source_21 ); | ||
| 1508 | tmp_eval_call_3__locals = tmp_assign_source_21; | ||
| 1509 | } | ||
| 1510 | { | ||
| 1511 | PyObject *tmp_assign_source_22; | ||
| 1512 | tmp_assign_source_22 = (PyObject *)moduledict_gi$_compat; | ||
| 1513 | assert( tmp_eval_call_3__globals == NULL ); | ||
| 1514 | Py_INCREF( tmp_assign_source_22 ); | ||
| 1515 | tmp_eval_call_3__globals = tmp_assign_source_22; | ||
| 1516 | } | ||
| 1517 | { | ||
| 1518 | PyObject *tmp_assign_source_23; | ||
| 1519 | tmp_assign_source_23 = const_str_digest_1a6288f59e7208b4832970c7a8e4e197; | ||
| 1520 | assert( tmp_eval_call_3__source == NULL ); | ||
| 1521 | Py_INCREF( tmp_assign_source_23 ); | ||
| 1522 | tmp_eval_call_3__source = tmp_assign_source_23; | ||
| 1523 | } | ||
| 1524 | // Tried code: | ||
| 1525 | { | ||
| 1526 | PyObject *tmp_assign_source_24; | ||
| 1527 | PyObject *tmp_called_instance_3; | ||
| 1528 | tmp_called_instance_3 = const_str_digest_1a6288f59e7208b4832970c7a8e4e197; | ||
| 1529 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 28; | ||
| 1530 | tmp_assign_source_24 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_3, const_str_plain_strip, &PyTuple_GET_ITEM( const_tuple_str_digest_ac02ab0238280e341b2aff0eed15b128_tuple, 0 ) ); | ||
| 1531 | |||
| 1532 | if ( tmp_assign_source_24 == NULL ) | ||
| 1533 | { | ||
| 1534 | assert( ERROR_OCCURRED() ); | ||
| 1535 | |||
| 1536 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1537 | |||
| 1538 | |||
| 1539 | exception_lineno = 28; | ||
| 1540 | |||
| 1541 | goto try_except_handler_3; | ||
| 1542 | } | ||
| 1543 | { | ||
| 1544 | PyObject *old = tmp_eval_call_3__source; | ||
| 1545 | assert( old != NULL ); | ||
| 1546 | tmp_eval_call_3__source = tmp_assign_source_24; | ||
| 1547 | Py_DECREF( old ); | ||
| 1548 | } | ||
| 1549 | |||
| 1550 | } | ||
| 1551 | { | ||
| 1552 | PyObject *tmp_eval_source_3; | ||
| 1553 | PyObject *tmp_eval_globals_3; | ||
| 1554 | PyObject *tmp_eval_locals_3; | ||
| 1555 | PyObject *tmp_eval_compiled_3; | ||
| 1556 | CHECK_OBJECT( tmp_eval_call_3__source ); | ||
| 1557 | tmp_eval_source_3 = tmp_eval_call_3__source; | ||
| 1558 | CHECK_OBJECT( tmp_eval_call_3__globals ); | ||
| 1559 | tmp_eval_globals_3 = tmp_eval_call_3__globals; | ||
| 1560 | CHECK_OBJECT( tmp_eval_call_3__locals ); | ||
| 1561 | tmp_eval_locals_3 = tmp_eval_call_3__locals; | ||
| 1562 | tmp_eval_compiled_3 = COMPILE_CODE( tmp_eval_source_3, const_str_angle_string, const_str_plain_eval, NULL, NULL, NULL ); | ||
| 1563 | if ( tmp_eval_compiled_3 == NULL ) | ||
| 1564 | { | ||
| 1565 | assert( ERROR_OCCURRED() ); | ||
| 1566 | |||
| 1567 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1568 | |||
| 1569 | |||
| 1570 | exception_lineno = 28; | ||
| 1571 | |||
| 1572 | goto try_except_handler_3; | ||
| 1573 | } | ||
| 1574 | tmp_assign_source_20 = EVAL_CODE( tmp_eval_compiled_3, tmp_eval_globals_3, tmp_eval_locals_3 ); | ||
| 1575 | Py_DECREF( tmp_eval_compiled_3 ); | ||
| 1576 | if ( tmp_assign_source_20 == NULL ) | ||
| 1577 | { | ||
| 1578 | assert( ERROR_OCCURRED() ); | ||
| 1579 | |||
| 1580 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1581 | |||
| 1582 | |||
| 1583 | exception_lineno = 28; | ||
| 1584 | |||
| 1585 | goto try_except_handler_3; | ||
| 1586 | } | ||
| 1587 | goto try_return_handler_3; | ||
| 1588 | } | ||
| 1589 | // tried codes exits in all cases | ||
| 1590 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 1591 | return MOD_RETURN_VALUE( NULL ); | ||
| 1592 | // Return handler code: | ||
| 1593 | try_return_handler_3:; | ||
| 1594 | CHECK_OBJECT( (PyObject *)tmp_eval_call_3__globals ); | ||
| 1595 | Py_DECREF( tmp_eval_call_3__globals ); | ||
| 1596 | tmp_eval_call_3__globals = NULL; | ||
| 1597 | |||
| 1598 | CHECK_OBJECT( (PyObject *)tmp_eval_call_3__locals ); | ||
| 1599 | Py_DECREF( tmp_eval_call_3__locals ); | ||
| 1600 | tmp_eval_call_3__locals = NULL; | ||
| 1601 | |||
| 1602 | Py_XDECREF( tmp_eval_call_3__source ); | ||
| 1603 | tmp_eval_call_3__source = NULL; | ||
| 1604 | |||
| 1605 | goto outline_result_3; | ||
| 1606 | // Exception handler code: | ||
| 1607 | try_except_handler_3:; | ||
| 1608 | exception_keeper_type_3 = exception_type; | ||
| 1609 | exception_keeper_value_3 = exception_value; | ||
| 1610 | exception_keeper_tb_3 = exception_tb; | ||
| 1611 | exception_keeper_lineno_3 = exception_lineno; | ||
| 1612 | exception_type = NULL; | ||
| 1613 | exception_value = NULL; | ||
| 1614 | exception_tb = NULL; | ||
| 1615 | exception_lineno = 0; | ||
| 1616 | |||
| 1617 | CHECK_OBJECT( (PyObject *)tmp_eval_call_3__globals ); | ||
| 1618 | Py_DECREF( tmp_eval_call_3__globals ); | ||
| 1619 | tmp_eval_call_3__globals = NULL; | ||
| 1620 | |||
| 1621 | CHECK_OBJECT( (PyObject *)tmp_eval_call_3__locals ); | ||
| 1622 | Py_DECREF( tmp_eval_call_3__locals ); | ||
| 1623 | tmp_eval_call_3__locals = NULL; | ||
| 1624 | |||
| 1625 | Py_XDECREF( tmp_eval_call_3__source ); | ||
| 1626 | tmp_eval_call_3__source = NULL; | ||
| 1627 | |||
| 1628 | // Re-raise. | ||
| 1629 | exception_type = exception_keeper_type_3; | ||
| 1630 | exception_value = exception_keeper_value_3; | ||
| 1631 | exception_tb = exception_keeper_tb_3; | ||
| 1632 | exception_lineno = exception_keeper_lineno_3; | ||
| 1633 | |||
| 1634 | goto frame_exception_exit_1; | ||
| 1635 | // End of try: | ||
| 1636 | // Return statement must have exited already. | ||
| 1637 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 1638 | return MOD_RETURN_VALUE( NULL ); | ||
| 1639 | outline_result_3:; | ||
| 1640 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_string_types, tmp_assign_source_20 ); | ||
| 1641 | } | ||
| 1642 | { | ||
| 1643 | PyObject *tmp_assign_source_25; | ||
| 1644 | { | ||
| 1645 | PyObject *tmp_assign_source_26; | ||
| 1646 | tmp_assign_source_26 = (PyObject *)moduledict_gi$_compat; | ||
| 1647 | assert( tmp_eval_call_4__locals == NULL ); | ||
| 1648 | Py_INCREF( tmp_assign_source_26 ); | ||
| 1649 | tmp_eval_call_4__locals = tmp_assign_source_26; | ||
| 1650 | } | ||
| 1651 | { | ||
| 1652 | PyObject *tmp_assign_source_27; | ||
| 1653 | tmp_assign_source_27 = (PyObject *)moduledict_gi$_compat; | ||
| 1654 | assert( tmp_eval_call_4__globals == NULL ); | ||
| 1655 | Py_INCREF( tmp_assign_source_27 ); | ||
| 1656 | tmp_eval_call_4__globals = tmp_assign_source_27; | ||
| 1657 | } | ||
| 1658 | { | ||
| 1659 | PyObject *tmp_assign_source_28; | ||
| 1660 | tmp_assign_source_28 = const_str_plain_unicode; | ||
| 1661 | assert( tmp_eval_call_4__source == NULL ); | ||
| 1662 | Py_INCREF( tmp_assign_source_28 ); | ||
| 1663 | tmp_eval_call_4__source = tmp_assign_source_28; | ||
| 1664 | } | ||
| 1665 | // Tried code: | ||
| 1666 | { | ||
| 1667 | PyObject *tmp_assign_source_29; | ||
| 1668 | PyObject *tmp_called_instance_4; | ||
| 1669 | tmp_called_instance_4 = const_str_plain_unicode; | ||
| 1670 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 29; | ||
| 1671 | tmp_assign_source_29 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_4, const_str_plain_strip, &PyTuple_GET_ITEM( const_tuple_str_digest_ac02ab0238280e341b2aff0eed15b128_tuple, 0 ) ); | ||
| 1672 | |||
| 1673 | if ( tmp_assign_source_29 == NULL ) | ||
| 1674 | { | ||
| 1675 | assert( ERROR_OCCURRED() ); | ||
| 1676 | |||
| 1677 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1678 | |||
| 1679 | |||
| 1680 | exception_lineno = 29; | ||
| 1681 | |||
| 1682 | goto try_except_handler_4; | ||
| 1683 | } | ||
| 1684 | { | ||
| 1685 | PyObject *old = tmp_eval_call_4__source; | ||
| 1686 | assert( old != NULL ); | ||
| 1687 | tmp_eval_call_4__source = tmp_assign_source_29; | ||
| 1688 | Py_DECREF( old ); | ||
| 1689 | } | ||
| 1690 | |||
| 1691 | } | ||
| 1692 | { | ||
| 1693 | PyObject *tmp_eval_source_4; | ||
| 1694 | PyObject *tmp_eval_globals_4; | ||
| 1695 | PyObject *tmp_eval_locals_4; | ||
| 1696 | PyObject *tmp_eval_compiled_4; | ||
| 1697 | CHECK_OBJECT( tmp_eval_call_4__source ); | ||
| 1698 | tmp_eval_source_4 = tmp_eval_call_4__source; | ||
| 1699 | CHECK_OBJECT( tmp_eval_call_4__globals ); | ||
| 1700 | tmp_eval_globals_4 = tmp_eval_call_4__globals; | ||
| 1701 | CHECK_OBJECT( tmp_eval_call_4__locals ); | ||
| 1702 | tmp_eval_locals_4 = tmp_eval_call_4__locals; | ||
| 1703 | tmp_eval_compiled_4 = COMPILE_CODE( tmp_eval_source_4, const_str_angle_string, const_str_plain_eval, NULL, NULL, NULL ); | ||
| 1704 | if ( tmp_eval_compiled_4 == NULL ) | ||
| 1705 | { | ||
| 1706 | assert( ERROR_OCCURRED() ); | ||
| 1707 | |||
| 1708 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1709 | |||
| 1710 | |||
| 1711 | exception_lineno = 29; | ||
| 1712 | |||
| 1713 | goto try_except_handler_4; | ||
| 1714 | } | ||
| 1715 | tmp_assign_source_25 = EVAL_CODE( tmp_eval_compiled_4, tmp_eval_globals_4, tmp_eval_locals_4 ); | ||
| 1716 | Py_DECREF( tmp_eval_compiled_4 ); | ||
| 1717 | if ( tmp_assign_source_25 == NULL ) | ||
| 1718 | { | ||
| 1719 | assert( ERROR_OCCURRED() ); | ||
| 1720 | |||
| 1721 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1722 | |||
| 1723 | |||
| 1724 | exception_lineno = 29; | ||
| 1725 | |||
| 1726 | goto try_except_handler_4; | ||
| 1727 | } | ||
| 1728 | goto try_return_handler_4; | ||
| 1729 | } | ||
| 1730 | // tried codes exits in all cases | ||
| 1731 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 1732 | return MOD_RETURN_VALUE( NULL ); | ||
| 1733 | // Return handler code: | ||
| 1734 | try_return_handler_4:; | ||
| 1735 | CHECK_OBJECT( (PyObject *)tmp_eval_call_4__globals ); | ||
| 1736 | Py_DECREF( tmp_eval_call_4__globals ); | ||
| 1737 | tmp_eval_call_4__globals = NULL; | ||
| 1738 | |||
| 1739 | CHECK_OBJECT( (PyObject *)tmp_eval_call_4__locals ); | ||
| 1740 | Py_DECREF( tmp_eval_call_4__locals ); | ||
| 1741 | tmp_eval_call_4__locals = NULL; | ||
| 1742 | |||
| 1743 | Py_XDECREF( tmp_eval_call_4__source ); | ||
| 1744 | tmp_eval_call_4__source = NULL; | ||
| 1745 | |||
| 1746 | goto outline_result_4; | ||
| 1747 | // Exception handler code: | ||
| 1748 | try_except_handler_4:; | ||
| 1749 | exception_keeper_type_4 = exception_type; | ||
| 1750 | exception_keeper_value_4 = exception_value; | ||
| 1751 | exception_keeper_tb_4 = exception_tb; | ||
| 1752 | exception_keeper_lineno_4 = exception_lineno; | ||
| 1753 | exception_type = NULL; | ||
| 1754 | exception_value = NULL; | ||
| 1755 | exception_tb = NULL; | ||
| 1756 | exception_lineno = 0; | ||
| 1757 | |||
| 1758 | CHECK_OBJECT( (PyObject *)tmp_eval_call_4__globals ); | ||
| 1759 | Py_DECREF( tmp_eval_call_4__globals ); | ||
| 1760 | tmp_eval_call_4__globals = NULL; | ||
| 1761 | |||
| 1762 | CHECK_OBJECT( (PyObject *)tmp_eval_call_4__locals ); | ||
| 1763 | Py_DECREF( tmp_eval_call_4__locals ); | ||
| 1764 | tmp_eval_call_4__locals = NULL; | ||
| 1765 | |||
| 1766 | Py_XDECREF( tmp_eval_call_4__source ); | ||
| 1767 | tmp_eval_call_4__source = NULL; | ||
| 1768 | |||
| 1769 | // Re-raise. | ||
| 1770 | exception_type = exception_keeper_type_4; | ||
| 1771 | exception_value = exception_keeper_value_4; | ||
| 1772 | exception_tb = exception_keeper_tb_4; | ||
| 1773 | exception_lineno = exception_keeper_lineno_4; | ||
| 1774 | |||
| 1775 | goto frame_exception_exit_1; | ||
| 1776 | // End of try: | ||
| 1777 | // Return statement must have exited already. | ||
| 1778 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 1779 | return MOD_RETURN_VALUE( NULL ); | ||
| 1780 | outline_result_4:; | ||
| 1781 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_text_type, tmp_assign_source_25 ); | ||
| 1782 | } | ||
| 1783 | { | ||
| 1784 | PyObject *tmp_assign_source_30; | ||
| 1785 | { | ||
| 1786 | PyObject *tmp_assign_source_31; | ||
| 1787 | tmp_assign_source_31 = (PyObject *)moduledict_gi$_compat; | ||
| 1788 | assert( tmp_eval_call_5__locals == NULL ); | ||
| 1789 | Py_INCREF( tmp_assign_source_31 ); | ||
| 1790 | tmp_eval_call_5__locals = tmp_assign_source_31; | ||
| 1791 | } | ||
| 1792 | { | ||
| 1793 | PyObject *tmp_assign_source_32; | ||
| 1794 | tmp_assign_source_32 = (PyObject *)moduledict_gi$_compat; | ||
| 1795 | assert( tmp_eval_call_5__globals == NULL ); | ||
| 1796 | Py_INCREF( tmp_assign_source_32 ); | ||
| 1797 | tmp_eval_call_5__globals = tmp_assign_source_32; | ||
| 1798 | } | ||
| 1799 | { | ||
| 1800 | PyObject *tmp_assign_source_33; | ||
| 1801 | tmp_assign_source_33 = const_str_plain_reload; | ||
| 1802 | assert( tmp_eval_call_5__source == NULL ); | ||
| 1803 | Py_INCREF( tmp_assign_source_33 ); | ||
| 1804 | tmp_eval_call_5__source = tmp_assign_source_33; | ||
| 1805 | } | ||
| 1806 | // Tried code: | ||
| 1807 | { | ||
| 1808 | PyObject *tmp_assign_source_34; | ||
| 1809 | PyObject *tmp_called_instance_5; | ||
| 1810 | tmp_called_instance_5 = const_str_plain_reload; | ||
| 1811 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 31; | ||
| 1812 | tmp_assign_source_34 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_5, const_str_plain_strip, &PyTuple_GET_ITEM( const_tuple_str_digest_ac02ab0238280e341b2aff0eed15b128_tuple, 0 ) ); | ||
| 1813 | |||
| 1814 | if ( tmp_assign_source_34 == NULL ) | ||
| 1815 | { | ||
| 1816 | assert( ERROR_OCCURRED() ); | ||
| 1817 | |||
| 1818 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1819 | |||
| 1820 | |||
| 1821 | exception_lineno = 31; | ||
| 1822 | |||
| 1823 | goto try_except_handler_5; | ||
| 1824 | } | ||
| 1825 | { | ||
| 1826 | PyObject *old = tmp_eval_call_5__source; | ||
| 1827 | assert( old != NULL ); | ||
| 1828 | tmp_eval_call_5__source = tmp_assign_source_34; | ||
| 1829 | Py_DECREF( old ); | ||
| 1830 | } | ||
| 1831 | |||
| 1832 | } | ||
| 1833 | { | ||
| 1834 | PyObject *tmp_eval_source_5; | ||
| 1835 | PyObject *tmp_eval_globals_5; | ||
| 1836 | PyObject *tmp_eval_locals_5; | ||
| 1837 | PyObject *tmp_eval_compiled_5; | ||
| 1838 | CHECK_OBJECT( tmp_eval_call_5__source ); | ||
| 1839 | tmp_eval_source_5 = tmp_eval_call_5__source; | ||
| 1840 | CHECK_OBJECT( tmp_eval_call_5__globals ); | ||
| 1841 | tmp_eval_globals_5 = tmp_eval_call_5__globals; | ||
| 1842 | CHECK_OBJECT( tmp_eval_call_5__locals ); | ||
| 1843 | tmp_eval_locals_5 = tmp_eval_call_5__locals; | ||
| 1844 | tmp_eval_compiled_5 = COMPILE_CODE( tmp_eval_source_5, const_str_angle_string, const_str_plain_eval, NULL, NULL, NULL ); | ||
| 1845 | if ( tmp_eval_compiled_5 == NULL ) | ||
| 1846 | { | ||
| 1847 | assert( ERROR_OCCURRED() ); | ||
| 1848 | |||
| 1849 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1850 | |||
| 1851 | |||
| 1852 | exception_lineno = 31; | ||
| 1853 | |||
| 1854 | goto try_except_handler_5; | ||
| 1855 | } | ||
| 1856 | tmp_assign_source_30 = EVAL_CODE( tmp_eval_compiled_5, tmp_eval_globals_5, tmp_eval_locals_5 ); | ||
| 1857 | Py_DECREF( tmp_eval_compiled_5 ); | ||
| 1858 | if ( tmp_assign_source_30 == NULL ) | ||
| 1859 | { | ||
| 1860 | assert( ERROR_OCCURRED() ); | ||
| 1861 | |||
| 1862 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1863 | |||
| 1864 | |||
| 1865 | exception_lineno = 31; | ||
| 1866 | |||
| 1867 | goto try_except_handler_5; | ||
| 1868 | } | ||
| 1869 | goto try_return_handler_5; | ||
| 1870 | } | ||
| 1871 | // tried codes exits in all cases | ||
| 1872 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 1873 | return MOD_RETURN_VALUE( NULL ); | ||
| 1874 | // Return handler code: | ||
| 1875 | try_return_handler_5:; | ||
| 1876 | CHECK_OBJECT( (PyObject *)tmp_eval_call_5__globals ); | ||
| 1877 | Py_DECREF( tmp_eval_call_5__globals ); | ||
| 1878 | tmp_eval_call_5__globals = NULL; | ||
| 1879 | |||
| 1880 | CHECK_OBJECT( (PyObject *)tmp_eval_call_5__locals ); | ||
| 1881 | Py_DECREF( tmp_eval_call_5__locals ); | ||
| 1882 | tmp_eval_call_5__locals = NULL; | ||
| 1883 | |||
| 1884 | Py_XDECREF( tmp_eval_call_5__source ); | ||
| 1885 | tmp_eval_call_5__source = NULL; | ||
| 1886 | |||
| 1887 | goto outline_result_5; | ||
| 1888 | // Exception handler code: | ||
| 1889 | try_except_handler_5:; | ||
| 1890 | exception_keeper_type_5 = exception_type; | ||
| 1891 | exception_keeper_value_5 = exception_value; | ||
| 1892 | exception_keeper_tb_5 = exception_tb; | ||
| 1893 | exception_keeper_lineno_5 = exception_lineno; | ||
| 1894 | exception_type = NULL; | ||
| 1895 | exception_value = NULL; | ||
| 1896 | exception_tb = NULL; | ||
| 1897 | exception_lineno = 0; | ||
| 1898 | |||
| 1899 | CHECK_OBJECT( (PyObject *)tmp_eval_call_5__globals ); | ||
| 1900 | Py_DECREF( tmp_eval_call_5__globals ); | ||
| 1901 | tmp_eval_call_5__globals = NULL; | ||
| 1902 | |||
| 1903 | CHECK_OBJECT( (PyObject *)tmp_eval_call_5__locals ); | ||
| 1904 | Py_DECREF( tmp_eval_call_5__locals ); | ||
| 1905 | tmp_eval_call_5__locals = NULL; | ||
| 1906 | |||
| 1907 | Py_XDECREF( tmp_eval_call_5__source ); | ||
| 1908 | tmp_eval_call_5__source = NULL; | ||
| 1909 | |||
| 1910 | // Re-raise. | ||
| 1911 | exception_type = exception_keeper_type_5; | ||
| 1912 | exception_value = exception_keeper_value_5; | ||
| 1913 | exception_tb = exception_keeper_tb_5; | ||
| 1914 | exception_lineno = exception_keeper_lineno_5; | ||
| 1915 | |||
| 1916 | goto frame_exception_exit_1; | ||
| 1917 | // End of try: | ||
| 1918 | // Return statement must have exited already. | ||
| 1919 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 1920 | return MOD_RETURN_VALUE( NULL ); | ||
| 1921 | outline_result_5:; | ||
| 1922 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_reload, tmp_assign_source_30 ); | ||
| 1923 | } | ||
| 1924 | { | ||
| 1925 | PyObject *tmp_assign_source_35; | ||
| 1926 | { | ||
| 1927 | PyObject *tmp_assign_source_36; | ||
| 1928 | tmp_assign_source_36 = (PyObject *)moduledict_gi$_compat; | ||
| 1929 | assert( tmp_eval_call_6__locals == NULL ); | ||
| 1930 | Py_INCREF( tmp_assign_source_36 ); | ||
| 1931 | tmp_eval_call_6__locals = tmp_assign_source_36; | ||
| 1932 | } | ||
| 1933 | { | ||
| 1934 | PyObject *tmp_assign_source_37; | ||
| 1935 | tmp_assign_source_37 = (PyObject *)moduledict_gi$_compat; | ||
| 1936 | assert( tmp_eval_call_6__globals == NULL ); | ||
| 1937 | Py_INCREF( tmp_assign_source_37 ); | ||
| 1938 | tmp_eval_call_6__globals = tmp_assign_source_37; | ||
| 1939 | } | ||
| 1940 | { | ||
| 1941 | PyObject *tmp_assign_source_38; | ||
| 1942 | tmp_assign_source_38 = const_str_plain_xrange; | ||
| 1943 | assert( tmp_eval_call_6__source == NULL ); | ||
| 1944 | Py_INCREF( tmp_assign_source_38 ); | ||
| 1945 | tmp_eval_call_6__source = tmp_assign_source_38; | ||
| 1946 | } | ||
| 1947 | // Tried code: | ||
| 1948 | { | ||
| 1949 | PyObject *tmp_assign_source_39; | ||
| 1950 | PyObject *tmp_called_instance_6; | ||
| 1951 | tmp_called_instance_6 = const_str_plain_xrange; | ||
| 1952 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 32; | ||
| 1953 | tmp_assign_source_39 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_6, const_str_plain_strip, &PyTuple_GET_ITEM( const_tuple_str_digest_ac02ab0238280e341b2aff0eed15b128_tuple, 0 ) ); | ||
| 1954 | |||
| 1955 | if ( tmp_assign_source_39 == NULL ) | ||
| 1956 | { | ||
| 1957 | assert( ERROR_OCCURRED() ); | ||
| 1958 | |||
| 1959 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1960 | |||
| 1961 | |||
| 1962 | exception_lineno = 32; | ||
| 1963 | |||
| 1964 | goto try_except_handler_6; | ||
| 1965 | } | ||
| 1966 | { | ||
| 1967 | PyObject *old = tmp_eval_call_6__source; | ||
| 1968 | assert( old != NULL ); | ||
| 1969 | tmp_eval_call_6__source = tmp_assign_source_39; | ||
| 1970 | Py_DECREF( old ); | ||
| 1971 | } | ||
| 1972 | |||
| 1973 | } | ||
| 1974 | { | ||
| 1975 | PyObject *tmp_eval_source_6; | ||
| 1976 | PyObject *tmp_eval_globals_6; | ||
| 1977 | PyObject *tmp_eval_locals_6; | ||
| 1978 | PyObject *tmp_eval_compiled_6; | ||
| 1979 | CHECK_OBJECT( tmp_eval_call_6__source ); | ||
| 1980 | tmp_eval_source_6 = tmp_eval_call_6__source; | ||
| 1981 | CHECK_OBJECT( tmp_eval_call_6__globals ); | ||
| 1982 | tmp_eval_globals_6 = tmp_eval_call_6__globals; | ||
| 1983 | CHECK_OBJECT( tmp_eval_call_6__locals ); | ||
| 1984 | tmp_eval_locals_6 = tmp_eval_call_6__locals; | ||
| 1985 | tmp_eval_compiled_6 = COMPILE_CODE( tmp_eval_source_6, const_str_angle_string, const_str_plain_eval, NULL, NULL, NULL ); | ||
| 1986 | if ( tmp_eval_compiled_6 == NULL ) | ||
| 1987 | { | ||
| 1988 | assert( ERROR_OCCURRED() ); | ||
| 1989 | |||
| 1990 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1991 | |||
| 1992 | |||
| 1993 | exception_lineno = 32; | ||
| 1994 | |||
| 1995 | goto try_except_handler_6; | ||
| 1996 | } | ||
| 1997 | tmp_assign_source_35 = EVAL_CODE( tmp_eval_compiled_6, tmp_eval_globals_6, tmp_eval_locals_6 ); | ||
| 1998 | Py_DECREF( tmp_eval_compiled_6 ); | ||
| 1999 | if ( tmp_assign_source_35 == NULL ) | ||
| 2000 | { | ||
| 2001 | assert( ERROR_OCCURRED() ); | ||
| 2002 | |||
| 2003 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2004 | |||
| 2005 | |||
| 2006 | exception_lineno = 32; | ||
| 2007 | |||
| 2008 | goto try_except_handler_6; | ||
| 2009 | } | ||
| 2010 | goto try_return_handler_6; | ||
| 2011 | } | ||
| 2012 | // tried codes exits in all cases | ||
| 2013 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 2014 | return MOD_RETURN_VALUE( NULL ); | ||
| 2015 | // Return handler code: | ||
| 2016 | try_return_handler_6:; | ||
| 2017 | CHECK_OBJECT( (PyObject *)tmp_eval_call_6__globals ); | ||
| 2018 | Py_DECREF( tmp_eval_call_6__globals ); | ||
| 2019 | tmp_eval_call_6__globals = NULL; | ||
| 2020 | |||
| 2021 | CHECK_OBJECT( (PyObject *)tmp_eval_call_6__locals ); | ||
| 2022 | Py_DECREF( tmp_eval_call_6__locals ); | ||
| 2023 | tmp_eval_call_6__locals = NULL; | ||
| 2024 | |||
| 2025 | Py_XDECREF( tmp_eval_call_6__source ); | ||
| 2026 | tmp_eval_call_6__source = NULL; | ||
| 2027 | |||
| 2028 | goto outline_result_6; | ||
| 2029 | // Exception handler code: | ||
| 2030 | try_except_handler_6:; | ||
| 2031 | exception_keeper_type_6 = exception_type; | ||
| 2032 | exception_keeper_value_6 = exception_value; | ||
| 2033 | exception_keeper_tb_6 = exception_tb; | ||
| 2034 | exception_keeper_lineno_6 = exception_lineno; | ||
| 2035 | exception_type = NULL; | ||
| 2036 | exception_value = NULL; | ||
| 2037 | exception_tb = NULL; | ||
| 2038 | exception_lineno = 0; | ||
| 2039 | |||
| 2040 | CHECK_OBJECT( (PyObject *)tmp_eval_call_6__globals ); | ||
| 2041 | Py_DECREF( tmp_eval_call_6__globals ); | ||
| 2042 | tmp_eval_call_6__globals = NULL; | ||
| 2043 | |||
| 2044 | CHECK_OBJECT( (PyObject *)tmp_eval_call_6__locals ); | ||
| 2045 | Py_DECREF( tmp_eval_call_6__locals ); | ||
| 2046 | tmp_eval_call_6__locals = NULL; | ||
| 2047 | |||
| 2048 | Py_XDECREF( tmp_eval_call_6__source ); | ||
| 2049 | tmp_eval_call_6__source = NULL; | ||
| 2050 | |||
| 2051 | // Re-raise. | ||
| 2052 | exception_type = exception_keeper_type_6; | ||
| 2053 | exception_value = exception_keeper_value_6; | ||
| 2054 | exception_tb = exception_keeper_tb_6; | ||
| 2055 | exception_lineno = exception_keeper_lineno_6; | ||
| 2056 | |||
| 2057 | goto frame_exception_exit_1; | ||
| 2058 | // End of try: | ||
| 2059 | // Return statement must have exited already. | ||
| 2060 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 2061 | return MOD_RETURN_VALUE( NULL ); | ||
| 2062 | outline_result_6:; | ||
| 2063 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_xrange, tmp_assign_source_35 ); | ||
| 2064 | } | ||
| 2065 | { | ||
| 2066 | PyObject *tmp_assign_source_40; | ||
| 2067 | { | ||
| 2068 | PyObject *tmp_assign_source_41; | ||
| 2069 | tmp_assign_source_41 = (PyObject *)moduledict_gi$_compat; | ||
| 2070 | assert( tmp_eval_call_7__locals == NULL ); | ||
| 2071 | Py_INCREF( tmp_assign_source_41 ); | ||
| 2072 | tmp_eval_call_7__locals = tmp_assign_source_41; | ||
| 2073 | } | ||
| 2074 | { | ||
| 2075 | PyObject *tmp_assign_source_42; | ||
| 2076 | tmp_assign_source_42 = (PyObject *)moduledict_gi$_compat; | ||
| 2077 | assert( tmp_eval_call_7__globals == NULL ); | ||
| 2078 | Py_INCREF( tmp_assign_source_42 ); | ||
| 2079 | tmp_eval_call_7__globals = tmp_assign_source_42; | ||
| 2080 | } | ||
| 2081 | { | ||
| 2082 | PyObject *tmp_assign_source_43; | ||
| 2083 | tmp_assign_source_43 = const_str_plain_cmp; | ||
| 2084 | assert( tmp_eval_call_7__source == NULL ); | ||
| 2085 | Py_INCREF( tmp_assign_source_43 ); | ||
| 2086 | tmp_eval_call_7__source = tmp_assign_source_43; | ||
| 2087 | } | ||
| 2088 | // Tried code: | ||
| 2089 | { | ||
| 2090 | PyObject *tmp_assign_source_44; | ||
| 2091 | PyObject *tmp_called_instance_7; | ||
| 2092 | tmp_called_instance_7 = const_str_plain_cmp; | ||
| 2093 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 33; | ||
| 2094 | tmp_assign_source_44 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_7, const_str_plain_strip, &PyTuple_GET_ITEM( const_tuple_str_digest_ac02ab0238280e341b2aff0eed15b128_tuple, 0 ) ); | ||
| 2095 | |||
| 2096 | if ( tmp_assign_source_44 == NULL ) | ||
| 2097 | { | ||
| 2098 | assert( ERROR_OCCURRED() ); | ||
| 2099 | |||
| 2100 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2101 | |||
| 2102 | |||
| 2103 | exception_lineno = 33; | ||
| 2104 | |||
| 2105 | goto try_except_handler_7; | ||
| 2106 | } | ||
| 2107 | { | ||
| 2108 | PyObject *old = tmp_eval_call_7__source; | ||
| 2109 | assert( old != NULL ); | ||
| 2110 | tmp_eval_call_7__source = tmp_assign_source_44; | ||
| 2111 | Py_DECREF( old ); | ||
| 2112 | } | ||
| 2113 | |||
| 2114 | } | ||
| 2115 | { | ||
| 2116 | PyObject *tmp_eval_source_7; | ||
| 2117 | PyObject *tmp_eval_globals_7; | ||
| 2118 | PyObject *tmp_eval_locals_7; | ||
| 2119 | PyObject *tmp_eval_compiled_7; | ||
| 2120 | CHECK_OBJECT( tmp_eval_call_7__source ); | ||
| 2121 | tmp_eval_source_7 = tmp_eval_call_7__source; | ||
| 2122 | CHECK_OBJECT( tmp_eval_call_7__globals ); | ||
| 2123 | tmp_eval_globals_7 = tmp_eval_call_7__globals; | ||
| 2124 | CHECK_OBJECT( tmp_eval_call_7__locals ); | ||
| 2125 | tmp_eval_locals_7 = tmp_eval_call_7__locals; | ||
| 2126 | tmp_eval_compiled_7 = COMPILE_CODE( tmp_eval_source_7, const_str_angle_string, const_str_plain_eval, NULL, NULL, NULL ); | ||
| 2127 | if ( tmp_eval_compiled_7 == NULL ) | ||
| 2128 | { | ||
| 2129 | assert( ERROR_OCCURRED() ); | ||
| 2130 | |||
| 2131 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2132 | |||
| 2133 | |||
| 2134 | exception_lineno = 33; | ||
| 2135 | |||
| 2136 | goto try_except_handler_7; | ||
| 2137 | } | ||
| 2138 | tmp_assign_source_40 = EVAL_CODE( tmp_eval_compiled_7, tmp_eval_globals_7, tmp_eval_locals_7 ); | ||
| 2139 | Py_DECREF( tmp_eval_compiled_7 ); | ||
| 2140 | if ( tmp_assign_source_40 == NULL ) | ||
| 2141 | { | ||
| 2142 | assert( ERROR_OCCURRED() ); | ||
| 2143 | |||
| 2144 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2145 | |||
| 2146 | |||
| 2147 | exception_lineno = 33; | ||
| 2148 | |||
| 2149 | goto try_except_handler_7; | ||
| 2150 | } | ||
| 2151 | goto try_return_handler_7; | ||
| 2152 | } | ||
| 2153 | // tried codes exits in all cases | ||
| 2154 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 2155 | return MOD_RETURN_VALUE( NULL ); | ||
| 2156 | // Return handler code: | ||
| 2157 | try_return_handler_7:; | ||
| 2158 | CHECK_OBJECT( (PyObject *)tmp_eval_call_7__globals ); | ||
| 2159 | Py_DECREF( tmp_eval_call_7__globals ); | ||
| 2160 | tmp_eval_call_7__globals = NULL; | ||
| 2161 | |||
| 2162 | CHECK_OBJECT( (PyObject *)tmp_eval_call_7__locals ); | ||
| 2163 | Py_DECREF( tmp_eval_call_7__locals ); | ||
| 2164 | tmp_eval_call_7__locals = NULL; | ||
| 2165 | |||
| 2166 | Py_XDECREF( tmp_eval_call_7__source ); | ||
| 2167 | tmp_eval_call_7__source = NULL; | ||
| 2168 | |||
| 2169 | goto outline_result_7; | ||
| 2170 | // Exception handler code: | ||
| 2171 | try_except_handler_7:; | ||
| 2172 | exception_keeper_type_7 = exception_type; | ||
| 2173 | exception_keeper_value_7 = exception_value; | ||
| 2174 | exception_keeper_tb_7 = exception_tb; | ||
| 2175 | exception_keeper_lineno_7 = exception_lineno; | ||
| 2176 | exception_type = NULL; | ||
| 2177 | exception_value = NULL; | ||
| 2178 | exception_tb = NULL; | ||
| 2179 | exception_lineno = 0; | ||
| 2180 | |||
| 2181 | CHECK_OBJECT( (PyObject *)tmp_eval_call_7__globals ); | ||
| 2182 | Py_DECREF( tmp_eval_call_7__globals ); | ||
| 2183 | tmp_eval_call_7__globals = NULL; | ||
| 2184 | |||
| 2185 | CHECK_OBJECT( (PyObject *)tmp_eval_call_7__locals ); | ||
| 2186 | Py_DECREF( tmp_eval_call_7__locals ); | ||
| 2187 | tmp_eval_call_7__locals = NULL; | ||
| 2188 | |||
| 2189 | Py_XDECREF( tmp_eval_call_7__source ); | ||
| 2190 | tmp_eval_call_7__source = NULL; | ||
| 2191 | |||
| 2192 | // Re-raise. | ||
| 2193 | exception_type = exception_keeper_type_7; | ||
| 2194 | exception_value = exception_keeper_value_7; | ||
| 2195 | exception_tb = exception_keeper_tb_7; | ||
| 2196 | exception_lineno = exception_keeper_lineno_7; | ||
| 2197 | |||
| 2198 | goto frame_exception_exit_1; | ||
| 2199 | // End of try: | ||
| 2200 | // Return statement must have exited already. | ||
| 2201 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 2202 | return MOD_RETURN_VALUE( NULL ); | ||
| 2203 | outline_result_7:; | ||
| 2204 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_cmp, tmp_assign_source_40 ); | ||
| 2205 | } | ||
| 2206 | { | ||
| 2207 | PyObject *tmp_outline_return_value_1; | ||
| 2208 | { | ||
| 2209 | PyObject *tmp_assign_source_45; | ||
| 2210 | tmp_assign_source_45 = (PyObject *)moduledict_gi$_compat; | ||
| 2211 | assert( tmp_exec_call_1__locals == NULL ); | ||
| 2212 | Py_INCREF( tmp_assign_source_45 ); | ||
| 2213 | tmp_exec_call_1__locals = tmp_assign_source_45; | ||
| 2214 | } | ||
| 2215 | { | ||
| 2216 | PyObject *tmp_assign_source_46; | ||
| 2217 | tmp_assign_source_46 = (PyObject *)moduledict_gi$_compat; | ||
| 2218 | assert( tmp_exec_call_1__globals == NULL ); | ||
| 2219 | Py_INCREF( tmp_assign_source_46 ); | ||
| 2220 | tmp_exec_call_1__globals = tmp_assign_source_46; | ||
| 2221 | } | ||
| 2222 | // Tried code: | ||
| 2223 | { | ||
| 2224 | PyObject *tmp_eval_source_8; | ||
| 2225 | PyObject *tmp_eval_globals_8; | ||
| 2226 | PyObject *tmp_eval_locals_8; | ||
| 2227 | PyObject *tmp_eval_compiled_8; | ||
| 2228 | tmp_eval_source_8 = const_str_digest_58ff6ccfc11c8774c9d298b85af436df; | ||
| 2229 | CHECK_OBJECT( tmp_exec_call_1__globals ); | ||
| 2230 | tmp_eval_globals_8 = tmp_exec_call_1__globals; | ||
| 2231 | CHECK_OBJECT( tmp_exec_call_1__locals ); | ||
| 2232 | tmp_eval_locals_8 = tmp_exec_call_1__locals; | ||
| 2233 | tmp_eval_compiled_8 = COMPILE_CODE( tmp_eval_source_8, const_str_angle_string, const_str_plain_exec, NULL, NULL, NULL ); | ||
| 2234 | if ( tmp_eval_compiled_8 == NULL ) | ||
| 2235 | { | ||
| 2236 | assert( ERROR_OCCURRED() ); | ||
| 2237 | |||
| 2238 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2239 | |||
| 2240 | |||
| 2241 | exception_lineno = 35; | ||
| 2242 | |||
| 2243 | goto try_except_handler_8; | ||
| 2244 | } | ||
| 2245 | tmp_outline_return_value_1 = EVAL_CODE( tmp_eval_compiled_8, tmp_eval_globals_8, tmp_eval_locals_8 ); | ||
| 2246 | Py_DECREF( tmp_eval_compiled_8 ); | ||
| 2247 | if ( tmp_outline_return_value_1 == NULL ) | ||
| 2248 | { | ||
| 2249 | assert( ERROR_OCCURRED() ); | ||
| 2250 | |||
| 2251 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2252 | |||
| 2253 | |||
| 2254 | exception_lineno = 35; | ||
| 2255 | |||
| 2256 | goto try_except_handler_8; | ||
| 2257 | } | ||
| 2258 | goto try_return_handler_8; | ||
| 2259 | } | ||
| 2260 | // tried codes exits in all cases | ||
| 2261 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 2262 | return MOD_RETURN_VALUE( NULL ); | ||
| 2263 | // Return handler code: | ||
| 2264 | try_return_handler_8:; | ||
| 2265 | CHECK_OBJECT( (PyObject *)tmp_exec_call_1__globals ); | ||
| 2266 | Py_DECREF( tmp_exec_call_1__globals ); | ||
| 2267 | tmp_exec_call_1__globals = NULL; | ||
| 2268 | |||
| 2269 | CHECK_OBJECT( (PyObject *)tmp_exec_call_1__locals ); | ||
| 2270 | Py_DECREF( tmp_exec_call_1__locals ); | ||
| 2271 | tmp_exec_call_1__locals = NULL; | ||
| 2272 | |||
| 2273 | goto outline_result_8; | ||
| 2274 | // Exception handler code: | ||
| 2275 | try_except_handler_8:; | ||
| 2276 | exception_keeper_type_8 = exception_type; | ||
| 2277 | exception_keeper_value_8 = exception_value; | ||
| 2278 | exception_keeper_tb_8 = exception_tb; | ||
| 2279 | exception_keeper_lineno_8 = exception_lineno; | ||
| 2280 | exception_type = NULL; | ||
| 2281 | exception_value = NULL; | ||
| 2282 | exception_tb = NULL; | ||
| 2283 | exception_lineno = 0; | ||
| 2284 | |||
| 2285 | CHECK_OBJECT( (PyObject *)tmp_exec_call_1__globals ); | ||
| 2286 | Py_DECREF( tmp_exec_call_1__globals ); | ||
| 2287 | tmp_exec_call_1__globals = NULL; | ||
| 2288 | |||
| 2289 | CHECK_OBJECT( (PyObject *)tmp_exec_call_1__locals ); | ||
| 2290 | Py_DECREF( tmp_exec_call_1__locals ); | ||
| 2291 | tmp_exec_call_1__locals = NULL; | ||
| 2292 | |||
| 2293 | // Re-raise. | ||
| 2294 | exception_type = exception_keeper_type_8; | ||
| 2295 | exception_value = exception_keeper_value_8; | ||
| 2296 | exception_tb = exception_keeper_tb_8; | ||
| 2297 | exception_lineno = exception_keeper_lineno_8; | ||
| 2298 | |||
| 2299 | goto frame_exception_exit_1; | ||
| 2300 | // End of try: | ||
| 2301 | // Return statement must have exited already. | ||
| 2302 | NUITKA_CANNOT_GET_HERE( gi$_compat ); | ||
| 2303 | return MOD_RETURN_VALUE( NULL ); | ||
| 2304 | outline_result_8:; | ||
| 2305 | Py_DECREF( tmp_outline_return_value_1 ); | ||
| 2306 | } | ||
| 2307 | goto branch_end_1; | ||
| 2308 | branch_no_1:; | ||
| 2309 | { | ||
| 2310 | PyObject *tmp_assign_source_47; | ||
| 2311 | tmp_assign_source_47 = Py_True; | ||
| 2312 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_PY3, tmp_assign_source_47 ); | ||
| 2313 | } | ||
| 2314 | { | ||
| 2315 | PyObject *tmp_assign_source_48; | ||
| 2316 | PyObject *tmp_import_name_from_3; | ||
| 2317 | PyObject *tmp_name_name_4; | ||
| 2318 | PyObject *tmp_globals_name_4; | ||
| 2319 | PyObject *tmp_locals_name_4; | ||
| 2320 | PyObject *tmp_fromlist_name_4; | ||
| 2321 | PyObject *tmp_level_name_4; | ||
| 2322 | tmp_name_name_4 = const_str_plain_io; | ||
| 2323 | tmp_globals_name_4 = (PyObject *)moduledict_gi$_compat; | ||
| 2324 | tmp_locals_name_4 = Py_None; | ||
| 2325 | tmp_fromlist_name_4 = const_tuple_str_plain_StringIO_tuple; | ||
| 2326 | tmp_level_name_4 = const_int_0; | ||
| 2327 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 39; | ||
| 2328 | tmp_import_name_from_3 = IMPORT_MODULE5( tmp_name_name_4, tmp_globals_name_4, tmp_locals_name_4, tmp_fromlist_name_4, tmp_level_name_4 ); | ||
| 2329 | if ( tmp_import_name_from_3 == NULL ) | ||
| 2330 | { | ||
| 2331 | assert( ERROR_OCCURRED() ); | ||
| 2332 | |||
| 2333 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2334 | |||
| 2335 | |||
| 2336 | exception_lineno = 39; | ||
| 2337 | |||
| 2338 | goto frame_exception_exit_1; | ||
| 2339 | } | ||
| 2340 | tmp_assign_source_48 = IMPORT_NAME( tmp_import_name_from_3, const_str_plain_StringIO ); | ||
| 2341 | Py_DECREF( tmp_import_name_from_3 ); | ||
| 2342 | if ( tmp_assign_source_48 == NULL ) | ||
| 2343 | { | ||
| 2344 | assert( ERROR_OCCURRED() ); | ||
| 2345 | |||
| 2346 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2347 | |||
| 2348 | |||
| 2349 | exception_lineno = 39; | ||
| 2350 | |||
| 2351 | goto frame_exception_exit_1; | ||
| 2352 | } | ||
| 2353 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_StringIO, tmp_assign_source_48 ); | ||
| 2354 | } | ||
| 2355 | { | ||
| 2356 | PyObject *tmp_assign_source_49; | ||
| 2357 | PyObject *tmp_import_name_from_4; | ||
| 2358 | PyObject *tmp_name_name_5; | ||
| 2359 | PyObject *tmp_globals_name_5; | ||
| 2360 | PyObject *tmp_locals_name_5; | ||
| 2361 | PyObject *tmp_fromlist_name_5; | ||
| 2362 | PyObject *tmp_level_name_5; | ||
| 2363 | tmp_name_name_5 = const_str_plain_collections; | ||
| 2364 | tmp_globals_name_5 = (PyObject *)moduledict_gi$_compat; | ||
| 2365 | tmp_locals_name_5 = Py_None; | ||
| 2366 | tmp_fromlist_name_5 = const_tuple_str_plain_UserList_tuple; | ||
| 2367 | tmp_level_name_5 = const_int_0; | ||
| 2368 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 42; | ||
| 2369 | tmp_import_name_from_4 = IMPORT_MODULE5( tmp_name_name_5, tmp_globals_name_5, tmp_locals_name_5, tmp_fromlist_name_5, tmp_level_name_5 ); | ||
| 2370 | if ( tmp_import_name_from_4 == NULL ) | ||
| 2371 | { | ||
| 2372 | assert( ERROR_OCCURRED() ); | ||
| 2373 | |||
| 2374 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2375 | |||
| 2376 | |||
| 2377 | exception_lineno = 42; | ||
| 2378 | |||
| 2379 | goto frame_exception_exit_1; | ||
| 2380 | } | ||
| 2381 | tmp_assign_source_49 = IMPORT_NAME( tmp_import_name_from_4, const_str_plain_UserList ); | ||
| 2382 | Py_DECREF( tmp_import_name_from_4 ); | ||
| 2383 | if ( tmp_assign_source_49 == NULL ) | ||
| 2384 | { | ||
| 2385 | assert( ERROR_OCCURRED() ); | ||
| 2386 | |||
| 2387 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2388 | |||
| 2389 | |||
| 2390 | exception_lineno = 42; | ||
| 2391 | |||
| 2392 | goto frame_exception_exit_1; | ||
| 2393 | } | ||
| 2394 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_UserList, tmp_assign_source_49 ); | ||
| 2395 | } | ||
| 2396 | { | ||
| 2397 | PyObject *tmp_assign_source_50; | ||
| 2398 | tmp_assign_source_50 = (PyObject *)&PyLong_Type; | ||
| 2399 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_long_, tmp_assign_source_50 ); | ||
| 2400 | } | ||
| 2401 | { | ||
| 2402 | PyObject *tmp_assign_source_51; | ||
| 2403 | tmp_assign_source_51 = const_tuple_type_int_tuple; | ||
| 2404 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_integer_types, tmp_assign_source_51 ); | ||
| 2405 | } | ||
| 2406 | { | ||
| 2407 | PyObject *tmp_assign_source_52; | ||
| 2408 | tmp_assign_source_52 = const_tuple_type_str_tuple; | ||
| 2409 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_string_types, tmp_assign_source_52 ); | ||
| 2410 | } | ||
| 2411 | { | ||
| 2412 | PyObject *tmp_assign_source_53; | ||
| 2413 | tmp_assign_source_53 = (PyObject *)&PyUnicode_Type; | ||
| 2414 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_text_type, tmp_assign_source_53 ); | ||
| 2415 | } | ||
| 2416 | { | ||
| 2417 | PyObject *tmp_assign_source_54; | ||
| 2418 | PyObject *tmp_import_name_from_5; | ||
| 2419 | PyObject *tmp_name_name_6; | ||
| 2420 | PyObject *tmp_globals_name_6; | ||
| 2421 | PyObject *tmp_locals_name_6; | ||
| 2422 | PyObject *tmp_fromlist_name_6; | ||
| 2423 | PyObject *tmp_level_name_6; | ||
| 2424 | tmp_name_name_6 = const_str_plain_importlib; | ||
| 2425 | tmp_globals_name_6 = (PyObject *)moduledict_gi$_compat; | ||
| 2426 | tmp_locals_name_6 = Py_None; | ||
| 2427 | tmp_fromlist_name_6 = const_tuple_str_plain_reload_tuple; | ||
| 2428 | tmp_level_name_6 = const_int_0; | ||
| 2429 | frame_158919088c58de14a3074744c1c289e5->m_frame.f_lineno = 50; | ||
| 2430 | tmp_import_name_from_5 = IMPORT_MODULE5( tmp_name_name_6, tmp_globals_name_6, tmp_locals_name_6, tmp_fromlist_name_6, tmp_level_name_6 ); | ||
| 2431 | if ( tmp_import_name_from_5 == NULL ) | ||
| 2432 | { | ||
| 2433 | assert( ERROR_OCCURRED() ); | ||
| 2434 | |||
| 2435 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2436 | |||
| 2437 | |||
| 2438 | exception_lineno = 50; | ||
| 2439 | |||
| 2440 | goto frame_exception_exit_1; | ||
| 2441 | } | ||
| 2442 | tmp_assign_source_54 = IMPORT_NAME( tmp_import_name_from_5, const_str_plain_reload ); | ||
| 2443 | Py_DECREF( tmp_import_name_from_5 ); | ||
| 2444 | if ( tmp_assign_source_54 == NULL ) | ||
| 2445 | { | ||
| 2446 | assert( ERROR_OCCURRED() ); | ||
| 2447 | |||
| 2448 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2449 | |||
| 2450 | |||
| 2451 | exception_lineno = 50; | ||
| 2452 | |||
| 2453 | goto frame_exception_exit_1; | ||
| 2454 | } | ||
| 2455 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_reload, tmp_assign_source_54 ); | ||
| 2456 | } | ||
| 2457 | { | ||
| 2458 | PyObject *tmp_assign_source_55; | ||
| 2459 | tmp_assign_source_55 = (PyObject *)&PyRange_Type; | ||
| 2460 | UPDATE_STRING_DICT0( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_xrange, tmp_assign_source_55 ); | ||
| 2461 | } | ||
| 2462 | { | ||
| 2463 | PyObject *tmp_assign_source_56; | ||
| 2464 | tmp_assign_source_56 = MAKE_FUNCTION_gi$_compat$$$function_1_lambda( ); | ||
| 2465 | |||
| 2466 | |||
| 2467 | |||
| 2468 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_cmp, tmp_assign_source_56 ); | ||
| 2469 | } | ||
| 2470 | { | ||
| 2471 | PyObject *tmp_assign_source_57; | ||
| 2472 | tmp_assign_source_57 = MAKE_FUNCTION_gi$_compat$$$function_2_reraise( ); | ||
| 2473 | |||
| 2474 | |||
| 2475 | |||
| 2476 | UPDATE_STRING_DICT1( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain_reraise, tmp_assign_source_57 ); | ||
| 2477 | } | ||
| 2478 | branch_end_1:; | ||
| 2479 | } | ||
| 2480 | |||
| 2481 | // Restore frame exception if necessary. | ||
| 2482 | #if 0 | ||
| 2483 | RESTORE_FRAME_EXCEPTION( frame_158919088c58de14a3074744c1c289e5 ); | ||
| 2484 | #endif | ||
| 2485 | popFrameStack(); | ||
| 2486 | |||
| 2487 | assertFrameObject( frame_158919088c58de14a3074744c1c289e5 ); | ||
| 2488 | |||
| 2489 | goto frame_no_exception_1; | ||
| 2490 | |||
| 2491 | frame_exception_exit_1:; | ||
| 2492 | #if 0 | ||
| 2493 | RESTORE_FRAME_EXCEPTION( frame_158919088c58de14a3074744c1c289e5 ); | ||
| 2494 | #endif | ||
| 2495 | |||
| 2496 | if ( exception_tb == NULL ) | ||
| 2497 | { | ||
| 2498 | exception_tb = MAKE_TRACEBACK( frame_158919088c58de14a3074744c1c289e5, exception_lineno ); | ||
| 2499 | } | ||
| 2500 | else if ( exception_tb->tb_frame != &frame_158919088c58de14a3074744c1c289e5->m_frame ) | ||
| 2501 | { | ||
| 2502 | exception_tb = ADD_TRACEBACK( exception_tb, frame_158919088c58de14a3074744c1c289e5, exception_lineno ); | ||
| 2503 | } | ||
| 2504 | |||
| 2505 | // Put the previous frame back on top. | ||
| 2506 | popFrameStack(); | ||
| 2507 | |||
| 2508 | // Return the error. | ||
| 2509 | goto module_exception_exit; | ||
| 2510 | |||
| 2511 | frame_no_exception_1:; | ||
| 2512 | |||
| 2513 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 2514 | #if 0 && 0 | ||
| 2515 | { | ||
| 2516 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_gi$_compat, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 2517 | |||
| 2518 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 2519 | { | ||
| 2520 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 2521 | |||
| 2522 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 2523 | CHECK_OBJECT( path_importer_cache ); | ||
| 2524 | |||
| 2525 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 2526 | assert( res == 0 ); | ||
| 2527 | } | ||
| 2528 | } | ||
| 2529 | #endif | ||
| 2530 | #endif | ||
| 2531 | |||
| 2532 | return MOD_RETURN_VALUE( module_gi$_compat ); | ||
| 2533 | module_exception_exit: | ||
| 2534 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 2535 | return MOD_RETURN_VALUE( NULL ); | ||
| 2536 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.gi._compat.o deleted (index 39d484d..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.gi._constants.c deleted (index afc3b7e..0000000) | |||
| 1 | /* Generated code for Python module 'gi._constants' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_gi$_constants" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_gi$_constants; | ||
| 31 | PyDictObject *moduledict_gi$_constants; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | static PyObject *const_str_plain_gchararray; | ||
| 35 | static PyObject *const_str_plain_GStrv; | ||
| 36 | extern PyObject *const_str_plain_TYPE_DOUBLE; | ||
| 37 | extern PyObject *const_str_plain___spec__; | ||
| 38 | static PyObject *const_str_plain_TYPE_UNICHAR; | ||
| 39 | extern PyObject *const_str_plain_GEnum; | ||
| 40 | static PyObject *const_str_plain_gint64; | ||
| 41 | static PyObject *const_tuple_str_plain_guchar_tuple; | ||
| 42 | extern PyObject *const_str_plain_TYPE_GTYPE; | ||
| 43 | extern PyObject *const_str_plain_TYPE_UINT64; | ||
| 44 | extern PyObject *const_str_plain___file__; | ||
| 45 | static PyObject *const_str_plain_gpointer; | ||
| 46 | static PyObject *const_tuple_str_plain_guint64_tuple; | ||
| 47 | extern PyObject *const_str_plain_TYPE_NONE; | ||
| 48 | extern PyObject *const_str_plain_TYPE_ENUM; | ||
| 49 | static PyObject *const_tuple_str_plain_gint64_tuple; | ||
| 50 | static PyObject *const_str_digest_eaf2c61369c720726d6bfae3a829bdae; | ||
| 51 | extern PyObject *const_str_digest_f4d333e44bfac310ff46328bad2521a0; | ||
| 52 | extern PyObject *const_str_plain_TYPE_PARAM; | ||
| 53 | static PyObject *const_str_digest_9b67c33d1a2b2293a94de4d5cb0bc1c3; | ||
| 54 | extern PyObject *const_str_plain___doc__; | ||
| 55 | extern PyObject *const_str_plain_TYPE_INT64; | ||
| 56 | extern PyObject *const_str_plain_TYPE_INTERFACE; | ||
| 57 | static PyObject *const_tuple_str_plain_guint_tuple; | ||
| 58 | static PyObject *const_tuple_str_plain_gulong_tuple; | ||
| 59 | static PyObject *const_tuple_str_plain_gpointer_tuple; | ||
| 60 | static PyObject *const_tuple_str_plain_gfloat_tuple; | ||
| 61 | static PyObject *const_str_plain_gint; | ||
| 62 | static PyObject *const_tuple_str_plain_gboolean_tuple; | ||
| 63 | static PyObject *const_tuple_str_plain_gdouble_tuple; | ||
| 64 | extern PyObject *const_tuple_str_plain__gi_tuple; | ||
| 65 | extern PyObject *const_str_plain_TYPE_BOXED; | ||
| 66 | extern PyObject *const_str_plain_GObject; | ||
| 67 | extern PyObject *const_str_plain_TYPE_UINT; | ||
| 68 | static PyObject *const_tuple_str_plain_GVariant_tuple; | ||
| 69 | extern PyObject *const_str_plain_GType; | ||
| 70 | extern PyObject *const_tuple_empty; | ||
| 71 | extern PyObject *const_str_plain_TYPE_CHAR; | ||
| 72 | extern PyObject *const_str_plain_TYPE_FLOAT; | ||
| 73 | extern PyObject *const_str_plain_TYPE_BOOLEAN; | ||
| 74 | extern PyObject *const_str_plain_TYPE_INT; | ||
| 75 | static PyObject *const_str_plain_gulong; | ||
| 76 | static PyObject *const_str_plain_from_name; | ||
| 77 | static PyObject *const_tuple_str_plain_GFlags_tuple; | ||
| 78 | extern PyObject *const_str_plain_TYPE_FLAGS; | ||
| 79 | static PyObject *const_tuple_str_plain_GParam_tuple; | ||
| 80 | extern PyObject *const_str_plain_void; | ||
| 81 | static PyObject *const_str_plain_GParam; | ||
| 82 | static PyObject *const_tuple_str_plain_GType_tuple; | ||
| 83 | extern PyObject *const_str_plain_TYPE_UCHAR; | ||
| 84 | static PyObject *const_str_plain_gfloat; | ||
| 85 | static PyObject *const_tuple_str_plain_gint_tuple; | ||
| 86 | extern PyObject *const_str_plain_TYPE_POINTER; | ||
| 87 | extern PyObject *const_str_plain__gi; | ||
| 88 | static PyObject *const_str_plain_gboolean; | ||
| 89 | extern PyObject *const_tuple_str_plain_void_tuple; | ||
| 90 | extern PyObject *const_str_plain_TYPE_PYOBJECT; | ||
| 91 | extern PyObject *const_str_plain_TYPE_STRING; | ||
| 92 | extern PyObject *const_str_plain_TYPE_ULONG; | ||
| 93 | static PyObject *const_tuple_str_plain_GBoxed_tuple; | ||
| 94 | static PyObject *const_str_plain_guint64; | ||
| 95 | extern PyObject *const_str_plain_GFlags; | ||
| 96 | static PyObject *const_str_plain_glong; | ||
| 97 | static PyObject *const_tuple_str_plain_GInterface_tuple; | ||
| 98 | static PyObject *const_tuple_str_plain_gchar_tuple; | ||
| 99 | extern PyObject *const_str_plain_origin; | ||
| 100 | extern PyObject *const_str_plain_TYPE_VARIANT; | ||
| 101 | static PyObject *const_tuple_str_plain_GStrv_tuple; | ||
| 102 | static PyObject *const_tuple_str_plain_PyObject_tuple; | ||
| 103 | static PyObject *const_tuple_str_plain_glong_tuple; | ||
| 104 | extern PyObject *const_str_plain___cached__; | ||
| 105 | static PyObject *const_str_plain_guint; | ||
| 106 | static PyObject *const_str_plain_gdouble; | ||
| 107 | extern PyObject *const_int_pos_1; | ||
| 108 | static PyObject *const_str_plain_GVariant; | ||
| 109 | extern PyObject *const_str_plain_GBoxed; | ||
| 110 | static PyObject *const_tuple_str_plain_gchararray_tuple; | ||
| 111 | extern PyObject *const_str_plain_TYPE_LONG; | ||
| 112 | static PyObject *const_str_plain_PyObject; | ||
| 113 | extern PyObject *const_str_plain_TYPE_INVALID; | ||
| 114 | static PyObject *const_str_plain_guchar; | ||
| 115 | extern PyObject *const_str_plain_TYPE_STRV; | ||
| 116 | extern PyObject *const_str_plain_has_location; | ||
| 117 | extern PyObject *const_tuple_str_plain_GObject_tuple; | ||
| 118 | extern PyObject *const_str_empty; | ||
| 119 | static PyObject *const_tuple_str_plain_GEnum_tuple; | ||
| 120 | static PyObject *const_str_plain_gchar; | ||
| 121 | extern PyObject *const_str_plain_GInterface; | ||
| 122 | extern PyObject *const_str_plain_TYPE_OBJECT; | ||
| 123 | static PyObject *module_filename_obj; | ||
| 124 | |||
| 125 | /* Indicator if this modules private constants were created yet. */ | ||
| 126 | static bool constants_created = false; | ||
| 127 | |||
| 128 | /* Function to create module private constants. */ | ||
| 129 | static void createModuleConstants( void ) | ||
| 130 | { | ||
| 131 | const_str_plain_gchararray = UNSTREAM_STRING_ASCII( &constant_bin[ 36198 ], 10, 1 ); | ||
| 132 | const_str_plain_GStrv = UNSTREAM_STRING_ASCII( &constant_bin[ 36208 ], 5, 1 ); | ||
| 133 | const_str_plain_TYPE_UNICHAR = UNSTREAM_STRING_ASCII( &constant_bin[ 36213 ], 12, 1 ); | ||
| 134 | const_str_plain_gint64 = UNSTREAM_STRING_ASCII( &constant_bin[ 36225 ], 6, 1 ); | ||
| 135 | const_tuple_str_plain_guchar_tuple = PyTuple_New( 1 ); | ||
| 136 | const_str_plain_guchar = UNSTREAM_STRING_ASCII( &constant_bin[ 36231 ], 6, 1 ); | ||
| 137 | PyTuple_SET_ITEM( const_tuple_str_plain_guchar_tuple, 0, const_str_plain_guchar ); Py_INCREF( const_str_plain_guchar ); | ||
| 138 | const_str_plain_gpointer = UNSTREAM_STRING_ASCII( &constant_bin[ 36237 ], 8, 1 ); | ||
| 139 | const_tuple_str_plain_guint64_tuple = PyTuple_New( 1 ); | ||
| 140 | const_str_plain_guint64 = UNSTREAM_STRING_ASCII( &constant_bin[ 36245 ], 7, 1 ); | ||
| 141 | PyTuple_SET_ITEM( const_tuple_str_plain_guint64_tuple, 0, const_str_plain_guint64 ); Py_INCREF( const_str_plain_guint64 ); | ||
| 142 | const_tuple_str_plain_gint64_tuple = PyTuple_New( 1 ); | ||
| 143 | PyTuple_SET_ITEM( const_tuple_str_plain_gint64_tuple, 0, const_str_plain_gint64 ); Py_INCREF( const_str_plain_gint64 ); | ||
| 144 | const_str_digest_eaf2c61369c720726d6bfae3a829bdae = UNSTREAM_STRING_ASCII( &constant_bin[ 36252 ], 22, 0 ); | ||
| 145 | const_str_digest_9b67c33d1a2b2293a94de4d5cb0bc1c3 = UNSTREAM_STRING_ASCII( &constant_bin[ 36274 ], 16, 0 ); | ||
| 146 | const_tuple_str_plain_guint_tuple = PyTuple_New( 1 ); | ||
| 147 | const_str_plain_guint = UNSTREAM_STRING_ASCII( &constant_bin[ 36245 ], 5, 1 ); | ||
| 148 | PyTuple_SET_ITEM( const_tuple_str_plain_guint_tuple, 0, const_str_plain_guint ); Py_INCREF( const_str_plain_guint ); | ||
| 149 | const_tuple_str_plain_gulong_tuple = PyTuple_New( 1 ); | ||
| 150 | const_str_plain_gulong = UNSTREAM_STRING_ASCII( &constant_bin[ 36290 ], 6, 1 ); | ||
| 151 | PyTuple_SET_ITEM( const_tuple_str_plain_gulong_tuple, 0, const_str_plain_gulong ); Py_INCREF( const_str_plain_gulong ); | ||
| 152 | const_tuple_str_plain_gpointer_tuple = PyTuple_New( 1 ); | ||
| 153 | PyTuple_SET_ITEM( const_tuple_str_plain_gpointer_tuple, 0, const_str_plain_gpointer ); Py_INCREF( const_str_plain_gpointer ); | ||
| 154 | const_tuple_str_plain_gfloat_tuple = PyTuple_New( 1 ); | ||
| 155 | const_str_plain_gfloat = UNSTREAM_STRING_ASCII( &constant_bin[ 36296 ], 6, 1 ); | ||
| 156 | PyTuple_SET_ITEM( const_tuple_str_plain_gfloat_tuple, 0, const_str_plain_gfloat ); Py_INCREF( const_str_plain_gfloat ); | ||
| 157 | const_str_plain_gint = UNSTREAM_STRING_ASCII( &constant_bin[ 36225 ], 4, 1 ); | ||
| 158 | const_tuple_str_plain_gboolean_tuple = PyTuple_New( 1 ); | ||
| 159 | const_str_plain_gboolean = UNSTREAM_STRING_ASCII( &constant_bin[ 36302 ], 8, 1 ); | ||
| 160 | PyTuple_SET_ITEM( const_tuple_str_plain_gboolean_tuple, 0, const_str_plain_gboolean ); Py_INCREF( const_str_plain_gboolean ); | ||
| 161 | const_tuple_str_plain_gdouble_tuple = PyTuple_New( 1 ); | ||
| 162 | const_str_plain_gdouble = UNSTREAM_STRING_ASCII( &constant_bin[ 36310 ], 7, 1 ); | ||
| 163 | PyTuple_SET_ITEM( const_tuple_str_plain_gdouble_tuple, 0, const_str_plain_gdouble ); Py_INCREF( const_str_plain_gdouble ); | ||
| 164 | const_tuple_str_plain_GVariant_tuple = PyTuple_New( 1 ); | ||
| 165 | const_str_plain_GVariant = UNSTREAM_STRING_ASCII( &constant_bin[ 36317 ], 8, 1 ); | ||
| 166 | PyTuple_SET_ITEM( const_tuple_str_plain_GVariant_tuple, 0, const_str_plain_GVariant ); Py_INCREF( const_str_plain_GVariant ); | ||
| 167 | const_str_plain_from_name = UNSTREAM_STRING_ASCII( &constant_bin[ 36325 ], 9, 1 ); | ||
| 168 | const_tuple_str_plain_GFlags_tuple = PyTuple_New( 1 ); | ||
| 169 | PyTuple_SET_ITEM( const_tuple_str_plain_GFlags_tuple, 0, const_str_plain_GFlags ); Py_INCREF( const_str_plain_GFlags ); | ||
| 170 | const_tuple_str_plain_GParam_tuple = PyTuple_New( 1 ); | ||
| 171 | const_str_plain_GParam = UNSTREAM_STRING_ASCII( &constant_bin[ 36334 ], 6, 1 ); | ||
| 172 | PyTuple_SET_ITEM( const_tuple_str_plain_GParam_tuple, 0, const_str_plain_GParam ); Py_INCREF( const_str_plain_GParam ); | ||
| 173 | const_tuple_str_plain_GType_tuple = PyTuple_New( 1 ); | ||
| 174 | PyTuple_SET_ITEM( const_tuple_str_plain_GType_tuple, 0, const_str_plain_GType ); Py_INCREF( const_str_plain_GType ); | ||
| 175 | const_tuple_str_plain_gint_tuple = PyTuple_New( 1 ); | ||
| 176 | PyTuple_SET_ITEM( const_tuple_str_plain_gint_tuple, 0, const_str_plain_gint ); Py_INCREF( const_str_plain_gint ); | ||
| 177 | const_tuple_str_plain_GBoxed_tuple = PyTuple_New( 1 ); | ||
| 178 | PyTuple_SET_ITEM( const_tuple_str_plain_GBoxed_tuple, 0, const_str_plain_GBoxed ); Py_INCREF( const_str_plain_GBoxed ); | ||
| 179 | const_str_plain_glong = UNSTREAM_STRING_ASCII( &constant_bin[ 36340 ], 5, 1 ); | ||
| 180 | const_tuple_str_plain_GInterface_tuple = PyTuple_New( 1 ); | ||
| 181 | PyTuple_SET_ITEM( const_tuple_str_plain_GInterface_tuple, 0, const_str_plain_GInterface ); Py_INCREF( const_str_plain_GInterface ); | ||
| 182 | const_tuple_str_plain_gchar_tuple = PyTuple_New( 1 ); | ||
| 183 | const_str_plain_gchar = UNSTREAM_STRING_ASCII( &constant_bin[ 36198 ], 5, 1 ); | ||
| 184 | PyTuple_SET_ITEM( const_tuple_str_plain_gchar_tuple, 0, const_str_plain_gchar ); Py_INCREF( const_str_plain_gchar ); | ||
| 185 | const_tuple_str_plain_GStrv_tuple = PyTuple_New( 1 ); | ||
| 186 | PyTuple_SET_ITEM( const_tuple_str_plain_GStrv_tuple, 0, const_str_plain_GStrv ); Py_INCREF( const_str_plain_GStrv ); | ||
| 187 | const_tuple_str_plain_PyObject_tuple = PyTuple_New( 1 ); | ||
| 188 | const_str_plain_PyObject = UNSTREAM_STRING_ASCII( &constant_bin[ 36345 ], 8, 1 ); | ||
| 189 | PyTuple_SET_ITEM( const_tuple_str_plain_PyObject_tuple, 0, const_str_plain_PyObject ); Py_INCREF( const_str_plain_PyObject ); | ||
| 190 | const_tuple_str_plain_glong_tuple = PyTuple_New( 1 ); | ||
| 191 | PyTuple_SET_ITEM( const_tuple_str_plain_glong_tuple, 0, const_str_plain_glong ); Py_INCREF( const_str_plain_glong ); | ||
| 192 | const_tuple_str_plain_gchararray_tuple = PyTuple_New( 1 ); | ||
| 193 | PyTuple_SET_ITEM( const_tuple_str_plain_gchararray_tuple, 0, const_str_plain_gchararray ); Py_INCREF( const_str_plain_gchararray ); | ||
| 194 | const_tuple_str_plain_GEnum_tuple = PyTuple_New( 1 ); | ||
| 195 | PyTuple_SET_ITEM( const_tuple_str_plain_GEnum_tuple, 0, const_str_plain_GEnum ); Py_INCREF( const_str_plain_GEnum ); | ||
| 196 | |||
| 197 | constants_created = true; | ||
| 198 | } | ||
| 199 | |||
| 200 | /* Function to verify module private constants for non-corruption. */ | ||
| 201 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 202 | void checkModuleConstants_gi$_constants( void ) | ||
| 203 | { | ||
| 204 | // The module may not have been used at all, then ignore this. | ||
| 205 | if (constants_created == false) return; | ||
| 206 | |||
| 207 | |||
| 208 | } | ||
| 209 | #endif | ||
| 210 | |||
| 211 | // The module code objects. | ||
| 212 | static PyCodeObject *codeobj_9b8fa347d6463efdd2286c4ba70ef98a; | ||
| 213 | |||
| 214 | static void createModuleCodeObjects(void) | ||
| 215 | { | ||
| 216 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_9b67c33d1a2b2293a94de4d5cb0bc1c3 ); | ||
| 217 | codeobj_9b8fa347d6463efdd2286c4ba70ef98a = MAKE_CODEOBJ( module_filename_obj, const_str_digest_eaf2c61369c720726d6bfae3a829bdae, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 218 | } | ||
| 219 | |||
| 220 | // The module function declarations. | ||
| 221 | |||
| 222 | |||
| 223 | // The module function definitions. | ||
| 224 | |||
| 225 | |||
| 226 | |||
| 227 | #if PYTHON_VERSION >= 300 | ||
| 228 | static struct PyModuleDef mdef_gi$_constants = | ||
| 229 | { | ||
| 230 | PyModuleDef_HEAD_INIT, | ||
| 231 | "gi._constants", | ||
| 232 | NULL, /* m_doc */ | ||
| 233 | -1, /* m_size */ | ||
| 234 | NULL, /* m_methods */ | ||
| 235 | NULL, /* m_reload */ | ||
| 236 | NULL, /* m_traverse */ | ||
| 237 | NULL, /* m_clear */ | ||
| 238 | NULL, /* m_free */ | ||
| 239 | }; | ||
| 240 | #endif | ||
| 241 | |||
| 242 | extern PyObject *const_str_plain___compiled__; | ||
| 243 | |||
| 244 | extern PyObject *const_str_plain___package__; | ||
| 245 | |||
| 246 | #if PYTHON_VERSION >= 300 | ||
| 247 | extern PyObject *const_str_dot; | ||
| 248 | extern PyObject *const_str_plain___loader__; | ||
| 249 | #endif | ||
| 250 | |||
| 251 | #if PYTHON_VERSION >= 340 | ||
| 252 | extern PyObject *const_str_plain___spec__; | ||
| 253 | extern PyObject *const_str_plain__initializing; | ||
| 254 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 255 | #endif | ||
| 256 | |||
| 257 | extern void _initCompiledCellType(); | ||
| 258 | extern void _initCompiledGeneratorType(); | ||
| 259 | extern void _initCompiledFunctionType(); | ||
| 260 | extern void _initCompiledMethodType(); | ||
| 261 | extern void _initCompiledFrameType(); | ||
| 262 | #if PYTHON_VERSION >= 350 | ||
| 263 | extern void _initCompiledCoroutineTypes(); | ||
| 264 | #endif | ||
| 265 | #if PYTHON_VERSION >= 360 | ||
| 266 | extern void _initCompiledAsyncgenTypes(); | ||
| 267 | #endif | ||
| 268 | |||
| 269 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 270 | |||
| 271 | // The exported interface to CPython. On import of the module, this function | ||
| 272 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 273 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 274 | |||
| 275 | MOD_INIT_DECL( gi$_constants ) | ||
| 276 | { | ||
| 277 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 278 | static bool _init_done = false; | ||
| 279 | |||
| 280 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 281 | if ( _init_done ) | ||
| 282 | { | ||
| 283 | return MOD_RETURN_VALUE( module_gi$_constants ); | ||
| 284 | } | ||
| 285 | else | ||
| 286 | { | ||
| 287 | _init_done = true; | ||
| 288 | } | ||
| 289 | #endif | ||
| 290 | |||
| 291 | #ifdef _NUITKA_MODULE | ||
| 292 | // In case of a stand alone extension module, need to call initialization | ||
| 293 | // the init here because that's the first and only time we are going to get | ||
| 294 | // called here. | ||
| 295 | |||
| 296 | // Initialize the constant values used. | ||
| 297 | _initBuiltinModule(); | ||
| 298 | createGlobalConstants(); | ||
| 299 | |||
| 300 | /* Initialize the compiled types of Nuitka. */ | ||
| 301 | _initCompiledCellType(); | ||
| 302 | _initCompiledGeneratorType(); | ||
| 303 | _initCompiledFunctionType(); | ||
| 304 | _initCompiledMethodType(); | ||
| 305 | _initCompiledFrameType(); | ||
| 306 | #if PYTHON_VERSION >= 350 | ||
| 307 | _initCompiledCoroutineTypes(); | ||
| 308 | #endif | ||
| 309 | #if PYTHON_VERSION >= 360 | ||
| 310 | _initCompiledAsyncgenTypes(); | ||
| 311 | #endif | ||
| 312 | |||
| 313 | #if PYTHON_VERSION < 300 | ||
| 314 | _initSlotCompare(); | ||
| 315 | #endif | ||
| 316 | #if PYTHON_VERSION >= 270 | ||
| 317 | _initSlotIternext(); | ||
| 318 | #endif | ||
| 319 | |||
| 320 | patchBuiltinModule(); | ||
| 321 | patchTypeComparison(); | ||
| 322 | |||
| 323 | // Enable meta path based loader if not already done. | ||
| 324 | #ifdef _NUITKA_TRACE | ||
| 325 | puts("gi._constants: Calling setupMetaPathBasedLoader()."); | ||
| 326 | #endif | ||
| 327 | setupMetaPathBasedLoader(); | ||
| 328 | |||
| 329 | #if PYTHON_VERSION >= 300 | ||
| 330 | patchInspectModule(); | ||
| 331 | #endif | ||
| 332 | |||
| 333 | #endif | ||
| 334 | |||
| 335 | /* The constants only used by this module are created now. */ | ||
| 336 | #ifdef _NUITKA_TRACE | ||
| 337 | puts("gi._constants: Calling createModuleConstants()."); | ||
| 338 | #endif | ||
| 339 | createModuleConstants(); | ||
| 340 | |||
| 341 | /* The code objects used by this module are created now. */ | ||
| 342 | #ifdef _NUITKA_TRACE | ||
| 343 | puts("gi._constants: Calling createModuleCodeObjects()."); | ||
| 344 | #endif | ||
| 345 | createModuleCodeObjects(); | ||
| 346 | |||
| 347 | // puts( "in initgi$_constants" ); | ||
| 348 | |||
| 349 | // Create the module object first. There are no methods initially, all are | ||
| 350 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 351 | // set at this time, as it could not contain NUL characters this way, they | ||
| 352 | // are instead set in early module code. No "self" for modules, we have no | ||
| 353 | // use for it. | ||
| 354 | #if PYTHON_VERSION < 300 | ||
| 355 | module_gi$_constants = Py_InitModule4( | ||
| 356 | "gi._constants", // Module Name | ||
| 357 | NULL, // No methods initially, all are added | ||
| 358 | // dynamically in actual module code only. | ||
| 359 | NULL, // No "__doc__" is initially set, as it could | ||
| 360 | // not contain NUL this way, added early in | ||
| 361 | // actual code. | ||
| 362 | NULL, // No self for modules, we don't use it. | ||
| 363 | PYTHON_API_VERSION | ||
| 364 | ); | ||
| 365 | #else | ||
| 366 | |||
| 367 | module_gi$_constants = PyModule_Create( &mdef_gi$_constants ); | ||
| 368 | #endif | ||
| 369 | |||
| 370 | moduledict_gi$_constants = MODULE_DICT( module_gi$_constants ); | ||
| 371 | |||
| 372 | // Set __compiled__ to what it we know. | ||
| 373 | UPDATE_STRING_DICT1( | ||
| 374 | moduledict_gi$_constants, | ||
| 375 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 376 | Nuitka_dunder_compiled_value | ||
| 377 | ); | ||
| 378 | |||
| 379 | // Update "__package__" value to what it ought to be. | ||
| 380 | { | ||
| 381 | #if 0 | ||
| 382 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 383 | |||
| 384 | UPDATE_STRING_DICT1( | ||
| 385 | moduledict_gi$_constants, | ||
| 386 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 387 | module_name | ||
| 388 | ); | ||
| 389 | #else | ||
| 390 | |||
| 391 | #if PYTHON_VERSION < 300 | ||
| 392 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 393 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 394 | |||
| 395 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 396 | |||
| 397 | if ( last_dot != NULL ) | ||
| 398 | { | ||
| 399 | UPDATE_STRING_DICT1( | ||
| 400 | moduledict_gi$_constants, | ||
| 401 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 402 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 403 | ); | ||
| 404 | } | ||
| 405 | #else | ||
| 406 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 407 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 408 | |||
| 409 | if ( dot_index != -1 ) | ||
| 410 | { | ||
| 411 | UPDATE_STRING_DICT1( | ||
| 412 | moduledict_gi$_constants, | ||
| 413 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 414 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 415 | ); | ||
| 416 | } | ||
| 417 | #endif | ||
| 418 | #endif | ||
| 419 | } | ||
| 420 | |||
| 421 | CHECK_OBJECT( module_gi$_constants ); | ||
| 422 | |||
| 423 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 424 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 425 | #if PYTHON_VERSION >= 300 | ||
| 426 | { | ||
| 427 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_f4d333e44bfac310ff46328bad2521a0, module_gi$_constants ); | ||
| 428 | |||
| 429 | assert( r != -1 ); | ||
| 430 | } | ||
| 431 | #endif | ||
| 432 | |||
| 433 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 434 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 435 | // before the frame object is allocated, or else it may fail. | ||
| 436 | |||
| 437 | if ( GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 438 | { | ||
| 439 | PyObject *value = (PyObject *)builtin_module; | ||
| 440 | |||
| 441 | // Check if main module, not a dict then but the module itself. | ||
| 442 | #if !defined(_NUITKA_EXE) || !0 | ||
| 443 | value = PyModule_GetDict( value ); | ||
| 444 | #endif | ||
| 445 | |||
| 446 | UPDATE_STRING_DICT0( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 447 | } | ||
| 448 | |||
| 449 | #if PYTHON_VERSION >= 300 | ||
| 450 | UPDATE_STRING_DICT0( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 451 | #endif | ||
| 452 | |||
| 453 | #if PYTHON_VERSION >= 340 | ||
| 454 | // Set the "__spec__" value | ||
| 455 | |||
| 456 | #if 0 | ||
| 457 | // Main modules just get "None" as spec. | ||
| 458 | UPDATE_STRING_DICT0( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 459 | #else | ||
| 460 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 461 | { | ||
| 462 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 463 | CHECK_OBJECT( bootstrap_module ); | ||
| 464 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 465 | Py_DECREF( bootstrap_module ); | ||
| 466 | |||
| 467 | PyObject *args[] = { | ||
| 468 | GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 469 | (PyObject *)&Nuitka_Loader_Type | ||
| 470 | }; | ||
| 471 | |||
| 472 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 473 | module_spec_class, | ||
| 474 | args | ||
| 475 | ); | ||
| 476 | Py_DECREF( module_spec_class ); | ||
| 477 | |||
| 478 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 479 | CHECK_OBJECT( spec_value ); | ||
| 480 | |||
| 481 | // For packages set the submodule search locations as well, even if to empty | ||
| 482 | // list, so investigating code will consider it a package. | ||
| 483 | #if 0 | ||
| 484 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 485 | #endif | ||
| 486 | |||
| 487 | // Mark the execution in the "__spec__" value. | ||
| 488 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 489 | |||
| 490 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 491 | } | ||
| 492 | #endif | ||
| 493 | #endif | ||
| 494 | |||
| 495 | // Temp variables if any | ||
| 496 | struct Nuitka_FrameObject *frame_9b8fa347d6463efdd2286c4ba70ef98a; | ||
| 497 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 498 | bool tmp_result; | ||
| 499 | PyObject *exception_type = NULL; | ||
| 500 | PyObject *exception_value = NULL; | ||
| 501 | PyTracebackObject *exception_tb = NULL; | ||
| 502 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 503 | |||
| 504 | // Module code. | ||
| 505 | { | ||
| 506 | PyObject *tmp_assign_source_1; | ||
| 507 | tmp_assign_source_1 = Py_None; | ||
| 508 | UPDATE_STRING_DICT0( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 509 | } | ||
| 510 | { | ||
| 511 | PyObject *tmp_assign_source_2; | ||
| 512 | tmp_assign_source_2 = module_filename_obj; | ||
| 513 | UPDATE_STRING_DICT0( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 514 | } | ||
| 515 | // Frame without reuse. | ||
| 516 | frame_9b8fa347d6463efdd2286c4ba70ef98a = MAKE_MODULE_FRAME( codeobj_9b8fa347d6463efdd2286c4ba70ef98a, module_gi$_constants ); | ||
| 517 | |||
| 518 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 519 | // owning it. | ||
| 520 | pushFrameStack( frame_9b8fa347d6463efdd2286c4ba70ef98a ); | ||
| 521 | assert( Py_REFCNT( frame_9b8fa347d6463efdd2286c4ba70ef98a ) == 2 ); | ||
| 522 | |||
| 523 | // Framed code: | ||
| 524 | { | ||
| 525 | PyObject *tmp_assattr_name_1; | ||
| 526 | PyObject *tmp_assattr_target_1; | ||
| 527 | PyObject *tmp_mvar_value_1; | ||
| 528 | tmp_assattr_name_1 = module_filename_obj; | ||
| 529 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 530 | |||
| 531 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 532 | { | ||
| 533 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 534 | } | ||
| 535 | |||
| 536 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 537 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 538 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 539 | if ( tmp_result == false ) | ||
| 540 | { | ||
| 541 | assert( ERROR_OCCURRED() ); | ||
| 542 | |||
| 543 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 544 | |||
| 545 | |||
| 546 | exception_lineno = 1; | ||
| 547 | |||
| 548 | goto frame_exception_exit_1; | ||
| 549 | } | ||
| 550 | } | ||
| 551 | { | ||
| 552 | PyObject *tmp_assattr_name_2; | ||
| 553 | PyObject *tmp_assattr_target_2; | ||
| 554 | PyObject *tmp_mvar_value_2; | ||
| 555 | tmp_assattr_name_2 = Py_True; | ||
| 556 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 557 | |||
| 558 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 559 | { | ||
| 560 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 561 | } | ||
| 562 | |||
| 563 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 564 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 565 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 566 | if ( tmp_result == false ) | ||
| 567 | { | ||
| 568 | assert( ERROR_OCCURRED() ); | ||
| 569 | |||
| 570 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 571 | |||
| 572 | |||
| 573 | exception_lineno = 1; | ||
| 574 | |||
| 575 | goto frame_exception_exit_1; | ||
| 576 | } | ||
| 577 | } | ||
| 578 | { | ||
| 579 | PyObject *tmp_assign_source_3; | ||
| 580 | tmp_assign_source_3 = Py_None; | ||
| 581 | UPDATE_STRING_DICT0( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 582 | } | ||
| 583 | { | ||
| 584 | PyObject *tmp_assign_source_4; | ||
| 585 | PyObject *tmp_import_name_from_1; | ||
| 586 | PyObject *tmp_name_name_1; | ||
| 587 | PyObject *tmp_globals_name_1; | ||
| 588 | PyObject *tmp_locals_name_1; | ||
| 589 | PyObject *tmp_fromlist_name_1; | ||
| 590 | PyObject *tmp_level_name_1; | ||
| 591 | tmp_name_name_1 = const_str_empty; | ||
| 592 | tmp_globals_name_1 = (PyObject *)moduledict_gi$_constants; | ||
| 593 | tmp_locals_name_1 = Py_None; | ||
| 594 | tmp_fromlist_name_1 = const_tuple_str_plain__gi_tuple; | ||
| 595 | tmp_level_name_1 = const_int_pos_1; | ||
| 596 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 20; | ||
| 597 | tmp_import_name_from_1 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 598 | if ( tmp_import_name_from_1 == NULL ) | ||
| 599 | { | ||
| 600 | assert( ERROR_OCCURRED() ); | ||
| 601 | |||
| 602 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 603 | |||
| 604 | |||
| 605 | exception_lineno = 20; | ||
| 606 | |||
| 607 | goto frame_exception_exit_1; | ||
| 608 | } | ||
| 609 | if ( PyModule_Check( tmp_import_name_from_1 ) ) | ||
| 610 | { | ||
| 611 | tmp_assign_source_4 = IMPORT_NAME_OR_MODULE( | ||
| 612 | tmp_import_name_from_1, | ||
| 613 | (PyObject *)MODULE_DICT(tmp_import_name_from_1), | ||
| 614 | const_str_plain__gi, | ||
| 615 | const_int_pos_1 | ||
| 616 | ); | ||
| 617 | } | ||
| 618 | else | ||
| 619 | { | ||
| 620 | tmp_assign_source_4 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain__gi ); | ||
| 621 | } | ||
| 622 | |||
| 623 | Py_DECREF( tmp_import_name_from_1 ); | ||
| 624 | if ( tmp_assign_source_4 == NULL ) | ||
| 625 | { | ||
| 626 | assert( ERROR_OCCURRED() ); | ||
| 627 | |||
| 628 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 629 | |||
| 630 | |||
| 631 | exception_lineno = 20; | ||
| 632 | |||
| 633 | goto frame_exception_exit_1; | ||
| 634 | } | ||
| 635 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi, tmp_assign_source_4 ); | ||
| 636 | } | ||
| 637 | { | ||
| 638 | PyObject *tmp_assign_source_5; | ||
| 639 | PyObject *tmp_source_name_1; | ||
| 640 | PyObject *tmp_mvar_value_3; | ||
| 641 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 642 | |||
| 643 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 644 | { | ||
| 645 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 646 | } | ||
| 647 | |||
| 648 | CHECK_OBJECT( tmp_mvar_value_3 ); | ||
| 649 | tmp_source_name_1 = tmp_mvar_value_3; | ||
| 650 | tmp_assign_source_5 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_TYPE_INVALID ); | ||
| 651 | if ( tmp_assign_source_5 == NULL ) | ||
| 652 | { | ||
| 653 | assert( ERROR_OCCURRED() ); | ||
| 654 | |||
| 655 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 656 | |||
| 657 | |||
| 658 | exception_lineno = 22; | ||
| 659 | |||
| 660 | goto frame_exception_exit_1; | ||
| 661 | } | ||
| 662 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_INVALID, tmp_assign_source_5 ); | ||
| 663 | } | ||
| 664 | { | ||
| 665 | PyObject *tmp_assign_source_6; | ||
| 666 | PyObject *tmp_called_instance_1; | ||
| 667 | PyObject *tmp_source_name_2; | ||
| 668 | PyObject *tmp_mvar_value_4; | ||
| 669 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 670 | |||
| 671 | if (unlikely( tmp_mvar_value_4 == NULL )) | ||
| 672 | { | ||
| 673 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 674 | } | ||
| 675 | |||
| 676 | if ( tmp_mvar_value_4 == NULL ) | ||
| 677 | { | ||
| 678 | |||
| 679 | exception_type = PyExc_NameError; | ||
| 680 | Py_INCREF( exception_type ); | ||
| 681 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 682 | exception_tb = NULL; | ||
| 683 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 684 | CHAIN_EXCEPTION( exception_value ); | ||
| 685 | |||
| 686 | exception_lineno = 23; | ||
| 687 | |||
| 688 | goto frame_exception_exit_1; | ||
| 689 | } | ||
| 690 | |||
| 691 | tmp_source_name_2 = tmp_mvar_value_4; | ||
| 692 | tmp_called_instance_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_GType ); | ||
| 693 | if ( tmp_called_instance_1 == NULL ) | ||
| 694 | { | ||
| 695 | assert( ERROR_OCCURRED() ); | ||
| 696 | |||
| 697 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 698 | |||
| 699 | |||
| 700 | exception_lineno = 23; | ||
| 701 | |||
| 702 | goto frame_exception_exit_1; | ||
| 703 | } | ||
| 704 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 23; | ||
| 705 | tmp_assign_source_6 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_1, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_void_tuple, 0 ) ); | ||
| 706 | |||
| 707 | Py_DECREF( tmp_called_instance_1 ); | ||
| 708 | if ( tmp_assign_source_6 == NULL ) | ||
| 709 | { | ||
| 710 | assert( ERROR_OCCURRED() ); | ||
| 711 | |||
| 712 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 713 | |||
| 714 | |||
| 715 | exception_lineno = 23; | ||
| 716 | |||
| 717 | goto frame_exception_exit_1; | ||
| 718 | } | ||
| 719 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_NONE, tmp_assign_source_6 ); | ||
| 720 | } | ||
| 721 | { | ||
| 722 | PyObject *tmp_assign_source_7; | ||
| 723 | PyObject *tmp_called_instance_2; | ||
| 724 | PyObject *tmp_source_name_3; | ||
| 725 | PyObject *tmp_mvar_value_5; | ||
| 726 | tmp_mvar_value_5 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 727 | |||
| 728 | if (unlikely( tmp_mvar_value_5 == NULL )) | ||
| 729 | { | ||
| 730 | tmp_mvar_value_5 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 731 | } | ||
| 732 | |||
| 733 | if ( tmp_mvar_value_5 == NULL ) | ||
| 734 | { | ||
| 735 | |||
| 736 | exception_type = PyExc_NameError; | ||
| 737 | Py_INCREF( exception_type ); | ||
| 738 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 739 | exception_tb = NULL; | ||
| 740 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 741 | CHAIN_EXCEPTION( exception_value ); | ||
| 742 | |||
| 743 | exception_lineno = 24; | ||
| 744 | |||
| 745 | goto frame_exception_exit_1; | ||
| 746 | } | ||
| 747 | |||
| 748 | tmp_source_name_3 = tmp_mvar_value_5; | ||
| 749 | tmp_called_instance_2 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_GType ); | ||
| 750 | if ( tmp_called_instance_2 == NULL ) | ||
| 751 | { | ||
| 752 | assert( ERROR_OCCURRED() ); | ||
| 753 | |||
| 754 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 755 | |||
| 756 | |||
| 757 | exception_lineno = 24; | ||
| 758 | |||
| 759 | goto frame_exception_exit_1; | ||
| 760 | } | ||
| 761 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 24; | ||
| 762 | tmp_assign_source_7 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_2, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_GInterface_tuple, 0 ) ); | ||
| 763 | |||
| 764 | Py_DECREF( tmp_called_instance_2 ); | ||
| 765 | if ( tmp_assign_source_7 == NULL ) | ||
| 766 | { | ||
| 767 | assert( ERROR_OCCURRED() ); | ||
| 768 | |||
| 769 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 770 | |||
| 771 | |||
| 772 | exception_lineno = 24; | ||
| 773 | |||
| 774 | goto frame_exception_exit_1; | ||
| 775 | } | ||
| 776 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_INTERFACE, tmp_assign_source_7 ); | ||
| 777 | } | ||
| 778 | { | ||
| 779 | PyObject *tmp_assign_source_8; | ||
| 780 | PyObject *tmp_called_instance_3; | ||
| 781 | PyObject *tmp_source_name_4; | ||
| 782 | PyObject *tmp_mvar_value_6; | ||
| 783 | tmp_mvar_value_6 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 784 | |||
| 785 | if (unlikely( tmp_mvar_value_6 == NULL )) | ||
| 786 | { | ||
| 787 | tmp_mvar_value_6 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 788 | } | ||
| 789 | |||
| 790 | if ( tmp_mvar_value_6 == NULL ) | ||
| 791 | { | ||
| 792 | |||
| 793 | exception_type = PyExc_NameError; | ||
| 794 | Py_INCREF( exception_type ); | ||
| 795 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 796 | exception_tb = NULL; | ||
| 797 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 798 | CHAIN_EXCEPTION( exception_value ); | ||
| 799 | |||
| 800 | exception_lineno = 25; | ||
| 801 | |||
| 802 | goto frame_exception_exit_1; | ||
| 803 | } | ||
| 804 | |||
| 805 | tmp_source_name_4 = tmp_mvar_value_6; | ||
| 806 | tmp_called_instance_3 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain_GType ); | ||
| 807 | if ( tmp_called_instance_3 == NULL ) | ||
| 808 | { | ||
| 809 | assert( ERROR_OCCURRED() ); | ||
| 810 | |||
| 811 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 812 | |||
| 813 | |||
| 814 | exception_lineno = 25; | ||
| 815 | |||
| 816 | goto frame_exception_exit_1; | ||
| 817 | } | ||
| 818 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 25; | ||
| 819 | tmp_assign_source_8 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_3, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_gchar_tuple, 0 ) ); | ||
| 820 | |||
| 821 | Py_DECREF( tmp_called_instance_3 ); | ||
| 822 | if ( tmp_assign_source_8 == NULL ) | ||
| 823 | { | ||
| 824 | assert( ERROR_OCCURRED() ); | ||
| 825 | |||
| 826 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 827 | |||
| 828 | |||
| 829 | exception_lineno = 25; | ||
| 830 | |||
| 831 | goto frame_exception_exit_1; | ||
| 832 | } | ||
| 833 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_CHAR, tmp_assign_source_8 ); | ||
| 834 | } | ||
| 835 | { | ||
| 836 | PyObject *tmp_assign_source_9; | ||
| 837 | PyObject *tmp_called_instance_4; | ||
| 838 | PyObject *tmp_source_name_5; | ||
| 839 | PyObject *tmp_mvar_value_7; | ||
| 840 | tmp_mvar_value_7 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 841 | |||
| 842 | if (unlikely( tmp_mvar_value_7 == NULL )) | ||
| 843 | { | ||
| 844 | tmp_mvar_value_7 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 845 | } | ||
| 846 | |||
| 847 | if ( tmp_mvar_value_7 == NULL ) | ||
| 848 | { | ||
| 849 | |||
| 850 | exception_type = PyExc_NameError; | ||
| 851 | Py_INCREF( exception_type ); | ||
| 852 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 853 | exception_tb = NULL; | ||
| 854 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 855 | CHAIN_EXCEPTION( exception_value ); | ||
| 856 | |||
| 857 | exception_lineno = 26; | ||
| 858 | |||
| 859 | goto frame_exception_exit_1; | ||
| 860 | } | ||
| 861 | |||
| 862 | tmp_source_name_5 = tmp_mvar_value_7; | ||
| 863 | tmp_called_instance_4 = LOOKUP_ATTRIBUTE( tmp_source_name_5, const_str_plain_GType ); | ||
| 864 | if ( tmp_called_instance_4 == NULL ) | ||
| 865 | { | ||
| 866 | assert( ERROR_OCCURRED() ); | ||
| 867 | |||
| 868 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 869 | |||
| 870 | |||
| 871 | exception_lineno = 26; | ||
| 872 | |||
| 873 | goto frame_exception_exit_1; | ||
| 874 | } | ||
| 875 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 26; | ||
| 876 | tmp_assign_source_9 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_4, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_guchar_tuple, 0 ) ); | ||
| 877 | |||
| 878 | Py_DECREF( tmp_called_instance_4 ); | ||
| 879 | if ( tmp_assign_source_9 == NULL ) | ||
| 880 | { | ||
| 881 | assert( ERROR_OCCURRED() ); | ||
| 882 | |||
| 883 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 884 | |||
| 885 | |||
| 886 | exception_lineno = 26; | ||
| 887 | |||
| 888 | goto frame_exception_exit_1; | ||
| 889 | } | ||
| 890 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_UCHAR, tmp_assign_source_9 ); | ||
| 891 | } | ||
| 892 | { | ||
| 893 | PyObject *tmp_assign_source_10; | ||
| 894 | PyObject *tmp_called_instance_5; | ||
| 895 | PyObject *tmp_source_name_6; | ||
| 896 | PyObject *tmp_mvar_value_8; | ||
| 897 | tmp_mvar_value_8 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 898 | |||
| 899 | if (unlikely( tmp_mvar_value_8 == NULL )) | ||
| 900 | { | ||
| 901 | tmp_mvar_value_8 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 902 | } | ||
| 903 | |||
| 904 | if ( tmp_mvar_value_8 == NULL ) | ||
| 905 | { | ||
| 906 | |||
| 907 | exception_type = PyExc_NameError; | ||
| 908 | Py_INCREF( exception_type ); | ||
| 909 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 910 | exception_tb = NULL; | ||
| 911 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 912 | CHAIN_EXCEPTION( exception_value ); | ||
| 913 | |||
| 914 | exception_lineno = 27; | ||
| 915 | |||
| 916 | goto frame_exception_exit_1; | ||
| 917 | } | ||
| 918 | |||
| 919 | tmp_source_name_6 = tmp_mvar_value_8; | ||
| 920 | tmp_called_instance_5 = LOOKUP_ATTRIBUTE( tmp_source_name_6, const_str_plain_GType ); | ||
| 921 | if ( tmp_called_instance_5 == NULL ) | ||
| 922 | { | ||
| 923 | assert( ERROR_OCCURRED() ); | ||
| 924 | |||
| 925 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 926 | |||
| 927 | |||
| 928 | exception_lineno = 27; | ||
| 929 | |||
| 930 | goto frame_exception_exit_1; | ||
| 931 | } | ||
| 932 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 27; | ||
| 933 | tmp_assign_source_10 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_5, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_gboolean_tuple, 0 ) ); | ||
| 934 | |||
| 935 | Py_DECREF( tmp_called_instance_5 ); | ||
| 936 | if ( tmp_assign_source_10 == NULL ) | ||
| 937 | { | ||
| 938 | assert( ERROR_OCCURRED() ); | ||
| 939 | |||
| 940 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 941 | |||
| 942 | |||
| 943 | exception_lineno = 27; | ||
| 944 | |||
| 945 | goto frame_exception_exit_1; | ||
| 946 | } | ||
| 947 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_BOOLEAN, tmp_assign_source_10 ); | ||
| 948 | } | ||
| 949 | { | ||
| 950 | PyObject *tmp_assign_source_11; | ||
| 951 | PyObject *tmp_called_instance_6; | ||
| 952 | PyObject *tmp_source_name_7; | ||
| 953 | PyObject *tmp_mvar_value_9; | ||
| 954 | tmp_mvar_value_9 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 955 | |||
| 956 | if (unlikely( tmp_mvar_value_9 == NULL )) | ||
| 957 | { | ||
| 958 | tmp_mvar_value_9 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 959 | } | ||
| 960 | |||
| 961 | if ( tmp_mvar_value_9 == NULL ) | ||
| 962 | { | ||
| 963 | |||
| 964 | exception_type = PyExc_NameError; | ||
| 965 | Py_INCREF( exception_type ); | ||
| 966 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 967 | exception_tb = NULL; | ||
| 968 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 969 | CHAIN_EXCEPTION( exception_value ); | ||
| 970 | |||
| 971 | exception_lineno = 28; | ||
| 972 | |||
| 973 | goto frame_exception_exit_1; | ||
| 974 | } | ||
| 975 | |||
| 976 | tmp_source_name_7 = tmp_mvar_value_9; | ||
| 977 | tmp_called_instance_6 = LOOKUP_ATTRIBUTE( tmp_source_name_7, const_str_plain_GType ); | ||
| 978 | if ( tmp_called_instance_6 == NULL ) | ||
| 979 | { | ||
| 980 | assert( ERROR_OCCURRED() ); | ||
| 981 | |||
| 982 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 983 | |||
| 984 | |||
| 985 | exception_lineno = 28; | ||
| 986 | |||
| 987 | goto frame_exception_exit_1; | ||
| 988 | } | ||
| 989 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 28; | ||
| 990 | tmp_assign_source_11 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_6, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_gint_tuple, 0 ) ); | ||
| 991 | |||
| 992 | Py_DECREF( tmp_called_instance_6 ); | ||
| 993 | if ( tmp_assign_source_11 == NULL ) | ||
| 994 | { | ||
| 995 | assert( ERROR_OCCURRED() ); | ||
| 996 | |||
| 997 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 998 | |||
| 999 | |||
| 1000 | exception_lineno = 28; | ||
| 1001 | |||
| 1002 | goto frame_exception_exit_1; | ||
| 1003 | } | ||
| 1004 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_INT, tmp_assign_source_11 ); | ||
| 1005 | } | ||
| 1006 | { | ||
| 1007 | PyObject *tmp_assign_source_12; | ||
| 1008 | PyObject *tmp_called_instance_7; | ||
| 1009 | PyObject *tmp_source_name_8; | ||
| 1010 | PyObject *tmp_mvar_value_10; | ||
| 1011 | tmp_mvar_value_10 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1012 | |||
| 1013 | if (unlikely( tmp_mvar_value_10 == NULL )) | ||
| 1014 | { | ||
| 1015 | tmp_mvar_value_10 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1016 | } | ||
| 1017 | |||
| 1018 | if ( tmp_mvar_value_10 == NULL ) | ||
| 1019 | { | ||
| 1020 | |||
| 1021 | exception_type = PyExc_NameError; | ||
| 1022 | Py_INCREF( exception_type ); | ||
| 1023 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1024 | exception_tb = NULL; | ||
| 1025 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1026 | CHAIN_EXCEPTION( exception_value ); | ||
| 1027 | |||
| 1028 | exception_lineno = 29; | ||
| 1029 | |||
| 1030 | goto frame_exception_exit_1; | ||
| 1031 | } | ||
| 1032 | |||
| 1033 | tmp_source_name_8 = tmp_mvar_value_10; | ||
| 1034 | tmp_called_instance_7 = LOOKUP_ATTRIBUTE( tmp_source_name_8, const_str_plain_GType ); | ||
| 1035 | if ( tmp_called_instance_7 == NULL ) | ||
| 1036 | { | ||
| 1037 | assert( ERROR_OCCURRED() ); | ||
| 1038 | |||
| 1039 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1040 | |||
| 1041 | |||
| 1042 | exception_lineno = 29; | ||
| 1043 | |||
| 1044 | goto frame_exception_exit_1; | ||
| 1045 | } | ||
| 1046 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 29; | ||
| 1047 | tmp_assign_source_12 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_7, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_guint_tuple, 0 ) ); | ||
| 1048 | |||
| 1049 | Py_DECREF( tmp_called_instance_7 ); | ||
| 1050 | if ( tmp_assign_source_12 == NULL ) | ||
| 1051 | { | ||
| 1052 | assert( ERROR_OCCURRED() ); | ||
| 1053 | |||
| 1054 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1055 | |||
| 1056 | |||
| 1057 | exception_lineno = 29; | ||
| 1058 | |||
| 1059 | goto frame_exception_exit_1; | ||
| 1060 | } | ||
| 1061 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_UINT, tmp_assign_source_12 ); | ||
| 1062 | } | ||
| 1063 | { | ||
| 1064 | PyObject *tmp_assign_source_13; | ||
| 1065 | PyObject *tmp_called_instance_8; | ||
| 1066 | PyObject *tmp_source_name_9; | ||
| 1067 | PyObject *tmp_mvar_value_11; | ||
| 1068 | tmp_mvar_value_11 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1069 | |||
| 1070 | if (unlikely( tmp_mvar_value_11 == NULL )) | ||
| 1071 | { | ||
| 1072 | tmp_mvar_value_11 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1073 | } | ||
| 1074 | |||
| 1075 | if ( tmp_mvar_value_11 == NULL ) | ||
| 1076 | { | ||
| 1077 | |||
| 1078 | exception_type = PyExc_NameError; | ||
| 1079 | Py_INCREF( exception_type ); | ||
| 1080 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1081 | exception_tb = NULL; | ||
| 1082 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1083 | CHAIN_EXCEPTION( exception_value ); | ||
| 1084 | |||
| 1085 | exception_lineno = 30; | ||
| 1086 | |||
| 1087 | goto frame_exception_exit_1; | ||
| 1088 | } | ||
| 1089 | |||
| 1090 | tmp_source_name_9 = tmp_mvar_value_11; | ||
| 1091 | tmp_called_instance_8 = LOOKUP_ATTRIBUTE( tmp_source_name_9, const_str_plain_GType ); | ||
| 1092 | if ( tmp_called_instance_8 == NULL ) | ||
| 1093 | { | ||
| 1094 | assert( ERROR_OCCURRED() ); | ||
| 1095 | |||
| 1096 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1097 | |||
| 1098 | |||
| 1099 | exception_lineno = 30; | ||
| 1100 | |||
| 1101 | goto frame_exception_exit_1; | ||
| 1102 | } | ||
| 1103 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 30; | ||
| 1104 | tmp_assign_source_13 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_8, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_glong_tuple, 0 ) ); | ||
| 1105 | |||
| 1106 | Py_DECREF( tmp_called_instance_8 ); | ||
| 1107 | if ( tmp_assign_source_13 == NULL ) | ||
| 1108 | { | ||
| 1109 | assert( ERROR_OCCURRED() ); | ||
| 1110 | |||
| 1111 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1112 | |||
| 1113 | |||
| 1114 | exception_lineno = 30; | ||
| 1115 | |||
| 1116 | goto frame_exception_exit_1; | ||
| 1117 | } | ||
| 1118 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_LONG, tmp_assign_source_13 ); | ||
| 1119 | } | ||
| 1120 | { | ||
| 1121 | PyObject *tmp_assign_source_14; | ||
| 1122 | PyObject *tmp_called_instance_9; | ||
| 1123 | PyObject *tmp_source_name_10; | ||
| 1124 | PyObject *tmp_mvar_value_12; | ||
| 1125 | tmp_mvar_value_12 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1126 | |||
| 1127 | if (unlikely( tmp_mvar_value_12 == NULL )) | ||
| 1128 | { | ||
| 1129 | tmp_mvar_value_12 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1130 | } | ||
| 1131 | |||
| 1132 | if ( tmp_mvar_value_12 == NULL ) | ||
| 1133 | { | ||
| 1134 | |||
| 1135 | exception_type = PyExc_NameError; | ||
| 1136 | Py_INCREF( exception_type ); | ||
| 1137 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1138 | exception_tb = NULL; | ||
| 1139 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1140 | CHAIN_EXCEPTION( exception_value ); | ||
| 1141 | |||
| 1142 | exception_lineno = 31; | ||
| 1143 | |||
| 1144 | goto frame_exception_exit_1; | ||
| 1145 | } | ||
| 1146 | |||
| 1147 | tmp_source_name_10 = tmp_mvar_value_12; | ||
| 1148 | tmp_called_instance_9 = LOOKUP_ATTRIBUTE( tmp_source_name_10, const_str_plain_GType ); | ||
| 1149 | if ( tmp_called_instance_9 == NULL ) | ||
| 1150 | { | ||
| 1151 | assert( ERROR_OCCURRED() ); | ||
| 1152 | |||
| 1153 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1154 | |||
| 1155 | |||
| 1156 | exception_lineno = 31; | ||
| 1157 | |||
| 1158 | goto frame_exception_exit_1; | ||
| 1159 | } | ||
| 1160 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 31; | ||
| 1161 | tmp_assign_source_14 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_9, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_gulong_tuple, 0 ) ); | ||
| 1162 | |||
| 1163 | Py_DECREF( tmp_called_instance_9 ); | ||
| 1164 | if ( tmp_assign_source_14 == NULL ) | ||
| 1165 | { | ||
| 1166 | assert( ERROR_OCCURRED() ); | ||
| 1167 | |||
| 1168 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1169 | |||
| 1170 | |||
| 1171 | exception_lineno = 31; | ||
| 1172 | |||
| 1173 | goto frame_exception_exit_1; | ||
| 1174 | } | ||
| 1175 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_ULONG, tmp_assign_source_14 ); | ||
| 1176 | } | ||
| 1177 | { | ||
| 1178 | PyObject *tmp_assign_source_15; | ||
| 1179 | PyObject *tmp_called_instance_10; | ||
| 1180 | PyObject *tmp_source_name_11; | ||
| 1181 | PyObject *tmp_mvar_value_13; | ||
| 1182 | tmp_mvar_value_13 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1183 | |||
| 1184 | if (unlikely( tmp_mvar_value_13 == NULL )) | ||
| 1185 | { | ||
| 1186 | tmp_mvar_value_13 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1187 | } | ||
| 1188 | |||
| 1189 | if ( tmp_mvar_value_13 == NULL ) | ||
| 1190 | { | ||
| 1191 | |||
| 1192 | exception_type = PyExc_NameError; | ||
| 1193 | Py_INCREF( exception_type ); | ||
| 1194 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1195 | exception_tb = NULL; | ||
| 1196 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1197 | CHAIN_EXCEPTION( exception_value ); | ||
| 1198 | |||
| 1199 | exception_lineno = 32; | ||
| 1200 | |||
| 1201 | goto frame_exception_exit_1; | ||
| 1202 | } | ||
| 1203 | |||
| 1204 | tmp_source_name_11 = tmp_mvar_value_13; | ||
| 1205 | tmp_called_instance_10 = LOOKUP_ATTRIBUTE( tmp_source_name_11, const_str_plain_GType ); | ||
| 1206 | if ( tmp_called_instance_10 == NULL ) | ||
| 1207 | { | ||
| 1208 | assert( ERROR_OCCURRED() ); | ||
| 1209 | |||
| 1210 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1211 | |||
| 1212 | |||
| 1213 | exception_lineno = 32; | ||
| 1214 | |||
| 1215 | goto frame_exception_exit_1; | ||
| 1216 | } | ||
| 1217 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 32; | ||
| 1218 | tmp_assign_source_15 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_10, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_gint64_tuple, 0 ) ); | ||
| 1219 | |||
| 1220 | Py_DECREF( tmp_called_instance_10 ); | ||
| 1221 | if ( tmp_assign_source_15 == NULL ) | ||
| 1222 | { | ||
| 1223 | assert( ERROR_OCCURRED() ); | ||
| 1224 | |||
| 1225 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1226 | |||
| 1227 | |||
| 1228 | exception_lineno = 32; | ||
| 1229 | |||
| 1230 | goto frame_exception_exit_1; | ||
| 1231 | } | ||
| 1232 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_INT64, tmp_assign_source_15 ); | ||
| 1233 | } | ||
| 1234 | { | ||
| 1235 | PyObject *tmp_assign_source_16; | ||
| 1236 | PyObject *tmp_called_instance_11; | ||
| 1237 | PyObject *tmp_source_name_12; | ||
| 1238 | PyObject *tmp_mvar_value_14; | ||
| 1239 | tmp_mvar_value_14 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1240 | |||
| 1241 | if (unlikely( tmp_mvar_value_14 == NULL )) | ||
| 1242 | { | ||
| 1243 | tmp_mvar_value_14 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1244 | } | ||
| 1245 | |||
| 1246 | if ( tmp_mvar_value_14 == NULL ) | ||
| 1247 | { | ||
| 1248 | |||
| 1249 | exception_type = PyExc_NameError; | ||
| 1250 | Py_INCREF( exception_type ); | ||
| 1251 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1252 | exception_tb = NULL; | ||
| 1253 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1254 | CHAIN_EXCEPTION( exception_value ); | ||
| 1255 | |||
| 1256 | exception_lineno = 33; | ||
| 1257 | |||
| 1258 | goto frame_exception_exit_1; | ||
| 1259 | } | ||
| 1260 | |||
| 1261 | tmp_source_name_12 = tmp_mvar_value_14; | ||
| 1262 | tmp_called_instance_11 = LOOKUP_ATTRIBUTE( tmp_source_name_12, const_str_plain_GType ); | ||
| 1263 | if ( tmp_called_instance_11 == NULL ) | ||
| 1264 | { | ||
| 1265 | assert( ERROR_OCCURRED() ); | ||
| 1266 | |||
| 1267 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1268 | |||
| 1269 | |||
| 1270 | exception_lineno = 33; | ||
| 1271 | |||
| 1272 | goto frame_exception_exit_1; | ||
| 1273 | } | ||
| 1274 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 33; | ||
| 1275 | tmp_assign_source_16 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_11, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_guint64_tuple, 0 ) ); | ||
| 1276 | |||
| 1277 | Py_DECREF( tmp_called_instance_11 ); | ||
| 1278 | if ( tmp_assign_source_16 == NULL ) | ||
| 1279 | { | ||
| 1280 | assert( ERROR_OCCURRED() ); | ||
| 1281 | |||
| 1282 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1283 | |||
| 1284 | |||
| 1285 | exception_lineno = 33; | ||
| 1286 | |||
| 1287 | goto frame_exception_exit_1; | ||
| 1288 | } | ||
| 1289 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_UINT64, tmp_assign_source_16 ); | ||
| 1290 | } | ||
| 1291 | { | ||
| 1292 | PyObject *tmp_assign_source_17; | ||
| 1293 | PyObject *tmp_called_instance_12; | ||
| 1294 | PyObject *tmp_source_name_13; | ||
| 1295 | PyObject *tmp_mvar_value_15; | ||
| 1296 | tmp_mvar_value_15 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1297 | |||
| 1298 | if (unlikely( tmp_mvar_value_15 == NULL )) | ||
| 1299 | { | ||
| 1300 | tmp_mvar_value_15 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1301 | } | ||
| 1302 | |||
| 1303 | if ( tmp_mvar_value_15 == NULL ) | ||
| 1304 | { | ||
| 1305 | |||
| 1306 | exception_type = PyExc_NameError; | ||
| 1307 | Py_INCREF( exception_type ); | ||
| 1308 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1309 | exception_tb = NULL; | ||
| 1310 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1311 | CHAIN_EXCEPTION( exception_value ); | ||
| 1312 | |||
| 1313 | exception_lineno = 34; | ||
| 1314 | |||
| 1315 | goto frame_exception_exit_1; | ||
| 1316 | } | ||
| 1317 | |||
| 1318 | tmp_source_name_13 = tmp_mvar_value_15; | ||
| 1319 | tmp_called_instance_12 = LOOKUP_ATTRIBUTE( tmp_source_name_13, const_str_plain_GType ); | ||
| 1320 | if ( tmp_called_instance_12 == NULL ) | ||
| 1321 | { | ||
| 1322 | assert( ERROR_OCCURRED() ); | ||
| 1323 | |||
| 1324 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1325 | |||
| 1326 | |||
| 1327 | exception_lineno = 34; | ||
| 1328 | |||
| 1329 | goto frame_exception_exit_1; | ||
| 1330 | } | ||
| 1331 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 34; | ||
| 1332 | tmp_assign_source_17 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_12, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_GEnum_tuple, 0 ) ); | ||
| 1333 | |||
| 1334 | Py_DECREF( tmp_called_instance_12 ); | ||
| 1335 | if ( tmp_assign_source_17 == NULL ) | ||
| 1336 | { | ||
| 1337 | assert( ERROR_OCCURRED() ); | ||
| 1338 | |||
| 1339 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1340 | |||
| 1341 | |||
| 1342 | exception_lineno = 34; | ||
| 1343 | |||
| 1344 | goto frame_exception_exit_1; | ||
| 1345 | } | ||
| 1346 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_ENUM, tmp_assign_source_17 ); | ||
| 1347 | } | ||
| 1348 | { | ||
| 1349 | PyObject *tmp_assign_source_18; | ||
| 1350 | PyObject *tmp_called_instance_13; | ||
| 1351 | PyObject *tmp_source_name_14; | ||
| 1352 | PyObject *tmp_mvar_value_16; | ||
| 1353 | tmp_mvar_value_16 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1354 | |||
| 1355 | if (unlikely( tmp_mvar_value_16 == NULL )) | ||
| 1356 | { | ||
| 1357 | tmp_mvar_value_16 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1358 | } | ||
| 1359 | |||
| 1360 | if ( tmp_mvar_value_16 == NULL ) | ||
| 1361 | { | ||
| 1362 | |||
| 1363 | exception_type = PyExc_NameError; | ||
| 1364 | Py_INCREF( exception_type ); | ||
| 1365 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1366 | exception_tb = NULL; | ||
| 1367 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1368 | CHAIN_EXCEPTION( exception_value ); | ||
| 1369 | |||
| 1370 | exception_lineno = 35; | ||
| 1371 | |||
| 1372 | goto frame_exception_exit_1; | ||
| 1373 | } | ||
| 1374 | |||
| 1375 | tmp_source_name_14 = tmp_mvar_value_16; | ||
| 1376 | tmp_called_instance_13 = LOOKUP_ATTRIBUTE( tmp_source_name_14, const_str_plain_GType ); | ||
| 1377 | if ( tmp_called_instance_13 == NULL ) | ||
| 1378 | { | ||
| 1379 | assert( ERROR_OCCURRED() ); | ||
| 1380 | |||
| 1381 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1382 | |||
| 1383 | |||
| 1384 | exception_lineno = 35; | ||
| 1385 | |||
| 1386 | goto frame_exception_exit_1; | ||
| 1387 | } | ||
| 1388 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 35; | ||
| 1389 | tmp_assign_source_18 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_13, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_GFlags_tuple, 0 ) ); | ||
| 1390 | |||
| 1391 | Py_DECREF( tmp_called_instance_13 ); | ||
| 1392 | if ( tmp_assign_source_18 == NULL ) | ||
| 1393 | { | ||
| 1394 | assert( ERROR_OCCURRED() ); | ||
| 1395 | |||
| 1396 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1397 | |||
| 1398 | |||
| 1399 | exception_lineno = 35; | ||
| 1400 | |||
| 1401 | goto frame_exception_exit_1; | ||
| 1402 | } | ||
| 1403 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_FLAGS, tmp_assign_source_18 ); | ||
| 1404 | } | ||
| 1405 | { | ||
| 1406 | PyObject *tmp_assign_source_19; | ||
| 1407 | PyObject *tmp_called_instance_14; | ||
| 1408 | PyObject *tmp_source_name_15; | ||
| 1409 | PyObject *tmp_mvar_value_17; | ||
| 1410 | tmp_mvar_value_17 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1411 | |||
| 1412 | if (unlikely( tmp_mvar_value_17 == NULL )) | ||
| 1413 | { | ||
| 1414 | tmp_mvar_value_17 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1415 | } | ||
| 1416 | |||
| 1417 | if ( tmp_mvar_value_17 == NULL ) | ||
| 1418 | { | ||
| 1419 | |||
| 1420 | exception_type = PyExc_NameError; | ||
| 1421 | Py_INCREF( exception_type ); | ||
| 1422 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1423 | exception_tb = NULL; | ||
| 1424 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1425 | CHAIN_EXCEPTION( exception_value ); | ||
| 1426 | |||
| 1427 | exception_lineno = 36; | ||
| 1428 | |||
| 1429 | goto frame_exception_exit_1; | ||
| 1430 | } | ||
| 1431 | |||
| 1432 | tmp_source_name_15 = tmp_mvar_value_17; | ||
| 1433 | tmp_called_instance_14 = LOOKUP_ATTRIBUTE( tmp_source_name_15, const_str_plain_GType ); | ||
| 1434 | if ( tmp_called_instance_14 == NULL ) | ||
| 1435 | { | ||
| 1436 | assert( ERROR_OCCURRED() ); | ||
| 1437 | |||
| 1438 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1439 | |||
| 1440 | |||
| 1441 | exception_lineno = 36; | ||
| 1442 | |||
| 1443 | goto frame_exception_exit_1; | ||
| 1444 | } | ||
| 1445 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 36; | ||
| 1446 | tmp_assign_source_19 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_14, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_gfloat_tuple, 0 ) ); | ||
| 1447 | |||
| 1448 | Py_DECREF( tmp_called_instance_14 ); | ||
| 1449 | if ( tmp_assign_source_19 == NULL ) | ||
| 1450 | { | ||
| 1451 | assert( ERROR_OCCURRED() ); | ||
| 1452 | |||
| 1453 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1454 | |||
| 1455 | |||
| 1456 | exception_lineno = 36; | ||
| 1457 | |||
| 1458 | goto frame_exception_exit_1; | ||
| 1459 | } | ||
| 1460 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_FLOAT, tmp_assign_source_19 ); | ||
| 1461 | } | ||
| 1462 | { | ||
| 1463 | PyObject *tmp_assign_source_20; | ||
| 1464 | PyObject *tmp_called_instance_15; | ||
| 1465 | PyObject *tmp_source_name_16; | ||
| 1466 | PyObject *tmp_mvar_value_18; | ||
| 1467 | tmp_mvar_value_18 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1468 | |||
| 1469 | if (unlikely( tmp_mvar_value_18 == NULL )) | ||
| 1470 | { | ||
| 1471 | tmp_mvar_value_18 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1472 | } | ||
| 1473 | |||
| 1474 | if ( tmp_mvar_value_18 == NULL ) | ||
| 1475 | { | ||
| 1476 | |||
| 1477 | exception_type = PyExc_NameError; | ||
| 1478 | Py_INCREF( exception_type ); | ||
| 1479 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1480 | exception_tb = NULL; | ||
| 1481 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1482 | CHAIN_EXCEPTION( exception_value ); | ||
| 1483 | |||
| 1484 | exception_lineno = 37; | ||
| 1485 | |||
| 1486 | goto frame_exception_exit_1; | ||
| 1487 | } | ||
| 1488 | |||
| 1489 | tmp_source_name_16 = tmp_mvar_value_18; | ||
| 1490 | tmp_called_instance_15 = LOOKUP_ATTRIBUTE( tmp_source_name_16, const_str_plain_GType ); | ||
| 1491 | if ( tmp_called_instance_15 == NULL ) | ||
| 1492 | { | ||
| 1493 | assert( ERROR_OCCURRED() ); | ||
| 1494 | |||
| 1495 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1496 | |||
| 1497 | |||
| 1498 | exception_lineno = 37; | ||
| 1499 | |||
| 1500 | goto frame_exception_exit_1; | ||
| 1501 | } | ||
| 1502 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 37; | ||
| 1503 | tmp_assign_source_20 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_15, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_gdouble_tuple, 0 ) ); | ||
| 1504 | |||
| 1505 | Py_DECREF( tmp_called_instance_15 ); | ||
| 1506 | if ( tmp_assign_source_20 == NULL ) | ||
| 1507 | { | ||
| 1508 | assert( ERROR_OCCURRED() ); | ||
| 1509 | |||
| 1510 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1511 | |||
| 1512 | |||
| 1513 | exception_lineno = 37; | ||
| 1514 | |||
| 1515 | goto frame_exception_exit_1; | ||
| 1516 | } | ||
| 1517 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_DOUBLE, tmp_assign_source_20 ); | ||
| 1518 | } | ||
| 1519 | { | ||
| 1520 | PyObject *tmp_assign_source_21; | ||
| 1521 | PyObject *tmp_called_instance_16; | ||
| 1522 | PyObject *tmp_source_name_17; | ||
| 1523 | PyObject *tmp_mvar_value_19; | ||
| 1524 | tmp_mvar_value_19 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1525 | |||
| 1526 | if (unlikely( tmp_mvar_value_19 == NULL )) | ||
| 1527 | { | ||
| 1528 | tmp_mvar_value_19 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1529 | } | ||
| 1530 | |||
| 1531 | if ( tmp_mvar_value_19 == NULL ) | ||
| 1532 | { | ||
| 1533 | |||
| 1534 | exception_type = PyExc_NameError; | ||
| 1535 | Py_INCREF( exception_type ); | ||
| 1536 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1537 | exception_tb = NULL; | ||
| 1538 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1539 | CHAIN_EXCEPTION( exception_value ); | ||
| 1540 | |||
| 1541 | exception_lineno = 38; | ||
| 1542 | |||
| 1543 | goto frame_exception_exit_1; | ||
| 1544 | } | ||
| 1545 | |||
| 1546 | tmp_source_name_17 = tmp_mvar_value_19; | ||
| 1547 | tmp_called_instance_16 = LOOKUP_ATTRIBUTE( tmp_source_name_17, const_str_plain_GType ); | ||
| 1548 | if ( tmp_called_instance_16 == NULL ) | ||
| 1549 | { | ||
| 1550 | assert( ERROR_OCCURRED() ); | ||
| 1551 | |||
| 1552 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1553 | |||
| 1554 | |||
| 1555 | exception_lineno = 38; | ||
| 1556 | |||
| 1557 | goto frame_exception_exit_1; | ||
| 1558 | } | ||
| 1559 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 38; | ||
| 1560 | tmp_assign_source_21 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_16, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_gchararray_tuple, 0 ) ); | ||
| 1561 | |||
| 1562 | Py_DECREF( tmp_called_instance_16 ); | ||
| 1563 | if ( tmp_assign_source_21 == NULL ) | ||
| 1564 | { | ||
| 1565 | assert( ERROR_OCCURRED() ); | ||
| 1566 | |||
| 1567 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1568 | |||
| 1569 | |||
| 1570 | exception_lineno = 38; | ||
| 1571 | |||
| 1572 | goto frame_exception_exit_1; | ||
| 1573 | } | ||
| 1574 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_STRING, tmp_assign_source_21 ); | ||
| 1575 | } | ||
| 1576 | { | ||
| 1577 | PyObject *tmp_assign_source_22; | ||
| 1578 | PyObject *tmp_called_instance_17; | ||
| 1579 | PyObject *tmp_source_name_18; | ||
| 1580 | PyObject *tmp_mvar_value_20; | ||
| 1581 | tmp_mvar_value_20 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1582 | |||
| 1583 | if (unlikely( tmp_mvar_value_20 == NULL )) | ||
| 1584 | { | ||
| 1585 | tmp_mvar_value_20 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1586 | } | ||
| 1587 | |||
| 1588 | if ( tmp_mvar_value_20 == NULL ) | ||
| 1589 | { | ||
| 1590 | |||
| 1591 | exception_type = PyExc_NameError; | ||
| 1592 | Py_INCREF( exception_type ); | ||
| 1593 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1594 | exception_tb = NULL; | ||
| 1595 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1596 | CHAIN_EXCEPTION( exception_value ); | ||
| 1597 | |||
| 1598 | exception_lineno = 39; | ||
| 1599 | |||
| 1600 | goto frame_exception_exit_1; | ||
| 1601 | } | ||
| 1602 | |||
| 1603 | tmp_source_name_18 = tmp_mvar_value_20; | ||
| 1604 | tmp_called_instance_17 = LOOKUP_ATTRIBUTE( tmp_source_name_18, const_str_plain_GType ); | ||
| 1605 | if ( tmp_called_instance_17 == NULL ) | ||
| 1606 | { | ||
| 1607 | assert( ERROR_OCCURRED() ); | ||
| 1608 | |||
| 1609 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1610 | |||
| 1611 | |||
| 1612 | exception_lineno = 39; | ||
| 1613 | |||
| 1614 | goto frame_exception_exit_1; | ||
| 1615 | } | ||
| 1616 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 39; | ||
| 1617 | tmp_assign_source_22 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_17, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_gpointer_tuple, 0 ) ); | ||
| 1618 | |||
| 1619 | Py_DECREF( tmp_called_instance_17 ); | ||
| 1620 | if ( tmp_assign_source_22 == NULL ) | ||
| 1621 | { | ||
| 1622 | assert( ERROR_OCCURRED() ); | ||
| 1623 | |||
| 1624 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1625 | |||
| 1626 | |||
| 1627 | exception_lineno = 39; | ||
| 1628 | |||
| 1629 | goto frame_exception_exit_1; | ||
| 1630 | } | ||
| 1631 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_POINTER, tmp_assign_source_22 ); | ||
| 1632 | } | ||
| 1633 | { | ||
| 1634 | PyObject *tmp_assign_source_23; | ||
| 1635 | PyObject *tmp_called_instance_18; | ||
| 1636 | PyObject *tmp_source_name_19; | ||
| 1637 | PyObject *tmp_mvar_value_21; | ||
| 1638 | tmp_mvar_value_21 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1639 | |||
| 1640 | if (unlikely( tmp_mvar_value_21 == NULL )) | ||
| 1641 | { | ||
| 1642 | tmp_mvar_value_21 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1643 | } | ||
| 1644 | |||
| 1645 | if ( tmp_mvar_value_21 == NULL ) | ||
| 1646 | { | ||
| 1647 | |||
| 1648 | exception_type = PyExc_NameError; | ||
| 1649 | Py_INCREF( exception_type ); | ||
| 1650 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1651 | exception_tb = NULL; | ||
| 1652 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1653 | CHAIN_EXCEPTION( exception_value ); | ||
| 1654 | |||
| 1655 | exception_lineno = 40; | ||
| 1656 | |||
| 1657 | goto frame_exception_exit_1; | ||
| 1658 | } | ||
| 1659 | |||
| 1660 | tmp_source_name_19 = tmp_mvar_value_21; | ||
| 1661 | tmp_called_instance_18 = LOOKUP_ATTRIBUTE( tmp_source_name_19, const_str_plain_GType ); | ||
| 1662 | if ( tmp_called_instance_18 == NULL ) | ||
| 1663 | { | ||
| 1664 | assert( ERROR_OCCURRED() ); | ||
| 1665 | |||
| 1666 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1667 | |||
| 1668 | |||
| 1669 | exception_lineno = 40; | ||
| 1670 | |||
| 1671 | goto frame_exception_exit_1; | ||
| 1672 | } | ||
| 1673 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 40; | ||
| 1674 | tmp_assign_source_23 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_18, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_GBoxed_tuple, 0 ) ); | ||
| 1675 | |||
| 1676 | Py_DECREF( tmp_called_instance_18 ); | ||
| 1677 | if ( tmp_assign_source_23 == NULL ) | ||
| 1678 | { | ||
| 1679 | assert( ERROR_OCCURRED() ); | ||
| 1680 | |||
| 1681 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1682 | |||
| 1683 | |||
| 1684 | exception_lineno = 40; | ||
| 1685 | |||
| 1686 | goto frame_exception_exit_1; | ||
| 1687 | } | ||
| 1688 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_BOXED, tmp_assign_source_23 ); | ||
| 1689 | } | ||
| 1690 | { | ||
| 1691 | PyObject *tmp_assign_source_24; | ||
| 1692 | PyObject *tmp_called_instance_19; | ||
| 1693 | PyObject *tmp_source_name_20; | ||
| 1694 | PyObject *tmp_mvar_value_22; | ||
| 1695 | tmp_mvar_value_22 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1696 | |||
| 1697 | if (unlikely( tmp_mvar_value_22 == NULL )) | ||
| 1698 | { | ||
| 1699 | tmp_mvar_value_22 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1700 | } | ||
| 1701 | |||
| 1702 | if ( tmp_mvar_value_22 == NULL ) | ||
| 1703 | { | ||
| 1704 | |||
| 1705 | exception_type = PyExc_NameError; | ||
| 1706 | Py_INCREF( exception_type ); | ||
| 1707 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1708 | exception_tb = NULL; | ||
| 1709 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1710 | CHAIN_EXCEPTION( exception_value ); | ||
| 1711 | |||
| 1712 | exception_lineno = 41; | ||
| 1713 | |||
| 1714 | goto frame_exception_exit_1; | ||
| 1715 | } | ||
| 1716 | |||
| 1717 | tmp_source_name_20 = tmp_mvar_value_22; | ||
| 1718 | tmp_called_instance_19 = LOOKUP_ATTRIBUTE( tmp_source_name_20, const_str_plain_GType ); | ||
| 1719 | if ( tmp_called_instance_19 == NULL ) | ||
| 1720 | { | ||
| 1721 | assert( ERROR_OCCURRED() ); | ||
| 1722 | |||
| 1723 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1724 | |||
| 1725 | |||
| 1726 | exception_lineno = 41; | ||
| 1727 | |||
| 1728 | goto frame_exception_exit_1; | ||
| 1729 | } | ||
| 1730 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 41; | ||
| 1731 | tmp_assign_source_24 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_19, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_GParam_tuple, 0 ) ); | ||
| 1732 | |||
| 1733 | Py_DECREF( tmp_called_instance_19 ); | ||
| 1734 | if ( tmp_assign_source_24 == NULL ) | ||
| 1735 | { | ||
| 1736 | assert( ERROR_OCCURRED() ); | ||
| 1737 | |||
| 1738 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1739 | |||
| 1740 | |||
| 1741 | exception_lineno = 41; | ||
| 1742 | |||
| 1743 | goto frame_exception_exit_1; | ||
| 1744 | } | ||
| 1745 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_PARAM, tmp_assign_source_24 ); | ||
| 1746 | } | ||
| 1747 | { | ||
| 1748 | PyObject *tmp_assign_source_25; | ||
| 1749 | PyObject *tmp_called_instance_20; | ||
| 1750 | PyObject *tmp_source_name_21; | ||
| 1751 | PyObject *tmp_mvar_value_23; | ||
| 1752 | tmp_mvar_value_23 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1753 | |||
| 1754 | if (unlikely( tmp_mvar_value_23 == NULL )) | ||
| 1755 | { | ||
| 1756 | tmp_mvar_value_23 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1757 | } | ||
| 1758 | |||
| 1759 | if ( tmp_mvar_value_23 == NULL ) | ||
| 1760 | { | ||
| 1761 | |||
| 1762 | exception_type = PyExc_NameError; | ||
| 1763 | Py_INCREF( exception_type ); | ||
| 1764 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1765 | exception_tb = NULL; | ||
| 1766 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1767 | CHAIN_EXCEPTION( exception_value ); | ||
| 1768 | |||
| 1769 | exception_lineno = 42; | ||
| 1770 | |||
| 1771 | goto frame_exception_exit_1; | ||
| 1772 | } | ||
| 1773 | |||
| 1774 | tmp_source_name_21 = tmp_mvar_value_23; | ||
| 1775 | tmp_called_instance_20 = LOOKUP_ATTRIBUTE( tmp_source_name_21, const_str_plain_GType ); | ||
| 1776 | if ( tmp_called_instance_20 == NULL ) | ||
| 1777 | { | ||
| 1778 | assert( ERROR_OCCURRED() ); | ||
| 1779 | |||
| 1780 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1781 | |||
| 1782 | |||
| 1783 | exception_lineno = 42; | ||
| 1784 | |||
| 1785 | goto frame_exception_exit_1; | ||
| 1786 | } | ||
| 1787 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 42; | ||
| 1788 | tmp_assign_source_25 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_20, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_GObject_tuple, 0 ) ); | ||
| 1789 | |||
| 1790 | Py_DECREF( tmp_called_instance_20 ); | ||
| 1791 | if ( tmp_assign_source_25 == NULL ) | ||
| 1792 | { | ||
| 1793 | assert( ERROR_OCCURRED() ); | ||
| 1794 | |||
| 1795 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1796 | |||
| 1797 | |||
| 1798 | exception_lineno = 42; | ||
| 1799 | |||
| 1800 | goto frame_exception_exit_1; | ||
| 1801 | } | ||
| 1802 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_OBJECT, tmp_assign_source_25 ); | ||
| 1803 | } | ||
| 1804 | { | ||
| 1805 | PyObject *tmp_assign_source_26; | ||
| 1806 | PyObject *tmp_called_instance_21; | ||
| 1807 | PyObject *tmp_source_name_22; | ||
| 1808 | PyObject *tmp_mvar_value_24; | ||
| 1809 | tmp_mvar_value_24 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1810 | |||
| 1811 | if (unlikely( tmp_mvar_value_24 == NULL )) | ||
| 1812 | { | ||
| 1813 | tmp_mvar_value_24 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1814 | } | ||
| 1815 | |||
| 1816 | if ( tmp_mvar_value_24 == NULL ) | ||
| 1817 | { | ||
| 1818 | |||
| 1819 | exception_type = PyExc_NameError; | ||
| 1820 | Py_INCREF( exception_type ); | ||
| 1821 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1822 | exception_tb = NULL; | ||
| 1823 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1824 | CHAIN_EXCEPTION( exception_value ); | ||
| 1825 | |||
| 1826 | exception_lineno = 43; | ||
| 1827 | |||
| 1828 | goto frame_exception_exit_1; | ||
| 1829 | } | ||
| 1830 | |||
| 1831 | tmp_source_name_22 = tmp_mvar_value_24; | ||
| 1832 | tmp_called_instance_21 = LOOKUP_ATTRIBUTE( tmp_source_name_22, const_str_plain_GType ); | ||
| 1833 | if ( tmp_called_instance_21 == NULL ) | ||
| 1834 | { | ||
| 1835 | assert( ERROR_OCCURRED() ); | ||
| 1836 | |||
| 1837 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1838 | |||
| 1839 | |||
| 1840 | exception_lineno = 43; | ||
| 1841 | |||
| 1842 | goto frame_exception_exit_1; | ||
| 1843 | } | ||
| 1844 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 43; | ||
| 1845 | tmp_assign_source_26 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_21, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_PyObject_tuple, 0 ) ); | ||
| 1846 | |||
| 1847 | Py_DECREF( tmp_called_instance_21 ); | ||
| 1848 | if ( tmp_assign_source_26 == NULL ) | ||
| 1849 | { | ||
| 1850 | assert( ERROR_OCCURRED() ); | ||
| 1851 | |||
| 1852 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1853 | |||
| 1854 | |||
| 1855 | exception_lineno = 43; | ||
| 1856 | |||
| 1857 | goto frame_exception_exit_1; | ||
| 1858 | } | ||
| 1859 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_PYOBJECT, tmp_assign_source_26 ); | ||
| 1860 | } | ||
| 1861 | { | ||
| 1862 | PyObject *tmp_assign_source_27; | ||
| 1863 | PyObject *tmp_called_instance_22; | ||
| 1864 | PyObject *tmp_source_name_23; | ||
| 1865 | PyObject *tmp_mvar_value_25; | ||
| 1866 | tmp_mvar_value_25 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1867 | |||
| 1868 | if (unlikely( tmp_mvar_value_25 == NULL )) | ||
| 1869 | { | ||
| 1870 | tmp_mvar_value_25 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1871 | } | ||
| 1872 | |||
| 1873 | if ( tmp_mvar_value_25 == NULL ) | ||
| 1874 | { | ||
| 1875 | |||
| 1876 | exception_type = PyExc_NameError; | ||
| 1877 | Py_INCREF( exception_type ); | ||
| 1878 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1879 | exception_tb = NULL; | ||
| 1880 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1881 | CHAIN_EXCEPTION( exception_value ); | ||
| 1882 | |||
| 1883 | exception_lineno = 44; | ||
| 1884 | |||
| 1885 | goto frame_exception_exit_1; | ||
| 1886 | } | ||
| 1887 | |||
| 1888 | tmp_source_name_23 = tmp_mvar_value_25; | ||
| 1889 | tmp_called_instance_22 = LOOKUP_ATTRIBUTE( tmp_source_name_23, const_str_plain_GType ); | ||
| 1890 | if ( tmp_called_instance_22 == NULL ) | ||
| 1891 | { | ||
| 1892 | assert( ERROR_OCCURRED() ); | ||
| 1893 | |||
| 1894 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1895 | |||
| 1896 | |||
| 1897 | exception_lineno = 44; | ||
| 1898 | |||
| 1899 | goto frame_exception_exit_1; | ||
| 1900 | } | ||
| 1901 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 44; | ||
| 1902 | tmp_assign_source_27 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_22, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_GType_tuple, 0 ) ); | ||
| 1903 | |||
| 1904 | Py_DECREF( tmp_called_instance_22 ); | ||
| 1905 | if ( tmp_assign_source_27 == NULL ) | ||
| 1906 | { | ||
| 1907 | assert( ERROR_OCCURRED() ); | ||
| 1908 | |||
| 1909 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1910 | |||
| 1911 | |||
| 1912 | exception_lineno = 44; | ||
| 1913 | |||
| 1914 | goto frame_exception_exit_1; | ||
| 1915 | } | ||
| 1916 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_GTYPE, tmp_assign_source_27 ); | ||
| 1917 | } | ||
| 1918 | { | ||
| 1919 | PyObject *tmp_assign_source_28; | ||
| 1920 | PyObject *tmp_called_instance_23; | ||
| 1921 | PyObject *tmp_source_name_24; | ||
| 1922 | PyObject *tmp_mvar_value_26; | ||
| 1923 | tmp_mvar_value_26 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1924 | |||
| 1925 | if (unlikely( tmp_mvar_value_26 == NULL )) | ||
| 1926 | { | ||
| 1927 | tmp_mvar_value_26 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1928 | } | ||
| 1929 | |||
| 1930 | if ( tmp_mvar_value_26 == NULL ) | ||
| 1931 | { | ||
| 1932 | |||
| 1933 | exception_type = PyExc_NameError; | ||
| 1934 | Py_INCREF( exception_type ); | ||
| 1935 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1936 | exception_tb = NULL; | ||
| 1937 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1938 | CHAIN_EXCEPTION( exception_value ); | ||
| 1939 | |||
| 1940 | exception_lineno = 45; | ||
| 1941 | |||
| 1942 | goto frame_exception_exit_1; | ||
| 1943 | } | ||
| 1944 | |||
| 1945 | tmp_source_name_24 = tmp_mvar_value_26; | ||
| 1946 | tmp_called_instance_23 = LOOKUP_ATTRIBUTE( tmp_source_name_24, const_str_plain_GType ); | ||
| 1947 | if ( tmp_called_instance_23 == NULL ) | ||
| 1948 | { | ||
| 1949 | assert( ERROR_OCCURRED() ); | ||
| 1950 | |||
| 1951 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1952 | |||
| 1953 | |||
| 1954 | exception_lineno = 45; | ||
| 1955 | |||
| 1956 | goto frame_exception_exit_1; | ||
| 1957 | } | ||
| 1958 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 45; | ||
| 1959 | tmp_assign_source_28 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_23, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_GStrv_tuple, 0 ) ); | ||
| 1960 | |||
| 1961 | Py_DECREF( tmp_called_instance_23 ); | ||
| 1962 | if ( tmp_assign_source_28 == NULL ) | ||
| 1963 | { | ||
| 1964 | assert( ERROR_OCCURRED() ); | ||
| 1965 | |||
| 1966 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1967 | |||
| 1968 | |||
| 1969 | exception_lineno = 45; | ||
| 1970 | |||
| 1971 | goto frame_exception_exit_1; | ||
| 1972 | } | ||
| 1973 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_STRV, tmp_assign_source_28 ); | ||
| 1974 | } | ||
| 1975 | { | ||
| 1976 | PyObject *tmp_assign_source_29; | ||
| 1977 | PyObject *tmp_called_instance_24; | ||
| 1978 | PyObject *tmp_source_name_25; | ||
| 1979 | PyObject *tmp_mvar_value_27; | ||
| 1980 | tmp_mvar_value_27 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1981 | |||
| 1982 | if (unlikely( tmp_mvar_value_27 == NULL )) | ||
| 1983 | { | ||
| 1984 | tmp_mvar_value_27 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__gi ); | ||
| 1985 | } | ||
| 1986 | |||
| 1987 | if ( tmp_mvar_value_27 == NULL ) | ||
| 1988 | { | ||
| 1989 | |||
| 1990 | exception_type = PyExc_NameError; | ||
| 1991 | Py_INCREF( exception_type ); | ||
| 1992 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_gi" ); | ||
| 1993 | exception_tb = NULL; | ||
| 1994 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1995 | CHAIN_EXCEPTION( exception_value ); | ||
| 1996 | |||
| 1997 | exception_lineno = 46; | ||
| 1998 | |||
| 1999 | goto frame_exception_exit_1; | ||
| 2000 | } | ||
| 2001 | |||
| 2002 | tmp_source_name_25 = tmp_mvar_value_27; | ||
| 2003 | tmp_called_instance_24 = LOOKUP_ATTRIBUTE( tmp_source_name_25, const_str_plain_GType ); | ||
| 2004 | if ( tmp_called_instance_24 == NULL ) | ||
| 2005 | { | ||
| 2006 | assert( ERROR_OCCURRED() ); | ||
| 2007 | |||
| 2008 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2009 | |||
| 2010 | |||
| 2011 | exception_lineno = 46; | ||
| 2012 | |||
| 2013 | goto frame_exception_exit_1; | ||
| 2014 | } | ||
| 2015 | frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame.f_lineno = 46; | ||
| 2016 | tmp_assign_source_29 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_24, const_str_plain_from_name, &PyTuple_GET_ITEM( const_tuple_str_plain_GVariant_tuple, 0 ) ); | ||
| 2017 | |||
| 2018 | Py_DECREF( tmp_called_instance_24 ); | ||
| 2019 | if ( tmp_assign_source_29 == NULL ) | ||
| 2020 | { | ||
| 2021 | assert( ERROR_OCCURRED() ); | ||
| 2022 | |||
| 2023 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2024 | |||
| 2025 | |||
| 2026 | exception_lineno = 46; | ||
| 2027 | |||
| 2028 | goto frame_exception_exit_1; | ||
| 2029 | } | ||
| 2030 | UPDATE_STRING_DICT1( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_VARIANT, tmp_assign_source_29 ); | ||
| 2031 | } | ||
| 2032 | { | ||
| 2033 | PyObject *tmp_assign_source_30; | ||
| 2034 | PyObject *tmp_mvar_value_28; | ||
| 2035 | tmp_mvar_value_28 = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_UINT ); | ||
| 2036 | |||
| 2037 | if (unlikely( tmp_mvar_value_28 == NULL )) | ||
| 2038 | { | ||
| 2039 | tmp_mvar_value_28 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_TYPE_UINT ); | ||
| 2040 | } | ||
| 2041 | |||
| 2042 | if ( tmp_mvar_value_28 == NULL ) | ||
| 2043 | { | ||
| 2044 | |||
| 2045 | exception_type = PyExc_NameError; | ||
| 2046 | Py_INCREF( exception_type ); | ||
| 2047 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "TYPE_UINT" ); | ||
| 2048 | exception_tb = NULL; | ||
| 2049 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2050 | CHAIN_EXCEPTION( exception_value ); | ||
| 2051 | |||
| 2052 | exception_lineno = 47; | ||
| 2053 | |||
| 2054 | goto frame_exception_exit_1; | ||
| 2055 | } | ||
| 2056 | |||
| 2057 | tmp_assign_source_30 = tmp_mvar_value_28; | ||
| 2058 | UPDATE_STRING_DICT0( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain_TYPE_UNICHAR, tmp_assign_source_30 ); | ||
| 2059 | } | ||
| 2060 | |||
| 2061 | // Restore frame exception if necessary. | ||
| 2062 | #if 0 | ||
| 2063 | RESTORE_FRAME_EXCEPTION( frame_9b8fa347d6463efdd2286c4ba70ef98a ); | ||
| 2064 | #endif | ||
| 2065 | popFrameStack(); | ||
| 2066 | |||
| 2067 | assertFrameObject( frame_9b8fa347d6463efdd2286c4ba70ef98a ); | ||
| 2068 | |||
| 2069 | goto frame_no_exception_1; | ||
| 2070 | |||
| 2071 | frame_exception_exit_1:; | ||
| 2072 | #if 0 | ||
| 2073 | RESTORE_FRAME_EXCEPTION( frame_9b8fa347d6463efdd2286c4ba70ef98a ); | ||
| 2074 | #endif | ||
| 2075 | |||
| 2076 | if ( exception_tb == NULL ) | ||
| 2077 | { | ||
| 2078 | exception_tb = MAKE_TRACEBACK( frame_9b8fa347d6463efdd2286c4ba70ef98a, exception_lineno ); | ||
| 2079 | } | ||
| 2080 | else if ( exception_tb->tb_frame != &frame_9b8fa347d6463efdd2286c4ba70ef98a->m_frame ) | ||
| 2081 | { | ||
| 2082 | exception_tb = ADD_TRACEBACK( exception_tb, frame_9b8fa347d6463efdd2286c4ba70ef98a, exception_lineno ); | ||
| 2083 | } | ||
| 2084 | |||
| 2085 | // Put the previous frame back on top. | ||
| 2086 | popFrameStack(); | ||
| 2087 | |||
| 2088 | // Return the error. | ||
| 2089 | goto module_exception_exit; | ||
| 2090 | |||
| 2091 | frame_no_exception_1:; | ||
| 2092 | |||
| 2093 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 2094 | #if 0 && 0 | ||
| 2095 | { | ||
| 2096 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_gi$_constants, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 2097 | |||
| 2098 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 2099 | { | ||
| 2100 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 2101 | |||
| 2102 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 2103 | CHECK_OBJECT( path_importer_cache ); | ||
| 2104 | |||
| 2105 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 2106 | assert( res == 0 ); | ||
| 2107 | } | ||
| 2108 | } | ||
| 2109 | #endif | ||
| 2110 | #endif | ||
| 2111 | |||
| 2112 | return MOD_RETURN_VALUE( module_gi$_constants ); | ||
| 2113 | module_exception_exit: | ||
| 2114 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 2115 | return MOD_RETURN_VALUE( NULL ); | ||
| 2116 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.gi._constants.o deleted (index c1fc54a..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.gi._error.c deleted (index 5875d93..0000000) | |||
| 1 | /* Generated code for Python module 'gi._error' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_gi$_error" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_gi$_error; | ||
| 31 | PyDictObject *moduledict_gi$_error; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain___orig_bases__; | ||
| 35 | extern PyObject *const_str_plain___module__; | ||
| 36 | extern PyObject *const_str_plain_metaclass; | ||
| 37 | static PyObject *const_str_digest_d79d2d3d3465aa4fbe81afc494eaeb8b; | ||
| 38 | extern PyObject *const_str_plain___spec__; | ||
| 39 | extern PyObject *const_str_plain___str__; | ||
| 40 | extern PyObject *const_str_plain_False; | ||
| 41 | extern PyObject *const_str_plain___name__; | ||
| 42 | extern PyObject *const_str_plain___class__; | ||
| 43 | static PyObject *const_str_digest_3d153c5d0eaaafb2f22f8a20dd96e148; | ||
| 44 | extern PyObject *const_str_plain___getitem__; | ||
| 45 | static PyObject *const_str_digest_89e98bf8388402041eeb0849366e274b; | ||
| 46 | extern PyObject *const_str_plain___qualname__; | ||
| 47 | static PyObject *const_str_digest_ab8bd434ecb26dfe63e508b968fd6e8d; | ||
| 48 | extern PyObject *const_str_angle_metaclass; | ||
| 49 | extern PyObject *const_tuple_str_dot_int_pos_1_tuple; | ||
| 50 | extern PyObject *const_tuple_str_plain___class___tuple; | ||
| 51 | extern PyObject *const_int_pos_1; | ||
| 52 | static PyObject *const_tuple_49b8833ad751fd7237ea8d13ccb226e2_tuple; | ||
| 53 | extern PyObject *const_str_plain___file__; | ||
| 54 | static PyObject *const_str_digest_567b5a7dadb515a36a01e9d4d7d66ed5; | ||
| 55 | static PyObject *const_str_digest_fae8fb32187bc00c89e7e2cdabcd3491; | ||
| 56 | extern PyObject *const_str_plain_copy; | ||
| 57 | static PyObject *const_tuple_str_plain_domain_str_plain_message_str_plain_code_tuple; | ||
| 58 | extern PyObject *const_int_0; | ||
| 59 | static PyObject *const_str_plain_code; | ||
| 60 | extern PyObject *const_str_plain___init__; | ||
| 61 | extern PyObject *const_str_plain___prepare__; | ||
| 62 | static PyObject *const_tuple_6dea1aea9578e84d91166d139e16dc91_tuple; | ||
| 63 | extern PyObject *const_tuple_str_plain_self_tuple; | ||
| 64 | extern PyObject *const_int_neg_1; | ||
| 65 | static PyObject *const_tuple_str_plain_self_str_plain_domain_str_plain_code_tuple; | ||
| 66 | extern PyObject *const_str_plain_self; | ||
| 67 | extern PyObject *const_str_plain_rsplit; | ||
| 68 | extern PyObject *const_str_plain_message; | ||
| 69 | extern PyObject *const_str_plain_origin; | ||
| 70 | extern PyObject *const_str_plain___repr__; | ||
| 71 | static PyObject *const_str_digest_75d07a2f87de39f67083eb2d499c83ad; | ||
| 72 | extern PyObject *const_str_plain_staticmethod; | ||
| 73 | static PyObject *const_str_plain_domain; | ||
| 74 | extern PyObject *const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 75 | extern PyObject *const_tuple_empty; | ||
| 76 | static PyObject *const_str_plain_new_literal; | ||
| 77 | static PyObject *const_str_digest_33e95f74b197591de3450bcfd2a89f41; | ||
| 78 | extern PyObject *const_str_plain_has_location; | ||
| 79 | static PyObject *const_str_digest_6bfa92c856dbf8e3e2c5e4b775af9644; | ||
| 80 | static PyObject *const_str_digest_f2c7de8ef8641c3740230a0d3fabd50a; | ||
| 81 | static PyObject *const_str_digest_0a242a1a96fce436ff82e3043ebfb035; | ||
| 82 | static PyObject *const_str_digest_05f5e7bda3c5f3dd043b13aed890190b; | ||
| 83 | static PyObject *const_str_digest_b68d7eac5477b1f045df4fe766f17454; | ||
| 84 | extern PyObject *const_str_plain_type; | ||
| 85 | static PyObject *const_str_digest_a9b7b3db680a6120a08bd1702778dec5; | ||
| 86 | static PyObject *const_tuple_type_RuntimeError_tuple; | ||
| 87 | extern PyObject *const_str_plain_matches; | ||
| 88 | static PyObject *const_str_plain_GError; | ||
| 89 | extern PyObject *const_str_plain___doc__; | ||
| 90 | extern PyObject *const_str_plain___cached__; | ||
| 91 | extern PyObject *const_str_dot; | ||
| 92 | extern PyObject *const_str_plain___debug__; | ||
| 93 | static PyObject *module_filename_obj; | ||
| 94 | |||
| 95 | /* Indicator if this modules private constants were created yet. */ | ||
| 96 | static bool constants_created = false; | ||
| 97 | |||
| 98 | /* Function to create module private constants. */ | ||
| 99 | static void createModuleConstants( void ) | ||
| 100 | { | ||
| 101 | const_str_digest_d79d2d3d3465aa4fbe81afc494eaeb8b = UNSTREAM_STRING_ASCII( &constant_bin[ 36353 ], 15, 0 ); | ||
| 102 | const_str_digest_3d153c5d0eaaafb2f22f8a20dd96e148 = UNSTREAM_STRING_ASCII( &constant_bin[ 36368 ], 13, 0 ); | ||
| 103 | const_str_digest_89e98bf8388402041eeb0849366e274b = UNSTREAM_STRING_ASCII( &constant_bin[ 36381 ], 18, 0 ); | ||
| 104 | const_str_digest_ab8bd434ecb26dfe63e508b968fd6e8d = UNSTREAM_STRING_ASCII( &constant_bin[ 36399 ], 11, 0 ); | ||
| 105 | const_tuple_49b8833ad751fd7237ea8d13ccb226e2_tuple = PyTuple_New( 3 ); | ||
| 106 | PyTuple_SET_ITEM( const_tuple_49b8833ad751fd7237ea8d13ccb226e2_tuple, 0, const_str_digest_3d153c5d0eaaafb2f22f8a20dd96e148 ); Py_INCREF( const_str_digest_3d153c5d0eaaafb2f22f8a20dd96e148 ); | ||
| 107 | const_str_digest_33e95f74b197591de3450bcfd2a89f41 = UNSTREAM_STRING_ASCII( &constant_bin[ 36410 ], 10, 0 ); | ||
| 108 | PyTuple_SET_ITEM( const_tuple_49b8833ad751fd7237ea8d13ccb226e2_tuple, 1, const_str_digest_33e95f74b197591de3450bcfd2a89f41 ); Py_INCREF( const_str_digest_33e95f74b197591de3450bcfd2a89f41 ); | ||
| 109 | PyTuple_SET_ITEM( const_tuple_49b8833ad751fd7237ea8d13ccb226e2_tuple, 2, const_int_0 ); Py_INCREF( const_int_0 ); | ||
| 110 | const_str_digest_567b5a7dadb515a36a01e9d4d7d66ed5 = UNSTREAM_STRING_ASCII( &constant_bin[ 36420 ], 11, 0 ); | ||
| 111 | const_str_digest_fae8fb32187bc00c89e7e2cdabcd3491 = UNSTREAM_STRING_ASCII( &constant_bin[ 36431 ], 12, 0 ); | ||
| 112 | const_tuple_str_plain_domain_str_plain_message_str_plain_code_tuple = PyTuple_New( 3 ); | ||
| 113 | const_str_plain_domain = UNSTREAM_STRING_ASCII( &constant_bin[ 36443 ], 6, 1 ); | ||
| 114 | PyTuple_SET_ITEM( const_tuple_str_plain_domain_str_plain_message_str_plain_code_tuple, 0, const_str_plain_domain ); Py_INCREF( const_str_plain_domain ); | ||
| 115 | PyTuple_SET_ITEM( const_tuple_str_plain_domain_str_plain_message_str_plain_code_tuple, 1, const_str_plain_message ); Py_INCREF( const_str_plain_message ); | ||
| 116 | const_str_plain_code = UNSTREAM_STRING_ASCII( &constant_bin[ 17351 ], 4, 1 ); | ||
| 117 | PyTuple_SET_ITEM( const_tuple_str_plain_domain_str_plain_message_str_plain_code_tuple, 2, const_str_plain_code ); Py_INCREF( const_str_plain_code ); | ||
| 118 | const_tuple_6dea1aea9578e84d91166d139e16dc91_tuple = PyTuple_New( 5 ); | ||
| 119 | PyTuple_SET_ITEM( const_tuple_6dea1aea9578e84d91166d139e16dc91_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 120 | PyTuple_SET_ITEM( const_tuple_6dea1aea9578e84d91166d139e16dc91_tuple, 1, const_str_plain_message ); Py_INCREF( const_str_plain_message ); | ||
| 121 | PyTuple_SET_ITEM( const_tuple_6dea1aea9578e84d91166d139e16dc91_tuple, 2, const_str_plain_domain ); Py_INCREF( const_str_plain_domain ); | ||
| 122 | PyTuple_SET_ITEM( const_tuple_6dea1aea9578e84d91166d139e16dc91_tuple, 3, const_str_plain_code ); Py_INCREF( const_str_plain_code ); | ||
| 123 | PyTuple_SET_ITEM( const_tuple_6dea1aea9578e84d91166d139e16dc91_tuple, 4, const_str_plain___class__ ); Py_INCREF( const_str_plain___class__ ); | ||
| 124 | const_tuple_str_plain_self_str_plain_domain_str_plain_code_tuple = PyTuple_New( 3 ); | ||
| 125 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_domain_str_plain_code_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 126 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_domain_str_plain_code_tuple, 1, const_str_plain_domain ); Py_INCREF( const_str_plain_domain ); | ||
| 127 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_domain_str_plain_code_tuple, 2, const_str_plain_code ); Py_INCREF( const_str_plain_code ); | ||
| 128 | const_str_digest_75d07a2f87de39f67083eb2d499c83ad = UNSTREAM_STRING_ASCII( &constant_bin[ 36449 ], 21, 0 ); | ||
| 129 | const_str_plain_new_literal = UNSTREAM_STRING_ASCII( &constant_bin[ 36388 ], 11, 1 ); | ||
| 130 | const_str_digest_6bfa92c856dbf8e3e2c5e4b775af9644 = UNSTREAM_STRING_ASCII( &constant_bin[ 36470 ], 15, 0 ); | ||
| 131 | const_str_digest_f2c7de8ef8641c3740230a0d3fabd50a = UNSTREAM_STRING_ASCII( &constant_bin[ 36485 ], 14, 0 ); | ||
| 132 | const_str_digest_0a242a1a96fce436ff82e3043ebfb035 = UNSTREAM_STRING_ASCII( &constant_bin[ 36499 ], 18, 0 ); | ||
| 133 | const_str_digest_05f5e7bda3c5f3dd043b13aed890190b = UNSTREAM_STRING_ASCII( &constant_bin[ 36517 ], 58, 0 ); | ||
| 134 | const_str_digest_b68d7eac5477b1f045df4fe766f17454 = UNSTREAM_STRING_ASCII( &constant_bin[ 36575 ], 14, 0 ); | ||
| 135 | const_str_digest_a9b7b3db680a6120a08bd1702778dec5 = UNSTREAM_STRING_ASCII( &constant_bin[ 36507 ], 9, 0 ); | ||
| 136 | const_tuple_type_RuntimeError_tuple = PyTuple_New( 1 ); | ||
| 137 | PyTuple_SET_ITEM( const_tuple_type_RuntimeError_tuple, 0, (PyObject *)PyExc_RuntimeError ); Py_INCREF( (PyObject *)PyExc_RuntimeError ); | ||
| 138 | const_str_plain_GError = UNSTREAM_STRING_ASCII( &constant_bin[ 36353 ], 6, 1 ); | ||
| 139 | |||
| 140 | constants_created = true; | ||
| 141 | } | ||
| 142 | |||
| 143 | /* Function to verify module private constants for non-corruption. */ | ||
| 144 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 145 | void checkModuleConstants_gi$_error( void ) | ||
| 146 | { | ||
| 147 | // The module may not have been used at all, then ignore this. | ||
| 148 | if (constants_created == false) return; | ||
| 149 | |||
| 150 | |||
| 151 | } | ||
| 152 | #endif | ||
| 153 | |||
| 154 | // The module code objects. | ||
| 155 | static PyCodeObject *codeobj_aafd294a192c701bd13d3c8b93cd1b82; | ||
| 156 | static PyCodeObject *codeobj_642fa75cb43d28afa93ff29e67523814; | ||
| 157 | static PyCodeObject *codeobj_cf0852ad4c7c0a4f24e105dd59eb5bb4; | ||
| 158 | static PyCodeObject *codeobj_c2ee6d133e87fb3a9c28fb092eeedd2d; | ||
| 159 | static PyCodeObject *codeobj_c275568401228a488599146a3b69044e; | ||
| 160 | static PyCodeObject *codeobj_305f11e425fc81aa725ee337171b21c9; | ||
| 161 | static PyCodeObject *codeobj_d5da4e4df6d7c426ebe86d0ed7048621; | ||
| 162 | static PyCodeObject *codeobj_59b5ad9c2ee887c3333a954738a2dfd7; | ||
| 163 | |||
| 164 | static void createModuleCodeObjects(void) | ||
| 165 | { | ||
| 166 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_fae8fb32187bc00c89e7e2cdabcd3491 ); | ||
| 167 | codeobj_aafd294a192c701bd13d3c8b93cd1b82 = MAKE_CODEOBJ( module_filename_obj, const_str_digest_0a242a1a96fce436ff82e3043ebfb035, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 168 | codeobj_642fa75cb43d28afa93ff29e67523814 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_GError, 30, const_tuple_str_plain___class___tuple, 0, 0, CO_NOFREE ); | ||
| 169 | codeobj_cf0852ad4c7c0a4f24e105dd59eb5bb4 = MAKE_CODEOBJ( module_filename_obj, const_str_plain___init__, 31, const_tuple_6dea1aea9578e84d91166d139e16dc91_tuple, 4, 0, CO_OPTIMIZED | CO_NEWLOCALS ); | ||
| 170 | codeobj_c2ee6d133e87fb3a9c28fb092eeedd2d = MAKE_CODEOBJ( module_filename_obj, const_str_plain___repr__, 40, const_tuple_str_plain_self_tuple, 1, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 171 | codeobj_c275568401228a488599146a3b69044e = MAKE_CODEOBJ( module_filename_obj, const_str_plain___str__, 37, const_tuple_str_plain_self_tuple, 1, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 172 | codeobj_305f11e425fc81aa725ee337171b21c9 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_copy, 45, const_tuple_str_plain_self_tuple, 1, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 173 | codeobj_d5da4e4df6d7c426ebe86d0ed7048621 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_matches, 48, const_tuple_str_plain_self_str_plain_domain_str_plain_code_tuple, 3, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 174 | codeobj_59b5ad9c2ee887c3333a954738a2dfd7 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_new_literal, 52, const_tuple_str_plain_domain_str_plain_message_str_plain_code_tuple, 3, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 175 | } | ||
| 176 | |||
| 177 | // The module function declarations. | ||
| 178 | NUITKA_CROSS_MODULE PyObject *impl___internal__$$$function_2__mro_entries_conversion( PyObject **python_pars ); | ||
| 179 | |||
| 180 | |||
| 181 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_1___init__( PyObject *defaults ); | ||
| 182 | |||
| 183 | |||
| 184 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_2___str__( ); | ||
| 185 | |||
| 186 | |||
| 187 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_3___repr__( ); | ||
| 188 | |||
| 189 | |||
| 190 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_4_copy( ); | ||
| 191 | |||
| 192 | |||
| 193 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_5_matches( ); | ||
| 194 | |||
| 195 | |||
| 196 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_6_new_literal( ); | ||
| 197 | |||
| 198 | |||
| 199 | // The module function definitions. | ||
| 200 | static PyObject *impl_gi$_error$$$function_1___init__( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 201 | { | ||
| 202 | // Preserve error status for checks | ||
| 203 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 204 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 205 | #endif | ||
| 206 | |||
| 207 | // Local variable declarations. | ||
| 208 | PyObject *par_self = python_pars[ 0 ]; | ||
| 209 | PyObject *par_message = python_pars[ 1 ]; | ||
| 210 | PyObject *par_domain = python_pars[ 2 ]; | ||
| 211 | PyObject *par_code = python_pars[ 3 ]; | ||
| 212 | struct Nuitka_FrameObject *frame_cf0852ad4c7c0a4f24e105dd59eb5bb4; | ||
| 213 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 214 | PyObject *exception_type = NULL; | ||
| 215 | PyObject *exception_value = NULL; | ||
| 216 | PyTracebackObject *exception_tb = NULL; | ||
| 217 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 218 | bool tmp_result; | ||
| 219 | static struct Nuitka_FrameObject *cache_frame_cf0852ad4c7c0a4f24e105dd59eb5bb4 = NULL; | ||
| 220 | PyObject *tmp_return_value = NULL; | ||
| 221 | PyObject *exception_keeper_type_1; | ||
| 222 | PyObject *exception_keeper_value_1; | ||
| 223 | PyTracebackObject *exception_keeper_tb_1; | ||
| 224 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 225 | |||
| 226 | // Actual function body. | ||
| 227 | // Tried code: | ||
| 228 | MAKE_OR_REUSE_FRAME( cache_frame_cf0852ad4c7c0a4f24e105dd59eb5bb4, codeobj_cf0852ad4c7c0a4f24e105dd59eb5bb4, module_gi$_error, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 229 | frame_cf0852ad4c7c0a4f24e105dd59eb5bb4 = cache_frame_cf0852ad4c7c0a4f24e105dd59eb5bb4; | ||
| 230 | |||
| 231 | // Push the new frame as the currently active one. | ||
| 232 | pushFrameStack( frame_cf0852ad4c7c0a4f24e105dd59eb5bb4 ); | ||
| 233 | |||
| 234 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 235 | assert( Py_REFCNT( frame_cf0852ad4c7c0a4f24e105dd59eb5bb4 ) == 2 ); // Frame stack | ||
| 236 | |||
| 237 | // Framed code: | ||
| 238 | { | ||
| 239 | PyObject *tmp_called_instance_1; | ||
| 240 | PyObject *tmp_type_name_1; | ||
| 241 | PyObject *tmp_mvar_value_1; | ||
| 242 | PyObject *tmp_object_name_1; | ||
| 243 | PyObject *tmp_call_result_1; | ||
| 244 | PyObject *tmp_args_element_name_1; | ||
| 245 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain_GError ); | ||
| 246 | |||
| 247 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 248 | { | ||
| 249 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_GError ); | ||
| 250 | } | ||
| 251 | |||
| 252 | if ( tmp_mvar_value_1 == NULL ) | ||
| 253 | { | ||
| 254 | |||
| 255 | exception_type = PyExc_NameError; | ||
| 256 | Py_INCREF( exception_type ); | ||
| 257 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "GError" ); | ||
| 258 | exception_tb = NULL; | ||
| 259 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 260 | CHAIN_EXCEPTION( exception_value ); | ||
| 261 | |||
| 262 | exception_lineno = 32; | ||
| 263 | type_description_1 = "ooooN"; | ||
| 264 | goto frame_exception_exit_1; | ||
| 265 | } | ||
| 266 | |||
| 267 | tmp_type_name_1 = tmp_mvar_value_1; | ||
| 268 | CHECK_OBJECT( par_self ); | ||
| 269 | tmp_object_name_1 = par_self; | ||
| 270 | tmp_called_instance_1 = BUILTIN_SUPER( tmp_type_name_1, tmp_object_name_1 ); | ||
| 271 | if ( tmp_called_instance_1 == NULL ) | ||
| 272 | { | ||
| 273 | assert( ERROR_OCCURRED() ); | ||
| 274 | |||
| 275 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 276 | |||
| 277 | |||
| 278 | exception_lineno = 32; | ||
| 279 | type_description_1 = "ooooN"; | ||
| 280 | goto frame_exception_exit_1; | ||
| 281 | } | ||
| 282 | CHECK_OBJECT( par_message ); | ||
| 283 | tmp_args_element_name_1 = par_message; | ||
| 284 | frame_cf0852ad4c7c0a4f24e105dd59eb5bb4->m_frame.f_lineno = 32; | ||
| 285 | { | ||
| 286 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 287 | tmp_call_result_1 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_1, const_str_plain___init__, call_args ); | ||
| 288 | } | ||
| 289 | |||
| 290 | Py_DECREF( tmp_called_instance_1 ); | ||
| 291 | if ( tmp_call_result_1 == NULL ) | ||
| 292 | { | ||
| 293 | assert( ERROR_OCCURRED() ); | ||
| 294 | |||
| 295 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 296 | |||
| 297 | |||
| 298 | exception_lineno = 32; | ||
| 299 | type_description_1 = "ooooN"; | ||
| 300 | goto frame_exception_exit_1; | ||
| 301 | } | ||
| 302 | Py_DECREF( tmp_call_result_1 ); | ||
| 303 | } | ||
| 304 | { | ||
| 305 | PyObject *tmp_assattr_name_1; | ||
| 306 | PyObject *tmp_assattr_target_1; | ||
| 307 | CHECK_OBJECT( par_message ); | ||
| 308 | tmp_assattr_name_1 = par_message; | ||
| 309 | CHECK_OBJECT( par_self ); | ||
| 310 | tmp_assattr_target_1 = par_self; | ||
| 311 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_message, tmp_assattr_name_1 ); | ||
| 312 | if ( tmp_result == false ) | ||
| 313 | { | ||
| 314 | assert( ERROR_OCCURRED() ); | ||
| 315 | |||
| 316 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 317 | |||
| 318 | |||
| 319 | exception_lineno = 33; | ||
| 320 | type_description_1 = "ooooN"; | ||
| 321 | goto frame_exception_exit_1; | ||
| 322 | } | ||
| 323 | } | ||
| 324 | { | ||
| 325 | PyObject *tmp_assattr_name_2; | ||
| 326 | PyObject *tmp_assattr_target_2; | ||
| 327 | CHECK_OBJECT( par_domain ); | ||
| 328 | tmp_assattr_name_2 = par_domain; | ||
| 329 | CHECK_OBJECT( par_self ); | ||
| 330 | tmp_assattr_target_2 = par_self; | ||
| 331 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_domain, tmp_assattr_name_2 ); | ||
| 332 | if ( tmp_result == false ) | ||
| 333 | { | ||
| 334 | assert( ERROR_OCCURRED() ); | ||
| 335 | |||
| 336 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 337 | |||
| 338 | |||
| 339 | exception_lineno = 34; | ||
| 340 | type_description_1 = "ooooN"; | ||
| 341 | goto frame_exception_exit_1; | ||
| 342 | } | ||
| 343 | } | ||
| 344 | { | ||
| 345 | PyObject *tmp_assattr_name_3; | ||
| 346 | PyObject *tmp_assattr_target_3; | ||
| 347 | CHECK_OBJECT( par_code ); | ||
| 348 | tmp_assattr_name_3 = par_code; | ||
| 349 | CHECK_OBJECT( par_self ); | ||
| 350 | tmp_assattr_target_3 = par_self; | ||
| 351 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_3, const_str_plain_code, tmp_assattr_name_3 ); | ||
| 352 | if ( tmp_result == false ) | ||
| 353 | { | ||
| 354 | assert( ERROR_OCCURRED() ); | ||
| 355 | |||
| 356 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 357 | |||
| 358 | |||
| 359 | exception_lineno = 35; | ||
| 360 | type_description_1 = "ooooN"; | ||
| 361 | goto frame_exception_exit_1; | ||
| 362 | } | ||
| 363 | } | ||
| 364 | |||
| 365 | #if 0 | ||
| 366 | RESTORE_FRAME_EXCEPTION( frame_cf0852ad4c7c0a4f24e105dd59eb5bb4 ); | ||
| 367 | #endif | ||
| 368 | |||
| 369 | // Put the previous frame back on top. | ||
| 370 | popFrameStack(); | ||
| 371 | |||
| 372 | goto frame_no_exception_1; | ||
| 373 | |||
| 374 | frame_exception_exit_1:; | ||
| 375 | |||
| 376 | #if 0 | ||
| 377 | RESTORE_FRAME_EXCEPTION( frame_cf0852ad4c7c0a4f24e105dd59eb5bb4 ); | ||
| 378 | #endif | ||
| 379 | |||
| 380 | if ( exception_tb == NULL ) | ||
| 381 | { | ||
| 382 | exception_tb = MAKE_TRACEBACK( frame_cf0852ad4c7c0a4f24e105dd59eb5bb4, exception_lineno ); | ||
| 383 | } | ||
| 384 | else if ( exception_tb->tb_frame != &frame_cf0852ad4c7c0a4f24e105dd59eb5bb4->m_frame ) | ||
| 385 | { | ||
| 386 | exception_tb = ADD_TRACEBACK( exception_tb, frame_cf0852ad4c7c0a4f24e105dd59eb5bb4, exception_lineno ); | ||
| 387 | } | ||
| 388 | |||
| 389 | // Attachs locals to frame if any. | ||
| 390 | Nuitka_Frame_AttachLocals( | ||
| 391 | (struct Nuitka_FrameObject *)frame_cf0852ad4c7c0a4f24e105dd59eb5bb4, | ||
| 392 | type_description_1, | ||
| 393 | par_self, | ||
| 394 | par_message, | ||
| 395 | par_domain, | ||
| 396 | par_code, | ||
| 397 | NULL | ||
| 398 | ); | ||
| 399 | |||
| 400 | |||
| 401 | // Release cached frame. | ||
| 402 | if ( frame_cf0852ad4c7c0a4f24e105dd59eb5bb4 == cache_frame_cf0852ad4c7c0a4f24e105dd59eb5bb4 ) | ||
| 403 | { | ||
| 404 | Py_DECREF( frame_cf0852ad4c7c0a4f24e105dd59eb5bb4 ); | ||
| 405 | } | ||
| 406 | cache_frame_cf0852ad4c7c0a4f24e105dd59eb5bb4 = NULL; | ||
| 407 | |||
| 408 | assertFrameObject( frame_cf0852ad4c7c0a4f24e105dd59eb5bb4 ); | ||
| 409 | |||
| 410 | // Put the previous frame back on top. | ||
| 411 | popFrameStack(); | ||
| 412 | |||
| 413 | // Return the error. | ||
| 414 | goto try_except_handler_1; | ||
| 415 | |||
| 416 | frame_no_exception_1:; | ||
| 417 | tmp_return_value = Py_None; | ||
| 418 | Py_INCREF( tmp_return_value ); | ||
| 419 | goto try_return_handler_1; | ||
| 420 | // tried codes exits in all cases | ||
| 421 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_1___init__ ); | ||
| 422 | return NULL; | ||
| 423 | // Return handler code: | ||
| 424 | try_return_handler_1:; | ||
| 425 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 426 | Py_DECREF( par_self ); | ||
| 427 | par_self = NULL; | ||
| 428 | |||
| 429 | CHECK_OBJECT( (PyObject *)par_message ); | ||
| 430 | Py_DECREF( par_message ); | ||
| 431 | par_message = NULL; | ||
| 432 | |||
| 433 | CHECK_OBJECT( (PyObject *)par_domain ); | ||
| 434 | Py_DECREF( par_domain ); | ||
| 435 | par_domain = NULL; | ||
| 436 | |||
| 437 | CHECK_OBJECT( (PyObject *)par_code ); | ||
| 438 | Py_DECREF( par_code ); | ||
| 439 | par_code = NULL; | ||
| 440 | |||
| 441 | goto function_return_exit; | ||
| 442 | // Exception handler code: | ||
| 443 | try_except_handler_1:; | ||
| 444 | exception_keeper_type_1 = exception_type; | ||
| 445 | exception_keeper_value_1 = exception_value; | ||
| 446 | exception_keeper_tb_1 = exception_tb; | ||
| 447 | exception_keeper_lineno_1 = exception_lineno; | ||
| 448 | exception_type = NULL; | ||
| 449 | exception_value = NULL; | ||
| 450 | exception_tb = NULL; | ||
| 451 | exception_lineno = 0; | ||
| 452 | |||
| 453 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 454 | Py_DECREF( par_self ); | ||
| 455 | par_self = NULL; | ||
| 456 | |||
| 457 | CHECK_OBJECT( (PyObject *)par_message ); | ||
| 458 | Py_DECREF( par_message ); | ||
| 459 | par_message = NULL; | ||
| 460 | |||
| 461 | CHECK_OBJECT( (PyObject *)par_domain ); | ||
| 462 | Py_DECREF( par_domain ); | ||
| 463 | par_domain = NULL; | ||
| 464 | |||
| 465 | CHECK_OBJECT( (PyObject *)par_code ); | ||
| 466 | Py_DECREF( par_code ); | ||
| 467 | par_code = NULL; | ||
| 468 | |||
| 469 | // Re-raise. | ||
| 470 | exception_type = exception_keeper_type_1; | ||
| 471 | exception_value = exception_keeper_value_1; | ||
| 472 | exception_tb = exception_keeper_tb_1; | ||
| 473 | exception_lineno = exception_keeper_lineno_1; | ||
| 474 | |||
| 475 | goto function_exception_exit; | ||
| 476 | // End of try: | ||
| 477 | |||
| 478 | // Return statement must have exited already. | ||
| 479 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_1___init__ ); | ||
| 480 | return NULL; | ||
| 481 | |||
| 482 | function_exception_exit: | ||
| 483 | assert( exception_type ); | ||
| 484 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 485 | |||
| 486 | return NULL; | ||
| 487 | |||
| 488 | function_return_exit: | ||
| 489 | // Function cleanup code if any. | ||
| 490 | |||
| 491 | |||
| 492 | // Actual function exit with return value, making sure we did not make | ||
| 493 | // the error status worse despite non-NULL return. | ||
| 494 | CHECK_OBJECT( tmp_return_value ); | ||
| 495 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 496 | return tmp_return_value; | ||
| 497 | } | ||
| 498 | |||
| 499 | |||
| 500 | static PyObject *impl_gi$_error$$$function_2___str__( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 501 | { | ||
| 502 | // Preserve error status for checks | ||
| 503 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 504 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 505 | #endif | ||
| 506 | |||
| 507 | // Local variable declarations. | ||
| 508 | PyObject *par_self = python_pars[ 0 ]; | ||
| 509 | struct Nuitka_FrameObject *frame_c275568401228a488599146a3b69044e; | ||
| 510 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 511 | PyObject *tmp_return_value = NULL; | ||
| 512 | PyObject *exception_type = NULL; | ||
| 513 | PyObject *exception_value = NULL; | ||
| 514 | PyTracebackObject *exception_tb = NULL; | ||
| 515 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 516 | static struct Nuitka_FrameObject *cache_frame_c275568401228a488599146a3b69044e = NULL; | ||
| 517 | PyObject *exception_keeper_type_1; | ||
| 518 | PyObject *exception_keeper_value_1; | ||
| 519 | PyTracebackObject *exception_keeper_tb_1; | ||
| 520 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 521 | |||
| 522 | // Actual function body. | ||
| 523 | // Tried code: | ||
| 524 | MAKE_OR_REUSE_FRAME( cache_frame_c275568401228a488599146a3b69044e, codeobj_c275568401228a488599146a3b69044e, module_gi$_error, sizeof(void *) ); | ||
| 525 | frame_c275568401228a488599146a3b69044e = cache_frame_c275568401228a488599146a3b69044e; | ||
| 526 | |||
| 527 | // Push the new frame as the currently active one. | ||
| 528 | pushFrameStack( frame_c275568401228a488599146a3b69044e ); | ||
| 529 | |||
| 530 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 531 | assert( Py_REFCNT( frame_c275568401228a488599146a3b69044e ) == 2 ); // Frame stack | ||
| 532 | |||
| 533 | // Framed code: | ||
| 534 | { | ||
| 535 | PyObject *tmp_left_name_1; | ||
| 536 | PyObject *tmp_right_name_1; | ||
| 537 | PyObject *tmp_tuple_element_1; | ||
| 538 | PyObject *tmp_source_name_1; | ||
| 539 | PyObject *tmp_source_name_2; | ||
| 540 | PyObject *tmp_source_name_3; | ||
| 541 | tmp_left_name_1 = const_str_digest_567b5a7dadb515a36a01e9d4d7d66ed5; | ||
| 542 | CHECK_OBJECT( par_self ); | ||
| 543 | tmp_source_name_1 = par_self; | ||
| 544 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_domain ); | ||
| 545 | if ( tmp_tuple_element_1 == NULL ) | ||
| 546 | { | ||
| 547 | assert( ERROR_OCCURRED() ); | ||
| 548 | |||
| 549 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 550 | |||
| 551 | |||
| 552 | exception_lineno = 38; | ||
| 553 | type_description_1 = "o"; | ||
| 554 | goto frame_exception_exit_1; | ||
| 555 | } | ||
| 556 | tmp_right_name_1 = PyTuple_New( 3 ); | ||
| 557 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_1 ); | ||
| 558 | CHECK_OBJECT( par_self ); | ||
| 559 | tmp_source_name_2 = par_self; | ||
| 560 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_message ); | ||
| 561 | if ( tmp_tuple_element_1 == NULL ) | ||
| 562 | { | ||
| 563 | assert( ERROR_OCCURRED() ); | ||
| 564 | |||
| 565 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 566 | Py_DECREF( tmp_right_name_1 ); | ||
| 567 | |||
| 568 | exception_lineno = 38; | ||
| 569 | type_description_1 = "o"; | ||
| 570 | goto frame_exception_exit_1; | ||
| 571 | } | ||
| 572 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_1 ); | ||
| 573 | CHECK_OBJECT( par_self ); | ||
| 574 | tmp_source_name_3 = par_self; | ||
| 575 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_code ); | ||
| 576 | if ( tmp_tuple_element_1 == NULL ) | ||
| 577 | { | ||
| 578 | assert( ERROR_OCCURRED() ); | ||
| 579 | |||
| 580 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 581 | Py_DECREF( tmp_right_name_1 ); | ||
| 582 | |||
| 583 | exception_lineno = 38; | ||
| 584 | type_description_1 = "o"; | ||
| 585 | goto frame_exception_exit_1; | ||
| 586 | } | ||
| 587 | PyTuple_SET_ITEM( tmp_right_name_1, 2, tmp_tuple_element_1 ); | ||
| 588 | tmp_return_value = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 589 | Py_DECREF( tmp_right_name_1 ); | ||
| 590 | if ( tmp_return_value == NULL ) | ||
| 591 | { | ||
| 592 | assert( ERROR_OCCURRED() ); | ||
| 593 | |||
| 594 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 595 | |||
| 596 | |||
| 597 | exception_lineno = 38; | ||
| 598 | type_description_1 = "o"; | ||
| 599 | goto frame_exception_exit_1; | ||
| 600 | } | ||
| 601 | goto frame_return_exit_1; | ||
| 602 | } | ||
| 603 | |||
| 604 | #if 0 | ||
| 605 | RESTORE_FRAME_EXCEPTION( frame_c275568401228a488599146a3b69044e ); | ||
| 606 | #endif | ||
| 607 | |||
| 608 | // Put the previous frame back on top. | ||
| 609 | popFrameStack(); | ||
| 610 | |||
| 611 | goto frame_no_exception_1; | ||
| 612 | |||
| 613 | frame_return_exit_1:; | ||
| 614 | #if 0 | ||
| 615 | RESTORE_FRAME_EXCEPTION( frame_c275568401228a488599146a3b69044e ); | ||
| 616 | #endif | ||
| 617 | |||
| 618 | // Put the previous frame back on top. | ||
| 619 | popFrameStack(); | ||
| 620 | |||
| 621 | goto try_return_handler_1; | ||
| 622 | |||
| 623 | frame_exception_exit_1:; | ||
| 624 | |||
| 625 | #if 0 | ||
| 626 | RESTORE_FRAME_EXCEPTION( frame_c275568401228a488599146a3b69044e ); | ||
| 627 | #endif | ||
| 628 | |||
| 629 | if ( exception_tb == NULL ) | ||
| 630 | { | ||
| 631 | exception_tb = MAKE_TRACEBACK( frame_c275568401228a488599146a3b69044e, exception_lineno ); | ||
| 632 | } | ||
| 633 | else if ( exception_tb->tb_frame != &frame_c275568401228a488599146a3b69044e->m_frame ) | ||
| 634 | { | ||
| 635 | exception_tb = ADD_TRACEBACK( exception_tb, frame_c275568401228a488599146a3b69044e, exception_lineno ); | ||
| 636 | } | ||
| 637 | |||
| 638 | // Attachs locals to frame if any. | ||
| 639 | Nuitka_Frame_AttachLocals( | ||
| 640 | (struct Nuitka_FrameObject *)frame_c275568401228a488599146a3b69044e, | ||
| 641 | type_description_1, | ||
| 642 | par_self | ||
| 643 | ); | ||
| 644 | |||
| 645 | |||
| 646 | // Release cached frame. | ||
| 647 | if ( frame_c275568401228a488599146a3b69044e == cache_frame_c275568401228a488599146a3b69044e ) | ||
| 648 | { | ||
| 649 | Py_DECREF( frame_c275568401228a488599146a3b69044e ); | ||
| 650 | } | ||
| 651 | cache_frame_c275568401228a488599146a3b69044e = NULL; | ||
| 652 | |||
| 653 | assertFrameObject( frame_c275568401228a488599146a3b69044e ); | ||
| 654 | |||
| 655 | // Put the previous frame back on top. | ||
| 656 | popFrameStack(); | ||
| 657 | |||
| 658 | // Return the error. | ||
| 659 | goto try_except_handler_1; | ||
| 660 | |||
| 661 | frame_no_exception_1:; | ||
| 662 | // tried codes exits in all cases | ||
| 663 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_2___str__ ); | ||
| 664 | return NULL; | ||
| 665 | // Return handler code: | ||
| 666 | try_return_handler_1:; | ||
| 667 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 668 | Py_DECREF( par_self ); | ||
| 669 | par_self = NULL; | ||
| 670 | |||
| 671 | goto function_return_exit; | ||
| 672 | // Exception handler code: | ||
| 673 | try_except_handler_1:; | ||
| 674 | exception_keeper_type_1 = exception_type; | ||
| 675 | exception_keeper_value_1 = exception_value; | ||
| 676 | exception_keeper_tb_1 = exception_tb; | ||
| 677 | exception_keeper_lineno_1 = exception_lineno; | ||
| 678 | exception_type = NULL; | ||
| 679 | exception_value = NULL; | ||
| 680 | exception_tb = NULL; | ||
| 681 | exception_lineno = 0; | ||
| 682 | |||
| 683 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 684 | Py_DECREF( par_self ); | ||
| 685 | par_self = NULL; | ||
| 686 | |||
| 687 | // Re-raise. | ||
| 688 | exception_type = exception_keeper_type_1; | ||
| 689 | exception_value = exception_keeper_value_1; | ||
| 690 | exception_tb = exception_keeper_tb_1; | ||
| 691 | exception_lineno = exception_keeper_lineno_1; | ||
| 692 | |||
| 693 | goto function_exception_exit; | ||
| 694 | // End of try: | ||
| 695 | |||
| 696 | // Return statement must have exited already. | ||
| 697 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_2___str__ ); | ||
| 698 | return NULL; | ||
| 699 | |||
| 700 | function_exception_exit: | ||
| 701 | assert( exception_type ); | ||
| 702 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 703 | |||
| 704 | return NULL; | ||
| 705 | |||
| 706 | function_return_exit: | ||
| 707 | // Function cleanup code if any. | ||
| 708 | |||
| 709 | |||
| 710 | // Actual function exit with return value, making sure we did not make | ||
| 711 | // the error status worse despite non-NULL return. | ||
| 712 | CHECK_OBJECT( tmp_return_value ); | ||
| 713 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 714 | return tmp_return_value; | ||
| 715 | } | ||
| 716 | |||
| 717 | |||
| 718 | static PyObject *impl_gi$_error$$$function_3___repr__( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 719 | { | ||
| 720 | // Preserve error status for checks | ||
| 721 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 722 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 723 | #endif | ||
| 724 | |||
| 725 | // Local variable declarations. | ||
| 726 | PyObject *par_self = python_pars[ 0 ]; | ||
| 727 | struct Nuitka_FrameObject *frame_c2ee6d133e87fb3a9c28fb092eeedd2d; | ||
| 728 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 729 | PyObject *tmp_return_value = NULL; | ||
| 730 | PyObject *exception_type = NULL; | ||
| 731 | PyObject *exception_value = NULL; | ||
| 732 | PyTracebackObject *exception_tb = NULL; | ||
| 733 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 734 | static struct Nuitka_FrameObject *cache_frame_c2ee6d133e87fb3a9c28fb092eeedd2d = NULL; | ||
| 735 | PyObject *exception_keeper_type_1; | ||
| 736 | PyObject *exception_keeper_value_1; | ||
| 737 | PyTracebackObject *exception_keeper_tb_1; | ||
| 738 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 739 | |||
| 740 | // Actual function body. | ||
| 741 | // Tried code: | ||
| 742 | MAKE_OR_REUSE_FRAME( cache_frame_c2ee6d133e87fb3a9c28fb092eeedd2d, codeobj_c2ee6d133e87fb3a9c28fb092eeedd2d, module_gi$_error, sizeof(void *) ); | ||
| 743 | frame_c2ee6d133e87fb3a9c28fb092eeedd2d = cache_frame_c2ee6d133e87fb3a9c28fb092eeedd2d; | ||
| 744 | |||
| 745 | // Push the new frame as the currently active one. | ||
| 746 | pushFrameStack( frame_c2ee6d133e87fb3a9c28fb092eeedd2d ); | ||
| 747 | |||
| 748 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 749 | assert( Py_REFCNT( frame_c2ee6d133e87fb3a9c28fb092eeedd2d ) == 2 ); // Frame stack | ||
| 750 | |||
| 751 | // Framed code: | ||
| 752 | { | ||
| 753 | PyObject *tmp_left_name_1; | ||
| 754 | PyObject *tmp_right_name_1; | ||
| 755 | PyObject *tmp_tuple_element_1; | ||
| 756 | PyObject *tmp_subscribed_name_1; | ||
| 757 | PyObject *tmp_called_instance_1; | ||
| 758 | PyObject *tmp_source_name_1; | ||
| 759 | PyObject *tmp_mvar_value_1; | ||
| 760 | PyObject *tmp_subscript_name_1; | ||
| 761 | PyObject *tmp_source_name_2; | ||
| 762 | PyObject *tmp_mvar_value_2; | ||
| 763 | PyObject *tmp_source_name_3; | ||
| 764 | PyObject *tmp_source_name_4; | ||
| 765 | PyObject *tmp_source_name_5; | ||
| 766 | tmp_left_name_1 = const_str_digest_75d07a2f87de39f67083eb2d499c83ad; | ||
| 767 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain_GError ); | ||
| 768 | |||
| 769 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 770 | { | ||
| 771 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_GError ); | ||
| 772 | } | ||
| 773 | |||
| 774 | if ( tmp_mvar_value_1 == NULL ) | ||
| 775 | { | ||
| 776 | |||
| 777 | exception_type = PyExc_NameError; | ||
| 778 | Py_INCREF( exception_type ); | ||
| 779 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "GError" ); | ||
| 780 | exception_tb = NULL; | ||
| 781 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 782 | CHAIN_EXCEPTION( exception_value ); | ||
| 783 | |||
| 784 | exception_lineno = 42; | ||
| 785 | type_description_1 = "o"; | ||
| 786 | goto frame_exception_exit_1; | ||
| 787 | } | ||
| 788 | |||
| 789 | tmp_source_name_1 = tmp_mvar_value_1; | ||
| 790 | tmp_called_instance_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain___module__ ); | ||
| 791 | if ( tmp_called_instance_1 == NULL ) | ||
| 792 | { | ||
| 793 | assert( ERROR_OCCURRED() ); | ||
| 794 | |||
| 795 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 796 | |||
| 797 | |||
| 798 | exception_lineno = 42; | ||
| 799 | type_description_1 = "o"; | ||
| 800 | goto frame_exception_exit_1; | ||
| 801 | } | ||
| 802 | frame_c2ee6d133e87fb3a9c28fb092eeedd2d->m_frame.f_lineno = 42; | ||
| 803 | tmp_subscribed_name_1 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_1, const_str_plain_rsplit, &PyTuple_GET_ITEM( const_tuple_str_dot_int_pos_1_tuple, 0 ) ); | ||
| 804 | |||
| 805 | Py_DECREF( tmp_called_instance_1 ); | ||
| 806 | if ( tmp_subscribed_name_1 == NULL ) | ||
| 807 | { | ||
| 808 | assert( ERROR_OCCURRED() ); | ||
| 809 | |||
| 810 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 811 | |||
| 812 | |||
| 813 | exception_lineno = 42; | ||
| 814 | type_description_1 = "o"; | ||
| 815 | goto frame_exception_exit_1; | ||
| 816 | } | ||
| 817 | tmp_subscript_name_1 = const_int_neg_1; | ||
| 818 | tmp_tuple_element_1 = LOOKUP_SUBSCRIPT_CONST( tmp_subscribed_name_1, tmp_subscript_name_1, -1 ); | ||
| 819 | Py_DECREF( tmp_subscribed_name_1 ); | ||
| 820 | if ( tmp_tuple_element_1 == NULL ) | ||
| 821 | { | ||
| 822 | assert( ERROR_OCCURRED() ); | ||
| 823 | |||
| 824 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 825 | |||
| 826 | |||
| 827 | exception_lineno = 42; | ||
| 828 | type_description_1 = "o"; | ||
| 829 | goto frame_exception_exit_1; | ||
| 830 | } | ||
| 831 | tmp_right_name_1 = PyTuple_New( 5 ); | ||
| 832 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_1 ); | ||
| 833 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain_GError ); | ||
| 834 | |||
| 835 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 836 | { | ||
| 837 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_GError ); | ||
| 838 | } | ||
| 839 | |||
| 840 | if ( tmp_mvar_value_2 == NULL ) | ||
| 841 | { | ||
| 842 | Py_DECREF( tmp_right_name_1 ); | ||
| 843 | exception_type = PyExc_NameError; | ||
| 844 | Py_INCREF( exception_type ); | ||
| 845 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "GError" ); | ||
| 846 | exception_tb = NULL; | ||
| 847 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 848 | CHAIN_EXCEPTION( exception_value ); | ||
| 849 | |||
| 850 | exception_lineno = 42; | ||
| 851 | type_description_1 = "o"; | ||
| 852 | goto frame_exception_exit_1; | ||
| 853 | } | ||
| 854 | |||
| 855 | tmp_source_name_2 = tmp_mvar_value_2; | ||
| 856 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain___name__ ); | ||
| 857 | if ( tmp_tuple_element_1 == NULL ) | ||
| 858 | { | ||
| 859 | assert( ERROR_OCCURRED() ); | ||
| 860 | |||
| 861 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 862 | Py_DECREF( tmp_right_name_1 ); | ||
| 863 | |||
| 864 | exception_lineno = 42; | ||
| 865 | type_description_1 = "o"; | ||
| 866 | goto frame_exception_exit_1; | ||
| 867 | } | ||
| 868 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_1 ); | ||
| 869 | CHECK_OBJECT( par_self ); | ||
| 870 | tmp_source_name_3 = par_self; | ||
| 871 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_message ); | ||
| 872 | if ( tmp_tuple_element_1 == NULL ) | ||
| 873 | { | ||
| 874 | assert( ERROR_OCCURRED() ); | ||
| 875 | |||
| 876 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 877 | Py_DECREF( tmp_right_name_1 ); | ||
| 878 | |||
| 879 | exception_lineno = 43; | ||
| 880 | type_description_1 = "o"; | ||
| 881 | goto frame_exception_exit_1; | ||
| 882 | } | ||
| 883 | PyTuple_SET_ITEM( tmp_right_name_1, 2, tmp_tuple_element_1 ); | ||
| 884 | CHECK_OBJECT( par_self ); | ||
| 885 | tmp_source_name_4 = par_self; | ||
| 886 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain_domain ); | ||
| 887 | if ( tmp_tuple_element_1 == NULL ) | ||
| 888 | { | ||
| 889 | assert( ERROR_OCCURRED() ); | ||
| 890 | |||
| 891 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 892 | Py_DECREF( tmp_right_name_1 ); | ||
| 893 | |||
| 894 | exception_lineno = 43; | ||
| 895 | type_description_1 = "o"; | ||
| 896 | goto frame_exception_exit_1; | ||
| 897 | } | ||
| 898 | PyTuple_SET_ITEM( tmp_right_name_1, 3, tmp_tuple_element_1 ); | ||
| 899 | CHECK_OBJECT( par_self ); | ||
| 900 | tmp_source_name_5 = par_self; | ||
| 901 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE( tmp_source_name_5, const_str_plain_code ); | ||
| 902 | if ( tmp_tuple_element_1 == NULL ) | ||
| 903 | { | ||
| 904 | assert( ERROR_OCCURRED() ); | ||
| 905 | |||
| 906 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 907 | Py_DECREF( tmp_right_name_1 ); | ||
| 908 | |||
| 909 | exception_lineno = 43; | ||
| 910 | type_description_1 = "o"; | ||
| 911 | goto frame_exception_exit_1; | ||
| 912 | } | ||
| 913 | PyTuple_SET_ITEM( tmp_right_name_1, 4, tmp_tuple_element_1 ); | ||
| 914 | tmp_return_value = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 915 | Py_DECREF( tmp_right_name_1 ); | ||
| 916 | if ( tmp_return_value == NULL ) | ||
| 917 | { | ||
| 918 | assert( ERROR_OCCURRED() ); | ||
| 919 | |||
| 920 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 921 | |||
| 922 | |||
| 923 | exception_lineno = 41; | ||
| 924 | type_description_1 = "o"; | ||
| 925 | goto frame_exception_exit_1; | ||
| 926 | } | ||
| 927 | goto frame_return_exit_1; | ||
| 928 | } | ||
| 929 | |||
| 930 | #if 0 | ||
| 931 | RESTORE_FRAME_EXCEPTION( frame_c2ee6d133e87fb3a9c28fb092eeedd2d ); | ||
| 932 | #endif | ||
| 933 | |||
| 934 | // Put the previous frame back on top. | ||
| 935 | popFrameStack(); | ||
| 936 | |||
| 937 | goto frame_no_exception_1; | ||
| 938 | |||
| 939 | frame_return_exit_1:; | ||
| 940 | #if 0 | ||
| 941 | RESTORE_FRAME_EXCEPTION( frame_c2ee6d133e87fb3a9c28fb092eeedd2d ); | ||
| 942 | #endif | ||
| 943 | |||
| 944 | // Put the previous frame back on top. | ||
| 945 | popFrameStack(); | ||
| 946 | |||
| 947 | goto try_return_handler_1; | ||
| 948 | |||
| 949 | frame_exception_exit_1:; | ||
| 950 | |||
| 951 | #if 0 | ||
| 952 | RESTORE_FRAME_EXCEPTION( frame_c2ee6d133e87fb3a9c28fb092eeedd2d ); | ||
| 953 | #endif | ||
| 954 | |||
| 955 | if ( exception_tb == NULL ) | ||
| 956 | { | ||
| 957 | exception_tb = MAKE_TRACEBACK( frame_c2ee6d133e87fb3a9c28fb092eeedd2d, exception_lineno ); | ||
| 958 | } | ||
| 959 | else if ( exception_tb->tb_frame != &frame_c2ee6d133e87fb3a9c28fb092eeedd2d->m_frame ) | ||
| 960 | { | ||
| 961 | exception_tb = ADD_TRACEBACK( exception_tb, frame_c2ee6d133e87fb3a9c28fb092eeedd2d, exception_lineno ); | ||
| 962 | } | ||
| 963 | |||
| 964 | // Attachs locals to frame if any. | ||
| 965 | Nuitka_Frame_AttachLocals( | ||
| 966 | (struct Nuitka_FrameObject *)frame_c2ee6d133e87fb3a9c28fb092eeedd2d, | ||
| 967 | type_description_1, | ||
| 968 | par_self | ||
| 969 | ); | ||
| 970 | |||
| 971 | |||
| 972 | // Release cached frame. | ||
| 973 | if ( frame_c2ee6d133e87fb3a9c28fb092eeedd2d == cache_frame_c2ee6d133e87fb3a9c28fb092eeedd2d ) | ||
| 974 | { | ||
| 975 | Py_DECREF( frame_c2ee6d133e87fb3a9c28fb092eeedd2d ); | ||
| 976 | } | ||
| 977 | cache_frame_c2ee6d133e87fb3a9c28fb092eeedd2d = NULL; | ||
| 978 | |||
| 979 | assertFrameObject( frame_c2ee6d133e87fb3a9c28fb092eeedd2d ); | ||
| 980 | |||
| 981 | // Put the previous frame back on top. | ||
| 982 | popFrameStack(); | ||
| 983 | |||
| 984 | // Return the error. | ||
| 985 | goto try_except_handler_1; | ||
| 986 | |||
| 987 | frame_no_exception_1:; | ||
| 988 | // tried codes exits in all cases | ||
| 989 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_3___repr__ ); | ||
| 990 | return NULL; | ||
| 991 | // Return handler code: | ||
| 992 | try_return_handler_1:; | ||
| 993 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 994 | Py_DECREF( par_self ); | ||
| 995 | par_self = NULL; | ||
| 996 | |||
| 997 | goto function_return_exit; | ||
| 998 | // Exception handler code: | ||
| 999 | try_except_handler_1:; | ||
| 1000 | exception_keeper_type_1 = exception_type; | ||
| 1001 | exception_keeper_value_1 = exception_value; | ||
| 1002 | exception_keeper_tb_1 = exception_tb; | ||
| 1003 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1004 | exception_type = NULL; | ||
| 1005 | exception_value = NULL; | ||
| 1006 | exception_tb = NULL; | ||
| 1007 | exception_lineno = 0; | ||
| 1008 | |||
| 1009 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1010 | Py_DECREF( par_self ); | ||
| 1011 | par_self = NULL; | ||
| 1012 | |||
| 1013 | // Re-raise. | ||
| 1014 | exception_type = exception_keeper_type_1; | ||
| 1015 | exception_value = exception_keeper_value_1; | ||
| 1016 | exception_tb = exception_keeper_tb_1; | ||
| 1017 | exception_lineno = exception_keeper_lineno_1; | ||
| 1018 | |||
| 1019 | goto function_exception_exit; | ||
| 1020 | // End of try: | ||
| 1021 | |||
| 1022 | // Return statement must have exited already. | ||
| 1023 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_3___repr__ ); | ||
| 1024 | return NULL; | ||
| 1025 | |||
| 1026 | function_exception_exit: | ||
| 1027 | assert( exception_type ); | ||
| 1028 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1029 | |||
| 1030 | return NULL; | ||
| 1031 | |||
| 1032 | function_return_exit: | ||
| 1033 | // Function cleanup code if any. | ||
| 1034 | |||
| 1035 | |||
| 1036 | // Actual function exit with return value, making sure we did not make | ||
| 1037 | // the error status worse despite non-NULL return. | ||
| 1038 | CHECK_OBJECT( tmp_return_value ); | ||
| 1039 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 1040 | return tmp_return_value; | ||
| 1041 | } | ||
| 1042 | |||
| 1043 | |||
| 1044 | static PyObject *impl_gi$_error$$$function_4_copy( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 1045 | { | ||
| 1046 | // Preserve error status for checks | ||
| 1047 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1048 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 1049 | #endif | ||
| 1050 | |||
| 1051 | // Local variable declarations. | ||
| 1052 | PyObject *par_self = python_pars[ 0 ]; | ||
| 1053 | struct Nuitka_FrameObject *frame_305f11e425fc81aa725ee337171b21c9; | ||
| 1054 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 1055 | PyObject *tmp_return_value = NULL; | ||
| 1056 | PyObject *exception_type = NULL; | ||
| 1057 | PyObject *exception_value = NULL; | ||
| 1058 | PyTracebackObject *exception_tb = NULL; | ||
| 1059 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 1060 | static struct Nuitka_FrameObject *cache_frame_305f11e425fc81aa725ee337171b21c9 = NULL; | ||
| 1061 | PyObject *exception_keeper_type_1; | ||
| 1062 | PyObject *exception_keeper_value_1; | ||
| 1063 | PyTracebackObject *exception_keeper_tb_1; | ||
| 1064 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 1065 | |||
| 1066 | // Actual function body. | ||
| 1067 | // Tried code: | ||
| 1068 | MAKE_OR_REUSE_FRAME( cache_frame_305f11e425fc81aa725ee337171b21c9, codeobj_305f11e425fc81aa725ee337171b21c9, module_gi$_error, sizeof(void *) ); | ||
| 1069 | frame_305f11e425fc81aa725ee337171b21c9 = cache_frame_305f11e425fc81aa725ee337171b21c9; | ||
| 1070 | |||
| 1071 | // Push the new frame as the currently active one. | ||
| 1072 | pushFrameStack( frame_305f11e425fc81aa725ee337171b21c9 ); | ||
| 1073 | |||
| 1074 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 1075 | assert( Py_REFCNT( frame_305f11e425fc81aa725ee337171b21c9 ) == 2 ); // Frame stack | ||
| 1076 | |||
| 1077 | // Framed code: | ||
| 1078 | { | ||
| 1079 | PyObject *tmp_called_name_1; | ||
| 1080 | PyObject *tmp_mvar_value_1; | ||
| 1081 | PyObject *tmp_args_element_name_1; | ||
| 1082 | PyObject *tmp_source_name_1; | ||
| 1083 | PyObject *tmp_args_element_name_2; | ||
| 1084 | PyObject *tmp_source_name_2; | ||
| 1085 | PyObject *tmp_args_element_name_3; | ||
| 1086 | PyObject *tmp_source_name_3; | ||
| 1087 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain_GError ); | ||
| 1088 | |||
| 1089 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 1090 | { | ||
| 1091 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_GError ); | ||
| 1092 | } | ||
| 1093 | |||
| 1094 | if ( tmp_mvar_value_1 == NULL ) | ||
| 1095 | { | ||
| 1096 | |||
| 1097 | exception_type = PyExc_NameError; | ||
| 1098 | Py_INCREF( exception_type ); | ||
| 1099 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "GError" ); | ||
| 1100 | exception_tb = NULL; | ||
| 1101 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1102 | CHAIN_EXCEPTION( exception_value ); | ||
| 1103 | |||
| 1104 | exception_lineno = 46; | ||
| 1105 | type_description_1 = "o"; | ||
| 1106 | goto frame_exception_exit_1; | ||
| 1107 | } | ||
| 1108 | |||
| 1109 | tmp_called_name_1 = tmp_mvar_value_1; | ||
| 1110 | CHECK_OBJECT( par_self ); | ||
| 1111 | tmp_source_name_1 = par_self; | ||
| 1112 | tmp_args_element_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_message ); | ||
| 1113 | if ( tmp_args_element_name_1 == NULL ) | ||
| 1114 | { | ||
| 1115 | assert( ERROR_OCCURRED() ); | ||
| 1116 | |||
| 1117 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1118 | |||
| 1119 | |||
| 1120 | exception_lineno = 46; | ||
| 1121 | type_description_1 = "o"; | ||
| 1122 | goto frame_exception_exit_1; | ||
| 1123 | } | ||
| 1124 | CHECK_OBJECT( par_self ); | ||
| 1125 | tmp_source_name_2 = par_self; | ||
| 1126 | tmp_args_element_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_domain ); | ||
| 1127 | if ( tmp_args_element_name_2 == NULL ) | ||
| 1128 | { | ||
| 1129 | assert( ERROR_OCCURRED() ); | ||
| 1130 | |||
| 1131 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1132 | Py_DECREF( tmp_args_element_name_1 ); | ||
| 1133 | |||
| 1134 | exception_lineno = 46; | ||
| 1135 | type_description_1 = "o"; | ||
| 1136 | goto frame_exception_exit_1; | ||
| 1137 | } | ||
| 1138 | CHECK_OBJECT( par_self ); | ||
| 1139 | tmp_source_name_3 = par_self; | ||
| 1140 | tmp_args_element_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_code ); | ||
| 1141 | if ( tmp_args_element_name_3 == NULL ) | ||
| 1142 | { | ||
| 1143 | assert( ERROR_OCCURRED() ); | ||
| 1144 | |||
| 1145 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1146 | Py_DECREF( tmp_args_element_name_1 ); | ||
| 1147 | Py_DECREF( tmp_args_element_name_2 ); | ||
| 1148 | |||
| 1149 | exception_lineno = 46; | ||
| 1150 | type_description_1 = "o"; | ||
| 1151 | goto frame_exception_exit_1; | ||
| 1152 | } | ||
| 1153 | frame_305f11e425fc81aa725ee337171b21c9->m_frame.f_lineno = 46; | ||
| 1154 | { | ||
| 1155 | PyObject *call_args[] = { tmp_args_element_name_1, tmp_args_element_name_2, tmp_args_element_name_3 }; | ||
| 1156 | tmp_return_value = CALL_FUNCTION_WITH_ARGS3( tmp_called_name_1, call_args ); | ||
| 1157 | } | ||
| 1158 | |||
| 1159 | Py_DECREF( tmp_args_element_name_1 ); | ||
| 1160 | Py_DECREF( tmp_args_element_name_2 ); | ||
| 1161 | Py_DECREF( tmp_args_element_name_3 ); | ||
| 1162 | if ( tmp_return_value == NULL ) | ||
| 1163 | { | ||
| 1164 | assert( ERROR_OCCURRED() ); | ||
| 1165 | |||
| 1166 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1167 | |||
| 1168 | |||
| 1169 | exception_lineno = 46; | ||
| 1170 | type_description_1 = "o"; | ||
| 1171 | goto frame_exception_exit_1; | ||
| 1172 | } | ||
| 1173 | goto frame_return_exit_1; | ||
| 1174 | } | ||
| 1175 | |||
| 1176 | #if 0 | ||
| 1177 | RESTORE_FRAME_EXCEPTION( frame_305f11e425fc81aa725ee337171b21c9 ); | ||
| 1178 | #endif | ||
| 1179 | |||
| 1180 | // Put the previous frame back on top. | ||
| 1181 | popFrameStack(); | ||
| 1182 | |||
| 1183 | goto frame_no_exception_1; | ||
| 1184 | |||
| 1185 | frame_return_exit_1:; | ||
| 1186 | #if 0 | ||
| 1187 | RESTORE_FRAME_EXCEPTION( frame_305f11e425fc81aa725ee337171b21c9 ); | ||
| 1188 | #endif | ||
| 1189 | |||
| 1190 | // Put the previous frame back on top. | ||
| 1191 | popFrameStack(); | ||
| 1192 | |||
| 1193 | goto try_return_handler_1; | ||
| 1194 | |||
| 1195 | frame_exception_exit_1:; | ||
| 1196 | |||
| 1197 | #if 0 | ||
| 1198 | RESTORE_FRAME_EXCEPTION( frame_305f11e425fc81aa725ee337171b21c9 ); | ||
| 1199 | #endif | ||
| 1200 | |||
| 1201 | if ( exception_tb == NULL ) | ||
| 1202 | { | ||
| 1203 | exception_tb = MAKE_TRACEBACK( frame_305f11e425fc81aa725ee337171b21c9, exception_lineno ); | ||
| 1204 | } | ||
| 1205 | else if ( exception_tb->tb_frame != &frame_305f11e425fc81aa725ee337171b21c9->m_frame ) | ||
| 1206 | { | ||
| 1207 | exception_tb = ADD_TRACEBACK( exception_tb, frame_305f11e425fc81aa725ee337171b21c9, exception_lineno ); | ||
| 1208 | } | ||
| 1209 | |||
| 1210 | // Attachs locals to frame if any. | ||
| 1211 | Nuitka_Frame_AttachLocals( | ||
| 1212 | (struct Nuitka_FrameObject *)frame_305f11e425fc81aa725ee337171b21c9, | ||
| 1213 | type_description_1, | ||
| 1214 | par_self | ||
| 1215 | ); | ||
| 1216 | |||
| 1217 | |||
| 1218 | // Release cached frame. | ||
| 1219 | if ( frame_305f11e425fc81aa725ee337171b21c9 == cache_frame_305f11e425fc81aa725ee337171b21c9 ) | ||
| 1220 | { | ||
| 1221 | Py_DECREF( frame_305f11e425fc81aa725ee337171b21c9 ); | ||
| 1222 | } | ||
| 1223 | cache_frame_305f11e425fc81aa725ee337171b21c9 = NULL; | ||
| 1224 | |||
| 1225 | assertFrameObject( frame_305f11e425fc81aa725ee337171b21c9 ); | ||
| 1226 | |||
| 1227 | // Put the previous frame back on top. | ||
| 1228 | popFrameStack(); | ||
| 1229 | |||
| 1230 | // Return the error. | ||
| 1231 | goto try_except_handler_1; | ||
| 1232 | |||
| 1233 | frame_no_exception_1:; | ||
| 1234 | // tried codes exits in all cases | ||
| 1235 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_4_copy ); | ||
| 1236 | return NULL; | ||
| 1237 | // Return handler code: | ||
| 1238 | try_return_handler_1:; | ||
| 1239 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1240 | Py_DECREF( par_self ); | ||
| 1241 | par_self = NULL; | ||
| 1242 | |||
| 1243 | goto function_return_exit; | ||
| 1244 | // Exception handler code: | ||
| 1245 | try_except_handler_1:; | ||
| 1246 | exception_keeper_type_1 = exception_type; | ||
| 1247 | exception_keeper_value_1 = exception_value; | ||
| 1248 | exception_keeper_tb_1 = exception_tb; | ||
| 1249 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1250 | exception_type = NULL; | ||
| 1251 | exception_value = NULL; | ||
| 1252 | exception_tb = NULL; | ||
| 1253 | exception_lineno = 0; | ||
| 1254 | |||
| 1255 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1256 | Py_DECREF( par_self ); | ||
| 1257 | par_self = NULL; | ||
| 1258 | |||
| 1259 | // Re-raise. | ||
| 1260 | exception_type = exception_keeper_type_1; | ||
| 1261 | exception_value = exception_keeper_value_1; | ||
| 1262 | exception_tb = exception_keeper_tb_1; | ||
| 1263 | exception_lineno = exception_keeper_lineno_1; | ||
| 1264 | |||
| 1265 | goto function_exception_exit; | ||
| 1266 | // End of try: | ||
| 1267 | |||
| 1268 | // Return statement must have exited already. | ||
| 1269 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_4_copy ); | ||
| 1270 | return NULL; | ||
| 1271 | |||
| 1272 | function_exception_exit: | ||
| 1273 | assert( exception_type ); | ||
| 1274 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1275 | |||
| 1276 | return NULL; | ||
| 1277 | |||
| 1278 | function_return_exit: | ||
| 1279 | // Function cleanup code if any. | ||
| 1280 | |||
| 1281 | |||
| 1282 | // Actual function exit with return value, making sure we did not make | ||
| 1283 | // the error status worse despite non-NULL return. | ||
| 1284 | CHECK_OBJECT( tmp_return_value ); | ||
| 1285 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 1286 | return tmp_return_value; | ||
| 1287 | } | ||
| 1288 | |||
| 1289 | |||
| 1290 | static PyObject *impl_gi$_error$$$function_5_matches( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 1291 | { | ||
| 1292 | // Preserve error status for checks | ||
| 1293 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1294 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 1295 | #endif | ||
| 1296 | |||
| 1297 | // Local variable declarations. | ||
| 1298 | PyObject *par_self = python_pars[ 0 ]; | ||
| 1299 | PyObject *par_domain = python_pars[ 1 ]; | ||
| 1300 | PyObject *par_code = python_pars[ 2 ]; | ||
| 1301 | struct Nuitka_FrameObject *frame_d5da4e4df6d7c426ebe86d0ed7048621; | ||
| 1302 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 1303 | PyObject *exception_type = NULL; | ||
| 1304 | PyObject *exception_value = NULL; | ||
| 1305 | PyTracebackObject *exception_tb = NULL; | ||
| 1306 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 1307 | static struct Nuitka_FrameObject *cache_frame_d5da4e4df6d7c426ebe86d0ed7048621 = NULL; | ||
| 1308 | PyObject *exception_keeper_type_1; | ||
| 1309 | PyObject *exception_keeper_value_1; | ||
| 1310 | PyTracebackObject *exception_keeper_tb_1; | ||
| 1311 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 1312 | |||
| 1313 | // Actual function body. | ||
| 1314 | // Tried code: | ||
| 1315 | MAKE_OR_REUSE_FRAME( cache_frame_d5da4e4df6d7c426ebe86d0ed7048621, codeobj_d5da4e4df6d7c426ebe86d0ed7048621, module_gi$_error, sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 1316 | frame_d5da4e4df6d7c426ebe86d0ed7048621 = cache_frame_d5da4e4df6d7c426ebe86d0ed7048621; | ||
| 1317 | |||
| 1318 | // Push the new frame as the currently active one. | ||
| 1319 | pushFrameStack( frame_d5da4e4df6d7c426ebe86d0ed7048621 ); | ||
| 1320 | |||
| 1321 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 1322 | assert( Py_REFCNT( frame_d5da4e4df6d7c426ebe86d0ed7048621 ) == 2 ); // Frame stack | ||
| 1323 | |||
| 1324 | // Framed code: | ||
| 1325 | { | ||
| 1326 | PyObject *tmp_raise_type_1; | ||
| 1327 | tmp_raise_type_1 = PyExc_NotImplementedError; | ||
| 1328 | exception_type = tmp_raise_type_1; | ||
| 1329 | Py_INCREF( tmp_raise_type_1 ); | ||
| 1330 | exception_lineno = 50; | ||
| 1331 | RAISE_EXCEPTION_WITH_TYPE( &exception_type, &exception_value, &exception_tb ); | ||
| 1332 | type_description_1 = "ooo"; | ||
| 1333 | goto frame_exception_exit_1; | ||
| 1334 | } | ||
| 1335 | |||
| 1336 | #if 0 | ||
| 1337 | RESTORE_FRAME_EXCEPTION( frame_d5da4e4df6d7c426ebe86d0ed7048621 ); | ||
| 1338 | #endif | ||
| 1339 | |||
| 1340 | // Put the previous frame back on top. | ||
| 1341 | popFrameStack(); | ||
| 1342 | |||
| 1343 | goto frame_no_exception_1; | ||
| 1344 | |||
| 1345 | frame_exception_exit_1:; | ||
| 1346 | |||
| 1347 | #if 0 | ||
| 1348 | RESTORE_FRAME_EXCEPTION( frame_d5da4e4df6d7c426ebe86d0ed7048621 ); | ||
| 1349 | #endif | ||
| 1350 | |||
| 1351 | if ( exception_tb == NULL ) | ||
| 1352 | { | ||
| 1353 | exception_tb = MAKE_TRACEBACK( frame_d5da4e4df6d7c426ebe86d0ed7048621, exception_lineno ); | ||
| 1354 | } | ||
| 1355 | else if ( exception_tb->tb_frame != &frame_d5da4e4df6d7c426ebe86d0ed7048621->m_frame ) | ||
| 1356 | { | ||
| 1357 | exception_tb = ADD_TRACEBACK( exception_tb, frame_d5da4e4df6d7c426ebe86d0ed7048621, exception_lineno ); | ||
| 1358 | } | ||
| 1359 | |||
| 1360 | // Attachs locals to frame if any. | ||
| 1361 | Nuitka_Frame_AttachLocals( | ||
| 1362 | (struct Nuitka_FrameObject *)frame_d5da4e4df6d7c426ebe86d0ed7048621, | ||
| 1363 | type_description_1, | ||
| 1364 | par_self, | ||
| 1365 | par_domain, | ||
| 1366 | par_code | ||
| 1367 | ); | ||
| 1368 | |||
| 1369 | |||
| 1370 | // Release cached frame. | ||
| 1371 | if ( frame_d5da4e4df6d7c426ebe86d0ed7048621 == cache_frame_d5da4e4df6d7c426ebe86d0ed7048621 ) | ||
| 1372 | { | ||
| 1373 | Py_DECREF( frame_d5da4e4df6d7c426ebe86d0ed7048621 ); | ||
| 1374 | } | ||
| 1375 | cache_frame_d5da4e4df6d7c426ebe86d0ed7048621 = NULL; | ||
| 1376 | |||
| 1377 | assertFrameObject( frame_d5da4e4df6d7c426ebe86d0ed7048621 ); | ||
| 1378 | |||
| 1379 | // Put the previous frame back on top. | ||
| 1380 | popFrameStack(); | ||
| 1381 | |||
| 1382 | // Return the error. | ||
| 1383 | goto try_except_handler_1; | ||
| 1384 | |||
| 1385 | frame_no_exception_1:; | ||
| 1386 | // tried codes exits in all cases | ||
| 1387 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_5_matches ); | ||
| 1388 | return NULL; | ||
| 1389 | // Exception handler code: | ||
| 1390 | try_except_handler_1:; | ||
| 1391 | exception_keeper_type_1 = exception_type; | ||
| 1392 | exception_keeper_value_1 = exception_value; | ||
| 1393 | exception_keeper_tb_1 = exception_tb; | ||
| 1394 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1395 | exception_type = NULL; | ||
| 1396 | exception_value = NULL; | ||
| 1397 | exception_tb = NULL; | ||
| 1398 | exception_lineno = 0; | ||
| 1399 | |||
| 1400 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1401 | Py_DECREF( par_self ); | ||
| 1402 | par_self = NULL; | ||
| 1403 | |||
| 1404 | CHECK_OBJECT( (PyObject *)par_domain ); | ||
| 1405 | Py_DECREF( par_domain ); | ||
| 1406 | par_domain = NULL; | ||
| 1407 | |||
| 1408 | CHECK_OBJECT( (PyObject *)par_code ); | ||
| 1409 | Py_DECREF( par_code ); | ||
| 1410 | par_code = NULL; | ||
| 1411 | |||
| 1412 | // Re-raise. | ||
| 1413 | exception_type = exception_keeper_type_1; | ||
| 1414 | exception_value = exception_keeper_value_1; | ||
| 1415 | exception_tb = exception_keeper_tb_1; | ||
| 1416 | exception_lineno = exception_keeper_lineno_1; | ||
| 1417 | |||
| 1418 | goto function_exception_exit; | ||
| 1419 | // End of try: | ||
| 1420 | |||
| 1421 | // Return statement must have exited already. | ||
| 1422 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_5_matches ); | ||
| 1423 | return NULL; | ||
| 1424 | |||
| 1425 | function_exception_exit: | ||
| 1426 | assert( exception_type ); | ||
| 1427 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1428 | |||
| 1429 | return NULL; | ||
| 1430 | |||
| 1431 | } | ||
| 1432 | |||
| 1433 | |||
| 1434 | static PyObject *impl_gi$_error$$$function_6_new_literal( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 1435 | { | ||
| 1436 | // Preserve error status for checks | ||
| 1437 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1438 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 1439 | #endif | ||
| 1440 | |||
| 1441 | // Local variable declarations. | ||
| 1442 | PyObject *par_domain = python_pars[ 0 ]; | ||
| 1443 | PyObject *par_message = python_pars[ 1 ]; | ||
| 1444 | PyObject *par_code = python_pars[ 2 ]; | ||
| 1445 | struct Nuitka_FrameObject *frame_59b5ad9c2ee887c3333a954738a2dfd7; | ||
| 1446 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 1447 | PyObject *exception_type = NULL; | ||
| 1448 | PyObject *exception_value = NULL; | ||
| 1449 | PyTracebackObject *exception_tb = NULL; | ||
| 1450 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 1451 | static struct Nuitka_FrameObject *cache_frame_59b5ad9c2ee887c3333a954738a2dfd7 = NULL; | ||
| 1452 | PyObject *exception_keeper_type_1; | ||
| 1453 | PyObject *exception_keeper_value_1; | ||
| 1454 | PyTracebackObject *exception_keeper_tb_1; | ||
| 1455 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 1456 | |||
| 1457 | // Actual function body. | ||
| 1458 | // Tried code: | ||
| 1459 | MAKE_OR_REUSE_FRAME( cache_frame_59b5ad9c2ee887c3333a954738a2dfd7, codeobj_59b5ad9c2ee887c3333a954738a2dfd7, module_gi$_error, sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 1460 | frame_59b5ad9c2ee887c3333a954738a2dfd7 = cache_frame_59b5ad9c2ee887c3333a954738a2dfd7; | ||
| 1461 | |||
| 1462 | // Push the new frame as the currently active one. | ||
| 1463 | pushFrameStack( frame_59b5ad9c2ee887c3333a954738a2dfd7 ); | ||
| 1464 | |||
| 1465 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 1466 | assert( Py_REFCNT( frame_59b5ad9c2ee887c3333a954738a2dfd7 ) == 2 ); // Frame stack | ||
| 1467 | |||
| 1468 | // Framed code: | ||
| 1469 | { | ||
| 1470 | PyObject *tmp_raise_type_1; | ||
| 1471 | tmp_raise_type_1 = PyExc_NotImplementedError; | ||
| 1472 | exception_type = tmp_raise_type_1; | ||
| 1473 | Py_INCREF( tmp_raise_type_1 ); | ||
| 1474 | exception_lineno = 55; | ||
| 1475 | RAISE_EXCEPTION_WITH_TYPE( &exception_type, &exception_value, &exception_tb ); | ||
| 1476 | type_description_1 = "ooo"; | ||
| 1477 | goto frame_exception_exit_1; | ||
| 1478 | } | ||
| 1479 | |||
| 1480 | #if 0 | ||
| 1481 | RESTORE_FRAME_EXCEPTION( frame_59b5ad9c2ee887c3333a954738a2dfd7 ); | ||
| 1482 | #endif | ||
| 1483 | |||
| 1484 | // Put the previous frame back on top. | ||
| 1485 | popFrameStack(); | ||
| 1486 | |||
| 1487 | goto frame_no_exception_1; | ||
| 1488 | |||
| 1489 | frame_exception_exit_1:; | ||
| 1490 | |||
| 1491 | #if 0 | ||
| 1492 | RESTORE_FRAME_EXCEPTION( frame_59b5ad9c2ee887c3333a954738a2dfd7 ); | ||
| 1493 | #endif | ||
| 1494 | |||
| 1495 | if ( exception_tb == NULL ) | ||
| 1496 | { | ||
| 1497 | exception_tb = MAKE_TRACEBACK( frame_59b5ad9c2ee887c3333a954738a2dfd7, exception_lineno ); | ||
| 1498 | } | ||
| 1499 | else if ( exception_tb->tb_frame != &frame_59b5ad9c2ee887c3333a954738a2dfd7->m_frame ) | ||
| 1500 | { | ||
| 1501 | exception_tb = ADD_TRACEBACK( exception_tb, frame_59b5ad9c2ee887c3333a954738a2dfd7, exception_lineno ); | ||
| 1502 | } | ||
| 1503 | |||
| 1504 | // Attachs locals to frame if any. | ||
| 1505 | Nuitka_Frame_AttachLocals( | ||
| 1506 | (struct Nuitka_FrameObject *)frame_59b5ad9c2ee887c3333a954738a2dfd7, | ||
| 1507 | type_description_1, | ||
| 1508 | par_domain, | ||
| 1509 | par_message, | ||
| 1510 | par_code | ||
| 1511 | ); | ||
| 1512 | |||
| 1513 | |||
| 1514 | // Release cached frame. | ||
| 1515 | if ( frame_59b5ad9c2ee887c3333a954738a2dfd7 == cache_frame_59b5ad9c2ee887c3333a954738a2dfd7 ) | ||
| 1516 | { | ||
| 1517 | Py_DECREF( frame_59b5ad9c2ee887c3333a954738a2dfd7 ); | ||
| 1518 | } | ||
| 1519 | cache_frame_59b5ad9c2ee887c3333a954738a2dfd7 = NULL; | ||
| 1520 | |||
| 1521 | assertFrameObject( frame_59b5ad9c2ee887c3333a954738a2dfd7 ); | ||
| 1522 | |||
| 1523 | // Put the previous frame back on top. | ||
| 1524 | popFrameStack(); | ||
| 1525 | |||
| 1526 | // Return the error. | ||
| 1527 | goto try_except_handler_1; | ||
| 1528 | |||
| 1529 | frame_no_exception_1:; | ||
| 1530 | // tried codes exits in all cases | ||
| 1531 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_6_new_literal ); | ||
| 1532 | return NULL; | ||
| 1533 | // Exception handler code: | ||
| 1534 | try_except_handler_1:; | ||
| 1535 | exception_keeper_type_1 = exception_type; | ||
| 1536 | exception_keeper_value_1 = exception_value; | ||
| 1537 | exception_keeper_tb_1 = exception_tb; | ||
| 1538 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1539 | exception_type = NULL; | ||
| 1540 | exception_value = NULL; | ||
| 1541 | exception_tb = NULL; | ||
| 1542 | exception_lineno = 0; | ||
| 1543 | |||
| 1544 | CHECK_OBJECT( (PyObject *)par_domain ); | ||
| 1545 | Py_DECREF( par_domain ); | ||
| 1546 | par_domain = NULL; | ||
| 1547 | |||
| 1548 | CHECK_OBJECT( (PyObject *)par_message ); | ||
| 1549 | Py_DECREF( par_message ); | ||
| 1550 | par_message = NULL; | ||
| 1551 | |||
| 1552 | CHECK_OBJECT( (PyObject *)par_code ); | ||
| 1553 | Py_DECREF( par_code ); | ||
| 1554 | par_code = NULL; | ||
| 1555 | |||
| 1556 | // Re-raise. | ||
| 1557 | exception_type = exception_keeper_type_1; | ||
| 1558 | exception_value = exception_keeper_value_1; | ||
| 1559 | exception_tb = exception_keeper_tb_1; | ||
| 1560 | exception_lineno = exception_keeper_lineno_1; | ||
| 1561 | |||
| 1562 | goto function_exception_exit; | ||
| 1563 | // End of try: | ||
| 1564 | |||
| 1565 | // Return statement must have exited already. | ||
| 1566 | NUITKA_CANNOT_GET_HERE( gi$_error$$$function_6_new_literal ); | ||
| 1567 | return NULL; | ||
| 1568 | |||
| 1569 | function_exception_exit: | ||
| 1570 | assert( exception_type ); | ||
| 1571 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1572 | |||
| 1573 | return NULL; | ||
| 1574 | |||
| 1575 | } | ||
| 1576 | |||
| 1577 | |||
| 1578 | |||
| 1579 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_1___init__( PyObject *defaults ) | ||
| 1580 | { | ||
| 1581 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1582 | impl_gi$_error$$$function_1___init__, | ||
| 1583 | const_str_plain___init__, | ||
| 1584 | #if PYTHON_VERSION >= 300 | ||
| 1585 | const_str_digest_d79d2d3d3465aa4fbe81afc494eaeb8b, | ||
| 1586 | #endif | ||
| 1587 | codeobj_cf0852ad4c7c0a4f24e105dd59eb5bb4, | ||
| 1588 | defaults, | ||
| 1589 | #if PYTHON_VERSION >= 300 | ||
| 1590 | NULL, | ||
| 1591 | NULL, | ||
| 1592 | #endif | ||
| 1593 | module_gi$_error, | ||
| 1594 | NULL, | ||
| 1595 | 0 | ||
| 1596 | ); | ||
| 1597 | |||
| 1598 | return (PyObject *)result; | ||
| 1599 | } | ||
| 1600 | |||
| 1601 | |||
| 1602 | |||
| 1603 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_2___str__( ) | ||
| 1604 | { | ||
| 1605 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1606 | impl_gi$_error$$$function_2___str__, | ||
| 1607 | const_str_plain___str__, | ||
| 1608 | #if PYTHON_VERSION >= 300 | ||
| 1609 | const_str_digest_b68d7eac5477b1f045df4fe766f17454, | ||
| 1610 | #endif | ||
| 1611 | codeobj_c275568401228a488599146a3b69044e, | ||
| 1612 | NULL, | ||
| 1613 | #if PYTHON_VERSION >= 300 | ||
| 1614 | NULL, | ||
| 1615 | NULL, | ||
| 1616 | #endif | ||
| 1617 | module_gi$_error, | ||
| 1618 | NULL, | ||
| 1619 | 0 | ||
| 1620 | ); | ||
| 1621 | |||
| 1622 | return (PyObject *)result; | ||
| 1623 | } | ||
| 1624 | |||
| 1625 | |||
| 1626 | |||
| 1627 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_3___repr__( ) | ||
| 1628 | { | ||
| 1629 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1630 | impl_gi$_error$$$function_3___repr__, | ||
| 1631 | const_str_plain___repr__, | ||
| 1632 | #if PYTHON_VERSION >= 300 | ||
| 1633 | const_str_digest_6bfa92c856dbf8e3e2c5e4b775af9644, | ||
| 1634 | #endif | ||
| 1635 | codeobj_c2ee6d133e87fb3a9c28fb092eeedd2d, | ||
| 1636 | NULL, | ||
| 1637 | #if PYTHON_VERSION >= 300 | ||
| 1638 | NULL, | ||
| 1639 | NULL, | ||
| 1640 | #endif | ||
| 1641 | module_gi$_error, | ||
| 1642 | NULL, | ||
| 1643 | 0 | ||
| 1644 | ); | ||
| 1645 | |||
| 1646 | return (PyObject *)result; | ||
| 1647 | } | ||
| 1648 | |||
| 1649 | |||
| 1650 | |||
| 1651 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_4_copy( ) | ||
| 1652 | { | ||
| 1653 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1654 | impl_gi$_error$$$function_4_copy, | ||
| 1655 | const_str_plain_copy, | ||
| 1656 | #if PYTHON_VERSION >= 300 | ||
| 1657 | const_str_digest_ab8bd434ecb26dfe63e508b968fd6e8d, | ||
| 1658 | #endif | ||
| 1659 | codeobj_305f11e425fc81aa725ee337171b21c9, | ||
| 1660 | NULL, | ||
| 1661 | #if PYTHON_VERSION >= 300 | ||
| 1662 | NULL, | ||
| 1663 | NULL, | ||
| 1664 | #endif | ||
| 1665 | module_gi$_error, | ||
| 1666 | NULL, | ||
| 1667 | 0 | ||
| 1668 | ); | ||
| 1669 | |||
| 1670 | return (PyObject *)result; | ||
| 1671 | } | ||
| 1672 | |||
| 1673 | |||
| 1674 | |||
| 1675 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_5_matches( ) | ||
| 1676 | { | ||
| 1677 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1678 | impl_gi$_error$$$function_5_matches, | ||
| 1679 | const_str_plain_matches, | ||
| 1680 | #if PYTHON_VERSION >= 300 | ||
| 1681 | const_str_digest_f2c7de8ef8641c3740230a0d3fabd50a, | ||
| 1682 | #endif | ||
| 1683 | codeobj_d5da4e4df6d7c426ebe86d0ed7048621, | ||
| 1684 | NULL, | ||
| 1685 | #if PYTHON_VERSION >= 300 | ||
| 1686 | NULL, | ||
| 1687 | NULL, | ||
| 1688 | #endif | ||
| 1689 | module_gi$_error, | ||
| 1690 | const_str_digest_05f5e7bda3c5f3dd043b13aed890190b, | ||
| 1691 | 0 | ||
| 1692 | ); | ||
| 1693 | |||
| 1694 | return (PyObject *)result; | ||
| 1695 | } | ||
| 1696 | |||
| 1697 | |||
| 1698 | |||
| 1699 | static PyObject *MAKE_FUNCTION_gi$_error$$$function_6_new_literal( ) | ||
| 1700 | { | ||
| 1701 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1702 | impl_gi$_error$$$function_6_new_literal, | ||
| 1703 | const_str_plain_new_literal, | ||
| 1704 | #if PYTHON_VERSION >= 300 | ||
| 1705 | const_str_digest_89e98bf8388402041eeb0849366e274b, | ||
| 1706 | #endif | ||
| 1707 | codeobj_59b5ad9c2ee887c3333a954738a2dfd7, | ||
| 1708 | NULL, | ||
| 1709 | #if PYTHON_VERSION >= 300 | ||
| 1710 | NULL, | ||
| 1711 | NULL, | ||
| 1712 | #endif | ||
| 1713 | module_gi$_error, | ||
| 1714 | const_str_digest_05f5e7bda3c5f3dd043b13aed890190b, | ||
| 1715 | 0 | ||
| 1716 | ); | ||
| 1717 | |||
| 1718 | return (PyObject *)result; | ||
| 1719 | } | ||
| 1720 | |||
| 1721 | |||
| 1722 | |||
| 1723 | #if PYTHON_VERSION >= 300 | ||
| 1724 | static struct PyModuleDef mdef_gi$_error = | ||
| 1725 | { | ||
| 1726 | PyModuleDef_HEAD_INIT, | ||
| 1727 | "gi._error", | ||
| 1728 | NULL, /* m_doc */ | ||
| 1729 | -1, /* m_size */ | ||
| 1730 | NULL, /* m_methods */ | ||
| 1731 | NULL, /* m_reload */ | ||
| 1732 | NULL, /* m_traverse */ | ||
| 1733 | NULL, /* m_clear */ | ||
| 1734 | NULL, /* m_free */ | ||
| 1735 | }; | ||
| 1736 | #endif | ||
| 1737 | |||
| 1738 | extern PyObject *const_str_plain___compiled__; | ||
| 1739 | |||
| 1740 | extern PyObject *const_str_plain___package__; | ||
| 1741 | |||
| 1742 | #if PYTHON_VERSION >= 300 | ||
| 1743 | extern PyObject *const_str_dot; | ||
| 1744 | extern PyObject *const_str_plain___loader__; | ||
| 1745 | #endif | ||
| 1746 | |||
| 1747 | #if PYTHON_VERSION >= 340 | ||
| 1748 | extern PyObject *const_str_plain___spec__; | ||
| 1749 | extern PyObject *const_str_plain__initializing; | ||
| 1750 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 1751 | #endif | ||
| 1752 | |||
| 1753 | extern void _initCompiledCellType(); | ||
| 1754 | extern void _initCompiledGeneratorType(); | ||
| 1755 | extern void _initCompiledFunctionType(); | ||
| 1756 | extern void _initCompiledMethodType(); | ||
| 1757 | extern void _initCompiledFrameType(); | ||
| 1758 | #if PYTHON_VERSION >= 350 | ||
| 1759 | extern void _initCompiledCoroutineTypes(); | ||
| 1760 | #endif | ||
| 1761 | #if PYTHON_VERSION >= 360 | ||
| 1762 | extern void _initCompiledAsyncgenTypes(); | ||
| 1763 | #endif | ||
| 1764 | |||
| 1765 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 1766 | |||
| 1767 | // The exported interface to CPython. On import of the module, this function | ||
| 1768 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 1769 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 1770 | |||
| 1771 | MOD_INIT_DECL( gi$_error ) | ||
| 1772 | { | ||
| 1773 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 1774 | static bool _init_done = false; | ||
| 1775 | |||
| 1776 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 1777 | if ( _init_done ) | ||
| 1778 | { | ||
| 1779 | return MOD_RETURN_VALUE( module_gi$_error ); | ||
| 1780 | } | ||
| 1781 | else | ||
| 1782 | { | ||
| 1783 | _init_done = true; | ||
| 1784 | } | ||
| 1785 | #endif | ||
| 1786 | |||
| 1787 | #ifdef _NUITKA_MODULE | ||
| 1788 | // In case of a stand alone extension module, need to call initialization | ||
| 1789 | // the init here because that's the first and only time we are going to get | ||
| 1790 | // called here. | ||
| 1791 | |||
| 1792 | // Initialize the constant values used. | ||
| 1793 | _initBuiltinModule(); | ||
| 1794 | createGlobalConstants(); | ||
| 1795 | |||
| 1796 | /* Initialize the compiled types of Nuitka. */ | ||
| 1797 | _initCompiledCellType(); | ||
| 1798 | _initCompiledGeneratorType(); | ||
| 1799 | _initCompiledFunctionType(); | ||
| 1800 | _initCompiledMethodType(); | ||
| 1801 | _initCompiledFrameType(); | ||
| 1802 | #if PYTHON_VERSION >= 350 | ||
| 1803 | _initCompiledCoroutineTypes(); | ||
| 1804 | #endif | ||
| 1805 | #if PYTHON_VERSION >= 360 | ||
| 1806 | _initCompiledAsyncgenTypes(); | ||
| 1807 | #endif | ||
| 1808 | |||
| 1809 | #if PYTHON_VERSION < 300 | ||
| 1810 | _initSlotCompare(); | ||
| 1811 | #endif | ||
| 1812 | #if PYTHON_VERSION >= 270 | ||
| 1813 | _initSlotIternext(); | ||
| 1814 | #endif | ||
| 1815 | |||
| 1816 | patchBuiltinModule(); | ||
| 1817 | patchTypeComparison(); | ||
| 1818 | |||
| 1819 | // Enable meta path based loader if not already done. | ||
| 1820 | #ifdef _NUITKA_TRACE | ||
| 1821 | puts("gi._error: Calling setupMetaPathBasedLoader()."); | ||
| 1822 | #endif | ||
| 1823 | setupMetaPathBasedLoader(); | ||
| 1824 | |||
| 1825 | #if PYTHON_VERSION >= 300 | ||
| 1826 | patchInspectModule(); | ||
| 1827 | #endif | ||
| 1828 | |||
| 1829 | #endif | ||
| 1830 | |||
| 1831 | /* The constants only used by this module are created now. */ | ||
| 1832 | #ifdef _NUITKA_TRACE | ||
| 1833 | puts("gi._error: Calling createModuleConstants()."); | ||
| 1834 | #endif | ||
| 1835 | createModuleConstants(); | ||
| 1836 | |||
| 1837 | /* The code objects used by this module are created now. */ | ||
| 1838 | #ifdef _NUITKA_TRACE | ||
| 1839 | puts("gi._error: Calling createModuleCodeObjects()."); | ||
| 1840 | #endif | ||
| 1841 | createModuleCodeObjects(); | ||
| 1842 | |||
| 1843 | // puts( "in initgi$_error" ); | ||
| 1844 | |||
| 1845 | // Create the module object first. There are no methods initially, all are | ||
| 1846 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 1847 | // set at this time, as it could not contain NUL characters this way, they | ||
| 1848 | // are instead set in early module code. No "self" for modules, we have no | ||
| 1849 | // use for it. | ||
| 1850 | #if PYTHON_VERSION < 300 | ||
| 1851 | module_gi$_error = Py_InitModule4( | ||
| 1852 | "gi._error", // Module Name | ||
| 1853 | NULL, // No methods initially, all are added | ||
| 1854 | // dynamically in actual module code only. | ||
| 1855 | NULL, // No "__doc__" is initially set, as it could | ||
| 1856 | // not contain NUL this way, added early in | ||
| 1857 | // actual code. | ||
| 1858 | NULL, // No self for modules, we don't use it. | ||
| 1859 | PYTHON_API_VERSION | ||
| 1860 | ); | ||
| 1861 | #else | ||
| 1862 | |||
| 1863 | module_gi$_error = PyModule_Create( &mdef_gi$_error ); | ||
| 1864 | #endif | ||
| 1865 | |||
| 1866 | moduledict_gi$_error = MODULE_DICT( module_gi$_error ); | ||
| 1867 | |||
| 1868 | // Set __compiled__ to what it we know. | ||
| 1869 | UPDATE_STRING_DICT1( | ||
| 1870 | moduledict_gi$_error, | ||
| 1871 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 1872 | Nuitka_dunder_compiled_value | ||
| 1873 | ); | ||
| 1874 | |||
| 1875 | // Update "__package__" value to what it ought to be. | ||
| 1876 | { | ||
| 1877 | #if 0 | ||
| 1878 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 1879 | |||
| 1880 | UPDATE_STRING_DICT1( | ||
| 1881 | moduledict_gi$_error, | ||
| 1882 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 1883 | module_name | ||
| 1884 | ); | ||
| 1885 | #else | ||
| 1886 | |||
| 1887 | #if PYTHON_VERSION < 300 | ||
| 1888 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 1889 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 1890 | |||
| 1891 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 1892 | |||
| 1893 | if ( last_dot != NULL ) | ||
| 1894 | { | ||
| 1895 | UPDATE_STRING_DICT1( | ||
| 1896 | moduledict_gi$_error, | ||
| 1897 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 1898 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 1899 | ); | ||
| 1900 | } | ||
| 1901 | #else | ||
| 1902 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 1903 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 1904 | |||
| 1905 | if ( dot_index != -1 ) | ||
| 1906 | { | ||
| 1907 | UPDATE_STRING_DICT1( | ||
| 1908 | moduledict_gi$_error, | ||
| 1909 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 1910 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 1911 | ); | ||
| 1912 | } | ||
| 1913 | #endif | ||
| 1914 | #endif | ||
| 1915 | } | ||
| 1916 | |||
| 1917 | CHECK_OBJECT( module_gi$_error ); | ||
| 1918 | |||
| 1919 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 1920 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 1921 | #if PYTHON_VERSION >= 300 | ||
| 1922 | { | ||
| 1923 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_a9b7b3db680a6120a08bd1702778dec5, module_gi$_error ); | ||
| 1924 | |||
| 1925 | assert( r != -1 ); | ||
| 1926 | } | ||
| 1927 | #endif | ||
| 1928 | |||
| 1929 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 1930 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 1931 | // before the frame object is allocated, or else it may fail. | ||
| 1932 | |||
| 1933 | if ( GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 1934 | { | ||
| 1935 | PyObject *value = (PyObject *)builtin_module; | ||
| 1936 | |||
| 1937 | // Check if main module, not a dict then but the module itself. | ||
| 1938 | #if !defined(_NUITKA_EXE) || !0 | ||
| 1939 | value = PyModule_GetDict( value ); | ||
| 1940 | #endif | ||
| 1941 | |||
| 1942 | UPDATE_STRING_DICT0( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 1943 | } | ||
| 1944 | |||
| 1945 | #if PYTHON_VERSION >= 300 | ||
| 1946 | UPDATE_STRING_DICT0( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 1947 | #endif | ||
| 1948 | |||
| 1949 | #if PYTHON_VERSION >= 340 | ||
| 1950 | // Set the "__spec__" value | ||
| 1951 | |||
| 1952 | #if 0 | ||
| 1953 | // Main modules just get "None" as spec. | ||
| 1954 | UPDATE_STRING_DICT0( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 1955 | #else | ||
| 1956 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 1957 | { | ||
| 1958 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 1959 | CHECK_OBJECT( bootstrap_module ); | ||
| 1960 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 1961 | Py_DECREF( bootstrap_module ); | ||
| 1962 | |||
| 1963 | PyObject *args[] = { | ||
| 1964 | GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 1965 | (PyObject *)&Nuitka_Loader_Type | ||
| 1966 | }; | ||
| 1967 | |||
| 1968 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 1969 | module_spec_class, | ||
| 1970 | args | ||
| 1971 | ); | ||
| 1972 | Py_DECREF( module_spec_class ); | ||
| 1973 | |||
| 1974 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 1975 | CHECK_OBJECT( spec_value ); | ||
| 1976 | |||
| 1977 | // For packages set the submodule search locations as well, even if to empty | ||
| 1978 | // list, so investigating code will consider it a package. | ||
| 1979 | #if 0 | ||
| 1980 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 1981 | #endif | ||
| 1982 | |||
| 1983 | // Mark the execution in the "__spec__" value. | ||
| 1984 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 1985 | |||
| 1986 | UPDATE_STRING_DICT1( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 1987 | } | ||
| 1988 | #endif | ||
| 1989 | #endif | ||
| 1990 | |||
| 1991 | // Temp variables if any | ||
| 1992 | PyObject *outline_0_var___class__ = NULL; | ||
| 1993 | PyObject *tmp_class_creation_1__bases = NULL; | ||
| 1994 | PyObject *tmp_class_creation_1__class_decl_dict = NULL; | ||
| 1995 | PyObject *tmp_class_creation_1__metaclass = NULL; | ||
| 1996 | PyObject *tmp_class_creation_1__prepared = NULL; | ||
| 1997 | struct Nuitka_FrameObject *frame_aafd294a192c701bd13d3c8b93cd1b82; | ||
| 1998 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 1999 | bool tmp_result; | ||
| 2000 | PyObject *exception_type = NULL; | ||
| 2001 | PyObject *exception_value = NULL; | ||
| 2002 | PyTracebackObject *exception_tb = NULL; | ||
| 2003 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 2004 | int tmp_res; | ||
| 2005 | PyObject *tmp_dictdel_dict; | ||
| 2006 | PyObject *tmp_dictdel_key; | ||
| 2007 | PyObject *locals_gi$_error_30 = NULL; | ||
| 2008 | PyObject *tmp_dictset_value; | ||
| 2009 | struct Nuitka_FrameObject *frame_642fa75cb43d28afa93ff29e67523814_2; | ||
| 2010 | NUITKA_MAY_BE_UNUSED char const *type_description_2 = NULL; | ||
| 2011 | static struct Nuitka_FrameObject *cache_frame_642fa75cb43d28afa93ff29e67523814_2 = NULL; | ||
| 2012 | PyObject *exception_keeper_type_1; | ||
| 2013 | PyObject *exception_keeper_value_1; | ||
| 2014 | PyTracebackObject *exception_keeper_tb_1; | ||
| 2015 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 2016 | PyObject *exception_keeper_type_2; | ||
| 2017 | PyObject *exception_keeper_value_2; | ||
| 2018 | PyTracebackObject *exception_keeper_tb_2; | ||
| 2019 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 2020 | PyObject *exception_keeper_type_3; | ||
| 2021 | PyObject *exception_keeper_value_3; | ||
| 2022 | PyTracebackObject *exception_keeper_tb_3; | ||
| 2023 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; | ||
| 2024 | |||
| 2025 | // Module code. | ||
| 2026 | { | ||
| 2027 | PyObject *tmp_assign_source_1; | ||
| 2028 | tmp_assign_source_1 = Py_None; | ||
| 2029 | UPDATE_STRING_DICT0( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 2030 | } | ||
| 2031 | { | ||
| 2032 | PyObject *tmp_assign_source_2; | ||
| 2033 | tmp_assign_source_2 = module_filename_obj; | ||
| 2034 | UPDATE_STRING_DICT0( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 2035 | } | ||
| 2036 | // Frame without reuse. | ||
| 2037 | frame_aafd294a192c701bd13d3c8b93cd1b82 = MAKE_MODULE_FRAME( codeobj_aafd294a192c701bd13d3c8b93cd1b82, module_gi$_error ); | ||
| 2038 | |||
| 2039 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 2040 | // owning it. | ||
| 2041 | pushFrameStack( frame_aafd294a192c701bd13d3c8b93cd1b82 ); | ||
| 2042 | assert( Py_REFCNT( frame_aafd294a192c701bd13d3c8b93cd1b82 ) == 2 ); | ||
| 2043 | |||
| 2044 | // Framed code: | ||
| 2045 | { | ||
| 2046 | PyObject *tmp_assattr_name_1; | ||
| 2047 | PyObject *tmp_assattr_target_1; | ||
| 2048 | PyObject *tmp_mvar_value_1; | ||
| 2049 | tmp_assattr_name_1 = module_filename_obj; | ||
| 2050 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2051 | |||
| 2052 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 2053 | { | ||
| 2054 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2055 | } | ||
| 2056 | |||
| 2057 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 2058 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 2059 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 2060 | if ( tmp_result == false ) | ||
| 2061 | { | ||
| 2062 | assert( ERROR_OCCURRED() ); | ||
| 2063 | |||
| 2064 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2065 | |||
| 2066 | |||
| 2067 | exception_lineno = 1; | ||
| 2068 | |||
| 2069 | goto frame_exception_exit_1; | ||
| 2070 | } | ||
| 2071 | } | ||
| 2072 | { | ||
| 2073 | PyObject *tmp_assattr_name_2; | ||
| 2074 | PyObject *tmp_assattr_target_2; | ||
| 2075 | PyObject *tmp_mvar_value_2; | ||
| 2076 | tmp_assattr_name_2 = Py_True; | ||
| 2077 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2078 | |||
| 2079 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 2080 | { | ||
| 2081 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2082 | } | ||
| 2083 | |||
| 2084 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 2085 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 2086 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 2087 | if ( tmp_result == false ) | ||
| 2088 | { | ||
| 2089 | assert( ERROR_OCCURRED() ); | ||
| 2090 | |||
| 2091 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2092 | |||
| 2093 | |||
| 2094 | exception_lineno = 1; | ||
| 2095 | |||
| 2096 | goto frame_exception_exit_1; | ||
| 2097 | } | ||
| 2098 | } | ||
| 2099 | { | ||
| 2100 | PyObject *tmp_assign_source_3; | ||
| 2101 | tmp_assign_source_3 = Py_None; | ||
| 2102 | UPDATE_STRING_DICT0( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 2103 | } | ||
| 2104 | // Tried code: | ||
| 2105 | { | ||
| 2106 | PyObject *tmp_assign_source_4; | ||
| 2107 | PyObject *tmp_dircall_arg1_1; | ||
| 2108 | tmp_dircall_arg1_1 = const_tuple_type_RuntimeError_tuple; | ||
| 2109 | Py_INCREF( tmp_dircall_arg1_1 ); | ||
| 2110 | |||
| 2111 | { | ||
| 2112 | PyObject *dir_call_args[] = {tmp_dircall_arg1_1}; | ||
| 2113 | tmp_assign_source_4 = impl___internal__$$$function_2__mro_entries_conversion( dir_call_args ); | ||
| 2114 | } | ||
| 2115 | if ( tmp_assign_source_4 == NULL ) | ||
| 2116 | { | ||
| 2117 | assert( ERROR_OCCURRED() ); | ||
| 2118 | |||
| 2119 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2120 | |||
| 2121 | |||
| 2122 | exception_lineno = 30; | ||
| 2123 | |||
| 2124 | goto try_except_handler_1; | ||
| 2125 | } | ||
| 2126 | assert( tmp_class_creation_1__bases == NULL ); | ||
| 2127 | tmp_class_creation_1__bases = tmp_assign_source_4; | ||
| 2128 | } | ||
| 2129 | { | ||
| 2130 | PyObject *tmp_assign_source_5; | ||
| 2131 | tmp_assign_source_5 = PyDict_New(); | ||
| 2132 | assert( tmp_class_creation_1__class_decl_dict == NULL ); | ||
| 2133 | tmp_class_creation_1__class_decl_dict = tmp_assign_source_5; | ||
| 2134 | } | ||
| 2135 | { | ||
| 2136 | PyObject *tmp_assign_source_6; | ||
| 2137 | PyObject *tmp_metaclass_name_1; | ||
| 2138 | nuitka_bool tmp_condition_result_1; | ||
| 2139 | PyObject *tmp_key_name_1; | ||
| 2140 | PyObject *tmp_dict_name_1; | ||
| 2141 | PyObject *tmp_dict_name_2; | ||
| 2142 | PyObject *tmp_key_name_2; | ||
| 2143 | nuitka_bool tmp_condition_result_2; | ||
| 2144 | int tmp_truth_name_1; | ||
| 2145 | PyObject *tmp_type_arg_1; | ||
| 2146 | PyObject *tmp_subscribed_name_1; | ||
| 2147 | PyObject *tmp_subscript_name_1; | ||
| 2148 | PyObject *tmp_bases_name_1; | ||
| 2149 | tmp_key_name_1 = const_str_plain_metaclass; | ||
| 2150 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 2151 | tmp_dict_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 2152 | tmp_res = PyDict_Contains( tmp_dict_name_1, tmp_key_name_1 ); | ||
| 2153 | if ( tmp_res == -1 ) | ||
| 2154 | { | ||
| 2155 | assert( ERROR_OCCURRED() ); | ||
| 2156 | |||
| 2157 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2158 | |||
| 2159 | |||
| 2160 | exception_lineno = 30; | ||
| 2161 | |||
| 2162 | goto try_except_handler_1; | ||
| 2163 | } | ||
| 2164 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2165 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 2166 | { | ||
| 2167 | goto condexpr_true_1; | ||
| 2168 | } | ||
| 2169 | else | ||
| 2170 | { | ||
| 2171 | goto condexpr_false_1; | ||
| 2172 | } | ||
| 2173 | condexpr_true_1:; | ||
| 2174 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 2175 | tmp_dict_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 2176 | tmp_key_name_2 = const_str_plain_metaclass; | ||
| 2177 | tmp_metaclass_name_1 = DICT_GET_ITEM( tmp_dict_name_2, tmp_key_name_2 ); | ||
| 2178 | if ( tmp_metaclass_name_1 == NULL ) | ||
| 2179 | { | ||
| 2180 | assert( ERROR_OCCURRED() ); | ||
| 2181 | |||
| 2182 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2183 | |||
| 2184 | |||
| 2185 | exception_lineno = 30; | ||
| 2186 | |||
| 2187 | goto try_except_handler_1; | ||
| 2188 | } | ||
| 2189 | goto condexpr_end_1; | ||
| 2190 | condexpr_false_1:; | ||
| 2191 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 2192 | tmp_truth_name_1 = CHECK_IF_TRUE( tmp_class_creation_1__bases ); | ||
| 2193 | if ( tmp_truth_name_1 == -1 ) | ||
| 2194 | { | ||
| 2195 | assert( ERROR_OCCURRED() ); | ||
| 2196 | |||
| 2197 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2198 | |||
| 2199 | |||
| 2200 | exception_lineno = 30; | ||
| 2201 | |||
| 2202 | goto try_except_handler_1; | ||
| 2203 | } | ||
| 2204 | tmp_condition_result_2 = tmp_truth_name_1 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2205 | if ( tmp_condition_result_2 == NUITKA_BOOL_TRUE ) | ||
| 2206 | { | ||
| 2207 | goto condexpr_true_2; | ||
| 2208 | } | ||
| 2209 | else | ||
| 2210 | { | ||
| 2211 | goto condexpr_false_2; | ||
| 2212 | } | ||
| 2213 | condexpr_true_2:; | ||
| 2214 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 2215 | tmp_subscribed_name_1 = tmp_class_creation_1__bases; | ||
| 2216 | tmp_subscript_name_1 = const_int_0; | ||
| 2217 | tmp_type_arg_1 = LOOKUP_SUBSCRIPT_CONST( tmp_subscribed_name_1, tmp_subscript_name_1, 0 ); | ||
| 2218 | if ( tmp_type_arg_1 == NULL ) | ||
| 2219 | { | ||
| 2220 | assert( ERROR_OCCURRED() ); | ||
| 2221 | |||
| 2222 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2223 | |||
| 2224 | |||
| 2225 | exception_lineno = 30; | ||
| 2226 | |||
| 2227 | goto try_except_handler_1; | ||
| 2228 | } | ||
| 2229 | tmp_metaclass_name_1 = BUILTIN_TYPE1( tmp_type_arg_1 ); | ||
| 2230 | Py_DECREF( tmp_type_arg_1 ); | ||
| 2231 | if ( tmp_metaclass_name_1 == NULL ) | ||
| 2232 | { | ||
| 2233 | assert( ERROR_OCCURRED() ); | ||
| 2234 | |||
| 2235 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2236 | |||
| 2237 | |||
| 2238 | exception_lineno = 30; | ||
| 2239 | |||
| 2240 | goto try_except_handler_1; | ||
| 2241 | } | ||
| 2242 | goto condexpr_end_2; | ||
| 2243 | condexpr_false_2:; | ||
| 2244 | tmp_metaclass_name_1 = (PyObject *)&PyType_Type; | ||
| 2245 | Py_INCREF( tmp_metaclass_name_1 ); | ||
| 2246 | condexpr_end_2:; | ||
| 2247 | condexpr_end_1:; | ||
| 2248 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 2249 | tmp_bases_name_1 = tmp_class_creation_1__bases; | ||
| 2250 | tmp_assign_source_6 = SELECT_METACLASS( tmp_metaclass_name_1, tmp_bases_name_1 ); | ||
| 2251 | Py_DECREF( tmp_metaclass_name_1 ); | ||
| 2252 | if ( tmp_assign_source_6 == NULL ) | ||
| 2253 | { | ||
| 2254 | assert( ERROR_OCCURRED() ); | ||
| 2255 | |||
| 2256 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2257 | |||
| 2258 | |||
| 2259 | exception_lineno = 30; | ||
| 2260 | |||
| 2261 | goto try_except_handler_1; | ||
| 2262 | } | ||
| 2263 | assert( tmp_class_creation_1__metaclass == NULL ); | ||
| 2264 | tmp_class_creation_1__metaclass = tmp_assign_source_6; | ||
| 2265 | } | ||
| 2266 | { | ||
| 2267 | nuitka_bool tmp_condition_result_3; | ||
| 2268 | PyObject *tmp_key_name_3; | ||
| 2269 | PyObject *tmp_dict_name_3; | ||
| 2270 | tmp_key_name_3 = const_str_plain_metaclass; | ||
| 2271 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 2272 | tmp_dict_name_3 = tmp_class_creation_1__class_decl_dict; | ||
| 2273 | tmp_res = PyDict_Contains( tmp_dict_name_3, tmp_key_name_3 ); | ||
| 2274 | if ( tmp_res == -1 ) | ||
| 2275 | { | ||
| 2276 | assert( ERROR_OCCURRED() ); | ||
| 2277 | |||
| 2278 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2279 | |||
| 2280 | |||
| 2281 | exception_lineno = 30; | ||
| 2282 | |||
| 2283 | goto try_except_handler_1; | ||
| 2284 | } | ||
| 2285 | tmp_condition_result_3 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2286 | if ( tmp_condition_result_3 == NUITKA_BOOL_TRUE ) | ||
| 2287 | { | ||
| 2288 | goto branch_yes_1; | ||
| 2289 | } | ||
| 2290 | else | ||
| 2291 | { | ||
| 2292 | goto branch_no_1; | ||
| 2293 | } | ||
| 2294 | branch_yes_1:; | ||
| 2295 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 2296 | tmp_dictdel_dict = tmp_class_creation_1__class_decl_dict; | ||
| 2297 | tmp_dictdel_key = const_str_plain_metaclass; | ||
| 2298 | tmp_result = DICT_REMOVE_ITEM( tmp_dictdel_dict, tmp_dictdel_key ); | ||
| 2299 | if ( tmp_result == false ) | ||
| 2300 | { | ||
| 2301 | assert( ERROR_OCCURRED() ); | ||
| 2302 | |||
| 2303 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2304 | |||
| 2305 | |||
| 2306 | exception_lineno = 30; | ||
| 2307 | |||
| 2308 | goto try_except_handler_1; | ||
| 2309 | } | ||
| 2310 | branch_no_1:; | ||
| 2311 | } | ||
| 2312 | { | ||
| 2313 | nuitka_bool tmp_condition_result_4; | ||
| 2314 | PyObject *tmp_source_name_1; | ||
| 2315 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 2316 | tmp_source_name_1 = tmp_class_creation_1__metaclass; | ||
| 2317 | tmp_res = PyObject_HasAttr( tmp_source_name_1, const_str_plain___prepare__ ); | ||
| 2318 | tmp_condition_result_4 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2319 | if ( tmp_condition_result_4 == NUITKA_BOOL_TRUE ) | ||
| 2320 | { | ||
| 2321 | goto branch_yes_2; | ||
| 2322 | } | ||
| 2323 | else | ||
| 2324 | { | ||
| 2325 | goto branch_no_2; | ||
| 2326 | } | ||
| 2327 | branch_yes_2:; | ||
| 2328 | { | ||
| 2329 | PyObject *tmp_assign_source_7; | ||
| 2330 | PyObject *tmp_called_name_1; | ||
| 2331 | PyObject *tmp_source_name_2; | ||
| 2332 | PyObject *tmp_args_name_1; | ||
| 2333 | PyObject *tmp_tuple_element_1; | ||
| 2334 | PyObject *tmp_kw_name_1; | ||
| 2335 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 2336 | tmp_source_name_2 = tmp_class_creation_1__metaclass; | ||
| 2337 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain___prepare__ ); | ||
| 2338 | if ( tmp_called_name_1 == NULL ) | ||
| 2339 | { | ||
| 2340 | assert( ERROR_OCCURRED() ); | ||
| 2341 | |||
| 2342 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2343 | |||
| 2344 | |||
| 2345 | exception_lineno = 30; | ||
| 2346 | |||
| 2347 | goto try_except_handler_1; | ||
| 2348 | } | ||
| 2349 | tmp_tuple_element_1 = const_str_plain_GError; | ||
| 2350 | tmp_args_name_1 = PyTuple_New( 2 ); | ||
| 2351 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 2352 | PyTuple_SET_ITEM( tmp_args_name_1, 0, tmp_tuple_element_1 ); | ||
| 2353 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 2354 | tmp_tuple_element_1 = tmp_class_creation_1__bases; | ||
| 2355 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 2356 | PyTuple_SET_ITEM( tmp_args_name_1, 1, tmp_tuple_element_1 ); | ||
| 2357 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 2358 | tmp_kw_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 2359 | frame_aafd294a192c701bd13d3c8b93cd1b82->m_frame.f_lineno = 30; | ||
| 2360 | tmp_assign_source_7 = CALL_FUNCTION( tmp_called_name_1, tmp_args_name_1, tmp_kw_name_1 ); | ||
| 2361 | Py_DECREF( tmp_called_name_1 ); | ||
| 2362 | Py_DECREF( tmp_args_name_1 ); | ||
| 2363 | if ( tmp_assign_source_7 == NULL ) | ||
| 2364 | { | ||
| 2365 | assert( ERROR_OCCURRED() ); | ||
| 2366 | |||
| 2367 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2368 | |||
| 2369 | |||
| 2370 | exception_lineno = 30; | ||
| 2371 | |||
| 2372 | goto try_except_handler_1; | ||
| 2373 | } | ||
| 2374 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 2375 | tmp_class_creation_1__prepared = tmp_assign_source_7; | ||
| 2376 | } | ||
| 2377 | { | ||
| 2378 | nuitka_bool tmp_condition_result_5; | ||
| 2379 | PyObject *tmp_operand_name_1; | ||
| 2380 | PyObject *tmp_source_name_3; | ||
| 2381 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 2382 | tmp_source_name_3 = tmp_class_creation_1__prepared; | ||
| 2383 | tmp_res = PyObject_HasAttr( tmp_source_name_3, const_str_plain___getitem__ ); | ||
| 2384 | tmp_operand_name_1 = ( tmp_res != 0 ) ? Py_True : Py_False; | ||
| 2385 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 2386 | if ( tmp_res == -1 ) | ||
| 2387 | { | ||
| 2388 | assert( ERROR_OCCURRED() ); | ||
| 2389 | |||
| 2390 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2391 | |||
| 2392 | |||
| 2393 | exception_lineno = 30; | ||
| 2394 | |||
| 2395 | goto try_except_handler_1; | ||
| 2396 | } | ||
| 2397 | tmp_condition_result_5 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2398 | if ( tmp_condition_result_5 == NUITKA_BOOL_TRUE ) | ||
| 2399 | { | ||
| 2400 | goto branch_yes_3; | ||
| 2401 | } | ||
| 2402 | else | ||
| 2403 | { | ||
| 2404 | goto branch_no_3; | ||
| 2405 | } | ||
| 2406 | branch_yes_3:; | ||
| 2407 | { | ||
| 2408 | PyObject *tmp_raise_type_1; | ||
| 2409 | PyObject *tmp_raise_value_1; | ||
| 2410 | PyObject *tmp_left_name_1; | ||
| 2411 | PyObject *tmp_right_name_1; | ||
| 2412 | PyObject *tmp_tuple_element_2; | ||
| 2413 | PyObject *tmp_getattr_target_1; | ||
| 2414 | PyObject *tmp_getattr_attr_1; | ||
| 2415 | PyObject *tmp_getattr_default_1; | ||
| 2416 | PyObject *tmp_source_name_4; | ||
| 2417 | PyObject *tmp_type_arg_2; | ||
| 2418 | tmp_raise_type_1 = PyExc_TypeError; | ||
| 2419 | tmp_left_name_1 = const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 2420 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 2421 | tmp_getattr_target_1 = tmp_class_creation_1__metaclass; | ||
| 2422 | tmp_getattr_attr_1 = const_str_plain___name__; | ||
| 2423 | tmp_getattr_default_1 = const_str_angle_metaclass; | ||
| 2424 | tmp_tuple_element_2 = BUILTIN_GETATTR( tmp_getattr_target_1, tmp_getattr_attr_1, tmp_getattr_default_1 ); | ||
| 2425 | if ( tmp_tuple_element_2 == NULL ) | ||
| 2426 | { | ||
| 2427 | assert( ERROR_OCCURRED() ); | ||
| 2428 | |||
| 2429 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2430 | |||
| 2431 | |||
| 2432 | exception_lineno = 30; | ||
| 2433 | |||
| 2434 | goto try_except_handler_1; | ||
| 2435 | } | ||
| 2436 | tmp_right_name_1 = PyTuple_New( 2 ); | ||
| 2437 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_2 ); | ||
| 2438 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 2439 | tmp_type_arg_2 = tmp_class_creation_1__prepared; | ||
| 2440 | tmp_source_name_4 = BUILTIN_TYPE1( tmp_type_arg_2 ); | ||
| 2441 | assert( !(tmp_source_name_4 == NULL) ); | ||
| 2442 | tmp_tuple_element_2 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain___name__ ); | ||
| 2443 | Py_DECREF( tmp_source_name_4 ); | ||
| 2444 | if ( tmp_tuple_element_2 == NULL ) | ||
| 2445 | { | ||
| 2446 | assert( ERROR_OCCURRED() ); | ||
| 2447 | |||
| 2448 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2449 | Py_DECREF( tmp_right_name_1 ); | ||
| 2450 | |||
| 2451 | exception_lineno = 30; | ||
| 2452 | |||
| 2453 | goto try_except_handler_1; | ||
| 2454 | } | ||
| 2455 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_2 ); | ||
| 2456 | tmp_raise_value_1 = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 2457 | Py_DECREF( tmp_right_name_1 ); | ||
| 2458 | if ( tmp_raise_value_1 == NULL ) | ||
| 2459 | { | ||
| 2460 | assert( ERROR_OCCURRED() ); | ||
| 2461 | |||
| 2462 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2463 | |||
| 2464 | |||
| 2465 | exception_lineno = 30; | ||
| 2466 | |||
| 2467 | goto try_except_handler_1; | ||
| 2468 | } | ||
| 2469 | exception_type = tmp_raise_type_1; | ||
| 2470 | Py_INCREF( tmp_raise_type_1 ); | ||
| 2471 | exception_value = tmp_raise_value_1; | ||
| 2472 | exception_lineno = 30; | ||
| 2473 | RAISE_EXCEPTION_IMPLICIT( &exception_type, &exception_value, &exception_tb ); | ||
| 2474 | |||
| 2475 | goto try_except_handler_1; | ||
| 2476 | } | ||
| 2477 | branch_no_3:; | ||
| 2478 | } | ||
| 2479 | goto branch_end_2; | ||
| 2480 | branch_no_2:; | ||
| 2481 | { | ||
| 2482 | PyObject *tmp_assign_source_8; | ||
| 2483 | tmp_assign_source_8 = PyDict_New(); | ||
| 2484 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 2485 | tmp_class_creation_1__prepared = tmp_assign_source_8; | ||
| 2486 | } | ||
| 2487 | branch_end_2:; | ||
| 2488 | } | ||
| 2489 | { | ||
| 2490 | PyObject *tmp_assign_source_9; | ||
| 2491 | { | ||
| 2492 | PyObject *tmp_set_locals_1; | ||
| 2493 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 2494 | tmp_set_locals_1 = tmp_class_creation_1__prepared; | ||
| 2495 | locals_gi$_error_30 = tmp_set_locals_1; | ||
| 2496 | Py_INCREF( tmp_set_locals_1 ); | ||
| 2497 | } | ||
| 2498 | // Tried code: | ||
| 2499 | // Tried code: | ||
| 2500 | tmp_dictset_value = const_str_digest_a9b7b3db680a6120a08bd1702778dec5; | ||
| 2501 | tmp_res = PyObject_SetItem( locals_gi$_error_30, const_str_plain___module__, tmp_dictset_value ); | ||
| 2502 | if ( tmp_res != 0 ) | ||
| 2503 | { | ||
| 2504 | assert( ERROR_OCCURRED() ); | ||
| 2505 | |||
| 2506 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2507 | |||
| 2508 | |||
| 2509 | exception_lineno = 30; | ||
| 2510 | |||
| 2511 | goto try_except_handler_3; | ||
| 2512 | } | ||
| 2513 | tmp_dictset_value = const_str_plain_GError; | ||
| 2514 | tmp_res = PyObject_SetItem( locals_gi$_error_30, const_str_plain___qualname__, tmp_dictset_value ); | ||
| 2515 | if ( tmp_res != 0 ) | ||
| 2516 | { | ||
| 2517 | assert( ERROR_OCCURRED() ); | ||
| 2518 | |||
| 2519 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2520 | |||
| 2521 | |||
| 2522 | exception_lineno = 30; | ||
| 2523 | |||
| 2524 | goto try_except_handler_3; | ||
| 2525 | } | ||
| 2526 | MAKE_OR_REUSE_FRAME( cache_frame_642fa75cb43d28afa93ff29e67523814_2, codeobj_642fa75cb43d28afa93ff29e67523814, module_gi$_error, sizeof(void *) ); | ||
| 2527 | frame_642fa75cb43d28afa93ff29e67523814_2 = cache_frame_642fa75cb43d28afa93ff29e67523814_2; | ||
| 2528 | |||
| 2529 | // Push the new frame as the currently active one. | ||
| 2530 | pushFrameStack( frame_642fa75cb43d28afa93ff29e67523814_2 ); | ||
| 2531 | |||
| 2532 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 2533 | assert( Py_REFCNT( frame_642fa75cb43d28afa93ff29e67523814_2 ) == 2 ); // Frame stack | ||
| 2534 | |||
| 2535 | // Framed code: | ||
| 2536 | { | ||
| 2537 | PyObject *tmp_defaults_1; | ||
| 2538 | tmp_defaults_1 = const_tuple_49b8833ad751fd7237ea8d13ccb226e2_tuple; | ||
| 2539 | Py_INCREF( tmp_defaults_1 ); | ||
| 2540 | tmp_dictset_value = MAKE_FUNCTION_gi$_error$$$function_1___init__( tmp_defaults_1 ); | ||
| 2541 | |||
| 2542 | |||
| 2543 | |||
| 2544 | tmp_res = PyObject_SetItem( locals_gi$_error_30, const_str_plain___init__, tmp_dictset_value ); | ||
| 2545 | Py_DECREF( tmp_dictset_value ); | ||
| 2546 | if ( tmp_res != 0 ) | ||
| 2547 | { | ||
| 2548 | assert( ERROR_OCCURRED() ); | ||
| 2549 | |||
| 2550 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2551 | |||
| 2552 | |||
| 2553 | exception_lineno = 31; | ||
| 2554 | type_description_2 = "o"; | ||
| 2555 | goto frame_exception_exit_2; | ||
| 2556 | } | ||
| 2557 | } | ||
| 2558 | tmp_dictset_value = MAKE_FUNCTION_gi$_error$$$function_2___str__( ); | ||
| 2559 | |||
| 2560 | |||
| 2561 | |||
| 2562 | tmp_res = PyObject_SetItem( locals_gi$_error_30, const_str_plain___str__, tmp_dictset_value ); | ||
| 2563 | Py_DECREF( tmp_dictset_value ); | ||
| 2564 | if ( tmp_res != 0 ) | ||
| 2565 | { | ||
| 2566 | assert( ERROR_OCCURRED() ); | ||
| 2567 | |||
| 2568 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2569 | |||
| 2570 | |||
| 2571 | exception_lineno = 37; | ||
| 2572 | type_description_2 = "o"; | ||
| 2573 | goto frame_exception_exit_2; | ||
| 2574 | } | ||
| 2575 | tmp_dictset_value = MAKE_FUNCTION_gi$_error$$$function_3___repr__( ); | ||
| 2576 | |||
| 2577 | |||
| 2578 | |||
| 2579 | tmp_res = PyObject_SetItem( locals_gi$_error_30, const_str_plain___repr__, tmp_dictset_value ); | ||
| 2580 | Py_DECREF( tmp_dictset_value ); | ||
| 2581 | if ( tmp_res != 0 ) | ||
| 2582 | { | ||
| 2583 | assert( ERROR_OCCURRED() ); | ||
| 2584 | |||
| 2585 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2586 | |||
| 2587 | |||
| 2588 | exception_lineno = 40; | ||
| 2589 | type_description_2 = "o"; | ||
| 2590 | goto frame_exception_exit_2; | ||
| 2591 | } | ||
| 2592 | tmp_dictset_value = MAKE_FUNCTION_gi$_error$$$function_4_copy( ); | ||
| 2593 | |||
| 2594 | |||
| 2595 | |||
| 2596 | tmp_res = PyObject_SetItem( locals_gi$_error_30, const_str_plain_copy, tmp_dictset_value ); | ||
| 2597 | Py_DECREF( tmp_dictset_value ); | ||
| 2598 | if ( tmp_res != 0 ) | ||
| 2599 | { | ||
| 2600 | assert( ERROR_OCCURRED() ); | ||
| 2601 | |||
| 2602 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2603 | |||
| 2604 | |||
| 2605 | exception_lineno = 45; | ||
| 2606 | type_description_2 = "o"; | ||
| 2607 | goto frame_exception_exit_2; | ||
| 2608 | } | ||
| 2609 | tmp_dictset_value = MAKE_FUNCTION_gi$_error$$$function_5_matches( ); | ||
| 2610 | |||
| 2611 | |||
| 2612 | |||
| 2613 | tmp_res = PyObject_SetItem( locals_gi$_error_30, const_str_plain_matches, tmp_dictset_value ); | ||
| 2614 | Py_DECREF( tmp_dictset_value ); | ||
| 2615 | if ( tmp_res != 0 ) | ||
| 2616 | { | ||
| 2617 | assert( ERROR_OCCURRED() ); | ||
| 2618 | |||
| 2619 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2620 | |||
| 2621 | |||
| 2622 | exception_lineno = 48; | ||
| 2623 | type_description_2 = "o"; | ||
| 2624 | goto frame_exception_exit_2; | ||
| 2625 | } | ||
| 2626 | { | ||
| 2627 | nuitka_bool tmp_condition_result_6; | ||
| 2628 | PyObject *tmp_called_name_2; | ||
| 2629 | PyObject *tmp_args_element_name_1; | ||
| 2630 | PyObject *tmp_staticmethod_arg_1; | ||
| 2631 | tmp_res = MAPPING_HAS_ITEM( locals_gi$_error_30, const_str_plain_staticmethod ); | ||
| 2632 | |||
| 2633 | if ( tmp_res == -1 ) | ||
| 2634 | { | ||
| 2635 | assert( ERROR_OCCURRED() ); | ||
| 2636 | |||
| 2637 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2638 | |||
| 2639 | |||
| 2640 | exception_lineno = 52; | ||
| 2641 | type_description_2 = "o"; | ||
| 2642 | goto frame_exception_exit_2; | ||
| 2643 | } | ||
| 2644 | tmp_condition_result_6 = ( tmp_res == 1 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2645 | if ( tmp_condition_result_6 == NUITKA_BOOL_TRUE ) | ||
| 2646 | { | ||
| 2647 | goto condexpr_true_3; | ||
| 2648 | } | ||
| 2649 | else | ||
| 2650 | { | ||
| 2651 | goto condexpr_false_3; | ||
| 2652 | } | ||
| 2653 | condexpr_true_3:; | ||
| 2654 | tmp_called_name_2 = PyObject_GetItem( locals_gi$_error_30, const_str_plain_staticmethod ); | ||
| 2655 | |||
| 2656 | if ( tmp_called_name_2 == NULL && CHECK_AND_CLEAR_KEY_ERROR_OCCURRED() ) | ||
| 2657 | { | ||
| 2658 | |||
| 2659 | exception_type = PyExc_NameError; | ||
| 2660 | Py_INCREF( exception_type ); | ||
| 2661 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "staticmethod" ); | ||
| 2662 | exception_tb = NULL; | ||
| 2663 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2664 | CHAIN_EXCEPTION( exception_value ); | ||
| 2665 | |||
| 2666 | exception_lineno = 52; | ||
| 2667 | type_description_2 = "o"; | ||
| 2668 | goto frame_exception_exit_2; | ||
| 2669 | } | ||
| 2670 | |||
| 2671 | if ( tmp_called_name_2 == NULL ) | ||
| 2672 | { | ||
| 2673 | assert( ERROR_OCCURRED() ); | ||
| 2674 | |||
| 2675 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2676 | |||
| 2677 | |||
| 2678 | exception_lineno = 52; | ||
| 2679 | type_description_2 = "o"; | ||
| 2680 | goto frame_exception_exit_2; | ||
| 2681 | } | ||
| 2682 | tmp_args_element_name_1 = MAKE_FUNCTION_gi$_error$$$function_6_new_literal( ); | ||
| 2683 | |||
| 2684 | |||
| 2685 | |||
| 2686 | frame_642fa75cb43d28afa93ff29e67523814_2->m_frame.f_lineno = 52; | ||
| 2687 | { | ||
| 2688 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 2689 | tmp_dictset_value = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_2, call_args ); | ||
| 2690 | } | ||
| 2691 | |||
| 2692 | Py_DECREF( tmp_called_name_2 ); | ||
| 2693 | Py_DECREF( tmp_args_element_name_1 ); | ||
| 2694 | if ( tmp_dictset_value == NULL ) | ||
| 2695 | { | ||
| 2696 | assert( ERROR_OCCURRED() ); | ||
| 2697 | |||
| 2698 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2699 | |||
| 2700 | |||
| 2701 | exception_lineno = 52; | ||
| 2702 | type_description_2 = "o"; | ||
| 2703 | goto frame_exception_exit_2; | ||
| 2704 | } | ||
| 2705 | goto condexpr_end_3; | ||
| 2706 | condexpr_false_3:; | ||
| 2707 | tmp_staticmethod_arg_1 = MAKE_FUNCTION_gi$_error$$$function_6_new_literal( ); | ||
| 2708 | |||
| 2709 | |||
| 2710 | |||
| 2711 | tmp_dictset_value = BUILTIN_STATICMETHOD( tmp_staticmethod_arg_1 ); | ||
| 2712 | Py_DECREF( tmp_staticmethod_arg_1 ); | ||
| 2713 | if ( tmp_dictset_value == NULL ) | ||
| 2714 | { | ||
| 2715 | assert( ERROR_OCCURRED() ); | ||
| 2716 | |||
| 2717 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2718 | |||
| 2719 | |||
| 2720 | exception_lineno = 52; | ||
| 2721 | type_description_2 = "o"; | ||
| 2722 | goto frame_exception_exit_2; | ||
| 2723 | } | ||
| 2724 | condexpr_end_3:; | ||
| 2725 | tmp_res = PyObject_SetItem( locals_gi$_error_30, const_str_plain_new_literal, tmp_dictset_value ); | ||
| 2726 | Py_DECREF( tmp_dictset_value ); | ||
| 2727 | if ( tmp_res != 0 ) | ||
| 2728 | { | ||
| 2729 | assert( ERROR_OCCURRED() ); | ||
| 2730 | |||
| 2731 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2732 | |||
| 2733 | |||
| 2734 | exception_lineno = 52; | ||
| 2735 | type_description_2 = "o"; | ||
| 2736 | goto frame_exception_exit_2; | ||
| 2737 | } | ||
| 2738 | } | ||
| 2739 | |||
| 2740 | #if 0 | ||
| 2741 | RESTORE_FRAME_EXCEPTION( frame_642fa75cb43d28afa93ff29e67523814_2 ); | ||
| 2742 | #endif | ||
| 2743 | |||
| 2744 | // Put the previous frame back on top. | ||
| 2745 | popFrameStack(); | ||
| 2746 | |||
| 2747 | goto frame_no_exception_1; | ||
| 2748 | |||
| 2749 | frame_exception_exit_2:; | ||
| 2750 | |||
| 2751 | #if 0 | ||
| 2752 | RESTORE_FRAME_EXCEPTION( frame_642fa75cb43d28afa93ff29e67523814_2 ); | ||
| 2753 | #endif | ||
| 2754 | |||
| 2755 | if ( exception_tb == NULL ) | ||
| 2756 | { | ||
| 2757 | exception_tb = MAKE_TRACEBACK( frame_642fa75cb43d28afa93ff29e67523814_2, exception_lineno ); | ||
| 2758 | } | ||
| 2759 | else if ( exception_tb->tb_frame != &frame_642fa75cb43d28afa93ff29e67523814_2->m_frame ) | ||
| 2760 | { | ||
| 2761 | exception_tb = ADD_TRACEBACK( exception_tb, frame_642fa75cb43d28afa93ff29e67523814_2, exception_lineno ); | ||
| 2762 | } | ||
| 2763 | |||
| 2764 | // Attachs locals to frame if any. | ||
| 2765 | Nuitka_Frame_AttachLocals( | ||
| 2766 | (struct Nuitka_FrameObject *)frame_642fa75cb43d28afa93ff29e67523814_2, | ||
| 2767 | type_description_2, | ||
| 2768 | outline_0_var___class__ | ||
| 2769 | ); | ||
| 2770 | |||
| 2771 | |||
| 2772 | // Release cached frame. | ||
| 2773 | if ( frame_642fa75cb43d28afa93ff29e67523814_2 == cache_frame_642fa75cb43d28afa93ff29e67523814_2 ) | ||
| 2774 | { | ||
| 2775 | Py_DECREF( frame_642fa75cb43d28afa93ff29e67523814_2 ); | ||
| 2776 | } | ||
| 2777 | cache_frame_642fa75cb43d28afa93ff29e67523814_2 = NULL; | ||
| 2778 | |||
| 2779 | assertFrameObject( frame_642fa75cb43d28afa93ff29e67523814_2 ); | ||
| 2780 | |||
| 2781 | // Put the previous frame back on top. | ||
| 2782 | popFrameStack(); | ||
| 2783 | |||
| 2784 | // Return the error. | ||
| 2785 | goto nested_frame_exit_1; | ||
| 2786 | |||
| 2787 | frame_no_exception_1:; | ||
| 2788 | goto skip_nested_handling_1; | ||
| 2789 | nested_frame_exit_1:; | ||
| 2790 | |||
| 2791 | goto try_except_handler_3; | ||
| 2792 | skip_nested_handling_1:; | ||
| 2793 | { | ||
| 2794 | nuitka_bool tmp_condition_result_7; | ||
| 2795 | PyObject *tmp_compexpr_left_1; | ||
| 2796 | PyObject *tmp_compexpr_right_1; | ||
| 2797 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 2798 | tmp_compexpr_left_1 = tmp_class_creation_1__bases; | ||
| 2799 | tmp_compexpr_right_1 = const_tuple_type_RuntimeError_tuple; | ||
| 2800 | tmp_res = RICH_COMPARE_BOOL_NOTEQ_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 2801 | if ( tmp_res == -1 ) | ||
| 2802 | { | ||
| 2803 | assert( ERROR_OCCURRED() ); | ||
| 2804 | |||
| 2805 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2806 | |||
| 2807 | |||
| 2808 | exception_lineno = 30; | ||
| 2809 | |||
| 2810 | goto try_except_handler_3; | ||
| 2811 | } | ||
| 2812 | tmp_condition_result_7 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2813 | if ( tmp_condition_result_7 == NUITKA_BOOL_TRUE ) | ||
| 2814 | { | ||
| 2815 | goto branch_yes_4; | ||
| 2816 | } | ||
| 2817 | else | ||
| 2818 | { | ||
| 2819 | goto branch_no_4; | ||
| 2820 | } | ||
| 2821 | branch_yes_4:; | ||
| 2822 | tmp_dictset_value = const_tuple_type_RuntimeError_tuple; | ||
| 2823 | tmp_res = PyObject_SetItem( locals_gi$_error_30, const_str_plain___orig_bases__, tmp_dictset_value ); | ||
| 2824 | if ( tmp_res != 0 ) | ||
| 2825 | { | ||
| 2826 | assert( ERROR_OCCURRED() ); | ||
| 2827 | |||
| 2828 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2829 | |||
| 2830 | |||
| 2831 | exception_lineno = 30; | ||
| 2832 | |||
| 2833 | goto try_except_handler_3; | ||
| 2834 | } | ||
| 2835 | branch_no_4:; | ||
| 2836 | } | ||
| 2837 | { | ||
| 2838 | PyObject *tmp_assign_source_10; | ||
| 2839 | PyObject *tmp_called_name_3; | ||
| 2840 | PyObject *tmp_args_name_2; | ||
| 2841 | PyObject *tmp_tuple_element_3; | ||
| 2842 | PyObject *tmp_kw_name_2; | ||
| 2843 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 2844 | tmp_called_name_3 = tmp_class_creation_1__metaclass; | ||
| 2845 | tmp_tuple_element_3 = const_str_plain_GError; | ||
| 2846 | tmp_args_name_2 = PyTuple_New( 3 ); | ||
| 2847 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 2848 | PyTuple_SET_ITEM( tmp_args_name_2, 0, tmp_tuple_element_3 ); | ||
| 2849 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 2850 | tmp_tuple_element_3 = tmp_class_creation_1__bases; | ||
| 2851 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 2852 | PyTuple_SET_ITEM( tmp_args_name_2, 1, tmp_tuple_element_3 ); | ||
| 2853 | tmp_tuple_element_3 = locals_gi$_error_30; | ||
| 2854 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 2855 | PyTuple_SET_ITEM( tmp_args_name_2, 2, tmp_tuple_element_3 ); | ||
| 2856 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 2857 | tmp_kw_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 2858 | frame_aafd294a192c701bd13d3c8b93cd1b82->m_frame.f_lineno = 30; | ||
| 2859 | tmp_assign_source_10 = CALL_FUNCTION( tmp_called_name_3, tmp_args_name_2, tmp_kw_name_2 ); | ||
| 2860 | Py_DECREF( tmp_args_name_2 ); | ||
| 2861 | if ( tmp_assign_source_10 == NULL ) | ||
| 2862 | { | ||
| 2863 | assert( ERROR_OCCURRED() ); | ||
| 2864 | |||
| 2865 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2866 | |||
| 2867 | |||
| 2868 | exception_lineno = 30; | ||
| 2869 | |||
| 2870 | goto try_except_handler_3; | ||
| 2871 | } | ||
| 2872 | assert( outline_0_var___class__ == NULL ); | ||
| 2873 | outline_0_var___class__ = tmp_assign_source_10; | ||
| 2874 | } | ||
| 2875 | CHECK_OBJECT( outline_0_var___class__ ); | ||
| 2876 | tmp_assign_source_9 = outline_0_var___class__; | ||
| 2877 | Py_INCREF( tmp_assign_source_9 ); | ||
| 2878 | goto try_return_handler_3; | ||
| 2879 | // tried codes exits in all cases | ||
| 2880 | NUITKA_CANNOT_GET_HERE( gi$_error ); | ||
| 2881 | return MOD_RETURN_VALUE( NULL ); | ||
| 2882 | // Return handler code: | ||
| 2883 | try_return_handler_3:; | ||
| 2884 | Py_DECREF( locals_gi$_error_30 ); | ||
| 2885 | locals_gi$_error_30 = NULL; | ||
| 2886 | goto try_return_handler_2; | ||
| 2887 | // Exception handler code: | ||
| 2888 | try_except_handler_3:; | ||
| 2889 | exception_keeper_type_1 = exception_type; | ||
| 2890 | exception_keeper_value_1 = exception_value; | ||
| 2891 | exception_keeper_tb_1 = exception_tb; | ||
| 2892 | exception_keeper_lineno_1 = exception_lineno; | ||
| 2893 | exception_type = NULL; | ||
| 2894 | exception_value = NULL; | ||
| 2895 | exception_tb = NULL; | ||
| 2896 | exception_lineno = 0; | ||
| 2897 | |||
| 2898 | Py_DECREF( locals_gi$_error_30 ); | ||
| 2899 | locals_gi$_error_30 = NULL; | ||
| 2900 | // Re-raise. | ||
| 2901 | exception_type = exception_keeper_type_1; | ||
| 2902 | exception_value = exception_keeper_value_1; | ||
| 2903 | exception_tb = exception_keeper_tb_1; | ||
| 2904 | exception_lineno = exception_keeper_lineno_1; | ||
| 2905 | |||
| 2906 | goto try_except_handler_2; | ||
| 2907 | // End of try: | ||
| 2908 | // tried codes exits in all cases | ||
| 2909 | NUITKA_CANNOT_GET_HERE( gi$_error ); | ||
| 2910 | return MOD_RETURN_VALUE( NULL ); | ||
| 2911 | // Return handler code: | ||
| 2912 | try_return_handler_2:; | ||
| 2913 | CHECK_OBJECT( (PyObject *)outline_0_var___class__ ); | ||
| 2914 | Py_DECREF( outline_0_var___class__ ); | ||
| 2915 | outline_0_var___class__ = NULL; | ||
| 2916 | |||
| 2917 | goto outline_result_1; | ||
| 2918 | // Exception handler code: | ||
| 2919 | try_except_handler_2:; | ||
| 2920 | exception_keeper_type_2 = exception_type; | ||
| 2921 | exception_keeper_value_2 = exception_value; | ||
| 2922 | exception_keeper_tb_2 = exception_tb; | ||
| 2923 | exception_keeper_lineno_2 = exception_lineno; | ||
| 2924 | exception_type = NULL; | ||
| 2925 | exception_value = NULL; | ||
| 2926 | exception_tb = NULL; | ||
| 2927 | exception_lineno = 0; | ||
| 2928 | |||
| 2929 | // Re-raise. | ||
| 2930 | exception_type = exception_keeper_type_2; | ||
| 2931 | exception_value = exception_keeper_value_2; | ||
| 2932 | exception_tb = exception_keeper_tb_2; | ||
| 2933 | exception_lineno = exception_keeper_lineno_2; | ||
| 2934 | |||
| 2935 | goto outline_exception_1; | ||
| 2936 | // End of try: | ||
| 2937 | // Return statement must have exited already. | ||
| 2938 | NUITKA_CANNOT_GET_HERE( gi$_error ); | ||
| 2939 | return MOD_RETURN_VALUE( NULL ); | ||
| 2940 | outline_exception_1:; | ||
| 2941 | exception_lineno = 30; | ||
| 2942 | goto try_except_handler_1; | ||
| 2943 | outline_result_1:; | ||
| 2944 | UPDATE_STRING_DICT1( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain_GError, tmp_assign_source_9 ); | ||
| 2945 | } | ||
| 2946 | goto try_end_1; | ||
| 2947 | // Exception handler code: | ||
| 2948 | try_except_handler_1:; | ||
| 2949 | exception_keeper_type_3 = exception_type; | ||
| 2950 | exception_keeper_value_3 = exception_value; | ||
| 2951 | exception_keeper_tb_3 = exception_tb; | ||
| 2952 | exception_keeper_lineno_3 = exception_lineno; | ||
| 2953 | exception_type = NULL; | ||
| 2954 | exception_value = NULL; | ||
| 2955 | exception_tb = NULL; | ||
| 2956 | exception_lineno = 0; | ||
| 2957 | |||
| 2958 | Py_XDECREF( tmp_class_creation_1__bases ); | ||
| 2959 | tmp_class_creation_1__bases = NULL; | ||
| 2960 | |||
| 2961 | Py_XDECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 2962 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 2963 | |||
| 2964 | Py_XDECREF( tmp_class_creation_1__metaclass ); | ||
| 2965 | tmp_class_creation_1__metaclass = NULL; | ||
| 2966 | |||
| 2967 | Py_XDECREF( tmp_class_creation_1__prepared ); | ||
| 2968 | tmp_class_creation_1__prepared = NULL; | ||
| 2969 | |||
| 2970 | // Re-raise. | ||
| 2971 | exception_type = exception_keeper_type_3; | ||
| 2972 | exception_value = exception_keeper_value_3; | ||
| 2973 | exception_tb = exception_keeper_tb_3; | ||
| 2974 | exception_lineno = exception_keeper_lineno_3; | ||
| 2975 | |||
| 2976 | goto frame_exception_exit_1; | ||
| 2977 | // End of try: | ||
| 2978 | try_end_1:; | ||
| 2979 | |||
| 2980 | // Restore frame exception if necessary. | ||
| 2981 | #if 0 | ||
| 2982 | RESTORE_FRAME_EXCEPTION( frame_aafd294a192c701bd13d3c8b93cd1b82 ); | ||
| 2983 | #endif | ||
| 2984 | popFrameStack(); | ||
| 2985 | |||
| 2986 | assertFrameObject( frame_aafd294a192c701bd13d3c8b93cd1b82 ); | ||
| 2987 | |||
| 2988 | goto frame_no_exception_2; | ||
| 2989 | |||
| 2990 | frame_exception_exit_1:; | ||
| 2991 | #if 0 | ||
| 2992 | RESTORE_FRAME_EXCEPTION( frame_aafd294a192c701bd13d3c8b93cd1b82 ); | ||
| 2993 | #endif | ||
| 2994 | |||
| 2995 | if ( exception_tb == NULL ) | ||
| 2996 | { | ||
| 2997 | exception_tb = MAKE_TRACEBACK( frame_aafd294a192c701bd13d3c8b93cd1b82, exception_lineno ); | ||
| 2998 | } | ||
| 2999 | else if ( exception_tb->tb_frame != &frame_aafd294a192c701bd13d3c8b93cd1b82->m_frame ) | ||
| 3000 | { | ||
| 3001 | exception_tb = ADD_TRACEBACK( exception_tb, frame_aafd294a192c701bd13d3c8b93cd1b82, exception_lineno ); | ||
| 3002 | } | ||
| 3003 | |||
| 3004 | // Put the previous frame back on top. | ||
| 3005 | popFrameStack(); | ||
| 3006 | |||
| 3007 | // Return the error. | ||
| 3008 | goto module_exception_exit; | ||
| 3009 | |||
| 3010 | frame_no_exception_2:; | ||
| 3011 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__bases ); | ||
| 3012 | Py_DECREF( tmp_class_creation_1__bases ); | ||
| 3013 | tmp_class_creation_1__bases = NULL; | ||
| 3014 | |||
| 3015 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__class_decl_dict ); | ||
| 3016 | Py_DECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 3017 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 3018 | |||
| 3019 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__metaclass ); | ||
| 3020 | Py_DECREF( tmp_class_creation_1__metaclass ); | ||
| 3021 | tmp_class_creation_1__metaclass = NULL; | ||
| 3022 | |||
| 3023 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__prepared ); | ||
| 3024 | Py_DECREF( tmp_class_creation_1__prepared ); | ||
| 3025 | tmp_class_creation_1__prepared = NULL; | ||
| 3026 | |||
| 3027 | |||
| 3028 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 3029 | #if 0 && 0 | ||
| 3030 | { | ||
| 3031 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_gi$_error, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 3032 | |||
| 3033 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 3034 | { | ||
| 3035 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 3036 | |||
| 3037 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 3038 | CHECK_OBJECT( path_importer_cache ); | ||
| 3039 | |||
| 3040 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 3041 | assert( res == 0 ); | ||
| 3042 | } | ||
| 3043 | } | ||
| 3044 | #endif | ||
| 3045 | #endif | ||
| 3046 | |||
| 3047 | return MOD_RETURN_VALUE( module_gi$_error ); | ||
| 3048 | module_exception_exit: | ||
| 3049 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 3050 | return MOD_RETURN_VALUE( NULL ); | ||
| 3051 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.gi._error.o deleted (index 8b89d00..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.gi._propertyhelper.c is too big (17841 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.gi._propertyhelper.o deleted (index 6a33b19..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.gi._signalhelper.c is too big (10787 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.gi._signalhelper.o deleted (index 818ff1c..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.gi.c is too big (6401 changes) and cannot be shown. |
| The diff for file Linux_Version/inventory_synchronisation.build/module.gi.docstring.c is too big (7426 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.gi.docstring.o deleted (index 109ce47..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.gi.importer.c is too big (6160 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.gi.importer.o deleted (index 636e8bf..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.gi.module.c is too big (10033 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.gi.module.o deleted (index 3ae0e56..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.gi.o deleted (index b04fbf6..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.gi.overrides.c is too big (15056 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.gi.overrides.o deleted (index 21117e1..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.gi.repository.c deleted (index f86d734..0000000) | |||
| 1 | /* Generated code for Python module 'gi.repository' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_gi$repository" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_gi$repository; | ||
| 31 | PyDictObject *moduledict_gi$repository; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain_environ; | ||
| 35 | extern PyObject *const_str_plain___spec__; | ||
| 36 | extern PyObject *const_str_plain_sys; | ||
| 37 | extern PyObject *const_str_plain_NUITKA_PACKAGE_gi; | ||
| 38 | extern PyObject *const_str_plain___file__; | ||
| 39 | static PyObject *const_str_plain_NUITKA_PACKAGE_gi_repository; | ||
| 40 | extern PyObject *const_str_plain_path; | ||
| 41 | extern PyObject *const_int_0; | ||
| 42 | extern PyObject *const_str_plain_repository; | ||
| 43 | static PyObject *const_str_plain_meta_path; | ||
| 44 | extern PyObject *const_str_digest_66f7aeb02c13e91a30a18f0ea911888b; | ||
| 45 | static PyObject *const_tuple_str_plain_DynamicImporter_tuple; | ||
| 46 | extern PyObject *const_str_plain___doc__; | ||
| 47 | extern PyObject *const_str_plain_DynamicImporter; | ||
| 48 | static PyObject *const_str_digest_8f95551d37969c5f95015e918e838603; | ||
| 49 | extern PyObject *const_str_plain_origin; | ||
| 50 | static PyObject *const_str_digest_03b795a3937010da10f7a96d4258ca81; | ||
| 51 | extern PyObject *const_str_plain_importer; | ||
| 52 | extern PyObject *const_str_digest_5bfaf90dbd407b4fc29090c8f6415242; | ||
| 53 | extern PyObject *const_tuple_0bb929f2f11716c81953a0b7b206d455_tuple; | ||
| 54 | extern PyObject *const_str_plain___path__; | ||
| 55 | extern PyObject *const_tuple_empty; | ||
| 56 | extern PyObject *const_str_plain_get; | ||
| 57 | extern PyObject *const_str_plain_has_location; | ||
| 58 | static PyObject *const_tuple_str_digest_66f7aeb02c13e91a30a18f0ea911888b_tuple; | ||
| 59 | extern PyObject *const_int_pos_2; | ||
| 60 | extern PyObject *const_str_plain_append; | ||
| 61 | extern PyObject *const_str_plain_join; | ||
| 62 | extern PyObject *const_str_plain_dirname; | ||
| 63 | static PyObject *const_tuple_f8b7b4ed70bd5864ef5170077720b8c9_tuple; | ||
| 64 | extern PyObject *const_str_plain_absolute_import; | ||
| 65 | extern PyObject *const_str_plain___cached__; | ||
| 66 | static PyObject *module_filename_obj; | ||
| 67 | |||
| 68 | /* Indicator if this modules private constants were created yet. */ | ||
| 69 | static bool constants_created = false; | ||
| 70 | |||
| 71 | /* Function to create module private constants. */ | ||
| 72 | static void createModuleConstants( void ) | ||
| 73 | { | ||
| 74 | const_str_plain_NUITKA_PACKAGE_gi_repository = UNSTREAM_STRING_ASCII( &constant_bin[ 52159 ], 28, 1 ); | ||
| 75 | const_str_plain_meta_path = UNSTREAM_STRING_ASCII( &constant_bin[ 52187 ], 9, 1 ); | ||
| 76 | const_tuple_str_plain_DynamicImporter_tuple = PyTuple_New( 1 ); | ||
| 77 | PyTuple_SET_ITEM( const_tuple_str_plain_DynamicImporter_tuple, 0, const_str_plain_DynamicImporter ); Py_INCREF( const_str_plain_DynamicImporter ); | ||
| 78 | const_str_digest_8f95551d37969c5f95015e918e838603 = UNSTREAM_STRING_ASCII( &constant_bin[ 52196 ], 22, 0 ); | ||
| 79 | const_str_digest_03b795a3937010da10f7a96d4258ca81 = UNSTREAM_STRING_ASCII( &constant_bin[ 52218 ], 25, 0 ); | ||
| 80 | const_tuple_str_digest_66f7aeb02c13e91a30a18f0ea911888b_tuple = PyTuple_New( 1 ); | ||
| 81 | PyTuple_SET_ITEM( const_tuple_str_digest_66f7aeb02c13e91a30a18f0ea911888b_tuple, 0, const_str_digest_66f7aeb02c13e91a30a18f0ea911888b ); Py_INCREF( const_str_digest_66f7aeb02c13e91a30a18f0ea911888b ); | ||
| 82 | const_tuple_f8b7b4ed70bd5864ef5170077720b8c9_tuple = PyTuple_New( 2 ); | ||
| 83 | PyTuple_SET_ITEM( const_tuple_f8b7b4ed70bd5864ef5170077720b8c9_tuple, 0, const_str_plain_NUITKA_PACKAGE_gi_repository ); Py_INCREF( const_str_plain_NUITKA_PACKAGE_gi_repository ); | ||
| 84 | PyTuple_SET_ITEM( const_tuple_f8b7b4ed70bd5864ef5170077720b8c9_tuple, 1, const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); Py_INCREF( const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); | ||
| 85 | |||
| 86 | constants_created = true; | ||
| 87 | } | ||
| 88 | |||
| 89 | /* Function to verify module private constants for non-corruption. */ | ||
| 90 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 91 | void checkModuleConstants_gi$repository( void ) | ||
| 92 | { | ||
| 93 | // The module may not have been used at all, then ignore this. | ||
| 94 | if (constants_created == false) return; | ||
| 95 | |||
| 96 | |||
| 97 | } | ||
| 98 | #endif | ||
| 99 | |||
| 100 | // The module code objects. | ||
| 101 | static PyCodeObject *codeobj_eb3c08b482b3ef431f85b2d43bf138b7; | ||
| 102 | |||
| 103 | static void createModuleCodeObjects(void) | ||
| 104 | { | ||
| 105 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_03b795a3937010da10f7a96d4258ca81 ); | ||
| 106 | codeobj_eb3c08b482b3ef431f85b2d43bf138b7 = MAKE_CODEOBJ( module_filename_obj, const_str_digest_8f95551d37969c5f95015e918e838603, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 107 | } | ||
| 108 | |||
| 109 | // The module function declarations. | ||
| 110 | |||
| 111 | |||
| 112 | // The module function definitions. | ||
| 113 | |||
| 114 | |||
| 115 | |||
| 116 | #if PYTHON_VERSION >= 300 | ||
| 117 | static struct PyModuleDef mdef_gi$repository = | ||
| 118 | { | ||
| 119 | PyModuleDef_HEAD_INIT, | ||
| 120 | "gi.repository", | ||
| 121 | NULL, /* m_doc */ | ||
| 122 | -1, /* m_size */ | ||
| 123 | NULL, /* m_methods */ | ||
| 124 | NULL, /* m_reload */ | ||
| 125 | NULL, /* m_traverse */ | ||
| 126 | NULL, /* m_clear */ | ||
| 127 | NULL, /* m_free */ | ||
| 128 | }; | ||
| 129 | #endif | ||
| 130 | |||
| 131 | extern PyObject *const_str_plain___compiled__; | ||
| 132 | |||
| 133 | extern PyObject *const_str_plain___package__; | ||
| 134 | |||
| 135 | #if PYTHON_VERSION >= 300 | ||
| 136 | extern PyObject *const_str_dot; | ||
| 137 | extern PyObject *const_str_plain___loader__; | ||
| 138 | #endif | ||
| 139 | |||
| 140 | #if PYTHON_VERSION >= 340 | ||
| 141 | extern PyObject *const_str_plain___spec__; | ||
| 142 | extern PyObject *const_str_plain__initializing; | ||
| 143 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 144 | #endif | ||
| 145 | |||
| 146 | extern void _initCompiledCellType(); | ||
| 147 | extern void _initCompiledGeneratorType(); | ||
| 148 | extern void _initCompiledFunctionType(); | ||
| 149 | extern void _initCompiledMethodType(); | ||
| 150 | extern void _initCompiledFrameType(); | ||
| 151 | #if PYTHON_VERSION >= 350 | ||
| 152 | extern void _initCompiledCoroutineTypes(); | ||
| 153 | #endif | ||
| 154 | #if PYTHON_VERSION >= 360 | ||
| 155 | extern void _initCompiledAsyncgenTypes(); | ||
| 156 | #endif | ||
| 157 | |||
| 158 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 159 | |||
| 160 | // The exported interface to CPython. On import of the module, this function | ||
| 161 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 162 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 163 | |||
| 164 | MOD_INIT_DECL( gi$repository ) | ||
| 165 | { | ||
| 166 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 167 | static bool _init_done = false; | ||
| 168 | |||
| 169 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 170 | if ( _init_done ) | ||
| 171 | { | ||
| 172 | return MOD_RETURN_VALUE( module_gi$repository ); | ||
| 173 | } | ||
| 174 | else | ||
| 175 | { | ||
| 176 | _init_done = true; | ||
| 177 | } | ||
| 178 | #endif | ||
| 179 | |||
| 180 | #ifdef _NUITKA_MODULE | ||
| 181 | // In case of a stand alone extension module, need to call initialization | ||
| 182 | // the init here because that's the first and only time we are going to get | ||
| 183 | // called here. | ||
| 184 | |||
| 185 | // Initialize the constant values used. | ||
| 186 | _initBuiltinModule(); | ||
| 187 | createGlobalConstants(); | ||
| 188 | |||
| 189 | /* Initialize the compiled types of Nuitka. */ | ||
| 190 | _initCompiledCellType(); | ||
| 191 | _initCompiledGeneratorType(); | ||
| 192 | _initCompiledFunctionType(); | ||
| 193 | _initCompiledMethodType(); | ||
| 194 | _initCompiledFrameType(); | ||
| 195 | #if PYTHON_VERSION >= 350 | ||
| 196 | _initCompiledCoroutineTypes(); | ||
| 197 | #endif | ||
| 198 | #if PYTHON_VERSION >= 360 | ||
| 199 | _initCompiledAsyncgenTypes(); | ||
| 200 | #endif | ||
| 201 | |||
| 202 | #if PYTHON_VERSION < 300 | ||
| 203 | _initSlotCompare(); | ||
| 204 | #endif | ||
| 205 | #if PYTHON_VERSION >= 270 | ||
| 206 | _initSlotIternext(); | ||
| 207 | #endif | ||
| 208 | |||
| 209 | patchBuiltinModule(); | ||
| 210 | patchTypeComparison(); | ||
| 211 | |||
| 212 | // Enable meta path based loader if not already done. | ||
| 213 | #ifdef _NUITKA_TRACE | ||
| 214 | puts("gi.repository: Calling setupMetaPathBasedLoader()."); | ||
| 215 | #endif | ||
| 216 | setupMetaPathBasedLoader(); | ||
| 217 | |||
| 218 | #if PYTHON_VERSION >= 300 | ||
| 219 | patchInspectModule(); | ||
| 220 | #endif | ||
| 221 | |||
| 222 | #endif | ||
| 223 | |||
| 224 | /* The constants only used by this module are created now. */ | ||
| 225 | #ifdef _NUITKA_TRACE | ||
| 226 | puts("gi.repository: Calling createModuleConstants()."); | ||
| 227 | #endif | ||
| 228 | createModuleConstants(); | ||
| 229 | |||
| 230 | /* The code objects used by this module are created now. */ | ||
| 231 | #ifdef _NUITKA_TRACE | ||
| 232 | puts("gi.repository: Calling createModuleCodeObjects()."); | ||
| 233 | #endif | ||
| 234 | createModuleCodeObjects(); | ||
| 235 | |||
| 236 | // puts( "in initgi$repository" ); | ||
| 237 | |||
| 238 | // Create the module object first. There are no methods initially, all are | ||
| 239 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 240 | // set at this time, as it could not contain NUL characters this way, they | ||
| 241 | // are instead set in early module code. No "self" for modules, we have no | ||
| 242 | // use for it. | ||
| 243 | #if PYTHON_VERSION < 300 | ||
| 244 | module_gi$repository = Py_InitModule4( | ||
| 245 | "gi.repository", // Module Name | ||
| 246 | NULL, // No methods initially, all are added | ||
| 247 | // dynamically in actual module code only. | ||
| 248 | NULL, // No "__doc__" is initially set, as it could | ||
| 249 | // not contain NUL this way, added early in | ||
| 250 | // actual code. | ||
| 251 | NULL, // No self for modules, we don't use it. | ||
| 252 | PYTHON_API_VERSION | ||
| 253 | ); | ||
| 254 | #else | ||
| 255 | |||
| 256 | module_gi$repository = PyModule_Create( &mdef_gi$repository ); | ||
| 257 | #endif | ||
| 258 | |||
| 259 | moduledict_gi$repository = MODULE_DICT( module_gi$repository ); | ||
| 260 | |||
| 261 | // Set __compiled__ to what it we know. | ||
| 262 | UPDATE_STRING_DICT1( | ||
| 263 | moduledict_gi$repository, | ||
| 264 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 265 | Nuitka_dunder_compiled_value | ||
| 266 | ); | ||
| 267 | |||
| 268 | // Update "__package__" value to what it ought to be. | ||
| 269 | { | ||
| 270 | #if 1 | ||
| 271 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 272 | |||
| 273 | UPDATE_STRING_DICT1( | ||
| 274 | moduledict_gi$repository, | ||
| 275 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 276 | module_name | ||
| 277 | ); | ||
| 278 | #else | ||
| 279 | |||
| 280 | #if PYTHON_VERSION < 300 | ||
| 281 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 282 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 283 | |||
| 284 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 285 | |||
| 286 | if ( last_dot != NULL ) | ||
| 287 | { | ||
| 288 | UPDATE_STRING_DICT1( | ||
| 289 | moduledict_gi$repository, | ||
| 290 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 291 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 292 | ); | ||
| 293 | } | ||
| 294 | #else | ||
| 295 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 296 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 297 | |||
| 298 | if ( dot_index != -1 ) | ||
| 299 | { | ||
| 300 | UPDATE_STRING_DICT1( | ||
| 301 | moduledict_gi$repository, | ||
| 302 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 303 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 304 | ); | ||
| 305 | } | ||
| 306 | #endif | ||
| 307 | #endif | ||
| 308 | } | ||
| 309 | |||
| 310 | CHECK_OBJECT( module_gi$repository ); | ||
| 311 | |||
| 312 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 313 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 314 | #if PYTHON_VERSION >= 300 | ||
| 315 | { | ||
| 316 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_66f7aeb02c13e91a30a18f0ea911888b, module_gi$repository ); | ||
| 317 | |||
| 318 | assert( r != -1 ); | ||
| 319 | } | ||
| 320 | #endif | ||
| 321 | |||
| 322 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 323 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 324 | // before the frame object is allocated, or else it may fail. | ||
| 325 | |||
| 326 | if ( GET_STRING_DICT_VALUE( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 327 | { | ||
| 328 | PyObject *value = (PyObject *)builtin_module; | ||
| 329 | |||
| 330 | // Check if main module, not a dict then but the module itself. | ||
| 331 | #if !defined(_NUITKA_EXE) || !0 | ||
| 332 | value = PyModule_GetDict( value ); | ||
| 333 | #endif | ||
| 334 | |||
| 335 | UPDATE_STRING_DICT0( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 336 | } | ||
| 337 | |||
| 338 | #if PYTHON_VERSION >= 300 | ||
| 339 | UPDATE_STRING_DICT0( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 340 | #endif | ||
| 341 | |||
| 342 | #if PYTHON_VERSION >= 340 | ||
| 343 | // Set the "__spec__" value | ||
| 344 | |||
| 345 | #if 0 | ||
| 346 | // Main modules just get "None" as spec. | ||
| 347 | UPDATE_STRING_DICT0( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 348 | #else | ||
| 349 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 350 | { | ||
| 351 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 352 | CHECK_OBJECT( bootstrap_module ); | ||
| 353 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 354 | Py_DECREF( bootstrap_module ); | ||
| 355 | |||
| 356 | PyObject *args[] = { | ||
| 357 | GET_STRING_DICT_VALUE( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 358 | (PyObject *)&Nuitka_Loader_Type | ||
| 359 | }; | ||
| 360 | |||
| 361 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 362 | module_spec_class, | ||
| 363 | args | ||
| 364 | ); | ||
| 365 | Py_DECREF( module_spec_class ); | ||
| 366 | |||
| 367 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 368 | CHECK_OBJECT( spec_value ); | ||
| 369 | |||
| 370 | // For packages set the submodule search locations as well, even if to empty | ||
| 371 | // list, so investigating code will consider it a package. | ||
| 372 | #if 1 | ||
| 373 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 374 | #endif | ||
| 375 | |||
| 376 | // Mark the execution in the "__spec__" value. | ||
| 377 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 378 | |||
| 379 | UPDATE_STRING_DICT1( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 380 | } | ||
| 381 | #endif | ||
| 382 | #endif | ||
| 383 | |||
| 384 | // Temp variables if any | ||
| 385 | struct Nuitka_FrameObject *frame_eb3c08b482b3ef431f85b2d43bf138b7; | ||
| 386 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 387 | PyObject *exception_type = NULL; | ||
| 388 | PyObject *exception_value = NULL; | ||
| 389 | PyTracebackObject *exception_tb = NULL; | ||
| 390 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 391 | bool tmp_result; | ||
| 392 | int tmp_res; | ||
| 393 | |||
| 394 | // Module code. | ||
| 395 | { | ||
| 396 | PyObject *tmp_assign_source_1; | ||
| 397 | tmp_assign_source_1 = Py_None; | ||
| 398 | UPDATE_STRING_DICT0( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 399 | } | ||
| 400 | { | ||
| 401 | PyObject *tmp_assign_source_2; | ||
| 402 | tmp_assign_source_2 = module_filename_obj; | ||
| 403 | UPDATE_STRING_DICT0( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 404 | } | ||
| 405 | // Frame without reuse. | ||
| 406 | frame_eb3c08b482b3ef431f85b2d43bf138b7 = MAKE_MODULE_FRAME( codeobj_eb3c08b482b3ef431f85b2d43bf138b7, module_gi$repository ); | ||
| 407 | |||
| 408 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 409 | // owning it. | ||
| 410 | pushFrameStack( frame_eb3c08b482b3ef431f85b2d43bf138b7 ); | ||
| 411 | assert( Py_REFCNT( frame_eb3c08b482b3ef431f85b2d43bf138b7 ) == 2 ); | ||
| 412 | |||
| 413 | // Framed code: | ||
| 414 | { | ||
| 415 | PyObject *tmp_assign_source_3; | ||
| 416 | PyObject *tmp_list_element_1; | ||
| 417 | PyObject *tmp_called_name_1; | ||
| 418 | PyObject *tmp_source_name_1; | ||
| 419 | PyObject *tmp_args_element_name_1; | ||
| 420 | PyObject *tmp_called_name_2; | ||
| 421 | PyObject *tmp_source_name_2; | ||
| 422 | PyObject *tmp_args_element_name_2; | ||
| 423 | PyObject *tmp_called_instance_1; | ||
| 424 | PyObject *tmp_args_element_name_3; | ||
| 425 | PyObject *tmp_called_instance_2; | ||
| 426 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 1; | ||
| 427 | { | ||
| 428 | PyObject *module = PyImport_ImportModule("os"); | ||
| 429 | if (likely( module != NULL )) | ||
| 430 | { | ||
| 431 | tmp_source_name_1 = PyObject_GetAttr( module, const_str_plain_path ); | ||
| 432 | } | ||
| 433 | else | ||
| 434 | { | ||
| 435 | tmp_source_name_1 = NULL; | ||
| 436 | } | ||
| 437 | } | ||
| 438 | |||
| 439 | if ( tmp_source_name_1 == NULL ) | ||
| 440 | { | ||
| 441 | assert( ERROR_OCCURRED() ); | ||
| 442 | |||
| 443 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 444 | |||
| 445 | |||
| 446 | exception_lineno = 1; | ||
| 447 | |||
| 448 | goto frame_exception_exit_1; | ||
| 449 | } | ||
| 450 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_dirname ); | ||
| 451 | if ( tmp_called_name_1 == NULL ) | ||
| 452 | { | ||
| 453 | assert( ERROR_OCCURRED() ); | ||
| 454 | |||
| 455 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 456 | |||
| 457 | |||
| 458 | exception_lineno = 1; | ||
| 459 | |||
| 460 | goto frame_exception_exit_1; | ||
| 461 | } | ||
| 462 | tmp_args_element_name_1 = module_filename_obj; | ||
| 463 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 1; | ||
| 464 | { | ||
| 465 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 466 | tmp_list_element_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, call_args ); | ||
| 467 | } | ||
| 468 | |||
| 469 | Py_DECREF( tmp_called_name_1 ); | ||
| 470 | if ( tmp_list_element_1 == NULL ) | ||
| 471 | { | ||
| 472 | assert( ERROR_OCCURRED() ); | ||
| 473 | |||
| 474 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 475 | |||
| 476 | |||
| 477 | exception_lineno = 1; | ||
| 478 | |||
| 479 | goto frame_exception_exit_1; | ||
| 480 | } | ||
| 481 | tmp_assign_source_3 = PyList_New( 3 ); | ||
| 482 | PyList_SET_ITEM( tmp_assign_source_3, 0, tmp_list_element_1 ); | ||
| 483 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 1; | ||
| 484 | { | ||
| 485 | PyObject *module = PyImport_ImportModule("os"); | ||
| 486 | if (likely( module != NULL )) | ||
| 487 | { | ||
| 488 | tmp_source_name_2 = PyObject_GetAttr( module, const_str_plain_path ); | ||
| 489 | } | ||
| 490 | else | ||
| 491 | { | ||
| 492 | tmp_source_name_2 = NULL; | ||
| 493 | } | ||
| 494 | } | ||
| 495 | |||
| 496 | if ( tmp_source_name_2 == NULL ) | ||
| 497 | { | ||
| 498 | assert( ERROR_OCCURRED() ); | ||
| 499 | |||
| 500 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 501 | Py_DECREF( tmp_assign_source_3 ); | ||
| 502 | |||
| 503 | exception_lineno = 1; | ||
| 504 | |||
| 505 | goto frame_exception_exit_1; | ||
| 506 | } | ||
| 507 | tmp_called_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_join ); | ||
| 508 | if ( tmp_called_name_2 == NULL ) | ||
| 509 | { | ||
| 510 | assert( ERROR_OCCURRED() ); | ||
| 511 | |||
| 512 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 513 | Py_DECREF( tmp_assign_source_3 ); | ||
| 514 | |||
| 515 | exception_lineno = 1; | ||
| 516 | |||
| 517 | goto frame_exception_exit_1; | ||
| 518 | } | ||
| 519 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 1; | ||
| 520 | { | ||
| 521 | PyObject *module = PyImport_ImportModule("os"); | ||
| 522 | if (likely( module != NULL )) | ||
| 523 | { | ||
| 524 | tmp_called_instance_1 = PyObject_GetAttr( module, const_str_plain_environ ); | ||
| 525 | } | ||
| 526 | else | ||
| 527 | { | ||
| 528 | tmp_called_instance_1 = NULL; | ||
| 529 | } | ||
| 530 | } | ||
| 531 | |||
| 532 | if ( tmp_called_instance_1 == NULL ) | ||
| 533 | { | ||
| 534 | assert( ERROR_OCCURRED() ); | ||
| 535 | |||
| 536 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 537 | Py_DECREF( tmp_assign_source_3 ); | ||
| 538 | Py_DECREF( tmp_called_name_2 ); | ||
| 539 | |||
| 540 | exception_lineno = 1; | ||
| 541 | |||
| 542 | goto frame_exception_exit_1; | ||
| 543 | } | ||
| 544 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 1; | ||
| 545 | tmp_args_element_name_2 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_1, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_0bb929f2f11716c81953a0b7b206d455_tuple, 0 ) ); | ||
| 546 | |||
| 547 | if ( tmp_args_element_name_2 == NULL ) | ||
| 548 | { | ||
| 549 | assert( ERROR_OCCURRED() ); | ||
| 550 | |||
| 551 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 552 | Py_DECREF( tmp_assign_source_3 ); | ||
| 553 | Py_DECREF( tmp_called_name_2 ); | ||
| 554 | |||
| 555 | exception_lineno = 1; | ||
| 556 | |||
| 557 | goto frame_exception_exit_1; | ||
| 558 | } | ||
| 559 | tmp_args_element_name_3 = const_str_plain_repository; | ||
| 560 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 1; | ||
| 561 | { | ||
| 562 | PyObject *call_args[] = { tmp_args_element_name_2, tmp_args_element_name_3 }; | ||
| 563 | tmp_list_element_1 = CALL_FUNCTION_WITH_ARGS2( tmp_called_name_2, call_args ); | ||
| 564 | } | ||
| 565 | |||
| 566 | Py_DECREF( tmp_called_name_2 ); | ||
| 567 | Py_DECREF( tmp_args_element_name_2 ); | ||
| 568 | if ( tmp_list_element_1 == NULL ) | ||
| 569 | { | ||
| 570 | assert( ERROR_OCCURRED() ); | ||
| 571 | |||
| 572 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 573 | Py_DECREF( tmp_assign_source_3 ); | ||
| 574 | |||
| 575 | exception_lineno = 1; | ||
| 576 | |||
| 577 | goto frame_exception_exit_1; | ||
| 578 | } | ||
| 579 | PyList_SET_ITEM( tmp_assign_source_3, 1, tmp_list_element_1 ); | ||
| 580 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 1; | ||
| 581 | { | ||
| 582 | PyObject *module = PyImport_ImportModule("os"); | ||
| 583 | if (likely( module != NULL )) | ||
| 584 | { | ||
| 585 | tmp_called_instance_2 = PyObject_GetAttr( module, const_str_plain_environ ); | ||
| 586 | } | ||
| 587 | else | ||
| 588 | { | ||
| 589 | tmp_called_instance_2 = NULL; | ||
| 590 | } | ||
| 591 | } | ||
| 592 | |||
| 593 | if ( tmp_called_instance_2 == NULL ) | ||
| 594 | { | ||
| 595 | assert( ERROR_OCCURRED() ); | ||
| 596 | |||
| 597 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 598 | Py_DECREF( tmp_assign_source_3 ); | ||
| 599 | |||
| 600 | exception_lineno = 1; | ||
| 601 | |||
| 602 | goto frame_exception_exit_1; | ||
| 603 | } | ||
| 604 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 1; | ||
| 605 | tmp_list_element_1 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_2, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_f8b7b4ed70bd5864ef5170077720b8c9_tuple, 0 ) ); | ||
| 606 | |||
| 607 | if ( tmp_list_element_1 == NULL ) | ||
| 608 | { | ||
| 609 | assert( ERROR_OCCURRED() ); | ||
| 610 | |||
| 611 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 612 | Py_DECREF( tmp_assign_source_3 ); | ||
| 613 | |||
| 614 | exception_lineno = 1; | ||
| 615 | |||
| 616 | goto frame_exception_exit_1; | ||
| 617 | } | ||
| 618 | PyList_SET_ITEM( tmp_assign_source_3, 2, tmp_list_element_1 ); | ||
| 619 | UPDATE_STRING_DICT1( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); | ||
| 620 | } | ||
| 621 | { | ||
| 622 | PyObject *tmp_assattr_name_1; | ||
| 623 | PyObject *tmp_assattr_target_1; | ||
| 624 | PyObject *tmp_mvar_value_1; | ||
| 625 | tmp_assattr_name_1 = module_filename_obj; | ||
| 626 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 627 | |||
| 628 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 629 | { | ||
| 630 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 631 | } | ||
| 632 | |||
| 633 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 634 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 635 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 636 | if ( tmp_result == false ) | ||
| 637 | { | ||
| 638 | assert( ERROR_OCCURRED() ); | ||
| 639 | |||
| 640 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 641 | |||
| 642 | |||
| 643 | exception_lineno = 1; | ||
| 644 | |||
| 645 | goto frame_exception_exit_1; | ||
| 646 | } | ||
| 647 | } | ||
| 648 | { | ||
| 649 | PyObject *tmp_assattr_name_2; | ||
| 650 | PyObject *tmp_assattr_target_2; | ||
| 651 | PyObject *tmp_mvar_value_2; | ||
| 652 | tmp_assattr_name_2 = Py_True; | ||
| 653 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 654 | |||
| 655 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 656 | { | ||
| 657 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 658 | } | ||
| 659 | |||
| 660 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 661 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 662 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 663 | if ( tmp_result == false ) | ||
| 664 | { | ||
| 665 | assert( ERROR_OCCURRED() ); | ||
| 666 | |||
| 667 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 668 | |||
| 669 | |||
| 670 | exception_lineno = 1; | ||
| 671 | |||
| 672 | goto frame_exception_exit_1; | ||
| 673 | } | ||
| 674 | } | ||
| 675 | { | ||
| 676 | PyObject *tmp_assign_source_4; | ||
| 677 | tmp_assign_source_4 = Py_None; | ||
| 678 | UPDATE_STRING_DICT0( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_4 ); | ||
| 679 | } | ||
| 680 | { | ||
| 681 | PyObject *tmp_assign_source_5; | ||
| 682 | PyObject *tmp_import_name_from_1; | ||
| 683 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 21; | ||
| 684 | tmp_import_name_from_1 = PyImport_ImportModule("__future__"); | ||
| 685 | assert( !(tmp_import_name_from_1 == NULL) ); | ||
| 686 | tmp_assign_source_5 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_absolute_import ); | ||
| 687 | if ( tmp_assign_source_5 == NULL ) | ||
| 688 | { | ||
| 689 | assert( ERROR_OCCURRED() ); | ||
| 690 | |||
| 691 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 692 | |||
| 693 | |||
| 694 | exception_lineno = 21; | ||
| 695 | |||
| 696 | goto frame_exception_exit_1; | ||
| 697 | } | ||
| 698 | UPDATE_STRING_DICT1( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain_absolute_import, tmp_assign_source_5 ); | ||
| 699 | } | ||
| 700 | { | ||
| 701 | PyObject *tmp_assign_source_6; | ||
| 702 | PyObject *tmp_name_name_1; | ||
| 703 | PyObject *tmp_globals_name_1; | ||
| 704 | PyObject *tmp_locals_name_1; | ||
| 705 | PyObject *tmp_fromlist_name_1; | ||
| 706 | PyObject *tmp_level_name_1; | ||
| 707 | tmp_name_name_1 = const_str_plain_sys; | ||
| 708 | tmp_globals_name_1 = (PyObject *)moduledict_gi$repository; | ||
| 709 | tmp_locals_name_1 = Py_None; | ||
| 710 | tmp_fromlist_name_1 = Py_None; | ||
| 711 | tmp_level_name_1 = const_int_0; | ||
| 712 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 23; | ||
| 713 | tmp_assign_source_6 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 714 | assert( !(tmp_assign_source_6 == NULL) ); | ||
| 715 | UPDATE_STRING_DICT1( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain_sys, tmp_assign_source_6 ); | ||
| 716 | } | ||
| 717 | { | ||
| 718 | PyObject *tmp_assign_source_7; | ||
| 719 | PyObject *tmp_import_name_from_2; | ||
| 720 | PyObject *tmp_name_name_2; | ||
| 721 | PyObject *tmp_globals_name_2; | ||
| 722 | PyObject *tmp_locals_name_2; | ||
| 723 | PyObject *tmp_fromlist_name_2; | ||
| 724 | PyObject *tmp_level_name_2; | ||
| 725 | tmp_name_name_2 = const_str_plain_importer; | ||
| 726 | tmp_globals_name_2 = (PyObject *)moduledict_gi$repository; | ||
| 727 | tmp_locals_name_2 = Py_None; | ||
| 728 | tmp_fromlist_name_2 = const_tuple_str_plain_DynamicImporter_tuple; | ||
| 729 | tmp_level_name_2 = const_int_pos_2; | ||
| 730 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 25; | ||
| 731 | tmp_import_name_from_2 = IMPORT_MODULE5( tmp_name_name_2, tmp_globals_name_2, tmp_locals_name_2, tmp_fromlist_name_2, tmp_level_name_2 ); | ||
| 732 | if ( tmp_import_name_from_2 == NULL ) | ||
| 733 | { | ||
| 734 | assert( ERROR_OCCURRED() ); | ||
| 735 | |||
| 736 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 737 | |||
| 738 | |||
| 739 | exception_lineno = 25; | ||
| 740 | |||
| 741 | goto frame_exception_exit_1; | ||
| 742 | } | ||
| 743 | if ( PyModule_Check( tmp_import_name_from_2 ) ) | ||
| 744 | { | ||
| 745 | tmp_assign_source_7 = IMPORT_NAME_OR_MODULE( | ||
| 746 | tmp_import_name_from_2, | ||
| 747 | (PyObject *)MODULE_DICT(tmp_import_name_from_2), | ||
| 748 | const_str_plain_DynamicImporter, | ||
| 749 | const_int_pos_2 | ||
| 750 | ); | ||
| 751 | } | ||
| 752 | else | ||
| 753 | { | ||
| 754 | tmp_assign_source_7 = IMPORT_NAME( tmp_import_name_from_2, const_str_plain_DynamicImporter ); | ||
| 755 | } | ||
| 756 | |||
| 757 | Py_DECREF( tmp_import_name_from_2 ); | ||
| 758 | if ( tmp_assign_source_7 == NULL ) | ||
| 759 | { | ||
| 760 | assert( ERROR_OCCURRED() ); | ||
| 761 | |||
| 762 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 763 | |||
| 764 | |||
| 765 | exception_lineno = 25; | ||
| 766 | |||
| 767 | goto frame_exception_exit_1; | ||
| 768 | } | ||
| 769 | UPDATE_STRING_DICT1( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain_DynamicImporter, tmp_assign_source_7 ); | ||
| 770 | } | ||
| 771 | { | ||
| 772 | PyObject *tmp_called_name_3; | ||
| 773 | PyObject *tmp_source_name_3; | ||
| 774 | PyObject *tmp_source_name_4; | ||
| 775 | PyObject *tmp_mvar_value_3; | ||
| 776 | PyObject *tmp_call_result_1; | ||
| 777 | PyObject *tmp_args_element_name_4; | ||
| 778 | PyObject *tmp_called_name_4; | ||
| 779 | PyObject *tmp_mvar_value_4; | ||
| 780 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain_sys ); | ||
| 781 | |||
| 782 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 783 | { | ||
| 784 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_sys ); | ||
| 785 | } | ||
| 786 | |||
| 787 | if ( tmp_mvar_value_3 == NULL ) | ||
| 788 | { | ||
| 789 | |||
| 790 | exception_type = PyExc_NameError; | ||
| 791 | Py_INCREF( exception_type ); | ||
| 792 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "sys" ); | ||
| 793 | exception_tb = NULL; | ||
| 794 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 795 | CHAIN_EXCEPTION( exception_value ); | ||
| 796 | |||
| 797 | exception_lineno = 27; | ||
| 798 | |||
| 799 | goto frame_exception_exit_1; | ||
| 800 | } | ||
| 801 | |||
| 802 | tmp_source_name_4 = tmp_mvar_value_3; | ||
| 803 | tmp_source_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain_meta_path ); | ||
| 804 | if ( tmp_source_name_3 == NULL ) | ||
| 805 | { | ||
| 806 | assert( ERROR_OCCURRED() ); | ||
| 807 | |||
| 808 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 809 | |||
| 810 | |||
| 811 | exception_lineno = 27; | ||
| 812 | |||
| 813 | goto frame_exception_exit_1; | ||
| 814 | } | ||
| 815 | tmp_called_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_append ); | ||
| 816 | Py_DECREF( tmp_source_name_3 ); | ||
| 817 | if ( tmp_called_name_3 == NULL ) | ||
| 818 | { | ||
| 819 | assert( ERROR_OCCURRED() ); | ||
| 820 | |||
| 821 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 822 | |||
| 823 | |||
| 824 | exception_lineno = 27; | ||
| 825 | |||
| 826 | goto frame_exception_exit_1; | ||
| 827 | } | ||
| 828 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain_DynamicImporter ); | ||
| 829 | |||
| 830 | if (unlikely( tmp_mvar_value_4 == NULL )) | ||
| 831 | { | ||
| 832 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_DynamicImporter ); | ||
| 833 | } | ||
| 834 | |||
| 835 | if ( tmp_mvar_value_4 == NULL ) | ||
| 836 | { | ||
| 837 | Py_DECREF( tmp_called_name_3 ); | ||
| 838 | exception_type = PyExc_NameError; | ||
| 839 | Py_INCREF( exception_type ); | ||
| 840 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "DynamicImporter" ); | ||
| 841 | exception_tb = NULL; | ||
| 842 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 843 | CHAIN_EXCEPTION( exception_value ); | ||
| 844 | |||
| 845 | exception_lineno = 27; | ||
| 846 | |||
| 847 | goto frame_exception_exit_1; | ||
| 848 | } | ||
| 849 | |||
| 850 | tmp_called_name_4 = tmp_mvar_value_4; | ||
| 851 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 27; | ||
| 852 | tmp_args_element_name_4 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_4, &PyTuple_GET_ITEM( const_tuple_str_digest_66f7aeb02c13e91a30a18f0ea911888b_tuple, 0 ) ); | ||
| 853 | |||
| 854 | if ( tmp_args_element_name_4 == NULL ) | ||
| 855 | { | ||
| 856 | assert( ERROR_OCCURRED() ); | ||
| 857 | |||
| 858 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 859 | Py_DECREF( tmp_called_name_3 ); | ||
| 860 | |||
| 861 | exception_lineno = 27; | ||
| 862 | |||
| 863 | goto frame_exception_exit_1; | ||
| 864 | } | ||
| 865 | frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame.f_lineno = 27; | ||
| 866 | { | ||
| 867 | PyObject *call_args[] = { tmp_args_element_name_4 }; | ||
| 868 | tmp_call_result_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_3, call_args ); | ||
| 869 | } | ||
| 870 | |||
| 871 | Py_DECREF( tmp_called_name_3 ); | ||
| 872 | Py_DECREF( tmp_args_element_name_4 ); | ||
| 873 | if ( tmp_call_result_1 == NULL ) | ||
| 874 | { | ||
| 875 | assert( ERROR_OCCURRED() ); | ||
| 876 | |||
| 877 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 878 | |||
| 879 | |||
| 880 | exception_lineno = 27; | ||
| 881 | |||
| 882 | goto frame_exception_exit_1; | ||
| 883 | } | ||
| 884 | Py_DECREF( tmp_call_result_1 ); | ||
| 885 | } | ||
| 886 | tmp_res = PyDict_DelItem( (PyObject *)moduledict_gi$repository, const_str_plain_DynamicImporter ); | ||
| 887 | tmp_result = tmp_res != -1; | ||
| 888 | if ( tmp_result == false ) CLEAR_ERROR_OCCURRED(); | ||
| 889 | |||
| 890 | if ( tmp_result == false ) | ||
| 891 | { | ||
| 892 | |||
| 893 | exception_type = PyExc_NameError; | ||
| 894 | Py_INCREF( exception_type ); | ||
| 895 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "DynamicImporter" ); | ||
| 896 | exception_tb = NULL; | ||
| 897 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 898 | CHAIN_EXCEPTION( exception_value ); | ||
| 899 | |||
| 900 | exception_lineno = 29; | ||
| 901 | |||
| 902 | goto frame_exception_exit_1; | ||
| 903 | } | ||
| 904 | |||
| 905 | tmp_res = PyDict_DelItem( (PyObject *)moduledict_gi$repository, const_str_plain_sys ); | ||
| 906 | tmp_result = tmp_res != -1; | ||
| 907 | if ( tmp_result == false ) CLEAR_ERROR_OCCURRED(); | ||
| 908 | |||
| 909 | if ( tmp_result == false ) | ||
| 910 | { | ||
| 911 | |||
| 912 | exception_type = PyExc_NameError; | ||
| 913 | Py_INCREF( exception_type ); | ||
| 914 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "sys" ); | ||
| 915 | exception_tb = NULL; | ||
| 916 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 917 | CHAIN_EXCEPTION( exception_value ); | ||
| 918 | |||
| 919 | exception_lineno = 30; | ||
| 920 | |||
| 921 | goto frame_exception_exit_1; | ||
| 922 | } | ||
| 923 | |||
| 924 | |||
| 925 | // Restore frame exception if necessary. | ||
| 926 | #if 0 | ||
| 927 | RESTORE_FRAME_EXCEPTION( frame_eb3c08b482b3ef431f85b2d43bf138b7 ); | ||
| 928 | #endif | ||
| 929 | popFrameStack(); | ||
| 930 | |||
| 931 | assertFrameObject( frame_eb3c08b482b3ef431f85b2d43bf138b7 ); | ||
| 932 | |||
| 933 | goto frame_no_exception_1; | ||
| 934 | |||
| 935 | frame_exception_exit_1:; | ||
| 936 | #if 0 | ||
| 937 | RESTORE_FRAME_EXCEPTION( frame_eb3c08b482b3ef431f85b2d43bf138b7 ); | ||
| 938 | #endif | ||
| 939 | |||
| 940 | if ( exception_tb == NULL ) | ||
| 941 | { | ||
| 942 | exception_tb = MAKE_TRACEBACK( frame_eb3c08b482b3ef431f85b2d43bf138b7, exception_lineno ); | ||
| 943 | } | ||
| 944 | else if ( exception_tb->tb_frame != &frame_eb3c08b482b3ef431f85b2d43bf138b7->m_frame ) | ||
| 945 | { | ||
| 946 | exception_tb = ADD_TRACEBACK( exception_tb, frame_eb3c08b482b3ef431f85b2d43bf138b7, exception_lineno ); | ||
| 947 | } | ||
| 948 | |||
| 949 | // Put the previous frame back on top. | ||
| 950 | popFrameStack(); | ||
| 951 | |||
| 952 | // Return the error. | ||
| 953 | goto module_exception_exit; | ||
| 954 | |||
| 955 | frame_no_exception_1:; | ||
| 956 | |||
| 957 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 958 | #if 1 && 0 | ||
| 959 | { | ||
| 960 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_gi$repository, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 961 | |||
| 962 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 963 | { | ||
| 964 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 965 | |||
| 966 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 967 | CHECK_OBJECT( path_importer_cache ); | ||
| 968 | |||
| 969 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 970 | assert( res == 0 ); | ||
| 971 | } | ||
| 972 | } | ||
| 973 | #endif | ||
| 974 | #endif | ||
| 975 | |||
| 976 | return MOD_RETURN_VALUE( module_gi$repository ); | ||
| 977 | module_exception_exit: | ||
| 978 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 979 | return MOD_RETURN_VALUE( NULL ); | ||
| 980 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.gi.repository.o deleted (index 98dca8c..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.gi.types.c is too big (17140 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.gi.types.o deleted (index 75df1c6..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.packages.c deleted (index dfd485b..0000000) | |||
| 1 | /* Generated code for Python module 'packages' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_packages" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_packages; | ||
| 31 | PyDictObject *moduledict_packages; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | static PyObject *const_str_plain_packages; | ||
| 35 | static PyObject *const_str_digest_bc260687f66d2bbe535276e6bbaf8f32; | ||
| 36 | extern PyObject *const_int_0; | ||
| 37 | static PyObject *const_list_str_digest_bc260687f66d2bbe535276e6bbaf8f32_list; | ||
| 38 | static PyObject *const_str_plain__frozen_importlib_external; | ||
| 39 | extern PyObject *const_str_plain___path__; | ||
| 40 | static PyObject *const_str_plain__NamespacePath; | ||
| 41 | |||
| 42 | /* Indicator if this modules private constants were created yet. */ | ||
| 43 | static bool constants_created = false; | ||
| 44 | |||
| 45 | /* Function to create module private constants. */ | ||
| 46 | static void createModuleConstants( void ) | ||
| 47 | { | ||
| 48 | const_str_plain_packages = UNSTREAM_STRING_ASCII( &constant_bin[ 113 ], 8, 1 ); | ||
| 49 | const_str_digest_bc260687f66d2bbe535276e6bbaf8f32 = UNSTREAM_STRING_ASCII( &constant_bin[ 54000 ], 91, 0 ); | ||
| 50 | const_list_str_digest_bc260687f66d2bbe535276e6bbaf8f32_list = PyList_New( 1 ); | ||
| 51 | PyList_SET_ITEM( const_list_str_digest_bc260687f66d2bbe535276e6bbaf8f32_list, 0, const_str_digest_bc260687f66d2bbe535276e6bbaf8f32 ); Py_INCREF( const_str_digest_bc260687f66d2bbe535276e6bbaf8f32 ); | ||
| 52 | const_str_plain__frozen_importlib_external = UNSTREAM_STRING_ASCII( &constant_bin[ 54091 ], 26, 1 ); | ||
| 53 | const_str_plain__NamespacePath = UNSTREAM_STRING_ASCII( &constant_bin[ 54117 ], 14, 1 ); | ||
| 54 | |||
| 55 | constants_created = true; | ||
| 56 | } | ||
| 57 | |||
| 58 | /* Function to verify module private constants for non-corruption. */ | ||
| 59 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 60 | void checkModuleConstants_packages( void ) | ||
| 61 | { | ||
| 62 | // The module may not have been used at all, then ignore this. | ||
| 63 | if (constants_created == false) return; | ||
| 64 | |||
| 65 | |||
| 66 | } | ||
| 67 | #endif | ||
| 68 | |||
| 69 | // The module code objects. | ||
| 70 | |||
| 71 | |||
| 72 | static void createModuleCodeObjects(void) | ||
| 73 | { | ||
| 74 | |||
| 75 | } | ||
| 76 | |||
| 77 | // The module function declarations. | ||
| 78 | |||
| 79 | |||
| 80 | // The module function definitions. | ||
| 81 | |||
| 82 | |||
| 83 | |||
| 84 | #if PYTHON_VERSION >= 300 | ||
| 85 | static struct PyModuleDef mdef_packages = | ||
| 86 | { | ||
| 87 | PyModuleDef_HEAD_INIT, | ||
| 88 | "packages", | ||
| 89 | NULL, /* m_doc */ | ||
| 90 | -1, /* m_size */ | ||
| 91 | NULL, /* m_methods */ | ||
| 92 | NULL, /* m_reload */ | ||
| 93 | NULL, /* m_traverse */ | ||
| 94 | NULL, /* m_clear */ | ||
| 95 | NULL, /* m_free */ | ||
| 96 | }; | ||
| 97 | #endif | ||
| 98 | |||
| 99 | extern PyObject *const_str_plain___compiled__; | ||
| 100 | |||
| 101 | extern PyObject *const_str_plain___package__; | ||
| 102 | |||
| 103 | #if PYTHON_VERSION >= 300 | ||
| 104 | extern PyObject *const_str_dot; | ||
| 105 | extern PyObject *const_str_plain___loader__; | ||
| 106 | #endif | ||
| 107 | |||
| 108 | #if PYTHON_VERSION >= 340 | ||
| 109 | extern PyObject *const_str_plain___spec__; | ||
| 110 | extern PyObject *const_str_plain__initializing; | ||
| 111 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 112 | #endif | ||
| 113 | |||
| 114 | extern void _initCompiledCellType(); | ||
| 115 | extern void _initCompiledGeneratorType(); | ||
| 116 | extern void _initCompiledFunctionType(); | ||
| 117 | extern void _initCompiledMethodType(); | ||
| 118 | extern void _initCompiledFrameType(); | ||
| 119 | #if PYTHON_VERSION >= 350 | ||
| 120 | extern void _initCompiledCoroutineTypes(); | ||
| 121 | #endif | ||
| 122 | #if PYTHON_VERSION >= 360 | ||
| 123 | extern void _initCompiledAsyncgenTypes(); | ||
| 124 | #endif | ||
| 125 | |||
| 126 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 127 | |||
| 128 | // The exported interface to CPython. On import of the module, this function | ||
| 129 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 130 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 131 | |||
| 132 | MOD_INIT_DECL( packages ) | ||
| 133 | { | ||
| 134 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 135 | static bool _init_done = false; | ||
| 136 | |||
| 137 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 138 | if ( _init_done ) | ||
| 139 | { | ||
| 140 | return MOD_RETURN_VALUE( module_packages ); | ||
| 141 | } | ||
| 142 | else | ||
| 143 | { | ||
| 144 | _init_done = true; | ||
| 145 | } | ||
| 146 | #endif | ||
| 147 | |||
| 148 | #ifdef _NUITKA_MODULE | ||
| 149 | // In case of a stand alone extension module, need to call initialization | ||
| 150 | // the init here because that's the first and only time we are going to get | ||
| 151 | // called here. | ||
| 152 | |||
| 153 | // Initialize the constant values used. | ||
| 154 | _initBuiltinModule(); | ||
| 155 | createGlobalConstants(); | ||
| 156 | |||
| 157 | /* Initialize the compiled types of Nuitka. */ | ||
| 158 | _initCompiledCellType(); | ||
| 159 | _initCompiledGeneratorType(); | ||
| 160 | _initCompiledFunctionType(); | ||
| 161 | _initCompiledMethodType(); | ||
| 162 | _initCompiledFrameType(); | ||
| 163 | #if PYTHON_VERSION >= 350 | ||
| 164 | _initCompiledCoroutineTypes(); | ||
| 165 | #endif | ||
| 166 | #if PYTHON_VERSION >= 360 | ||
| 167 | _initCompiledAsyncgenTypes(); | ||
| 168 | #endif | ||
| 169 | |||
| 170 | #if PYTHON_VERSION < 300 | ||
| 171 | _initSlotCompare(); | ||
| 172 | #endif | ||
| 173 | #if PYTHON_VERSION >= 270 | ||
| 174 | _initSlotIternext(); | ||
| 175 | #endif | ||
| 176 | |||
| 177 | patchBuiltinModule(); | ||
| 178 | patchTypeComparison(); | ||
| 179 | |||
| 180 | // Enable meta path based loader if not already done. | ||
| 181 | #ifdef _NUITKA_TRACE | ||
| 182 | puts("packages: Calling setupMetaPathBasedLoader()."); | ||
| 183 | #endif | ||
| 184 | setupMetaPathBasedLoader(); | ||
| 185 | |||
| 186 | #if PYTHON_VERSION >= 300 | ||
| 187 | patchInspectModule(); | ||
| 188 | #endif | ||
| 189 | |||
| 190 | #endif | ||
| 191 | |||
| 192 | /* The constants only used by this module are created now. */ | ||
| 193 | #ifdef _NUITKA_TRACE | ||
| 194 | puts("packages: Calling createModuleConstants()."); | ||
| 195 | #endif | ||
| 196 | createModuleConstants(); | ||
| 197 | |||
| 198 | /* The code objects used by this module are created now. */ | ||
| 199 | #ifdef _NUITKA_TRACE | ||
| 200 | puts("packages: Calling createModuleCodeObjects()."); | ||
| 201 | #endif | ||
| 202 | createModuleCodeObjects(); | ||
| 203 | |||
| 204 | // puts( "in initpackages" ); | ||
| 205 | |||
| 206 | // Create the module object first. There are no methods initially, all are | ||
| 207 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 208 | // set at this time, as it could not contain NUL characters this way, they | ||
| 209 | // are instead set in early module code. No "self" for modules, we have no | ||
| 210 | // use for it. | ||
| 211 | #if PYTHON_VERSION < 300 | ||
| 212 | module_packages = Py_InitModule4( | ||
| 213 | "packages", // Module Name | ||
| 214 | NULL, // No methods initially, all are added | ||
| 215 | // dynamically in actual module code only. | ||
| 216 | NULL, // No "__doc__" is initially set, as it could | ||
| 217 | // not contain NUL this way, added early in | ||
| 218 | // actual code. | ||
| 219 | NULL, // No self for modules, we don't use it. | ||
| 220 | PYTHON_API_VERSION | ||
| 221 | ); | ||
| 222 | #else | ||
| 223 | |||
| 224 | module_packages = PyModule_Create( &mdef_packages ); | ||
| 225 | #endif | ||
| 226 | |||
| 227 | moduledict_packages = MODULE_DICT( module_packages ); | ||
| 228 | |||
| 229 | // Set __compiled__ to what it we know. | ||
| 230 | UPDATE_STRING_DICT1( | ||
| 231 | moduledict_packages, | ||
| 232 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 233 | Nuitka_dunder_compiled_value | ||
| 234 | ); | ||
| 235 | |||
| 236 | // Update "__package__" value to what it ought to be. | ||
| 237 | { | ||
| 238 | #if 1 | ||
| 239 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_packages, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 240 | |||
| 241 | UPDATE_STRING_DICT1( | ||
| 242 | moduledict_packages, | ||
| 243 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 244 | module_name | ||
| 245 | ); | ||
| 246 | #else | ||
| 247 | |||
| 248 | #if PYTHON_VERSION < 300 | ||
| 249 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_packages, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 250 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 251 | |||
| 252 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 253 | |||
| 254 | if ( last_dot != NULL ) | ||
| 255 | { | ||
| 256 | UPDATE_STRING_DICT1( | ||
| 257 | moduledict_packages, | ||
| 258 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 259 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 260 | ); | ||
| 261 | } | ||
| 262 | #else | ||
| 263 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_packages, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 264 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 265 | |||
| 266 | if ( dot_index != -1 ) | ||
| 267 | { | ||
| 268 | UPDATE_STRING_DICT1( | ||
| 269 | moduledict_packages, | ||
| 270 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 271 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 272 | ); | ||
| 273 | } | ||
| 274 | #endif | ||
| 275 | #endif | ||
| 276 | } | ||
| 277 | |||
| 278 | CHECK_OBJECT( module_packages ); | ||
| 279 | |||
| 280 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 281 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 282 | #if PYTHON_VERSION >= 300 | ||
| 283 | { | ||
| 284 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_plain_packages, module_packages ); | ||
| 285 | |||
| 286 | assert( r != -1 ); | ||
| 287 | } | ||
| 288 | #endif | ||
| 289 | |||
| 290 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 291 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 292 | // before the frame object is allocated, or else it may fail. | ||
| 293 | |||
| 294 | if ( GET_STRING_DICT_VALUE( moduledict_packages, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 295 | { | ||
| 296 | PyObject *value = (PyObject *)builtin_module; | ||
| 297 | |||
| 298 | // Check if main module, not a dict then but the module itself. | ||
| 299 | #if !defined(_NUITKA_EXE) || !0 | ||
| 300 | value = PyModule_GetDict( value ); | ||
| 301 | #endif | ||
| 302 | |||
| 303 | UPDATE_STRING_DICT0( moduledict_packages, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 304 | } | ||
| 305 | |||
| 306 | #if PYTHON_VERSION >= 300 | ||
| 307 | UPDATE_STRING_DICT0( moduledict_packages, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 308 | #endif | ||
| 309 | |||
| 310 | #if PYTHON_VERSION >= 340 | ||
| 311 | // Set the "__spec__" value | ||
| 312 | |||
| 313 | #if 0 | ||
| 314 | // Main modules just get "None" as spec. | ||
| 315 | UPDATE_STRING_DICT0( moduledict_packages, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 316 | #else | ||
| 317 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 318 | { | ||
| 319 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 320 | CHECK_OBJECT( bootstrap_module ); | ||
| 321 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 322 | Py_DECREF( bootstrap_module ); | ||
| 323 | |||
| 324 | PyObject *args[] = { | ||
| 325 | GET_STRING_DICT_VALUE( moduledict_packages, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 326 | (PyObject *)&Nuitka_Loader_Type | ||
| 327 | }; | ||
| 328 | |||
| 329 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 330 | module_spec_class, | ||
| 331 | args | ||
| 332 | ); | ||
| 333 | Py_DECREF( module_spec_class ); | ||
| 334 | |||
| 335 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 336 | CHECK_OBJECT( spec_value ); | ||
| 337 | |||
| 338 | // For packages set the submodule search locations as well, even if to empty | ||
| 339 | // list, so investigating code will consider it a package. | ||
| 340 | #if 1 | ||
| 341 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 342 | #endif | ||
| 343 | |||
| 344 | // Mark the execution in the "__spec__" value. | ||
| 345 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 346 | |||
| 347 | UPDATE_STRING_DICT1( moduledict_packages, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 348 | } | ||
| 349 | #endif | ||
| 350 | #endif | ||
| 351 | |||
| 352 | // Temp variables if any | ||
| 353 | PyObject *exception_type = NULL; | ||
| 354 | PyObject *exception_value = NULL; | ||
| 355 | PyTracebackObject *exception_tb = NULL; | ||
| 356 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 357 | |||
| 358 | // Module code. | ||
| 359 | { | ||
| 360 | PyObject *tmp_assign_source_1; | ||
| 361 | PyObject *tmp_called_name_1; | ||
| 362 | PyObject *tmp_import_name_from_1; | ||
| 363 | PyObject *tmp_name_name_1; | ||
| 364 | PyObject *tmp_level_name_1; | ||
| 365 | PyObject *tmp_call_arg_element_1; | ||
| 366 | PyObject *tmp_call_arg_element_2; | ||
| 367 | PyObject *tmp_call_arg_element_3; | ||
| 368 | tmp_name_name_1 = const_str_plain__frozen_importlib_external; | ||
| 369 | tmp_level_name_1 = const_int_0; | ||
| 370 | tmp_import_name_from_1 = IMPORT_MODULE_KW( tmp_name_name_1, NULL, NULL, NULL, tmp_level_name_1 ); | ||
| 371 | if ( tmp_import_name_from_1 == NULL ) | ||
| 372 | { | ||
| 373 | assert( ERROR_OCCURRED() ); | ||
| 374 | |||
| 375 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 376 | |||
| 377 | |||
| 378 | |||
| 379 | |||
| 380 | goto module_exception_exit; | ||
| 381 | } | ||
| 382 | tmp_called_name_1 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain__NamespacePath ); | ||
| 383 | Py_DECREF( tmp_import_name_from_1 ); | ||
| 384 | if ( tmp_called_name_1 == NULL ) | ||
| 385 | { | ||
| 386 | assert( ERROR_OCCURRED() ); | ||
| 387 | |||
| 388 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 389 | |||
| 390 | |||
| 391 | |||
| 392 | |||
| 393 | goto module_exception_exit; | ||
| 394 | } | ||
| 395 | tmp_call_arg_element_1 = const_str_plain_packages; | ||
| 396 | tmp_call_arg_element_2 = LIST_COPY( const_list_str_digest_bc260687f66d2bbe535276e6bbaf8f32_list ); | ||
| 397 | tmp_call_arg_element_3 = Py_None; | ||
| 398 | { | ||
| 399 | PyObject *call_args[] = { tmp_call_arg_element_1, tmp_call_arg_element_2, tmp_call_arg_element_3 }; | ||
| 400 | tmp_assign_source_1 = CALL_FUNCTION_WITH_ARGS3( tmp_called_name_1, call_args ); | ||
| 401 | } | ||
| 402 | |||
| 403 | Py_DECREF( tmp_called_name_1 ); | ||
| 404 | Py_DECREF( tmp_call_arg_element_2 ); | ||
| 405 | if ( tmp_assign_source_1 == NULL ) | ||
| 406 | { | ||
| 407 | assert( ERROR_OCCURRED() ); | ||
| 408 | |||
| 409 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 410 | |||
| 411 | |||
| 412 | |||
| 413 | |||
| 414 | goto module_exception_exit; | ||
| 415 | } | ||
| 416 | UPDATE_STRING_DICT1( moduledict_packages, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_1 ); | ||
| 417 | } | ||
| 418 | |||
| 419 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 420 | #if 1 && 0 | ||
| 421 | { | ||
| 422 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_packages, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 423 | |||
| 424 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 425 | { | ||
| 426 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 427 | |||
| 428 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 429 | CHECK_OBJECT( path_importer_cache ); | ||
| 430 | |||
| 431 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 432 | assert( res == 0 ); | ||
| 433 | } | ||
| 434 | } | ||
| 435 | #endif | ||
| 436 | #endif | ||
| 437 | |||
| 438 | return MOD_RETURN_VALUE( module_packages ); | ||
| 439 | module_exception_exit: | ||
| 440 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 441 | return MOD_RETURN_VALUE( NULL ); | ||
| 442 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.packages.o deleted (index 7ddd3ad..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.packages.syncfile.c is too big (13940 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.packages.syncfile.o deleted (index 714a407..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.problem.c is too big (25977 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.problem.config.c deleted (index 1ac4cc6..0000000) | |||
| 1 | /* Generated code for Python module 'problem.config' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_problem$config" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_problem$config; | ||
| 31 | PyDictObject *moduledict_problem$config; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain___file__; | ||
| 35 | static PyObject *const_str_digest_f508a49fcfaf4f961fc80f666c4294a4; | ||
| 36 | static PyObject *const_str_digest_4f06c4a09ed82220293be841d8ea9ac4; | ||
| 37 | extern PyObject *const_str_plain_origin; | ||
| 38 | extern PyObject *const_str_plain___spec__; | ||
| 39 | extern PyObject *const_str_digest_6b7875a4f8a36dd7de7a8976a2d1d45e; | ||
| 40 | static PyObject *const_str_digest_7ff415fa9449a25a9ce1a729d2ed6531; | ||
| 41 | extern PyObject *const_tuple_empty; | ||
| 42 | extern PyObject *const_str_plain_DEFAULT_DUMP_LOCATION; | ||
| 43 | extern PyObject *const_str_plain___doc__; | ||
| 44 | extern PyObject *const_str_plain___cached__; | ||
| 45 | extern PyObject *const_str_plain_has_location; | ||
| 46 | static PyObject *module_filename_obj; | ||
| 47 | |||
| 48 | /* Indicator if this modules private constants were created yet. */ | ||
| 49 | static bool constants_created = false; | ||
| 50 | |||
| 51 | /* Function to create module private constants. */ | ||
| 52 | static void createModuleConstants( void ) | ||
| 53 | { | ||
| 54 | const_str_digest_f508a49fcfaf4f961fc80f666c4294a4 = UNSTREAM_STRING_ASCII( &constant_bin[ 58136 ], 23, 0 ); | ||
| 55 | const_str_digest_4f06c4a09ed82220293be841d8ea9ac4 = UNSTREAM_STRING_ASCII( &constant_bin[ 58159 ], 15, 0 ); | ||
| 56 | const_str_digest_7ff415fa9449a25a9ce1a729d2ed6531 = UNSTREAM_STRING_ASCII( &constant_bin[ 58174 ], 17, 0 ); | ||
| 57 | |||
| 58 | constants_created = true; | ||
| 59 | } | ||
| 60 | |||
| 61 | /* Function to verify module private constants for non-corruption. */ | ||
| 62 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 63 | void checkModuleConstants_problem$config( void ) | ||
| 64 | { | ||
| 65 | // The module may not have been used at all, then ignore this. | ||
| 66 | if (constants_created == false) return; | ||
| 67 | |||
| 68 | |||
| 69 | } | ||
| 70 | #endif | ||
| 71 | |||
| 72 | // The module code objects. | ||
| 73 | static PyCodeObject *codeobj_fd4a70ef8a112678d459bb3386ad4c54; | ||
| 74 | |||
| 75 | static void createModuleCodeObjects(void) | ||
| 76 | { | ||
| 77 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_7ff415fa9449a25a9ce1a729d2ed6531 ); | ||
| 78 | codeobj_fd4a70ef8a112678d459bb3386ad4c54 = MAKE_CODEOBJ( module_filename_obj, const_str_digest_f508a49fcfaf4f961fc80f666c4294a4, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 79 | } | ||
| 80 | |||
| 81 | // The module function declarations. | ||
| 82 | |||
| 83 | |||
| 84 | // The module function definitions. | ||
| 85 | |||
| 86 | |||
| 87 | |||
| 88 | #if PYTHON_VERSION >= 300 | ||
| 89 | static struct PyModuleDef mdef_problem$config = | ||
| 90 | { | ||
| 91 | PyModuleDef_HEAD_INIT, | ||
| 92 | "problem.config", | ||
| 93 | NULL, /* m_doc */ | ||
| 94 | -1, /* m_size */ | ||
| 95 | NULL, /* m_methods */ | ||
| 96 | NULL, /* m_reload */ | ||
| 97 | NULL, /* m_traverse */ | ||
| 98 | NULL, /* m_clear */ | ||
| 99 | NULL, /* m_free */ | ||
| 100 | }; | ||
| 101 | #endif | ||
| 102 | |||
| 103 | extern PyObject *const_str_plain___compiled__; | ||
| 104 | |||
| 105 | extern PyObject *const_str_plain___package__; | ||
| 106 | |||
| 107 | #if PYTHON_VERSION >= 300 | ||
| 108 | extern PyObject *const_str_dot; | ||
| 109 | extern PyObject *const_str_plain___loader__; | ||
| 110 | #endif | ||
| 111 | |||
| 112 | #if PYTHON_VERSION >= 340 | ||
| 113 | extern PyObject *const_str_plain___spec__; | ||
| 114 | extern PyObject *const_str_plain__initializing; | ||
| 115 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 116 | #endif | ||
| 117 | |||
| 118 | extern void _initCompiledCellType(); | ||
| 119 | extern void _initCompiledGeneratorType(); | ||
| 120 | extern void _initCompiledFunctionType(); | ||
| 121 | extern void _initCompiledMethodType(); | ||
| 122 | extern void _initCompiledFrameType(); | ||
| 123 | #if PYTHON_VERSION >= 350 | ||
| 124 | extern void _initCompiledCoroutineTypes(); | ||
| 125 | #endif | ||
| 126 | #if PYTHON_VERSION >= 360 | ||
| 127 | extern void _initCompiledAsyncgenTypes(); | ||
| 128 | #endif | ||
| 129 | |||
| 130 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 131 | |||
| 132 | // The exported interface to CPython. On import of the module, this function | ||
| 133 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 134 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 135 | |||
| 136 | MOD_INIT_DECL( problem$config ) | ||
| 137 | { | ||
| 138 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 139 | static bool _init_done = false; | ||
| 140 | |||
| 141 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 142 | if ( _init_done ) | ||
| 143 | { | ||
| 144 | return MOD_RETURN_VALUE( module_problem$config ); | ||
| 145 | } | ||
| 146 | else | ||
| 147 | { | ||
| 148 | _init_done = true; | ||
| 149 | } | ||
| 150 | #endif | ||
| 151 | |||
| 152 | #ifdef _NUITKA_MODULE | ||
| 153 | // In case of a stand alone extension module, need to call initialization | ||
| 154 | // the init here because that's the first and only time we are going to get | ||
| 155 | // called here. | ||
| 156 | |||
| 157 | // Initialize the constant values used. | ||
| 158 | _initBuiltinModule(); | ||
| 159 | createGlobalConstants(); | ||
| 160 | |||
| 161 | /* Initialize the compiled types of Nuitka. */ | ||
| 162 | _initCompiledCellType(); | ||
| 163 | _initCompiledGeneratorType(); | ||
| 164 | _initCompiledFunctionType(); | ||
| 165 | _initCompiledMethodType(); | ||
| 166 | _initCompiledFrameType(); | ||
| 167 | #if PYTHON_VERSION >= 350 | ||
| 168 | _initCompiledCoroutineTypes(); | ||
| 169 | #endif | ||
| 170 | #if PYTHON_VERSION >= 360 | ||
| 171 | _initCompiledAsyncgenTypes(); | ||
| 172 | #endif | ||
| 173 | |||
| 174 | #if PYTHON_VERSION < 300 | ||
| 175 | _initSlotCompare(); | ||
| 176 | #endif | ||
| 177 | #if PYTHON_VERSION >= 270 | ||
| 178 | _initSlotIternext(); | ||
| 179 | #endif | ||
| 180 | |||
| 181 | patchBuiltinModule(); | ||
| 182 | patchTypeComparison(); | ||
| 183 | |||
| 184 | // Enable meta path based loader if not already done. | ||
| 185 | #ifdef _NUITKA_TRACE | ||
| 186 | puts("problem.config: Calling setupMetaPathBasedLoader()."); | ||
| 187 | #endif | ||
| 188 | setupMetaPathBasedLoader(); | ||
| 189 | |||
| 190 | #if PYTHON_VERSION >= 300 | ||
| 191 | patchInspectModule(); | ||
| 192 | #endif | ||
| 193 | |||
| 194 | #endif | ||
| 195 | |||
| 196 | /* The constants only used by this module are created now. */ | ||
| 197 | #ifdef _NUITKA_TRACE | ||
| 198 | puts("problem.config: Calling createModuleConstants()."); | ||
| 199 | #endif | ||
| 200 | createModuleConstants(); | ||
| 201 | |||
| 202 | /* The code objects used by this module are created now. */ | ||
| 203 | #ifdef _NUITKA_TRACE | ||
| 204 | puts("problem.config: Calling createModuleCodeObjects()."); | ||
| 205 | #endif | ||
| 206 | createModuleCodeObjects(); | ||
| 207 | |||
| 208 | // puts( "in initproblem$config" ); | ||
| 209 | |||
| 210 | // Create the module object first. There are no methods initially, all are | ||
| 211 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 212 | // set at this time, as it could not contain NUL characters this way, they | ||
| 213 | // are instead set in early module code. No "self" for modules, we have no | ||
| 214 | // use for it. | ||
| 215 | #if PYTHON_VERSION < 300 | ||
| 216 | module_problem$config = Py_InitModule4( | ||
| 217 | "problem.config", // Module Name | ||
| 218 | NULL, // No methods initially, all are added | ||
| 219 | // dynamically in actual module code only. | ||
| 220 | NULL, // No "__doc__" is initially set, as it could | ||
| 221 | // not contain NUL this way, added early in | ||
| 222 | // actual code. | ||
| 223 | NULL, // No self for modules, we don't use it. | ||
| 224 | PYTHON_API_VERSION | ||
| 225 | ); | ||
| 226 | #else | ||
| 227 | |||
| 228 | module_problem$config = PyModule_Create( &mdef_problem$config ); | ||
| 229 | #endif | ||
| 230 | |||
| 231 | moduledict_problem$config = MODULE_DICT( module_problem$config ); | ||
| 232 | |||
| 233 | // Set __compiled__ to what it we know. | ||
| 234 | UPDATE_STRING_DICT1( | ||
| 235 | moduledict_problem$config, | ||
| 236 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 237 | Nuitka_dunder_compiled_value | ||
| 238 | ); | ||
| 239 | |||
| 240 | // Update "__package__" value to what it ought to be. | ||
| 241 | { | ||
| 242 | #if 0 | ||
| 243 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 244 | |||
| 245 | UPDATE_STRING_DICT1( | ||
| 246 | moduledict_problem$config, | ||
| 247 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 248 | module_name | ||
| 249 | ); | ||
| 250 | #else | ||
| 251 | |||
| 252 | #if PYTHON_VERSION < 300 | ||
| 253 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 254 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 255 | |||
| 256 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 257 | |||
| 258 | if ( last_dot != NULL ) | ||
| 259 | { | ||
| 260 | UPDATE_STRING_DICT1( | ||
| 261 | moduledict_problem$config, | ||
| 262 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 263 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 264 | ); | ||
| 265 | } | ||
| 266 | #else | ||
| 267 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 268 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 269 | |||
| 270 | if ( dot_index != -1 ) | ||
| 271 | { | ||
| 272 | UPDATE_STRING_DICT1( | ||
| 273 | moduledict_problem$config, | ||
| 274 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 275 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 276 | ); | ||
| 277 | } | ||
| 278 | #endif | ||
| 279 | #endif | ||
| 280 | } | ||
| 281 | |||
| 282 | CHECK_OBJECT( module_problem$config ); | ||
| 283 | |||
| 284 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 285 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 286 | #if PYTHON_VERSION >= 300 | ||
| 287 | { | ||
| 288 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_6b7875a4f8a36dd7de7a8976a2d1d45e, module_problem$config ); | ||
| 289 | |||
| 290 | assert( r != -1 ); | ||
| 291 | } | ||
| 292 | #endif | ||
| 293 | |||
| 294 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 295 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 296 | // before the frame object is allocated, or else it may fail. | ||
| 297 | |||
| 298 | if ( GET_STRING_DICT_VALUE( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 299 | { | ||
| 300 | PyObject *value = (PyObject *)builtin_module; | ||
| 301 | |||
| 302 | // Check if main module, not a dict then but the module itself. | ||
| 303 | #if !defined(_NUITKA_EXE) || !0 | ||
| 304 | value = PyModule_GetDict( value ); | ||
| 305 | #endif | ||
| 306 | |||
| 307 | UPDATE_STRING_DICT0( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 308 | } | ||
| 309 | |||
| 310 | #if PYTHON_VERSION >= 300 | ||
| 311 | UPDATE_STRING_DICT0( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 312 | #endif | ||
| 313 | |||
| 314 | #if PYTHON_VERSION >= 340 | ||
| 315 | // Set the "__spec__" value | ||
| 316 | |||
| 317 | #if 0 | ||
| 318 | // Main modules just get "None" as spec. | ||
| 319 | UPDATE_STRING_DICT0( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 320 | #else | ||
| 321 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 322 | { | ||
| 323 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 324 | CHECK_OBJECT( bootstrap_module ); | ||
| 325 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 326 | Py_DECREF( bootstrap_module ); | ||
| 327 | |||
| 328 | PyObject *args[] = { | ||
| 329 | GET_STRING_DICT_VALUE( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 330 | (PyObject *)&Nuitka_Loader_Type | ||
| 331 | }; | ||
| 332 | |||
| 333 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 334 | module_spec_class, | ||
| 335 | args | ||
| 336 | ); | ||
| 337 | Py_DECREF( module_spec_class ); | ||
| 338 | |||
| 339 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 340 | CHECK_OBJECT( spec_value ); | ||
| 341 | |||
| 342 | // For packages set the submodule search locations as well, even if to empty | ||
| 343 | // list, so investigating code will consider it a package. | ||
| 344 | #if 0 | ||
| 345 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 346 | #endif | ||
| 347 | |||
| 348 | // Mark the execution in the "__spec__" value. | ||
| 349 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 350 | |||
| 351 | UPDATE_STRING_DICT1( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 352 | } | ||
| 353 | #endif | ||
| 354 | #endif | ||
| 355 | |||
| 356 | // Temp variables if any | ||
| 357 | struct Nuitka_FrameObject *frame_fd4a70ef8a112678d459bb3386ad4c54; | ||
| 358 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 359 | bool tmp_result; | ||
| 360 | PyObject *exception_type = NULL; | ||
| 361 | PyObject *exception_value = NULL; | ||
| 362 | PyTracebackObject *exception_tb = NULL; | ||
| 363 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 364 | |||
| 365 | // Module code. | ||
| 366 | { | ||
| 367 | PyObject *tmp_assign_source_1; | ||
| 368 | tmp_assign_source_1 = Py_None; | ||
| 369 | UPDATE_STRING_DICT0( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 370 | } | ||
| 371 | { | ||
| 372 | PyObject *tmp_assign_source_2; | ||
| 373 | tmp_assign_source_2 = module_filename_obj; | ||
| 374 | UPDATE_STRING_DICT0( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 375 | } | ||
| 376 | // Frame without reuse. | ||
| 377 | frame_fd4a70ef8a112678d459bb3386ad4c54 = MAKE_MODULE_FRAME( codeobj_fd4a70ef8a112678d459bb3386ad4c54, module_problem$config ); | ||
| 378 | |||
| 379 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 380 | // owning it. | ||
| 381 | pushFrameStack( frame_fd4a70ef8a112678d459bb3386ad4c54 ); | ||
| 382 | assert( Py_REFCNT( frame_fd4a70ef8a112678d459bb3386ad4c54 ) == 2 ); | ||
| 383 | |||
| 384 | // Framed code: | ||
| 385 | { | ||
| 386 | PyObject *tmp_assattr_name_1; | ||
| 387 | PyObject *tmp_assattr_target_1; | ||
| 388 | PyObject *tmp_mvar_value_1; | ||
| 389 | tmp_assattr_name_1 = module_filename_obj; | ||
| 390 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 391 | |||
| 392 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 393 | { | ||
| 394 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 395 | } | ||
| 396 | |||
| 397 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 398 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 399 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 400 | if ( tmp_result == false ) | ||
| 401 | { | ||
| 402 | assert( ERROR_OCCURRED() ); | ||
| 403 | |||
| 404 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 405 | |||
| 406 | |||
| 407 | exception_lineno = 1; | ||
| 408 | |||
| 409 | goto frame_exception_exit_1; | ||
| 410 | } | ||
| 411 | } | ||
| 412 | { | ||
| 413 | PyObject *tmp_assattr_name_2; | ||
| 414 | PyObject *tmp_assattr_target_2; | ||
| 415 | PyObject *tmp_mvar_value_2; | ||
| 416 | tmp_assattr_name_2 = Py_True; | ||
| 417 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 418 | |||
| 419 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 420 | { | ||
| 421 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 422 | } | ||
| 423 | |||
| 424 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 425 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 426 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 427 | if ( tmp_result == false ) | ||
| 428 | { | ||
| 429 | assert( ERROR_OCCURRED() ); | ||
| 430 | |||
| 431 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 432 | |||
| 433 | |||
| 434 | exception_lineno = 1; | ||
| 435 | |||
| 436 | goto frame_exception_exit_1; | ||
| 437 | } | ||
| 438 | } | ||
| 439 | |||
| 440 | // Restore frame exception if necessary. | ||
| 441 | #if 0 | ||
| 442 | RESTORE_FRAME_EXCEPTION( frame_fd4a70ef8a112678d459bb3386ad4c54 ); | ||
| 443 | #endif | ||
| 444 | popFrameStack(); | ||
| 445 | |||
| 446 | assertFrameObject( frame_fd4a70ef8a112678d459bb3386ad4c54 ); | ||
| 447 | |||
| 448 | goto frame_no_exception_1; | ||
| 449 | |||
| 450 | frame_exception_exit_1:; | ||
| 451 | #if 0 | ||
| 452 | RESTORE_FRAME_EXCEPTION( frame_fd4a70ef8a112678d459bb3386ad4c54 ); | ||
| 453 | #endif | ||
| 454 | |||
| 455 | if ( exception_tb == NULL ) | ||
| 456 | { | ||
| 457 | exception_tb = MAKE_TRACEBACK( frame_fd4a70ef8a112678d459bb3386ad4c54, exception_lineno ); | ||
| 458 | } | ||
| 459 | else if ( exception_tb->tb_frame != &frame_fd4a70ef8a112678d459bb3386ad4c54->m_frame ) | ||
| 460 | { | ||
| 461 | exception_tb = ADD_TRACEBACK( exception_tb, frame_fd4a70ef8a112678d459bb3386ad4c54, exception_lineno ); | ||
| 462 | } | ||
| 463 | |||
| 464 | // Put the previous frame back on top. | ||
| 465 | popFrameStack(); | ||
| 466 | |||
| 467 | // Return the error. | ||
| 468 | goto module_exception_exit; | ||
| 469 | |||
| 470 | frame_no_exception_1:; | ||
| 471 | { | ||
| 472 | PyObject *tmp_assign_source_3; | ||
| 473 | tmp_assign_source_3 = Py_None; | ||
| 474 | UPDATE_STRING_DICT0( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 475 | } | ||
| 476 | { | ||
| 477 | PyObject *tmp_assign_source_4; | ||
| 478 | tmp_assign_source_4 = const_str_digest_4f06c4a09ed82220293be841d8ea9ac4; | ||
| 479 | UPDATE_STRING_DICT0( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain_DEFAULT_DUMP_LOCATION, tmp_assign_source_4 ); | ||
| 480 | } | ||
| 481 | |||
| 482 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 483 | #if 0 && 0 | ||
| 484 | { | ||
| 485 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_problem$config, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 486 | |||
| 487 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 488 | { | ||
| 489 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 490 | |||
| 491 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 492 | CHECK_OBJECT( path_importer_cache ); | ||
| 493 | |||
| 494 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 495 | assert( res == 0 ); | ||
| 496 | } | ||
| 497 | } | ||
| 498 | #endif | ||
| 499 | #endif | ||
| 500 | |||
| 501 | return MOD_RETURN_VALUE( module_problem$config ); | ||
| 502 | module_exception_exit: | ||
| 503 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 504 | return MOD_RETURN_VALUE( NULL ); | ||
| 505 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.problem.config.o deleted (index 1cb6528..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.problem.exception.c deleted (index e470e2c..0000000) | |||
| 1 | /* Generated code for Python module 'problem.exception' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_problem$exception" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_problem$exception; | ||
| 31 | PyDictObject *moduledict_problem$exception; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain___orig_bases__; | ||
| 35 | extern PyObject *const_tuple_type_Exception_tuple; | ||
| 36 | extern PyObject *const_str_plain_ValidationError; | ||
| 37 | extern PyObject *const_str_plain___module__; | ||
| 38 | extern PyObject *const_str_plain_metaclass; | ||
| 39 | static PyObject *const_str_digest_bee932220404a0d6d16451c5d76caea9; | ||
| 40 | extern PyObject *const_str_plain___spec__; | ||
| 41 | static PyObject *const_str_plain_UnavailableSource; | ||
| 42 | static PyObject *const_str_digest_2eaf9b251885e997348baaf55bbf0533; | ||
| 43 | extern PyObject *const_str_plain___name__; | ||
| 44 | extern PyObject *const_str_plain___getitem__; | ||
| 45 | extern PyObject *const_str_plain___qualname__; | ||
| 46 | extern PyObject *const_str_angle_metaclass; | ||
| 47 | extern PyObject *const_str_plain_InvalidProblem; | ||
| 48 | extern PyObject *const_str_plain___file__; | ||
| 49 | extern PyObject *const_str_plain_AuthFailure; | ||
| 50 | static PyObject *const_str_digest_00db517de1bed7d0a4665e59ad7cde98; | ||
| 51 | extern PyObject *const_int_0; | ||
| 52 | extern PyObject *const_str_plain___prepare__; | ||
| 53 | extern PyObject *const_str_plain_origin; | ||
| 54 | extern PyObject *const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 55 | extern PyObject *const_tuple_empty; | ||
| 56 | extern PyObject *const_str_plain_has_location; | ||
| 57 | extern PyObject *const_str_plain_type; | ||
| 58 | extern PyObject *const_str_plain___doc__; | ||
| 59 | extern PyObject *const_str_plain___cached__; | ||
| 60 | static PyObject *module_filename_obj; | ||
| 61 | |||
| 62 | /* Indicator if this modules private constants were created yet. */ | ||
| 63 | static bool constants_created = false; | ||
| 64 | |||
| 65 | /* Function to create module private constants. */ | ||
| 66 | static void createModuleConstants( void ) | ||
| 67 | { | ||
| 68 | const_str_digest_bee932220404a0d6d16451c5d76caea9 = UNSTREAM_STRING_ASCII( &constant_bin[ 58191 ], 26, 0 ); | ||
| 69 | const_str_plain_UnavailableSource = UNSTREAM_STRING_ASCII( &constant_bin[ 58217 ], 17, 1 ); | ||
| 70 | const_str_digest_2eaf9b251885e997348baaf55bbf0533 = UNSTREAM_STRING_ASCII( &constant_bin[ 58199 ], 17, 0 ); | ||
| 71 | const_str_digest_00db517de1bed7d0a4665e59ad7cde98 = UNSTREAM_STRING_ASCII( &constant_bin[ 58234 ], 20, 0 ); | ||
| 72 | |||
| 73 | constants_created = true; | ||
| 74 | } | ||
| 75 | |||
| 76 | /* Function to verify module private constants for non-corruption. */ | ||
| 77 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 78 | void checkModuleConstants_problem$exception( void ) | ||
| 79 | { | ||
| 80 | // The module may not have been used at all, then ignore this. | ||
| 81 | if (constants_created == false) return; | ||
| 82 | |||
| 83 | |||
| 84 | } | ||
| 85 | #endif | ||
| 86 | |||
| 87 | // The module code objects. | ||
| 88 | static PyCodeObject *codeobj_8a1d77d53dfcd0df1957edabb69a2c4a; | ||
| 89 | |||
| 90 | static void createModuleCodeObjects(void) | ||
| 91 | { | ||
| 92 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_00db517de1bed7d0a4665e59ad7cde98 ); | ||
| 93 | codeobj_8a1d77d53dfcd0df1957edabb69a2c4a = MAKE_CODEOBJ( module_filename_obj, const_str_digest_bee932220404a0d6d16451c5d76caea9, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 94 | } | ||
| 95 | |||
| 96 | // The module function declarations. | ||
| 97 | NUITKA_CROSS_MODULE PyObject *impl___internal__$$$function_2__mro_entries_conversion( PyObject **python_pars ); | ||
| 98 | |||
| 99 | |||
| 100 | // The module function definitions. | ||
| 101 | |||
| 102 | |||
| 103 | |||
| 104 | #if PYTHON_VERSION >= 300 | ||
| 105 | static struct PyModuleDef mdef_problem$exception = | ||
| 106 | { | ||
| 107 | PyModuleDef_HEAD_INIT, | ||
| 108 | "problem.exception", | ||
| 109 | NULL, /* m_doc */ | ||
| 110 | -1, /* m_size */ | ||
| 111 | NULL, /* m_methods */ | ||
| 112 | NULL, /* m_reload */ | ||
| 113 | NULL, /* m_traverse */ | ||
| 114 | NULL, /* m_clear */ | ||
| 115 | NULL, /* m_free */ | ||
| 116 | }; | ||
| 117 | #endif | ||
| 118 | |||
| 119 | extern PyObject *const_str_plain___compiled__; | ||
| 120 | |||
| 121 | extern PyObject *const_str_plain___package__; | ||
| 122 | |||
| 123 | #if PYTHON_VERSION >= 300 | ||
| 124 | extern PyObject *const_str_dot; | ||
| 125 | extern PyObject *const_str_plain___loader__; | ||
| 126 | #endif | ||
| 127 | |||
| 128 | #if PYTHON_VERSION >= 340 | ||
| 129 | extern PyObject *const_str_plain___spec__; | ||
| 130 | extern PyObject *const_str_plain__initializing; | ||
| 131 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 132 | #endif | ||
| 133 | |||
| 134 | extern void _initCompiledCellType(); | ||
| 135 | extern void _initCompiledGeneratorType(); | ||
| 136 | extern void _initCompiledFunctionType(); | ||
| 137 | extern void _initCompiledMethodType(); | ||
| 138 | extern void _initCompiledFrameType(); | ||
| 139 | #if PYTHON_VERSION >= 350 | ||
| 140 | extern void _initCompiledCoroutineTypes(); | ||
| 141 | #endif | ||
| 142 | #if PYTHON_VERSION >= 360 | ||
| 143 | extern void _initCompiledAsyncgenTypes(); | ||
| 144 | #endif | ||
| 145 | |||
| 146 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 147 | |||
| 148 | // The exported interface to CPython. On import of the module, this function | ||
| 149 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 150 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 151 | |||
| 152 | MOD_INIT_DECL( problem$exception ) | ||
| 153 | { | ||
| 154 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 155 | static bool _init_done = false; | ||
| 156 | |||
| 157 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 158 | if ( _init_done ) | ||
| 159 | { | ||
| 160 | return MOD_RETURN_VALUE( module_problem$exception ); | ||
| 161 | } | ||
| 162 | else | ||
| 163 | { | ||
| 164 | _init_done = true; | ||
| 165 | } | ||
| 166 | #endif | ||
| 167 | |||
| 168 | #ifdef _NUITKA_MODULE | ||
| 169 | // In case of a stand alone extension module, need to call initialization | ||
| 170 | // the init here because that's the first and only time we are going to get | ||
| 171 | // called here. | ||
| 172 | |||
| 173 | // Initialize the constant values used. | ||
| 174 | _initBuiltinModule(); | ||
| 175 | createGlobalConstants(); | ||
| 176 | |||
| 177 | /* Initialize the compiled types of Nuitka. */ | ||
| 178 | _initCompiledCellType(); | ||
| 179 | _initCompiledGeneratorType(); | ||
| 180 | _initCompiledFunctionType(); | ||
| 181 | _initCompiledMethodType(); | ||
| 182 | _initCompiledFrameType(); | ||
| 183 | #if PYTHON_VERSION >= 350 | ||
| 184 | _initCompiledCoroutineTypes(); | ||
| 185 | #endif | ||
| 186 | #if PYTHON_VERSION >= 360 | ||
| 187 | _initCompiledAsyncgenTypes(); | ||
| 188 | #endif | ||
| 189 | |||
| 190 | #if PYTHON_VERSION < 300 | ||
| 191 | _initSlotCompare(); | ||
| 192 | #endif | ||
| 193 | #if PYTHON_VERSION >= 270 | ||
| 194 | _initSlotIternext(); | ||
| 195 | #endif | ||
| 196 | |||
| 197 | patchBuiltinModule(); | ||
| 198 | patchTypeComparison(); | ||
| 199 | |||
| 200 | // Enable meta path based loader if not already done. | ||
| 201 | #ifdef _NUITKA_TRACE | ||
| 202 | puts("problem.exception: Calling setupMetaPathBasedLoader()."); | ||
| 203 | #endif | ||
| 204 | setupMetaPathBasedLoader(); | ||
| 205 | |||
| 206 | #if PYTHON_VERSION >= 300 | ||
| 207 | patchInspectModule(); | ||
| 208 | #endif | ||
| 209 | |||
| 210 | #endif | ||
| 211 | |||
| 212 | /* The constants only used by this module are created now. */ | ||
| 213 | #ifdef _NUITKA_TRACE | ||
| 214 | puts("problem.exception: Calling createModuleConstants()."); | ||
| 215 | #endif | ||
| 216 | createModuleConstants(); | ||
| 217 | |||
| 218 | /* The code objects used by this module are created now. */ | ||
| 219 | #ifdef _NUITKA_TRACE | ||
| 220 | puts("problem.exception: Calling createModuleCodeObjects()."); | ||
| 221 | #endif | ||
| 222 | createModuleCodeObjects(); | ||
| 223 | |||
| 224 | // puts( "in initproblem$exception" ); | ||
| 225 | |||
| 226 | // Create the module object first. There are no methods initially, all are | ||
| 227 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 228 | // set at this time, as it could not contain NUL characters this way, they | ||
| 229 | // are instead set in early module code. No "self" for modules, we have no | ||
| 230 | // use for it. | ||
| 231 | #if PYTHON_VERSION < 300 | ||
| 232 | module_problem$exception = Py_InitModule4( | ||
| 233 | "problem.exception", // Module Name | ||
| 234 | NULL, // No methods initially, all are added | ||
| 235 | // dynamically in actual module code only. | ||
| 236 | NULL, // No "__doc__" is initially set, as it could | ||
| 237 | // not contain NUL this way, added early in | ||
| 238 | // actual code. | ||
| 239 | NULL, // No self for modules, we don't use it. | ||
| 240 | PYTHON_API_VERSION | ||
| 241 | ); | ||
| 242 | #else | ||
| 243 | |||
| 244 | module_problem$exception = PyModule_Create( &mdef_problem$exception ); | ||
| 245 | #endif | ||
| 246 | |||
| 247 | moduledict_problem$exception = MODULE_DICT( module_problem$exception ); | ||
| 248 | |||
| 249 | // Set __compiled__ to what it we know. | ||
| 250 | UPDATE_STRING_DICT1( | ||
| 251 | moduledict_problem$exception, | ||
| 252 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 253 | Nuitka_dunder_compiled_value | ||
| 254 | ); | ||
| 255 | |||
| 256 | // Update "__package__" value to what it ought to be. | ||
| 257 | { | ||
| 258 | #if 0 | ||
| 259 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 260 | |||
| 261 | UPDATE_STRING_DICT1( | ||
| 262 | moduledict_problem$exception, | ||
| 263 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 264 | module_name | ||
| 265 | ); | ||
| 266 | #else | ||
| 267 | |||
| 268 | #if PYTHON_VERSION < 300 | ||
| 269 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 270 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 271 | |||
| 272 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 273 | |||
| 274 | if ( last_dot != NULL ) | ||
| 275 | { | ||
| 276 | UPDATE_STRING_DICT1( | ||
| 277 | moduledict_problem$exception, | ||
| 278 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 279 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 280 | ); | ||
| 281 | } | ||
| 282 | #else | ||
| 283 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 284 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 285 | |||
| 286 | if ( dot_index != -1 ) | ||
| 287 | { | ||
| 288 | UPDATE_STRING_DICT1( | ||
| 289 | moduledict_problem$exception, | ||
| 290 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 291 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 292 | ); | ||
| 293 | } | ||
| 294 | #endif | ||
| 295 | #endif | ||
| 296 | } | ||
| 297 | |||
| 298 | CHECK_OBJECT( module_problem$exception ); | ||
| 299 | |||
| 300 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 301 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 302 | #if PYTHON_VERSION >= 300 | ||
| 303 | { | ||
| 304 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_2eaf9b251885e997348baaf55bbf0533, module_problem$exception ); | ||
| 305 | |||
| 306 | assert( r != -1 ); | ||
| 307 | } | ||
| 308 | #endif | ||
| 309 | |||
| 310 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 311 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 312 | // before the frame object is allocated, or else it may fail. | ||
| 313 | |||
| 314 | if ( GET_STRING_DICT_VALUE( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 315 | { | ||
| 316 | PyObject *value = (PyObject *)builtin_module; | ||
| 317 | |||
| 318 | // Check if main module, not a dict then but the module itself. | ||
| 319 | #if !defined(_NUITKA_EXE) || !0 | ||
| 320 | value = PyModule_GetDict( value ); | ||
| 321 | #endif | ||
| 322 | |||
| 323 | UPDATE_STRING_DICT0( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 324 | } | ||
| 325 | |||
| 326 | #if PYTHON_VERSION >= 300 | ||
| 327 | UPDATE_STRING_DICT0( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 328 | #endif | ||
| 329 | |||
| 330 | #if PYTHON_VERSION >= 340 | ||
| 331 | // Set the "__spec__" value | ||
| 332 | |||
| 333 | #if 0 | ||
| 334 | // Main modules just get "None" as spec. | ||
| 335 | UPDATE_STRING_DICT0( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 336 | #else | ||
| 337 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 338 | { | ||
| 339 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 340 | CHECK_OBJECT( bootstrap_module ); | ||
| 341 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 342 | Py_DECREF( bootstrap_module ); | ||
| 343 | |||
| 344 | PyObject *args[] = { | ||
| 345 | GET_STRING_DICT_VALUE( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 346 | (PyObject *)&Nuitka_Loader_Type | ||
| 347 | }; | ||
| 348 | |||
| 349 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 350 | module_spec_class, | ||
| 351 | args | ||
| 352 | ); | ||
| 353 | Py_DECREF( module_spec_class ); | ||
| 354 | |||
| 355 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 356 | CHECK_OBJECT( spec_value ); | ||
| 357 | |||
| 358 | // For packages set the submodule search locations as well, even if to empty | ||
| 359 | // list, so investigating code will consider it a package. | ||
| 360 | #if 0 | ||
| 361 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 362 | #endif | ||
| 363 | |||
| 364 | // Mark the execution in the "__spec__" value. | ||
| 365 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 366 | |||
| 367 | UPDATE_STRING_DICT1( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 368 | } | ||
| 369 | #endif | ||
| 370 | #endif | ||
| 371 | |||
| 372 | // Temp variables if any | ||
| 373 | PyObject *outline_0_var___class__ = NULL; | ||
| 374 | PyObject *outline_1_var___class__ = NULL; | ||
| 375 | PyObject *outline_2_var___class__ = NULL; | ||
| 376 | PyObject *outline_3_var___class__ = NULL; | ||
| 377 | PyObject *tmp_class_creation_1__bases = NULL; | ||
| 378 | PyObject *tmp_class_creation_1__class_decl_dict = NULL; | ||
| 379 | PyObject *tmp_class_creation_1__metaclass = NULL; | ||
| 380 | PyObject *tmp_class_creation_1__prepared = NULL; | ||
| 381 | PyObject *tmp_class_creation_2__bases = NULL; | ||
| 382 | PyObject *tmp_class_creation_2__class_decl_dict = NULL; | ||
| 383 | PyObject *tmp_class_creation_2__metaclass = NULL; | ||
| 384 | PyObject *tmp_class_creation_2__prepared = NULL; | ||
| 385 | PyObject *tmp_class_creation_3__bases = NULL; | ||
| 386 | PyObject *tmp_class_creation_3__class_decl_dict = NULL; | ||
| 387 | PyObject *tmp_class_creation_3__metaclass = NULL; | ||
| 388 | PyObject *tmp_class_creation_3__prepared = NULL; | ||
| 389 | PyObject *tmp_class_creation_4__bases = NULL; | ||
| 390 | PyObject *tmp_class_creation_4__class_decl_dict = NULL; | ||
| 391 | PyObject *tmp_class_creation_4__metaclass = NULL; | ||
| 392 | PyObject *tmp_class_creation_4__prepared = NULL; | ||
| 393 | struct Nuitka_FrameObject *frame_8a1d77d53dfcd0df1957edabb69a2c4a; | ||
| 394 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 395 | bool tmp_result; | ||
| 396 | PyObject *exception_type = NULL; | ||
| 397 | PyObject *exception_value = NULL; | ||
| 398 | PyTracebackObject *exception_tb = NULL; | ||
| 399 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 400 | int tmp_res; | ||
| 401 | PyObject *tmp_dictdel_dict; | ||
| 402 | PyObject *tmp_dictdel_key; | ||
| 403 | PyObject *locals_problem$exception_1 = NULL; | ||
| 404 | PyObject *tmp_dictset_value; | ||
| 405 | PyObject *exception_keeper_type_1; | ||
| 406 | PyObject *exception_keeper_value_1; | ||
| 407 | PyTracebackObject *exception_keeper_tb_1; | ||
| 408 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 409 | PyObject *exception_keeper_type_2; | ||
| 410 | PyObject *exception_keeper_value_2; | ||
| 411 | PyTracebackObject *exception_keeper_tb_2; | ||
| 412 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 413 | PyObject *exception_keeper_type_3; | ||
| 414 | PyObject *exception_keeper_value_3; | ||
| 415 | PyTracebackObject *exception_keeper_tb_3; | ||
| 416 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; | ||
| 417 | PyObject *locals_problem$exception_5 = NULL; | ||
| 418 | PyObject *exception_keeper_type_4; | ||
| 419 | PyObject *exception_keeper_value_4; | ||
| 420 | PyTracebackObject *exception_keeper_tb_4; | ||
| 421 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_4; | ||
| 422 | PyObject *exception_keeper_type_5; | ||
| 423 | PyObject *exception_keeper_value_5; | ||
| 424 | PyTracebackObject *exception_keeper_tb_5; | ||
| 425 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_5; | ||
| 426 | PyObject *exception_keeper_type_6; | ||
| 427 | PyObject *exception_keeper_value_6; | ||
| 428 | PyTracebackObject *exception_keeper_tb_6; | ||
| 429 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_6; | ||
| 430 | PyObject *locals_problem$exception_9 = NULL; | ||
| 431 | PyObject *exception_keeper_type_7; | ||
| 432 | PyObject *exception_keeper_value_7; | ||
| 433 | PyTracebackObject *exception_keeper_tb_7; | ||
| 434 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_7; | ||
| 435 | PyObject *exception_keeper_type_8; | ||
| 436 | PyObject *exception_keeper_value_8; | ||
| 437 | PyTracebackObject *exception_keeper_tb_8; | ||
| 438 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_8; | ||
| 439 | PyObject *exception_keeper_type_9; | ||
| 440 | PyObject *exception_keeper_value_9; | ||
| 441 | PyTracebackObject *exception_keeper_tb_9; | ||
| 442 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_9; | ||
| 443 | PyObject *locals_problem$exception_13 = NULL; | ||
| 444 | PyObject *exception_keeper_type_10; | ||
| 445 | PyObject *exception_keeper_value_10; | ||
| 446 | PyTracebackObject *exception_keeper_tb_10; | ||
| 447 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_10; | ||
| 448 | PyObject *exception_keeper_type_11; | ||
| 449 | PyObject *exception_keeper_value_11; | ||
| 450 | PyTracebackObject *exception_keeper_tb_11; | ||
| 451 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_11; | ||
| 452 | PyObject *exception_keeper_type_12; | ||
| 453 | PyObject *exception_keeper_value_12; | ||
| 454 | PyTracebackObject *exception_keeper_tb_12; | ||
| 455 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_12; | ||
| 456 | |||
| 457 | // Module code. | ||
| 458 | { | ||
| 459 | PyObject *tmp_assign_source_1; | ||
| 460 | tmp_assign_source_1 = Py_None; | ||
| 461 | UPDATE_STRING_DICT0( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 462 | } | ||
| 463 | { | ||
| 464 | PyObject *tmp_assign_source_2; | ||
| 465 | tmp_assign_source_2 = module_filename_obj; | ||
| 466 | UPDATE_STRING_DICT0( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 467 | } | ||
| 468 | // Frame without reuse. | ||
| 469 | frame_8a1d77d53dfcd0df1957edabb69a2c4a = MAKE_MODULE_FRAME( codeobj_8a1d77d53dfcd0df1957edabb69a2c4a, module_problem$exception ); | ||
| 470 | |||
| 471 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 472 | // owning it. | ||
| 473 | pushFrameStack( frame_8a1d77d53dfcd0df1957edabb69a2c4a ); | ||
| 474 | assert( Py_REFCNT( frame_8a1d77d53dfcd0df1957edabb69a2c4a ) == 2 ); | ||
| 475 | |||
| 476 | // Framed code: | ||
| 477 | { | ||
| 478 | PyObject *tmp_assattr_name_1; | ||
| 479 | PyObject *tmp_assattr_target_1; | ||
| 480 | PyObject *tmp_mvar_value_1; | ||
| 481 | tmp_assattr_name_1 = module_filename_obj; | ||
| 482 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 483 | |||
| 484 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 485 | { | ||
| 486 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 487 | } | ||
| 488 | |||
| 489 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 490 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 491 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 492 | if ( tmp_result == false ) | ||
| 493 | { | ||
| 494 | assert( ERROR_OCCURRED() ); | ||
| 495 | |||
| 496 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 497 | |||
| 498 | |||
| 499 | exception_lineno = 1; | ||
| 500 | |||
| 501 | goto frame_exception_exit_1; | ||
| 502 | } | ||
| 503 | } | ||
| 504 | { | ||
| 505 | PyObject *tmp_assattr_name_2; | ||
| 506 | PyObject *tmp_assattr_target_2; | ||
| 507 | PyObject *tmp_mvar_value_2; | ||
| 508 | tmp_assattr_name_2 = Py_True; | ||
| 509 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 510 | |||
| 511 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 512 | { | ||
| 513 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 514 | } | ||
| 515 | |||
| 516 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 517 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 518 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 519 | if ( tmp_result == false ) | ||
| 520 | { | ||
| 521 | assert( ERROR_OCCURRED() ); | ||
| 522 | |||
| 523 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 524 | |||
| 525 | |||
| 526 | exception_lineno = 1; | ||
| 527 | |||
| 528 | goto frame_exception_exit_1; | ||
| 529 | } | ||
| 530 | } | ||
| 531 | { | ||
| 532 | PyObject *tmp_assign_source_3; | ||
| 533 | tmp_assign_source_3 = Py_None; | ||
| 534 | UPDATE_STRING_DICT0( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 535 | } | ||
| 536 | // Tried code: | ||
| 537 | { | ||
| 538 | PyObject *tmp_assign_source_4; | ||
| 539 | PyObject *tmp_dircall_arg1_1; | ||
| 540 | tmp_dircall_arg1_1 = const_tuple_type_Exception_tuple; | ||
| 541 | Py_INCREF( tmp_dircall_arg1_1 ); | ||
| 542 | |||
| 543 | { | ||
| 544 | PyObject *dir_call_args[] = {tmp_dircall_arg1_1}; | ||
| 545 | tmp_assign_source_4 = impl___internal__$$$function_2__mro_entries_conversion( dir_call_args ); | ||
| 546 | } | ||
| 547 | if ( tmp_assign_source_4 == NULL ) | ||
| 548 | { | ||
| 549 | assert( ERROR_OCCURRED() ); | ||
| 550 | |||
| 551 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 552 | |||
| 553 | |||
| 554 | exception_lineno = 1; | ||
| 555 | |||
| 556 | goto try_except_handler_1; | ||
| 557 | } | ||
| 558 | assert( tmp_class_creation_1__bases == NULL ); | ||
| 559 | tmp_class_creation_1__bases = tmp_assign_source_4; | ||
| 560 | } | ||
| 561 | { | ||
| 562 | PyObject *tmp_assign_source_5; | ||
| 563 | tmp_assign_source_5 = PyDict_New(); | ||
| 564 | assert( tmp_class_creation_1__class_decl_dict == NULL ); | ||
| 565 | tmp_class_creation_1__class_decl_dict = tmp_assign_source_5; | ||
| 566 | } | ||
| 567 | { | ||
| 568 | PyObject *tmp_assign_source_6; | ||
| 569 | PyObject *tmp_metaclass_name_1; | ||
| 570 | nuitka_bool tmp_condition_result_1; | ||
| 571 | PyObject *tmp_key_name_1; | ||
| 572 | PyObject *tmp_dict_name_1; | ||
| 573 | PyObject *tmp_dict_name_2; | ||
| 574 | PyObject *tmp_key_name_2; | ||
| 575 | nuitka_bool tmp_condition_result_2; | ||
| 576 | int tmp_truth_name_1; | ||
| 577 | PyObject *tmp_type_arg_1; | ||
| 578 | PyObject *tmp_subscribed_name_1; | ||
| 579 | PyObject *tmp_subscript_name_1; | ||
| 580 | PyObject *tmp_bases_name_1; | ||
| 581 | tmp_key_name_1 = const_str_plain_metaclass; | ||
| 582 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 583 | tmp_dict_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 584 | tmp_res = PyDict_Contains( tmp_dict_name_1, tmp_key_name_1 ); | ||
| 585 | if ( tmp_res == -1 ) | ||
| 586 | { | ||
| 587 | assert( ERROR_OCCURRED() ); | ||
| 588 | |||
| 589 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 590 | |||
| 591 | |||
| 592 | exception_lineno = 1; | ||
| 593 | |||
| 594 | goto try_except_handler_1; | ||
| 595 | } | ||
| 596 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 597 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 598 | { | ||
| 599 | goto condexpr_true_1; | ||
| 600 | } | ||
| 601 | else | ||
| 602 | { | ||
| 603 | goto condexpr_false_1; | ||
| 604 | } | ||
| 605 | condexpr_true_1:; | ||
| 606 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 607 | tmp_dict_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 608 | tmp_key_name_2 = const_str_plain_metaclass; | ||
| 609 | tmp_metaclass_name_1 = DICT_GET_ITEM( tmp_dict_name_2, tmp_key_name_2 ); | ||
| 610 | if ( tmp_metaclass_name_1 == NULL ) | ||
| 611 | { | ||
| 612 | assert( ERROR_OCCURRED() ); | ||
| 613 | |||
| 614 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 615 | |||
| 616 | |||
| 617 | exception_lineno = 1; | ||
| 618 | |||
| 619 | goto try_except_handler_1; | ||
| 620 | } | ||
| 621 | goto condexpr_end_1; | ||
| 622 | condexpr_false_1:; | ||
| 623 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 624 | tmp_truth_name_1 = CHECK_IF_TRUE( tmp_class_creation_1__bases ); | ||
| 625 | if ( tmp_truth_name_1 == -1 ) | ||
| 626 | { | ||
| 627 | assert( ERROR_OCCURRED() ); | ||
| 628 | |||
| 629 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 630 | |||
| 631 | |||
| 632 | exception_lineno = 1; | ||
| 633 | |||
| 634 | goto try_except_handler_1; | ||
| 635 | } | ||
| 636 | tmp_condition_result_2 = tmp_truth_name_1 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 637 | if ( tmp_condition_result_2 == NUITKA_BOOL_TRUE ) | ||
| 638 | { | ||
| 639 | goto condexpr_true_2; | ||
| 640 | } | ||
| 641 | else | ||
| 642 | { | ||
| 643 | goto condexpr_false_2; | ||
| 644 | } | ||
| 645 | condexpr_true_2:; | ||
| 646 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 647 | tmp_subscribed_name_1 = tmp_class_creation_1__bases; | ||
| 648 | tmp_subscript_name_1 = const_int_0; | ||
| 649 | tmp_type_arg_1 = LOOKUP_SUBSCRIPT_CONST( tmp_subscribed_name_1, tmp_subscript_name_1, 0 ); | ||
| 650 | if ( tmp_type_arg_1 == NULL ) | ||
| 651 | { | ||
| 652 | assert( ERROR_OCCURRED() ); | ||
| 653 | |||
| 654 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 655 | |||
| 656 | |||
| 657 | exception_lineno = 1; | ||
| 658 | |||
| 659 | goto try_except_handler_1; | ||
| 660 | } | ||
| 661 | tmp_metaclass_name_1 = BUILTIN_TYPE1( tmp_type_arg_1 ); | ||
| 662 | Py_DECREF( tmp_type_arg_1 ); | ||
| 663 | if ( tmp_metaclass_name_1 == NULL ) | ||
| 664 | { | ||
| 665 | assert( ERROR_OCCURRED() ); | ||
| 666 | |||
| 667 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 668 | |||
| 669 | |||
| 670 | exception_lineno = 1; | ||
| 671 | |||
| 672 | goto try_except_handler_1; | ||
| 673 | } | ||
| 674 | goto condexpr_end_2; | ||
| 675 | condexpr_false_2:; | ||
| 676 | tmp_metaclass_name_1 = (PyObject *)&PyType_Type; | ||
| 677 | Py_INCREF( tmp_metaclass_name_1 ); | ||
| 678 | condexpr_end_2:; | ||
| 679 | condexpr_end_1:; | ||
| 680 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 681 | tmp_bases_name_1 = tmp_class_creation_1__bases; | ||
| 682 | tmp_assign_source_6 = SELECT_METACLASS( tmp_metaclass_name_1, tmp_bases_name_1 ); | ||
| 683 | Py_DECREF( tmp_metaclass_name_1 ); | ||
| 684 | if ( tmp_assign_source_6 == NULL ) | ||
| 685 | { | ||
| 686 | assert( ERROR_OCCURRED() ); | ||
| 687 | |||
| 688 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 689 | |||
| 690 | |||
| 691 | exception_lineno = 1; | ||
| 692 | |||
| 693 | goto try_except_handler_1; | ||
| 694 | } | ||
| 695 | assert( tmp_class_creation_1__metaclass == NULL ); | ||
| 696 | tmp_class_creation_1__metaclass = tmp_assign_source_6; | ||
| 697 | } | ||
| 698 | { | ||
| 699 | nuitka_bool tmp_condition_result_3; | ||
| 700 | PyObject *tmp_key_name_3; | ||
| 701 | PyObject *tmp_dict_name_3; | ||
| 702 | tmp_key_name_3 = const_str_plain_metaclass; | ||
| 703 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 704 | tmp_dict_name_3 = tmp_class_creation_1__class_decl_dict; | ||
| 705 | tmp_res = PyDict_Contains( tmp_dict_name_3, tmp_key_name_3 ); | ||
| 706 | if ( tmp_res == -1 ) | ||
| 707 | { | ||
| 708 | assert( ERROR_OCCURRED() ); | ||
| 709 | |||
| 710 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 711 | |||
| 712 | |||
| 713 | exception_lineno = 1; | ||
| 714 | |||
| 715 | goto try_except_handler_1; | ||
| 716 | } | ||
| 717 | tmp_condition_result_3 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 718 | if ( tmp_condition_result_3 == NUITKA_BOOL_TRUE ) | ||
| 719 | { | ||
| 720 | goto branch_yes_1; | ||
| 721 | } | ||
| 722 | else | ||
| 723 | { | ||
| 724 | goto branch_no_1; | ||
| 725 | } | ||
| 726 | branch_yes_1:; | ||
| 727 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 728 | tmp_dictdel_dict = tmp_class_creation_1__class_decl_dict; | ||
| 729 | tmp_dictdel_key = const_str_plain_metaclass; | ||
| 730 | tmp_result = DICT_REMOVE_ITEM( tmp_dictdel_dict, tmp_dictdel_key ); | ||
| 731 | if ( tmp_result == false ) | ||
| 732 | { | ||
| 733 | assert( ERROR_OCCURRED() ); | ||
| 734 | |||
| 735 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 736 | |||
| 737 | |||
| 738 | exception_lineno = 1; | ||
| 739 | |||
| 740 | goto try_except_handler_1; | ||
| 741 | } | ||
| 742 | branch_no_1:; | ||
| 743 | } | ||
| 744 | { | ||
| 745 | nuitka_bool tmp_condition_result_4; | ||
| 746 | PyObject *tmp_source_name_1; | ||
| 747 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 748 | tmp_source_name_1 = tmp_class_creation_1__metaclass; | ||
| 749 | tmp_res = PyObject_HasAttr( tmp_source_name_1, const_str_plain___prepare__ ); | ||
| 750 | tmp_condition_result_4 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 751 | if ( tmp_condition_result_4 == NUITKA_BOOL_TRUE ) | ||
| 752 | { | ||
| 753 | goto branch_yes_2; | ||
| 754 | } | ||
| 755 | else | ||
| 756 | { | ||
| 757 | goto branch_no_2; | ||
| 758 | } | ||
| 759 | branch_yes_2:; | ||
| 760 | { | ||
| 761 | PyObject *tmp_assign_source_7; | ||
| 762 | PyObject *tmp_called_name_1; | ||
| 763 | PyObject *tmp_source_name_2; | ||
| 764 | PyObject *tmp_args_name_1; | ||
| 765 | PyObject *tmp_tuple_element_1; | ||
| 766 | PyObject *tmp_kw_name_1; | ||
| 767 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 768 | tmp_source_name_2 = tmp_class_creation_1__metaclass; | ||
| 769 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain___prepare__ ); | ||
| 770 | if ( tmp_called_name_1 == NULL ) | ||
| 771 | { | ||
| 772 | assert( ERROR_OCCURRED() ); | ||
| 773 | |||
| 774 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 775 | |||
| 776 | |||
| 777 | exception_lineno = 1; | ||
| 778 | |||
| 779 | goto try_except_handler_1; | ||
| 780 | } | ||
| 781 | tmp_tuple_element_1 = const_str_plain_AuthFailure; | ||
| 782 | tmp_args_name_1 = PyTuple_New( 2 ); | ||
| 783 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 784 | PyTuple_SET_ITEM( tmp_args_name_1, 0, tmp_tuple_element_1 ); | ||
| 785 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 786 | tmp_tuple_element_1 = tmp_class_creation_1__bases; | ||
| 787 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 788 | PyTuple_SET_ITEM( tmp_args_name_1, 1, tmp_tuple_element_1 ); | ||
| 789 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 790 | tmp_kw_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 791 | frame_8a1d77d53dfcd0df1957edabb69a2c4a->m_frame.f_lineno = 1; | ||
| 792 | tmp_assign_source_7 = CALL_FUNCTION( tmp_called_name_1, tmp_args_name_1, tmp_kw_name_1 ); | ||
| 793 | Py_DECREF( tmp_called_name_1 ); | ||
| 794 | Py_DECREF( tmp_args_name_1 ); | ||
| 795 | if ( tmp_assign_source_7 == NULL ) | ||
| 796 | { | ||
| 797 | assert( ERROR_OCCURRED() ); | ||
| 798 | |||
| 799 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 800 | |||
| 801 | |||
| 802 | exception_lineno = 1; | ||
| 803 | |||
| 804 | goto try_except_handler_1; | ||
| 805 | } | ||
| 806 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 807 | tmp_class_creation_1__prepared = tmp_assign_source_7; | ||
| 808 | } | ||
| 809 | { | ||
| 810 | nuitka_bool tmp_condition_result_5; | ||
| 811 | PyObject *tmp_operand_name_1; | ||
| 812 | PyObject *tmp_source_name_3; | ||
| 813 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 814 | tmp_source_name_3 = tmp_class_creation_1__prepared; | ||
| 815 | tmp_res = PyObject_HasAttr( tmp_source_name_3, const_str_plain___getitem__ ); | ||
| 816 | tmp_operand_name_1 = ( tmp_res != 0 ) ? Py_True : Py_False; | ||
| 817 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 818 | if ( tmp_res == -1 ) | ||
| 819 | { | ||
| 820 | assert( ERROR_OCCURRED() ); | ||
| 821 | |||
| 822 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 823 | |||
| 824 | |||
| 825 | exception_lineno = 1; | ||
| 826 | |||
| 827 | goto try_except_handler_1; | ||
| 828 | } | ||
| 829 | tmp_condition_result_5 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 830 | if ( tmp_condition_result_5 == NUITKA_BOOL_TRUE ) | ||
| 831 | { | ||
| 832 | goto branch_yes_3; | ||
| 833 | } | ||
| 834 | else | ||
| 835 | { | ||
| 836 | goto branch_no_3; | ||
| 837 | } | ||
| 838 | branch_yes_3:; | ||
| 839 | { | ||
| 840 | PyObject *tmp_raise_type_1; | ||
| 841 | PyObject *tmp_raise_value_1; | ||
| 842 | PyObject *tmp_left_name_1; | ||
| 843 | PyObject *tmp_right_name_1; | ||
| 844 | PyObject *tmp_tuple_element_2; | ||
| 845 | PyObject *tmp_getattr_target_1; | ||
| 846 | PyObject *tmp_getattr_attr_1; | ||
| 847 | PyObject *tmp_getattr_default_1; | ||
| 848 | PyObject *tmp_source_name_4; | ||
| 849 | PyObject *tmp_type_arg_2; | ||
| 850 | tmp_raise_type_1 = PyExc_TypeError; | ||
| 851 | tmp_left_name_1 = const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 852 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 853 | tmp_getattr_target_1 = tmp_class_creation_1__metaclass; | ||
| 854 | tmp_getattr_attr_1 = const_str_plain___name__; | ||
| 855 | tmp_getattr_default_1 = const_str_angle_metaclass; | ||
| 856 | tmp_tuple_element_2 = BUILTIN_GETATTR( tmp_getattr_target_1, tmp_getattr_attr_1, tmp_getattr_default_1 ); | ||
| 857 | if ( tmp_tuple_element_2 == NULL ) | ||
| 858 | { | ||
| 859 | assert( ERROR_OCCURRED() ); | ||
| 860 | |||
| 861 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 862 | |||
| 863 | |||
| 864 | exception_lineno = 1; | ||
| 865 | |||
| 866 | goto try_except_handler_1; | ||
| 867 | } | ||
| 868 | tmp_right_name_1 = PyTuple_New( 2 ); | ||
| 869 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_2 ); | ||
| 870 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 871 | tmp_type_arg_2 = tmp_class_creation_1__prepared; | ||
| 872 | tmp_source_name_4 = BUILTIN_TYPE1( tmp_type_arg_2 ); | ||
| 873 | assert( !(tmp_source_name_4 == NULL) ); | ||
| 874 | tmp_tuple_element_2 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain___name__ ); | ||
| 875 | Py_DECREF( tmp_source_name_4 ); | ||
| 876 | if ( tmp_tuple_element_2 == NULL ) | ||
| 877 | { | ||
| 878 | assert( ERROR_OCCURRED() ); | ||
| 879 | |||
| 880 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 881 | Py_DECREF( tmp_right_name_1 ); | ||
| 882 | |||
| 883 | exception_lineno = 1; | ||
| 884 | |||
| 885 | goto try_except_handler_1; | ||
| 886 | } | ||
| 887 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_2 ); | ||
| 888 | tmp_raise_value_1 = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 889 | Py_DECREF( tmp_right_name_1 ); | ||
| 890 | if ( tmp_raise_value_1 == NULL ) | ||
| 891 | { | ||
| 892 | assert( ERROR_OCCURRED() ); | ||
| 893 | |||
| 894 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 895 | |||
| 896 | |||
| 897 | exception_lineno = 1; | ||
| 898 | |||
| 899 | goto try_except_handler_1; | ||
| 900 | } | ||
| 901 | exception_type = tmp_raise_type_1; | ||
| 902 | Py_INCREF( tmp_raise_type_1 ); | ||
| 903 | exception_value = tmp_raise_value_1; | ||
| 904 | exception_lineno = 1; | ||
| 905 | RAISE_EXCEPTION_IMPLICIT( &exception_type, &exception_value, &exception_tb ); | ||
| 906 | |||
| 907 | goto try_except_handler_1; | ||
| 908 | } | ||
| 909 | branch_no_3:; | ||
| 910 | } | ||
| 911 | goto branch_end_2; | ||
| 912 | branch_no_2:; | ||
| 913 | { | ||
| 914 | PyObject *tmp_assign_source_8; | ||
| 915 | tmp_assign_source_8 = PyDict_New(); | ||
| 916 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 917 | tmp_class_creation_1__prepared = tmp_assign_source_8; | ||
| 918 | } | ||
| 919 | branch_end_2:; | ||
| 920 | } | ||
| 921 | { | ||
| 922 | PyObject *tmp_assign_source_9; | ||
| 923 | { | ||
| 924 | PyObject *tmp_set_locals_1; | ||
| 925 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 926 | tmp_set_locals_1 = tmp_class_creation_1__prepared; | ||
| 927 | locals_problem$exception_1 = tmp_set_locals_1; | ||
| 928 | Py_INCREF( tmp_set_locals_1 ); | ||
| 929 | } | ||
| 930 | // Tried code: | ||
| 931 | // Tried code: | ||
| 932 | tmp_dictset_value = const_str_digest_2eaf9b251885e997348baaf55bbf0533; | ||
| 933 | tmp_res = PyObject_SetItem( locals_problem$exception_1, const_str_plain___module__, tmp_dictset_value ); | ||
| 934 | if ( tmp_res != 0 ) | ||
| 935 | { | ||
| 936 | assert( ERROR_OCCURRED() ); | ||
| 937 | |||
| 938 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 939 | |||
| 940 | |||
| 941 | exception_lineno = 1; | ||
| 942 | |||
| 943 | goto try_except_handler_3; | ||
| 944 | } | ||
| 945 | tmp_dictset_value = const_str_plain_AuthFailure; | ||
| 946 | tmp_res = PyObject_SetItem( locals_problem$exception_1, const_str_plain___qualname__, tmp_dictset_value ); | ||
| 947 | if ( tmp_res != 0 ) | ||
| 948 | { | ||
| 949 | assert( ERROR_OCCURRED() ); | ||
| 950 | |||
| 951 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 952 | |||
| 953 | |||
| 954 | exception_lineno = 1; | ||
| 955 | |||
| 956 | goto try_except_handler_3; | ||
| 957 | } | ||
| 958 | { | ||
| 959 | nuitka_bool tmp_condition_result_6; | ||
| 960 | PyObject *tmp_compexpr_left_1; | ||
| 961 | PyObject *tmp_compexpr_right_1; | ||
| 962 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 963 | tmp_compexpr_left_1 = tmp_class_creation_1__bases; | ||
| 964 | tmp_compexpr_right_1 = const_tuple_type_Exception_tuple; | ||
| 965 | tmp_res = RICH_COMPARE_BOOL_NOTEQ_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 966 | if ( tmp_res == -1 ) | ||
| 967 | { | ||
| 968 | assert( ERROR_OCCURRED() ); | ||
| 969 | |||
| 970 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 971 | |||
| 972 | |||
| 973 | exception_lineno = 1; | ||
| 974 | |||
| 975 | goto try_except_handler_3; | ||
| 976 | } | ||
| 977 | tmp_condition_result_6 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 978 | if ( tmp_condition_result_6 == NUITKA_BOOL_TRUE ) | ||
| 979 | { | ||
| 980 | goto branch_yes_4; | ||
| 981 | } | ||
| 982 | else | ||
| 983 | { | ||
| 984 | goto branch_no_4; | ||
| 985 | } | ||
| 986 | branch_yes_4:; | ||
| 987 | tmp_dictset_value = const_tuple_type_Exception_tuple; | ||
| 988 | tmp_res = PyObject_SetItem( locals_problem$exception_1, const_str_plain___orig_bases__, tmp_dictset_value ); | ||
| 989 | if ( tmp_res != 0 ) | ||
| 990 | { | ||
| 991 | assert( ERROR_OCCURRED() ); | ||
| 992 | |||
| 993 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 994 | |||
| 995 | |||
| 996 | exception_lineno = 1; | ||
| 997 | |||
| 998 | goto try_except_handler_3; | ||
| 999 | } | ||
| 1000 | branch_no_4:; | ||
| 1001 | } | ||
| 1002 | { | ||
| 1003 | PyObject *tmp_assign_source_10; | ||
| 1004 | PyObject *tmp_called_name_2; | ||
| 1005 | PyObject *tmp_args_name_2; | ||
| 1006 | PyObject *tmp_tuple_element_3; | ||
| 1007 | PyObject *tmp_kw_name_2; | ||
| 1008 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 1009 | tmp_called_name_2 = tmp_class_creation_1__metaclass; | ||
| 1010 | tmp_tuple_element_3 = const_str_plain_AuthFailure; | ||
| 1011 | tmp_args_name_2 = PyTuple_New( 3 ); | ||
| 1012 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 1013 | PyTuple_SET_ITEM( tmp_args_name_2, 0, tmp_tuple_element_3 ); | ||
| 1014 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 1015 | tmp_tuple_element_3 = tmp_class_creation_1__bases; | ||
| 1016 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 1017 | PyTuple_SET_ITEM( tmp_args_name_2, 1, tmp_tuple_element_3 ); | ||
| 1018 | tmp_tuple_element_3 = locals_problem$exception_1; | ||
| 1019 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 1020 | PyTuple_SET_ITEM( tmp_args_name_2, 2, tmp_tuple_element_3 ); | ||
| 1021 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 1022 | tmp_kw_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 1023 | frame_8a1d77d53dfcd0df1957edabb69a2c4a->m_frame.f_lineno = 1; | ||
| 1024 | tmp_assign_source_10 = CALL_FUNCTION( tmp_called_name_2, tmp_args_name_2, tmp_kw_name_2 ); | ||
| 1025 | Py_DECREF( tmp_args_name_2 ); | ||
| 1026 | if ( tmp_assign_source_10 == NULL ) | ||
| 1027 | { | ||
| 1028 | assert( ERROR_OCCURRED() ); | ||
| 1029 | |||
| 1030 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1031 | |||
| 1032 | |||
| 1033 | exception_lineno = 1; | ||
| 1034 | |||
| 1035 | goto try_except_handler_3; | ||
| 1036 | } | ||
| 1037 | assert( outline_0_var___class__ == NULL ); | ||
| 1038 | outline_0_var___class__ = tmp_assign_source_10; | ||
| 1039 | } | ||
| 1040 | CHECK_OBJECT( outline_0_var___class__ ); | ||
| 1041 | tmp_assign_source_9 = outline_0_var___class__; | ||
| 1042 | Py_INCREF( tmp_assign_source_9 ); | ||
| 1043 | goto try_return_handler_3; | ||
| 1044 | // tried codes exits in all cases | ||
| 1045 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 1046 | return MOD_RETURN_VALUE( NULL ); | ||
| 1047 | // Return handler code: | ||
| 1048 | try_return_handler_3:; | ||
| 1049 | Py_DECREF( locals_problem$exception_1 ); | ||
| 1050 | locals_problem$exception_1 = NULL; | ||
| 1051 | goto try_return_handler_2; | ||
| 1052 | // Exception handler code: | ||
| 1053 | try_except_handler_3:; | ||
| 1054 | exception_keeper_type_1 = exception_type; | ||
| 1055 | exception_keeper_value_1 = exception_value; | ||
| 1056 | exception_keeper_tb_1 = exception_tb; | ||
| 1057 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1058 | exception_type = NULL; | ||
| 1059 | exception_value = NULL; | ||
| 1060 | exception_tb = NULL; | ||
| 1061 | exception_lineno = 0; | ||
| 1062 | |||
| 1063 | Py_DECREF( locals_problem$exception_1 ); | ||
| 1064 | locals_problem$exception_1 = NULL; | ||
| 1065 | // Re-raise. | ||
| 1066 | exception_type = exception_keeper_type_1; | ||
| 1067 | exception_value = exception_keeper_value_1; | ||
| 1068 | exception_tb = exception_keeper_tb_1; | ||
| 1069 | exception_lineno = exception_keeper_lineno_1; | ||
| 1070 | |||
| 1071 | goto try_except_handler_2; | ||
| 1072 | // End of try: | ||
| 1073 | // tried codes exits in all cases | ||
| 1074 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 1075 | return MOD_RETURN_VALUE( NULL ); | ||
| 1076 | // Return handler code: | ||
| 1077 | try_return_handler_2:; | ||
| 1078 | CHECK_OBJECT( (PyObject *)outline_0_var___class__ ); | ||
| 1079 | Py_DECREF( outline_0_var___class__ ); | ||
| 1080 | outline_0_var___class__ = NULL; | ||
| 1081 | |||
| 1082 | goto outline_result_1; | ||
| 1083 | // Exception handler code: | ||
| 1084 | try_except_handler_2:; | ||
| 1085 | exception_keeper_type_2 = exception_type; | ||
| 1086 | exception_keeper_value_2 = exception_value; | ||
| 1087 | exception_keeper_tb_2 = exception_tb; | ||
| 1088 | exception_keeper_lineno_2 = exception_lineno; | ||
| 1089 | exception_type = NULL; | ||
| 1090 | exception_value = NULL; | ||
| 1091 | exception_tb = NULL; | ||
| 1092 | exception_lineno = 0; | ||
| 1093 | |||
| 1094 | // Re-raise. | ||
| 1095 | exception_type = exception_keeper_type_2; | ||
| 1096 | exception_value = exception_keeper_value_2; | ||
| 1097 | exception_tb = exception_keeper_tb_2; | ||
| 1098 | exception_lineno = exception_keeper_lineno_2; | ||
| 1099 | |||
| 1100 | goto outline_exception_1; | ||
| 1101 | // End of try: | ||
| 1102 | // Return statement must have exited already. | ||
| 1103 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 1104 | return MOD_RETURN_VALUE( NULL ); | ||
| 1105 | outline_exception_1:; | ||
| 1106 | exception_lineno = 1; | ||
| 1107 | goto try_except_handler_1; | ||
| 1108 | outline_result_1:; | ||
| 1109 | UPDATE_STRING_DICT1( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain_AuthFailure, tmp_assign_source_9 ); | ||
| 1110 | } | ||
| 1111 | goto try_end_1; | ||
| 1112 | // Exception handler code: | ||
| 1113 | try_except_handler_1:; | ||
| 1114 | exception_keeper_type_3 = exception_type; | ||
| 1115 | exception_keeper_value_3 = exception_value; | ||
| 1116 | exception_keeper_tb_3 = exception_tb; | ||
| 1117 | exception_keeper_lineno_3 = exception_lineno; | ||
| 1118 | exception_type = NULL; | ||
| 1119 | exception_value = NULL; | ||
| 1120 | exception_tb = NULL; | ||
| 1121 | exception_lineno = 0; | ||
| 1122 | |||
| 1123 | Py_XDECREF( tmp_class_creation_1__bases ); | ||
| 1124 | tmp_class_creation_1__bases = NULL; | ||
| 1125 | |||
| 1126 | Py_XDECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 1127 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 1128 | |||
| 1129 | Py_XDECREF( tmp_class_creation_1__metaclass ); | ||
| 1130 | tmp_class_creation_1__metaclass = NULL; | ||
| 1131 | |||
| 1132 | Py_XDECREF( tmp_class_creation_1__prepared ); | ||
| 1133 | tmp_class_creation_1__prepared = NULL; | ||
| 1134 | |||
| 1135 | // Re-raise. | ||
| 1136 | exception_type = exception_keeper_type_3; | ||
| 1137 | exception_value = exception_keeper_value_3; | ||
| 1138 | exception_tb = exception_keeper_tb_3; | ||
| 1139 | exception_lineno = exception_keeper_lineno_3; | ||
| 1140 | |||
| 1141 | goto frame_exception_exit_1; | ||
| 1142 | // End of try: | ||
| 1143 | try_end_1:; | ||
| 1144 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__bases ); | ||
| 1145 | Py_DECREF( tmp_class_creation_1__bases ); | ||
| 1146 | tmp_class_creation_1__bases = NULL; | ||
| 1147 | |||
| 1148 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__class_decl_dict ); | ||
| 1149 | Py_DECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 1150 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 1151 | |||
| 1152 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__metaclass ); | ||
| 1153 | Py_DECREF( tmp_class_creation_1__metaclass ); | ||
| 1154 | tmp_class_creation_1__metaclass = NULL; | ||
| 1155 | |||
| 1156 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__prepared ); | ||
| 1157 | Py_DECREF( tmp_class_creation_1__prepared ); | ||
| 1158 | tmp_class_creation_1__prepared = NULL; | ||
| 1159 | |||
| 1160 | // Tried code: | ||
| 1161 | { | ||
| 1162 | PyObject *tmp_assign_source_11; | ||
| 1163 | PyObject *tmp_dircall_arg1_2; | ||
| 1164 | tmp_dircall_arg1_2 = const_tuple_type_Exception_tuple; | ||
| 1165 | Py_INCREF( tmp_dircall_arg1_2 ); | ||
| 1166 | |||
| 1167 | { | ||
| 1168 | PyObject *dir_call_args[] = {tmp_dircall_arg1_2}; | ||
| 1169 | tmp_assign_source_11 = impl___internal__$$$function_2__mro_entries_conversion( dir_call_args ); | ||
| 1170 | } | ||
| 1171 | if ( tmp_assign_source_11 == NULL ) | ||
| 1172 | { | ||
| 1173 | assert( ERROR_OCCURRED() ); | ||
| 1174 | |||
| 1175 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1176 | |||
| 1177 | |||
| 1178 | exception_lineno = 5; | ||
| 1179 | |||
| 1180 | goto try_except_handler_4; | ||
| 1181 | } | ||
| 1182 | assert( tmp_class_creation_2__bases == NULL ); | ||
| 1183 | tmp_class_creation_2__bases = tmp_assign_source_11; | ||
| 1184 | } | ||
| 1185 | { | ||
| 1186 | PyObject *tmp_assign_source_12; | ||
| 1187 | tmp_assign_source_12 = PyDict_New(); | ||
| 1188 | assert( tmp_class_creation_2__class_decl_dict == NULL ); | ||
| 1189 | tmp_class_creation_2__class_decl_dict = tmp_assign_source_12; | ||
| 1190 | } | ||
| 1191 | { | ||
| 1192 | PyObject *tmp_assign_source_13; | ||
| 1193 | PyObject *tmp_metaclass_name_2; | ||
| 1194 | nuitka_bool tmp_condition_result_7; | ||
| 1195 | PyObject *tmp_key_name_4; | ||
| 1196 | PyObject *tmp_dict_name_4; | ||
| 1197 | PyObject *tmp_dict_name_5; | ||
| 1198 | PyObject *tmp_key_name_5; | ||
| 1199 | nuitka_bool tmp_condition_result_8; | ||
| 1200 | int tmp_truth_name_2; | ||
| 1201 | PyObject *tmp_type_arg_3; | ||
| 1202 | PyObject *tmp_subscribed_name_2; | ||
| 1203 | PyObject *tmp_subscript_name_2; | ||
| 1204 | PyObject *tmp_bases_name_2; | ||
| 1205 | tmp_key_name_4 = const_str_plain_metaclass; | ||
| 1206 | CHECK_OBJECT( tmp_class_creation_2__class_decl_dict ); | ||
| 1207 | tmp_dict_name_4 = tmp_class_creation_2__class_decl_dict; | ||
| 1208 | tmp_res = PyDict_Contains( tmp_dict_name_4, tmp_key_name_4 ); | ||
| 1209 | if ( tmp_res == -1 ) | ||
| 1210 | { | ||
| 1211 | assert( ERROR_OCCURRED() ); | ||
| 1212 | |||
| 1213 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1214 | |||
| 1215 | |||
| 1216 | exception_lineno = 5; | ||
| 1217 | |||
| 1218 | goto try_except_handler_4; | ||
| 1219 | } | ||
| 1220 | tmp_condition_result_7 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1221 | if ( tmp_condition_result_7 == NUITKA_BOOL_TRUE ) | ||
| 1222 | { | ||
| 1223 | goto condexpr_true_3; | ||
| 1224 | } | ||
| 1225 | else | ||
| 1226 | { | ||
| 1227 | goto condexpr_false_3; | ||
| 1228 | } | ||
| 1229 | condexpr_true_3:; | ||
| 1230 | CHECK_OBJECT( tmp_class_creation_2__class_decl_dict ); | ||
| 1231 | tmp_dict_name_5 = tmp_class_creation_2__class_decl_dict; | ||
| 1232 | tmp_key_name_5 = const_str_plain_metaclass; | ||
| 1233 | tmp_metaclass_name_2 = DICT_GET_ITEM( tmp_dict_name_5, tmp_key_name_5 ); | ||
| 1234 | if ( tmp_metaclass_name_2 == NULL ) | ||
| 1235 | { | ||
| 1236 | assert( ERROR_OCCURRED() ); | ||
| 1237 | |||
| 1238 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1239 | |||
| 1240 | |||
| 1241 | exception_lineno = 5; | ||
| 1242 | |||
| 1243 | goto try_except_handler_4; | ||
| 1244 | } | ||
| 1245 | goto condexpr_end_3; | ||
| 1246 | condexpr_false_3:; | ||
| 1247 | CHECK_OBJECT( tmp_class_creation_2__bases ); | ||
| 1248 | tmp_truth_name_2 = CHECK_IF_TRUE( tmp_class_creation_2__bases ); | ||
| 1249 | if ( tmp_truth_name_2 == -1 ) | ||
| 1250 | { | ||
| 1251 | assert( ERROR_OCCURRED() ); | ||
| 1252 | |||
| 1253 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1254 | |||
| 1255 | |||
| 1256 | exception_lineno = 5; | ||
| 1257 | |||
| 1258 | goto try_except_handler_4; | ||
| 1259 | } | ||
| 1260 | tmp_condition_result_8 = tmp_truth_name_2 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1261 | if ( tmp_condition_result_8 == NUITKA_BOOL_TRUE ) | ||
| 1262 | { | ||
| 1263 | goto condexpr_true_4; | ||
| 1264 | } | ||
| 1265 | else | ||
| 1266 | { | ||
| 1267 | goto condexpr_false_4; | ||
| 1268 | } | ||
| 1269 | condexpr_true_4:; | ||
| 1270 | CHECK_OBJECT( tmp_class_creation_2__bases ); | ||
| 1271 | tmp_subscribed_name_2 = tmp_class_creation_2__bases; | ||
| 1272 | tmp_subscript_name_2 = const_int_0; | ||
| 1273 | tmp_type_arg_3 = LOOKUP_SUBSCRIPT_CONST( tmp_subscribed_name_2, tmp_subscript_name_2, 0 ); | ||
| 1274 | if ( tmp_type_arg_3 == NULL ) | ||
| 1275 | { | ||
| 1276 | assert( ERROR_OCCURRED() ); | ||
| 1277 | |||
| 1278 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1279 | |||
| 1280 | |||
| 1281 | exception_lineno = 5; | ||
| 1282 | |||
| 1283 | goto try_except_handler_4; | ||
| 1284 | } | ||
| 1285 | tmp_metaclass_name_2 = BUILTIN_TYPE1( tmp_type_arg_3 ); | ||
| 1286 | Py_DECREF( tmp_type_arg_3 ); | ||
| 1287 | if ( tmp_metaclass_name_2 == NULL ) | ||
| 1288 | { | ||
| 1289 | assert( ERROR_OCCURRED() ); | ||
| 1290 | |||
| 1291 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1292 | |||
| 1293 | |||
| 1294 | exception_lineno = 5; | ||
| 1295 | |||
| 1296 | goto try_except_handler_4; | ||
| 1297 | } | ||
| 1298 | goto condexpr_end_4; | ||
| 1299 | condexpr_false_4:; | ||
| 1300 | tmp_metaclass_name_2 = (PyObject *)&PyType_Type; | ||
| 1301 | Py_INCREF( tmp_metaclass_name_2 ); | ||
| 1302 | condexpr_end_4:; | ||
| 1303 | condexpr_end_3:; | ||
| 1304 | CHECK_OBJECT( tmp_class_creation_2__bases ); | ||
| 1305 | tmp_bases_name_2 = tmp_class_creation_2__bases; | ||
| 1306 | tmp_assign_source_13 = SELECT_METACLASS( tmp_metaclass_name_2, tmp_bases_name_2 ); | ||
| 1307 | Py_DECREF( tmp_metaclass_name_2 ); | ||
| 1308 | if ( tmp_assign_source_13 == NULL ) | ||
| 1309 | { | ||
| 1310 | assert( ERROR_OCCURRED() ); | ||
| 1311 | |||
| 1312 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1313 | |||
| 1314 | |||
| 1315 | exception_lineno = 5; | ||
| 1316 | |||
| 1317 | goto try_except_handler_4; | ||
| 1318 | } | ||
| 1319 | assert( tmp_class_creation_2__metaclass == NULL ); | ||
| 1320 | tmp_class_creation_2__metaclass = tmp_assign_source_13; | ||
| 1321 | } | ||
| 1322 | { | ||
| 1323 | nuitka_bool tmp_condition_result_9; | ||
| 1324 | PyObject *tmp_key_name_6; | ||
| 1325 | PyObject *tmp_dict_name_6; | ||
| 1326 | tmp_key_name_6 = const_str_plain_metaclass; | ||
| 1327 | CHECK_OBJECT( tmp_class_creation_2__class_decl_dict ); | ||
| 1328 | tmp_dict_name_6 = tmp_class_creation_2__class_decl_dict; | ||
| 1329 | tmp_res = PyDict_Contains( tmp_dict_name_6, tmp_key_name_6 ); | ||
| 1330 | if ( tmp_res == -1 ) | ||
| 1331 | { | ||
| 1332 | assert( ERROR_OCCURRED() ); | ||
| 1333 | |||
| 1334 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1335 | |||
| 1336 | |||
| 1337 | exception_lineno = 5; | ||
| 1338 | |||
| 1339 | goto try_except_handler_4; | ||
| 1340 | } | ||
| 1341 | tmp_condition_result_9 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1342 | if ( tmp_condition_result_9 == NUITKA_BOOL_TRUE ) | ||
| 1343 | { | ||
| 1344 | goto branch_yes_5; | ||
| 1345 | } | ||
| 1346 | else | ||
| 1347 | { | ||
| 1348 | goto branch_no_5; | ||
| 1349 | } | ||
| 1350 | branch_yes_5:; | ||
| 1351 | CHECK_OBJECT( tmp_class_creation_2__class_decl_dict ); | ||
| 1352 | tmp_dictdel_dict = tmp_class_creation_2__class_decl_dict; | ||
| 1353 | tmp_dictdel_key = const_str_plain_metaclass; | ||
| 1354 | tmp_result = DICT_REMOVE_ITEM( tmp_dictdel_dict, tmp_dictdel_key ); | ||
| 1355 | if ( tmp_result == false ) | ||
| 1356 | { | ||
| 1357 | assert( ERROR_OCCURRED() ); | ||
| 1358 | |||
| 1359 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1360 | |||
| 1361 | |||
| 1362 | exception_lineno = 5; | ||
| 1363 | |||
| 1364 | goto try_except_handler_4; | ||
| 1365 | } | ||
| 1366 | branch_no_5:; | ||
| 1367 | } | ||
| 1368 | { | ||
| 1369 | nuitka_bool tmp_condition_result_10; | ||
| 1370 | PyObject *tmp_source_name_5; | ||
| 1371 | CHECK_OBJECT( tmp_class_creation_2__metaclass ); | ||
| 1372 | tmp_source_name_5 = tmp_class_creation_2__metaclass; | ||
| 1373 | tmp_res = PyObject_HasAttr( tmp_source_name_5, const_str_plain___prepare__ ); | ||
| 1374 | tmp_condition_result_10 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1375 | if ( tmp_condition_result_10 == NUITKA_BOOL_TRUE ) | ||
| 1376 | { | ||
| 1377 | goto branch_yes_6; | ||
| 1378 | } | ||
| 1379 | else | ||
| 1380 | { | ||
| 1381 | goto branch_no_6; | ||
| 1382 | } | ||
| 1383 | branch_yes_6:; | ||
| 1384 | { | ||
| 1385 | PyObject *tmp_assign_source_14; | ||
| 1386 | PyObject *tmp_called_name_3; | ||
| 1387 | PyObject *tmp_source_name_6; | ||
| 1388 | PyObject *tmp_args_name_3; | ||
| 1389 | PyObject *tmp_tuple_element_4; | ||
| 1390 | PyObject *tmp_kw_name_3; | ||
| 1391 | CHECK_OBJECT( tmp_class_creation_2__metaclass ); | ||
| 1392 | tmp_source_name_6 = tmp_class_creation_2__metaclass; | ||
| 1393 | tmp_called_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_6, const_str_plain___prepare__ ); | ||
| 1394 | if ( tmp_called_name_3 == NULL ) | ||
| 1395 | { | ||
| 1396 | assert( ERROR_OCCURRED() ); | ||
| 1397 | |||
| 1398 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1399 | |||
| 1400 | |||
| 1401 | exception_lineno = 5; | ||
| 1402 | |||
| 1403 | goto try_except_handler_4; | ||
| 1404 | } | ||
| 1405 | tmp_tuple_element_4 = const_str_plain_InvalidProblem; | ||
| 1406 | tmp_args_name_3 = PyTuple_New( 2 ); | ||
| 1407 | Py_INCREF( tmp_tuple_element_4 ); | ||
| 1408 | PyTuple_SET_ITEM( tmp_args_name_3, 0, tmp_tuple_element_4 ); | ||
| 1409 | CHECK_OBJECT( tmp_class_creation_2__bases ); | ||
| 1410 | tmp_tuple_element_4 = tmp_class_creation_2__bases; | ||
| 1411 | Py_INCREF( tmp_tuple_element_4 ); | ||
| 1412 | PyTuple_SET_ITEM( tmp_args_name_3, 1, tmp_tuple_element_4 ); | ||
| 1413 | CHECK_OBJECT( tmp_class_creation_2__class_decl_dict ); | ||
| 1414 | tmp_kw_name_3 = tmp_class_creation_2__class_decl_dict; | ||
| 1415 | frame_8a1d77d53dfcd0df1957edabb69a2c4a->m_frame.f_lineno = 5; | ||
| 1416 | tmp_assign_source_14 = CALL_FUNCTION( tmp_called_name_3, tmp_args_name_3, tmp_kw_name_3 ); | ||
| 1417 | Py_DECREF( tmp_called_name_3 ); | ||
| 1418 | Py_DECREF( tmp_args_name_3 ); | ||
| 1419 | if ( tmp_assign_source_14 == NULL ) | ||
| 1420 | { | ||
| 1421 | assert( ERROR_OCCURRED() ); | ||
| 1422 | |||
| 1423 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1424 | |||
| 1425 | |||
| 1426 | exception_lineno = 5; | ||
| 1427 | |||
| 1428 | goto try_except_handler_4; | ||
| 1429 | } | ||
| 1430 | assert( tmp_class_creation_2__prepared == NULL ); | ||
| 1431 | tmp_class_creation_2__prepared = tmp_assign_source_14; | ||
| 1432 | } | ||
| 1433 | { | ||
| 1434 | nuitka_bool tmp_condition_result_11; | ||
| 1435 | PyObject *tmp_operand_name_2; | ||
| 1436 | PyObject *tmp_source_name_7; | ||
| 1437 | CHECK_OBJECT( tmp_class_creation_2__prepared ); | ||
| 1438 | tmp_source_name_7 = tmp_class_creation_2__prepared; | ||
| 1439 | tmp_res = PyObject_HasAttr( tmp_source_name_7, const_str_plain___getitem__ ); | ||
| 1440 | tmp_operand_name_2 = ( tmp_res != 0 ) ? Py_True : Py_False; | ||
| 1441 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_2 ); | ||
| 1442 | if ( tmp_res == -1 ) | ||
| 1443 | { | ||
| 1444 | assert( ERROR_OCCURRED() ); | ||
| 1445 | |||
| 1446 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1447 | |||
| 1448 | |||
| 1449 | exception_lineno = 5; | ||
| 1450 | |||
| 1451 | goto try_except_handler_4; | ||
| 1452 | } | ||
| 1453 | tmp_condition_result_11 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1454 | if ( tmp_condition_result_11 == NUITKA_BOOL_TRUE ) | ||
| 1455 | { | ||
| 1456 | goto branch_yes_7; | ||
| 1457 | } | ||
| 1458 | else | ||
| 1459 | { | ||
| 1460 | goto branch_no_7; | ||
| 1461 | } | ||
| 1462 | branch_yes_7:; | ||
| 1463 | { | ||
| 1464 | PyObject *tmp_raise_type_2; | ||
| 1465 | PyObject *tmp_raise_value_2; | ||
| 1466 | PyObject *tmp_left_name_2; | ||
| 1467 | PyObject *tmp_right_name_2; | ||
| 1468 | PyObject *tmp_tuple_element_5; | ||
| 1469 | PyObject *tmp_getattr_target_2; | ||
| 1470 | PyObject *tmp_getattr_attr_2; | ||
| 1471 | PyObject *tmp_getattr_default_2; | ||
| 1472 | PyObject *tmp_source_name_8; | ||
| 1473 | PyObject *tmp_type_arg_4; | ||
| 1474 | tmp_raise_type_2 = PyExc_TypeError; | ||
| 1475 | tmp_left_name_2 = const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 1476 | CHECK_OBJECT( tmp_class_creation_2__metaclass ); | ||
| 1477 | tmp_getattr_target_2 = tmp_class_creation_2__metaclass; | ||
| 1478 | tmp_getattr_attr_2 = const_str_plain___name__; | ||
| 1479 | tmp_getattr_default_2 = const_str_angle_metaclass; | ||
| 1480 | tmp_tuple_element_5 = BUILTIN_GETATTR( tmp_getattr_target_2, tmp_getattr_attr_2, tmp_getattr_default_2 ); | ||
| 1481 | if ( tmp_tuple_element_5 == NULL ) | ||
| 1482 | { | ||
| 1483 | assert( ERROR_OCCURRED() ); | ||
| 1484 | |||
| 1485 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1486 | |||
| 1487 | |||
| 1488 | exception_lineno = 5; | ||
| 1489 | |||
| 1490 | goto try_except_handler_4; | ||
| 1491 | } | ||
| 1492 | tmp_right_name_2 = PyTuple_New( 2 ); | ||
| 1493 | PyTuple_SET_ITEM( tmp_right_name_2, 0, tmp_tuple_element_5 ); | ||
| 1494 | CHECK_OBJECT( tmp_class_creation_2__prepared ); | ||
| 1495 | tmp_type_arg_4 = tmp_class_creation_2__prepared; | ||
| 1496 | tmp_source_name_8 = BUILTIN_TYPE1( tmp_type_arg_4 ); | ||
| 1497 | assert( !(tmp_source_name_8 == NULL) ); | ||
| 1498 | tmp_tuple_element_5 = LOOKUP_ATTRIBUTE( tmp_source_name_8, const_str_plain___name__ ); | ||
| 1499 | Py_DECREF( tmp_source_name_8 ); | ||
| 1500 | if ( tmp_tuple_element_5 == NULL ) | ||
| 1501 | { | ||
| 1502 | assert( ERROR_OCCURRED() ); | ||
| 1503 | |||
| 1504 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1505 | Py_DECREF( tmp_right_name_2 ); | ||
| 1506 | |||
| 1507 | exception_lineno = 5; | ||
| 1508 | |||
| 1509 | goto try_except_handler_4; | ||
| 1510 | } | ||
| 1511 | PyTuple_SET_ITEM( tmp_right_name_2, 1, tmp_tuple_element_5 ); | ||
| 1512 | tmp_raise_value_2 = BINARY_OPERATION_REMAINDER( tmp_left_name_2, tmp_right_name_2 ); | ||
| 1513 | Py_DECREF( tmp_right_name_2 ); | ||
| 1514 | if ( tmp_raise_value_2 == NULL ) | ||
| 1515 | { | ||
| 1516 | assert( ERROR_OCCURRED() ); | ||
| 1517 | |||
| 1518 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1519 | |||
| 1520 | |||
| 1521 | exception_lineno = 5; | ||
| 1522 | |||
| 1523 | goto try_except_handler_4; | ||
| 1524 | } | ||
| 1525 | exception_type = tmp_raise_type_2; | ||
| 1526 | Py_INCREF( tmp_raise_type_2 ); | ||
| 1527 | exception_value = tmp_raise_value_2; | ||
| 1528 | exception_lineno = 5; | ||
| 1529 | RAISE_EXCEPTION_IMPLICIT( &exception_type, &exception_value, &exception_tb ); | ||
| 1530 | |||
| 1531 | goto try_except_handler_4; | ||
| 1532 | } | ||
| 1533 | branch_no_7:; | ||
| 1534 | } | ||
| 1535 | goto branch_end_6; | ||
| 1536 | branch_no_6:; | ||
| 1537 | { | ||
| 1538 | PyObject *tmp_assign_source_15; | ||
| 1539 | tmp_assign_source_15 = PyDict_New(); | ||
| 1540 | assert( tmp_class_creation_2__prepared == NULL ); | ||
| 1541 | tmp_class_creation_2__prepared = tmp_assign_source_15; | ||
| 1542 | } | ||
| 1543 | branch_end_6:; | ||
| 1544 | } | ||
| 1545 | { | ||
| 1546 | PyObject *tmp_assign_source_16; | ||
| 1547 | { | ||
| 1548 | PyObject *tmp_set_locals_2; | ||
| 1549 | CHECK_OBJECT( tmp_class_creation_2__prepared ); | ||
| 1550 | tmp_set_locals_2 = tmp_class_creation_2__prepared; | ||
| 1551 | locals_problem$exception_5 = tmp_set_locals_2; | ||
| 1552 | Py_INCREF( tmp_set_locals_2 ); | ||
| 1553 | } | ||
| 1554 | // Tried code: | ||
| 1555 | // Tried code: | ||
| 1556 | tmp_dictset_value = const_str_digest_2eaf9b251885e997348baaf55bbf0533; | ||
| 1557 | tmp_res = PyObject_SetItem( locals_problem$exception_5, const_str_plain___module__, tmp_dictset_value ); | ||
| 1558 | if ( tmp_res != 0 ) | ||
| 1559 | { | ||
| 1560 | assert( ERROR_OCCURRED() ); | ||
| 1561 | |||
| 1562 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1563 | |||
| 1564 | |||
| 1565 | exception_lineno = 5; | ||
| 1566 | |||
| 1567 | goto try_except_handler_6; | ||
| 1568 | } | ||
| 1569 | tmp_dictset_value = const_str_plain_InvalidProblem; | ||
| 1570 | tmp_res = PyObject_SetItem( locals_problem$exception_5, const_str_plain___qualname__, tmp_dictset_value ); | ||
| 1571 | if ( tmp_res != 0 ) | ||
| 1572 | { | ||
| 1573 | assert( ERROR_OCCURRED() ); | ||
| 1574 | |||
| 1575 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1576 | |||
| 1577 | |||
| 1578 | exception_lineno = 5; | ||
| 1579 | |||
| 1580 | goto try_except_handler_6; | ||
| 1581 | } | ||
| 1582 | { | ||
| 1583 | nuitka_bool tmp_condition_result_12; | ||
| 1584 | PyObject *tmp_compexpr_left_2; | ||
| 1585 | PyObject *tmp_compexpr_right_2; | ||
| 1586 | CHECK_OBJECT( tmp_class_creation_2__bases ); | ||
| 1587 | tmp_compexpr_left_2 = tmp_class_creation_2__bases; | ||
| 1588 | tmp_compexpr_right_2 = const_tuple_type_Exception_tuple; | ||
| 1589 | tmp_res = RICH_COMPARE_BOOL_NOTEQ_OBJECT_OBJECT( tmp_compexpr_left_2, tmp_compexpr_right_2 ); | ||
| 1590 | if ( tmp_res == -1 ) | ||
| 1591 | { | ||
| 1592 | assert( ERROR_OCCURRED() ); | ||
| 1593 | |||
| 1594 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1595 | |||
| 1596 | |||
| 1597 | exception_lineno = 5; | ||
| 1598 | |||
| 1599 | goto try_except_handler_6; | ||
| 1600 | } | ||
| 1601 | tmp_condition_result_12 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1602 | if ( tmp_condition_result_12 == NUITKA_BOOL_TRUE ) | ||
| 1603 | { | ||
| 1604 | goto branch_yes_8; | ||
| 1605 | } | ||
| 1606 | else | ||
| 1607 | { | ||
| 1608 | goto branch_no_8; | ||
| 1609 | } | ||
| 1610 | branch_yes_8:; | ||
| 1611 | tmp_dictset_value = const_tuple_type_Exception_tuple; | ||
| 1612 | tmp_res = PyObject_SetItem( locals_problem$exception_5, const_str_plain___orig_bases__, tmp_dictset_value ); | ||
| 1613 | if ( tmp_res != 0 ) | ||
| 1614 | { | ||
| 1615 | assert( ERROR_OCCURRED() ); | ||
| 1616 | |||
| 1617 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1618 | |||
| 1619 | |||
| 1620 | exception_lineno = 5; | ||
| 1621 | |||
| 1622 | goto try_except_handler_6; | ||
| 1623 | } | ||
| 1624 | branch_no_8:; | ||
| 1625 | } | ||
| 1626 | { | ||
| 1627 | PyObject *tmp_assign_source_17; | ||
| 1628 | PyObject *tmp_called_name_4; | ||
| 1629 | PyObject *tmp_args_name_4; | ||
| 1630 | PyObject *tmp_tuple_element_6; | ||
| 1631 | PyObject *tmp_kw_name_4; | ||
| 1632 | CHECK_OBJECT( tmp_class_creation_2__metaclass ); | ||
| 1633 | tmp_called_name_4 = tmp_class_creation_2__metaclass; | ||
| 1634 | tmp_tuple_element_6 = const_str_plain_InvalidProblem; | ||
| 1635 | tmp_args_name_4 = PyTuple_New( 3 ); | ||
| 1636 | Py_INCREF( tmp_tuple_element_6 ); | ||
| 1637 | PyTuple_SET_ITEM( tmp_args_name_4, 0, tmp_tuple_element_6 ); | ||
| 1638 | CHECK_OBJECT( tmp_class_creation_2__bases ); | ||
| 1639 | tmp_tuple_element_6 = tmp_class_creation_2__bases; | ||
| 1640 | Py_INCREF( tmp_tuple_element_6 ); | ||
| 1641 | PyTuple_SET_ITEM( tmp_args_name_4, 1, tmp_tuple_element_6 ); | ||
| 1642 | tmp_tuple_element_6 = locals_problem$exception_5; | ||
| 1643 | Py_INCREF( tmp_tuple_element_6 ); | ||
| 1644 | PyTuple_SET_ITEM( tmp_args_name_4, 2, tmp_tuple_element_6 ); | ||
| 1645 | CHECK_OBJECT( tmp_class_creation_2__class_decl_dict ); | ||
| 1646 | tmp_kw_name_4 = tmp_class_creation_2__class_decl_dict; | ||
| 1647 | frame_8a1d77d53dfcd0df1957edabb69a2c4a->m_frame.f_lineno = 5; | ||
| 1648 | tmp_assign_source_17 = CALL_FUNCTION( tmp_called_name_4, tmp_args_name_4, tmp_kw_name_4 ); | ||
| 1649 | Py_DECREF( tmp_args_name_4 ); | ||
| 1650 | if ( tmp_assign_source_17 == NULL ) | ||
| 1651 | { | ||
| 1652 | assert( ERROR_OCCURRED() ); | ||
| 1653 | |||
| 1654 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1655 | |||
| 1656 | |||
| 1657 | exception_lineno = 5; | ||
| 1658 | |||
| 1659 | goto try_except_handler_6; | ||
| 1660 | } | ||
| 1661 | assert( outline_1_var___class__ == NULL ); | ||
| 1662 | outline_1_var___class__ = tmp_assign_source_17; | ||
| 1663 | } | ||
| 1664 | CHECK_OBJECT( outline_1_var___class__ ); | ||
| 1665 | tmp_assign_source_16 = outline_1_var___class__; | ||
| 1666 | Py_INCREF( tmp_assign_source_16 ); | ||
| 1667 | goto try_return_handler_6; | ||
| 1668 | // tried codes exits in all cases | ||
| 1669 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 1670 | return MOD_RETURN_VALUE( NULL ); | ||
| 1671 | // Return handler code: | ||
| 1672 | try_return_handler_6:; | ||
| 1673 | Py_DECREF( locals_problem$exception_5 ); | ||
| 1674 | locals_problem$exception_5 = NULL; | ||
| 1675 | goto try_return_handler_5; | ||
| 1676 | // Exception handler code: | ||
| 1677 | try_except_handler_6:; | ||
| 1678 | exception_keeper_type_4 = exception_type; | ||
| 1679 | exception_keeper_value_4 = exception_value; | ||
| 1680 | exception_keeper_tb_4 = exception_tb; | ||
| 1681 | exception_keeper_lineno_4 = exception_lineno; | ||
| 1682 | exception_type = NULL; | ||
| 1683 | exception_value = NULL; | ||
| 1684 | exception_tb = NULL; | ||
| 1685 | exception_lineno = 0; | ||
| 1686 | |||
| 1687 | Py_DECREF( locals_problem$exception_5 ); | ||
| 1688 | locals_problem$exception_5 = NULL; | ||
| 1689 | // Re-raise. | ||
| 1690 | exception_type = exception_keeper_type_4; | ||
| 1691 | exception_value = exception_keeper_value_4; | ||
| 1692 | exception_tb = exception_keeper_tb_4; | ||
| 1693 | exception_lineno = exception_keeper_lineno_4; | ||
| 1694 | |||
| 1695 | goto try_except_handler_5; | ||
| 1696 | // End of try: | ||
| 1697 | // tried codes exits in all cases | ||
| 1698 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 1699 | return MOD_RETURN_VALUE( NULL ); | ||
| 1700 | // Return handler code: | ||
| 1701 | try_return_handler_5:; | ||
| 1702 | CHECK_OBJECT( (PyObject *)outline_1_var___class__ ); | ||
| 1703 | Py_DECREF( outline_1_var___class__ ); | ||
| 1704 | outline_1_var___class__ = NULL; | ||
| 1705 | |||
| 1706 | goto outline_result_2; | ||
| 1707 | // Exception handler code: | ||
| 1708 | try_except_handler_5:; | ||
| 1709 | exception_keeper_type_5 = exception_type; | ||
| 1710 | exception_keeper_value_5 = exception_value; | ||
| 1711 | exception_keeper_tb_5 = exception_tb; | ||
| 1712 | exception_keeper_lineno_5 = exception_lineno; | ||
| 1713 | exception_type = NULL; | ||
| 1714 | exception_value = NULL; | ||
| 1715 | exception_tb = NULL; | ||
| 1716 | exception_lineno = 0; | ||
| 1717 | |||
| 1718 | // Re-raise. | ||
| 1719 | exception_type = exception_keeper_type_5; | ||
| 1720 | exception_value = exception_keeper_value_5; | ||
| 1721 | exception_tb = exception_keeper_tb_5; | ||
| 1722 | exception_lineno = exception_keeper_lineno_5; | ||
| 1723 | |||
| 1724 | goto outline_exception_2; | ||
| 1725 | // End of try: | ||
| 1726 | // Return statement must have exited already. | ||
| 1727 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 1728 | return MOD_RETURN_VALUE( NULL ); | ||
| 1729 | outline_exception_2:; | ||
| 1730 | exception_lineno = 5; | ||
| 1731 | goto try_except_handler_4; | ||
| 1732 | outline_result_2:; | ||
| 1733 | UPDATE_STRING_DICT1( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain_InvalidProblem, tmp_assign_source_16 ); | ||
| 1734 | } | ||
| 1735 | goto try_end_2; | ||
| 1736 | // Exception handler code: | ||
| 1737 | try_except_handler_4:; | ||
| 1738 | exception_keeper_type_6 = exception_type; | ||
| 1739 | exception_keeper_value_6 = exception_value; | ||
| 1740 | exception_keeper_tb_6 = exception_tb; | ||
| 1741 | exception_keeper_lineno_6 = exception_lineno; | ||
| 1742 | exception_type = NULL; | ||
| 1743 | exception_value = NULL; | ||
| 1744 | exception_tb = NULL; | ||
| 1745 | exception_lineno = 0; | ||
| 1746 | |||
| 1747 | Py_XDECREF( tmp_class_creation_2__bases ); | ||
| 1748 | tmp_class_creation_2__bases = NULL; | ||
| 1749 | |||
| 1750 | Py_XDECREF( tmp_class_creation_2__class_decl_dict ); | ||
| 1751 | tmp_class_creation_2__class_decl_dict = NULL; | ||
| 1752 | |||
| 1753 | Py_XDECREF( tmp_class_creation_2__metaclass ); | ||
| 1754 | tmp_class_creation_2__metaclass = NULL; | ||
| 1755 | |||
| 1756 | Py_XDECREF( tmp_class_creation_2__prepared ); | ||
| 1757 | tmp_class_creation_2__prepared = NULL; | ||
| 1758 | |||
| 1759 | // Re-raise. | ||
| 1760 | exception_type = exception_keeper_type_6; | ||
| 1761 | exception_value = exception_keeper_value_6; | ||
| 1762 | exception_tb = exception_keeper_tb_6; | ||
| 1763 | exception_lineno = exception_keeper_lineno_6; | ||
| 1764 | |||
| 1765 | goto frame_exception_exit_1; | ||
| 1766 | // End of try: | ||
| 1767 | try_end_2:; | ||
| 1768 | CHECK_OBJECT( (PyObject *)tmp_class_creation_2__bases ); | ||
| 1769 | Py_DECREF( tmp_class_creation_2__bases ); | ||
| 1770 | tmp_class_creation_2__bases = NULL; | ||
| 1771 | |||
| 1772 | CHECK_OBJECT( (PyObject *)tmp_class_creation_2__class_decl_dict ); | ||
| 1773 | Py_DECREF( tmp_class_creation_2__class_decl_dict ); | ||
| 1774 | tmp_class_creation_2__class_decl_dict = NULL; | ||
| 1775 | |||
| 1776 | CHECK_OBJECT( (PyObject *)tmp_class_creation_2__metaclass ); | ||
| 1777 | Py_DECREF( tmp_class_creation_2__metaclass ); | ||
| 1778 | tmp_class_creation_2__metaclass = NULL; | ||
| 1779 | |||
| 1780 | CHECK_OBJECT( (PyObject *)tmp_class_creation_2__prepared ); | ||
| 1781 | Py_DECREF( tmp_class_creation_2__prepared ); | ||
| 1782 | tmp_class_creation_2__prepared = NULL; | ||
| 1783 | |||
| 1784 | // Tried code: | ||
| 1785 | { | ||
| 1786 | PyObject *tmp_assign_source_18; | ||
| 1787 | PyObject *tmp_dircall_arg1_3; | ||
| 1788 | tmp_dircall_arg1_3 = const_tuple_type_Exception_tuple; | ||
| 1789 | Py_INCREF( tmp_dircall_arg1_3 ); | ||
| 1790 | |||
| 1791 | { | ||
| 1792 | PyObject *dir_call_args[] = {tmp_dircall_arg1_3}; | ||
| 1793 | tmp_assign_source_18 = impl___internal__$$$function_2__mro_entries_conversion( dir_call_args ); | ||
| 1794 | } | ||
| 1795 | if ( tmp_assign_source_18 == NULL ) | ||
| 1796 | { | ||
| 1797 | assert( ERROR_OCCURRED() ); | ||
| 1798 | |||
| 1799 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1800 | |||
| 1801 | |||
| 1802 | exception_lineno = 9; | ||
| 1803 | |||
| 1804 | goto try_except_handler_7; | ||
| 1805 | } | ||
| 1806 | assert( tmp_class_creation_3__bases == NULL ); | ||
| 1807 | tmp_class_creation_3__bases = tmp_assign_source_18; | ||
| 1808 | } | ||
| 1809 | { | ||
| 1810 | PyObject *tmp_assign_source_19; | ||
| 1811 | tmp_assign_source_19 = PyDict_New(); | ||
| 1812 | assert( tmp_class_creation_3__class_decl_dict == NULL ); | ||
| 1813 | tmp_class_creation_3__class_decl_dict = tmp_assign_source_19; | ||
| 1814 | } | ||
| 1815 | { | ||
| 1816 | PyObject *tmp_assign_source_20; | ||
| 1817 | PyObject *tmp_metaclass_name_3; | ||
| 1818 | nuitka_bool tmp_condition_result_13; | ||
| 1819 | PyObject *tmp_key_name_7; | ||
| 1820 | PyObject *tmp_dict_name_7; | ||
| 1821 | PyObject *tmp_dict_name_8; | ||
| 1822 | PyObject *tmp_key_name_8; | ||
| 1823 | nuitka_bool tmp_condition_result_14; | ||
| 1824 | int tmp_truth_name_3; | ||
| 1825 | PyObject *tmp_type_arg_5; | ||
| 1826 | PyObject *tmp_subscribed_name_3; | ||
| 1827 | PyObject *tmp_subscript_name_3; | ||
| 1828 | PyObject *tmp_bases_name_3; | ||
| 1829 | tmp_key_name_7 = const_str_plain_metaclass; | ||
| 1830 | CHECK_OBJECT( tmp_class_creation_3__class_decl_dict ); | ||
| 1831 | tmp_dict_name_7 = tmp_class_creation_3__class_decl_dict; | ||
| 1832 | tmp_res = PyDict_Contains( tmp_dict_name_7, tmp_key_name_7 ); | ||
| 1833 | if ( tmp_res == -1 ) | ||
| 1834 | { | ||
| 1835 | assert( ERROR_OCCURRED() ); | ||
| 1836 | |||
| 1837 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1838 | |||
| 1839 | |||
| 1840 | exception_lineno = 9; | ||
| 1841 | |||
| 1842 | goto try_except_handler_7; | ||
| 1843 | } | ||
| 1844 | tmp_condition_result_13 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1845 | if ( tmp_condition_result_13 == NUITKA_BOOL_TRUE ) | ||
| 1846 | { | ||
| 1847 | goto condexpr_true_5; | ||
| 1848 | } | ||
| 1849 | else | ||
| 1850 | { | ||
| 1851 | goto condexpr_false_5; | ||
| 1852 | } | ||
| 1853 | condexpr_true_5:; | ||
| 1854 | CHECK_OBJECT( tmp_class_creation_3__class_decl_dict ); | ||
| 1855 | tmp_dict_name_8 = tmp_class_creation_3__class_decl_dict; | ||
| 1856 | tmp_key_name_8 = const_str_plain_metaclass; | ||
| 1857 | tmp_metaclass_name_3 = DICT_GET_ITEM( tmp_dict_name_8, tmp_key_name_8 ); | ||
| 1858 | if ( tmp_metaclass_name_3 == NULL ) | ||
| 1859 | { | ||
| 1860 | assert( ERROR_OCCURRED() ); | ||
| 1861 | |||
| 1862 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1863 | |||
| 1864 | |||
| 1865 | exception_lineno = 9; | ||
| 1866 | |||
| 1867 | goto try_except_handler_7; | ||
| 1868 | } | ||
| 1869 | goto condexpr_end_5; | ||
| 1870 | condexpr_false_5:; | ||
| 1871 | CHECK_OBJECT( tmp_class_creation_3__bases ); | ||
| 1872 | tmp_truth_name_3 = CHECK_IF_TRUE( tmp_class_creation_3__bases ); | ||
| 1873 | if ( tmp_truth_name_3 == -1 ) | ||
| 1874 | { | ||
| 1875 | assert( ERROR_OCCURRED() ); | ||
| 1876 | |||
| 1877 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1878 | |||
| 1879 | |||
| 1880 | exception_lineno = 9; | ||
| 1881 | |||
| 1882 | goto try_except_handler_7; | ||
| 1883 | } | ||
| 1884 | tmp_condition_result_14 = tmp_truth_name_3 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1885 | if ( tmp_condition_result_14 == NUITKA_BOOL_TRUE ) | ||
| 1886 | { | ||
| 1887 | goto condexpr_true_6; | ||
| 1888 | } | ||
| 1889 | else | ||
| 1890 | { | ||
| 1891 | goto condexpr_false_6; | ||
| 1892 | } | ||
| 1893 | condexpr_true_6:; | ||
| 1894 | CHECK_OBJECT( tmp_class_creation_3__bases ); | ||
| 1895 | tmp_subscribed_name_3 = tmp_class_creation_3__bases; | ||
| 1896 | tmp_subscript_name_3 = const_int_0; | ||
| 1897 | tmp_type_arg_5 = LOOKUP_SUBSCRIPT_CONST( tmp_subscribed_name_3, tmp_subscript_name_3, 0 ); | ||
| 1898 | if ( tmp_type_arg_5 == NULL ) | ||
| 1899 | { | ||
| 1900 | assert( ERROR_OCCURRED() ); | ||
| 1901 | |||
| 1902 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1903 | |||
| 1904 | |||
| 1905 | exception_lineno = 9; | ||
| 1906 | |||
| 1907 | goto try_except_handler_7; | ||
| 1908 | } | ||
| 1909 | tmp_metaclass_name_3 = BUILTIN_TYPE1( tmp_type_arg_5 ); | ||
| 1910 | Py_DECREF( tmp_type_arg_5 ); | ||
| 1911 | if ( tmp_metaclass_name_3 == NULL ) | ||
| 1912 | { | ||
| 1913 | assert( ERROR_OCCURRED() ); | ||
| 1914 | |||
| 1915 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1916 | |||
| 1917 | |||
| 1918 | exception_lineno = 9; | ||
| 1919 | |||
| 1920 | goto try_except_handler_7; | ||
| 1921 | } | ||
| 1922 | goto condexpr_end_6; | ||
| 1923 | condexpr_false_6:; | ||
| 1924 | tmp_metaclass_name_3 = (PyObject *)&PyType_Type; | ||
| 1925 | Py_INCREF( tmp_metaclass_name_3 ); | ||
| 1926 | condexpr_end_6:; | ||
| 1927 | condexpr_end_5:; | ||
| 1928 | CHECK_OBJECT( tmp_class_creation_3__bases ); | ||
| 1929 | tmp_bases_name_3 = tmp_class_creation_3__bases; | ||
| 1930 | tmp_assign_source_20 = SELECT_METACLASS( tmp_metaclass_name_3, tmp_bases_name_3 ); | ||
| 1931 | Py_DECREF( tmp_metaclass_name_3 ); | ||
| 1932 | if ( tmp_assign_source_20 == NULL ) | ||
| 1933 | { | ||
| 1934 | assert( ERROR_OCCURRED() ); | ||
| 1935 | |||
| 1936 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1937 | |||
| 1938 | |||
| 1939 | exception_lineno = 9; | ||
| 1940 | |||
| 1941 | goto try_except_handler_7; | ||
| 1942 | } | ||
| 1943 | assert( tmp_class_creation_3__metaclass == NULL ); | ||
| 1944 | tmp_class_creation_3__metaclass = tmp_assign_source_20; | ||
| 1945 | } | ||
| 1946 | { | ||
| 1947 | nuitka_bool tmp_condition_result_15; | ||
| 1948 | PyObject *tmp_key_name_9; | ||
| 1949 | PyObject *tmp_dict_name_9; | ||
| 1950 | tmp_key_name_9 = const_str_plain_metaclass; | ||
| 1951 | CHECK_OBJECT( tmp_class_creation_3__class_decl_dict ); | ||
| 1952 | tmp_dict_name_9 = tmp_class_creation_3__class_decl_dict; | ||
| 1953 | tmp_res = PyDict_Contains( tmp_dict_name_9, tmp_key_name_9 ); | ||
| 1954 | if ( tmp_res == -1 ) | ||
| 1955 | { | ||
| 1956 | assert( ERROR_OCCURRED() ); | ||
| 1957 | |||
| 1958 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1959 | |||
| 1960 | |||
| 1961 | exception_lineno = 9; | ||
| 1962 | |||
| 1963 | goto try_except_handler_7; | ||
| 1964 | } | ||
| 1965 | tmp_condition_result_15 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1966 | if ( tmp_condition_result_15 == NUITKA_BOOL_TRUE ) | ||
| 1967 | { | ||
| 1968 | goto branch_yes_9; | ||
| 1969 | } | ||
| 1970 | else | ||
| 1971 | { | ||
| 1972 | goto branch_no_9; | ||
| 1973 | } | ||
| 1974 | branch_yes_9:; | ||
| 1975 | CHECK_OBJECT( tmp_class_creation_3__class_decl_dict ); | ||
| 1976 | tmp_dictdel_dict = tmp_class_creation_3__class_decl_dict; | ||
| 1977 | tmp_dictdel_key = const_str_plain_metaclass; | ||
| 1978 | tmp_result = DICT_REMOVE_ITEM( tmp_dictdel_dict, tmp_dictdel_key ); | ||
| 1979 | if ( tmp_result == false ) | ||
| 1980 | { | ||
| 1981 | assert( ERROR_OCCURRED() ); | ||
| 1982 | |||
| 1983 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1984 | |||
| 1985 | |||
| 1986 | exception_lineno = 9; | ||
| 1987 | |||
| 1988 | goto try_except_handler_7; | ||
| 1989 | } | ||
| 1990 | branch_no_9:; | ||
| 1991 | } | ||
| 1992 | { | ||
| 1993 | nuitka_bool tmp_condition_result_16; | ||
| 1994 | PyObject *tmp_source_name_9; | ||
| 1995 | CHECK_OBJECT( tmp_class_creation_3__metaclass ); | ||
| 1996 | tmp_source_name_9 = tmp_class_creation_3__metaclass; | ||
| 1997 | tmp_res = PyObject_HasAttr( tmp_source_name_9, const_str_plain___prepare__ ); | ||
| 1998 | tmp_condition_result_16 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1999 | if ( tmp_condition_result_16 == NUITKA_BOOL_TRUE ) | ||
| 2000 | { | ||
| 2001 | goto branch_yes_10; | ||
| 2002 | } | ||
| 2003 | else | ||
| 2004 | { | ||
| 2005 | goto branch_no_10; | ||
| 2006 | } | ||
| 2007 | branch_yes_10:; | ||
| 2008 | { | ||
| 2009 | PyObject *tmp_assign_source_21; | ||
| 2010 | PyObject *tmp_called_name_5; | ||
| 2011 | PyObject *tmp_source_name_10; | ||
| 2012 | PyObject *tmp_args_name_5; | ||
| 2013 | PyObject *tmp_tuple_element_7; | ||
| 2014 | PyObject *tmp_kw_name_5; | ||
| 2015 | CHECK_OBJECT( tmp_class_creation_3__metaclass ); | ||
| 2016 | tmp_source_name_10 = tmp_class_creation_3__metaclass; | ||
| 2017 | tmp_called_name_5 = LOOKUP_ATTRIBUTE( tmp_source_name_10, const_str_plain___prepare__ ); | ||
| 2018 | if ( tmp_called_name_5 == NULL ) | ||
| 2019 | { | ||
| 2020 | assert( ERROR_OCCURRED() ); | ||
| 2021 | |||
| 2022 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2023 | |||
| 2024 | |||
| 2025 | exception_lineno = 9; | ||
| 2026 | |||
| 2027 | goto try_except_handler_7; | ||
| 2028 | } | ||
| 2029 | tmp_tuple_element_7 = const_str_plain_UnavailableSource; | ||
| 2030 | tmp_args_name_5 = PyTuple_New( 2 ); | ||
| 2031 | Py_INCREF( tmp_tuple_element_7 ); | ||
| 2032 | PyTuple_SET_ITEM( tmp_args_name_5, 0, tmp_tuple_element_7 ); | ||
| 2033 | CHECK_OBJECT( tmp_class_creation_3__bases ); | ||
| 2034 | tmp_tuple_element_7 = tmp_class_creation_3__bases; | ||
| 2035 | Py_INCREF( tmp_tuple_element_7 ); | ||
| 2036 | PyTuple_SET_ITEM( tmp_args_name_5, 1, tmp_tuple_element_7 ); | ||
| 2037 | CHECK_OBJECT( tmp_class_creation_3__class_decl_dict ); | ||
| 2038 | tmp_kw_name_5 = tmp_class_creation_3__class_decl_dict; | ||
| 2039 | frame_8a1d77d53dfcd0df1957edabb69a2c4a->m_frame.f_lineno = 9; | ||
| 2040 | tmp_assign_source_21 = CALL_FUNCTION( tmp_called_name_5, tmp_args_name_5, tmp_kw_name_5 ); | ||
| 2041 | Py_DECREF( tmp_called_name_5 ); | ||
| 2042 | Py_DECREF( tmp_args_name_5 ); | ||
| 2043 | if ( tmp_assign_source_21 == NULL ) | ||
| 2044 | { | ||
| 2045 | assert( ERROR_OCCURRED() ); | ||
| 2046 | |||
| 2047 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2048 | |||
| 2049 | |||
| 2050 | exception_lineno = 9; | ||
| 2051 | |||
| 2052 | goto try_except_handler_7; | ||
| 2053 | } | ||
| 2054 | assert( tmp_class_creation_3__prepared == NULL ); | ||
| 2055 | tmp_class_creation_3__prepared = tmp_assign_source_21; | ||
| 2056 | } | ||
| 2057 | { | ||
| 2058 | nuitka_bool tmp_condition_result_17; | ||
| 2059 | PyObject *tmp_operand_name_3; | ||
| 2060 | PyObject *tmp_source_name_11; | ||
| 2061 | CHECK_OBJECT( tmp_class_creation_3__prepared ); | ||
| 2062 | tmp_source_name_11 = tmp_class_creation_3__prepared; | ||
| 2063 | tmp_res = PyObject_HasAttr( tmp_source_name_11, const_str_plain___getitem__ ); | ||
| 2064 | tmp_operand_name_3 = ( tmp_res != 0 ) ? Py_True : Py_False; | ||
| 2065 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_3 ); | ||
| 2066 | if ( tmp_res == -1 ) | ||
| 2067 | { | ||
| 2068 | assert( ERROR_OCCURRED() ); | ||
| 2069 | |||
| 2070 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2071 | |||
| 2072 | |||
| 2073 | exception_lineno = 9; | ||
| 2074 | |||
| 2075 | goto try_except_handler_7; | ||
| 2076 | } | ||
| 2077 | tmp_condition_result_17 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2078 | if ( tmp_condition_result_17 == NUITKA_BOOL_TRUE ) | ||
| 2079 | { | ||
| 2080 | goto branch_yes_11; | ||
| 2081 | } | ||
| 2082 | else | ||
| 2083 | { | ||
| 2084 | goto branch_no_11; | ||
| 2085 | } | ||
| 2086 | branch_yes_11:; | ||
| 2087 | { | ||
| 2088 | PyObject *tmp_raise_type_3; | ||
| 2089 | PyObject *tmp_raise_value_3; | ||
| 2090 | PyObject *tmp_left_name_3; | ||
| 2091 | PyObject *tmp_right_name_3; | ||
| 2092 | PyObject *tmp_tuple_element_8; | ||
| 2093 | PyObject *tmp_getattr_target_3; | ||
| 2094 | PyObject *tmp_getattr_attr_3; | ||
| 2095 | PyObject *tmp_getattr_default_3; | ||
| 2096 | PyObject *tmp_source_name_12; | ||
| 2097 | PyObject *tmp_type_arg_6; | ||
| 2098 | tmp_raise_type_3 = PyExc_TypeError; | ||
| 2099 | tmp_left_name_3 = const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 2100 | CHECK_OBJECT( tmp_class_creation_3__metaclass ); | ||
| 2101 | tmp_getattr_target_3 = tmp_class_creation_3__metaclass; | ||
| 2102 | tmp_getattr_attr_3 = const_str_plain___name__; | ||
| 2103 | tmp_getattr_default_3 = const_str_angle_metaclass; | ||
| 2104 | tmp_tuple_element_8 = BUILTIN_GETATTR( tmp_getattr_target_3, tmp_getattr_attr_3, tmp_getattr_default_3 ); | ||
| 2105 | if ( tmp_tuple_element_8 == NULL ) | ||
| 2106 | { | ||
| 2107 | assert( ERROR_OCCURRED() ); | ||
| 2108 | |||
| 2109 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2110 | |||
| 2111 | |||
| 2112 | exception_lineno = 9; | ||
| 2113 | |||
| 2114 | goto try_except_handler_7; | ||
| 2115 | } | ||
| 2116 | tmp_right_name_3 = PyTuple_New( 2 ); | ||
| 2117 | PyTuple_SET_ITEM( tmp_right_name_3, 0, tmp_tuple_element_8 ); | ||
| 2118 | CHECK_OBJECT( tmp_class_creation_3__prepared ); | ||
| 2119 | tmp_type_arg_6 = tmp_class_creation_3__prepared; | ||
| 2120 | tmp_source_name_12 = BUILTIN_TYPE1( tmp_type_arg_6 ); | ||
| 2121 | assert( !(tmp_source_name_12 == NULL) ); | ||
| 2122 | tmp_tuple_element_8 = LOOKUP_ATTRIBUTE( tmp_source_name_12, const_str_plain___name__ ); | ||
| 2123 | Py_DECREF( tmp_source_name_12 ); | ||
| 2124 | if ( tmp_tuple_element_8 == NULL ) | ||
| 2125 | { | ||
| 2126 | assert( ERROR_OCCURRED() ); | ||
| 2127 | |||
| 2128 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2129 | Py_DECREF( tmp_right_name_3 ); | ||
| 2130 | |||
| 2131 | exception_lineno = 9; | ||
| 2132 | |||
| 2133 | goto try_except_handler_7; | ||
| 2134 | } | ||
| 2135 | PyTuple_SET_ITEM( tmp_right_name_3, 1, tmp_tuple_element_8 ); | ||
| 2136 | tmp_raise_value_3 = BINARY_OPERATION_REMAINDER( tmp_left_name_3, tmp_right_name_3 ); | ||
| 2137 | Py_DECREF( tmp_right_name_3 ); | ||
| 2138 | if ( tmp_raise_value_3 == NULL ) | ||
| 2139 | { | ||
| 2140 | assert( ERROR_OCCURRED() ); | ||
| 2141 | |||
| 2142 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2143 | |||
| 2144 | |||
| 2145 | exception_lineno = 9; | ||
| 2146 | |||
| 2147 | goto try_except_handler_7; | ||
| 2148 | } | ||
| 2149 | exception_type = tmp_raise_type_3; | ||
| 2150 | Py_INCREF( tmp_raise_type_3 ); | ||
| 2151 | exception_value = tmp_raise_value_3; | ||
| 2152 | exception_lineno = 9; | ||
| 2153 | RAISE_EXCEPTION_IMPLICIT( &exception_type, &exception_value, &exception_tb ); | ||
| 2154 | |||
| 2155 | goto try_except_handler_7; | ||
| 2156 | } | ||
| 2157 | branch_no_11:; | ||
| 2158 | } | ||
| 2159 | goto branch_end_10; | ||
| 2160 | branch_no_10:; | ||
| 2161 | { | ||
| 2162 | PyObject *tmp_assign_source_22; | ||
| 2163 | tmp_assign_source_22 = PyDict_New(); | ||
| 2164 | assert( tmp_class_creation_3__prepared == NULL ); | ||
| 2165 | tmp_class_creation_3__prepared = tmp_assign_source_22; | ||
| 2166 | } | ||
| 2167 | branch_end_10:; | ||
| 2168 | } | ||
| 2169 | { | ||
| 2170 | PyObject *tmp_assign_source_23; | ||
| 2171 | { | ||
| 2172 | PyObject *tmp_set_locals_3; | ||
| 2173 | CHECK_OBJECT( tmp_class_creation_3__prepared ); | ||
| 2174 | tmp_set_locals_3 = tmp_class_creation_3__prepared; | ||
| 2175 | locals_problem$exception_9 = tmp_set_locals_3; | ||
| 2176 | Py_INCREF( tmp_set_locals_3 ); | ||
| 2177 | } | ||
| 2178 | // Tried code: | ||
| 2179 | // Tried code: | ||
| 2180 | tmp_dictset_value = const_str_digest_2eaf9b251885e997348baaf55bbf0533; | ||
| 2181 | tmp_res = PyObject_SetItem( locals_problem$exception_9, const_str_plain___module__, tmp_dictset_value ); | ||
| 2182 | if ( tmp_res != 0 ) | ||
| 2183 | { | ||
| 2184 | assert( ERROR_OCCURRED() ); | ||
| 2185 | |||
| 2186 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2187 | |||
| 2188 | |||
| 2189 | exception_lineno = 9; | ||
| 2190 | |||
| 2191 | goto try_except_handler_9; | ||
| 2192 | } | ||
| 2193 | tmp_dictset_value = const_str_plain_UnavailableSource; | ||
| 2194 | tmp_res = PyObject_SetItem( locals_problem$exception_9, const_str_plain___qualname__, tmp_dictset_value ); | ||
| 2195 | if ( tmp_res != 0 ) | ||
| 2196 | { | ||
| 2197 | assert( ERROR_OCCURRED() ); | ||
| 2198 | |||
| 2199 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2200 | |||
| 2201 | |||
| 2202 | exception_lineno = 9; | ||
| 2203 | |||
| 2204 | goto try_except_handler_9; | ||
| 2205 | } | ||
| 2206 | { | ||
| 2207 | nuitka_bool tmp_condition_result_18; | ||
| 2208 | PyObject *tmp_compexpr_left_3; | ||
| 2209 | PyObject *tmp_compexpr_right_3; | ||
| 2210 | CHECK_OBJECT( tmp_class_creation_3__bases ); | ||
| 2211 | tmp_compexpr_left_3 = tmp_class_creation_3__bases; | ||
| 2212 | tmp_compexpr_right_3 = const_tuple_type_Exception_tuple; | ||
| 2213 | tmp_res = RICH_COMPARE_BOOL_NOTEQ_OBJECT_OBJECT( tmp_compexpr_left_3, tmp_compexpr_right_3 ); | ||
| 2214 | if ( tmp_res == -1 ) | ||
| 2215 | { | ||
| 2216 | assert( ERROR_OCCURRED() ); | ||
| 2217 | |||
| 2218 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2219 | |||
| 2220 | |||
| 2221 | exception_lineno = 9; | ||
| 2222 | |||
| 2223 | goto try_except_handler_9; | ||
| 2224 | } | ||
| 2225 | tmp_condition_result_18 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2226 | if ( tmp_condition_result_18 == NUITKA_BOOL_TRUE ) | ||
| 2227 | { | ||
| 2228 | goto branch_yes_12; | ||
| 2229 | } | ||
| 2230 | else | ||
| 2231 | { | ||
| 2232 | goto branch_no_12; | ||
| 2233 | } | ||
| 2234 | branch_yes_12:; | ||
| 2235 | tmp_dictset_value = const_tuple_type_Exception_tuple; | ||
| 2236 | tmp_res = PyObject_SetItem( locals_problem$exception_9, const_str_plain___orig_bases__, tmp_dictset_value ); | ||
| 2237 | if ( tmp_res != 0 ) | ||
| 2238 | { | ||
| 2239 | assert( ERROR_OCCURRED() ); | ||
| 2240 | |||
| 2241 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2242 | |||
| 2243 | |||
| 2244 | exception_lineno = 9; | ||
| 2245 | |||
| 2246 | goto try_except_handler_9; | ||
| 2247 | } | ||
| 2248 | branch_no_12:; | ||
| 2249 | } | ||
| 2250 | { | ||
| 2251 | PyObject *tmp_assign_source_24; | ||
| 2252 | PyObject *tmp_called_name_6; | ||
| 2253 | PyObject *tmp_args_name_6; | ||
| 2254 | PyObject *tmp_tuple_element_9; | ||
| 2255 | PyObject *tmp_kw_name_6; | ||
| 2256 | CHECK_OBJECT( tmp_class_creation_3__metaclass ); | ||
| 2257 | tmp_called_name_6 = tmp_class_creation_3__metaclass; | ||
| 2258 | tmp_tuple_element_9 = const_str_plain_UnavailableSource; | ||
| 2259 | tmp_args_name_6 = PyTuple_New( 3 ); | ||
| 2260 | Py_INCREF( tmp_tuple_element_9 ); | ||
| 2261 | PyTuple_SET_ITEM( tmp_args_name_6, 0, tmp_tuple_element_9 ); | ||
| 2262 | CHECK_OBJECT( tmp_class_creation_3__bases ); | ||
| 2263 | tmp_tuple_element_9 = tmp_class_creation_3__bases; | ||
| 2264 | Py_INCREF( tmp_tuple_element_9 ); | ||
| 2265 | PyTuple_SET_ITEM( tmp_args_name_6, 1, tmp_tuple_element_9 ); | ||
| 2266 | tmp_tuple_element_9 = locals_problem$exception_9; | ||
| 2267 | Py_INCREF( tmp_tuple_element_9 ); | ||
| 2268 | PyTuple_SET_ITEM( tmp_args_name_6, 2, tmp_tuple_element_9 ); | ||
| 2269 | CHECK_OBJECT( tmp_class_creation_3__class_decl_dict ); | ||
| 2270 | tmp_kw_name_6 = tmp_class_creation_3__class_decl_dict; | ||
| 2271 | frame_8a1d77d53dfcd0df1957edabb69a2c4a->m_frame.f_lineno = 9; | ||
| 2272 | tmp_assign_source_24 = CALL_FUNCTION( tmp_called_name_6, tmp_args_name_6, tmp_kw_name_6 ); | ||
| 2273 | Py_DECREF( tmp_args_name_6 ); | ||
| 2274 | if ( tmp_assign_source_24 == NULL ) | ||
| 2275 | { | ||
| 2276 | assert( ERROR_OCCURRED() ); | ||
| 2277 | |||
| 2278 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2279 | |||
| 2280 | |||
| 2281 | exception_lineno = 9; | ||
| 2282 | |||
| 2283 | goto try_except_handler_9; | ||
| 2284 | } | ||
| 2285 | assert( outline_2_var___class__ == NULL ); | ||
| 2286 | outline_2_var___class__ = tmp_assign_source_24; | ||
| 2287 | } | ||
| 2288 | CHECK_OBJECT( outline_2_var___class__ ); | ||
| 2289 | tmp_assign_source_23 = outline_2_var___class__; | ||
| 2290 | Py_INCREF( tmp_assign_source_23 ); | ||
| 2291 | goto try_return_handler_9; | ||
| 2292 | // tried codes exits in all cases | ||
| 2293 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 2294 | return MOD_RETURN_VALUE( NULL ); | ||
| 2295 | // Return handler code: | ||
| 2296 | try_return_handler_9:; | ||
| 2297 | Py_DECREF( locals_problem$exception_9 ); | ||
| 2298 | locals_problem$exception_9 = NULL; | ||
| 2299 | goto try_return_handler_8; | ||
| 2300 | // Exception handler code: | ||
| 2301 | try_except_handler_9:; | ||
| 2302 | exception_keeper_type_7 = exception_type; | ||
| 2303 | exception_keeper_value_7 = exception_value; | ||
| 2304 | exception_keeper_tb_7 = exception_tb; | ||
| 2305 | exception_keeper_lineno_7 = exception_lineno; | ||
| 2306 | exception_type = NULL; | ||
| 2307 | exception_value = NULL; | ||
| 2308 | exception_tb = NULL; | ||
| 2309 | exception_lineno = 0; | ||
| 2310 | |||
| 2311 | Py_DECREF( locals_problem$exception_9 ); | ||
| 2312 | locals_problem$exception_9 = NULL; | ||
| 2313 | // Re-raise. | ||
| 2314 | exception_type = exception_keeper_type_7; | ||
| 2315 | exception_value = exception_keeper_value_7; | ||
| 2316 | exception_tb = exception_keeper_tb_7; | ||
| 2317 | exception_lineno = exception_keeper_lineno_7; | ||
| 2318 | |||
| 2319 | goto try_except_handler_8; | ||
| 2320 | // End of try: | ||
| 2321 | // tried codes exits in all cases | ||
| 2322 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 2323 | return MOD_RETURN_VALUE( NULL ); | ||
| 2324 | // Return handler code: | ||
| 2325 | try_return_handler_8:; | ||
| 2326 | CHECK_OBJECT( (PyObject *)outline_2_var___class__ ); | ||
| 2327 | Py_DECREF( outline_2_var___class__ ); | ||
| 2328 | outline_2_var___class__ = NULL; | ||
| 2329 | |||
| 2330 | goto outline_result_3; | ||
| 2331 | // Exception handler code: | ||
| 2332 | try_except_handler_8:; | ||
| 2333 | exception_keeper_type_8 = exception_type; | ||
| 2334 | exception_keeper_value_8 = exception_value; | ||
| 2335 | exception_keeper_tb_8 = exception_tb; | ||
| 2336 | exception_keeper_lineno_8 = exception_lineno; | ||
| 2337 | exception_type = NULL; | ||
| 2338 | exception_value = NULL; | ||
| 2339 | exception_tb = NULL; | ||
| 2340 | exception_lineno = 0; | ||
| 2341 | |||
| 2342 | // Re-raise. | ||
| 2343 | exception_type = exception_keeper_type_8; | ||
| 2344 | exception_value = exception_keeper_value_8; | ||
| 2345 | exception_tb = exception_keeper_tb_8; | ||
| 2346 | exception_lineno = exception_keeper_lineno_8; | ||
| 2347 | |||
| 2348 | goto outline_exception_3; | ||
| 2349 | // End of try: | ||
| 2350 | // Return statement must have exited already. | ||
| 2351 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 2352 | return MOD_RETURN_VALUE( NULL ); | ||
| 2353 | outline_exception_3:; | ||
| 2354 | exception_lineno = 9; | ||
| 2355 | goto try_except_handler_7; | ||
| 2356 | outline_result_3:; | ||
| 2357 | UPDATE_STRING_DICT1( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain_UnavailableSource, tmp_assign_source_23 ); | ||
| 2358 | } | ||
| 2359 | goto try_end_3; | ||
| 2360 | // Exception handler code: | ||
| 2361 | try_except_handler_7:; | ||
| 2362 | exception_keeper_type_9 = exception_type; | ||
| 2363 | exception_keeper_value_9 = exception_value; | ||
| 2364 | exception_keeper_tb_9 = exception_tb; | ||
| 2365 | exception_keeper_lineno_9 = exception_lineno; | ||
| 2366 | exception_type = NULL; | ||
| 2367 | exception_value = NULL; | ||
| 2368 | exception_tb = NULL; | ||
| 2369 | exception_lineno = 0; | ||
| 2370 | |||
| 2371 | Py_XDECREF( tmp_class_creation_3__bases ); | ||
| 2372 | tmp_class_creation_3__bases = NULL; | ||
| 2373 | |||
| 2374 | Py_XDECREF( tmp_class_creation_3__class_decl_dict ); | ||
| 2375 | tmp_class_creation_3__class_decl_dict = NULL; | ||
| 2376 | |||
| 2377 | Py_XDECREF( tmp_class_creation_3__metaclass ); | ||
| 2378 | tmp_class_creation_3__metaclass = NULL; | ||
| 2379 | |||
| 2380 | Py_XDECREF( tmp_class_creation_3__prepared ); | ||
| 2381 | tmp_class_creation_3__prepared = NULL; | ||
| 2382 | |||
| 2383 | // Re-raise. | ||
| 2384 | exception_type = exception_keeper_type_9; | ||
| 2385 | exception_value = exception_keeper_value_9; | ||
| 2386 | exception_tb = exception_keeper_tb_9; | ||
| 2387 | exception_lineno = exception_keeper_lineno_9; | ||
| 2388 | |||
| 2389 | goto frame_exception_exit_1; | ||
| 2390 | // End of try: | ||
| 2391 | try_end_3:; | ||
| 2392 | CHECK_OBJECT( (PyObject *)tmp_class_creation_3__bases ); | ||
| 2393 | Py_DECREF( tmp_class_creation_3__bases ); | ||
| 2394 | tmp_class_creation_3__bases = NULL; | ||
| 2395 | |||
| 2396 | CHECK_OBJECT( (PyObject *)tmp_class_creation_3__class_decl_dict ); | ||
| 2397 | Py_DECREF( tmp_class_creation_3__class_decl_dict ); | ||
| 2398 | tmp_class_creation_3__class_decl_dict = NULL; | ||
| 2399 | |||
| 2400 | CHECK_OBJECT( (PyObject *)tmp_class_creation_3__metaclass ); | ||
| 2401 | Py_DECREF( tmp_class_creation_3__metaclass ); | ||
| 2402 | tmp_class_creation_3__metaclass = NULL; | ||
| 2403 | |||
| 2404 | CHECK_OBJECT( (PyObject *)tmp_class_creation_3__prepared ); | ||
| 2405 | Py_DECREF( tmp_class_creation_3__prepared ); | ||
| 2406 | tmp_class_creation_3__prepared = NULL; | ||
| 2407 | |||
| 2408 | // Tried code: | ||
| 2409 | { | ||
| 2410 | PyObject *tmp_assign_source_25; | ||
| 2411 | PyObject *tmp_dircall_arg1_4; | ||
| 2412 | tmp_dircall_arg1_4 = const_tuple_type_Exception_tuple; | ||
| 2413 | Py_INCREF( tmp_dircall_arg1_4 ); | ||
| 2414 | |||
| 2415 | { | ||
| 2416 | PyObject *dir_call_args[] = {tmp_dircall_arg1_4}; | ||
| 2417 | tmp_assign_source_25 = impl___internal__$$$function_2__mro_entries_conversion( dir_call_args ); | ||
| 2418 | } | ||
| 2419 | if ( tmp_assign_source_25 == NULL ) | ||
| 2420 | { | ||
| 2421 | assert( ERROR_OCCURRED() ); | ||
| 2422 | |||
| 2423 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2424 | |||
| 2425 | |||
| 2426 | exception_lineno = 13; | ||
| 2427 | |||
| 2428 | goto try_except_handler_10; | ||
| 2429 | } | ||
| 2430 | assert( tmp_class_creation_4__bases == NULL ); | ||
| 2431 | tmp_class_creation_4__bases = tmp_assign_source_25; | ||
| 2432 | } | ||
| 2433 | { | ||
| 2434 | PyObject *tmp_assign_source_26; | ||
| 2435 | tmp_assign_source_26 = PyDict_New(); | ||
| 2436 | assert( tmp_class_creation_4__class_decl_dict == NULL ); | ||
| 2437 | tmp_class_creation_4__class_decl_dict = tmp_assign_source_26; | ||
| 2438 | } | ||
| 2439 | { | ||
| 2440 | PyObject *tmp_assign_source_27; | ||
| 2441 | PyObject *tmp_metaclass_name_4; | ||
| 2442 | nuitka_bool tmp_condition_result_19; | ||
| 2443 | PyObject *tmp_key_name_10; | ||
| 2444 | PyObject *tmp_dict_name_10; | ||
| 2445 | PyObject *tmp_dict_name_11; | ||
| 2446 | PyObject *tmp_key_name_11; | ||
| 2447 | nuitka_bool tmp_condition_result_20; | ||
| 2448 | int tmp_truth_name_4; | ||
| 2449 | PyObject *tmp_type_arg_7; | ||
| 2450 | PyObject *tmp_subscribed_name_4; | ||
| 2451 | PyObject *tmp_subscript_name_4; | ||
| 2452 | PyObject *tmp_bases_name_4; | ||
| 2453 | tmp_key_name_10 = const_str_plain_metaclass; | ||
| 2454 | CHECK_OBJECT( tmp_class_creation_4__class_decl_dict ); | ||
| 2455 | tmp_dict_name_10 = tmp_class_creation_4__class_decl_dict; | ||
| 2456 | tmp_res = PyDict_Contains( tmp_dict_name_10, tmp_key_name_10 ); | ||
| 2457 | if ( tmp_res == -1 ) | ||
| 2458 | { | ||
| 2459 | assert( ERROR_OCCURRED() ); | ||
| 2460 | |||
| 2461 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2462 | |||
| 2463 | |||
| 2464 | exception_lineno = 13; | ||
| 2465 | |||
| 2466 | goto try_except_handler_10; | ||
| 2467 | } | ||
| 2468 | tmp_condition_result_19 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2469 | if ( tmp_condition_result_19 == NUITKA_BOOL_TRUE ) | ||
| 2470 | { | ||
| 2471 | goto condexpr_true_7; | ||
| 2472 | } | ||
| 2473 | else | ||
| 2474 | { | ||
| 2475 | goto condexpr_false_7; | ||
| 2476 | } | ||
| 2477 | condexpr_true_7:; | ||
| 2478 | CHECK_OBJECT( tmp_class_creation_4__class_decl_dict ); | ||
| 2479 | tmp_dict_name_11 = tmp_class_creation_4__class_decl_dict; | ||
| 2480 | tmp_key_name_11 = const_str_plain_metaclass; | ||
| 2481 | tmp_metaclass_name_4 = DICT_GET_ITEM( tmp_dict_name_11, tmp_key_name_11 ); | ||
| 2482 | if ( tmp_metaclass_name_4 == NULL ) | ||
| 2483 | { | ||
| 2484 | assert( ERROR_OCCURRED() ); | ||
| 2485 | |||
| 2486 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2487 | |||
| 2488 | |||
| 2489 | exception_lineno = 13; | ||
| 2490 | |||
| 2491 | goto try_except_handler_10; | ||
| 2492 | } | ||
| 2493 | goto condexpr_end_7; | ||
| 2494 | condexpr_false_7:; | ||
| 2495 | CHECK_OBJECT( tmp_class_creation_4__bases ); | ||
| 2496 | tmp_truth_name_4 = CHECK_IF_TRUE( tmp_class_creation_4__bases ); | ||
| 2497 | if ( tmp_truth_name_4 == -1 ) | ||
| 2498 | { | ||
| 2499 | assert( ERROR_OCCURRED() ); | ||
| 2500 | |||
| 2501 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2502 | |||
| 2503 | |||
| 2504 | exception_lineno = 13; | ||
| 2505 | |||
| 2506 | goto try_except_handler_10; | ||
| 2507 | } | ||
| 2508 | tmp_condition_result_20 = tmp_truth_name_4 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2509 | if ( tmp_condition_result_20 == NUITKA_BOOL_TRUE ) | ||
| 2510 | { | ||
| 2511 | goto condexpr_true_8; | ||
| 2512 | } | ||
| 2513 | else | ||
| 2514 | { | ||
| 2515 | goto condexpr_false_8; | ||
| 2516 | } | ||
| 2517 | condexpr_true_8:; | ||
| 2518 | CHECK_OBJECT( tmp_class_creation_4__bases ); | ||
| 2519 | tmp_subscribed_name_4 = tmp_class_creation_4__bases; | ||
| 2520 | tmp_subscript_name_4 = const_int_0; | ||
| 2521 | tmp_type_arg_7 = LOOKUP_SUBSCRIPT_CONST( tmp_subscribed_name_4, tmp_subscript_name_4, 0 ); | ||
| 2522 | if ( tmp_type_arg_7 == NULL ) | ||
| 2523 | { | ||
| 2524 | assert( ERROR_OCCURRED() ); | ||
| 2525 | |||
| 2526 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2527 | |||
| 2528 | |||
| 2529 | exception_lineno = 13; | ||
| 2530 | |||
| 2531 | goto try_except_handler_10; | ||
| 2532 | } | ||
| 2533 | tmp_metaclass_name_4 = BUILTIN_TYPE1( tmp_type_arg_7 ); | ||
| 2534 | Py_DECREF( tmp_type_arg_7 ); | ||
| 2535 | if ( tmp_metaclass_name_4 == NULL ) | ||
| 2536 | { | ||
| 2537 | assert( ERROR_OCCURRED() ); | ||
| 2538 | |||
| 2539 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2540 | |||
| 2541 | |||
| 2542 | exception_lineno = 13; | ||
| 2543 | |||
| 2544 | goto try_except_handler_10; | ||
| 2545 | } | ||
| 2546 | goto condexpr_end_8; | ||
| 2547 | condexpr_false_8:; | ||
| 2548 | tmp_metaclass_name_4 = (PyObject *)&PyType_Type; | ||
| 2549 | Py_INCREF( tmp_metaclass_name_4 ); | ||
| 2550 | condexpr_end_8:; | ||
| 2551 | condexpr_end_7:; | ||
| 2552 | CHECK_OBJECT( tmp_class_creation_4__bases ); | ||
| 2553 | tmp_bases_name_4 = tmp_class_creation_4__bases; | ||
| 2554 | tmp_assign_source_27 = SELECT_METACLASS( tmp_metaclass_name_4, tmp_bases_name_4 ); | ||
| 2555 | Py_DECREF( tmp_metaclass_name_4 ); | ||
| 2556 | if ( tmp_assign_source_27 == NULL ) | ||
| 2557 | { | ||
| 2558 | assert( ERROR_OCCURRED() ); | ||
| 2559 | |||
| 2560 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2561 | |||
| 2562 | |||
| 2563 | exception_lineno = 13; | ||
| 2564 | |||
| 2565 | goto try_except_handler_10; | ||
| 2566 | } | ||
| 2567 | assert( tmp_class_creation_4__metaclass == NULL ); | ||
| 2568 | tmp_class_creation_4__metaclass = tmp_assign_source_27; | ||
| 2569 | } | ||
| 2570 | { | ||
| 2571 | nuitka_bool tmp_condition_result_21; | ||
| 2572 | PyObject *tmp_key_name_12; | ||
| 2573 | PyObject *tmp_dict_name_12; | ||
| 2574 | tmp_key_name_12 = const_str_plain_metaclass; | ||
| 2575 | CHECK_OBJECT( tmp_class_creation_4__class_decl_dict ); | ||
| 2576 | tmp_dict_name_12 = tmp_class_creation_4__class_decl_dict; | ||
| 2577 | tmp_res = PyDict_Contains( tmp_dict_name_12, tmp_key_name_12 ); | ||
| 2578 | if ( tmp_res == -1 ) | ||
| 2579 | { | ||
| 2580 | assert( ERROR_OCCURRED() ); | ||
| 2581 | |||
| 2582 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2583 | |||
| 2584 | |||
| 2585 | exception_lineno = 13; | ||
| 2586 | |||
| 2587 | goto try_except_handler_10; | ||
| 2588 | } | ||
| 2589 | tmp_condition_result_21 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2590 | if ( tmp_condition_result_21 == NUITKA_BOOL_TRUE ) | ||
| 2591 | { | ||
| 2592 | goto branch_yes_13; | ||
| 2593 | } | ||
| 2594 | else | ||
| 2595 | { | ||
| 2596 | goto branch_no_13; | ||
| 2597 | } | ||
| 2598 | branch_yes_13:; | ||
| 2599 | CHECK_OBJECT( tmp_class_creation_4__class_decl_dict ); | ||
| 2600 | tmp_dictdel_dict = tmp_class_creation_4__class_decl_dict; | ||
| 2601 | tmp_dictdel_key = const_str_plain_metaclass; | ||
| 2602 | tmp_result = DICT_REMOVE_ITEM( tmp_dictdel_dict, tmp_dictdel_key ); | ||
| 2603 | if ( tmp_result == false ) | ||
| 2604 | { | ||
| 2605 | assert( ERROR_OCCURRED() ); | ||
| 2606 | |||
| 2607 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2608 | |||
| 2609 | |||
| 2610 | exception_lineno = 13; | ||
| 2611 | |||
| 2612 | goto try_except_handler_10; | ||
| 2613 | } | ||
| 2614 | branch_no_13:; | ||
| 2615 | } | ||
| 2616 | { | ||
| 2617 | nuitka_bool tmp_condition_result_22; | ||
| 2618 | PyObject *tmp_source_name_13; | ||
| 2619 | CHECK_OBJECT( tmp_class_creation_4__metaclass ); | ||
| 2620 | tmp_source_name_13 = tmp_class_creation_4__metaclass; | ||
| 2621 | tmp_res = PyObject_HasAttr( tmp_source_name_13, const_str_plain___prepare__ ); | ||
| 2622 | tmp_condition_result_22 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2623 | if ( tmp_condition_result_22 == NUITKA_BOOL_TRUE ) | ||
| 2624 | { | ||
| 2625 | goto branch_yes_14; | ||
| 2626 | } | ||
| 2627 | else | ||
| 2628 | { | ||
| 2629 | goto branch_no_14; | ||
| 2630 | } | ||
| 2631 | branch_yes_14:; | ||
| 2632 | { | ||
| 2633 | PyObject *tmp_assign_source_28; | ||
| 2634 | PyObject *tmp_called_name_7; | ||
| 2635 | PyObject *tmp_source_name_14; | ||
| 2636 | PyObject *tmp_args_name_7; | ||
| 2637 | PyObject *tmp_tuple_element_10; | ||
| 2638 | PyObject *tmp_kw_name_7; | ||
| 2639 | CHECK_OBJECT( tmp_class_creation_4__metaclass ); | ||
| 2640 | tmp_source_name_14 = tmp_class_creation_4__metaclass; | ||
| 2641 | tmp_called_name_7 = LOOKUP_ATTRIBUTE( tmp_source_name_14, const_str_plain___prepare__ ); | ||
| 2642 | if ( tmp_called_name_7 == NULL ) | ||
| 2643 | { | ||
| 2644 | assert( ERROR_OCCURRED() ); | ||
| 2645 | |||
| 2646 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2647 | |||
| 2648 | |||
| 2649 | exception_lineno = 13; | ||
| 2650 | |||
| 2651 | goto try_except_handler_10; | ||
| 2652 | } | ||
| 2653 | tmp_tuple_element_10 = const_str_plain_ValidationError; | ||
| 2654 | tmp_args_name_7 = PyTuple_New( 2 ); | ||
| 2655 | Py_INCREF( tmp_tuple_element_10 ); | ||
| 2656 | PyTuple_SET_ITEM( tmp_args_name_7, 0, tmp_tuple_element_10 ); | ||
| 2657 | CHECK_OBJECT( tmp_class_creation_4__bases ); | ||
| 2658 | tmp_tuple_element_10 = tmp_class_creation_4__bases; | ||
| 2659 | Py_INCREF( tmp_tuple_element_10 ); | ||
| 2660 | PyTuple_SET_ITEM( tmp_args_name_7, 1, tmp_tuple_element_10 ); | ||
| 2661 | CHECK_OBJECT( tmp_class_creation_4__class_decl_dict ); | ||
| 2662 | tmp_kw_name_7 = tmp_class_creation_4__class_decl_dict; | ||
| 2663 | frame_8a1d77d53dfcd0df1957edabb69a2c4a->m_frame.f_lineno = 13; | ||
| 2664 | tmp_assign_source_28 = CALL_FUNCTION( tmp_called_name_7, tmp_args_name_7, tmp_kw_name_7 ); | ||
| 2665 | Py_DECREF( tmp_called_name_7 ); | ||
| 2666 | Py_DECREF( tmp_args_name_7 ); | ||
| 2667 | if ( tmp_assign_source_28 == NULL ) | ||
| 2668 | { | ||
| 2669 | assert( ERROR_OCCURRED() ); | ||
| 2670 | |||
| 2671 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2672 | |||
| 2673 | |||
| 2674 | exception_lineno = 13; | ||
| 2675 | |||
| 2676 | goto try_except_handler_10; | ||
| 2677 | } | ||
| 2678 | assert( tmp_class_creation_4__prepared == NULL ); | ||
| 2679 | tmp_class_creation_4__prepared = tmp_assign_source_28; | ||
| 2680 | } | ||
| 2681 | { | ||
| 2682 | nuitka_bool tmp_condition_result_23; | ||
| 2683 | PyObject *tmp_operand_name_4; | ||
| 2684 | PyObject *tmp_source_name_15; | ||
| 2685 | CHECK_OBJECT( tmp_class_creation_4__prepared ); | ||
| 2686 | tmp_source_name_15 = tmp_class_creation_4__prepared; | ||
| 2687 | tmp_res = PyObject_HasAttr( tmp_source_name_15, const_str_plain___getitem__ ); | ||
| 2688 | tmp_operand_name_4 = ( tmp_res != 0 ) ? Py_True : Py_False; | ||
| 2689 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_4 ); | ||
| 2690 | if ( tmp_res == -1 ) | ||
| 2691 | { | ||
| 2692 | assert( ERROR_OCCURRED() ); | ||
| 2693 | |||
| 2694 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2695 | |||
| 2696 | |||
| 2697 | exception_lineno = 13; | ||
| 2698 | |||
| 2699 | goto try_except_handler_10; | ||
| 2700 | } | ||
| 2701 | tmp_condition_result_23 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2702 | if ( tmp_condition_result_23 == NUITKA_BOOL_TRUE ) | ||
| 2703 | { | ||
| 2704 | goto branch_yes_15; | ||
| 2705 | } | ||
| 2706 | else | ||
| 2707 | { | ||
| 2708 | goto branch_no_15; | ||
| 2709 | } | ||
| 2710 | branch_yes_15:; | ||
| 2711 | { | ||
| 2712 | PyObject *tmp_raise_type_4; | ||
| 2713 | PyObject *tmp_raise_value_4; | ||
| 2714 | PyObject *tmp_left_name_4; | ||
| 2715 | PyObject *tmp_right_name_4; | ||
| 2716 | PyObject *tmp_tuple_element_11; | ||
| 2717 | PyObject *tmp_getattr_target_4; | ||
| 2718 | PyObject *tmp_getattr_attr_4; | ||
| 2719 | PyObject *tmp_getattr_default_4; | ||
| 2720 | PyObject *tmp_source_name_16; | ||
| 2721 | PyObject *tmp_type_arg_8; | ||
| 2722 | tmp_raise_type_4 = PyExc_TypeError; | ||
| 2723 | tmp_left_name_4 = const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 2724 | CHECK_OBJECT( tmp_class_creation_4__metaclass ); | ||
| 2725 | tmp_getattr_target_4 = tmp_class_creation_4__metaclass; | ||
| 2726 | tmp_getattr_attr_4 = const_str_plain___name__; | ||
| 2727 | tmp_getattr_default_4 = const_str_angle_metaclass; | ||
| 2728 | tmp_tuple_element_11 = BUILTIN_GETATTR( tmp_getattr_target_4, tmp_getattr_attr_4, tmp_getattr_default_4 ); | ||
| 2729 | if ( tmp_tuple_element_11 == NULL ) | ||
| 2730 | { | ||
| 2731 | assert( ERROR_OCCURRED() ); | ||
| 2732 | |||
| 2733 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2734 | |||
| 2735 | |||
| 2736 | exception_lineno = 13; | ||
| 2737 | |||
| 2738 | goto try_except_handler_10; | ||
| 2739 | } | ||
| 2740 | tmp_right_name_4 = PyTuple_New( 2 ); | ||
| 2741 | PyTuple_SET_ITEM( tmp_right_name_4, 0, tmp_tuple_element_11 ); | ||
| 2742 | CHECK_OBJECT( tmp_class_creation_4__prepared ); | ||
| 2743 | tmp_type_arg_8 = tmp_class_creation_4__prepared; | ||
| 2744 | tmp_source_name_16 = BUILTIN_TYPE1( tmp_type_arg_8 ); | ||
| 2745 | assert( !(tmp_source_name_16 == NULL) ); | ||
| 2746 | tmp_tuple_element_11 = LOOKUP_ATTRIBUTE( tmp_source_name_16, const_str_plain___name__ ); | ||
| 2747 | Py_DECREF( tmp_source_name_16 ); | ||
| 2748 | if ( tmp_tuple_element_11 == NULL ) | ||
| 2749 | { | ||
| 2750 | assert( ERROR_OCCURRED() ); | ||
| 2751 | |||
| 2752 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2753 | Py_DECREF( tmp_right_name_4 ); | ||
| 2754 | |||
| 2755 | exception_lineno = 13; | ||
| 2756 | |||
| 2757 | goto try_except_handler_10; | ||
| 2758 | } | ||
| 2759 | PyTuple_SET_ITEM( tmp_right_name_4, 1, tmp_tuple_element_11 ); | ||
| 2760 | tmp_raise_value_4 = BINARY_OPERATION_REMAINDER( tmp_left_name_4, tmp_right_name_4 ); | ||
| 2761 | Py_DECREF( tmp_right_name_4 ); | ||
| 2762 | if ( tmp_raise_value_4 == NULL ) | ||
| 2763 | { | ||
| 2764 | assert( ERROR_OCCURRED() ); | ||
| 2765 | |||
| 2766 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2767 | |||
| 2768 | |||
| 2769 | exception_lineno = 13; | ||
| 2770 | |||
| 2771 | goto try_except_handler_10; | ||
| 2772 | } | ||
| 2773 | exception_type = tmp_raise_type_4; | ||
| 2774 | Py_INCREF( tmp_raise_type_4 ); | ||
| 2775 | exception_value = tmp_raise_value_4; | ||
| 2776 | exception_lineno = 13; | ||
| 2777 | RAISE_EXCEPTION_IMPLICIT( &exception_type, &exception_value, &exception_tb ); | ||
| 2778 | |||
| 2779 | goto try_except_handler_10; | ||
| 2780 | } | ||
| 2781 | branch_no_15:; | ||
| 2782 | } | ||
| 2783 | goto branch_end_14; | ||
| 2784 | branch_no_14:; | ||
| 2785 | { | ||
| 2786 | PyObject *tmp_assign_source_29; | ||
| 2787 | tmp_assign_source_29 = PyDict_New(); | ||
| 2788 | assert( tmp_class_creation_4__prepared == NULL ); | ||
| 2789 | tmp_class_creation_4__prepared = tmp_assign_source_29; | ||
| 2790 | } | ||
| 2791 | branch_end_14:; | ||
| 2792 | } | ||
| 2793 | { | ||
| 2794 | PyObject *tmp_assign_source_30; | ||
| 2795 | { | ||
| 2796 | PyObject *tmp_set_locals_4; | ||
| 2797 | CHECK_OBJECT( tmp_class_creation_4__prepared ); | ||
| 2798 | tmp_set_locals_4 = tmp_class_creation_4__prepared; | ||
| 2799 | locals_problem$exception_13 = tmp_set_locals_4; | ||
| 2800 | Py_INCREF( tmp_set_locals_4 ); | ||
| 2801 | } | ||
| 2802 | // Tried code: | ||
| 2803 | // Tried code: | ||
| 2804 | tmp_dictset_value = const_str_digest_2eaf9b251885e997348baaf55bbf0533; | ||
| 2805 | tmp_res = PyObject_SetItem( locals_problem$exception_13, const_str_plain___module__, tmp_dictset_value ); | ||
| 2806 | if ( tmp_res != 0 ) | ||
| 2807 | { | ||
| 2808 | assert( ERROR_OCCURRED() ); | ||
| 2809 | |||
| 2810 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2811 | |||
| 2812 | |||
| 2813 | exception_lineno = 13; | ||
| 2814 | |||
| 2815 | goto try_except_handler_12; | ||
| 2816 | } | ||
| 2817 | tmp_dictset_value = const_str_plain_ValidationError; | ||
| 2818 | tmp_res = PyObject_SetItem( locals_problem$exception_13, const_str_plain___qualname__, tmp_dictset_value ); | ||
| 2819 | if ( tmp_res != 0 ) | ||
| 2820 | { | ||
| 2821 | assert( ERROR_OCCURRED() ); | ||
| 2822 | |||
| 2823 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2824 | |||
| 2825 | |||
| 2826 | exception_lineno = 13; | ||
| 2827 | |||
| 2828 | goto try_except_handler_12; | ||
| 2829 | } | ||
| 2830 | { | ||
| 2831 | nuitka_bool tmp_condition_result_24; | ||
| 2832 | PyObject *tmp_compexpr_left_4; | ||
| 2833 | PyObject *tmp_compexpr_right_4; | ||
| 2834 | CHECK_OBJECT( tmp_class_creation_4__bases ); | ||
| 2835 | tmp_compexpr_left_4 = tmp_class_creation_4__bases; | ||
| 2836 | tmp_compexpr_right_4 = const_tuple_type_Exception_tuple; | ||
| 2837 | tmp_res = RICH_COMPARE_BOOL_NOTEQ_OBJECT_OBJECT( tmp_compexpr_left_4, tmp_compexpr_right_4 ); | ||
| 2838 | if ( tmp_res == -1 ) | ||
| 2839 | { | ||
| 2840 | assert( ERROR_OCCURRED() ); | ||
| 2841 | |||
| 2842 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2843 | |||
| 2844 | |||
| 2845 | exception_lineno = 13; | ||
| 2846 | |||
| 2847 | goto try_except_handler_12; | ||
| 2848 | } | ||
| 2849 | tmp_condition_result_24 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2850 | if ( tmp_condition_result_24 == NUITKA_BOOL_TRUE ) | ||
| 2851 | { | ||
| 2852 | goto branch_yes_16; | ||
| 2853 | } | ||
| 2854 | else | ||
| 2855 | { | ||
| 2856 | goto branch_no_16; | ||
| 2857 | } | ||
| 2858 | branch_yes_16:; | ||
| 2859 | tmp_dictset_value = const_tuple_type_Exception_tuple; | ||
| 2860 | tmp_res = PyObject_SetItem( locals_problem$exception_13, const_str_plain___orig_bases__, tmp_dictset_value ); | ||
| 2861 | if ( tmp_res != 0 ) | ||
| 2862 | { | ||
| 2863 | assert( ERROR_OCCURRED() ); | ||
| 2864 | |||
| 2865 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2866 | |||
| 2867 | |||
| 2868 | exception_lineno = 13; | ||
| 2869 | |||
| 2870 | goto try_except_handler_12; | ||
| 2871 | } | ||
| 2872 | branch_no_16:; | ||
| 2873 | } | ||
| 2874 | { | ||
| 2875 | PyObject *tmp_assign_source_31; | ||
| 2876 | PyObject *tmp_called_name_8; | ||
| 2877 | PyObject *tmp_args_name_8; | ||
| 2878 | PyObject *tmp_tuple_element_12; | ||
| 2879 | PyObject *tmp_kw_name_8; | ||
| 2880 | CHECK_OBJECT( tmp_class_creation_4__metaclass ); | ||
| 2881 | tmp_called_name_8 = tmp_class_creation_4__metaclass; | ||
| 2882 | tmp_tuple_element_12 = const_str_plain_ValidationError; | ||
| 2883 | tmp_args_name_8 = PyTuple_New( 3 ); | ||
| 2884 | Py_INCREF( tmp_tuple_element_12 ); | ||
| 2885 | PyTuple_SET_ITEM( tmp_args_name_8, 0, tmp_tuple_element_12 ); | ||
| 2886 | CHECK_OBJECT( tmp_class_creation_4__bases ); | ||
| 2887 | tmp_tuple_element_12 = tmp_class_creation_4__bases; | ||
| 2888 | Py_INCREF( tmp_tuple_element_12 ); | ||
| 2889 | PyTuple_SET_ITEM( tmp_args_name_8, 1, tmp_tuple_element_12 ); | ||
| 2890 | tmp_tuple_element_12 = locals_problem$exception_13; | ||
| 2891 | Py_INCREF( tmp_tuple_element_12 ); | ||
| 2892 | PyTuple_SET_ITEM( tmp_args_name_8, 2, tmp_tuple_element_12 ); | ||
| 2893 | CHECK_OBJECT( tmp_class_creation_4__class_decl_dict ); | ||
| 2894 | tmp_kw_name_8 = tmp_class_creation_4__class_decl_dict; | ||
| 2895 | frame_8a1d77d53dfcd0df1957edabb69a2c4a->m_frame.f_lineno = 13; | ||
| 2896 | tmp_assign_source_31 = CALL_FUNCTION( tmp_called_name_8, tmp_args_name_8, tmp_kw_name_8 ); | ||
| 2897 | Py_DECREF( tmp_args_name_8 ); | ||
| 2898 | if ( tmp_assign_source_31 == NULL ) | ||
| 2899 | { | ||
| 2900 | assert( ERROR_OCCURRED() ); | ||
| 2901 | |||
| 2902 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2903 | |||
| 2904 | |||
| 2905 | exception_lineno = 13; | ||
| 2906 | |||
| 2907 | goto try_except_handler_12; | ||
| 2908 | } | ||
| 2909 | assert( outline_3_var___class__ == NULL ); | ||
| 2910 | outline_3_var___class__ = tmp_assign_source_31; | ||
| 2911 | } | ||
| 2912 | CHECK_OBJECT( outline_3_var___class__ ); | ||
| 2913 | tmp_assign_source_30 = outline_3_var___class__; | ||
| 2914 | Py_INCREF( tmp_assign_source_30 ); | ||
| 2915 | goto try_return_handler_12; | ||
| 2916 | // tried codes exits in all cases | ||
| 2917 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 2918 | return MOD_RETURN_VALUE( NULL ); | ||
| 2919 | // Return handler code: | ||
| 2920 | try_return_handler_12:; | ||
| 2921 | Py_DECREF( locals_problem$exception_13 ); | ||
| 2922 | locals_problem$exception_13 = NULL; | ||
| 2923 | goto try_return_handler_11; | ||
| 2924 | // Exception handler code: | ||
| 2925 | try_except_handler_12:; | ||
| 2926 | exception_keeper_type_10 = exception_type; | ||
| 2927 | exception_keeper_value_10 = exception_value; | ||
| 2928 | exception_keeper_tb_10 = exception_tb; | ||
| 2929 | exception_keeper_lineno_10 = exception_lineno; | ||
| 2930 | exception_type = NULL; | ||
| 2931 | exception_value = NULL; | ||
| 2932 | exception_tb = NULL; | ||
| 2933 | exception_lineno = 0; | ||
| 2934 | |||
| 2935 | Py_DECREF( locals_problem$exception_13 ); | ||
| 2936 | locals_problem$exception_13 = NULL; | ||
| 2937 | // Re-raise. | ||
| 2938 | exception_type = exception_keeper_type_10; | ||
| 2939 | exception_value = exception_keeper_value_10; | ||
| 2940 | exception_tb = exception_keeper_tb_10; | ||
| 2941 | exception_lineno = exception_keeper_lineno_10; | ||
| 2942 | |||
| 2943 | goto try_except_handler_11; | ||
| 2944 | // End of try: | ||
| 2945 | // tried codes exits in all cases | ||
| 2946 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 2947 | return MOD_RETURN_VALUE( NULL ); | ||
| 2948 | // Return handler code: | ||
| 2949 | try_return_handler_11:; | ||
| 2950 | CHECK_OBJECT( (PyObject *)outline_3_var___class__ ); | ||
| 2951 | Py_DECREF( outline_3_var___class__ ); | ||
| 2952 | outline_3_var___class__ = NULL; | ||
| 2953 | |||
| 2954 | goto outline_result_4; | ||
| 2955 | // Exception handler code: | ||
| 2956 | try_except_handler_11:; | ||
| 2957 | exception_keeper_type_11 = exception_type; | ||
| 2958 | exception_keeper_value_11 = exception_value; | ||
| 2959 | exception_keeper_tb_11 = exception_tb; | ||
| 2960 | exception_keeper_lineno_11 = exception_lineno; | ||
| 2961 | exception_type = NULL; | ||
| 2962 | exception_value = NULL; | ||
| 2963 | exception_tb = NULL; | ||
| 2964 | exception_lineno = 0; | ||
| 2965 | |||
| 2966 | // Re-raise. | ||
| 2967 | exception_type = exception_keeper_type_11; | ||
| 2968 | exception_value = exception_keeper_value_11; | ||
| 2969 | exception_tb = exception_keeper_tb_11; | ||
| 2970 | exception_lineno = exception_keeper_lineno_11; | ||
| 2971 | |||
| 2972 | goto outline_exception_4; | ||
| 2973 | // End of try: | ||
| 2974 | // Return statement must have exited already. | ||
| 2975 | NUITKA_CANNOT_GET_HERE( problem$exception ); | ||
| 2976 | return MOD_RETURN_VALUE( NULL ); | ||
| 2977 | outline_exception_4:; | ||
| 2978 | exception_lineno = 13; | ||
| 2979 | goto try_except_handler_10; | ||
| 2980 | outline_result_4:; | ||
| 2981 | UPDATE_STRING_DICT1( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain_ValidationError, tmp_assign_source_30 ); | ||
| 2982 | } | ||
| 2983 | goto try_end_4; | ||
| 2984 | // Exception handler code: | ||
| 2985 | try_except_handler_10:; | ||
| 2986 | exception_keeper_type_12 = exception_type; | ||
| 2987 | exception_keeper_value_12 = exception_value; | ||
| 2988 | exception_keeper_tb_12 = exception_tb; | ||
| 2989 | exception_keeper_lineno_12 = exception_lineno; | ||
| 2990 | exception_type = NULL; | ||
| 2991 | exception_value = NULL; | ||
| 2992 | exception_tb = NULL; | ||
| 2993 | exception_lineno = 0; | ||
| 2994 | |||
| 2995 | Py_XDECREF( tmp_class_creation_4__bases ); | ||
| 2996 | tmp_class_creation_4__bases = NULL; | ||
| 2997 | |||
| 2998 | Py_XDECREF( tmp_class_creation_4__class_decl_dict ); | ||
| 2999 | tmp_class_creation_4__class_decl_dict = NULL; | ||
| 3000 | |||
| 3001 | Py_XDECREF( tmp_class_creation_4__metaclass ); | ||
| 3002 | tmp_class_creation_4__metaclass = NULL; | ||
| 3003 | |||
| 3004 | Py_XDECREF( tmp_class_creation_4__prepared ); | ||
| 3005 | tmp_class_creation_4__prepared = NULL; | ||
| 3006 | |||
| 3007 | // Re-raise. | ||
| 3008 | exception_type = exception_keeper_type_12; | ||
| 3009 | exception_value = exception_keeper_value_12; | ||
| 3010 | exception_tb = exception_keeper_tb_12; | ||
| 3011 | exception_lineno = exception_keeper_lineno_12; | ||
| 3012 | |||
| 3013 | goto frame_exception_exit_1; | ||
| 3014 | // End of try: | ||
| 3015 | try_end_4:; | ||
| 3016 | |||
| 3017 | // Restore frame exception if necessary. | ||
| 3018 | #if 0 | ||
| 3019 | RESTORE_FRAME_EXCEPTION( frame_8a1d77d53dfcd0df1957edabb69a2c4a ); | ||
| 3020 | #endif | ||
| 3021 | popFrameStack(); | ||
| 3022 | |||
| 3023 | assertFrameObject( frame_8a1d77d53dfcd0df1957edabb69a2c4a ); | ||
| 3024 | |||
| 3025 | goto frame_no_exception_1; | ||
| 3026 | |||
| 3027 | frame_exception_exit_1:; | ||
| 3028 | #if 0 | ||
| 3029 | RESTORE_FRAME_EXCEPTION( frame_8a1d77d53dfcd0df1957edabb69a2c4a ); | ||
| 3030 | #endif | ||
| 3031 | |||
| 3032 | if ( exception_tb == NULL ) | ||
| 3033 | { | ||
| 3034 | exception_tb = MAKE_TRACEBACK( frame_8a1d77d53dfcd0df1957edabb69a2c4a, exception_lineno ); | ||
| 3035 | } | ||
| 3036 | else if ( exception_tb->tb_frame != &frame_8a1d77d53dfcd0df1957edabb69a2c4a->m_frame ) | ||
| 3037 | { | ||
| 3038 | exception_tb = ADD_TRACEBACK( exception_tb, frame_8a1d77d53dfcd0df1957edabb69a2c4a, exception_lineno ); | ||
| 3039 | } | ||
| 3040 | |||
| 3041 | // Put the previous frame back on top. | ||
| 3042 | popFrameStack(); | ||
| 3043 | |||
| 3044 | // Return the error. | ||
| 3045 | goto module_exception_exit; | ||
| 3046 | |||
| 3047 | frame_no_exception_1:; | ||
| 3048 | CHECK_OBJECT( (PyObject *)tmp_class_creation_4__bases ); | ||
| 3049 | Py_DECREF( tmp_class_creation_4__bases ); | ||
| 3050 | tmp_class_creation_4__bases = NULL; | ||
| 3051 | |||
| 3052 | CHECK_OBJECT( (PyObject *)tmp_class_creation_4__class_decl_dict ); | ||
| 3053 | Py_DECREF( tmp_class_creation_4__class_decl_dict ); | ||
| 3054 | tmp_class_creation_4__class_decl_dict = NULL; | ||
| 3055 | |||
| 3056 | CHECK_OBJECT( (PyObject *)tmp_class_creation_4__metaclass ); | ||
| 3057 | Py_DECREF( tmp_class_creation_4__metaclass ); | ||
| 3058 | tmp_class_creation_4__metaclass = NULL; | ||
| 3059 | |||
| 3060 | CHECK_OBJECT( (PyObject *)tmp_class_creation_4__prepared ); | ||
| 3061 | Py_DECREF( tmp_class_creation_4__prepared ); | ||
| 3062 | tmp_class_creation_4__prepared = NULL; | ||
| 3063 | |||
| 3064 | |||
| 3065 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 3066 | #if 0 && 0 | ||
| 3067 | { | ||
| 3068 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_problem$exception, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 3069 | |||
| 3070 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 3071 | { | ||
| 3072 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 3073 | |||
| 3074 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 3075 | CHECK_OBJECT( path_importer_cache ); | ||
| 3076 | |||
| 3077 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 3078 | assert( res == 0 ); | ||
| 3079 | } | ||
| 3080 | } | ||
| 3081 | #endif | ||
| 3082 | #endif | ||
| 3083 | |||
| 3084 | return MOD_RETURN_VALUE( module_problem$exception ); | ||
| 3085 | module_exception_exit: | ||
| 3086 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 3087 | return MOD_RETURN_VALUE( NULL ); | ||
| 3088 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.problem.exception.o deleted (index fe3f45f..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.problem.o deleted (index 162c85b..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.problem.proxies.c is too big (16588 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.problem.proxies.o deleted (index d73d866..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.problem.tools.c deleted (index 04478a9..0000000) | |||
| 1 | /* Generated code for Python module 'problem.tools' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_problem$tools" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_problem$tools; | ||
| 31 | PyDictObject *moduledict_problem$tools; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | static PyObject *const_str_digest_e9480640b8997841e4b2ee49a5790308; | ||
| 35 | extern PyObject *const_str_plain_problemify; | ||
| 36 | extern PyObject *const_str_plain_Unknown; | ||
| 37 | extern PyObject *const_str_plain___spec__; | ||
| 38 | extern PyObject *const_str_plain_typ; | ||
| 39 | static PyObject *const_str_plain_values; | ||
| 40 | extern PyObject *const_str_plain_zip; | ||
| 41 | extern PyObject *const_str_plain___file__; | ||
| 42 | static PyObject *const_str_digest_dc59ccedcb8e86646f0eb79b95ebaa0a; | ||
| 43 | extern PyObject *const_int_0; | ||
| 44 | extern PyObject *const_str_plain__proxy; | ||
| 45 | extern PyObject *const_str_plain__probdir; | ||
| 46 | extern PyObject *const_str_plain_problem; | ||
| 47 | extern PyObject *const_str_plain_PROBLEM_TYPES; | ||
| 48 | static PyObject *const_str_plain_class_name; | ||
| 49 | extern PyObject *const_str_plain__persisted; | ||
| 50 | extern PyObject *const_str_plain_origin; | ||
| 51 | extern PyObject *const_str_plain_keys; | ||
| 52 | extern PyObject *const_str_plain_get_item; | ||
| 53 | extern PyObject *const_tuple_empty; | ||
| 54 | extern PyObject *const_str_plain_prob; | ||
| 55 | extern PyObject *const_str_plain_has_location; | ||
| 56 | static PyObject *const_str_plain_capitalize; | ||
| 57 | static PyObject *const_str_plain_probdir; | ||
| 58 | static PyObject *const_str_digest_499979b635b7c845abd599857a0e57d4; | ||
| 59 | extern PyObject *const_str_plain_type; | ||
| 60 | static PyObject *const_tuple_d1d8fb94505c5290365af41c2389814a_tuple; | ||
| 61 | extern PyObject *const_str_plain_proxy; | ||
| 62 | extern PyObject *const_str_plain___doc__; | ||
| 63 | extern PyObject *const_str_plain___cached__; | ||
| 64 | extern PyObject *const_str_plain_reason; | ||
| 65 | extern PyObject *const_str_plain_lower; | ||
| 66 | static PyObject *const_str_plain_by_typ; | ||
| 67 | static PyObject *module_filename_obj; | ||
| 68 | |||
| 69 | /* Indicator if this modules private constants were created yet. */ | ||
| 70 | static bool constants_created = false; | ||
| 71 | |||
| 72 | /* Function to create module private constants. */ | ||
| 73 | static void createModuleConstants( void ) | ||
| 74 | { | ||
| 75 | const_str_digest_e9480640b8997841e4b2ee49a5790308 = UNSTREAM_STRING_ASCII( &constant_bin[ 59477 ], 13, 0 ); | ||
| 76 | const_str_plain_values = UNSTREAM_STRING_ASCII( &constant_bin[ 36974 ], 6, 1 ); | ||
| 77 | const_str_digest_dc59ccedcb8e86646f0eb79b95ebaa0a = UNSTREAM_STRING_ASCII( &constant_bin[ 59490 ], 16, 0 ); | ||
| 78 | const_str_plain_class_name = UNSTREAM_STRING_ASCII( &constant_bin[ 59506 ], 10, 1 ); | ||
| 79 | const_str_plain_capitalize = UNSTREAM_STRING_ASCII( &constant_bin[ 59516 ], 10, 1 ); | ||
| 80 | const_str_plain_probdir = UNSTREAM_STRING_ASCII( &constant_bin[ 59526 ], 7, 1 ); | ||
| 81 | const_str_digest_499979b635b7c845abd599857a0e57d4 = UNSTREAM_STRING_ASCII( &constant_bin[ 59533 ], 22, 0 ); | ||
| 82 | const_tuple_d1d8fb94505c5290365af41c2389814a_tuple = PyTuple_New( 7 ); | ||
| 83 | PyTuple_SET_ITEM( const_tuple_d1d8fb94505c5290365af41c2389814a_tuple, 0, const_str_plain_probdir ); Py_INCREF( const_str_plain_probdir ); | ||
| 84 | PyTuple_SET_ITEM( const_tuple_d1d8fb94505c5290365af41c2389814a_tuple, 1, const_str_plain_proxy ); Py_INCREF( const_str_plain_proxy ); | ||
| 85 | const_str_plain_by_typ = UNSTREAM_STRING_ASCII( &constant_bin[ 59555 ], 6, 1 ); | ||
| 86 | PyTuple_SET_ITEM( const_tuple_d1d8fb94505c5290365af41c2389814a_tuple, 2, const_str_plain_by_typ ); Py_INCREF( const_str_plain_by_typ ); | ||
| 87 | PyTuple_SET_ITEM( const_tuple_d1d8fb94505c5290365af41c2389814a_tuple, 3, const_str_plain_typ ); Py_INCREF( const_str_plain_typ ); | ||
| 88 | PyTuple_SET_ITEM( const_tuple_d1d8fb94505c5290365af41c2389814a_tuple, 4, const_str_plain_reason ); Py_INCREF( const_str_plain_reason ); | ||
| 89 | PyTuple_SET_ITEM( const_tuple_d1d8fb94505c5290365af41c2389814a_tuple, 5, const_str_plain_class_name ); Py_INCREF( const_str_plain_class_name ); | ||
| 90 | PyTuple_SET_ITEM( const_tuple_d1d8fb94505c5290365af41c2389814a_tuple, 6, const_str_plain_prob ); Py_INCREF( const_str_plain_prob ); | ||
| 91 | |||
| 92 | constants_created = true; | ||
| 93 | } | ||
| 94 | |||
| 95 | /* Function to verify module private constants for non-corruption. */ | ||
| 96 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 97 | void checkModuleConstants_problem$tools( void ) | ||
| 98 | { | ||
| 99 | // The module may not have been used at all, then ignore this. | ||
| 100 | if (constants_created == false) return; | ||
| 101 | |||
| 102 | |||
| 103 | } | ||
| 104 | #endif | ||
| 105 | |||
| 106 | // The module code objects. | ||
| 107 | static PyCodeObject *codeobj_a4a0a7f025d399266b1fa6b2e02694c9; | ||
| 108 | static PyCodeObject *codeobj_2fbe876a264adae43b46ac322742b500; | ||
| 109 | |||
| 110 | static void createModuleCodeObjects(void) | ||
| 111 | { | ||
| 112 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_dc59ccedcb8e86646f0eb79b95ebaa0a ); | ||
| 113 | codeobj_a4a0a7f025d399266b1fa6b2e02694c9 = MAKE_CODEOBJ( module_filename_obj, const_str_digest_499979b635b7c845abd599857a0e57d4, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 114 | codeobj_2fbe876a264adae43b46ac322742b500 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_problemify, 4, const_tuple_d1d8fb94505c5290365af41c2389814a_tuple, 2, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 115 | } | ||
| 116 | |||
| 117 | // The module function declarations. | ||
| 118 | static PyObject *MAKE_FUNCTION_problem$tools$$$function_1_problemify( ); | ||
| 119 | |||
| 120 | |||
| 121 | // The module function definitions. | ||
| 122 | static PyObject *impl_problem$tools$$$function_1_problemify( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 123 | { | ||
| 124 | // Preserve error status for checks | ||
| 125 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 126 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 127 | #endif | ||
| 128 | |||
| 129 | // Local variable declarations. | ||
| 130 | PyObject *par_probdir = python_pars[ 0 ]; | ||
| 131 | PyObject *par_proxy = python_pars[ 1 ]; | ||
| 132 | PyObject *var_by_typ = NULL; | ||
| 133 | PyObject *var_typ = NULL; | ||
| 134 | PyObject *var_reason = NULL; | ||
| 135 | PyObject *var_class_name = NULL; | ||
| 136 | PyObject *var_prob = NULL; | ||
| 137 | struct Nuitka_FrameObject *frame_2fbe876a264adae43b46ac322742b500; | ||
| 138 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 139 | PyObject *exception_type = NULL; | ||
| 140 | PyObject *exception_value = NULL; | ||
| 141 | PyTracebackObject *exception_tb = NULL; | ||
| 142 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 143 | int tmp_res; | ||
| 144 | bool tmp_result; | ||
| 145 | static struct Nuitka_FrameObject *cache_frame_2fbe876a264adae43b46ac322742b500 = NULL; | ||
| 146 | PyObject *tmp_return_value = NULL; | ||
| 147 | PyObject *exception_keeper_type_1; | ||
| 148 | PyObject *exception_keeper_value_1; | ||
| 149 | PyTracebackObject *exception_keeper_tb_1; | ||
| 150 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 151 | |||
| 152 | // Actual function body. | ||
| 153 | // Tried code: | ||
| 154 | MAKE_OR_REUSE_FRAME( cache_frame_2fbe876a264adae43b46ac322742b500, codeobj_2fbe876a264adae43b46ac322742b500, module_problem$tools, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 155 | frame_2fbe876a264adae43b46ac322742b500 = cache_frame_2fbe876a264adae43b46ac322742b500; | ||
| 156 | |||
| 157 | // Push the new frame as the currently active one. | ||
| 158 | pushFrameStack( frame_2fbe876a264adae43b46ac322742b500 ); | ||
| 159 | |||
| 160 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 161 | assert( Py_REFCNT( frame_2fbe876a264adae43b46ac322742b500 ) == 2 ); // Frame stack | ||
| 162 | |||
| 163 | // Framed code: | ||
| 164 | { | ||
| 165 | PyObject *tmp_assign_source_1; | ||
| 166 | PyObject *tmp_dict_seq_1; | ||
| 167 | PyObject *tmp_called_name_1; | ||
| 168 | PyObject *tmp_args_element_name_1; | ||
| 169 | PyObject *tmp_called_instance_1; | ||
| 170 | PyObject *tmp_source_name_1; | ||
| 171 | PyObject *tmp_mvar_value_1; | ||
| 172 | PyObject *tmp_args_element_name_2; | ||
| 173 | PyObject *tmp_called_instance_2; | ||
| 174 | PyObject *tmp_source_name_2; | ||
| 175 | PyObject *tmp_mvar_value_2; | ||
| 176 | tmp_called_name_1 = (PyObject *)&PyZip_Type; | ||
| 177 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain_problem ); | ||
| 178 | |||
| 179 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 180 | { | ||
| 181 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_problem ); | ||
| 182 | } | ||
| 183 | |||
| 184 | if ( tmp_mvar_value_1 == NULL ) | ||
| 185 | { | ||
| 186 | |||
| 187 | exception_type = PyExc_NameError; | ||
| 188 | Py_INCREF( exception_type ); | ||
| 189 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "problem" ); | ||
| 190 | exception_tb = NULL; | ||
| 191 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 192 | CHAIN_EXCEPTION( exception_value ); | ||
| 193 | |||
| 194 | exception_lineno = 5; | ||
| 195 | type_description_1 = "ooooooo"; | ||
| 196 | goto frame_exception_exit_1; | ||
| 197 | } | ||
| 198 | |||
| 199 | tmp_source_name_1 = tmp_mvar_value_1; | ||
| 200 | tmp_called_instance_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_PROBLEM_TYPES ); | ||
| 201 | if ( tmp_called_instance_1 == NULL ) | ||
| 202 | { | ||
| 203 | assert( ERROR_OCCURRED() ); | ||
| 204 | |||
| 205 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 206 | |||
| 207 | |||
| 208 | exception_lineno = 5; | ||
| 209 | type_description_1 = "ooooooo"; | ||
| 210 | goto frame_exception_exit_1; | ||
| 211 | } | ||
| 212 | frame_2fbe876a264adae43b46ac322742b500->m_frame.f_lineno = 5; | ||
| 213 | tmp_args_element_name_1 = CALL_METHOD_NO_ARGS( tmp_called_instance_1, const_str_plain_values ); | ||
| 214 | Py_DECREF( tmp_called_instance_1 ); | ||
| 215 | if ( tmp_args_element_name_1 == NULL ) | ||
| 216 | { | ||
| 217 | assert( ERROR_OCCURRED() ); | ||
| 218 | |||
| 219 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 220 | |||
| 221 | |||
| 222 | exception_lineno = 5; | ||
| 223 | type_description_1 = "ooooooo"; | ||
| 224 | goto frame_exception_exit_1; | ||
| 225 | } | ||
| 226 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain_problem ); | ||
| 227 | |||
| 228 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 229 | { | ||
| 230 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_problem ); | ||
| 231 | } | ||
| 232 | |||
| 233 | if ( tmp_mvar_value_2 == NULL ) | ||
| 234 | { | ||
| 235 | Py_DECREF( tmp_args_element_name_1 ); | ||
| 236 | exception_type = PyExc_NameError; | ||
| 237 | Py_INCREF( exception_type ); | ||
| 238 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "problem" ); | ||
| 239 | exception_tb = NULL; | ||
| 240 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 241 | CHAIN_EXCEPTION( exception_value ); | ||
| 242 | |||
| 243 | exception_lineno = 6; | ||
| 244 | type_description_1 = "ooooooo"; | ||
| 245 | goto frame_exception_exit_1; | ||
| 246 | } | ||
| 247 | |||
| 248 | tmp_source_name_2 = tmp_mvar_value_2; | ||
| 249 | tmp_called_instance_2 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_PROBLEM_TYPES ); | ||
| 250 | if ( tmp_called_instance_2 == NULL ) | ||
| 251 | { | ||
| 252 | assert( ERROR_OCCURRED() ); | ||
| 253 | |||
| 254 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 255 | Py_DECREF( tmp_args_element_name_1 ); | ||
| 256 | |||
| 257 | exception_lineno = 6; | ||
| 258 | type_description_1 = "ooooooo"; | ||
| 259 | goto frame_exception_exit_1; | ||
| 260 | } | ||
| 261 | frame_2fbe876a264adae43b46ac322742b500->m_frame.f_lineno = 6; | ||
| 262 | tmp_args_element_name_2 = CALL_METHOD_NO_ARGS( tmp_called_instance_2, const_str_plain_keys ); | ||
| 263 | Py_DECREF( tmp_called_instance_2 ); | ||
| 264 | if ( tmp_args_element_name_2 == NULL ) | ||
| 265 | { | ||
| 266 | assert( ERROR_OCCURRED() ); | ||
| 267 | |||
| 268 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 269 | Py_DECREF( tmp_args_element_name_1 ); | ||
| 270 | |||
| 271 | exception_lineno = 6; | ||
| 272 | type_description_1 = "ooooooo"; | ||
| 273 | goto frame_exception_exit_1; | ||
| 274 | } | ||
| 275 | frame_2fbe876a264adae43b46ac322742b500->m_frame.f_lineno = 5; | ||
| 276 | { | ||
| 277 | PyObject *call_args[] = { tmp_args_element_name_1, tmp_args_element_name_2 }; | ||
| 278 | tmp_dict_seq_1 = CALL_FUNCTION_WITH_ARGS2( tmp_called_name_1, call_args ); | ||
| 279 | } | ||
| 280 | |||
| 281 | Py_DECREF( tmp_args_element_name_1 ); | ||
| 282 | Py_DECREF( tmp_args_element_name_2 ); | ||
| 283 | if ( tmp_dict_seq_1 == NULL ) | ||
| 284 | { | ||
| 285 | assert( ERROR_OCCURRED() ); | ||
| 286 | |||
| 287 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 288 | |||
| 289 | |||
| 290 | exception_lineno = 5; | ||
| 291 | type_description_1 = "ooooooo"; | ||
| 292 | goto frame_exception_exit_1; | ||
| 293 | } | ||
| 294 | tmp_assign_source_1 = TO_DICT( tmp_dict_seq_1, NULL ); | ||
| 295 | Py_DECREF( tmp_dict_seq_1 ); | ||
| 296 | if ( tmp_assign_source_1 == NULL ) | ||
| 297 | { | ||
| 298 | assert( ERROR_OCCURRED() ); | ||
| 299 | |||
| 300 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 301 | |||
| 302 | |||
| 303 | exception_lineno = 5; | ||
| 304 | type_description_1 = "ooooooo"; | ||
| 305 | goto frame_exception_exit_1; | ||
| 306 | } | ||
| 307 | assert( var_by_typ == NULL ); | ||
| 308 | var_by_typ = tmp_assign_source_1; | ||
| 309 | } | ||
| 310 | { | ||
| 311 | PyObject *tmp_assign_source_2; | ||
| 312 | PyObject *tmp_called_instance_3; | ||
| 313 | PyObject *tmp_args_element_name_3; | ||
| 314 | PyObject *tmp_args_element_name_4; | ||
| 315 | CHECK_OBJECT( par_proxy ); | ||
| 316 | tmp_called_instance_3 = par_proxy; | ||
| 317 | CHECK_OBJECT( par_probdir ); | ||
| 318 | tmp_args_element_name_3 = par_probdir; | ||
| 319 | tmp_args_element_name_4 = const_str_plain_type; | ||
| 320 | frame_2fbe876a264adae43b46ac322742b500->m_frame.f_lineno = 8; | ||
| 321 | { | ||
| 322 | PyObject *call_args[] = { tmp_args_element_name_3, tmp_args_element_name_4 }; | ||
| 323 | tmp_assign_source_2 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_3, const_str_plain_get_item, call_args ); | ||
| 324 | } | ||
| 325 | |||
| 326 | if ( tmp_assign_source_2 == NULL ) | ||
| 327 | { | ||
| 328 | assert( ERROR_OCCURRED() ); | ||
| 329 | |||
| 330 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 331 | |||
| 332 | |||
| 333 | exception_lineno = 8; | ||
| 334 | type_description_1 = "ooooooo"; | ||
| 335 | goto frame_exception_exit_1; | ||
| 336 | } | ||
| 337 | assert( var_typ == NULL ); | ||
| 338 | var_typ = tmp_assign_source_2; | ||
| 339 | } | ||
| 340 | { | ||
| 341 | PyObject *tmp_assign_source_3; | ||
| 342 | PyObject *tmp_called_instance_4; | ||
| 343 | PyObject *tmp_args_element_name_5; | ||
| 344 | PyObject *tmp_args_element_name_6; | ||
| 345 | CHECK_OBJECT( par_proxy ); | ||
| 346 | tmp_called_instance_4 = par_proxy; | ||
| 347 | CHECK_OBJECT( par_probdir ); | ||
| 348 | tmp_args_element_name_5 = par_probdir; | ||
| 349 | tmp_args_element_name_6 = const_str_plain_reason; | ||
| 350 | frame_2fbe876a264adae43b46ac322742b500->m_frame.f_lineno = 9; | ||
| 351 | { | ||
| 352 | PyObject *call_args[] = { tmp_args_element_name_5, tmp_args_element_name_6 }; | ||
| 353 | tmp_assign_source_3 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_4, const_str_plain_get_item, call_args ); | ||
| 354 | } | ||
| 355 | |||
| 356 | if ( tmp_assign_source_3 == NULL ) | ||
| 357 | { | ||
| 358 | assert( ERROR_OCCURRED() ); | ||
| 359 | |||
| 360 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 361 | |||
| 362 | |||
| 363 | exception_lineno = 9; | ||
| 364 | type_description_1 = "ooooooo"; | ||
| 365 | goto frame_exception_exit_1; | ||
| 366 | } | ||
| 367 | assert( var_reason == NULL ); | ||
| 368 | var_reason = tmp_assign_source_3; | ||
| 369 | } | ||
| 370 | { | ||
| 371 | nuitka_bool tmp_condition_result_1; | ||
| 372 | PyObject *tmp_key_name_1; | ||
| 373 | PyObject *tmp_dict_name_1; | ||
| 374 | CHECK_OBJECT( var_typ ); | ||
| 375 | tmp_key_name_1 = var_typ; | ||
| 376 | CHECK_OBJECT( var_by_typ ); | ||
| 377 | tmp_dict_name_1 = var_by_typ; | ||
| 378 | tmp_res = PyDict_Contains( tmp_dict_name_1, tmp_key_name_1 ); | ||
| 379 | if ( tmp_res == -1 ) | ||
| 380 | { | ||
| 381 | assert( ERROR_OCCURRED() ); | ||
| 382 | |||
| 383 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 384 | |||
| 385 | |||
| 386 | exception_lineno = 11; | ||
| 387 | type_description_1 = "ooooooo"; | ||
| 388 | goto frame_exception_exit_1; | ||
| 389 | } | ||
| 390 | tmp_condition_result_1 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 391 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 392 | { | ||
| 393 | goto branch_yes_1; | ||
| 394 | } | ||
| 395 | else | ||
| 396 | { | ||
| 397 | goto branch_no_1; | ||
| 398 | } | ||
| 399 | branch_yes_1:; | ||
| 400 | { | ||
| 401 | PyObject *tmp_assign_source_4; | ||
| 402 | tmp_assign_source_4 = const_str_plain_Unknown; | ||
| 403 | assert( var_class_name == NULL ); | ||
| 404 | Py_INCREF( tmp_assign_source_4 ); | ||
| 405 | var_class_name = tmp_assign_source_4; | ||
| 406 | } | ||
| 407 | goto branch_end_1; | ||
| 408 | branch_no_1:; | ||
| 409 | { | ||
| 410 | PyObject *tmp_assign_source_5; | ||
| 411 | PyObject *tmp_called_instance_5; | ||
| 412 | PyObject *tmp_called_instance_6; | ||
| 413 | PyObject *tmp_dict_name_2; | ||
| 414 | PyObject *tmp_key_name_2; | ||
| 415 | CHECK_OBJECT( var_by_typ ); | ||
| 416 | tmp_dict_name_2 = var_by_typ; | ||
| 417 | CHECK_OBJECT( var_typ ); | ||
| 418 | tmp_key_name_2 = var_typ; | ||
| 419 | tmp_called_instance_6 = DICT_GET_ITEM( tmp_dict_name_2, tmp_key_name_2 ); | ||
| 420 | if ( tmp_called_instance_6 == NULL ) | ||
| 421 | { | ||
| 422 | assert( ERROR_OCCURRED() ); | ||
| 423 | |||
| 424 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 425 | |||
| 426 | |||
| 427 | exception_lineno = 14; | ||
| 428 | type_description_1 = "ooooooo"; | ||
| 429 | goto frame_exception_exit_1; | ||
| 430 | } | ||
| 431 | frame_2fbe876a264adae43b46ac322742b500->m_frame.f_lineno = 14; | ||
| 432 | tmp_called_instance_5 = CALL_METHOD_NO_ARGS( tmp_called_instance_6, const_str_plain_lower ); | ||
| 433 | Py_DECREF( tmp_called_instance_6 ); | ||
| 434 | if ( tmp_called_instance_5 == NULL ) | ||
| 435 | { | ||
| 436 | assert( ERROR_OCCURRED() ); | ||
| 437 | |||
| 438 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 439 | |||
| 440 | |||
| 441 | exception_lineno = 14; | ||
| 442 | type_description_1 = "ooooooo"; | ||
| 443 | goto frame_exception_exit_1; | ||
| 444 | } | ||
| 445 | frame_2fbe876a264adae43b46ac322742b500->m_frame.f_lineno = 14; | ||
| 446 | tmp_assign_source_5 = CALL_METHOD_NO_ARGS( tmp_called_instance_5, const_str_plain_capitalize ); | ||
| 447 | Py_DECREF( tmp_called_instance_5 ); | ||
| 448 | if ( tmp_assign_source_5 == NULL ) | ||
| 449 | { | ||
| 450 | assert( ERROR_OCCURRED() ); | ||
| 451 | |||
| 452 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 453 | |||
| 454 | |||
| 455 | exception_lineno = 14; | ||
| 456 | type_description_1 = "ooooooo"; | ||
| 457 | goto frame_exception_exit_1; | ||
| 458 | } | ||
| 459 | assert( var_class_name == NULL ); | ||
| 460 | var_class_name = tmp_assign_source_5; | ||
| 461 | } | ||
| 462 | branch_end_1:; | ||
| 463 | } | ||
| 464 | { | ||
| 465 | PyObject *tmp_assign_source_6; | ||
| 466 | PyObject *tmp_called_name_2; | ||
| 467 | PyObject *tmp_getattr_target_1; | ||
| 468 | PyObject *tmp_mvar_value_3; | ||
| 469 | PyObject *tmp_getattr_attr_1; | ||
| 470 | PyObject *tmp_args_element_name_7; | ||
| 471 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain_problem ); | ||
| 472 | |||
| 473 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 474 | { | ||
| 475 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_problem ); | ||
| 476 | } | ||
| 477 | |||
| 478 | if ( tmp_mvar_value_3 == NULL ) | ||
| 479 | { | ||
| 480 | |||
| 481 | exception_type = PyExc_NameError; | ||
| 482 | Py_INCREF( exception_type ); | ||
| 483 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "problem" ); | ||
| 484 | exception_tb = NULL; | ||
| 485 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 486 | CHAIN_EXCEPTION( exception_value ); | ||
| 487 | |||
| 488 | exception_lineno = 16; | ||
| 489 | type_description_1 = "ooooooo"; | ||
| 490 | goto frame_exception_exit_1; | ||
| 491 | } | ||
| 492 | |||
| 493 | tmp_getattr_target_1 = tmp_mvar_value_3; | ||
| 494 | CHECK_OBJECT( var_class_name ); | ||
| 495 | tmp_getattr_attr_1 = var_class_name; | ||
| 496 | tmp_called_name_2 = BUILTIN_GETATTR( tmp_getattr_target_1, tmp_getattr_attr_1, NULL ); | ||
| 497 | if ( tmp_called_name_2 == NULL ) | ||
| 498 | { | ||
| 499 | assert( ERROR_OCCURRED() ); | ||
| 500 | |||
| 501 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 502 | |||
| 503 | |||
| 504 | exception_lineno = 16; | ||
| 505 | type_description_1 = "ooooooo"; | ||
| 506 | goto frame_exception_exit_1; | ||
| 507 | } | ||
| 508 | CHECK_OBJECT( var_reason ); | ||
| 509 | tmp_args_element_name_7 = var_reason; | ||
| 510 | frame_2fbe876a264adae43b46ac322742b500->m_frame.f_lineno = 16; | ||
| 511 | { | ||
| 512 | PyObject *call_args[] = { tmp_args_element_name_7 }; | ||
| 513 | tmp_assign_source_6 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_2, call_args ); | ||
| 514 | } | ||
| 515 | |||
| 516 | Py_DECREF( tmp_called_name_2 ); | ||
| 517 | if ( tmp_assign_source_6 == NULL ) | ||
| 518 | { | ||
| 519 | assert( ERROR_OCCURRED() ); | ||
| 520 | |||
| 521 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 522 | |||
| 523 | |||
| 524 | exception_lineno = 16; | ||
| 525 | type_description_1 = "ooooooo"; | ||
| 526 | goto frame_exception_exit_1; | ||
| 527 | } | ||
| 528 | assert( var_prob == NULL ); | ||
| 529 | var_prob = tmp_assign_source_6; | ||
| 530 | } | ||
| 531 | { | ||
| 532 | PyObject *tmp_assattr_name_1; | ||
| 533 | PyObject *tmp_assattr_target_1; | ||
| 534 | CHECK_OBJECT( par_probdir ); | ||
| 535 | tmp_assattr_name_1 = par_probdir; | ||
| 536 | CHECK_OBJECT( var_prob ); | ||
| 537 | tmp_assattr_target_1 = var_prob; | ||
| 538 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain__probdir, tmp_assattr_name_1 ); | ||
| 539 | if ( tmp_result == false ) | ||
| 540 | { | ||
| 541 | assert( ERROR_OCCURRED() ); | ||
| 542 | |||
| 543 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 544 | |||
| 545 | |||
| 546 | exception_lineno = 17; | ||
| 547 | type_description_1 = "ooooooo"; | ||
| 548 | goto frame_exception_exit_1; | ||
| 549 | } | ||
| 550 | } | ||
| 551 | { | ||
| 552 | PyObject *tmp_assattr_name_2; | ||
| 553 | PyObject *tmp_assattr_target_2; | ||
| 554 | tmp_assattr_name_2 = Py_True; | ||
| 555 | CHECK_OBJECT( var_prob ); | ||
| 556 | tmp_assattr_target_2 = var_prob; | ||
| 557 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain__persisted, tmp_assattr_name_2 ); | ||
| 558 | if ( tmp_result == false ) | ||
| 559 | { | ||
| 560 | assert( ERROR_OCCURRED() ); | ||
| 561 | |||
| 562 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 563 | |||
| 564 | |||
| 565 | exception_lineno = 18; | ||
| 566 | type_description_1 = "ooooooo"; | ||
| 567 | goto frame_exception_exit_1; | ||
| 568 | } | ||
| 569 | } | ||
| 570 | { | ||
| 571 | PyObject *tmp_assattr_name_3; | ||
| 572 | PyObject *tmp_assattr_target_3; | ||
| 573 | CHECK_OBJECT( par_proxy ); | ||
| 574 | tmp_assattr_name_3 = par_proxy; | ||
| 575 | CHECK_OBJECT( var_prob ); | ||
| 576 | tmp_assattr_target_3 = var_prob; | ||
| 577 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_3, const_str_plain__proxy, tmp_assattr_name_3 ); | ||
| 578 | if ( tmp_result == false ) | ||
| 579 | { | ||
| 580 | assert( ERROR_OCCURRED() ); | ||
| 581 | |||
| 582 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 583 | |||
| 584 | |||
| 585 | exception_lineno = 19; | ||
| 586 | type_description_1 = "ooooooo"; | ||
| 587 | goto frame_exception_exit_1; | ||
| 588 | } | ||
| 589 | } | ||
| 590 | |||
| 591 | #if 0 | ||
| 592 | RESTORE_FRAME_EXCEPTION( frame_2fbe876a264adae43b46ac322742b500 ); | ||
| 593 | #endif | ||
| 594 | |||
| 595 | // Put the previous frame back on top. | ||
| 596 | popFrameStack(); | ||
| 597 | |||
| 598 | goto frame_no_exception_1; | ||
| 599 | |||
| 600 | frame_exception_exit_1:; | ||
| 601 | |||
| 602 | #if 0 | ||
| 603 | RESTORE_FRAME_EXCEPTION( frame_2fbe876a264adae43b46ac322742b500 ); | ||
| 604 | #endif | ||
| 605 | |||
| 606 | if ( exception_tb == NULL ) | ||
| 607 | { | ||
| 608 | exception_tb = MAKE_TRACEBACK( frame_2fbe876a264adae43b46ac322742b500, exception_lineno ); | ||
| 609 | } | ||
| 610 | else if ( exception_tb->tb_frame != &frame_2fbe876a264adae43b46ac322742b500->m_frame ) | ||
| 611 | { | ||
| 612 | exception_tb = ADD_TRACEBACK( exception_tb, frame_2fbe876a264adae43b46ac322742b500, exception_lineno ); | ||
| 613 | } | ||
| 614 | |||
| 615 | // Attachs locals to frame if any. | ||
| 616 | Nuitka_Frame_AttachLocals( | ||
| 617 | (struct Nuitka_FrameObject *)frame_2fbe876a264adae43b46ac322742b500, | ||
| 618 | type_description_1, | ||
| 619 | par_probdir, | ||
| 620 | par_proxy, | ||
| 621 | var_by_typ, | ||
| 622 | var_typ, | ||
| 623 | var_reason, | ||
| 624 | var_class_name, | ||
| 625 | var_prob | ||
| 626 | ); | ||
| 627 | |||
| 628 | |||
| 629 | // Release cached frame. | ||
| 630 | if ( frame_2fbe876a264adae43b46ac322742b500 == cache_frame_2fbe876a264adae43b46ac322742b500 ) | ||
| 631 | { | ||
| 632 | Py_DECREF( frame_2fbe876a264adae43b46ac322742b500 ); | ||
| 633 | } | ||
| 634 | cache_frame_2fbe876a264adae43b46ac322742b500 = NULL; | ||
| 635 | |||
| 636 | assertFrameObject( frame_2fbe876a264adae43b46ac322742b500 ); | ||
| 637 | |||
| 638 | // Put the previous frame back on top. | ||
| 639 | popFrameStack(); | ||
| 640 | |||
| 641 | // Return the error. | ||
| 642 | goto try_except_handler_1; | ||
| 643 | |||
| 644 | frame_no_exception_1:; | ||
| 645 | CHECK_OBJECT( var_prob ); | ||
| 646 | tmp_return_value = var_prob; | ||
| 647 | Py_INCREF( tmp_return_value ); | ||
| 648 | goto try_return_handler_1; | ||
| 649 | // tried codes exits in all cases | ||
| 650 | NUITKA_CANNOT_GET_HERE( problem$tools$$$function_1_problemify ); | ||
| 651 | return NULL; | ||
| 652 | // Return handler code: | ||
| 653 | try_return_handler_1:; | ||
| 654 | CHECK_OBJECT( (PyObject *)par_probdir ); | ||
| 655 | Py_DECREF( par_probdir ); | ||
| 656 | par_probdir = NULL; | ||
| 657 | |||
| 658 | CHECK_OBJECT( (PyObject *)par_proxy ); | ||
| 659 | Py_DECREF( par_proxy ); | ||
| 660 | par_proxy = NULL; | ||
| 661 | |||
| 662 | CHECK_OBJECT( (PyObject *)var_by_typ ); | ||
| 663 | Py_DECREF( var_by_typ ); | ||
| 664 | var_by_typ = NULL; | ||
| 665 | |||
| 666 | CHECK_OBJECT( (PyObject *)var_typ ); | ||
| 667 | Py_DECREF( var_typ ); | ||
| 668 | var_typ = NULL; | ||
| 669 | |||
| 670 | CHECK_OBJECT( (PyObject *)var_reason ); | ||
| 671 | Py_DECREF( var_reason ); | ||
| 672 | var_reason = NULL; | ||
| 673 | |||
| 674 | CHECK_OBJECT( (PyObject *)var_class_name ); | ||
| 675 | Py_DECREF( var_class_name ); | ||
| 676 | var_class_name = NULL; | ||
| 677 | |||
| 678 | CHECK_OBJECT( (PyObject *)var_prob ); | ||
| 679 | Py_DECREF( var_prob ); | ||
| 680 | var_prob = NULL; | ||
| 681 | |||
| 682 | goto function_return_exit; | ||
| 683 | // Exception handler code: | ||
| 684 | try_except_handler_1:; | ||
| 685 | exception_keeper_type_1 = exception_type; | ||
| 686 | exception_keeper_value_1 = exception_value; | ||
| 687 | exception_keeper_tb_1 = exception_tb; | ||
| 688 | exception_keeper_lineno_1 = exception_lineno; | ||
| 689 | exception_type = NULL; | ||
| 690 | exception_value = NULL; | ||
| 691 | exception_tb = NULL; | ||
| 692 | exception_lineno = 0; | ||
| 693 | |||
| 694 | CHECK_OBJECT( (PyObject *)par_probdir ); | ||
| 695 | Py_DECREF( par_probdir ); | ||
| 696 | par_probdir = NULL; | ||
| 697 | |||
| 698 | CHECK_OBJECT( (PyObject *)par_proxy ); | ||
| 699 | Py_DECREF( par_proxy ); | ||
| 700 | par_proxy = NULL; | ||
| 701 | |||
| 702 | Py_XDECREF( var_by_typ ); | ||
| 703 | var_by_typ = NULL; | ||
| 704 | |||
| 705 | Py_XDECREF( var_typ ); | ||
| 706 | var_typ = NULL; | ||
| 707 | |||
| 708 | Py_XDECREF( var_reason ); | ||
| 709 | var_reason = NULL; | ||
| 710 | |||
| 711 | Py_XDECREF( var_class_name ); | ||
| 712 | var_class_name = NULL; | ||
| 713 | |||
| 714 | Py_XDECREF( var_prob ); | ||
| 715 | var_prob = NULL; | ||
| 716 | |||
| 717 | // Re-raise. | ||
| 718 | exception_type = exception_keeper_type_1; | ||
| 719 | exception_value = exception_keeper_value_1; | ||
| 720 | exception_tb = exception_keeper_tb_1; | ||
| 721 | exception_lineno = exception_keeper_lineno_1; | ||
| 722 | |||
| 723 | goto function_exception_exit; | ||
| 724 | // End of try: | ||
| 725 | |||
| 726 | // Return statement must have exited already. | ||
| 727 | NUITKA_CANNOT_GET_HERE( problem$tools$$$function_1_problemify ); | ||
| 728 | return NULL; | ||
| 729 | |||
| 730 | function_exception_exit: | ||
| 731 | assert( exception_type ); | ||
| 732 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 733 | |||
| 734 | return NULL; | ||
| 735 | |||
| 736 | function_return_exit: | ||
| 737 | // Function cleanup code if any. | ||
| 738 | |||
| 739 | |||
| 740 | // Actual function exit with return value, making sure we did not make | ||
| 741 | // the error status worse despite non-NULL return. | ||
| 742 | CHECK_OBJECT( tmp_return_value ); | ||
| 743 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 744 | return tmp_return_value; | ||
| 745 | } | ||
| 746 | |||
| 747 | |||
| 748 | |||
| 749 | static PyObject *MAKE_FUNCTION_problem$tools$$$function_1_problemify( ) | ||
| 750 | { | ||
| 751 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 752 | impl_problem$tools$$$function_1_problemify, | ||
| 753 | const_str_plain_problemify, | ||
| 754 | #if PYTHON_VERSION >= 300 | ||
| 755 | NULL, | ||
| 756 | #endif | ||
| 757 | codeobj_2fbe876a264adae43b46ac322742b500, | ||
| 758 | NULL, | ||
| 759 | #if PYTHON_VERSION >= 300 | ||
| 760 | NULL, | ||
| 761 | NULL, | ||
| 762 | #endif | ||
| 763 | module_problem$tools, | ||
| 764 | NULL, | ||
| 765 | 0 | ||
| 766 | ); | ||
| 767 | |||
| 768 | return (PyObject *)result; | ||
| 769 | } | ||
| 770 | |||
| 771 | |||
| 772 | |||
| 773 | #if PYTHON_VERSION >= 300 | ||
| 774 | static struct PyModuleDef mdef_problem$tools = | ||
| 775 | { | ||
| 776 | PyModuleDef_HEAD_INIT, | ||
| 777 | "problem.tools", | ||
| 778 | NULL, /* m_doc */ | ||
| 779 | -1, /* m_size */ | ||
| 780 | NULL, /* m_methods */ | ||
| 781 | NULL, /* m_reload */ | ||
| 782 | NULL, /* m_traverse */ | ||
| 783 | NULL, /* m_clear */ | ||
| 784 | NULL, /* m_free */ | ||
| 785 | }; | ||
| 786 | #endif | ||
| 787 | |||
| 788 | extern PyObject *const_str_plain___compiled__; | ||
| 789 | |||
| 790 | extern PyObject *const_str_plain___package__; | ||
| 791 | |||
| 792 | #if PYTHON_VERSION >= 300 | ||
| 793 | extern PyObject *const_str_dot; | ||
| 794 | extern PyObject *const_str_plain___loader__; | ||
| 795 | #endif | ||
| 796 | |||
| 797 | #if PYTHON_VERSION >= 340 | ||
| 798 | extern PyObject *const_str_plain___spec__; | ||
| 799 | extern PyObject *const_str_plain__initializing; | ||
| 800 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 801 | #endif | ||
| 802 | |||
| 803 | extern void _initCompiledCellType(); | ||
| 804 | extern void _initCompiledGeneratorType(); | ||
| 805 | extern void _initCompiledFunctionType(); | ||
| 806 | extern void _initCompiledMethodType(); | ||
| 807 | extern void _initCompiledFrameType(); | ||
| 808 | #if PYTHON_VERSION >= 350 | ||
| 809 | extern void _initCompiledCoroutineTypes(); | ||
| 810 | #endif | ||
| 811 | #if PYTHON_VERSION >= 360 | ||
| 812 | extern void _initCompiledAsyncgenTypes(); | ||
| 813 | #endif | ||
| 814 | |||
| 815 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 816 | |||
| 817 | // The exported interface to CPython. On import of the module, this function | ||
| 818 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 819 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 820 | |||
| 821 | MOD_INIT_DECL( problem$tools ) | ||
| 822 | { | ||
| 823 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 824 | static bool _init_done = false; | ||
| 825 | |||
| 826 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 827 | if ( _init_done ) | ||
| 828 | { | ||
| 829 | return MOD_RETURN_VALUE( module_problem$tools ); | ||
| 830 | } | ||
| 831 | else | ||
| 832 | { | ||
| 833 | _init_done = true; | ||
| 834 | } | ||
| 835 | #endif | ||
| 836 | |||
| 837 | #ifdef _NUITKA_MODULE | ||
| 838 | // In case of a stand alone extension module, need to call initialization | ||
| 839 | // the init here because that's the first and only time we are going to get | ||
| 840 | // called here. | ||
| 841 | |||
| 842 | // Initialize the constant values used. | ||
| 843 | _initBuiltinModule(); | ||
| 844 | createGlobalConstants(); | ||
| 845 | |||
| 846 | /* Initialize the compiled types of Nuitka. */ | ||
| 847 | _initCompiledCellType(); | ||
| 848 | _initCompiledGeneratorType(); | ||
| 849 | _initCompiledFunctionType(); | ||
| 850 | _initCompiledMethodType(); | ||
| 851 | _initCompiledFrameType(); | ||
| 852 | #if PYTHON_VERSION >= 350 | ||
| 853 | _initCompiledCoroutineTypes(); | ||
| 854 | #endif | ||
| 855 | #if PYTHON_VERSION >= 360 | ||
| 856 | _initCompiledAsyncgenTypes(); | ||
| 857 | #endif | ||
| 858 | |||
| 859 | #if PYTHON_VERSION < 300 | ||
| 860 | _initSlotCompare(); | ||
| 861 | #endif | ||
| 862 | #if PYTHON_VERSION >= 270 | ||
| 863 | _initSlotIternext(); | ||
| 864 | #endif | ||
| 865 | |||
| 866 | patchBuiltinModule(); | ||
| 867 | patchTypeComparison(); | ||
| 868 | |||
| 869 | // Enable meta path based loader if not already done. | ||
| 870 | #ifdef _NUITKA_TRACE | ||
| 871 | puts("problem.tools: Calling setupMetaPathBasedLoader()."); | ||
| 872 | #endif | ||
| 873 | setupMetaPathBasedLoader(); | ||
| 874 | |||
| 875 | #if PYTHON_VERSION >= 300 | ||
| 876 | patchInspectModule(); | ||
| 877 | #endif | ||
| 878 | |||
| 879 | #endif | ||
| 880 | |||
| 881 | /* The constants only used by this module are created now. */ | ||
| 882 | #ifdef _NUITKA_TRACE | ||
| 883 | puts("problem.tools: Calling createModuleConstants()."); | ||
| 884 | #endif | ||
| 885 | createModuleConstants(); | ||
| 886 | |||
| 887 | /* The code objects used by this module are created now. */ | ||
| 888 | #ifdef _NUITKA_TRACE | ||
| 889 | puts("problem.tools: Calling createModuleCodeObjects()."); | ||
| 890 | #endif | ||
| 891 | createModuleCodeObjects(); | ||
| 892 | |||
| 893 | // puts( "in initproblem$tools" ); | ||
| 894 | |||
| 895 | // Create the module object first. There are no methods initially, all are | ||
| 896 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 897 | // set at this time, as it could not contain NUL characters this way, they | ||
| 898 | // are instead set in early module code. No "self" for modules, we have no | ||
| 899 | // use for it. | ||
| 900 | #if PYTHON_VERSION < 300 | ||
| 901 | module_problem$tools = Py_InitModule4( | ||
| 902 | "problem.tools", // Module Name | ||
| 903 | NULL, // No methods initially, all are added | ||
| 904 | // dynamically in actual module code only. | ||
| 905 | NULL, // No "__doc__" is initially set, as it could | ||
| 906 | // not contain NUL this way, added early in | ||
| 907 | // actual code. | ||
| 908 | NULL, // No self for modules, we don't use it. | ||
| 909 | PYTHON_API_VERSION | ||
| 910 | ); | ||
| 911 | #else | ||
| 912 | |||
| 913 | module_problem$tools = PyModule_Create( &mdef_problem$tools ); | ||
| 914 | #endif | ||
| 915 | |||
| 916 | moduledict_problem$tools = MODULE_DICT( module_problem$tools ); | ||
| 917 | |||
| 918 | // Set __compiled__ to what it we know. | ||
| 919 | UPDATE_STRING_DICT1( | ||
| 920 | moduledict_problem$tools, | ||
| 921 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 922 | Nuitka_dunder_compiled_value | ||
| 923 | ); | ||
| 924 | |||
| 925 | // Update "__package__" value to what it ought to be. | ||
| 926 | { | ||
| 927 | #if 0 | ||
| 928 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 929 | |||
| 930 | UPDATE_STRING_DICT1( | ||
| 931 | moduledict_problem$tools, | ||
| 932 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 933 | module_name | ||
| 934 | ); | ||
| 935 | #else | ||
| 936 | |||
| 937 | #if PYTHON_VERSION < 300 | ||
| 938 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 939 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 940 | |||
| 941 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 942 | |||
| 943 | if ( last_dot != NULL ) | ||
| 944 | { | ||
| 945 | UPDATE_STRING_DICT1( | ||
| 946 | moduledict_problem$tools, | ||
| 947 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 948 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 949 | ); | ||
| 950 | } | ||
| 951 | #else | ||
| 952 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 953 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 954 | |||
| 955 | if ( dot_index != -1 ) | ||
| 956 | { | ||
| 957 | UPDATE_STRING_DICT1( | ||
| 958 | moduledict_problem$tools, | ||
| 959 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 960 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 961 | ); | ||
| 962 | } | ||
| 963 | #endif | ||
| 964 | #endif | ||
| 965 | } | ||
| 966 | |||
| 967 | CHECK_OBJECT( module_problem$tools ); | ||
| 968 | |||
| 969 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 970 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 971 | #if PYTHON_VERSION >= 300 | ||
| 972 | { | ||
| 973 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_e9480640b8997841e4b2ee49a5790308, module_problem$tools ); | ||
| 974 | |||
| 975 | assert( r != -1 ); | ||
| 976 | } | ||
| 977 | #endif | ||
| 978 | |||
| 979 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 980 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 981 | // before the frame object is allocated, or else it may fail. | ||
| 982 | |||
| 983 | if ( GET_STRING_DICT_VALUE( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 984 | { | ||
| 985 | PyObject *value = (PyObject *)builtin_module; | ||
| 986 | |||
| 987 | // Check if main module, not a dict then but the module itself. | ||
| 988 | #if !defined(_NUITKA_EXE) || !0 | ||
| 989 | value = PyModule_GetDict( value ); | ||
| 990 | #endif | ||
| 991 | |||
| 992 | UPDATE_STRING_DICT0( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 993 | } | ||
| 994 | |||
| 995 | #if PYTHON_VERSION >= 300 | ||
| 996 | UPDATE_STRING_DICT0( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 997 | #endif | ||
| 998 | |||
| 999 | #if PYTHON_VERSION >= 340 | ||
| 1000 | // Set the "__spec__" value | ||
| 1001 | |||
| 1002 | #if 0 | ||
| 1003 | // Main modules just get "None" as spec. | ||
| 1004 | UPDATE_STRING_DICT0( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 1005 | #else | ||
| 1006 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 1007 | { | ||
| 1008 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 1009 | CHECK_OBJECT( bootstrap_module ); | ||
| 1010 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 1011 | Py_DECREF( bootstrap_module ); | ||
| 1012 | |||
| 1013 | PyObject *args[] = { | ||
| 1014 | GET_STRING_DICT_VALUE( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 1015 | (PyObject *)&Nuitka_Loader_Type | ||
| 1016 | }; | ||
| 1017 | |||
| 1018 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 1019 | module_spec_class, | ||
| 1020 | args | ||
| 1021 | ); | ||
| 1022 | Py_DECREF( module_spec_class ); | ||
| 1023 | |||
| 1024 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 1025 | CHECK_OBJECT( spec_value ); | ||
| 1026 | |||
| 1027 | // For packages set the submodule search locations as well, even if to empty | ||
| 1028 | // list, so investigating code will consider it a package. | ||
| 1029 | #if 0 | ||
| 1030 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 1031 | #endif | ||
| 1032 | |||
| 1033 | // Mark the execution in the "__spec__" value. | ||
| 1034 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 1035 | |||
| 1036 | UPDATE_STRING_DICT1( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 1037 | } | ||
| 1038 | #endif | ||
| 1039 | #endif | ||
| 1040 | |||
| 1041 | // Temp variables if any | ||
| 1042 | struct Nuitka_FrameObject *frame_a4a0a7f025d399266b1fa6b2e02694c9; | ||
| 1043 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 1044 | bool tmp_result; | ||
| 1045 | PyObject *exception_type = NULL; | ||
| 1046 | PyObject *exception_value = NULL; | ||
| 1047 | PyTracebackObject *exception_tb = NULL; | ||
| 1048 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 1049 | |||
| 1050 | // Module code. | ||
| 1051 | { | ||
| 1052 | PyObject *tmp_assign_source_1; | ||
| 1053 | tmp_assign_source_1 = Py_None; | ||
| 1054 | UPDATE_STRING_DICT0( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 1055 | } | ||
| 1056 | { | ||
| 1057 | PyObject *tmp_assign_source_2; | ||
| 1058 | tmp_assign_source_2 = module_filename_obj; | ||
| 1059 | UPDATE_STRING_DICT0( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 1060 | } | ||
| 1061 | // Frame without reuse. | ||
| 1062 | frame_a4a0a7f025d399266b1fa6b2e02694c9 = MAKE_MODULE_FRAME( codeobj_a4a0a7f025d399266b1fa6b2e02694c9, module_problem$tools ); | ||
| 1063 | |||
| 1064 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 1065 | // owning it. | ||
| 1066 | pushFrameStack( frame_a4a0a7f025d399266b1fa6b2e02694c9 ); | ||
| 1067 | assert( Py_REFCNT( frame_a4a0a7f025d399266b1fa6b2e02694c9 ) == 2 ); | ||
| 1068 | |||
| 1069 | // Framed code: | ||
| 1070 | { | ||
| 1071 | PyObject *tmp_assattr_name_1; | ||
| 1072 | PyObject *tmp_assattr_target_1; | ||
| 1073 | PyObject *tmp_mvar_value_1; | ||
| 1074 | tmp_assattr_name_1 = module_filename_obj; | ||
| 1075 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1076 | |||
| 1077 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 1078 | { | ||
| 1079 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1080 | } | ||
| 1081 | |||
| 1082 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 1083 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 1084 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 1085 | if ( tmp_result == false ) | ||
| 1086 | { | ||
| 1087 | assert( ERROR_OCCURRED() ); | ||
| 1088 | |||
| 1089 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1090 | |||
| 1091 | |||
| 1092 | exception_lineno = 1; | ||
| 1093 | |||
| 1094 | goto frame_exception_exit_1; | ||
| 1095 | } | ||
| 1096 | } | ||
| 1097 | { | ||
| 1098 | PyObject *tmp_assattr_name_2; | ||
| 1099 | PyObject *tmp_assattr_target_2; | ||
| 1100 | PyObject *tmp_mvar_value_2; | ||
| 1101 | tmp_assattr_name_2 = Py_True; | ||
| 1102 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1103 | |||
| 1104 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 1105 | { | ||
| 1106 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1107 | } | ||
| 1108 | |||
| 1109 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 1110 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 1111 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 1112 | if ( tmp_result == false ) | ||
| 1113 | { | ||
| 1114 | assert( ERROR_OCCURRED() ); | ||
| 1115 | |||
| 1116 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1117 | |||
| 1118 | |||
| 1119 | exception_lineno = 1; | ||
| 1120 | |||
| 1121 | goto frame_exception_exit_1; | ||
| 1122 | } | ||
| 1123 | } | ||
| 1124 | { | ||
| 1125 | PyObject *tmp_assign_source_3; | ||
| 1126 | tmp_assign_source_3 = Py_None; | ||
| 1127 | UPDATE_STRING_DICT0( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 1128 | } | ||
| 1129 | { | ||
| 1130 | PyObject *tmp_assign_source_4; | ||
| 1131 | PyObject *tmp_name_name_1; | ||
| 1132 | PyObject *tmp_globals_name_1; | ||
| 1133 | PyObject *tmp_locals_name_1; | ||
| 1134 | PyObject *tmp_fromlist_name_1; | ||
| 1135 | PyObject *tmp_level_name_1; | ||
| 1136 | tmp_name_name_1 = const_str_plain_problem; | ||
| 1137 | tmp_globals_name_1 = (PyObject *)moduledict_problem$tools; | ||
| 1138 | tmp_locals_name_1 = Py_None; | ||
| 1139 | tmp_fromlist_name_1 = Py_None; | ||
| 1140 | tmp_level_name_1 = const_int_0; | ||
| 1141 | frame_a4a0a7f025d399266b1fa6b2e02694c9->m_frame.f_lineno = 1; | ||
| 1142 | tmp_assign_source_4 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 1143 | if ( tmp_assign_source_4 == NULL ) | ||
| 1144 | { | ||
| 1145 | assert( ERROR_OCCURRED() ); | ||
| 1146 | |||
| 1147 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1148 | |||
| 1149 | |||
| 1150 | exception_lineno = 1; | ||
| 1151 | |||
| 1152 | goto frame_exception_exit_1; | ||
| 1153 | } | ||
| 1154 | UPDATE_STRING_DICT1( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain_problem, tmp_assign_source_4 ); | ||
| 1155 | } | ||
| 1156 | |||
| 1157 | // Restore frame exception if necessary. | ||
| 1158 | #if 0 | ||
| 1159 | RESTORE_FRAME_EXCEPTION( frame_a4a0a7f025d399266b1fa6b2e02694c9 ); | ||
| 1160 | #endif | ||
| 1161 | popFrameStack(); | ||
| 1162 | |||
| 1163 | assertFrameObject( frame_a4a0a7f025d399266b1fa6b2e02694c9 ); | ||
| 1164 | |||
| 1165 | goto frame_no_exception_1; | ||
| 1166 | |||
| 1167 | frame_exception_exit_1:; | ||
| 1168 | #if 0 | ||
| 1169 | RESTORE_FRAME_EXCEPTION( frame_a4a0a7f025d399266b1fa6b2e02694c9 ); | ||
| 1170 | #endif | ||
| 1171 | |||
| 1172 | if ( exception_tb == NULL ) | ||
| 1173 | { | ||
| 1174 | exception_tb = MAKE_TRACEBACK( frame_a4a0a7f025d399266b1fa6b2e02694c9, exception_lineno ); | ||
| 1175 | } | ||
| 1176 | else if ( exception_tb->tb_frame != &frame_a4a0a7f025d399266b1fa6b2e02694c9->m_frame ) | ||
| 1177 | { | ||
| 1178 | exception_tb = ADD_TRACEBACK( exception_tb, frame_a4a0a7f025d399266b1fa6b2e02694c9, exception_lineno ); | ||
| 1179 | } | ||
| 1180 | |||
| 1181 | // Put the previous frame back on top. | ||
| 1182 | popFrameStack(); | ||
| 1183 | |||
| 1184 | // Return the error. | ||
| 1185 | goto module_exception_exit; | ||
| 1186 | |||
| 1187 | frame_no_exception_1:; | ||
| 1188 | { | ||
| 1189 | PyObject *tmp_assign_source_5; | ||
| 1190 | tmp_assign_source_5 = MAKE_FUNCTION_problem$tools$$$function_1_problemify( ); | ||
| 1191 | |||
| 1192 | |||
| 1193 | |||
| 1194 | UPDATE_STRING_DICT1( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain_problemify, tmp_assign_source_5 ); | ||
| 1195 | } | ||
| 1196 | |||
| 1197 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 1198 | #if 0 && 0 | ||
| 1199 | { | ||
| 1200 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_problem$tools, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 1201 | |||
| 1202 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 1203 | { | ||
| 1204 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 1205 | |||
| 1206 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 1207 | CHECK_OBJECT( path_importer_cache ); | ||
| 1208 | |||
| 1209 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 1210 | assert( res == 0 ); | ||
| 1211 | } | ||
| 1212 | } | ||
| 1213 | #endif | ||
| 1214 | #endif | ||
| 1215 | |||
| 1216 | return MOD_RETURN_VALUE( module_problem$tools ); | ||
| 1217 | module_exception_exit: | ||
| 1218 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1219 | return MOD_RETURN_VALUE( NULL ); | ||
| 1220 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.problem.tools.o deleted (index 2d55874..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.problem.watch.c deleted (index 604ee8b..0000000) | |||
| 1 | /* Generated code for Python module 'problem.watch' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_problem$watch" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_problem$watch; | ||
| 31 | PyDictObject *moduledict_problem$watch; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain_cb; | ||
| 35 | static PyObject *const_str_plain_run; | ||
| 36 | extern PyObject *const_str_plain_metaclass; | ||
| 37 | extern PyObject *const_str_plain___spec__; | ||
| 38 | extern PyObject *const_str_plain___name__; | ||
| 39 | static PyObject *const_str_plain_comp; | ||
| 40 | extern PyObject *const_tuple_str_plain___class___tuple; | ||
| 41 | extern PyObject *const_str_angle_metaclass; | ||
| 42 | extern PyObject *const_str_plain_object; | ||
| 43 | extern PyObject *const_str_plain___file__; | ||
| 44 | extern PyObject *const_str_digest_66f7aeb02c13e91a30a18f0ea911888b; | ||
| 45 | static PyObject *const_str_digest_72c59ad0b3a8aec75a46b62cd5dd728b; | ||
| 46 | static PyObject *const_str_digest_b2d0a1653b5af1672cfbe7f3cb38e88b; | ||
| 47 | extern PyObject *const_str_plain_problem; | ||
| 48 | extern PyObject *const_str_plain_add_signal_receiver; | ||
| 49 | static PyObject *const_str_digest_dba1471062040150ffbf7ed03f51f70c; | ||
| 50 | static PyObject *const_str_digest_d24697c673930d75fe1aca791c659f37; | ||
| 51 | extern PyObject *const_str_plain_os; | ||
| 52 | static PyObject *const_tuple_14ad85c7c9b76401ec48cf226f55f7c3_tuple; | ||
| 53 | static PyObject *const_tuple_e2ca65f3276165d546ff9461351dced6_tuple; | ||
| 54 | static PyObject *const_str_digest_9d806eaad66d3756ba04cb4ec720b7d6; | ||
| 55 | static PyObject *const_str_plain_add_callback; | ||
| 56 | static PyObject *const_str_digest_c8c3013b85174ee4c7e95aa9fc093e73; | ||
| 57 | static PyObject *const_str_digest_643fe9e7c334d124dd12d07dd04bc6d7; | ||
| 58 | extern PyObject *const_str_plain_ddir; | ||
| 59 | extern PyObject *const_str_plain___doc__; | ||
| 60 | static PyObject *const_dict_a4f2d71d9b034fe27739e030391a7c6a; | ||
| 61 | static PyObject *const_str_plain_callbacks; | ||
| 62 | extern PyObject *const_str_plain___orig_bases__; | ||
| 63 | static PyObject *const_str_plain_quit; | ||
| 64 | static PyObject *const_str_plain_loop; | ||
| 65 | extern PyObject *const_str_plain_DBusGMainLoop; | ||
| 66 | extern PyObject *const_str_plain___qualname__; | ||
| 67 | extern PyObject *const_str_digest_168dabde1c45fe2c6a98ec9eae56b3f0; | ||
| 68 | static PyObject *const_tuple_str_plain_DBusGMainLoop_tuple; | ||
| 69 | extern PyObject *const_str_plain_tools; | ||
| 70 | extern PyObject *const_str_plain_path; | ||
| 71 | extern PyObject *const_str_plain_dbus; | ||
| 72 | extern PyObject *const_tuple_str_plain_self_tuple; | ||
| 73 | extern PyObject *const_str_plain_proxies; | ||
| 74 | static PyObject *const_str_digest_69674f8f0ed7d7d7d2f89a2b85e765b6; | ||
| 75 | static PyObject *const_tuple_str_plain_self_str_plain_fun_tuple; | ||
| 76 | extern PyObject *const_str_plain_GObject; | ||
| 77 | static PyObject *const_dict_214d5d3fa9eae68a8726794127da42a3; | ||
| 78 | static PyObject *const_tuple_str_digest_d24697c673930d75fe1aca791c659f37_tuple; | ||
| 79 | static PyObject *const_str_plain_evt_match_old_path; | ||
| 80 | extern PyObject *const_tuple_empty; | ||
| 81 | extern PyObject *const_str_plain_fun; | ||
| 82 | extern PyObject *const_str_plain_append; | ||
| 83 | extern PyObject *const_str_plain_duphash; | ||
| 84 | extern PyObject *const_str_plain_get_proxy; | ||
| 85 | static PyObject *const_str_digest_fc8a5876d3416745601ebf18c127ebfc; | ||
| 86 | static PyObject *const_str_digest_43d8e4fe59387d69a0785160b55bc74b; | ||
| 87 | extern PyObject *const_str_plain_ProblemWatcher; | ||
| 88 | extern PyObject *const_str_plain___getitem__; | ||
| 89 | extern PyObject *const_str_plain_getuid; | ||
| 90 | static PyObject *const_str_digest_df675e9e6a3e348cc28010e5ca774d50; | ||
| 91 | extern PyObject *const_int_0; | ||
| 92 | static PyObject *const_str_digest_7772fb89b733df96f112d88eda9d1ea3; | ||
| 93 | extern PyObject *const_str_plain_origin; | ||
| 94 | extern PyObject *const_str_plain_bus; | ||
| 95 | extern PyObject *const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 96 | extern PyObject *const_str_plain_uid; | ||
| 97 | static PyObject *const_str_plain__new_problem_handler; | ||
| 98 | extern PyObject *const_str_plain_prob; | ||
| 99 | static PyObject *const_str_plain_Crash; | ||
| 100 | extern PyObject *const_str_plain_gobject; | ||
| 101 | static PyObject *const_str_plain_evt_match; | ||
| 102 | extern PyObject *const_str_plain_type; | ||
| 103 | extern PyObject *const_str_plain___cached__; | ||
| 104 | extern PyObject *const_str_plain_signal_name; | ||
| 105 | extern PyObject *const_str_plain___class__; | ||
| 106 | extern PyObject *const_str_plain_problemify; | ||
| 107 | extern PyObject *const_tuple_type_object_tuple; | ||
| 108 | extern PyObject *const_str_plain___module__; | ||
| 109 | extern PyObject *const_str_plain_debug; | ||
| 110 | extern PyObject *const_str_plain_threads_init; | ||
| 111 | static PyObject *const_str_plain_MainLoop; | ||
| 112 | extern PyObject *const_str_plain_auth; | ||
| 113 | extern PyObject *const_str_plain_uuid; | ||
| 114 | extern PyObject *const_str_plain___prepare__; | ||
| 115 | extern PyObject *const_str_plain___init__; | ||
| 116 | extern PyObject *const_str_plain_self; | ||
| 117 | extern PyObject *const_str_plain_private; | ||
| 118 | static PyObject *const_str_digest_38fb2aa5dde28301dc9b212f510d8ef6; | ||
| 119 | extern PyObject *const_str_plain_has_location; | ||
| 120 | static PyObject *const_str_digest_7206f320397eb203421b0c49b1ab89b7; | ||
| 121 | extern PyObject *const_tuple_str_plain_GObject_tuple; | ||
| 122 | extern PyObject *const_str_plain_SystemBus; | ||
| 123 | extern PyObject *const_str_plain_logging; | ||
| 124 | extern PyObject *const_str_plain_format; | ||
| 125 | extern PyObject *const_str_digest_a70d2bed936523093700e5558854519a; | ||
| 126 | extern PyObject *const_str_plain_mainloop; | ||
| 127 | static PyObject *const_str_digest_990bbe65ddad861de2be6243a6ff3138; | ||
| 128 | static PyObject *module_filename_obj; | ||
| 129 | |||
| 130 | /* Indicator if this modules private constants were created yet. */ | ||
| 131 | static bool constants_created = false; | ||
| 132 | |||
| 133 | /* Function to create module private constants. */ | ||
| 134 | static void createModuleConstants( void ) | ||
| 135 | { | ||
| 136 | const_str_plain_run = UNSTREAM_STRING_ASCII( &constant_bin[ 2667 ], 3, 1 ); | ||
| 137 | const_str_plain_comp = UNSTREAM_STRING_ASCII( &constant_bin[ 3893 ], 4, 1 ); | ||
| 138 | const_str_digest_72c59ad0b3a8aec75a46b62cd5dd728b = UNSTREAM_STRING_ASCII( &constant_bin[ 59561 ], 22, 0 ); | ||
| 139 | const_str_digest_b2d0a1653b5af1672cfbe7f3cb38e88b = UNSTREAM_STRING_ASCII( &constant_bin[ 59583 ], 123, 0 ); | ||
| 140 | const_str_digest_dba1471062040150ffbf7ed03f51f70c = UNSTREAM_STRING_ASCII( &constant_bin[ 59706 ], 27, 0 ); | ||
| 141 | const_str_digest_d24697c673930d75fe1aca791c659f37 = UNSTREAM_STRING_ASCII( &constant_bin[ 59733 ], 33, 0 ); | ||
| 142 | const_tuple_14ad85c7c9b76401ec48cf226f55f7c3_tuple = PyTuple_New( 8 ); | ||
| 143 | PyTuple_SET_ITEM( const_tuple_14ad85c7c9b76401ec48cf226f55f7c3_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 144 | PyTuple_SET_ITEM( const_tuple_14ad85c7c9b76401ec48cf226f55f7c3_tuple, 1, const_str_plain_auth ); Py_INCREF( const_str_plain_auth ); | ||
| 145 | PyTuple_SET_ITEM( const_tuple_14ad85c7c9b76401ec48cf226f55f7c3_tuple, 2, const_str_plain_dbus ); Py_INCREF( const_str_plain_dbus ); | ||
| 146 | PyTuple_SET_ITEM( const_tuple_14ad85c7c9b76401ec48cf226f55f7c3_tuple, 3, const_str_plain_gobject ); Py_INCREF( const_str_plain_gobject ); | ||
| 147 | PyTuple_SET_ITEM( const_tuple_14ad85c7c9b76401ec48cf226f55f7c3_tuple, 4, const_str_plain_DBusGMainLoop ); Py_INCREF( const_str_plain_DBusGMainLoop ); | ||
| 148 | PyTuple_SET_ITEM( const_tuple_14ad85c7c9b76401ec48cf226f55f7c3_tuple, 5, const_str_plain_bus ); Py_INCREF( const_str_plain_bus ); | ||
| 149 | const_str_plain_evt_match = UNSTREAM_STRING_ASCII( &constant_bin[ 59766 ], 9, 1 ); | ||
| 150 | PyTuple_SET_ITEM( const_tuple_14ad85c7c9b76401ec48cf226f55f7c3_tuple, 6, const_str_plain_evt_match ); Py_INCREF( const_str_plain_evt_match ); | ||
| 151 | const_str_plain_evt_match_old_path = UNSTREAM_STRING_ASCII( &constant_bin[ 59775 ], 18, 1 ); | ||
| 152 | PyTuple_SET_ITEM( const_tuple_14ad85c7c9b76401ec48cf226f55f7c3_tuple, 7, const_str_plain_evt_match_old_path ); Py_INCREF( const_str_plain_evt_match_old_path ); | ||
| 153 | const_tuple_e2ca65f3276165d546ff9461351dced6_tuple = PyTuple_New( 8 ); | ||
| 154 | PyTuple_SET_ITEM( const_tuple_e2ca65f3276165d546ff9461351dced6_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 155 | PyTuple_SET_ITEM( const_tuple_e2ca65f3276165d546ff9461351dced6_tuple, 1, const_str_plain_comp ); Py_INCREF( const_str_plain_comp ); | ||
| 156 | PyTuple_SET_ITEM( const_tuple_e2ca65f3276165d546ff9461351dced6_tuple, 2, const_str_plain_ddir ); Py_INCREF( const_str_plain_ddir ); | ||
| 157 | PyTuple_SET_ITEM( const_tuple_e2ca65f3276165d546ff9461351dced6_tuple, 3, const_str_plain_uid ); Py_INCREF( const_str_plain_uid ); | ||
| 158 | PyTuple_SET_ITEM( const_tuple_e2ca65f3276165d546ff9461351dced6_tuple, 4, const_str_plain_uuid ); Py_INCREF( const_str_plain_uuid ); | ||
| 159 | PyTuple_SET_ITEM( const_tuple_e2ca65f3276165d546ff9461351dced6_tuple, 5, const_str_plain_duphash ); Py_INCREF( const_str_plain_duphash ); | ||
| 160 | PyTuple_SET_ITEM( const_tuple_e2ca65f3276165d546ff9461351dced6_tuple, 6, const_str_plain_prob ); Py_INCREF( const_str_plain_prob ); | ||
| 161 | PyTuple_SET_ITEM( const_tuple_e2ca65f3276165d546ff9461351dced6_tuple, 7, const_str_plain_cb ); Py_INCREF( const_str_plain_cb ); | ||
| 162 | const_str_digest_9d806eaad66d3756ba04cb4ec720b7d6 = UNSTREAM_STRING_ASCII( &constant_bin[ 59793 ], 23, 0 ); | ||
| 163 | const_str_plain_add_callback = UNSTREAM_STRING_ASCII( &constant_bin[ 59721 ], 12, 1 ); | ||
| 164 | const_str_digest_c8c3013b85174ee4c7e95aa9fc093e73 = UNSTREAM_STRING_ASCII( &constant_bin[ 59816 ], 19, 0 ); | ||
| 165 | const_str_digest_643fe9e7c334d124dd12d07dd04bc6d7 = UNSTREAM_STRING_ASCII( &constant_bin[ 59835 ], 16, 0 ); | ||
| 166 | const_dict_a4f2d71d9b034fe27739e030391a7c6a = _PyDict_NewPresized( 2 ); | ||
| 167 | const_str_plain_Crash = UNSTREAM_STRING_ASCII( &constant_bin[ 59851 ], 5, 1 ); | ||
| 168 | PyDict_SetItem( const_dict_a4f2d71d9b034fe27739e030391a7c6a, const_str_plain_signal_name, const_str_plain_Crash ); | ||
| 169 | PyDict_SetItem( const_dict_a4f2d71d9b034fe27739e030391a7c6a, const_str_plain_path, const_str_digest_a70d2bed936523093700e5558854519a ); | ||
| 170 | assert( PyDict_Size( const_dict_a4f2d71d9b034fe27739e030391a7c6a ) == 2 ); | ||
| 171 | const_str_plain_callbacks = UNSTREAM_STRING_ASCII( &constant_bin[ 20653 ], 9, 1 ); | ||
| 172 | const_str_plain_quit = UNSTREAM_STRING_ASCII( &constant_bin[ 59831 ], 4, 1 ); | ||
| 173 | const_str_plain_loop = UNSTREAM_STRING_ASCII( &constant_bin[ 3008 ], 4, 1 ); | ||
| 174 | const_tuple_str_plain_DBusGMainLoop_tuple = PyTuple_New( 1 ); | ||
| 175 | PyTuple_SET_ITEM( const_tuple_str_plain_DBusGMainLoop_tuple, 0, const_str_plain_DBusGMainLoop ); Py_INCREF( const_str_plain_DBusGMainLoop ); | ||
| 176 | const_str_digest_69674f8f0ed7d7d7d2f89a2b85e765b6 = UNSTREAM_STRING_ASCII( &constant_bin[ 59856 ], 27, 0 ); | ||
| 177 | const_tuple_str_plain_self_str_plain_fun_tuple = PyTuple_New( 2 ); | ||
| 178 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_fun_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 179 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_fun_tuple, 1, const_str_plain_fun ); Py_INCREF( const_str_plain_fun ); | ||
| 180 | const_dict_214d5d3fa9eae68a8726794127da42a3 = _PyDict_NewPresized( 2 ); | ||
| 181 | PyDict_SetItem( const_dict_214d5d3fa9eae68a8726794127da42a3, const_str_plain_signal_name, const_str_plain_Crash ); | ||
| 182 | PyDict_SetItem( const_dict_214d5d3fa9eae68a8726794127da42a3, const_str_plain_path, const_str_digest_643fe9e7c334d124dd12d07dd04bc6d7 ); | ||
| 183 | assert( PyDict_Size( const_dict_214d5d3fa9eae68a8726794127da42a3 ) == 2 ); | ||
| 184 | const_tuple_str_digest_d24697c673930d75fe1aca791c659f37_tuple = PyTuple_New( 1 ); | ||
| 185 | PyTuple_SET_ITEM( const_tuple_str_digest_d24697c673930d75fe1aca791c659f37_tuple, 0, const_str_digest_d24697c673930d75fe1aca791c659f37 ); Py_INCREF( const_str_digest_d24697c673930d75fe1aca791c659f37 ); | ||
| 186 | const_str_digest_fc8a5876d3416745601ebf18c127ebfc = UNSTREAM_STRING_ASCII( &constant_bin[ 59883 ], 217, 0 ); | ||
| 187 | const_str_digest_43d8e4fe59387d69a0785160b55bc74b = UNSTREAM_STRING_ASCII( &constant_bin[ 60100 ], 43, 0 ); | ||
| 188 | const_str_digest_df675e9e6a3e348cc28010e5ca774d50 = UNSTREAM_STRING_ASCII( &constant_bin[ 60143 ], 18, 0 ); | ||
| 189 | const_str_digest_7772fb89b733df96f112d88eda9d1ea3 = UNSTREAM_STRING_ASCII( &constant_bin[ 60161 ], 35, 0 ); | ||
| 190 | const_str_plain__new_problem_handler = UNSTREAM_STRING_ASCII( &constant_bin[ 60176 ], 20, 1 ); | ||
| 191 | const_str_plain_MainLoop = UNSTREAM_STRING_ASCII( &constant_bin[ 4574 ], 8, 1 ); | ||
| 192 | const_str_digest_38fb2aa5dde28301dc9b212f510d8ef6 = UNSTREAM_STRING_ASCII( &constant_bin[ 59569 ], 13, 0 ); | ||
| 193 | const_str_digest_7206f320397eb203421b0c49b1ab89b7 = UNSTREAM_STRING_ASCII( &constant_bin[ 60196 ], 26, 0 ); | ||
| 194 | const_str_digest_990bbe65ddad861de2be6243a6ff3138 = UNSTREAM_STRING_ASCII( &constant_bin[ 60222 ], 16, 0 ); | ||
| 195 | |||
| 196 | constants_created = true; | ||
| 197 | } | ||
| 198 | |||
| 199 | /* Function to verify module private constants for non-corruption. */ | ||
| 200 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 201 | void checkModuleConstants_problem$watch( void ) | ||
| 202 | { | ||
| 203 | // The module may not have been used at all, then ignore this. | ||
| 204 | if (constants_created == false) return; | ||
| 205 | |||
| 206 | |||
| 207 | } | ||
| 208 | #endif | ||
| 209 | |||
| 210 | // The module code objects. | ||
| 211 | static PyCodeObject *codeobj_2765838b8bb3ab223eab9353cd0c488a; | ||
| 212 | static PyCodeObject *codeobj_6460bfc2f936b42b752a8a65fb70122a; | ||
| 213 | static PyCodeObject *codeobj_661f64abf7d853df92ffc10bd5c6cf99; | ||
| 214 | static PyCodeObject *codeobj_784f5e5265e35255ee834cc666e1c059; | ||
| 215 | static PyCodeObject *codeobj_e34ffbe571bf75d50a2cbfa2fb6c5ad9; | ||
| 216 | static PyCodeObject *codeobj_abae12faeac5cbdafa8c4d1e0a41676e; | ||
| 217 | static PyCodeObject *codeobj_d9dbed341759cfaa50c801239ced923d; | ||
| 218 | |||
| 219 | static void createModuleCodeObjects(void) | ||
| 220 | { | ||
| 221 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_990bbe65ddad861de2be6243a6ff3138 ); | ||
| 222 | codeobj_2765838b8bb3ab223eab9353cd0c488a = MAKE_CODEOBJ( module_filename_obj, const_str_digest_72c59ad0b3a8aec75a46b62cd5dd728b, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 223 | codeobj_6460bfc2f936b42b752a8a65fb70122a = MAKE_CODEOBJ( module_filename_obj, const_str_plain_ProblemWatcher, 7, const_tuple_str_plain___class___tuple, 0, 0, CO_NOFREE ); | ||
| 224 | codeobj_661f64abf7d853df92ffc10bd5c6cf99 = MAKE_CODEOBJ( module_filename_obj, const_str_plain___init__, 16, const_tuple_14ad85c7c9b76401ec48cf226f55f7c3_tuple, 2, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 225 | codeobj_784f5e5265e35255ee834cc666e1c059 = MAKE_CODEOBJ( module_filename_obj, const_str_plain__new_problem_handler, 44, const_tuple_e2ca65f3276165d546ff9461351dced6_tuple, 6, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 226 | codeobj_e34ffbe571bf75d50a2cbfa2fb6c5ad9 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_add_callback, 55, const_tuple_str_plain_self_str_plain_fun_tuple, 2, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 227 | codeobj_abae12faeac5cbdafa8c4d1e0a41676e = MAKE_CODEOBJ( module_filename_obj, const_str_plain_quit, 69, const_tuple_str_plain_self_tuple, 1, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 228 | codeobj_d9dbed341759cfaa50c801239ced923d = MAKE_CODEOBJ( module_filename_obj, const_str_plain_run, 64, const_tuple_str_plain_self_tuple, 1, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 229 | } | ||
| 230 | |||
| 231 | // The module function declarations. | ||
| 232 | NUITKA_CROSS_MODULE PyObject *impl___internal__$$$function_2__mro_entries_conversion( PyObject **python_pars ); | ||
| 233 | |||
| 234 | |||
| 235 | static PyObject *MAKE_FUNCTION_problem$watch$$$function_1___init__( ); | ||
| 236 | |||
| 237 | |||
| 238 | static PyObject *MAKE_FUNCTION_problem$watch$$$function_2__new_problem_handler( ); | ||
| 239 | |||
| 240 | |||
| 241 | static PyObject *MAKE_FUNCTION_problem$watch$$$function_3_add_callback( ); | ||
| 242 | |||
| 243 | |||
| 244 | static PyObject *MAKE_FUNCTION_problem$watch$$$function_4_run( ); | ||
| 245 | |||
| 246 | |||
| 247 | static PyObject *MAKE_FUNCTION_problem$watch$$$function_5_quit( ); | ||
| 248 | |||
| 249 | |||
| 250 | // The module function definitions. | ||
| 251 | static PyObject *impl_problem$watch$$$function_1___init__( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 252 | { | ||
| 253 | // Preserve error status for checks | ||
| 254 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 255 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 256 | #endif | ||
| 257 | |||
| 258 | // Local variable declarations. | ||
| 259 | PyObject *par_self = python_pars[ 0 ]; | ||
| 260 | PyObject *par_auth = python_pars[ 1 ]; | ||
| 261 | PyObject *var_dbus = NULL; | ||
| 262 | PyObject *var_gobject = NULL; | ||
| 263 | PyObject *var_DBusGMainLoop = NULL; | ||
| 264 | PyObject *var_bus = NULL; | ||
| 265 | PyObject *var_evt_match = NULL; | ||
| 266 | PyObject *var_evt_match_old_path = NULL; | ||
| 267 | struct Nuitka_FrameObject *frame_661f64abf7d853df92ffc10bd5c6cf99; | ||
| 268 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 269 | PyObject *exception_type = NULL; | ||
| 270 | PyObject *exception_value = NULL; | ||
| 271 | PyTracebackObject *exception_tb = NULL; | ||
| 272 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 273 | int tmp_res; | ||
| 274 | bool tmp_result; | ||
| 275 | static struct Nuitka_FrameObject *cache_frame_661f64abf7d853df92ffc10bd5c6cf99 = NULL; | ||
| 276 | PyObject *tmp_return_value = NULL; | ||
| 277 | PyObject *exception_keeper_type_1; | ||
| 278 | PyObject *exception_keeper_value_1; | ||
| 279 | PyTracebackObject *exception_keeper_tb_1; | ||
| 280 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 281 | |||
| 282 | // Actual function body. | ||
| 283 | // Tried code: | ||
| 284 | MAKE_OR_REUSE_FRAME( cache_frame_661f64abf7d853df92ffc10bd5c6cf99, codeobj_661f64abf7d853df92ffc10bd5c6cf99, module_problem$watch, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 285 | frame_661f64abf7d853df92ffc10bd5c6cf99 = cache_frame_661f64abf7d853df92ffc10bd5c6cf99; | ||
| 286 | |||
| 287 | // Push the new frame as the currently active one. | ||
| 288 | pushFrameStack( frame_661f64abf7d853df92ffc10bd5c6cf99 ); | ||
| 289 | |||
| 290 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 291 | assert( Py_REFCNT( frame_661f64abf7d853df92ffc10bd5c6cf99 ) == 2 ); // Frame stack | ||
| 292 | |||
| 293 | // Framed code: | ||
| 294 | { | ||
| 295 | PyObject *tmp_assign_source_1; | ||
| 296 | PyObject *tmp_name_name_1; | ||
| 297 | PyObject *tmp_globals_name_1; | ||
| 298 | PyObject *tmp_locals_name_1; | ||
| 299 | PyObject *tmp_fromlist_name_1; | ||
| 300 | PyObject *tmp_level_name_1; | ||
| 301 | tmp_name_name_1 = const_str_plain_dbus; | ||
| 302 | tmp_globals_name_1 = (PyObject *)moduledict_problem$watch; | ||
| 303 | tmp_locals_name_1 = Py_None; | ||
| 304 | tmp_fromlist_name_1 = Py_None; | ||
| 305 | tmp_level_name_1 = const_int_0; | ||
| 306 | frame_661f64abf7d853df92ffc10bd5c6cf99->m_frame.f_lineno = 17; | ||
| 307 | tmp_assign_source_1 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 308 | if ( tmp_assign_source_1 == NULL ) | ||
| 309 | { | ||
| 310 | assert( ERROR_OCCURRED() ); | ||
| 311 | |||
| 312 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 313 | |||
| 314 | |||
| 315 | exception_lineno = 17; | ||
| 316 | type_description_1 = "oooooooo"; | ||
| 317 | goto frame_exception_exit_1; | ||
| 318 | } | ||
| 319 | assert( var_dbus == NULL ); | ||
| 320 | var_dbus = tmp_assign_source_1; | ||
| 321 | } | ||
| 322 | { | ||
| 323 | PyObject *tmp_assign_source_2; | ||
| 324 | PyObject *tmp_import_name_from_1; | ||
| 325 | PyObject *tmp_name_name_2; | ||
| 326 | PyObject *tmp_globals_name_2; | ||
| 327 | PyObject *tmp_locals_name_2; | ||
| 328 | PyObject *tmp_fromlist_name_2; | ||
| 329 | PyObject *tmp_level_name_2; | ||
| 330 | tmp_name_name_2 = const_str_digest_66f7aeb02c13e91a30a18f0ea911888b; | ||
| 331 | tmp_globals_name_2 = (PyObject *)moduledict_problem$watch; | ||
| 332 | tmp_locals_name_2 = Py_None; | ||
| 333 | tmp_fromlist_name_2 = const_tuple_str_plain_GObject_tuple; | ||
| 334 | tmp_level_name_2 = const_int_0; | ||
| 335 | frame_661f64abf7d853df92ffc10bd5c6cf99->m_frame.f_lineno = 18; | ||
| 336 | tmp_import_name_from_1 = IMPORT_MODULE5( tmp_name_name_2, tmp_globals_name_2, tmp_locals_name_2, tmp_fromlist_name_2, tmp_level_name_2 ); | ||
| 337 | if ( tmp_import_name_from_1 == NULL ) | ||
| 338 | { | ||
| 339 | assert( ERROR_OCCURRED() ); | ||
| 340 | |||
| 341 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 342 | |||
| 343 | |||
| 344 | exception_lineno = 18; | ||
| 345 | type_description_1 = "oooooooo"; | ||
| 346 | goto frame_exception_exit_1; | ||
| 347 | } | ||
| 348 | tmp_assign_source_2 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain_GObject ); | ||
| 349 | Py_DECREF( tmp_import_name_from_1 ); | ||
| 350 | if ( tmp_assign_source_2 == NULL ) | ||
| 351 | { | ||
| 352 | assert( ERROR_OCCURRED() ); | ||
| 353 | |||
| 354 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 355 | |||
| 356 | |||
| 357 | exception_lineno = 18; | ||
| 358 | type_description_1 = "oooooooo"; | ||
| 359 | goto frame_exception_exit_1; | ||
| 360 | } | ||
| 361 | assert( var_gobject == NULL ); | ||
| 362 | var_gobject = tmp_assign_source_2; | ||
| 363 | } | ||
| 364 | { | ||
| 365 | PyObject *tmp_assign_source_3; | ||
| 366 | PyObject *tmp_import_name_from_2; | ||
| 367 | PyObject *tmp_name_name_3; | ||
| 368 | PyObject *tmp_globals_name_3; | ||
| 369 | PyObject *tmp_locals_name_3; | ||
| 370 | PyObject *tmp_fromlist_name_3; | ||
| 371 | PyObject *tmp_level_name_3; | ||
| 372 | tmp_name_name_3 = const_str_digest_168dabde1c45fe2c6a98ec9eae56b3f0; | ||
| 373 | tmp_globals_name_3 = (PyObject *)moduledict_problem$watch; | ||
| 374 | tmp_locals_name_3 = Py_None; | ||
| 375 | tmp_fromlist_name_3 = const_tuple_str_plain_DBusGMainLoop_tuple; | ||
| 376 | tmp_level_name_3 = const_int_0; | ||
| 377 | frame_661f64abf7d853df92ffc10bd5c6cf99->m_frame.f_lineno = 19; | ||
| 378 | tmp_import_name_from_2 = IMPORT_MODULE5( tmp_name_name_3, tmp_globals_name_3, tmp_locals_name_3, tmp_fromlist_name_3, tmp_level_name_3 ); | ||
| 379 | if ( tmp_import_name_from_2 == NULL ) | ||
| 380 | { | ||
| 381 | assert( ERROR_OCCURRED() ); | ||
| 382 | |||
| 383 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 384 | |||
| 385 | |||
| 386 | exception_lineno = 19; | ||
| 387 | type_description_1 = "oooooooo"; | ||
| 388 | goto frame_exception_exit_1; | ||
| 389 | } | ||
| 390 | tmp_assign_source_3 = IMPORT_NAME( tmp_import_name_from_2, const_str_plain_DBusGMainLoop ); | ||
| 391 | Py_DECREF( tmp_import_name_from_2 ); | ||
| 392 | if ( tmp_assign_source_3 == NULL ) | ||
| 393 | { | ||
| 394 | assert( ERROR_OCCURRED() ); | ||
| 395 | |||
| 396 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 397 | |||
| 398 | |||
| 399 | exception_lineno = 19; | ||
| 400 | type_description_1 = "oooooooo"; | ||
| 401 | goto frame_exception_exit_1; | ||
| 402 | } | ||
| 403 | assert( var_DBusGMainLoop == NULL ); | ||
| 404 | var_DBusGMainLoop = tmp_assign_source_3; | ||
| 405 | } | ||
| 406 | { | ||
| 407 | PyObject *tmp_called_instance_1; | ||
| 408 | PyObject *tmp_call_result_1; | ||
| 409 | CHECK_OBJECT( var_gobject ); | ||
| 410 | tmp_called_instance_1 = var_gobject; | ||
| 411 | frame_661f64abf7d853df92ffc10bd5c6cf99->m_frame.f_lineno = 21; | ||
| 412 | tmp_call_result_1 = CALL_METHOD_NO_ARGS( tmp_called_instance_1, const_str_plain_threads_init ); | ||
| 413 | if ( tmp_call_result_1 == NULL ) | ||
| 414 | { | ||
| 415 | assert( ERROR_OCCURRED() ); | ||
| 416 | |||
| 417 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 418 | |||
| 419 | |||
| 420 | exception_lineno = 21; | ||
| 421 | type_description_1 = "oooooooo"; | ||
| 422 | goto frame_exception_exit_1; | ||
| 423 | } | ||
| 424 | Py_DECREF( tmp_call_result_1 ); | ||
| 425 | } | ||
| 426 | { | ||
| 427 | PyObject *tmp_assign_source_4; | ||
| 428 | PyObject *tmp_called_name_1; | ||
| 429 | PyObject *tmp_source_name_1; | ||
| 430 | PyObject *tmp_kw_name_1; | ||
| 431 | PyObject *tmp_dict_key_1; | ||
| 432 | PyObject *tmp_dict_value_1; | ||
| 433 | PyObject *tmp_called_name_2; | ||
| 434 | PyObject *tmp_dict_key_2; | ||
| 435 | PyObject *tmp_dict_value_2; | ||
| 436 | CHECK_OBJECT( var_dbus ); | ||
| 437 | tmp_source_name_1 = var_dbus; | ||
| 438 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_SystemBus ); | ||
| 439 | if ( tmp_called_name_1 == NULL ) | ||
| 440 | { | ||
| 441 | assert( ERROR_OCCURRED() ); | ||
| 442 | |||
| 443 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 444 | |||
| 445 | |||
| 446 | exception_lineno = 23; | ||
| 447 | type_description_1 = "oooooooo"; | ||
| 448 | goto frame_exception_exit_1; | ||
| 449 | } | ||
| 450 | tmp_dict_key_1 = const_str_plain_mainloop; | ||
| 451 | CHECK_OBJECT( var_DBusGMainLoop ); | ||
| 452 | tmp_called_name_2 = var_DBusGMainLoop; | ||
| 453 | frame_661f64abf7d853df92ffc10bd5c6cf99->m_frame.f_lineno = 24; | ||
| 454 | tmp_dict_value_1 = CALL_FUNCTION_NO_ARGS( tmp_called_name_2 ); | ||
| 455 | if ( tmp_dict_value_1 == NULL ) | ||
| 456 | { | ||
| 457 | assert( ERROR_OCCURRED() ); | ||
| 458 | |||
| 459 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 460 | Py_DECREF( tmp_called_name_1 ); | ||
| 461 | |||
| 462 | exception_lineno = 24; | ||
| 463 | type_description_1 = "oooooooo"; | ||
| 464 | goto frame_exception_exit_1; | ||
| 465 | } | ||
| 466 | tmp_kw_name_1 = _PyDict_NewPresized( 2 ); | ||
| 467 | tmp_res = PyDict_SetItem( tmp_kw_name_1, tmp_dict_key_1, tmp_dict_value_1 ); | ||
| 468 | Py_DECREF( tmp_dict_value_1 ); | ||
| 469 | assert( !(tmp_res != 0) ); | ||
| 470 | tmp_dict_key_2 = const_str_plain_private; | ||
| 471 | tmp_dict_value_2 = Py_True; | ||
| 472 | tmp_res = PyDict_SetItem( tmp_kw_name_1, tmp_dict_key_2, tmp_dict_value_2 ); | ||
| 473 | assert( !(tmp_res != 0) ); | ||
| 474 | frame_661f64abf7d853df92ffc10bd5c6cf99->m_frame.f_lineno = 23; | ||
| 475 | tmp_assign_source_4 = CALL_FUNCTION_WITH_KEYARGS( tmp_called_name_1, tmp_kw_name_1 ); | ||
| 476 | Py_DECREF( tmp_called_name_1 ); | ||
| 477 | Py_DECREF( tmp_kw_name_1 ); | ||
| 478 | if ( tmp_assign_source_4 == NULL ) | ||
| 479 | { | ||
| 480 | assert( ERROR_OCCURRED() ); | ||
| 481 | |||
| 482 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 483 | |||
| 484 | |||
| 485 | exception_lineno = 23; | ||
| 486 | type_description_1 = "oooooooo"; | ||
| 487 | goto frame_exception_exit_1; | ||
| 488 | } | ||
| 489 | assert( var_bus == NULL ); | ||
| 490 | var_bus = tmp_assign_source_4; | ||
| 491 | } | ||
| 492 | { | ||
| 493 | PyObject *tmp_assattr_name_1; | ||
| 494 | PyObject *tmp_assattr_target_1; | ||
| 495 | CHECK_OBJECT( var_bus ); | ||
| 496 | tmp_assattr_name_1 = var_bus; | ||
| 497 | CHECK_OBJECT( par_self ); | ||
| 498 | tmp_assattr_target_1 = par_self; | ||
| 499 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_bus, tmp_assattr_name_1 ); | ||
| 500 | if ( tmp_result == false ) | ||
| 501 | { | ||
| 502 | assert( ERROR_OCCURRED() ); | ||
| 503 | |||
| 504 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 505 | |||
| 506 | |||
| 507 | exception_lineno = 27; | ||
| 508 | type_description_1 = "oooooooo"; | ||
| 509 | goto frame_exception_exit_1; | ||
| 510 | } | ||
| 511 | } | ||
| 512 | { | ||
| 513 | PyObject *tmp_assattr_name_2; | ||
| 514 | PyObject *tmp_assattr_target_2; | ||
| 515 | CHECK_OBJECT( par_auth ); | ||
| 516 | tmp_assattr_name_2 = par_auth; | ||
| 517 | CHECK_OBJECT( par_self ); | ||
| 518 | tmp_assattr_target_2 = par_self; | ||
| 519 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_auth, tmp_assattr_name_2 ); | ||
| 520 | if ( tmp_result == false ) | ||
| 521 | { | ||
| 522 | assert( ERROR_OCCURRED() ); | ||
| 523 | |||
| 524 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 525 | |||
| 526 | |||
| 527 | exception_lineno = 28; | ||
| 528 | type_description_1 = "oooooooo"; | ||
| 529 | goto frame_exception_exit_1; | ||
| 530 | } | ||
| 531 | } | ||
| 532 | { | ||
| 533 | PyObject *tmp_assattr_name_3; | ||
| 534 | PyObject *tmp_assattr_target_3; | ||
| 535 | tmp_assattr_name_3 = PyList_New( 0 ); | ||
| 536 | CHECK_OBJECT( par_self ); | ||
| 537 | tmp_assattr_target_3 = par_self; | ||
| 538 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_3, const_str_plain_callbacks, tmp_assattr_name_3 ); | ||
| 539 | Py_DECREF( tmp_assattr_name_3 ); | ||
| 540 | if ( tmp_result == false ) | ||
| 541 | { | ||
| 542 | assert( ERROR_OCCURRED() ); | ||
| 543 | |||
| 544 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 545 | |||
| 546 | |||
| 547 | exception_lineno = 29; | ||
| 548 | type_description_1 = "oooooooo"; | ||
| 549 | goto frame_exception_exit_1; | ||
| 550 | } | ||
| 551 | } | ||
| 552 | { | ||
| 553 | PyObject *tmp_assign_source_5; | ||
| 554 | PyObject *tmp_called_name_3; | ||
| 555 | PyObject *tmp_source_name_2; | ||
| 556 | PyObject *tmp_source_name_3; | ||
| 557 | PyObject *tmp_args_name_1; | ||
| 558 | PyObject *tmp_tuple_element_1; | ||
| 559 | PyObject *tmp_source_name_4; | ||
| 560 | PyObject *tmp_kw_name_2; | ||
| 561 | CHECK_OBJECT( par_self ); | ||
| 562 | tmp_source_name_3 = par_self; | ||
| 563 | tmp_source_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_bus ); | ||
| 564 | if ( tmp_source_name_2 == NULL ) | ||
| 565 | { | ||
| 566 | assert( ERROR_OCCURRED() ); | ||
| 567 | |||
| 568 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 569 | |||
| 570 | |||
| 571 | exception_lineno = 33; | ||
| 572 | type_description_1 = "oooooooo"; | ||
| 573 | goto frame_exception_exit_1; | ||
| 574 | } | ||
| 575 | tmp_called_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_add_signal_receiver ); | ||
| 576 | Py_DECREF( tmp_source_name_2 ); | ||
| 577 | if ( tmp_called_name_3 == NULL ) | ||
| 578 | { | ||
| 579 | assert( ERROR_OCCURRED() ); | ||
| 580 | |||
| 581 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 582 | |||
| 583 | |||
| 584 | exception_lineno = 33; | ||
| 585 | type_description_1 = "oooooooo"; | ||
| 586 | goto frame_exception_exit_1; | ||
| 587 | } | ||
| 588 | CHECK_OBJECT( par_self ); | ||
| 589 | tmp_source_name_4 = par_self; | ||
| 590 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain__new_problem_handler ); | ||
| 591 | if ( tmp_tuple_element_1 == NULL ) | ||
| 592 | { | ||
| 593 | assert( ERROR_OCCURRED() ); | ||
| 594 | |||
| 595 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 596 | Py_DECREF( tmp_called_name_3 ); | ||
| 597 | |||
| 598 | exception_lineno = 34; | ||
| 599 | type_description_1 = "oooooooo"; | ||
| 600 | goto frame_exception_exit_1; | ||
| 601 | } | ||
| 602 | tmp_args_name_1 = PyTuple_New( 1 ); | ||
| 603 | PyTuple_SET_ITEM( tmp_args_name_1, 0, tmp_tuple_element_1 ); | ||
| 604 | tmp_kw_name_2 = PyDict_Copy( const_dict_a4f2d71d9b034fe27739e030391a7c6a ); | ||
| 605 | frame_661f64abf7d853df92ffc10bd5c6cf99->m_frame.f_lineno = 33; | ||
| 606 | tmp_assign_source_5 = CALL_FUNCTION( tmp_called_name_3, tmp_args_name_1, tmp_kw_name_2 ); | ||
| 607 | Py_DECREF( tmp_called_name_3 ); | ||
| 608 | Py_DECREF( tmp_args_name_1 ); | ||
| 609 | Py_DECREF( tmp_kw_name_2 ); | ||
| 610 | if ( tmp_assign_source_5 == NULL ) | ||
| 611 | { | ||
| 612 | assert( ERROR_OCCURRED() ); | ||
| 613 | |||
| 614 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 615 | |||
| 616 | |||
| 617 | exception_lineno = 33; | ||
| 618 | type_description_1 = "oooooooo"; | ||
| 619 | goto frame_exception_exit_1; | ||
| 620 | } | ||
| 621 | assert( var_evt_match == NULL ); | ||
| 622 | var_evt_match = tmp_assign_source_5; | ||
| 623 | } | ||
| 624 | { | ||
| 625 | PyObject *tmp_assign_source_6; | ||
| 626 | PyObject *tmp_called_name_4; | ||
| 627 | PyObject *tmp_source_name_5; | ||
| 628 | PyObject *tmp_source_name_6; | ||
| 629 | PyObject *tmp_args_name_2; | ||
| 630 | PyObject *tmp_tuple_element_2; | ||
| 631 | PyObject *tmp_source_name_7; | ||
| 632 | PyObject *tmp_kw_name_3; | ||
| 633 | CHECK_OBJECT( par_self ); | ||
| 634 | tmp_source_name_6 = par_self; | ||
| 635 | tmp_source_name_5 = LOOKUP_ATTRIBUTE( tmp_source_name_6, const_str_plain_bus ); | ||
| 636 | if ( tmp_source_name_5 == NULL ) | ||
| 637 | { | ||
| 638 | assert( ERROR_OCCURRED() ); | ||
| 639 | |||
| 640 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 641 | |||
| 642 | |||
| 643 | exception_lineno = 38; | ||
| 644 | type_description_1 = "oooooooo"; | ||
| 645 | goto frame_exception_exit_1; | ||
| 646 | } | ||
| 647 | tmp_called_name_4 = LOOKUP_ATTRIBUTE( tmp_source_name_5, const_str_plain_add_signal_receiver ); | ||
| 648 | Py_DECREF( tmp_source_name_5 ); | ||
| 649 | if ( tmp_called_name_4 == NULL ) | ||
| 650 | { | ||
| 651 | assert( ERROR_OCCURRED() ); | ||
| 652 | |||
| 653 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 654 | |||
| 655 | |||
| 656 | exception_lineno = 38; | ||
| 657 | type_description_1 = "oooooooo"; | ||
| 658 | goto frame_exception_exit_1; | ||
| 659 | } | ||
| 660 | CHECK_OBJECT( par_self ); | ||
| 661 | tmp_source_name_7 = par_self; | ||
| 662 | tmp_tuple_element_2 = LOOKUP_ATTRIBUTE( tmp_source_name_7, const_str_plain__new_problem_handler ); | ||
| 663 | if ( tmp_tuple_element_2 == NULL ) | ||
| 664 | { | ||
| 665 | assert( ERROR_OCCURRED() ); | ||
| 666 | |||
| 667 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 668 | Py_DECREF( tmp_called_name_4 ); | ||
| 669 | |||
| 670 | exception_lineno = 39; | ||
| 671 | type_description_1 = "oooooooo"; | ||
| 672 | goto frame_exception_exit_1; | ||
| 673 | } | ||
| 674 | tmp_args_name_2 = PyTuple_New( 1 ); | ||
| 675 | PyTuple_SET_ITEM( tmp_args_name_2, 0, tmp_tuple_element_2 ); | ||
| 676 | tmp_kw_name_3 = PyDict_Copy( const_dict_214d5d3fa9eae68a8726794127da42a3 ); | ||
| 677 | frame_661f64abf7d853df92ffc10bd5c6cf99->m_frame.f_lineno = 38; | ||
| 678 | tmp_assign_source_6 = CALL_FUNCTION( tmp_called_name_4, tmp_args_name_2, tmp_kw_name_3 ); | ||
| 679 | Py_DECREF( tmp_called_name_4 ); | ||
| 680 | Py_DECREF( tmp_args_name_2 ); | ||
| 681 | Py_DECREF( tmp_kw_name_3 ); | ||
| 682 | if ( tmp_assign_source_6 == NULL ) | ||
| 683 | { | ||
| 684 | assert( ERROR_OCCURRED() ); | ||
| 685 | |||
| 686 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 687 | |||
| 688 | |||
| 689 | exception_lineno = 38; | ||
| 690 | type_description_1 = "oooooooo"; | ||
| 691 | goto frame_exception_exit_1; | ||
| 692 | } | ||
| 693 | assert( var_evt_match_old_path == NULL ); | ||
| 694 | var_evt_match_old_path = tmp_assign_source_6; | ||
| 695 | } | ||
| 696 | { | ||
| 697 | PyObject *tmp_assattr_name_4; | ||
| 698 | PyObject *tmp_called_instance_2; | ||
| 699 | PyObject *tmp_assattr_target_4; | ||
| 700 | CHECK_OBJECT( var_gobject ); | ||
| 701 | tmp_called_instance_2 = var_gobject; | ||
| 702 | frame_661f64abf7d853df92ffc10bd5c6cf99->m_frame.f_lineno = 42; | ||
| 703 | tmp_assattr_name_4 = CALL_METHOD_NO_ARGS( tmp_called_instance_2, const_str_plain_MainLoop ); | ||
| 704 | if ( tmp_assattr_name_4 == NULL ) | ||
| 705 | { | ||
| 706 | assert( ERROR_OCCURRED() ); | ||
| 707 | |||
| 708 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 709 | |||
| 710 | |||
| 711 | exception_lineno = 42; | ||
| 712 | type_description_1 = "oooooooo"; | ||
| 713 | goto frame_exception_exit_1; | ||
| 714 | } | ||
| 715 | CHECK_OBJECT( par_self ); | ||
| 716 | tmp_assattr_target_4 = par_self; | ||
| 717 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_4, const_str_plain_loop, tmp_assattr_name_4 ); | ||
| 718 | Py_DECREF( tmp_assattr_name_4 ); | ||
| 719 | if ( tmp_result == false ) | ||
| 720 | { | ||
| 721 | assert( ERROR_OCCURRED() ); | ||
| 722 | |||
| 723 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 724 | |||
| 725 | |||
| 726 | exception_lineno = 42; | ||
| 727 | type_description_1 = "oooooooo"; | ||
| 728 | goto frame_exception_exit_1; | ||
| 729 | } | ||
| 730 | } | ||
| 731 | |||
| 732 | #if 0 | ||
| 733 | RESTORE_FRAME_EXCEPTION( frame_661f64abf7d853df92ffc10bd5c6cf99 ); | ||
| 734 | #endif | ||
| 735 | |||
| 736 | // Put the previous frame back on top. | ||
| 737 | popFrameStack(); | ||
| 738 | |||
| 739 | goto frame_no_exception_1; | ||
| 740 | |||
| 741 | frame_exception_exit_1:; | ||
| 742 | |||
| 743 | #if 0 | ||
| 744 | RESTORE_FRAME_EXCEPTION( frame_661f64abf7d853df92ffc10bd5c6cf99 ); | ||
| 745 | #endif | ||
| 746 | |||
| 747 | if ( exception_tb == NULL ) | ||
| 748 | { | ||
| 749 | exception_tb = MAKE_TRACEBACK( frame_661f64abf7d853df92ffc10bd5c6cf99, exception_lineno ); | ||
| 750 | } | ||
| 751 | else if ( exception_tb->tb_frame != &frame_661f64abf7d853df92ffc10bd5c6cf99->m_frame ) | ||
| 752 | { | ||
| 753 | exception_tb = ADD_TRACEBACK( exception_tb, frame_661f64abf7d853df92ffc10bd5c6cf99, exception_lineno ); | ||
| 754 | } | ||
| 755 | |||
| 756 | // Attachs locals to frame if any. | ||
| 757 | Nuitka_Frame_AttachLocals( | ||
| 758 | (struct Nuitka_FrameObject *)frame_661f64abf7d853df92ffc10bd5c6cf99, | ||
| 759 | type_description_1, | ||
| 760 | par_self, | ||
| 761 | par_auth, | ||
| 762 | var_dbus, | ||
| 763 | var_gobject, | ||
| 764 | var_DBusGMainLoop, | ||
| 765 | var_bus, | ||
| 766 | var_evt_match, | ||
| 767 | var_evt_match_old_path | ||
| 768 | ); | ||
| 769 | |||
| 770 | |||
| 771 | // Release cached frame. | ||
| 772 | if ( frame_661f64abf7d853df92ffc10bd5c6cf99 == cache_frame_661f64abf7d853df92ffc10bd5c6cf99 ) | ||
| 773 | { | ||
| 774 | Py_DECREF( frame_661f64abf7d853df92ffc10bd5c6cf99 ); | ||
| 775 | } | ||
| 776 | cache_frame_661f64abf7d853df92ffc10bd5c6cf99 = NULL; | ||
| 777 | |||
| 778 | assertFrameObject( frame_661f64abf7d853df92ffc10bd5c6cf99 ); | ||
| 779 | |||
| 780 | // Put the previous frame back on top. | ||
| 781 | popFrameStack(); | ||
| 782 | |||
| 783 | // Return the error. | ||
| 784 | goto try_except_handler_1; | ||
| 785 | |||
| 786 | frame_no_exception_1:; | ||
| 787 | tmp_return_value = Py_None; | ||
| 788 | Py_INCREF( tmp_return_value ); | ||
| 789 | goto try_return_handler_1; | ||
| 790 | // tried codes exits in all cases | ||
| 791 | NUITKA_CANNOT_GET_HERE( problem$watch$$$function_1___init__ ); | ||
| 792 | return NULL; | ||
| 793 | // Return handler code: | ||
| 794 | try_return_handler_1:; | ||
| 795 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 796 | Py_DECREF( par_self ); | ||
| 797 | par_self = NULL; | ||
| 798 | |||
| 799 | CHECK_OBJECT( (PyObject *)par_auth ); | ||
| 800 | Py_DECREF( par_auth ); | ||
| 801 | par_auth = NULL; | ||
| 802 | |||
| 803 | CHECK_OBJECT( (PyObject *)var_dbus ); | ||
| 804 | Py_DECREF( var_dbus ); | ||
| 805 | var_dbus = NULL; | ||
| 806 | |||
| 807 | CHECK_OBJECT( (PyObject *)var_gobject ); | ||
| 808 | Py_DECREF( var_gobject ); | ||
| 809 | var_gobject = NULL; | ||
| 810 | |||
| 811 | CHECK_OBJECT( (PyObject *)var_DBusGMainLoop ); | ||
| 812 | Py_DECREF( var_DBusGMainLoop ); | ||
| 813 | var_DBusGMainLoop = NULL; | ||
| 814 | |||
| 815 | CHECK_OBJECT( (PyObject *)var_bus ); | ||
| 816 | Py_DECREF( var_bus ); | ||
| 817 | var_bus = NULL; | ||
| 818 | |||
| 819 | CHECK_OBJECT( (PyObject *)var_evt_match ); | ||
| 820 | Py_DECREF( var_evt_match ); | ||
| 821 | var_evt_match = NULL; | ||
| 822 | |||
| 823 | CHECK_OBJECT( (PyObject *)var_evt_match_old_path ); | ||
| 824 | Py_DECREF( var_evt_match_old_path ); | ||
| 825 | var_evt_match_old_path = NULL; | ||
| 826 | |||
| 827 | goto function_return_exit; | ||
| 828 | // Exception handler code: | ||
| 829 | try_except_handler_1:; | ||
| 830 | exception_keeper_type_1 = exception_type; | ||
| 831 | exception_keeper_value_1 = exception_value; | ||
| 832 | exception_keeper_tb_1 = exception_tb; | ||
| 833 | exception_keeper_lineno_1 = exception_lineno; | ||
| 834 | exception_type = NULL; | ||
| 835 | exception_value = NULL; | ||
| 836 | exception_tb = NULL; | ||
| 837 | exception_lineno = 0; | ||
| 838 | |||
| 839 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 840 | Py_DECREF( par_self ); | ||
| 841 | par_self = NULL; | ||
| 842 | |||
| 843 | CHECK_OBJECT( (PyObject *)par_auth ); | ||
| 844 | Py_DECREF( par_auth ); | ||
| 845 | par_auth = NULL; | ||
| 846 | |||
| 847 | Py_XDECREF( var_dbus ); | ||
| 848 | var_dbus = NULL; | ||
| 849 | |||
| 850 | Py_XDECREF( var_gobject ); | ||
| 851 | var_gobject = NULL; | ||
| 852 | |||
| 853 | Py_XDECREF( var_DBusGMainLoop ); | ||
| 854 | var_DBusGMainLoop = NULL; | ||
| 855 | |||
| 856 | Py_XDECREF( var_bus ); | ||
| 857 | var_bus = NULL; | ||
| 858 | |||
| 859 | Py_XDECREF( var_evt_match ); | ||
| 860 | var_evt_match = NULL; | ||
| 861 | |||
| 862 | Py_XDECREF( var_evt_match_old_path ); | ||
| 863 | var_evt_match_old_path = NULL; | ||
| 864 | |||
| 865 | // Re-raise. | ||
| 866 | exception_type = exception_keeper_type_1; | ||
| 867 | exception_value = exception_keeper_value_1; | ||
| 868 | exception_tb = exception_keeper_tb_1; | ||
| 869 | exception_lineno = exception_keeper_lineno_1; | ||
| 870 | |||
| 871 | goto function_exception_exit; | ||
| 872 | // End of try: | ||
| 873 | |||
| 874 | // Return statement must have exited already. | ||
| 875 | NUITKA_CANNOT_GET_HERE( problem$watch$$$function_1___init__ ); | ||
| 876 | return NULL; | ||
| 877 | |||
| 878 | function_exception_exit: | ||
| 879 | assert( exception_type ); | ||
| 880 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 881 | |||
| 882 | return NULL; | ||
| 883 | |||
| 884 | function_return_exit: | ||
| 885 | // Function cleanup code if any. | ||
| 886 | |||
| 887 | |||
| 888 | // Actual function exit with return value, making sure we did not make | ||
| 889 | // the error status worse despite non-NULL return. | ||
| 890 | CHECK_OBJECT( tmp_return_value ); | ||
| 891 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 892 | return tmp_return_value; | ||
| 893 | } | ||
| 894 | |||
| 895 | |||
| 896 | static PyObject *impl_problem$watch$$$function_2__new_problem_handler( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 897 | { | ||
| 898 | // Preserve error status for checks | ||
| 899 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 900 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 901 | #endif | ||
| 902 | |||
| 903 | // Local variable declarations. | ||
| 904 | PyObject *par_self = python_pars[ 0 ]; | ||
| 905 | PyObject *par_comp = python_pars[ 1 ]; | ||
| 906 | PyObject *par_ddir = python_pars[ 2 ]; | ||
| 907 | PyObject *par_uid = python_pars[ 3 ]; | ||
| 908 | PyObject *par_uuid = python_pars[ 4 ]; | ||
| 909 | PyObject *par_duphash = python_pars[ 5 ]; | ||
| 910 | PyObject *var_prob = NULL; | ||
| 911 | PyObject *var_cb = NULL; | ||
| 912 | PyObject *tmp_for_loop_1__for_iterator = NULL; | ||
| 913 | PyObject *tmp_for_loop_1__iter_value = NULL; | ||
| 914 | struct Nuitka_FrameObject *frame_784f5e5265e35255ee834cc666e1c059; | ||
| 915 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 916 | PyObject *exception_type = NULL; | ||
| 917 | PyObject *exception_value = NULL; | ||
| 918 | PyTracebackObject *exception_tb = NULL; | ||
| 919 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 920 | int tmp_res; | ||
| 921 | PyObject *tmp_return_value = NULL; | ||
| 922 | PyObject *exception_keeper_type_1; | ||
| 923 | PyObject *exception_keeper_value_1; | ||
| 924 | PyTracebackObject *exception_keeper_tb_1; | ||
| 925 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 926 | static struct Nuitka_FrameObject *cache_frame_784f5e5265e35255ee834cc666e1c059 = NULL; | ||
| 927 | PyObject *exception_keeper_type_2; | ||
| 928 | PyObject *exception_keeper_value_2; | ||
| 929 | PyTracebackObject *exception_keeper_tb_2; | ||
| 930 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 931 | |||
| 932 | // Actual function body. | ||
| 933 | // Tried code: | ||
| 934 | MAKE_OR_REUSE_FRAME( cache_frame_784f5e5265e35255ee834cc666e1c059, codeobj_784f5e5265e35255ee834cc666e1c059, module_problem$watch, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 935 | frame_784f5e5265e35255ee834cc666e1c059 = cache_frame_784f5e5265e35255ee834cc666e1c059; | ||
| 936 | |||
| 937 | // Push the new frame as the currently active one. | ||
| 938 | pushFrameStack( frame_784f5e5265e35255ee834cc666e1c059 ); | ||
| 939 | |||
| 940 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 941 | assert( Py_REFCNT( frame_784f5e5265e35255ee834cc666e1c059 ) == 2 ); // Frame stack | ||
| 942 | |||
| 943 | // Framed code: | ||
| 944 | { | ||
| 945 | PyObject *tmp_called_instance_1; | ||
| 946 | PyObject *tmp_mvar_value_1; | ||
| 947 | PyObject *tmp_call_result_1; | ||
| 948 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain_logging ); | ||
| 949 | |||
| 950 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 951 | { | ||
| 952 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_logging ); | ||
| 953 | } | ||
| 954 | |||
| 955 | if ( tmp_mvar_value_1 == NULL ) | ||
| 956 | { | ||
| 957 | |||
| 958 | exception_type = PyExc_NameError; | ||
| 959 | Py_INCREF( exception_type ); | ||
| 960 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "logging" ); | ||
| 961 | exception_tb = NULL; | ||
| 962 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 963 | CHAIN_EXCEPTION( exception_value ); | ||
| 964 | |||
| 965 | exception_lineno = 45; | ||
| 966 | type_description_1 = "oooooooo"; | ||
| 967 | goto frame_exception_exit_1; | ||
| 968 | } | ||
| 969 | |||
| 970 | tmp_called_instance_1 = tmp_mvar_value_1; | ||
| 971 | frame_784f5e5265e35255ee834cc666e1c059->m_frame.f_lineno = 45; | ||
| 972 | tmp_call_result_1 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_1, const_str_plain_debug, &PyTuple_GET_ITEM( const_tuple_str_digest_d24697c673930d75fe1aca791c659f37_tuple, 0 ) ); | ||
| 973 | |||
| 974 | if ( tmp_call_result_1 == NULL ) | ||
| 975 | { | ||
| 976 | assert( ERROR_OCCURRED() ); | ||
| 977 | |||
| 978 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 979 | |||
| 980 | |||
| 981 | exception_lineno = 45; | ||
| 982 | type_description_1 = "oooooooo"; | ||
| 983 | goto frame_exception_exit_1; | ||
| 984 | } | ||
| 985 | Py_DECREF( tmp_call_result_1 ); | ||
| 986 | } | ||
| 987 | { | ||
| 988 | nuitka_bool tmp_condition_result_1; | ||
| 989 | int tmp_and_left_truth_1; | ||
| 990 | nuitka_bool tmp_and_left_value_1; | ||
| 991 | nuitka_bool tmp_and_right_value_1; | ||
| 992 | PyObject *tmp_compexpr_left_1; | ||
| 993 | PyObject *tmp_compexpr_right_1; | ||
| 994 | PyObject *tmp_int_arg_1; | ||
| 995 | PyObject *tmp_called_instance_2; | ||
| 996 | PyObject *tmp_mvar_value_2; | ||
| 997 | PyObject *tmp_operand_name_1; | ||
| 998 | PyObject *tmp_source_name_1; | ||
| 999 | CHECK_OBJECT( par_uid ); | ||
| 1000 | tmp_int_arg_1 = par_uid; | ||
| 1001 | tmp_compexpr_left_1 = PyNumber_Int( tmp_int_arg_1 ); | ||
| 1002 | if ( tmp_compexpr_left_1 == NULL ) | ||
| 1003 | { | ||
| 1004 | assert( ERROR_OCCURRED() ); | ||
| 1005 | |||
| 1006 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1007 | |||
| 1008 | |||
| 1009 | exception_lineno = 46; | ||
| 1010 | type_description_1 = "oooooooo"; | ||
| 1011 | goto frame_exception_exit_1; | ||
| 1012 | } | ||
| 1013 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1014 | |||
| 1015 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 1016 | { | ||
| 1017 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1018 | } | ||
| 1019 | |||
| 1020 | if ( tmp_mvar_value_2 == NULL ) | ||
| 1021 | { | ||
| 1022 | Py_DECREF( tmp_compexpr_left_1 ); | ||
| 1023 | exception_type = PyExc_NameError; | ||
| 1024 | Py_INCREF( exception_type ); | ||
| 1025 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "os" ); | ||
| 1026 | exception_tb = NULL; | ||
| 1027 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1028 | CHAIN_EXCEPTION( exception_value ); | ||
| 1029 | |||
| 1030 | exception_lineno = 46; | ||
| 1031 | type_description_1 = "oooooooo"; | ||
| 1032 | goto frame_exception_exit_1; | ||
| 1033 | } | ||
| 1034 | |||
| 1035 | tmp_called_instance_2 = tmp_mvar_value_2; | ||
| 1036 | frame_784f5e5265e35255ee834cc666e1c059->m_frame.f_lineno = 46; | ||
| 1037 | tmp_compexpr_right_1 = CALL_METHOD_NO_ARGS( tmp_called_instance_2, const_str_plain_getuid ); | ||
| 1038 | if ( tmp_compexpr_right_1 == NULL ) | ||
| 1039 | { | ||
| 1040 | assert( ERROR_OCCURRED() ); | ||
| 1041 | |||
| 1042 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1043 | Py_DECREF( tmp_compexpr_left_1 ); | ||
| 1044 | |||
| 1045 | exception_lineno = 46; | ||
| 1046 | type_description_1 = "oooooooo"; | ||
| 1047 | goto frame_exception_exit_1; | ||
| 1048 | } | ||
| 1049 | tmp_res = RICH_COMPARE_BOOL_NOTEQ_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 1050 | Py_DECREF( tmp_compexpr_left_1 ); | ||
| 1051 | Py_DECREF( tmp_compexpr_right_1 ); | ||
| 1052 | if ( tmp_res == -1 ) | ||
| 1053 | { | ||
| 1054 | assert( ERROR_OCCURRED() ); | ||
| 1055 | |||
| 1056 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1057 | |||
| 1058 | |||
| 1059 | exception_lineno = 46; | ||
| 1060 | type_description_1 = "oooooooo"; | ||
| 1061 | goto frame_exception_exit_1; | ||
| 1062 | } | ||
| 1063 | tmp_and_left_value_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1064 | tmp_and_left_truth_1 = tmp_and_left_value_1 == NUITKA_BOOL_TRUE ? 1 : 0; | ||
| 1065 | if ( tmp_and_left_truth_1 == 1 ) | ||
| 1066 | { | ||
| 1067 | goto and_right_1; | ||
| 1068 | } | ||
| 1069 | else | ||
| 1070 | { | ||
| 1071 | goto and_left_1; | ||
| 1072 | } | ||
| 1073 | and_right_1:; | ||
| 1074 | CHECK_OBJECT( par_self ); | ||
| 1075 | tmp_source_name_1 = par_self; | ||
| 1076 | tmp_operand_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_auth ); | ||
| 1077 | if ( tmp_operand_name_1 == NULL ) | ||
| 1078 | { | ||
| 1079 | assert( ERROR_OCCURRED() ); | ||
| 1080 | |||
| 1081 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1082 | |||
| 1083 | |||
| 1084 | exception_lineno = 46; | ||
| 1085 | type_description_1 = "oooooooo"; | ||
| 1086 | goto frame_exception_exit_1; | ||
| 1087 | } | ||
| 1088 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 1089 | Py_DECREF( tmp_operand_name_1 ); | ||
| 1090 | if ( tmp_res == -1 ) | ||
| 1091 | { | ||
| 1092 | assert( ERROR_OCCURRED() ); | ||
| 1093 | |||
| 1094 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1095 | |||
| 1096 | |||
| 1097 | exception_lineno = 46; | ||
| 1098 | type_description_1 = "oooooooo"; | ||
| 1099 | goto frame_exception_exit_1; | ||
| 1100 | } | ||
| 1101 | tmp_and_right_value_1 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1102 | tmp_condition_result_1 = tmp_and_right_value_1; | ||
| 1103 | goto and_end_1; | ||
| 1104 | and_left_1:; | ||
| 1105 | tmp_condition_result_1 = tmp_and_left_value_1; | ||
| 1106 | and_end_1:; | ||
| 1107 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 1108 | { | ||
| 1109 | goto branch_yes_1; | ||
| 1110 | } | ||
| 1111 | else | ||
| 1112 | { | ||
| 1113 | goto branch_no_1; | ||
| 1114 | } | ||
| 1115 | branch_yes_1:; | ||
| 1116 | { | ||
| 1117 | PyObject *tmp_called_name_1; | ||
| 1118 | PyObject *tmp_source_name_2; | ||
| 1119 | PyObject *tmp_mvar_value_3; | ||
| 1120 | PyObject *tmp_call_result_2; | ||
| 1121 | PyObject *tmp_args_element_name_1; | ||
| 1122 | PyObject *tmp_called_instance_3; | ||
| 1123 | PyObject *tmp_args_element_name_2; | ||
| 1124 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain_logging ); | ||
| 1125 | |||
| 1126 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 1127 | { | ||
| 1128 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_logging ); | ||
| 1129 | } | ||
| 1130 | |||
| 1131 | if ( tmp_mvar_value_3 == NULL ) | ||
| 1132 | { | ||
| 1133 | |||
| 1134 | exception_type = PyExc_NameError; | ||
| 1135 | Py_INCREF( exception_type ); | ||
| 1136 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "logging" ); | ||
| 1137 | exception_tb = NULL; | ||
| 1138 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1139 | CHAIN_EXCEPTION( exception_value ); | ||
| 1140 | |||
| 1141 | exception_lineno = 47; | ||
| 1142 | type_description_1 = "oooooooo"; | ||
| 1143 | goto frame_exception_exit_1; | ||
| 1144 | } | ||
| 1145 | |||
| 1146 | tmp_source_name_2 = tmp_mvar_value_3; | ||
| 1147 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_debug ); | ||
| 1148 | if ( tmp_called_name_1 == NULL ) | ||
| 1149 | { | ||
| 1150 | assert( ERROR_OCCURRED() ); | ||
| 1151 | |||
| 1152 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1153 | |||
| 1154 | |||
| 1155 | exception_lineno = 47; | ||
| 1156 | type_description_1 = "oooooooo"; | ||
| 1157 | goto frame_exception_exit_1; | ||
| 1158 | } | ||
| 1159 | tmp_called_instance_3 = const_str_digest_43d8e4fe59387d69a0785160b55bc74b; | ||
| 1160 | CHECK_OBJECT( par_uid ); | ||
| 1161 | tmp_args_element_name_2 = par_uid; | ||
| 1162 | frame_784f5e5265e35255ee834cc666e1c059->m_frame.f_lineno = 47; | ||
| 1163 | { | ||
| 1164 | PyObject *call_args[] = { tmp_args_element_name_2 }; | ||
| 1165 | tmp_args_element_name_1 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_3, const_str_plain_format, call_args ); | ||
| 1166 | } | ||
| 1167 | |||
| 1168 | if ( tmp_args_element_name_1 == NULL ) | ||
| 1169 | { | ||
| 1170 | assert( ERROR_OCCURRED() ); | ||
| 1171 | |||
| 1172 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1173 | Py_DECREF( tmp_called_name_1 ); | ||
| 1174 | |||
| 1175 | exception_lineno = 47; | ||
| 1176 | type_description_1 = "oooooooo"; | ||
| 1177 | goto frame_exception_exit_1; | ||
| 1178 | } | ||
| 1179 | frame_784f5e5265e35255ee834cc666e1c059->m_frame.f_lineno = 47; | ||
| 1180 | { | ||
| 1181 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 1182 | tmp_call_result_2 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, call_args ); | ||
| 1183 | } | ||
| 1184 | |||
| 1185 | Py_DECREF( tmp_called_name_1 ); | ||
| 1186 | Py_DECREF( tmp_args_element_name_1 ); | ||
| 1187 | if ( tmp_call_result_2 == NULL ) | ||
| 1188 | { | ||
| 1189 | assert( ERROR_OCCURRED() ); | ||
| 1190 | |||
| 1191 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1192 | |||
| 1193 | |||
| 1194 | exception_lineno = 47; | ||
| 1195 | type_description_1 = "oooooooo"; | ||
| 1196 | goto frame_exception_exit_1; | ||
| 1197 | } | ||
| 1198 | Py_DECREF( tmp_call_result_2 ); | ||
| 1199 | } | ||
| 1200 | tmp_return_value = Py_None; | ||
| 1201 | Py_INCREF( tmp_return_value ); | ||
| 1202 | goto frame_return_exit_1; | ||
| 1203 | branch_no_1:; | ||
| 1204 | } | ||
| 1205 | { | ||
| 1206 | PyObject *tmp_assign_source_1; | ||
| 1207 | PyObject *tmp_called_name_2; | ||
| 1208 | PyObject *tmp_source_name_3; | ||
| 1209 | PyObject *tmp_source_name_4; | ||
| 1210 | PyObject *tmp_mvar_value_4; | ||
| 1211 | PyObject *tmp_args_element_name_3; | ||
| 1212 | PyObject *tmp_args_element_name_4; | ||
| 1213 | PyObject *tmp_called_instance_4; | ||
| 1214 | PyObject *tmp_source_name_5; | ||
| 1215 | PyObject *tmp_mvar_value_5; | ||
| 1216 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain_problem ); | ||
| 1217 | |||
| 1218 | if (unlikely( tmp_mvar_value_4 == NULL )) | ||
| 1219 | { | ||
| 1220 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_problem ); | ||
| 1221 | } | ||
| 1222 | |||
| 1223 | if ( tmp_mvar_value_4 == NULL ) | ||
| 1224 | { | ||
| 1225 | |||
| 1226 | exception_type = PyExc_NameError; | ||
| 1227 | Py_INCREF( exception_type ); | ||
| 1228 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "problem" ); | ||
| 1229 | exception_tb = NULL; | ||
| 1230 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1231 | CHAIN_EXCEPTION( exception_value ); | ||
| 1232 | |||
| 1233 | exception_lineno = 51; | ||
| 1234 | type_description_1 = "oooooooo"; | ||
| 1235 | goto frame_exception_exit_1; | ||
| 1236 | } | ||
| 1237 | |||
| 1238 | tmp_source_name_4 = tmp_mvar_value_4; | ||
| 1239 | tmp_source_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain_tools ); | ||
| 1240 | if ( tmp_source_name_3 == NULL ) | ||
| 1241 | { | ||
| 1242 | assert( ERROR_OCCURRED() ); | ||
| 1243 | |||
| 1244 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1245 | |||
| 1246 | |||
| 1247 | exception_lineno = 51; | ||
| 1248 | type_description_1 = "oooooooo"; | ||
| 1249 | goto frame_exception_exit_1; | ||
| 1250 | } | ||
| 1251 | tmp_called_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_problemify ); | ||
| 1252 | Py_DECREF( tmp_source_name_3 ); | ||
| 1253 | if ( tmp_called_name_2 == NULL ) | ||
| 1254 | { | ||
| 1255 | assert( ERROR_OCCURRED() ); | ||
| 1256 | |||
| 1257 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1258 | |||
| 1259 | |||
| 1260 | exception_lineno = 51; | ||
| 1261 | type_description_1 = "oooooooo"; | ||
| 1262 | goto frame_exception_exit_1; | ||
| 1263 | } | ||
| 1264 | CHECK_OBJECT( par_ddir ); | ||
| 1265 | tmp_args_element_name_3 = par_ddir; | ||
| 1266 | tmp_mvar_value_5 = GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain_problem ); | ||
| 1267 | |||
| 1268 | if (unlikely( tmp_mvar_value_5 == NULL )) | ||
| 1269 | { | ||
| 1270 | tmp_mvar_value_5 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_problem ); | ||
| 1271 | } | ||
| 1272 | |||
| 1273 | if ( tmp_mvar_value_5 == NULL ) | ||
| 1274 | { | ||
| 1275 | Py_DECREF( tmp_called_name_2 ); | ||
| 1276 | exception_type = PyExc_NameError; | ||
| 1277 | Py_INCREF( exception_type ); | ||
| 1278 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "problem" ); | ||
| 1279 | exception_tb = NULL; | ||
| 1280 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1281 | CHAIN_EXCEPTION( exception_value ); | ||
| 1282 | |||
| 1283 | exception_lineno = 51; | ||
| 1284 | type_description_1 = "oooooooo"; | ||
| 1285 | goto frame_exception_exit_1; | ||
| 1286 | } | ||
| 1287 | |||
| 1288 | tmp_source_name_5 = tmp_mvar_value_5; | ||
| 1289 | tmp_called_instance_4 = LOOKUP_ATTRIBUTE( tmp_source_name_5, const_str_plain_proxies ); | ||
| 1290 | if ( tmp_called_instance_4 == NULL ) | ||
| 1291 | { | ||
| 1292 | assert( ERROR_OCCURRED() ); | ||
| 1293 | |||
| 1294 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1295 | Py_DECREF( tmp_called_name_2 ); | ||
| 1296 | |||
| 1297 | exception_lineno = 51; | ||
| 1298 | type_description_1 = "oooooooo"; | ||
| 1299 | goto frame_exception_exit_1; | ||
| 1300 | } | ||
| 1301 | frame_784f5e5265e35255ee834cc666e1c059->m_frame.f_lineno = 51; | ||
| 1302 | tmp_args_element_name_4 = CALL_METHOD_NO_ARGS( tmp_called_instance_4, const_str_plain_get_proxy ); | ||
| 1303 | Py_DECREF( tmp_called_instance_4 ); | ||
| 1304 | if ( tmp_args_element_name_4 == NULL ) | ||
| 1305 | { | ||
| 1306 | assert( ERROR_OCCURRED() ); | ||
| 1307 | |||
| 1308 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1309 | Py_DECREF( tmp_called_name_2 ); | ||
| 1310 | |||
| 1311 | exception_lineno = 51; | ||
| 1312 | type_description_1 = "oooooooo"; | ||
| 1313 | goto frame_exception_exit_1; | ||
| 1314 | } | ||
| 1315 | frame_784f5e5265e35255ee834cc666e1c059->m_frame.f_lineno = 51; | ||
| 1316 | { | ||
| 1317 | PyObject *call_args[] = { tmp_args_element_name_3, tmp_args_element_name_4 }; | ||
| 1318 | tmp_assign_source_1 = CALL_FUNCTION_WITH_ARGS2( tmp_called_name_2, call_args ); | ||
| 1319 | } | ||
| 1320 | |||
| 1321 | Py_DECREF( tmp_called_name_2 ); | ||
| 1322 | Py_DECREF( tmp_args_element_name_4 ); | ||
| 1323 | if ( tmp_assign_source_1 == NULL ) | ||
| 1324 | { | ||
| 1325 | assert( ERROR_OCCURRED() ); | ||
| 1326 | |||
| 1327 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1328 | |||
| 1329 | |||
| 1330 | exception_lineno = 51; | ||
| 1331 | type_description_1 = "oooooooo"; | ||
| 1332 | goto frame_exception_exit_1; | ||
| 1333 | } | ||
| 1334 | assert( var_prob == NULL ); | ||
| 1335 | var_prob = tmp_assign_source_1; | ||
| 1336 | } | ||
| 1337 | { | ||
| 1338 | PyObject *tmp_assign_source_2; | ||
| 1339 | PyObject *tmp_iter_arg_1; | ||
| 1340 | PyObject *tmp_source_name_6; | ||
| 1341 | CHECK_OBJECT( par_self ); | ||
| 1342 | tmp_source_name_6 = par_self; | ||
| 1343 | tmp_iter_arg_1 = LOOKUP_ATTRIBUTE( tmp_source_name_6, const_str_plain_callbacks ); | ||
| 1344 | if ( tmp_iter_arg_1 == NULL ) | ||
| 1345 | { | ||
| 1346 | assert( ERROR_OCCURRED() ); | ||
| 1347 | |||
| 1348 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1349 | |||
| 1350 | |||
| 1351 | exception_lineno = 52; | ||
| 1352 | type_description_1 = "oooooooo"; | ||
| 1353 | goto frame_exception_exit_1; | ||
| 1354 | } | ||
| 1355 | tmp_assign_source_2 = MAKE_ITERATOR( tmp_iter_arg_1 ); | ||
| 1356 | Py_DECREF( tmp_iter_arg_1 ); | ||
| 1357 | if ( tmp_assign_source_2 == NULL ) | ||
| 1358 | { | ||
| 1359 | assert( ERROR_OCCURRED() ); | ||
| 1360 | |||
| 1361 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1362 | |||
| 1363 | |||
| 1364 | exception_lineno = 52; | ||
| 1365 | type_description_1 = "oooooooo"; | ||
| 1366 | goto frame_exception_exit_1; | ||
| 1367 | } | ||
| 1368 | assert( tmp_for_loop_1__for_iterator == NULL ); | ||
| 1369 | tmp_for_loop_1__for_iterator = tmp_assign_source_2; | ||
| 1370 | } | ||
| 1371 | // Tried code: | ||
| 1372 | loop_start_1:; | ||
| 1373 | { | ||
| 1374 | PyObject *tmp_next_source_1; | ||
| 1375 | PyObject *tmp_assign_source_3; | ||
| 1376 | CHECK_OBJECT( tmp_for_loop_1__for_iterator ); | ||
| 1377 | tmp_next_source_1 = tmp_for_loop_1__for_iterator; | ||
| 1378 | tmp_assign_source_3 = ITERATOR_NEXT( tmp_next_source_1 ); | ||
| 1379 | if ( tmp_assign_source_3 == NULL ) | ||
| 1380 | { | ||
| 1381 | if ( CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED() ) | ||
| 1382 | { | ||
| 1383 | |||
| 1384 | goto loop_end_1; | ||
| 1385 | } | ||
| 1386 | else | ||
| 1387 | { | ||
| 1388 | |||
| 1389 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1390 | type_description_1 = "oooooooo"; | ||
| 1391 | exception_lineno = 52; | ||
| 1392 | goto try_except_handler_2; | ||
| 1393 | } | ||
| 1394 | } | ||
| 1395 | |||
| 1396 | { | ||
| 1397 | PyObject *old = tmp_for_loop_1__iter_value; | ||
| 1398 | tmp_for_loop_1__iter_value = tmp_assign_source_3; | ||
| 1399 | Py_XDECREF( old ); | ||
| 1400 | } | ||
| 1401 | |||
| 1402 | } | ||
| 1403 | { | ||
| 1404 | PyObject *tmp_assign_source_4; | ||
| 1405 | CHECK_OBJECT( tmp_for_loop_1__iter_value ); | ||
| 1406 | tmp_assign_source_4 = tmp_for_loop_1__iter_value; | ||
| 1407 | { | ||
| 1408 | PyObject *old = var_cb; | ||
| 1409 | var_cb = tmp_assign_source_4; | ||
| 1410 | Py_INCREF( var_cb ); | ||
| 1411 | Py_XDECREF( old ); | ||
| 1412 | } | ||
| 1413 | |||
| 1414 | } | ||
| 1415 | { | ||
| 1416 | PyObject *tmp_called_name_3; | ||
| 1417 | PyObject *tmp_call_result_3; | ||
| 1418 | PyObject *tmp_args_element_name_5; | ||
| 1419 | CHECK_OBJECT( var_cb ); | ||
| 1420 | tmp_called_name_3 = var_cb; | ||
| 1421 | CHECK_OBJECT( var_prob ); | ||
| 1422 | tmp_args_element_name_5 = var_prob; | ||
| 1423 | frame_784f5e5265e35255ee834cc666e1c059->m_frame.f_lineno = 53; | ||
| 1424 | { | ||
| 1425 | PyObject *call_args[] = { tmp_args_element_name_5 }; | ||
| 1426 | tmp_call_result_3 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_3, call_args ); | ||
| 1427 | } | ||
| 1428 | |||
| 1429 | if ( tmp_call_result_3 == NULL ) | ||
| 1430 | { | ||
| 1431 | assert( ERROR_OCCURRED() ); | ||
| 1432 | |||
| 1433 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1434 | |||
| 1435 | |||
| 1436 | exception_lineno = 53; | ||
| 1437 | type_description_1 = "oooooooo"; | ||
| 1438 | goto try_except_handler_2; | ||
| 1439 | } | ||
| 1440 | Py_DECREF( tmp_call_result_3 ); | ||
| 1441 | } | ||
| 1442 | if ( CONSIDER_THREADING() == false ) | ||
| 1443 | { | ||
| 1444 | assert( ERROR_OCCURRED() ); | ||
| 1445 | |||
| 1446 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1447 | |||
| 1448 | |||
| 1449 | exception_lineno = 52; | ||
| 1450 | type_description_1 = "oooooooo"; | ||
| 1451 | goto try_except_handler_2; | ||
| 1452 | } | ||
| 1453 | goto loop_start_1; | ||
| 1454 | loop_end_1:; | ||
| 1455 | goto try_end_1; | ||
| 1456 | // Exception handler code: | ||
| 1457 | try_except_handler_2:; | ||
| 1458 | exception_keeper_type_1 = exception_type; | ||
| 1459 | exception_keeper_value_1 = exception_value; | ||
| 1460 | exception_keeper_tb_1 = exception_tb; | ||
| 1461 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1462 | exception_type = NULL; | ||
| 1463 | exception_value = NULL; | ||
| 1464 | exception_tb = NULL; | ||
| 1465 | exception_lineno = 0; | ||
| 1466 | |||
| 1467 | Py_XDECREF( tmp_for_loop_1__iter_value ); | ||
| 1468 | tmp_for_loop_1__iter_value = NULL; | ||
| 1469 | |||
| 1470 | CHECK_OBJECT( (PyObject *)tmp_for_loop_1__for_iterator ); | ||
| 1471 | Py_DECREF( tmp_for_loop_1__for_iterator ); | ||
| 1472 | tmp_for_loop_1__for_iterator = NULL; | ||
| 1473 | |||
| 1474 | // Re-raise. | ||
| 1475 | exception_type = exception_keeper_type_1; | ||
| 1476 | exception_value = exception_keeper_value_1; | ||
| 1477 | exception_tb = exception_keeper_tb_1; | ||
| 1478 | exception_lineno = exception_keeper_lineno_1; | ||
| 1479 | |||
| 1480 | goto frame_exception_exit_1; | ||
| 1481 | // End of try: | ||
| 1482 | try_end_1:; | ||
| 1483 | |||
| 1484 | #if 0 | ||
| 1485 | RESTORE_FRAME_EXCEPTION( frame_784f5e5265e35255ee834cc666e1c059 ); | ||
| 1486 | #endif | ||
| 1487 | |||
| 1488 | // Put the previous frame back on top. | ||
| 1489 | popFrameStack(); | ||
| 1490 | |||
| 1491 | goto frame_no_exception_1; | ||
| 1492 | |||
| 1493 | frame_return_exit_1:; | ||
| 1494 | #if 0 | ||
| 1495 | RESTORE_FRAME_EXCEPTION( frame_784f5e5265e35255ee834cc666e1c059 ); | ||
| 1496 | #endif | ||
| 1497 | |||
| 1498 | // Put the previous frame back on top. | ||
| 1499 | popFrameStack(); | ||
| 1500 | |||
| 1501 | goto try_return_handler_1; | ||
| 1502 | |||
| 1503 | frame_exception_exit_1:; | ||
| 1504 | |||
| 1505 | #if 0 | ||
| 1506 | RESTORE_FRAME_EXCEPTION( frame_784f5e5265e35255ee834cc666e1c059 ); | ||
| 1507 | #endif | ||
| 1508 | |||
| 1509 | if ( exception_tb == NULL ) | ||
| 1510 | { | ||
| 1511 | exception_tb = MAKE_TRACEBACK( frame_784f5e5265e35255ee834cc666e1c059, exception_lineno ); | ||
| 1512 | } | ||
| 1513 | else if ( exception_tb->tb_frame != &frame_784f5e5265e35255ee834cc666e1c059->m_frame ) | ||
| 1514 | { | ||
| 1515 | exception_tb = ADD_TRACEBACK( exception_tb, frame_784f5e5265e35255ee834cc666e1c059, exception_lineno ); | ||
| 1516 | } | ||
| 1517 | |||
| 1518 | // Attachs locals to frame if any. | ||
| 1519 | Nuitka_Frame_AttachLocals( | ||
| 1520 | (struct Nuitka_FrameObject *)frame_784f5e5265e35255ee834cc666e1c059, | ||
| 1521 | type_description_1, | ||
| 1522 | par_self, | ||
| 1523 | par_comp, | ||
| 1524 | par_ddir, | ||
| 1525 | par_uid, | ||
| 1526 | par_uuid, | ||
| 1527 | par_duphash, | ||
| 1528 | var_prob, | ||
| 1529 | var_cb | ||
| 1530 | ); | ||
| 1531 | |||
| 1532 | |||
| 1533 | // Release cached frame. | ||
| 1534 | if ( frame_784f5e5265e35255ee834cc666e1c059 == cache_frame_784f5e5265e35255ee834cc666e1c059 ) | ||
| 1535 | { | ||
| 1536 | Py_DECREF( frame_784f5e5265e35255ee834cc666e1c059 ); | ||
| 1537 | } | ||
| 1538 | cache_frame_784f5e5265e35255ee834cc666e1c059 = NULL; | ||
| 1539 | |||
| 1540 | assertFrameObject( frame_784f5e5265e35255ee834cc666e1c059 ); | ||
| 1541 | |||
| 1542 | // Put the previous frame back on top. | ||
| 1543 | popFrameStack(); | ||
| 1544 | |||
| 1545 | // Return the error. | ||
| 1546 | goto try_except_handler_1; | ||
| 1547 | |||
| 1548 | frame_no_exception_1:; | ||
| 1549 | Py_XDECREF( tmp_for_loop_1__iter_value ); | ||
| 1550 | tmp_for_loop_1__iter_value = NULL; | ||
| 1551 | |||
| 1552 | CHECK_OBJECT( (PyObject *)tmp_for_loop_1__for_iterator ); | ||
| 1553 | Py_DECREF( tmp_for_loop_1__for_iterator ); | ||
| 1554 | tmp_for_loop_1__for_iterator = NULL; | ||
| 1555 | |||
| 1556 | tmp_return_value = Py_None; | ||
| 1557 | Py_INCREF( tmp_return_value ); | ||
| 1558 | goto try_return_handler_1; | ||
| 1559 | // tried codes exits in all cases | ||
| 1560 | NUITKA_CANNOT_GET_HERE( problem$watch$$$function_2__new_problem_handler ); | ||
| 1561 | return NULL; | ||
| 1562 | // Return handler code: | ||
| 1563 | try_return_handler_1:; | ||
| 1564 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1565 | Py_DECREF( par_self ); | ||
| 1566 | par_self = NULL; | ||
| 1567 | |||
| 1568 | CHECK_OBJECT( (PyObject *)par_comp ); | ||
| 1569 | Py_DECREF( par_comp ); | ||
| 1570 | par_comp = NULL; | ||
| 1571 | |||
| 1572 | CHECK_OBJECT( (PyObject *)par_ddir ); | ||
| 1573 | Py_DECREF( par_ddir ); | ||
| 1574 | par_ddir = NULL; | ||
| 1575 | |||
| 1576 | CHECK_OBJECT( (PyObject *)par_uid ); | ||
| 1577 | Py_DECREF( par_uid ); | ||
| 1578 | par_uid = NULL; | ||
| 1579 | |||
| 1580 | CHECK_OBJECT( (PyObject *)par_uuid ); | ||
| 1581 | Py_DECREF( par_uuid ); | ||
| 1582 | par_uuid = NULL; | ||
| 1583 | |||
| 1584 | CHECK_OBJECT( (PyObject *)par_duphash ); | ||
| 1585 | Py_DECREF( par_duphash ); | ||
| 1586 | par_duphash = NULL; | ||
| 1587 | |||
| 1588 | Py_XDECREF( var_prob ); | ||
| 1589 | var_prob = NULL; | ||
| 1590 | |||
| 1591 | Py_XDECREF( var_cb ); | ||
| 1592 | var_cb = NULL; | ||
| 1593 | |||
| 1594 | goto function_return_exit; | ||
| 1595 | // Exception handler code: | ||
| 1596 | try_except_handler_1:; | ||
| 1597 | exception_keeper_type_2 = exception_type; | ||
| 1598 | exception_keeper_value_2 = exception_value; | ||
| 1599 | exception_keeper_tb_2 = exception_tb; | ||
| 1600 | exception_keeper_lineno_2 = exception_lineno; | ||
| 1601 | exception_type = NULL; | ||
| 1602 | exception_value = NULL; | ||
| 1603 | exception_tb = NULL; | ||
| 1604 | exception_lineno = 0; | ||
| 1605 | |||
| 1606 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1607 | Py_DECREF( par_self ); | ||
| 1608 | par_self = NULL; | ||
| 1609 | |||
| 1610 | CHECK_OBJECT( (PyObject *)par_comp ); | ||
| 1611 | Py_DECREF( par_comp ); | ||
| 1612 | par_comp = NULL; | ||
| 1613 | |||
| 1614 | CHECK_OBJECT( (PyObject *)par_ddir ); | ||
| 1615 | Py_DECREF( par_ddir ); | ||
| 1616 | par_ddir = NULL; | ||
| 1617 | |||
| 1618 | CHECK_OBJECT( (PyObject *)par_uid ); | ||
| 1619 | Py_DECREF( par_uid ); | ||
| 1620 | par_uid = NULL; | ||
| 1621 | |||
| 1622 | CHECK_OBJECT( (PyObject *)par_uuid ); | ||
| 1623 | Py_DECREF( par_uuid ); | ||
| 1624 | par_uuid = NULL; | ||
| 1625 | |||
| 1626 | CHECK_OBJECT( (PyObject *)par_duphash ); | ||
| 1627 | Py_DECREF( par_duphash ); | ||
| 1628 | par_duphash = NULL; | ||
| 1629 | |||
| 1630 | Py_XDECREF( var_prob ); | ||
| 1631 | var_prob = NULL; | ||
| 1632 | |||
| 1633 | Py_XDECREF( var_cb ); | ||
| 1634 | var_cb = NULL; | ||
| 1635 | |||
| 1636 | // Re-raise. | ||
| 1637 | exception_type = exception_keeper_type_2; | ||
| 1638 | exception_value = exception_keeper_value_2; | ||
| 1639 | exception_tb = exception_keeper_tb_2; | ||
| 1640 | exception_lineno = exception_keeper_lineno_2; | ||
| 1641 | |||
| 1642 | goto function_exception_exit; | ||
| 1643 | // End of try: | ||
| 1644 | |||
| 1645 | // Return statement must have exited already. | ||
| 1646 | NUITKA_CANNOT_GET_HERE( problem$watch$$$function_2__new_problem_handler ); | ||
| 1647 | return NULL; | ||
| 1648 | |||
| 1649 | function_exception_exit: | ||
| 1650 | assert( exception_type ); | ||
| 1651 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1652 | |||
| 1653 | return NULL; | ||
| 1654 | |||
| 1655 | function_return_exit: | ||
| 1656 | // Function cleanup code if any. | ||
| 1657 | |||
| 1658 | |||
| 1659 | // Actual function exit with return value, making sure we did not make | ||
| 1660 | // the error status worse despite non-NULL return. | ||
| 1661 | CHECK_OBJECT( tmp_return_value ); | ||
| 1662 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 1663 | return tmp_return_value; | ||
| 1664 | } | ||
| 1665 | |||
| 1666 | |||
| 1667 | static PyObject *impl_problem$watch$$$function_3_add_callback( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 1668 | { | ||
| 1669 | // Preserve error status for checks | ||
| 1670 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1671 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 1672 | #endif | ||
| 1673 | |||
| 1674 | // Local variable declarations. | ||
| 1675 | PyObject *par_self = python_pars[ 0 ]; | ||
| 1676 | PyObject *par_fun = python_pars[ 1 ]; | ||
| 1677 | struct Nuitka_FrameObject *frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9; | ||
| 1678 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 1679 | PyObject *exception_type = NULL; | ||
| 1680 | PyObject *exception_value = NULL; | ||
| 1681 | PyTracebackObject *exception_tb = NULL; | ||
| 1682 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 1683 | static struct Nuitka_FrameObject *cache_frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9 = NULL; | ||
| 1684 | PyObject *tmp_return_value = NULL; | ||
| 1685 | PyObject *exception_keeper_type_1; | ||
| 1686 | PyObject *exception_keeper_value_1; | ||
| 1687 | PyTracebackObject *exception_keeper_tb_1; | ||
| 1688 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 1689 | |||
| 1690 | // Actual function body. | ||
| 1691 | // Tried code: | ||
| 1692 | MAKE_OR_REUSE_FRAME( cache_frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9, codeobj_e34ffbe571bf75d50a2cbfa2fb6c5ad9, module_problem$watch, sizeof(void *)+sizeof(void *) ); | ||
| 1693 | frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9 = cache_frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9; | ||
| 1694 | |||
| 1695 | // Push the new frame as the currently active one. | ||
| 1696 | pushFrameStack( frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9 ); | ||
| 1697 | |||
| 1698 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 1699 | assert( Py_REFCNT( frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9 ) == 2 ); // Frame stack | ||
| 1700 | |||
| 1701 | // Framed code: | ||
| 1702 | { | ||
| 1703 | PyObject *tmp_called_instance_1; | ||
| 1704 | PyObject *tmp_source_name_1; | ||
| 1705 | PyObject *tmp_call_result_1; | ||
| 1706 | PyObject *tmp_args_element_name_1; | ||
| 1707 | CHECK_OBJECT( par_self ); | ||
| 1708 | tmp_source_name_1 = par_self; | ||
| 1709 | tmp_called_instance_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_callbacks ); | ||
| 1710 | if ( tmp_called_instance_1 == NULL ) | ||
| 1711 | { | ||
| 1712 | assert( ERROR_OCCURRED() ); | ||
| 1713 | |||
| 1714 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1715 | |||
| 1716 | |||
| 1717 | exception_lineno = 62; | ||
| 1718 | type_description_1 = "oo"; | ||
| 1719 | goto frame_exception_exit_1; | ||
| 1720 | } | ||
| 1721 | CHECK_OBJECT( par_fun ); | ||
| 1722 | tmp_args_element_name_1 = par_fun; | ||
| 1723 | frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9->m_frame.f_lineno = 62; | ||
| 1724 | { | ||
| 1725 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 1726 | tmp_call_result_1 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_1, const_str_plain_append, call_args ); | ||
| 1727 | } | ||
| 1728 | |||
| 1729 | Py_DECREF( tmp_called_instance_1 ); | ||
| 1730 | if ( tmp_call_result_1 == NULL ) | ||
| 1731 | { | ||
| 1732 | assert( ERROR_OCCURRED() ); | ||
| 1733 | |||
| 1734 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1735 | |||
| 1736 | |||
| 1737 | exception_lineno = 62; | ||
| 1738 | type_description_1 = "oo"; | ||
| 1739 | goto frame_exception_exit_1; | ||
| 1740 | } | ||
| 1741 | Py_DECREF( tmp_call_result_1 ); | ||
| 1742 | } | ||
| 1743 | |||
| 1744 | #if 0 | ||
| 1745 | RESTORE_FRAME_EXCEPTION( frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9 ); | ||
| 1746 | #endif | ||
| 1747 | |||
| 1748 | // Put the previous frame back on top. | ||
| 1749 | popFrameStack(); | ||
| 1750 | |||
| 1751 | goto frame_no_exception_1; | ||
| 1752 | |||
| 1753 | frame_exception_exit_1:; | ||
| 1754 | |||
| 1755 | #if 0 | ||
| 1756 | RESTORE_FRAME_EXCEPTION( frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9 ); | ||
| 1757 | #endif | ||
| 1758 | |||
| 1759 | if ( exception_tb == NULL ) | ||
| 1760 | { | ||
| 1761 | exception_tb = MAKE_TRACEBACK( frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9, exception_lineno ); | ||
| 1762 | } | ||
| 1763 | else if ( exception_tb->tb_frame != &frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9->m_frame ) | ||
| 1764 | { | ||
| 1765 | exception_tb = ADD_TRACEBACK( exception_tb, frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9, exception_lineno ); | ||
| 1766 | } | ||
| 1767 | |||
| 1768 | // Attachs locals to frame if any. | ||
| 1769 | Nuitka_Frame_AttachLocals( | ||
| 1770 | (struct Nuitka_FrameObject *)frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9, | ||
| 1771 | type_description_1, | ||
| 1772 | par_self, | ||
| 1773 | par_fun | ||
| 1774 | ); | ||
| 1775 | |||
| 1776 | |||
| 1777 | // Release cached frame. | ||
| 1778 | if ( frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9 == cache_frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9 ) | ||
| 1779 | { | ||
| 1780 | Py_DECREF( frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9 ); | ||
| 1781 | } | ||
| 1782 | cache_frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9 = NULL; | ||
| 1783 | |||
| 1784 | assertFrameObject( frame_e34ffbe571bf75d50a2cbfa2fb6c5ad9 ); | ||
| 1785 | |||
| 1786 | // Put the previous frame back on top. | ||
| 1787 | popFrameStack(); | ||
| 1788 | |||
| 1789 | // Return the error. | ||
| 1790 | goto try_except_handler_1; | ||
| 1791 | |||
| 1792 | frame_no_exception_1:; | ||
| 1793 | tmp_return_value = Py_None; | ||
| 1794 | Py_INCREF( tmp_return_value ); | ||
| 1795 | goto try_return_handler_1; | ||
| 1796 | // tried codes exits in all cases | ||
| 1797 | NUITKA_CANNOT_GET_HERE( problem$watch$$$function_3_add_callback ); | ||
| 1798 | return NULL; | ||
| 1799 | // Return handler code: | ||
| 1800 | try_return_handler_1:; | ||
| 1801 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1802 | Py_DECREF( par_self ); | ||
| 1803 | par_self = NULL; | ||
| 1804 | |||
| 1805 | CHECK_OBJECT( (PyObject *)par_fun ); | ||
| 1806 | Py_DECREF( par_fun ); | ||
| 1807 | par_fun = NULL; | ||
| 1808 | |||
| 1809 | goto function_return_exit; | ||
| 1810 | // Exception handler code: | ||
| 1811 | try_except_handler_1:; | ||
| 1812 | exception_keeper_type_1 = exception_type; | ||
| 1813 | exception_keeper_value_1 = exception_value; | ||
| 1814 | exception_keeper_tb_1 = exception_tb; | ||
| 1815 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1816 | exception_type = NULL; | ||
| 1817 | exception_value = NULL; | ||
| 1818 | exception_tb = NULL; | ||
| 1819 | exception_lineno = 0; | ||
| 1820 | |||
| 1821 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1822 | Py_DECREF( par_self ); | ||
| 1823 | par_self = NULL; | ||
| 1824 | |||
| 1825 | CHECK_OBJECT( (PyObject *)par_fun ); | ||
| 1826 | Py_DECREF( par_fun ); | ||
| 1827 | par_fun = NULL; | ||
| 1828 | |||
| 1829 | // Re-raise. | ||
| 1830 | exception_type = exception_keeper_type_1; | ||
| 1831 | exception_value = exception_keeper_value_1; | ||
| 1832 | exception_tb = exception_keeper_tb_1; | ||
| 1833 | exception_lineno = exception_keeper_lineno_1; | ||
| 1834 | |||
| 1835 | goto function_exception_exit; | ||
| 1836 | // End of try: | ||
| 1837 | |||
| 1838 | // Return statement must have exited already. | ||
| 1839 | NUITKA_CANNOT_GET_HERE( problem$watch$$$function_3_add_callback ); | ||
| 1840 | return NULL; | ||
| 1841 | |||
| 1842 | function_exception_exit: | ||
| 1843 | assert( exception_type ); | ||
| 1844 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1845 | |||
| 1846 | return NULL; | ||
| 1847 | |||
| 1848 | function_return_exit: | ||
| 1849 | // Function cleanup code if any. | ||
| 1850 | |||
| 1851 | |||
| 1852 | // Actual function exit with return value, making sure we did not make | ||
| 1853 | // the error status worse despite non-NULL return. | ||
| 1854 | CHECK_OBJECT( tmp_return_value ); | ||
| 1855 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 1856 | return tmp_return_value; | ||
| 1857 | } | ||
| 1858 | |||
| 1859 | |||
| 1860 | static PyObject *impl_problem$watch$$$function_4_run( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 1861 | { | ||
| 1862 | // Preserve error status for checks | ||
| 1863 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1864 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 1865 | #endif | ||
| 1866 | |||
| 1867 | // Local variable declarations. | ||
| 1868 | PyObject *par_self = python_pars[ 0 ]; | ||
| 1869 | struct Nuitka_FrameObject *frame_d9dbed341759cfaa50c801239ced923d; | ||
| 1870 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 1871 | PyObject *exception_type = NULL; | ||
| 1872 | PyObject *exception_value = NULL; | ||
| 1873 | PyTracebackObject *exception_tb = NULL; | ||
| 1874 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 1875 | static struct Nuitka_FrameObject *cache_frame_d9dbed341759cfaa50c801239ced923d = NULL; | ||
| 1876 | PyObject *tmp_return_value = NULL; | ||
| 1877 | PyObject *exception_keeper_type_1; | ||
| 1878 | PyObject *exception_keeper_value_1; | ||
| 1879 | PyTracebackObject *exception_keeper_tb_1; | ||
| 1880 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 1881 | |||
| 1882 | // Actual function body. | ||
| 1883 | // Tried code: | ||
| 1884 | MAKE_OR_REUSE_FRAME( cache_frame_d9dbed341759cfaa50c801239ced923d, codeobj_d9dbed341759cfaa50c801239ced923d, module_problem$watch, sizeof(void *) ); | ||
| 1885 | frame_d9dbed341759cfaa50c801239ced923d = cache_frame_d9dbed341759cfaa50c801239ced923d; | ||
| 1886 | |||
| 1887 | // Push the new frame as the currently active one. | ||
| 1888 | pushFrameStack( frame_d9dbed341759cfaa50c801239ced923d ); | ||
| 1889 | |||
| 1890 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 1891 | assert( Py_REFCNT( frame_d9dbed341759cfaa50c801239ced923d ) == 2 ); // Frame stack | ||
| 1892 | |||
| 1893 | // Framed code: | ||
| 1894 | { | ||
| 1895 | PyObject *tmp_called_instance_1; | ||
| 1896 | PyObject *tmp_source_name_1; | ||
| 1897 | PyObject *tmp_call_result_1; | ||
| 1898 | CHECK_OBJECT( par_self ); | ||
| 1899 | tmp_source_name_1 = par_self; | ||
| 1900 | tmp_called_instance_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_loop ); | ||
| 1901 | if ( tmp_called_instance_1 == NULL ) | ||
| 1902 | { | ||
| 1903 | assert( ERROR_OCCURRED() ); | ||
| 1904 | |||
| 1905 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1906 | |||
| 1907 | |||
| 1908 | exception_lineno = 67; | ||
| 1909 | type_description_1 = "o"; | ||
| 1910 | goto frame_exception_exit_1; | ||
| 1911 | } | ||
| 1912 | frame_d9dbed341759cfaa50c801239ced923d->m_frame.f_lineno = 67; | ||
| 1913 | tmp_call_result_1 = CALL_METHOD_NO_ARGS( tmp_called_instance_1, const_str_plain_run ); | ||
| 1914 | Py_DECREF( tmp_called_instance_1 ); | ||
| 1915 | if ( tmp_call_result_1 == NULL ) | ||
| 1916 | { | ||
| 1917 | assert( ERROR_OCCURRED() ); | ||
| 1918 | |||
| 1919 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1920 | |||
| 1921 | |||
| 1922 | exception_lineno = 67; | ||
| 1923 | type_description_1 = "o"; | ||
| 1924 | goto frame_exception_exit_1; | ||
| 1925 | } | ||
| 1926 | Py_DECREF( tmp_call_result_1 ); | ||
| 1927 | } | ||
| 1928 | |||
| 1929 | #if 0 | ||
| 1930 | RESTORE_FRAME_EXCEPTION( frame_d9dbed341759cfaa50c801239ced923d ); | ||
| 1931 | #endif | ||
| 1932 | |||
| 1933 | // Put the previous frame back on top. | ||
| 1934 | popFrameStack(); | ||
| 1935 | |||
| 1936 | goto frame_no_exception_1; | ||
| 1937 | |||
| 1938 | frame_exception_exit_1:; | ||
| 1939 | |||
| 1940 | #if 0 | ||
| 1941 | RESTORE_FRAME_EXCEPTION( frame_d9dbed341759cfaa50c801239ced923d ); | ||
| 1942 | #endif | ||
| 1943 | |||
| 1944 | if ( exception_tb == NULL ) | ||
| 1945 | { | ||
| 1946 | exception_tb = MAKE_TRACEBACK( frame_d9dbed341759cfaa50c801239ced923d, exception_lineno ); | ||
| 1947 | } | ||
| 1948 | else if ( exception_tb->tb_frame != &frame_d9dbed341759cfaa50c801239ced923d->m_frame ) | ||
| 1949 | { | ||
| 1950 | exception_tb = ADD_TRACEBACK( exception_tb, frame_d9dbed341759cfaa50c801239ced923d, exception_lineno ); | ||
| 1951 | } | ||
| 1952 | |||
| 1953 | // Attachs locals to frame if any. | ||
| 1954 | Nuitka_Frame_AttachLocals( | ||
| 1955 | (struct Nuitka_FrameObject *)frame_d9dbed341759cfaa50c801239ced923d, | ||
| 1956 | type_description_1, | ||
| 1957 | par_self | ||
| 1958 | ); | ||
| 1959 | |||
| 1960 | |||
| 1961 | // Release cached frame. | ||
| 1962 | if ( frame_d9dbed341759cfaa50c801239ced923d == cache_frame_d9dbed341759cfaa50c801239ced923d ) | ||
| 1963 | { | ||
| 1964 | Py_DECREF( frame_d9dbed341759cfaa50c801239ced923d ); | ||
| 1965 | } | ||
| 1966 | cache_frame_d9dbed341759cfaa50c801239ced923d = NULL; | ||
| 1967 | |||
| 1968 | assertFrameObject( frame_d9dbed341759cfaa50c801239ced923d ); | ||
| 1969 | |||
| 1970 | // Put the previous frame back on top. | ||
| 1971 | popFrameStack(); | ||
| 1972 | |||
| 1973 | // Return the error. | ||
| 1974 | goto try_except_handler_1; | ||
| 1975 | |||
| 1976 | frame_no_exception_1:; | ||
| 1977 | tmp_return_value = Py_None; | ||
| 1978 | Py_INCREF( tmp_return_value ); | ||
| 1979 | goto try_return_handler_1; | ||
| 1980 | // tried codes exits in all cases | ||
| 1981 | NUITKA_CANNOT_GET_HERE( problem$watch$$$function_4_run ); | ||
| 1982 | return NULL; | ||
| 1983 | // Return handler code: | ||
| 1984 | try_return_handler_1:; | ||
| 1985 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 1986 | Py_DECREF( par_self ); | ||
| 1987 | par_self = NULL; | ||
| 1988 | |||
| 1989 | goto function_return_exit; | ||
| 1990 | // Exception handler code: | ||
| 1991 | try_except_handler_1:; | ||
| 1992 | exception_keeper_type_1 = exception_type; | ||
| 1993 | exception_keeper_value_1 = exception_value; | ||
| 1994 | exception_keeper_tb_1 = exception_tb; | ||
| 1995 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1996 | exception_type = NULL; | ||
| 1997 | exception_value = NULL; | ||
| 1998 | exception_tb = NULL; | ||
| 1999 | exception_lineno = 0; | ||
| 2000 | |||
| 2001 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 2002 | Py_DECREF( par_self ); | ||
| 2003 | par_self = NULL; | ||
| 2004 | |||
| 2005 | // Re-raise. | ||
| 2006 | exception_type = exception_keeper_type_1; | ||
| 2007 | exception_value = exception_keeper_value_1; | ||
| 2008 | exception_tb = exception_keeper_tb_1; | ||
| 2009 | exception_lineno = exception_keeper_lineno_1; | ||
| 2010 | |||
| 2011 | goto function_exception_exit; | ||
| 2012 | // End of try: | ||
| 2013 | |||
| 2014 | // Return statement must have exited already. | ||
| 2015 | NUITKA_CANNOT_GET_HERE( problem$watch$$$function_4_run ); | ||
| 2016 | return NULL; | ||
| 2017 | |||
| 2018 | function_exception_exit: | ||
| 2019 | assert( exception_type ); | ||
| 2020 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 2021 | |||
| 2022 | return NULL; | ||
| 2023 | |||
| 2024 | function_return_exit: | ||
| 2025 | // Function cleanup code if any. | ||
| 2026 | |||
| 2027 | |||
| 2028 | // Actual function exit with return value, making sure we did not make | ||
| 2029 | // the error status worse despite non-NULL return. | ||
| 2030 | CHECK_OBJECT( tmp_return_value ); | ||
| 2031 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 2032 | return tmp_return_value; | ||
| 2033 | } | ||
| 2034 | |||
| 2035 | |||
| 2036 | static PyObject *impl_problem$watch$$$function_5_quit( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 2037 | { | ||
| 2038 | // Preserve error status for checks | ||
| 2039 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 2040 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 2041 | #endif | ||
| 2042 | |||
| 2043 | // Local variable declarations. | ||
| 2044 | PyObject *par_self = python_pars[ 0 ]; | ||
| 2045 | struct Nuitka_FrameObject *frame_abae12faeac5cbdafa8c4d1e0a41676e; | ||
| 2046 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 2047 | PyObject *exception_type = NULL; | ||
| 2048 | PyObject *exception_value = NULL; | ||
| 2049 | PyTracebackObject *exception_tb = NULL; | ||
| 2050 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 2051 | static struct Nuitka_FrameObject *cache_frame_abae12faeac5cbdafa8c4d1e0a41676e = NULL; | ||
| 2052 | PyObject *tmp_return_value = NULL; | ||
| 2053 | PyObject *exception_keeper_type_1; | ||
| 2054 | PyObject *exception_keeper_value_1; | ||
| 2055 | PyTracebackObject *exception_keeper_tb_1; | ||
| 2056 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 2057 | |||
| 2058 | // Actual function body. | ||
| 2059 | // Tried code: | ||
| 2060 | MAKE_OR_REUSE_FRAME( cache_frame_abae12faeac5cbdafa8c4d1e0a41676e, codeobj_abae12faeac5cbdafa8c4d1e0a41676e, module_problem$watch, sizeof(void *) ); | ||
| 2061 | frame_abae12faeac5cbdafa8c4d1e0a41676e = cache_frame_abae12faeac5cbdafa8c4d1e0a41676e; | ||
| 2062 | |||
| 2063 | // Push the new frame as the currently active one. | ||
| 2064 | pushFrameStack( frame_abae12faeac5cbdafa8c4d1e0a41676e ); | ||
| 2065 | |||
| 2066 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 2067 | assert( Py_REFCNT( frame_abae12faeac5cbdafa8c4d1e0a41676e ) == 2 ); // Frame stack | ||
| 2068 | |||
| 2069 | // Framed code: | ||
| 2070 | { | ||
| 2071 | PyObject *tmp_called_instance_1; | ||
| 2072 | PyObject *tmp_source_name_1; | ||
| 2073 | PyObject *tmp_call_result_1; | ||
| 2074 | CHECK_OBJECT( par_self ); | ||
| 2075 | tmp_source_name_1 = par_self; | ||
| 2076 | tmp_called_instance_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_loop ); | ||
| 2077 | if ( tmp_called_instance_1 == NULL ) | ||
| 2078 | { | ||
| 2079 | assert( ERROR_OCCURRED() ); | ||
| 2080 | |||
| 2081 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2082 | |||
| 2083 | |||
| 2084 | exception_lineno = 72; | ||
| 2085 | type_description_1 = "o"; | ||
| 2086 | goto frame_exception_exit_1; | ||
| 2087 | } | ||
| 2088 | frame_abae12faeac5cbdafa8c4d1e0a41676e->m_frame.f_lineno = 72; | ||
| 2089 | tmp_call_result_1 = CALL_METHOD_NO_ARGS( tmp_called_instance_1, const_str_plain_quit ); | ||
| 2090 | Py_DECREF( tmp_called_instance_1 ); | ||
| 2091 | if ( tmp_call_result_1 == NULL ) | ||
| 2092 | { | ||
| 2093 | assert( ERROR_OCCURRED() ); | ||
| 2094 | |||
| 2095 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2096 | |||
| 2097 | |||
| 2098 | exception_lineno = 72; | ||
| 2099 | type_description_1 = "o"; | ||
| 2100 | goto frame_exception_exit_1; | ||
| 2101 | } | ||
| 2102 | Py_DECREF( tmp_call_result_1 ); | ||
| 2103 | } | ||
| 2104 | |||
| 2105 | #if 0 | ||
| 2106 | RESTORE_FRAME_EXCEPTION( frame_abae12faeac5cbdafa8c4d1e0a41676e ); | ||
| 2107 | #endif | ||
| 2108 | |||
| 2109 | // Put the previous frame back on top. | ||
| 2110 | popFrameStack(); | ||
| 2111 | |||
| 2112 | goto frame_no_exception_1; | ||
| 2113 | |||
| 2114 | frame_exception_exit_1:; | ||
| 2115 | |||
| 2116 | #if 0 | ||
| 2117 | RESTORE_FRAME_EXCEPTION( frame_abae12faeac5cbdafa8c4d1e0a41676e ); | ||
| 2118 | #endif | ||
| 2119 | |||
| 2120 | if ( exception_tb == NULL ) | ||
| 2121 | { | ||
| 2122 | exception_tb = MAKE_TRACEBACK( frame_abae12faeac5cbdafa8c4d1e0a41676e, exception_lineno ); | ||
| 2123 | } | ||
| 2124 | else if ( exception_tb->tb_frame != &frame_abae12faeac5cbdafa8c4d1e0a41676e->m_frame ) | ||
| 2125 | { | ||
| 2126 | exception_tb = ADD_TRACEBACK( exception_tb, frame_abae12faeac5cbdafa8c4d1e0a41676e, exception_lineno ); | ||
| 2127 | } | ||
| 2128 | |||
| 2129 | // Attachs locals to frame if any. | ||
| 2130 | Nuitka_Frame_AttachLocals( | ||
| 2131 | (struct Nuitka_FrameObject *)frame_abae12faeac5cbdafa8c4d1e0a41676e, | ||
| 2132 | type_description_1, | ||
| 2133 | par_self | ||
| 2134 | ); | ||
| 2135 | |||
| 2136 | |||
| 2137 | // Release cached frame. | ||
| 2138 | if ( frame_abae12faeac5cbdafa8c4d1e0a41676e == cache_frame_abae12faeac5cbdafa8c4d1e0a41676e ) | ||
| 2139 | { | ||
| 2140 | Py_DECREF( frame_abae12faeac5cbdafa8c4d1e0a41676e ); | ||
| 2141 | } | ||
| 2142 | cache_frame_abae12faeac5cbdafa8c4d1e0a41676e = NULL; | ||
| 2143 | |||
| 2144 | assertFrameObject( frame_abae12faeac5cbdafa8c4d1e0a41676e ); | ||
| 2145 | |||
| 2146 | // Put the previous frame back on top. | ||
| 2147 | popFrameStack(); | ||
| 2148 | |||
| 2149 | // Return the error. | ||
| 2150 | goto try_except_handler_1; | ||
| 2151 | |||
| 2152 | frame_no_exception_1:; | ||
| 2153 | tmp_return_value = Py_None; | ||
| 2154 | Py_INCREF( tmp_return_value ); | ||
| 2155 | goto try_return_handler_1; | ||
| 2156 | // tried codes exits in all cases | ||
| 2157 | NUITKA_CANNOT_GET_HERE( problem$watch$$$function_5_quit ); | ||
| 2158 | return NULL; | ||
| 2159 | // Return handler code: | ||
| 2160 | try_return_handler_1:; | ||
| 2161 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 2162 | Py_DECREF( par_self ); | ||
| 2163 | par_self = NULL; | ||
| 2164 | |||
| 2165 | goto function_return_exit; | ||
| 2166 | // Exception handler code: | ||
| 2167 | try_except_handler_1:; | ||
| 2168 | exception_keeper_type_1 = exception_type; | ||
| 2169 | exception_keeper_value_1 = exception_value; | ||
| 2170 | exception_keeper_tb_1 = exception_tb; | ||
| 2171 | exception_keeper_lineno_1 = exception_lineno; | ||
| 2172 | exception_type = NULL; | ||
| 2173 | exception_value = NULL; | ||
| 2174 | exception_tb = NULL; | ||
| 2175 | exception_lineno = 0; | ||
| 2176 | |||
| 2177 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 2178 | Py_DECREF( par_self ); | ||
| 2179 | par_self = NULL; | ||
| 2180 | |||
| 2181 | // Re-raise. | ||
| 2182 | exception_type = exception_keeper_type_1; | ||
| 2183 | exception_value = exception_keeper_value_1; | ||
| 2184 | exception_tb = exception_keeper_tb_1; | ||
| 2185 | exception_lineno = exception_keeper_lineno_1; | ||
| 2186 | |||
| 2187 | goto function_exception_exit; | ||
| 2188 | // End of try: | ||
| 2189 | |||
| 2190 | // Return statement must have exited already. | ||
| 2191 | NUITKA_CANNOT_GET_HERE( problem$watch$$$function_5_quit ); | ||
| 2192 | return NULL; | ||
| 2193 | |||
| 2194 | function_exception_exit: | ||
| 2195 | assert( exception_type ); | ||
| 2196 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 2197 | |||
| 2198 | return NULL; | ||
| 2199 | |||
| 2200 | function_return_exit: | ||
| 2201 | // Function cleanup code if any. | ||
| 2202 | |||
| 2203 | |||
| 2204 | // Actual function exit with return value, making sure we did not make | ||
| 2205 | // the error status worse despite non-NULL return. | ||
| 2206 | CHECK_OBJECT( tmp_return_value ); | ||
| 2207 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 2208 | return tmp_return_value; | ||
| 2209 | } | ||
| 2210 | |||
| 2211 | |||
| 2212 | |||
| 2213 | static PyObject *MAKE_FUNCTION_problem$watch$$$function_1___init__( ) | ||
| 2214 | { | ||
| 2215 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 2216 | impl_problem$watch$$$function_1___init__, | ||
| 2217 | const_str_plain___init__, | ||
| 2218 | #if PYTHON_VERSION >= 300 | ||
| 2219 | const_str_digest_9d806eaad66d3756ba04cb4ec720b7d6, | ||
| 2220 | #endif | ||
| 2221 | codeobj_661f64abf7d853df92ffc10bd5c6cf99, | ||
| 2222 | NULL, | ||
| 2223 | #if PYTHON_VERSION >= 300 | ||
| 2224 | NULL, | ||
| 2225 | NULL, | ||
| 2226 | #endif | ||
| 2227 | module_problem$watch, | ||
| 2228 | NULL, | ||
| 2229 | 0 | ||
| 2230 | ); | ||
| 2231 | |||
| 2232 | return (PyObject *)result; | ||
| 2233 | } | ||
| 2234 | |||
| 2235 | |||
| 2236 | |||
| 2237 | static PyObject *MAKE_FUNCTION_problem$watch$$$function_2__new_problem_handler( ) | ||
| 2238 | { | ||
| 2239 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 2240 | impl_problem$watch$$$function_2__new_problem_handler, | ||
| 2241 | const_str_plain__new_problem_handler, | ||
| 2242 | #if PYTHON_VERSION >= 300 | ||
| 2243 | const_str_digest_7772fb89b733df96f112d88eda9d1ea3, | ||
| 2244 | #endif | ||
| 2245 | codeobj_784f5e5265e35255ee834cc666e1c059, | ||
| 2246 | NULL, | ||
| 2247 | #if PYTHON_VERSION >= 300 | ||
| 2248 | NULL, | ||
| 2249 | NULL, | ||
| 2250 | #endif | ||
| 2251 | module_problem$watch, | ||
| 2252 | NULL, | ||
| 2253 | 0 | ||
| 2254 | ); | ||
| 2255 | |||
| 2256 | return (PyObject *)result; | ||
| 2257 | } | ||
| 2258 | |||
| 2259 | |||
| 2260 | |||
| 2261 | static PyObject *MAKE_FUNCTION_problem$watch$$$function_3_add_callback( ) | ||
| 2262 | { | ||
| 2263 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 2264 | impl_problem$watch$$$function_3_add_callback, | ||
| 2265 | const_str_plain_add_callback, | ||
| 2266 | #if PYTHON_VERSION >= 300 | ||
| 2267 | const_str_digest_dba1471062040150ffbf7ed03f51f70c, | ||
| 2268 | #endif | ||
| 2269 | codeobj_e34ffbe571bf75d50a2cbfa2fb6c5ad9, | ||
| 2270 | NULL, | ||
| 2271 | #if PYTHON_VERSION >= 300 | ||
| 2272 | NULL, | ||
| 2273 | NULL, | ||
| 2274 | #endif | ||
| 2275 | module_problem$watch, | ||
| 2276 | const_str_digest_b2d0a1653b5af1672cfbe7f3cb38e88b, | ||
| 2277 | 0 | ||
| 2278 | ); | ||
| 2279 | |||
| 2280 | return (PyObject *)result; | ||
| 2281 | } | ||
| 2282 | |||
| 2283 | |||
| 2284 | |||
| 2285 | static PyObject *MAKE_FUNCTION_problem$watch$$$function_4_run( ) | ||
| 2286 | { | ||
| 2287 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 2288 | impl_problem$watch$$$function_4_run, | ||
| 2289 | const_str_plain_run, | ||
| 2290 | #if PYTHON_VERSION >= 300 | ||
| 2291 | const_str_digest_df675e9e6a3e348cc28010e5ca774d50, | ||
| 2292 | #endif | ||
| 2293 | codeobj_d9dbed341759cfaa50c801239ced923d, | ||
| 2294 | NULL, | ||
| 2295 | #if PYTHON_VERSION >= 300 | ||
| 2296 | NULL, | ||
| 2297 | NULL, | ||
| 2298 | #endif | ||
| 2299 | module_problem$watch, | ||
| 2300 | const_str_digest_69674f8f0ed7d7d7d2f89a2b85e765b6, | ||
| 2301 | 0 | ||
| 2302 | ); | ||
| 2303 | |||
| 2304 | return (PyObject *)result; | ||
| 2305 | } | ||
| 2306 | |||
| 2307 | |||
| 2308 | |||
| 2309 | static PyObject *MAKE_FUNCTION_problem$watch$$$function_5_quit( ) | ||
| 2310 | { | ||
| 2311 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 2312 | impl_problem$watch$$$function_5_quit, | ||
| 2313 | const_str_plain_quit, | ||
| 2314 | #if PYTHON_VERSION >= 300 | ||
| 2315 | const_str_digest_c8c3013b85174ee4c7e95aa9fc093e73, | ||
| 2316 | #endif | ||
| 2317 | codeobj_abae12faeac5cbdafa8c4d1e0a41676e, | ||
| 2318 | NULL, | ||
| 2319 | #if PYTHON_VERSION >= 300 | ||
| 2320 | NULL, | ||
| 2321 | NULL, | ||
| 2322 | #endif | ||
| 2323 | module_problem$watch, | ||
| 2324 | const_str_digest_7206f320397eb203421b0c49b1ab89b7, | ||
| 2325 | 0 | ||
| 2326 | ); | ||
| 2327 | |||
| 2328 | return (PyObject *)result; | ||
| 2329 | } | ||
| 2330 | |||
| 2331 | |||
| 2332 | |||
| 2333 | #if PYTHON_VERSION >= 300 | ||
| 2334 | static struct PyModuleDef mdef_problem$watch = | ||
| 2335 | { | ||
| 2336 | PyModuleDef_HEAD_INIT, | ||
| 2337 | "problem.watch", | ||
| 2338 | NULL, /* m_doc */ | ||
| 2339 | -1, /* m_size */ | ||
| 2340 | NULL, /* m_methods */ | ||
| 2341 | NULL, /* m_reload */ | ||
| 2342 | NULL, /* m_traverse */ | ||
| 2343 | NULL, /* m_clear */ | ||
| 2344 | NULL, /* m_free */ | ||
| 2345 | }; | ||
| 2346 | #endif | ||
| 2347 | |||
| 2348 | extern PyObject *const_str_plain___compiled__; | ||
| 2349 | |||
| 2350 | extern PyObject *const_str_plain___package__; | ||
| 2351 | |||
| 2352 | #if PYTHON_VERSION >= 300 | ||
| 2353 | extern PyObject *const_str_dot; | ||
| 2354 | extern PyObject *const_str_plain___loader__; | ||
| 2355 | #endif | ||
| 2356 | |||
| 2357 | #if PYTHON_VERSION >= 340 | ||
| 2358 | extern PyObject *const_str_plain___spec__; | ||
| 2359 | extern PyObject *const_str_plain__initializing; | ||
| 2360 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 2361 | #endif | ||
| 2362 | |||
| 2363 | extern void _initCompiledCellType(); | ||
| 2364 | extern void _initCompiledGeneratorType(); | ||
| 2365 | extern void _initCompiledFunctionType(); | ||
| 2366 | extern void _initCompiledMethodType(); | ||
| 2367 | extern void _initCompiledFrameType(); | ||
| 2368 | #if PYTHON_VERSION >= 350 | ||
| 2369 | extern void _initCompiledCoroutineTypes(); | ||
| 2370 | #endif | ||
| 2371 | #if PYTHON_VERSION >= 360 | ||
| 2372 | extern void _initCompiledAsyncgenTypes(); | ||
| 2373 | #endif | ||
| 2374 | |||
| 2375 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 2376 | |||
| 2377 | // The exported interface to CPython. On import of the module, this function | ||
| 2378 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 2379 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 2380 | |||
| 2381 | MOD_INIT_DECL( problem$watch ) | ||
| 2382 | { | ||
| 2383 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 2384 | static bool _init_done = false; | ||
| 2385 | |||
| 2386 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 2387 | if ( _init_done ) | ||
| 2388 | { | ||
| 2389 | return MOD_RETURN_VALUE( module_problem$watch ); | ||
| 2390 | } | ||
| 2391 | else | ||
| 2392 | { | ||
| 2393 | _init_done = true; | ||
| 2394 | } | ||
| 2395 | #endif | ||
| 2396 | |||
| 2397 | #ifdef _NUITKA_MODULE | ||
| 2398 | // In case of a stand alone extension module, need to call initialization | ||
| 2399 | // the init here because that's the first and only time we are going to get | ||
| 2400 | // called here. | ||
| 2401 | |||
| 2402 | // Initialize the constant values used. | ||
| 2403 | _initBuiltinModule(); | ||
| 2404 | createGlobalConstants(); | ||
| 2405 | |||
| 2406 | /* Initialize the compiled types of Nuitka. */ | ||
| 2407 | _initCompiledCellType(); | ||
| 2408 | _initCompiledGeneratorType(); | ||
| 2409 | _initCompiledFunctionType(); | ||
| 2410 | _initCompiledMethodType(); | ||
| 2411 | _initCompiledFrameType(); | ||
| 2412 | #if PYTHON_VERSION >= 350 | ||
| 2413 | _initCompiledCoroutineTypes(); | ||
| 2414 | #endif | ||
| 2415 | #if PYTHON_VERSION >= 360 | ||
| 2416 | _initCompiledAsyncgenTypes(); | ||
| 2417 | #endif | ||
| 2418 | |||
| 2419 | #if PYTHON_VERSION < 300 | ||
| 2420 | _initSlotCompare(); | ||
| 2421 | #endif | ||
| 2422 | #if PYTHON_VERSION >= 270 | ||
| 2423 | _initSlotIternext(); | ||
| 2424 | #endif | ||
| 2425 | |||
| 2426 | patchBuiltinModule(); | ||
| 2427 | patchTypeComparison(); | ||
| 2428 | |||
| 2429 | // Enable meta path based loader if not already done. | ||
| 2430 | #ifdef _NUITKA_TRACE | ||
| 2431 | puts("problem.watch: Calling setupMetaPathBasedLoader()."); | ||
| 2432 | #endif | ||
| 2433 | setupMetaPathBasedLoader(); | ||
| 2434 | |||
| 2435 | #if PYTHON_VERSION >= 300 | ||
| 2436 | patchInspectModule(); | ||
| 2437 | #endif | ||
| 2438 | |||
| 2439 | #endif | ||
| 2440 | |||
| 2441 | /* The constants only used by this module are created now. */ | ||
| 2442 | #ifdef _NUITKA_TRACE | ||
| 2443 | puts("problem.watch: Calling createModuleConstants()."); | ||
| 2444 | #endif | ||
| 2445 | createModuleConstants(); | ||
| 2446 | |||
| 2447 | /* The code objects used by this module are created now. */ | ||
| 2448 | #ifdef _NUITKA_TRACE | ||
| 2449 | puts("problem.watch: Calling createModuleCodeObjects()."); | ||
| 2450 | #endif | ||
| 2451 | createModuleCodeObjects(); | ||
| 2452 | |||
| 2453 | // puts( "in initproblem$watch" ); | ||
| 2454 | |||
| 2455 | // Create the module object first. There are no methods initially, all are | ||
| 2456 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 2457 | // set at this time, as it could not contain NUL characters this way, they | ||
| 2458 | // are instead set in early module code. No "self" for modules, we have no | ||
| 2459 | // use for it. | ||
| 2460 | #if PYTHON_VERSION < 300 | ||
| 2461 | module_problem$watch = Py_InitModule4( | ||
| 2462 | "problem.watch", // Module Name | ||
| 2463 | NULL, // No methods initially, all are added | ||
| 2464 | // dynamically in actual module code only. | ||
| 2465 | NULL, // No "__doc__" is initially set, as it could | ||
| 2466 | // not contain NUL this way, added early in | ||
| 2467 | // actual code. | ||
| 2468 | NULL, // No self for modules, we don't use it. | ||
| 2469 | PYTHON_API_VERSION | ||
| 2470 | ); | ||
| 2471 | #else | ||
| 2472 | |||
| 2473 | module_problem$watch = PyModule_Create( &mdef_problem$watch ); | ||
| 2474 | #endif | ||
| 2475 | |||
| 2476 | moduledict_problem$watch = MODULE_DICT( module_problem$watch ); | ||
| 2477 | |||
| 2478 | // Set __compiled__ to what it we know. | ||
| 2479 | UPDATE_STRING_DICT1( | ||
| 2480 | moduledict_problem$watch, | ||
| 2481 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 2482 | Nuitka_dunder_compiled_value | ||
| 2483 | ); | ||
| 2484 | |||
| 2485 | // Update "__package__" value to what it ought to be. | ||
| 2486 | { | ||
| 2487 | #if 0 | ||
| 2488 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 2489 | |||
| 2490 | UPDATE_STRING_DICT1( | ||
| 2491 | moduledict_problem$watch, | ||
| 2492 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 2493 | module_name | ||
| 2494 | ); | ||
| 2495 | #else | ||
| 2496 | |||
| 2497 | #if PYTHON_VERSION < 300 | ||
| 2498 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 2499 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 2500 | |||
| 2501 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 2502 | |||
| 2503 | if ( last_dot != NULL ) | ||
| 2504 | { | ||
| 2505 | UPDATE_STRING_DICT1( | ||
| 2506 | moduledict_problem$watch, | ||
| 2507 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 2508 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 2509 | ); | ||
| 2510 | } | ||
| 2511 | #else | ||
| 2512 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 2513 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 2514 | |||
| 2515 | if ( dot_index != -1 ) | ||
| 2516 | { | ||
| 2517 | UPDATE_STRING_DICT1( | ||
| 2518 | moduledict_problem$watch, | ||
| 2519 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 2520 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 2521 | ); | ||
| 2522 | } | ||
| 2523 | #endif | ||
| 2524 | #endif | ||
| 2525 | } | ||
| 2526 | |||
| 2527 | CHECK_OBJECT( module_problem$watch ); | ||
| 2528 | |||
| 2529 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 2530 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 2531 | #if PYTHON_VERSION >= 300 | ||
| 2532 | { | ||
| 2533 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_38fb2aa5dde28301dc9b212f510d8ef6, module_problem$watch ); | ||
| 2534 | |||
| 2535 | assert( r != -1 ); | ||
| 2536 | } | ||
| 2537 | #endif | ||
| 2538 | |||
| 2539 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 2540 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 2541 | // before the frame object is allocated, or else it may fail. | ||
| 2542 | |||
| 2543 | if ( GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 2544 | { | ||
| 2545 | PyObject *value = (PyObject *)builtin_module; | ||
| 2546 | |||
| 2547 | // Check if main module, not a dict then but the module itself. | ||
| 2548 | #if !defined(_NUITKA_EXE) || !0 | ||
| 2549 | value = PyModule_GetDict( value ); | ||
| 2550 | #endif | ||
| 2551 | |||
| 2552 | UPDATE_STRING_DICT0( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 2553 | } | ||
| 2554 | |||
| 2555 | #if PYTHON_VERSION >= 300 | ||
| 2556 | UPDATE_STRING_DICT0( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 2557 | #endif | ||
| 2558 | |||
| 2559 | #if PYTHON_VERSION >= 340 | ||
| 2560 | // Set the "__spec__" value | ||
| 2561 | |||
| 2562 | #if 0 | ||
| 2563 | // Main modules just get "None" as spec. | ||
| 2564 | UPDATE_STRING_DICT0( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 2565 | #else | ||
| 2566 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 2567 | { | ||
| 2568 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 2569 | CHECK_OBJECT( bootstrap_module ); | ||
| 2570 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 2571 | Py_DECREF( bootstrap_module ); | ||
| 2572 | |||
| 2573 | PyObject *args[] = { | ||
| 2574 | GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 2575 | (PyObject *)&Nuitka_Loader_Type | ||
| 2576 | }; | ||
| 2577 | |||
| 2578 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 2579 | module_spec_class, | ||
| 2580 | args | ||
| 2581 | ); | ||
| 2582 | Py_DECREF( module_spec_class ); | ||
| 2583 | |||
| 2584 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 2585 | CHECK_OBJECT( spec_value ); | ||
| 2586 | |||
| 2587 | // For packages set the submodule search locations as well, even if to empty | ||
| 2588 | // list, so investigating code will consider it a package. | ||
| 2589 | #if 0 | ||
| 2590 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 2591 | #endif | ||
| 2592 | |||
| 2593 | // Mark the execution in the "__spec__" value. | ||
| 2594 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 2595 | |||
| 2596 | UPDATE_STRING_DICT1( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 2597 | } | ||
| 2598 | #endif | ||
| 2599 | #endif | ||
| 2600 | |||
| 2601 | // Temp variables if any | ||
| 2602 | PyObject *outline_0_var___class__ = NULL; | ||
| 2603 | PyObject *tmp_class_creation_1__bases = NULL; | ||
| 2604 | PyObject *tmp_class_creation_1__class_decl_dict = NULL; | ||
| 2605 | PyObject *tmp_class_creation_1__metaclass = NULL; | ||
| 2606 | PyObject *tmp_class_creation_1__prepared = NULL; | ||
| 2607 | struct Nuitka_FrameObject *frame_2765838b8bb3ab223eab9353cd0c488a; | ||
| 2608 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 2609 | bool tmp_result; | ||
| 2610 | PyObject *exception_type = NULL; | ||
| 2611 | PyObject *exception_value = NULL; | ||
| 2612 | PyTracebackObject *exception_tb = NULL; | ||
| 2613 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 2614 | int tmp_res; | ||
| 2615 | PyObject *tmp_dictdel_dict; | ||
| 2616 | PyObject *tmp_dictdel_key; | ||
| 2617 | PyObject *locals_problem$watch_7 = NULL; | ||
| 2618 | PyObject *tmp_dictset_value; | ||
| 2619 | struct Nuitka_FrameObject *frame_6460bfc2f936b42b752a8a65fb70122a_2; | ||
| 2620 | NUITKA_MAY_BE_UNUSED char const *type_description_2 = NULL; | ||
| 2621 | static struct Nuitka_FrameObject *cache_frame_6460bfc2f936b42b752a8a65fb70122a_2 = NULL; | ||
| 2622 | PyObject *exception_keeper_type_1; | ||
| 2623 | PyObject *exception_keeper_value_1; | ||
| 2624 | PyTracebackObject *exception_keeper_tb_1; | ||
| 2625 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 2626 | PyObject *exception_keeper_type_2; | ||
| 2627 | PyObject *exception_keeper_value_2; | ||
| 2628 | PyTracebackObject *exception_keeper_tb_2; | ||
| 2629 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 2630 | PyObject *exception_keeper_type_3; | ||
| 2631 | PyObject *exception_keeper_value_3; | ||
| 2632 | PyTracebackObject *exception_keeper_tb_3; | ||
| 2633 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; | ||
| 2634 | |||
| 2635 | // Module code. | ||
| 2636 | { | ||
| 2637 | PyObject *tmp_assign_source_1; | ||
| 2638 | tmp_assign_source_1 = Py_None; | ||
| 2639 | UPDATE_STRING_DICT0( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 2640 | } | ||
| 2641 | { | ||
| 2642 | PyObject *tmp_assign_source_2; | ||
| 2643 | tmp_assign_source_2 = module_filename_obj; | ||
| 2644 | UPDATE_STRING_DICT0( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 2645 | } | ||
| 2646 | // Frame without reuse. | ||
| 2647 | frame_2765838b8bb3ab223eab9353cd0c488a = MAKE_MODULE_FRAME( codeobj_2765838b8bb3ab223eab9353cd0c488a, module_problem$watch ); | ||
| 2648 | |||
| 2649 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 2650 | // owning it. | ||
| 2651 | pushFrameStack( frame_2765838b8bb3ab223eab9353cd0c488a ); | ||
| 2652 | assert( Py_REFCNT( frame_2765838b8bb3ab223eab9353cd0c488a ) == 2 ); | ||
| 2653 | |||
| 2654 | // Framed code: | ||
| 2655 | { | ||
| 2656 | PyObject *tmp_assattr_name_1; | ||
| 2657 | PyObject *tmp_assattr_target_1; | ||
| 2658 | PyObject *tmp_mvar_value_1; | ||
| 2659 | tmp_assattr_name_1 = module_filename_obj; | ||
| 2660 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2661 | |||
| 2662 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 2663 | { | ||
| 2664 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2665 | } | ||
| 2666 | |||
| 2667 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 2668 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 2669 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 2670 | if ( tmp_result == false ) | ||
| 2671 | { | ||
| 2672 | assert( ERROR_OCCURRED() ); | ||
| 2673 | |||
| 2674 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2675 | |||
| 2676 | |||
| 2677 | exception_lineno = 1; | ||
| 2678 | |||
| 2679 | goto frame_exception_exit_1; | ||
| 2680 | } | ||
| 2681 | } | ||
| 2682 | { | ||
| 2683 | PyObject *tmp_assattr_name_2; | ||
| 2684 | PyObject *tmp_assattr_target_2; | ||
| 2685 | PyObject *tmp_mvar_value_2; | ||
| 2686 | tmp_assattr_name_2 = Py_True; | ||
| 2687 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2688 | |||
| 2689 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 2690 | { | ||
| 2691 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 2692 | } | ||
| 2693 | |||
| 2694 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 2695 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 2696 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 2697 | if ( tmp_result == false ) | ||
| 2698 | { | ||
| 2699 | assert( ERROR_OCCURRED() ); | ||
| 2700 | |||
| 2701 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2702 | |||
| 2703 | |||
| 2704 | exception_lineno = 1; | ||
| 2705 | |||
| 2706 | goto frame_exception_exit_1; | ||
| 2707 | } | ||
| 2708 | } | ||
| 2709 | { | ||
| 2710 | PyObject *tmp_assign_source_3; | ||
| 2711 | tmp_assign_source_3 = Py_None; | ||
| 2712 | UPDATE_STRING_DICT0( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 2713 | } | ||
| 2714 | { | ||
| 2715 | PyObject *tmp_assign_source_4; | ||
| 2716 | PyObject *tmp_name_name_1; | ||
| 2717 | PyObject *tmp_globals_name_1; | ||
| 2718 | PyObject *tmp_locals_name_1; | ||
| 2719 | PyObject *tmp_fromlist_name_1; | ||
| 2720 | PyObject *tmp_level_name_1; | ||
| 2721 | tmp_name_name_1 = const_str_plain_os; | ||
| 2722 | tmp_globals_name_1 = (PyObject *)moduledict_problem$watch; | ||
| 2723 | tmp_locals_name_1 = Py_None; | ||
| 2724 | tmp_fromlist_name_1 = Py_None; | ||
| 2725 | tmp_level_name_1 = const_int_0; | ||
| 2726 | frame_2765838b8bb3ab223eab9353cd0c488a->m_frame.f_lineno = 1; | ||
| 2727 | tmp_assign_source_4 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 2728 | if ( tmp_assign_source_4 == NULL ) | ||
| 2729 | { | ||
| 2730 | assert( ERROR_OCCURRED() ); | ||
| 2731 | |||
| 2732 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2733 | |||
| 2734 | |||
| 2735 | exception_lineno = 1; | ||
| 2736 | |||
| 2737 | goto frame_exception_exit_1; | ||
| 2738 | } | ||
| 2739 | UPDATE_STRING_DICT1( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain_os, tmp_assign_source_4 ); | ||
| 2740 | } | ||
| 2741 | { | ||
| 2742 | PyObject *tmp_assign_source_5; | ||
| 2743 | PyObject *tmp_name_name_2; | ||
| 2744 | PyObject *tmp_globals_name_2; | ||
| 2745 | PyObject *tmp_locals_name_2; | ||
| 2746 | PyObject *tmp_fromlist_name_2; | ||
| 2747 | PyObject *tmp_level_name_2; | ||
| 2748 | tmp_name_name_2 = const_str_plain_logging; | ||
| 2749 | tmp_globals_name_2 = (PyObject *)moduledict_problem$watch; | ||
| 2750 | tmp_locals_name_2 = Py_None; | ||
| 2751 | tmp_fromlist_name_2 = Py_None; | ||
| 2752 | tmp_level_name_2 = const_int_0; | ||
| 2753 | frame_2765838b8bb3ab223eab9353cd0c488a->m_frame.f_lineno = 2; | ||
| 2754 | tmp_assign_source_5 = IMPORT_MODULE5( tmp_name_name_2, tmp_globals_name_2, tmp_locals_name_2, tmp_fromlist_name_2, tmp_level_name_2 ); | ||
| 2755 | if ( tmp_assign_source_5 == NULL ) | ||
| 2756 | { | ||
| 2757 | assert( ERROR_OCCURRED() ); | ||
| 2758 | |||
| 2759 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2760 | |||
| 2761 | |||
| 2762 | exception_lineno = 2; | ||
| 2763 | |||
| 2764 | goto frame_exception_exit_1; | ||
| 2765 | } | ||
| 2766 | UPDATE_STRING_DICT1( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain_logging, tmp_assign_source_5 ); | ||
| 2767 | } | ||
| 2768 | { | ||
| 2769 | PyObject *tmp_assign_source_6; | ||
| 2770 | PyObject *tmp_name_name_3; | ||
| 2771 | PyObject *tmp_globals_name_3; | ||
| 2772 | PyObject *tmp_locals_name_3; | ||
| 2773 | PyObject *tmp_fromlist_name_3; | ||
| 2774 | PyObject *tmp_level_name_3; | ||
| 2775 | tmp_name_name_3 = const_str_plain_problem; | ||
| 2776 | tmp_globals_name_3 = (PyObject *)moduledict_problem$watch; | ||
| 2777 | tmp_locals_name_3 = Py_None; | ||
| 2778 | tmp_fromlist_name_3 = Py_None; | ||
| 2779 | tmp_level_name_3 = const_int_0; | ||
| 2780 | frame_2765838b8bb3ab223eab9353cd0c488a->m_frame.f_lineno = 4; | ||
| 2781 | tmp_assign_source_6 = IMPORT_MODULE5( tmp_name_name_3, tmp_globals_name_3, tmp_locals_name_3, tmp_fromlist_name_3, tmp_level_name_3 ); | ||
| 2782 | if ( tmp_assign_source_6 == NULL ) | ||
| 2783 | { | ||
| 2784 | assert( ERROR_OCCURRED() ); | ||
| 2785 | |||
| 2786 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2787 | |||
| 2788 | |||
| 2789 | exception_lineno = 4; | ||
| 2790 | |||
| 2791 | goto frame_exception_exit_1; | ||
| 2792 | } | ||
| 2793 | UPDATE_STRING_DICT1( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain_problem, tmp_assign_source_6 ); | ||
| 2794 | } | ||
| 2795 | // Tried code: | ||
| 2796 | { | ||
| 2797 | PyObject *tmp_assign_source_7; | ||
| 2798 | PyObject *tmp_dircall_arg1_1; | ||
| 2799 | tmp_dircall_arg1_1 = const_tuple_type_object_tuple; | ||
| 2800 | Py_INCREF( tmp_dircall_arg1_1 ); | ||
| 2801 | |||
| 2802 | { | ||
| 2803 | PyObject *dir_call_args[] = {tmp_dircall_arg1_1}; | ||
| 2804 | tmp_assign_source_7 = impl___internal__$$$function_2__mro_entries_conversion( dir_call_args ); | ||
| 2805 | } | ||
| 2806 | if ( tmp_assign_source_7 == NULL ) | ||
| 2807 | { | ||
| 2808 | assert( ERROR_OCCURRED() ); | ||
| 2809 | |||
| 2810 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2811 | |||
| 2812 | |||
| 2813 | exception_lineno = 7; | ||
| 2814 | |||
| 2815 | goto try_except_handler_1; | ||
| 2816 | } | ||
| 2817 | assert( tmp_class_creation_1__bases == NULL ); | ||
| 2818 | tmp_class_creation_1__bases = tmp_assign_source_7; | ||
| 2819 | } | ||
| 2820 | { | ||
| 2821 | PyObject *tmp_assign_source_8; | ||
| 2822 | tmp_assign_source_8 = PyDict_New(); | ||
| 2823 | assert( tmp_class_creation_1__class_decl_dict == NULL ); | ||
| 2824 | tmp_class_creation_1__class_decl_dict = tmp_assign_source_8; | ||
| 2825 | } | ||
| 2826 | { | ||
| 2827 | PyObject *tmp_assign_source_9; | ||
| 2828 | PyObject *tmp_metaclass_name_1; | ||
| 2829 | nuitka_bool tmp_condition_result_1; | ||
| 2830 | PyObject *tmp_key_name_1; | ||
| 2831 | PyObject *tmp_dict_name_1; | ||
| 2832 | PyObject *tmp_dict_name_2; | ||
| 2833 | PyObject *tmp_key_name_2; | ||
| 2834 | nuitka_bool tmp_condition_result_2; | ||
| 2835 | int tmp_truth_name_1; | ||
| 2836 | PyObject *tmp_type_arg_1; | ||
| 2837 | PyObject *tmp_subscribed_name_1; | ||
| 2838 | PyObject *tmp_subscript_name_1; | ||
| 2839 | PyObject *tmp_bases_name_1; | ||
| 2840 | tmp_key_name_1 = const_str_plain_metaclass; | ||
| 2841 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 2842 | tmp_dict_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 2843 | tmp_res = PyDict_Contains( tmp_dict_name_1, tmp_key_name_1 ); | ||
| 2844 | if ( tmp_res == -1 ) | ||
| 2845 | { | ||
| 2846 | assert( ERROR_OCCURRED() ); | ||
| 2847 | |||
| 2848 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2849 | |||
| 2850 | |||
| 2851 | exception_lineno = 7; | ||
| 2852 | |||
| 2853 | goto try_except_handler_1; | ||
| 2854 | } | ||
| 2855 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2856 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 2857 | { | ||
| 2858 | goto condexpr_true_1; | ||
| 2859 | } | ||
| 2860 | else | ||
| 2861 | { | ||
| 2862 | goto condexpr_false_1; | ||
| 2863 | } | ||
| 2864 | condexpr_true_1:; | ||
| 2865 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 2866 | tmp_dict_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 2867 | tmp_key_name_2 = const_str_plain_metaclass; | ||
| 2868 | tmp_metaclass_name_1 = DICT_GET_ITEM( tmp_dict_name_2, tmp_key_name_2 ); | ||
| 2869 | if ( tmp_metaclass_name_1 == NULL ) | ||
| 2870 | { | ||
| 2871 | assert( ERROR_OCCURRED() ); | ||
| 2872 | |||
| 2873 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2874 | |||
| 2875 | |||
| 2876 | exception_lineno = 7; | ||
| 2877 | |||
| 2878 | goto try_except_handler_1; | ||
| 2879 | } | ||
| 2880 | goto condexpr_end_1; | ||
| 2881 | condexpr_false_1:; | ||
| 2882 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 2883 | tmp_truth_name_1 = CHECK_IF_TRUE( tmp_class_creation_1__bases ); | ||
| 2884 | if ( tmp_truth_name_1 == -1 ) | ||
| 2885 | { | ||
| 2886 | assert( ERROR_OCCURRED() ); | ||
| 2887 | |||
| 2888 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2889 | |||
| 2890 | |||
| 2891 | exception_lineno = 7; | ||
| 2892 | |||
| 2893 | goto try_except_handler_1; | ||
| 2894 | } | ||
| 2895 | tmp_condition_result_2 = tmp_truth_name_1 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2896 | if ( tmp_condition_result_2 == NUITKA_BOOL_TRUE ) | ||
| 2897 | { | ||
| 2898 | goto condexpr_true_2; | ||
| 2899 | } | ||
| 2900 | else | ||
| 2901 | { | ||
| 2902 | goto condexpr_false_2; | ||
| 2903 | } | ||
| 2904 | condexpr_true_2:; | ||
| 2905 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 2906 | tmp_subscribed_name_1 = tmp_class_creation_1__bases; | ||
| 2907 | tmp_subscript_name_1 = const_int_0; | ||
| 2908 | tmp_type_arg_1 = LOOKUP_SUBSCRIPT_CONST( tmp_subscribed_name_1, tmp_subscript_name_1, 0 ); | ||
| 2909 | if ( tmp_type_arg_1 == NULL ) | ||
| 2910 | { | ||
| 2911 | assert( ERROR_OCCURRED() ); | ||
| 2912 | |||
| 2913 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2914 | |||
| 2915 | |||
| 2916 | exception_lineno = 7; | ||
| 2917 | |||
| 2918 | goto try_except_handler_1; | ||
| 2919 | } | ||
| 2920 | tmp_metaclass_name_1 = BUILTIN_TYPE1( tmp_type_arg_1 ); | ||
| 2921 | Py_DECREF( tmp_type_arg_1 ); | ||
| 2922 | if ( tmp_metaclass_name_1 == NULL ) | ||
| 2923 | { | ||
| 2924 | assert( ERROR_OCCURRED() ); | ||
| 2925 | |||
| 2926 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2927 | |||
| 2928 | |||
| 2929 | exception_lineno = 7; | ||
| 2930 | |||
| 2931 | goto try_except_handler_1; | ||
| 2932 | } | ||
| 2933 | goto condexpr_end_2; | ||
| 2934 | condexpr_false_2:; | ||
| 2935 | tmp_metaclass_name_1 = (PyObject *)&PyType_Type; | ||
| 2936 | Py_INCREF( tmp_metaclass_name_1 ); | ||
| 2937 | condexpr_end_2:; | ||
| 2938 | condexpr_end_1:; | ||
| 2939 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 2940 | tmp_bases_name_1 = tmp_class_creation_1__bases; | ||
| 2941 | tmp_assign_source_9 = SELECT_METACLASS( tmp_metaclass_name_1, tmp_bases_name_1 ); | ||
| 2942 | Py_DECREF( tmp_metaclass_name_1 ); | ||
| 2943 | if ( tmp_assign_source_9 == NULL ) | ||
| 2944 | { | ||
| 2945 | assert( ERROR_OCCURRED() ); | ||
| 2946 | |||
| 2947 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2948 | |||
| 2949 | |||
| 2950 | exception_lineno = 7; | ||
| 2951 | |||
| 2952 | goto try_except_handler_1; | ||
| 2953 | } | ||
| 2954 | assert( tmp_class_creation_1__metaclass == NULL ); | ||
| 2955 | tmp_class_creation_1__metaclass = tmp_assign_source_9; | ||
| 2956 | } | ||
| 2957 | { | ||
| 2958 | nuitka_bool tmp_condition_result_3; | ||
| 2959 | PyObject *tmp_key_name_3; | ||
| 2960 | PyObject *tmp_dict_name_3; | ||
| 2961 | tmp_key_name_3 = const_str_plain_metaclass; | ||
| 2962 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 2963 | tmp_dict_name_3 = tmp_class_creation_1__class_decl_dict; | ||
| 2964 | tmp_res = PyDict_Contains( tmp_dict_name_3, tmp_key_name_3 ); | ||
| 2965 | if ( tmp_res == -1 ) | ||
| 2966 | { | ||
| 2967 | assert( ERROR_OCCURRED() ); | ||
| 2968 | |||
| 2969 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2970 | |||
| 2971 | |||
| 2972 | exception_lineno = 7; | ||
| 2973 | |||
| 2974 | goto try_except_handler_1; | ||
| 2975 | } | ||
| 2976 | tmp_condition_result_3 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2977 | if ( tmp_condition_result_3 == NUITKA_BOOL_TRUE ) | ||
| 2978 | { | ||
| 2979 | goto branch_yes_1; | ||
| 2980 | } | ||
| 2981 | else | ||
| 2982 | { | ||
| 2983 | goto branch_no_1; | ||
| 2984 | } | ||
| 2985 | branch_yes_1:; | ||
| 2986 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 2987 | tmp_dictdel_dict = tmp_class_creation_1__class_decl_dict; | ||
| 2988 | tmp_dictdel_key = const_str_plain_metaclass; | ||
| 2989 | tmp_result = DICT_REMOVE_ITEM( tmp_dictdel_dict, tmp_dictdel_key ); | ||
| 2990 | if ( tmp_result == false ) | ||
| 2991 | { | ||
| 2992 | assert( ERROR_OCCURRED() ); | ||
| 2993 | |||
| 2994 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2995 | |||
| 2996 | |||
| 2997 | exception_lineno = 7; | ||
| 2998 | |||
| 2999 | goto try_except_handler_1; | ||
| 3000 | } | ||
| 3001 | branch_no_1:; | ||
| 3002 | } | ||
| 3003 | { | ||
| 3004 | nuitka_bool tmp_condition_result_4; | ||
| 3005 | PyObject *tmp_source_name_1; | ||
| 3006 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 3007 | tmp_source_name_1 = tmp_class_creation_1__metaclass; | ||
| 3008 | tmp_res = PyObject_HasAttr( tmp_source_name_1, const_str_plain___prepare__ ); | ||
| 3009 | tmp_condition_result_4 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 3010 | if ( tmp_condition_result_4 == NUITKA_BOOL_TRUE ) | ||
| 3011 | { | ||
| 3012 | goto branch_yes_2; | ||
| 3013 | } | ||
| 3014 | else | ||
| 3015 | { | ||
| 3016 | goto branch_no_2; | ||
| 3017 | } | ||
| 3018 | branch_yes_2:; | ||
| 3019 | { | ||
| 3020 | PyObject *tmp_assign_source_10; | ||
| 3021 | PyObject *tmp_called_name_1; | ||
| 3022 | PyObject *tmp_source_name_2; | ||
| 3023 | PyObject *tmp_args_name_1; | ||
| 3024 | PyObject *tmp_tuple_element_1; | ||
| 3025 | PyObject *tmp_kw_name_1; | ||
| 3026 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 3027 | tmp_source_name_2 = tmp_class_creation_1__metaclass; | ||
| 3028 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain___prepare__ ); | ||
| 3029 | if ( tmp_called_name_1 == NULL ) | ||
| 3030 | { | ||
| 3031 | assert( ERROR_OCCURRED() ); | ||
| 3032 | |||
| 3033 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3034 | |||
| 3035 | |||
| 3036 | exception_lineno = 7; | ||
| 3037 | |||
| 3038 | goto try_except_handler_1; | ||
| 3039 | } | ||
| 3040 | tmp_tuple_element_1 = const_str_plain_ProblemWatcher; | ||
| 3041 | tmp_args_name_1 = PyTuple_New( 2 ); | ||
| 3042 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 3043 | PyTuple_SET_ITEM( tmp_args_name_1, 0, tmp_tuple_element_1 ); | ||
| 3044 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 3045 | tmp_tuple_element_1 = tmp_class_creation_1__bases; | ||
| 3046 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 3047 | PyTuple_SET_ITEM( tmp_args_name_1, 1, tmp_tuple_element_1 ); | ||
| 3048 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 3049 | tmp_kw_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 3050 | frame_2765838b8bb3ab223eab9353cd0c488a->m_frame.f_lineno = 7; | ||
| 3051 | tmp_assign_source_10 = CALL_FUNCTION( tmp_called_name_1, tmp_args_name_1, tmp_kw_name_1 ); | ||
| 3052 | Py_DECREF( tmp_called_name_1 ); | ||
| 3053 | Py_DECREF( tmp_args_name_1 ); | ||
| 3054 | if ( tmp_assign_source_10 == NULL ) | ||
| 3055 | { | ||
| 3056 | assert( ERROR_OCCURRED() ); | ||
| 3057 | |||
| 3058 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3059 | |||
| 3060 | |||
| 3061 | exception_lineno = 7; | ||
| 3062 | |||
| 3063 | goto try_except_handler_1; | ||
| 3064 | } | ||
| 3065 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 3066 | tmp_class_creation_1__prepared = tmp_assign_source_10; | ||
| 3067 | } | ||
| 3068 | { | ||
| 3069 | nuitka_bool tmp_condition_result_5; | ||
| 3070 | PyObject *tmp_operand_name_1; | ||
| 3071 | PyObject *tmp_source_name_3; | ||
| 3072 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 3073 | tmp_source_name_3 = tmp_class_creation_1__prepared; | ||
| 3074 | tmp_res = PyObject_HasAttr( tmp_source_name_3, const_str_plain___getitem__ ); | ||
| 3075 | tmp_operand_name_1 = ( tmp_res != 0 ) ? Py_True : Py_False; | ||
| 3076 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 3077 | if ( tmp_res == -1 ) | ||
| 3078 | { | ||
| 3079 | assert( ERROR_OCCURRED() ); | ||
| 3080 | |||
| 3081 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3082 | |||
| 3083 | |||
| 3084 | exception_lineno = 7; | ||
| 3085 | |||
| 3086 | goto try_except_handler_1; | ||
| 3087 | } | ||
| 3088 | tmp_condition_result_5 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 3089 | if ( tmp_condition_result_5 == NUITKA_BOOL_TRUE ) | ||
| 3090 | { | ||
| 3091 | goto branch_yes_3; | ||
| 3092 | } | ||
| 3093 | else | ||
| 3094 | { | ||
| 3095 | goto branch_no_3; | ||
| 3096 | } | ||
| 3097 | branch_yes_3:; | ||
| 3098 | { | ||
| 3099 | PyObject *tmp_raise_type_1; | ||
| 3100 | PyObject *tmp_raise_value_1; | ||
| 3101 | PyObject *tmp_left_name_1; | ||
| 3102 | PyObject *tmp_right_name_1; | ||
| 3103 | PyObject *tmp_tuple_element_2; | ||
| 3104 | PyObject *tmp_getattr_target_1; | ||
| 3105 | PyObject *tmp_getattr_attr_1; | ||
| 3106 | PyObject *tmp_getattr_default_1; | ||
| 3107 | PyObject *tmp_source_name_4; | ||
| 3108 | PyObject *tmp_type_arg_2; | ||
| 3109 | tmp_raise_type_1 = PyExc_TypeError; | ||
| 3110 | tmp_left_name_1 = const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 3111 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 3112 | tmp_getattr_target_1 = tmp_class_creation_1__metaclass; | ||
| 3113 | tmp_getattr_attr_1 = const_str_plain___name__; | ||
| 3114 | tmp_getattr_default_1 = const_str_angle_metaclass; | ||
| 3115 | tmp_tuple_element_2 = BUILTIN_GETATTR( tmp_getattr_target_1, tmp_getattr_attr_1, tmp_getattr_default_1 ); | ||
| 3116 | if ( tmp_tuple_element_2 == NULL ) | ||
| 3117 | { | ||
| 3118 | assert( ERROR_OCCURRED() ); | ||
| 3119 | |||
| 3120 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3121 | |||
| 3122 | |||
| 3123 | exception_lineno = 7; | ||
| 3124 | |||
| 3125 | goto try_except_handler_1; | ||
| 3126 | } | ||
| 3127 | tmp_right_name_1 = PyTuple_New( 2 ); | ||
| 3128 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_2 ); | ||
| 3129 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 3130 | tmp_type_arg_2 = tmp_class_creation_1__prepared; | ||
| 3131 | tmp_source_name_4 = BUILTIN_TYPE1( tmp_type_arg_2 ); | ||
| 3132 | assert( !(tmp_source_name_4 == NULL) ); | ||
| 3133 | tmp_tuple_element_2 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain___name__ ); | ||
| 3134 | Py_DECREF( tmp_source_name_4 ); | ||
| 3135 | if ( tmp_tuple_element_2 == NULL ) | ||
| 3136 | { | ||
| 3137 | assert( ERROR_OCCURRED() ); | ||
| 3138 | |||
| 3139 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3140 | Py_DECREF( tmp_right_name_1 ); | ||
| 3141 | |||
| 3142 | exception_lineno = 7; | ||
| 3143 | |||
| 3144 | goto try_except_handler_1; | ||
| 3145 | } | ||
| 3146 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_2 ); | ||
| 3147 | tmp_raise_value_1 = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 3148 | Py_DECREF( tmp_right_name_1 ); | ||
| 3149 | if ( tmp_raise_value_1 == NULL ) | ||
| 3150 | { | ||
| 3151 | assert( ERROR_OCCURRED() ); | ||
| 3152 | |||
| 3153 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3154 | |||
| 3155 | |||
| 3156 | exception_lineno = 7; | ||
| 3157 | |||
| 3158 | goto try_except_handler_1; | ||
| 3159 | } | ||
| 3160 | exception_type = tmp_raise_type_1; | ||
| 3161 | Py_INCREF( tmp_raise_type_1 ); | ||
| 3162 | exception_value = tmp_raise_value_1; | ||
| 3163 | exception_lineno = 7; | ||
| 3164 | RAISE_EXCEPTION_IMPLICIT( &exception_type, &exception_value, &exception_tb ); | ||
| 3165 | |||
| 3166 | goto try_except_handler_1; | ||
| 3167 | } | ||
| 3168 | branch_no_3:; | ||
| 3169 | } | ||
| 3170 | goto branch_end_2; | ||
| 3171 | branch_no_2:; | ||
| 3172 | { | ||
| 3173 | PyObject *tmp_assign_source_11; | ||
| 3174 | tmp_assign_source_11 = PyDict_New(); | ||
| 3175 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 3176 | tmp_class_creation_1__prepared = tmp_assign_source_11; | ||
| 3177 | } | ||
| 3178 | branch_end_2:; | ||
| 3179 | } | ||
| 3180 | { | ||
| 3181 | PyObject *tmp_assign_source_12; | ||
| 3182 | { | ||
| 3183 | PyObject *tmp_set_locals_1; | ||
| 3184 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 3185 | tmp_set_locals_1 = tmp_class_creation_1__prepared; | ||
| 3186 | locals_problem$watch_7 = tmp_set_locals_1; | ||
| 3187 | Py_INCREF( tmp_set_locals_1 ); | ||
| 3188 | } | ||
| 3189 | // Tried code: | ||
| 3190 | // Tried code: | ||
| 3191 | tmp_dictset_value = const_str_digest_38fb2aa5dde28301dc9b212f510d8ef6; | ||
| 3192 | tmp_res = PyObject_SetItem( locals_problem$watch_7, const_str_plain___module__, tmp_dictset_value ); | ||
| 3193 | if ( tmp_res != 0 ) | ||
| 3194 | { | ||
| 3195 | assert( ERROR_OCCURRED() ); | ||
| 3196 | |||
| 3197 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3198 | |||
| 3199 | |||
| 3200 | exception_lineno = 7; | ||
| 3201 | |||
| 3202 | goto try_except_handler_3; | ||
| 3203 | } | ||
| 3204 | tmp_dictset_value = const_str_digest_fc8a5876d3416745601ebf18c127ebfc; | ||
| 3205 | tmp_res = PyObject_SetItem( locals_problem$watch_7, const_str_plain___doc__, tmp_dictset_value ); | ||
| 3206 | if ( tmp_res != 0 ) | ||
| 3207 | { | ||
| 3208 | assert( ERROR_OCCURRED() ); | ||
| 3209 | |||
| 3210 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3211 | |||
| 3212 | |||
| 3213 | exception_lineno = 7; | ||
| 3214 | |||
| 3215 | goto try_except_handler_3; | ||
| 3216 | } | ||
| 3217 | tmp_dictset_value = const_str_plain_ProblemWatcher; | ||
| 3218 | tmp_res = PyObject_SetItem( locals_problem$watch_7, const_str_plain___qualname__, tmp_dictset_value ); | ||
| 3219 | if ( tmp_res != 0 ) | ||
| 3220 | { | ||
| 3221 | assert( ERROR_OCCURRED() ); | ||
| 3222 | |||
| 3223 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3224 | |||
| 3225 | |||
| 3226 | exception_lineno = 7; | ||
| 3227 | |||
| 3228 | goto try_except_handler_3; | ||
| 3229 | } | ||
| 3230 | MAKE_OR_REUSE_FRAME( cache_frame_6460bfc2f936b42b752a8a65fb70122a_2, codeobj_6460bfc2f936b42b752a8a65fb70122a, module_problem$watch, sizeof(void *) ); | ||
| 3231 | frame_6460bfc2f936b42b752a8a65fb70122a_2 = cache_frame_6460bfc2f936b42b752a8a65fb70122a_2; | ||
| 3232 | |||
| 3233 | // Push the new frame as the currently active one. | ||
| 3234 | pushFrameStack( frame_6460bfc2f936b42b752a8a65fb70122a_2 ); | ||
| 3235 | |||
| 3236 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 3237 | assert( Py_REFCNT( frame_6460bfc2f936b42b752a8a65fb70122a_2 ) == 2 ); // Frame stack | ||
| 3238 | |||
| 3239 | // Framed code: | ||
| 3240 | tmp_dictset_value = MAKE_FUNCTION_problem$watch$$$function_1___init__( ); | ||
| 3241 | |||
| 3242 | |||
| 3243 | |||
| 3244 | tmp_res = PyObject_SetItem( locals_problem$watch_7, const_str_plain___init__, tmp_dictset_value ); | ||
| 3245 | Py_DECREF( tmp_dictset_value ); | ||
| 3246 | if ( tmp_res != 0 ) | ||
| 3247 | { | ||
| 3248 | assert( ERROR_OCCURRED() ); | ||
| 3249 | |||
| 3250 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3251 | |||
| 3252 | |||
| 3253 | exception_lineno = 16; | ||
| 3254 | type_description_2 = "o"; | ||
| 3255 | goto frame_exception_exit_2; | ||
| 3256 | } | ||
| 3257 | tmp_dictset_value = MAKE_FUNCTION_problem$watch$$$function_2__new_problem_handler( ); | ||
| 3258 | |||
| 3259 | |||
| 3260 | |||
| 3261 | tmp_res = PyObject_SetItem( locals_problem$watch_7, const_str_plain__new_problem_handler, tmp_dictset_value ); | ||
| 3262 | Py_DECREF( tmp_dictset_value ); | ||
| 3263 | if ( tmp_res != 0 ) | ||
| 3264 | { | ||
| 3265 | assert( ERROR_OCCURRED() ); | ||
| 3266 | |||
| 3267 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3268 | |||
| 3269 | |||
| 3270 | exception_lineno = 44; | ||
| 3271 | type_description_2 = "o"; | ||
| 3272 | goto frame_exception_exit_2; | ||
| 3273 | } | ||
| 3274 | tmp_dictset_value = MAKE_FUNCTION_problem$watch$$$function_3_add_callback( ); | ||
| 3275 | |||
| 3276 | |||
| 3277 | |||
| 3278 | tmp_res = PyObject_SetItem( locals_problem$watch_7, const_str_plain_add_callback, tmp_dictset_value ); | ||
| 3279 | Py_DECREF( tmp_dictset_value ); | ||
| 3280 | if ( tmp_res != 0 ) | ||
| 3281 | { | ||
| 3282 | assert( ERROR_OCCURRED() ); | ||
| 3283 | |||
| 3284 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3285 | |||
| 3286 | |||
| 3287 | exception_lineno = 55; | ||
| 3288 | type_description_2 = "o"; | ||
| 3289 | goto frame_exception_exit_2; | ||
| 3290 | } | ||
| 3291 | tmp_dictset_value = MAKE_FUNCTION_problem$watch$$$function_4_run( ); | ||
| 3292 | |||
| 3293 | |||
| 3294 | |||
| 3295 | tmp_res = PyObject_SetItem( locals_problem$watch_7, const_str_plain_run, tmp_dictset_value ); | ||
| 3296 | Py_DECREF( tmp_dictset_value ); | ||
| 3297 | if ( tmp_res != 0 ) | ||
| 3298 | { | ||
| 3299 | assert( ERROR_OCCURRED() ); | ||
| 3300 | |||
| 3301 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3302 | |||
| 3303 | |||
| 3304 | exception_lineno = 64; | ||
| 3305 | type_description_2 = "o"; | ||
| 3306 | goto frame_exception_exit_2; | ||
| 3307 | } | ||
| 3308 | tmp_dictset_value = MAKE_FUNCTION_problem$watch$$$function_5_quit( ); | ||
| 3309 | |||
| 3310 | |||
| 3311 | |||
| 3312 | tmp_res = PyObject_SetItem( locals_problem$watch_7, const_str_plain_quit, tmp_dictset_value ); | ||
| 3313 | Py_DECREF( tmp_dictset_value ); | ||
| 3314 | if ( tmp_res != 0 ) | ||
| 3315 | { | ||
| 3316 | assert( ERROR_OCCURRED() ); | ||
| 3317 | |||
| 3318 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3319 | |||
| 3320 | |||
| 3321 | exception_lineno = 69; | ||
| 3322 | type_description_2 = "o"; | ||
| 3323 | goto frame_exception_exit_2; | ||
| 3324 | } | ||
| 3325 | |||
| 3326 | #if 0 | ||
| 3327 | RESTORE_FRAME_EXCEPTION( frame_6460bfc2f936b42b752a8a65fb70122a_2 ); | ||
| 3328 | #endif | ||
| 3329 | |||
| 3330 | // Put the previous frame back on top. | ||
| 3331 | popFrameStack(); | ||
| 3332 | |||
| 3333 | goto frame_no_exception_1; | ||
| 3334 | |||
| 3335 | frame_exception_exit_2:; | ||
| 3336 | |||
| 3337 | #if 0 | ||
| 3338 | RESTORE_FRAME_EXCEPTION( frame_6460bfc2f936b42b752a8a65fb70122a_2 ); | ||
| 3339 | #endif | ||
| 3340 | |||
| 3341 | if ( exception_tb == NULL ) | ||
| 3342 | { | ||
| 3343 | exception_tb = MAKE_TRACEBACK( frame_6460bfc2f936b42b752a8a65fb70122a_2, exception_lineno ); | ||
| 3344 | } | ||
| 3345 | else if ( exception_tb->tb_frame != &frame_6460bfc2f936b42b752a8a65fb70122a_2->m_frame ) | ||
| 3346 | { | ||
| 3347 | exception_tb = ADD_TRACEBACK( exception_tb, frame_6460bfc2f936b42b752a8a65fb70122a_2, exception_lineno ); | ||
| 3348 | } | ||
| 3349 | |||
| 3350 | // Attachs locals to frame if any. | ||
| 3351 | Nuitka_Frame_AttachLocals( | ||
| 3352 | (struct Nuitka_FrameObject *)frame_6460bfc2f936b42b752a8a65fb70122a_2, | ||
| 3353 | type_description_2, | ||
| 3354 | outline_0_var___class__ | ||
| 3355 | ); | ||
| 3356 | |||
| 3357 | |||
| 3358 | // Release cached frame. | ||
| 3359 | if ( frame_6460bfc2f936b42b752a8a65fb70122a_2 == cache_frame_6460bfc2f936b42b752a8a65fb70122a_2 ) | ||
| 3360 | { | ||
| 3361 | Py_DECREF( frame_6460bfc2f936b42b752a8a65fb70122a_2 ); | ||
| 3362 | } | ||
| 3363 | cache_frame_6460bfc2f936b42b752a8a65fb70122a_2 = NULL; | ||
| 3364 | |||
| 3365 | assertFrameObject( frame_6460bfc2f936b42b752a8a65fb70122a_2 ); | ||
| 3366 | |||
| 3367 | // Put the previous frame back on top. | ||
| 3368 | popFrameStack(); | ||
| 3369 | |||
| 3370 | // Return the error. | ||
| 3371 | goto nested_frame_exit_1; | ||
| 3372 | |||
| 3373 | frame_no_exception_1:; | ||
| 3374 | goto skip_nested_handling_1; | ||
| 3375 | nested_frame_exit_1:; | ||
| 3376 | |||
| 3377 | goto try_except_handler_3; | ||
| 3378 | skip_nested_handling_1:; | ||
| 3379 | { | ||
| 3380 | nuitka_bool tmp_condition_result_6; | ||
| 3381 | PyObject *tmp_compexpr_left_1; | ||
| 3382 | PyObject *tmp_compexpr_right_1; | ||
| 3383 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 3384 | tmp_compexpr_left_1 = tmp_class_creation_1__bases; | ||
| 3385 | tmp_compexpr_right_1 = const_tuple_type_object_tuple; | ||
| 3386 | tmp_res = RICH_COMPARE_BOOL_NOTEQ_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 3387 | if ( tmp_res == -1 ) | ||
| 3388 | { | ||
| 3389 | assert( ERROR_OCCURRED() ); | ||
| 3390 | |||
| 3391 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3392 | |||
| 3393 | |||
| 3394 | exception_lineno = 7; | ||
| 3395 | |||
| 3396 | goto try_except_handler_3; | ||
| 3397 | } | ||
| 3398 | tmp_condition_result_6 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 3399 | if ( tmp_condition_result_6 == NUITKA_BOOL_TRUE ) | ||
| 3400 | { | ||
| 3401 | goto branch_yes_4; | ||
| 3402 | } | ||
| 3403 | else | ||
| 3404 | { | ||
| 3405 | goto branch_no_4; | ||
| 3406 | } | ||
| 3407 | branch_yes_4:; | ||
| 3408 | tmp_dictset_value = const_tuple_type_object_tuple; | ||
| 3409 | tmp_res = PyObject_SetItem( locals_problem$watch_7, const_str_plain___orig_bases__, tmp_dictset_value ); | ||
| 3410 | if ( tmp_res != 0 ) | ||
| 3411 | { | ||
| 3412 | assert( ERROR_OCCURRED() ); | ||
| 3413 | |||
| 3414 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3415 | |||
| 3416 | |||
| 3417 | exception_lineno = 7; | ||
| 3418 | |||
| 3419 | goto try_except_handler_3; | ||
| 3420 | } | ||
| 3421 | branch_no_4:; | ||
| 3422 | } | ||
| 3423 | { | ||
| 3424 | PyObject *tmp_assign_source_13; | ||
| 3425 | PyObject *tmp_called_name_2; | ||
| 3426 | PyObject *tmp_args_name_2; | ||
| 3427 | PyObject *tmp_tuple_element_3; | ||
| 3428 | PyObject *tmp_kw_name_2; | ||
| 3429 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 3430 | tmp_called_name_2 = tmp_class_creation_1__metaclass; | ||
| 3431 | tmp_tuple_element_3 = const_str_plain_ProblemWatcher; | ||
| 3432 | tmp_args_name_2 = PyTuple_New( 3 ); | ||
| 3433 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 3434 | PyTuple_SET_ITEM( tmp_args_name_2, 0, tmp_tuple_element_3 ); | ||
| 3435 | CHECK_OBJECT( tmp_class_creation_1__bases ); | ||
| 3436 | tmp_tuple_element_3 = tmp_class_creation_1__bases; | ||
| 3437 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 3438 | PyTuple_SET_ITEM( tmp_args_name_2, 1, tmp_tuple_element_3 ); | ||
| 3439 | tmp_tuple_element_3 = locals_problem$watch_7; | ||
| 3440 | Py_INCREF( tmp_tuple_element_3 ); | ||
| 3441 | PyTuple_SET_ITEM( tmp_args_name_2, 2, tmp_tuple_element_3 ); | ||
| 3442 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 3443 | tmp_kw_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 3444 | frame_2765838b8bb3ab223eab9353cd0c488a->m_frame.f_lineno = 7; | ||
| 3445 | tmp_assign_source_13 = CALL_FUNCTION( tmp_called_name_2, tmp_args_name_2, tmp_kw_name_2 ); | ||
| 3446 | Py_DECREF( tmp_args_name_2 ); | ||
| 3447 | if ( tmp_assign_source_13 == NULL ) | ||
| 3448 | { | ||
| 3449 | assert( ERROR_OCCURRED() ); | ||
| 3450 | |||
| 3451 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 3452 | |||
| 3453 | |||
| 3454 | exception_lineno = 7; | ||
| 3455 | |||
| 3456 | goto try_except_handler_3; | ||
| 3457 | } | ||
| 3458 | assert( outline_0_var___class__ == NULL ); | ||
| 3459 | outline_0_var___class__ = tmp_assign_source_13; | ||
| 3460 | } | ||
| 3461 | CHECK_OBJECT( outline_0_var___class__ ); | ||
| 3462 | tmp_assign_source_12 = outline_0_var___class__; | ||
| 3463 | Py_INCREF( tmp_assign_source_12 ); | ||
| 3464 | goto try_return_handler_3; | ||
| 3465 | // tried codes exits in all cases | ||
| 3466 | NUITKA_CANNOT_GET_HERE( problem$watch ); | ||
| 3467 | return MOD_RETURN_VALUE( NULL ); | ||
| 3468 | // Return handler code: | ||
| 3469 | try_return_handler_3:; | ||
| 3470 | Py_DECREF( locals_problem$watch_7 ); | ||
| 3471 | locals_problem$watch_7 = NULL; | ||
| 3472 | goto try_return_handler_2; | ||
| 3473 | // Exception handler code: | ||
| 3474 | try_except_handler_3:; | ||
| 3475 | exception_keeper_type_1 = exception_type; | ||
| 3476 | exception_keeper_value_1 = exception_value; | ||
| 3477 | exception_keeper_tb_1 = exception_tb; | ||
| 3478 | exception_keeper_lineno_1 = exception_lineno; | ||
| 3479 | exception_type = NULL; | ||
| 3480 | exception_value = NULL; | ||
| 3481 | exception_tb = NULL; | ||
| 3482 | exception_lineno = 0; | ||
| 3483 | |||
| 3484 | Py_DECREF( locals_problem$watch_7 ); | ||
| 3485 | locals_problem$watch_7 = NULL; | ||
| 3486 | // Re-raise. | ||
| 3487 | exception_type = exception_keeper_type_1; | ||
| 3488 | exception_value = exception_keeper_value_1; | ||
| 3489 | exception_tb = exception_keeper_tb_1; | ||
| 3490 | exception_lineno = exception_keeper_lineno_1; | ||
| 3491 | |||
| 3492 | goto try_except_handler_2; | ||
| 3493 | // End of try: | ||
| 3494 | // tried codes exits in all cases | ||
| 3495 | NUITKA_CANNOT_GET_HERE( problem$watch ); | ||
| 3496 | return MOD_RETURN_VALUE( NULL ); | ||
| 3497 | // Return handler code: | ||
| 3498 | try_return_handler_2:; | ||
| 3499 | CHECK_OBJECT( (PyObject *)outline_0_var___class__ ); | ||
| 3500 | Py_DECREF( outline_0_var___class__ ); | ||
| 3501 | outline_0_var___class__ = NULL; | ||
| 3502 | |||
| 3503 | goto outline_result_1; | ||
| 3504 | // Exception handler code: | ||
| 3505 | try_except_handler_2:; | ||
| 3506 | exception_keeper_type_2 = exception_type; | ||
| 3507 | exception_keeper_value_2 = exception_value; | ||
| 3508 | exception_keeper_tb_2 = exception_tb; | ||
| 3509 | exception_keeper_lineno_2 = exception_lineno; | ||
| 3510 | exception_type = NULL; | ||
| 3511 | exception_value = NULL; | ||
| 3512 | exception_tb = NULL; | ||
| 3513 | exception_lineno = 0; | ||
| 3514 | |||
| 3515 | // Re-raise. | ||
| 3516 | exception_type = exception_keeper_type_2; | ||
| 3517 | exception_value = exception_keeper_value_2; | ||
| 3518 | exception_tb = exception_keeper_tb_2; | ||
| 3519 | exception_lineno = exception_keeper_lineno_2; | ||
| 3520 | |||
| 3521 | goto outline_exception_1; | ||
| 3522 | // End of try: | ||
| 3523 | // Return statement must have exited already. | ||
| 3524 | NUITKA_CANNOT_GET_HERE( problem$watch ); | ||
| 3525 | return MOD_RETURN_VALUE( NULL ); | ||
| 3526 | outline_exception_1:; | ||
| 3527 | exception_lineno = 7; | ||
| 3528 | goto try_except_handler_1; | ||
| 3529 | outline_result_1:; | ||
| 3530 | UPDATE_STRING_DICT1( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain_ProblemWatcher, tmp_assign_source_12 ); | ||
| 3531 | } | ||
| 3532 | goto try_end_1; | ||
| 3533 | // Exception handler code: | ||
| 3534 | try_except_handler_1:; | ||
| 3535 | exception_keeper_type_3 = exception_type; | ||
| 3536 | exception_keeper_value_3 = exception_value; | ||
| 3537 | exception_keeper_tb_3 = exception_tb; | ||
| 3538 | exception_keeper_lineno_3 = exception_lineno; | ||
| 3539 | exception_type = NULL; | ||
| 3540 | exception_value = NULL; | ||
| 3541 | exception_tb = NULL; | ||
| 3542 | exception_lineno = 0; | ||
| 3543 | |||
| 3544 | Py_XDECREF( tmp_class_creation_1__bases ); | ||
| 3545 | tmp_class_creation_1__bases = NULL; | ||
| 3546 | |||
| 3547 | Py_XDECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 3548 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 3549 | |||
| 3550 | Py_XDECREF( tmp_class_creation_1__metaclass ); | ||
| 3551 | tmp_class_creation_1__metaclass = NULL; | ||
| 3552 | |||
| 3553 | Py_XDECREF( tmp_class_creation_1__prepared ); | ||
| 3554 | tmp_class_creation_1__prepared = NULL; | ||
| 3555 | |||
| 3556 | // Re-raise. | ||
| 3557 | exception_type = exception_keeper_type_3; | ||
| 3558 | exception_value = exception_keeper_value_3; | ||
| 3559 | exception_tb = exception_keeper_tb_3; | ||
| 3560 | exception_lineno = exception_keeper_lineno_3; | ||
| 3561 | |||
| 3562 | goto frame_exception_exit_1; | ||
| 3563 | // End of try: | ||
| 3564 | try_end_1:; | ||
| 3565 | |||
| 3566 | // Restore frame exception if necessary. | ||
| 3567 | #if 0 | ||
| 3568 | RESTORE_FRAME_EXCEPTION( frame_2765838b8bb3ab223eab9353cd0c488a ); | ||
| 3569 | #endif | ||
| 3570 | popFrameStack(); | ||
| 3571 | |||
| 3572 | assertFrameObject( frame_2765838b8bb3ab223eab9353cd0c488a ); | ||
| 3573 | |||
| 3574 | goto frame_no_exception_2; | ||
| 3575 | |||
| 3576 | frame_exception_exit_1:; | ||
| 3577 | #if 0 | ||
| 3578 | RESTORE_FRAME_EXCEPTION( frame_2765838b8bb3ab223eab9353cd0c488a ); | ||
| 3579 | #endif | ||
| 3580 | |||
| 3581 | if ( exception_tb == NULL ) | ||
| 3582 | { | ||
| 3583 | exception_tb = MAKE_TRACEBACK( frame_2765838b8bb3ab223eab9353cd0c488a, exception_lineno ); | ||
| 3584 | } | ||
| 3585 | else if ( exception_tb->tb_frame != &frame_2765838b8bb3ab223eab9353cd0c488a->m_frame ) | ||
| 3586 | { | ||
| 3587 | exception_tb = ADD_TRACEBACK( exception_tb, frame_2765838b8bb3ab223eab9353cd0c488a, exception_lineno ); | ||
| 3588 | } | ||
| 3589 | |||
| 3590 | // Put the previous frame back on top. | ||
| 3591 | popFrameStack(); | ||
| 3592 | |||
| 3593 | // Return the error. | ||
| 3594 | goto module_exception_exit; | ||
| 3595 | |||
| 3596 | frame_no_exception_2:; | ||
| 3597 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__bases ); | ||
| 3598 | Py_DECREF( tmp_class_creation_1__bases ); | ||
| 3599 | tmp_class_creation_1__bases = NULL; | ||
| 3600 | |||
| 3601 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__class_decl_dict ); | ||
| 3602 | Py_DECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 3603 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 3604 | |||
| 3605 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__metaclass ); | ||
| 3606 | Py_DECREF( tmp_class_creation_1__metaclass ); | ||
| 3607 | tmp_class_creation_1__metaclass = NULL; | ||
| 3608 | |||
| 3609 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__prepared ); | ||
| 3610 | Py_DECREF( tmp_class_creation_1__prepared ); | ||
| 3611 | tmp_class_creation_1__prepared = NULL; | ||
| 3612 | |||
| 3613 | |||
| 3614 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 3615 | #if 0 && 0 | ||
| 3616 | { | ||
| 3617 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_problem$watch, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 3618 | |||
| 3619 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 3620 | { | ||
| 3621 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 3622 | |||
| 3623 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 3624 | CHECK_OBJECT( path_importer_cache ); | ||
| 3625 | |||
| 3626 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 3627 | assert( res == 0 ); | ||
| 3628 | } | ||
| 3629 | } | ||
| 3630 | #endif | ||
| 3631 | #endif | ||
| 3632 | |||
| 3633 | return MOD_RETURN_VALUE( module_problem$watch ); | ||
| 3634 | module_exception_exit: | ||
| 3635 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 3636 | return MOD_RETURN_VALUE( NULL ); | ||
| 3637 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.problem.watch.o deleted (index 46269d9..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.pyanaconda.c deleted (index fcb93ef..0000000) | |||
| 1 | /* Generated code for Python module 'pyanaconda' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_pyanaconda" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_pyanaconda; | ||
| 31 | PyDictObject *moduledict_pyanaconda; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_tuple_259a9893e45702189ab930fb0b217a08_tuple; | ||
| 35 | extern PyObject *const_str_plain___file__; | ||
| 36 | extern PyObject *const_str_plain_environ; | ||
| 37 | extern PyObject *const_str_plain_get; | ||
| 38 | extern PyObject *const_str_plain_origin; | ||
| 39 | extern PyObject *const_str_plain_NUITKA_PACKAGE_pyanaconda; | ||
| 40 | extern PyObject *const_str_plain_pyanaconda; | ||
| 41 | extern PyObject *const_str_plain___spec__; | ||
| 42 | extern PyObject *const_str_plain_path; | ||
| 43 | static PyObject *const_str_digest_6000b95d301ac9488e85c55b29009bf8; | ||
| 44 | extern PyObject *const_str_plain_dirname; | ||
| 45 | extern PyObject *const_str_digest_5bfaf90dbd407b4fc29090c8f6415242; | ||
| 46 | extern PyObject *const_str_plain___path__; | ||
| 47 | extern PyObject *const_tuple_empty; | ||
| 48 | extern PyObject *const_str_plain___doc__; | ||
| 49 | extern PyObject *const_str_plain___cached__; | ||
| 50 | extern PyObject *const_str_plain_has_location; | ||
| 51 | static PyObject *const_str_digest_ee51389397333081ea3664bada9e22cb; | ||
| 52 | static PyObject *module_filename_obj; | ||
| 53 | |||
| 54 | /* Indicator if this modules private constants were created yet. */ | ||
| 55 | static bool constants_created = false; | ||
| 56 | |||
| 57 | /* Function to create module private constants. */ | ||
| 58 | static void createModuleConstants( void ) | ||
| 59 | { | ||
| 60 | const_str_digest_6000b95d301ac9488e85c55b29009bf8 = UNSTREAM_STRING_ASCII( &constant_bin[ 60238 ], 19, 0 ); | ||
| 61 | const_str_digest_ee51389397333081ea3664bada9e22cb = UNSTREAM_STRING_ASCII( &constant_bin[ 60257 ], 22, 0 ); | ||
| 62 | |||
| 63 | constants_created = true; | ||
| 64 | } | ||
| 65 | |||
| 66 | /* Function to verify module private constants for non-corruption. */ | ||
| 67 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 68 | void checkModuleConstants_pyanaconda( void ) | ||
| 69 | { | ||
| 70 | // The module may not have been used at all, then ignore this. | ||
| 71 | if (constants_created == false) return; | ||
| 72 | |||
| 73 | |||
| 74 | } | ||
| 75 | #endif | ||
| 76 | |||
| 77 | // The module code objects. | ||
| 78 | static PyCodeObject *codeobj_4cf88d18e1b9d52f5b8ad46477dac15a; | ||
| 79 | |||
| 80 | static void createModuleCodeObjects(void) | ||
| 81 | { | ||
| 82 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_ee51389397333081ea3664bada9e22cb ); | ||
| 83 | codeobj_4cf88d18e1b9d52f5b8ad46477dac15a = MAKE_CODEOBJ( module_filename_obj, const_str_digest_6000b95d301ac9488e85c55b29009bf8, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 84 | } | ||
| 85 | |||
| 86 | // The module function declarations. | ||
| 87 | |||
| 88 | |||
| 89 | // The module function definitions. | ||
| 90 | |||
| 91 | |||
| 92 | |||
| 93 | #if PYTHON_VERSION >= 300 | ||
| 94 | static struct PyModuleDef mdef_pyanaconda = | ||
| 95 | { | ||
| 96 | PyModuleDef_HEAD_INIT, | ||
| 97 | "pyanaconda", | ||
| 98 | NULL, /* m_doc */ | ||
| 99 | -1, /* m_size */ | ||
| 100 | NULL, /* m_methods */ | ||
| 101 | NULL, /* m_reload */ | ||
| 102 | NULL, /* m_traverse */ | ||
| 103 | NULL, /* m_clear */ | ||
| 104 | NULL, /* m_free */ | ||
| 105 | }; | ||
| 106 | #endif | ||
| 107 | |||
| 108 | extern PyObject *const_str_plain___compiled__; | ||
| 109 | |||
| 110 | extern PyObject *const_str_plain___package__; | ||
| 111 | |||
| 112 | #if PYTHON_VERSION >= 300 | ||
| 113 | extern PyObject *const_str_dot; | ||
| 114 | extern PyObject *const_str_plain___loader__; | ||
| 115 | #endif | ||
| 116 | |||
| 117 | #if PYTHON_VERSION >= 340 | ||
| 118 | extern PyObject *const_str_plain___spec__; | ||
| 119 | extern PyObject *const_str_plain__initializing; | ||
| 120 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 121 | #endif | ||
| 122 | |||
| 123 | extern void _initCompiledCellType(); | ||
| 124 | extern void _initCompiledGeneratorType(); | ||
| 125 | extern void _initCompiledFunctionType(); | ||
| 126 | extern void _initCompiledMethodType(); | ||
| 127 | extern void _initCompiledFrameType(); | ||
| 128 | #if PYTHON_VERSION >= 350 | ||
| 129 | extern void _initCompiledCoroutineTypes(); | ||
| 130 | #endif | ||
| 131 | #if PYTHON_VERSION >= 360 | ||
| 132 | extern void _initCompiledAsyncgenTypes(); | ||
| 133 | #endif | ||
| 134 | |||
| 135 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 136 | |||
| 137 | // The exported interface to CPython. On import of the module, this function | ||
| 138 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 139 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 140 | |||
| 141 | MOD_INIT_DECL( pyanaconda ) | ||
| 142 | { | ||
| 143 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 144 | static bool _init_done = false; | ||
| 145 | |||
| 146 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 147 | if ( _init_done ) | ||
| 148 | { | ||
| 149 | return MOD_RETURN_VALUE( module_pyanaconda ); | ||
| 150 | } | ||
| 151 | else | ||
| 152 | { | ||
| 153 | _init_done = true; | ||
| 154 | } | ||
| 155 | #endif | ||
| 156 | |||
| 157 | #ifdef _NUITKA_MODULE | ||
| 158 | // In case of a stand alone extension module, need to call initialization | ||
| 159 | // the init here because that's the first and only time we are going to get | ||
| 160 | // called here. | ||
| 161 | |||
| 162 | // Initialize the constant values used. | ||
| 163 | _initBuiltinModule(); | ||
| 164 | createGlobalConstants(); | ||
| 165 | |||
| 166 | /* Initialize the compiled types of Nuitka. */ | ||
| 167 | _initCompiledCellType(); | ||
| 168 | _initCompiledGeneratorType(); | ||
| 169 | _initCompiledFunctionType(); | ||
| 170 | _initCompiledMethodType(); | ||
| 171 | _initCompiledFrameType(); | ||
| 172 | #if PYTHON_VERSION >= 350 | ||
| 173 | _initCompiledCoroutineTypes(); | ||
| 174 | #endif | ||
| 175 | #if PYTHON_VERSION >= 360 | ||
| 176 | _initCompiledAsyncgenTypes(); | ||
| 177 | #endif | ||
| 178 | |||
| 179 | #if PYTHON_VERSION < 300 | ||
| 180 | _initSlotCompare(); | ||
| 181 | #endif | ||
| 182 | #if PYTHON_VERSION >= 270 | ||
| 183 | _initSlotIternext(); | ||
| 184 | #endif | ||
| 185 | |||
| 186 | patchBuiltinModule(); | ||
| 187 | patchTypeComparison(); | ||
| 188 | |||
| 189 | // Enable meta path based loader if not already done. | ||
| 190 | #ifdef _NUITKA_TRACE | ||
| 191 | puts("pyanaconda: Calling setupMetaPathBasedLoader()."); | ||
| 192 | #endif | ||
| 193 | setupMetaPathBasedLoader(); | ||
| 194 | |||
| 195 | #if PYTHON_VERSION >= 300 | ||
| 196 | patchInspectModule(); | ||
| 197 | #endif | ||
| 198 | |||
| 199 | #endif | ||
| 200 | |||
| 201 | /* The constants only used by this module are created now. */ | ||
| 202 | #ifdef _NUITKA_TRACE | ||
| 203 | puts("pyanaconda: Calling createModuleConstants()."); | ||
| 204 | #endif | ||
| 205 | createModuleConstants(); | ||
| 206 | |||
| 207 | /* The code objects used by this module are created now. */ | ||
| 208 | #ifdef _NUITKA_TRACE | ||
| 209 | puts("pyanaconda: Calling createModuleCodeObjects()."); | ||
| 210 | #endif | ||
| 211 | createModuleCodeObjects(); | ||
| 212 | |||
| 213 | // puts( "in initpyanaconda" ); | ||
| 214 | |||
| 215 | // Create the module object first. There are no methods initially, all are | ||
| 216 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 217 | // set at this time, as it could not contain NUL characters this way, they | ||
| 218 | // are instead set in early module code. No "self" for modules, we have no | ||
| 219 | // use for it. | ||
| 220 | #if PYTHON_VERSION < 300 | ||
| 221 | module_pyanaconda = Py_InitModule4( | ||
| 222 | "pyanaconda", // Module Name | ||
| 223 | NULL, // No methods initially, all are added | ||
| 224 | // dynamically in actual module code only. | ||
| 225 | NULL, // No "__doc__" is initially set, as it could | ||
| 226 | // not contain NUL this way, added early in | ||
| 227 | // actual code. | ||
| 228 | NULL, // No self for modules, we don't use it. | ||
| 229 | PYTHON_API_VERSION | ||
| 230 | ); | ||
| 231 | #else | ||
| 232 | |||
| 233 | module_pyanaconda = PyModule_Create( &mdef_pyanaconda ); | ||
| 234 | #endif | ||
| 235 | |||
| 236 | moduledict_pyanaconda = MODULE_DICT( module_pyanaconda ); | ||
| 237 | |||
| 238 | // Set __compiled__ to what it we know. | ||
| 239 | UPDATE_STRING_DICT1( | ||
| 240 | moduledict_pyanaconda, | ||
| 241 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 242 | Nuitka_dunder_compiled_value | ||
| 243 | ); | ||
| 244 | |||
| 245 | // Update "__package__" value to what it ought to be. | ||
| 246 | { | ||
| 247 | #if 1 | ||
| 248 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 249 | |||
| 250 | UPDATE_STRING_DICT1( | ||
| 251 | moduledict_pyanaconda, | ||
| 252 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 253 | module_name | ||
| 254 | ); | ||
| 255 | #else | ||
| 256 | |||
| 257 | #if PYTHON_VERSION < 300 | ||
| 258 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 259 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 260 | |||
| 261 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 262 | |||
| 263 | if ( last_dot != NULL ) | ||
| 264 | { | ||
| 265 | UPDATE_STRING_DICT1( | ||
| 266 | moduledict_pyanaconda, | ||
| 267 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 268 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 269 | ); | ||
| 270 | } | ||
| 271 | #else | ||
| 272 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 273 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 274 | |||
| 275 | if ( dot_index != -1 ) | ||
| 276 | { | ||
| 277 | UPDATE_STRING_DICT1( | ||
| 278 | moduledict_pyanaconda, | ||
| 279 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 280 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 281 | ); | ||
| 282 | } | ||
| 283 | #endif | ||
| 284 | #endif | ||
| 285 | } | ||
| 286 | |||
| 287 | CHECK_OBJECT( module_pyanaconda ); | ||
| 288 | |||
| 289 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 290 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 291 | #if PYTHON_VERSION >= 300 | ||
| 292 | { | ||
| 293 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_plain_pyanaconda, module_pyanaconda ); | ||
| 294 | |||
| 295 | assert( r != -1 ); | ||
| 296 | } | ||
| 297 | #endif | ||
| 298 | |||
| 299 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 300 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 301 | // before the frame object is allocated, or else it may fail. | ||
| 302 | |||
| 303 | if ( GET_STRING_DICT_VALUE( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 304 | { | ||
| 305 | PyObject *value = (PyObject *)builtin_module; | ||
| 306 | |||
| 307 | // Check if main module, not a dict then but the module itself. | ||
| 308 | #if !defined(_NUITKA_EXE) || !0 | ||
| 309 | value = PyModule_GetDict( value ); | ||
| 310 | #endif | ||
| 311 | |||
| 312 | UPDATE_STRING_DICT0( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 313 | } | ||
| 314 | |||
| 315 | #if PYTHON_VERSION >= 300 | ||
| 316 | UPDATE_STRING_DICT0( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 317 | #endif | ||
| 318 | |||
| 319 | #if PYTHON_VERSION >= 340 | ||
| 320 | // Set the "__spec__" value | ||
| 321 | |||
| 322 | #if 0 | ||
| 323 | // Main modules just get "None" as spec. | ||
| 324 | UPDATE_STRING_DICT0( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 325 | #else | ||
| 326 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 327 | { | ||
| 328 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 329 | CHECK_OBJECT( bootstrap_module ); | ||
| 330 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 331 | Py_DECREF( bootstrap_module ); | ||
| 332 | |||
| 333 | PyObject *args[] = { | ||
| 334 | GET_STRING_DICT_VALUE( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 335 | (PyObject *)&Nuitka_Loader_Type | ||
| 336 | }; | ||
| 337 | |||
| 338 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 339 | module_spec_class, | ||
| 340 | args | ||
| 341 | ); | ||
| 342 | Py_DECREF( module_spec_class ); | ||
| 343 | |||
| 344 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 345 | CHECK_OBJECT( spec_value ); | ||
| 346 | |||
| 347 | // For packages set the submodule search locations as well, even if to empty | ||
| 348 | // list, so investigating code will consider it a package. | ||
| 349 | #if 1 | ||
| 350 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 351 | #endif | ||
| 352 | |||
| 353 | // Mark the execution in the "__spec__" value. | ||
| 354 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 355 | |||
| 356 | UPDATE_STRING_DICT1( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 357 | } | ||
| 358 | #endif | ||
| 359 | #endif | ||
| 360 | |||
| 361 | // Temp variables if any | ||
| 362 | struct Nuitka_FrameObject *frame_4cf88d18e1b9d52f5b8ad46477dac15a; | ||
| 363 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 364 | PyObject *exception_type = NULL; | ||
| 365 | PyObject *exception_value = NULL; | ||
| 366 | PyTracebackObject *exception_tb = NULL; | ||
| 367 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 368 | bool tmp_result; | ||
| 369 | |||
| 370 | // Module code. | ||
| 371 | { | ||
| 372 | PyObject *tmp_assign_source_1; | ||
| 373 | tmp_assign_source_1 = Py_None; | ||
| 374 | UPDATE_STRING_DICT0( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 375 | } | ||
| 376 | { | ||
| 377 | PyObject *tmp_assign_source_2; | ||
| 378 | tmp_assign_source_2 = module_filename_obj; | ||
| 379 | UPDATE_STRING_DICT0( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 380 | } | ||
| 381 | // Frame without reuse. | ||
| 382 | frame_4cf88d18e1b9d52f5b8ad46477dac15a = MAKE_MODULE_FRAME( codeobj_4cf88d18e1b9d52f5b8ad46477dac15a, module_pyanaconda ); | ||
| 383 | |||
| 384 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 385 | // owning it. | ||
| 386 | pushFrameStack( frame_4cf88d18e1b9d52f5b8ad46477dac15a ); | ||
| 387 | assert( Py_REFCNT( frame_4cf88d18e1b9d52f5b8ad46477dac15a ) == 2 ); | ||
| 388 | |||
| 389 | // Framed code: | ||
| 390 | { | ||
| 391 | PyObject *tmp_assign_source_3; | ||
| 392 | PyObject *tmp_list_element_1; | ||
| 393 | PyObject *tmp_called_name_1; | ||
| 394 | PyObject *tmp_source_name_1; | ||
| 395 | PyObject *tmp_args_element_name_1; | ||
| 396 | PyObject *tmp_called_instance_1; | ||
| 397 | frame_4cf88d18e1b9d52f5b8ad46477dac15a->m_frame.f_lineno = 1; | ||
| 398 | { | ||
| 399 | PyObject *module = PyImport_ImportModule("os"); | ||
| 400 | if (likely( module != NULL )) | ||
| 401 | { | ||
| 402 | tmp_source_name_1 = PyObject_GetAttr( module, const_str_plain_path ); | ||
| 403 | } | ||
| 404 | else | ||
| 405 | { | ||
| 406 | tmp_source_name_1 = NULL; | ||
| 407 | } | ||
| 408 | } | ||
| 409 | |||
| 410 | if ( tmp_source_name_1 == NULL ) | ||
| 411 | { | ||
| 412 | assert( ERROR_OCCURRED() ); | ||
| 413 | |||
| 414 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 415 | |||
| 416 | |||
| 417 | exception_lineno = 1; | ||
| 418 | |||
| 419 | goto frame_exception_exit_1; | ||
| 420 | } | ||
| 421 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_dirname ); | ||
| 422 | if ( tmp_called_name_1 == NULL ) | ||
| 423 | { | ||
| 424 | assert( ERROR_OCCURRED() ); | ||
| 425 | |||
| 426 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 427 | |||
| 428 | |||
| 429 | exception_lineno = 1; | ||
| 430 | |||
| 431 | goto frame_exception_exit_1; | ||
| 432 | } | ||
| 433 | tmp_args_element_name_1 = module_filename_obj; | ||
| 434 | frame_4cf88d18e1b9d52f5b8ad46477dac15a->m_frame.f_lineno = 1; | ||
| 435 | { | ||
| 436 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 437 | tmp_list_element_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, call_args ); | ||
| 438 | } | ||
| 439 | |||
| 440 | Py_DECREF( tmp_called_name_1 ); | ||
| 441 | if ( tmp_list_element_1 == NULL ) | ||
| 442 | { | ||
| 443 | assert( ERROR_OCCURRED() ); | ||
| 444 | |||
| 445 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 446 | |||
| 447 | |||
| 448 | exception_lineno = 1; | ||
| 449 | |||
| 450 | goto frame_exception_exit_1; | ||
| 451 | } | ||
| 452 | tmp_assign_source_3 = PyList_New( 2 ); | ||
| 453 | PyList_SET_ITEM( tmp_assign_source_3, 0, tmp_list_element_1 ); | ||
| 454 | frame_4cf88d18e1b9d52f5b8ad46477dac15a->m_frame.f_lineno = 1; | ||
| 455 | { | ||
| 456 | PyObject *module = PyImport_ImportModule("os"); | ||
| 457 | if (likely( module != NULL )) | ||
| 458 | { | ||
| 459 | tmp_called_instance_1 = PyObject_GetAttr( module, const_str_plain_environ ); | ||
| 460 | } | ||
| 461 | else | ||
| 462 | { | ||
| 463 | tmp_called_instance_1 = NULL; | ||
| 464 | } | ||
| 465 | } | ||
| 466 | |||
| 467 | if ( tmp_called_instance_1 == NULL ) | ||
| 468 | { | ||
| 469 | assert( ERROR_OCCURRED() ); | ||
| 470 | |||
| 471 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 472 | Py_DECREF( tmp_assign_source_3 ); | ||
| 473 | |||
| 474 | exception_lineno = 1; | ||
| 475 | |||
| 476 | goto frame_exception_exit_1; | ||
| 477 | } | ||
| 478 | frame_4cf88d18e1b9d52f5b8ad46477dac15a->m_frame.f_lineno = 1; | ||
| 479 | tmp_list_element_1 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_1, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_259a9893e45702189ab930fb0b217a08_tuple, 0 ) ); | ||
| 480 | |||
| 481 | if ( tmp_list_element_1 == NULL ) | ||
| 482 | { | ||
| 483 | assert( ERROR_OCCURRED() ); | ||
| 484 | |||
| 485 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 486 | Py_DECREF( tmp_assign_source_3 ); | ||
| 487 | |||
| 488 | exception_lineno = 1; | ||
| 489 | |||
| 490 | goto frame_exception_exit_1; | ||
| 491 | } | ||
| 492 | PyList_SET_ITEM( tmp_assign_source_3, 1, tmp_list_element_1 ); | ||
| 493 | UPDATE_STRING_DICT1( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); | ||
| 494 | } | ||
| 495 | { | ||
| 496 | PyObject *tmp_assattr_name_1; | ||
| 497 | PyObject *tmp_assattr_target_1; | ||
| 498 | PyObject *tmp_mvar_value_1; | ||
| 499 | tmp_assattr_name_1 = module_filename_obj; | ||
| 500 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 501 | |||
| 502 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 503 | { | ||
| 504 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 505 | } | ||
| 506 | |||
| 507 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 508 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 509 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 510 | if ( tmp_result == false ) | ||
| 511 | { | ||
| 512 | assert( ERROR_OCCURRED() ); | ||
| 513 | |||
| 514 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 515 | |||
| 516 | |||
| 517 | exception_lineno = 1; | ||
| 518 | |||
| 519 | goto frame_exception_exit_1; | ||
| 520 | } | ||
| 521 | } | ||
| 522 | { | ||
| 523 | PyObject *tmp_assattr_name_2; | ||
| 524 | PyObject *tmp_assattr_target_2; | ||
| 525 | PyObject *tmp_mvar_value_2; | ||
| 526 | tmp_assattr_name_2 = Py_True; | ||
| 527 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 528 | |||
| 529 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 530 | { | ||
| 531 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 532 | } | ||
| 533 | |||
| 534 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 535 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 536 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 537 | if ( tmp_result == false ) | ||
| 538 | { | ||
| 539 | assert( ERROR_OCCURRED() ); | ||
| 540 | |||
| 541 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 542 | |||
| 543 | |||
| 544 | exception_lineno = 1; | ||
| 545 | |||
| 546 | goto frame_exception_exit_1; | ||
| 547 | } | ||
| 548 | } | ||
| 549 | |||
| 550 | // Restore frame exception if necessary. | ||
| 551 | #if 0 | ||
| 552 | RESTORE_FRAME_EXCEPTION( frame_4cf88d18e1b9d52f5b8ad46477dac15a ); | ||
| 553 | #endif | ||
| 554 | popFrameStack(); | ||
| 555 | |||
| 556 | assertFrameObject( frame_4cf88d18e1b9d52f5b8ad46477dac15a ); | ||
| 557 | |||
| 558 | goto frame_no_exception_1; | ||
| 559 | |||
| 560 | frame_exception_exit_1:; | ||
| 561 | #if 0 | ||
| 562 | RESTORE_FRAME_EXCEPTION( frame_4cf88d18e1b9d52f5b8ad46477dac15a ); | ||
| 563 | #endif | ||
| 564 | |||
| 565 | if ( exception_tb == NULL ) | ||
| 566 | { | ||
| 567 | exception_tb = MAKE_TRACEBACK( frame_4cf88d18e1b9d52f5b8ad46477dac15a, exception_lineno ); | ||
| 568 | } | ||
| 569 | else if ( exception_tb->tb_frame != &frame_4cf88d18e1b9d52f5b8ad46477dac15a->m_frame ) | ||
| 570 | { | ||
| 571 | exception_tb = ADD_TRACEBACK( exception_tb, frame_4cf88d18e1b9d52f5b8ad46477dac15a, exception_lineno ); | ||
| 572 | } | ||
| 573 | |||
| 574 | // Put the previous frame back on top. | ||
| 575 | popFrameStack(); | ||
| 576 | |||
| 577 | // Return the error. | ||
| 578 | goto module_exception_exit; | ||
| 579 | |||
| 580 | frame_no_exception_1:; | ||
| 581 | { | ||
| 582 | PyObject *tmp_assign_source_4; | ||
| 583 | tmp_assign_source_4 = Py_None; | ||
| 584 | UPDATE_STRING_DICT0( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_4 ); | ||
| 585 | } | ||
| 586 | |||
| 587 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 588 | #if 1 && 0 | ||
| 589 | { | ||
| 590 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_pyanaconda, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 591 | |||
| 592 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 593 | { | ||
| 594 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 595 | |||
| 596 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 597 | CHECK_OBJECT( path_importer_cache ); | ||
| 598 | |||
| 599 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 600 | assert( res == 0 ); | ||
| 601 | } | ||
| 602 | } | ||
| 603 | #endif | ||
| 604 | #endif | ||
| 605 | |||
| 606 | return MOD_RETURN_VALUE( module_pyanaconda ); | ||
| 607 | module_exception_exit: | ||
| 608 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 609 | return MOD_RETURN_VALUE( NULL ); | ||
| 610 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.pyanaconda.core.c deleted (index 28b9b76..0000000) | |||
| 1 | /* Generated code for Python module 'pyanaconda.core' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_pyanaconda$core" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_pyanaconda$core; | ||
| 31 | PyDictObject *moduledict_pyanaconda$core; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain_environ; | ||
| 35 | extern PyObject *const_str_plain___spec__; | ||
| 36 | extern PyObject *const_str_plain___file__; | ||
| 37 | static PyObject *const_str_plain_NUITKA_PACKAGE_pyanaconda_core; | ||
| 38 | extern PyObject *const_str_plain_path; | ||
| 39 | static PyObject *const_str_digest_82ac62b426047df629bd2ea30b557ac2; | ||
| 40 | static PyObject *const_tuple_ecacb0dfe5951b973dbf286dc8a36900_tuple; | ||
| 41 | static PyObject *const_str_digest_6f34036093031c40b9e178f17c8fd909; | ||
| 42 | extern PyObject *const_str_plain_origin; | ||
| 43 | extern PyObject *const_str_plain_NUITKA_PACKAGE_pyanaconda; | ||
| 44 | extern PyObject *const_str_digest_5bfaf90dbd407b4fc29090c8f6415242; | ||
| 45 | static PyObject *const_str_plain_core; | ||
| 46 | extern PyObject *const_str_plain___path__; | ||
| 47 | extern PyObject *const_tuple_empty; | ||
| 48 | extern PyObject *const_str_plain_get; | ||
| 49 | extern PyObject *const_str_plain_has_location; | ||
| 50 | extern PyObject *const_tuple_259a9893e45702189ab930fb0b217a08_tuple; | ||
| 51 | extern PyObject *const_str_plain_join; | ||
| 52 | static PyObject *const_str_digest_2e749e7b32da5cdd738704cf9cdc1397; | ||
| 53 | extern PyObject *const_str_plain_dirname; | ||
| 54 | extern PyObject *const_str_plain___doc__; | ||
| 55 | extern PyObject *const_str_plain___cached__; | ||
| 56 | static PyObject *module_filename_obj; | ||
| 57 | |||
| 58 | /* Indicator if this modules private constants were created yet. */ | ||
| 59 | static bool constants_created = false; | ||
| 60 | |||
| 61 | /* Function to create module private constants. */ | ||
| 62 | static void createModuleConstants( void ) | ||
| 63 | { | ||
| 64 | const_str_plain_NUITKA_PACKAGE_pyanaconda_core = UNSTREAM_STRING_ASCII( &constant_bin[ 60279 ], 30, 1 ); | ||
| 65 | const_str_digest_82ac62b426047df629bd2ea30b557ac2 = UNSTREAM_STRING_ASCII( &constant_bin[ 60309 ], 15, 0 ); | ||
| 66 | const_tuple_ecacb0dfe5951b973dbf286dc8a36900_tuple = PyTuple_New( 2 ); | ||
| 67 | PyTuple_SET_ITEM( const_tuple_ecacb0dfe5951b973dbf286dc8a36900_tuple, 0, const_str_plain_NUITKA_PACKAGE_pyanaconda_core ); Py_INCREF( const_str_plain_NUITKA_PACKAGE_pyanaconda_core ); | ||
| 68 | PyTuple_SET_ITEM( const_tuple_ecacb0dfe5951b973dbf286dc8a36900_tuple, 1, const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); Py_INCREF( const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); | ||
| 69 | const_str_digest_6f34036093031c40b9e178f17c8fd909 = UNSTREAM_STRING_ASCII( &constant_bin[ 60324 ], 27, 0 ); | ||
| 70 | const_str_plain_core = UNSTREAM_STRING_ASCII( &constant_bin[ 56153 ], 4, 1 ); | ||
| 71 | const_str_digest_2e749e7b32da5cdd738704cf9cdc1397 = UNSTREAM_STRING_ASCII( &constant_bin[ 60351 ], 24, 0 ); | ||
| 72 | |||
| 73 | constants_created = true; | ||
| 74 | } | ||
| 75 | |||
| 76 | /* Function to verify module private constants for non-corruption. */ | ||
| 77 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 78 | void checkModuleConstants_pyanaconda$core( void ) | ||
| 79 | { | ||
| 80 | // The module may not have been used at all, then ignore this. | ||
| 81 | if (constants_created == false) return; | ||
| 82 | |||
| 83 | |||
| 84 | } | ||
| 85 | #endif | ||
| 86 | |||
| 87 | // The module code objects. | ||
| 88 | static PyCodeObject *codeobj_bf2cf6b736c8964d756cf4703c4b507e; | ||
| 89 | |||
| 90 | static void createModuleCodeObjects(void) | ||
| 91 | { | ||
| 92 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_6f34036093031c40b9e178f17c8fd909 ); | ||
| 93 | codeobj_bf2cf6b736c8964d756cf4703c4b507e = MAKE_CODEOBJ( module_filename_obj, const_str_digest_2e749e7b32da5cdd738704cf9cdc1397, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 94 | } | ||
| 95 | |||
| 96 | // The module function declarations. | ||
| 97 | |||
| 98 | |||
| 99 | // The module function definitions. | ||
| 100 | |||
| 101 | |||
| 102 | |||
| 103 | #if PYTHON_VERSION >= 300 | ||
| 104 | static struct PyModuleDef mdef_pyanaconda$core = | ||
| 105 | { | ||
| 106 | PyModuleDef_HEAD_INIT, | ||
| 107 | "pyanaconda.core", | ||
| 108 | NULL, /* m_doc */ | ||
| 109 | -1, /* m_size */ | ||
| 110 | NULL, /* m_methods */ | ||
| 111 | NULL, /* m_reload */ | ||
| 112 | NULL, /* m_traverse */ | ||
| 113 | NULL, /* m_clear */ | ||
| 114 | NULL, /* m_free */ | ||
| 115 | }; | ||
| 116 | #endif | ||
| 117 | |||
| 118 | extern PyObject *const_str_plain___compiled__; | ||
| 119 | |||
| 120 | extern PyObject *const_str_plain___package__; | ||
| 121 | |||
| 122 | #if PYTHON_VERSION >= 300 | ||
| 123 | extern PyObject *const_str_dot; | ||
| 124 | extern PyObject *const_str_plain___loader__; | ||
| 125 | #endif | ||
| 126 | |||
| 127 | #if PYTHON_VERSION >= 340 | ||
| 128 | extern PyObject *const_str_plain___spec__; | ||
| 129 | extern PyObject *const_str_plain__initializing; | ||
| 130 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 131 | #endif | ||
| 132 | |||
| 133 | extern void _initCompiledCellType(); | ||
| 134 | extern void _initCompiledGeneratorType(); | ||
| 135 | extern void _initCompiledFunctionType(); | ||
| 136 | extern void _initCompiledMethodType(); | ||
| 137 | extern void _initCompiledFrameType(); | ||
| 138 | #if PYTHON_VERSION >= 350 | ||
| 139 | extern void _initCompiledCoroutineTypes(); | ||
| 140 | #endif | ||
| 141 | #if PYTHON_VERSION >= 360 | ||
| 142 | extern void _initCompiledAsyncgenTypes(); | ||
| 143 | #endif | ||
| 144 | |||
| 145 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 146 | |||
| 147 | // The exported interface to CPython. On import of the module, this function | ||
| 148 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 149 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 150 | |||
| 151 | MOD_INIT_DECL( pyanaconda$core ) | ||
| 152 | { | ||
| 153 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 154 | static bool _init_done = false; | ||
| 155 | |||
| 156 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 157 | if ( _init_done ) | ||
| 158 | { | ||
| 159 | return MOD_RETURN_VALUE( module_pyanaconda$core ); | ||
| 160 | } | ||
| 161 | else | ||
| 162 | { | ||
| 163 | _init_done = true; | ||
| 164 | } | ||
| 165 | #endif | ||
| 166 | |||
| 167 | #ifdef _NUITKA_MODULE | ||
| 168 | // In case of a stand alone extension module, need to call initialization | ||
| 169 | // the init here because that's the first and only time we are going to get | ||
| 170 | // called here. | ||
| 171 | |||
| 172 | // Initialize the constant values used. | ||
| 173 | _initBuiltinModule(); | ||
| 174 | createGlobalConstants(); | ||
| 175 | |||
| 176 | /* Initialize the compiled types of Nuitka. */ | ||
| 177 | _initCompiledCellType(); | ||
| 178 | _initCompiledGeneratorType(); | ||
| 179 | _initCompiledFunctionType(); | ||
| 180 | _initCompiledMethodType(); | ||
| 181 | _initCompiledFrameType(); | ||
| 182 | #if PYTHON_VERSION >= 350 | ||
| 183 | _initCompiledCoroutineTypes(); | ||
| 184 | #endif | ||
| 185 | #if PYTHON_VERSION >= 360 | ||
| 186 | _initCompiledAsyncgenTypes(); | ||
| 187 | #endif | ||
| 188 | |||
| 189 | #if PYTHON_VERSION < 300 | ||
| 190 | _initSlotCompare(); | ||
| 191 | #endif | ||
| 192 | #if PYTHON_VERSION >= 270 | ||
| 193 | _initSlotIternext(); | ||
| 194 | #endif | ||
| 195 | |||
| 196 | patchBuiltinModule(); | ||
| 197 | patchTypeComparison(); | ||
| 198 | |||
| 199 | // Enable meta path based loader if not already done. | ||
| 200 | #ifdef _NUITKA_TRACE | ||
| 201 | puts("pyanaconda.core: Calling setupMetaPathBasedLoader()."); | ||
| 202 | #endif | ||
| 203 | setupMetaPathBasedLoader(); | ||
| 204 | |||
| 205 | #if PYTHON_VERSION >= 300 | ||
| 206 | patchInspectModule(); | ||
| 207 | #endif | ||
| 208 | |||
| 209 | #endif | ||
| 210 | |||
| 211 | /* The constants only used by this module are created now. */ | ||
| 212 | #ifdef _NUITKA_TRACE | ||
| 213 | puts("pyanaconda.core: Calling createModuleConstants()."); | ||
| 214 | #endif | ||
| 215 | createModuleConstants(); | ||
| 216 | |||
| 217 | /* The code objects used by this module are created now. */ | ||
| 218 | #ifdef _NUITKA_TRACE | ||
| 219 | puts("pyanaconda.core: Calling createModuleCodeObjects()."); | ||
| 220 | #endif | ||
| 221 | createModuleCodeObjects(); | ||
| 222 | |||
| 223 | // puts( "in initpyanaconda$core" ); | ||
| 224 | |||
| 225 | // Create the module object first. There are no methods initially, all are | ||
| 226 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 227 | // set at this time, as it could not contain NUL characters this way, they | ||
| 228 | // are instead set in early module code. No "self" for modules, we have no | ||
| 229 | // use for it. | ||
| 230 | #if PYTHON_VERSION < 300 | ||
| 231 | module_pyanaconda$core = Py_InitModule4( | ||
| 232 | "pyanaconda.core", // Module Name | ||
| 233 | NULL, // No methods initially, all are added | ||
| 234 | // dynamically in actual module code only. | ||
| 235 | NULL, // No "__doc__" is initially set, as it could | ||
| 236 | // not contain NUL this way, added early in | ||
| 237 | // actual code. | ||
| 238 | NULL, // No self for modules, we don't use it. | ||
| 239 | PYTHON_API_VERSION | ||
| 240 | ); | ||
| 241 | #else | ||
| 242 | |||
| 243 | module_pyanaconda$core = PyModule_Create( &mdef_pyanaconda$core ); | ||
| 244 | #endif | ||
| 245 | |||
| 246 | moduledict_pyanaconda$core = MODULE_DICT( module_pyanaconda$core ); | ||
| 247 | |||
| 248 | // Set __compiled__ to what it we know. | ||
| 249 | UPDATE_STRING_DICT1( | ||
| 250 | moduledict_pyanaconda$core, | ||
| 251 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 252 | Nuitka_dunder_compiled_value | ||
| 253 | ); | ||
| 254 | |||
| 255 | // Update "__package__" value to what it ought to be. | ||
| 256 | { | ||
| 257 | #if 1 | ||
| 258 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 259 | |||
| 260 | UPDATE_STRING_DICT1( | ||
| 261 | moduledict_pyanaconda$core, | ||
| 262 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 263 | module_name | ||
| 264 | ); | ||
| 265 | #else | ||
| 266 | |||
| 267 | #if PYTHON_VERSION < 300 | ||
| 268 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 269 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 270 | |||
| 271 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 272 | |||
| 273 | if ( last_dot != NULL ) | ||
| 274 | { | ||
| 275 | UPDATE_STRING_DICT1( | ||
| 276 | moduledict_pyanaconda$core, | ||
| 277 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 278 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 279 | ); | ||
| 280 | } | ||
| 281 | #else | ||
| 282 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 283 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 284 | |||
| 285 | if ( dot_index != -1 ) | ||
| 286 | { | ||
| 287 | UPDATE_STRING_DICT1( | ||
| 288 | moduledict_pyanaconda$core, | ||
| 289 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 290 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 291 | ); | ||
| 292 | } | ||
| 293 | #endif | ||
| 294 | #endif | ||
| 295 | } | ||
| 296 | |||
| 297 | CHECK_OBJECT( module_pyanaconda$core ); | ||
| 298 | |||
| 299 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 300 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 301 | #if PYTHON_VERSION >= 300 | ||
| 302 | { | ||
| 303 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_82ac62b426047df629bd2ea30b557ac2, module_pyanaconda$core ); | ||
| 304 | |||
| 305 | assert( r != -1 ); | ||
| 306 | } | ||
| 307 | #endif | ||
| 308 | |||
| 309 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 310 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 311 | // before the frame object is allocated, or else it may fail. | ||
| 312 | |||
| 313 | if ( GET_STRING_DICT_VALUE( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 314 | { | ||
| 315 | PyObject *value = (PyObject *)builtin_module; | ||
| 316 | |||
| 317 | // Check if main module, not a dict then but the module itself. | ||
| 318 | #if !defined(_NUITKA_EXE) || !0 | ||
| 319 | value = PyModule_GetDict( value ); | ||
| 320 | #endif | ||
| 321 | |||
| 322 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 323 | } | ||
| 324 | |||
| 325 | #if PYTHON_VERSION >= 300 | ||
| 326 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 327 | #endif | ||
| 328 | |||
| 329 | #if PYTHON_VERSION >= 340 | ||
| 330 | // Set the "__spec__" value | ||
| 331 | |||
| 332 | #if 0 | ||
| 333 | // Main modules just get "None" as spec. | ||
| 334 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 335 | #else | ||
| 336 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 337 | { | ||
| 338 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 339 | CHECK_OBJECT( bootstrap_module ); | ||
| 340 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 341 | Py_DECREF( bootstrap_module ); | ||
| 342 | |||
| 343 | PyObject *args[] = { | ||
| 344 | GET_STRING_DICT_VALUE( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 345 | (PyObject *)&Nuitka_Loader_Type | ||
| 346 | }; | ||
| 347 | |||
| 348 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 349 | module_spec_class, | ||
| 350 | args | ||
| 351 | ); | ||
| 352 | Py_DECREF( module_spec_class ); | ||
| 353 | |||
| 354 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 355 | CHECK_OBJECT( spec_value ); | ||
| 356 | |||
| 357 | // For packages set the submodule search locations as well, even if to empty | ||
| 358 | // list, so investigating code will consider it a package. | ||
| 359 | #if 1 | ||
| 360 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 361 | #endif | ||
| 362 | |||
| 363 | // Mark the execution in the "__spec__" value. | ||
| 364 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 365 | |||
| 366 | UPDATE_STRING_DICT1( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 367 | } | ||
| 368 | #endif | ||
| 369 | #endif | ||
| 370 | |||
| 371 | // Temp variables if any | ||
| 372 | struct Nuitka_FrameObject *frame_bf2cf6b736c8964d756cf4703c4b507e; | ||
| 373 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 374 | PyObject *exception_type = NULL; | ||
| 375 | PyObject *exception_value = NULL; | ||
| 376 | PyTracebackObject *exception_tb = NULL; | ||
| 377 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 378 | bool tmp_result; | ||
| 379 | |||
| 380 | // Module code. | ||
| 381 | { | ||
| 382 | PyObject *tmp_assign_source_1; | ||
| 383 | tmp_assign_source_1 = Py_None; | ||
| 384 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 385 | } | ||
| 386 | { | ||
| 387 | PyObject *tmp_assign_source_2; | ||
| 388 | tmp_assign_source_2 = module_filename_obj; | ||
| 389 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 390 | } | ||
| 391 | // Frame without reuse. | ||
| 392 | frame_bf2cf6b736c8964d756cf4703c4b507e = MAKE_MODULE_FRAME( codeobj_bf2cf6b736c8964d756cf4703c4b507e, module_pyanaconda$core ); | ||
| 393 | |||
| 394 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 395 | // owning it. | ||
| 396 | pushFrameStack( frame_bf2cf6b736c8964d756cf4703c4b507e ); | ||
| 397 | assert( Py_REFCNT( frame_bf2cf6b736c8964d756cf4703c4b507e ) == 2 ); | ||
| 398 | |||
| 399 | // Framed code: | ||
| 400 | { | ||
| 401 | PyObject *tmp_assign_source_3; | ||
| 402 | PyObject *tmp_list_element_1; | ||
| 403 | PyObject *tmp_called_name_1; | ||
| 404 | PyObject *tmp_source_name_1; | ||
| 405 | PyObject *tmp_args_element_name_1; | ||
| 406 | PyObject *tmp_called_name_2; | ||
| 407 | PyObject *tmp_source_name_2; | ||
| 408 | PyObject *tmp_args_element_name_2; | ||
| 409 | PyObject *tmp_called_instance_1; | ||
| 410 | PyObject *tmp_args_element_name_3; | ||
| 411 | PyObject *tmp_called_instance_2; | ||
| 412 | frame_bf2cf6b736c8964d756cf4703c4b507e->m_frame.f_lineno = 1; | ||
| 413 | { | ||
| 414 | PyObject *module = PyImport_ImportModule("os"); | ||
| 415 | if (likely( module != NULL )) | ||
| 416 | { | ||
| 417 | tmp_source_name_1 = PyObject_GetAttr( module, const_str_plain_path ); | ||
| 418 | } | ||
| 419 | else | ||
| 420 | { | ||
| 421 | tmp_source_name_1 = NULL; | ||
| 422 | } | ||
| 423 | } | ||
| 424 | |||
| 425 | if ( tmp_source_name_1 == NULL ) | ||
| 426 | { | ||
| 427 | assert( ERROR_OCCURRED() ); | ||
| 428 | |||
| 429 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 430 | |||
| 431 | |||
| 432 | exception_lineno = 1; | ||
| 433 | |||
| 434 | goto frame_exception_exit_1; | ||
| 435 | } | ||
| 436 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_dirname ); | ||
| 437 | if ( tmp_called_name_1 == NULL ) | ||
| 438 | { | ||
| 439 | assert( ERROR_OCCURRED() ); | ||
| 440 | |||
| 441 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 442 | |||
| 443 | |||
| 444 | exception_lineno = 1; | ||
| 445 | |||
| 446 | goto frame_exception_exit_1; | ||
| 447 | } | ||
| 448 | tmp_args_element_name_1 = module_filename_obj; | ||
| 449 | frame_bf2cf6b736c8964d756cf4703c4b507e->m_frame.f_lineno = 1; | ||
| 450 | { | ||
| 451 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 452 | tmp_list_element_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, call_args ); | ||
| 453 | } | ||
| 454 | |||
| 455 | Py_DECREF( tmp_called_name_1 ); | ||
| 456 | if ( tmp_list_element_1 == NULL ) | ||
| 457 | { | ||
| 458 | assert( ERROR_OCCURRED() ); | ||
| 459 | |||
| 460 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 461 | |||
| 462 | |||
| 463 | exception_lineno = 1; | ||
| 464 | |||
| 465 | goto frame_exception_exit_1; | ||
| 466 | } | ||
| 467 | tmp_assign_source_3 = PyList_New( 3 ); | ||
| 468 | PyList_SET_ITEM( tmp_assign_source_3, 0, tmp_list_element_1 ); | ||
| 469 | frame_bf2cf6b736c8964d756cf4703c4b507e->m_frame.f_lineno = 1; | ||
| 470 | { | ||
| 471 | PyObject *module = PyImport_ImportModule("os"); | ||
| 472 | if (likely( module != NULL )) | ||
| 473 | { | ||
| 474 | tmp_source_name_2 = PyObject_GetAttr( module, const_str_plain_path ); | ||
| 475 | } | ||
| 476 | else | ||
| 477 | { | ||
| 478 | tmp_source_name_2 = NULL; | ||
| 479 | } | ||
| 480 | } | ||
| 481 | |||
| 482 | if ( tmp_source_name_2 == NULL ) | ||
| 483 | { | ||
| 484 | assert( ERROR_OCCURRED() ); | ||
| 485 | |||
| 486 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 487 | Py_DECREF( tmp_assign_source_3 ); | ||
| 488 | |||
| 489 | exception_lineno = 1; | ||
| 490 | |||
| 491 | goto frame_exception_exit_1; | ||
| 492 | } | ||
| 493 | tmp_called_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_join ); | ||
| 494 | if ( tmp_called_name_2 == NULL ) | ||
| 495 | { | ||
| 496 | assert( ERROR_OCCURRED() ); | ||
| 497 | |||
| 498 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 499 | Py_DECREF( tmp_assign_source_3 ); | ||
| 500 | |||
| 501 | exception_lineno = 1; | ||
| 502 | |||
| 503 | goto frame_exception_exit_1; | ||
| 504 | } | ||
| 505 | frame_bf2cf6b736c8964d756cf4703c4b507e->m_frame.f_lineno = 1; | ||
| 506 | { | ||
| 507 | PyObject *module = PyImport_ImportModule("os"); | ||
| 508 | if (likely( module != NULL )) | ||
| 509 | { | ||
| 510 | tmp_called_instance_1 = PyObject_GetAttr( module, const_str_plain_environ ); | ||
| 511 | } | ||
| 512 | else | ||
| 513 | { | ||
| 514 | tmp_called_instance_1 = NULL; | ||
| 515 | } | ||
| 516 | } | ||
| 517 | |||
| 518 | if ( tmp_called_instance_1 == NULL ) | ||
| 519 | { | ||
| 520 | assert( ERROR_OCCURRED() ); | ||
| 521 | |||
| 522 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 523 | Py_DECREF( tmp_assign_source_3 ); | ||
| 524 | Py_DECREF( tmp_called_name_2 ); | ||
| 525 | |||
| 526 | exception_lineno = 1; | ||
| 527 | |||
| 528 | goto frame_exception_exit_1; | ||
| 529 | } | ||
| 530 | frame_bf2cf6b736c8964d756cf4703c4b507e->m_frame.f_lineno = 1; | ||
| 531 | tmp_args_element_name_2 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_1, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_259a9893e45702189ab930fb0b217a08_tuple, 0 ) ); | ||
| 532 | |||
| 533 | if ( tmp_args_element_name_2 == NULL ) | ||
| 534 | { | ||
| 535 | assert( ERROR_OCCURRED() ); | ||
| 536 | |||
| 537 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 538 | Py_DECREF( tmp_assign_source_3 ); | ||
| 539 | Py_DECREF( tmp_called_name_2 ); | ||
| 540 | |||
| 541 | exception_lineno = 1; | ||
| 542 | |||
| 543 | goto frame_exception_exit_1; | ||
| 544 | } | ||
| 545 | tmp_args_element_name_3 = const_str_plain_core; | ||
| 546 | frame_bf2cf6b736c8964d756cf4703c4b507e->m_frame.f_lineno = 1; | ||
| 547 | { | ||
| 548 | PyObject *call_args[] = { tmp_args_element_name_2, tmp_args_element_name_3 }; | ||
| 549 | tmp_list_element_1 = CALL_FUNCTION_WITH_ARGS2( tmp_called_name_2, call_args ); | ||
| 550 | } | ||
| 551 | |||
| 552 | Py_DECREF( tmp_called_name_2 ); | ||
| 553 | Py_DECREF( tmp_args_element_name_2 ); | ||
| 554 | if ( tmp_list_element_1 == NULL ) | ||
| 555 | { | ||
| 556 | assert( ERROR_OCCURRED() ); | ||
| 557 | |||
| 558 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 559 | Py_DECREF( tmp_assign_source_3 ); | ||
| 560 | |||
| 561 | exception_lineno = 1; | ||
| 562 | |||
| 563 | goto frame_exception_exit_1; | ||
| 564 | } | ||
| 565 | PyList_SET_ITEM( tmp_assign_source_3, 1, tmp_list_element_1 ); | ||
| 566 | frame_bf2cf6b736c8964d756cf4703c4b507e->m_frame.f_lineno = 1; | ||
| 567 | { | ||
| 568 | PyObject *module = PyImport_ImportModule("os"); | ||
| 569 | if (likely( module != NULL )) | ||
| 570 | { | ||
| 571 | tmp_called_instance_2 = PyObject_GetAttr( module, const_str_plain_environ ); | ||
| 572 | } | ||
| 573 | else | ||
| 574 | { | ||
| 575 | tmp_called_instance_2 = NULL; | ||
| 576 | } | ||
| 577 | } | ||
| 578 | |||
| 579 | if ( tmp_called_instance_2 == NULL ) | ||
| 580 | { | ||
| 581 | assert( ERROR_OCCURRED() ); | ||
| 582 | |||
| 583 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 584 | Py_DECREF( tmp_assign_source_3 ); | ||
| 585 | |||
| 586 | exception_lineno = 1; | ||
| 587 | |||
| 588 | goto frame_exception_exit_1; | ||
| 589 | } | ||
| 590 | frame_bf2cf6b736c8964d756cf4703c4b507e->m_frame.f_lineno = 1; | ||
| 591 | tmp_list_element_1 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_2, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_ecacb0dfe5951b973dbf286dc8a36900_tuple, 0 ) ); | ||
| 592 | |||
| 593 | if ( tmp_list_element_1 == NULL ) | ||
| 594 | { | ||
| 595 | assert( ERROR_OCCURRED() ); | ||
| 596 | |||
| 597 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 598 | Py_DECREF( tmp_assign_source_3 ); | ||
| 599 | |||
| 600 | exception_lineno = 1; | ||
| 601 | |||
| 602 | goto frame_exception_exit_1; | ||
| 603 | } | ||
| 604 | PyList_SET_ITEM( tmp_assign_source_3, 2, tmp_list_element_1 ); | ||
| 605 | UPDATE_STRING_DICT1( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); | ||
| 606 | } | ||
| 607 | { | ||
| 608 | PyObject *tmp_assattr_name_1; | ||
| 609 | PyObject *tmp_assattr_target_1; | ||
| 610 | PyObject *tmp_mvar_value_1; | ||
| 611 | tmp_assattr_name_1 = module_filename_obj; | ||
| 612 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 613 | |||
| 614 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 615 | { | ||
| 616 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 617 | } | ||
| 618 | |||
| 619 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 620 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 621 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 622 | if ( tmp_result == false ) | ||
| 623 | { | ||
| 624 | assert( ERROR_OCCURRED() ); | ||
| 625 | |||
| 626 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 627 | |||
| 628 | |||
| 629 | exception_lineno = 1; | ||
| 630 | |||
| 631 | goto frame_exception_exit_1; | ||
| 632 | } | ||
| 633 | } | ||
| 634 | { | ||
| 635 | PyObject *tmp_assattr_name_2; | ||
| 636 | PyObject *tmp_assattr_target_2; | ||
| 637 | PyObject *tmp_mvar_value_2; | ||
| 638 | tmp_assattr_name_2 = Py_True; | ||
| 639 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 640 | |||
| 641 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 642 | { | ||
| 643 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 644 | } | ||
| 645 | |||
| 646 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 647 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 648 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 649 | if ( tmp_result == false ) | ||
| 650 | { | ||
| 651 | assert( ERROR_OCCURRED() ); | ||
| 652 | |||
| 653 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 654 | |||
| 655 | |||
| 656 | exception_lineno = 1; | ||
| 657 | |||
| 658 | goto frame_exception_exit_1; | ||
| 659 | } | ||
| 660 | } | ||
| 661 | |||
| 662 | // Restore frame exception if necessary. | ||
| 663 | #if 0 | ||
| 664 | RESTORE_FRAME_EXCEPTION( frame_bf2cf6b736c8964d756cf4703c4b507e ); | ||
| 665 | #endif | ||
| 666 | popFrameStack(); | ||
| 667 | |||
| 668 | assertFrameObject( frame_bf2cf6b736c8964d756cf4703c4b507e ); | ||
| 669 | |||
| 670 | goto frame_no_exception_1; | ||
| 671 | |||
| 672 | frame_exception_exit_1:; | ||
| 673 | #if 0 | ||
| 674 | RESTORE_FRAME_EXCEPTION( frame_bf2cf6b736c8964d756cf4703c4b507e ); | ||
| 675 | #endif | ||
| 676 | |||
| 677 | if ( exception_tb == NULL ) | ||
| 678 | { | ||
| 679 | exception_tb = MAKE_TRACEBACK( frame_bf2cf6b736c8964d756cf4703c4b507e, exception_lineno ); | ||
| 680 | } | ||
| 681 | else if ( exception_tb->tb_frame != &frame_bf2cf6b736c8964d756cf4703c4b507e->m_frame ) | ||
| 682 | { | ||
| 683 | exception_tb = ADD_TRACEBACK( exception_tb, frame_bf2cf6b736c8964d756cf4703c4b507e, exception_lineno ); | ||
| 684 | } | ||
| 685 | |||
| 686 | // Put the previous frame back on top. | ||
| 687 | popFrameStack(); | ||
| 688 | |||
| 689 | // Return the error. | ||
| 690 | goto module_exception_exit; | ||
| 691 | |||
| 692 | frame_no_exception_1:; | ||
| 693 | { | ||
| 694 | PyObject *tmp_assign_source_4; | ||
| 695 | tmp_assign_source_4 = Py_None; | ||
| 696 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_4 ); | ||
| 697 | } | ||
| 698 | |||
| 699 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 700 | #if 1 && 0 | ||
| 701 | { | ||
| 702 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 703 | |||
| 704 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 705 | { | ||
| 706 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 707 | |||
| 708 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 709 | CHECK_OBJECT( path_importer_cache ); | ||
| 710 | |||
| 711 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 712 | assert( res == 0 ); | ||
| 713 | } | ||
| 714 | } | ||
| 715 | #endif | ||
| 716 | #endif | ||
| 717 | |||
| 718 | return MOD_RETURN_VALUE( module_pyanaconda$core ); | ||
| 719 | module_exception_exit: | ||
| 720 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 721 | return MOD_RETURN_VALUE( NULL ); | ||
| 722 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.pyanaconda.core.i18n.c deleted (index 1bbc6e2..0000000) | |||
| 1 | /* Generated code for Python module 'pyanaconda.core.i18n' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_pyanaconda$core$i18n" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_pyanaconda$core$i18n; | ||
| 31 | PyDictObject *moduledict_pyanaconda$core$i18n; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | static PyObject *const_str_digest_a22a95a8a1458c25ae4bc5ec7d1fc8ef; | ||
| 35 | static PyObject *const_str_plain_fallback; | ||
| 36 | static PyObject *const_tuple_str_plain_c_str_plain_x_tuple; | ||
| 37 | static PyObject *const_str_plain_ctxid; | ||
| 38 | static PyObject *const_str_plain_msgctxt; | ||
| 39 | extern PyObject *const_str_plain___spec__; | ||
| 40 | static PyObject *const_list_830d0364cfa54296e4e01dcf682d4b05_list; | ||
| 41 | static PyObject *const_tuple_98f87f734f9fb1ab67172f0d908a1c6d_tuple; | ||
| 42 | static PyObject *const_str_plain_z; | ||
| 43 | extern PyObject *const_tuple_str_plain_x_tuple; | ||
| 44 | extern PyObject *const_str_plain___all__; | ||
| 45 | extern PyObject *const_str_plain_y; | ||
| 46 | extern PyObject *const_str_digest_6807157bfb6aeb31712b82d637fd949a; | ||
| 47 | static PyObject *const_dict_473c2e80bee00322efee381030636345; | ||
| 48 | extern PyObject *const_str_plain___file__; | ||
| 49 | static PyObject *const_str_digest_248bf1bbbd8f85d18c457585c435999c; | ||
| 50 | extern PyObject *const_str_plain_n; | ||
| 51 | static PyObject *const_str_plain_N_; | ||
| 52 | static PyObject *const_str_plain_msgid; | ||
| 53 | extern PyObject *const_int_0; | ||
| 54 | static PyObject *const_str_plain_ngettext; | ||
| 55 | static PyObject *const_str_plain_gettext; | ||
| 56 | static PyObject *const_str_plain_msgid_plural; | ||
| 57 | static PyObject *const_str_plain_P_; | ||
| 58 | static PyObject *const_tuple_str_plain_x_str_plain_y_str_plain_z_tuple; | ||
| 59 | static PyObject *const_tuple_6f48abd8137833d35d208780e491b470_tuple; | ||
| 60 | extern PyObject *const_str_plain_origin; | ||
| 61 | static PyObject *const_tuple_str_plain_anaconda_tuple; | ||
| 62 | extern PyObject *const_str_plain_x; | ||
| 63 | extern PyObject *const_tuple_empty; | ||
| 64 | static PyObject *const_str_plain_c; | ||
| 65 | static PyObject *const_str_plain_CP_; | ||
| 66 | extern PyObject *const_str_plain_has_location; | ||
| 67 | static PyObject *const_str_plain_C_; | ||
| 68 | extern PyObject *const_str_plain_anaconda; | ||
| 69 | static PyObject *const_str_plain_CN_; | ||
| 70 | static PyObject *const_str_plain_translation; | ||
| 71 | extern PyObject *const_str_angle_lambda; | ||
| 72 | extern PyObject *const_str_empty; | ||
| 73 | static PyObject *const_str_digest_8f81abcc758bd7d49237bccd59957fbf; | ||
| 74 | extern PyObject *const_str_plain___doc__; | ||
| 75 | extern PyObject *const_str_plain___cached__; | ||
| 76 | extern PyObject *const_str_plain___debug__; | ||
| 77 | extern PyObject *const_str_plain__; | ||
| 78 | static PyObject *module_filename_obj; | ||
| 79 | |||
| 80 | /* Indicator if this modules private constants were created yet. */ | ||
| 81 | static bool constants_created = false; | ||
| 82 | |||
| 83 | /* Function to create module private constants. */ | ||
| 84 | static void createModuleConstants( void ) | ||
| 85 | { | ||
| 86 | const_str_digest_a22a95a8a1458c25ae4bc5ec7d1fc8ef = UNSTREAM_STRING_ASCII( &constant_bin[ 60375 ], 29, 0 ); | ||
| 87 | const_str_plain_fallback = UNSTREAM_STRING_ASCII( &constant_bin[ 60404 ], 8, 1 ); | ||
| 88 | const_tuple_str_plain_c_str_plain_x_tuple = PyTuple_New( 2 ); | ||
| 89 | const_str_plain_c = UNSTREAM_STRING_ASCII( &constant_bin[ 5 ], 1, 1 ); | ||
| 90 | PyTuple_SET_ITEM( const_tuple_str_plain_c_str_plain_x_tuple, 0, const_str_plain_c ); Py_INCREF( const_str_plain_c ); | ||
| 91 | PyTuple_SET_ITEM( const_tuple_str_plain_c_str_plain_x_tuple, 1, const_str_plain_x ); Py_INCREF( const_str_plain_x ); | ||
| 92 | const_str_plain_ctxid = UNSTREAM_STRING_ASCII( &constant_bin[ 60412 ], 5, 1 ); | ||
| 93 | const_str_plain_msgctxt = UNSTREAM_STRING_ASCII( &constant_bin[ 60417 ], 7, 1 ); | ||
| 94 | const_list_830d0364cfa54296e4e01dcf682d4b05_list = PyList_New( 6 ); | ||
| 95 | PyList_SET_ITEM( const_list_830d0364cfa54296e4e01dcf682d4b05_list, 0, const_str_plain__ ); Py_INCREF( const_str_plain__ ); | ||
| 96 | const_str_plain_N_ = UNSTREAM_STRING_ASCII( &constant_bin[ 3419 ], 2, 1 ); | ||
| 97 | PyList_SET_ITEM( const_list_830d0364cfa54296e4e01dcf682d4b05_list, 1, const_str_plain_N_ ); Py_INCREF( const_str_plain_N_ ); | ||
| 98 | const_str_plain_P_ = UNSTREAM_STRING_ASCII( &constant_bin[ 60424 ], 2, 1 ); | ||
| 99 | PyList_SET_ITEM( const_list_830d0364cfa54296e4e01dcf682d4b05_list, 2, const_str_plain_P_ ); Py_INCREF( const_str_plain_P_ ); | ||
| 100 | const_str_plain_C_ = UNSTREAM_STRING_ASCII( &constant_bin[ 60426 ], 2, 1 ); | ||
| 101 | PyList_SET_ITEM( const_list_830d0364cfa54296e4e01dcf682d4b05_list, 3, const_str_plain_C_ ); Py_INCREF( const_str_plain_C_ ); | ||
| 102 | const_str_plain_CN_ = UNSTREAM_STRING_ASCII( &constant_bin[ 60428 ], 3, 1 ); | ||
| 103 | PyList_SET_ITEM( const_list_830d0364cfa54296e4e01dcf682d4b05_list, 4, const_str_plain_CN_ ); Py_INCREF( const_str_plain_CN_ ); | ||
| 104 | const_str_plain_CP_ = UNSTREAM_STRING_ASCII( &constant_bin[ 60431 ], 3, 1 ); | ||
| 105 | PyList_SET_ITEM( const_list_830d0364cfa54296e4e01dcf682d4b05_list, 5, const_str_plain_CP_ ); Py_INCREF( const_str_plain_CP_ ); | ||
| 106 | const_tuple_98f87f734f9fb1ab67172f0d908a1c6d_tuple = PyTuple_New( 6 ); | ||
| 107 | PyTuple_SET_ITEM( const_tuple_98f87f734f9fb1ab67172f0d908a1c6d_tuple, 0, const_str_plain_msgctxt ); Py_INCREF( const_str_plain_msgctxt ); | ||
| 108 | const_str_plain_msgid = UNSTREAM_STRING_ASCII( &constant_bin[ 60434 ], 5, 1 ); | ||
| 109 | PyTuple_SET_ITEM( const_tuple_98f87f734f9fb1ab67172f0d908a1c6d_tuple, 1, const_str_plain_msgid ); Py_INCREF( const_str_plain_msgid ); | ||
| 110 | const_str_plain_msgid_plural = UNSTREAM_STRING_ASCII( &constant_bin[ 60439 ], 12, 1 ); | ||
| 111 | PyTuple_SET_ITEM( const_tuple_98f87f734f9fb1ab67172f0d908a1c6d_tuple, 2, const_str_plain_msgid_plural ); Py_INCREF( const_str_plain_msgid_plural ); | ||
| 112 | PyTuple_SET_ITEM( const_tuple_98f87f734f9fb1ab67172f0d908a1c6d_tuple, 3, const_str_plain_n ); Py_INCREF( const_str_plain_n ); | ||
| 113 | PyTuple_SET_ITEM( const_tuple_98f87f734f9fb1ab67172f0d908a1c6d_tuple, 4, const_str_plain_ctxid ); Py_INCREF( const_str_plain_ctxid ); | ||
| 114 | const_str_plain_translation = UNSTREAM_STRING_ASCII( &constant_bin[ 60451 ], 11, 1 ); | ||
| 115 | PyTuple_SET_ITEM( const_tuple_98f87f734f9fb1ab67172f0d908a1c6d_tuple, 5, const_str_plain_translation ); Py_INCREF( const_str_plain_translation ); | ||
| 116 | const_str_plain_z = UNSTREAM_STRING_ASCII( &constant_bin[ 169 ], 1, 1 ); | ||
| 117 | const_dict_473c2e80bee00322efee381030636345 = _PyDict_NewPresized( 1 ); | ||
| 118 | PyDict_SetItem( const_dict_473c2e80bee00322efee381030636345, const_str_plain_fallback, Py_True ); | ||
| 119 | assert( PyDict_Size( const_dict_473c2e80bee00322efee381030636345 ) == 1 ); | ||
| 120 | const_str_digest_248bf1bbbd8f85d18c457585c435999c = UNSTREAM_STRING_ASCII( &constant_bin[ 60462 ], 23, 0 ); | ||
| 121 | const_str_plain_ngettext = UNSTREAM_STRING_ASCII( &constant_bin[ 60485 ], 8, 1 ); | ||
| 122 | const_str_plain_gettext = UNSTREAM_STRING_ASCII( &constant_bin[ 60486 ], 7, 1 ); | ||
| 123 | const_tuple_str_plain_x_str_plain_y_str_plain_z_tuple = PyTuple_New( 3 ); | ||
| 124 | PyTuple_SET_ITEM( const_tuple_str_plain_x_str_plain_y_str_plain_z_tuple, 0, const_str_plain_x ); Py_INCREF( const_str_plain_x ); | ||
| 125 | PyTuple_SET_ITEM( const_tuple_str_plain_x_str_plain_y_str_plain_z_tuple, 1, const_str_plain_y ); Py_INCREF( const_str_plain_y ); | ||
| 126 | PyTuple_SET_ITEM( const_tuple_str_plain_x_str_plain_y_str_plain_z_tuple, 2, const_str_plain_z ); Py_INCREF( const_str_plain_z ); | ||
| 127 | const_tuple_6f48abd8137833d35d208780e491b470_tuple = PyTuple_New( 4 ); | ||
| 128 | PyTuple_SET_ITEM( const_tuple_6f48abd8137833d35d208780e491b470_tuple, 0, const_str_plain_msgctxt ); Py_INCREF( const_str_plain_msgctxt ); | ||
| 129 | PyTuple_SET_ITEM( const_tuple_6f48abd8137833d35d208780e491b470_tuple, 1, const_str_plain_msgid ); Py_INCREF( const_str_plain_msgid ); | ||
| 130 | PyTuple_SET_ITEM( const_tuple_6f48abd8137833d35d208780e491b470_tuple, 2, const_str_plain_ctxid ); Py_INCREF( const_str_plain_ctxid ); | ||
| 131 | PyTuple_SET_ITEM( const_tuple_6f48abd8137833d35d208780e491b470_tuple, 3, const_str_plain_translation ); Py_INCREF( const_str_plain_translation ); | ||
| 132 | const_tuple_str_plain_anaconda_tuple = PyTuple_New( 1 ); | ||
| 133 | PyTuple_SET_ITEM( const_tuple_str_plain_anaconda_tuple, 0, const_str_plain_anaconda ); Py_INCREF( const_str_plain_anaconda ); | ||
| 134 | const_str_digest_8f81abcc758bd7d49237bccd59957fbf = UNSTREAM_STRING_ASCII( &constant_bin[ 60493 ], 5, 0 ); | ||
| 135 | |||
| 136 | constants_created = true; | ||
| 137 | } | ||
| 138 | |||
| 139 | /* Function to verify module private constants for non-corruption. */ | ||
| 140 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 141 | void checkModuleConstants_pyanaconda$core$i18n( void ) | ||
| 142 | { | ||
| 143 | // The module may not have been used at all, then ignore this. | ||
| 144 | if (constants_created == false) return; | ||
| 145 | |||
| 146 | |||
| 147 | } | ||
| 148 | #endif | ||
| 149 | |||
| 150 | // The module code objects. | ||
| 151 | static PyCodeObject *codeobj_f730620f5ee989aac193fa77c67d6f4a; | ||
| 152 | static PyCodeObject *codeobj_d765fe45db9ef7595d660bb43896d023; | ||
| 153 | static PyCodeObject *codeobj_fdd80ad7539722ce2ee1767ffdb93d5a; | ||
| 154 | static PyCodeObject *codeobj_480615cbf52dc323ba5e9ee5031489a0; | ||
| 155 | static PyCodeObject *codeobj_d7b69a6e2471cfb718b957956bfa223e; | ||
| 156 | static PyCodeObject *codeobj_7c2a651ec1ba148f1aa253ff463e3423; | ||
| 157 | static PyCodeObject *codeobj_53cbd7eb6b277b0842ed240aae366bf7; | ||
| 158 | |||
| 159 | static void createModuleCodeObjects(void) | ||
| 160 | { | ||
| 161 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_248bf1bbbd8f85d18c457585c435999c ); | ||
| 162 | codeobj_f730620f5ee989aac193fa77c67d6f4a = MAKE_CODEOBJ( module_filename_obj, const_str_angle_lambda, 24, const_tuple_str_plain_x_tuple, 1, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 163 | codeobj_d765fe45db9ef7595d660bb43896d023 = MAKE_CODEOBJ( module_filename_obj, const_str_angle_lambda, 25, const_tuple_str_plain_x_tuple, 1, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 164 | codeobj_fdd80ad7539722ce2ee1767ffdb93d5a = MAKE_CODEOBJ( module_filename_obj, const_str_angle_lambda, 26, const_tuple_str_plain_x_str_plain_y_str_plain_z_tuple, 3, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 165 | codeobj_480615cbf52dc323ba5e9ee5031489a0 = MAKE_CODEOBJ( module_filename_obj, const_str_angle_lambda, 43, const_tuple_str_plain_c_str_plain_x_tuple, 2, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 166 | codeobj_d7b69a6e2471cfb718b957956bfa223e = MAKE_CODEOBJ( module_filename_obj, const_str_digest_a22a95a8a1458c25ae4bc5ec7d1fc8ef, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 167 | codeobj_7c2a651ec1ba148f1aa253ff463e3423 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_CP_, 46, const_tuple_98f87f734f9fb1ab67172f0d908a1c6d_tuple, 4, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 168 | codeobj_53cbd7eb6b277b0842ed240aae366bf7 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_C_, 32, const_tuple_6f48abd8137833d35d208780e491b470_tuple, 2, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 169 | } | ||
| 170 | |||
| 171 | // The module function declarations. | ||
| 172 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_1_lambda( ); | ||
| 173 | |||
| 174 | |||
| 175 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_2_lambda( ); | ||
| 176 | |||
| 177 | |||
| 178 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_3_lambda( ); | ||
| 179 | |||
| 180 | |||
| 181 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_4_C_( ); | ||
| 182 | |||
| 183 | |||
| 184 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_5_lambda( ); | ||
| 185 | |||
| 186 | |||
| 187 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_6_CP_( ); | ||
| 188 | |||
| 189 | |||
| 190 | // The module function definitions. | ||
| 191 | static PyObject *impl_pyanaconda$core$i18n$$$function_1_lambda( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 192 | { | ||
| 193 | // Preserve error status for checks | ||
| 194 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 195 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 196 | #endif | ||
| 197 | |||
| 198 | // Local variable declarations. | ||
| 199 | PyObject *par_x = python_pars[ 0 ]; | ||
| 200 | PyObject *tmp_return_value = NULL; | ||
| 201 | |||
| 202 | // Actual function body. | ||
| 203 | // Tried code: | ||
| 204 | CHECK_OBJECT( par_x ); | ||
| 205 | tmp_return_value = par_x; | ||
| 206 | Py_INCREF( tmp_return_value ); | ||
| 207 | goto try_return_handler_1; | ||
| 208 | // tried codes exits in all cases | ||
| 209 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_1_lambda ); | ||
| 210 | return NULL; | ||
| 211 | // Return handler code: | ||
| 212 | try_return_handler_1:; | ||
| 213 | CHECK_OBJECT( (PyObject *)par_x ); | ||
| 214 | Py_DECREF( par_x ); | ||
| 215 | par_x = NULL; | ||
| 216 | |||
| 217 | goto function_return_exit; | ||
| 218 | // End of try: | ||
| 219 | |||
| 220 | // Return statement must have exited already. | ||
| 221 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_1_lambda ); | ||
| 222 | return NULL; | ||
| 223 | |||
| 224 | |||
| 225 | function_return_exit: | ||
| 226 | // Function cleanup code if any. | ||
| 227 | |||
| 228 | |||
| 229 | // Actual function exit with return value, making sure we did not make | ||
| 230 | // the error status worse despite non-NULL return. | ||
| 231 | CHECK_OBJECT( tmp_return_value ); | ||
| 232 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 233 | return tmp_return_value; | ||
| 234 | } | ||
| 235 | |||
| 236 | |||
| 237 | static PyObject *impl_pyanaconda$core$i18n$$$function_2_lambda( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 238 | { | ||
| 239 | // Preserve error status for checks | ||
| 240 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 241 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 242 | #endif | ||
| 243 | |||
| 244 | // Local variable declarations. | ||
| 245 | PyObject *par_x = python_pars[ 0 ]; | ||
| 246 | struct Nuitka_FrameObject *frame_d765fe45db9ef7595d660bb43896d023; | ||
| 247 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 248 | PyObject *tmp_return_value = NULL; | ||
| 249 | int tmp_res; | ||
| 250 | PyObject *exception_type = NULL; | ||
| 251 | PyObject *exception_value = NULL; | ||
| 252 | PyTracebackObject *exception_tb = NULL; | ||
| 253 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 254 | static struct Nuitka_FrameObject *cache_frame_d765fe45db9ef7595d660bb43896d023 = NULL; | ||
| 255 | PyObject *exception_keeper_type_1; | ||
| 256 | PyObject *exception_keeper_value_1; | ||
| 257 | PyTracebackObject *exception_keeper_tb_1; | ||
| 258 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 259 | |||
| 260 | // Actual function body. | ||
| 261 | // Tried code: | ||
| 262 | MAKE_OR_REUSE_FRAME( cache_frame_d765fe45db9ef7595d660bb43896d023, codeobj_d765fe45db9ef7595d660bb43896d023, module_pyanaconda$core$i18n, sizeof(void *) ); | ||
| 263 | frame_d765fe45db9ef7595d660bb43896d023 = cache_frame_d765fe45db9ef7595d660bb43896d023; | ||
| 264 | |||
| 265 | // Push the new frame as the currently active one. | ||
| 266 | pushFrameStack( frame_d765fe45db9ef7595d660bb43896d023 ); | ||
| 267 | |||
| 268 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 269 | assert( Py_REFCNT( frame_d765fe45db9ef7595d660bb43896d023 ) == 2 ); // Frame stack | ||
| 270 | |||
| 271 | // Framed code: | ||
| 272 | { | ||
| 273 | nuitka_bool tmp_condition_result_1; | ||
| 274 | PyObject *tmp_compexpr_left_1; | ||
| 275 | PyObject *tmp_compexpr_right_1; | ||
| 276 | PyObject *tmp_called_instance_1; | ||
| 277 | PyObject *tmp_called_name_1; | ||
| 278 | PyObject *tmp_source_name_1; | ||
| 279 | PyObject *tmp_mvar_value_1; | ||
| 280 | PyObject *tmp_args_name_1; | ||
| 281 | PyObject *tmp_kw_name_1; | ||
| 282 | PyObject *tmp_args_element_name_1; | ||
| 283 | CHECK_OBJECT( par_x ); | ||
| 284 | tmp_compexpr_left_1 = par_x; | ||
| 285 | tmp_compexpr_right_1 = const_str_empty; | ||
| 286 | tmp_res = RICH_COMPARE_BOOL_NOTEQ_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 287 | if ( tmp_res == -1 ) | ||
| 288 | { | ||
| 289 | assert( ERROR_OCCURRED() ); | ||
| 290 | |||
| 291 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 292 | |||
| 293 | |||
| 294 | exception_lineno = 25; | ||
| 295 | type_description_1 = "o"; | ||
| 296 | goto frame_exception_exit_1; | ||
| 297 | } | ||
| 298 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 299 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 300 | { | ||
| 301 | goto condexpr_true_1; | ||
| 302 | } | ||
| 303 | else | ||
| 304 | { | ||
| 305 | goto condexpr_false_1; | ||
| 306 | } | ||
| 307 | condexpr_true_1:; | ||
| 308 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain_gettext ); | ||
| 309 | |||
| 310 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 311 | { | ||
| 312 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_gettext ); | ||
| 313 | } | ||
| 314 | |||
| 315 | if ( tmp_mvar_value_1 == NULL ) | ||
| 316 | { | ||
| 317 | |||
| 318 | exception_type = PyExc_NameError; | ||
| 319 | Py_INCREF( exception_type ); | ||
| 320 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "gettext" ); | ||
| 321 | exception_tb = NULL; | ||
| 322 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 323 | CHAIN_EXCEPTION( exception_value ); | ||
| 324 | |||
| 325 | exception_lineno = 25; | ||
| 326 | type_description_1 = "o"; | ||
| 327 | goto frame_exception_exit_1; | ||
| 328 | } | ||
| 329 | |||
| 330 | tmp_source_name_1 = tmp_mvar_value_1; | ||
| 331 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_translation ); | ||
| 332 | if ( tmp_called_name_1 == NULL ) | ||
| 333 | { | ||
| 334 | assert( ERROR_OCCURRED() ); | ||
| 335 | |||
| 336 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 337 | |||
| 338 | |||
| 339 | exception_lineno = 25; | ||
| 340 | type_description_1 = "o"; | ||
| 341 | goto frame_exception_exit_1; | ||
| 342 | } | ||
| 343 | tmp_args_name_1 = const_tuple_str_plain_anaconda_tuple; | ||
| 344 | tmp_kw_name_1 = PyDict_Copy( const_dict_473c2e80bee00322efee381030636345 ); | ||
| 345 | frame_d765fe45db9ef7595d660bb43896d023->m_frame.f_lineno = 25; | ||
| 346 | tmp_called_instance_1 = CALL_FUNCTION( tmp_called_name_1, tmp_args_name_1, tmp_kw_name_1 ); | ||
| 347 | Py_DECREF( tmp_called_name_1 ); | ||
| 348 | Py_DECREF( tmp_kw_name_1 ); | ||
| 349 | if ( tmp_called_instance_1 == NULL ) | ||
| 350 | { | ||
| 351 | assert( ERROR_OCCURRED() ); | ||
| 352 | |||
| 353 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 354 | |||
| 355 | |||
| 356 | exception_lineno = 25; | ||
| 357 | type_description_1 = "o"; | ||
| 358 | goto frame_exception_exit_1; | ||
| 359 | } | ||
| 360 | CHECK_OBJECT( par_x ); | ||
| 361 | tmp_args_element_name_1 = par_x; | ||
| 362 | frame_d765fe45db9ef7595d660bb43896d023->m_frame.f_lineno = 25; | ||
| 363 | { | ||
| 364 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 365 | tmp_return_value = CALL_METHOD_WITH_ARGS1( tmp_called_instance_1, const_str_plain_gettext, call_args ); | ||
| 366 | } | ||
| 367 | |||
| 368 | Py_DECREF( tmp_called_instance_1 ); | ||
| 369 | if ( tmp_return_value == NULL ) | ||
| 370 | { | ||
| 371 | assert( ERROR_OCCURRED() ); | ||
| 372 | |||
| 373 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 374 | |||
| 375 | |||
| 376 | exception_lineno = 25; | ||
| 377 | type_description_1 = "o"; | ||
| 378 | goto frame_exception_exit_1; | ||
| 379 | } | ||
| 380 | goto condexpr_end_1; | ||
| 381 | condexpr_false_1:; | ||
| 382 | tmp_return_value = const_str_empty; | ||
| 383 | Py_INCREF( tmp_return_value ); | ||
| 384 | condexpr_end_1:; | ||
| 385 | goto frame_return_exit_1; | ||
| 386 | } | ||
| 387 | |||
| 388 | #if 0 | ||
| 389 | RESTORE_FRAME_EXCEPTION( frame_d765fe45db9ef7595d660bb43896d023 ); | ||
| 390 | #endif | ||
| 391 | |||
| 392 | // Put the previous frame back on top. | ||
| 393 | popFrameStack(); | ||
| 394 | |||
| 395 | goto frame_no_exception_1; | ||
| 396 | |||
| 397 | frame_return_exit_1:; | ||
| 398 | #if 0 | ||
| 399 | RESTORE_FRAME_EXCEPTION( frame_d765fe45db9ef7595d660bb43896d023 ); | ||
| 400 | #endif | ||
| 401 | |||
| 402 | // Put the previous frame back on top. | ||
| 403 | popFrameStack(); | ||
| 404 | |||
| 405 | goto try_return_handler_1; | ||
| 406 | |||
| 407 | frame_exception_exit_1:; | ||
| 408 | |||
| 409 | #if 0 | ||
| 410 | RESTORE_FRAME_EXCEPTION( frame_d765fe45db9ef7595d660bb43896d023 ); | ||
| 411 | #endif | ||
| 412 | |||
| 413 | if ( exception_tb == NULL ) | ||
| 414 | { | ||
| 415 | exception_tb = MAKE_TRACEBACK( frame_d765fe45db9ef7595d660bb43896d023, exception_lineno ); | ||
| 416 | } | ||
| 417 | else if ( exception_tb->tb_frame != &frame_d765fe45db9ef7595d660bb43896d023->m_frame ) | ||
| 418 | { | ||
| 419 | exception_tb = ADD_TRACEBACK( exception_tb, frame_d765fe45db9ef7595d660bb43896d023, exception_lineno ); | ||
| 420 | } | ||
| 421 | |||
| 422 | // Attachs locals to frame if any. | ||
| 423 | Nuitka_Frame_AttachLocals( | ||
| 424 | (struct Nuitka_FrameObject *)frame_d765fe45db9ef7595d660bb43896d023, | ||
| 425 | type_description_1, | ||
| 426 | par_x | ||
| 427 | ); | ||
| 428 | |||
| 429 | |||
| 430 | // Release cached frame. | ||
| 431 | if ( frame_d765fe45db9ef7595d660bb43896d023 == cache_frame_d765fe45db9ef7595d660bb43896d023 ) | ||
| 432 | { | ||
| 433 | Py_DECREF( frame_d765fe45db9ef7595d660bb43896d023 ); | ||
| 434 | } | ||
| 435 | cache_frame_d765fe45db9ef7595d660bb43896d023 = NULL; | ||
| 436 | |||
| 437 | assertFrameObject( frame_d765fe45db9ef7595d660bb43896d023 ); | ||
| 438 | |||
| 439 | // Put the previous frame back on top. | ||
| 440 | popFrameStack(); | ||
| 441 | |||
| 442 | // Return the error. | ||
| 443 | goto try_except_handler_1; | ||
| 444 | |||
| 445 | frame_no_exception_1:; | ||
| 446 | // tried codes exits in all cases | ||
| 447 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_2_lambda ); | ||
| 448 | return NULL; | ||
| 449 | // Return handler code: | ||
| 450 | try_return_handler_1:; | ||
| 451 | CHECK_OBJECT( (PyObject *)par_x ); | ||
| 452 | Py_DECREF( par_x ); | ||
| 453 | par_x = NULL; | ||
| 454 | |||
| 455 | goto function_return_exit; | ||
| 456 | // Exception handler code: | ||
| 457 | try_except_handler_1:; | ||
| 458 | exception_keeper_type_1 = exception_type; | ||
| 459 | exception_keeper_value_1 = exception_value; | ||
| 460 | exception_keeper_tb_1 = exception_tb; | ||
| 461 | exception_keeper_lineno_1 = exception_lineno; | ||
| 462 | exception_type = NULL; | ||
| 463 | exception_value = NULL; | ||
| 464 | exception_tb = NULL; | ||
| 465 | exception_lineno = 0; | ||
| 466 | |||
| 467 | CHECK_OBJECT( (PyObject *)par_x ); | ||
| 468 | Py_DECREF( par_x ); | ||
| 469 | par_x = NULL; | ||
| 470 | |||
| 471 | // Re-raise. | ||
| 472 | exception_type = exception_keeper_type_1; | ||
| 473 | exception_value = exception_keeper_value_1; | ||
| 474 | exception_tb = exception_keeper_tb_1; | ||
| 475 | exception_lineno = exception_keeper_lineno_1; | ||
| 476 | |||
| 477 | goto function_exception_exit; | ||
| 478 | // End of try: | ||
| 479 | |||
| 480 | // Return statement must have exited already. | ||
| 481 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_2_lambda ); | ||
| 482 | return NULL; | ||
| 483 | |||
| 484 | function_exception_exit: | ||
| 485 | assert( exception_type ); | ||
| 486 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 487 | |||
| 488 | return NULL; | ||
| 489 | |||
| 490 | function_return_exit: | ||
| 491 | // Function cleanup code if any. | ||
| 492 | |||
| 493 | |||
| 494 | // Actual function exit with return value, making sure we did not make | ||
| 495 | // the error status worse despite non-NULL return. | ||
| 496 | CHECK_OBJECT( tmp_return_value ); | ||
| 497 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 498 | return tmp_return_value; | ||
| 499 | } | ||
| 500 | |||
| 501 | |||
| 502 | static PyObject *impl_pyanaconda$core$i18n$$$function_3_lambda( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 503 | { | ||
| 504 | // Preserve error status for checks | ||
| 505 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 506 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 507 | #endif | ||
| 508 | |||
| 509 | // Local variable declarations. | ||
| 510 | PyObject *par_x = python_pars[ 0 ]; | ||
| 511 | PyObject *par_y = python_pars[ 1 ]; | ||
| 512 | PyObject *par_z = python_pars[ 2 ]; | ||
| 513 | struct Nuitka_FrameObject *frame_fdd80ad7539722ce2ee1767ffdb93d5a; | ||
| 514 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 515 | PyObject *tmp_return_value = NULL; | ||
| 516 | PyObject *exception_type = NULL; | ||
| 517 | PyObject *exception_value = NULL; | ||
| 518 | PyTracebackObject *exception_tb = NULL; | ||
| 519 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 520 | static struct Nuitka_FrameObject *cache_frame_fdd80ad7539722ce2ee1767ffdb93d5a = NULL; | ||
| 521 | PyObject *exception_keeper_type_1; | ||
| 522 | PyObject *exception_keeper_value_1; | ||
| 523 | PyTracebackObject *exception_keeper_tb_1; | ||
| 524 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 525 | |||
| 526 | // Actual function body. | ||
| 527 | // Tried code: | ||
| 528 | MAKE_OR_REUSE_FRAME( cache_frame_fdd80ad7539722ce2ee1767ffdb93d5a, codeobj_fdd80ad7539722ce2ee1767ffdb93d5a, module_pyanaconda$core$i18n, sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 529 | frame_fdd80ad7539722ce2ee1767ffdb93d5a = cache_frame_fdd80ad7539722ce2ee1767ffdb93d5a; | ||
| 530 | |||
| 531 | // Push the new frame as the currently active one. | ||
| 532 | pushFrameStack( frame_fdd80ad7539722ce2ee1767ffdb93d5a ); | ||
| 533 | |||
| 534 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 535 | assert( Py_REFCNT( frame_fdd80ad7539722ce2ee1767ffdb93d5a ) == 2 ); // Frame stack | ||
| 536 | |||
| 537 | // Framed code: | ||
| 538 | { | ||
| 539 | PyObject *tmp_called_instance_1; | ||
| 540 | PyObject *tmp_called_name_1; | ||
| 541 | PyObject *tmp_source_name_1; | ||
| 542 | PyObject *tmp_mvar_value_1; | ||
| 543 | PyObject *tmp_args_name_1; | ||
| 544 | PyObject *tmp_kw_name_1; | ||
| 545 | PyObject *tmp_args_element_name_1; | ||
| 546 | PyObject *tmp_args_element_name_2; | ||
| 547 | PyObject *tmp_args_element_name_3; | ||
| 548 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain_gettext ); | ||
| 549 | |||
| 550 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 551 | { | ||
| 552 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_gettext ); | ||
| 553 | } | ||
| 554 | |||
| 555 | if ( tmp_mvar_value_1 == NULL ) | ||
| 556 | { | ||
| 557 | |||
| 558 | exception_type = PyExc_NameError; | ||
| 559 | Py_INCREF( exception_type ); | ||
| 560 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "gettext" ); | ||
| 561 | exception_tb = NULL; | ||
| 562 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 563 | CHAIN_EXCEPTION( exception_value ); | ||
| 564 | |||
| 565 | exception_lineno = 26; | ||
| 566 | type_description_1 = "ooo"; | ||
| 567 | goto frame_exception_exit_1; | ||
| 568 | } | ||
| 569 | |||
| 570 | tmp_source_name_1 = tmp_mvar_value_1; | ||
| 571 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_translation ); | ||
| 572 | if ( tmp_called_name_1 == NULL ) | ||
| 573 | { | ||
| 574 | assert( ERROR_OCCURRED() ); | ||
| 575 | |||
| 576 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 577 | |||
| 578 | |||
| 579 | exception_lineno = 26; | ||
| 580 | type_description_1 = "ooo"; | ||
| 581 | goto frame_exception_exit_1; | ||
| 582 | } | ||
| 583 | tmp_args_name_1 = const_tuple_str_plain_anaconda_tuple; | ||
| 584 | tmp_kw_name_1 = PyDict_Copy( const_dict_473c2e80bee00322efee381030636345 ); | ||
| 585 | frame_fdd80ad7539722ce2ee1767ffdb93d5a->m_frame.f_lineno = 26; | ||
| 586 | tmp_called_instance_1 = CALL_FUNCTION( tmp_called_name_1, tmp_args_name_1, tmp_kw_name_1 ); | ||
| 587 | Py_DECREF( tmp_called_name_1 ); | ||
| 588 | Py_DECREF( tmp_kw_name_1 ); | ||
| 589 | if ( tmp_called_instance_1 == NULL ) | ||
| 590 | { | ||
| 591 | assert( ERROR_OCCURRED() ); | ||
| 592 | |||
| 593 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 594 | |||
| 595 | |||
| 596 | exception_lineno = 26; | ||
| 597 | type_description_1 = "ooo"; | ||
| 598 | goto frame_exception_exit_1; | ||
| 599 | } | ||
| 600 | CHECK_OBJECT( par_x ); | ||
| 601 | tmp_args_element_name_1 = par_x; | ||
| 602 | CHECK_OBJECT( par_y ); | ||
| 603 | tmp_args_element_name_2 = par_y; | ||
| 604 | CHECK_OBJECT( par_z ); | ||
| 605 | tmp_args_element_name_3 = par_z; | ||
| 606 | frame_fdd80ad7539722ce2ee1767ffdb93d5a->m_frame.f_lineno = 26; | ||
| 607 | { | ||
| 608 | PyObject *call_args[] = { tmp_args_element_name_1, tmp_args_element_name_2, tmp_args_element_name_3 }; | ||
| 609 | tmp_return_value = CALL_METHOD_WITH_ARGS3( tmp_called_instance_1, const_str_plain_ngettext, call_args ); | ||
| 610 | } | ||
| 611 | |||
| 612 | Py_DECREF( tmp_called_instance_1 ); | ||
| 613 | if ( tmp_return_value == NULL ) | ||
| 614 | { | ||
| 615 | assert( ERROR_OCCURRED() ); | ||
| 616 | |||
| 617 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 618 | |||
| 619 | |||
| 620 | exception_lineno = 26; | ||
| 621 | type_description_1 = "ooo"; | ||
| 622 | goto frame_exception_exit_1; | ||
| 623 | } | ||
| 624 | goto frame_return_exit_1; | ||
| 625 | } | ||
| 626 | |||
| 627 | #if 0 | ||
| 628 | RESTORE_FRAME_EXCEPTION( frame_fdd80ad7539722ce2ee1767ffdb93d5a ); | ||
| 629 | #endif | ||
| 630 | |||
| 631 | // Put the previous frame back on top. | ||
| 632 | popFrameStack(); | ||
| 633 | |||
| 634 | goto frame_no_exception_1; | ||
| 635 | |||
| 636 | frame_return_exit_1:; | ||
| 637 | #if 0 | ||
| 638 | RESTORE_FRAME_EXCEPTION( frame_fdd80ad7539722ce2ee1767ffdb93d5a ); | ||
| 639 | #endif | ||
| 640 | |||
| 641 | // Put the previous frame back on top. | ||
| 642 | popFrameStack(); | ||
| 643 | |||
| 644 | goto try_return_handler_1; | ||
| 645 | |||
| 646 | frame_exception_exit_1:; | ||
| 647 | |||
| 648 | #if 0 | ||
| 649 | RESTORE_FRAME_EXCEPTION( frame_fdd80ad7539722ce2ee1767ffdb93d5a ); | ||
| 650 | #endif | ||
| 651 | |||
| 652 | if ( exception_tb == NULL ) | ||
| 653 | { | ||
| 654 | exception_tb = MAKE_TRACEBACK( frame_fdd80ad7539722ce2ee1767ffdb93d5a, exception_lineno ); | ||
| 655 | } | ||
| 656 | else if ( exception_tb->tb_frame != &frame_fdd80ad7539722ce2ee1767ffdb93d5a->m_frame ) | ||
| 657 | { | ||
| 658 | exception_tb = ADD_TRACEBACK( exception_tb, frame_fdd80ad7539722ce2ee1767ffdb93d5a, exception_lineno ); | ||
| 659 | } | ||
| 660 | |||
| 661 | // Attachs locals to frame if any. | ||
| 662 | Nuitka_Frame_AttachLocals( | ||
| 663 | (struct Nuitka_FrameObject *)frame_fdd80ad7539722ce2ee1767ffdb93d5a, | ||
| 664 | type_description_1, | ||
| 665 | par_x, | ||
| 666 | par_y, | ||
| 667 | par_z | ||
| 668 | ); | ||
| 669 | |||
| 670 | |||
| 671 | // Release cached frame. | ||
| 672 | if ( frame_fdd80ad7539722ce2ee1767ffdb93d5a == cache_frame_fdd80ad7539722ce2ee1767ffdb93d5a ) | ||
| 673 | { | ||
| 674 | Py_DECREF( frame_fdd80ad7539722ce2ee1767ffdb93d5a ); | ||
| 675 | } | ||
| 676 | cache_frame_fdd80ad7539722ce2ee1767ffdb93d5a = NULL; | ||
| 677 | |||
| 678 | assertFrameObject( frame_fdd80ad7539722ce2ee1767ffdb93d5a ); | ||
| 679 | |||
| 680 | // Put the previous frame back on top. | ||
| 681 | popFrameStack(); | ||
| 682 | |||
| 683 | // Return the error. | ||
| 684 | goto try_except_handler_1; | ||
| 685 | |||
| 686 | frame_no_exception_1:; | ||
| 687 | // tried codes exits in all cases | ||
| 688 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_3_lambda ); | ||
| 689 | return NULL; | ||
| 690 | // Return handler code: | ||
| 691 | try_return_handler_1:; | ||
| 692 | CHECK_OBJECT( (PyObject *)par_x ); | ||
| 693 | Py_DECREF( par_x ); | ||
| 694 | par_x = NULL; | ||
| 695 | |||
| 696 | CHECK_OBJECT( (PyObject *)par_y ); | ||
| 697 | Py_DECREF( par_y ); | ||
| 698 | par_y = NULL; | ||
| 699 | |||
| 700 | CHECK_OBJECT( (PyObject *)par_z ); | ||
| 701 | Py_DECREF( par_z ); | ||
| 702 | par_z = NULL; | ||
| 703 | |||
| 704 | goto function_return_exit; | ||
| 705 | // Exception handler code: | ||
| 706 | try_except_handler_1:; | ||
| 707 | exception_keeper_type_1 = exception_type; | ||
| 708 | exception_keeper_value_1 = exception_value; | ||
| 709 | exception_keeper_tb_1 = exception_tb; | ||
| 710 | exception_keeper_lineno_1 = exception_lineno; | ||
| 711 | exception_type = NULL; | ||
| 712 | exception_value = NULL; | ||
| 713 | exception_tb = NULL; | ||
| 714 | exception_lineno = 0; | ||
| 715 | |||
| 716 | CHECK_OBJECT( (PyObject *)par_x ); | ||
| 717 | Py_DECREF( par_x ); | ||
| 718 | par_x = NULL; | ||
| 719 | |||
| 720 | CHECK_OBJECT( (PyObject *)par_y ); | ||
| 721 | Py_DECREF( par_y ); | ||
| 722 | par_y = NULL; | ||
| 723 | |||
| 724 | CHECK_OBJECT( (PyObject *)par_z ); | ||
| 725 | Py_DECREF( par_z ); | ||
| 726 | par_z = NULL; | ||
| 727 | |||
| 728 | // Re-raise. | ||
| 729 | exception_type = exception_keeper_type_1; | ||
| 730 | exception_value = exception_keeper_value_1; | ||
| 731 | exception_tb = exception_keeper_tb_1; | ||
| 732 | exception_lineno = exception_keeper_lineno_1; | ||
| 733 | |||
| 734 | goto function_exception_exit; | ||
| 735 | // End of try: | ||
| 736 | |||
| 737 | // Return statement must have exited already. | ||
| 738 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_3_lambda ); | ||
| 739 | return NULL; | ||
| 740 | |||
| 741 | function_exception_exit: | ||
| 742 | assert( exception_type ); | ||
| 743 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 744 | |||
| 745 | return NULL; | ||
| 746 | |||
| 747 | function_return_exit: | ||
| 748 | // Function cleanup code if any. | ||
| 749 | |||
| 750 | |||
| 751 | // Actual function exit with return value, making sure we did not make | ||
| 752 | // the error status worse despite non-NULL return. | ||
| 753 | CHECK_OBJECT( tmp_return_value ); | ||
| 754 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 755 | return tmp_return_value; | ||
| 756 | } | ||
| 757 | |||
| 758 | |||
| 759 | static PyObject *impl_pyanaconda$core$i18n$$$function_4_C_( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 760 | { | ||
| 761 | // Preserve error status for checks | ||
| 762 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 763 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 764 | #endif | ||
| 765 | |||
| 766 | // Local variable declarations. | ||
| 767 | PyObject *par_msgctxt = python_pars[ 0 ]; | ||
| 768 | PyObject *par_msgid = python_pars[ 1 ]; | ||
| 769 | PyObject *var_ctxid = NULL; | ||
| 770 | PyObject *var_translation = NULL; | ||
| 771 | struct Nuitka_FrameObject *frame_53cbd7eb6b277b0842ed240aae366bf7; | ||
| 772 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 773 | PyObject *exception_type = NULL; | ||
| 774 | PyObject *exception_value = NULL; | ||
| 775 | PyTracebackObject *exception_tb = NULL; | ||
| 776 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 777 | int tmp_res; | ||
| 778 | PyObject *tmp_return_value = NULL; | ||
| 779 | static struct Nuitka_FrameObject *cache_frame_53cbd7eb6b277b0842ed240aae366bf7 = NULL; | ||
| 780 | PyObject *exception_keeper_type_1; | ||
| 781 | PyObject *exception_keeper_value_1; | ||
| 782 | PyTracebackObject *exception_keeper_tb_1; | ||
| 783 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 784 | |||
| 785 | // Actual function body. | ||
| 786 | // Tried code: | ||
| 787 | MAKE_OR_REUSE_FRAME( cache_frame_53cbd7eb6b277b0842ed240aae366bf7, codeobj_53cbd7eb6b277b0842ed240aae366bf7, module_pyanaconda$core$i18n, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 788 | frame_53cbd7eb6b277b0842ed240aae366bf7 = cache_frame_53cbd7eb6b277b0842ed240aae366bf7; | ||
| 789 | |||
| 790 | // Push the new frame as the currently active one. | ||
| 791 | pushFrameStack( frame_53cbd7eb6b277b0842ed240aae366bf7 ); | ||
| 792 | |||
| 793 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 794 | assert( Py_REFCNT( frame_53cbd7eb6b277b0842ed240aae366bf7 ) == 2 ); // Frame stack | ||
| 795 | |||
| 796 | // Framed code: | ||
| 797 | { | ||
| 798 | PyObject *tmp_assign_source_1; | ||
| 799 | PyObject *tmp_left_name_1; | ||
| 800 | PyObject *tmp_right_name_1; | ||
| 801 | PyObject *tmp_tuple_element_1; | ||
| 802 | tmp_left_name_1 = const_str_digest_8f81abcc758bd7d49237bccd59957fbf; | ||
| 803 | CHECK_OBJECT( par_msgctxt ); | ||
| 804 | tmp_tuple_element_1 = par_msgctxt; | ||
| 805 | tmp_right_name_1 = PyTuple_New( 2 ); | ||
| 806 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 807 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_1 ); | ||
| 808 | CHECK_OBJECT( par_msgid ); | ||
| 809 | tmp_tuple_element_1 = par_msgid; | ||
| 810 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 811 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_1 ); | ||
| 812 | tmp_assign_source_1 = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 813 | Py_DECREF( tmp_right_name_1 ); | ||
| 814 | if ( tmp_assign_source_1 == NULL ) | ||
| 815 | { | ||
| 816 | assert( ERROR_OCCURRED() ); | ||
| 817 | |||
| 818 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 819 | |||
| 820 | |||
| 821 | exception_lineno = 33; | ||
| 822 | type_description_1 = "oooo"; | ||
| 823 | goto frame_exception_exit_1; | ||
| 824 | } | ||
| 825 | assert( var_ctxid == NULL ); | ||
| 826 | var_ctxid = tmp_assign_source_1; | ||
| 827 | } | ||
| 828 | { | ||
| 829 | PyObject *tmp_assign_source_2; | ||
| 830 | PyObject *tmp_called_name_1; | ||
| 831 | PyObject *tmp_mvar_value_1; | ||
| 832 | PyObject *tmp_args_element_name_1; | ||
| 833 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain__ ); | ||
| 834 | |||
| 835 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 836 | { | ||
| 837 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__ ); | ||
| 838 | } | ||
| 839 | |||
| 840 | if ( tmp_mvar_value_1 == NULL ) | ||
| 841 | { | ||
| 842 | |||
| 843 | exception_type = PyExc_NameError; | ||
| 844 | Py_INCREF( exception_type ); | ||
| 845 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_" ); | ||
| 846 | exception_tb = NULL; | ||
| 847 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 848 | CHAIN_EXCEPTION( exception_value ); | ||
| 849 | |||
| 850 | exception_lineno = 34; | ||
| 851 | type_description_1 = "oooo"; | ||
| 852 | goto frame_exception_exit_1; | ||
| 853 | } | ||
| 854 | |||
| 855 | tmp_called_name_1 = tmp_mvar_value_1; | ||
| 856 | CHECK_OBJECT( var_ctxid ); | ||
| 857 | tmp_args_element_name_1 = var_ctxid; | ||
| 858 | frame_53cbd7eb6b277b0842ed240aae366bf7->m_frame.f_lineno = 34; | ||
| 859 | { | ||
| 860 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 861 | tmp_assign_source_2 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, call_args ); | ||
| 862 | } | ||
| 863 | |||
| 864 | if ( tmp_assign_source_2 == NULL ) | ||
| 865 | { | ||
| 866 | assert( ERROR_OCCURRED() ); | ||
| 867 | |||
| 868 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 869 | |||
| 870 | |||
| 871 | exception_lineno = 34; | ||
| 872 | type_description_1 = "oooo"; | ||
| 873 | goto frame_exception_exit_1; | ||
| 874 | } | ||
| 875 | assert( var_translation == NULL ); | ||
| 876 | var_translation = tmp_assign_source_2; | ||
| 877 | } | ||
| 878 | { | ||
| 879 | nuitka_bool tmp_condition_result_1; | ||
| 880 | PyObject *tmp_compexpr_left_1; | ||
| 881 | PyObject *tmp_compexpr_right_1; | ||
| 882 | CHECK_OBJECT( var_translation ); | ||
| 883 | tmp_compexpr_left_1 = var_translation; | ||
| 884 | CHECK_OBJECT( var_ctxid ); | ||
| 885 | tmp_compexpr_right_1 = var_ctxid; | ||
| 886 | tmp_res = RICH_COMPARE_BOOL_EQ_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 887 | if ( tmp_res == -1 ) | ||
| 888 | { | ||
| 889 | assert( ERROR_OCCURRED() ); | ||
| 890 | |||
| 891 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 892 | |||
| 893 | |||
| 894 | exception_lineno = 37; | ||
| 895 | type_description_1 = "oooo"; | ||
| 896 | goto frame_exception_exit_1; | ||
| 897 | } | ||
| 898 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 899 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 900 | { | ||
| 901 | goto branch_yes_1; | ||
| 902 | } | ||
| 903 | else | ||
| 904 | { | ||
| 905 | goto branch_no_1; | ||
| 906 | } | ||
| 907 | branch_yes_1:; | ||
| 908 | CHECK_OBJECT( par_msgid ); | ||
| 909 | tmp_return_value = par_msgid; | ||
| 910 | Py_INCREF( tmp_return_value ); | ||
| 911 | goto frame_return_exit_1; | ||
| 912 | goto branch_end_1; | ||
| 913 | branch_no_1:; | ||
| 914 | CHECK_OBJECT( var_translation ); | ||
| 915 | tmp_return_value = var_translation; | ||
| 916 | Py_INCREF( tmp_return_value ); | ||
| 917 | goto frame_return_exit_1; | ||
| 918 | branch_end_1:; | ||
| 919 | } | ||
| 920 | |||
| 921 | #if 0 | ||
| 922 | RESTORE_FRAME_EXCEPTION( frame_53cbd7eb6b277b0842ed240aae366bf7 ); | ||
| 923 | #endif | ||
| 924 | |||
| 925 | // Put the previous frame back on top. | ||
| 926 | popFrameStack(); | ||
| 927 | |||
| 928 | goto frame_no_exception_1; | ||
| 929 | |||
| 930 | frame_return_exit_1:; | ||
| 931 | #if 0 | ||
| 932 | RESTORE_FRAME_EXCEPTION( frame_53cbd7eb6b277b0842ed240aae366bf7 ); | ||
| 933 | #endif | ||
| 934 | |||
| 935 | // Put the previous frame back on top. | ||
| 936 | popFrameStack(); | ||
| 937 | |||
| 938 | goto try_return_handler_1; | ||
| 939 | |||
| 940 | frame_exception_exit_1:; | ||
| 941 | |||
| 942 | #if 0 | ||
| 943 | RESTORE_FRAME_EXCEPTION( frame_53cbd7eb6b277b0842ed240aae366bf7 ); | ||
| 944 | #endif | ||
| 945 | |||
| 946 | if ( exception_tb == NULL ) | ||
| 947 | { | ||
| 948 | exception_tb = MAKE_TRACEBACK( frame_53cbd7eb6b277b0842ed240aae366bf7, exception_lineno ); | ||
| 949 | } | ||
| 950 | else if ( exception_tb->tb_frame != &frame_53cbd7eb6b277b0842ed240aae366bf7->m_frame ) | ||
| 951 | { | ||
| 952 | exception_tb = ADD_TRACEBACK( exception_tb, frame_53cbd7eb6b277b0842ed240aae366bf7, exception_lineno ); | ||
| 953 | } | ||
| 954 | |||
| 955 | // Attachs locals to frame if any. | ||
| 956 | Nuitka_Frame_AttachLocals( | ||
| 957 | (struct Nuitka_FrameObject *)frame_53cbd7eb6b277b0842ed240aae366bf7, | ||
| 958 | type_description_1, | ||
| 959 | par_msgctxt, | ||
| 960 | par_msgid, | ||
| 961 | var_ctxid, | ||
| 962 | var_translation | ||
| 963 | ); | ||
| 964 | |||
| 965 | |||
| 966 | // Release cached frame. | ||
| 967 | if ( frame_53cbd7eb6b277b0842ed240aae366bf7 == cache_frame_53cbd7eb6b277b0842ed240aae366bf7 ) | ||
| 968 | { | ||
| 969 | Py_DECREF( frame_53cbd7eb6b277b0842ed240aae366bf7 ); | ||
| 970 | } | ||
| 971 | cache_frame_53cbd7eb6b277b0842ed240aae366bf7 = NULL; | ||
| 972 | |||
| 973 | assertFrameObject( frame_53cbd7eb6b277b0842ed240aae366bf7 ); | ||
| 974 | |||
| 975 | // Put the previous frame back on top. | ||
| 976 | popFrameStack(); | ||
| 977 | |||
| 978 | // Return the error. | ||
| 979 | goto try_except_handler_1; | ||
| 980 | |||
| 981 | frame_no_exception_1:; | ||
| 982 | // tried codes exits in all cases | ||
| 983 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_4_C_ ); | ||
| 984 | return NULL; | ||
| 985 | // Return handler code: | ||
| 986 | try_return_handler_1:; | ||
| 987 | CHECK_OBJECT( (PyObject *)par_msgctxt ); | ||
| 988 | Py_DECREF( par_msgctxt ); | ||
| 989 | par_msgctxt = NULL; | ||
| 990 | |||
| 991 | CHECK_OBJECT( (PyObject *)par_msgid ); | ||
| 992 | Py_DECREF( par_msgid ); | ||
| 993 | par_msgid = NULL; | ||
| 994 | |||
| 995 | CHECK_OBJECT( (PyObject *)var_ctxid ); | ||
| 996 | Py_DECREF( var_ctxid ); | ||
| 997 | var_ctxid = NULL; | ||
| 998 | |||
| 999 | CHECK_OBJECT( (PyObject *)var_translation ); | ||
| 1000 | Py_DECREF( var_translation ); | ||
| 1001 | var_translation = NULL; | ||
| 1002 | |||
| 1003 | goto function_return_exit; | ||
| 1004 | // Exception handler code: | ||
| 1005 | try_except_handler_1:; | ||
| 1006 | exception_keeper_type_1 = exception_type; | ||
| 1007 | exception_keeper_value_1 = exception_value; | ||
| 1008 | exception_keeper_tb_1 = exception_tb; | ||
| 1009 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1010 | exception_type = NULL; | ||
| 1011 | exception_value = NULL; | ||
| 1012 | exception_tb = NULL; | ||
| 1013 | exception_lineno = 0; | ||
| 1014 | |||
| 1015 | CHECK_OBJECT( (PyObject *)par_msgctxt ); | ||
| 1016 | Py_DECREF( par_msgctxt ); | ||
| 1017 | par_msgctxt = NULL; | ||
| 1018 | |||
| 1019 | CHECK_OBJECT( (PyObject *)par_msgid ); | ||
| 1020 | Py_DECREF( par_msgid ); | ||
| 1021 | par_msgid = NULL; | ||
| 1022 | |||
| 1023 | Py_XDECREF( var_ctxid ); | ||
| 1024 | var_ctxid = NULL; | ||
| 1025 | |||
| 1026 | Py_XDECREF( var_translation ); | ||
| 1027 | var_translation = NULL; | ||
| 1028 | |||
| 1029 | // Re-raise. | ||
| 1030 | exception_type = exception_keeper_type_1; | ||
| 1031 | exception_value = exception_keeper_value_1; | ||
| 1032 | exception_tb = exception_keeper_tb_1; | ||
| 1033 | exception_lineno = exception_keeper_lineno_1; | ||
| 1034 | |||
| 1035 | goto function_exception_exit; | ||
| 1036 | // End of try: | ||
| 1037 | |||
| 1038 | // Return statement must have exited already. | ||
| 1039 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_4_C_ ); | ||
| 1040 | return NULL; | ||
| 1041 | |||
| 1042 | function_exception_exit: | ||
| 1043 | assert( exception_type ); | ||
| 1044 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1045 | |||
| 1046 | return NULL; | ||
| 1047 | |||
| 1048 | function_return_exit: | ||
| 1049 | // Function cleanup code if any. | ||
| 1050 | |||
| 1051 | |||
| 1052 | // Actual function exit with return value, making sure we did not make | ||
| 1053 | // the error status worse despite non-NULL return. | ||
| 1054 | CHECK_OBJECT( tmp_return_value ); | ||
| 1055 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 1056 | return tmp_return_value; | ||
| 1057 | } | ||
| 1058 | |||
| 1059 | |||
| 1060 | static PyObject *impl_pyanaconda$core$i18n$$$function_5_lambda( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 1061 | { | ||
| 1062 | // Preserve error status for checks | ||
| 1063 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1064 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 1065 | #endif | ||
| 1066 | |||
| 1067 | // Local variable declarations. | ||
| 1068 | PyObject *par_c = python_pars[ 0 ]; | ||
| 1069 | PyObject *par_x = python_pars[ 1 ]; | ||
| 1070 | PyObject *tmp_return_value = NULL; | ||
| 1071 | |||
| 1072 | // Actual function body. | ||
| 1073 | // Tried code: | ||
| 1074 | CHECK_OBJECT( par_x ); | ||
| 1075 | tmp_return_value = par_x; | ||
| 1076 | Py_INCREF( tmp_return_value ); | ||
| 1077 | goto try_return_handler_1; | ||
| 1078 | // tried codes exits in all cases | ||
| 1079 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_5_lambda ); | ||
| 1080 | return NULL; | ||
| 1081 | // Return handler code: | ||
| 1082 | try_return_handler_1:; | ||
| 1083 | CHECK_OBJECT( (PyObject *)par_c ); | ||
| 1084 | Py_DECREF( par_c ); | ||
| 1085 | par_c = NULL; | ||
| 1086 | |||
| 1087 | CHECK_OBJECT( (PyObject *)par_x ); | ||
| 1088 | Py_DECREF( par_x ); | ||
| 1089 | par_x = NULL; | ||
| 1090 | |||
| 1091 | goto function_return_exit; | ||
| 1092 | // End of try: | ||
| 1093 | |||
| 1094 | // Return statement must have exited already. | ||
| 1095 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_5_lambda ); | ||
| 1096 | return NULL; | ||
| 1097 | |||
| 1098 | |||
| 1099 | function_return_exit: | ||
| 1100 | // Function cleanup code if any. | ||
| 1101 | |||
| 1102 | |||
| 1103 | // Actual function exit with return value, making sure we did not make | ||
| 1104 | // the error status worse despite non-NULL return. | ||
| 1105 | CHECK_OBJECT( tmp_return_value ); | ||
| 1106 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 1107 | return tmp_return_value; | ||
| 1108 | } | ||
| 1109 | |||
| 1110 | |||
| 1111 | static PyObject *impl_pyanaconda$core$i18n$$$function_6_CP_( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 1112 | { | ||
| 1113 | // Preserve error status for checks | ||
| 1114 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 1115 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 1116 | #endif | ||
| 1117 | |||
| 1118 | // Local variable declarations. | ||
| 1119 | PyObject *par_msgctxt = python_pars[ 0 ]; | ||
| 1120 | PyObject *par_msgid = python_pars[ 1 ]; | ||
| 1121 | PyObject *par_msgid_plural = python_pars[ 2 ]; | ||
| 1122 | PyObject *par_n = python_pars[ 3 ]; | ||
| 1123 | PyObject *var_ctxid = NULL; | ||
| 1124 | PyObject *var_translation = NULL; | ||
| 1125 | struct Nuitka_FrameObject *frame_7c2a651ec1ba148f1aa253ff463e3423; | ||
| 1126 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 1127 | PyObject *exception_type = NULL; | ||
| 1128 | PyObject *exception_value = NULL; | ||
| 1129 | PyTracebackObject *exception_tb = NULL; | ||
| 1130 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 1131 | int tmp_res; | ||
| 1132 | PyObject *tmp_return_value = NULL; | ||
| 1133 | static struct Nuitka_FrameObject *cache_frame_7c2a651ec1ba148f1aa253ff463e3423 = NULL; | ||
| 1134 | PyObject *exception_keeper_type_1; | ||
| 1135 | PyObject *exception_keeper_value_1; | ||
| 1136 | PyTracebackObject *exception_keeper_tb_1; | ||
| 1137 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 1138 | |||
| 1139 | // Actual function body. | ||
| 1140 | // Tried code: | ||
| 1141 | MAKE_OR_REUSE_FRAME( cache_frame_7c2a651ec1ba148f1aa253ff463e3423, codeobj_7c2a651ec1ba148f1aa253ff463e3423, module_pyanaconda$core$i18n, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *) ); | ||
| 1142 | frame_7c2a651ec1ba148f1aa253ff463e3423 = cache_frame_7c2a651ec1ba148f1aa253ff463e3423; | ||
| 1143 | |||
| 1144 | // Push the new frame as the currently active one. | ||
| 1145 | pushFrameStack( frame_7c2a651ec1ba148f1aa253ff463e3423 ); | ||
| 1146 | |||
| 1147 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 1148 | assert( Py_REFCNT( frame_7c2a651ec1ba148f1aa253ff463e3423 ) == 2 ); // Frame stack | ||
| 1149 | |||
| 1150 | // Framed code: | ||
| 1151 | { | ||
| 1152 | PyObject *tmp_assign_source_1; | ||
| 1153 | PyObject *tmp_left_name_1; | ||
| 1154 | PyObject *tmp_right_name_1; | ||
| 1155 | PyObject *tmp_tuple_element_1; | ||
| 1156 | tmp_left_name_1 = const_str_digest_8f81abcc758bd7d49237bccd59957fbf; | ||
| 1157 | CHECK_OBJECT( par_msgctxt ); | ||
| 1158 | tmp_tuple_element_1 = par_msgctxt; | ||
| 1159 | tmp_right_name_1 = PyTuple_New( 2 ); | ||
| 1160 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 1161 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_1 ); | ||
| 1162 | CHECK_OBJECT( par_msgid ); | ||
| 1163 | tmp_tuple_element_1 = par_msgid; | ||
| 1164 | Py_INCREF( tmp_tuple_element_1 ); | ||
| 1165 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_1 ); | ||
| 1166 | tmp_assign_source_1 = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 1167 | Py_DECREF( tmp_right_name_1 ); | ||
| 1168 | if ( tmp_assign_source_1 == NULL ) | ||
| 1169 | { | ||
| 1170 | assert( ERROR_OCCURRED() ); | ||
| 1171 | |||
| 1172 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1173 | |||
| 1174 | |||
| 1175 | exception_lineno = 47; | ||
| 1176 | type_description_1 = "oooooo"; | ||
| 1177 | goto frame_exception_exit_1; | ||
| 1178 | } | ||
| 1179 | assert( var_ctxid == NULL ); | ||
| 1180 | var_ctxid = tmp_assign_source_1; | ||
| 1181 | } | ||
| 1182 | { | ||
| 1183 | PyObject *tmp_assign_source_2; | ||
| 1184 | PyObject *tmp_called_name_1; | ||
| 1185 | PyObject *tmp_mvar_value_1; | ||
| 1186 | PyObject *tmp_args_element_name_1; | ||
| 1187 | PyObject *tmp_args_element_name_2; | ||
| 1188 | PyObject *tmp_args_element_name_3; | ||
| 1189 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain_P_ ); | ||
| 1190 | |||
| 1191 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 1192 | { | ||
| 1193 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_P_ ); | ||
| 1194 | } | ||
| 1195 | |||
| 1196 | if ( tmp_mvar_value_1 == NULL ) | ||
| 1197 | { | ||
| 1198 | |||
| 1199 | exception_type = PyExc_NameError; | ||
| 1200 | Py_INCREF( exception_type ); | ||
| 1201 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "P_" ); | ||
| 1202 | exception_tb = NULL; | ||
| 1203 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1204 | CHAIN_EXCEPTION( exception_value ); | ||
| 1205 | |||
| 1206 | exception_lineno = 48; | ||
| 1207 | type_description_1 = "oooooo"; | ||
| 1208 | goto frame_exception_exit_1; | ||
| 1209 | } | ||
| 1210 | |||
| 1211 | tmp_called_name_1 = tmp_mvar_value_1; | ||
| 1212 | CHECK_OBJECT( var_ctxid ); | ||
| 1213 | tmp_args_element_name_1 = var_ctxid; | ||
| 1214 | CHECK_OBJECT( par_msgid_plural ); | ||
| 1215 | tmp_args_element_name_2 = par_msgid_plural; | ||
| 1216 | CHECK_OBJECT( par_n ); | ||
| 1217 | tmp_args_element_name_3 = par_n; | ||
| 1218 | frame_7c2a651ec1ba148f1aa253ff463e3423->m_frame.f_lineno = 48; | ||
| 1219 | { | ||
| 1220 | PyObject *call_args[] = { tmp_args_element_name_1, tmp_args_element_name_2, tmp_args_element_name_3 }; | ||
| 1221 | tmp_assign_source_2 = CALL_FUNCTION_WITH_ARGS3( tmp_called_name_1, call_args ); | ||
| 1222 | } | ||
| 1223 | |||
| 1224 | if ( tmp_assign_source_2 == NULL ) | ||
| 1225 | { | ||
| 1226 | assert( ERROR_OCCURRED() ); | ||
| 1227 | |||
| 1228 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1229 | |||
| 1230 | |||
| 1231 | exception_lineno = 48; | ||
| 1232 | type_description_1 = "oooooo"; | ||
| 1233 | goto frame_exception_exit_1; | ||
| 1234 | } | ||
| 1235 | assert( var_translation == NULL ); | ||
| 1236 | var_translation = tmp_assign_source_2; | ||
| 1237 | } | ||
| 1238 | { | ||
| 1239 | nuitka_bool tmp_condition_result_1; | ||
| 1240 | PyObject *tmp_compexpr_left_1; | ||
| 1241 | PyObject *tmp_compexpr_right_1; | ||
| 1242 | CHECK_OBJECT( var_translation ); | ||
| 1243 | tmp_compexpr_left_1 = var_translation; | ||
| 1244 | CHECK_OBJECT( var_ctxid ); | ||
| 1245 | tmp_compexpr_right_1 = var_ctxid; | ||
| 1246 | tmp_res = RICH_COMPARE_BOOL_EQ_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 1247 | if ( tmp_res == -1 ) | ||
| 1248 | { | ||
| 1249 | assert( ERROR_OCCURRED() ); | ||
| 1250 | |||
| 1251 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1252 | |||
| 1253 | |||
| 1254 | exception_lineno = 53; | ||
| 1255 | type_description_1 = "oooooo"; | ||
| 1256 | goto frame_exception_exit_1; | ||
| 1257 | } | ||
| 1258 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 1259 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 1260 | { | ||
| 1261 | goto branch_yes_1; | ||
| 1262 | } | ||
| 1263 | else | ||
| 1264 | { | ||
| 1265 | goto branch_no_1; | ||
| 1266 | } | ||
| 1267 | branch_yes_1:; | ||
| 1268 | CHECK_OBJECT( par_msgid ); | ||
| 1269 | tmp_return_value = par_msgid; | ||
| 1270 | Py_INCREF( tmp_return_value ); | ||
| 1271 | goto frame_return_exit_1; | ||
| 1272 | goto branch_end_1; | ||
| 1273 | branch_no_1:; | ||
| 1274 | CHECK_OBJECT( var_translation ); | ||
| 1275 | tmp_return_value = var_translation; | ||
| 1276 | Py_INCREF( tmp_return_value ); | ||
| 1277 | goto frame_return_exit_1; | ||
| 1278 | branch_end_1:; | ||
| 1279 | } | ||
| 1280 | |||
| 1281 | #if 0 | ||
| 1282 | RESTORE_FRAME_EXCEPTION( frame_7c2a651ec1ba148f1aa253ff463e3423 ); | ||
| 1283 | #endif | ||
| 1284 | |||
| 1285 | // Put the previous frame back on top. | ||
| 1286 | popFrameStack(); | ||
| 1287 | |||
| 1288 | goto frame_no_exception_1; | ||
| 1289 | |||
| 1290 | frame_return_exit_1:; | ||
| 1291 | #if 0 | ||
| 1292 | RESTORE_FRAME_EXCEPTION( frame_7c2a651ec1ba148f1aa253ff463e3423 ); | ||
| 1293 | #endif | ||
| 1294 | |||
| 1295 | // Put the previous frame back on top. | ||
| 1296 | popFrameStack(); | ||
| 1297 | |||
| 1298 | goto try_return_handler_1; | ||
| 1299 | |||
| 1300 | frame_exception_exit_1:; | ||
| 1301 | |||
| 1302 | #if 0 | ||
| 1303 | RESTORE_FRAME_EXCEPTION( frame_7c2a651ec1ba148f1aa253ff463e3423 ); | ||
| 1304 | #endif | ||
| 1305 | |||
| 1306 | if ( exception_tb == NULL ) | ||
| 1307 | { | ||
| 1308 | exception_tb = MAKE_TRACEBACK( frame_7c2a651ec1ba148f1aa253ff463e3423, exception_lineno ); | ||
| 1309 | } | ||
| 1310 | else if ( exception_tb->tb_frame != &frame_7c2a651ec1ba148f1aa253ff463e3423->m_frame ) | ||
| 1311 | { | ||
| 1312 | exception_tb = ADD_TRACEBACK( exception_tb, frame_7c2a651ec1ba148f1aa253ff463e3423, exception_lineno ); | ||
| 1313 | } | ||
| 1314 | |||
| 1315 | // Attachs locals to frame if any. | ||
| 1316 | Nuitka_Frame_AttachLocals( | ||
| 1317 | (struct Nuitka_FrameObject *)frame_7c2a651ec1ba148f1aa253ff463e3423, | ||
| 1318 | type_description_1, | ||
| 1319 | par_msgctxt, | ||
| 1320 | par_msgid, | ||
| 1321 | par_msgid_plural, | ||
| 1322 | par_n, | ||
| 1323 | var_ctxid, | ||
| 1324 | var_translation | ||
| 1325 | ); | ||
| 1326 | |||
| 1327 | |||
| 1328 | // Release cached frame. | ||
| 1329 | if ( frame_7c2a651ec1ba148f1aa253ff463e3423 == cache_frame_7c2a651ec1ba148f1aa253ff463e3423 ) | ||
| 1330 | { | ||
| 1331 | Py_DECREF( frame_7c2a651ec1ba148f1aa253ff463e3423 ); | ||
| 1332 | } | ||
| 1333 | cache_frame_7c2a651ec1ba148f1aa253ff463e3423 = NULL; | ||
| 1334 | |||
| 1335 | assertFrameObject( frame_7c2a651ec1ba148f1aa253ff463e3423 ); | ||
| 1336 | |||
| 1337 | // Put the previous frame back on top. | ||
| 1338 | popFrameStack(); | ||
| 1339 | |||
| 1340 | // Return the error. | ||
| 1341 | goto try_except_handler_1; | ||
| 1342 | |||
| 1343 | frame_no_exception_1:; | ||
| 1344 | // tried codes exits in all cases | ||
| 1345 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_6_CP_ ); | ||
| 1346 | return NULL; | ||
| 1347 | // Return handler code: | ||
| 1348 | try_return_handler_1:; | ||
| 1349 | CHECK_OBJECT( (PyObject *)par_msgctxt ); | ||
| 1350 | Py_DECREF( par_msgctxt ); | ||
| 1351 | par_msgctxt = NULL; | ||
| 1352 | |||
| 1353 | CHECK_OBJECT( (PyObject *)par_msgid ); | ||
| 1354 | Py_DECREF( par_msgid ); | ||
| 1355 | par_msgid = NULL; | ||
| 1356 | |||
| 1357 | CHECK_OBJECT( (PyObject *)par_msgid_plural ); | ||
| 1358 | Py_DECREF( par_msgid_plural ); | ||
| 1359 | par_msgid_plural = NULL; | ||
| 1360 | |||
| 1361 | CHECK_OBJECT( (PyObject *)par_n ); | ||
| 1362 | Py_DECREF( par_n ); | ||
| 1363 | par_n = NULL; | ||
| 1364 | |||
| 1365 | CHECK_OBJECT( (PyObject *)var_ctxid ); | ||
| 1366 | Py_DECREF( var_ctxid ); | ||
| 1367 | var_ctxid = NULL; | ||
| 1368 | |||
| 1369 | CHECK_OBJECT( (PyObject *)var_translation ); | ||
| 1370 | Py_DECREF( var_translation ); | ||
| 1371 | var_translation = NULL; | ||
| 1372 | |||
| 1373 | goto function_return_exit; | ||
| 1374 | // Exception handler code: | ||
| 1375 | try_except_handler_1:; | ||
| 1376 | exception_keeper_type_1 = exception_type; | ||
| 1377 | exception_keeper_value_1 = exception_value; | ||
| 1378 | exception_keeper_tb_1 = exception_tb; | ||
| 1379 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1380 | exception_type = NULL; | ||
| 1381 | exception_value = NULL; | ||
| 1382 | exception_tb = NULL; | ||
| 1383 | exception_lineno = 0; | ||
| 1384 | |||
| 1385 | CHECK_OBJECT( (PyObject *)par_msgctxt ); | ||
| 1386 | Py_DECREF( par_msgctxt ); | ||
| 1387 | par_msgctxt = NULL; | ||
| 1388 | |||
| 1389 | CHECK_OBJECT( (PyObject *)par_msgid ); | ||
| 1390 | Py_DECREF( par_msgid ); | ||
| 1391 | par_msgid = NULL; | ||
| 1392 | |||
| 1393 | CHECK_OBJECT( (PyObject *)par_msgid_plural ); | ||
| 1394 | Py_DECREF( par_msgid_plural ); | ||
| 1395 | par_msgid_plural = NULL; | ||
| 1396 | |||
| 1397 | CHECK_OBJECT( (PyObject *)par_n ); | ||
| 1398 | Py_DECREF( par_n ); | ||
| 1399 | par_n = NULL; | ||
| 1400 | |||
| 1401 | Py_XDECREF( var_ctxid ); | ||
| 1402 | var_ctxid = NULL; | ||
| 1403 | |||
| 1404 | Py_XDECREF( var_translation ); | ||
| 1405 | var_translation = NULL; | ||
| 1406 | |||
| 1407 | // Re-raise. | ||
| 1408 | exception_type = exception_keeper_type_1; | ||
| 1409 | exception_value = exception_keeper_value_1; | ||
| 1410 | exception_tb = exception_keeper_tb_1; | ||
| 1411 | exception_lineno = exception_keeper_lineno_1; | ||
| 1412 | |||
| 1413 | goto function_exception_exit; | ||
| 1414 | // End of try: | ||
| 1415 | |||
| 1416 | // Return statement must have exited already. | ||
| 1417 | NUITKA_CANNOT_GET_HERE( pyanaconda$core$i18n$$$function_6_CP_ ); | ||
| 1418 | return NULL; | ||
| 1419 | |||
| 1420 | function_exception_exit: | ||
| 1421 | assert( exception_type ); | ||
| 1422 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1423 | |||
| 1424 | return NULL; | ||
| 1425 | |||
| 1426 | function_return_exit: | ||
| 1427 | // Function cleanup code if any. | ||
| 1428 | |||
| 1429 | |||
| 1430 | // Actual function exit with return value, making sure we did not make | ||
| 1431 | // the error status worse despite non-NULL return. | ||
| 1432 | CHECK_OBJECT( tmp_return_value ); | ||
| 1433 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 1434 | return tmp_return_value; | ||
| 1435 | } | ||
| 1436 | |||
| 1437 | |||
| 1438 | |||
| 1439 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_1_lambda( ) | ||
| 1440 | { | ||
| 1441 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1442 | impl_pyanaconda$core$i18n$$$function_1_lambda, | ||
| 1443 | const_str_angle_lambda, | ||
| 1444 | #if PYTHON_VERSION >= 300 | ||
| 1445 | NULL, | ||
| 1446 | #endif | ||
| 1447 | codeobj_f730620f5ee989aac193fa77c67d6f4a, | ||
| 1448 | NULL, | ||
| 1449 | #if PYTHON_VERSION >= 300 | ||
| 1450 | NULL, | ||
| 1451 | NULL, | ||
| 1452 | #endif | ||
| 1453 | module_pyanaconda$core$i18n, | ||
| 1454 | NULL, | ||
| 1455 | 0 | ||
| 1456 | ); | ||
| 1457 | |||
| 1458 | return (PyObject *)result; | ||
| 1459 | } | ||
| 1460 | |||
| 1461 | |||
| 1462 | |||
| 1463 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_2_lambda( ) | ||
| 1464 | { | ||
| 1465 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1466 | impl_pyanaconda$core$i18n$$$function_2_lambda, | ||
| 1467 | const_str_angle_lambda, | ||
| 1468 | #if PYTHON_VERSION >= 300 | ||
| 1469 | NULL, | ||
| 1470 | #endif | ||
| 1471 | codeobj_d765fe45db9ef7595d660bb43896d023, | ||
| 1472 | NULL, | ||
| 1473 | #if PYTHON_VERSION >= 300 | ||
| 1474 | NULL, | ||
| 1475 | NULL, | ||
| 1476 | #endif | ||
| 1477 | module_pyanaconda$core$i18n, | ||
| 1478 | NULL, | ||
| 1479 | 0 | ||
| 1480 | ); | ||
| 1481 | |||
| 1482 | return (PyObject *)result; | ||
| 1483 | } | ||
| 1484 | |||
| 1485 | |||
| 1486 | |||
| 1487 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_3_lambda( ) | ||
| 1488 | { | ||
| 1489 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1490 | impl_pyanaconda$core$i18n$$$function_3_lambda, | ||
| 1491 | const_str_angle_lambda, | ||
| 1492 | #if PYTHON_VERSION >= 300 | ||
| 1493 | NULL, | ||
| 1494 | #endif | ||
| 1495 | codeobj_fdd80ad7539722ce2ee1767ffdb93d5a, | ||
| 1496 | NULL, | ||
| 1497 | #if PYTHON_VERSION >= 300 | ||
| 1498 | NULL, | ||
| 1499 | NULL, | ||
| 1500 | #endif | ||
| 1501 | module_pyanaconda$core$i18n, | ||
| 1502 | NULL, | ||
| 1503 | 0 | ||
| 1504 | ); | ||
| 1505 | |||
| 1506 | return (PyObject *)result; | ||
| 1507 | } | ||
| 1508 | |||
| 1509 | |||
| 1510 | |||
| 1511 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_4_C_( ) | ||
| 1512 | { | ||
| 1513 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1514 | impl_pyanaconda$core$i18n$$$function_4_C_, | ||
| 1515 | const_str_plain_C_, | ||
| 1516 | #if PYTHON_VERSION >= 300 | ||
| 1517 | NULL, | ||
| 1518 | #endif | ||
| 1519 | codeobj_53cbd7eb6b277b0842ed240aae366bf7, | ||
| 1520 | NULL, | ||
| 1521 | #if PYTHON_VERSION >= 300 | ||
| 1522 | NULL, | ||
| 1523 | NULL, | ||
| 1524 | #endif | ||
| 1525 | module_pyanaconda$core$i18n, | ||
| 1526 | NULL, | ||
| 1527 | 0 | ||
| 1528 | ); | ||
| 1529 | |||
| 1530 | return (PyObject *)result; | ||
| 1531 | } | ||
| 1532 | |||
| 1533 | |||
| 1534 | |||
| 1535 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_5_lambda( ) | ||
| 1536 | { | ||
| 1537 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1538 | impl_pyanaconda$core$i18n$$$function_5_lambda, | ||
| 1539 | const_str_angle_lambda, | ||
| 1540 | #if PYTHON_VERSION >= 300 | ||
| 1541 | NULL, | ||
| 1542 | #endif | ||
| 1543 | codeobj_480615cbf52dc323ba5e9ee5031489a0, | ||
| 1544 | NULL, | ||
| 1545 | #if PYTHON_VERSION >= 300 | ||
| 1546 | NULL, | ||
| 1547 | NULL, | ||
| 1548 | #endif | ||
| 1549 | module_pyanaconda$core$i18n, | ||
| 1550 | NULL, | ||
| 1551 | 0 | ||
| 1552 | ); | ||
| 1553 | |||
| 1554 | return (PyObject *)result; | ||
| 1555 | } | ||
| 1556 | |||
| 1557 | |||
| 1558 | |||
| 1559 | static PyObject *MAKE_FUNCTION_pyanaconda$core$i18n$$$function_6_CP_( ) | ||
| 1560 | { | ||
| 1561 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 1562 | impl_pyanaconda$core$i18n$$$function_6_CP_, | ||
| 1563 | const_str_plain_CP_, | ||
| 1564 | #if PYTHON_VERSION >= 300 | ||
| 1565 | NULL, | ||
| 1566 | #endif | ||
| 1567 | codeobj_7c2a651ec1ba148f1aa253ff463e3423, | ||
| 1568 | NULL, | ||
| 1569 | #if PYTHON_VERSION >= 300 | ||
| 1570 | NULL, | ||
| 1571 | NULL, | ||
| 1572 | #endif | ||
| 1573 | module_pyanaconda$core$i18n, | ||
| 1574 | NULL, | ||
| 1575 | 0 | ||
| 1576 | ); | ||
| 1577 | |||
| 1578 | return (PyObject *)result; | ||
| 1579 | } | ||
| 1580 | |||
| 1581 | |||
| 1582 | |||
| 1583 | #if PYTHON_VERSION >= 300 | ||
| 1584 | static struct PyModuleDef mdef_pyanaconda$core$i18n = | ||
| 1585 | { | ||
| 1586 | PyModuleDef_HEAD_INIT, | ||
| 1587 | "pyanaconda.core.i18n", | ||
| 1588 | NULL, /* m_doc */ | ||
| 1589 | -1, /* m_size */ | ||
| 1590 | NULL, /* m_methods */ | ||
| 1591 | NULL, /* m_reload */ | ||
| 1592 | NULL, /* m_traverse */ | ||
| 1593 | NULL, /* m_clear */ | ||
| 1594 | NULL, /* m_free */ | ||
| 1595 | }; | ||
| 1596 | #endif | ||
| 1597 | |||
| 1598 | extern PyObject *const_str_plain___compiled__; | ||
| 1599 | |||
| 1600 | extern PyObject *const_str_plain___package__; | ||
| 1601 | |||
| 1602 | #if PYTHON_VERSION >= 300 | ||
| 1603 | extern PyObject *const_str_dot; | ||
| 1604 | extern PyObject *const_str_plain___loader__; | ||
| 1605 | #endif | ||
| 1606 | |||
| 1607 | #if PYTHON_VERSION >= 340 | ||
| 1608 | extern PyObject *const_str_plain___spec__; | ||
| 1609 | extern PyObject *const_str_plain__initializing; | ||
| 1610 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 1611 | #endif | ||
| 1612 | |||
| 1613 | extern void _initCompiledCellType(); | ||
| 1614 | extern void _initCompiledGeneratorType(); | ||
| 1615 | extern void _initCompiledFunctionType(); | ||
| 1616 | extern void _initCompiledMethodType(); | ||
| 1617 | extern void _initCompiledFrameType(); | ||
| 1618 | #if PYTHON_VERSION >= 350 | ||
| 1619 | extern void _initCompiledCoroutineTypes(); | ||
| 1620 | #endif | ||
| 1621 | #if PYTHON_VERSION >= 360 | ||
| 1622 | extern void _initCompiledAsyncgenTypes(); | ||
| 1623 | #endif | ||
| 1624 | |||
| 1625 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 1626 | |||
| 1627 | // The exported interface to CPython. On import of the module, this function | ||
| 1628 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 1629 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 1630 | |||
| 1631 | MOD_INIT_DECL( pyanaconda$core$i18n ) | ||
| 1632 | { | ||
| 1633 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 1634 | static bool _init_done = false; | ||
| 1635 | |||
| 1636 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 1637 | if ( _init_done ) | ||
| 1638 | { | ||
| 1639 | return MOD_RETURN_VALUE( module_pyanaconda$core$i18n ); | ||
| 1640 | } | ||
| 1641 | else | ||
| 1642 | { | ||
| 1643 | _init_done = true; | ||
| 1644 | } | ||
| 1645 | #endif | ||
| 1646 | |||
| 1647 | #ifdef _NUITKA_MODULE | ||
| 1648 | // In case of a stand alone extension module, need to call initialization | ||
| 1649 | // the init here because that's the first and only time we are going to get | ||
| 1650 | // called here. | ||
| 1651 | |||
| 1652 | // Initialize the constant values used. | ||
| 1653 | _initBuiltinModule(); | ||
| 1654 | createGlobalConstants(); | ||
| 1655 | |||
| 1656 | /* Initialize the compiled types of Nuitka. */ | ||
| 1657 | _initCompiledCellType(); | ||
| 1658 | _initCompiledGeneratorType(); | ||
| 1659 | _initCompiledFunctionType(); | ||
| 1660 | _initCompiledMethodType(); | ||
| 1661 | _initCompiledFrameType(); | ||
| 1662 | #if PYTHON_VERSION >= 350 | ||
| 1663 | _initCompiledCoroutineTypes(); | ||
| 1664 | #endif | ||
| 1665 | #if PYTHON_VERSION >= 360 | ||
| 1666 | _initCompiledAsyncgenTypes(); | ||
| 1667 | #endif | ||
| 1668 | |||
| 1669 | #if PYTHON_VERSION < 300 | ||
| 1670 | _initSlotCompare(); | ||
| 1671 | #endif | ||
| 1672 | #if PYTHON_VERSION >= 270 | ||
| 1673 | _initSlotIternext(); | ||
| 1674 | #endif | ||
| 1675 | |||
| 1676 | patchBuiltinModule(); | ||
| 1677 | patchTypeComparison(); | ||
| 1678 | |||
| 1679 | // Enable meta path based loader if not already done. | ||
| 1680 | #ifdef _NUITKA_TRACE | ||
| 1681 | puts("pyanaconda.core.i18n: Calling setupMetaPathBasedLoader()."); | ||
| 1682 | #endif | ||
| 1683 | setupMetaPathBasedLoader(); | ||
| 1684 | |||
| 1685 | #if PYTHON_VERSION >= 300 | ||
| 1686 | patchInspectModule(); | ||
| 1687 | #endif | ||
| 1688 | |||
| 1689 | #endif | ||
| 1690 | |||
| 1691 | /* The constants only used by this module are created now. */ | ||
| 1692 | #ifdef _NUITKA_TRACE | ||
| 1693 | puts("pyanaconda.core.i18n: Calling createModuleConstants()."); | ||
| 1694 | #endif | ||
| 1695 | createModuleConstants(); | ||
| 1696 | |||
| 1697 | /* The code objects used by this module are created now. */ | ||
| 1698 | #ifdef _NUITKA_TRACE | ||
| 1699 | puts("pyanaconda.core.i18n: Calling createModuleCodeObjects()."); | ||
| 1700 | #endif | ||
| 1701 | createModuleCodeObjects(); | ||
| 1702 | |||
| 1703 | // puts( "in initpyanaconda$core$i18n" ); | ||
| 1704 | |||
| 1705 | // Create the module object first. There are no methods initially, all are | ||
| 1706 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 1707 | // set at this time, as it could not contain NUL characters this way, they | ||
| 1708 | // are instead set in early module code. No "self" for modules, we have no | ||
| 1709 | // use for it. | ||
| 1710 | #if PYTHON_VERSION < 300 | ||
| 1711 | module_pyanaconda$core$i18n = Py_InitModule4( | ||
| 1712 | "pyanaconda.core.i18n", // Module Name | ||
| 1713 | NULL, // No methods initially, all are added | ||
| 1714 | // dynamically in actual module code only. | ||
| 1715 | NULL, // No "__doc__" is initially set, as it could | ||
| 1716 | // not contain NUL this way, added early in | ||
| 1717 | // actual code. | ||
| 1718 | NULL, // No self for modules, we don't use it. | ||
| 1719 | PYTHON_API_VERSION | ||
| 1720 | ); | ||
| 1721 | #else | ||
| 1722 | |||
| 1723 | module_pyanaconda$core$i18n = PyModule_Create( &mdef_pyanaconda$core$i18n ); | ||
| 1724 | #endif | ||
| 1725 | |||
| 1726 | moduledict_pyanaconda$core$i18n = MODULE_DICT( module_pyanaconda$core$i18n ); | ||
| 1727 | |||
| 1728 | // Set __compiled__ to what it we know. | ||
| 1729 | UPDATE_STRING_DICT1( | ||
| 1730 | moduledict_pyanaconda$core$i18n, | ||
| 1731 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 1732 | Nuitka_dunder_compiled_value | ||
| 1733 | ); | ||
| 1734 | |||
| 1735 | // Update "__package__" value to what it ought to be. | ||
| 1736 | { | ||
| 1737 | #if 0 | ||
| 1738 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 1739 | |||
| 1740 | UPDATE_STRING_DICT1( | ||
| 1741 | moduledict_pyanaconda$core$i18n, | ||
| 1742 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 1743 | module_name | ||
| 1744 | ); | ||
| 1745 | #else | ||
| 1746 | |||
| 1747 | #if PYTHON_VERSION < 300 | ||
| 1748 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 1749 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 1750 | |||
| 1751 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 1752 | |||
| 1753 | if ( last_dot != NULL ) | ||
| 1754 | { | ||
| 1755 | UPDATE_STRING_DICT1( | ||
| 1756 | moduledict_pyanaconda$core$i18n, | ||
| 1757 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 1758 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 1759 | ); | ||
| 1760 | } | ||
| 1761 | #else | ||
| 1762 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 1763 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 1764 | |||
| 1765 | if ( dot_index != -1 ) | ||
| 1766 | { | ||
| 1767 | UPDATE_STRING_DICT1( | ||
| 1768 | moduledict_pyanaconda$core$i18n, | ||
| 1769 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 1770 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 1771 | ); | ||
| 1772 | } | ||
| 1773 | #endif | ||
| 1774 | #endif | ||
| 1775 | } | ||
| 1776 | |||
| 1777 | CHECK_OBJECT( module_pyanaconda$core$i18n ); | ||
| 1778 | |||
| 1779 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 1780 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 1781 | #if PYTHON_VERSION >= 300 | ||
| 1782 | { | ||
| 1783 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_6807157bfb6aeb31712b82d637fd949a, module_pyanaconda$core$i18n ); | ||
| 1784 | |||
| 1785 | assert( r != -1 ); | ||
| 1786 | } | ||
| 1787 | #endif | ||
| 1788 | |||
| 1789 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 1790 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 1791 | // before the frame object is allocated, or else it may fail. | ||
| 1792 | |||
| 1793 | if ( GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 1794 | { | ||
| 1795 | PyObject *value = (PyObject *)builtin_module; | ||
| 1796 | |||
| 1797 | // Check if main module, not a dict then but the module itself. | ||
| 1798 | #if !defined(_NUITKA_EXE) || !0 | ||
| 1799 | value = PyModule_GetDict( value ); | ||
| 1800 | #endif | ||
| 1801 | |||
| 1802 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 1803 | } | ||
| 1804 | |||
| 1805 | #if PYTHON_VERSION >= 300 | ||
| 1806 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 1807 | #endif | ||
| 1808 | |||
| 1809 | #if PYTHON_VERSION >= 340 | ||
| 1810 | // Set the "__spec__" value | ||
| 1811 | |||
| 1812 | #if 0 | ||
| 1813 | // Main modules just get "None" as spec. | ||
| 1814 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 1815 | #else | ||
| 1816 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 1817 | { | ||
| 1818 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 1819 | CHECK_OBJECT( bootstrap_module ); | ||
| 1820 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 1821 | Py_DECREF( bootstrap_module ); | ||
| 1822 | |||
| 1823 | PyObject *args[] = { | ||
| 1824 | GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 1825 | (PyObject *)&Nuitka_Loader_Type | ||
| 1826 | }; | ||
| 1827 | |||
| 1828 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 1829 | module_spec_class, | ||
| 1830 | args | ||
| 1831 | ); | ||
| 1832 | Py_DECREF( module_spec_class ); | ||
| 1833 | |||
| 1834 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 1835 | CHECK_OBJECT( spec_value ); | ||
| 1836 | |||
| 1837 | // For packages set the submodule search locations as well, even if to empty | ||
| 1838 | // list, so investigating code will consider it a package. | ||
| 1839 | #if 0 | ||
| 1840 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 1841 | #endif | ||
| 1842 | |||
| 1843 | // Mark the execution in the "__spec__" value. | ||
| 1844 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 1845 | |||
| 1846 | UPDATE_STRING_DICT1( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 1847 | } | ||
| 1848 | #endif | ||
| 1849 | #endif | ||
| 1850 | |||
| 1851 | // Temp variables if any | ||
| 1852 | struct Nuitka_FrameObject *frame_d7b69a6e2471cfb718b957956bfa223e; | ||
| 1853 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 1854 | bool tmp_result; | ||
| 1855 | PyObject *exception_type = NULL; | ||
| 1856 | PyObject *exception_value = NULL; | ||
| 1857 | PyTracebackObject *exception_tb = NULL; | ||
| 1858 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 1859 | |||
| 1860 | // Module code. | ||
| 1861 | { | ||
| 1862 | PyObject *tmp_assign_source_1; | ||
| 1863 | tmp_assign_source_1 = Py_None; | ||
| 1864 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 1865 | } | ||
| 1866 | { | ||
| 1867 | PyObject *tmp_assign_source_2; | ||
| 1868 | tmp_assign_source_2 = module_filename_obj; | ||
| 1869 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 1870 | } | ||
| 1871 | // Frame without reuse. | ||
| 1872 | frame_d7b69a6e2471cfb718b957956bfa223e = MAKE_MODULE_FRAME( codeobj_d7b69a6e2471cfb718b957956bfa223e, module_pyanaconda$core$i18n ); | ||
| 1873 | |||
| 1874 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 1875 | // owning it. | ||
| 1876 | pushFrameStack( frame_d7b69a6e2471cfb718b957956bfa223e ); | ||
| 1877 | assert( Py_REFCNT( frame_d7b69a6e2471cfb718b957956bfa223e ) == 2 ); | ||
| 1878 | |||
| 1879 | // Framed code: | ||
| 1880 | { | ||
| 1881 | PyObject *tmp_assattr_name_1; | ||
| 1882 | PyObject *tmp_assattr_target_1; | ||
| 1883 | PyObject *tmp_mvar_value_1; | ||
| 1884 | tmp_assattr_name_1 = module_filename_obj; | ||
| 1885 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1886 | |||
| 1887 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 1888 | { | ||
| 1889 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1890 | } | ||
| 1891 | |||
| 1892 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 1893 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 1894 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 1895 | if ( tmp_result == false ) | ||
| 1896 | { | ||
| 1897 | assert( ERROR_OCCURRED() ); | ||
| 1898 | |||
| 1899 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1900 | |||
| 1901 | |||
| 1902 | exception_lineno = 1; | ||
| 1903 | |||
| 1904 | goto frame_exception_exit_1; | ||
| 1905 | } | ||
| 1906 | } | ||
| 1907 | { | ||
| 1908 | PyObject *tmp_assattr_name_2; | ||
| 1909 | PyObject *tmp_assattr_target_2; | ||
| 1910 | PyObject *tmp_mvar_value_2; | ||
| 1911 | tmp_assattr_name_2 = Py_True; | ||
| 1912 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1913 | |||
| 1914 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 1915 | { | ||
| 1916 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1917 | } | ||
| 1918 | |||
| 1919 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 1920 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 1921 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 1922 | if ( tmp_result == false ) | ||
| 1923 | { | ||
| 1924 | assert( ERROR_OCCURRED() ); | ||
| 1925 | |||
| 1926 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1927 | |||
| 1928 | |||
| 1929 | exception_lineno = 1; | ||
| 1930 | |||
| 1931 | goto frame_exception_exit_1; | ||
| 1932 | } | ||
| 1933 | } | ||
| 1934 | { | ||
| 1935 | PyObject *tmp_assign_source_3; | ||
| 1936 | tmp_assign_source_3 = Py_None; | ||
| 1937 | UPDATE_STRING_DICT0( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 1938 | } | ||
| 1939 | { | ||
| 1940 | PyObject *tmp_assign_source_4; | ||
| 1941 | tmp_assign_source_4 = LIST_COPY( const_list_830d0364cfa54296e4e01dcf682d4b05_list ); | ||
| 1942 | UPDATE_STRING_DICT1( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___all__, tmp_assign_source_4 ); | ||
| 1943 | } | ||
| 1944 | { | ||
| 1945 | PyObject *tmp_assign_source_5; | ||
| 1946 | PyObject *tmp_name_name_1; | ||
| 1947 | PyObject *tmp_globals_name_1; | ||
| 1948 | PyObject *tmp_locals_name_1; | ||
| 1949 | PyObject *tmp_fromlist_name_1; | ||
| 1950 | PyObject *tmp_level_name_1; | ||
| 1951 | tmp_name_name_1 = const_str_plain_gettext; | ||
| 1952 | tmp_globals_name_1 = (PyObject *)moduledict_pyanaconda$core$i18n; | ||
| 1953 | tmp_locals_name_1 = Py_None; | ||
| 1954 | tmp_fromlist_name_1 = Py_None; | ||
| 1955 | tmp_level_name_1 = const_int_0; | ||
| 1956 | frame_d7b69a6e2471cfb718b957956bfa223e->m_frame.f_lineno = 22; | ||
| 1957 | tmp_assign_source_5 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 1958 | if ( tmp_assign_source_5 == NULL ) | ||
| 1959 | { | ||
| 1960 | assert( ERROR_OCCURRED() ); | ||
| 1961 | |||
| 1962 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1963 | |||
| 1964 | |||
| 1965 | exception_lineno = 22; | ||
| 1966 | |||
| 1967 | goto frame_exception_exit_1; | ||
| 1968 | } | ||
| 1969 | UPDATE_STRING_DICT1( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain_gettext, tmp_assign_source_5 ); | ||
| 1970 | } | ||
| 1971 | |||
| 1972 | // Restore frame exception if necessary. | ||
| 1973 | #if 0 | ||
| 1974 | RESTORE_FRAME_EXCEPTION( frame_d7b69a6e2471cfb718b957956bfa223e ); | ||
| 1975 | #endif | ||
| 1976 | popFrameStack(); | ||
| 1977 | |||
| 1978 | assertFrameObject( frame_d7b69a6e2471cfb718b957956bfa223e ); | ||
| 1979 | |||
| 1980 | goto frame_no_exception_1; | ||
| 1981 | |||
| 1982 | frame_exception_exit_1:; | ||
| 1983 | #if 0 | ||
| 1984 | RESTORE_FRAME_EXCEPTION( frame_d7b69a6e2471cfb718b957956bfa223e ); | ||
| 1985 | #endif | ||
| 1986 | |||
| 1987 | if ( exception_tb == NULL ) | ||
| 1988 | { | ||
| 1989 | exception_tb = MAKE_TRACEBACK( frame_d7b69a6e2471cfb718b957956bfa223e, exception_lineno ); | ||
| 1990 | } | ||
| 1991 | else if ( exception_tb->tb_frame != &frame_d7b69a6e2471cfb718b957956bfa223e->m_frame ) | ||
| 1992 | { | ||
| 1993 | exception_tb = ADD_TRACEBACK( exception_tb, frame_d7b69a6e2471cfb718b957956bfa223e, exception_lineno ); | ||
| 1994 | } | ||
| 1995 | |||
| 1996 | // Put the previous frame back on top. | ||
| 1997 | popFrameStack(); | ||
| 1998 | |||
| 1999 | // Return the error. | ||
| 2000 | goto module_exception_exit; | ||
| 2001 | |||
| 2002 | frame_no_exception_1:; | ||
| 2003 | { | ||
| 2004 | PyObject *tmp_assign_source_6; | ||
| 2005 | tmp_assign_source_6 = MAKE_FUNCTION_pyanaconda$core$i18n$$$function_1_lambda( ); | ||
| 2006 | |||
| 2007 | |||
| 2008 | |||
| 2009 | UPDATE_STRING_DICT1( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain_N_, tmp_assign_source_6 ); | ||
| 2010 | } | ||
| 2011 | { | ||
| 2012 | PyObject *tmp_assign_source_7; | ||
| 2013 | tmp_assign_source_7 = MAKE_FUNCTION_pyanaconda$core$i18n$$$function_2_lambda( ); | ||
| 2014 | |||
| 2015 | |||
| 2016 | |||
| 2017 | UPDATE_STRING_DICT1( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain__, tmp_assign_source_7 ); | ||
| 2018 | } | ||
| 2019 | { | ||
| 2020 | PyObject *tmp_assign_source_8; | ||
| 2021 | tmp_assign_source_8 = MAKE_FUNCTION_pyanaconda$core$i18n$$$function_3_lambda( ); | ||
| 2022 | |||
| 2023 | |||
| 2024 | |||
| 2025 | UPDATE_STRING_DICT1( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain_P_, tmp_assign_source_8 ); | ||
| 2026 | } | ||
| 2027 | { | ||
| 2028 | PyObject *tmp_assign_source_9; | ||
| 2029 | tmp_assign_source_9 = MAKE_FUNCTION_pyanaconda$core$i18n$$$function_4_C_( ); | ||
| 2030 | |||
| 2031 | |||
| 2032 | |||
| 2033 | UPDATE_STRING_DICT1( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain_C_, tmp_assign_source_9 ); | ||
| 2034 | } | ||
| 2035 | { | ||
| 2036 | PyObject *tmp_assign_source_10; | ||
| 2037 | tmp_assign_source_10 = MAKE_FUNCTION_pyanaconda$core$i18n$$$function_5_lambda( ); | ||
| 2038 | |||
| 2039 | |||
| 2040 | |||
| 2041 | UPDATE_STRING_DICT1( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain_CN_, tmp_assign_source_10 ); | ||
| 2042 | } | ||
| 2043 | { | ||
| 2044 | PyObject *tmp_assign_source_11; | ||
| 2045 | tmp_assign_source_11 = MAKE_FUNCTION_pyanaconda$core$i18n$$$function_6_CP_( ); | ||
| 2046 | |||
| 2047 | |||
| 2048 | |||
| 2049 | UPDATE_STRING_DICT1( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain_CP_, tmp_assign_source_11 ); | ||
| 2050 | } | ||
| 2051 | |||
| 2052 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 2053 | #if 0 && 0 | ||
| 2054 | { | ||
| 2055 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_pyanaconda$core$i18n, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 2056 | |||
| 2057 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 2058 | { | ||
| 2059 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 2060 | |||
| 2061 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 2062 | CHECK_OBJECT( path_importer_cache ); | ||
| 2063 | |||
| 2064 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 2065 | assert( res == 0 ); | ||
| 2066 | } | ||
| 2067 | } | ||
| 2068 | #endif | ||
| 2069 | #endif | ||
| 2070 | |||
| 2071 | return MOD_RETURN_VALUE( module_pyanaconda$core$i18n ); | ||
| 2072 | module_exception_exit: | ||
| 2073 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 2074 | return MOD_RETURN_VALUE( NULL ); | ||
| 2075 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.pyanaconda.core.i18n.o deleted (index f041414..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.pyanaconda.core.o deleted (index 8f02550..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.pyanaconda.o deleted (index b99e44f..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.pyanaconda.product.c deleted (index dbd154a..0000000) | |||
| 1 | /* Generated code for Python module 'pyanaconda.product' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_pyanaconda$product" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_pyanaconda$product; | ||
| 31 | PyDictObject *moduledict_pyanaconda$product; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | static PyObject *const_str_plain_ANACONDA_PRODUCTARCH; | ||
| 35 | static PyObject *const_str_plain_set; | ||
| 36 | extern PyObject *const_str_plain_index; | ||
| 37 | extern PyObject *const_str_plain___spec__; | ||
| 38 | extern PyObject *const_str_plain_UUID; | ||
| 39 | static PyObject *const_str_plain_PRODBUILDPATH; | ||
| 40 | static PyObject *const_str_plain_ANACONDA_PRODUCTVARIANT; | ||
| 41 | extern PyObject *const_str_plain___file__; | ||
| 42 | extern PyObject *const_str_plain_productVersion; | ||
| 43 | static PyObject *const_str_plain_ANACONDA_BUGURL; | ||
| 44 | static PyObject *const_str_digest_f259902e5c4e3accbfad88a2489e5d77; | ||
| 45 | extern PyObject *const_int_neg_1; | ||
| 46 | static PyObject *const_tuple_str_plain___tuple; | ||
| 47 | static PyObject *const_str_plain_productVariant; | ||
| 48 | static PyObject *const_str_plain_add_section; | ||
| 49 | extern PyObject *const_str_plain_os; | ||
| 50 | static PyObject *const_str_plain_Arch; | ||
| 51 | static PyObject *const_str_plain_Version; | ||
| 52 | extern PyObject *const_str_plain_read; | ||
| 53 | static PyObject *const_tuple_str_plain_ANACONDA_ISFINAL_str_plain_false_tuple; | ||
| 54 | static PyObject *const_str_plain_false; | ||
| 55 | extern PyObject *const_str_plain___doc__; | ||
| 56 | extern PyObject *const_str_dot; | ||
| 57 | extern PyObject *const_str_plain_environ; | ||
| 58 | extern PyObject *const_str_plain_productName; | ||
| 59 | static PyObject *const_str_plain_ANACONDA_PRODUCTNAME; | ||
| 60 | static PyObject *const_tuple_str_plain_Main_str_plain_IsFinal_tuple; | ||
| 61 | static PyObject *const_str_digest_299dc5a63bc229b8fc193ff2445a947f; | ||
| 62 | static PyObject *const_str_plain_ConfigParser; | ||
| 63 | static PyObject *const_tuple_str_plain_ANACONDA_PRODUCTVARIANT_str_empty_tuple; | ||
| 64 | static PyObject *const_tuple_str_plain_Main_str_plain_Product_tuple; | ||
| 65 | extern PyObject *const_tuple_str_dot_tuple; | ||
| 66 | extern PyObject *const_tuple_empty; | ||
| 67 | extern PyObject *const_str_plain_name; | ||
| 68 | static PyObject *const_str_plain_configparser; | ||
| 69 | static PyObject *const_tuple_str_digest_bc0f45fb253980f6a51c7a840136365c_tuple; | ||
| 70 | extern PyObject *const_str_plain_config; | ||
| 71 | static PyObject *const_str_digest_f6773c00b8fc3f6f4ad6e3ef692da28b; | ||
| 72 | static PyObject *const_str_plain_BugURL; | ||
| 73 | extern PyObject *const_str_digest_6807157bfb6aeb31712b82d637fd949a; | ||
| 74 | extern PyObject *const_int_0; | ||
| 75 | static PyObject *const_str_digest_a87bee146472c3a904d2f3b0113fcd4d; | ||
| 76 | static PyObject *const_str_digest_87c4d693b61afc6011d198d416a718f9; | ||
| 77 | extern PyObject *const_str_plain_origin; | ||
| 78 | static PyObject *const_str_plain_uname; | ||
| 79 | static PyObject *const_str_plain_Variant; | ||
| 80 | extern PyObject *const_str_plain_rawhide; | ||
| 81 | extern PyObject *const_str_plain_anaconda; | ||
| 82 | extern PyObject *const_int_pos_4; | ||
| 83 | static PyObject *const_str_plain_development; | ||
| 84 | static PyObject *const_str_plain_translated_new_install_name; | ||
| 85 | static PyObject *const_str_digest_56efa89f4535a54029e801e0bafcb626; | ||
| 86 | static PyObject *const_str_plain_Main; | ||
| 87 | static PyObject *const_str_digest_bc0f45fb253980f6a51c7a840136365c; | ||
| 88 | extern PyObject *const_str_plain___cached__; | ||
| 89 | static PyObject *const_tuple_str_plain_Main_str_plain_BugURL_tuple; | ||
| 90 | extern PyObject *const_str_plain__; | ||
| 91 | static PyObject *const_tuple_str_plain_Main_str_plain_Variant_tuple; | ||
| 92 | static PyObject *const_tuple_str_plain_Main_tuple; | ||
| 93 | static PyObject *const_str_plain_getboolean; | ||
| 94 | static PyObject *const_str_plain_productArch; | ||
| 95 | static PyObject *const_str_plain_ANACONDA_PRODUCTVERSION; | ||
| 96 | static PyObject *const_tuple_str_plain_Main_str_plain_UUID_str_empty_tuple; | ||
| 97 | extern PyObject *const_int_pos_1; | ||
| 98 | static PyObject *const_str_plain_isFinal; | ||
| 99 | static PyObject *const_tuple_str_plain_PRODBUILDPATH_str_empty_tuple; | ||
| 100 | static PyObject *const_tuple_str_plain_Main_str_plain_Version_tuple; | ||
| 101 | static PyObject *const_tuple_str_plain_ANACONDA_PRODUCTVERSION_str_plain_bluesky_tuple; | ||
| 102 | static PyObject *const_str_plain_distributionText; | ||
| 103 | static PyObject *const_str_digest_d37b13b47eafe43d94d94046592bb5a1; | ||
| 104 | static PyObject *const_tuple_str_digest_56efa89f4535a54029e801e0bafcb626_tuple; | ||
| 105 | static PyObject *const_str_plain_Product; | ||
| 106 | static PyObject *const_str_plain_bugUrl; | ||
| 107 | extern PyObject *const_str_plain_get; | ||
| 108 | static PyObject *const_str_plain_IsFinal; | ||
| 109 | extern PyObject *const_str_plain_has_location; | ||
| 110 | static PyObject *const_str_plain_productStamp; | ||
| 111 | extern PyObject *const_str_plain_version; | ||
| 112 | static PyObject *const_tuple_d434e6cbdd827511992d51c79639728b_tuple; | ||
| 113 | static PyObject *const_tuple_str_plain_Main_str_plain_Arch_tuple; | ||
| 114 | static PyObject *const_str_plain_bluesky; | ||
| 115 | extern PyObject *const_str_empty; | ||
| 116 | static PyObject *const_tuple_str_plain_ANACONDA_PRODUCTNAME_str_plain_anaconda_tuple; | ||
| 117 | static PyObject *const_str_plain_ANACONDA_ISFINAL; | ||
| 118 | static PyObject *const_tuple_str_plain_Main_str_plain_UUID_tuple; | ||
| 119 | static PyObject *module_filename_obj; | ||
| 120 | |||
| 121 | /* Indicator if this modules private constants were created yet. */ | ||
| 122 | static bool constants_created = false; | ||
| 123 | |||
| 124 | /* Function to create module private constants. */ | ||
| 125 | static void createModuleConstants( void ) | ||
| 126 | { | ||
| 127 | const_str_plain_ANACONDA_PRODUCTARCH = UNSTREAM_STRING_ASCII( &constant_bin[ 60498 ], 20, 1 ); | ||
| 128 | const_str_plain_set = UNSTREAM_STRING_ASCII( &constant_bin[ 1731 ], 3, 1 ); | ||
| 129 | const_str_plain_PRODBUILDPATH = UNSTREAM_STRING_ASCII( &constant_bin[ 60518 ], 13, 1 ); | ||
| 130 | const_str_plain_ANACONDA_PRODUCTVARIANT = UNSTREAM_STRING_ASCII( &constant_bin[ 60531 ], 23, 1 ); | ||
| 131 | const_str_plain_ANACONDA_BUGURL = UNSTREAM_STRING_ASCII( &constant_bin[ 60554 ], 15, 1 ); | ||
| 132 | const_str_digest_f259902e5c4e3accbfad88a2489e5d77 = UNSTREAM_STRING_ASCII( &constant_bin[ 60569 ], 24, 0 ); | ||
| 133 | const_tuple_str_plain___tuple = PyTuple_New( 1 ); | ||
| 134 | PyTuple_SET_ITEM( const_tuple_str_plain___tuple, 0, const_str_plain__ ); Py_INCREF( const_str_plain__ ); | ||
| 135 | const_str_plain_productVariant = UNSTREAM_STRING_ASCII( &constant_bin[ 60593 ], 14, 1 ); | ||
| 136 | const_str_plain_add_section = UNSTREAM_STRING_ASCII( &constant_bin[ 60607 ], 11, 1 ); | ||
| 137 | const_str_plain_Arch = UNSTREAM_STRING_ASCII( &constant_bin[ 60618 ], 4, 1 ); | ||
| 138 | const_str_plain_Version = UNSTREAM_STRING_ASCII( &constant_bin[ 60622 ], 7, 1 ); | ||
| 139 | const_tuple_str_plain_ANACONDA_ISFINAL_str_plain_false_tuple = PyTuple_New( 2 ); | ||
| 140 | const_str_plain_ANACONDA_ISFINAL = UNSTREAM_STRING_ASCII( &constant_bin[ 60629 ], 16, 1 ); | ||
| 141 | PyTuple_SET_ITEM( const_tuple_str_plain_ANACONDA_ISFINAL_str_plain_false_tuple, 0, const_str_plain_ANACONDA_ISFINAL ); Py_INCREF( const_str_plain_ANACONDA_ISFINAL ); | ||
| 142 | const_str_plain_false = UNSTREAM_STRING_ASCII( &constant_bin[ 10291 ], 5, 1 ); | ||
| 143 | PyTuple_SET_ITEM( const_tuple_str_plain_ANACONDA_ISFINAL_str_plain_false_tuple, 1, const_str_plain_false ); Py_INCREF( const_str_plain_false ); | ||
| 144 | const_str_plain_ANACONDA_PRODUCTNAME = UNSTREAM_STRING_ASCII( &constant_bin[ 60645 ], 20, 1 ); | ||
| 145 | const_tuple_str_plain_Main_str_plain_IsFinal_tuple = PyTuple_New( 2 ); | ||
| 146 | const_str_plain_Main = UNSTREAM_STRING_ASCII( &constant_bin[ 4574 ], 4, 1 ); | ||
| 147 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_IsFinal_tuple, 0, const_str_plain_Main ); Py_INCREF( const_str_plain_Main ); | ||
| 148 | const_str_plain_IsFinal = UNSTREAM_STRING_ASCII( &constant_bin[ 60665 ], 7, 1 ); | ||
| 149 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_IsFinal_tuple, 1, const_str_plain_IsFinal ); Py_INCREF( const_str_plain_IsFinal ); | ||
| 150 | const_str_digest_299dc5a63bc229b8fc193ff2445a947f = UNSTREAM_STRING_ASCII( &constant_bin[ 60672 ], 18, 0 ); | ||
| 151 | const_str_plain_ConfigParser = UNSTREAM_STRING_ASCII( &constant_bin[ 60690 ], 12, 1 ); | ||
| 152 | const_tuple_str_plain_ANACONDA_PRODUCTVARIANT_str_empty_tuple = PyTuple_New( 2 ); | ||
| 153 | PyTuple_SET_ITEM( const_tuple_str_plain_ANACONDA_PRODUCTVARIANT_str_empty_tuple, 0, const_str_plain_ANACONDA_PRODUCTVARIANT ); Py_INCREF( const_str_plain_ANACONDA_PRODUCTVARIANT ); | ||
| 154 | PyTuple_SET_ITEM( const_tuple_str_plain_ANACONDA_PRODUCTVARIANT_str_empty_tuple, 1, const_str_empty ); Py_INCREF( const_str_empty ); | ||
| 155 | const_tuple_str_plain_Main_str_plain_Product_tuple = PyTuple_New( 2 ); | ||
| 156 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_Product_tuple, 0, const_str_plain_Main ); Py_INCREF( const_str_plain_Main ); | ||
| 157 | const_str_plain_Product = UNSTREAM_STRING_ASCII( &constant_bin[ 60702 ], 7, 1 ); | ||
| 158 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_Product_tuple, 1, const_str_plain_Product ); Py_INCREF( const_str_plain_Product ); | ||
| 159 | const_str_plain_configparser = UNSTREAM_STRING_ASCII( &constant_bin[ 60709 ], 12, 1 ); | ||
| 160 | const_tuple_str_digest_bc0f45fb253980f6a51c7a840136365c_tuple = PyTuple_New( 1 ); | ||
| 161 | const_str_digest_bc0f45fb253980f6a51c7a840136365c = UNSTREAM_STRING_ASCII( &constant_bin[ 60721 ], 47, 0 ); | ||
| 162 | PyTuple_SET_ITEM( const_tuple_str_digest_bc0f45fb253980f6a51c7a840136365c_tuple, 0, const_str_digest_bc0f45fb253980f6a51c7a840136365c ); Py_INCREF( const_str_digest_bc0f45fb253980f6a51c7a840136365c ); | ||
| 163 | const_str_digest_f6773c00b8fc3f6f4ad6e3ef692da28b = UNSTREAM_STRING_ASCII( &constant_bin[ 60768 ], 45, 0 ); | ||
| 164 | const_str_plain_BugURL = UNSTREAM_STRING_ASCII( &constant_bin[ 60813 ], 6, 1 ); | ||
| 165 | const_str_digest_a87bee146472c3a904d2f3b0113fcd4d = UNSTREAM_STRING_ASCII( &constant_bin[ 60819 ], 21, 0 ); | ||
| 166 | const_str_digest_87c4d693b61afc6011d198d416a718f9 = UNSTREAM_STRING_ASCII( &constant_bin[ 60840 ], 27, 0 ); | ||
| 167 | const_str_plain_uname = UNSTREAM_STRING_ASCII( &constant_bin[ 60867 ], 5, 1 ); | ||
| 168 | const_str_plain_Variant = UNSTREAM_STRING_ASCII( &constant_bin[ 36318 ], 7, 1 ); | ||
| 169 | const_str_plain_development = UNSTREAM_STRING_ASCII( &constant_bin[ 60872 ], 11, 1 ); | ||
| 170 | const_str_plain_translated_new_install_name = UNSTREAM_STRING_ASCII( &constant_bin[ 60883 ], 27, 1 ); | ||
| 171 | const_str_digest_56efa89f4535a54029e801e0bafcb626 = UNSTREAM_STRING_ASCII( &constant_bin[ 60910 ], 37, 0 ); | ||
| 172 | const_tuple_str_plain_Main_str_plain_BugURL_tuple = PyTuple_New( 2 ); | ||
| 173 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_BugURL_tuple, 0, const_str_plain_Main ); Py_INCREF( const_str_plain_Main ); | ||
| 174 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_BugURL_tuple, 1, const_str_plain_BugURL ); Py_INCREF( const_str_plain_BugURL ); | ||
| 175 | const_tuple_str_plain_Main_str_plain_Variant_tuple = PyTuple_New( 2 ); | ||
| 176 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_Variant_tuple, 0, const_str_plain_Main ); Py_INCREF( const_str_plain_Main ); | ||
| 177 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_Variant_tuple, 1, const_str_plain_Variant ); Py_INCREF( const_str_plain_Variant ); | ||
| 178 | const_tuple_str_plain_Main_tuple = PyTuple_New( 1 ); | ||
| 179 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_tuple, 0, const_str_plain_Main ); Py_INCREF( const_str_plain_Main ); | ||
| 180 | const_str_plain_getboolean = UNSTREAM_STRING_ASCII( &constant_bin[ 60947 ], 10, 1 ); | ||
| 181 | const_str_plain_productArch = UNSTREAM_STRING_ASCII( &constant_bin[ 60957 ], 11, 1 ); | ||
| 182 | const_str_plain_ANACONDA_PRODUCTVERSION = UNSTREAM_STRING_ASCII( &constant_bin[ 60968 ], 23, 1 ); | ||
| 183 | const_tuple_str_plain_Main_str_plain_UUID_str_empty_tuple = PyTuple_New( 3 ); | ||
| 184 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_UUID_str_empty_tuple, 0, const_str_plain_Main ); Py_INCREF( const_str_plain_Main ); | ||
| 185 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_UUID_str_empty_tuple, 1, const_str_plain_UUID ); Py_INCREF( const_str_plain_UUID ); | ||
| 186 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_UUID_str_empty_tuple, 2, const_str_empty ); Py_INCREF( const_str_empty ); | ||
| 187 | const_str_plain_isFinal = UNSTREAM_STRING_ASCII( &constant_bin[ 60991 ], 7, 1 ); | ||
| 188 | const_tuple_str_plain_PRODBUILDPATH_str_empty_tuple = PyTuple_New( 2 ); | ||
| 189 | PyTuple_SET_ITEM( const_tuple_str_plain_PRODBUILDPATH_str_empty_tuple, 0, const_str_plain_PRODBUILDPATH ); Py_INCREF( const_str_plain_PRODBUILDPATH ); | ||
| 190 | PyTuple_SET_ITEM( const_tuple_str_plain_PRODBUILDPATH_str_empty_tuple, 1, const_str_empty ); Py_INCREF( const_str_empty ); | ||
| 191 | const_tuple_str_plain_Main_str_plain_Version_tuple = PyTuple_New( 2 ); | ||
| 192 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_Version_tuple, 0, const_str_plain_Main ); Py_INCREF( const_str_plain_Main ); | ||
| 193 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_Version_tuple, 1, const_str_plain_Version ); Py_INCREF( const_str_plain_Version ); | ||
| 194 | const_tuple_str_plain_ANACONDA_PRODUCTVERSION_str_plain_bluesky_tuple = PyTuple_New( 2 ); | ||
| 195 | PyTuple_SET_ITEM( const_tuple_str_plain_ANACONDA_PRODUCTVERSION_str_plain_bluesky_tuple, 0, const_str_plain_ANACONDA_PRODUCTVERSION ); Py_INCREF( const_str_plain_ANACONDA_PRODUCTVERSION ); | ||
| 196 | const_str_plain_bluesky = UNSTREAM_STRING_ASCII( &constant_bin[ 60998 ], 7, 1 ); | ||
| 197 | PyTuple_SET_ITEM( const_tuple_str_plain_ANACONDA_PRODUCTVERSION_str_plain_bluesky_tuple, 1, const_str_plain_bluesky ); Py_INCREF( const_str_plain_bluesky ); | ||
| 198 | const_str_plain_distributionText = UNSTREAM_STRING_ASCII( &constant_bin[ 61005 ], 16, 1 ); | ||
| 199 | const_str_digest_d37b13b47eafe43d94d94046592bb5a1 = UNSTREAM_STRING_ASCII( &constant_bin[ 60581 ], 12, 0 ); | ||
| 200 | const_tuple_str_digest_56efa89f4535a54029e801e0bafcb626_tuple = PyTuple_New( 1 ); | ||
| 201 | PyTuple_SET_ITEM( const_tuple_str_digest_56efa89f4535a54029e801e0bafcb626_tuple, 0, const_str_digest_56efa89f4535a54029e801e0bafcb626 ); Py_INCREF( const_str_digest_56efa89f4535a54029e801e0bafcb626 ); | ||
| 202 | const_str_plain_bugUrl = UNSTREAM_STRING_ASCII( &constant_bin[ 61021 ], 6, 1 ); | ||
| 203 | const_str_plain_productStamp = UNSTREAM_STRING_ASCII( &constant_bin[ 61027 ], 12, 1 ); | ||
| 204 | const_tuple_d434e6cbdd827511992d51c79639728b_tuple = PyTuple_New( 2 ); | ||
| 205 | PyTuple_SET_ITEM( const_tuple_d434e6cbdd827511992d51c79639728b_tuple, 0, const_str_plain_ANACONDA_BUGURL ); Py_INCREF( const_str_plain_ANACONDA_BUGURL ); | ||
| 206 | PyTuple_SET_ITEM( const_tuple_d434e6cbdd827511992d51c79639728b_tuple, 1, const_str_digest_f6773c00b8fc3f6f4ad6e3ef692da28b ); Py_INCREF( const_str_digest_f6773c00b8fc3f6f4ad6e3ef692da28b ); | ||
| 207 | const_tuple_str_plain_Main_str_plain_Arch_tuple = PyTuple_New( 2 ); | ||
| 208 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_Arch_tuple, 0, const_str_plain_Main ); Py_INCREF( const_str_plain_Main ); | ||
| 209 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_Arch_tuple, 1, const_str_plain_Arch ); Py_INCREF( const_str_plain_Arch ); | ||
| 210 | const_tuple_str_plain_ANACONDA_PRODUCTNAME_str_plain_anaconda_tuple = PyTuple_New( 2 ); | ||
| 211 | PyTuple_SET_ITEM( const_tuple_str_plain_ANACONDA_PRODUCTNAME_str_plain_anaconda_tuple, 0, const_str_plain_ANACONDA_PRODUCTNAME ); Py_INCREF( const_str_plain_ANACONDA_PRODUCTNAME ); | ||
| 212 | PyTuple_SET_ITEM( const_tuple_str_plain_ANACONDA_PRODUCTNAME_str_plain_anaconda_tuple, 1, const_str_plain_anaconda ); Py_INCREF( const_str_plain_anaconda ); | ||
| 213 | const_tuple_str_plain_Main_str_plain_UUID_tuple = PyTuple_New( 2 ); | ||
| 214 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_UUID_tuple, 0, const_str_plain_Main ); Py_INCREF( const_str_plain_Main ); | ||
| 215 | PyTuple_SET_ITEM( const_tuple_str_plain_Main_str_plain_UUID_tuple, 1, const_str_plain_UUID ); Py_INCREF( const_str_plain_UUID ); | ||
| 216 | |||
| 217 | constants_created = true; | ||
| 218 | } | ||
| 219 | |||
| 220 | /* Function to verify module private constants for non-corruption. */ | ||
| 221 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 222 | void checkModuleConstants_pyanaconda$product( void ) | ||
| 223 | { | ||
| 224 | // The module may not have been used at all, then ignore this. | ||
| 225 | if (constants_created == false) return; | ||
| 226 | |||
| 227 | |||
| 228 | } | ||
| 229 | #endif | ||
| 230 | |||
| 231 | // The module code objects. | ||
| 232 | static PyCodeObject *codeobj_3a42a00e1e492502a58e5fadda60aaa2; | ||
| 233 | static PyCodeObject *codeobj_a228aa4b6b7c44754b400bd7f75510ca; | ||
| 234 | static PyCodeObject *codeobj_2c6df6d99e94cc333b2b0fc088e354df; | ||
| 235 | |||
| 236 | static void createModuleCodeObjects(void) | ||
| 237 | { | ||
| 238 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_a87bee146472c3a904d2f3b0113fcd4d ); | ||
| 239 | codeobj_3a42a00e1e492502a58e5fadda60aaa2 = MAKE_CODEOBJ( module_filename_obj, const_str_digest_87c4d693b61afc6011d198d416a718f9, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 240 | codeobj_a228aa4b6b7c44754b400bd7f75510ca = MAKE_CODEOBJ( module_filename_obj, const_str_plain_distributionText, 54, const_tuple_empty, 0, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 241 | codeobj_2c6df6d99e94cc333b2b0fc088e354df = MAKE_CODEOBJ( module_filename_obj, const_str_plain_translated_new_install_name, 58, const_tuple_empty, 0, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 242 | } | ||
| 243 | |||
| 244 | // The module function declarations. | ||
| 245 | static PyObject *MAKE_FUNCTION_pyanaconda$product$$$function_1_distributionText( ); | ||
| 246 | |||
| 247 | |||
| 248 | static PyObject *MAKE_FUNCTION_pyanaconda$product$$$function_2_translated_new_install_name( ); | ||
| 249 | |||
| 250 | |||
| 251 | // The module function definitions. | ||
| 252 | static PyObject *impl_pyanaconda$product$$$function_1_distributionText( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 253 | { | ||
| 254 | // Preserve error status for checks | ||
| 255 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 256 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 257 | #endif | ||
| 258 | |||
| 259 | // Local variable declarations. | ||
| 260 | struct Nuitka_FrameObject *frame_a228aa4b6b7c44754b400bd7f75510ca; | ||
| 261 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 262 | PyObject *tmp_return_value = NULL; | ||
| 263 | PyObject *exception_type = NULL; | ||
| 264 | PyObject *exception_value = NULL; | ||
| 265 | PyTracebackObject *exception_tb = NULL; | ||
| 266 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 267 | int tmp_res; | ||
| 268 | static struct Nuitka_FrameObject *cache_frame_a228aa4b6b7c44754b400bd7f75510ca = NULL; | ||
| 269 | |||
| 270 | // Actual function body. | ||
| 271 | MAKE_OR_REUSE_FRAME( cache_frame_a228aa4b6b7c44754b400bd7f75510ca, codeobj_a228aa4b6b7c44754b400bd7f75510ca, module_pyanaconda$product, 0 ); | ||
| 272 | frame_a228aa4b6b7c44754b400bd7f75510ca = cache_frame_a228aa4b6b7c44754b400bd7f75510ca; | ||
| 273 | |||
| 274 | // Push the new frame as the currently active one. | ||
| 275 | pushFrameStack( frame_a228aa4b6b7c44754b400bd7f75510ca ); | ||
| 276 | |||
| 277 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 278 | assert( Py_REFCNT( frame_a228aa4b6b7c44754b400bd7f75510ca ) == 2 ); // Frame stack | ||
| 279 | |||
| 280 | // Framed code: | ||
| 281 | { | ||
| 282 | PyObject *tmp_left_name_1; | ||
| 283 | PyObject *tmp_called_name_1; | ||
| 284 | PyObject *tmp_mvar_value_1; | ||
| 285 | PyObject *tmp_right_name_1; | ||
| 286 | PyObject *tmp_dict_key_1; | ||
| 287 | PyObject *tmp_dict_value_1; | ||
| 288 | PyObject *tmp_mvar_value_2; | ||
| 289 | PyObject *tmp_dict_key_2; | ||
| 290 | PyObject *tmp_dict_value_2; | ||
| 291 | PyObject *tmp_mvar_value_3; | ||
| 292 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain__ ); | ||
| 293 | |||
| 294 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 295 | { | ||
| 296 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__ ); | ||
| 297 | } | ||
| 298 | |||
| 299 | if ( tmp_mvar_value_1 == NULL ) | ||
| 300 | { | ||
| 301 | |||
| 302 | exception_type = PyExc_NameError; | ||
| 303 | Py_INCREF( exception_type ); | ||
| 304 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_" ); | ||
| 305 | exception_tb = NULL; | ||
| 306 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 307 | CHAIN_EXCEPTION( exception_value ); | ||
| 308 | |||
| 309 | exception_lineno = 55; | ||
| 310 | |||
| 311 | goto frame_exception_exit_1; | ||
| 312 | } | ||
| 313 | |||
| 314 | tmp_called_name_1 = tmp_mvar_value_1; | ||
| 315 | frame_a228aa4b6b7c44754b400bd7f75510ca->m_frame.f_lineno = 55; | ||
| 316 | tmp_left_name_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, &PyTuple_GET_ITEM( const_tuple_str_digest_bc0f45fb253980f6a51c7a840136365c_tuple, 0 ) ); | ||
| 317 | |||
| 318 | if ( tmp_left_name_1 == NULL ) | ||
| 319 | { | ||
| 320 | assert( ERROR_OCCURRED() ); | ||
| 321 | |||
| 322 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 323 | |||
| 324 | |||
| 325 | exception_lineno = 55; | ||
| 326 | |||
| 327 | goto frame_exception_exit_1; | ||
| 328 | } | ||
| 329 | tmp_dict_key_1 = const_str_plain_productName; | ||
| 330 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productName ); | ||
| 331 | |||
| 332 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 333 | { | ||
| 334 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_productName ); | ||
| 335 | } | ||
| 336 | |||
| 337 | if ( tmp_mvar_value_2 == NULL ) | ||
| 338 | { | ||
| 339 | Py_DECREF( tmp_left_name_1 ); | ||
| 340 | exception_type = PyExc_NameError; | ||
| 341 | Py_INCREF( exception_type ); | ||
| 342 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "productName" ); | ||
| 343 | exception_tb = NULL; | ||
| 344 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 345 | CHAIN_EXCEPTION( exception_value ); | ||
| 346 | |||
| 347 | exception_lineno = 56; | ||
| 348 | |||
| 349 | goto frame_exception_exit_1; | ||
| 350 | } | ||
| 351 | |||
| 352 | tmp_dict_value_1 = tmp_mvar_value_2; | ||
| 353 | tmp_right_name_1 = _PyDict_NewPresized( 2 ); | ||
| 354 | tmp_res = PyDict_SetItem( tmp_right_name_1, tmp_dict_key_1, tmp_dict_value_1 ); | ||
| 355 | assert( !(tmp_res != 0) ); | ||
| 356 | tmp_dict_key_2 = const_str_plain_productVersion; | ||
| 357 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productVersion ); | ||
| 358 | |||
| 359 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 360 | { | ||
| 361 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_productVersion ); | ||
| 362 | } | ||
| 363 | |||
| 364 | if ( tmp_mvar_value_3 == NULL ) | ||
| 365 | { | ||
| 366 | Py_DECREF( tmp_left_name_1 ); | ||
| 367 | Py_DECREF( tmp_right_name_1 ); | ||
| 368 | exception_type = PyExc_NameError; | ||
| 369 | Py_INCREF( exception_type ); | ||
| 370 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "productVersion" ); | ||
| 371 | exception_tb = NULL; | ||
| 372 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 373 | CHAIN_EXCEPTION( exception_value ); | ||
| 374 | |||
| 375 | exception_lineno = 56; | ||
| 376 | |||
| 377 | goto frame_exception_exit_1; | ||
| 378 | } | ||
| 379 | |||
| 380 | tmp_dict_value_2 = tmp_mvar_value_3; | ||
| 381 | tmp_res = PyDict_SetItem( tmp_right_name_1, tmp_dict_key_2, tmp_dict_value_2 ); | ||
| 382 | assert( !(tmp_res != 0) ); | ||
| 383 | tmp_return_value = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 384 | Py_DECREF( tmp_left_name_1 ); | ||
| 385 | Py_DECREF( tmp_right_name_1 ); | ||
| 386 | if ( tmp_return_value == NULL ) | ||
| 387 | { | ||
| 388 | assert( ERROR_OCCURRED() ); | ||
| 389 | |||
| 390 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 391 | |||
| 392 | |||
| 393 | exception_lineno = 55; | ||
| 394 | |||
| 395 | goto frame_exception_exit_1; | ||
| 396 | } | ||
| 397 | goto frame_return_exit_1; | ||
| 398 | } | ||
| 399 | |||
| 400 | #if 0 | ||
| 401 | RESTORE_FRAME_EXCEPTION( frame_a228aa4b6b7c44754b400bd7f75510ca ); | ||
| 402 | #endif | ||
| 403 | |||
| 404 | // Put the previous frame back on top. | ||
| 405 | popFrameStack(); | ||
| 406 | |||
| 407 | goto frame_no_exception_1; | ||
| 408 | |||
| 409 | frame_return_exit_1:; | ||
| 410 | #if 0 | ||
| 411 | RESTORE_FRAME_EXCEPTION( frame_a228aa4b6b7c44754b400bd7f75510ca ); | ||
| 412 | #endif | ||
| 413 | |||
| 414 | // Put the previous frame back on top. | ||
| 415 | popFrameStack(); | ||
| 416 | |||
| 417 | goto function_return_exit; | ||
| 418 | |||
| 419 | frame_exception_exit_1:; | ||
| 420 | |||
| 421 | #if 0 | ||
| 422 | RESTORE_FRAME_EXCEPTION( frame_a228aa4b6b7c44754b400bd7f75510ca ); | ||
| 423 | #endif | ||
| 424 | |||
| 425 | if ( exception_tb == NULL ) | ||
| 426 | { | ||
| 427 | exception_tb = MAKE_TRACEBACK( frame_a228aa4b6b7c44754b400bd7f75510ca, exception_lineno ); | ||
| 428 | } | ||
| 429 | else if ( exception_tb->tb_frame != &frame_a228aa4b6b7c44754b400bd7f75510ca->m_frame ) | ||
| 430 | { | ||
| 431 | exception_tb = ADD_TRACEBACK( exception_tb, frame_a228aa4b6b7c44754b400bd7f75510ca, exception_lineno ); | ||
| 432 | } | ||
| 433 | |||
| 434 | // Attachs locals to frame if any. | ||
| 435 | Nuitka_Frame_AttachLocals( | ||
| 436 | (struct Nuitka_FrameObject *)frame_a228aa4b6b7c44754b400bd7f75510ca, | ||
| 437 | type_description_1 | ||
| 438 | ); | ||
| 439 | |||
| 440 | |||
| 441 | // Release cached frame. | ||
| 442 | if ( frame_a228aa4b6b7c44754b400bd7f75510ca == cache_frame_a228aa4b6b7c44754b400bd7f75510ca ) | ||
| 443 | { | ||
| 444 | Py_DECREF( frame_a228aa4b6b7c44754b400bd7f75510ca ); | ||
| 445 | } | ||
| 446 | cache_frame_a228aa4b6b7c44754b400bd7f75510ca = NULL; | ||
| 447 | |||
| 448 | assertFrameObject( frame_a228aa4b6b7c44754b400bd7f75510ca ); | ||
| 449 | |||
| 450 | // Put the previous frame back on top. | ||
| 451 | popFrameStack(); | ||
| 452 | |||
| 453 | // Return the error. | ||
| 454 | goto function_exception_exit; | ||
| 455 | |||
| 456 | frame_no_exception_1:; | ||
| 457 | |||
| 458 | // Return statement must have exited already. | ||
| 459 | NUITKA_CANNOT_GET_HERE( pyanaconda$product$$$function_1_distributionText ); | ||
| 460 | return NULL; | ||
| 461 | |||
| 462 | function_exception_exit: | ||
| 463 | assert( exception_type ); | ||
| 464 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 465 | |||
| 466 | return NULL; | ||
| 467 | |||
| 468 | function_return_exit: | ||
| 469 | // Function cleanup code if any. | ||
| 470 | |||
| 471 | |||
| 472 | // Actual function exit with return value, making sure we did not make | ||
| 473 | // the error status worse despite non-NULL return. | ||
| 474 | CHECK_OBJECT( tmp_return_value ); | ||
| 475 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 476 | return tmp_return_value; | ||
| 477 | } | ||
| 478 | |||
| 479 | |||
| 480 | static PyObject *impl_pyanaconda$product$$$function_2_translated_new_install_name( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 481 | { | ||
| 482 | // Preserve error status for checks | ||
| 483 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 484 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 485 | #endif | ||
| 486 | |||
| 487 | // Local variable declarations. | ||
| 488 | struct Nuitka_FrameObject *frame_2c6df6d99e94cc333b2b0fc088e354df; | ||
| 489 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 490 | PyObject *tmp_return_value = NULL; | ||
| 491 | PyObject *exception_type = NULL; | ||
| 492 | PyObject *exception_value = NULL; | ||
| 493 | PyTracebackObject *exception_tb = NULL; | ||
| 494 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 495 | int tmp_res; | ||
| 496 | static struct Nuitka_FrameObject *cache_frame_2c6df6d99e94cc333b2b0fc088e354df = NULL; | ||
| 497 | |||
| 498 | // Actual function body. | ||
| 499 | MAKE_OR_REUSE_FRAME( cache_frame_2c6df6d99e94cc333b2b0fc088e354df, codeobj_2c6df6d99e94cc333b2b0fc088e354df, module_pyanaconda$product, 0 ); | ||
| 500 | frame_2c6df6d99e94cc333b2b0fc088e354df = cache_frame_2c6df6d99e94cc333b2b0fc088e354df; | ||
| 501 | |||
| 502 | // Push the new frame as the currently active one. | ||
| 503 | pushFrameStack( frame_2c6df6d99e94cc333b2b0fc088e354df ); | ||
| 504 | |||
| 505 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 506 | assert( Py_REFCNT( frame_2c6df6d99e94cc333b2b0fc088e354df ) == 2 ); // Frame stack | ||
| 507 | |||
| 508 | // Framed code: | ||
| 509 | { | ||
| 510 | PyObject *tmp_left_name_1; | ||
| 511 | PyObject *tmp_called_name_1; | ||
| 512 | PyObject *tmp_mvar_value_1; | ||
| 513 | PyObject *tmp_right_name_1; | ||
| 514 | PyObject *tmp_dict_key_1; | ||
| 515 | PyObject *tmp_dict_value_1; | ||
| 516 | PyObject *tmp_mvar_value_2; | ||
| 517 | PyObject *tmp_dict_key_2; | ||
| 518 | PyObject *tmp_dict_value_2; | ||
| 519 | PyObject *tmp_mvar_value_3; | ||
| 520 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain__ ); | ||
| 521 | |||
| 522 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 523 | { | ||
| 524 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain__ ); | ||
| 525 | } | ||
| 526 | |||
| 527 | if ( tmp_mvar_value_1 == NULL ) | ||
| 528 | { | ||
| 529 | |||
| 530 | exception_type = PyExc_NameError; | ||
| 531 | Py_INCREF( exception_type ); | ||
| 532 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "_" ); | ||
| 533 | exception_tb = NULL; | ||
| 534 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 535 | CHAIN_EXCEPTION( exception_value ); | ||
| 536 | |||
| 537 | exception_lineno = 59; | ||
| 538 | |||
| 539 | goto frame_exception_exit_1; | ||
| 540 | } | ||
| 541 | |||
| 542 | tmp_called_name_1 = tmp_mvar_value_1; | ||
| 543 | frame_2c6df6d99e94cc333b2b0fc088e354df->m_frame.f_lineno = 59; | ||
| 544 | tmp_left_name_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, &PyTuple_GET_ITEM( const_tuple_str_digest_56efa89f4535a54029e801e0bafcb626_tuple, 0 ) ); | ||
| 545 | |||
| 546 | if ( tmp_left_name_1 == NULL ) | ||
| 547 | { | ||
| 548 | assert( ERROR_OCCURRED() ); | ||
| 549 | |||
| 550 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 551 | |||
| 552 | |||
| 553 | exception_lineno = 59; | ||
| 554 | |||
| 555 | goto frame_exception_exit_1; | ||
| 556 | } | ||
| 557 | tmp_dict_key_1 = const_str_plain_name; | ||
| 558 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productName ); | ||
| 559 | |||
| 560 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 561 | { | ||
| 562 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_productName ); | ||
| 563 | } | ||
| 564 | |||
| 565 | if ( tmp_mvar_value_2 == NULL ) | ||
| 566 | { | ||
| 567 | Py_DECREF( tmp_left_name_1 ); | ||
| 568 | exception_type = PyExc_NameError; | ||
| 569 | Py_INCREF( exception_type ); | ||
| 570 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "productName" ); | ||
| 571 | exception_tb = NULL; | ||
| 572 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 573 | CHAIN_EXCEPTION( exception_value ); | ||
| 574 | |||
| 575 | exception_lineno = 59; | ||
| 576 | |||
| 577 | goto frame_exception_exit_1; | ||
| 578 | } | ||
| 579 | |||
| 580 | tmp_dict_value_1 = tmp_mvar_value_2; | ||
| 581 | tmp_right_name_1 = _PyDict_NewPresized( 2 ); | ||
| 582 | tmp_res = PyDict_SetItem( tmp_right_name_1, tmp_dict_key_1, tmp_dict_value_1 ); | ||
| 583 | assert( !(tmp_res != 0) ); | ||
| 584 | tmp_dict_key_2 = const_str_plain_version; | ||
| 585 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productVersion ); | ||
| 586 | |||
| 587 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 588 | { | ||
| 589 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_productVersion ); | ||
| 590 | } | ||
| 591 | |||
| 592 | if ( tmp_mvar_value_3 == NULL ) | ||
| 593 | { | ||
| 594 | Py_DECREF( tmp_left_name_1 ); | ||
| 595 | Py_DECREF( tmp_right_name_1 ); | ||
| 596 | exception_type = PyExc_NameError; | ||
| 597 | Py_INCREF( exception_type ); | ||
| 598 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "productVersion" ); | ||
| 599 | exception_tb = NULL; | ||
| 600 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 601 | CHAIN_EXCEPTION( exception_value ); | ||
| 602 | |||
| 603 | exception_lineno = 59; | ||
| 604 | |||
| 605 | goto frame_exception_exit_1; | ||
| 606 | } | ||
| 607 | |||
| 608 | tmp_dict_value_2 = tmp_mvar_value_3; | ||
| 609 | tmp_res = PyDict_SetItem( tmp_right_name_1, tmp_dict_key_2, tmp_dict_value_2 ); | ||
| 610 | assert( !(tmp_res != 0) ); | ||
| 611 | tmp_return_value = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 612 | Py_DECREF( tmp_left_name_1 ); | ||
| 613 | Py_DECREF( tmp_right_name_1 ); | ||
| 614 | if ( tmp_return_value == NULL ) | ||
| 615 | { | ||
| 616 | assert( ERROR_OCCURRED() ); | ||
| 617 | |||
| 618 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 619 | |||
| 620 | |||
| 621 | exception_lineno = 59; | ||
| 622 | |||
| 623 | goto frame_exception_exit_1; | ||
| 624 | } | ||
| 625 | goto frame_return_exit_1; | ||
| 626 | } | ||
| 627 | |||
| 628 | #if 0 | ||
| 629 | RESTORE_FRAME_EXCEPTION( frame_2c6df6d99e94cc333b2b0fc088e354df ); | ||
| 630 | #endif | ||
| 631 | |||
| 632 | // Put the previous frame back on top. | ||
| 633 | popFrameStack(); | ||
| 634 | |||
| 635 | goto frame_no_exception_1; | ||
| 636 | |||
| 637 | frame_return_exit_1:; | ||
| 638 | #if 0 | ||
| 639 | RESTORE_FRAME_EXCEPTION( frame_2c6df6d99e94cc333b2b0fc088e354df ); | ||
| 640 | #endif | ||
| 641 | |||
| 642 | // Put the previous frame back on top. | ||
| 643 | popFrameStack(); | ||
| 644 | |||
| 645 | goto function_return_exit; | ||
| 646 | |||
| 647 | frame_exception_exit_1:; | ||
| 648 | |||
| 649 | #if 0 | ||
| 650 | RESTORE_FRAME_EXCEPTION( frame_2c6df6d99e94cc333b2b0fc088e354df ); | ||
| 651 | #endif | ||
| 652 | |||
| 653 | if ( exception_tb == NULL ) | ||
| 654 | { | ||
| 655 | exception_tb = MAKE_TRACEBACK( frame_2c6df6d99e94cc333b2b0fc088e354df, exception_lineno ); | ||
| 656 | } | ||
| 657 | else if ( exception_tb->tb_frame != &frame_2c6df6d99e94cc333b2b0fc088e354df->m_frame ) | ||
| 658 | { | ||
| 659 | exception_tb = ADD_TRACEBACK( exception_tb, frame_2c6df6d99e94cc333b2b0fc088e354df, exception_lineno ); | ||
| 660 | } | ||
| 661 | |||
| 662 | // Attachs locals to frame if any. | ||
| 663 | Nuitka_Frame_AttachLocals( | ||
| 664 | (struct Nuitka_FrameObject *)frame_2c6df6d99e94cc333b2b0fc088e354df, | ||
| 665 | type_description_1 | ||
| 666 | ); | ||
| 667 | |||
| 668 | |||
| 669 | // Release cached frame. | ||
| 670 | if ( frame_2c6df6d99e94cc333b2b0fc088e354df == cache_frame_2c6df6d99e94cc333b2b0fc088e354df ) | ||
| 671 | { | ||
| 672 | Py_DECREF( frame_2c6df6d99e94cc333b2b0fc088e354df ); | ||
| 673 | } | ||
| 674 | cache_frame_2c6df6d99e94cc333b2b0fc088e354df = NULL; | ||
| 675 | |||
| 676 | assertFrameObject( frame_2c6df6d99e94cc333b2b0fc088e354df ); | ||
| 677 | |||
| 678 | // Put the previous frame back on top. | ||
| 679 | popFrameStack(); | ||
| 680 | |||
| 681 | // Return the error. | ||
| 682 | goto function_exception_exit; | ||
| 683 | |||
| 684 | frame_no_exception_1:; | ||
| 685 | |||
| 686 | // Return statement must have exited already. | ||
| 687 | NUITKA_CANNOT_GET_HERE( pyanaconda$product$$$function_2_translated_new_install_name ); | ||
| 688 | return NULL; | ||
| 689 | |||
| 690 | function_exception_exit: | ||
| 691 | assert( exception_type ); | ||
| 692 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 693 | |||
| 694 | return NULL; | ||
| 695 | |||
| 696 | function_return_exit: | ||
| 697 | // Function cleanup code if any. | ||
| 698 | |||
| 699 | |||
| 700 | // Actual function exit with return value, making sure we did not make | ||
| 701 | // the error status worse despite non-NULL return. | ||
| 702 | CHECK_OBJECT( tmp_return_value ); | ||
| 703 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 704 | return tmp_return_value; | ||
| 705 | } | ||
| 706 | |||
| 707 | |||
| 708 | |||
| 709 | static PyObject *MAKE_FUNCTION_pyanaconda$product$$$function_1_distributionText( ) | ||
| 710 | { | ||
| 711 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 712 | impl_pyanaconda$product$$$function_1_distributionText, | ||
| 713 | const_str_plain_distributionText, | ||
| 714 | #if PYTHON_VERSION >= 300 | ||
| 715 | NULL, | ||
| 716 | #endif | ||
| 717 | codeobj_a228aa4b6b7c44754b400bd7f75510ca, | ||
| 718 | NULL, | ||
| 719 | #if PYTHON_VERSION >= 300 | ||
| 720 | NULL, | ||
| 721 | NULL, | ||
| 722 | #endif | ||
| 723 | module_pyanaconda$product, | ||
| 724 | NULL, | ||
| 725 | 0 | ||
| 726 | ); | ||
| 727 | |||
| 728 | return (PyObject *)result; | ||
| 729 | } | ||
| 730 | |||
| 731 | |||
| 732 | |||
| 733 | static PyObject *MAKE_FUNCTION_pyanaconda$product$$$function_2_translated_new_install_name( ) | ||
| 734 | { | ||
| 735 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 736 | impl_pyanaconda$product$$$function_2_translated_new_install_name, | ||
| 737 | const_str_plain_translated_new_install_name, | ||
| 738 | #if PYTHON_VERSION >= 300 | ||
| 739 | NULL, | ||
| 740 | #endif | ||
| 741 | codeobj_2c6df6d99e94cc333b2b0fc088e354df, | ||
| 742 | NULL, | ||
| 743 | #if PYTHON_VERSION >= 300 | ||
| 744 | NULL, | ||
| 745 | NULL, | ||
| 746 | #endif | ||
| 747 | module_pyanaconda$product, | ||
| 748 | NULL, | ||
| 749 | 0 | ||
| 750 | ); | ||
| 751 | |||
| 752 | return (PyObject *)result; | ||
| 753 | } | ||
| 754 | |||
| 755 | |||
| 756 | |||
| 757 | #if PYTHON_VERSION >= 300 | ||
| 758 | static struct PyModuleDef mdef_pyanaconda$product = | ||
| 759 | { | ||
| 760 | PyModuleDef_HEAD_INIT, | ||
| 761 | "pyanaconda.product", | ||
| 762 | NULL, /* m_doc */ | ||
| 763 | -1, /* m_size */ | ||
| 764 | NULL, /* m_methods */ | ||
| 765 | NULL, /* m_reload */ | ||
| 766 | NULL, /* m_traverse */ | ||
| 767 | NULL, /* m_clear */ | ||
| 768 | NULL, /* m_free */ | ||
| 769 | }; | ||
| 770 | #endif | ||
| 771 | |||
| 772 | extern PyObject *const_str_plain___compiled__; | ||
| 773 | |||
| 774 | extern PyObject *const_str_plain___package__; | ||
| 775 | |||
| 776 | #if PYTHON_VERSION >= 300 | ||
| 777 | extern PyObject *const_str_dot; | ||
| 778 | extern PyObject *const_str_plain___loader__; | ||
| 779 | #endif | ||
| 780 | |||
| 781 | #if PYTHON_VERSION >= 340 | ||
| 782 | extern PyObject *const_str_plain___spec__; | ||
| 783 | extern PyObject *const_str_plain__initializing; | ||
| 784 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 785 | #endif | ||
| 786 | |||
| 787 | extern void _initCompiledCellType(); | ||
| 788 | extern void _initCompiledGeneratorType(); | ||
| 789 | extern void _initCompiledFunctionType(); | ||
| 790 | extern void _initCompiledMethodType(); | ||
| 791 | extern void _initCompiledFrameType(); | ||
| 792 | #if PYTHON_VERSION >= 350 | ||
| 793 | extern void _initCompiledCoroutineTypes(); | ||
| 794 | #endif | ||
| 795 | #if PYTHON_VERSION >= 360 | ||
| 796 | extern void _initCompiledAsyncgenTypes(); | ||
| 797 | #endif | ||
| 798 | |||
| 799 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 800 | |||
| 801 | // The exported interface to CPython. On import of the module, this function | ||
| 802 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 803 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 804 | |||
| 805 | MOD_INIT_DECL( pyanaconda$product ) | ||
| 806 | { | ||
| 807 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 808 | static bool _init_done = false; | ||
| 809 | |||
| 810 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 811 | if ( _init_done ) | ||
| 812 | { | ||
| 813 | return MOD_RETURN_VALUE( module_pyanaconda$product ); | ||
| 814 | } | ||
| 815 | else | ||
| 816 | { | ||
| 817 | _init_done = true; | ||
| 818 | } | ||
| 819 | #endif | ||
| 820 | |||
| 821 | #ifdef _NUITKA_MODULE | ||
| 822 | // In case of a stand alone extension module, need to call initialization | ||
| 823 | // the init here because that's the first and only time we are going to get | ||
| 824 | // called here. | ||
| 825 | |||
| 826 | // Initialize the constant values used. | ||
| 827 | _initBuiltinModule(); | ||
| 828 | createGlobalConstants(); | ||
| 829 | |||
| 830 | /* Initialize the compiled types of Nuitka. */ | ||
| 831 | _initCompiledCellType(); | ||
| 832 | _initCompiledGeneratorType(); | ||
| 833 | _initCompiledFunctionType(); | ||
| 834 | _initCompiledMethodType(); | ||
| 835 | _initCompiledFrameType(); | ||
| 836 | #if PYTHON_VERSION >= 350 | ||
| 837 | _initCompiledCoroutineTypes(); | ||
| 838 | #endif | ||
| 839 | #if PYTHON_VERSION >= 360 | ||
| 840 | _initCompiledAsyncgenTypes(); | ||
| 841 | #endif | ||
| 842 | |||
| 843 | #if PYTHON_VERSION < 300 | ||
| 844 | _initSlotCompare(); | ||
| 845 | #endif | ||
| 846 | #if PYTHON_VERSION >= 270 | ||
| 847 | _initSlotIternext(); | ||
| 848 | #endif | ||
| 849 | |||
| 850 | patchBuiltinModule(); | ||
| 851 | patchTypeComparison(); | ||
| 852 | |||
| 853 | // Enable meta path based loader if not already done. | ||
| 854 | #ifdef _NUITKA_TRACE | ||
| 855 | puts("pyanaconda.product: Calling setupMetaPathBasedLoader()."); | ||
| 856 | #endif | ||
| 857 | setupMetaPathBasedLoader(); | ||
| 858 | |||
| 859 | #if PYTHON_VERSION >= 300 | ||
| 860 | patchInspectModule(); | ||
| 861 | #endif | ||
| 862 | |||
| 863 | #endif | ||
| 864 | |||
| 865 | /* The constants only used by this module are created now. */ | ||
| 866 | #ifdef _NUITKA_TRACE | ||
| 867 | puts("pyanaconda.product: Calling createModuleConstants()."); | ||
| 868 | #endif | ||
| 869 | createModuleConstants(); | ||
| 870 | |||
| 871 | /* The code objects used by this module are created now. */ | ||
| 872 | #ifdef _NUITKA_TRACE | ||
| 873 | puts("pyanaconda.product: Calling createModuleCodeObjects()."); | ||
| 874 | #endif | ||
| 875 | createModuleCodeObjects(); | ||
| 876 | |||
| 877 | // puts( "in initpyanaconda$product" ); | ||
| 878 | |||
| 879 | // Create the module object first. There are no methods initially, all are | ||
| 880 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 881 | // set at this time, as it could not contain NUL characters this way, they | ||
| 882 | // are instead set in early module code. No "self" for modules, we have no | ||
| 883 | // use for it. | ||
| 884 | #if PYTHON_VERSION < 300 | ||
| 885 | module_pyanaconda$product = Py_InitModule4( | ||
| 886 | "pyanaconda.product", // Module Name | ||
| 887 | NULL, // No methods initially, all are added | ||
| 888 | // dynamically in actual module code only. | ||
| 889 | NULL, // No "__doc__" is initially set, as it could | ||
| 890 | // not contain NUL this way, added early in | ||
| 891 | // actual code. | ||
| 892 | NULL, // No self for modules, we don't use it. | ||
| 893 | PYTHON_API_VERSION | ||
| 894 | ); | ||
| 895 | #else | ||
| 896 | |||
| 897 | module_pyanaconda$product = PyModule_Create( &mdef_pyanaconda$product ); | ||
| 898 | #endif | ||
| 899 | |||
| 900 | moduledict_pyanaconda$product = MODULE_DICT( module_pyanaconda$product ); | ||
| 901 | |||
| 902 | // Set __compiled__ to what it we know. | ||
| 903 | UPDATE_STRING_DICT1( | ||
| 904 | moduledict_pyanaconda$product, | ||
| 905 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 906 | Nuitka_dunder_compiled_value | ||
| 907 | ); | ||
| 908 | |||
| 909 | // Update "__package__" value to what it ought to be. | ||
| 910 | { | ||
| 911 | #if 0 | ||
| 912 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 913 | |||
| 914 | UPDATE_STRING_DICT1( | ||
| 915 | moduledict_pyanaconda$product, | ||
| 916 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 917 | module_name | ||
| 918 | ); | ||
| 919 | #else | ||
| 920 | |||
| 921 | #if PYTHON_VERSION < 300 | ||
| 922 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 923 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 924 | |||
| 925 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 926 | |||
| 927 | if ( last_dot != NULL ) | ||
| 928 | { | ||
| 929 | UPDATE_STRING_DICT1( | ||
| 930 | moduledict_pyanaconda$product, | ||
| 931 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 932 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 933 | ); | ||
| 934 | } | ||
| 935 | #else | ||
| 936 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 937 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 938 | |||
| 939 | if ( dot_index != -1 ) | ||
| 940 | { | ||
| 941 | UPDATE_STRING_DICT1( | ||
| 942 | moduledict_pyanaconda$product, | ||
| 943 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 944 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 945 | ); | ||
| 946 | } | ||
| 947 | #endif | ||
| 948 | #endif | ||
| 949 | } | ||
| 950 | |||
| 951 | CHECK_OBJECT( module_pyanaconda$product ); | ||
| 952 | |||
| 953 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 954 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 955 | #if PYTHON_VERSION >= 300 | ||
| 956 | { | ||
| 957 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_299dc5a63bc229b8fc193ff2445a947f, module_pyanaconda$product ); | ||
| 958 | |||
| 959 | assert( r != -1 ); | ||
| 960 | } | ||
| 961 | #endif | ||
| 962 | |||
| 963 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 964 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 965 | // before the frame object is allocated, or else it may fail. | ||
| 966 | |||
| 967 | if ( GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 968 | { | ||
| 969 | PyObject *value = (PyObject *)builtin_module; | ||
| 970 | |||
| 971 | // Check if main module, not a dict then but the module itself. | ||
| 972 | #if !defined(_NUITKA_EXE) || !0 | ||
| 973 | value = PyModule_GetDict( value ); | ||
| 974 | #endif | ||
| 975 | |||
| 976 | UPDATE_STRING_DICT0( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 977 | } | ||
| 978 | |||
| 979 | #if PYTHON_VERSION >= 300 | ||
| 980 | UPDATE_STRING_DICT0( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 981 | #endif | ||
| 982 | |||
| 983 | #if PYTHON_VERSION >= 340 | ||
| 984 | // Set the "__spec__" value | ||
| 985 | |||
| 986 | #if 0 | ||
| 987 | // Main modules just get "None" as spec. | ||
| 988 | UPDATE_STRING_DICT0( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 989 | #else | ||
| 990 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 991 | { | ||
| 992 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 993 | CHECK_OBJECT( bootstrap_module ); | ||
| 994 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 995 | Py_DECREF( bootstrap_module ); | ||
| 996 | |||
| 997 | PyObject *args[] = { | ||
| 998 | GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 999 | (PyObject *)&Nuitka_Loader_Type | ||
| 1000 | }; | ||
| 1001 | |||
| 1002 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 1003 | module_spec_class, | ||
| 1004 | args | ||
| 1005 | ); | ||
| 1006 | Py_DECREF( module_spec_class ); | ||
| 1007 | |||
| 1008 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 1009 | CHECK_OBJECT( spec_value ); | ||
| 1010 | |||
| 1011 | // For packages set the submodule search locations as well, even if to empty | ||
| 1012 | // list, so investigating code will consider it a package. | ||
| 1013 | #if 0 | ||
| 1014 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 1015 | #endif | ||
| 1016 | |||
| 1017 | // Mark the execution in the "__spec__" value. | ||
| 1018 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 1019 | |||
| 1020 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 1021 | } | ||
| 1022 | #endif | ||
| 1023 | #endif | ||
| 1024 | |||
| 1025 | // Temp variables if any | ||
| 1026 | struct Nuitka_FrameObject *frame_3a42a00e1e492502a58e5fadda60aaa2; | ||
| 1027 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 1028 | bool tmp_result; | ||
| 1029 | PyObject *exception_type = NULL; | ||
| 1030 | PyObject *exception_value = NULL; | ||
| 1031 | PyTracebackObject *exception_tb = NULL; | ||
| 1032 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 1033 | int tmp_res; | ||
| 1034 | |||
| 1035 | // Module code. | ||
| 1036 | { | ||
| 1037 | PyObject *tmp_assign_source_1; | ||
| 1038 | tmp_assign_source_1 = Py_None; | ||
| 1039 | UPDATE_STRING_DICT0( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 1040 | } | ||
| 1041 | { | ||
| 1042 | PyObject *tmp_assign_source_2; | ||
| 1043 | tmp_assign_source_2 = module_filename_obj; | ||
| 1044 | UPDATE_STRING_DICT0( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 1045 | } | ||
| 1046 | // Frame without reuse. | ||
| 1047 | frame_3a42a00e1e492502a58e5fadda60aaa2 = MAKE_MODULE_FRAME( codeobj_3a42a00e1e492502a58e5fadda60aaa2, module_pyanaconda$product ); | ||
| 1048 | |||
| 1049 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 1050 | // owning it. | ||
| 1051 | pushFrameStack( frame_3a42a00e1e492502a58e5fadda60aaa2 ); | ||
| 1052 | assert( Py_REFCNT( frame_3a42a00e1e492502a58e5fadda60aaa2 ) == 2 ); | ||
| 1053 | |||
| 1054 | // Framed code: | ||
| 1055 | { | ||
| 1056 | PyObject *tmp_assattr_name_1; | ||
| 1057 | PyObject *tmp_assattr_target_1; | ||
| 1058 | PyObject *tmp_mvar_value_1; | ||
| 1059 | tmp_assattr_name_1 = module_filename_obj; | ||
| 1060 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1061 | |||
| 1062 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 1063 | { | ||
| 1064 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1065 | } | ||
| 1066 | |||
| 1067 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 1068 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 1069 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 1070 | if ( tmp_result == false ) | ||
| 1071 | { | ||
| 1072 | assert( ERROR_OCCURRED() ); | ||
| 1073 | |||
| 1074 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1075 | |||
| 1076 | |||
| 1077 | exception_lineno = 1; | ||
| 1078 | |||
| 1079 | goto frame_exception_exit_1; | ||
| 1080 | } | ||
| 1081 | } | ||
| 1082 | { | ||
| 1083 | PyObject *tmp_assattr_name_2; | ||
| 1084 | PyObject *tmp_assattr_target_2; | ||
| 1085 | PyObject *tmp_mvar_value_2; | ||
| 1086 | tmp_assattr_name_2 = Py_True; | ||
| 1087 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1088 | |||
| 1089 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 1090 | { | ||
| 1091 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 1092 | } | ||
| 1093 | |||
| 1094 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 1095 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 1096 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 1097 | if ( tmp_result == false ) | ||
| 1098 | { | ||
| 1099 | assert( ERROR_OCCURRED() ); | ||
| 1100 | |||
| 1101 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1102 | |||
| 1103 | |||
| 1104 | exception_lineno = 1; | ||
| 1105 | |||
| 1106 | goto frame_exception_exit_1; | ||
| 1107 | } | ||
| 1108 | } | ||
| 1109 | { | ||
| 1110 | PyObject *tmp_assign_source_3; | ||
| 1111 | tmp_assign_source_3 = Py_None; | ||
| 1112 | UPDATE_STRING_DICT0( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 1113 | } | ||
| 1114 | { | ||
| 1115 | PyObject *tmp_assign_source_4; | ||
| 1116 | PyObject *tmp_name_name_1; | ||
| 1117 | PyObject *tmp_globals_name_1; | ||
| 1118 | PyObject *tmp_locals_name_1; | ||
| 1119 | PyObject *tmp_fromlist_name_1; | ||
| 1120 | PyObject *tmp_level_name_1; | ||
| 1121 | tmp_name_name_1 = const_str_plain_configparser; | ||
| 1122 | tmp_globals_name_1 = (PyObject *)moduledict_pyanaconda$product; | ||
| 1123 | tmp_locals_name_1 = Py_None; | ||
| 1124 | tmp_fromlist_name_1 = Py_None; | ||
| 1125 | tmp_level_name_1 = const_int_0; | ||
| 1126 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 20; | ||
| 1127 | tmp_assign_source_4 = IMPORT_MODULE5( tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1 ); | ||
| 1128 | if ( tmp_assign_source_4 == NULL ) | ||
| 1129 | { | ||
| 1130 | assert( ERROR_OCCURRED() ); | ||
| 1131 | |||
| 1132 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1133 | |||
| 1134 | |||
| 1135 | exception_lineno = 20; | ||
| 1136 | |||
| 1137 | goto frame_exception_exit_1; | ||
| 1138 | } | ||
| 1139 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_configparser, tmp_assign_source_4 ); | ||
| 1140 | } | ||
| 1141 | { | ||
| 1142 | PyObject *tmp_assign_source_5; | ||
| 1143 | PyObject *tmp_name_name_2; | ||
| 1144 | PyObject *tmp_globals_name_2; | ||
| 1145 | PyObject *tmp_locals_name_2; | ||
| 1146 | PyObject *tmp_fromlist_name_2; | ||
| 1147 | PyObject *tmp_level_name_2; | ||
| 1148 | tmp_name_name_2 = const_str_plain_os; | ||
| 1149 | tmp_globals_name_2 = (PyObject *)moduledict_pyanaconda$product; | ||
| 1150 | tmp_locals_name_2 = Py_None; | ||
| 1151 | tmp_fromlist_name_2 = Py_None; | ||
| 1152 | tmp_level_name_2 = const_int_0; | ||
| 1153 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 21; | ||
| 1154 | tmp_assign_source_5 = IMPORT_MODULE5( tmp_name_name_2, tmp_globals_name_2, tmp_locals_name_2, tmp_fromlist_name_2, tmp_level_name_2 ); | ||
| 1155 | if ( tmp_assign_source_5 == NULL ) | ||
| 1156 | { | ||
| 1157 | assert( ERROR_OCCURRED() ); | ||
| 1158 | |||
| 1159 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1160 | |||
| 1161 | |||
| 1162 | exception_lineno = 21; | ||
| 1163 | |||
| 1164 | goto frame_exception_exit_1; | ||
| 1165 | } | ||
| 1166 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_os, tmp_assign_source_5 ); | ||
| 1167 | } | ||
| 1168 | { | ||
| 1169 | PyObject *tmp_assign_source_6; | ||
| 1170 | PyObject *tmp_import_name_from_1; | ||
| 1171 | PyObject *tmp_name_name_3; | ||
| 1172 | PyObject *tmp_globals_name_3; | ||
| 1173 | PyObject *tmp_locals_name_3; | ||
| 1174 | PyObject *tmp_fromlist_name_3; | ||
| 1175 | PyObject *tmp_level_name_3; | ||
| 1176 | tmp_name_name_3 = const_str_digest_6807157bfb6aeb31712b82d637fd949a; | ||
| 1177 | tmp_globals_name_3 = (PyObject *)moduledict_pyanaconda$product; | ||
| 1178 | tmp_locals_name_3 = Py_None; | ||
| 1179 | tmp_fromlist_name_3 = const_tuple_str_plain___tuple; | ||
| 1180 | tmp_level_name_3 = const_int_0; | ||
| 1181 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 23; | ||
| 1182 | tmp_import_name_from_1 = IMPORT_MODULE5( tmp_name_name_3, tmp_globals_name_3, tmp_locals_name_3, tmp_fromlist_name_3, tmp_level_name_3 ); | ||
| 1183 | if ( tmp_import_name_from_1 == NULL ) | ||
| 1184 | { | ||
| 1185 | assert( ERROR_OCCURRED() ); | ||
| 1186 | |||
| 1187 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1188 | |||
| 1189 | |||
| 1190 | exception_lineno = 23; | ||
| 1191 | |||
| 1192 | goto frame_exception_exit_1; | ||
| 1193 | } | ||
| 1194 | tmp_assign_source_6 = IMPORT_NAME( tmp_import_name_from_1, const_str_plain__ ); | ||
| 1195 | Py_DECREF( tmp_import_name_from_1 ); | ||
| 1196 | if ( tmp_assign_source_6 == NULL ) | ||
| 1197 | { | ||
| 1198 | assert( ERROR_OCCURRED() ); | ||
| 1199 | |||
| 1200 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1201 | |||
| 1202 | |||
| 1203 | exception_lineno = 23; | ||
| 1204 | |||
| 1205 | goto frame_exception_exit_1; | ||
| 1206 | } | ||
| 1207 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain__, tmp_assign_source_6 ); | ||
| 1208 | } | ||
| 1209 | { | ||
| 1210 | PyObject *tmp_assign_source_7; | ||
| 1211 | PyObject *tmp_called_instance_1; | ||
| 1212 | PyObject *tmp_mvar_value_3; | ||
| 1213 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_configparser ); | ||
| 1214 | |||
| 1215 | if (unlikely( tmp_mvar_value_3 == NULL )) | ||
| 1216 | { | ||
| 1217 | tmp_mvar_value_3 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_configparser ); | ||
| 1218 | } | ||
| 1219 | |||
| 1220 | if ( tmp_mvar_value_3 == NULL ) | ||
| 1221 | { | ||
| 1222 | |||
| 1223 | exception_type = PyExc_NameError; | ||
| 1224 | Py_INCREF( exception_type ); | ||
| 1225 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "configparser" ); | ||
| 1226 | exception_tb = NULL; | ||
| 1227 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1228 | CHAIN_EXCEPTION( exception_value ); | ||
| 1229 | |||
| 1230 | exception_lineno = 27; | ||
| 1231 | |||
| 1232 | goto frame_exception_exit_1; | ||
| 1233 | } | ||
| 1234 | |||
| 1235 | tmp_called_instance_1 = tmp_mvar_value_3; | ||
| 1236 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 27; | ||
| 1237 | tmp_assign_source_7 = CALL_METHOD_NO_ARGS( tmp_called_instance_1, const_str_plain_ConfigParser ); | ||
| 1238 | if ( tmp_assign_source_7 == NULL ) | ||
| 1239 | { | ||
| 1240 | assert( ERROR_OCCURRED() ); | ||
| 1241 | |||
| 1242 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1243 | |||
| 1244 | |||
| 1245 | exception_lineno = 27; | ||
| 1246 | |||
| 1247 | goto frame_exception_exit_1; | ||
| 1248 | } | ||
| 1249 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config, tmp_assign_source_7 ); | ||
| 1250 | } | ||
| 1251 | { | ||
| 1252 | PyObject *tmp_called_instance_2; | ||
| 1253 | PyObject *tmp_mvar_value_4; | ||
| 1254 | PyObject *tmp_call_result_1; | ||
| 1255 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1256 | |||
| 1257 | if (unlikely( tmp_mvar_value_4 == NULL )) | ||
| 1258 | { | ||
| 1259 | tmp_mvar_value_4 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1260 | } | ||
| 1261 | |||
| 1262 | CHECK_OBJECT( tmp_mvar_value_4 ); | ||
| 1263 | tmp_called_instance_2 = tmp_mvar_value_4; | ||
| 1264 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 28; | ||
| 1265 | tmp_call_result_1 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_2, const_str_plain_add_section, &PyTuple_GET_ITEM( const_tuple_str_plain_Main_tuple, 0 ) ); | ||
| 1266 | |||
| 1267 | if ( tmp_call_result_1 == NULL ) | ||
| 1268 | { | ||
| 1269 | assert( ERROR_OCCURRED() ); | ||
| 1270 | |||
| 1271 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1272 | |||
| 1273 | |||
| 1274 | exception_lineno = 28; | ||
| 1275 | |||
| 1276 | goto frame_exception_exit_1; | ||
| 1277 | } | ||
| 1278 | Py_DECREF( tmp_call_result_1 ); | ||
| 1279 | } | ||
| 1280 | { | ||
| 1281 | PyObject *tmp_called_name_1; | ||
| 1282 | PyObject *tmp_source_name_1; | ||
| 1283 | PyObject *tmp_mvar_value_5; | ||
| 1284 | PyObject *tmp_call_result_2; | ||
| 1285 | PyObject *tmp_args_element_name_1; | ||
| 1286 | PyObject *tmp_args_element_name_2; | ||
| 1287 | PyObject *tmp_args_element_name_3; | ||
| 1288 | PyObject *tmp_called_name_2; | ||
| 1289 | PyObject *tmp_source_name_2; | ||
| 1290 | PyObject *tmp_source_name_3; | ||
| 1291 | PyObject *tmp_mvar_value_6; | ||
| 1292 | PyObject *tmp_args_element_name_4; | ||
| 1293 | PyObject *tmp_args_element_name_5; | ||
| 1294 | PyObject *tmp_subscribed_name_1; | ||
| 1295 | PyObject *tmp_called_instance_3; | ||
| 1296 | PyObject *tmp_mvar_value_7; | ||
| 1297 | PyObject *tmp_subscript_name_1; | ||
| 1298 | tmp_mvar_value_5 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1299 | |||
| 1300 | if (unlikely( tmp_mvar_value_5 == NULL )) | ||
| 1301 | { | ||
| 1302 | tmp_mvar_value_5 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1303 | } | ||
| 1304 | |||
| 1305 | if ( tmp_mvar_value_5 == NULL ) | ||
| 1306 | { | ||
| 1307 | |||
| 1308 | exception_type = PyExc_NameError; | ||
| 1309 | Py_INCREF( exception_type ); | ||
| 1310 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 1311 | exception_tb = NULL; | ||
| 1312 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1313 | CHAIN_EXCEPTION( exception_value ); | ||
| 1314 | |||
| 1315 | exception_lineno = 29; | ||
| 1316 | |||
| 1317 | goto frame_exception_exit_1; | ||
| 1318 | } | ||
| 1319 | |||
| 1320 | tmp_source_name_1 = tmp_mvar_value_5; | ||
| 1321 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_set ); | ||
| 1322 | if ( tmp_called_name_1 == NULL ) | ||
| 1323 | { | ||
| 1324 | assert( ERROR_OCCURRED() ); | ||
| 1325 | |||
| 1326 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1327 | |||
| 1328 | |||
| 1329 | exception_lineno = 29; | ||
| 1330 | |||
| 1331 | goto frame_exception_exit_1; | ||
| 1332 | } | ||
| 1333 | tmp_args_element_name_1 = const_str_plain_Main; | ||
| 1334 | tmp_args_element_name_2 = const_str_plain_Arch; | ||
| 1335 | tmp_mvar_value_6 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1336 | |||
| 1337 | if (unlikely( tmp_mvar_value_6 == NULL )) | ||
| 1338 | { | ||
| 1339 | tmp_mvar_value_6 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1340 | } | ||
| 1341 | |||
| 1342 | if ( tmp_mvar_value_6 == NULL ) | ||
| 1343 | { | ||
| 1344 | Py_DECREF( tmp_called_name_1 ); | ||
| 1345 | exception_type = PyExc_NameError; | ||
| 1346 | Py_INCREF( exception_type ); | ||
| 1347 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "os" ); | ||
| 1348 | exception_tb = NULL; | ||
| 1349 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1350 | CHAIN_EXCEPTION( exception_value ); | ||
| 1351 | |||
| 1352 | exception_lineno = 29; | ||
| 1353 | |||
| 1354 | goto frame_exception_exit_1; | ||
| 1355 | } | ||
| 1356 | |||
| 1357 | tmp_source_name_3 = tmp_mvar_value_6; | ||
| 1358 | tmp_source_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_3, const_str_plain_environ ); | ||
| 1359 | if ( tmp_source_name_2 == NULL ) | ||
| 1360 | { | ||
| 1361 | assert( ERROR_OCCURRED() ); | ||
| 1362 | |||
| 1363 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1364 | Py_DECREF( tmp_called_name_1 ); | ||
| 1365 | |||
| 1366 | exception_lineno = 29; | ||
| 1367 | |||
| 1368 | goto frame_exception_exit_1; | ||
| 1369 | } | ||
| 1370 | tmp_called_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_get ); | ||
| 1371 | Py_DECREF( tmp_source_name_2 ); | ||
| 1372 | if ( tmp_called_name_2 == NULL ) | ||
| 1373 | { | ||
| 1374 | assert( ERROR_OCCURRED() ); | ||
| 1375 | |||
| 1376 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1377 | Py_DECREF( tmp_called_name_1 ); | ||
| 1378 | |||
| 1379 | exception_lineno = 29; | ||
| 1380 | |||
| 1381 | goto frame_exception_exit_1; | ||
| 1382 | } | ||
| 1383 | tmp_args_element_name_4 = const_str_plain_ANACONDA_PRODUCTARCH; | ||
| 1384 | tmp_mvar_value_7 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1385 | |||
| 1386 | if (unlikely( tmp_mvar_value_7 == NULL )) | ||
| 1387 | { | ||
| 1388 | tmp_mvar_value_7 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1389 | } | ||
| 1390 | |||
| 1391 | if ( tmp_mvar_value_7 == NULL ) | ||
| 1392 | { | ||
| 1393 | Py_DECREF( tmp_called_name_1 ); | ||
| 1394 | Py_DECREF( tmp_called_name_2 ); | ||
| 1395 | exception_type = PyExc_NameError; | ||
| 1396 | Py_INCREF( exception_type ); | ||
| 1397 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "os" ); | ||
| 1398 | exception_tb = NULL; | ||
| 1399 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1400 | CHAIN_EXCEPTION( exception_value ); | ||
| 1401 | |||
| 1402 | exception_lineno = 29; | ||
| 1403 | |||
| 1404 | goto frame_exception_exit_1; | ||
| 1405 | } | ||
| 1406 | |||
| 1407 | tmp_called_instance_3 = tmp_mvar_value_7; | ||
| 1408 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 29; | ||
| 1409 | tmp_subscribed_name_1 = CALL_METHOD_NO_ARGS( tmp_called_instance_3, const_str_plain_uname ); | ||
| 1410 | if ( tmp_subscribed_name_1 == NULL ) | ||
| 1411 | { | ||
| 1412 | assert( ERROR_OCCURRED() ); | ||
| 1413 | |||
| 1414 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1415 | Py_DECREF( tmp_called_name_1 ); | ||
| 1416 | Py_DECREF( tmp_called_name_2 ); | ||
| 1417 | |||
| 1418 | exception_lineno = 29; | ||
| 1419 | |||
| 1420 | goto frame_exception_exit_1; | ||
| 1421 | } | ||
| 1422 | tmp_subscript_name_1 = const_int_pos_4; | ||
| 1423 | tmp_args_element_name_5 = LOOKUP_SUBSCRIPT_CONST( tmp_subscribed_name_1, tmp_subscript_name_1, 4 ); | ||
| 1424 | Py_DECREF( tmp_subscribed_name_1 ); | ||
| 1425 | if ( tmp_args_element_name_5 == NULL ) | ||
| 1426 | { | ||
| 1427 | assert( ERROR_OCCURRED() ); | ||
| 1428 | |||
| 1429 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1430 | Py_DECREF( tmp_called_name_1 ); | ||
| 1431 | Py_DECREF( tmp_called_name_2 ); | ||
| 1432 | |||
| 1433 | exception_lineno = 29; | ||
| 1434 | |||
| 1435 | goto frame_exception_exit_1; | ||
| 1436 | } | ||
| 1437 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 29; | ||
| 1438 | { | ||
| 1439 | PyObject *call_args[] = { tmp_args_element_name_4, tmp_args_element_name_5 }; | ||
| 1440 | tmp_args_element_name_3 = CALL_FUNCTION_WITH_ARGS2( tmp_called_name_2, call_args ); | ||
| 1441 | } | ||
| 1442 | |||
| 1443 | Py_DECREF( tmp_called_name_2 ); | ||
| 1444 | Py_DECREF( tmp_args_element_name_5 ); | ||
| 1445 | if ( tmp_args_element_name_3 == NULL ) | ||
| 1446 | { | ||
| 1447 | assert( ERROR_OCCURRED() ); | ||
| 1448 | |||
| 1449 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1450 | Py_DECREF( tmp_called_name_1 ); | ||
| 1451 | |||
| 1452 | exception_lineno = 29; | ||
| 1453 | |||
| 1454 | goto frame_exception_exit_1; | ||
| 1455 | } | ||
| 1456 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 29; | ||
| 1457 | { | ||
| 1458 | PyObject *call_args[] = { tmp_args_element_name_1, tmp_args_element_name_2, tmp_args_element_name_3 }; | ||
| 1459 | tmp_call_result_2 = CALL_FUNCTION_WITH_ARGS3( tmp_called_name_1, call_args ); | ||
| 1460 | } | ||
| 1461 | |||
| 1462 | Py_DECREF( tmp_called_name_1 ); | ||
| 1463 | Py_DECREF( tmp_args_element_name_3 ); | ||
| 1464 | if ( tmp_call_result_2 == NULL ) | ||
| 1465 | { | ||
| 1466 | assert( ERROR_OCCURRED() ); | ||
| 1467 | |||
| 1468 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1469 | |||
| 1470 | |||
| 1471 | exception_lineno = 29; | ||
| 1472 | |||
| 1473 | goto frame_exception_exit_1; | ||
| 1474 | } | ||
| 1475 | Py_DECREF( tmp_call_result_2 ); | ||
| 1476 | } | ||
| 1477 | { | ||
| 1478 | PyObject *tmp_called_name_3; | ||
| 1479 | PyObject *tmp_source_name_4; | ||
| 1480 | PyObject *tmp_mvar_value_8; | ||
| 1481 | PyObject *tmp_call_result_3; | ||
| 1482 | PyObject *tmp_args_element_name_6; | ||
| 1483 | PyObject *tmp_args_element_name_7; | ||
| 1484 | PyObject *tmp_args_element_name_8; | ||
| 1485 | PyObject *tmp_called_instance_4; | ||
| 1486 | PyObject *tmp_source_name_5; | ||
| 1487 | PyObject *tmp_mvar_value_9; | ||
| 1488 | tmp_mvar_value_8 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1489 | |||
| 1490 | if (unlikely( tmp_mvar_value_8 == NULL )) | ||
| 1491 | { | ||
| 1492 | tmp_mvar_value_8 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1493 | } | ||
| 1494 | |||
| 1495 | if ( tmp_mvar_value_8 == NULL ) | ||
| 1496 | { | ||
| 1497 | |||
| 1498 | exception_type = PyExc_NameError; | ||
| 1499 | Py_INCREF( exception_type ); | ||
| 1500 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 1501 | exception_tb = NULL; | ||
| 1502 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1503 | CHAIN_EXCEPTION( exception_value ); | ||
| 1504 | |||
| 1505 | exception_lineno = 30; | ||
| 1506 | |||
| 1507 | goto frame_exception_exit_1; | ||
| 1508 | } | ||
| 1509 | |||
| 1510 | tmp_source_name_4 = tmp_mvar_value_8; | ||
| 1511 | tmp_called_name_3 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain_set ); | ||
| 1512 | if ( tmp_called_name_3 == NULL ) | ||
| 1513 | { | ||
| 1514 | assert( ERROR_OCCURRED() ); | ||
| 1515 | |||
| 1516 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1517 | |||
| 1518 | |||
| 1519 | exception_lineno = 30; | ||
| 1520 | |||
| 1521 | goto frame_exception_exit_1; | ||
| 1522 | } | ||
| 1523 | tmp_args_element_name_6 = const_str_plain_Main; | ||
| 1524 | tmp_args_element_name_7 = const_str_plain_BugURL; | ||
| 1525 | tmp_mvar_value_9 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1526 | |||
| 1527 | if (unlikely( tmp_mvar_value_9 == NULL )) | ||
| 1528 | { | ||
| 1529 | tmp_mvar_value_9 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1530 | } | ||
| 1531 | |||
| 1532 | if ( tmp_mvar_value_9 == NULL ) | ||
| 1533 | { | ||
| 1534 | Py_DECREF( tmp_called_name_3 ); | ||
| 1535 | exception_type = PyExc_NameError; | ||
| 1536 | Py_INCREF( exception_type ); | ||
| 1537 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "os" ); | ||
| 1538 | exception_tb = NULL; | ||
| 1539 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1540 | CHAIN_EXCEPTION( exception_value ); | ||
| 1541 | |||
| 1542 | exception_lineno = 30; | ||
| 1543 | |||
| 1544 | goto frame_exception_exit_1; | ||
| 1545 | } | ||
| 1546 | |||
| 1547 | tmp_source_name_5 = tmp_mvar_value_9; | ||
| 1548 | tmp_called_instance_4 = LOOKUP_ATTRIBUTE( tmp_source_name_5, const_str_plain_environ ); | ||
| 1549 | if ( tmp_called_instance_4 == NULL ) | ||
| 1550 | { | ||
| 1551 | assert( ERROR_OCCURRED() ); | ||
| 1552 | |||
| 1553 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1554 | Py_DECREF( tmp_called_name_3 ); | ||
| 1555 | |||
| 1556 | exception_lineno = 30; | ||
| 1557 | |||
| 1558 | goto frame_exception_exit_1; | ||
| 1559 | } | ||
| 1560 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 30; | ||
| 1561 | tmp_args_element_name_8 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_4, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_d434e6cbdd827511992d51c79639728b_tuple, 0 ) ); | ||
| 1562 | |||
| 1563 | Py_DECREF( tmp_called_instance_4 ); | ||
| 1564 | if ( tmp_args_element_name_8 == NULL ) | ||
| 1565 | { | ||
| 1566 | assert( ERROR_OCCURRED() ); | ||
| 1567 | |||
| 1568 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1569 | Py_DECREF( tmp_called_name_3 ); | ||
| 1570 | |||
| 1571 | exception_lineno = 30; | ||
| 1572 | |||
| 1573 | goto frame_exception_exit_1; | ||
| 1574 | } | ||
| 1575 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 30; | ||
| 1576 | { | ||
| 1577 | PyObject *call_args[] = { tmp_args_element_name_6, tmp_args_element_name_7, tmp_args_element_name_8 }; | ||
| 1578 | tmp_call_result_3 = CALL_FUNCTION_WITH_ARGS3( tmp_called_name_3, call_args ); | ||
| 1579 | } | ||
| 1580 | |||
| 1581 | Py_DECREF( tmp_called_name_3 ); | ||
| 1582 | Py_DECREF( tmp_args_element_name_8 ); | ||
| 1583 | if ( tmp_call_result_3 == NULL ) | ||
| 1584 | { | ||
| 1585 | assert( ERROR_OCCURRED() ); | ||
| 1586 | |||
| 1587 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1588 | |||
| 1589 | |||
| 1590 | exception_lineno = 30; | ||
| 1591 | |||
| 1592 | goto frame_exception_exit_1; | ||
| 1593 | } | ||
| 1594 | Py_DECREF( tmp_call_result_3 ); | ||
| 1595 | } | ||
| 1596 | { | ||
| 1597 | PyObject *tmp_called_name_4; | ||
| 1598 | PyObject *tmp_source_name_6; | ||
| 1599 | PyObject *tmp_mvar_value_10; | ||
| 1600 | PyObject *tmp_call_result_4; | ||
| 1601 | PyObject *tmp_args_element_name_9; | ||
| 1602 | PyObject *tmp_args_element_name_10; | ||
| 1603 | PyObject *tmp_args_element_name_11; | ||
| 1604 | PyObject *tmp_called_instance_5; | ||
| 1605 | PyObject *tmp_source_name_7; | ||
| 1606 | PyObject *tmp_mvar_value_11; | ||
| 1607 | tmp_mvar_value_10 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1608 | |||
| 1609 | if (unlikely( tmp_mvar_value_10 == NULL )) | ||
| 1610 | { | ||
| 1611 | tmp_mvar_value_10 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1612 | } | ||
| 1613 | |||
| 1614 | if ( tmp_mvar_value_10 == NULL ) | ||
| 1615 | { | ||
| 1616 | |||
| 1617 | exception_type = PyExc_NameError; | ||
| 1618 | Py_INCREF( exception_type ); | ||
| 1619 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 1620 | exception_tb = NULL; | ||
| 1621 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1622 | CHAIN_EXCEPTION( exception_value ); | ||
| 1623 | |||
| 1624 | exception_lineno = 31; | ||
| 1625 | |||
| 1626 | goto frame_exception_exit_1; | ||
| 1627 | } | ||
| 1628 | |||
| 1629 | tmp_source_name_6 = tmp_mvar_value_10; | ||
| 1630 | tmp_called_name_4 = LOOKUP_ATTRIBUTE( tmp_source_name_6, const_str_plain_set ); | ||
| 1631 | if ( tmp_called_name_4 == NULL ) | ||
| 1632 | { | ||
| 1633 | assert( ERROR_OCCURRED() ); | ||
| 1634 | |||
| 1635 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1636 | |||
| 1637 | |||
| 1638 | exception_lineno = 31; | ||
| 1639 | |||
| 1640 | goto frame_exception_exit_1; | ||
| 1641 | } | ||
| 1642 | tmp_args_element_name_9 = const_str_plain_Main; | ||
| 1643 | tmp_args_element_name_10 = const_str_plain_IsFinal; | ||
| 1644 | tmp_mvar_value_11 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1645 | |||
| 1646 | if (unlikely( tmp_mvar_value_11 == NULL )) | ||
| 1647 | { | ||
| 1648 | tmp_mvar_value_11 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1649 | } | ||
| 1650 | |||
| 1651 | if ( tmp_mvar_value_11 == NULL ) | ||
| 1652 | { | ||
| 1653 | Py_DECREF( tmp_called_name_4 ); | ||
| 1654 | exception_type = PyExc_NameError; | ||
| 1655 | Py_INCREF( exception_type ); | ||
| 1656 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "os" ); | ||
| 1657 | exception_tb = NULL; | ||
| 1658 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1659 | CHAIN_EXCEPTION( exception_value ); | ||
| 1660 | |||
| 1661 | exception_lineno = 31; | ||
| 1662 | |||
| 1663 | goto frame_exception_exit_1; | ||
| 1664 | } | ||
| 1665 | |||
| 1666 | tmp_source_name_7 = tmp_mvar_value_11; | ||
| 1667 | tmp_called_instance_5 = LOOKUP_ATTRIBUTE( tmp_source_name_7, const_str_plain_environ ); | ||
| 1668 | if ( tmp_called_instance_5 == NULL ) | ||
| 1669 | { | ||
| 1670 | assert( ERROR_OCCURRED() ); | ||
| 1671 | |||
| 1672 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1673 | Py_DECREF( tmp_called_name_4 ); | ||
| 1674 | |||
| 1675 | exception_lineno = 31; | ||
| 1676 | |||
| 1677 | goto frame_exception_exit_1; | ||
| 1678 | } | ||
| 1679 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 31; | ||
| 1680 | tmp_args_element_name_11 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_5, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_ANACONDA_ISFINAL_str_plain_false_tuple, 0 ) ); | ||
| 1681 | |||
| 1682 | Py_DECREF( tmp_called_instance_5 ); | ||
| 1683 | if ( tmp_args_element_name_11 == NULL ) | ||
| 1684 | { | ||
| 1685 | assert( ERROR_OCCURRED() ); | ||
| 1686 | |||
| 1687 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1688 | Py_DECREF( tmp_called_name_4 ); | ||
| 1689 | |||
| 1690 | exception_lineno = 31; | ||
| 1691 | |||
| 1692 | goto frame_exception_exit_1; | ||
| 1693 | } | ||
| 1694 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 31; | ||
| 1695 | { | ||
| 1696 | PyObject *call_args[] = { tmp_args_element_name_9, tmp_args_element_name_10, tmp_args_element_name_11 }; | ||
| 1697 | tmp_call_result_4 = CALL_FUNCTION_WITH_ARGS3( tmp_called_name_4, call_args ); | ||
| 1698 | } | ||
| 1699 | |||
| 1700 | Py_DECREF( tmp_called_name_4 ); | ||
| 1701 | Py_DECREF( tmp_args_element_name_11 ); | ||
| 1702 | if ( tmp_call_result_4 == NULL ) | ||
| 1703 | { | ||
| 1704 | assert( ERROR_OCCURRED() ); | ||
| 1705 | |||
| 1706 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1707 | |||
| 1708 | |||
| 1709 | exception_lineno = 31; | ||
| 1710 | |||
| 1711 | goto frame_exception_exit_1; | ||
| 1712 | } | ||
| 1713 | Py_DECREF( tmp_call_result_4 ); | ||
| 1714 | } | ||
| 1715 | { | ||
| 1716 | PyObject *tmp_called_name_5; | ||
| 1717 | PyObject *tmp_source_name_8; | ||
| 1718 | PyObject *tmp_mvar_value_12; | ||
| 1719 | PyObject *tmp_call_result_5; | ||
| 1720 | PyObject *tmp_args_element_name_12; | ||
| 1721 | PyObject *tmp_args_element_name_13; | ||
| 1722 | PyObject *tmp_args_element_name_14; | ||
| 1723 | PyObject *tmp_called_instance_6; | ||
| 1724 | PyObject *tmp_source_name_9; | ||
| 1725 | PyObject *tmp_mvar_value_13; | ||
| 1726 | tmp_mvar_value_12 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1727 | |||
| 1728 | if (unlikely( tmp_mvar_value_12 == NULL )) | ||
| 1729 | { | ||
| 1730 | tmp_mvar_value_12 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1731 | } | ||
| 1732 | |||
| 1733 | if ( tmp_mvar_value_12 == NULL ) | ||
| 1734 | { | ||
| 1735 | |||
| 1736 | exception_type = PyExc_NameError; | ||
| 1737 | Py_INCREF( exception_type ); | ||
| 1738 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 1739 | exception_tb = NULL; | ||
| 1740 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1741 | CHAIN_EXCEPTION( exception_value ); | ||
| 1742 | |||
| 1743 | exception_lineno = 32; | ||
| 1744 | |||
| 1745 | goto frame_exception_exit_1; | ||
| 1746 | } | ||
| 1747 | |||
| 1748 | tmp_source_name_8 = tmp_mvar_value_12; | ||
| 1749 | tmp_called_name_5 = LOOKUP_ATTRIBUTE( tmp_source_name_8, const_str_plain_set ); | ||
| 1750 | if ( tmp_called_name_5 == NULL ) | ||
| 1751 | { | ||
| 1752 | assert( ERROR_OCCURRED() ); | ||
| 1753 | |||
| 1754 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1755 | |||
| 1756 | |||
| 1757 | exception_lineno = 32; | ||
| 1758 | |||
| 1759 | goto frame_exception_exit_1; | ||
| 1760 | } | ||
| 1761 | tmp_args_element_name_12 = const_str_plain_Main; | ||
| 1762 | tmp_args_element_name_13 = const_str_plain_Product; | ||
| 1763 | tmp_mvar_value_13 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1764 | |||
| 1765 | if (unlikely( tmp_mvar_value_13 == NULL )) | ||
| 1766 | { | ||
| 1767 | tmp_mvar_value_13 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1768 | } | ||
| 1769 | |||
| 1770 | if ( tmp_mvar_value_13 == NULL ) | ||
| 1771 | { | ||
| 1772 | Py_DECREF( tmp_called_name_5 ); | ||
| 1773 | exception_type = PyExc_NameError; | ||
| 1774 | Py_INCREF( exception_type ); | ||
| 1775 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "os" ); | ||
| 1776 | exception_tb = NULL; | ||
| 1777 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1778 | CHAIN_EXCEPTION( exception_value ); | ||
| 1779 | |||
| 1780 | exception_lineno = 32; | ||
| 1781 | |||
| 1782 | goto frame_exception_exit_1; | ||
| 1783 | } | ||
| 1784 | |||
| 1785 | tmp_source_name_9 = tmp_mvar_value_13; | ||
| 1786 | tmp_called_instance_6 = LOOKUP_ATTRIBUTE( tmp_source_name_9, const_str_plain_environ ); | ||
| 1787 | if ( tmp_called_instance_6 == NULL ) | ||
| 1788 | { | ||
| 1789 | assert( ERROR_OCCURRED() ); | ||
| 1790 | |||
| 1791 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1792 | Py_DECREF( tmp_called_name_5 ); | ||
| 1793 | |||
| 1794 | exception_lineno = 32; | ||
| 1795 | |||
| 1796 | goto frame_exception_exit_1; | ||
| 1797 | } | ||
| 1798 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 32; | ||
| 1799 | tmp_args_element_name_14 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_6, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_ANACONDA_PRODUCTNAME_str_plain_anaconda_tuple, 0 ) ); | ||
| 1800 | |||
| 1801 | Py_DECREF( tmp_called_instance_6 ); | ||
| 1802 | if ( tmp_args_element_name_14 == NULL ) | ||
| 1803 | { | ||
| 1804 | assert( ERROR_OCCURRED() ); | ||
| 1805 | |||
| 1806 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1807 | Py_DECREF( tmp_called_name_5 ); | ||
| 1808 | |||
| 1809 | exception_lineno = 32; | ||
| 1810 | |||
| 1811 | goto frame_exception_exit_1; | ||
| 1812 | } | ||
| 1813 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 32; | ||
| 1814 | { | ||
| 1815 | PyObject *call_args[] = { tmp_args_element_name_12, tmp_args_element_name_13, tmp_args_element_name_14 }; | ||
| 1816 | tmp_call_result_5 = CALL_FUNCTION_WITH_ARGS3( tmp_called_name_5, call_args ); | ||
| 1817 | } | ||
| 1818 | |||
| 1819 | Py_DECREF( tmp_called_name_5 ); | ||
| 1820 | Py_DECREF( tmp_args_element_name_14 ); | ||
| 1821 | if ( tmp_call_result_5 == NULL ) | ||
| 1822 | { | ||
| 1823 | assert( ERROR_OCCURRED() ); | ||
| 1824 | |||
| 1825 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1826 | |||
| 1827 | |||
| 1828 | exception_lineno = 32; | ||
| 1829 | |||
| 1830 | goto frame_exception_exit_1; | ||
| 1831 | } | ||
| 1832 | Py_DECREF( tmp_call_result_5 ); | ||
| 1833 | } | ||
| 1834 | { | ||
| 1835 | PyObject *tmp_called_name_6; | ||
| 1836 | PyObject *tmp_source_name_10; | ||
| 1837 | PyObject *tmp_mvar_value_14; | ||
| 1838 | PyObject *tmp_call_result_6; | ||
| 1839 | PyObject *tmp_args_element_name_15; | ||
| 1840 | PyObject *tmp_args_element_name_16; | ||
| 1841 | PyObject *tmp_args_element_name_17; | ||
| 1842 | PyObject *tmp_called_instance_7; | ||
| 1843 | PyObject *tmp_source_name_11; | ||
| 1844 | PyObject *tmp_mvar_value_15; | ||
| 1845 | tmp_mvar_value_14 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1846 | |||
| 1847 | if (unlikely( tmp_mvar_value_14 == NULL )) | ||
| 1848 | { | ||
| 1849 | tmp_mvar_value_14 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1850 | } | ||
| 1851 | |||
| 1852 | if ( tmp_mvar_value_14 == NULL ) | ||
| 1853 | { | ||
| 1854 | |||
| 1855 | exception_type = PyExc_NameError; | ||
| 1856 | Py_INCREF( exception_type ); | ||
| 1857 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 1858 | exception_tb = NULL; | ||
| 1859 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1860 | CHAIN_EXCEPTION( exception_value ); | ||
| 1861 | |||
| 1862 | exception_lineno = 33; | ||
| 1863 | |||
| 1864 | goto frame_exception_exit_1; | ||
| 1865 | } | ||
| 1866 | |||
| 1867 | tmp_source_name_10 = tmp_mvar_value_14; | ||
| 1868 | tmp_called_name_6 = LOOKUP_ATTRIBUTE( tmp_source_name_10, const_str_plain_set ); | ||
| 1869 | if ( tmp_called_name_6 == NULL ) | ||
| 1870 | { | ||
| 1871 | assert( ERROR_OCCURRED() ); | ||
| 1872 | |||
| 1873 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1874 | |||
| 1875 | |||
| 1876 | exception_lineno = 33; | ||
| 1877 | |||
| 1878 | goto frame_exception_exit_1; | ||
| 1879 | } | ||
| 1880 | tmp_args_element_name_15 = const_str_plain_Main; | ||
| 1881 | tmp_args_element_name_16 = const_str_plain_Variant; | ||
| 1882 | tmp_mvar_value_15 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1883 | |||
| 1884 | if (unlikely( tmp_mvar_value_15 == NULL )) | ||
| 1885 | { | ||
| 1886 | tmp_mvar_value_15 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 1887 | } | ||
| 1888 | |||
| 1889 | if ( tmp_mvar_value_15 == NULL ) | ||
| 1890 | { | ||
| 1891 | Py_DECREF( tmp_called_name_6 ); | ||
| 1892 | exception_type = PyExc_NameError; | ||
| 1893 | Py_INCREF( exception_type ); | ||
| 1894 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "os" ); | ||
| 1895 | exception_tb = NULL; | ||
| 1896 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1897 | CHAIN_EXCEPTION( exception_value ); | ||
| 1898 | |||
| 1899 | exception_lineno = 33; | ||
| 1900 | |||
| 1901 | goto frame_exception_exit_1; | ||
| 1902 | } | ||
| 1903 | |||
| 1904 | tmp_source_name_11 = tmp_mvar_value_15; | ||
| 1905 | tmp_called_instance_7 = LOOKUP_ATTRIBUTE( tmp_source_name_11, const_str_plain_environ ); | ||
| 1906 | if ( tmp_called_instance_7 == NULL ) | ||
| 1907 | { | ||
| 1908 | assert( ERROR_OCCURRED() ); | ||
| 1909 | |||
| 1910 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1911 | Py_DECREF( tmp_called_name_6 ); | ||
| 1912 | |||
| 1913 | exception_lineno = 33; | ||
| 1914 | |||
| 1915 | goto frame_exception_exit_1; | ||
| 1916 | } | ||
| 1917 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 33; | ||
| 1918 | tmp_args_element_name_17 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_7, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_ANACONDA_PRODUCTVARIANT_str_empty_tuple, 0 ) ); | ||
| 1919 | |||
| 1920 | Py_DECREF( tmp_called_instance_7 ); | ||
| 1921 | if ( tmp_args_element_name_17 == NULL ) | ||
| 1922 | { | ||
| 1923 | assert( ERROR_OCCURRED() ); | ||
| 1924 | |||
| 1925 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1926 | Py_DECREF( tmp_called_name_6 ); | ||
| 1927 | |||
| 1928 | exception_lineno = 33; | ||
| 1929 | |||
| 1930 | goto frame_exception_exit_1; | ||
| 1931 | } | ||
| 1932 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 33; | ||
| 1933 | { | ||
| 1934 | PyObject *call_args[] = { tmp_args_element_name_15, tmp_args_element_name_16, tmp_args_element_name_17 }; | ||
| 1935 | tmp_call_result_6 = CALL_FUNCTION_WITH_ARGS3( tmp_called_name_6, call_args ); | ||
| 1936 | } | ||
| 1937 | |||
| 1938 | Py_DECREF( tmp_called_name_6 ); | ||
| 1939 | Py_DECREF( tmp_args_element_name_17 ); | ||
| 1940 | if ( tmp_call_result_6 == NULL ) | ||
| 1941 | { | ||
| 1942 | assert( ERROR_OCCURRED() ); | ||
| 1943 | |||
| 1944 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1945 | |||
| 1946 | |||
| 1947 | exception_lineno = 33; | ||
| 1948 | |||
| 1949 | goto frame_exception_exit_1; | ||
| 1950 | } | ||
| 1951 | Py_DECREF( tmp_call_result_6 ); | ||
| 1952 | } | ||
| 1953 | { | ||
| 1954 | PyObject *tmp_called_instance_8; | ||
| 1955 | PyObject *tmp_mvar_value_16; | ||
| 1956 | PyObject *tmp_call_result_7; | ||
| 1957 | tmp_mvar_value_16 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1958 | |||
| 1959 | if (unlikely( tmp_mvar_value_16 == NULL )) | ||
| 1960 | { | ||
| 1961 | tmp_mvar_value_16 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 1962 | } | ||
| 1963 | |||
| 1964 | if ( tmp_mvar_value_16 == NULL ) | ||
| 1965 | { | ||
| 1966 | |||
| 1967 | exception_type = PyExc_NameError; | ||
| 1968 | Py_INCREF( exception_type ); | ||
| 1969 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 1970 | exception_tb = NULL; | ||
| 1971 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 1972 | CHAIN_EXCEPTION( exception_value ); | ||
| 1973 | |||
| 1974 | exception_lineno = 34; | ||
| 1975 | |||
| 1976 | goto frame_exception_exit_1; | ||
| 1977 | } | ||
| 1978 | |||
| 1979 | tmp_called_instance_8 = tmp_mvar_value_16; | ||
| 1980 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 34; | ||
| 1981 | tmp_call_result_7 = CALL_METHOD_WITH_ARGS3( tmp_called_instance_8, const_str_plain_set, &PyTuple_GET_ITEM( const_tuple_str_plain_Main_str_plain_UUID_str_empty_tuple, 0 ) ); | ||
| 1982 | |||
| 1983 | if ( tmp_call_result_7 == NULL ) | ||
| 1984 | { | ||
| 1985 | assert( ERROR_OCCURRED() ); | ||
| 1986 | |||
| 1987 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1988 | |||
| 1989 | |||
| 1990 | exception_lineno = 34; | ||
| 1991 | |||
| 1992 | goto frame_exception_exit_1; | ||
| 1993 | } | ||
| 1994 | Py_DECREF( tmp_call_result_7 ); | ||
| 1995 | } | ||
| 1996 | { | ||
| 1997 | PyObject *tmp_called_name_7; | ||
| 1998 | PyObject *tmp_source_name_12; | ||
| 1999 | PyObject *tmp_mvar_value_17; | ||
| 2000 | PyObject *tmp_call_result_8; | ||
| 2001 | PyObject *tmp_args_element_name_18; | ||
| 2002 | PyObject *tmp_args_element_name_19; | ||
| 2003 | PyObject *tmp_args_element_name_20; | ||
| 2004 | PyObject *tmp_called_instance_9; | ||
| 2005 | PyObject *tmp_source_name_13; | ||
| 2006 | PyObject *tmp_mvar_value_18; | ||
| 2007 | tmp_mvar_value_17 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2008 | |||
| 2009 | if (unlikely( tmp_mvar_value_17 == NULL )) | ||
| 2010 | { | ||
| 2011 | tmp_mvar_value_17 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2012 | } | ||
| 2013 | |||
| 2014 | if ( tmp_mvar_value_17 == NULL ) | ||
| 2015 | { | ||
| 2016 | |||
| 2017 | exception_type = PyExc_NameError; | ||
| 2018 | Py_INCREF( exception_type ); | ||
| 2019 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 2020 | exception_tb = NULL; | ||
| 2021 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2022 | CHAIN_EXCEPTION( exception_value ); | ||
| 2023 | |||
| 2024 | exception_lineno = 35; | ||
| 2025 | |||
| 2026 | goto frame_exception_exit_1; | ||
| 2027 | } | ||
| 2028 | |||
| 2029 | tmp_source_name_12 = tmp_mvar_value_17; | ||
| 2030 | tmp_called_name_7 = LOOKUP_ATTRIBUTE( tmp_source_name_12, const_str_plain_set ); | ||
| 2031 | if ( tmp_called_name_7 == NULL ) | ||
| 2032 | { | ||
| 2033 | assert( ERROR_OCCURRED() ); | ||
| 2034 | |||
| 2035 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2036 | |||
| 2037 | |||
| 2038 | exception_lineno = 35; | ||
| 2039 | |||
| 2040 | goto frame_exception_exit_1; | ||
| 2041 | } | ||
| 2042 | tmp_args_element_name_18 = const_str_plain_Main; | ||
| 2043 | tmp_args_element_name_19 = const_str_plain_Version; | ||
| 2044 | tmp_mvar_value_18 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 2045 | |||
| 2046 | if (unlikely( tmp_mvar_value_18 == NULL )) | ||
| 2047 | { | ||
| 2048 | tmp_mvar_value_18 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 2049 | } | ||
| 2050 | |||
| 2051 | if ( tmp_mvar_value_18 == NULL ) | ||
| 2052 | { | ||
| 2053 | Py_DECREF( tmp_called_name_7 ); | ||
| 2054 | exception_type = PyExc_NameError; | ||
| 2055 | Py_INCREF( exception_type ); | ||
| 2056 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "os" ); | ||
| 2057 | exception_tb = NULL; | ||
| 2058 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2059 | CHAIN_EXCEPTION( exception_value ); | ||
| 2060 | |||
| 2061 | exception_lineno = 35; | ||
| 2062 | |||
| 2063 | goto frame_exception_exit_1; | ||
| 2064 | } | ||
| 2065 | |||
| 2066 | tmp_source_name_13 = tmp_mvar_value_18; | ||
| 2067 | tmp_called_instance_9 = LOOKUP_ATTRIBUTE( tmp_source_name_13, const_str_plain_environ ); | ||
| 2068 | if ( tmp_called_instance_9 == NULL ) | ||
| 2069 | { | ||
| 2070 | assert( ERROR_OCCURRED() ); | ||
| 2071 | |||
| 2072 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2073 | Py_DECREF( tmp_called_name_7 ); | ||
| 2074 | |||
| 2075 | exception_lineno = 35; | ||
| 2076 | |||
| 2077 | goto frame_exception_exit_1; | ||
| 2078 | } | ||
| 2079 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 35; | ||
| 2080 | tmp_args_element_name_20 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_9, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_ANACONDA_PRODUCTVERSION_str_plain_bluesky_tuple, 0 ) ); | ||
| 2081 | |||
| 2082 | Py_DECREF( tmp_called_instance_9 ); | ||
| 2083 | if ( tmp_args_element_name_20 == NULL ) | ||
| 2084 | { | ||
| 2085 | assert( ERROR_OCCURRED() ); | ||
| 2086 | |||
| 2087 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2088 | Py_DECREF( tmp_called_name_7 ); | ||
| 2089 | |||
| 2090 | exception_lineno = 35; | ||
| 2091 | |||
| 2092 | goto frame_exception_exit_1; | ||
| 2093 | } | ||
| 2094 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 35; | ||
| 2095 | { | ||
| 2096 | PyObject *call_args[] = { tmp_args_element_name_18, tmp_args_element_name_19, tmp_args_element_name_20 }; | ||
| 2097 | tmp_call_result_8 = CALL_FUNCTION_WITH_ARGS3( tmp_called_name_7, call_args ); | ||
| 2098 | } | ||
| 2099 | |||
| 2100 | Py_DECREF( tmp_called_name_7 ); | ||
| 2101 | Py_DECREF( tmp_args_element_name_20 ); | ||
| 2102 | if ( tmp_call_result_8 == NULL ) | ||
| 2103 | { | ||
| 2104 | assert( ERROR_OCCURRED() ); | ||
| 2105 | |||
| 2106 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2107 | |||
| 2108 | |||
| 2109 | exception_lineno = 35; | ||
| 2110 | |||
| 2111 | goto frame_exception_exit_1; | ||
| 2112 | } | ||
| 2113 | Py_DECREF( tmp_call_result_8 ); | ||
| 2114 | } | ||
| 2115 | { | ||
| 2116 | PyObject *tmp_called_name_8; | ||
| 2117 | PyObject *tmp_source_name_14; | ||
| 2118 | PyObject *tmp_mvar_value_19; | ||
| 2119 | PyObject *tmp_call_result_9; | ||
| 2120 | PyObject *tmp_args_element_name_21; | ||
| 2121 | PyObject *tmp_list_element_1; | ||
| 2122 | PyObject *tmp_called_instance_10; | ||
| 2123 | PyObject *tmp_source_name_15; | ||
| 2124 | PyObject *tmp_mvar_value_20; | ||
| 2125 | tmp_mvar_value_19 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2126 | |||
| 2127 | if (unlikely( tmp_mvar_value_19 == NULL )) | ||
| 2128 | { | ||
| 2129 | tmp_mvar_value_19 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2130 | } | ||
| 2131 | |||
| 2132 | if ( tmp_mvar_value_19 == NULL ) | ||
| 2133 | { | ||
| 2134 | |||
| 2135 | exception_type = PyExc_NameError; | ||
| 2136 | Py_INCREF( exception_type ); | ||
| 2137 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 2138 | exception_tb = NULL; | ||
| 2139 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2140 | CHAIN_EXCEPTION( exception_value ); | ||
| 2141 | |||
| 2142 | exception_lineno = 38; | ||
| 2143 | |||
| 2144 | goto frame_exception_exit_1; | ||
| 2145 | } | ||
| 2146 | |||
| 2147 | tmp_source_name_14 = tmp_mvar_value_19; | ||
| 2148 | tmp_called_name_8 = LOOKUP_ATTRIBUTE( tmp_source_name_14, const_str_plain_read ); | ||
| 2149 | if ( tmp_called_name_8 == NULL ) | ||
| 2150 | { | ||
| 2151 | assert( ERROR_OCCURRED() ); | ||
| 2152 | |||
| 2153 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2154 | |||
| 2155 | |||
| 2156 | exception_lineno = 38; | ||
| 2157 | |||
| 2158 | goto frame_exception_exit_1; | ||
| 2159 | } | ||
| 2160 | tmp_list_element_1 = const_str_digest_d37b13b47eafe43d94d94046592bb5a1; | ||
| 2161 | tmp_args_element_name_21 = PyList_New( 3 ); | ||
| 2162 | Py_INCREF( tmp_list_element_1 ); | ||
| 2163 | PyList_SET_ITEM( tmp_args_element_name_21, 0, tmp_list_element_1 ); | ||
| 2164 | tmp_list_element_1 = const_str_digest_f259902e5c4e3accbfad88a2489e5d77; | ||
| 2165 | Py_INCREF( tmp_list_element_1 ); | ||
| 2166 | PyList_SET_ITEM( tmp_args_element_name_21, 1, tmp_list_element_1 ); | ||
| 2167 | tmp_mvar_value_20 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 2168 | |||
| 2169 | if (unlikely( tmp_mvar_value_20 == NULL )) | ||
| 2170 | { | ||
| 2171 | tmp_mvar_value_20 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_os ); | ||
| 2172 | } | ||
| 2173 | |||
| 2174 | if ( tmp_mvar_value_20 == NULL ) | ||
| 2175 | { | ||
| 2176 | Py_DECREF( tmp_called_name_8 ); | ||
| 2177 | Py_DECREF( tmp_args_element_name_21 ); | ||
| 2178 | exception_type = PyExc_NameError; | ||
| 2179 | Py_INCREF( exception_type ); | ||
| 2180 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "os" ); | ||
| 2181 | exception_tb = NULL; | ||
| 2182 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2183 | CHAIN_EXCEPTION( exception_value ); | ||
| 2184 | |||
| 2185 | exception_lineno = 38; | ||
| 2186 | |||
| 2187 | goto frame_exception_exit_1; | ||
| 2188 | } | ||
| 2189 | |||
| 2190 | tmp_source_name_15 = tmp_mvar_value_20; | ||
| 2191 | tmp_called_instance_10 = LOOKUP_ATTRIBUTE( tmp_source_name_15, const_str_plain_environ ); | ||
| 2192 | if ( tmp_called_instance_10 == NULL ) | ||
| 2193 | { | ||
| 2194 | assert( ERROR_OCCURRED() ); | ||
| 2195 | |||
| 2196 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2197 | Py_DECREF( tmp_called_name_8 ); | ||
| 2198 | Py_DECREF( tmp_args_element_name_21 ); | ||
| 2199 | |||
| 2200 | exception_lineno = 38; | ||
| 2201 | |||
| 2202 | goto frame_exception_exit_1; | ||
| 2203 | } | ||
| 2204 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 38; | ||
| 2205 | tmp_list_element_1 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_10, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_PRODBUILDPATH_str_empty_tuple, 0 ) ); | ||
| 2206 | |||
| 2207 | Py_DECREF( tmp_called_instance_10 ); | ||
| 2208 | if ( tmp_list_element_1 == NULL ) | ||
| 2209 | { | ||
| 2210 | assert( ERROR_OCCURRED() ); | ||
| 2211 | |||
| 2212 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2213 | Py_DECREF( tmp_called_name_8 ); | ||
| 2214 | Py_DECREF( tmp_args_element_name_21 ); | ||
| 2215 | |||
| 2216 | exception_lineno = 38; | ||
| 2217 | |||
| 2218 | goto frame_exception_exit_1; | ||
| 2219 | } | ||
| 2220 | PyList_SET_ITEM( tmp_args_element_name_21, 2, tmp_list_element_1 ); | ||
| 2221 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 38; | ||
| 2222 | { | ||
| 2223 | PyObject *call_args[] = { tmp_args_element_name_21 }; | ||
| 2224 | tmp_call_result_9 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_8, call_args ); | ||
| 2225 | } | ||
| 2226 | |||
| 2227 | Py_DECREF( tmp_called_name_8 ); | ||
| 2228 | Py_DECREF( tmp_args_element_name_21 ); | ||
| 2229 | if ( tmp_call_result_9 == NULL ) | ||
| 2230 | { | ||
| 2231 | assert( ERROR_OCCURRED() ); | ||
| 2232 | |||
| 2233 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2234 | |||
| 2235 | |||
| 2236 | exception_lineno = 38; | ||
| 2237 | |||
| 2238 | goto frame_exception_exit_1; | ||
| 2239 | } | ||
| 2240 | Py_DECREF( tmp_call_result_9 ); | ||
| 2241 | } | ||
| 2242 | { | ||
| 2243 | PyObject *tmp_assign_source_8; | ||
| 2244 | PyObject *tmp_called_instance_11; | ||
| 2245 | PyObject *tmp_mvar_value_21; | ||
| 2246 | tmp_mvar_value_21 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2247 | |||
| 2248 | if (unlikely( tmp_mvar_value_21 == NULL )) | ||
| 2249 | { | ||
| 2250 | tmp_mvar_value_21 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2251 | } | ||
| 2252 | |||
| 2253 | if ( tmp_mvar_value_21 == NULL ) | ||
| 2254 | { | ||
| 2255 | |||
| 2256 | exception_type = PyExc_NameError; | ||
| 2257 | Py_INCREF( exception_type ); | ||
| 2258 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 2259 | exception_tb = NULL; | ||
| 2260 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2261 | CHAIN_EXCEPTION( exception_value ); | ||
| 2262 | |||
| 2263 | exception_lineno = 41; | ||
| 2264 | |||
| 2265 | goto frame_exception_exit_1; | ||
| 2266 | } | ||
| 2267 | |||
| 2268 | tmp_called_instance_11 = tmp_mvar_value_21; | ||
| 2269 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 41; | ||
| 2270 | tmp_assign_source_8 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_11, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_Main_str_plain_BugURL_tuple, 0 ) ); | ||
| 2271 | |||
| 2272 | if ( tmp_assign_source_8 == NULL ) | ||
| 2273 | { | ||
| 2274 | assert( ERROR_OCCURRED() ); | ||
| 2275 | |||
| 2276 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2277 | |||
| 2278 | |||
| 2279 | exception_lineno = 41; | ||
| 2280 | |||
| 2281 | goto frame_exception_exit_1; | ||
| 2282 | } | ||
| 2283 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_bugUrl, tmp_assign_source_8 ); | ||
| 2284 | } | ||
| 2285 | { | ||
| 2286 | PyObject *tmp_assign_source_9; | ||
| 2287 | PyObject *tmp_called_instance_12; | ||
| 2288 | PyObject *tmp_mvar_value_22; | ||
| 2289 | tmp_mvar_value_22 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2290 | |||
| 2291 | if (unlikely( tmp_mvar_value_22 == NULL )) | ||
| 2292 | { | ||
| 2293 | tmp_mvar_value_22 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2294 | } | ||
| 2295 | |||
| 2296 | if ( tmp_mvar_value_22 == NULL ) | ||
| 2297 | { | ||
| 2298 | |||
| 2299 | exception_type = PyExc_NameError; | ||
| 2300 | Py_INCREF( exception_type ); | ||
| 2301 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 2302 | exception_tb = NULL; | ||
| 2303 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2304 | CHAIN_EXCEPTION( exception_value ); | ||
| 2305 | |||
| 2306 | exception_lineno = 42; | ||
| 2307 | |||
| 2308 | goto frame_exception_exit_1; | ||
| 2309 | } | ||
| 2310 | |||
| 2311 | tmp_called_instance_12 = tmp_mvar_value_22; | ||
| 2312 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 42; | ||
| 2313 | tmp_assign_source_9 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_12, const_str_plain_getboolean, &PyTuple_GET_ITEM( const_tuple_str_plain_Main_str_plain_IsFinal_tuple, 0 ) ); | ||
| 2314 | |||
| 2315 | if ( tmp_assign_source_9 == NULL ) | ||
| 2316 | { | ||
| 2317 | assert( ERROR_OCCURRED() ); | ||
| 2318 | |||
| 2319 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2320 | |||
| 2321 | |||
| 2322 | exception_lineno = 42; | ||
| 2323 | |||
| 2324 | goto frame_exception_exit_1; | ||
| 2325 | } | ||
| 2326 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_isFinal, tmp_assign_source_9 ); | ||
| 2327 | } | ||
| 2328 | { | ||
| 2329 | PyObject *tmp_assign_source_10; | ||
| 2330 | PyObject *tmp_called_instance_13; | ||
| 2331 | PyObject *tmp_mvar_value_23; | ||
| 2332 | tmp_mvar_value_23 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2333 | |||
| 2334 | if (unlikely( tmp_mvar_value_23 == NULL )) | ||
| 2335 | { | ||
| 2336 | tmp_mvar_value_23 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2337 | } | ||
| 2338 | |||
| 2339 | if ( tmp_mvar_value_23 == NULL ) | ||
| 2340 | { | ||
| 2341 | |||
| 2342 | exception_type = PyExc_NameError; | ||
| 2343 | Py_INCREF( exception_type ); | ||
| 2344 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 2345 | exception_tb = NULL; | ||
| 2346 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2347 | CHAIN_EXCEPTION( exception_value ); | ||
| 2348 | |||
| 2349 | exception_lineno = 43; | ||
| 2350 | |||
| 2351 | goto frame_exception_exit_1; | ||
| 2352 | } | ||
| 2353 | |||
| 2354 | tmp_called_instance_13 = tmp_mvar_value_23; | ||
| 2355 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 43; | ||
| 2356 | tmp_assign_source_10 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_13, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_Main_str_plain_Arch_tuple, 0 ) ); | ||
| 2357 | |||
| 2358 | if ( tmp_assign_source_10 == NULL ) | ||
| 2359 | { | ||
| 2360 | assert( ERROR_OCCURRED() ); | ||
| 2361 | |||
| 2362 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2363 | |||
| 2364 | |||
| 2365 | exception_lineno = 43; | ||
| 2366 | |||
| 2367 | goto frame_exception_exit_1; | ||
| 2368 | } | ||
| 2369 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productArch, tmp_assign_source_10 ); | ||
| 2370 | } | ||
| 2371 | { | ||
| 2372 | PyObject *tmp_assign_source_11; | ||
| 2373 | PyObject *tmp_called_instance_14; | ||
| 2374 | PyObject *tmp_mvar_value_24; | ||
| 2375 | tmp_mvar_value_24 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2376 | |||
| 2377 | if (unlikely( tmp_mvar_value_24 == NULL )) | ||
| 2378 | { | ||
| 2379 | tmp_mvar_value_24 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2380 | } | ||
| 2381 | |||
| 2382 | if ( tmp_mvar_value_24 == NULL ) | ||
| 2383 | { | ||
| 2384 | |||
| 2385 | exception_type = PyExc_NameError; | ||
| 2386 | Py_INCREF( exception_type ); | ||
| 2387 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 2388 | exception_tb = NULL; | ||
| 2389 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2390 | CHAIN_EXCEPTION( exception_value ); | ||
| 2391 | |||
| 2392 | exception_lineno = 44; | ||
| 2393 | |||
| 2394 | goto frame_exception_exit_1; | ||
| 2395 | } | ||
| 2396 | |||
| 2397 | tmp_called_instance_14 = tmp_mvar_value_24; | ||
| 2398 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 44; | ||
| 2399 | tmp_assign_source_11 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_14, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_Main_str_plain_Product_tuple, 0 ) ); | ||
| 2400 | |||
| 2401 | if ( tmp_assign_source_11 == NULL ) | ||
| 2402 | { | ||
| 2403 | assert( ERROR_OCCURRED() ); | ||
| 2404 | |||
| 2405 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2406 | |||
| 2407 | |||
| 2408 | exception_lineno = 44; | ||
| 2409 | |||
| 2410 | goto frame_exception_exit_1; | ||
| 2411 | } | ||
| 2412 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productName, tmp_assign_source_11 ); | ||
| 2413 | } | ||
| 2414 | { | ||
| 2415 | PyObject *tmp_assign_source_12; | ||
| 2416 | PyObject *tmp_called_instance_15; | ||
| 2417 | PyObject *tmp_mvar_value_25; | ||
| 2418 | tmp_mvar_value_25 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2419 | |||
| 2420 | if (unlikely( tmp_mvar_value_25 == NULL )) | ||
| 2421 | { | ||
| 2422 | tmp_mvar_value_25 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2423 | } | ||
| 2424 | |||
| 2425 | if ( tmp_mvar_value_25 == NULL ) | ||
| 2426 | { | ||
| 2427 | |||
| 2428 | exception_type = PyExc_NameError; | ||
| 2429 | Py_INCREF( exception_type ); | ||
| 2430 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 2431 | exception_tb = NULL; | ||
| 2432 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2433 | CHAIN_EXCEPTION( exception_value ); | ||
| 2434 | |||
| 2435 | exception_lineno = 45; | ||
| 2436 | |||
| 2437 | goto frame_exception_exit_1; | ||
| 2438 | } | ||
| 2439 | |||
| 2440 | tmp_called_instance_15 = tmp_mvar_value_25; | ||
| 2441 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 45; | ||
| 2442 | tmp_assign_source_12 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_15, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_Main_str_plain_Variant_tuple, 0 ) ); | ||
| 2443 | |||
| 2444 | if ( tmp_assign_source_12 == NULL ) | ||
| 2445 | { | ||
| 2446 | assert( ERROR_OCCURRED() ); | ||
| 2447 | |||
| 2448 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2449 | |||
| 2450 | |||
| 2451 | exception_lineno = 45; | ||
| 2452 | |||
| 2453 | goto frame_exception_exit_1; | ||
| 2454 | } | ||
| 2455 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productVariant, tmp_assign_source_12 ); | ||
| 2456 | } | ||
| 2457 | { | ||
| 2458 | PyObject *tmp_assign_source_13; | ||
| 2459 | PyObject *tmp_called_instance_16; | ||
| 2460 | PyObject *tmp_mvar_value_26; | ||
| 2461 | tmp_mvar_value_26 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2462 | |||
| 2463 | if (unlikely( tmp_mvar_value_26 == NULL )) | ||
| 2464 | { | ||
| 2465 | tmp_mvar_value_26 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2466 | } | ||
| 2467 | |||
| 2468 | if ( tmp_mvar_value_26 == NULL ) | ||
| 2469 | { | ||
| 2470 | |||
| 2471 | exception_type = PyExc_NameError; | ||
| 2472 | Py_INCREF( exception_type ); | ||
| 2473 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 2474 | exception_tb = NULL; | ||
| 2475 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2476 | CHAIN_EXCEPTION( exception_value ); | ||
| 2477 | |||
| 2478 | exception_lineno = 46; | ||
| 2479 | |||
| 2480 | goto frame_exception_exit_1; | ||
| 2481 | } | ||
| 2482 | |||
| 2483 | tmp_called_instance_16 = tmp_mvar_value_26; | ||
| 2484 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 46; | ||
| 2485 | tmp_assign_source_13 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_16, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_Main_str_plain_UUID_tuple, 0 ) ); | ||
| 2486 | |||
| 2487 | if ( tmp_assign_source_13 == NULL ) | ||
| 2488 | { | ||
| 2489 | assert( ERROR_OCCURRED() ); | ||
| 2490 | |||
| 2491 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2492 | |||
| 2493 | |||
| 2494 | exception_lineno = 46; | ||
| 2495 | |||
| 2496 | goto frame_exception_exit_1; | ||
| 2497 | } | ||
| 2498 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productStamp, tmp_assign_source_13 ); | ||
| 2499 | } | ||
| 2500 | { | ||
| 2501 | PyObject *tmp_assign_source_14; | ||
| 2502 | PyObject *tmp_called_instance_17; | ||
| 2503 | PyObject *tmp_mvar_value_27; | ||
| 2504 | tmp_mvar_value_27 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2505 | |||
| 2506 | if (unlikely( tmp_mvar_value_27 == NULL )) | ||
| 2507 | { | ||
| 2508 | tmp_mvar_value_27 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_config ); | ||
| 2509 | } | ||
| 2510 | |||
| 2511 | if ( tmp_mvar_value_27 == NULL ) | ||
| 2512 | { | ||
| 2513 | |||
| 2514 | exception_type = PyExc_NameError; | ||
| 2515 | Py_INCREF( exception_type ); | ||
| 2516 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "config" ); | ||
| 2517 | exception_tb = NULL; | ||
| 2518 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2519 | CHAIN_EXCEPTION( exception_value ); | ||
| 2520 | |||
| 2521 | exception_lineno = 47; | ||
| 2522 | |||
| 2523 | goto frame_exception_exit_1; | ||
| 2524 | } | ||
| 2525 | |||
| 2526 | tmp_called_instance_17 = tmp_mvar_value_27; | ||
| 2527 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 47; | ||
| 2528 | tmp_assign_source_14 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_17, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_str_plain_Main_str_plain_Version_tuple, 0 ) ); | ||
| 2529 | |||
| 2530 | if ( tmp_assign_source_14 == NULL ) | ||
| 2531 | { | ||
| 2532 | assert( ERROR_OCCURRED() ); | ||
| 2533 | |||
| 2534 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2535 | |||
| 2536 | |||
| 2537 | exception_lineno = 47; | ||
| 2538 | |||
| 2539 | goto frame_exception_exit_1; | ||
| 2540 | } | ||
| 2541 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productVersion, tmp_assign_source_14 ); | ||
| 2542 | } | ||
| 2543 | { | ||
| 2544 | nuitka_bool tmp_condition_result_1; | ||
| 2545 | int tmp_and_left_truth_1; | ||
| 2546 | nuitka_bool tmp_and_left_value_1; | ||
| 2547 | nuitka_bool tmp_and_right_value_1; | ||
| 2548 | PyObject *tmp_operand_name_1; | ||
| 2549 | PyObject *tmp_mvar_value_28; | ||
| 2550 | PyObject *tmp_compexpr_left_1; | ||
| 2551 | PyObject *tmp_compexpr_right_1; | ||
| 2552 | PyObject *tmp_called_instance_18; | ||
| 2553 | PyObject *tmp_mvar_value_29; | ||
| 2554 | tmp_mvar_value_28 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productArch ); | ||
| 2555 | |||
| 2556 | if (unlikely( tmp_mvar_value_28 == NULL )) | ||
| 2557 | { | ||
| 2558 | tmp_mvar_value_28 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_productArch ); | ||
| 2559 | } | ||
| 2560 | |||
| 2561 | if ( tmp_mvar_value_28 == NULL ) | ||
| 2562 | { | ||
| 2563 | |||
| 2564 | exception_type = PyExc_NameError; | ||
| 2565 | Py_INCREF( exception_type ); | ||
| 2566 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "productArch" ); | ||
| 2567 | exception_tb = NULL; | ||
| 2568 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2569 | CHAIN_EXCEPTION( exception_value ); | ||
| 2570 | |||
| 2571 | exception_lineno = 49; | ||
| 2572 | |||
| 2573 | goto frame_exception_exit_1; | ||
| 2574 | } | ||
| 2575 | |||
| 2576 | tmp_operand_name_1 = tmp_mvar_value_28; | ||
| 2577 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 2578 | if ( tmp_res == -1 ) | ||
| 2579 | { | ||
| 2580 | assert( ERROR_OCCURRED() ); | ||
| 2581 | |||
| 2582 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2583 | |||
| 2584 | |||
| 2585 | exception_lineno = 49; | ||
| 2586 | |||
| 2587 | goto frame_exception_exit_1; | ||
| 2588 | } | ||
| 2589 | tmp_and_left_value_1 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2590 | tmp_and_left_truth_1 = tmp_and_left_value_1 == NUITKA_BOOL_TRUE ? 1 : 0; | ||
| 2591 | if ( tmp_and_left_truth_1 == 1 ) | ||
| 2592 | { | ||
| 2593 | goto and_right_1; | ||
| 2594 | } | ||
| 2595 | else | ||
| 2596 | { | ||
| 2597 | goto and_left_1; | ||
| 2598 | } | ||
| 2599 | and_right_1:; | ||
| 2600 | tmp_mvar_value_29 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productStamp ); | ||
| 2601 | |||
| 2602 | if (unlikely( tmp_mvar_value_29 == NULL )) | ||
| 2603 | { | ||
| 2604 | tmp_mvar_value_29 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_productStamp ); | ||
| 2605 | } | ||
| 2606 | |||
| 2607 | if ( tmp_mvar_value_29 == NULL ) | ||
| 2608 | { | ||
| 2609 | |||
| 2610 | exception_type = PyExc_NameError; | ||
| 2611 | Py_INCREF( exception_type ); | ||
| 2612 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "productStamp" ); | ||
| 2613 | exception_tb = NULL; | ||
| 2614 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2615 | CHAIN_EXCEPTION( exception_value ); | ||
| 2616 | |||
| 2617 | exception_lineno = 49; | ||
| 2618 | |||
| 2619 | goto frame_exception_exit_1; | ||
| 2620 | } | ||
| 2621 | |||
| 2622 | tmp_called_instance_18 = tmp_mvar_value_29; | ||
| 2623 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 49; | ||
| 2624 | tmp_compexpr_left_1 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_18, const_str_plain_index, &PyTuple_GET_ITEM( const_tuple_str_dot_tuple, 0 ) ); | ||
| 2625 | |||
| 2626 | if ( tmp_compexpr_left_1 == NULL ) | ||
| 2627 | { | ||
| 2628 | assert( ERROR_OCCURRED() ); | ||
| 2629 | |||
| 2630 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2631 | |||
| 2632 | |||
| 2633 | exception_lineno = 49; | ||
| 2634 | |||
| 2635 | goto frame_exception_exit_1; | ||
| 2636 | } | ||
| 2637 | tmp_compexpr_right_1 = const_int_neg_1; | ||
| 2638 | tmp_res = RICH_COMPARE_BOOL_NOTEQ_OBJECT_OBJECT( tmp_compexpr_left_1, tmp_compexpr_right_1 ); | ||
| 2639 | Py_DECREF( tmp_compexpr_left_1 ); | ||
| 2640 | if ( tmp_res == -1 ) | ||
| 2641 | { | ||
| 2642 | assert( ERROR_OCCURRED() ); | ||
| 2643 | |||
| 2644 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2645 | |||
| 2646 | |||
| 2647 | exception_lineno = 49; | ||
| 2648 | |||
| 2649 | goto frame_exception_exit_1; | ||
| 2650 | } | ||
| 2651 | tmp_and_right_value_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2652 | tmp_condition_result_1 = tmp_and_right_value_1; | ||
| 2653 | goto and_end_1; | ||
| 2654 | and_left_1:; | ||
| 2655 | tmp_condition_result_1 = tmp_and_left_value_1; | ||
| 2656 | and_end_1:; | ||
| 2657 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 2658 | { | ||
| 2659 | goto branch_yes_1; | ||
| 2660 | } | ||
| 2661 | else | ||
| 2662 | { | ||
| 2663 | goto branch_no_1; | ||
| 2664 | } | ||
| 2665 | branch_yes_1:; | ||
| 2666 | { | ||
| 2667 | PyObject *tmp_assign_source_15; | ||
| 2668 | PyObject *tmp_subscribed_name_2; | ||
| 2669 | PyObject *tmp_mvar_value_30; | ||
| 2670 | PyObject *tmp_subscript_name_2; | ||
| 2671 | PyObject *tmp_start_name_1; | ||
| 2672 | PyObject *tmp_left_name_1; | ||
| 2673 | PyObject *tmp_called_instance_19; | ||
| 2674 | PyObject *tmp_mvar_value_31; | ||
| 2675 | PyObject *tmp_right_name_1; | ||
| 2676 | PyObject *tmp_stop_name_1; | ||
| 2677 | PyObject *tmp_step_name_1; | ||
| 2678 | tmp_mvar_value_30 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productStamp ); | ||
| 2679 | |||
| 2680 | if (unlikely( tmp_mvar_value_30 == NULL )) | ||
| 2681 | { | ||
| 2682 | tmp_mvar_value_30 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_productStamp ); | ||
| 2683 | } | ||
| 2684 | |||
| 2685 | if ( tmp_mvar_value_30 == NULL ) | ||
| 2686 | { | ||
| 2687 | |||
| 2688 | exception_type = PyExc_NameError; | ||
| 2689 | Py_INCREF( exception_type ); | ||
| 2690 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "productStamp" ); | ||
| 2691 | exception_tb = NULL; | ||
| 2692 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2693 | CHAIN_EXCEPTION( exception_value ); | ||
| 2694 | |||
| 2695 | exception_lineno = 50; | ||
| 2696 | |||
| 2697 | goto frame_exception_exit_1; | ||
| 2698 | } | ||
| 2699 | |||
| 2700 | tmp_subscribed_name_2 = tmp_mvar_value_30; | ||
| 2701 | tmp_mvar_value_31 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productStamp ); | ||
| 2702 | |||
| 2703 | if (unlikely( tmp_mvar_value_31 == NULL )) | ||
| 2704 | { | ||
| 2705 | tmp_mvar_value_31 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_productStamp ); | ||
| 2706 | } | ||
| 2707 | |||
| 2708 | if ( tmp_mvar_value_31 == NULL ) | ||
| 2709 | { | ||
| 2710 | |||
| 2711 | exception_type = PyExc_NameError; | ||
| 2712 | Py_INCREF( exception_type ); | ||
| 2713 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "productStamp" ); | ||
| 2714 | exception_tb = NULL; | ||
| 2715 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2716 | CHAIN_EXCEPTION( exception_value ); | ||
| 2717 | |||
| 2718 | exception_lineno = 50; | ||
| 2719 | |||
| 2720 | goto frame_exception_exit_1; | ||
| 2721 | } | ||
| 2722 | |||
| 2723 | tmp_called_instance_19 = tmp_mvar_value_31; | ||
| 2724 | frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame.f_lineno = 50; | ||
| 2725 | tmp_left_name_1 = CALL_METHOD_WITH_ARGS1( tmp_called_instance_19, const_str_plain_index, &PyTuple_GET_ITEM( const_tuple_str_dot_tuple, 0 ) ); | ||
| 2726 | |||
| 2727 | if ( tmp_left_name_1 == NULL ) | ||
| 2728 | { | ||
| 2729 | assert( ERROR_OCCURRED() ); | ||
| 2730 | |||
| 2731 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2732 | |||
| 2733 | |||
| 2734 | exception_lineno = 50; | ||
| 2735 | |||
| 2736 | goto frame_exception_exit_1; | ||
| 2737 | } | ||
| 2738 | tmp_right_name_1 = const_int_pos_1; | ||
| 2739 | tmp_start_name_1 = BINARY_OPERATION_ADD_OBJECT_LONG( tmp_left_name_1, tmp_right_name_1 ); | ||
| 2740 | Py_DECREF( tmp_left_name_1 ); | ||
| 2741 | if ( tmp_start_name_1 == NULL ) | ||
| 2742 | { | ||
| 2743 | assert( ERROR_OCCURRED() ); | ||
| 2744 | |||
| 2745 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2746 | |||
| 2747 | |||
| 2748 | exception_lineno = 50; | ||
| 2749 | |||
| 2750 | goto frame_exception_exit_1; | ||
| 2751 | } | ||
| 2752 | tmp_stop_name_1 = Py_None; | ||
| 2753 | tmp_step_name_1 = Py_None; | ||
| 2754 | tmp_subscript_name_2 = MAKE_SLICEOBJ3( tmp_start_name_1, tmp_stop_name_1, tmp_step_name_1 ); | ||
| 2755 | Py_DECREF( tmp_start_name_1 ); | ||
| 2756 | assert( !(tmp_subscript_name_2 == NULL) ); | ||
| 2757 | tmp_assign_source_15 = LOOKUP_SUBSCRIPT( tmp_subscribed_name_2, tmp_subscript_name_2 ); | ||
| 2758 | Py_DECREF( tmp_subscript_name_2 ); | ||
| 2759 | if ( tmp_assign_source_15 == NULL ) | ||
| 2760 | { | ||
| 2761 | assert( ERROR_OCCURRED() ); | ||
| 2762 | |||
| 2763 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2764 | |||
| 2765 | |||
| 2766 | exception_lineno = 50; | ||
| 2767 | |||
| 2768 | goto frame_exception_exit_1; | ||
| 2769 | } | ||
| 2770 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productArch, tmp_assign_source_15 ); | ||
| 2771 | } | ||
| 2772 | branch_no_1:; | ||
| 2773 | } | ||
| 2774 | { | ||
| 2775 | nuitka_bool tmp_condition_result_2; | ||
| 2776 | PyObject *tmp_compexpr_left_2; | ||
| 2777 | PyObject *tmp_compexpr_right_2; | ||
| 2778 | PyObject *tmp_mvar_value_32; | ||
| 2779 | tmp_mvar_value_32 = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productVersion ); | ||
| 2780 | |||
| 2781 | if (unlikely( tmp_mvar_value_32 == NULL )) | ||
| 2782 | { | ||
| 2783 | tmp_mvar_value_32 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain_productVersion ); | ||
| 2784 | } | ||
| 2785 | |||
| 2786 | if ( tmp_mvar_value_32 == NULL ) | ||
| 2787 | { | ||
| 2788 | |||
| 2789 | exception_type = PyExc_NameError; | ||
| 2790 | Py_INCREF( exception_type ); | ||
| 2791 | exception_value = PyUnicode_FromFormat( "name '%s' is not defined", "productVersion" ); | ||
| 2792 | exception_tb = NULL; | ||
| 2793 | NORMALIZE_EXCEPTION( &exception_type, &exception_value, &exception_tb ); | ||
| 2794 | CHAIN_EXCEPTION( exception_value ); | ||
| 2795 | |||
| 2796 | exception_lineno = 51; | ||
| 2797 | |||
| 2798 | goto frame_exception_exit_1; | ||
| 2799 | } | ||
| 2800 | |||
| 2801 | tmp_compexpr_left_2 = tmp_mvar_value_32; | ||
| 2802 | tmp_compexpr_right_2 = const_str_plain_development; | ||
| 2803 | tmp_res = RICH_COMPARE_BOOL_EQ_OBJECT_OBJECT_NORECURSE( tmp_compexpr_left_2, tmp_compexpr_right_2 ); | ||
| 2804 | if ( tmp_res == -1 ) | ||
| 2805 | { | ||
| 2806 | assert( ERROR_OCCURRED() ); | ||
| 2807 | |||
| 2808 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 2809 | |||
| 2810 | |||
| 2811 | exception_lineno = 51; | ||
| 2812 | |||
| 2813 | goto frame_exception_exit_1; | ||
| 2814 | } | ||
| 2815 | tmp_condition_result_2 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 2816 | if ( tmp_condition_result_2 == NUITKA_BOOL_TRUE ) | ||
| 2817 | { | ||
| 2818 | goto branch_yes_2; | ||
| 2819 | } | ||
| 2820 | else | ||
| 2821 | { | ||
| 2822 | goto branch_no_2; | ||
| 2823 | } | ||
| 2824 | branch_yes_2:; | ||
| 2825 | { | ||
| 2826 | PyObject *tmp_assign_source_16; | ||
| 2827 | tmp_assign_source_16 = const_str_plain_rawhide; | ||
| 2828 | UPDATE_STRING_DICT0( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_productVersion, tmp_assign_source_16 ); | ||
| 2829 | } | ||
| 2830 | branch_no_2:; | ||
| 2831 | } | ||
| 2832 | |||
| 2833 | // Restore frame exception if necessary. | ||
| 2834 | #if 0 | ||
| 2835 | RESTORE_FRAME_EXCEPTION( frame_3a42a00e1e492502a58e5fadda60aaa2 ); | ||
| 2836 | #endif | ||
| 2837 | popFrameStack(); | ||
| 2838 | |||
| 2839 | assertFrameObject( frame_3a42a00e1e492502a58e5fadda60aaa2 ); | ||
| 2840 | |||
| 2841 | goto frame_no_exception_1; | ||
| 2842 | |||
| 2843 | frame_exception_exit_1:; | ||
| 2844 | #if 0 | ||
| 2845 | RESTORE_FRAME_EXCEPTION( frame_3a42a00e1e492502a58e5fadda60aaa2 ); | ||
| 2846 | #endif | ||
| 2847 | |||
| 2848 | if ( exception_tb == NULL ) | ||
| 2849 | { | ||
| 2850 | exception_tb = MAKE_TRACEBACK( frame_3a42a00e1e492502a58e5fadda60aaa2, exception_lineno ); | ||
| 2851 | } | ||
| 2852 | else if ( exception_tb->tb_frame != &frame_3a42a00e1e492502a58e5fadda60aaa2->m_frame ) | ||
| 2853 | { | ||
| 2854 | exception_tb = ADD_TRACEBACK( exception_tb, frame_3a42a00e1e492502a58e5fadda60aaa2, exception_lineno ); | ||
| 2855 | } | ||
| 2856 | |||
| 2857 | // Put the previous frame back on top. | ||
| 2858 | popFrameStack(); | ||
| 2859 | |||
| 2860 | // Return the error. | ||
| 2861 | goto module_exception_exit; | ||
| 2862 | |||
| 2863 | frame_no_exception_1:; | ||
| 2864 | { | ||
| 2865 | PyObject *tmp_assign_source_17; | ||
| 2866 | tmp_assign_source_17 = MAKE_FUNCTION_pyanaconda$product$$$function_1_distributionText( ); | ||
| 2867 | |||
| 2868 | |||
| 2869 | |||
| 2870 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_distributionText, tmp_assign_source_17 ); | ||
| 2871 | } | ||
| 2872 | { | ||
| 2873 | PyObject *tmp_assign_source_18; | ||
| 2874 | tmp_assign_source_18 = MAKE_FUNCTION_pyanaconda$product$$$function_2_translated_new_install_name( ); | ||
| 2875 | |||
| 2876 | |||
| 2877 | |||
| 2878 | UPDATE_STRING_DICT1( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain_translated_new_install_name, tmp_assign_source_18 ); | ||
| 2879 | } | ||
| 2880 | |||
| 2881 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 2882 | #if 0 && 0 | ||
| 2883 | { | ||
| 2884 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_pyanaconda$product, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 2885 | |||
| 2886 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 2887 | { | ||
| 2888 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 2889 | |||
| 2890 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 2891 | CHECK_OBJECT( path_importer_cache ); | ||
| 2892 | |||
| 2893 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 2894 | assert( res == 0 ); | ||
| 2895 | } | ||
| 2896 | } | ||
| 2897 | #endif | ||
| 2898 | #endif | ||
| 2899 | |||
| 2900 | return MOD_RETURN_VALUE( module_pyanaconda$product ); | ||
| 2901 | module_exception_exit: | ||
| 2902 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 2903 | return MOD_RETURN_VALUE( NULL ); | ||
| 2904 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.pyanaconda.product.o deleted (index 7310832..0000000) |
| The diff for file Linux_Version/inventory_synchronisation.build/module.report.c is too big (10672 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.report.io.GTKIO.c deleted (index c23a481..0000000) | |||
| 1 | /* Generated code for Python module 'report.io.GTKIO' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_report$io$GTKIO" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_report$io$GTKIO; | ||
| 31 | PyDictObject *moduledict_report$io$GTKIO; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_tuple_none_tuple; | ||
| 35 | static PyObject *const_str_digest_52fa4ffbfdece4e7a30da01e0fbf9288; | ||
| 36 | extern PyObject *const_str_plain___module__; | ||
| 37 | extern PyObject *const_str_plain_metaclass; | ||
| 38 | extern PyObject *const_str_plain___spec__; | ||
| 39 | extern PyObject *const_str_plain___name__; | ||
| 40 | extern PyObject *const_str_plain___getitem__; | ||
| 41 | extern PyObject *const_tuple_str_plain___class___tuple; | ||
| 42 | extern PyObject *const_str_plain___qualname__; | ||
| 43 | extern PyObject *const_str_angle_metaclass; | ||
| 44 | extern PyObject *const_str_plain___file__; | ||
| 45 | static PyObject *const_str_digest_47375380eb3bc90dce4323b242ca94a2; | ||
| 46 | static PyObject *const_str_digest_68a3f652bbf89b5aba2ae5136bcf7c24; | ||
| 47 | extern PyObject *const_str_digest_176045277faffdb215e36349ee6bf75e; | ||
| 48 | extern PyObject *const_str_plain___prepare__; | ||
| 49 | extern PyObject *const_str_plain___init__; | ||
| 50 | extern PyObject *const_str_plain_self; | ||
| 51 | extern PyObject *const_str_plain_origin; | ||
| 52 | extern PyObject *const_str_plain_None; | ||
| 53 | extern PyObject *const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 54 | extern PyObject *const_str_plain_GTKIO; | ||
| 55 | extern PyObject *const_tuple_empty; | ||
| 56 | static PyObject *const_str_digest_1ef1ac85d7751e4149b8f11bf34541a2; | ||
| 57 | static PyObject *const_tuple_str_plain_self_str_plain_loginManager_tuple; | ||
| 58 | static PyObject *const_str_plain_loginManager; | ||
| 59 | extern PyObject *const_str_plain_has_location; | ||
| 60 | extern PyObject *const_str_plain_type; | ||
| 61 | static PyObject *const_tuple_str_plain_GTKIO_tuple_empty_tuple; | ||
| 62 | extern PyObject *const_str_plain___doc__; | ||
| 63 | extern PyObject *const_str_plain___cached__; | ||
| 64 | extern PyObject *const_str_plain___class__; | ||
| 65 | static PyObject *module_filename_obj; | ||
| 66 | |||
| 67 | /* Indicator if this modules private constants were created yet. */ | ||
| 68 | static bool constants_created = false; | ||
| 69 | |||
| 70 | /* Function to create module private constants. */ | ||
| 71 | static void createModuleConstants( void ) | ||
| 72 | { | ||
| 73 | const_str_digest_52fa4ffbfdece4e7a30da01e0fbf9288 = UNSTREAM_STRING_ASCII( &constant_bin[ 62732 ], 14, 0 ); | ||
| 74 | const_str_digest_47375380eb3bc90dce4323b242ca94a2 = UNSTREAM_STRING_ASCII( &constant_bin[ 62746 ], 18, 0 ); | ||
| 75 | const_str_digest_68a3f652bbf89b5aba2ae5136bcf7c24 = UNSTREAM_STRING_ASCII( &constant_bin[ 62764 ], 24, 0 ); | ||
| 76 | const_str_digest_1ef1ac85d7751e4149b8f11bf34541a2 = UNSTREAM_STRING_ASCII( &constant_bin[ 62772 ], 15, 0 ); | ||
| 77 | const_tuple_str_plain_self_str_plain_loginManager_tuple = PyTuple_New( 2 ); | ||
| 78 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_loginManager_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 79 | const_str_plain_loginManager = UNSTREAM_STRING_ASCII( &constant_bin[ 62788 ], 12, 1 ); | ||
| 80 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_loginManager_tuple, 1, const_str_plain_loginManager ); Py_INCREF( const_str_plain_loginManager ); | ||
| 81 | const_tuple_str_plain_GTKIO_tuple_empty_tuple = PyTuple_New( 2 ); | ||
| 82 | PyTuple_SET_ITEM( const_tuple_str_plain_GTKIO_tuple_empty_tuple, 0, const_str_plain_GTKIO ); Py_INCREF( const_str_plain_GTKIO ); | ||
| 83 | PyTuple_SET_ITEM( const_tuple_str_plain_GTKIO_tuple_empty_tuple, 1, const_tuple_empty ); Py_INCREF( const_tuple_empty ); | ||
| 84 | |||
| 85 | constants_created = true; | ||
| 86 | } | ||
| 87 | |||
| 88 | /* Function to verify module private constants for non-corruption. */ | ||
| 89 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 90 | void checkModuleConstants_report$io$GTKIO( void ) | ||
| 91 | { | ||
| 92 | // The module may not have been used at all, then ignore this. | ||
| 93 | if (constants_created == false) return; | ||
| 94 | |||
| 95 | |||
| 96 | } | ||
| 97 | #endif | ||
| 98 | |||
| 99 | // The module code objects. | ||
| 100 | static PyCodeObject *codeobj_f317f93dbc32e90714a596337ab5d52d; | ||
| 101 | static PyCodeObject *codeobj_bd3d2bedcbc2a52dbbc29cdd8d42c4f6; | ||
| 102 | static PyCodeObject *codeobj_3e569ac6b68ea74c67ced2f53145a66a; | ||
| 103 | |||
| 104 | static void createModuleCodeObjects(void) | ||
| 105 | { | ||
| 106 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_47375380eb3bc90dce4323b242ca94a2 ); | ||
| 107 | codeobj_f317f93dbc32e90714a596337ab5d52d = MAKE_CODEOBJ( module_filename_obj, const_str_digest_68a3f652bbf89b5aba2ae5136bcf7c24, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 108 | codeobj_bd3d2bedcbc2a52dbbc29cdd8d42c4f6 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_GTKIO, 19, const_tuple_str_plain___class___tuple, 0, 0, CO_NOFREE ); | ||
| 109 | codeobj_3e569ac6b68ea74c67ced2f53145a66a = MAKE_CODEOBJ( module_filename_obj, const_str_plain___init__, 20, const_tuple_str_plain_self_str_plain_loginManager_tuple, 2, 0, CO_NOFREE ); | ||
| 110 | } | ||
| 111 | |||
| 112 | // The module function declarations. | ||
| 113 | static PyObject *MAKE_FUNCTION_report$io$GTKIO$$$function_1___init__( PyObject *defaults ); | ||
| 114 | |||
| 115 | |||
| 116 | // The module function definitions. | ||
| 117 | static PyObject *impl_report$io$GTKIO$$$function_1___init__( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 118 | { | ||
| 119 | // Preserve error status for checks | ||
| 120 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 121 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 122 | #endif | ||
| 123 | |||
| 124 | // Local variable declarations. | ||
| 125 | PyObject *par_self = python_pars[ 0 ]; | ||
| 126 | PyObject *par_loginManager = python_pars[ 1 ]; | ||
| 127 | PyObject *tmp_return_value = NULL; | ||
| 128 | |||
| 129 | // Actual function body. | ||
| 130 | // Tried code: | ||
| 131 | tmp_return_value = Py_None; | ||
| 132 | Py_INCREF( tmp_return_value ); | ||
| 133 | goto try_return_handler_1; | ||
| 134 | // tried codes exits in all cases | ||
| 135 | NUITKA_CANNOT_GET_HERE( report$io$GTKIO$$$function_1___init__ ); | ||
| 136 | return NULL; | ||
| 137 | // Return handler code: | ||
| 138 | try_return_handler_1:; | ||
| 139 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 140 | Py_DECREF( par_self ); | ||
| 141 | par_self = NULL; | ||
| 142 | |||
| 143 | CHECK_OBJECT( (PyObject *)par_loginManager ); | ||
| 144 | Py_DECREF( par_loginManager ); | ||
| 145 | par_loginManager = NULL; | ||
| 146 | |||
| 147 | goto function_return_exit; | ||
| 148 | // End of try: | ||
| 149 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 150 | Py_DECREF( par_self ); | ||
| 151 | par_self = NULL; | ||
| 152 | |||
| 153 | CHECK_OBJECT( (PyObject *)par_loginManager ); | ||
| 154 | Py_DECREF( par_loginManager ); | ||
| 155 | par_loginManager = NULL; | ||
| 156 | |||
| 157 | |||
| 158 | // Return statement must have exited already. | ||
| 159 | NUITKA_CANNOT_GET_HERE( report$io$GTKIO$$$function_1___init__ ); | ||
| 160 | return NULL; | ||
| 161 | |||
| 162 | |||
| 163 | function_return_exit: | ||
| 164 | // Function cleanup code if any. | ||
| 165 | |||
| 166 | |||
| 167 | // Actual function exit with return value, making sure we did not make | ||
| 168 | // the error status worse despite non-NULL return. | ||
| 169 | CHECK_OBJECT( tmp_return_value ); | ||
| 170 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 171 | return tmp_return_value; | ||
| 172 | } | ||
| 173 | |||
| 174 | |||
| 175 | |||
| 176 | static PyObject *MAKE_FUNCTION_report$io$GTKIO$$$function_1___init__( PyObject *defaults ) | ||
| 177 | { | ||
| 178 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 179 | impl_report$io$GTKIO$$$function_1___init__, | ||
| 180 | const_str_plain___init__, | ||
| 181 | #if PYTHON_VERSION >= 300 | ||
| 182 | const_str_digest_52fa4ffbfdece4e7a30da01e0fbf9288, | ||
| 183 | #endif | ||
| 184 | codeobj_3e569ac6b68ea74c67ced2f53145a66a, | ||
| 185 | defaults, | ||
| 186 | #if PYTHON_VERSION >= 300 | ||
| 187 | NULL, | ||
| 188 | NULL, | ||
| 189 | #endif | ||
| 190 | module_report$io$GTKIO, | ||
| 191 | NULL, | ||
| 192 | 0 | ||
| 193 | ); | ||
| 194 | |||
| 195 | return (PyObject *)result; | ||
| 196 | } | ||
| 197 | |||
| 198 | |||
| 199 | |||
| 200 | #if PYTHON_VERSION >= 300 | ||
| 201 | static struct PyModuleDef mdef_report$io$GTKIO = | ||
| 202 | { | ||
| 203 | PyModuleDef_HEAD_INIT, | ||
| 204 | "report.io.GTKIO", | ||
| 205 | NULL, /* m_doc */ | ||
| 206 | -1, /* m_size */ | ||
| 207 | NULL, /* m_methods */ | ||
| 208 | NULL, /* m_reload */ | ||
| 209 | NULL, /* m_traverse */ | ||
| 210 | NULL, /* m_clear */ | ||
| 211 | NULL, /* m_free */ | ||
| 212 | }; | ||
| 213 | #endif | ||
| 214 | |||
| 215 | extern PyObject *const_str_plain___compiled__; | ||
| 216 | |||
| 217 | extern PyObject *const_str_plain___package__; | ||
| 218 | |||
| 219 | #if PYTHON_VERSION >= 300 | ||
| 220 | extern PyObject *const_str_dot; | ||
| 221 | extern PyObject *const_str_plain___loader__; | ||
| 222 | #endif | ||
| 223 | |||
| 224 | #if PYTHON_VERSION >= 340 | ||
| 225 | extern PyObject *const_str_plain___spec__; | ||
| 226 | extern PyObject *const_str_plain__initializing; | ||
| 227 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 228 | #endif | ||
| 229 | |||
| 230 | extern void _initCompiledCellType(); | ||
| 231 | extern void _initCompiledGeneratorType(); | ||
| 232 | extern void _initCompiledFunctionType(); | ||
| 233 | extern void _initCompiledMethodType(); | ||
| 234 | extern void _initCompiledFrameType(); | ||
| 235 | #if PYTHON_VERSION >= 350 | ||
| 236 | extern void _initCompiledCoroutineTypes(); | ||
| 237 | #endif | ||
| 238 | #if PYTHON_VERSION >= 360 | ||
| 239 | extern void _initCompiledAsyncgenTypes(); | ||
| 240 | #endif | ||
| 241 | |||
| 242 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 243 | |||
| 244 | // The exported interface to CPython. On import of the module, this function | ||
| 245 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 246 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 247 | |||
| 248 | MOD_INIT_DECL( report$io$GTKIO ) | ||
| 249 | { | ||
| 250 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 251 | static bool _init_done = false; | ||
| 252 | |||
| 253 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 254 | if ( _init_done ) | ||
| 255 | { | ||
| 256 | return MOD_RETURN_VALUE( module_report$io$GTKIO ); | ||
| 257 | } | ||
| 258 | else | ||
| 259 | { | ||
| 260 | _init_done = true; | ||
| 261 | } | ||
| 262 | #endif | ||
| 263 | |||
| 264 | #ifdef _NUITKA_MODULE | ||
| 265 | // In case of a stand alone extension module, need to call initialization | ||
| 266 | // the init here because that's the first and only time we are going to get | ||
| 267 | // called here. | ||
| 268 | |||
| 269 | // Initialize the constant values used. | ||
| 270 | _initBuiltinModule(); | ||
| 271 | createGlobalConstants(); | ||
| 272 | |||
| 273 | /* Initialize the compiled types of Nuitka. */ | ||
| 274 | _initCompiledCellType(); | ||
| 275 | _initCompiledGeneratorType(); | ||
| 276 | _initCompiledFunctionType(); | ||
| 277 | _initCompiledMethodType(); | ||
| 278 | _initCompiledFrameType(); | ||
| 279 | #if PYTHON_VERSION >= 350 | ||
| 280 | _initCompiledCoroutineTypes(); | ||
| 281 | #endif | ||
| 282 | #if PYTHON_VERSION >= 360 | ||
| 283 | _initCompiledAsyncgenTypes(); | ||
| 284 | #endif | ||
| 285 | |||
| 286 | #if PYTHON_VERSION < 300 | ||
| 287 | _initSlotCompare(); | ||
| 288 | #endif | ||
| 289 | #if PYTHON_VERSION >= 270 | ||
| 290 | _initSlotIternext(); | ||
| 291 | #endif | ||
| 292 | |||
| 293 | patchBuiltinModule(); | ||
| 294 | patchTypeComparison(); | ||
| 295 | |||
| 296 | // Enable meta path based loader if not already done. | ||
| 297 | #ifdef _NUITKA_TRACE | ||
| 298 | puts("report.io.GTKIO: Calling setupMetaPathBasedLoader()."); | ||
| 299 | #endif | ||
| 300 | setupMetaPathBasedLoader(); | ||
| 301 | |||
| 302 | #if PYTHON_VERSION >= 300 | ||
| 303 | patchInspectModule(); | ||
| 304 | #endif | ||
| 305 | |||
| 306 | #endif | ||
| 307 | |||
| 308 | /* The constants only used by this module are created now. */ | ||
| 309 | #ifdef _NUITKA_TRACE | ||
| 310 | puts("report.io.GTKIO: Calling createModuleConstants()."); | ||
| 311 | #endif | ||
| 312 | createModuleConstants(); | ||
| 313 | |||
| 314 | /* The code objects used by this module are created now. */ | ||
| 315 | #ifdef _NUITKA_TRACE | ||
| 316 | puts("report.io.GTKIO: Calling createModuleCodeObjects()."); | ||
| 317 | #endif | ||
| 318 | createModuleCodeObjects(); | ||
| 319 | |||
| 320 | // puts( "in initreport$io$GTKIO" ); | ||
| 321 | |||
| 322 | // Create the module object first. There are no methods initially, all are | ||
| 323 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 324 | // set at this time, as it could not contain NUL characters this way, they | ||
| 325 | // are instead set in early module code. No "self" for modules, we have no | ||
| 326 | // use for it. | ||
| 327 | #if PYTHON_VERSION < 300 | ||
| 328 | module_report$io$GTKIO = Py_InitModule4( | ||
| 329 | "report.io.GTKIO", // Module Name | ||
| 330 | NULL, // No methods initially, all are added | ||
| 331 | // dynamically in actual module code only. | ||
| 332 | NULL, // No "__doc__" is initially set, as it could | ||
| 333 | // not contain NUL this way, added early in | ||
| 334 | // actual code. | ||
| 335 | NULL, // No self for modules, we don't use it. | ||
| 336 | PYTHON_API_VERSION | ||
| 337 | ); | ||
| 338 | #else | ||
| 339 | |||
| 340 | module_report$io$GTKIO = PyModule_Create( &mdef_report$io$GTKIO ); | ||
| 341 | #endif | ||
| 342 | |||
| 343 | moduledict_report$io$GTKIO = MODULE_DICT( module_report$io$GTKIO ); | ||
| 344 | |||
| 345 | // Set __compiled__ to what it we know. | ||
| 346 | UPDATE_STRING_DICT1( | ||
| 347 | moduledict_report$io$GTKIO, | ||
| 348 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 349 | Nuitka_dunder_compiled_value | ||
| 350 | ); | ||
| 351 | |||
| 352 | // Update "__package__" value to what it ought to be. | ||
| 353 | { | ||
| 354 | #if 0 | ||
| 355 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 356 | |||
| 357 | UPDATE_STRING_DICT1( | ||
| 358 | moduledict_report$io$GTKIO, | ||
| 359 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 360 | module_name | ||
| 361 | ); | ||
| 362 | #else | ||
| 363 | |||
| 364 | #if PYTHON_VERSION < 300 | ||
| 365 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 366 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 367 | |||
| 368 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 369 | |||
| 370 | if ( last_dot != NULL ) | ||
| 371 | { | ||
| 372 | UPDATE_STRING_DICT1( | ||
| 373 | moduledict_report$io$GTKIO, | ||
| 374 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 375 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 376 | ); | ||
| 377 | } | ||
| 378 | #else | ||
| 379 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 380 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 381 | |||
| 382 | if ( dot_index != -1 ) | ||
| 383 | { | ||
| 384 | UPDATE_STRING_DICT1( | ||
| 385 | moduledict_report$io$GTKIO, | ||
| 386 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 387 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 388 | ); | ||
| 389 | } | ||
| 390 | #endif | ||
| 391 | #endif | ||
| 392 | } | ||
| 393 | |||
| 394 | CHECK_OBJECT( module_report$io$GTKIO ); | ||
| 395 | |||
| 396 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 397 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 398 | #if PYTHON_VERSION >= 300 | ||
| 399 | { | ||
| 400 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_1ef1ac85d7751e4149b8f11bf34541a2, module_report$io$GTKIO ); | ||
| 401 | |||
| 402 | assert( r != -1 ); | ||
| 403 | } | ||
| 404 | #endif | ||
| 405 | |||
| 406 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 407 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 408 | // before the frame object is allocated, or else it may fail. | ||
| 409 | |||
| 410 | if ( GET_STRING_DICT_VALUE( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 411 | { | ||
| 412 | PyObject *value = (PyObject *)builtin_module; | ||
| 413 | |||
| 414 | // Check if main module, not a dict then but the module itself. | ||
| 415 | #if !defined(_NUITKA_EXE) || !0 | ||
| 416 | value = PyModule_GetDict( value ); | ||
| 417 | #endif | ||
| 418 | |||
| 419 | UPDATE_STRING_DICT0( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 420 | } | ||
| 421 | |||
| 422 | #if PYTHON_VERSION >= 300 | ||
| 423 | UPDATE_STRING_DICT0( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 424 | #endif | ||
| 425 | |||
| 426 | #if PYTHON_VERSION >= 340 | ||
| 427 | // Set the "__spec__" value | ||
| 428 | |||
| 429 | #if 0 | ||
| 430 | // Main modules just get "None" as spec. | ||
| 431 | UPDATE_STRING_DICT0( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 432 | #else | ||
| 433 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 434 | { | ||
| 435 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 436 | CHECK_OBJECT( bootstrap_module ); | ||
| 437 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 438 | Py_DECREF( bootstrap_module ); | ||
| 439 | |||
| 440 | PyObject *args[] = { | ||
| 441 | GET_STRING_DICT_VALUE( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 442 | (PyObject *)&Nuitka_Loader_Type | ||
| 443 | }; | ||
| 444 | |||
| 445 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 446 | module_spec_class, | ||
| 447 | args | ||
| 448 | ); | ||
| 449 | Py_DECREF( module_spec_class ); | ||
| 450 | |||
| 451 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 452 | CHECK_OBJECT( spec_value ); | ||
| 453 | |||
| 454 | // For packages set the submodule search locations as well, even if to empty | ||
| 455 | // list, so investigating code will consider it a package. | ||
| 456 | #if 0 | ||
| 457 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 458 | #endif | ||
| 459 | |||
| 460 | // Mark the execution in the "__spec__" value. | ||
| 461 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 462 | |||
| 463 | UPDATE_STRING_DICT1( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 464 | } | ||
| 465 | #endif | ||
| 466 | #endif | ||
| 467 | |||
| 468 | // Temp variables if any | ||
| 469 | PyObject *outline_0_var___class__ = NULL; | ||
| 470 | PyObject *tmp_class_creation_1__class_decl_dict = NULL; | ||
| 471 | PyObject *tmp_class_creation_1__metaclass = NULL; | ||
| 472 | PyObject *tmp_class_creation_1__prepared = NULL; | ||
| 473 | struct Nuitka_FrameObject *frame_f317f93dbc32e90714a596337ab5d52d; | ||
| 474 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 475 | bool tmp_result; | ||
| 476 | PyObject *exception_type = NULL; | ||
| 477 | PyObject *exception_value = NULL; | ||
| 478 | PyTracebackObject *exception_tb = NULL; | ||
| 479 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 480 | int tmp_res; | ||
| 481 | PyObject *tmp_dictdel_dict; | ||
| 482 | PyObject *tmp_dictdel_key; | ||
| 483 | PyObject *locals_report$io$GTKIO_19 = NULL; | ||
| 484 | PyObject *tmp_dictset_value; | ||
| 485 | struct Nuitka_FrameObject *frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2; | ||
| 486 | NUITKA_MAY_BE_UNUSED char const *type_description_2 = NULL; | ||
| 487 | static struct Nuitka_FrameObject *cache_frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2 = NULL; | ||
| 488 | PyObject *exception_keeper_type_1; | ||
| 489 | PyObject *exception_keeper_value_1; | ||
| 490 | PyTracebackObject *exception_keeper_tb_1; | ||
| 491 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 492 | PyObject *exception_keeper_type_2; | ||
| 493 | PyObject *exception_keeper_value_2; | ||
| 494 | PyTracebackObject *exception_keeper_tb_2; | ||
| 495 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 496 | PyObject *exception_keeper_type_3; | ||
| 497 | PyObject *exception_keeper_value_3; | ||
| 498 | PyTracebackObject *exception_keeper_tb_3; | ||
| 499 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; | ||
| 500 | |||
| 501 | // Module code. | ||
| 502 | { | ||
| 503 | PyObject *tmp_assign_source_1; | ||
| 504 | tmp_assign_source_1 = const_str_digest_176045277faffdb215e36349ee6bf75e; | ||
| 505 | UPDATE_STRING_DICT0( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 506 | } | ||
| 507 | { | ||
| 508 | PyObject *tmp_assign_source_2; | ||
| 509 | tmp_assign_source_2 = module_filename_obj; | ||
| 510 | UPDATE_STRING_DICT0( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 511 | } | ||
| 512 | // Frame without reuse. | ||
| 513 | frame_f317f93dbc32e90714a596337ab5d52d = MAKE_MODULE_FRAME( codeobj_f317f93dbc32e90714a596337ab5d52d, module_report$io$GTKIO ); | ||
| 514 | |||
| 515 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 516 | // owning it. | ||
| 517 | pushFrameStack( frame_f317f93dbc32e90714a596337ab5d52d ); | ||
| 518 | assert( Py_REFCNT( frame_f317f93dbc32e90714a596337ab5d52d ) == 2 ); | ||
| 519 | |||
| 520 | // Framed code: | ||
| 521 | { | ||
| 522 | PyObject *tmp_assattr_name_1; | ||
| 523 | PyObject *tmp_assattr_target_1; | ||
| 524 | PyObject *tmp_mvar_value_1; | ||
| 525 | tmp_assattr_name_1 = module_filename_obj; | ||
| 526 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 527 | |||
| 528 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 529 | { | ||
| 530 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 531 | } | ||
| 532 | |||
| 533 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 534 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 535 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 536 | if ( tmp_result == false ) | ||
| 537 | { | ||
| 538 | assert( ERROR_OCCURRED() ); | ||
| 539 | |||
| 540 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 541 | |||
| 542 | |||
| 543 | exception_lineno = 1; | ||
| 544 | |||
| 545 | goto frame_exception_exit_1; | ||
| 546 | } | ||
| 547 | } | ||
| 548 | { | ||
| 549 | PyObject *tmp_assattr_name_2; | ||
| 550 | PyObject *tmp_assattr_target_2; | ||
| 551 | PyObject *tmp_mvar_value_2; | ||
| 552 | tmp_assattr_name_2 = Py_True; | ||
| 553 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 554 | |||
| 555 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 556 | { | ||
| 557 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 558 | } | ||
| 559 | |||
| 560 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 561 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 562 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 563 | if ( tmp_result == false ) | ||
| 564 | { | ||
| 565 | assert( ERROR_OCCURRED() ); | ||
| 566 | |||
| 567 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 568 | |||
| 569 | |||
| 570 | exception_lineno = 1; | ||
| 571 | |||
| 572 | goto frame_exception_exit_1; | ||
| 573 | } | ||
| 574 | } | ||
| 575 | { | ||
| 576 | PyObject *tmp_assign_source_3; | ||
| 577 | tmp_assign_source_3 = Py_None; | ||
| 578 | UPDATE_STRING_DICT0( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 579 | } | ||
| 580 | { | ||
| 581 | PyObject *tmp_assign_source_4; | ||
| 582 | tmp_assign_source_4 = PyDict_New(); | ||
| 583 | assert( tmp_class_creation_1__class_decl_dict == NULL ); | ||
| 584 | tmp_class_creation_1__class_decl_dict = tmp_assign_source_4; | ||
| 585 | } | ||
| 586 | // Tried code: | ||
| 587 | { | ||
| 588 | PyObject *tmp_assign_source_5; | ||
| 589 | PyObject *tmp_metaclass_name_1; | ||
| 590 | nuitka_bool tmp_condition_result_1; | ||
| 591 | PyObject *tmp_key_name_1; | ||
| 592 | PyObject *tmp_dict_name_1; | ||
| 593 | PyObject *tmp_dict_name_2; | ||
| 594 | PyObject *tmp_key_name_2; | ||
| 595 | PyObject *tmp_bases_name_1; | ||
| 596 | tmp_key_name_1 = const_str_plain_metaclass; | ||
| 597 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 598 | tmp_dict_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 599 | tmp_res = PyDict_Contains( tmp_dict_name_1, tmp_key_name_1 ); | ||
| 600 | if ( tmp_res == -1 ) | ||
| 601 | { | ||
| 602 | assert( ERROR_OCCURRED() ); | ||
| 603 | |||
| 604 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 605 | |||
| 606 | |||
| 607 | exception_lineno = 19; | ||
| 608 | |||
| 609 | goto try_except_handler_1; | ||
| 610 | } | ||
| 611 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 612 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 613 | { | ||
| 614 | goto condexpr_true_1; | ||
| 615 | } | ||
| 616 | else | ||
| 617 | { | ||
| 618 | goto condexpr_false_1; | ||
| 619 | } | ||
| 620 | condexpr_true_1:; | ||
| 621 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 622 | tmp_dict_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 623 | tmp_key_name_2 = const_str_plain_metaclass; | ||
| 624 | tmp_metaclass_name_1 = DICT_GET_ITEM( tmp_dict_name_2, tmp_key_name_2 ); | ||
| 625 | if ( tmp_metaclass_name_1 == NULL ) | ||
| 626 | { | ||
| 627 | assert( ERROR_OCCURRED() ); | ||
| 628 | |||
| 629 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 630 | |||
| 631 | |||
| 632 | exception_lineno = 19; | ||
| 633 | |||
| 634 | goto try_except_handler_1; | ||
| 635 | } | ||
| 636 | goto condexpr_end_1; | ||
| 637 | condexpr_false_1:; | ||
| 638 | tmp_metaclass_name_1 = (PyObject *)&PyType_Type; | ||
| 639 | Py_INCREF( tmp_metaclass_name_1 ); | ||
| 640 | condexpr_end_1:; | ||
| 641 | tmp_bases_name_1 = const_tuple_empty; | ||
| 642 | tmp_assign_source_5 = SELECT_METACLASS( tmp_metaclass_name_1, tmp_bases_name_1 ); | ||
| 643 | Py_DECREF( tmp_metaclass_name_1 ); | ||
| 644 | if ( tmp_assign_source_5 == NULL ) | ||
| 645 | { | ||
| 646 | assert( ERROR_OCCURRED() ); | ||
| 647 | |||
| 648 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 649 | |||
| 650 | |||
| 651 | exception_lineno = 19; | ||
| 652 | |||
| 653 | goto try_except_handler_1; | ||
| 654 | } | ||
| 655 | assert( tmp_class_creation_1__metaclass == NULL ); | ||
| 656 | tmp_class_creation_1__metaclass = tmp_assign_source_5; | ||
| 657 | } | ||
| 658 | { | ||
| 659 | nuitka_bool tmp_condition_result_2; | ||
| 660 | PyObject *tmp_key_name_3; | ||
| 661 | PyObject *tmp_dict_name_3; | ||
| 662 | tmp_key_name_3 = const_str_plain_metaclass; | ||
| 663 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 664 | tmp_dict_name_3 = tmp_class_creation_1__class_decl_dict; | ||
| 665 | tmp_res = PyDict_Contains( tmp_dict_name_3, tmp_key_name_3 ); | ||
| 666 | if ( tmp_res == -1 ) | ||
| 667 | { | ||
| 668 | assert( ERROR_OCCURRED() ); | ||
| 669 | |||
| 670 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 671 | |||
| 672 | |||
| 673 | exception_lineno = 19; | ||
| 674 | |||
| 675 | goto try_except_handler_1; | ||
| 676 | } | ||
| 677 | tmp_condition_result_2 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 678 | if ( tmp_condition_result_2 == NUITKA_BOOL_TRUE ) | ||
| 679 | { | ||
| 680 | goto branch_yes_1; | ||
| 681 | } | ||
| 682 | else | ||
| 683 | { | ||
| 684 | goto branch_no_1; | ||
| 685 | } | ||
| 686 | branch_yes_1:; | ||
| 687 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 688 | tmp_dictdel_dict = tmp_class_creation_1__class_decl_dict; | ||
| 689 | tmp_dictdel_key = const_str_plain_metaclass; | ||
| 690 | tmp_result = DICT_REMOVE_ITEM( tmp_dictdel_dict, tmp_dictdel_key ); | ||
| 691 | if ( tmp_result == false ) | ||
| 692 | { | ||
| 693 | assert( ERROR_OCCURRED() ); | ||
| 694 | |||
| 695 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 696 | |||
| 697 | |||
| 698 | exception_lineno = 19; | ||
| 699 | |||
| 700 | goto try_except_handler_1; | ||
| 701 | } | ||
| 702 | branch_no_1:; | ||
| 703 | } | ||
| 704 | { | ||
| 705 | nuitka_bool tmp_condition_result_3; | ||
| 706 | PyObject *tmp_source_name_1; | ||
| 707 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 708 | tmp_source_name_1 = tmp_class_creation_1__metaclass; | ||
| 709 | tmp_res = PyObject_HasAttr( tmp_source_name_1, const_str_plain___prepare__ ); | ||
| 710 | tmp_condition_result_3 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 711 | if ( tmp_condition_result_3 == NUITKA_BOOL_TRUE ) | ||
| 712 | { | ||
| 713 | goto branch_yes_2; | ||
| 714 | } | ||
| 715 | else | ||
| 716 | { | ||
| 717 | goto branch_no_2; | ||
| 718 | } | ||
| 719 | branch_yes_2:; | ||
| 720 | { | ||
| 721 | PyObject *tmp_assign_source_6; | ||
| 722 | PyObject *tmp_called_name_1; | ||
| 723 | PyObject *tmp_source_name_2; | ||
| 724 | PyObject *tmp_args_name_1; | ||
| 725 | PyObject *tmp_kw_name_1; | ||
| 726 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 727 | tmp_source_name_2 = tmp_class_creation_1__metaclass; | ||
| 728 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain___prepare__ ); | ||
| 729 | if ( tmp_called_name_1 == NULL ) | ||
| 730 | { | ||
| 731 | assert( ERROR_OCCURRED() ); | ||
| 732 | |||
| 733 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 734 | |||
| 735 | |||
| 736 | exception_lineno = 19; | ||
| 737 | |||
| 738 | goto try_except_handler_1; | ||
| 739 | } | ||
| 740 | tmp_args_name_1 = const_tuple_str_plain_GTKIO_tuple_empty_tuple; | ||
| 741 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 742 | tmp_kw_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 743 | frame_f317f93dbc32e90714a596337ab5d52d->m_frame.f_lineno = 19; | ||
| 744 | tmp_assign_source_6 = CALL_FUNCTION( tmp_called_name_1, tmp_args_name_1, tmp_kw_name_1 ); | ||
| 745 | Py_DECREF( tmp_called_name_1 ); | ||
| 746 | if ( tmp_assign_source_6 == NULL ) | ||
| 747 | { | ||
| 748 | assert( ERROR_OCCURRED() ); | ||
| 749 | |||
| 750 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 751 | |||
| 752 | |||
| 753 | exception_lineno = 19; | ||
| 754 | |||
| 755 | goto try_except_handler_1; | ||
| 756 | } | ||
| 757 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 758 | tmp_class_creation_1__prepared = tmp_assign_source_6; | ||
| 759 | } | ||
| 760 | { | ||
| 761 | nuitka_bool tmp_condition_result_4; | ||
| 762 | PyObject *tmp_operand_name_1; | ||
| 763 | PyObject *tmp_source_name_3; | ||
| 764 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 765 | tmp_source_name_3 = tmp_class_creation_1__prepared; | ||
| 766 | tmp_res = PyObject_HasAttr( tmp_source_name_3, const_str_plain___getitem__ ); | ||
| 767 | tmp_operand_name_1 = ( tmp_res != 0 ) ? Py_True : Py_False; | ||
| 768 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 769 | if ( tmp_res == -1 ) | ||
| 770 | { | ||
| 771 | assert( ERROR_OCCURRED() ); | ||
| 772 | |||
| 773 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 774 | |||
| 775 | |||
| 776 | exception_lineno = 19; | ||
| 777 | |||
| 778 | goto try_except_handler_1; | ||
| 779 | } | ||
| 780 | tmp_condition_result_4 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 781 | if ( tmp_condition_result_4 == NUITKA_BOOL_TRUE ) | ||
| 782 | { | ||
| 783 | goto branch_yes_3; | ||
| 784 | } | ||
| 785 | else | ||
| 786 | { | ||
| 787 | goto branch_no_3; | ||
| 788 | } | ||
| 789 | branch_yes_3:; | ||
| 790 | { | ||
| 791 | PyObject *tmp_raise_type_1; | ||
| 792 | PyObject *tmp_raise_value_1; | ||
| 793 | PyObject *tmp_left_name_1; | ||
| 794 | PyObject *tmp_right_name_1; | ||
| 795 | PyObject *tmp_tuple_element_1; | ||
| 796 | PyObject *tmp_getattr_target_1; | ||
| 797 | PyObject *tmp_getattr_attr_1; | ||
| 798 | PyObject *tmp_getattr_default_1; | ||
| 799 | PyObject *tmp_source_name_4; | ||
| 800 | PyObject *tmp_type_arg_1; | ||
| 801 | tmp_raise_type_1 = PyExc_TypeError; | ||
| 802 | tmp_left_name_1 = const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 803 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 804 | tmp_getattr_target_1 = tmp_class_creation_1__metaclass; | ||
| 805 | tmp_getattr_attr_1 = const_str_plain___name__; | ||
| 806 | tmp_getattr_default_1 = const_str_angle_metaclass; | ||
| 807 | tmp_tuple_element_1 = BUILTIN_GETATTR( tmp_getattr_target_1, tmp_getattr_attr_1, tmp_getattr_default_1 ); | ||
| 808 | if ( tmp_tuple_element_1 == NULL ) | ||
| 809 | { | ||
| 810 | assert( ERROR_OCCURRED() ); | ||
| 811 | |||
| 812 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 813 | |||
| 814 | |||
| 815 | exception_lineno = 19; | ||
| 816 | |||
| 817 | goto try_except_handler_1; | ||
| 818 | } | ||
| 819 | tmp_right_name_1 = PyTuple_New( 2 ); | ||
| 820 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_1 ); | ||
| 821 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 822 | tmp_type_arg_1 = tmp_class_creation_1__prepared; | ||
| 823 | tmp_source_name_4 = BUILTIN_TYPE1( tmp_type_arg_1 ); | ||
| 824 | assert( !(tmp_source_name_4 == NULL) ); | ||
| 825 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain___name__ ); | ||
| 826 | Py_DECREF( tmp_source_name_4 ); | ||
| 827 | if ( tmp_tuple_element_1 == NULL ) | ||
| 828 | { | ||
| 829 | assert( ERROR_OCCURRED() ); | ||
| 830 | |||
| 831 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 832 | Py_DECREF( tmp_right_name_1 ); | ||
| 833 | |||
| 834 | exception_lineno = 19; | ||
| 835 | |||
| 836 | goto try_except_handler_1; | ||
| 837 | } | ||
| 838 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_1 ); | ||
| 839 | tmp_raise_value_1 = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 840 | Py_DECREF( tmp_right_name_1 ); | ||
| 841 | if ( tmp_raise_value_1 == NULL ) | ||
| 842 | { | ||
| 843 | assert( ERROR_OCCURRED() ); | ||
| 844 | |||
| 845 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 846 | |||
| 847 | |||
| 848 | exception_lineno = 19; | ||
| 849 | |||
| 850 | goto try_except_handler_1; | ||
| 851 | } | ||
| 852 | exception_type = tmp_raise_type_1; | ||
| 853 | Py_INCREF( tmp_raise_type_1 ); | ||
| 854 | exception_value = tmp_raise_value_1; | ||
| 855 | exception_lineno = 19; | ||
| 856 | RAISE_EXCEPTION_IMPLICIT( &exception_type, &exception_value, &exception_tb ); | ||
| 857 | |||
| 858 | goto try_except_handler_1; | ||
| 859 | } | ||
| 860 | branch_no_3:; | ||
| 861 | } | ||
| 862 | goto branch_end_2; | ||
| 863 | branch_no_2:; | ||
| 864 | { | ||
| 865 | PyObject *tmp_assign_source_7; | ||
| 866 | tmp_assign_source_7 = PyDict_New(); | ||
| 867 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 868 | tmp_class_creation_1__prepared = tmp_assign_source_7; | ||
| 869 | } | ||
| 870 | branch_end_2:; | ||
| 871 | } | ||
| 872 | { | ||
| 873 | PyObject *tmp_assign_source_8; | ||
| 874 | { | ||
| 875 | PyObject *tmp_set_locals_1; | ||
| 876 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 877 | tmp_set_locals_1 = tmp_class_creation_1__prepared; | ||
| 878 | locals_report$io$GTKIO_19 = tmp_set_locals_1; | ||
| 879 | Py_INCREF( tmp_set_locals_1 ); | ||
| 880 | } | ||
| 881 | // Tried code: | ||
| 882 | // Tried code: | ||
| 883 | tmp_dictset_value = const_str_digest_1ef1ac85d7751e4149b8f11bf34541a2; | ||
| 884 | tmp_res = PyObject_SetItem( locals_report$io$GTKIO_19, const_str_plain___module__, tmp_dictset_value ); | ||
| 885 | if ( tmp_res != 0 ) | ||
| 886 | { | ||
| 887 | assert( ERROR_OCCURRED() ); | ||
| 888 | |||
| 889 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 890 | |||
| 891 | |||
| 892 | exception_lineno = 19; | ||
| 893 | |||
| 894 | goto try_except_handler_3; | ||
| 895 | } | ||
| 896 | tmp_dictset_value = const_str_plain_GTKIO; | ||
| 897 | tmp_res = PyObject_SetItem( locals_report$io$GTKIO_19, const_str_plain___qualname__, tmp_dictset_value ); | ||
| 898 | if ( tmp_res != 0 ) | ||
| 899 | { | ||
| 900 | assert( ERROR_OCCURRED() ); | ||
| 901 | |||
| 902 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 903 | |||
| 904 | |||
| 905 | exception_lineno = 19; | ||
| 906 | |||
| 907 | goto try_except_handler_3; | ||
| 908 | } | ||
| 909 | MAKE_OR_REUSE_FRAME( cache_frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2, codeobj_bd3d2bedcbc2a52dbbc29cdd8d42c4f6, module_report$io$GTKIO, sizeof(void *) ); | ||
| 910 | frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2 = cache_frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2; | ||
| 911 | |||
| 912 | // Push the new frame as the currently active one. | ||
| 913 | pushFrameStack( frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2 ); | ||
| 914 | |||
| 915 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 916 | assert( Py_REFCNT( frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2 ) == 2 ); // Frame stack | ||
| 917 | |||
| 918 | // Framed code: | ||
| 919 | { | ||
| 920 | PyObject *tmp_defaults_1; | ||
| 921 | tmp_defaults_1 = const_tuple_none_tuple; | ||
| 922 | Py_INCREF( tmp_defaults_1 ); | ||
| 923 | tmp_dictset_value = MAKE_FUNCTION_report$io$GTKIO$$$function_1___init__( tmp_defaults_1 ); | ||
| 924 | |||
| 925 | |||
| 926 | |||
| 927 | tmp_res = PyObject_SetItem( locals_report$io$GTKIO_19, const_str_plain___init__, tmp_dictset_value ); | ||
| 928 | Py_DECREF( tmp_dictset_value ); | ||
| 929 | if ( tmp_res != 0 ) | ||
| 930 | { | ||
| 931 | assert( ERROR_OCCURRED() ); | ||
| 932 | |||
| 933 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 934 | |||
| 935 | |||
| 936 | exception_lineno = 20; | ||
| 937 | type_description_2 = "o"; | ||
| 938 | goto frame_exception_exit_2; | ||
| 939 | } | ||
| 940 | } | ||
| 941 | |||
| 942 | #if 0 | ||
| 943 | RESTORE_FRAME_EXCEPTION( frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2 ); | ||
| 944 | #endif | ||
| 945 | |||
| 946 | // Put the previous frame back on top. | ||
| 947 | popFrameStack(); | ||
| 948 | |||
| 949 | goto frame_no_exception_1; | ||
| 950 | |||
| 951 | frame_exception_exit_2:; | ||
| 952 | |||
| 953 | #if 0 | ||
| 954 | RESTORE_FRAME_EXCEPTION( frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2 ); | ||
| 955 | #endif | ||
| 956 | |||
| 957 | if ( exception_tb == NULL ) | ||
| 958 | { | ||
| 959 | exception_tb = MAKE_TRACEBACK( frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2, exception_lineno ); | ||
| 960 | } | ||
| 961 | else if ( exception_tb->tb_frame != &frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2->m_frame ) | ||
| 962 | { | ||
| 963 | exception_tb = ADD_TRACEBACK( exception_tb, frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2, exception_lineno ); | ||
| 964 | } | ||
| 965 | |||
| 966 | // Attachs locals to frame if any. | ||
| 967 | Nuitka_Frame_AttachLocals( | ||
| 968 | (struct Nuitka_FrameObject *)frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2, | ||
| 969 | type_description_2, | ||
| 970 | outline_0_var___class__ | ||
| 971 | ); | ||
| 972 | |||
| 973 | |||
| 974 | // Release cached frame. | ||
| 975 | if ( frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2 == cache_frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2 ) | ||
| 976 | { | ||
| 977 | Py_DECREF( frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2 ); | ||
| 978 | } | ||
| 979 | cache_frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2 = NULL; | ||
| 980 | |||
| 981 | assertFrameObject( frame_bd3d2bedcbc2a52dbbc29cdd8d42c4f6_2 ); | ||
| 982 | |||
| 983 | // Put the previous frame back on top. | ||
| 984 | popFrameStack(); | ||
| 985 | |||
| 986 | // Return the error. | ||
| 987 | goto nested_frame_exit_1; | ||
| 988 | |||
| 989 | frame_no_exception_1:; | ||
| 990 | goto skip_nested_handling_1; | ||
| 991 | nested_frame_exit_1:; | ||
| 992 | |||
| 993 | goto try_except_handler_3; | ||
| 994 | skip_nested_handling_1:; | ||
| 995 | { | ||
| 996 | PyObject *tmp_assign_source_9; | ||
| 997 | PyObject *tmp_called_name_2; | ||
| 998 | PyObject *tmp_args_name_2; | ||
| 999 | PyObject *tmp_tuple_element_2; | ||
| 1000 | PyObject *tmp_kw_name_2; | ||
| 1001 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 1002 | tmp_called_name_2 = tmp_class_creation_1__metaclass; | ||
| 1003 | tmp_tuple_element_2 = const_str_plain_GTKIO; | ||
| 1004 | tmp_args_name_2 = PyTuple_New( 3 ); | ||
| 1005 | Py_INCREF( tmp_tuple_element_2 ); | ||
| 1006 | PyTuple_SET_ITEM( tmp_args_name_2, 0, tmp_tuple_element_2 ); | ||
| 1007 | tmp_tuple_element_2 = const_tuple_empty; | ||
| 1008 | Py_INCREF( tmp_tuple_element_2 ); | ||
| 1009 | PyTuple_SET_ITEM( tmp_args_name_2, 1, tmp_tuple_element_2 ); | ||
| 1010 | tmp_tuple_element_2 = locals_report$io$GTKIO_19; | ||
| 1011 | Py_INCREF( tmp_tuple_element_2 ); | ||
| 1012 | PyTuple_SET_ITEM( tmp_args_name_2, 2, tmp_tuple_element_2 ); | ||
| 1013 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 1014 | tmp_kw_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 1015 | frame_f317f93dbc32e90714a596337ab5d52d->m_frame.f_lineno = 19; | ||
| 1016 | tmp_assign_source_9 = CALL_FUNCTION( tmp_called_name_2, tmp_args_name_2, tmp_kw_name_2 ); | ||
| 1017 | Py_DECREF( tmp_args_name_2 ); | ||
| 1018 | if ( tmp_assign_source_9 == NULL ) | ||
| 1019 | { | ||
| 1020 | assert( ERROR_OCCURRED() ); | ||
| 1021 | |||
| 1022 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1023 | |||
| 1024 | |||
| 1025 | exception_lineno = 19; | ||
| 1026 | |||
| 1027 | goto try_except_handler_3; | ||
| 1028 | } | ||
| 1029 | assert( outline_0_var___class__ == NULL ); | ||
| 1030 | outline_0_var___class__ = tmp_assign_source_9; | ||
| 1031 | } | ||
| 1032 | CHECK_OBJECT( outline_0_var___class__ ); | ||
| 1033 | tmp_assign_source_8 = outline_0_var___class__; | ||
| 1034 | Py_INCREF( tmp_assign_source_8 ); | ||
| 1035 | goto try_return_handler_3; | ||
| 1036 | // tried codes exits in all cases | ||
| 1037 | NUITKA_CANNOT_GET_HERE( report$io$GTKIO ); | ||
| 1038 | return MOD_RETURN_VALUE( NULL ); | ||
| 1039 | // Return handler code: | ||
| 1040 | try_return_handler_3:; | ||
| 1041 | Py_DECREF( locals_report$io$GTKIO_19 ); | ||
| 1042 | locals_report$io$GTKIO_19 = NULL; | ||
| 1043 | goto try_return_handler_2; | ||
| 1044 | // Exception handler code: | ||
| 1045 | try_except_handler_3:; | ||
| 1046 | exception_keeper_type_1 = exception_type; | ||
| 1047 | exception_keeper_value_1 = exception_value; | ||
| 1048 | exception_keeper_tb_1 = exception_tb; | ||
| 1049 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1050 | exception_type = NULL; | ||
| 1051 | exception_value = NULL; | ||
| 1052 | exception_tb = NULL; | ||
| 1053 | exception_lineno = 0; | ||
| 1054 | |||
| 1055 | Py_DECREF( locals_report$io$GTKIO_19 ); | ||
| 1056 | locals_report$io$GTKIO_19 = NULL; | ||
| 1057 | // Re-raise. | ||
| 1058 | exception_type = exception_keeper_type_1; | ||
| 1059 | exception_value = exception_keeper_value_1; | ||
| 1060 | exception_tb = exception_keeper_tb_1; | ||
| 1061 | exception_lineno = exception_keeper_lineno_1; | ||
| 1062 | |||
| 1063 | goto try_except_handler_2; | ||
| 1064 | // End of try: | ||
| 1065 | // tried codes exits in all cases | ||
| 1066 | NUITKA_CANNOT_GET_HERE( report$io$GTKIO ); | ||
| 1067 | return MOD_RETURN_VALUE( NULL ); | ||
| 1068 | // Return handler code: | ||
| 1069 | try_return_handler_2:; | ||
| 1070 | CHECK_OBJECT( (PyObject *)outline_0_var___class__ ); | ||
| 1071 | Py_DECREF( outline_0_var___class__ ); | ||
| 1072 | outline_0_var___class__ = NULL; | ||
| 1073 | |||
| 1074 | goto outline_result_1; | ||
| 1075 | // Exception handler code: | ||
| 1076 | try_except_handler_2:; | ||
| 1077 | exception_keeper_type_2 = exception_type; | ||
| 1078 | exception_keeper_value_2 = exception_value; | ||
| 1079 | exception_keeper_tb_2 = exception_tb; | ||
| 1080 | exception_keeper_lineno_2 = exception_lineno; | ||
| 1081 | exception_type = NULL; | ||
| 1082 | exception_value = NULL; | ||
| 1083 | exception_tb = NULL; | ||
| 1084 | exception_lineno = 0; | ||
| 1085 | |||
| 1086 | // Re-raise. | ||
| 1087 | exception_type = exception_keeper_type_2; | ||
| 1088 | exception_value = exception_keeper_value_2; | ||
| 1089 | exception_tb = exception_keeper_tb_2; | ||
| 1090 | exception_lineno = exception_keeper_lineno_2; | ||
| 1091 | |||
| 1092 | goto outline_exception_1; | ||
| 1093 | // End of try: | ||
| 1094 | // Return statement must have exited already. | ||
| 1095 | NUITKA_CANNOT_GET_HERE( report$io$GTKIO ); | ||
| 1096 | return MOD_RETURN_VALUE( NULL ); | ||
| 1097 | outline_exception_1:; | ||
| 1098 | exception_lineno = 19; | ||
| 1099 | goto try_except_handler_1; | ||
| 1100 | outline_result_1:; | ||
| 1101 | UPDATE_STRING_DICT1( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain_GTKIO, tmp_assign_source_8 ); | ||
| 1102 | } | ||
| 1103 | goto try_end_1; | ||
| 1104 | // Exception handler code: | ||
| 1105 | try_except_handler_1:; | ||
| 1106 | exception_keeper_type_3 = exception_type; | ||
| 1107 | exception_keeper_value_3 = exception_value; | ||
| 1108 | exception_keeper_tb_3 = exception_tb; | ||
| 1109 | exception_keeper_lineno_3 = exception_lineno; | ||
| 1110 | exception_type = NULL; | ||
| 1111 | exception_value = NULL; | ||
| 1112 | exception_tb = NULL; | ||
| 1113 | exception_lineno = 0; | ||
| 1114 | |||
| 1115 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__class_decl_dict ); | ||
| 1116 | Py_DECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 1117 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 1118 | |||
| 1119 | Py_XDECREF( tmp_class_creation_1__metaclass ); | ||
| 1120 | tmp_class_creation_1__metaclass = NULL; | ||
| 1121 | |||
| 1122 | Py_XDECREF( tmp_class_creation_1__prepared ); | ||
| 1123 | tmp_class_creation_1__prepared = NULL; | ||
| 1124 | |||
| 1125 | // Re-raise. | ||
| 1126 | exception_type = exception_keeper_type_3; | ||
| 1127 | exception_value = exception_keeper_value_3; | ||
| 1128 | exception_tb = exception_keeper_tb_3; | ||
| 1129 | exception_lineno = exception_keeper_lineno_3; | ||
| 1130 | |||
| 1131 | goto frame_exception_exit_1; | ||
| 1132 | // End of try: | ||
| 1133 | try_end_1:; | ||
| 1134 | |||
| 1135 | // Restore frame exception if necessary. | ||
| 1136 | #if 0 | ||
| 1137 | RESTORE_FRAME_EXCEPTION( frame_f317f93dbc32e90714a596337ab5d52d ); | ||
| 1138 | #endif | ||
| 1139 | popFrameStack(); | ||
| 1140 | |||
| 1141 | assertFrameObject( frame_f317f93dbc32e90714a596337ab5d52d ); | ||
| 1142 | |||
| 1143 | goto frame_no_exception_2; | ||
| 1144 | |||
| 1145 | frame_exception_exit_1:; | ||
| 1146 | #if 0 | ||
| 1147 | RESTORE_FRAME_EXCEPTION( frame_f317f93dbc32e90714a596337ab5d52d ); | ||
| 1148 | #endif | ||
| 1149 | |||
| 1150 | if ( exception_tb == NULL ) | ||
| 1151 | { | ||
| 1152 | exception_tb = MAKE_TRACEBACK( frame_f317f93dbc32e90714a596337ab5d52d, exception_lineno ); | ||
| 1153 | } | ||
| 1154 | else if ( exception_tb->tb_frame != &frame_f317f93dbc32e90714a596337ab5d52d->m_frame ) | ||
| 1155 | { | ||
| 1156 | exception_tb = ADD_TRACEBACK( exception_tb, frame_f317f93dbc32e90714a596337ab5d52d, exception_lineno ); | ||
| 1157 | } | ||
| 1158 | |||
| 1159 | // Put the previous frame back on top. | ||
| 1160 | popFrameStack(); | ||
| 1161 | |||
| 1162 | // Return the error. | ||
| 1163 | goto module_exception_exit; | ||
| 1164 | |||
| 1165 | frame_no_exception_2:; | ||
| 1166 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__class_decl_dict ); | ||
| 1167 | Py_DECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 1168 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 1169 | |||
| 1170 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__metaclass ); | ||
| 1171 | Py_DECREF( tmp_class_creation_1__metaclass ); | ||
| 1172 | tmp_class_creation_1__metaclass = NULL; | ||
| 1173 | |||
| 1174 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__prepared ); | ||
| 1175 | Py_DECREF( tmp_class_creation_1__prepared ); | ||
| 1176 | tmp_class_creation_1__prepared = NULL; | ||
| 1177 | |||
| 1178 | |||
| 1179 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 1180 | #if 0 && 0 | ||
| 1181 | { | ||
| 1182 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_report$io$GTKIO, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 1183 | |||
| 1184 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 1185 | { | ||
| 1186 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 1187 | |||
| 1188 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 1189 | CHECK_OBJECT( path_importer_cache ); | ||
| 1190 | |||
| 1191 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 1192 | assert( res == 0 ); | ||
| 1193 | } | ||
| 1194 | } | ||
| 1195 | #endif | ||
| 1196 | #endif | ||
| 1197 | |||
| 1198 | return MOD_RETURN_VALUE( module_report$io$GTKIO ); | ||
| 1199 | module_exception_exit: | ||
| 1200 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1201 | return MOD_RETURN_VALUE( NULL ); | ||
| 1202 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.report.io.GTKIO.o deleted (index 18db208..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.report.io.NewtIO.c deleted (index 8561fb4..0000000) | |||
| 1 | /* Generated code for Python module 'report.io.NewtIO' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_report$io$NewtIO" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_report$io$NewtIO; | ||
| 31 | PyDictObject *moduledict_report$io$NewtIO; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_tuple_none_tuple; | ||
| 35 | static PyObject *const_tuple_str_plain_self_str_plain_screen_tuple; | ||
| 36 | extern PyObject *const_str_plain___module__; | ||
| 37 | extern PyObject *const_str_plain_metaclass; | ||
| 38 | extern PyObject *const_str_plain___spec__; | ||
| 39 | extern PyObject *const_str_plain___name__; | ||
| 40 | extern PyObject *const_str_plain___getitem__; | ||
| 41 | extern PyObject *const_tuple_str_plain___class___tuple; | ||
| 42 | extern PyObject *const_str_plain___qualname__; | ||
| 43 | extern PyObject *const_str_angle_metaclass; | ||
| 44 | static PyObject *const_str_digest_4e2f6e561fa1031d090abec5a622d092; | ||
| 45 | extern PyObject *const_str_plain___file__; | ||
| 46 | extern PyObject *const_str_digest_176045277faffdb215e36349ee6bf75e; | ||
| 47 | static PyObject *const_str_digest_7715188dc0febbfbe72b65e6a036f1ac; | ||
| 48 | extern PyObject *const_str_plain___prepare__; | ||
| 49 | extern PyObject *const_str_plain_screen; | ||
| 50 | extern PyObject *const_str_plain___init__; | ||
| 51 | extern PyObject *const_str_plain_NewtIO; | ||
| 52 | extern PyObject *const_str_plain_self; | ||
| 53 | extern PyObject *const_str_plain_origin; | ||
| 54 | extern PyObject *const_str_plain_None; | ||
| 55 | extern PyObject *const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 56 | extern PyObject *const_tuple_empty; | ||
| 57 | extern PyObject *const_str_plain_has_location; | ||
| 58 | static PyObject *const_str_digest_dc13f55d19264521d8ed7b93fc804cfc; | ||
| 59 | extern PyObject *const_str_plain_type; | ||
| 60 | static PyObject *const_tuple_str_plain_NewtIO_tuple_empty_tuple; | ||
| 61 | static PyObject *const_str_digest_debf5b9358a851537735d570e16aa508; | ||
| 62 | extern PyObject *const_str_plain___doc__; | ||
| 63 | extern PyObject *const_str_plain___cached__; | ||
| 64 | extern PyObject *const_str_plain___class__; | ||
| 65 | static PyObject *module_filename_obj; | ||
| 66 | |||
| 67 | /* Indicator if this modules private constants were created yet. */ | ||
| 68 | static bool constants_created = false; | ||
| 69 | |||
| 70 | /* Function to create module private constants. */ | ||
| 71 | static void createModuleConstants( void ) | ||
| 72 | { | ||
| 73 | const_tuple_str_plain_self_str_plain_screen_tuple = PyTuple_New( 2 ); | ||
| 74 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_screen_tuple, 0, const_str_plain_self ); Py_INCREF( const_str_plain_self ); | ||
| 75 | PyTuple_SET_ITEM( const_tuple_str_plain_self_str_plain_screen_tuple, 1, const_str_plain_screen ); Py_INCREF( const_str_plain_screen ); | ||
| 76 | const_str_digest_4e2f6e561fa1031d090abec5a622d092 = UNSTREAM_STRING_ASCII( &constant_bin[ 62800 ], 25, 0 ); | ||
| 77 | const_str_digest_7715188dc0febbfbe72b65e6a036f1ac = UNSTREAM_STRING_ASCII( &constant_bin[ 62825 ], 19, 0 ); | ||
| 78 | const_str_digest_dc13f55d19264521d8ed7b93fc804cfc = UNSTREAM_STRING_ASCII( &constant_bin[ 62844 ], 15, 0 ); | ||
| 79 | const_tuple_str_plain_NewtIO_tuple_empty_tuple = PyTuple_New( 2 ); | ||
| 80 | PyTuple_SET_ITEM( const_tuple_str_plain_NewtIO_tuple_empty_tuple, 0, const_str_plain_NewtIO ); Py_INCREF( const_str_plain_NewtIO ); | ||
| 81 | PyTuple_SET_ITEM( const_tuple_str_plain_NewtIO_tuple_empty_tuple, 1, const_tuple_empty ); Py_INCREF( const_tuple_empty ); | ||
| 82 | const_str_digest_debf5b9358a851537735d570e16aa508 = UNSTREAM_STRING_ASCII( &constant_bin[ 62808 ], 16, 0 ); | ||
| 83 | |||
| 84 | constants_created = true; | ||
| 85 | } | ||
| 86 | |||
| 87 | /* Function to verify module private constants for non-corruption. */ | ||
| 88 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 89 | void checkModuleConstants_report$io$NewtIO( void ) | ||
| 90 | { | ||
| 91 | // The module may not have been used at all, then ignore this. | ||
| 92 | if (constants_created == false) return; | ||
| 93 | |||
| 94 | |||
| 95 | } | ||
| 96 | #endif | ||
| 97 | |||
| 98 | // The module code objects. | ||
| 99 | static PyCodeObject *codeobj_18b78128e0125c956ec3805bbfb019aa; | ||
| 100 | static PyCodeObject *codeobj_efafc63824b2c278d751769aa5012c25; | ||
| 101 | static PyCodeObject *codeobj_02749f8a58fb3768f54ffd70b40b45fa; | ||
| 102 | |||
| 103 | static void createModuleCodeObjects(void) | ||
| 104 | { | ||
| 105 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_7715188dc0febbfbe72b65e6a036f1ac ); | ||
| 106 | codeobj_18b78128e0125c956ec3805bbfb019aa = MAKE_CODEOBJ( module_filename_obj, const_str_digest_4e2f6e561fa1031d090abec5a622d092, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 107 | codeobj_efafc63824b2c278d751769aa5012c25 = MAKE_CODEOBJ( module_filename_obj, const_str_plain_NewtIO, 19, const_tuple_str_plain___class___tuple, 0, 0, CO_NOFREE ); | ||
| 108 | codeobj_02749f8a58fb3768f54ffd70b40b45fa = MAKE_CODEOBJ( module_filename_obj, const_str_plain___init__, 20, const_tuple_str_plain_self_str_plain_screen_tuple, 2, 0, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE ); | ||
| 109 | } | ||
| 110 | |||
| 111 | // The module function declarations. | ||
| 112 | static PyObject *MAKE_FUNCTION_report$io$NewtIO$$$function_1___init__( PyObject *defaults ); | ||
| 113 | |||
| 114 | |||
| 115 | // The module function definitions. | ||
| 116 | static PyObject *impl_report$io$NewtIO$$$function_1___init__( struct Nuitka_FunctionObject const *self, PyObject **python_pars ) | ||
| 117 | { | ||
| 118 | // Preserve error status for checks | ||
| 119 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 120 | NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED(); | ||
| 121 | #endif | ||
| 122 | |||
| 123 | // Local variable declarations. | ||
| 124 | PyObject *par_self = python_pars[ 0 ]; | ||
| 125 | PyObject *par_screen = python_pars[ 1 ]; | ||
| 126 | struct Nuitka_FrameObject *frame_02749f8a58fb3768f54ffd70b40b45fa; | ||
| 127 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 128 | bool tmp_result; | ||
| 129 | PyObject *exception_type = NULL; | ||
| 130 | PyObject *exception_value = NULL; | ||
| 131 | PyTracebackObject *exception_tb = NULL; | ||
| 132 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 133 | static struct Nuitka_FrameObject *cache_frame_02749f8a58fb3768f54ffd70b40b45fa = NULL; | ||
| 134 | PyObject *tmp_return_value = NULL; | ||
| 135 | PyObject *exception_keeper_type_1; | ||
| 136 | PyObject *exception_keeper_value_1; | ||
| 137 | PyTracebackObject *exception_keeper_tb_1; | ||
| 138 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 139 | |||
| 140 | // Actual function body. | ||
| 141 | // Tried code: | ||
| 142 | MAKE_OR_REUSE_FRAME( cache_frame_02749f8a58fb3768f54ffd70b40b45fa, codeobj_02749f8a58fb3768f54ffd70b40b45fa, module_report$io$NewtIO, sizeof(void *)+sizeof(void *) ); | ||
| 143 | frame_02749f8a58fb3768f54ffd70b40b45fa = cache_frame_02749f8a58fb3768f54ffd70b40b45fa; | ||
| 144 | |||
| 145 | // Push the new frame as the currently active one. | ||
| 146 | pushFrameStack( frame_02749f8a58fb3768f54ffd70b40b45fa ); | ||
| 147 | |||
| 148 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 149 | assert( Py_REFCNT( frame_02749f8a58fb3768f54ffd70b40b45fa ) == 2 ); // Frame stack | ||
| 150 | |||
| 151 | // Framed code: | ||
| 152 | { | ||
| 153 | PyObject *tmp_assattr_name_1; | ||
| 154 | PyObject *tmp_assattr_target_1; | ||
| 155 | CHECK_OBJECT( par_screen ); | ||
| 156 | tmp_assattr_name_1 = par_screen; | ||
| 157 | CHECK_OBJECT( par_self ); | ||
| 158 | tmp_assattr_target_1 = par_self; | ||
| 159 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_screen, tmp_assattr_name_1 ); | ||
| 160 | if ( tmp_result == false ) | ||
| 161 | { | ||
| 162 | assert( ERROR_OCCURRED() ); | ||
| 163 | |||
| 164 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 165 | |||
| 166 | |||
| 167 | exception_lineno = 21; | ||
| 168 | type_description_1 = "oo"; | ||
| 169 | goto frame_exception_exit_1; | ||
| 170 | } | ||
| 171 | } | ||
| 172 | |||
| 173 | #if 0 | ||
| 174 | RESTORE_FRAME_EXCEPTION( frame_02749f8a58fb3768f54ffd70b40b45fa ); | ||
| 175 | #endif | ||
| 176 | |||
| 177 | // Put the previous frame back on top. | ||
| 178 | popFrameStack(); | ||
| 179 | |||
| 180 | goto frame_no_exception_1; | ||
| 181 | |||
| 182 | frame_exception_exit_1:; | ||
| 183 | |||
| 184 | #if 0 | ||
| 185 | RESTORE_FRAME_EXCEPTION( frame_02749f8a58fb3768f54ffd70b40b45fa ); | ||
| 186 | #endif | ||
| 187 | |||
| 188 | if ( exception_tb == NULL ) | ||
| 189 | { | ||
| 190 | exception_tb = MAKE_TRACEBACK( frame_02749f8a58fb3768f54ffd70b40b45fa, exception_lineno ); | ||
| 191 | } | ||
| 192 | else if ( exception_tb->tb_frame != &frame_02749f8a58fb3768f54ffd70b40b45fa->m_frame ) | ||
| 193 | { | ||
| 194 | exception_tb = ADD_TRACEBACK( exception_tb, frame_02749f8a58fb3768f54ffd70b40b45fa, exception_lineno ); | ||
| 195 | } | ||
| 196 | |||
| 197 | // Attachs locals to frame if any. | ||
| 198 | Nuitka_Frame_AttachLocals( | ||
| 199 | (struct Nuitka_FrameObject *)frame_02749f8a58fb3768f54ffd70b40b45fa, | ||
| 200 | type_description_1, | ||
| 201 | par_self, | ||
| 202 | par_screen | ||
| 203 | ); | ||
| 204 | |||
| 205 | |||
| 206 | // Release cached frame. | ||
| 207 | if ( frame_02749f8a58fb3768f54ffd70b40b45fa == cache_frame_02749f8a58fb3768f54ffd70b40b45fa ) | ||
| 208 | { | ||
| 209 | Py_DECREF( frame_02749f8a58fb3768f54ffd70b40b45fa ); | ||
| 210 | } | ||
| 211 | cache_frame_02749f8a58fb3768f54ffd70b40b45fa = NULL; | ||
| 212 | |||
| 213 | assertFrameObject( frame_02749f8a58fb3768f54ffd70b40b45fa ); | ||
| 214 | |||
| 215 | // Put the previous frame back on top. | ||
| 216 | popFrameStack(); | ||
| 217 | |||
| 218 | // Return the error. | ||
| 219 | goto try_except_handler_1; | ||
| 220 | |||
| 221 | frame_no_exception_1:; | ||
| 222 | tmp_return_value = Py_None; | ||
| 223 | Py_INCREF( tmp_return_value ); | ||
| 224 | goto try_return_handler_1; | ||
| 225 | // tried codes exits in all cases | ||
| 226 | NUITKA_CANNOT_GET_HERE( report$io$NewtIO$$$function_1___init__ ); | ||
| 227 | return NULL; | ||
| 228 | // Return handler code: | ||
| 229 | try_return_handler_1:; | ||
| 230 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 231 | Py_DECREF( par_self ); | ||
| 232 | par_self = NULL; | ||
| 233 | |||
| 234 | CHECK_OBJECT( (PyObject *)par_screen ); | ||
| 235 | Py_DECREF( par_screen ); | ||
| 236 | par_screen = NULL; | ||
| 237 | |||
| 238 | goto function_return_exit; | ||
| 239 | // Exception handler code: | ||
| 240 | try_except_handler_1:; | ||
| 241 | exception_keeper_type_1 = exception_type; | ||
| 242 | exception_keeper_value_1 = exception_value; | ||
| 243 | exception_keeper_tb_1 = exception_tb; | ||
| 244 | exception_keeper_lineno_1 = exception_lineno; | ||
| 245 | exception_type = NULL; | ||
| 246 | exception_value = NULL; | ||
| 247 | exception_tb = NULL; | ||
| 248 | exception_lineno = 0; | ||
| 249 | |||
| 250 | CHECK_OBJECT( (PyObject *)par_self ); | ||
| 251 | Py_DECREF( par_self ); | ||
| 252 | par_self = NULL; | ||
| 253 | |||
| 254 | CHECK_OBJECT( (PyObject *)par_screen ); | ||
| 255 | Py_DECREF( par_screen ); | ||
| 256 | par_screen = NULL; | ||
| 257 | |||
| 258 | // Re-raise. | ||
| 259 | exception_type = exception_keeper_type_1; | ||
| 260 | exception_value = exception_keeper_value_1; | ||
| 261 | exception_tb = exception_keeper_tb_1; | ||
| 262 | exception_lineno = exception_keeper_lineno_1; | ||
| 263 | |||
| 264 | goto function_exception_exit; | ||
| 265 | // End of try: | ||
| 266 | |||
| 267 | // Return statement must have exited already. | ||
| 268 | NUITKA_CANNOT_GET_HERE( report$io$NewtIO$$$function_1___init__ ); | ||
| 269 | return NULL; | ||
| 270 | |||
| 271 | function_exception_exit: | ||
| 272 | assert( exception_type ); | ||
| 273 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 274 | |||
| 275 | return NULL; | ||
| 276 | |||
| 277 | function_return_exit: | ||
| 278 | // Function cleanup code if any. | ||
| 279 | |||
| 280 | |||
| 281 | // Actual function exit with return value, making sure we did not make | ||
| 282 | // the error status worse despite non-NULL return. | ||
| 283 | CHECK_OBJECT( tmp_return_value ); | ||
| 284 | assert( had_error || !ERROR_OCCURRED() ); | ||
| 285 | return tmp_return_value; | ||
| 286 | } | ||
| 287 | |||
| 288 | |||
| 289 | |||
| 290 | static PyObject *MAKE_FUNCTION_report$io$NewtIO$$$function_1___init__( PyObject *defaults ) | ||
| 291 | { | ||
| 292 | struct Nuitka_FunctionObject *result = Nuitka_Function_New( | ||
| 293 | impl_report$io$NewtIO$$$function_1___init__, | ||
| 294 | const_str_plain___init__, | ||
| 295 | #if PYTHON_VERSION >= 300 | ||
| 296 | const_str_digest_dc13f55d19264521d8ed7b93fc804cfc, | ||
| 297 | #endif | ||
| 298 | codeobj_02749f8a58fb3768f54ffd70b40b45fa, | ||
| 299 | defaults, | ||
| 300 | #if PYTHON_VERSION >= 300 | ||
| 301 | NULL, | ||
| 302 | NULL, | ||
| 303 | #endif | ||
| 304 | module_report$io$NewtIO, | ||
| 305 | NULL, | ||
| 306 | 0 | ||
| 307 | ); | ||
| 308 | |||
| 309 | return (PyObject *)result; | ||
| 310 | } | ||
| 311 | |||
| 312 | |||
| 313 | |||
| 314 | #if PYTHON_VERSION >= 300 | ||
| 315 | static struct PyModuleDef mdef_report$io$NewtIO = | ||
| 316 | { | ||
| 317 | PyModuleDef_HEAD_INIT, | ||
| 318 | "report.io.NewtIO", | ||
| 319 | NULL, /* m_doc */ | ||
| 320 | -1, /* m_size */ | ||
| 321 | NULL, /* m_methods */ | ||
| 322 | NULL, /* m_reload */ | ||
| 323 | NULL, /* m_traverse */ | ||
| 324 | NULL, /* m_clear */ | ||
| 325 | NULL, /* m_free */ | ||
| 326 | }; | ||
| 327 | #endif | ||
| 328 | |||
| 329 | extern PyObject *const_str_plain___compiled__; | ||
| 330 | |||
| 331 | extern PyObject *const_str_plain___package__; | ||
| 332 | |||
| 333 | #if PYTHON_VERSION >= 300 | ||
| 334 | extern PyObject *const_str_dot; | ||
| 335 | extern PyObject *const_str_plain___loader__; | ||
| 336 | #endif | ||
| 337 | |||
| 338 | #if PYTHON_VERSION >= 340 | ||
| 339 | extern PyObject *const_str_plain___spec__; | ||
| 340 | extern PyObject *const_str_plain__initializing; | ||
| 341 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 342 | #endif | ||
| 343 | |||
| 344 | extern void _initCompiledCellType(); | ||
| 345 | extern void _initCompiledGeneratorType(); | ||
| 346 | extern void _initCompiledFunctionType(); | ||
| 347 | extern void _initCompiledMethodType(); | ||
| 348 | extern void _initCompiledFrameType(); | ||
| 349 | #if PYTHON_VERSION >= 350 | ||
| 350 | extern void _initCompiledCoroutineTypes(); | ||
| 351 | #endif | ||
| 352 | #if PYTHON_VERSION >= 360 | ||
| 353 | extern void _initCompiledAsyncgenTypes(); | ||
| 354 | #endif | ||
| 355 | |||
| 356 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 357 | |||
| 358 | // The exported interface to CPython. On import of the module, this function | ||
| 359 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 360 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 361 | |||
| 362 | MOD_INIT_DECL( report$io$NewtIO ) | ||
| 363 | { | ||
| 364 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 365 | static bool _init_done = false; | ||
| 366 | |||
| 367 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 368 | if ( _init_done ) | ||
| 369 | { | ||
| 370 | return MOD_RETURN_VALUE( module_report$io$NewtIO ); | ||
| 371 | } | ||
| 372 | else | ||
| 373 | { | ||
| 374 | _init_done = true; | ||
| 375 | } | ||
| 376 | #endif | ||
| 377 | |||
| 378 | #ifdef _NUITKA_MODULE | ||
| 379 | // In case of a stand alone extension module, need to call initialization | ||
| 380 | // the init here because that's the first and only time we are going to get | ||
| 381 | // called here. | ||
| 382 | |||
| 383 | // Initialize the constant values used. | ||
| 384 | _initBuiltinModule(); | ||
| 385 | createGlobalConstants(); | ||
| 386 | |||
| 387 | /* Initialize the compiled types of Nuitka. */ | ||
| 388 | _initCompiledCellType(); | ||
| 389 | _initCompiledGeneratorType(); | ||
| 390 | _initCompiledFunctionType(); | ||
| 391 | _initCompiledMethodType(); | ||
| 392 | _initCompiledFrameType(); | ||
| 393 | #if PYTHON_VERSION >= 350 | ||
| 394 | _initCompiledCoroutineTypes(); | ||
| 395 | #endif | ||
| 396 | #if PYTHON_VERSION >= 360 | ||
| 397 | _initCompiledAsyncgenTypes(); | ||
| 398 | #endif | ||
| 399 | |||
| 400 | #if PYTHON_VERSION < 300 | ||
| 401 | _initSlotCompare(); | ||
| 402 | #endif | ||
| 403 | #if PYTHON_VERSION >= 270 | ||
| 404 | _initSlotIternext(); | ||
| 405 | #endif | ||
| 406 | |||
| 407 | patchBuiltinModule(); | ||
| 408 | patchTypeComparison(); | ||
| 409 | |||
| 410 | // Enable meta path based loader if not already done. | ||
| 411 | #ifdef _NUITKA_TRACE | ||
| 412 | puts("report.io.NewtIO: Calling setupMetaPathBasedLoader()."); | ||
| 413 | #endif | ||
| 414 | setupMetaPathBasedLoader(); | ||
| 415 | |||
| 416 | #if PYTHON_VERSION >= 300 | ||
| 417 | patchInspectModule(); | ||
| 418 | #endif | ||
| 419 | |||
| 420 | #endif | ||
| 421 | |||
| 422 | /* The constants only used by this module are created now. */ | ||
| 423 | #ifdef _NUITKA_TRACE | ||
| 424 | puts("report.io.NewtIO: Calling createModuleConstants()."); | ||
| 425 | #endif | ||
| 426 | createModuleConstants(); | ||
| 427 | |||
| 428 | /* The code objects used by this module are created now. */ | ||
| 429 | #ifdef _NUITKA_TRACE | ||
| 430 | puts("report.io.NewtIO: Calling createModuleCodeObjects()."); | ||
| 431 | #endif | ||
| 432 | createModuleCodeObjects(); | ||
| 433 | |||
| 434 | // puts( "in initreport$io$NewtIO" ); | ||
| 435 | |||
| 436 | // Create the module object first. There are no methods initially, all are | ||
| 437 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 438 | // set at this time, as it could not contain NUL characters this way, they | ||
| 439 | // are instead set in early module code. No "self" for modules, we have no | ||
| 440 | // use for it. | ||
| 441 | #if PYTHON_VERSION < 300 | ||
| 442 | module_report$io$NewtIO = Py_InitModule4( | ||
| 443 | "report.io.NewtIO", // Module Name | ||
| 444 | NULL, // No methods initially, all are added | ||
| 445 | // dynamically in actual module code only. | ||
| 446 | NULL, // No "__doc__" is initially set, as it could | ||
| 447 | // not contain NUL this way, added early in | ||
| 448 | // actual code. | ||
| 449 | NULL, // No self for modules, we don't use it. | ||
| 450 | PYTHON_API_VERSION | ||
| 451 | ); | ||
| 452 | #else | ||
| 453 | |||
| 454 | module_report$io$NewtIO = PyModule_Create( &mdef_report$io$NewtIO ); | ||
| 455 | #endif | ||
| 456 | |||
| 457 | moduledict_report$io$NewtIO = MODULE_DICT( module_report$io$NewtIO ); | ||
| 458 | |||
| 459 | // Set __compiled__ to what it we know. | ||
| 460 | UPDATE_STRING_DICT1( | ||
| 461 | moduledict_report$io$NewtIO, | ||
| 462 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 463 | Nuitka_dunder_compiled_value | ||
| 464 | ); | ||
| 465 | |||
| 466 | // Update "__package__" value to what it ought to be. | ||
| 467 | { | ||
| 468 | #if 0 | ||
| 469 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 470 | |||
| 471 | UPDATE_STRING_DICT1( | ||
| 472 | moduledict_report$io$NewtIO, | ||
| 473 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 474 | module_name | ||
| 475 | ); | ||
| 476 | #else | ||
| 477 | |||
| 478 | #if PYTHON_VERSION < 300 | ||
| 479 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 480 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 481 | |||
| 482 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 483 | |||
| 484 | if ( last_dot != NULL ) | ||
| 485 | { | ||
| 486 | UPDATE_STRING_DICT1( | ||
| 487 | moduledict_report$io$NewtIO, | ||
| 488 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 489 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 490 | ); | ||
| 491 | } | ||
| 492 | #else | ||
| 493 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 494 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 495 | |||
| 496 | if ( dot_index != -1 ) | ||
| 497 | { | ||
| 498 | UPDATE_STRING_DICT1( | ||
| 499 | moduledict_report$io$NewtIO, | ||
| 500 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 501 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 502 | ); | ||
| 503 | } | ||
| 504 | #endif | ||
| 505 | #endif | ||
| 506 | } | ||
| 507 | |||
| 508 | CHECK_OBJECT( module_report$io$NewtIO ); | ||
| 509 | |||
| 510 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 511 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 512 | #if PYTHON_VERSION >= 300 | ||
| 513 | { | ||
| 514 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_debf5b9358a851537735d570e16aa508, module_report$io$NewtIO ); | ||
| 515 | |||
| 516 | assert( r != -1 ); | ||
| 517 | } | ||
| 518 | #endif | ||
| 519 | |||
| 520 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 521 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 522 | // before the frame object is allocated, or else it may fail. | ||
| 523 | |||
| 524 | if ( GET_STRING_DICT_VALUE( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 525 | { | ||
| 526 | PyObject *value = (PyObject *)builtin_module; | ||
| 527 | |||
| 528 | // Check if main module, not a dict then but the module itself. | ||
| 529 | #if !defined(_NUITKA_EXE) || !0 | ||
| 530 | value = PyModule_GetDict( value ); | ||
| 531 | #endif | ||
| 532 | |||
| 533 | UPDATE_STRING_DICT0( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 534 | } | ||
| 535 | |||
| 536 | #if PYTHON_VERSION >= 300 | ||
| 537 | UPDATE_STRING_DICT0( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 538 | #endif | ||
| 539 | |||
| 540 | #if PYTHON_VERSION >= 340 | ||
| 541 | // Set the "__spec__" value | ||
| 542 | |||
| 543 | #if 0 | ||
| 544 | // Main modules just get "None" as spec. | ||
| 545 | UPDATE_STRING_DICT0( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 546 | #else | ||
| 547 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 548 | { | ||
| 549 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 550 | CHECK_OBJECT( bootstrap_module ); | ||
| 551 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 552 | Py_DECREF( bootstrap_module ); | ||
| 553 | |||
| 554 | PyObject *args[] = { | ||
| 555 | GET_STRING_DICT_VALUE( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 556 | (PyObject *)&Nuitka_Loader_Type | ||
| 557 | }; | ||
| 558 | |||
| 559 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 560 | module_spec_class, | ||
| 561 | args | ||
| 562 | ); | ||
| 563 | Py_DECREF( module_spec_class ); | ||
| 564 | |||
| 565 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 566 | CHECK_OBJECT( spec_value ); | ||
| 567 | |||
| 568 | // For packages set the submodule search locations as well, even if to empty | ||
| 569 | // list, so investigating code will consider it a package. | ||
| 570 | #if 0 | ||
| 571 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 572 | #endif | ||
| 573 | |||
| 574 | // Mark the execution in the "__spec__" value. | ||
| 575 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 576 | |||
| 577 | UPDATE_STRING_DICT1( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 578 | } | ||
| 579 | #endif | ||
| 580 | #endif | ||
| 581 | |||
| 582 | // Temp variables if any | ||
| 583 | PyObject *outline_0_var___class__ = NULL; | ||
| 584 | PyObject *tmp_class_creation_1__class_decl_dict = NULL; | ||
| 585 | PyObject *tmp_class_creation_1__metaclass = NULL; | ||
| 586 | PyObject *tmp_class_creation_1__prepared = NULL; | ||
| 587 | struct Nuitka_FrameObject *frame_18b78128e0125c956ec3805bbfb019aa; | ||
| 588 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 589 | bool tmp_result; | ||
| 590 | PyObject *exception_type = NULL; | ||
| 591 | PyObject *exception_value = NULL; | ||
| 592 | PyTracebackObject *exception_tb = NULL; | ||
| 593 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 594 | int tmp_res; | ||
| 595 | PyObject *tmp_dictdel_dict; | ||
| 596 | PyObject *tmp_dictdel_key; | ||
| 597 | PyObject *locals_report$io$NewtIO_19 = NULL; | ||
| 598 | PyObject *tmp_dictset_value; | ||
| 599 | struct Nuitka_FrameObject *frame_efafc63824b2c278d751769aa5012c25_2; | ||
| 600 | NUITKA_MAY_BE_UNUSED char const *type_description_2 = NULL; | ||
| 601 | static struct Nuitka_FrameObject *cache_frame_efafc63824b2c278d751769aa5012c25_2 = NULL; | ||
| 602 | PyObject *exception_keeper_type_1; | ||
| 603 | PyObject *exception_keeper_value_1; | ||
| 604 | PyTracebackObject *exception_keeper_tb_1; | ||
| 605 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 606 | PyObject *exception_keeper_type_2; | ||
| 607 | PyObject *exception_keeper_value_2; | ||
| 608 | PyTracebackObject *exception_keeper_tb_2; | ||
| 609 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 610 | PyObject *exception_keeper_type_3; | ||
| 611 | PyObject *exception_keeper_value_3; | ||
| 612 | PyTracebackObject *exception_keeper_tb_3; | ||
| 613 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; | ||
| 614 | |||
| 615 | // Module code. | ||
| 616 | { | ||
| 617 | PyObject *tmp_assign_source_1; | ||
| 618 | tmp_assign_source_1 = const_str_digest_176045277faffdb215e36349ee6bf75e; | ||
| 619 | UPDATE_STRING_DICT0( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 620 | } | ||
| 621 | { | ||
| 622 | PyObject *tmp_assign_source_2; | ||
| 623 | tmp_assign_source_2 = module_filename_obj; | ||
| 624 | UPDATE_STRING_DICT0( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 625 | } | ||
| 626 | // Frame without reuse. | ||
| 627 | frame_18b78128e0125c956ec3805bbfb019aa = MAKE_MODULE_FRAME( codeobj_18b78128e0125c956ec3805bbfb019aa, module_report$io$NewtIO ); | ||
| 628 | |||
| 629 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 630 | // owning it. | ||
| 631 | pushFrameStack( frame_18b78128e0125c956ec3805bbfb019aa ); | ||
| 632 | assert( Py_REFCNT( frame_18b78128e0125c956ec3805bbfb019aa ) == 2 ); | ||
| 633 | |||
| 634 | // Framed code: | ||
| 635 | { | ||
| 636 | PyObject *tmp_assattr_name_1; | ||
| 637 | PyObject *tmp_assattr_target_1; | ||
| 638 | PyObject *tmp_mvar_value_1; | ||
| 639 | tmp_assattr_name_1 = module_filename_obj; | ||
| 640 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 641 | |||
| 642 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 643 | { | ||
| 644 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 645 | } | ||
| 646 | |||
| 647 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 648 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 649 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 650 | if ( tmp_result == false ) | ||
| 651 | { | ||
| 652 | assert( ERROR_OCCURRED() ); | ||
| 653 | |||
| 654 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 655 | |||
| 656 | |||
| 657 | exception_lineno = 1; | ||
| 658 | |||
| 659 | goto frame_exception_exit_1; | ||
| 660 | } | ||
| 661 | } | ||
| 662 | { | ||
| 663 | PyObject *tmp_assattr_name_2; | ||
| 664 | PyObject *tmp_assattr_target_2; | ||
| 665 | PyObject *tmp_mvar_value_2; | ||
| 666 | tmp_assattr_name_2 = Py_True; | ||
| 667 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 668 | |||
| 669 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 670 | { | ||
| 671 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 672 | } | ||
| 673 | |||
| 674 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 675 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 676 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 677 | if ( tmp_result == false ) | ||
| 678 | { | ||
| 679 | assert( ERROR_OCCURRED() ); | ||
| 680 | |||
| 681 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 682 | |||
| 683 | |||
| 684 | exception_lineno = 1; | ||
| 685 | |||
| 686 | goto frame_exception_exit_1; | ||
| 687 | } | ||
| 688 | } | ||
| 689 | { | ||
| 690 | PyObject *tmp_assign_source_3; | ||
| 691 | tmp_assign_source_3 = Py_None; | ||
| 692 | UPDATE_STRING_DICT0( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 693 | } | ||
| 694 | { | ||
| 695 | PyObject *tmp_assign_source_4; | ||
| 696 | tmp_assign_source_4 = PyDict_New(); | ||
| 697 | assert( tmp_class_creation_1__class_decl_dict == NULL ); | ||
| 698 | tmp_class_creation_1__class_decl_dict = tmp_assign_source_4; | ||
| 699 | } | ||
| 700 | // Tried code: | ||
| 701 | { | ||
| 702 | PyObject *tmp_assign_source_5; | ||
| 703 | PyObject *tmp_metaclass_name_1; | ||
| 704 | nuitka_bool tmp_condition_result_1; | ||
| 705 | PyObject *tmp_key_name_1; | ||
| 706 | PyObject *tmp_dict_name_1; | ||
| 707 | PyObject *tmp_dict_name_2; | ||
| 708 | PyObject *tmp_key_name_2; | ||
| 709 | PyObject *tmp_bases_name_1; | ||
| 710 | tmp_key_name_1 = const_str_plain_metaclass; | ||
| 711 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 712 | tmp_dict_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 713 | tmp_res = PyDict_Contains( tmp_dict_name_1, tmp_key_name_1 ); | ||
| 714 | if ( tmp_res == -1 ) | ||
| 715 | { | ||
| 716 | assert( ERROR_OCCURRED() ); | ||
| 717 | |||
| 718 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 719 | |||
| 720 | |||
| 721 | exception_lineno = 19; | ||
| 722 | |||
| 723 | goto try_except_handler_1; | ||
| 724 | } | ||
| 725 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 726 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 727 | { | ||
| 728 | goto condexpr_true_1; | ||
| 729 | } | ||
| 730 | else | ||
| 731 | { | ||
| 732 | goto condexpr_false_1; | ||
| 733 | } | ||
| 734 | condexpr_true_1:; | ||
| 735 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 736 | tmp_dict_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 737 | tmp_key_name_2 = const_str_plain_metaclass; | ||
| 738 | tmp_metaclass_name_1 = DICT_GET_ITEM( tmp_dict_name_2, tmp_key_name_2 ); | ||
| 739 | if ( tmp_metaclass_name_1 == NULL ) | ||
| 740 | { | ||
| 741 | assert( ERROR_OCCURRED() ); | ||
| 742 | |||
| 743 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 744 | |||
| 745 | |||
| 746 | exception_lineno = 19; | ||
| 747 | |||
| 748 | goto try_except_handler_1; | ||
| 749 | } | ||
| 750 | goto condexpr_end_1; | ||
| 751 | condexpr_false_1:; | ||
| 752 | tmp_metaclass_name_1 = (PyObject *)&PyType_Type; | ||
| 753 | Py_INCREF( tmp_metaclass_name_1 ); | ||
| 754 | condexpr_end_1:; | ||
| 755 | tmp_bases_name_1 = const_tuple_empty; | ||
| 756 | tmp_assign_source_5 = SELECT_METACLASS( tmp_metaclass_name_1, tmp_bases_name_1 ); | ||
| 757 | Py_DECREF( tmp_metaclass_name_1 ); | ||
| 758 | if ( tmp_assign_source_5 == NULL ) | ||
| 759 | { | ||
| 760 | assert( ERROR_OCCURRED() ); | ||
| 761 | |||
| 762 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 763 | |||
| 764 | |||
| 765 | exception_lineno = 19; | ||
| 766 | |||
| 767 | goto try_except_handler_1; | ||
| 768 | } | ||
| 769 | assert( tmp_class_creation_1__metaclass == NULL ); | ||
| 770 | tmp_class_creation_1__metaclass = tmp_assign_source_5; | ||
| 771 | } | ||
| 772 | { | ||
| 773 | nuitka_bool tmp_condition_result_2; | ||
| 774 | PyObject *tmp_key_name_3; | ||
| 775 | PyObject *tmp_dict_name_3; | ||
| 776 | tmp_key_name_3 = const_str_plain_metaclass; | ||
| 777 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 778 | tmp_dict_name_3 = tmp_class_creation_1__class_decl_dict; | ||
| 779 | tmp_res = PyDict_Contains( tmp_dict_name_3, tmp_key_name_3 ); | ||
| 780 | if ( tmp_res == -1 ) | ||
| 781 | { | ||
| 782 | assert( ERROR_OCCURRED() ); | ||
| 783 | |||
| 784 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 785 | |||
| 786 | |||
| 787 | exception_lineno = 19; | ||
| 788 | |||
| 789 | goto try_except_handler_1; | ||
| 790 | } | ||
| 791 | tmp_condition_result_2 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 792 | if ( tmp_condition_result_2 == NUITKA_BOOL_TRUE ) | ||
| 793 | { | ||
| 794 | goto branch_yes_1; | ||
| 795 | } | ||
| 796 | else | ||
| 797 | { | ||
| 798 | goto branch_no_1; | ||
| 799 | } | ||
| 800 | branch_yes_1:; | ||
| 801 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 802 | tmp_dictdel_dict = tmp_class_creation_1__class_decl_dict; | ||
| 803 | tmp_dictdel_key = const_str_plain_metaclass; | ||
| 804 | tmp_result = DICT_REMOVE_ITEM( tmp_dictdel_dict, tmp_dictdel_key ); | ||
| 805 | if ( tmp_result == false ) | ||
| 806 | { | ||
| 807 | assert( ERROR_OCCURRED() ); | ||
| 808 | |||
| 809 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 810 | |||
| 811 | |||
| 812 | exception_lineno = 19; | ||
| 813 | |||
| 814 | goto try_except_handler_1; | ||
| 815 | } | ||
| 816 | branch_no_1:; | ||
| 817 | } | ||
| 818 | { | ||
| 819 | nuitka_bool tmp_condition_result_3; | ||
| 820 | PyObject *tmp_source_name_1; | ||
| 821 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 822 | tmp_source_name_1 = tmp_class_creation_1__metaclass; | ||
| 823 | tmp_res = PyObject_HasAttr( tmp_source_name_1, const_str_plain___prepare__ ); | ||
| 824 | tmp_condition_result_3 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 825 | if ( tmp_condition_result_3 == NUITKA_BOOL_TRUE ) | ||
| 826 | { | ||
| 827 | goto branch_yes_2; | ||
| 828 | } | ||
| 829 | else | ||
| 830 | { | ||
| 831 | goto branch_no_2; | ||
| 832 | } | ||
| 833 | branch_yes_2:; | ||
| 834 | { | ||
| 835 | PyObject *tmp_assign_source_6; | ||
| 836 | PyObject *tmp_called_name_1; | ||
| 837 | PyObject *tmp_source_name_2; | ||
| 838 | PyObject *tmp_args_name_1; | ||
| 839 | PyObject *tmp_kw_name_1; | ||
| 840 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 841 | tmp_source_name_2 = tmp_class_creation_1__metaclass; | ||
| 842 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain___prepare__ ); | ||
| 843 | if ( tmp_called_name_1 == NULL ) | ||
| 844 | { | ||
| 845 | assert( ERROR_OCCURRED() ); | ||
| 846 | |||
| 847 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 848 | |||
| 849 | |||
| 850 | exception_lineno = 19; | ||
| 851 | |||
| 852 | goto try_except_handler_1; | ||
| 853 | } | ||
| 854 | tmp_args_name_1 = const_tuple_str_plain_NewtIO_tuple_empty_tuple; | ||
| 855 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 856 | tmp_kw_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 857 | frame_18b78128e0125c956ec3805bbfb019aa->m_frame.f_lineno = 19; | ||
| 858 | tmp_assign_source_6 = CALL_FUNCTION( tmp_called_name_1, tmp_args_name_1, tmp_kw_name_1 ); | ||
| 859 | Py_DECREF( tmp_called_name_1 ); | ||
| 860 | if ( tmp_assign_source_6 == NULL ) | ||
| 861 | { | ||
| 862 | assert( ERROR_OCCURRED() ); | ||
| 863 | |||
| 864 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 865 | |||
| 866 | |||
| 867 | exception_lineno = 19; | ||
| 868 | |||
| 869 | goto try_except_handler_1; | ||
| 870 | } | ||
| 871 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 872 | tmp_class_creation_1__prepared = tmp_assign_source_6; | ||
| 873 | } | ||
| 874 | { | ||
| 875 | nuitka_bool tmp_condition_result_4; | ||
| 876 | PyObject *tmp_operand_name_1; | ||
| 877 | PyObject *tmp_source_name_3; | ||
| 878 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 879 | tmp_source_name_3 = tmp_class_creation_1__prepared; | ||
| 880 | tmp_res = PyObject_HasAttr( tmp_source_name_3, const_str_plain___getitem__ ); | ||
| 881 | tmp_operand_name_1 = ( tmp_res != 0 ) ? Py_True : Py_False; | ||
| 882 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 883 | if ( tmp_res == -1 ) | ||
| 884 | { | ||
| 885 | assert( ERROR_OCCURRED() ); | ||
| 886 | |||
| 887 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 888 | |||
| 889 | |||
| 890 | exception_lineno = 19; | ||
| 891 | |||
| 892 | goto try_except_handler_1; | ||
| 893 | } | ||
| 894 | tmp_condition_result_4 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 895 | if ( tmp_condition_result_4 == NUITKA_BOOL_TRUE ) | ||
| 896 | { | ||
| 897 | goto branch_yes_3; | ||
| 898 | } | ||
| 899 | else | ||
| 900 | { | ||
| 901 | goto branch_no_3; | ||
| 902 | } | ||
| 903 | branch_yes_3:; | ||
| 904 | { | ||
| 905 | PyObject *tmp_raise_type_1; | ||
| 906 | PyObject *tmp_raise_value_1; | ||
| 907 | PyObject *tmp_left_name_1; | ||
| 908 | PyObject *tmp_right_name_1; | ||
| 909 | PyObject *tmp_tuple_element_1; | ||
| 910 | PyObject *tmp_getattr_target_1; | ||
| 911 | PyObject *tmp_getattr_attr_1; | ||
| 912 | PyObject *tmp_getattr_default_1; | ||
| 913 | PyObject *tmp_source_name_4; | ||
| 914 | PyObject *tmp_type_arg_1; | ||
| 915 | tmp_raise_type_1 = PyExc_TypeError; | ||
| 916 | tmp_left_name_1 = const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 917 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 918 | tmp_getattr_target_1 = tmp_class_creation_1__metaclass; | ||
| 919 | tmp_getattr_attr_1 = const_str_plain___name__; | ||
| 920 | tmp_getattr_default_1 = const_str_angle_metaclass; | ||
| 921 | tmp_tuple_element_1 = BUILTIN_GETATTR( tmp_getattr_target_1, tmp_getattr_attr_1, tmp_getattr_default_1 ); | ||
| 922 | if ( tmp_tuple_element_1 == NULL ) | ||
| 923 | { | ||
| 924 | assert( ERROR_OCCURRED() ); | ||
| 925 | |||
| 926 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 927 | |||
| 928 | |||
| 929 | exception_lineno = 19; | ||
| 930 | |||
| 931 | goto try_except_handler_1; | ||
| 932 | } | ||
| 933 | tmp_right_name_1 = PyTuple_New( 2 ); | ||
| 934 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_1 ); | ||
| 935 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 936 | tmp_type_arg_1 = tmp_class_creation_1__prepared; | ||
| 937 | tmp_source_name_4 = BUILTIN_TYPE1( tmp_type_arg_1 ); | ||
| 938 | assert( !(tmp_source_name_4 == NULL) ); | ||
| 939 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain___name__ ); | ||
| 940 | Py_DECREF( tmp_source_name_4 ); | ||
| 941 | if ( tmp_tuple_element_1 == NULL ) | ||
| 942 | { | ||
| 943 | assert( ERROR_OCCURRED() ); | ||
| 944 | |||
| 945 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 946 | Py_DECREF( tmp_right_name_1 ); | ||
| 947 | |||
| 948 | exception_lineno = 19; | ||
| 949 | |||
| 950 | goto try_except_handler_1; | ||
| 951 | } | ||
| 952 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_1 ); | ||
| 953 | tmp_raise_value_1 = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 954 | Py_DECREF( tmp_right_name_1 ); | ||
| 955 | if ( tmp_raise_value_1 == NULL ) | ||
| 956 | { | ||
| 957 | assert( ERROR_OCCURRED() ); | ||
| 958 | |||
| 959 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 960 | |||
| 961 | |||
| 962 | exception_lineno = 19; | ||
| 963 | |||
| 964 | goto try_except_handler_1; | ||
| 965 | } | ||
| 966 | exception_type = tmp_raise_type_1; | ||
| 967 | Py_INCREF( tmp_raise_type_1 ); | ||
| 968 | exception_value = tmp_raise_value_1; | ||
| 969 | exception_lineno = 19; | ||
| 970 | RAISE_EXCEPTION_IMPLICIT( &exception_type, &exception_value, &exception_tb ); | ||
| 971 | |||
| 972 | goto try_except_handler_1; | ||
| 973 | } | ||
| 974 | branch_no_3:; | ||
| 975 | } | ||
| 976 | goto branch_end_2; | ||
| 977 | branch_no_2:; | ||
| 978 | { | ||
| 979 | PyObject *tmp_assign_source_7; | ||
| 980 | tmp_assign_source_7 = PyDict_New(); | ||
| 981 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 982 | tmp_class_creation_1__prepared = tmp_assign_source_7; | ||
| 983 | } | ||
| 984 | branch_end_2:; | ||
| 985 | } | ||
| 986 | { | ||
| 987 | PyObject *tmp_assign_source_8; | ||
| 988 | { | ||
| 989 | PyObject *tmp_set_locals_1; | ||
| 990 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 991 | tmp_set_locals_1 = tmp_class_creation_1__prepared; | ||
| 992 | locals_report$io$NewtIO_19 = tmp_set_locals_1; | ||
| 993 | Py_INCREF( tmp_set_locals_1 ); | ||
| 994 | } | ||
| 995 | // Tried code: | ||
| 996 | // Tried code: | ||
| 997 | tmp_dictset_value = const_str_digest_debf5b9358a851537735d570e16aa508; | ||
| 998 | tmp_res = PyObject_SetItem( locals_report$io$NewtIO_19, const_str_plain___module__, tmp_dictset_value ); | ||
| 999 | if ( tmp_res != 0 ) | ||
| 1000 | { | ||
| 1001 | assert( ERROR_OCCURRED() ); | ||
| 1002 | |||
| 1003 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1004 | |||
| 1005 | |||
| 1006 | exception_lineno = 19; | ||
| 1007 | |||
| 1008 | goto try_except_handler_3; | ||
| 1009 | } | ||
| 1010 | tmp_dictset_value = const_str_plain_NewtIO; | ||
| 1011 | tmp_res = PyObject_SetItem( locals_report$io$NewtIO_19, const_str_plain___qualname__, tmp_dictset_value ); | ||
| 1012 | if ( tmp_res != 0 ) | ||
| 1013 | { | ||
| 1014 | assert( ERROR_OCCURRED() ); | ||
| 1015 | |||
| 1016 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1017 | |||
| 1018 | |||
| 1019 | exception_lineno = 19; | ||
| 1020 | |||
| 1021 | goto try_except_handler_3; | ||
| 1022 | } | ||
| 1023 | MAKE_OR_REUSE_FRAME( cache_frame_efafc63824b2c278d751769aa5012c25_2, codeobj_efafc63824b2c278d751769aa5012c25, module_report$io$NewtIO, sizeof(void *) ); | ||
| 1024 | frame_efafc63824b2c278d751769aa5012c25_2 = cache_frame_efafc63824b2c278d751769aa5012c25_2; | ||
| 1025 | |||
| 1026 | // Push the new frame as the currently active one. | ||
| 1027 | pushFrameStack( frame_efafc63824b2c278d751769aa5012c25_2 ); | ||
| 1028 | |||
| 1029 | // Mark the frame object as in use, ref count 1 will be up for reuse. | ||
| 1030 | assert( Py_REFCNT( frame_efafc63824b2c278d751769aa5012c25_2 ) == 2 ); // Frame stack | ||
| 1031 | |||
| 1032 | // Framed code: | ||
| 1033 | { | ||
| 1034 | PyObject *tmp_defaults_1; | ||
| 1035 | tmp_defaults_1 = const_tuple_none_tuple; | ||
| 1036 | Py_INCREF( tmp_defaults_1 ); | ||
| 1037 | tmp_dictset_value = MAKE_FUNCTION_report$io$NewtIO$$$function_1___init__( tmp_defaults_1 ); | ||
| 1038 | |||
| 1039 | |||
| 1040 | |||
| 1041 | tmp_res = PyObject_SetItem( locals_report$io$NewtIO_19, const_str_plain___init__, tmp_dictset_value ); | ||
| 1042 | Py_DECREF( tmp_dictset_value ); | ||
| 1043 | if ( tmp_res != 0 ) | ||
| 1044 | { | ||
| 1045 | assert( ERROR_OCCURRED() ); | ||
| 1046 | |||
| 1047 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1048 | |||
| 1049 | |||
| 1050 | exception_lineno = 20; | ||
| 1051 | type_description_2 = "o"; | ||
| 1052 | goto frame_exception_exit_2; | ||
| 1053 | } | ||
| 1054 | } | ||
| 1055 | |||
| 1056 | #if 0 | ||
| 1057 | RESTORE_FRAME_EXCEPTION( frame_efafc63824b2c278d751769aa5012c25_2 ); | ||
| 1058 | #endif | ||
| 1059 | |||
| 1060 | // Put the previous frame back on top. | ||
| 1061 | popFrameStack(); | ||
| 1062 | |||
| 1063 | goto frame_no_exception_1; | ||
| 1064 | |||
| 1065 | frame_exception_exit_2:; | ||
| 1066 | |||
| 1067 | #if 0 | ||
| 1068 | RESTORE_FRAME_EXCEPTION( frame_efafc63824b2c278d751769aa5012c25_2 ); | ||
| 1069 | #endif | ||
| 1070 | |||
| 1071 | if ( exception_tb == NULL ) | ||
| 1072 | { | ||
| 1073 | exception_tb = MAKE_TRACEBACK( frame_efafc63824b2c278d751769aa5012c25_2, exception_lineno ); | ||
| 1074 | } | ||
| 1075 | else if ( exception_tb->tb_frame != &frame_efafc63824b2c278d751769aa5012c25_2->m_frame ) | ||
| 1076 | { | ||
| 1077 | exception_tb = ADD_TRACEBACK( exception_tb, frame_efafc63824b2c278d751769aa5012c25_2, exception_lineno ); | ||
| 1078 | } | ||
| 1079 | |||
| 1080 | // Attachs locals to frame if any. | ||
| 1081 | Nuitka_Frame_AttachLocals( | ||
| 1082 | (struct Nuitka_FrameObject *)frame_efafc63824b2c278d751769aa5012c25_2, | ||
| 1083 | type_description_2, | ||
| 1084 | outline_0_var___class__ | ||
| 1085 | ); | ||
| 1086 | |||
| 1087 | |||
| 1088 | // Release cached frame. | ||
| 1089 | if ( frame_efafc63824b2c278d751769aa5012c25_2 == cache_frame_efafc63824b2c278d751769aa5012c25_2 ) | ||
| 1090 | { | ||
| 1091 | Py_DECREF( frame_efafc63824b2c278d751769aa5012c25_2 ); | ||
| 1092 | } | ||
| 1093 | cache_frame_efafc63824b2c278d751769aa5012c25_2 = NULL; | ||
| 1094 | |||
| 1095 | assertFrameObject( frame_efafc63824b2c278d751769aa5012c25_2 ); | ||
| 1096 | |||
| 1097 | // Put the previous frame back on top. | ||
| 1098 | popFrameStack(); | ||
| 1099 | |||
| 1100 | // Return the error. | ||
| 1101 | goto nested_frame_exit_1; | ||
| 1102 | |||
| 1103 | frame_no_exception_1:; | ||
| 1104 | goto skip_nested_handling_1; | ||
| 1105 | nested_frame_exit_1:; | ||
| 1106 | |||
| 1107 | goto try_except_handler_3; | ||
| 1108 | skip_nested_handling_1:; | ||
| 1109 | { | ||
| 1110 | PyObject *tmp_assign_source_9; | ||
| 1111 | PyObject *tmp_called_name_2; | ||
| 1112 | PyObject *tmp_args_name_2; | ||
| 1113 | PyObject *tmp_tuple_element_2; | ||
| 1114 | PyObject *tmp_kw_name_2; | ||
| 1115 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 1116 | tmp_called_name_2 = tmp_class_creation_1__metaclass; | ||
| 1117 | tmp_tuple_element_2 = const_str_plain_NewtIO; | ||
| 1118 | tmp_args_name_2 = PyTuple_New( 3 ); | ||
| 1119 | Py_INCREF( tmp_tuple_element_2 ); | ||
| 1120 | PyTuple_SET_ITEM( tmp_args_name_2, 0, tmp_tuple_element_2 ); | ||
| 1121 | tmp_tuple_element_2 = const_tuple_empty; | ||
| 1122 | Py_INCREF( tmp_tuple_element_2 ); | ||
| 1123 | PyTuple_SET_ITEM( tmp_args_name_2, 1, tmp_tuple_element_2 ); | ||
| 1124 | tmp_tuple_element_2 = locals_report$io$NewtIO_19; | ||
| 1125 | Py_INCREF( tmp_tuple_element_2 ); | ||
| 1126 | PyTuple_SET_ITEM( tmp_args_name_2, 2, tmp_tuple_element_2 ); | ||
| 1127 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 1128 | tmp_kw_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 1129 | frame_18b78128e0125c956ec3805bbfb019aa->m_frame.f_lineno = 19; | ||
| 1130 | tmp_assign_source_9 = CALL_FUNCTION( tmp_called_name_2, tmp_args_name_2, tmp_kw_name_2 ); | ||
| 1131 | Py_DECREF( tmp_args_name_2 ); | ||
| 1132 | if ( tmp_assign_source_9 == NULL ) | ||
| 1133 | { | ||
| 1134 | assert( ERROR_OCCURRED() ); | ||
| 1135 | |||
| 1136 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 1137 | |||
| 1138 | |||
| 1139 | exception_lineno = 19; | ||
| 1140 | |||
| 1141 | goto try_except_handler_3; | ||
| 1142 | } | ||
| 1143 | assert( outline_0_var___class__ == NULL ); | ||
| 1144 | outline_0_var___class__ = tmp_assign_source_9; | ||
| 1145 | } | ||
| 1146 | CHECK_OBJECT( outline_0_var___class__ ); | ||
| 1147 | tmp_assign_source_8 = outline_0_var___class__; | ||
| 1148 | Py_INCREF( tmp_assign_source_8 ); | ||
| 1149 | goto try_return_handler_3; | ||
| 1150 | // tried codes exits in all cases | ||
| 1151 | NUITKA_CANNOT_GET_HERE( report$io$NewtIO ); | ||
| 1152 | return MOD_RETURN_VALUE( NULL ); | ||
| 1153 | // Return handler code: | ||
| 1154 | try_return_handler_3:; | ||
| 1155 | Py_DECREF( locals_report$io$NewtIO_19 ); | ||
| 1156 | locals_report$io$NewtIO_19 = NULL; | ||
| 1157 | goto try_return_handler_2; | ||
| 1158 | // Exception handler code: | ||
| 1159 | try_except_handler_3:; | ||
| 1160 | exception_keeper_type_1 = exception_type; | ||
| 1161 | exception_keeper_value_1 = exception_value; | ||
| 1162 | exception_keeper_tb_1 = exception_tb; | ||
| 1163 | exception_keeper_lineno_1 = exception_lineno; | ||
| 1164 | exception_type = NULL; | ||
| 1165 | exception_value = NULL; | ||
| 1166 | exception_tb = NULL; | ||
| 1167 | exception_lineno = 0; | ||
| 1168 | |||
| 1169 | Py_DECREF( locals_report$io$NewtIO_19 ); | ||
| 1170 | locals_report$io$NewtIO_19 = NULL; | ||
| 1171 | // Re-raise. | ||
| 1172 | exception_type = exception_keeper_type_1; | ||
| 1173 | exception_value = exception_keeper_value_1; | ||
| 1174 | exception_tb = exception_keeper_tb_1; | ||
| 1175 | exception_lineno = exception_keeper_lineno_1; | ||
| 1176 | |||
| 1177 | goto try_except_handler_2; | ||
| 1178 | // End of try: | ||
| 1179 | // tried codes exits in all cases | ||
| 1180 | NUITKA_CANNOT_GET_HERE( report$io$NewtIO ); | ||
| 1181 | return MOD_RETURN_VALUE( NULL ); | ||
| 1182 | // Return handler code: | ||
| 1183 | try_return_handler_2:; | ||
| 1184 | CHECK_OBJECT( (PyObject *)outline_0_var___class__ ); | ||
| 1185 | Py_DECREF( outline_0_var___class__ ); | ||
| 1186 | outline_0_var___class__ = NULL; | ||
| 1187 | |||
| 1188 | goto outline_result_1; | ||
| 1189 | // Exception handler code: | ||
| 1190 | try_except_handler_2:; | ||
| 1191 | exception_keeper_type_2 = exception_type; | ||
| 1192 | exception_keeper_value_2 = exception_value; | ||
| 1193 | exception_keeper_tb_2 = exception_tb; | ||
| 1194 | exception_keeper_lineno_2 = exception_lineno; | ||
| 1195 | exception_type = NULL; | ||
| 1196 | exception_value = NULL; | ||
| 1197 | exception_tb = NULL; | ||
| 1198 | exception_lineno = 0; | ||
| 1199 | |||
| 1200 | // Re-raise. | ||
| 1201 | exception_type = exception_keeper_type_2; | ||
| 1202 | exception_value = exception_keeper_value_2; | ||
| 1203 | exception_tb = exception_keeper_tb_2; | ||
| 1204 | exception_lineno = exception_keeper_lineno_2; | ||
| 1205 | |||
| 1206 | goto outline_exception_1; | ||
| 1207 | // End of try: | ||
| 1208 | // Return statement must have exited already. | ||
| 1209 | NUITKA_CANNOT_GET_HERE( report$io$NewtIO ); | ||
| 1210 | return MOD_RETURN_VALUE( NULL ); | ||
| 1211 | outline_exception_1:; | ||
| 1212 | exception_lineno = 19; | ||
| 1213 | goto try_except_handler_1; | ||
| 1214 | outline_result_1:; | ||
| 1215 | UPDATE_STRING_DICT1( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain_NewtIO, tmp_assign_source_8 ); | ||
| 1216 | } | ||
| 1217 | goto try_end_1; | ||
| 1218 | // Exception handler code: | ||
| 1219 | try_except_handler_1:; | ||
| 1220 | exception_keeper_type_3 = exception_type; | ||
| 1221 | exception_keeper_value_3 = exception_value; | ||
| 1222 | exception_keeper_tb_3 = exception_tb; | ||
| 1223 | exception_keeper_lineno_3 = exception_lineno; | ||
| 1224 | exception_type = NULL; | ||
| 1225 | exception_value = NULL; | ||
| 1226 | exception_tb = NULL; | ||
| 1227 | exception_lineno = 0; | ||
| 1228 | |||
| 1229 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__class_decl_dict ); | ||
| 1230 | Py_DECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 1231 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 1232 | |||
| 1233 | Py_XDECREF( tmp_class_creation_1__metaclass ); | ||
| 1234 | tmp_class_creation_1__metaclass = NULL; | ||
| 1235 | |||
| 1236 | Py_XDECREF( tmp_class_creation_1__prepared ); | ||
| 1237 | tmp_class_creation_1__prepared = NULL; | ||
| 1238 | |||
| 1239 | // Re-raise. | ||
| 1240 | exception_type = exception_keeper_type_3; | ||
| 1241 | exception_value = exception_keeper_value_3; | ||
| 1242 | exception_tb = exception_keeper_tb_3; | ||
| 1243 | exception_lineno = exception_keeper_lineno_3; | ||
| 1244 | |||
| 1245 | goto frame_exception_exit_1; | ||
| 1246 | // End of try: | ||
| 1247 | try_end_1:; | ||
| 1248 | |||
| 1249 | // Restore frame exception if necessary. | ||
| 1250 | #if 0 | ||
| 1251 | RESTORE_FRAME_EXCEPTION( frame_18b78128e0125c956ec3805bbfb019aa ); | ||
| 1252 | #endif | ||
| 1253 | popFrameStack(); | ||
| 1254 | |||
| 1255 | assertFrameObject( frame_18b78128e0125c956ec3805bbfb019aa ); | ||
| 1256 | |||
| 1257 | goto frame_no_exception_2; | ||
| 1258 | |||
| 1259 | frame_exception_exit_1:; | ||
| 1260 | #if 0 | ||
| 1261 | RESTORE_FRAME_EXCEPTION( frame_18b78128e0125c956ec3805bbfb019aa ); | ||
| 1262 | #endif | ||
| 1263 | |||
| 1264 | if ( exception_tb == NULL ) | ||
| 1265 | { | ||
| 1266 | exception_tb = MAKE_TRACEBACK( frame_18b78128e0125c956ec3805bbfb019aa, exception_lineno ); | ||
| 1267 | } | ||
| 1268 | else if ( exception_tb->tb_frame != &frame_18b78128e0125c956ec3805bbfb019aa->m_frame ) | ||
| 1269 | { | ||
| 1270 | exception_tb = ADD_TRACEBACK( exception_tb, frame_18b78128e0125c956ec3805bbfb019aa, exception_lineno ); | ||
| 1271 | } | ||
| 1272 | |||
| 1273 | // Put the previous frame back on top. | ||
| 1274 | popFrameStack(); | ||
| 1275 | |||
| 1276 | // Return the error. | ||
| 1277 | goto module_exception_exit; | ||
| 1278 | |||
| 1279 | frame_no_exception_2:; | ||
| 1280 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__class_decl_dict ); | ||
| 1281 | Py_DECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 1282 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 1283 | |||
| 1284 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__metaclass ); | ||
| 1285 | Py_DECREF( tmp_class_creation_1__metaclass ); | ||
| 1286 | tmp_class_creation_1__metaclass = NULL; | ||
| 1287 | |||
| 1288 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__prepared ); | ||
| 1289 | Py_DECREF( tmp_class_creation_1__prepared ); | ||
| 1290 | tmp_class_creation_1__prepared = NULL; | ||
| 1291 | |||
| 1292 | |||
| 1293 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 1294 | #if 0 && 0 | ||
| 1295 | { | ||
| 1296 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_report$io$NewtIO, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 1297 | |||
| 1298 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 1299 | { | ||
| 1300 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 1301 | |||
| 1302 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 1303 | CHECK_OBJECT( path_importer_cache ); | ||
| 1304 | |||
| 1305 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 1306 | assert( res == 0 ); | ||
| 1307 | } | ||
| 1308 | } | ||
| 1309 | #endif | ||
| 1310 | #endif | ||
| 1311 | |||
| 1312 | return MOD_RETURN_VALUE( module_report$io$NewtIO ); | ||
| 1313 | module_exception_exit: | ||
| 1314 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1315 | return MOD_RETURN_VALUE( NULL ); | ||
| 1316 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.report.io.NewtIO.o deleted (index 4f31b0d..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.report.io.TextIO.c deleted (index 8485715..0000000) | |||
| 1 | /* Generated code for Python module 'report.io.TextIO' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_report$io$TextIO" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_report$io$TextIO; | ||
| 31 | PyDictObject *moduledict_report$io$TextIO; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain___module__; | ||
| 35 | extern PyObject *const_str_plain_metaclass; | ||
| 36 | extern PyObject *const_str_plain___spec__; | ||
| 37 | extern PyObject *const_str_plain___name__; | ||
| 38 | static PyObject *const_str_digest_123b4e124ee4feffe9a8d4135cf3126c; | ||
| 39 | extern PyObject *const_str_plain___getitem__; | ||
| 40 | extern PyObject *const_str_plain___qualname__; | ||
| 41 | extern PyObject *const_str_angle_metaclass; | ||
| 42 | static PyObject *const_str_digest_6702dfb42467019d7745f99d1750586a; | ||
| 43 | extern PyObject *const_str_plain___file__; | ||
| 44 | extern PyObject *const_str_digest_176045277faffdb215e36349ee6bf75e; | ||
| 45 | extern PyObject *const_str_plain___prepare__; | ||
| 46 | static PyObject *const_tuple_str_plain_TextIO_tuple_empty_tuple; | ||
| 47 | extern PyObject *const_str_plain_origin; | ||
| 48 | extern PyObject *const_str_plain_TextIO; | ||
| 49 | extern PyObject *const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 50 | extern PyObject *const_tuple_empty; | ||
| 51 | extern PyObject *const_str_plain_has_location; | ||
| 52 | extern PyObject *const_str_plain_type; | ||
| 53 | extern PyObject *const_str_plain___doc__; | ||
| 54 | extern PyObject *const_str_plain___cached__; | ||
| 55 | static PyObject *const_str_digest_960fa03cb837af7eefb9f9569c955f0d; | ||
| 56 | static PyObject *module_filename_obj; | ||
| 57 | |||
| 58 | /* Indicator if this modules private constants were created yet. */ | ||
| 59 | static bool constants_created = false; | ||
| 60 | |||
| 61 | /* Function to create module private constants. */ | ||
| 62 | static void createModuleConstants( void ) | ||
| 63 | { | ||
| 64 | const_str_digest_123b4e124ee4feffe9a8d4135cf3126c = UNSTREAM_STRING_ASCII( &constant_bin[ 62859 ], 19, 0 ); | ||
| 65 | const_str_digest_6702dfb42467019d7745f99d1750586a = UNSTREAM_STRING_ASCII( &constant_bin[ 62878 ], 16, 0 ); | ||
| 66 | const_tuple_str_plain_TextIO_tuple_empty_tuple = PyTuple_New( 2 ); | ||
| 67 | PyTuple_SET_ITEM( const_tuple_str_plain_TextIO_tuple_empty_tuple, 0, const_str_plain_TextIO ); Py_INCREF( const_str_plain_TextIO ); | ||
| 68 | PyTuple_SET_ITEM( const_tuple_str_plain_TextIO_tuple_empty_tuple, 1, const_tuple_empty ); Py_INCREF( const_tuple_empty ); | ||
| 69 | const_str_digest_960fa03cb837af7eefb9f9569c955f0d = UNSTREAM_STRING_ASCII( &constant_bin[ 62894 ], 25, 0 ); | ||
| 70 | |||
| 71 | constants_created = true; | ||
| 72 | } | ||
| 73 | |||
| 74 | /* Function to verify module private constants for non-corruption. */ | ||
| 75 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 76 | void checkModuleConstants_report$io$TextIO( void ) | ||
| 77 | { | ||
| 78 | // The module may not have been used at all, then ignore this. | ||
| 79 | if (constants_created == false) return; | ||
| 80 | |||
| 81 | |||
| 82 | } | ||
| 83 | #endif | ||
| 84 | |||
| 85 | // The module code objects. | ||
| 86 | static PyCodeObject *codeobj_e1242c991aa353411f6ceee1c9249495; | ||
| 87 | |||
| 88 | static void createModuleCodeObjects(void) | ||
| 89 | { | ||
| 90 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_123b4e124ee4feffe9a8d4135cf3126c ); | ||
| 91 | codeobj_e1242c991aa353411f6ceee1c9249495 = MAKE_CODEOBJ( module_filename_obj, const_str_digest_960fa03cb837af7eefb9f9569c955f0d, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 92 | } | ||
| 93 | |||
| 94 | // The module function declarations. | ||
| 95 | |||
| 96 | |||
| 97 | // The module function definitions. | ||
| 98 | |||
| 99 | |||
| 100 | |||
| 101 | #if PYTHON_VERSION >= 300 | ||
| 102 | static struct PyModuleDef mdef_report$io$TextIO = | ||
| 103 | { | ||
| 104 | PyModuleDef_HEAD_INIT, | ||
| 105 | "report.io.TextIO", | ||
| 106 | NULL, /* m_doc */ | ||
| 107 | -1, /* m_size */ | ||
| 108 | NULL, /* m_methods */ | ||
| 109 | NULL, /* m_reload */ | ||
| 110 | NULL, /* m_traverse */ | ||
| 111 | NULL, /* m_clear */ | ||
| 112 | NULL, /* m_free */ | ||
| 113 | }; | ||
| 114 | #endif | ||
| 115 | |||
| 116 | extern PyObject *const_str_plain___compiled__; | ||
| 117 | |||
| 118 | extern PyObject *const_str_plain___package__; | ||
| 119 | |||
| 120 | #if PYTHON_VERSION >= 300 | ||
| 121 | extern PyObject *const_str_dot; | ||
| 122 | extern PyObject *const_str_plain___loader__; | ||
| 123 | #endif | ||
| 124 | |||
| 125 | #if PYTHON_VERSION >= 340 | ||
| 126 | extern PyObject *const_str_plain___spec__; | ||
| 127 | extern PyObject *const_str_plain__initializing; | ||
| 128 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 129 | #endif | ||
| 130 | |||
| 131 | extern void _initCompiledCellType(); | ||
| 132 | extern void _initCompiledGeneratorType(); | ||
| 133 | extern void _initCompiledFunctionType(); | ||
| 134 | extern void _initCompiledMethodType(); | ||
| 135 | extern void _initCompiledFrameType(); | ||
| 136 | #if PYTHON_VERSION >= 350 | ||
| 137 | extern void _initCompiledCoroutineTypes(); | ||
| 138 | #endif | ||
| 139 | #if PYTHON_VERSION >= 360 | ||
| 140 | extern void _initCompiledAsyncgenTypes(); | ||
| 141 | #endif | ||
| 142 | |||
| 143 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 144 | |||
| 145 | // The exported interface to CPython. On import of the module, this function | ||
| 146 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 147 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 148 | |||
| 149 | MOD_INIT_DECL( report$io$TextIO ) | ||
| 150 | { | ||
| 151 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 152 | static bool _init_done = false; | ||
| 153 | |||
| 154 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 155 | if ( _init_done ) | ||
| 156 | { | ||
| 157 | return MOD_RETURN_VALUE( module_report$io$TextIO ); | ||
| 158 | } | ||
| 159 | else | ||
| 160 | { | ||
| 161 | _init_done = true; | ||
| 162 | } | ||
| 163 | #endif | ||
| 164 | |||
| 165 | #ifdef _NUITKA_MODULE | ||
| 166 | // In case of a stand alone extension module, need to call initialization | ||
| 167 | // the init here because that's the first and only time we are going to get | ||
| 168 | // called here. | ||
| 169 | |||
| 170 | // Initialize the constant values used. | ||
| 171 | _initBuiltinModule(); | ||
| 172 | createGlobalConstants(); | ||
| 173 | |||
| 174 | /* Initialize the compiled types of Nuitka. */ | ||
| 175 | _initCompiledCellType(); | ||
| 176 | _initCompiledGeneratorType(); | ||
| 177 | _initCompiledFunctionType(); | ||
| 178 | _initCompiledMethodType(); | ||
| 179 | _initCompiledFrameType(); | ||
| 180 | #if PYTHON_VERSION >= 350 | ||
| 181 | _initCompiledCoroutineTypes(); | ||
| 182 | #endif | ||
| 183 | #if PYTHON_VERSION >= 360 | ||
| 184 | _initCompiledAsyncgenTypes(); | ||
| 185 | #endif | ||
| 186 | |||
| 187 | #if PYTHON_VERSION < 300 | ||
| 188 | _initSlotCompare(); | ||
| 189 | #endif | ||
| 190 | #if PYTHON_VERSION >= 270 | ||
| 191 | _initSlotIternext(); | ||
| 192 | #endif | ||
| 193 | |||
| 194 | patchBuiltinModule(); | ||
| 195 | patchTypeComparison(); | ||
| 196 | |||
| 197 | // Enable meta path based loader if not already done. | ||
| 198 | #ifdef _NUITKA_TRACE | ||
| 199 | puts("report.io.TextIO: Calling setupMetaPathBasedLoader()."); | ||
| 200 | #endif | ||
| 201 | setupMetaPathBasedLoader(); | ||
| 202 | |||
| 203 | #if PYTHON_VERSION >= 300 | ||
| 204 | patchInspectModule(); | ||
| 205 | #endif | ||
| 206 | |||
| 207 | #endif | ||
| 208 | |||
| 209 | /* The constants only used by this module are created now. */ | ||
| 210 | #ifdef _NUITKA_TRACE | ||
| 211 | puts("report.io.TextIO: Calling createModuleConstants()."); | ||
| 212 | #endif | ||
| 213 | createModuleConstants(); | ||
| 214 | |||
| 215 | /* The code objects used by this module are created now. */ | ||
| 216 | #ifdef _NUITKA_TRACE | ||
| 217 | puts("report.io.TextIO: Calling createModuleCodeObjects()."); | ||
| 218 | #endif | ||
| 219 | createModuleCodeObjects(); | ||
| 220 | |||
| 221 | // puts( "in initreport$io$TextIO" ); | ||
| 222 | |||
| 223 | // Create the module object first. There are no methods initially, all are | ||
| 224 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 225 | // set at this time, as it could not contain NUL characters this way, they | ||
| 226 | // are instead set in early module code. No "self" for modules, we have no | ||
| 227 | // use for it. | ||
| 228 | #if PYTHON_VERSION < 300 | ||
| 229 | module_report$io$TextIO = Py_InitModule4( | ||
| 230 | "report.io.TextIO", // Module Name | ||
| 231 | NULL, // No methods initially, all are added | ||
| 232 | // dynamically in actual module code only. | ||
| 233 | NULL, // No "__doc__" is initially set, as it could | ||
| 234 | // not contain NUL this way, added early in | ||
| 235 | // actual code. | ||
| 236 | NULL, // No self for modules, we don't use it. | ||
| 237 | PYTHON_API_VERSION | ||
| 238 | ); | ||
| 239 | #else | ||
| 240 | |||
| 241 | module_report$io$TextIO = PyModule_Create( &mdef_report$io$TextIO ); | ||
| 242 | #endif | ||
| 243 | |||
| 244 | moduledict_report$io$TextIO = MODULE_DICT( module_report$io$TextIO ); | ||
| 245 | |||
| 246 | // Set __compiled__ to what it we know. | ||
| 247 | UPDATE_STRING_DICT1( | ||
| 248 | moduledict_report$io$TextIO, | ||
| 249 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 250 | Nuitka_dunder_compiled_value | ||
| 251 | ); | ||
| 252 | |||
| 253 | // Update "__package__" value to what it ought to be. | ||
| 254 | { | ||
| 255 | #if 0 | ||
| 256 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 257 | |||
| 258 | UPDATE_STRING_DICT1( | ||
| 259 | moduledict_report$io$TextIO, | ||
| 260 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 261 | module_name | ||
| 262 | ); | ||
| 263 | #else | ||
| 264 | |||
| 265 | #if PYTHON_VERSION < 300 | ||
| 266 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 267 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 268 | |||
| 269 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 270 | |||
| 271 | if ( last_dot != NULL ) | ||
| 272 | { | ||
| 273 | UPDATE_STRING_DICT1( | ||
| 274 | moduledict_report$io$TextIO, | ||
| 275 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 276 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 277 | ); | ||
| 278 | } | ||
| 279 | #else | ||
| 280 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 281 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 282 | |||
| 283 | if ( dot_index != -1 ) | ||
| 284 | { | ||
| 285 | UPDATE_STRING_DICT1( | ||
| 286 | moduledict_report$io$TextIO, | ||
| 287 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 288 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 289 | ); | ||
| 290 | } | ||
| 291 | #endif | ||
| 292 | #endif | ||
| 293 | } | ||
| 294 | |||
| 295 | CHECK_OBJECT( module_report$io$TextIO ); | ||
| 296 | |||
| 297 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 298 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 299 | #if PYTHON_VERSION >= 300 | ||
| 300 | { | ||
| 301 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_6702dfb42467019d7745f99d1750586a, module_report$io$TextIO ); | ||
| 302 | |||
| 303 | assert( r != -1 ); | ||
| 304 | } | ||
| 305 | #endif | ||
| 306 | |||
| 307 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 308 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 309 | // before the frame object is allocated, or else it may fail. | ||
| 310 | |||
| 311 | if ( GET_STRING_DICT_VALUE( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 312 | { | ||
| 313 | PyObject *value = (PyObject *)builtin_module; | ||
| 314 | |||
| 315 | // Check if main module, not a dict then but the module itself. | ||
| 316 | #if !defined(_NUITKA_EXE) || !0 | ||
| 317 | value = PyModule_GetDict( value ); | ||
| 318 | #endif | ||
| 319 | |||
| 320 | UPDATE_STRING_DICT0( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 321 | } | ||
| 322 | |||
| 323 | #if PYTHON_VERSION >= 300 | ||
| 324 | UPDATE_STRING_DICT0( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 325 | #endif | ||
| 326 | |||
| 327 | #if PYTHON_VERSION >= 340 | ||
| 328 | // Set the "__spec__" value | ||
| 329 | |||
| 330 | #if 0 | ||
| 331 | // Main modules just get "None" as spec. | ||
| 332 | UPDATE_STRING_DICT0( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 333 | #else | ||
| 334 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 335 | { | ||
| 336 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 337 | CHECK_OBJECT( bootstrap_module ); | ||
| 338 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 339 | Py_DECREF( bootstrap_module ); | ||
| 340 | |||
| 341 | PyObject *args[] = { | ||
| 342 | GET_STRING_DICT_VALUE( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 343 | (PyObject *)&Nuitka_Loader_Type | ||
| 344 | }; | ||
| 345 | |||
| 346 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 347 | module_spec_class, | ||
| 348 | args | ||
| 349 | ); | ||
| 350 | Py_DECREF( module_spec_class ); | ||
| 351 | |||
| 352 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 353 | CHECK_OBJECT( spec_value ); | ||
| 354 | |||
| 355 | // For packages set the submodule search locations as well, even if to empty | ||
| 356 | // list, so investigating code will consider it a package. | ||
| 357 | #if 0 | ||
| 358 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 359 | #endif | ||
| 360 | |||
| 361 | // Mark the execution in the "__spec__" value. | ||
| 362 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 363 | |||
| 364 | UPDATE_STRING_DICT1( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 365 | } | ||
| 366 | #endif | ||
| 367 | #endif | ||
| 368 | |||
| 369 | // Temp variables if any | ||
| 370 | PyObject *outline_0_var___class__ = NULL; | ||
| 371 | PyObject *tmp_class_creation_1__class_decl_dict = NULL; | ||
| 372 | PyObject *tmp_class_creation_1__metaclass = NULL; | ||
| 373 | PyObject *tmp_class_creation_1__prepared = NULL; | ||
| 374 | struct Nuitka_FrameObject *frame_e1242c991aa353411f6ceee1c9249495; | ||
| 375 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 376 | bool tmp_result; | ||
| 377 | PyObject *exception_type = NULL; | ||
| 378 | PyObject *exception_value = NULL; | ||
| 379 | PyTracebackObject *exception_tb = NULL; | ||
| 380 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 381 | int tmp_res; | ||
| 382 | PyObject *tmp_dictdel_dict; | ||
| 383 | PyObject *tmp_dictdel_key; | ||
| 384 | PyObject *locals_report$io$TextIO_19 = NULL; | ||
| 385 | PyObject *tmp_dictset_value; | ||
| 386 | PyObject *exception_keeper_type_1; | ||
| 387 | PyObject *exception_keeper_value_1; | ||
| 388 | PyTracebackObject *exception_keeper_tb_1; | ||
| 389 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1; | ||
| 390 | PyObject *exception_keeper_type_2; | ||
| 391 | PyObject *exception_keeper_value_2; | ||
| 392 | PyTracebackObject *exception_keeper_tb_2; | ||
| 393 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2; | ||
| 394 | PyObject *exception_keeper_type_3; | ||
| 395 | PyObject *exception_keeper_value_3; | ||
| 396 | PyTracebackObject *exception_keeper_tb_3; | ||
| 397 | NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3; | ||
| 398 | |||
| 399 | // Module code. | ||
| 400 | { | ||
| 401 | PyObject *tmp_assign_source_1; | ||
| 402 | tmp_assign_source_1 = const_str_digest_176045277faffdb215e36349ee6bf75e; | ||
| 403 | UPDATE_STRING_DICT0( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 404 | } | ||
| 405 | { | ||
| 406 | PyObject *tmp_assign_source_2; | ||
| 407 | tmp_assign_source_2 = module_filename_obj; | ||
| 408 | UPDATE_STRING_DICT0( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 409 | } | ||
| 410 | // Frame without reuse. | ||
| 411 | frame_e1242c991aa353411f6ceee1c9249495 = MAKE_MODULE_FRAME( codeobj_e1242c991aa353411f6ceee1c9249495, module_report$io$TextIO ); | ||
| 412 | |||
| 413 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 414 | // owning it. | ||
| 415 | pushFrameStack( frame_e1242c991aa353411f6ceee1c9249495 ); | ||
| 416 | assert( Py_REFCNT( frame_e1242c991aa353411f6ceee1c9249495 ) == 2 ); | ||
| 417 | |||
| 418 | // Framed code: | ||
| 419 | { | ||
| 420 | PyObject *tmp_assattr_name_1; | ||
| 421 | PyObject *tmp_assattr_target_1; | ||
| 422 | PyObject *tmp_mvar_value_1; | ||
| 423 | tmp_assattr_name_1 = module_filename_obj; | ||
| 424 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 425 | |||
| 426 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 427 | { | ||
| 428 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 429 | } | ||
| 430 | |||
| 431 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 432 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 433 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 434 | if ( tmp_result == false ) | ||
| 435 | { | ||
| 436 | assert( ERROR_OCCURRED() ); | ||
| 437 | |||
| 438 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 439 | |||
| 440 | |||
| 441 | exception_lineno = 1; | ||
| 442 | |||
| 443 | goto frame_exception_exit_1; | ||
| 444 | } | ||
| 445 | } | ||
| 446 | { | ||
| 447 | PyObject *tmp_assattr_name_2; | ||
| 448 | PyObject *tmp_assattr_target_2; | ||
| 449 | PyObject *tmp_mvar_value_2; | ||
| 450 | tmp_assattr_name_2 = Py_True; | ||
| 451 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 452 | |||
| 453 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 454 | { | ||
| 455 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 456 | } | ||
| 457 | |||
| 458 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 459 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 460 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 461 | if ( tmp_result == false ) | ||
| 462 | { | ||
| 463 | assert( ERROR_OCCURRED() ); | ||
| 464 | |||
| 465 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 466 | |||
| 467 | |||
| 468 | exception_lineno = 1; | ||
| 469 | |||
| 470 | goto frame_exception_exit_1; | ||
| 471 | } | ||
| 472 | } | ||
| 473 | { | ||
| 474 | PyObject *tmp_assign_source_3; | ||
| 475 | tmp_assign_source_3 = Py_None; | ||
| 476 | UPDATE_STRING_DICT0( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3 ); | ||
| 477 | } | ||
| 478 | { | ||
| 479 | PyObject *tmp_assign_source_4; | ||
| 480 | tmp_assign_source_4 = PyDict_New(); | ||
| 481 | assert( tmp_class_creation_1__class_decl_dict == NULL ); | ||
| 482 | tmp_class_creation_1__class_decl_dict = tmp_assign_source_4; | ||
| 483 | } | ||
| 484 | // Tried code: | ||
| 485 | { | ||
| 486 | PyObject *tmp_assign_source_5; | ||
| 487 | PyObject *tmp_metaclass_name_1; | ||
| 488 | nuitka_bool tmp_condition_result_1; | ||
| 489 | PyObject *tmp_key_name_1; | ||
| 490 | PyObject *tmp_dict_name_1; | ||
| 491 | PyObject *tmp_dict_name_2; | ||
| 492 | PyObject *tmp_key_name_2; | ||
| 493 | PyObject *tmp_bases_name_1; | ||
| 494 | tmp_key_name_1 = const_str_plain_metaclass; | ||
| 495 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 496 | tmp_dict_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 497 | tmp_res = PyDict_Contains( tmp_dict_name_1, tmp_key_name_1 ); | ||
| 498 | if ( tmp_res == -1 ) | ||
| 499 | { | ||
| 500 | assert( ERROR_OCCURRED() ); | ||
| 501 | |||
| 502 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 503 | |||
| 504 | |||
| 505 | exception_lineno = 19; | ||
| 506 | |||
| 507 | goto try_except_handler_1; | ||
| 508 | } | ||
| 509 | tmp_condition_result_1 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 510 | if ( tmp_condition_result_1 == NUITKA_BOOL_TRUE ) | ||
| 511 | { | ||
| 512 | goto condexpr_true_1; | ||
| 513 | } | ||
| 514 | else | ||
| 515 | { | ||
| 516 | goto condexpr_false_1; | ||
| 517 | } | ||
| 518 | condexpr_true_1:; | ||
| 519 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 520 | tmp_dict_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 521 | tmp_key_name_2 = const_str_plain_metaclass; | ||
| 522 | tmp_metaclass_name_1 = DICT_GET_ITEM( tmp_dict_name_2, tmp_key_name_2 ); | ||
| 523 | if ( tmp_metaclass_name_1 == NULL ) | ||
| 524 | { | ||
| 525 | assert( ERROR_OCCURRED() ); | ||
| 526 | |||
| 527 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 528 | |||
| 529 | |||
| 530 | exception_lineno = 19; | ||
| 531 | |||
| 532 | goto try_except_handler_1; | ||
| 533 | } | ||
| 534 | goto condexpr_end_1; | ||
| 535 | condexpr_false_1:; | ||
| 536 | tmp_metaclass_name_1 = (PyObject *)&PyType_Type; | ||
| 537 | Py_INCREF( tmp_metaclass_name_1 ); | ||
| 538 | condexpr_end_1:; | ||
| 539 | tmp_bases_name_1 = const_tuple_empty; | ||
| 540 | tmp_assign_source_5 = SELECT_METACLASS( tmp_metaclass_name_1, tmp_bases_name_1 ); | ||
| 541 | Py_DECREF( tmp_metaclass_name_1 ); | ||
| 542 | if ( tmp_assign_source_5 == NULL ) | ||
| 543 | { | ||
| 544 | assert( ERROR_OCCURRED() ); | ||
| 545 | |||
| 546 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 547 | |||
| 548 | |||
| 549 | exception_lineno = 19; | ||
| 550 | |||
| 551 | goto try_except_handler_1; | ||
| 552 | } | ||
| 553 | assert( tmp_class_creation_1__metaclass == NULL ); | ||
| 554 | tmp_class_creation_1__metaclass = tmp_assign_source_5; | ||
| 555 | } | ||
| 556 | { | ||
| 557 | nuitka_bool tmp_condition_result_2; | ||
| 558 | PyObject *tmp_key_name_3; | ||
| 559 | PyObject *tmp_dict_name_3; | ||
| 560 | tmp_key_name_3 = const_str_plain_metaclass; | ||
| 561 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 562 | tmp_dict_name_3 = tmp_class_creation_1__class_decl_dict; | ||
| 563 | tmp_res = PyDict_Contains( tmp_dict_name_3, tmp_key_name_3 ); | ||
| 564 | if ( tmp_res == -1 ) | ||
| 565 | { | ||
| 566 | assert( ERROR_OCCURRED() ); | ||
| 567 | |||
| 568 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 569 | |||
| 570 | |||
| 571 | exception_lineno = 19; | ||
| 572 | |||
| 573 | goto try_except_handler_1; | ||
| 574 | } | ||
| 575 | tmp_condition_result_2 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 576 | if ( tmp_condition_result_2 == NUITKA_BOOL_TRUE ) | ||
| 577 | { | ||
| 578 | goto branch_yes_1; | ||
| 579 | } | ||
| 580 | else | ||
| 581 | { | ||
| 582 | goto branch_no_1; | ||
| 583 | } | ||
| 584 | branch_yes_1:; | ||
| 585 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 586 | tmp_dictdel_dict = tmp_class_creation_1__class_decl_dict; | ||
| 587 | tmp_dictdel_key = const_str_plain_metaclass; | ||
| 588 | tmp_result = DICT_REMOVE_ITEM( tmp_dictdel_dict, tmp_dictdel_key ); | ||
| 589 | if ( tmp_result == false ) | ||
| 590 | { | ||
| 591 | assert( ERROR_OCCURRED() ); | ||
| 592 | |||
| 593 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 594 | |||
| 595 | |||
| 596 | exception_lineno = 19; | ||
| 597 | |||
| 598 | goto try_except_handler_1; | ||
| 599 | } | ||
| 600 | branch_no_1:; | ||
| 601 | } | ||
| 602 | { | ||
| 603 | nuitka_bool tmp_condition_result_3; | ||
| 604 | PyObject *tmp_source_name_1; | ||
| 605 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 606 | tmp_source_name_1 = tmp_class_creation_1__metaclass; | ||
| 607 | tmp_res = PyObject_HasAttr( tmp_source_name_1, const_str_plain___prepare__ ); | ||
| 608 | tmp_condition_result_3 = ( tmp_res != 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 609 | if ( tmp_condition_result_3 == NUITKA_BOOL_TRUE ) | ||
| 610 | { | ||
| 611 | goto branch_yes_2; | ||
| 612 | } | ||
| 613 | else | ||
| 614 | { | ||
| 615 | goto branch_no_2; | ||
| 616 | } | ||
| 617 | branch_yes_2:; | ||
| 618 | { | ||
| 619 | PyObject *tmp_assign_source_6; | ||
| 620 | PyObject *tmp_called_name_1; | ||
| 621 | PyObject *tmp_source_name_2; | ||
| 622 | PyObject *tmp_args_name_1; | ||
| 623 | PyObject *tmp_kw_name_1; | ||
| 624 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 625 | tmp_source_name_2 = tmp_class_creation_1__metaclass; | ||
| 626 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain___prepare__ ); | ||
| 627 | if ( tmp_called_name_1 == NULL ) | ||
| 628 | { | ||
| 629 | assert( ERROR_OCCURRED() ); | ||
| 630 | |||
| 631 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 632 | |||
| 633 | |||
| 634 | exception_lineno = 19; | ||
| 635 | |||
| 636 | goto try_except_handler_1; | ||
| 637 | } | ||
| 638 | tmp_args_name_1 = const_tuple_str_plain_TextIO_tuple_empty_tuple; | ||
| 639 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 640 | tmp_kw_name_1 = tmp_class_creation_1__class_decl_dict; | ||
| 641 | frame_e1242c991aa353411f6ceee1c9249495->m_frame.f_lineno = 19; | ||
| 642 | tmp_assign_source_6 = CALL_FUNCTION( tmp_called_name_1, tmp_args_name_1, tmp_kw_name_1 ); | ||
| 643 | Py_DECREF( tmp_called_name_1 ); | ||
| 644 | if ( tmp_assign_source_6 == NULL ) | ||
| 645 | { | ||
| 646 | assert( ERROR_OCCURRED() ); | ||
| 647 | |||
| 648 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 649 | |||
| 650 | |||
| 651 | exception_lineno = 19; | ||
| 652 | |||
| 653 | goto try_except_handler_1; | ||
| 654 | } | ||
| 655 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 656 | tmp_class_creation_1__prepared = tmp_assign_source_6; | ||
| 657 | } | ||
| 658 | { | ||
| 659 | nuitka_bool tmp_condition_result_4; | ||
| 660 | PyObject *tmp_operand_name_1; | ||
| 661 | PyObject *tmp_source_name_3; | ||
| 662 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 663 | tmp_source_name_3 = tmp_class_creation_1__prepared; | ||
| 664 | tmp_res = PyObject_HasAttr( tmp_source_name_3, const_str_plain___getitem__ ); | ||
| 665 | tmp_operand_name_1 = ( tmp_res != 0 ) ? Py_True : Py_False; | ||
| 666 | tmp_res = CHECK_IF_TRUE( tmp_operand_name_1 ); | ||
| 667 | if ( tmp_res == -1 ) | ||
| 668 | { | ||
| 669 | assert( ERROR_OCCURRED() ); | ||
| 670 | |||
| 671 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 672 | |||
| 673 | |||
| 674 | exception_lineno = 19; | ||
| 675 | |||
| 676 | goto try_except_handler_1; | ||
| 677 | } | ||
| 678 | tmp_condition_result_4 = ( tmp_res == 0 ) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE; | ||
| 679 | if ( tmp_condition_result_4 == NUITKA_BOOL_TRUE ) | ||
| 680 | { | ||
| 681 | goto branch_yes_3; | ||
| 682 | } | ||
| 683 | else | ||
| 684 | { | ||
| 685 | goto branch_no_3; | ||
| 686 | } | ||
| 687 | branch_yes_3:; | ||
| 688 | { | ||
| 689 | PyObject *tmp_raise_type_1; | ||
| 690 | PyObject *tmp_raise_value_1; | ||
| 691 | PyObject *tmp_left_name_1; | ||
| 692 | PyObject *tmp_right_name_1; | ||
| 693 | PyObject *tmp_tuple_element_1; | ||
| 694 | PyObject *tmp_getattr_target_1; | ||
| 695 | PyObject *tmp_getattr_attr_1; | ||
| 696 | PyObject *tmp_getattr_default_1; | ||
| 697 | PyObject *tmp_source_name_4; | ||
| 698 | PyObject *tmp_type_arg_1; | ||
| 699 | tmp_raise_type_1 = PyExc_TypeError; | ||
| 700 | tmp_left_name_1 = const_str_digest_75fd71b1edada749c2ef7ac810062295; | ||
| 701 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 702 | tmp_getattr_target_1 = tmp_class_creation_1__metaclass; | ||
| 703 | tmp_getattr_attr_1 = const_str_plain___name__; | ||
| 704 | tmp_getattr_default_1 = const_str_angle_metaclass; | ||
| 705 | tmp_tuple_element_1 = BUILTIN_GETATTR( tmp_getattr_target_1, tmp_getattr_attr_1, tmp_getattr_default_1 ); | ||
| 706 | if ( tmp_tuple_element_1 == NULL ) | ||
| 707 | { | ||
| 708 | assert( ERROR_OCCURRED() ); | ||
| 709 | |||
| 710 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 711 | |||
| 712 | |||
| 713 | exception_lineno = 19; | ||
| 714 | |||
| 715 | goto try_except_handler_1; | ||
| 716 | } | ||
| 717 | tmp_right_name_1 = PyTuple_New( 2 ); | ||
| 718 | PyTuple_SET_ITEM( tmp_right_name_1, 0, tmp_tuple_element_1 ); | ||
| 719 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 720 | tmp_type_arg_1 = tmp_class_creation_1__prepared; | ||
| 721 | tmp_source_name_4 = BUILTIN_TYPE1( tmp_type_arg_1 ); | ||
| 722 | assert( !(tmp_source_name_4 == NULL) ); | ||
| 723 | tmp_tuple_element_1 = LOOKUP_ATTRIBUTE( tmp_source_name_4, const_str_plain___name__ ); | ||
| 724 | Py_DECREF( tmp_source_name_4 ); | ||
| 725 | if ( tmp_tuple_element_1 == NULL ) | ||
| 726 | { | ||
| 727 | assert( ERROR_OCCURRED() ); | ||
| 728 | |||
| 729 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 730 | Py_DECREF( tmp_right_name_1 ); | ||
| 731 | |||
| 732 | exception_lineno = 19; | ||
| 733 | |||
| 734 | goto try_except_handler_1; | ||
| 735 | } | ||
| 736 | PyTuple_SET_ITEM( tmp_right_name_1, 1, tmp_tuple_element_1 ); | ||
| 737 | tmp_raise_value_1 = BINARY_OPERATION_REMAINDER( tmp_left_name_1, tmp_right_name_1 ); | ||
| 738 | Py_DECREF( tmp_right_name_1 ); | ||
| 739 | if ( tmp_raise_value_1 == NULL ) | ||
| 740 | { | ||
| 741 | assert( ERROR_OCCURRED() ); | ||
| 742 | |||
| 743 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 744 | |||
| 745 | |||
| 746 | exception_lineno = 19; | ||
| 747 | |||
| 748 | goto try_except_handler_1; | ||
| 749 | } | ||
| 750 | exception_type = tmp_raise_type_1; | ||
| 751 | Py_INCREF( tmp_raise_type_1 ); | ||
| 752 | exception_value = tmp_raise_value_1; | ||
| 753 | exception_lineno = 19; | ||
| 754 | RAISE_EXCEPTION_IMPLICIT( &exception_type, &exception_value, &exception_tb ); | ||
| 755 | |||
| 756 | goto try_except_handler_1; | ||
| 757 | } | ||
| 758 | branch_no_3:; | ||
| 759 | } | ||
| 760 | goto branch_end_2; | ||
| 761 | branch_no_2:; | ||
| 762 | { | ||
| 763 | PyObject *tmp_assign_source_7; | ||
| 764 | tmp_assign_source_7 = PyDict_New(); | ||
| 765 | assert( tmp_class_creation_1__prepared == NULL ); | ||
| 766 | tmp_class_creation_1__prepared = tmp_assign_source_7; | ||
| 767 | } | ||
| 768 | branch_end_2:; | ||
| 769 | } | ||
| 770 | { | ||
| 771 | PyObject *tmp_assign_source_8; | ||
| 772 | { | ||
| 773 | PyObject *tmp_set_locals_1; | ||
| 774 | CHECK_OBJECT( tmp_class_creation_1__prepared ); | ||
| 775 | tmp_set_locals_1 = tmp_class_creation_1__prepared; | ||
| 776 | locals_report$io$TextIO_19 = tmp_set_locals_1; | ||
| 777 | Py_INCREF( tmp_set_locals_1 ); | ||
| 778 | } | ||
| 779 | // Tried code: | ||
| 780 | // Tried code: | ||
| 781 | tmp_dictset_value = const_str_digest_6702dfb42467019d7745f99d1750586a; | ||
| 782 | tmp_res = PyObject_SetItem( locals_report$io$TextIO_19, const_str_plain___module__, tmp_dictset_value ); | ||
| 783 | if ( tmp_res != 0 ) | ||
| 784 | { | ||
| 785 | assert( ERROR_OCCURRED() ); | ||
| 786 | |||
| 787 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 788 | |||
| 789 | |||
| 790 | exception_lineno = 19; | ||
| 791 | |||
| 792 | goto try_except_handler_3; | ||
| 793 | } | ||
| 794 | tmp_dictset_value = const_str_plain_TextIO; | ||
| 795 | tmp_res = PyObject_SetItem( locals_report$io$TextIO_19, const_str_plain___qualname__, tmp_dictset_value ); | ||
| 796 | if ( tmp_res != 0 ) | ||
| 797 | { | ||
| 798 | assert( ERROR_OCCURRED() ); | ||
| 799 | |||
| 800 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 801 | |||
| 802 | |||
| 803 | exception_lineno = 19; | ||
| 804 | |||
| 805 | goto try_except_handler_3; | ||
| 806 | } | ||
| 807 | { | ||
| 808 | PyObject *tmp_assign_source_9; | ||
| 809 | PyObject *tmp_called_name_2; | ||
| 810 | PyObject *tmp_args_name_2; | ||
| 811 | PyObject *tmp_tuple_element_2; | ||
| 812 | PyObject *tmp_kw_name_2; | ||
| 813 | CHECK_OBJECT( tmp_class_creation_1__metaclass ); | ||
| 814 | tmp_called_name_2 = tmp_class_creation_1__metaclass; | ||
| 815 | tmp_tuple_element_2 = const_str_plain_TextIO; | ||
| 816 | tmp_args_name_2 = PyTuple_New( 3 ); | ||
| 817 | Py_INCREF( tmp_tuple_element_2 ); | ||
| 818 | PyTuple_SET_ITEM( tmp_args_name_2, 0, tmp_tuple_element_2 ); | ||
| 819 | tmp_tuple_element_2 = const_tuple_empty; | ||
| 820 | Py_INCREF( tmp_tuple_element_2 ); | ||
| 821 | PyTuple_SET_ITEM( tmp_args_name_2, 1, tmp_tuple_element_2 ); | ||
| 822 | tmp_tuple_element_2 = locals_report$io$TextIO_19; | ||
| 823 | Py_INCREF( tmp_tuple_element_2 ); | ||
| 824 | PyTuple_SET_ITEM( tmp_args_name_2, 2, tmp_tuple_element_2 ); | ||
| 825 | CHECK_OBJECT( tmp_class_creation_1__class_decl_dict ); | ||
| 826 | tmp_kw_name_2 = tmp_class_creation_1__class_decl_dict; | ||
| 827 | frame_e1242c991aa353411f6ceee1c9249495->m_frame.f_lineno = 19; | ||
| 828 | tmp_assign_source_9 = CALL_FUNCTION( tmp_called_name_2, tmp_args_name_2, tmp_kw_name_2 ); | ||
| 829 | Py_DECREF( tmp_args_name_2 ); | ||
| 830 | if ( tmp_assign_source_9 == NULL ) | ||
| 831 | { | ||
| 832 | assert( ERROR_OCCURRED() ); | ||
| 833 | |||
| 834 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 835 | |||
| 836 | |||
| 837 | exception_lineno = 19; | ||
| 838 | |||
| 839 | goto try_except_handler_3; | ||
| 840 | } | ||
| 841 | assert( outline_0_var___class__ == NULL ); | ||
| 842 | outline_0_var___class__ = tmp_assign_source_9; | ||
| 843 | } | ||
| 844 | CHECK_OBJECT( outline_0_var___class__ ); | ||
| 845 | tmp_assign_source_8 = outline_0_var___class__; | ||
| 846 | Py_INCREF( tmp_assign_source_8 ); | ||
| 847 | goto try_return_handler_3; | ||
| 848 | // tried codes exits in all cases | ||
| 849 | NUITKA_CANNOT_GET_HERE( report$io$TextIO ); | ||
| 850 | return MOD_RETURN_VALUE( NULL ); | ||
| 851 | // Return handler code: | ||
| 852 | try_return_handler_3:; | ||
| 853 | Py_DECREF( locals_report$io$TextIO_19 ); | ||
| 854 | locals_report$io$TextIO_19 = NULL; | ||
| 855 | goto try_return_handler_2; | ||
| 856 | // Exception handler code: | ||
| 857 | try_except_handler_3:; | ||
| 858 | exception_keeper_type_1 = exception_type; | ||
| 859 | exception_keeper_value_1 = exception_value; | ||
| 860 | exception_keeper_tb_1 = exception_tb; | ||
| 861 | exception_keeper_lineno_1 = exception_lineno; | ||
| 862 | exception_type = NULL; | ||
| 863 | exception_value = NULL; | ||
| 864 | exception_tb = NULL; | ||
| 865 | exception_lineno = 0; | ||
| 866 | |||
| 867 | Py_DECREF( locals_report$io$TextIO_19 ); | ||
| 868 | locals_report$io$TextIO_19 = NULL; | ||
| 869 | // Re-raise. | ||
| 870 | exception_type = exception_keeper_type_1; | ||
| 871 | exception_value = exception_keeper_value_1; | ||
| 872 | exception_tb = exception_keeper_tb_1; | ||
| 873 | exception_lineno = exception_keeper_lineno_1; | ||
| 874 | |||
| 875 | goto try_except_handler_2; | ||
| 876 | // End of try: | ||
| 877 | // tried codes exits in all cases | ||
| 878 | NUITKA_CANNOT_GET_HERE( report$io$TextIO ); | ||
| 879 | return MOD_RETURN_VALUE( NULL ); | ||
| 880 | // Return handler code: | ||
| 881 | try_return_handler_2:; | ||
| 882 | CHECK_OBJECT( (PyObject *)outline_0_var___class__ ); | ||
| 883 | Py_DECREF( outline_0_var___class__ ); | ||
| 884 | outline_0_var___class__ = NULL; | ||
| 885 | |||
| 886 | goto outline_result_1; | ||
| 887 | // Exception handler code: | ||
| 888 | try_except_handler_2:; | ||
| 889 | exception_keeper_type_2 = exception_type; | ||
| 890 | exception_keeper_value_2 = exception_value; | ||
| 891 | exception_keeper_tb_2 = exception_tb; | ||
| 892 | exception_keeper_lineno_2 = exception_lineno; | ||
| 893 | exception_type = NULL; | ||
| 894 | exception_value = NULL; | ||
| 895 | exception_tb = NULL; | ||
| 896 | exception_lineno = 0; | ||
| 897 | |||
| 898 | // Re-raise. | ||
| 899 | exception_type = exception_keeper_type_2; | ||
| 900 | exception_value = exception_keeper_value_2; | ||
| 901 | exception_tb = exception_keeper_tb_2; | ||
| 902 | exception_lineno = exception_keeper_lineno_2; | ||
| 903 | |||
| 904 | goto outline_exception_1; | ||
| 905 | // End of try: | ||
| 906 | // Return statement must have exited already. | ||
| 907 | NUITKA_CANNOT_GET_HERE( report$io$TextIO ); | ||
| 908 | return MOD_RETURN_VALUE( NULL ); | ||
| 909 | outline_exception_1:; | ||
| 910 | exception_lineno = 19; | ||
| 911 | goto try_except_handler_1; | ||
| 912 | outline_result_1:; | ||
| 913 | UPDATE_STRING_DICT1( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain_TextIO, tmp_assign_source_8 ); | ||
| 914 | } | ||
| 915 | goto try_end_1; | ||
| 916 | // Exception handler code: | ||
| 917 | try_except_handler_1:; | ||
| 918 | exception_keeper_type_3 = exception_type; | ||
| 919 | exception_keeper_value_3 = exception_value; | ||
| 920 | exception_keeper_tb_3 = exception_tb; | ||
| 921 | exception_keeper_lineno_3 = exception_lineno; | ||
| 922 | exception_type = NULL; | ||
| 923 | exception_value = NULL; | ||
| 924 | exception_tb = NULL; | ||
| 925 | exception_lineno = 0; | ||
| 926 | |||
| 927 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__class_decl_dict ); | ||
| 928 | Py_DECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 929 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 930 | |||
| 931 | Py_XDECREF( tmp_class_creation_1__metaclass ); | ||
| 932 | tmp_class_creation_1__metaclass = NULL; | ||
| 933 | |||
| 934 | Py_XDECREF( tmp_class_creation_1__prepared ); | ||
| 935 | tmp_class_creation_1__prepared = NULL; | ||
| 936 | |||
| 937 | // Re-raise. | ||
| 938 | exception_type = exception_keeper_type_3; | ||
| 939 | exception_value = exception_keeper_value_3; | ||
| 940 | exception_tb = exception_keeper_tb_3; | ||
| 941 | exception_lineno = exception_keeper_lineno_3; | ||
| 942 | |||
| 943 | goto frame_exception_exit_1; | ||
| 944 | // End of try: | ||
| 945 | try_end_1:; | ||
| 946 | |||
| 947 | // Restore frame exception if necessary. | ||
| 948 | #if 0 | ||
| 949 | RESTORE_FRAME_EXCEPTION( frame_e1242c991aa353411f6ceee1c9249495 ); | ||
| 950 | #endif | ||
| 951 | popFrameStack(); | ||
| 952 | |||
| 953 | assertFrameObject( frame_e1242c991aa353411f6ceee1c9249495 ); | ||
| 954 | |||
| 955 | goto frame_no_exception_1; | ||
| 956 | |||
| 957 | frame_exception_exit_1:; | ||
| 958 | #if 0 | ||
| 959 | RESTORE_FRAME_EXCEPTION( frame_e1242c991aa353411f6ceee1c9249495 ); | ||
| 960 | #endif | ||
| 961 | |||
| 962 | if ( exception_tb == NULL ) | ||
| 963 | { | ||
| 964 | exception_tb = MAKE_TRACEBACK( frame_e1242c991aa353411f6ceee1c9249495, exception_lineno ); | ||
| 965 | } | ||
| 966 | else if ( exception_tb->tb_frame != &frame_e1242c991aa353411f6ceee1c9249495->m_frame ) | ||
| 967 | { | ||
| 968 | exception_tb = ADD_TRACEBACK( exception_tb, frame_e1242c991aa353411f6ceee1c9249495, exception_lineno ); | ||
| 969 | } | ||
| 970 | |||
| 971 | // Put the previous frame back on top. | ||
| 972 | popFrameStack(); | ||
| 973 | |||
| 974 | // Return the error. | ||
| 975 | goto module_exception_exit; | ||
| 976 | |||
| 977 | frame_no_exception_1:; | ||
| 978 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__class_decl_dict ); | ||
| 979 | Py_DECREF( tmp_class_creation_1__class_decl_dict ); | ||
| 980 | tmp_class_creation_1__class_decl_dict = NULL; | ||
| 981 | |||
| 982 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__metaclass ); | ||
| 983 | Py_DECREF( tmp_class_creation_1__metaclass ); | ||
| 984 | tmp_class_creation_1__metaclass = NULL; | ||
| 985 | |||
| 986 | CHECK_OBJECT( (PyObject *)tmp_class_creation_1__prepared ); | ||
| 987 | Py_DECREF( tmp_class_creation_1__prepared ); | ||
| 988 | tmp_class_creation_1__prepared = NULL; | ||
| 989 | |||
| 990 | |||
| 991 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 992 | #if 0 && 0 | ||
| 993 | { | ||
| 994 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_report$io$TextIO, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 995 | |||
| 996 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 997 | { | ||
| 998 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 999 | |||
| 1000 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 1001 | CHECK_OBJECT( path_importer_cache ); | ||
| 1002 | |||
| 1003 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 1004 | assert( res == 0 ); | ||
| 1005 | } | ||
| 1006 | } | ||
| 1007 | #endif | ||
| 1008 | #endif | ||
| 1009 | |||
| 1010 | return MOD_RETURN_VALUE( module_report$io$TextIO ); | ||
| 1011 | module_exception_exit: | ||
| 1012 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 1013 | return MOD_RETURN_VALUE( NULL ); | ||
| 1014 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.report.io.TextIO.o deleted (index 18e480d..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.report.io.c deleted (index 9e83ee1..0000000) | |||
| 1 | /* Generated code for Python module 'report.io' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_report$io" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_report$io; | ||
| 31 | PyDictObject *moduledict_report$io; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain_environ; | ||
| 35 | extern PyObject *const_str_plain___spec__; | ||
| 36 | extern PyObject *const_str_plain_io; | ||
| 37 | static PyObject *const_tuple_da2096dc58666fa1a6a04b58e47b1662_tuple; | ||
| 38 | extern PyObject *const_str_digest_6f576c460435f45aaedb10ae95808089; | ||
| 39 | extern PyObject *const_str_plain___file__; | ||
| 40 | extern PyObject *const_str_plain_NUITKA_PACKAGE_report; | ||
| 41 | static PyObject *const_str_digest_7a2fd582acbf7f35fe70d039fc51ada5; | ||
| 42 | extern PyObject *const_str_plain_path; | ||
| 43 | static PyObject *const_str_plain_NUITKA_PACKAGE_report_io; | ||
| 44 | extern PyObject *const_tuple_c715d881e41895e419fdbff3ad722aae_tuple; | ||
| 45 | extern PyObject *const_str_plain_origin; | ||
| 46 | extern PyObject *const_str_digest_5bfaf90dbd407b4fc29090c8f6415242; | ||
| 47 | extern PyObject *const_str_plain___path__; | ||
| 48 | extern PyObject *const_tuple_empty; | ||
| 49 | extern PyObject *const_str_plain_get; | ||
| 50 | extern PyObject *const_str_plain_has_location; | ||
| 51 | static PyObject *const_str_digest_6301a26a46463d25cfcd6160fcccdae0; | ||
| 52 | extern PyObject *const_str_plain_join; | ||
| 53 | extern PyObject *const_str_plain_dirname; | ||
| 54 | extern PyObject *const_str_plain___doc__; | ||
| 55 | extern PyObject *const_str_plain___cached__; | ||
| 56 | static PyObject *module_filename_obj; | ||
| 57 | |||
| 58 | /* Indicator if this modules private constants were created yet. */ | ||
| 59 | static bool constants_created = false; | ||
| 60 | |||
| 61 | /* Function to create module private constants. */ | ||
| 62 | static void createModuleConstants( void ) | ||
| 63 | { | ||
| 64 | const_tuple_da2096dc58666fa1a6a04b58e47b1662_tuple = PyTuple_New( 2 ); | ||
| 65 | const_str_plain_NUITKA_PACKAGE_report_io = UNSTREAM_STRING_ASCII( &constant_bin[ 62669 ], 24, 1 ); | ||
| 66 | PyTuple_SET_ITEM( const_tuple_da2096dc58666fa1a6a04b58e47b1662_tuple, 0, const_str_plain_NUITKA_PACKAGE_report_io ); Py_INCREF( const_str_plain_NUITKA_PACKAGE_report_io ); | ||
| 67 | PyTuple_SET_ITEM( const_tuple_da2096dc58666fa1a6a04b58e47b1662_tuple, 1, const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); Py_INCREF( const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); | ||
| 68 | const_str_digest_7a2fd582acbf7f35fe70d039fc51ada5 = UNSTREAM_STRING_ASCII( &constant_bin[ 62693 ], 18, 0 ); | ||
| 69 | const_str_digest_6301a26a46463d25cfcd6160fcccdae0 = UNSTREAM_STRING_ASCII( &constant_bin[ 62711 ], 21, 0 ); | ||
| 70 | |||
| 71 | constants_created = true; | ||
| 72 | } | ||
| 73 | |||
| 74 | /* Function to verify module private constants for non-corruption. */ | ||
| 75 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 76 | void checkModuleConstants_report$io( void ) | ||
| 77 | { | ||
| 78 | // The module may not have been used at all, then ignore this. | ||
| 79 | if (constants_created == false) return; | ||
| 80 | |||
| 81 | |||
| 82 | } | ||
| 83 | #endif | ||
| 84 | |||
| 85 | // The module code objects. | ||
| 86 | static PyCodeObject *codeobj_ebecc230d2754c06fe68a6f5dfc0fb14; | ||
| 87 | |||
| 88 | static void createModuleCodeObjects(void) | ||
| 89 | { | ||
| 90 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_6301a26a46463d25cfcd6160fcccdae0 ); | ||
| 91 | codeobj_ebecc230d2754c06fe68a6f5dfc0fb14 = MAKE_CODEOBJ( module_filename_obj, const_str_digest_7a2fd582acbf7f35fe70d039fc51ada5, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 92 | } | ||
| 93 | |||
| 94 | // The module function declarations. | ||
| 95 | |||
| 96 | |||
| 97 | // The module function definitions. | ||
| 98 | |||
| 99 | |||
| 100 | |||
| 101 | #if PYTHON_VERSION >= 300 | ||
| 102 | static struct PyModuleDef mdef_report$io = | ||
| 103 | { | ||
| 104 | PyModuleDef_HEAD_INIT, | ||
| 105 | "report.io", | ||
| 106 | NULL, /* m_doc */ | ||
| 107 | -1, /* m_size */ | ||
| 108 | NULL, /* m_methods */ | ||
| 109 | NULL, /* m_reload */ | ||
| 110 | NULL, /* m_traverse */ | ||
| 111 | NULL, /* m_clear */ | ||
| 112 | NULL, /* m_free */ | ||
| 113 | }; | ||
| 114 | #endif | ||
| 115 | |||
| 116 | extern PyObject *const_str_plain___compiled__; | ||
| 117 | |||
| 118 | extern PyObject *const_str_plain___package__; | ||
| 119 | |||
| 120 | #if PYTHON_VERSION >= 300 | ||
| 121 | extern PyObject *const_str_dot; | ||
| 122 | extern PyObject *const_str_plain___loader__; | ||
| 123 | #endif | ||
| 124 | |||
| 125 | #if PYTHON_VERSION >= 340 | ||
| 126 | extern PyObject *const_str_plain___spec__; | ||
| 127 | extern PyObject *const_str_plain__initializing; | ||
| 128 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 129 | #endif | ||
| 130 | |||
| 131 | extern void _initCompiledCellType(); | ||
| 132 | extern void _initCompiledGeneratorType(); | ||
| 133 | extern void _initCompiledFunctionType(); | ||
| 134 | extern void _initCompiledMethodType(); | ||
| 135 | extern void _initCompiledFrameType(); | ||
| 136 | #if PYTHON_VERSION >= 350 | ||
| 137 | extern void _initCompiledCoroutineTypes(); | ||
| 138 | #endif | ||
| 139 | #if PYTHON_VERSION >= 360 | ||
| 140 | extern void _initCompiledAsyncgenTypes(); | ||
| 141 | #endif | ||
| 142 | |||
| 143 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 144 | |||
| 145 | // The exported interface to CPython. On import of the module, this function | ||
| 146 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 147 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 148 | |||
| 149 | MOD_INIT_DECL( report$io ) | ||
| 150 | { | ||
| 151 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 152 | static bool _init_done = false; | ||
| 153 | |||
| 154 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 155 | if ( _init_done ) | ||
| 156 | { | ||
| 157 | return MOD_RETURN_VALUE( module_report$io ); | ||
| 158 | } | ||
| 159 | else | ||
| 160 | { | ||
| 161 | _init_done = true; | ||
| 162 | } | ||
| 163 | #endif | ||
| 164 | |||
| 165 | #ifdef _NUITKA_MODULE | ||
| 166 | // In case of a stand alone extension module, need to call initialization | ||
| 167 | // the init here because that's the first and only time we are going to get | ||
| 168 | // called here. | ||
| 169 | |||
| 170 | // Initialize the constant values used. | ||
| 171 | _initBuiltinModule(); | ||
| 172 | createGlobalConstants(); | ||
| 173 | |||
| 174 | /* Initialize the compiled types of Nuitka. */ | ||
| 175 | _initCompiledCellType(); | ||
| 176 | _initCompiledGeneratorType(); | ||
| 177 | _initCompiledFunctionType(); | ||
| 178 | _initCompiledMethodType(); | ||
| 179 | _initCompiledFrameType(); | ||
| 180 | #if PYTHON_VERSION >= 350 | ||
| 181 | _initCompiledCoroutineTypes(); | ||
| 182 | #endif | ||
| 183 | #if PYTHON_VERSION >= 360 | ||
| 184 | _initCompiledAsyncgenTypes(); | ||
| 185 | #endif | ||
| 186 | |||
| 187 | #if PYTHON_VERSION < 300 | ||
| 188 | _initSlotCompare(); | ||
| 189 | #endif | ||
| 190 | #if PYTHON_VERSION >= 270 | ||
| 191 | _initSlotIternext(); | ||
| 192 | #endif | ||
| 193 | |||
| 194 | patchBuiltinModule(); | ||
| 195 | patchTypeComparison(); | ||
| 196 | |||
| 197 | // Enable meta path based loader if not already done. | ||
| 198 | #ifdef _NUITKA_TRACE | ||
| 199 | puts("report.io: Calling setupMetaPathBasedLoader()."); | ||
| 200 | #endif | ||
| 201 | setupMetaPathBasedLoader(); | ||
| 202 | |||
| 203 | #if PYTHON_VERSION >= 300 | ||
| 204 | patchInspectModule(); | ||
| 205 | #endif | ||
| 206 | |||
| 207 | #endif | ||
| 208 | |||
| 209 | /* The constants only used by this module are created now. */ | ||
| 210 | #ifdef _NUITKA_TRACE | ||
| 211 | puts("report.io: Calling createModuleConstants()."); | ||
| 212 | #endif | ||
| 213 | createModuleConstants(); | ||
| 214 | |||
| 215 | /* The code objects used by this module are created now. */ | ||
| 216 | #ifdef _NUITKA_TRACE | ||
| 217 | puts("report.io: Calling createModuleCodeObjects()."); | ||
| 218 | #endif | ||
| 219 | createModuleCodeObjects(); | ||
| 220 | |||
| 221 | // puts( "in initreport$io" ); | ||
| 222 | |||
| 223 | // Create the module object first. There are no methods initially, all are | ||
| 224 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 225 | // set at this time, as it could not contain NUL characters this way, they | ||
| 226 | // are instead set in early module code. No "self" for modules, we have no | ||
| 227 | // use for it. | ||
| 228 | #if PYTHON_VERSION < 300 | ||
| 229 | module_report$io = Py_InitModule4( | ||
| 230 | "report.io", // Module Name | ||
| 231 | NULL, // No methods initially, all are added | ||
| 232 | // dynamically in actual module code only. | ||
| 233 | NULL, // No "__doc__" is initially set, as it could | ||
| 234 | // not contain NUL this way, added early in | ||
| 235 | // actual code. | ||
| 236 | NULL, // No self for modules, we don't use it. | ||
| 237 | PYTHON_API_VERSION | ||
| 238 | ); | ||
| 239 | #else | ||
| 240 | |||
| 241 | module_report$io = PyModule_Create( &mdef_report$io ); | ||
| 242 | #endif | ||
| 243 | |||
| 244 | moduledict_report$io = MODULE_DICT( module_report$io ); | ||
| 245 | |||
| 246 | // Set __compiled__ to what it we know. | ||
| 247 | UPDATE_STRING_DICT1( | ||
| 248 | moduledict_report$io, | ||
| 249 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 250 | Nuitka_dunder_compiled_value | ||
| 251 | ); | ||
| 252 | |||
| 253 | // Update "__package__" value to what it ought to be. | ||
| 254 | { | ||
| 255 | #if 1 | ||
| 256 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 257 | |||
| 258 | UPDATE_STRING_DICT1( | ||
| 259 | moduledict_report$io, | ||
| 260 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 261 | module_name | ||
| 262 | ); | ||
| 263 | #else | ||
| 264 | |||
| 265 | #if PYTHON_VERSION < 300 | ||
| 266 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 267 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 268 | |||
| 269 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 270 | |||
| 271 | if ( last_dot != NULL ) | ||
| 272 | { | ||
| 273 | UPDATE_STRING_DICT1( | ||
| 274 | moduledict_report$io, | ||
| 275 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 276 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 277 | ); | ||
| 278 | } | ||
| 279 | #else | ||
| 280 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 281 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 282 | |||
| 283 | if ( dot_index != -1 ) | ||
| 284 | { | ||
| 285 | UPDATE_STRING_DICT1( | ||
| 286 | moduledict_report$io, | ||
| 287 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 288 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 289 | ); | ||
| 290 | } | ||
| 291 | #endif | ||
| 292 | #endif | ||
| 293 | } | ||
| 294 | |||
| 295 | CHECK_OBJECT( module_report$io ); | ||
| 296 | |||
| 297 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 298 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 299 | #if PYTHON_VERSION >= 300 | ||
| 300 | { | ||
| 301 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_digest_6f576c460435f45aaedb10ae95808089, module_report$io ); | ||
| 302 | |||
| 303 | assert( r != -1 ); | ||
| 304 | } | ||
| 305 | #endif | ||
| 306 | |||
| 307 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 308 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 309 | // before the frame object is allocated, or else it may fail. | ||
| 310 | |||
| 311 | if ( GET_STRING_DICT_VALUE( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 312 | { | ||
| 313 | PyObject *value = (PyObject *)builtin_module; | ||
| 314 | |||
| 315 | // Check if main module, not a dict then but the module itself. | ||
| 316 | #if !defined(_NUITKA_EXE) || !0 | ||
| 317 | value = PyModule_GetDict( value ); | ||
| 318 | #endif | ||
| 319 | |||
| 320 | UPDATE_STRING_DICT0( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 321 | } | ||
| 322 | |||
| 323 | #if PYTHON_VERSION >= 300 | ||
| 324 | UPDATE_STRING_DICT0( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 325 | #endif | ||
| 326 | |||
| 327 | #if PYTHON_VERSION >= 340 | ||
| 328 | // Set the "__spec__" value | ||
| 329 | |||
| 330 | #if 0 | ||
| 331 | // Main modules just get "None" as spec. | ||
| 332 | UPDATE_STRING_DICT0( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 333 | #else | ||
| 334 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 335 | { | ||
| 336 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 337 | CHECK_OBJECT( bootstrap_module ); | ||
| 338 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 339 | Py_DECREF( bootstrap_module ); | ||
| 340 | |||
| 341 | PyObject *args[] = { | ||
| 342 | GET_STRING_DICT_VALUE( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 343 | (PyObject *)&Nuitka_Loader_Type | ||
| 344 | }; | ||
| 345 | |||
| 346 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 347 | module_spec_class, | ||
| 348 | args | ||
| 349 | ); | ||
| 350 | Py_DECREF( module_spec_class ); | ||
| 351 | |||
| 352 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 353 | CHECK_OBJECT( spec_value ); | ||
| 354 | |||
| 355 | // For packages set the submodule search locations as well, even if to empty | ||
| 356 | // list, so investigating code will consider it a package. | ||
| 357 | #if 1 | ||
| 358 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 359 | #endif | ||
| 360 | |||
| 361 | // Mark the execution in the "__spec__" value. | ||
| 362 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 363 | |||
| 364 | UPDATE_STRING_DICT1( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 365 | } | ||
| 366 | #endif | ||
| 367 | #endif | ||
| 368 | |||
| 369 | // Temp variables if any | ||
| 370 | struct Nuitka_FrameObject *frame_ebecc230d2754c06fe68a6f5dfc0fb14; | ||
| 371 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 372 | PyObject *exception_type = NULL; | ||
| 373 | PyObject *exception_value = NULL; | ||
| 374 | PyTracebackObject *exception_tb = NULL; | ||
| 375 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 376 | bool tmp_result; | ||
| 377 | |||
| 378 | // Module code. | ||
| 379 | { | ||
| 380 | PyObject *tmp_assign_source_1; | ||
| 381 | tmp_assign_source_1 = Py_None; | ||
| 382 | UPDATE_STRING_DICT0( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 383 | } | ||
| 384 | { | ||
| 385 | PyObject *tmp_assign_source_2; | ||
| 386 | tmp_assign_source_2 = module_filename_obj; | ||
| 387 | UPDATE_STRING_DICT0( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 388 | } | ||
| 389 | // Frame without reuse. | ||
| 390 | frame_ebecc230d2754c06fe68a6f5dfc0fb14 = MAKE_MODULE_FRAME( codeobj_ebecc230d2754c06fe68a6f5dfc0fb14, module_report$io ); | ||
| 391 | |||
| 392 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 393 | // owning it. | ||
| 394 | pushFrameStack( frame_ebecc230d2754c06fe68a6f5dfc0fb14 ); | ||
| 395 | assert( Py_REFCNT( frame_ebecc230d2754c06fe68a6f5dfc0fb14 ) == 2 ); | ||
| 396 | |||
| 397 | // Framed code: | ||
| 398 | { | ||
| 399 | PyObject *tmp_assign_source_3; | ||
| 400 | PyObject *tmp_list_element_1; | ||
| 401 | PyObject *tmp_called_name_1; | ||
| 402 | PyObject *tmp_source_name_1; | ||
| 403 | PyObject *tmp_args_element_name_1; | ||
| 404 | PyObject *tmp_called_name_2; | ||
| 405 | PyObject *tmp_source_name_2; | ||
| 406 | PyObject *tmp_args_element_name_2; | ||
| 407 | PyObject *tmp_called_instance_1; | ||
| 408 | PyObject *tmp_args_element_name_3; | ||
| 409 | PyObject *tmp_called_instance_2; | ||
| 410 | frame_ebecc230d2754c06fe68a6f5dfc0fb14->m_frame.f_lineno = 1; | ||
| 411 | { | ||
| 412 | PyObject *module = PyImport_ImportModule("os"); | ||
| 413 | if (likely( module != NULL )) | ||
| 414 | { | ||
| 415 | tmp_source_name_1 = PyObject_GetAttr( module, const_str_plain_path ); | ||
| 416 | } | ||
| 417 | else | ||
| 418 | { | ||
| 419 | tmp_source_name_1 = NULL; | ||
| 420 | } | ||
| 421 | } | ||
| 422 | |||
| 423 | if ( tmp_source_name_1 == NULL ) | ||
| 424 | { | ||
| 425 | assert( ERROR_OCCURRED() ); | ||
| 426 | |||
| 427 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 428 | |||
| 429 | |||
| 430 | exception_lineno = 1; | ||
| 431 | |||
| 432 | goto frame_exception_exit_1; | ||
| 433 | } | ||
| 434 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_dirname ); | ||
| 435 | if ( tmp_called_name_1 == NULL ) | ||
| 436 | { | ||
| 437 | assert( ERROR_OCCURRED() ); | ||
| 438 | |||
| 439 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 440 | |||
| 441 | |||
| 442 | exception_lineno = 1; | ||
| 443 | |||
| 444 | goto frame_exception_exit_1; | ||
| 445 | } | ||
| 446 | tmp_args_element_name_1 = module_filename_obj; | ||
| 447 | frame_ebecc230d2754c06fe68a6f5dfc0fb14->m_frame.f_lineno = 1; | ||
| 448 | { | ||
| 449 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 450 | tmp_list_element_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, call_args ); | ||
| 451 | } | ||
| 452 | |||
| 453 | Py_DECREF( tmp_called_name_1 ); | ||
| 454 | if ( tmp_list_element_1 == NULL ) | ||
| 455 | { | ||
| 456 | assert( ERROR_OCCURRED() ); | ||
| 457 | |||
| 458 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 459 | |||
| 460 | |||
| 461 | exception_lineno = 1; | ||
| 462 | |||
| 463 | goto frame_exception_exit_1; | ||
| 464 | } | ||
| 465 | tmp_assign_source_3 = PyList_New( 3 ); | ||
| 466 | PyList_SET_ITEM( tmp_assign_source_3, 0, tmp_list_element_1 ); | ||
| 467 | frame_ebecc230d2754c06fe68a6f5dfc0fb14->m_frame.f_lineno = 1; | ||
| 468 | { | ||
| 469 | PyObject *module = PyImport_ImportModule("os"); | ||
| 470 | if (likely( module != NULL )) | ||
| 471 | { | ||
| 472 | tmp_source_name_2 = PyObject_GetAttr( module, const_str_plain_path ); | ||
| 473 | } | ||
| 474 | else | ||
| 475 | { | ||
| 476 | tmp_source_name_2 = NULL; | ||
| 477 | } | ||
| 478 | } | ||
| 479 | |||
| 480 | if ( tmp_source_name_2 == NULL ) | ||
| 481 | { | ||
| 482 | assert( ERROR_OCCURRED() ); | ||
| 483 | |||
| 484 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 485 | Py_DECREF( tmp_assign_source_3 ); | ||
| 486 | |||
| 487 | exception_lineno = 1; | ||
| 488 | |||
| 489 | goto frame_exception_exit_1; | ||
| 490 | } | ||
| 491 | tmp_called_name_2 = LOOKUP_ATTRIBUTE( tmp_source_name_2, const_str_plain_join ); | ||
| 492 | if ( tmp_called_name_2 == NULL ) | ||
| 493 | { | ||
| 494 | assert( ERROR_OCCURRED() ); | ||
| 495 | |||
| 496 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 497 | Py_DECREF( tmp_assign_source_3 ); | ||
| 498 | |||
| 499 | exception_lineno = 1; | ||
| 500 | |||
| 501 | goto frame_exception_exit_1; | ||
| 502 | } | ||
| 503 | frame_ebecc230d2754c06fe68a6f5dfc0fb14->m_frame.f_lineno = 1; | ||
| 504 | { | ||
| 505 | PyObject *module = PyImport_ImportModule("os"); | ||
| 506 | if (likely( module != NULL )) | ||
| 507 | { | ||
| 508 | tmp_called_instance_1 = PyObject_GetAttr( module, const_str_plain_environ ); | ||
| 509 | } | ||
| 510 | else | ||
| 511 | { | ||
| 512 | tmp_called_instance_1 = NULL; | ||
| 513 | } | ||
| 514 | } | ||
| 515 | |||
| 516 | if ( tmp_called_instance_1 == NULL ) | ||
| 517 | { | ||
| 518 | assert( ERROR_OCCURRED() ); | ||
| 519 | |||
| 520 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 521 | Py_DECREF( tmp_assign_source_3 ); | ||
| 522 | Py_DECREF( tmp_called_name_2 ); | ||
| 523 | |||
| 524 | exception_lineno = 1; | ||
| 525 | |||
| 526 | goto frame_exception_exit_1; | ||
| 527 | } | ||
| 528 | frame_ebecc230d2754c06fe68a6f5dfc0fb14->m_frame.f_lineno = 1; | ||
| 529 | tmp_args_element_name_2 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_1, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_c715d881e41895e419fdbff3ad722aae_tuple, 0 ) ); | ||
| 530 | |||
| 531 | if ( tmp_args_element_name_2 == NULL ) | ||
| 532 | { | ||
| 533 | assert( ERROR_OCCURRED() ); | ||
| 534 | |||
| 535 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 536 | Py_DECREF( tmp_assign_source_3 ); | ||
| 537 | Py_DECREF( tmp_called_name_2 ); | ||
| 538 | |||
| 539 | exception_lineno = 1; | ||
| 540 | |||
| 541 | goto frame_exception_exit_1; | ||
| 542 | } | ||
| 543 | tmp_args_element_name_3 = const_str_plain_io; | ||
| 544 | frame_ebecc230d2754c06fe68a6f5dfc0fb14->m_frame.f_lineno = 1; | ||
| 545 | { | ||
| 546 | PyObject *call_args[] = { tmp_args_element_name_2, tmp_args_element_name_3 }; | ||
| 547 | tmp_list_element_1 = CALL_FUNCTION_WITH_ARGS2( tmp_called_name_2, call_args ); | ||
| 548 | } | ||
| 549 | |||
| 550 | Py_DECREF( tmp_called_name_2 ); | ||
| 551 | Py_DECREF( tmp_args_element_name_2 ); | ||
| 552 | if ( tmp_list_element_1 == NULL ) | ||
| 553 | { | ||
| 554 | assert( ERROR_OCCURRED() ); | ||
| 555 | |||
| 556 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 557 | Py_DECREF( tmp_assign_source_3 ); | ||
| 558 | |||
| 559 | exception_lineno = 1; | ||
| 560 | |||
| 561 | goto frame_exception_exit_1; | ||
| 562 | } | ||
| 563 | PyList_SET_ITEM( tmp_assign_source_3, 1, tmp_list_element_1 ); | ||
| 564 | frame_ebecc230d2754c06fe68a6f5dfc0fb14->m_frame.f_lineno = 1; | ||
| 565 | { | ||
| 566 | PyObject *module = PyImport_ImportModule("os"); | ||
| 567 | if (likely( module != NULL )) | ||
| 568 | { | ||
| 569 | tmp_called_instance_2 = PyObject_GetAttr( module, const_str_plain_environ ); | ||
| 570 | } | ||
| 571 | else | ||
| 572 | { | ||
| 573 | tmp_called_instance_2 = NULL; | ||
| 574 | } | ||
| 575 | } | ||
| 576 | |||
| 577 | if ( tmp_called_instance_2 == NULL ) | ||
| 578 | { | ||
| 579 | assert( ERROR_OCCURRED() ); | ||
| 580 | |||
| 581 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 582 | Py_DECREF( tmp_assign_source_3 ); | ||
| 583 | |||
| 584 | exception_lineno = 1; | ||
| 585 | |||
| 586 | goto frame_exception_exit_1; | ||
| 587 | } | ||
| 588 | frame_ebecc230d2754c06fe68a6f5dfc0fb14->m_frame.f_lineno = 1; | ||
| 589 | tmp_list_element_1 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_2, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_da2096dc58666fa1a6a04b58e47b1662_tuple, 0 ) ); | ||
| 590 | |||
| 591 | if ( tmp_list_element_1 == NULL ) | ||
| 592 | { | ||
| 593 | assert( ERROR_OCCURRED() ); | ||
| 594 | |||
| 595 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 596 | Py_DECREF( tmp_assign_source_3 ); | ||
| 597 | |||
| 598 | exception_lineno = 1; | ||
| 599 | |||
| 600 | goto frame_exception_exit_1; | ||
| 601 | } | ||
| 602 | PyList_SET_ITEM( tmp_assign_source_3, 2, tmp_list_element_1 ); | ||
| 603 | UPDATE_STRING_DICT1( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); | ||
| 604 | } | ||
| 605 | { | ||
| 606 | PyObject *tmp_assattr_name_1; | ||
| 607 | PyObject *tmp_assattr_target_1; | ||
| 608 | PyObject *tmp_mvar_value_1; | ||
| 609 | tmp_assattr_name_1 = module_filename_obj; | ||
| 610 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 611 | |||
| 612 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 613 | { | ||
| 614 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 615 | } | ||
| 616 | |||
| 617 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 618 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 619 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 620 | if ( tmp_result == false ) | ||
| 621 | { | ||
| 622 | assert( ERROR_OCCURRED() ); | ||
| 623 | |||
| 624 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 625 | |||
| 626 | |||
| 627 | exception_lineno = 1; | ||
| 628 | |||
| 629 | goto frame_exception_exit_1; | ||
| 630 | } | ||
| 631 | } | ||
| 632 | { | ||
| 633 | PyObject *tmp_assattr_name_2; | ||
| 634 | PyObject *tmp_assattr_target_2; | ||
| 635 | PyObject *tmp_mvar_value_2; | ||
| 636 | tmp_assattr_name_2 = Py_True; | ||
| 637 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 638 | |||
| 639 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 640 | { | ||
| 641 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 642 | } | ||
| 643 | |||
| 644 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 645 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 646 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 647 | if ( tmp_result == false ) | ||
| 648 | { | ||
| 649 | assert( ERROR_OCCURRED() ); | ||
| 650 | |||
| 651 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 652 | |||
| 653 | |||
| 654 | exception_lineno = 1; | ||
| 655 | |||
| 656 | goto frame_exception_exit_1; | ||
| 657 | } | ||
| 658 | } | ||
| 659 | |||
| 660 | // Restore frame exception if necessary. | ||
| 661 | #if 0 | ||
| 662 | RESTORE_FRAME_EXCEPTION( frame_ebecc230d2754c06fe68a6f5dfc0fb14 ); | ||
| 663 | #endif | ||
| 664 | popFrameStack(); | ||
| 665 | |||
| 666 | assertFrameObject( frame_ebecc230d2754c06fe68a6f5dfc0fb14 ); | ||
| 667 | |||
| 668 | goto frame_no_exception_1; | ||
| 669 | |||
| 670 | frame_exception_exit_1:; | ||
| 671 | #if 0 | ||
| 672 | RESTORE_FRAME_EXCEPTION( frame_ebecc230d2754c06fe68a6f5dfc0fb14 ); | ||
| 673 | #endif | ||
| 674 | |||
| 675 | if ( exception_tb == NULL ) | ||
| 676 | { | ||
| 677 | exception_tb = MAKE_TRACEBACK( frame_ebecc230d2754c06fe68a6f5dfc0fb14, exception_lineno ); | ||
| 678 | } | ||
| 679 | else if ( exception_tb->tb_frame != &frame_ebecc230d2754c06fe68a6f5dfc0fb14->m_frame ) | ||
| 680 | { | ||
| 681 | exception_tb = ADD_TRACEBACK( exception_tb, frame_ebecc230d2754c06fe68a6f5dfc0fb14, exception_lineno ); | ||
| 682 | } | ||
| 683 | |||
| 684 | // Put the previous frame back on top. | ||
| 685 | popFrameStack(); | ||
| 686 | |||
| 687 | // Return the error. | ||
| 688 | goto module_exception_exit; | ||
| 689 | |||
| 690 | frame_no_exception_1:; | ||
| 691 | { | ||
| 692 | PyObject *tmp_assign_source_4; | ||
| 693 | tmp_assign_source_4 = Py_None; | ||
| 694 | UPDATE_STRING_DICT0( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_4 ); | ||
| 695 | } | ||
| 696 | |||
| 697 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 698 | #if 1 && 0 | ||
| 699 | { | ||
| 700 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_report$io, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 701 | |||
| 702 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 703 | { | ||
| 704 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 705 | |||
| 706 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 707 | CHECK_OBJECT( path_importer_cache ); | ||
| 708 | |||
| 709 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 710 | assert( res == 0 ); | ||
| 711 | } | ||
| 712 | } | ||
| 713 | #endif | ||
| 714 | #endif | ||
| 715 | |||
| 716 | return MOD_RETURN_VALUE( module_report$io ); | ||
| 717 | module_exception_exit: | ||
| 718 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 719 | return MOD_RETURN_VALUE( NULL ); | ||
| 720 | } | ||
| File Linux_Version/inventory_synchronisation.build/module.report.io.o deleted (index bb49a86..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.report.o deleted (index 6b621ad..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.systemd.c deleted (index 1ae72ba..0000000) | |||
| 1 | /* Generated code for Python module 'systemd' | ||
| 2 | * created by Nuitka version 0.6.3 | ||
| 3 | * | ||
| 4 | * This code is in part copyright 2019 Kay Hayen. | ||
| 5 | * | ||
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
| 7 | * you may not use this file except in compliance with the License. | ||
| 8 | * You may obtain a copy of the License at | ||
| 9 | * | ||
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
| 11 | * | ||
| 12 | * Unless required by applicable law or agreed to in writing, software | ||
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
| 15 | * See the License for the specific language governing permissions and | ||
| 16 | * limitations under the License. | ||
| 17 | */ | ||
| 18 | |||
| 19 | #include "nuitka/prelude.h" | ||
| 20 | |||
| 21 | #include "__helpers.h" | ||
| 22 | |||
| 23 | /* The "_module_systemd" is a Python object pointer of module type. | ||
| 24 | * | ||
| 25 | * Note: For full compatibility with CPython, every module variable access | ||
| 26 | * needs to go through it except for cases where the module cannot possibly | ||
| 27 | * have changed in the mean time. | ||
| 28 | */ | ||
| 29 | |||
| 30 | PyObject *module_systemd; | ||
| 31 | PyDictObject *moduledict_systemd; | ||
| 32 | |||
| 33 | /* The declarations of module constants used, if any. */ | ||
| 34 | extern PyObject *const_str_plain___file__; | ||
| 35 | extern PyObject *const_str_plain_environ; | ||
| 36 | extern PyObject *const_str_plain_get; | ||
| 37 | extern PyObject *const_str_plain_origin; | ||
| 38 | static PyObject *const_str_plain_NUITKA_PACKAGE_systemd; | ||
| 39 | extern PyObject *const_str_plain___spec__; | ||
| 40 | extern PyObject *const_str_plain_path; | ||
| 41 | static PyObject *const_tuple_e13953b47470e88067c8bce77c755d8d_tuple; | ||
| 42 | extern PyObject *const_str_plain_dirname; | ||
| 43 | extern PyObject *const_str_plain_systemd; | ||
| 44 | static PyObject *const_str_digest_f33c8917621acefd403301dcb303af69; | ||
| 45 | static PyObject *const_str_digest_a512e549da921b70c0fe01cb896f27f2; | ||
| 46 | extern PyObject *const_str_digest_5bfaf90dbd407b4fc29090c8f6415242; | ||
| 47 | extern PyObject *const_str_plain___path__; | ||
| 48 | extern PyObject *const_tuple_empty; | ||
| 49 | extern PyObject *const_str_plain___doc__; | ||
| 50 | extern PyObject *const_str_plain___cached__; | ||
| 51 | extern PyObject *const_str_plain_has_location; | ||
| 52 | static PyObject *module_filename_obj; | ||
| 53 | |||
| 54 | /* Indicator if this modules private constants were created yet. */ | ||
| 55 | static bool constants_created = false; | ||
| 56 | |||
| 57 | /* Function to create module private constants. */ | ||
| 58 | static void createModuleConstants( void ) | ||
| 59 | { | ||
| 60 | const_str_plain_NUITKA_PACKAGE_systemd = UNSTREAM_STRING_ASCII( &constant_bin[ 62919 ], 22, 1 ); | ||
| 61 | const_tuple_e13953b47470e88067c8bce77c755d8d_tuple = PyTuple_New( 2 ); | ||
| 62 | PyTuple_SET_ITEM( const_tuple_e13953b47470e88067c8bce77c755d8d_tuple, 0, const_str_plain_NUITKA_PACKAGE_systemd ); Py_INCREF( const_str_plain_NUITKA_PACKAGE_systemd ); | ||
| 63 | PyTuple_SET_ITEM( const_tuple_e13953b47470e88067c8bce77c755d8d_tuple, 1, const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); Py_INCREF( const_str_digest_5bfaf90dbd407b4fc29090c8f6415242 ); | ||
| 64 | const_str_digest_f33c8917621acefd403301dcb303af69 = UNSTREAM_STRING_ASCII( &constant_bin[ 62941 ], 19, 0 ); | ||
| 65 | const_str_digest_a512e549da921b70c0fe01cb896f27f2 = UNSTREAM_STRING_ASCII( &constant_bin[ 62960 ], 16, 0 ); | ||
| 66 | |||
| 67 | constants_created = true; | ||
| 68 | } | ||
| 69 | |||
| 70 | /* Function to verify module private constants for non-corruption. */ | ||
| 71 | #ifndef __NUITKA_NO_ASSERT__ | ||
| 72 | void checkModuleConstants_systemd( void ) | ||
| 73 | { | ||
| 74 | // The module may not have been used at all, then ignore this. | ||
| 75 | if (constants_created == false) return; | ||
| 76 | |||
| 77 | |||
| 78 | } | ||
| 79 | #endif | ||
| 80 | |||
| 81 | // The module code objects. | ||
| 82 | static PyCodeObject *codeobj_a0dcda2462cfba7e16808270b4c9780e; | ||
| 83 | |||
| 84 | static void createModuleCodeObjects(void) | ||
| 85 | { | ||
| 86 | module_filename_obj = MAKE_RELATIVE_PATH( const_str_digest_f33c8917621acefd403301dcb303af69 ); | ||
| 87 | codeobj_a0dcda2462cfba7e16808270b4c9780e = MAKE_CODEOBJ( module_filename_obj, const_str_digest_a512e549da921b70c0fe01cb896f27f2, 1, const_tuple_empty, 0, 0, CO_NOFREE ); | ||
| 88 | } | ||
| 89 | |||
| 90 | // The module function declarations. | ||
| 91 | |||
| 92 | |||
| 93 | // The module function definitions. | ||
| 94 | |||
| 95 | |||
| 96 | |||
| 97 | #if PYTHON_VERSION >= 300 | ||
| 98 | static struct PyModuleDef mdef_systemd = | ||
| 99 | { | ||
| 100 | PyModuleDef_HEAD_INIT, | ||
| 101 | "systemd", | ||
| 102 | NULL, /* m_doc */ | ||
| 103 | -1, /* m_size */ | ||
| 104 | NULL, /* m_methods */ | ||
| 105 | NULL, /* m_reload */ | ||
| 106 | NULL, /* m_traverse */ | ||
| 107 | NULL, /* m_clear */ | ||
| 108 | NULL, /* m_free */ | ||
| 109 | }; | ||
| 110 | #endif | ||
| 111 | |||
| 112 | extern PyObject *const_str_plain___compiled__; | ||
| 113 | |||
| 114 | extern PyObject *const_str_plain___package__; | ||
| 115 | |||
| 116 | #if PYTHON_VERSION >= 300 | ||
| 117 | extern PyObject *const_str_dot; | ||
| 118 | extern PyObject *const_str_plain___loader__; | ||
| 119 | #endif | ||
| 120 | |||
| 121 | #if PYTHON_VERSION >= 340 | ||
| 122 | extern PyObject *const_str_plain___spec__; | ||
| 123 | extern PyObject *const_str_plain__initializing; | ||
| 124 | extern PyObject *const_str_plain_submodule_search_locations; | ||
| 125 | #endif | ||
| 126 | |||
| 127 | extern void _initCompiledCellType(); | ||
| 128 | extern void _initCompiledGeneratorType(); | ||
| 129 | extern void _initCompiledFunctionType(); | ||
| 130 | extern void _initCompiledMethodType(); | ||
| 131 | extern void _initCompiledFrameType(); | ||
| 132 | #if PYTHON_VERSION >= 350 | ||
| 133 | extern void _initCompiledCoroutineTypes(); | ||
| 134 | #endif | ||
| 135 | #if PYTHON_VERSION >= 360 | ||
| 136 | extern void _initCompiledAsyncgenTypes(); | ||
| 137 | #endif | ||
| 138 | |||
| 139 | extern PyTypeObject Nuitka_Loader_Type; | ||
| 140 | |||
| 141 | // The exported interface to CPython. On import of the module, this function | ||
| 142 | // gets called. It has to have an exact function name, in cases it's a shared | ||
| 143 | // library export. This is hidden behind the MOD_INIT_DECL. | ||
| 144 | |||
| 145 | MOD_INIT_DECL( systemd ) | ||
| 146 | { | ||
| 147 | #if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300 | ||
| 148 | static bool _init_done = false; | ||
| 149 | |||
| 150 | // Modules might be imported repeatedly, which is to be ignored. | ||
| 151 | if ( _init_done ) | ||
| 152 | { | ||
| 153 | return MOD_RETURN_VALUE( module_systemd ); | ||
| 154 | } | ||
| 155 | else | ||
| 156 | { | ||
| 157 | _init_done = true; | ||
| 158 | } | ||
| 159 | #endif | ||
| 160 | |||
| 161 | #ifdef _NUITKA_MODULE | ||
| 162 | // In case of a stand alone extension module, need to call initialization | ||
| 163 | // the init here because that's the first and only time we are going to get | ||
| 164 | // called here. | ||
| 165 | |||
| 166 | // Initialize the constant values used. | ||
| 167 | _initBuiltinModule(); | ||
| 168 | createGlobalConstants(); | ||
| 169 | |||
| 170 | /* Initialize the compiled types of Nuitka. */ | ||
| 171 | _initCompiledCellType(); | ||
| 172 | _initCompiledGeneratorType(); | ||
| 173 | _initCompiledFunctionType(); | ||
| 174 | _initCompiledMethodType(); | ||
| 175 | _initCompiledFrameType(); | ||
| 176 | #if PYTHON_VERSION >= 350 | ||
| 177 | _initCompiledCoroutineTypes(); | ||
| 178 | #endif | ||
| 179 | #if PYTHON_VERSION >= 360 | ||
| 180 | _initCompiledAsyncgenTypes(); | ||
| 181 | #endif | ||
| 182 | |||
| 183 | #if PYTHON_VERSION < 300 | ||
| 184 | _initSlotCompare(); | ||
| 185 | #endif | ||
| 186 | #if PYTHON_VERSION >= 270 | ||
| 187 | _initSlotIternext(); | ||
| 188 | #endif | ||
| 189 | |||
| 190 | patchBuiltinModule(); | ||
| 191 | patchTypeComparison(); | ||
| 192 | |||
| 193 | // Enable meta path based loader if not already done. | ||
| 194 | #ifdef _NUITKA_TRACE | ||
| 195 | puts("systemd: Calling setupMetaPathBasedLoader()."); | ||
| 196 | #endif | ||
| 197 | setupMetaPathBasedLoader(); | ||
| 198 | |||
| 199 | #if PYTHON_VERSION >= 300 | ||
| 200 | patchInspectModule(); | ||
| 201 | #endif | ||
| 202 | |||
| 203 | #endif | ||
| 204 | |||
| 205 | /* The constants only used by this module are created now. */ | ||
| 206 | #ifdef _NUITKA_TRACE | ||
| 207 | puts("systemd: Calling createModuleConstants()."); | ||
| 208 | #endif | ||
| 209 | createModuleConstants(); | ||
| 210 | |||
| 211 | /* The code objects used by this module are created now. */ | ||
| 212 | #ifdef _NUITKA_TRACE | ||
| 213 | puts("systemd: Calling createModuleCodeObjects()."); | ||
| 214 | #endif | ||
| 215 | createModuleCodeObjects(); | ||
| 216 | |||
| 217 | // puts( "in initsystemd" ); | ||
| 218 | |||
| 219 | // Create the module object first. There are no methods initially, all are | ||
| 220 | // added dynamically in actual code only. Also no "__doc__" is initially | ||
| 221 | // set at this time, as it could not contain NUL characters this way, they | ||
| 222 | // are instead set in early module code. No "self" for modules, we have no | ||
| 223 | // use for it. | ||
| 224 | #if PYTHON_VERSION < 300 | ||
| 225 | module_systemd = Py_InitModule4( | ||
| 226 | "systemd", // Module Name | ||
| 227 | NULL, // No methods initially, all are added | ||
| 228 | // dynamically in actual module code only. | ||
| 229 | NULL, // No "__doc__" is initially set, as it could | ||
| 230 | // not contain NUL this way, added early in | ||
| 231 | // actual code. | ||
| 232 | NULL, // No self for modules, we don't use it. | ||
| 233 | PYTHON_API_VERSION | ||
| 234 | ); | ||
| 235 | #else | ||
| 236 | |||
| 237 | module_systemd = PyModule_Create( &mdef_systemd ); | ||
| 238 | #endif | ||
| 239 | |||
| 240 | moduledict_systemd = MODULE_DICT( module_systemd ); | ||
| 241 | |||
| 242 | // Set __compiled__ to what it we know. | ||
| 243 | UPDATE_STRING_DICT1( | ||
| 244 | moduledict_systemd, | ||
| 245 | (Nuitka_StringObject *)const_str_plain___compiled__, | ||
| 246 | Nuitka_dunder_compiled_value | ||
| 247 | ); | ||
| 248 | |||
| 249 | // Update "__package__" value to what it ought to be. | ||
| 250 | { | ||
| 251 | #if 1 | ||
| 252 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 253 | |||
| 254 | UPDATE_STRING_DICT1( | ||
| 255 | moduledict_systemd, | ||
| 256 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 257 | module_name | ||
| 258 | ); | ||
| 259 | #else | ||
| 260 | |||
| 261 | #if PYTHON_VERSION < 300 | ||
| 262 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 263 | char const *module_name_cstr = PyString_AS_STRING( module_name ); | ||
| 264 | |||
| 265 | char const *last_dot = strrchr( module_name_cstr, '.' ); | ||
| 266 | |||
| 267 | if ( last_dot != NULL ) | ||
| 268 | { | ||
| 269 | UPDATE_STRING_DICT1( | ||
| 270 | moduledict_systemd, | ||
| 271 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 272 | PyString_FromStringAndSize( module_name_cstr, last_dot - module_name_cstr ) | ||
| 273 | ); | ||
| 274 | } | ||
| 275 | #else | ||
| 276 | PyObject *module_name = GET_STRING_DICT_VALUE( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___name__ ); | ||
| 277 | Py_ssize_t dot_index = PyUnicode_Find( module_name, const_str_dot, 0, PyUnicode_GetLength( module_name ), -1 ); | ||
| 278 | |||
| 279 | if ( dot_index != -1 ) | ||
| 280 | { | ||
| 281 | UPDATE_STRING_DICT1( | ||
| 282 | moduledict_systemd, | ||
| 283 | (Nuitka_StringObject *)const_str_plain___package__, | ||
| 284 | PyUnicode_Substring( module_name, 0, dot_index ) | ||
| 285 | ); | ||
| 286 | } | ||
| 287 | #endif | ||
| 288 | #endif | ||
| 289 | } | ||
| 290 | |||
| 291 | CHECK_OBJECT( module_systemd ); | ||
| 292 | |||
| 293 | // Seems to work for Python2.7 out of the box, but for Python3, the module | ||
| 294 | // doesn't automatically enter "sys.modules", so do it manually. | ||
| 295 | #if PYTHON_VERSION >= 300 | ||
| 296 | { | ||
| 297 | int r = PyObject_SetItem( PyImport_GetModuleDict(), const_str_plain_systemd, module_systemd ); | ||
| 298 | |||
| 299 | assert( r != -1 ); | ||
| 300 | } | ||
| 301 | #endif | ||
| 302 | |||
| 303 | // For deep importing of a module we need to have "__builtins__", so we set | ||
| 304 | // it ourselves in the same way than CPython does. Note: This must be done | ||
| 305 | // before the frame object is allocated, or else it may fail. | ||
| 306 | |||
| 307 | if ( GET_STRING_DICT_VALUE( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___builtins__ ) == NULL ) | ||
| 308 | { | ||
| 309 | PyObject *value = (PyObject *)builtin_module; | ||
| 310 | |||
| 311 | // Check if main module, not a dict then but the module itself. | ||
| 312 | #if !defined(_NUITKA_EXE) || !0 | ||
| 313 | value = PyModule_GetDict( value ); | ||
| 314 | #endif | ||
| 315 | |||
| 316 | UPDATE_STRING_DICT0( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___builtins__, value ); | ||
| 317 | } | ||
| 318 | |||
| 319 | #if PYTHON_VERSION >= 300 | ||
| 320 | UPDATE_STRING_DICT0( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type ); | ||
| 321 | #endif | ||
| 322 | |||
| 323 | #if PYTHON_VERSION >= 340 | ||
| 324 | // Set the "__spec__" value | ||
| 325 | |||
| 326 | #if 0 | ||
| 327 | // Main modules just get "None" as spec. | ||
| 328 | UPDATE_STRING_DICT0( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___spec__, Py_None ); | ||
| 329 | #else | ||
| 330 | // Other modules get a "ModuleSpec" from the standard mechanism. | ||
| 331 | { | ||
| 332 | PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap"); | ||
| 333 | CHECK_OBJECT( bootstrap_module ); | ||
| 334 | PyObject *module_spec_class = PyObject_GetAttrString( bootstrap_module, "ModuleSpec" ); | ||
| 335 | Py_DECREF( bootstrap_module ); | ||
| 336 | |||
| 337 | PyObject *args[] = { | ||
| 338 | GET_STRING_DICT_VALUE( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___name__ ), | ||
| 339 | (PyObject *)&Nuitka_Loader_Type | ||
| 340 | }; | ||
| 341 | |||
| 342 | PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2( | ||
| 343 | module_spec_class, | ||
| 344 | args | ||
| 345 | ); | ||
| 346 | Py_DECREF( module_spec_class ); | ||
| 347 | |||
| 348 | // We can assume this to never fail, or else we are in trouble anyway. | ||
| 349 | CHECK_OBJECT( spec_value ); | ||
| 350 | |||
| 351 | // For packages set the submodule search locations as well, even if to empty | ||
| 352 | // list, so investigating code will consider it a package. | ||
| 353 | #if 1 | ||
| 354 | SET_ATTRIBUTE( spec_value, const_str_plain_submodule_search_locations, PyList_New(0) ); | ||
| 355 | #endif | ||
| 356 | |||
| 357 | // Mark the execution in the "__spec__" value. | ||
| 358 | SET_ATTRIBUTE( spec_value, const_str_plain__initializing, Py_True ); | ||
| 359 | |||
| 360 | UPDATE_STRING_DICT1( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___spec__, spec_value ); | ||
| 361 | } | ||
| 362 | #endif | ||
| 363 | #endif | ||
| 364 | |||
| 365 | // Temp variables if any | ||
| 366 | struct Nuitka_FrameObject *frame_a0dcda2462cfba7e16808270b4c9780e; | ||
| 367 | NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; | ||
| 368 | PyObject *exception_type = NULL; | ||
| 369 | PyObject *exception_value = NULL; | ||
| 370 | PyTracebackObject *exception_tb = NULL; | ||
| 371 | NUITKA_MAY_BE_UNUSED int exception_lineno = 0; | ||
| 372 | bool tmp_result; | ||
| 373 | |||
| 374 | // Module code. | ||
| 375 | { | ||
| 376 | PyObject *tmp_assign_source_1; | ||
| 377 | tmp_assign_source_1 = Py_None; | ||
| 378 | UPDATE_STRING_DICT0( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1 ); | ||
| 379 | } | ||
| 380 | { | ||
| 381 | PyObject *tmp_assign_source_2; | ||
| 382 | tmp_assign_source_2 = module_filename_obj; | ||
| 383 | UPDATE_STRING_DICT0( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2 ); | ||
| 384 | } | ||
| 385 | // Frame without reuse. | ||
| 386 | frame_a0dcda2462cfba7e16808270b4c9780e = MAKE_MODULE_FRAME( codeobj_a0dcda2462cfba7e16808270b4c9780e, module_systemd ); | ||
| 387 | |||
| 388 | // Push the new frame as the currently active one, and we should be exclusively | ||
| 389 | // owning it. | ||
| 390 | pushFrameStack( frame_a0dcda2462cfba7e16808270b4c9780e ); | ||
| 391 | assert( Py_REFCNT( frame_a0dcda2462cfba7e16808270b4c9780e ) == 2 ); | ||
| 392 | |||
| 393 | // Framed code: | ||
| 394 | { | ||
| 395 | PyObject *tmp_assign_source_3; | ||
| 396 | PyObject *tmp_list_element_1; | ||
| 397 | PyObject *tmp_called_name_1; | ||
| 398 | PyObject *tmp_source_name_1; | ||
| 399 | PyObject *tmp_args_element_name_1; | ||
| 400 | PyObject *tmp_called_instance_1; | ||
| 401 | frame_a0dcda2462cfba7e16808270b4c9780e->m_frame.f_lineno = 1; | ||
| 402 | { | ||
| 403 | PyObject *module = PyImport_ImportModule("os"); | ||
| 404 | if (likely( module != NULL )) | ||
| 405 | { | ||
| 406 | tmp_source_name_1 = PyObject_GetAttr( module, const_str_plain_path ); | ||
| 407 | } | ||
| 408 | else | ||
| 409 | { | ||
| 410 | tmp_source_name_1 = NULL; | ||
| 411 | } | ||
| 412 | } | ||
| 413 | |||
| 414 | if ( tmp_source_name_1 == NULL ) | ||
| 415 | { | ||
| 416 | assert( ERROR_OCCURRED() ); | ||
| 417 | |||
| 418 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 419 | |||
| 420 | |||
| 421 | exception_lineno = 1; | ||
| 422 | |||
| 423 | goto frame_exception_exit_1; | ||
| 424 | } | ||
| 425 | tmp_called_name_1 = LOOKUP_ATTRIBUTE( tmp_source_name_1, const_str_plain_dirname ); | ||
| 426 | if ( tmp_called_name_1 == NULL ) | ||
| 427 | { | ||
| 428 | assert( ERROR_OCCURRED() ); | ||
| 429 | |||
| 430 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 431 | |||
| 432 | |||
| 433 | exception_lineno = 1; | ||
| 434 | |||
| 435 | goto frame_exception_exit_1; | ||
| 436 | } | ||
| 437 | tmp_args_element_name_1 = module_filename_obj; | ||
| 438 | frame_a0dcda2462cfba7e16808270b4c9780e->m_frame.f_lineno = 1; | ||
| 439 | { | ||
| 440 | PyObject *call_args[] = { tmp_args_element_name_1 }; | ||
| 441 | tmp_list_element_1 = CALL_FUNCTION_WITH_ARGS1( tmp_called_name_1, call_args ); | ||
| 442 | } | ||
| 443 | |||
| 444 | Py_DECREF( tmp_called_name_1 ); | ||
| 445 | if ( tmp_list_element_1 == NULL ) | ||
| 446 | { | ||
| 447 | assert( ERROR_OCCURRED() ); | ||
| 448 | |||
| 449 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 450 | |||
| 451 | |||
| 452 | exception_lineno = 1; | ||
| 453 | |||
| 454 | goto frame_exception_exit_1; | ||
| 455 | } | ||
| 456 | tmp_assign_source_3 = PyList_New( 2 ); | ||
| 457 | PyList_SET_ITEM( tmp_assign_source_3, 0, tmp_list_element_1 ); | ||
| 458 | frame_a0dcda2462cfba7e16808270b4c9780e->m_frame.f_lineno = 1; | ||
| 459 | { | ||
| 460 | PyObject *module = PyImport_ImportModule("os"); | ||
| 461 | if (likely( module != NULL )) | ||
| 462 | { | ||
| 463 | tmp_called_instance_1 = PyObject_GetAttr( module, const_str_plain_environ ); | ||
| 464 | } | ||
| 465 | else | ||
| 466 | { | ||
| 467 | tmp_called_instance_1 = NULL; | ||
| 468 | } | ||
| 469 | } | ||
| 470 | |||
| 471 | if ( tmp_called_instance_1 == NULL ) | ||
| 472 | { | ||
| 473 | assert( ERROR_OCCURRED() ); | ||
| 474 | |||
| 475 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 476 | Py_DECREF( tmp_assign_source_3 ); | ||
| 477 | |||
| 478 | exception_lineno = 1; | ||
| 479 | |||
| 480 | goto frame_exception_exit_1; | ||
| 481 | } | ||
| 482 | frame_a0dcda2462cfba7e16808270b4c9780e->m_frame.f_lineno = 1; | ||
| 483 | tmp_list_element_1 = CALL_METHOD_WITH_ARGS2( tmp_called_instance_1, const_str_plain_get, &PyTuple_GET_ITEM( const_tuple_e13953b47470e88067c8bce77c755d8d_tuple, 0 ) ); | ||
| 484 | |||
| 485 | if ( tmp_list_element_1 == NULL ) | ||
| 486 | { | ||
| 487 | assert( ERROR_OCCURRED() ); | ||
| 488 | |||
| 489 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 490 | Py_DECREF( tmp_assign_source_3 ); | ||
| 491 | |||
| 492 | exception_lineno = 1; | ||
| 493 | |||
| 494 | goto frame_exception_exit_1; | ||
| 495 | } | ||
| 496 | PyList_SET_ITEM( tmp_assign_source_3, 1, tmp_list_element_1 ); | ||
| 497 | UPDATE_STRING_DICT1( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___path__, tmp_assign_source_3 ); | ||
| 498 | } | ||
| 499 | { | ||
| 500 | PyObject *tmp_assattr_name_1; | ||
| 501 | PyObject *tmp_assattr_target_1; | ||
| 502 | PyObject *tmp_mvar_value_1; | ||
| 503 | tmp_assattr_name_1 = module_filename_obj; | ||
| 504 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 505 | |||
| 506 | if (unlikely( tmp_mvar_value_1 == NULL )) | ||
| 507 | { | ||
| 508 | tmp_mvar_value_1 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 509 | } | ||
| 510 | |||
| 511 | CHECK_OBJECT( tmp_mvar_value_1 ); | ||
| 512 | tmp_assattr_target_1 = tmp_mvar_value_1; | ||
| 513 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1 ); | ||
| 514 | if ( tmp_result == false ) | ||
| 515 | { | ||
| 516 | assert( ERROR_OCCURRED() ); | ||
| 517 | |||
| 518 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 519 | |||
| 520 | |||
| 521 | exception_lineno = 1; | ||
| 522 | |||
| 523 | goto frame_exception_exit_1; | ||
| 524 | } | ||
| 525 | } | ||
| 526 | { | ||
| 527 | PyObject *tmp_assattr_name_2; | ||
| 528 | PyObject *tmp_assattr_target_2; | ||
| 529 | PyObject *tmp_mvar_value_2; | ||
| 530 | tmp_assattr_name_2 = Py_True; | ||
| 531 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 532 | |||
| 533 | if (unlikely( tmp_mvar_value_2 == NULL )) | ||
| 534 | { | ||
| 535 | tmp_mvar_value_2 = GET_STRING_DICT_VALUE( dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__ ); | ||
| 536 | } | ||
| 537 | |||
| 538 | CHECK_OBJECT( tmp_mvar_value_2 ); | ||
| 539 | tmp_assattr_target_2 = tmp_mvar_value_2; | ||
| 540 | tmp_result = SET_ATTRIBUTE( tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2 ); | ||
| 541 | if ( tmp_result == false ) | ||
| 542 | { | ||
| 543 | assert( ERROR_OCCURRED() ); | ||
| 544 | |||
| 545 | FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb ); | ||
| 546 | |||
| 547 | |||
| 548 | exception_lineno = 1; | ||
| 549 | |||
| 550 | goto frame_exception_exit_1; | ||
| 551 | } | ||
| 552 | } | ||
| 553 | |||
| 554 | // Restore frame exception if necessary. | ||
| 555 | #if 0 | ||
| 556 | RESTORE_FRAME_EXCEPTION( frame_a0dcda2462cfba7e16808270b4c9780e ); | ||
| 557 | #endif | ||
| 558 | popFrameStack(); | ||
| 559 | |||
| 560 | assertFrameObject( frame_a0dcda2462cfba7e16808270b4c9780e ); | ||
| 561 | |||
| 562 | goto frame_no_exception_1; | ||
| 563 | |||
| 564 | frame_exception_exit_1:; | ||
| 565 | #if 0 | ||
| 566 | RESTORE_FRAME_EXCEPTION( frame_a0dcda2462cfba7e16808270b4c9780e ); | ||
| 567 | #endif | ||
| 568 | |||
| 569 | if ( exception_tb == NULL ) | ||
| 570 | { | ||
| 571 | exception_tb = MAKE_TRACEBACK( frame_a0dcda2462cfba7e16808270b4c9780e, exception_lineno ); | ||
| 572 | } | ||
| 573 | else if ( exception_tb->tb_frame != &frame_a0dcda2462cfba7e16808270b4c9780e->m_frame ) | ||
| 574 | { | ||
| 575 | exception_tb = ADD_TRACEBACK( exception_tb, frame_a0dcda2462cfba7e16808270b4c9780e, exception_lineno ); | ||
| 576 | } | ||
| 577 | |||
| 578 | // Put the previous frame back on top. | ||
| 579 | popFrameStack(); | ||
| 580 | |||
| 581 | // Return the error. | ||
| 582 | goto module_exception_exit; | ||
| 583 | |||
| 584 | frame_no_exception_1:; | ||
| 585 | { | ||
| 586 | PyObject *tmp_assign_source_4; | ||
| 587 | tmp_assign_source_4 = Py_None; | ||
| 588 | UPDATE_STRING_DICT0( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_4 ); | ||
| 589 | } | ||
| 590 | |||
| 591 | #if _NUITKA_EXPERIMENTAL_PKGUTIL_ITERMODULES | ||
| 592 | #if 1 && 0 | ||
| 593 | { | ||
| 594 | PyObject *path_value = GET_STRING_DICT_VALUE( moduledict_systemd, (Nuitka_StringObject *)const_str_plain___path__ ); | ||
| 595 | |||
| 596 | if (path_value && PyList_CheckExact(path_value) && PyList_Size(path_value) > 0) | ||
| 597 | { | ||
| 598 | PyObject *path_element = PyList_GetItem( path_value, 0 ); | ||
| 599 | |||
| 600 | PyObject *path_importer_cache = PySys_GetObject((char *)"path_importer_cache"); | ||
| 601 | CHECK_OBJECT( path_importer_cache ); | ||
| 602 | |||
| 603 | int res = PyDict_SetItem( path_importer_cache, path_element, (PyObject *)&Nuitka_Loader_Type ); | ||
| 604 | assert( res == 0 ); | ||
| 605 | } | ||
| 606 | } | ||
| 607 | #endif | ||
| 608 | #endif | ||
| 609 | |||
| 610 | return MOD_RETURN_VALUE( module_systemd ); | ||
| 611 | module_exception_exit: | ||
| 612 | RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb ); | ||
| 613 | return MOD_RETURN_VALUE( NULL ); | ||
| 614 | } | ||
| The diff for file Linux_Version/inventory_synchronisation.build/module.systemd.journal.c is too big (20794 changes) and cannot be shown. |
| File Linux_Version/inventory_synchronisation.build/module.systemd.journal.o deleted (index c80285c..0000000) |
| File Linux_Version/inventory_synchronisation.build/module.systemd.o deleted (index 5912d3c..0000000) |
| File Linux_Version/inventory_synchronisation.build/scons-report.txt deleted (index e9cd63e..0000000) | |||
| 1 | AS=as | ||
| 2 | ASCOM=$AS $ASFLAGS -o $TARGET $SOURCES | ||
| 3 | ASPPCOM=$CC $ASPPFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES | ||
| 4 | ASPPFLAGS=$ASFLAGS | ||
| 5 | CC=gcc | ||
| 6 | CCCOM=$CC -o $TARGET -c $CFLAGS $CCFLAGS $_CCCOMCOM $SOURCES | ||
| 7 | CCVERSION=8 | ||
| 8 | CFILESUFFIX=.c | ||
| 9 | CPPDEFPREFIX=-D | ||
| 10 | CPPDEFSUFFIX= | ||
| 11 | CXX=g++ | ||
| 12 | CXXCOM=$CXX -o $TARGET -c $CXXFLAGS $CCFLAGS $_CCCOMCOM $SOURCES | ||
| 13 | CXXFILESUFFIX=.cc | ||
| 14 | INCPREFIX=-I | ||
| 15 | INCSUFFIX= | ||
| 16 | LDMODULE=$SHLINK | ||
| 17 | LDMODULECOM=$LDMODULE -o $TARGET $LDMODULEFLAGS $__LDMODULEVERSIONFLAGS $__RPATH $SOURCES $_LIBDIRFLAGS $_LIBFLAGS | ||
| 18 | LDMODULEFLAGS=$SHLINKFLAGS | ||
| 19 | LDMODULENOVERSIONSYMLINKS=$SHLIBNOVERSIONSYMLINKS | ||
| 20 | LDMODULEPREFIX=$SHLIBPREFIX | ||
| 21 | LDMODULESUFFIX=$SHLIBSUFFIX | ||
| 22 | LDMODULEVERSION=$SHLIBVERSION | ||
| 23 | LDMODULEVERSIONFLAGS=$SHLIBVERSIONFLAGS | ||
| 24 | LIBDIRPREFIX=-L | ||
| 25 | LIBDIRSUFFIX= | ||
| 26 | LIBLINKPREFIX=-l | ||
| 27 | LIBLINKSUFFIX= | ||
| 28 | LIBPREFIX=lib | ||
| 29 | LIBSUFFIX=.a | ||
| 30 | LINK=$SMARTLINK | ||
| 31 | LINKCOM=$LINK -o $TARGET $LINKFLAGS $__RPATH $SOURCES $_LIBDIRFLAGS $_LIBFLAGS | ||
| 32 | OBJPREFIX= | ||
| 33 | OBJSUFFIX=.o | ||
| 34 | PLATFORM=posix | ||
| 35 | PROGPREFIX= | ||
| 36 | PROGSUFFIX= | ||
| 37 | RPATHPREFIX=-Wl,-rpath= | ||
| 38 | RPATHSUFFIX= | ||
| 39 | SHCC=$CC | ||
| 40 | SHCCCOM=$SHCC -o $TARGET -c $SHCFLAGS $SHCCFLAGS $_CCCOMCOM $SOURCES | ||
| 41 | SHCXX=$CXX | ||
| 42 | SHCXXCOM=$SHCXX -o $TARGET -c $SHCXXFLAGS $SHCCFLAGS $_CCCOMCOM $SOURCES | ||
| 43 | SHELL=sh | ||
| 44 | SHLIBPREFIX= | ||
| 45 | SHLIBSUFFIX=.so | ||
| 46 | SHLINK=$LINK | ||
| 47 | SHLINKCOM=$SHLINK -o $TARGET $SHLINKFLAGS $__SHLIBVERSIONFLAGS $__RPATH $SOURCES $_LIBDIRFLAGS $_LIBFLAGS | ||
| 48 | SHOBJPREFIX=$OBJPREFIX | ||
| 49 | SHOBJSUFFIX=.os | ||
| 50 | TARGET_ARCH=x86_64 | ||
| 51 | TEMPFILEPREFIX=@ | ||
| File build_new_version.sh changed (mode: 100755) (index 946b294..29dac83) | |||
| 2 | 2 | ||
| 3 | 3 | cd Linux_Version/ | cd Linux_Version/ |
| 4 | 4 | echo $PWD | echo $PWD |
| 5 | echo "Delete all existing content of 'Linux_Version'" | ||
| 6 | 5 | if [ -f $PWD/inventory_synchronisation.dist ]; then | if [ -f $PWD/inventory_synchronisation.dist ]; then |
| 6 | echo "Delete all existing content of 'Linux_Version'" | ||
| 7 | 7 | rm -irf * | rm -irf * |
| 8 | 8 | fi | fi |
| 9 | 9 | echo "Build the script into a executable file using nuitka." | echo "Build the script into a executable file using nuitka." |
| File clean_upload.sh added (mode: 100755) (index 0000000..842a6af) | |||
| 1 | #!/bin/bash | ||
| 2 | |||
| 3 | cd ./Upload/ | ||
| 4 | rm *.csv | ||
| File inventory_synchronisation.py changed (mode: 100644) (index d6c28ce..acf4f8b) | |||
| ... | ... | def main(): | |
| 95 | 95 | ||
| 96 | 96 | # Ask the user if the task is to import received items at amazon or to | # Ask the user if the task is to import received items at amazon or to |
| 97 | 97 | # create a new order for production | # create a new order for production |
| 98 | line = chr(1758) * 70 | ||
| 99 | altline = chr(1757) * 70 | ||
| 100 | print("{0}\n".format(line)) | ||
| 101 | print(" "+chr(420)+"reparation for the Script / Vorbereitung für den Script\n") | ||
| 102 | print("{0}\n".format(line)) | ||
| 103 | print(" Get a export of all variations from plentymarkets\n & save it in Report\n") | ||
| 104 | print(" Lade einen Export von allen Varianten in Plentymarkets\n & speichere diesen in Report\n") | ||
| 105 | print("{0}\n".format(altline)) | ||
| 106 | print(" Save your Storagereport from Amazon as .csv and name the column\n of the units to be sent as FBA-SHIPMENT\n") | ||
| 107 | print(" Speichere deine Lagerbestandsdatei as .csv und benenne die Spalte\n mit den zu versendenden Artikeln als FBA-SHIPMENT\n") | ||
| 108 | print("{0}\n".format(altline)) | ||
| 109 | print(" Get a export of the locations from plentymarkets\n & save it in Report\n") | ||
| 110 | print(" Lade einen Export der Lagerstandorte von plentymarkets\n & speichere diesen in Report\n") | ||
| 111 | print("{0}\n".format(line)) | ||
| 112 | |||
| 98 | 113 | task = '' | task = '' |
| 99 | 114 | ||
| 100 | 115 | while(not(task.lower() == 'amazon' or task.lower() == 'order' or task.lower() == 'fba')): | while(not(task.lower() == 'amazon' or task.lower() == 'order' or task.lower() == 'fba')): |
| 101 | task = input('Do you want to create a new production order (order)\nDo you want to import received items at Amazon (amazon)?\nOr do you want to create a new Shipping to Amazon (fba)?\n') | ||
| 102 | if(not(task.lower() == 'amazon' or task.lower() == 'order' or task.lower() == 'fba')): | ||
| 103 | print("Please enter either 'amazon' ,'order' or 'fba'.\n") | ||
| 116 | task = input('Do you want to create a new production order (order)||DEPRECATED||\nDo you want to import received items at Amazon (amazon)?\nOr do you want to create a new Shipping to Amazon (fba)?\n') | ||
| 117 | if(not(task.lower() == 'amazon' or task.lower() == 'fba')): | ||
| 118 | print("Please enter either 'amazon' or 'fba'.\n") | ||
| 104 | 119 | ||
| 105 | 120 | # Ask the User to enter the ID of the order that he wants to change | # Ask the User to enter the ID of the order that he wants to change |
| 106 | order = '' | ||
| 107 | |||
| 108 | while(not(order.isdigit())): | ||
| 109 | if(task.lower() == 'amazon' or task.lower() == 'fba'): | ||
| 110 | order = input('Please enter the ID of the Plentymarkets Order: ') | ||
| 111 | if(task.lower() == 'order'): | ||
| 112 | order = input('Please enter the highest available Order ID\nFrom Plentymarkets.\n') | ||
| 113 | order = int(order) | ||
| 114 | order = str(order) | ||
| 115 | if(not(order.isdigit())): | ||
| 116 | print("Please enter a valid Order ID which only consists of numbers.\n") | ||
| 121 | order ='0000' | ||
| 117 | 122 | ||
| 118 | 123 | # A filedialog for the export and the report file | # A filedialog for the export and the report file |
| 119 | 124 | root = Tk() | root = Tk() |
| 120 | 125 | root.withdraw() | root.withdraw() |
| 126 | print("\n{0}\n".format(line)) | ||
| 121 | 127 | print("Open the export file of all items, to get the Variation ID which is needed for the Upload.\n") | print("Open the export file of all items, to get the Variation ID which is needed for the Upload.\n") |
| 122 | 128 | export = askopenfilename(initialdir=reportpath | export = askopenfilename(initialdir=reportpath |
| 123 | 129 | , title="Export from Plentymarkets" | , title="Export from Plentymarkets" |
| ... | ... | def main(): | |
| 126 | 132 | # AMAZON RECEIVED PART | # AMAZON RECEIVED PART |
| 127 | 133 | if(task.lower() == 'amazon'): | if(task.lower() == 'amazon'): |
| 128 | 134 | print("Open the report file of the recent delivered FBA packages,\nthis will contain the amount of items that amazon received.\n") | print("Open the report file of the recent delivered FBA packages,\nthis will contain the amount of items that amazon received.\n") |
| 135 | print("\n{0}\n".format(line)) | ||
| 129 | 136 | report = askopenfilename(initialdir=reportpath | report = askopenfilename(initialdir=reportpath |
| 130 | 137 | , title="FBA-Report" | , title="FBA-Report" |
| 131 | 138 | , filetypes=[ ("csv files" ,"*.csv" ) ] ) | , filetypes=[ ("csv files" ,"*.csv" ) ] ) |
| ... | ... | def main(): | |
| 141 | 148 | # NEW ORDER IMPORT PART | # NEW ORDER IMPORT PART |
| 142 | 149 | if(task.lower() == 'order'): | if(task.lower() == 'order'): |
| 143 | 150 | print("Open the Excel list of items to be ordered.\n") | print("Open the Excel list of items to be ordered.\n") |
| 151 | print("\n{0}\n".format(line)) | ||
| 144 | 152 | neworder = askopenfilename(initialdir=reportpath | neworder = askopenfilename(initialdir=reportpath |
| 145 | 153 | , title="Order list for production" | , title="Order list for production" |
| 146 | 154 | , filetypes=[ ("csv files" ,"*.csv" ) ] ) | , filetypes=[ ("csv files" ,"*.csv" ) ] ) |
| ... | ... | def main(): | |
| 156 | 164 | # NEW FBA SHIPMENT PART | # NEW FBA SHIPMENT PART |
| 157 | 165 | if(task.lower() == 'fba'): | if(task.lower() == 'fba'): |
| 158 | 166 | print("Open the stock report with the calculated shipment.\n") | print("Open the stock report with the calculated shipment.\n") |
| 167 | print("\n{0}\n".format(line)) | ||
| 159 | 168 | newshipment = askopenfilename(initialdir=reportpath, | newshipment = askopenfilename(initialdir=reportpath, |
| 160 | 169 | title="Latest stock report from Amazon", | title="Latest stock report from Amazon", |
| 161 | 170 | filetypes=[ ("csv files", "*.csv") ]) | filetypes=[ ("csv files", "*.csv") ]) |
| 162 | importAmazonOrder(export=export, folder=uploadpath, orderid=order, | ||
| 163 | plentyid=configid, stockreport=newshipment | ||
| 171 | importAmazonOrder(export=export, reportfolder=reportpath, folder=uploadpath, | ||
| 172 | orderid=order, plentyid=configid, stockreport=newshipment | ||
| 164 | 173 | ) | ) |
| 165 | 174 | #try: | #try: |
| 166 | 175 | #print("here will be the function for the ExcelSheet") | #print("here will be the function for the ExcelSheet") |
| File packages/__pycache__/picklist_creation.cpython-37.pyc added (mode: 100644) (index 0000000..9ba7187) |
| File packages/__pycache__/syncfile.cpython-37.pyc changed (mode: 100644) (index 369ed6a..a36c165) |
| File packages/picklist_creation.py added (mode: 100644) (index 0000000..5e48b4c) | |||
| 1 | from tkinter import Tk | ||
| 2 | import csv | ||
| 3 | from tkinter.filedialog import askopenfilename | ||
| 4 | from packages import syncfile | ||
| 5 | |||
| 6 | def picklist_creation(shipmentlist, folder, uploadfolder): | ||
| 7 | |||
| 8 | # Get the path of the locationlist | ||
| 9 | locationlist = askopenfilename(initialdir=folder, | ||
| 10 | title="Locationlist", | ||
| 11 | filetypes=[ ("csv files", "*.csv") ]) | ||
| 12 | |||
| 13 | # The headers of the outputfile | ||
| 14 | column_names = ['Sku', 'location', 'Barcode', '@location', 'Shipment'] | ||
| 15 | |||
| 16 | # Define the Dictionary for the datasets and the list for multiple locations | ||
| 17 | # on a single SKU | ||
| 18 | Data = {} | ||
| 19 | locations = {} | ||
| 20 | shipping_items = [] | ||
| 21 | |||
| 22 | # Open the locationlist and gather all locations for each sku | ||
| 23 | with open(locationlist, mode = 'r') as item: | ||
| 24 | reader = csv.DictReader(item, delimiter=';') | ||
| 25 | |||
| 26 | for row in reader: | ||
| 27 | # Check if there is already an entry for the specific SKU if not create | ||
| 28 | # a new key value pair with the sku as key and a list of rows of that sku | ||
| 29 | if(row['VariationNo'] not in [*locations]): | ||
| 30 | locations[row['VariationNo']] = list() | ||
| 31 | locations[row['VariationNo']].append(row) | ||
| 32 | |||
| 33 | elif(row['VariationNo'] in [*locations]): | ||
| 34 | locations[row[ 'VariationNo' ]].append(row) | ||
| 35 | |||
| 36 | # Open the shipmentlist and create a list of items that are going to be shipped | ||
| 37 | with open(shipmentlist, mode = 'r') as item: | ||
| 38 | reader = csv.DictReader(item, delimiter=';') | ||
| 39 | |||
| 40 | number = 0 | ||
| 41 | for row in reader: | ||
| 42 | if(row['Menge']): | ||
| 43 | number += int( row['Menge'] ) | ||
| 44 | shipping_items.append(row['Name']) | ||
| 45 | |||
| 46 | items_in_skulist = 0 | ||
| 47 | for skulist in locations: | ||
| 48 | number = 0 | ||
| 49 | for index, row in enumerate( locations[ skulist ] ): | ||
| 50 | if(row['VariationNo'] in [*shipping_items]): | ||
| 51 | items_in_skulist += 1 | ||
| 52 | number += 1 | ||
| 53 | values = [row['VariationNo'], row['LocationName'], row['Barcode'], row['Stock'], ''] | ||
| 54 | |||
| 55 | Data[row['VariationNo'] + '+' + str(number)] = dict(zip(column_names, values)) | ||
| 56 | |||
| 57 | # Open the shipmentlist and get the shipment quantity | ||
| 58 | with open(shipmentlist, mode = 'r') as item: | ||
| 59 | reader = csv.DictReader(item,delimiter=';') | ||
| 60 | |||
| 61 | for row in reader: | ||
| 62 | if(row['Name']+'+1' in [*Data]): | ||
| 63 | Data[row['Name']+'+1']['Shipment'] = row['Menge'] | ||
| 64 | |||
| 65 | syncfile.writeNewCsv(dataset=Data,path=uploadfolder, header=column_names,name='picklist') | ||
| File packages/syncfile.py changed (mode: 100644) (index 3bb0115..bcabb4f) | |||
| ... | ... | import sys | |
| 2 | 2 | import csv | import csv |
| 3 | 3 | import re | import re |
| 4 | 4 | from os.path import isfile | from os.path import isfile |
| 5 | from packages import picklist_creation | ||
| 5 | 6 | ||
| 6 | 7 | def writeNewCsv(dataset, path, header, name): | def writeNewCsv(dataset, path, header, name): |
| 7 | 8 | '''Write Data into new CSV for Upload | '''Write Data into new CSV for Upload |
| ... | ... | def writeNewCsv(dataset, path, header, name): | |
| 22 | 23 | writer = csv.DictWriter(item, delimiter=";", fieldnames=header) | writer = csv.DictWriter(item, delimiter=";", fieldnames=header) |
| 23 | 24 | writer.writeheader() | writer.writeheader() |
| 24 | 25 | for row in dataset: | for row in dataset: |
| 25 | if(dataset[row]['RowVariationID']): | ||
| 26 | writer.writerow(dataset[row]) | ||
| 26 | writer.writerow(dataset[row]) | ||
| 27 | 27 | ||
| 28 | 28 | if(isfile(output_path)): | if(isfile(output_path)): |
| 29 | 29 | print("Upload file successfully created under {0}".format(output_path)) | print("Upload file successfully created under {0}".format(output_path)) |
| ... | ... | def writeNewCsv(dataset, path, header, name): | |
| 31 | 31 | return output_path | return output_path |
| 32 | 32 | ||
| 33 | 33 | ||
| 34 | def importAmazonOrder(export, folder, orderid, plentyid, report='', stockreport=''): | ||
| 34 | def importAmazonOrder(export, reportfolder, folder, orderid, plentyid, report='', stockreport=''): | ||
| 35 | 35 | # Define the headers of the new Sync File | # Define the headers of the new Sync File |
| 36 | 36 | column_names = ['CustomerID','FirstName','LastName','OrderID' | column_names = ['CustomerID','FirstName','LastName','OrderID' |
| 37 | 37 | ,'OrderType','StoreID','ID_der_Adresse' | ,'OrderType','StoreID','ID_der_Adresse' |
| ... | ... | def importAmazonOrder(export, folder, orderid, plentyid, report='', stockreport= | |
| 138 | 138 | # in order to speed up the shipping process | # in order to speed up the shipping process |
| 139 | 139 | if(int(amount) > 8): | if(int(amount) > 8): |
| 140 | 140 | amount = 5 * round(int( amount ) / 5) | amount = 5 * round(int( amount ) / 5) |
| 141 | print(sku + ':' + str( amount )) | ||
| 142 | 141 | ||
| 143 | 142 | values = [customer_id, first_name, last_name, orderid, | values = [customer_id, first_name, last_name, orderid, |
| 144 | 143 | '1', plentyid, adress_id, | '1', plentyid, adress_id, |
| ... | ... | def importAmazonOrder(export, folder, orderid, plentyid, report='', stockreport= | |
| 162 | 161 | Data[row['VariationNumber']]['Preis'] = row['PurchasePrice'] | Data[row['VariationNumber']]['Preis'] = row['PurchasePrice'] |
| 163 | 162 | # Write the finished Data dictionary into a new file | # Write the finished Data dictionary into a new file |
| 164 | 163 | ||
| 165 | writeNewCsv(dataset=Data, path=folder, header=column_names, name=syncname) | ||
| 164 | shipment = writeNewCsv(dataset=Data, path=folder, header=column_names, name=syncname) | ||
| 165 | if(stockreport and not(report)): | ||
| 166 | picklist_creation.picklist_creation(shipmentlist=shipment, folder=reportfolder, uploadfolder=folder) | ||
| 166 | 167 | ||
| 167 | 168 | def importNewOrder(export, folder, orderlist, orderid, producerlist, plentyid): | def importNewOrder(export, folder, orderlist, orderid, producerlist, plentyid): |
| 168 | 169 | ||
Hints:
Before first commit, do not forget to setup your git environment:
Clone this repository using HTTP(S):
Clone this repository using ssh (do not forget to upload a key first):
Clone this repository using git:
You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a merge request:
Before first commit, do not forget to setup your git environment:
git config --global user.name "your_name_here"
git config --global user.email "your@email_here"
git config --global user.email "your@email_here"
Clone this repository using HTTP(S):
git clone https://rocketgit.com/user/initBasti/Complete_Order_Plenty_Update
Clone this repository using ssh (do not forget to upload a key first):
git clone ssh://rocketgit@ssh.rocketgit.com/user/initBasti/Complete_Order_Plenty_Update
Clone this repository using git:
git clone git://git.rocketgit.com/user/initBasti/Complete_Order_Plenty_Update
You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a merge request:
... clone the repository ...
... make some changes and some commits ...
git push origin main
... make some changes and some commits ...
git push origin main
RocketGit
Rocket your launch!
Rocket your launch!