Nuitka
The Python compiler
Loading...
Searching...
No Matches
CompiledGeneratorTypeUncompiledIntegration.c
1// Copyright 2026, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
2
10// This file is included from another C file, help IDEs to still parse it on
11// its own.
12#ifdef __IDE_ONLY__
13#include "nuitka/prelude.h"
14#endif
15
16// spell-checker: ignore f_valuestack,f_stacktop,PYGEN,_Py_CODEUNIT,OPARG
17// spell-checker: ignore localsplus,stacktop,f_funcobj,genexit
18// spell-checker: ignore deopt,subscr,isinstance,getitem,noargs,aiter,anext
19// spell-checker: ignore classderef,getattribute,precall,nondescriptor,pyfunc
20
21#if PYTHON_VERSION >= 0x300
22static PyObject *Nuitka_CallGeneratorThrowMethod(PyObject *throw_method,
23 struct Nuitka_ExceptionPreservationItem *exception_state);
24#endif
25
26#if PYTHON_VERSION >= 0x300
27static PyBaseExceptionObject *Nuitka_BaseExceptionSingleArg_new(PyThreadState *tstate, PyTypeObject *type,
28 PyObject *arg) {
29 PyBaseExceptionObject *result = (PyBaseExceptionObject *)type->tp_alloc(type, 0);
30
31 result->dict = NULL;
32 result->traceback = NULL;
33 result->cause = NULL;
34 result->context = NULL;
35 result->suppress_context = 0;
36
37 if (arg != NULL) {
38 result->args = MAKE_TUPLE1(tstate, arg);
39 } else {
40 result->args = const_tuple_empty;
41 Py_INCREF_IMMORTAL(result->args);
42 }
43
44 return result;
45}
46
47static PyObject *Nuitka_CreateStopIteration(PyThreadState *tstate, PyObject *value) {
48 if (value == Py_None) {
49 value = NULL;
50 }
51
52 PyStopIterationObject *result =
53 (PyStopIterationObject *)Nuitka_BaseExceptionSingleArg_new(tstate, (PyTypeObject *)PyExc_StopIteration, value);
54
55#if PYTHON_VERSION >= 0x3c0
56 if (value == NULL) {
57 // Immortal value.
58 result->value = Py_None;
59 } else {
60 result->value = value;
61 Py_INCREF(value);
62 }
63#else
64 result->value = value;
65 Py_XINCREF(value);
66#endif
67
68 return (PyObject *)result;
69}
70
71// This function takes no reference to value, and publishes a StopIteration
72// exception with it.
73static void Nuitka_SetStopIterationValue(PyThreadState *tstate, PyObject *value) {
74 CHECK_OBJECT(value);
75
76#if PYTHON_VERSION <= 0x352
77 PyObject *stop_value = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, PyExc_StopIteration, value);
78
79 if (unlikely(stop_value == NULL)) {
80 return;
81 }
82
83 SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_StopIteration, stop_value);
84#elif PYTHON_VERSION < 0x3c0
85 if (likely(!PyTuple_Check(value) && !PyExceptionInstance_Check(value))) {
86 SET_CURRENT_EXCEPTION_TYPE0_VALUE0(tstate, PyExc_StopIteration, value);
87 } else {
88 struct Nuitka_ExceptionPreservationItem exception_state = {Py_NewRef(PyExc_StopIteration),
89 Nuitka_CreateStopIteration(tstate, value)};
90
91 RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
92 }
93#else
94 struct Nuitka_ExceptionPreservationItem exception_state = {Nuitka_CreateStopIteration(tstate, value)};
95
96 RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
97#endif
98}
99#endif
100
101static void SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(PyThreadState *tstate) {
102#if PYTHON_VERSION < 0x3c0
103 SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
104#else
105 struct Nuitka_ExceptionPreservationItem exception_state = {Nuitka_CreateStopIteration(tstate, NULL)};
106
107 RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
108#endif
109}
110
111#if PYTHON_VERSION >= 0x360
112
113#if PYTHON_VERSION >= 0x3c0
114static PyObject *Nuitka_CreateStopAsyncIteration(PyThreadState *tstate) {
115 return (PyObject *)Nuitka_BaseExceptionSingleArg_new(tstate, (PyTypeObject *)PyExc_StopAsyncIteration, NULL);
116}
117#endif
118
119static void SET_CURRENT_EXCEPTION_STOP_ASYNC_ITERATION(PyThreadState *tstate) {
120#if PYTHON_VERSION < 0x3c0
121 SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopAsyncIteration);
122#else
123 struct Nuitka_ExceptionPreservationItem exception_state = {Nuitka_CreateStopAsyncIteration(tstate)};
124
125 RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
126#endif
127}
128
129#endif
130
131#if PYTHON_VERSION >= 0x3c0
132static PyObject *Nuitka_CreateGeneratorExit(PyThreadState *tstate) {
133 return (PyObject *)Nuitka_BaseExceptionSingleArg_new(tstate, (PyTypeObject *)PyExc_GeneratorExit, NULL);
134}
135#endif
136
137#if PYTHON_VERSION >= 0x300
138static void SET_CURRENT_EXCEPTION_GENERATOR_EXIT(PyThreadState *tstate) {
139#if PYTHON_VERSION < 0x3c0
140 SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_GeneratorExit);
141#else
142 struct Nuitka_ExceptionPreservationItem exception_state = {Nuitka_CreateGeneratorExit(tstate)};
143
144 RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
145#endif
146}
147#endif
148
149#if PYTHON_VERSION >= 0x300
150static bool Nuitka_PyGen_FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue) {
151#if PYTHON_VERSION < 0x3c0
152 if (!HAS_ERROR_OCCURRED(tstate)) {
153 *pvalue = Py_None;
154 Py_INCREF_IMMORTAL(Py_None);
155
156 return true;
157 } else if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, tstate->curexc_type, PyExc_StopIteration)) {
158 PyObject *value = NULL;
159
160 PyObject *exception_type, *exception_value;
161 PyTracebackObject *exception_tb;
162
163 FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
164
165 if (exception_value) {
166 // TODO: API call here should be eliminated.
167 if (PyObject_TypeCheck(exception_value, (PyTypeObject *)exception_type)) {
168 value = ((PyStopIterationObject *)exception_value)->value;
169 Py_INCREF(value);
170 Py_DECREF(exception_value);
171 } else if (exception_type == PyExc_StopIteration && !PyTuple_Check(exception_value)) {
172 value = exception_value;
173 } else {
174 NORMALIZE_EXCEPTION(tstate, &exception_type, &exception_value, &exception_tb);
175
176 if (!PyObject_TypeCheck(exception_value, (PyTypeObject *)PyExc_StopIteration)) {
177 RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
178
179 return false;
180 }
181
182 value = ((PyStopIterationObject *)exception_value)->value;
183 Py_INCREF(value);
184
185 Py_DECREF(exception_value);
186 }
187 }
188
189 Py_XDECREF(exception_type);
190 Py_XDECREF(exception_tb);
191
192 if (value == NULL) {
193 value = Py_None;
194 Py_INCREF(value);
195 }
196
197 *pvalue = value;
198
199 return true;
200 } else {
201 return false;
202 }
203#else
204 if (!HAS_ERROR_OCCURRED(tstate)) {
205 *pvalue = Py_None;
206 Py_INCREF_IMMORTAL(Py_None);
207
208 return true;
209 } else if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, tstate->current_exception, PyExc_StopIteration)) {
210 PyObject *value = NULL;
211
212 PyObject *exc = tstate->current_exception;
213 tstate->current_exception = NULL;
214
215 value = Py_NewRef(((PyStopIterationObject *)exc)->value);
216 Py_DECREF(exc);
217
218 if (value == NULL) {
219 value = Py_None;
220 }
221
222 *pvalue = value;
223
224 return true;
225
226 } else {
227 return false;
228 }
229#endif
230}
231#endif
232
233#if PYTHON_VERSION >= 0x370
234static inline void Nuitka_PyGen_exc_state_clear(_PyErr_StackItem *exc_state) {
235#if PYTHON_VERSION < 0x3b0
236 PyObject *t = exc_state->exc_type;
237#endif
238 PyObject *v = exc_state->exc_value;
239#if PYTHON_VERSION < 0x3b0
240 PyObject *tb = exc_state->exc_traceback;
241#endif
242
243#if PYTHON_VERSION < 0x3b0
244 exc_state->exc_type = NULL;
245#endif
246 exc_state->exc_value = NULL;
247#if PYTHON_VERSION < 0x3b0
248 exc_state->exc_traceback = NULL;
249#endif
250
251#if PYTHON_VERSION < 0x3b0
252 Py_XDECREF(t);
253#endif
254 Py_XDECREF(v);
255#if PYTHON_VERSION < 0x3b0
256 Py_XDECREF(tb);
257#endif
258}
259#endif
260
261#if PYTHON_VERSION >= 0x300
262
263#if PYTHON_VERSION < 0x3b0
264static inline bool Nuitka_PyFrameHasCompleted(PyFrameObject *const frame) {
265#if PYTHON_VERSION < 0x3a0
266 return frame->f_stacktop == NULL;
267#else
268 return frame->f_state > FRAME_EXECUTING;
269#endif
270}
271#endif
272
273#if PYTHON_VERSION >= 0x3d0
274// TODO: For performance, expand this for pre-3.13 as well
275static void Nuitka_PyErr_ChainStackItem(PyThreadState *tstate) {
276 assert(HAS_ERROR_OCCURRED(tstate));
277
278 _PyErr_StackItem *exc_info = tstate->exc_info;
279 PyObject *handled_exception = exc_info->exc_value;
280
281 if (handled_exception == NULL || handled_exception == Py_None) {
282 return;
283 }
284
285 PyObject *current_exception = tstate->current_exception;
286 ASSERT_NORMALIZED_EXCEPTION_VALUE(current_exception);
287
288 if (handled_exception == current_exception) {
289 return;
290 }
291
292 PyObject *chain_exception = current_exception;
293
294 while (true) {
295 PyObject *context = Nuitka_Exception_GetContext(chain_exception);
296 if (context == NULL) {
297 break;
298 }
299
300 CHECK_OBJECT(context);
301
302 if (context == handled_exception) {
303 Nuitka_Exception_DeleteContext(chain_exception);
304 break;
305 }
306
307 chain_exception = context;
308 }
309
310 Nuitka_Exception_SetContext(current_exception, handled_exception);
311}
312#endif
313
314// This is for CPython iterator objects, the respective code is not exported as
315// API, so we need to redo it. This is an re-implementation that closely follows
316// what it does. It's unrelated to compiled generators, and used from coroutines
317// and asyncgen to interact with them.
318static PyObject *Nuitka_PyGen_Send(PyThreadState *tstate, PyGenObject *gen, PyObject *arg) {
319#if PYTHON_VERSION >= 0x3a0
320 PyObject *result;
321
322 // TODO: Avoid API call for performance.
323 PySendResult res = PyIter_Send((PyObject *)gen, arg, &result);
324
325 switch (res) {
326 case PYGEN_RETURN:
327 if (result == NULL) {
328 SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
329 } else {
330 if (result != Py_None) {
331 Nuitka_SetStopIterationValue(tstate, result);
332 }
333
334 Py_DECREF(result);
335 }
336
337 return NULL;
338 case PYGEN_NEXT:
339 return result;
340 case PYGEN_ERROR:
341 return NULL;
342 default:
343 NUITKA_CANNOT_GET_HERE("invalid PYGEN_ result");
344 }
345#else
346
347 PyFrameObject *f = gen->gi_frame;
348
349#if PYTHON_VERSION >= 0x3b0
350 if (gen->gi_frame_state == FRAME_EXECUTING) {
351#elif PYTHON_VERSION >= 0x3a0
352 if (f != NULL && _PyFrame_IsExecuting(f)) {
353#else
354 if (unlikely(gen->gi_running)) {
355#endif
356 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "generator already executing");
357 return NULL;
358 }
359
360#if PYTHON_VERSION < 0x3b0
361 if (f == NULL || Nuitka_PyFrameHasCompleted(f)) {
362#else
363 if (gen->gi_frame_state >= FRAME_COMPLETED) {
364#endif
365 // Set exception if called from send()
366 if (arg != NULL) {
367 SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
368 }
369
370 return NULL;
371 }
372
373#if PYTHON_VERSION < 0x3a0
374 if (f->f_lasti == -1) {
375 if (unlikely(arg && arg != Py_None)) {
376 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError,
377 "can't send non-None value to a just-started generator");
378
379 return NULL;
380 }
381 } else {
382 // Put arg on top of the value stack
383 PyObject *tmp = arg ? arg : Py_None;
384
385 Py_INCREF(tmp);
386 *(f->f_stacktop++) = tmp;
387 }
388#else
389 // CPython assertions, check them
390 assert(_PyFrame_IsRunnable(f));
391 assert(f->f_lasti >= 0 || ((unsigned char *)PyBytes_AS_STRING(f->f_code->co_code))[0] == 129);
392
393 PyObject *gen_result = arg ? arg : Py_None;
394 Py_INCREF(gen_result);
395 gen->gi_frame->f_valuestack[gen->gi_frame->f_stackdepth] = gen_result;
396 gen->gi_frame->f_stackdepth++;
397#endif
398
399 // Generators always return to their most recent caller, not necessarily
400 // their creator.
401 tstate = PyThreadState_GET();
402 Py_XINCREF(tstate->frame);
403
404 f->f_back = tstate->frame;
405
406#if PYTHON_VERSION < 0x3a0
407 gen->gi_running = 1;
408#endif
409#if PYTHON_VERSION >= 0x370
410 gen->gi_exc_state.previous_item = tstate->exc_info;
411 tstate->exc_info = &gen->gi_exc_state;
412#endif
413
414#if PYTHON_VERSION < 0x390
415 PyObject *result = PyEval_EvalFrameEx(f, 0);
416#else
417 PyObject *result = _PyEval_EvalFrame(tstate, f, 0);
418#endif
419
420#if PYTHON_VERSION >= 0x370
421 tstate->exc_info = gen->gi_exc_state.previous_item;
422 gen->gi_exc_state.previous_item = NULL;
423#endif
424#if PYTHON_VERSION < 0x3a0
425 gen->gi_running = 0;
426#endif
427
428 // Don't keep the reference to f_back any longer than necessary. It
429 // may keep a chain of frames alive or it could create a reference
430 // cycle.
431 Py_CLEAR(f->f_back);
432
433 // If the generator just returned (as opposed to yielding), signal that the
434 // generator is exhausted.
435#if PYTHON_VERSION < 0x3a0
436 if (result && f->f_stacktop == NULL) {
437 if (result == Py_None) {
438 SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
439 } else {
440 PyObject *e = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, (PyObject *)PyExc_StopIteration, result);
441
442 if (likely(e != NULL)) {
443 SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_StopIteration, e);
444 }
445 }
446
447 Py_CLEAR(result);
448 }
449
450 if (result == NULL || f->f_stacktop == NULL) {
451#if PYTHON_VERSION < 0x370
452 // Generator is finished, remove exception from frame before releasing
453 // it.
454 PyObject *type = f->f_exc_type;
455 PyObject *value = f->f_exc_value;
456 PyObject *traceback = f->f_exc_traceback;
457 f->f_exc_type = NULL;
458 f->f_exc_value = NULL;
459 f->f_exc_traceback = NULL;
460 Py_XDECREF(type);
461 Py_XDECREF(value);
462 Py_XDECREF(traceback);
463#else
464 Nuitka_PyGen_exc_state_clear(&gen->gi_exc_state);
465#endif
466
467 // Now release frame.
468#if PYTHON_VERSION >= 0x300
469 gen->gi_frame->f_gen = NULL;
470#endif
471 gen->gi_frame = NULL;
472 Py_DECREF(f);
473 }
474#else
475 if (result) {
476 if (!_PyFrameHasCompleted(f)) {
477 return result;
478 }
479 assert(result == Py_None || !PyAsyncGen_CheckExact(gen));
480
481 if (result == Py_None && !PyAsyncGen_CheckExact(gen)) {
482 Py_DECREF_IMMORTAL(result);
483 result = NULL;
484 }
485 } else {
486 if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
487 const char *msg = "generator raised StopIteration";
488 if (PyCoro_CheckExact(gen)) {
489 msg = "coroutine raised StopIteration";
490 } else if (PyAsyncGen_CheckExact(gen)) {
491 msg = "async generator raised StopIteration";
492 }
493 _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
494 } else if (PyAsyncGen_CheckExact(gen) && PyErr_ExceptionMatches(PyExc_StopAsyncIteration)) {
495 const char *msg = "async generator raised StopAsyncIteration";
496 _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
497 }
498
499 result = NULL;
500 }
501
502 Nuitka_PyGen_exc_state_clear(&gen->gi_exc_state);
503
504 gen->gi_frame->f_gen = NULL;
505 gen->gi_frame = NULL;
506
507 Py_DECREF(f);
508
509#endif
510
511 return result;
512#endif
513}
514
515#endif
516
517// Not done for Python2, indicate usability for compiled generators, but it
518// seems that mostly coroutines need it anyway, so the benefit would be only for
519// performance and not by a lot.
520#if PYTHON_VERSION >= 0x300
521#define NUITKA_UNCOMPILED_THROW_INTEGRATION 1
522#endif
523
524#if NUITKA_UNCOMPILED_THROW_INTEGRATION
525
526static bool _Nuitka_Generator_check_throw(PyThreadState *tstate,
527 struct Nuitka_ExceptionPreservationItem *exception_state);
528
529#if PYTHON_VERSION < 0x3b0
530#include <opcode.h>
531// Clashes with our helper names.
532#undef CALL_FUNCTION
533#endif
534
535static PyObject *Nuitka_PyGen_gen_close(PyThreadState *tstate, PyGenObject *gen, PyObject *args);
536static int Nuitka_PyGen_gen_close_iter(PyThreadState *tstate, PyObject *yf);
537
538// Restarting with 3.11, because the structures and internal API have
539// changed so much, makes no sense to keep it in one code. For older
540// versions, the else branch is there.
541#if PYTHON_VERSION >= 0x3b0
542
543// Private opcode mapping, that we need too
544const uint8_t Nuitka_PyOpcode_Deopt[256] = {
545#if PYTHON_VERSION >= 0x3e0
546 [121] = 121,
547 [122] = 122,
548 [123] = 123,
549 [124] = 124,
550 [125] = 125,
551 [126] = 126,
552 [127] = 127,
553 [212] = 212,
554 [213] = 213,
555 [214] = 214,
556 [215] = 215,
557 [216] = 216,
558 [217] = 217,
559 [218] = 218,
560 [219] = 219,
561 [220] = 220,
562 [221] = 221,
563 [222] = 222,
564 [223] = 223,
565 [224] = 224,
566 [225] = 225,
567 [226] = 226,
568 [227] = 227,
569 [228] = 228,
570 [229] = 229,
571 [230] = 230,
572 [231] = 231,
573 [232] = 232,
574 [233] = 233,
575 [BINARY_OP] = BINARY_OP,
576 [BINARY_OP_ADD_FLOAT] = BINARY_OP,
577 [BINARY_OP_ADD_INT] = BINARY_OP,
578 [BINARY_OP_ADD_UNICODE] = BINARY_OP,
579 [BINARY_OP_EXTEND] = BINARY_OP,
580 [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP,
581 [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP,
582 [BINARY_OP_MULTIPLY_INT] = BINARY_OP,
583 [BINARY_OP_SUBSCR_DICT] = BINARY_OP,
584 [BINARY_OP_SUBSCR_GETITEM] = BINARY_OP,
585 [BINARY_OP_SUBSCR_LIST_INT] = BINARY_OP,
586 [BINARY_OP_SUBSCR_LIST_SLICE] = BINARY_OP,
587 [BINARY_OP_SUBSCR_STR_INT] = BINARY_OP,
588 [BINARY_OP_SUBSCR_TUPLE_INT] = BINARY_OP,
589 [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP,
590 [BINARY_OP_SUBTRACT_INT] = BINARY_OP,
591 [BINARY_SLICE] = BINARY_SLICE,
592 [BUILD_INTERPOLATION] = BUILD_INTERPOLATION,
593 [BUILD_LIST] = BUILD_LIST,
594 [BUILD_MAP] = BUILD_MAP,
595 [BUILD_SET] = BUILD_SET,
596 [BUILD_SLICE] = BUILD_SLICE,
597 [BUILD_STRING] = BUILD_STRING,
598 [BUILD_TEMPLATE] = BUILD_TEMPLATE,
599 [BUILD_TUPLE] = BUILD_TUPLE,
600 [CACHE] = CACHE,
601 [CALL] = CALL,
602 [CALL_ALLOC_AND_ENTER_INIT] = CALL,
603 [CALL_BOUND_METHOD_EXACT_ARGS] = CALL,
604 [CALL_BOUND_METHOD_GENERAL] = CALL,
605 [CALL_BUILTIN_CLASS] = CALL,
606 [CALL_BUILTIN_FAST] = CALL,
607 [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL,
608 [CALL_BUILTIN_O] = CALL,
609 [CALL_FUNCTION_EX] = CALL_FUNCTION_EX,
610 [CALL_INTRINSIC_1] = CALL_INTRINSIC_1,
611 [CALL_INTRINSIC_2] = CALL_INTRINSIC_2,
612 [CALL_ISINSTANCE] = CALL,
613 [CALL_KW] = CALL_KW,
614 [CALL_KW_BOUND_METHOD] = CALL_KW,
615 [CALL_KW_NON_PY] = CALL_KW,
616 [CALL_KW_PY] = CALL_KW,
617 [CALL_LEN] = CALL,
618 [CALL_LIST_APPEND] = CALL,
619 [CALL_METHOD_DESCRIPTOR_FAST] = CALL,
620 [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL,
621 [CALL_METHOD_DESCRIPTOR_NOARGS] = CALL,
622 [CALL_METHOD_DESCRIPTOR_O] = CALL,
623 [CALL_NON_PY_GENERAL] = CALL,
624 [CALL_PY_EXACT_ARGS] = CALL,
625 [CALL_PY_GENERAL] = CALL,
626 [CALL_STR_1] = CALL,
627 [CALL_TUPLE_1] = CALL,
628 [CALL_TYPE_1] = CALL,
629 [CHECK_EG_MATCH] = CHECK_EG_MATCH,
630 [CHECK_EXC_MATCH] = CHECK_EXC_MATCH,
631 [CLEANUP_THROW] = CLEANUP_THROW,
632 [COMPARE_OP] = COMPARE_OP,
633 [COMPARE_OP_FLOAT] = COMPARE_OP,
634 [COMPARE_OP_INT] = COMPARE_OP,
635 [COMPARE_OP_STR] = COMPARE_OP,
636 [CONTAINS_OP] = CONTAINS_OP,
637 [CONTAINS_OP_DICT] = CONTAINS_OP,
638 [CONTAINS_OP_SET] = CONTAINS_OP,
639 [CONVERT_VALUE] = CONVERT_VALUE,
640 [COPY] = COPY,
641 [COPY_FREE_VARS] = COPY_FREE_VARS,
642 [DELETE_ATTR] = DELETE_ATTR,
643 [DELETE_DEREF] = DELETE_DEREF,
644 [DELETE_FAST] = DELETE_FAST,
645 [DELETE_GLOBAL] = DELETE_GLOBAL,
646 [DELETE_NAME] = DELETE_NAME,
647 [DELETE_SUBSCR] = DELETE_SUBSCR,
648 [DICT_MERGE] = DICT_MERGE,
649 [DICT_UPDATE] = DICT_UPDATE,
650 [END_ASYNC_FOR] = END_ASYNC_FOR,
651 [END_FOR] = END_FOR,
652 [END_SEND] = END_SEND,
653 [ENTER_EXECUTOR] = ENTER_EXECUTOR,
654 [EXIT_INIT_CHECK] = EXIT_INIT_CHECK,
655 [EXTENDED_ARG] = EXTENDED_ARG,
656 [FORMAT_SIMPLE] = FORMAT_SIMPLE,
657 [FORMAT_WITH_SPEC] = FORMAT_WITH_SPEC,
658 [FOR_ITER] = FOR_ITER,
659 [FOR_ITER_GEN] = FOR_ITER,
660 [FOR_ITER_LIST] = FOR_ITER,
661 [FOR_ITER_RANGE] = FOR_ITER,
662 [FOR_ITER_TUPLE] = FOR_ITER,
663 [GET_AITER] = GET_AITER,
664 [GET_ANEXT] = GET_ANEXT,
665 [GET_AWAITABLE] = GET_AWAITABLE,
666 [GET_ITER] = GET_ITER,
667 [GET_LEN] = GET_LEN,
668 [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER,
669 [IMPORT_FROM] = IMPORT_FROM,
670 [IMPORT_NAME] = IMPORT_NAME,
671 [INSTRUMENTED_CALL] = INSTRUMENTED_CALL,
672 [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX,
673 [INSTRUMENTED_CALL_KW] = INSTRUMENTED_CALL_KW,
674 [INSTRUMENTED_END_ASYNC_FOR] = INSTRUMENTED_END_ASYNC_FOR,
675 [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR,
676 [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND,
677 [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER,
678 [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION,
679 [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD,
680 [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD,
681 [INSTRUMENTED_LINE] = INSTRUMENTED_LINE,
682 [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR,
683 [INSTRUMENTED_NOT_TAKEN] = INSTRUMENTED_NOT_TAKEN,
684 [INSTRUMENTED_POP_ITER] = INSTRUMENTED_POP_ITER,
685 [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE,
686 [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE,
687 [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE,
688 [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE,
689 [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME,
690 [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE,
691 [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE,
692 [INTERPRETER_EXIT] = INTERPRETER_EXIT,
693 [IS_OP] = IS_OP,
694 [JUMP_BACKWARD] = JUMP_BACKWARD,
695 [JUMP_BACKWARD_JIT] = JUMP_BACKWARD,
696 [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT,
697 [JUMP_BACKWARD_NO_JIT] = JUMP_BACKWARD,
698 [JUMP_FORWARD] = JUMP_FORWARD,
699 [LIST_APPEND] = LIST_APPEND,
700 [LIST_EXTEND] = LIST_EXTEND,
701 [LOAD_ATTR] = LOAD_ATTR,
702 [LOAD_ATTR_CLASS] = LOAD_ATTR,
703 [LOAD_ATTR_CLASS_WITH_METACLASS_CHECK] = LOAD_ATTR,
704 [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR,
705 [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR,
706 [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR,
707 [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR,
708 [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR,
709 [LOAD_ATTR_MODULE] = LOAD_ATTR,
710 [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = LOAD_ATTR,
711 [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = LOAD_ATTR,
712 [LOAD_ATTR_PROPERTY] = LOAD_ATTR,
713 [LOAD_ATTR_SLOT] = LOAD_ATTR,
714 [LOAD_ATTR_WITH_HINT] = LOAD_ATTR,
715 [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS,
716 [LOAD_COMMON_CONSTANT] = LOAD_COMMON_CONSTANT,
717 [LOAD_CONST] = LOAD_CONST,
718 [LOAD_CONST_IMMORTAL] = LOAD_CONST,
719 [LOAD_CONST_MORTAL] = LOAD_CONST,
720 [LOAD_DEREF] = LOAD_DEREF,
721 [LOAD_FAST] = LOAD_FAST,
722 [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR,
723 [LOAD_FAST_BORROW] = LOAD_FAST_BORROW,
724 [LOAD_FAST_BORROW_LOAD_FAST_BORROW] = LOAD_FAST_BORROW_LOAD_FAST_BORROW,
725 [LOAD_FAST_CHECK] = LOAD_FAST_CHECK,
726 [LOAD_FAST_LOAD_FAST] = LOAD_FAST_LOAD_FAST,
727 [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF,
728 [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS,
729 [LOAD_GLOBAL] = LOAD_GLOBAL,
730 [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL,
731 [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL,
732 [LOAD_LOCALS] = LOAD_LOCALS,
733 [LOAD_NAME] = LOAD_NAME,
734 [LOAD_SMALL_INT] = LOAD_SMALL_INT,
735 [LOAD_SPECIAL] = LOAD_SPECIAL,
736 [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR,
737 [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR,
738 [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR,
739 [MAKE_CELL] = MAKE_CELL,
740 [MAKE_FUNCTION] = MAKE_FUNCTION,
741 [MAP_ADD] = MAP_ADD,
742 [MATCH_CLASS] = MATCH_CLASS,
743 [MATCH_KEYS] = MATCH_KEYS,
744 [MATCH_MAPPING] = MATCH_MAPPING,
745 [MATCH_SEQUENCE] = MATCH_SEQUENCE,
746 [NOP] = NOP,
747 [NOT_TAKEN] = NOT_TAKEN,
748 [POP_EXCEPT] = POP_EXCEPT,
749 [POP_ITER] = POP_ITER,
750 [POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE,
751 [POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE,
752 [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE,
753 [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE,
754 [POP_TOP] = POP_TOP,
755 [PUSH_EXC_INFO] = PUSH_EXC_INFO,
756 [PUSH_NULL] = PUSH_NULL,
757 [RAISE_VARARGS] = RAISE_VARARGS,
758 [RERAISE] = RERAISE,
759 [RESERVED] = RESERVED,
760 [RESUME] = RESUME,
761 [RESUME_CHECK] = RESUME,
762 [RETURN_GENERATOR] = RETURN_GENERATOR,
763 [RETURN_VALUE] = RETURN_VALUE,
764 [SEND] = SEND,
765 [SEND_GEN] = SEND,
766 [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS,
767 [SET_ADD] = SET_ADD,
768 [SET_FUNCTION_ATTRIBUTE] = SET_FUNCTION_ATTRIBUTE,
769 [SET_UPDATE] = SET_UPDATE,
770 [STORE_ATTR] = STORE_ATTR,
771 [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR,
772 [STORE_ATTR_SLOT] = STORE_ATTR,
773 [STORE_ATTR_WITH_HINT] = STORE_ATTR,
774 [STORE_DEREF] = STORE_DEREF,
775 [STORE_FAST] = STORE_FAST,
776 [STORE_FAST_LOAD_FAST] = STORE_FAST_LOAD_FAST,
777 [STORE_FAST_STORE_FAST] = STORE_FAST_STORE_FAST,
778 [STORE_GLOBAL] = STORE_GLOBAL,
779 [STORE_NAME] = STORE_NAME,
780 [STORE_SLICE] = STORE_SLICE,
781 [STORE_SUBSCR] = STORE_SUBSCR,
782 [STORE_SUBSCR_DICT] = STORE_SUBSCR,
783 [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR,
784 [SWAP] = SWAP,
785 [TO_BOOL] = TO_BOOL,
786 [TO_BOOL_ALWAYS_TRUE] = TO_BOOL,
787 [TO_BOOL_BOOL] = TO_BOOL,
788 [TO_BOOL_INT] = TO_BOOL,
789 [TO_BOOL_LIST] = TO_BOOL,
790 [TO_BOOL_NONE] = TO_BOOL,
791 [TO_BOOL_STR] = TO_BOOL,
792 [UNARY_INVERT] = UNARY_INVERT,
793 [UNARY_NEGATIVE] = UNARY_NEGATIVE,
794 [UNARY_NOT] = UNARY_NOT,
795 [UNPACK_EX] = UNPACK_EX,
796 [UNPACK_SEQUENCE] = UNPACK_SEQUENCE,
797 [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE,
798 [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE,
799 [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE,
800 [WITH_EXCEPT_START] = WITH_EXCEPT_START,
801 [YIELD_VALUE] = YIELD_VALUE,
802#elif PYTHON_VERSION >= 0x3d0
803 [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH,
804 [BEFORE_WITH] = BEFORE_WITH,
805 [BINARY_OP] = BINARY_OP,
806 [BINARY_OP_ADD_FLOAT] = BINARY_OP,
807 [BINARY_OP_ADD_INT] = BINARY_OP,
808 [BINARY_OP_ADD_UNICODE] = BINARY_OP,
809 [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP,
810 [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP,
811 [BINARY_OP_MULTIPLY_INT] = BINARY_OP,
812 [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP,
813 [BINARY_OP_SUBTRACT_INT] = BINARY_OP,
814 [BINARY_SLICE] = BINARY_SLICE,
815 [BINARY_SUBSCR] = BINARY_SUBSCR,
816 [BINARY_SUBSCR_DICT] = BINARY_SUBSCR,
817 [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR,
818 [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR,
819 [BINARY_SUBSCR_STR_INT] = BINARY_SUBSCR,
820 [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR,
821 [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP,
822 [BUILD_LIST] = BUILD_LIST,
823 [BUILD_MAP] = BUILD_MAP,
824 [BUILD_SET] = BUILD_SET,
825 [BUILD_SLICE] = BUILD_SLICE,
826 [BUILD_STRING] = BUILD_STRING,
827 [BUILD_TUPLE] = BUILD_TUPLE,
828 [CACHE] = CACHE,
829 [CALL] = CALL,
830 [CALL_ALLOC_AND_ENTER_INIT] = CALL,
831 [CALL_BOUND_METHOD_EXACT_ARGS] = CALL,
832 [CALL_BOUND_METHOD_GENERAL] = CALL,
833 [CALL_BUILTIN_CLASS] = CALL,
834 [CALL_BUILTIN_FAST] = CALL,
835 [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL,
836 [CALL_BUILTIN_O] = CALL,
837 [CALL_FUNCTION_EX] = CALL_FUNCTION_EX,
838 [CALL_INTRINSIC_1] = CALL_INTRINSIC_1,
839 [CALL_INTRINSIC_2] = CALL_INTRINSIC_2,
840 [CALL_ISINSTANCE] = CALL,
841 [CALL_KW] = CALL_KW,
842 [CALL_LEN] = CALL,
843 [CALL_LIST_APPEND] = CALL,
844 [CALL_METHOD_DESCRIPTOR_FAST] = CALL,
845 [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL,
846 [CALL_METHOD_DESCRIPTOR_NOARGS] = CALL,
847 [CALL_METHOD_DESCRIPTOR_O] = CALL,
848 [CALL_NON_PY_GENERAL] = CALL,
849 [CALL_PY_EXACT_ARGS] = CALL,
850 [CALL_PY_GENERAL] = CALL,
851 [CALL_STR_1] = CALL,
852 [CALL_TUPLE_1] = CALL,
853 [CALL_TYPE_1] = CALL,
854 [CHECK_EG_MATCH] = CHECK_EG_MATCH,
855 [CHECK_EXC_MATCH] = CHECK_EXC_MATCH,
856 [CLEANUP_THROW] = CLEANUP_THROW,
857 [COMPARE_OP] = COMPARE_OP,
858 [COMPARE_OP_FLOAT] = COMPARE_OP,
859 [COMPARE_OP_INT] = COMPARE_OP,
860 [COMPARE_OP_STR] = COMPARE_OP,
861 [CONTAINS_OP] = CONTAINS_OP,
862 [CONTAINS_OP_DICT] = CONTAINS_OP,
863 [CONTAINS_OP_SET] = CONTAINS_OP,
864 [CONVERT_VALUE] = CONVERT_VALUE,
865 [COPY] = COPY,
866 [COPY_FREE_VARS] = COPY_FREE_VARS,
867 [DELETE_ATTR] = DELETE_ATTR,
868 [DELETE_DEREF] = DELETE_DEREF,
869 [DELETE_FAST] = DELETE_FAST,
870 [DELETE_GLOBAL] = DELETE_GLOBAL,
871 [DELETE_NAME] = DELETE_NAME,
872 [DELETE_SUBSCR] = DELETE_SUBSCR,
873 [DICT_MERGE] = DICT_MERGE,
874 [DICT_UPDATE] = DICT_UPDATE,
875 [END_ASYNC_FOR] = END_ASYNC_FOR,
876 [END_FOR] = END_FOR,
877 [END_SEND] = END_SEND,
878 [ENTER_EXECUTOR] = ENTER_EXECUTOR,
879 [EXIT_INIT_CHECK] = EXIT_INIT_CHECK,
880 [EXTENDED_ARG] = EXTENDED_ARG,
881 [FORMAT_SIMPLE] = FORMAT_SIMPLE,
882 [FORMAT_WITH_SPEC] = FORMAT_WITH_SPEC,
883 [FOR_ITER] = FOR_ITER,
884 [FOR_ITER_GEN] = FOR_ITER,
885 [FOR_ITER_LIST] = FOR_ITER,
886 [FOR_ITER_RANGE] = FOR_ITER,
887 [FOR_ITER_TUPLE] = FOR_ITER,
888 [GET_AITER] = GET_AITER,
889 [GET_ANEXT] = GET_ANEXT,
890 [GET_AWAITABLE] = GET_AWAITABLE,
891 [GET_ITER] = GET_ITER,
892 [GET_LEN] = GET_LEN,
893 [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER,
894 [IMPORT_FROM] = IMPORT_FROM,
895 [IMPORT_NAME] = IMPORT_NAME,
896 [INSTRUMENTED_CALL] = INSTRUMENTED_CALL,
897 [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX,
898 [INSTRUMENTED_CALL_KW] = INSTRUMENTED_CALL_KW,
899 [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR,
900 [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND,
901 [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER,
902 [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION,
903 [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD,
904 [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD,
905 [INSTRUMENTED_LINE] = INSTRUMENTED_LINE,
906 [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR,
907 [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE,
908 [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE,
909 [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE,
910 [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE,
911 [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME,
912 [INSTRUMENTED_RETURN_CONST] = INSTRUMENTED_RETURN_CONST,
913 [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE,
914 [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE,
915 [INTERPRETER_EXIT] = INTERPRETER_EXIT,
916 [IS_OP] = IS_OP,
917 [JUMP_BACKWARD] = JUMP_BACKWARD,
918 [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT,
919 [JUMP_FORWARD] = JUMP_FORWARD,
920 [LIST_APPEND] = LIST_APPEND,
921 [LIST_EXTEND] = LIST_EXTEND,
922 [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR,
923 [LOAD_ATTR] = LOAD_ATTR,
924 [LOAD_ATTR_CLASS] = LOAD_ATTR,
925 [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR,
926 [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR,
927 [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR,
928 [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR,
929 [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR,
930 [LOAD_ATTR_MODULE] = LOAD_ATTR,
931 [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = LOAD_ATTR,
932 [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = LOAD_ATTR,
933 [LOAD_ATTR_PROPERTY] = LOAD_ATTR,
934 [LOAD_ATTR_SLOT] = LOAD_ATTR,
935 [LOAD_ATTR_WITH_HINT] = LOAD_ATTR,
936 [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS,
937 [LOAD_CONST] = LOAD_CONST,
938 [LOAD_DEREF] = LOAD_DEREF,
939 [LOAD_FAST] = LOAD_FAST,
940 [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR,
941 [LOAD_FAST_CHECK] = LOAD_FAST_CHECK,
942 [LOAD_FAST_LOAD_FAST] = LOAD_FAST_LOAD_FAST,
943 [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF,
944 [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS,
945 [LOAD_GLOBAL] = LOAD_GLOBAL,
946 [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL,
947 [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL,
948 [LOAD_LOCALS] = LOAD_LOCALS,
949 [LOAD_NAME] = LOAD_NAME,
950 [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR,
951 [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR,
952 [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR,
953 [MAKE_CELL] = MAKE_CELL,
954 [MAKE_FUNCTION] = MAKE_FUNCTION,
955 [MAP_ADD] = MAP_ADD,
956 [MATCH_CLASS] = MATCH_CLASS,
957 [MATCH_KEYS] = MATCH_KEYS,
958 [MATCH_MAPPING] = MATCH_MAPPING,
959 [MATCH_SEQUENCE] = MATCH_SEQUENCE,
960 [NOP] = NOP,
961 [POP_EXCEPT] = POP_EXCEPT,
962 [POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE,
963 [POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE,
964 [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE,
965 [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE,
966 [POP_TOP] = POP_TOP,
967 [PUSH_EXC_INFO] = PUSH_EXC_INFO,
968 [PUSH_NULL] = PUSH_NULL,
969 [RAISE_VARARGS] = RAISE_VARARGS,
970 [RERAISE] = RERAISE,
971 [RESERVED] = RESERVED,
972 [RESUME] = RESUME,
973 [RESUME_CHECK] = RESUME,
974 [RETURN_CONST] = RETURN_CONST,
975 [RETURN_GENERATOR] = RETURN_GENERATOR,
976 [RETURN_VALUE] = RETURN_VALUE,
977 [SEND] = SEND,
978 [SEND_GEN] = SEND,
979 [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS,
980 [SET_ADD] = SET_ADD,
981 [SET_FUNCTION_ATTRIBUTE] = SET_FUNCTION_ATTRIBUTE,
982 [SET_UPDATE] = SET_UPDATE,
983 [STORE_ATTR] = STORE_ATTR,
984 [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR,
985 [STORE_ATTR_SLOT] = STORE_ATTR,
986 [STORE_ATTR_WITH_HINT] = STORE_ATTR,
987 [STORE_DEREF] = STORE_DEREF,
988 [STORE_FAST] = STORE_FAST,
989 [STORE_FAST_LOAD_FAST] = STORE_FAST_LOAD_FAST,
990 [STORE_FAST_STORE_FAST] = STORE_FAST_STORE_FAST,
991 [STORE_GLOBAL] = STORE_GLOBAL,
992 [STORE_NAME] = STORE_NAME,
993 [STORE_SLICE] = STORE_SLICE,
994 [STORE_SUBSCR] = STORE_SUBSCR,
995 [STORE_SUBSCR_DICT] = STORE_SUBSCR,
996 [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR,
997 [SWAP] = SWAP,
998 [TO_BOOL] = TO_BOOL,
999 [TO_BOOL_ALWAYS_TRUE] = TO_BOOL,
1000 [TO_BOOL_BOOL] = TO_BOOL,
1001 [TO_BOOL_INT] = TO_BOOL,
1002 [TO_BOOL_LIST] = TO_BOOL,
1003 [TO_BOOL_NONE] = TO_BOOL,
1004 [TO_BOOL_STR] = TO_BOOL,
1005 [UNARY_INVERT] = UNARY_INVERT,
1006 [UNARY_NEGATIVE] = UNARY_NEGATIVE,
1007 [UNARY_NOT] = UNARY_NOT,
1008 [UNPACK_EX] = UNPACK_EX,
1009 [UNPACK_SEQUENCE] = UNPACK_SEQUENCE,
1010 [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE,
1011 [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE,
1012 [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE,
1013 [WITH_EXCEPT_START] = WITH_EXCEPT_START,
1014 [YIELD_VALUE] = YIELD_VALUE,
1015#elif PYTHON_VERSION >= 0x3c0
1016 [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH,
1017 [BEFORE_WITH] = BEFORE_WITH,
1018 [BINARY_OP] = BINARY_OP,
1019 [BINARY_OP_ADD_FLOAT] = BINARY_OP,
1020 [BINARY_OP_ADD_INT] = BINARY_OP,
1021 [BINARY_OP_ADD_UNICODE] = BINARY_OP,
1022 [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP,
1023 [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP,
1024 [BINARY_OP_MULTIPLY_INT] = BINARY_OP,
1025 [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP,
1026 [BINARY_OP_SUBTRACT_INT] = BINARY_OP,
1027 [BINARY_SLICE] = BINARY_SLICE,
1028 [BINARY_SUBSCR] = BINARY_SUBSCR,
1029 [BINARY_SUBSCR_DICT] = BINARY_SUBSCR,
1030 [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR,
1031 [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR,
1032 [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR,
1033 [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP,
1034 [BUILD_LIST] = BUILD_LIST,
1035 [BUILD_MAP] = BUILD_MAP,
1036 [BUILD_SET] = BUILD_SET,
1037 [BUILD_SLICE] = BUILD_SLICE,
1038 [BUILD_STRING] = BUILD_STRING,
1039 [BUILD_TUPLE] = BUILD_TUPLE,
1040 [CACHE] = CACHE,
1041 [CALL] = CALL,
1042 [CALL_BOUND_METHOD_EXACT_ARGS] = CALL,
1043 [CALL_BUILTIN_CLASS] = CALL,
1044 [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL,
1045 [CALL_FUNCTION_EX] = CALL_FUNCTION_EX,
1046 [CALL_INTRINSIC_1] = CALL_INTRINSIC_1,
1047 [CALL_INTRINSIC_2] = CALL_INTRINSIC_2,
1048 [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL,
1049 [CALL_NO_KW_BUILTIN_FAST] = CALL,
1050 [CALL_NO_KW_BUILTIN_O] = CALL,
1051 [CALL_NO_KW_ISINSTANCE] = CALL,
1052 [CALL_NO_KW_LEN] = CALL,
1053 [CALL_NO_KW_LIST_APPEND] = CALL,
1054 [CALL_NO_KW_METHOD_DESCRIPTOR_FAST] = CALL,
1055 [CALL_NO_KW_METHOD_DESCRIPTOR_NOARGS] = CALL,
1056 [CALL_NO_KW_METHOD_DESCRIPTOR_O] = CALL,
1057 [CALL_NO_KW_STR_1] = CALL,
1058 [CALL_NO_KW_TUPLE_1] = CALL,
1059 [CALL_NO_KW_TYPE_1] = CALL,
1060 [CALL_PY_EXACT_ARGS] = CALL,
1061 [CALL_PY_WITH_DEFAULTS] = CALL,
1062 [CHECK_EG_MATCH] = CHECK_EG_MATCH,
1063 [CHECK_EXC_MATCH] = CHECK_EXC_MATCH,
1064 [CLEANUP_THROW] = CLEANUP_THROW,
1065 [COMPARE_OP] = COMPARE_OP,
1066 [COMPARE_OP_FLOAT] = COMPARE_OP,
1067 [COMPARE_OP_INT] = COMPARE_OP,
1068 [COMPARE_OP_STR] = COMPARE_OP,
1069 [CONTAINS_OP] = CONTAINS_OP,
1070 [COPY] = COPY,
1071 [COPY_FREE_VARS] = COPY_FREE_VARS,
1072 [DELETE_ATTR] = DELETE_ATTR,
1073 [DELETE_DEREF] = DELETE_DEREF,
1074 [DELETE_FAST] = DELETE_FAST,
1075 [DELETE_GLOBAL] = DELETE_GLOBAL,
1076 [DELETE_NAME] = DELETE_NAME,
1077 [DELETE_SUBSCR] = DELETE_SUBSCR,
1078 [DICT_MERGE] = DICT_MERGE,
1079 [DICT_UPDATE] = DICT_UPDATE,
1080 [END_ASYNC_FOR] = END_ASYNC_FOR,
1081 [END_FOR] = END_FOR,
1082 [END_SEND] = END_SEND,
1083 [EXTENDED_ARG] = EXTENDED_ARG,
1084 [FORMAT_VALUE] = FORMAT_VALUE,
1085 [FOR_ITER] = FOR_ITER,
1086 [FOR_ITER_GEN] = FOR_ITER,
1087 [FOR_ITER_LIST] = FOR_ITER,
1088 [FOR_ITER_RANGE] = FOR_ITER,
1089 [FOR_ITER_TUPLE] = FOR_ITER,
1090 [GET_AITER] = GET_AITER,
1091 [GET_ANEXT] = GET_ANEXT,
1092 [GET_AWAITABLE] = GET_AWAITABLE,
1093 [GET_ITER] = GET_ITER,
1094 [GET_LEN] = GET_LEN,
1095 [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER,
1096 [IMPORT_FROM] = IMPORT_FROM,
1097 [IMPORT_NAME] = IMPORT_NAME,
1098 [INSTRUMENTED_CALL] = INSTRUMENTED_CALL,
1099 [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX,
1100 [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR,
1101 [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND,
1102 [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER,
1103 [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION,
1104 [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD,
1105 [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD,
1106 [INSTRUMENTED_LINE] = INSTRUMENTED_LINE,
1107 [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR,
1108 [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE,
1109 [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE,
1110 [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE,
1111 [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE,
1112 [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME,
1113 [INSTRUMENTED_RETURN_CONST] = INSTRUMENTED_RETURN_CONST,
1114 [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE,
1115 [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE,
1116 [INTERPRETER_EXIT] = INTERPRETER_EXIT,
1117 [IS_OP] = IS_OP,
1118 [JUMP_BACKWARD] = JUMP_BACKWARD,
1119 [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT,
1120 [JUMP_FORWARD] = JUMP_FORWARD,
1121 [KW_NAMES] = KW_NAMES,
1122 [LIST_APPEND] = LIST_APPEND,
1123 [LIST_EXTEND] = LIST_EXTEND,
1124 [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR,
1125 [LOAD_ATTR] = LOAD_ATTR,
1126 [LOAD_ATTR_CLASS] = LOAD_ATTR,
1127 [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR,
1128 [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR,
1129 [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR,
1130 [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR,
1131 [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR,
1132 [LOAD_ATTR_MODULE] = LOAD_ATTR,
1133 [LOAD_ATTR_PROPERTY] = LOAD_ATTR,
1134 [LOAD_ATTR_SLOT] = LOAD_ATTR,
1135 [LOAD_ATTR_WITH_HINT] = LOAD_ATTR,
1136 [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS,
1137 [LOAD_CLOSURE] = LOAD_CLOSURE,
1138 [LOAD_CONST] = LOAD_CONST,
1139 [LOAD_CONST__LOAD_FAST] = LOAD_CONST,
1140 [LOAD_DEREF] = LOAD_DEREF,
1141 [LOAD_FAST] = LOAD_FAST,
1142 [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR,
1143 [LOAD_FAST_CHECK] = LOAD_FAST_CHECK,
1144 [LOAD_FAST__LOAD_CONST] = LOAD_FAST,
1145 [LOAD_FAST__LOAD_FAST] = LOAD_FAST,
1146 [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF,
1147 [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS,
1148 [LOAD_GLOBAL] = LOAD_GLOBAL,
1149 [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL,
1150 [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL,
1151 [LOAD_LOCALS] = LOAD_LOCALS,
1152 [LOAD_NAME] = LOAD_NAME,
1153 [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR,
1154 [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR,
1155 [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR,
1156 [MAKE_CELL] = MAKE_CELL,
1157 [MAKE_FUNCTION] = MAKE_FUNCTION,
1158 [MAP_ADD] = MAP_ADD,
1159 [MATCH_CLASS] = MATCH_CLASS,
1160 [MATCH_KEYS] = MATCH_KEYS,
1161 [MATCH_MAPPING] = MATCH_MAPPING,
1162 [MATCH_SEQUENCE] = MATCH_SEQUENCE,
1163 [NOP] = NOP,
1164 [POP_EXCEPT] = POP_EXCEPT,
1165 [POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE,
1166 [POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE,
1167 [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE,
1168 [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE,
1169 [POP_TOP] = POP_TOP,
1170 [PUSH_EXC_INFO] = PUSH_EXC_INFO,
1171 [PUSH_NULL] = PUSH_NULL,
1172 [RAISE_VARARGS] = RAISE_VARARGS,
1173 [RERAISE] = RERAISE,
1174 [RESERVED] = RESERVED,
1175 [RESUME] = RESUME,
1176 [RETURN_CONST] = RETURN_CONST,
1177 [RETURN_GENERATOR] = RETURN_GENERATOR,
1178 [RETURN_VALUE] = RETURN_VALUE,
1179 [SEND] = SEND,
1180 [SEND_GEN] = SEND,
1181 [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS,
1182 [SET_ADD] = SET_ADD,
1183 [SET_UPDATE] = SET_UPDATE,
1184 [STORE_ATTR] = STORE_ATTR,
1185 [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR,
1186 [STORE_ATTR_SLOT] = STORE_ATTR,
1187 [STORE_ATTR_WITH_HINT] = STORE_ATTR,
1188 [STORE_DEREF] = STORE_DEREF,
1189 [STORE_FAST] = STORE_FAST,
1190 [STORE_FAST__LOAD_FAST] = STORE_FAST,
1191 [STORE_FAST__STORE_FAST] = STORE_FAST,
1192 [STORE_GLOBAL] = STORE_GLOBAL,
1193 [STORE_NAME] = STORE_NAME,
1194 [STORE_SLICE] = STORE_SLICE,
1195 [STORE_SUBSCR] = STORE_SUBSCR,
1196 [STORE_SUBSCR_DICT] = STORE_SUBSCR,
1197 [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR,
1198 [SWAP] = SWAP,
1199 [UNARY_INVERT] = UNARY_INVERT,
1200 [UNARY_NEGATIVE] = UNARY_NEGATIVE,
1201 [UNARY_NOT] = UNARY_NOT,
1202 [UNPACK_EX] = UNPACK_EX,
1203 [UNPACK_SEQUENCE] = UNPACK_SEQUENCE,
1204 [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE,
1205 [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE,
1206 [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE,
1207 [WITH_EXCEPT_START] = WITH_EXCEPT_START,
1208 [YIELD_VALUE] = YIELD_VALUE,
1209#else
1210 [ASYNC_GEN_WRAP] = ASYNC_GEN_WRAP,
1211 [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH,
1212 [BEFORE_WITH] = BEFORE_WITH,
1213 [BINARY_OP] = BINARY_OP,
1214 [BINARY_OP_ADAPTIVE] = BINARY_OP,
1215 [BINARY_OP_ADD_FLOAT] = BINARY_OP,
1216 [BINARY_OP_ADD_INT] = BINARY_OP,
1217 [BINARY_OP_ADD_UNICODE] = BINARY_OP,
1218 [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP,
1219 [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP,
1220 [BINARY_OP_MULTIPLY_INT] = BINARY_OP,
1221 [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP,
1222 [BINARY_OP_SUBTRACT_INT] = BINARY_OP,
1223 [BINARY_SUBSCR] = BINARY_SUBSCR,
1224 [BINARY_SUBSCR_ADAPTIVE] = BINARY_SUBSCR,
1225 [BINARY_SUBSCR_DICT] = BINARY_SUBSCR,
1226 [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR,
1227 [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR,
1228 [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR,
1229 [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP,
1230 [BUILD_LIST] = BUILD_LIST,
1231 [BUILD_MAP] = BUILD_MAP,
1232 [BUILD_SET] = BUILD_SET,
1233 [BUILD_SLICE] = BUILD_SLICE,
1234 [BUILD_STRING] = BUILD_STRING,
1235 [BUILD_TUPLE] = BUILD_TUPLE,
1236 [CACHE] = CACHE,
1237 [CALL] = CALL,
1238 [CALL_ADAPTIVE] = CALL,
1239 [CALL_FUNCTION_EX] = CALL_FUNCTION_EX,
1240 [CALL_PY_EXACT_ARGS] = CALL,
1241 [CALL_PY_WITH_DEFAULTS] = CALL,
1242 [CHECK_EG_MATCH] = CHECK_EG_MATCH,
1243 [CHECK_EXC_MATCH] = CHECK_EXC_MATCH,
1244 [COMPARE_OP] = COMPARE_OP,
1245 [COMPARE_OP_ADAPTIVE] = COMPARE_OP,
1246 [COMPARE_OP_FLOAT_JUMP] = COMPARE_OP,
1247 [COMPARE_OP_INT_JUMP] = COMPARE_OP,
1248 [COMPARE_OP_STR_JUMP] = COMPARE_OP,
1249 [CONTAINS_OP] = CONTAINS_OP,
1250 [COPY] = COPY,
1251 [COPY_FREE_VARS] = COPY_FREE_VARS,
1252 [DELETE_ATTR] = DELETE_ATTR,
1253 [DELETE_DEREF] = DELETE_DEREF,
1254 [DELETE_FAST] = DELETE_FAST,
1255 [DELETE_GLOBAL] = DELETE_GLOBAL,
1256 [DELETE_NAME] = DELETE_NAME,
1257 [DELETE_SUBSCR] = DELETE_SUBSCR,
1258 [DICT_MERGE] = DICT_MERGE,
1259 [DICT_UPDATE] = DICT_UPDATE,
1260 [END_ASYNC_FOR] = END_ASYNC_FOR,
1261 [EXTENDED_ARG] = EXTENDED_ARG,
1262 [EXTENDED_ARG_QUICK] = EXTENDED_ARG,
1263 [FORMAT_VALUE] = FORMAT_VALUE,
1264 [FOR_ITER] = FOR_ITER,
1265 [GET_AITER] = GET_AITER,
1266 [GET_ANEXT] = GET_ANEXT,
1267 [GET_AWAITABLE] = GET_AWAITABLE,
1268 [GET_ITER] = GET_ITER,
1269 [GET_LEN] = GET_LEN,
1270 [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER,
1271 [IMPORT_FROM] = IMPORT_FROM,
1272 [IMPORT_NAME] = IMPORT_NAME,
1273 [IMPORT_STAR] = IMPORT_STAR,
1274 [IS_OP] = IS_OP,
1275 [JUMP_BACKWARD] = JUMP_BACKWARD,
1276 [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT,
1277 [JUMP_BACKWARD_QUICK] = JUMP_BACKWARD,
1278 [JUMP_FORWARD] = JUMP_FORWARD,
1279 [JUMP_IF_FALSE_OR_POP] = JUMP_IF_FALSE_OR_POP,
1280 [JUMP_IF_TRUE_OR_POP] = JUMP_IF_TRUE_OR_POP,
1281 [KW_NAMES] = KW_NAMES,
1282 [LIST_APPEND] = LIST_APPEND,
1283 [LIST_EXTEND] = LIST_EXTEND,
1284 [LIST_TO_TUPLE] = LIST_TO_TUPLE,
1285 [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR,
1286 [LOAD_ATTR] = LOAD_ATTR,
1287 [LOAD_ATTR_ADAPTIVE] = LOAD_ATTR,
1288 [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR,
1289 [LOAD_ATTR_MODULE] = LOAD_ATTR,
1290 [LOAD_ATTR_SLOT] = LOAD_ATTR,
1291 [LOAD_ATTR_WITH_HINT] = LOAD_ATTR,
1292 [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS,
1293 [LOAD_CLASSDEREF] = LOAD_CLASSDEREF,
1294 [LOAD_CLOSURE] = LOAD_CLOSURE,
1295 [LOAD_CONST] = LOAD_CONST,
1296 [LOAD_CONST__LOAD_FAST] = LOAD_CONST,
1297 [LOAD_DEREF] = LOAD_DEREF,
1298 [LOAD_FAST] = LOAD_FAST,
1299 [LOAD_FAST__LOAD_CONST] = LOAD_FAST,
1300 [LOAD_FAST__LOAD_FAST] = LOAD_FAST,
1301 [LOAD_GLOBAL] = LOAD_GLOBAL,
1302 [LOAD_GLOBAL_ADAPTIVE] = LOAD_GLOBAL,
1303 [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL,
1304 [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL,
1305 [LOAD_METHOD] = LOAD_METHOD,
1306 [LOAD_METHOD_ADAPTIVE] = LOAD_METHOD,
1307 [LOAD_METHOD_CLASS] = LOAD_METHOD,
1308 [LOAD_METHOD_MODULE] = LOAD_METHOD,
1309 [LOAD_METHOD_NO_DICT] = LOAD_METHOD,
1310 [LOAD_METHOD_WITH_DICT] = LOAD_METHOD,
1311 [LOAD_METHOD_WITH_VALUES] = LOAD_METHOD,
1312 [LOAD_NAME] = LOAD_NAME,
1313 [MAKE_CELL] = MAKE_CELL,
1314 [MAKE_FUNCTION] = MAKE_FUNCTION,
1315 [MAP_ADD] = MAP_ADD,
1316 [MATCH_CLASS] = MATCH_CLASS,
1317 [MATCH_KEYS] = MATCH_KEYS,
1318 [MATCH_MAPPING] = MATCH_MAPPING,
1319 [MATCH_SEQUENCE] = MATCH_SEQUENCE,
1320 [NOP] = NOP,
1321 [POP_EXCEPT] = POP_EXCEPT,
1322 [POP_JUMP_BACKWARD_IF_FALSE] = POP_JUMP_BACKWARD_IF_FALSE,
1323 [POP_JUMP_BACKWARD_IF_NONE] = POP_JUMP_BACKWARD_IF_NONE,
1324 [POP_JUMP_BACKWARD_IF_NOT_NONE] = POP_JUMP_BACKWARD_IF_NOT_NONE,
1325 [POP_JUMP_BACKWARD_IF_TRUE] = POP_JUMP_BACKWARD_IF_TRUE,
1326 [POP_JUMP_FORWARD_IF_FALSE] = POP_JUMP_FORWARD_IF_FALSE,
1327 [POP_JUMP_FORWARD_IF_NONE] = POP_JUMP_FORWARD_IF_NONE,
1328 [POP_JUMP_FORWARD_IF_NOT_NONE] = POP_JUMP_FORWARD_IF_NOT_NONE,
1329 [POP_JUMP_FORWARD_IF_TRUE] = POP_JUMP_FORWARD_IF_TRUE,
1330 [POP_TOP] = POP_TOP,
1331 [PRECALL] = PRECALL,
1332 [PRECALL_ADAPTIVE] = PRECALL,
1333 [PRECALL_BOUND_METHOD] = PRECALL,
1334 [PRECALL_BUILTIN_CLASS] = PRECALL,
1335 [PRECALL_BUILTIN_FAST_WITH_KEYWORDS] = PRECALL,
1336 [PRECALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = PRECALL,
1337 [PRECALL_NO_KW_BUILTIN_FAST] = PRECALL,
1338 [PRECALL_NO_KW_BUILTIN_O] = PRECALL,
1339 [PRECALL_NO_KW_ISINSTANCE] = PRECALL,
1340 [PRECALL_NO_KW_LEN] = PRECALL,
1341 [PRECALL_NO_KW_LIST_APPEND] = PRECALL,
1342 [PRECALL_NO_KW_METHOD_DESCRIPTOR_FAST] = PRECALL,
1343 [PRECALL_NO_KW_METHOD_DESCRIPTOR_NOARGS] = PRECALL,
1344 [PRECALL_NO_KW_METHOD_DESCRIPTOR_O] = PRECALL,
1345 [PRECALL_NO_KW_STR_1] = PRECALL,
1346 [PRECALL_NO_KW_TUPLE_1] = PRECALL,
1347 [PRECALL_NO_KW_TYPE_1] = PRECALL,
1348 [PRECALL_PYFUNC] = PRECALL,
1349 [PREP_RERAISE_STAR] = PREP_RERAISE_STAR,
1350 [PRINT_EXPR] = PRINT_EXPR,
1351 [PUSH_EXC_INFO] = PUSH_EXC_INFO,
1352 [PUSH_NULL] = PUSH_NULL,
1353 [RAISE_VARARGS] = RAISE_VARARGS,
1354 [RERAISE] = RERAISE,
1355 [RESUME] = RESUME,
1356 [RESUME_QUICK] = RESUME,
1357 [RETURN_GENERATOR] = RETURN_GENERATOR,
1358 [RETURN_VALUE] = RETURN_VALUE,
1359 [SEND] = SEND,
1360 [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS,
1361 [SET_ADD] = SET_ADD,
1362 [SET_UPDATE] = SET_UPDATE,
1363 [STORE_ATTR] = STORE_ATTR,
1364 [STORE_ATTR_ADAPTIVE] = STORE_ATTR,
1365 [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR,
1366 [STORE_ATTR_SLOT] = STORE_ATTR,
1367 [STORE_ATTR_WITH_HINT] = STORE_ATTR,
1368 [STORE_DEREF] = STORE_DEREF,
1369 [STORE_FAST] = STORE_FAST,
1370 [STORE_FAST__LOAD_FAST] = STORE_FAST,
1371 [STORE_FAST__STORE_FAST] = STORE_FAST,
1372 [STORE_GLOBAL] = STORE_GLOBAL,
1373 [STORE_NAME] = STORE_NAME,
1374 [STORE_SUBSCR] = STORE_SUBSCR,
1375 [STORE_SUBSCR_ADAPTIVE] = STORE_SUBSCR,
1376 [STORE_SUBSCR_DICT] = STORE_SUBSCR,
1377 [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR,
1378 [SWAP] = SWAP,
1379 [UNARY_INVERT] = UNARY_INVERT,
1380 [UNARY_NEGATIVE] = UNARY_NEGATIVE,
1381 [UNARY_NOT] = UNARY_NOT,
1382 [UNARY_POSITIVE] = UNARY_POSITIVE,
1383 [UNPACK_EX] = UNPACK_EX,
1384 [UNPACK_SEQUENCE] = UNPACK_SEQUENCE,
1385 [UNPACK_SEQUENCE_ADAPTIVE] = UNPACK_SEQUENCE,
1386 [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE,
1387 [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE,
1388 [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE,
1389 [WITH_EXCEPT_START] = WITH_EXCEPT_START,
1390 [YIELD_VALUE] = YIELD_VALUE,
1391#endif
1392};
1393
1394#if PYTHON_VERSION >= 0x3d0
1395static inline bool _Nuitka_is_resume(_Py_CODEUNIT *instr) {
1396 uint8_t code = FT_ATOMIC_LOAD_UINT8_RELAXED(instr->op.code);
1397 return (code == RESUME || code == RESUME_CHECK || code == INSTRUMENTED_RESUME);
1398}
1399#endif
1400
1401PyObject *Nuitka_PyGen_yf(PyGenObject *gen) {
1402#if PYTHON_VERSION >= 0x3e0
1403 if (gen->gi_frame_state == FRAME_SUSPENDED_YIELD_FROM) {
1404 _PyInterpreterFrame *frame = &gen->gi_iframe;
1405 return PyStackRef_AsPyObjectNew(_PyFrame_StackPeek(frame));
1406 }
1407 return NULL;
1408#elif PYTHON_VERSION >= 0x3d0
1409 if (gen->gi_frame_state == FRAME_SUSPENDED_YIELD_FROM) {
1410 _PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;
1411 assert(_Nuitka_is_resume(frame->instr_ptr));
1412 assert((frame->instr_ptr->op.arg & RESUME_OPARG_LOCATION_MASK) >= RESUME_AFTER_YIELD_FROM);
1413 return Py_NewRef(_PyFrame_StackPeek(frame));
1414 }
1415 return NULL;
1416#else
1417 PyObject *yf = NULL;
1418
1419 if (gen->gi_frame_state < FRAME_CLEARED) {
1420 _PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;
1421
1422 if (gen->gi_frame_state == FRAME_CREATED) {
1423 return NULL;
1424 }
1425
1426 _Py_CODEUNIT next = frame->prev_instr[1];
1427
1428 if (Nuitka_PyOpcode_Deopt[_Py_OPCODE(next)] != RESUME || _Py_OPARG(next) < 2) {
1429 return NULL;
1430 }
1431
1432 yf = _PyFrame_StackPeek(frame);
1433
1434 Py_INCREF(yf);
1435 }
1436
1437 return yf;
1438#endif
1439}
1440
1441#if PYTHON_VERSION < 0x3c0
1442// Because it is not exported, we need to duplicate this.
1443static PyFrameObject *_Nuitka_PyFrame_New_NoTrack(PyCodeObject *code) {
1444 int slots = code->co_nlocalsplus + code->co_stacksize;
1445
1446 PyFrameObject *f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type, slots);
1447
1448 if (f == NULL) {
1449 return NULL;
1450 }
1451
1452 f->f_back = NULL;
1453 f->f_trace = NULL;
1454 f->f_trace_lines = 1;
1455 f->f_trace_opcodes = 0;
1456 f->f_fast_as_locals = 0;
1457 f->f_lineno = 0;
1458
1459 return f;
1460}
1461
1462// Also not exported.
1463static PyFrameObject *_Nuitka_PyFrame_MakeAndSetFrameObject(PyThreadState *tstate, _PyInterpreterFrame *frame) {
1464 assert(frame->frame_obj == NULL);
1465
1466 struct Nuitka_ExceptionPreservationItem saved_exception_state;
1467 FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
1468
1469 PyFrameObject *f = _Nuitka_PyFrame_New_NoTrack(frame->f_code);
1470
1471 // Out of memory should be rare.
1472 assert(f != NULL);
1473
1474 RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
1475
1476 // Apparently there are situations where there is a race with what code creates the
1477 // frame, and this time it's not us.
1478 if (frame->frame_obj) {
1479 f->f_frame = (_PyInterpreterFrame *)f->_f_frame_data;
1480 f->f_frame->owner = FRAME_CLEARED;
1481 f->f_frame->frame_obj = f;
1482 Py_DECREF(f);
1483
1484 return frame->frame_obj;
1485 }
1486
1487 assert(frame->owner != FRAME_OWNED_BY_FRAME_OBJECT);
1488 assert(frame->owner != FRAME_CLEARED);
1489
1490 f->f_frame = frame;
1491 frame->frame_obj = f;
1492
1493 return f;
1494}
1495
1496// The header variant uses un-exported code, replicate it with using our own variation.
1497static inline PyFrameObject *_Nuitka_PyFrame_GetFrameObject(PyThreadState *tstate, _PyInterpreterFrame *frame) {
1498 assert(!_PyFrame_IsIncomplete(frame));
1499
1500 PyFrameObject *res = frame->frame_obj;
1501
1502 if (res != NULL) {
1503 return res;
1504 }
1505
1506 return _Nuitka_PyFrame_MakeAndSetFrameObject(tstate, frame);
1507}
1508
1509// Also not exported, taking over a frame object.
1510static void _Nuitka_take_ownership(PyThreadState *tstate, PyFrameObject *f, _PyInterpreterFrame *frame) {
1511 assert(frame->owner != FRAME_OWNED_BY_FRAME_OBJECT);
1512 assert(frame->owner != FRAME_CLEARED);
1513
1514 Py_ssize_t size = ((char *)&frame->localsplus[frame->stacktop]) - (char *)frame;
1515 memcpy((_PyInterpreterFrame *)f->_f_frame_data, frame, size);
1516
1517 frame = (_PyInterpreterFrame *)f->_f_frame_data;
1518 f->f_frame = frame;
1519 frame->owner = FRAME_OWNED_BY_FRAME_OBJECT;
1520
1521 assert(f->f_back == NULL);
1522
1523 _PyInterpreterFrame *prev = frame->previous;
1524 while (prev && _PyFrame_IsIncomplete(prev)) {
1525 prev = prev->previous;
1526 }
1527
1528 // Link the back frame, which may have to be created.
1529 if (prev) {
1530 // Link PyFrameObject "f_back" and remove link through "_PyInterpreterFrame".previous
1531 // TODO: Nuitka doesn't do that for compiled frames ever, is that really needed?
1532 PyFrameObject *back = _Nuitka_PyFrame_GetFrameObject(tstate, prev);
1533
1534 if (unlikely(back == NULL)) {
1535 DROP_ERROR_OCCURRED(tstate);
1536 } else {
1537 f->f_back = (PyFrameObject *)Py_NewRef(back);
1538 }
1539
1540 frame->previous = NULL;
1541 }
1542
1543 if (!_PyObject_GC_IS_TRACKED((PyObject *)f)) {
1544 Nuitka_GC_Track((PyObject *)f);
1545 }
1546}
1547
1548// Cleanup up the frame is also not exported.
1549static void _Nuitka_PyFrame_Clear(PyThreadState *tstate, _PyInterpreterFrame *frame) {
1550 assert(frame->owner != FRAME_OWNED_BY_GENERATOR || _PyFrame_GetGenerator(frame)->gi_frame_state == FRAME_CLEARED);
1551
1552 if (frame->frame_obj) {
1553 PyFrameObject *f = frame->frame_obj;
1554 frame->frame_obj = NULL;
1555
1556 if (Py_REFCNT(f) > 1) {
1557 _Nuitka_take_ownership(tstate, f, frame);
1558 Py_DECREF(f);
1559
1560 return;
1561 }
1562
1563 Py_DECREF(f);
1564 }
1565
1566 assert(frame->stacktop >= 0);
1567 for (int i = 0; i < frame->stacktop; i++) {
1568 Py_XDECREF(frame->localsplus[i]);
1569 }
1570
1571 Py_XDECREF(frame->frame_obj);
1572 Py_XDECREF(frame->f_locals);
1573#if PYTHON_VERSION < 0x3c0
1574 Py_DECREF(frame->f_func);
1575#elif PYTHON_VERSION < 0x3e0
1576 Py_DECREF(frame->f_funcobj);
1577#else
1578 PyStackRef_CLEAR(frame->f_funcobj);
1579#endif
1580
1581#if PYTHON_VERSION < 0x3d0
1582 Py_XDECREF(frame->f_code);
1583#elif PYTHON_VERSION < 0x3e0
1584 Py_XDECREF(frame->f_executable);
1585#else
1586 PyStackRef_CLEAR(frame->f_executable);
1587#endif
1588}
1589#endif
1590
1591// Needs to be similar to "gen_send_ex2" implementation in CPython. This is the low
1592// end of an uncompiled generator receiving a value.
1593static PySendResult Nuitka_PyGen_gen_send_ex2(PyThreadState *tstate, PyGenObject *gen, PyObject *arg,
1594 PyObject **result_ptr, int exc, int closing) {
1595#if PYTHON_VERSION >= 0x3e0
1596 _PyInterpreterFrame *frame = &gen->gi_iframe;
1597#else
1598 _PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;
1599#endif
1600 PyObject *result;
1601
1602 *result_ptr = NULL;
1603
1604 if (gen->gi_frame_state == FRAME_CREATED && arg != NULL && arg != Py_None) {
1605 const char *msg = "can't send non-None value to a just-started generator";
1606 if (PyCoro_CheckExact(gen)) {
1607 msg = "can't send non-None value to a just-started coroutine";
1608 } else if (PyAsyncGen_CheckExact(gen)) {
1609 msg = "can't send non-None value to a just-started async generator";
1610 }
1611
1612 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, msg);
1613 return PYGEN_ERROR;
1614 }
1615
1616 if (gen->gi_frame_state == FRAME_EXECUTING) {
1617 const char *msg = "generator already executing";
1618
1619 if (PyCoro_CheckExact(gen)) {
1620 msg = "coroutine already executing";
1621 } else if (PyAsyncGen_CheckExact(gen)) {
1622 msg = "async generator already executing";
1623 }
1624
1625 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, msg);
1626 return PYGEN_ERROR;
1627 }
1628
1629 if (gen->gi_frame_state >= FRAME_COMPLETED) {
1630 if (PyCoro_CheckExact(gen) && !closing) {
1631 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "cannot reuse already awaited coroutine");
1632 } else if (arg && !exc) {
1633 *result_ptr = Py_None;
1634 Py_INCREF_IMMORTAL(*result_ptr);
1635 return PYGEN_RETURN;
1636 }
1637 return PYGEN_ERROR;
1638 }
1639
1640#if PYTHON_VERSION >= 0x3d0
1641 assert(gen->gi_frame_state == FRAME_CREATED || FRAME_STATE_SUSPENDED(gen->gi_frame_state));
1642#else
1643 assert(gen->gi_frame_state < FRAME_EXECUTING);
1644#endif
1645
1646 // Put arg on the frame's stack
1647 result = arg ? arg : Py_None;
1648#if PYTHON_VERSION >= 0x3e0
1649 _PyFrame_StackPush(frame, PyStackRef_FromPyObjectNew(result));
1650#else
1651 Py_INCREF(result);
1652 _PyFrame_StackPush(frame, result);
1653#endif
1654
1655#if PYTHON_VERSION < 0x3c0
1656 frame->previous = CURRENT_TSTATE_INTERPRETER_FRAME(tstate);
1657#endif
1658
1659 _PyErr_StackItem *prev_exc_info = tstate->exc_info;
1660 gen->gi_exc_state.previous_item = prev_exc_info;
1661
1662 tstate->exc_info = &gen->gi_exc_state;
1663
1664 if (exc) {
1665 assert(HAS_ERROR_OCCURRED(tstate));
1666#if PYTHON_VERSION >= 0x3d0
1667 Nuitka_PyErr_ChainStackItem(tstate);
1668#else
1669 _PyErr_ChainStackItem(NULL);
1670#endif
1671 }
1672
1673 gen->gi_frame_state = FRAME_EXECUTING;
1674 result = _PyEval_EvalFrame(tstate, frame, exc);
1675#if PYTHON_VERSION < 0x3c0
1676 if (gen->gi_frame_state == FRAME_EXECUTING) {
1677 gen->gi_frame_state = FRAME_COMPLETED;
1678 }
1679 tstate->exc_info = gen->gi_exc_state.previous_item;
1680 gen->gi_exc_state.previous_item = NULL;
1681
1682 assert(CURRENT_TSTATE_INTERPRETER_FRAME(tstate) == frame->previous);
1683 frame->previous = NULL;
1684#else
1685 assert(tstate->exc_info == prev_exc_info);
1686 assert(gen->gi_exc_state.previous_item == NULL);
1687 assert(gen->gi_frame_state != FRAME_EXECUTING);
1688 assert(frame->previous == NULL);
1689#endif
1690 if (result != NULL) {
1691#if PYTHON_VERSION >= 0x3d0
1692 // Match published CPython 3.13+/3.14 suspended states, including YIELD_FROM.
1693 if (gen->gi_frame_state == FRAME_SUSPENDED || gen->gi_frame_state == FRAME_SUSPENDED_YIELD_FROM) {
1694#else
1695 if (gen->gi_frame_state == FRAME_SUSPENDED) {
1696#endif
1697 *result_ptr = result;
1698 return PYGEN_NEXT;
1699 }
1700
1701 assert(result == Py_None || !PyAsyncGen_CheckExact(gen));
1702
1703 if (result == Py_None && !PyAsyncGen_CheckExact(gen) && !arg) {
1704 // TODO: Have Py_CLEAR_IMMORTAL maybe
1705
1706 Py_CLEAR(result);
1707 }
1708 } else {
1709#if PYTHON_VERSION < 0x3c0
1710 if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
1711 const char *msg = "generator raised StopIteration";
1712 if (PyCoro_CheckExact(gen)) {
1713 msg = "coroutine raised StopIteration";
1714 } else if (PyAsyncGen_CheckExact(gen)) {
1715 msg = "async generator raised StopIteration";
1716 }
1717 _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
1718 } else if (PyAsyncGen_CheckExact(gen) && PyErr_ExceptionMatches(PyExc_StopAsyncIteration)) {
1719 const char *msg = "async generator raised StopAsyncIteration";
1720 _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
1721 }
1722#else
1723 assert(!PyErr_ExceptionMatches(PyExc_StopIteration));
1724 assert(!PyAsyncGen_CheckExact(gen) || !PyErr_ExceptionMatches(PyExc_StopAsyncIteration));
1725
1726#endif
1727 }
1728
1729 _PyErr_ClearExcState(&gen->gi_exc_state);
1730
1731 gen->gi_frame_state = FRAME_CLEARED;
1732
1733#if PYTHON_VERSION < 0x3c0
1734 _Nuitka_PyFrame_Clear(tstate, frame);
1735#endif
1736
1737 *result_ptr = result;
1738 return result ? PYGEN_RETURN : PYGEN_ERROR;
1739}
1740
1741static PyObject *Nuitka_PyGen_gen_send_ex(PyThreadState *tstate, PyGenObject *gen, PyObject *arg, int exc,
1742 int closing) {
1743 PyObject *result;
1744
1745 if (Nuitka_PyGen_gen_send_ex2(tstate, gen, arg, &result, exc, closing) == PYGEN_RETURN) {
1746 if (PyAsyncGen_CheckExact(gen)) {
1747 assert(result == Py_None);
1748 SET_CURRENT_EXCEPTION_STOP_ASYNC_ITERATION(tstate);
1749 } else if (result == Py_None) {
1750 SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
1751 } else {
1752 Nuitka_SetStopIterationValue(tstate, result);
1753 }
1754
1755 Py_DECREF(result);
1756 return NULL;
1757 }
1758
1759 return result;
1760}
1761
1762// This function is called when throwing to an uncompiled generator. Coroutines and generators
1763// do this in their yielding from.
1764// Note:
1765// Exception arguments are passed for ownership and must be released before returning. The
1766// value of exception_type will not be NULL, but the actual exception will not necessarily
1767// be normalized.
1768static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenObject *gen, int close_on_genexit,
1769 struct Nuitka_ExceptionPreservationItem *exception_state) {
1770#if _DEBUG_GENERATOR
1771 PRINT_STRING("Nuitka_UncompiledGenerator_throw: Enter ");
1772 PRINT_ITEM((PyObject *)gen);
1773 PRINT_EXCEPTION_STATE(exception_state);
1774 PRINT_NEW_LINE();
1775#endif
1776
1777 PyObject *yf = Nuitka_PyGen_yf(gen);
1778
1779 if (yf != NULL) {
1780#if PYTHON_VERSION >= 0x3e0
1781 _PyInterpreterFrame *frame = &gen->gi_iframe;
1782#else
1783 _PyInterpreterFrame *frame = (_PyInterpreterFrame *)gen->gi_iframe;
1784#endif
1785
1786 if (close_on_genexit && EXCEPTION_STATE_MATCH_BOOL_SINGLE(tstate, exception_state, PyExc_GeneratorExit)) {
1787 PyFrameState state = (PyFrameState)gen->gi_frame_state;
1788 gen->gi_frame_state = FRAME_EXECUTING;
1789
1790 int err = Nuitka_PyGen_gen_close_iter(tstate, yf);
1791
1792 gen->gi_frame_state = state;
1793
1794 Py_DECREF(yf);
1795
1796 if (err < 0) {
1797 // Releasing exception, we are done with it, raising instead the error just
1798 // occurred.
1799 RELEASE_ERROR_OCCURRED_STATE(exception_state);
1800
1801 return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 0);
1802 }
1803
1804 // Handing exception ownership to this code.
1805 goto throw_here;
1806 }
1807
1808 PyObject *ret;
1809
1810 if (PyGen_CheckExact(yf) || PyCoro_CheckExact(yf)) {
1811 _PyInterpreterFrame *prev = CURRENT_TSTATE_INTERPRETER_FRAME(tstate);
1812 frame->previous = prev;
1813 CURRENT_TSTATE_INTERPRETER_FRAME(tstate) = frame;
1814 PyFrameState state = (PyFrameState)gen->gi_frame_state;
1815 gen->gi_frame_state = FRAME_EXECUTING;
1816
1817 // Handing exception ownership to "Nuitka_UncompiledGenerator_throw".
1818 ret = Nuitka_UncompiledGenerator_throw(tstate, (PyGenObject *)yf, close_on_genexit, exception_state);
1819 gen->gi_frame_state = state;
1820 CURRENT_TSTATE_INTERPRETER_FRAME(tstate) = prev;
1821 frame->previous = NULL;
1822 } else {
1823#if 0
1824 // TODO: Add slow mode traces.
1825 PRINT_ITEM(yf);
1826 PRINT_NEW_LINE();
1827#endif
1828
1829 PyObject *meth = LOOKUP_ATTRIBUTE(tstate, yf, const_str_plain_throw);
1830
1831 if (unlikely(meth == NULL)) {
1832 Py_DECREF(yf);
1833
1834 goto failed_throw;
1835 }
1836
1837 if (meth == NULL) {
1838 Py_DECREF(yf);
1839 goto throw_here;
1840 }
1841
1842 PyFrameState state = (PyFrameState)gen->gi_frame_state;
1843 gen->gi_frame_state = FRAME_EXECUTING;
1844
1845 ret = Nuitka_CallGeneratorThrowMethod(meth, exception_state);
1846
1847 gen->gi_frame_state = state;
1848
1849 // Releasing exception, we are done with it.
1850 RELEASE_ERROR_OCCURRED_STATE(exception_state);
1851
1852 Py_DECREF(meth);
1853 }
1854 Py_DECREF(yf);
1855
1856 if (ret == NULL) {
1857#if PYTHON_VERSION < 0x3c0
1858 PyObject *val;
1859 assert(gen->gi_frame_state < FRAME_CLEARED);
1860 ret = _PyFrame_StackPop((_PyInterpreterFrame *)gen->gi_iframe);
1861 assert(ret == yf);
1862 Py_DECREF(ret);
1863 assert(_PyInterpreterFrame_LASTI(frame) >= 0);
1864 assert(_Py_OPCODE(frame->prev_instr[-1]) == SEND);
1865 int jump = _Py_OPARG(frame->prev_instr[-1]);
1866 frame->prev_instr += jump - 1;
1867 if (Nuitka_PyGen_FetchStopIterationValue(tstate, &val)) {
1868 ret = Nuitka_PyGen_gen_send_ex(tstate, gen, val, 0, 0);
1869 Py_DECREF(val);
1870 } else
1871#endif
1872 {
1873 ret = Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 0);
1874 }
1875 }
1876
1877 return ret;
1878 }
1879
1880throw_here:
1881 tstate = _PyThreadState_GET();
1882
1883 if (unlikely(_Nuitka_Generator_check_throw(tstate, exception_state) == false)) {
1884 // Exception was released by _Nuitka_Generator_check_throw already.
1885 return NULL;
1886 }
1887
1888 RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
1889
1890 return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 1);
1891
1892failed_throw:
1893 RELEASE_ERROR_OCCURRED_STATE(exception_state);
1894
1895 return NULL;
1896}
1897
1898#else
1899
1900// For Python3.10 or earlier:
1901
1902static PyObject *Nuitka_PyGen_yf(PyGenObject *gen) {
1903 PyFrameObject *f = gen->gi_frame;
1904
1905#if PYTHON_VERSION < 0x3a0
1906 if (f && f->f_stacktop) {
1907#else
1908 if (f) {
1909#endif
1910 PyObject *bytecode = f->f_code->co_code;
1911 unsigned char *code = (unsigned char *)PyBytes_AS_STRING(bytecode);
1912
1913 if (f->f_lasti < 0) {
1914 return NULL;
1915 }
1916
1917#if PYTHON_VERSION < 0x360
1918 if (code[f->f_lasti + 1] != YIELD_FROM)
1919#elif PYTHON_VERSION < 0x3a0
1920 if (code[f->f_lasti + sizeof(_Py_CODEUNIT)] != YIELD_FROM)
1921#else
1922 if (code[(f->f_lasti + 1) * sizeof(_Py_CODEUNIT)] != YIELD_FROM)
1923#endif
1924 {
1925 return NULL;
1926 }
1927
1928#if PYTHON_VERSION < 0x3a0
1929 PyObject *yf = f->f_stacktop[-1];
1930#else
1931 assert(f->f_stackdepth > 0);
1932 PyObject *yf = f->f_valuestack[f->f_stackdepth - 1];
1933#endif
1934 Py_INCREF(yf);
1935 return yf;
1936 } else {
1937 return NULL;
1938 }
1939}
1940
1941static PyObject *Nuitka_PyGen_gen_send_ex(PyThreadState *tstate, PyGenObject *gen, PyObject *arg, int exc,
1942 int closing) {
1943 PyFrameObject *f = gen->gi_frame;
1944 PyObject *result;
1945
1946#if PYTHON_VERSION >= 0x3a0
1947 if (f != NULL && unlikely(_PyFrame_IsExecuting(f))) {
1948#else
1949 if (unlikely(gen->gi_running)) {
1950#endif
1951 char const *msg = "generator already executing";
1952
1953#if PYTHON_VERSION >= 0x350
1954 if (PyCoro_CheckExact(gen)) {
1955 msg = "coroutine already executing";
1956 }
1957#if PYTHON_VERSION >= 0x360
1958 else if (PyAsyncGen_CheckExact(gen)) {
1959 msg = "async generator already executing";
1960 }
1961#endif
1962#endif
1963 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, msg);
1964
1965 return NULL;
1966 }
1967
1968 if (f == NULL || Nuitka_PyFrameHasCompleted(f)) {
1969#if PYTHON_VERSION >= 0x350
1970 if (PyCoro_CheckExact(gen) && !closing) {
1971 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "cannot reuse already awaited coroutine");
1972 } else
1973#endif
1974 if (arg && !exc) {
1975#if PYTHON_VERSION >= 0x360
1976 if (PyAsyncGen_CheckExact(gen)) {
1977 SET_CURRENT_EXCEPTION_STOP_ASYNC_ITERATION(tstate);
1978 } else
1979#endif
1980 {
1981 SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
1982 }
1983 }
1984 return NULL;
1985 }
1986
1987#if PYTHON_VERSION < 0x3a0
1988 if (f->f_lasti == -1) {
1989 if (unlikely(arg != NULL && arg != Py_None)) {
1990 char const *msg = "can't send non-None value to a just-started generator";
1991
1992#if PYTHON_VERSION >= 0x350
1993 if (PyCoro_CheckExact(gen)) {
1994 msg = "can't send non-None value to a just-started coroutine";
1995 }
1996#if PYTHON_VERSION >= 0x360
1997 else if (PyAsyncGen_CheckExact(gen)) {
1998 msg = "can't send non-None value to a just-started async generator";
1999 }
2000#endif
2001#endif
2002
2003 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, msg);
2004 return NULL;
2005 }
2006 } else {
2007 // Put arg on the frame's stack
2008 result = arg ? arg : Py_None;
2009 Py_INCREF(result);
2010 *(f->f_stacktop++) = result;
2011 }
2012#else
2013 // CPython assertions, check them
2014 assert(_PyFrame_IsRunnable(f));
2015 assert(f->f_lasti >= 0 || ((unsigned char *)PyBytes_AS_STRING(f->f_code->co_code))[0] == GEN_START);
2016
2017 result = arg ? arg : Py_None;
2018 Py_INCREF(result);
2019 gen->gi_frame->f_valuestack[gen->gi_frame->f_stackdepth] = result;
2020 gen->gi_frame->f_stackdepth++;
2021#endif
2022
2023 Py_XINCREF(tstate->frame);
2024 f->f_back = tstate->frame;
2025
2026#if PYTHON_VERSION < 0x3a0
2027 gen->gi_running = 1;
2028#endif
2029#if PYTHON_VERSION >= 0x370
2030 gen->gi_exc_state.previous_item = tstate->exc_info;
2031 tstate->exc_info = &gen->gi_exc_state;
2032#endif
2033#if PYTHON_VERSION < 0x390
2034 result = PyEval_EvalFrameEx(f, exc);
2035#else
2036 result = _PyEval_EvalFrame(tstate, f, exc);
2037#endif
2038#if PYTHON_VERSION >= 0x370
2039 tstate->exc_info = gen->gi_exc_state.previous_item;
2040 gen->gi_exc_state.previous_item = NULL;
2041#endif
2042#if PYTHON_VERSION < 0x3a0
2043 gen->gi_running = 0;
2044#endif
2045
2046 Py_CLEAR(f->f_back);
2047
2048#if PYTHON_VERSION < 0x3a0
2049 if (result && f->f_stacktop == NULL) {
2050 if (result == Py_None) {
2051#if PYTHON_VERSION >= 0x360
2052 if (PyAsyncGen_CheckExact(gen)) {
2053 SET_CURRENT_EXCEPTION_STOP_ASYNC_ITERATION(tstate);
2054 } else
2055#endif
2056 {
2057 SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
2058 }
2059 } else {
2060 Nuitka_SetStopIterationValue(tstate, result);
2061 }
2062
2063 // TODO: Add Py_CLEAR_IMMORTAL maybe
2064 Py_CLEAR(result);
2065 }
2066#if PYTHON_VERSION >= 0x350
2067 else if (result == NULL && PyErr_ExceptionMatches(PyExc_StopIteration)) {
2068#if PYTHON_VERSION < 0x370
2069 const int check_stop_iter_error_flags = CO_FUTURE_GENERATOR_STOP | CO_COROUTINE |
2070#if PYTHON_VERSION >= 0x360
2071 CO_ASYNC_GENERATOR |
2072#endif
2073 CO_ITERABLE_COROUTINE;
2074
2075 if (unlikely(gen->gi_code != NULL && ((PyCodeObject *)gen->gi_code)->co_flags & check_stop_iter_error_flags))
2076#endif
2077 {
2078 char const *msg = "generator raised StopIteration";
2079
2080 if (PyCoro_CheckExact(gen)) {
2081 msg = "coroutine raised StopIteration";
2082 }
2083#if PYTHON_VERSION >= 0x360
2084 else if (PyAsyncGen_CheckExact(gen)) {
2085 msg = "async generator raised StopIteration";
2086 }
2087#endif
2088
2089#if PYTHON_VERSION >= 0x360
2090 _PyErr_FormatFromCause(
2091#else
2092 PyErr_Format(
2093#endif
2094 PyExc_RuntimeError, "%s", msg);
2095 }
2096 }
2097#endif
2098#if PYTHON_VERSION >= 0x360
2099 else if (result == NULL && PyAsyncGen_CheckExact(gen) && PyErr_ExceptionMatches(PyExc_StopAsyncIteration)) {
2100 char const *msg = "async generator raised StopAsyncIteration";
2101 _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
2102 }
2103#endif
2104
2105 if (!result || f->f_stacktop == NULL) {
2106#if PYTHON_VERSION < 0x370
2107 PyObject *t, *v, *tb;
2108 t = f->f_exc_type;
2109 v = f->f_exc_value;
2110 tb = f->f_exc_traceback;
2111 f->f_exc_type = NULL;
2112 f->f_exc_value = NULL;
2113 f->f_exc_traceback = NULL;
2114 Py_XDECREF(t);
2115 Py_XDECREF(v);
2116 Py_XDECREF(tb);
2117#else
2118 Nuitka_PyGen_exc_state_clear(&gen->gi_exc_state);
2119#endif
2120 gen->gi_frame->f_gen = NULL;
2121 gen->gi_frame = NULL;
2122 Py_DECREF(f);
2123 }
2124#else
2125 if (result) {
2126 if (!_PyFrameHasCompleted(f)) {
2127 return result;
2128 }
2129
2130 assert(result == Py_None || !PyAsyncGen_CheckExact(gen));
2131 if (PyAsyncGen_CheckExact(gen)) {
2132 assert(result == Py_None);
2133 SET_CURRENT_EXCEPTION_STOP_ASYNC_ITERATION(tstate);
2134 } else if (result == Py_None) {
2135 SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
2136 } else {
2137 Nuitka_SetStopIterationValue(tstate, result);
2138 }
2139
2140 // TODO: Add Py_CLEAR_IMMORTAL maybe
2141 Py_CLEAR(result);
2142 } else {
2143 if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
2144 const char *msg = "generator raised StopIteration";
2145 if (PyCoro_CheckExact(gen)) {
2146 msg = "coroutine raised StopIteration";
2147 } else if (PyAsyncGen_CheckExact(gen)) {
2148 msg = "async generator raised StopIteration";
2149 }
2150 _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
2151 } else if (PyAsyncGen_CheckExact(gen) && PyErr_ExceptionMatches(PyExc_StopAsyncIteration)) {
2152 const char *msg = "async generator raised StopAsyncIteration";
2153
2154 // TODO: Have our own variant of this.
2155 _PyErr_FormatFromCause(PyExc_RuntimeError, "%s", msg);
2156 }
2157 }
2158
2159 Nuitka_PyGen_exc_state_clear(&gen->gi_exc_state);
2160
2161 gen->gi_frame->f_gen = NULL;
2162 gen->gi_frame = NULL;
2163
2164 Py_DECREF(f);
2165#endif
2166 return result;
2167}
2168
2169// This function is called when throwing to an uncompiled generator. Coroutines and generators
2170// do this in their yielding from.
2171// Note:
2172// Exception arguments are passed for ownership and must be released before returning. The
2173// value of exception_type will not be NULL, but the actual exception will not necessarily
2174// be normalized.
2175static PyObject *Nuitka_UncompiledGenerator_throw(PyThreadState *tstate, PyGenObject *gen, int close_on_genexit,
2176 struct Nuitka_ExceptionPreservationItem *exception_state) {
2177#if _DEBUG_GENERATOR
2178 PRINT_STRING("Nuitka_UncompiledGenerator_throw: Enter ");
2179 PRINT_ITEM((PyObject *)gen);
2180 PRINT_EXCEPTION_STATE(exception_state);
2181 PRINT_NEW_LINE();
2182#endif
2183
2184 PyObject *yf = Nuitka_PyGen_yf(gen);
2185
2186 assert(HAS_EXCEPTION_STATE(exception_state));
2187
2188 if (yf != NULL) {
2189 if (close_on_genexit &&
2190 EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_state->exception_type, PyExc_GeneratorExit)) {
2191#if PYTHON_VERSION < 0x3a0
2192 gen->gi_running = 1;
2193#else
2194 PyFrameState state = gen->gi_frame->f_state;
2195 gen->gi_frame->f_state = FRAME_EXECUTING;
2196#endif
2197
2198 int err = Nuitka_PyGen_gen_close_iter(tstate, yf);
2199#if PYTHON_VERSION < 0x3a0
2200 gen->gi_running = 0;
2201#else
2202 gen->gi_frame->f_state = state;
2203#endif
2204 Py_DECREF(yf);
2205
2206 if (err < 0) {
2207 // Releasing exception, we are done with it, raising instead the error just
2208 // occurred.
2209 RELEASE_ERROR_OCCURRED_STATE(exception_state);
2210
2211 return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 0);
2212 }
2213
2214 // Handing exception ownership to this code.
2215 goto throw_here;
2216 }
2217
2218 PyObject *ret;
2219
2220 if (PyGen_CheckExact(yf)
2221#if PYTHON_VERSION >= 0x350
2222 || PyCoro_CheckExact(yf)
2223#endif
2224 ) {
2225#if PYTHON_VERSION < 0x3a0
2226 gen->gi_running = 1;
2227#else
2228 PyFrameState state = gen->gi_frame->f_state;
2229 gen->gi_frame->f_state = FRAME_EXECUTING;
2230#endif
2231
2232 // Handing exception ownership to "Nuitka_UncompiledGenerator_throw".
2233 ret = Nuitka_UncompiledGenerator_throw(tstate, (PyGenObject *)yf, close_on_genexit, exception_state);
2234
2235#if PYTHON_VERSION < 0x3a0
2236 gen->gi_running = 0;
2237#else
2238 gen->gi_frame->f_state = state;
2239#endif
2240 } else {
2241#if 0
2242 // TODO: Add slow mode traces.
2243 PRINT_ITEM(yf);
2244 PRINT_NEW_LINE();
2245#endif
2246
2247 // TODO: Use faster code here too.
2248 PyObject *meth = PyObject_GetAttr(yf, const_str_plain_throw);
2249
2250 if (meth == NULL) {
2251 if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
2252 Py_DECREF(yf);
2253
2254 // Releasing exception, we are done with it.
2255 RELEASE_ERROR_OCCURRED_STATE(exception_state);
2256
2257 return NULL;
2258 }
2259
2260 CLEAR_ERROR_OCCURRED(tstate);
2261 Py_DECREF(yf);
2262
2263 // Handing exception ownership to this code.
2264 goto throw_here;
2265 }
2266
2267#if PYTHON_VERSION < 0x3a0
2268 gen->gi_running = 1;
2269#else
2270 PyFrameState state = gen->gi_frame->f_state;
2271 gen->gi_frame->f_state = FRAME_EXECUTING;
2272#endif
2273 // TODO: Faster call code should be used.
2274 ret = Nuitka_CallGeneratorThrowMethod(meth, exception_state);
2275
2276#if PYTHON_VERSION < 0x3a0
2277 gen->gi_running = 0;
2278#else
2279 gen->gi_frame->f_state = state;
2280#endif
2281
2282 // Releasing exception, we are done with it.
2283 RELEASE_ERROR_OCCURRED_STATE(exception_state);
2284
2285 Py_DECREF(meth);
2286 }
2287
2288 Py_DECREF(yf);
2289
2290 if (ret == NULL) {
2291#if PYTHON_VERSION < 0x3a0
2292 ret = *(--gen->gi_frame->f_stacktop);
2293#else
2294 assert(gen->gi_frame->f_stackdepth > 0);
2295 gen->gi_frame->f_stackdepth--;
2296 ret = gen->gi_frame->f_valuestack[gen->gi_frame->f_stackdepth];
2297#endif
2298 Py_DECREF(ret);
2299
2300#if PYTHON_VERSION < 0x360
2301 gen->gi_frame->f_lasti += 1;
2302#elif PYTHON_VERSION < 0x3a0
2303 gen->gi_frame->f_lasti += sizeof(_Py_CODEUNIT);
2304#else
2305 gen->gi_frame->f_lasti += 1;
2306#endif
2307
2308 if (Nuitka_PyGen_FetchStopIterationValue(tstate, &exception_state->exception_value)) {
2309 ret = Nuitka_PyGen_gen_send_ex(tstate, gen, exception_state->exception_value, 0, 0);
2310
2311 Py_DECREF(exception_state->exception_value);
2312 } else {
2313 ret = Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 0);
2314 }
2315 }
2316 return ret;
2317 }
2318
2319throw_here:
2320 // We continue to have exception ownership here.
2321 if (unlikely(_Nuitka_Generator_check_throw(tstate, exception_state) == false)) {
2322 // Exception was released by _Nuitka_Generator_check_throw already.
2323 return NULL;
2324 }
2325
2326 // Transfer exception ownership to published exception.
2327 RESTORE_ERROR_OCCURRED_STATE(tstate, exception_state);
2328
2329 return Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 1);
2330}
2331
2332#endif
2333
2334static int Nuitka_PyGen_gen_close_iter(PyThreadState *tstate, PyObject *yf) {
2335 PyObject *retval = NULL;
2336
2337 if (PyGen_CheckExact(yf)
2338#if PYTHON_VERSION >= 0x350
2339 || PyCoro_CheckExact(yf)
2340#endif
2341 ) {
2342 assert(false);
2343 retval = Nuitka_PyGen_gen_close(tstate, (PyGenObject *)yf, NULL);
2344
2345 if (retval == NULL) {
2346 return -1;
2347 }
2348 } else {
2349 PyObject *meth = PyObject_GetAttr(yf, const_str_plain_close);
2350
2351 if (meth == NULL) {
2352 if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
2353 PyErr_WriteUnraisable(yf);
2354 }
2355
2356 CLEAR_ERROR_OCCURRED(tstate);
2357 } else {
2358 retval = CALL_FUNCTION_NO_ARGS(tstate, meth);
2359
2360 Py_DECREF(meth);
2361
2362 if (retval == NULL) {
2363 return -1;
2364 }
2365 }
2366 }
2367
2368 Py_XDECREF(retval);
2369 return 0;
2370}
2371
2372static PyObject *Nuitka_PyGen_gen_close(PyThreadState *tstate, PyGenObject *gen, PyObject *args) {
2373 PyObject *yf = Nuitka_PyGen_yf(gen);
2374 int err = 0;
2375
2376 if (yf != NULL) {
2377#if PYTHON_VERSION >= 0x3b0
2378 PyFrameState state = (PyFrameState)gen->gi_frame_state;
2379 gen->gi_frame_state = FRAME_EXECUTING;
2380#elif PYTHON_VERSION >= 0x3a0
2381 PyFrameState state = gen->gi_frame->f_state;
2382 gen->gi_frame->f_state = FRAME_EXECUTING;
2383#else
2384 gen->gi_running = 1;
2385#endif
2386 err = Nuitka_PyGen_gen_close_iter(tstate, yf);
2387
2388#if PYTHON_VERSION >= 0x3b0
2389 gen->gi_frame_state = state;
2390#elif PYTHON_VERSION >= 0x3a0
2391 gen->gi_frame->f_state = state;
2392#else
2393 gen->gi_running = 0;
2394#endif
2395 Py_DECREF(yf);
2396 }
2397
2398 if (err == 0) {
2399 SET_CURRENT_EXCEPTION_GENERATOR_EXIT(tstate);
2400 }
2401
2402 PyObject *retval = Nuitka_PyGen_gen_send_ex(tstate, gen, Py_None, 1, 1);
2403
2404 if (retval != NULL) {
2405 char const *msg = "generator ignored GeneratorExit";
2406
2407#if PYTHON_VERSION >= 0x350
2408 if (PyCoro_CheckExact(gen)) {
2409 msg = "coroutine ignored GeneratorExit";
2410 }
2411#if PYTHON_VERSION >= 0x360
2412 else if (PyAsyncGen_CheckExact(gen)) {
2413 msg = "async generator ignored GeneratorExit";
2414 }
2415#endif
2416#endif
2417 Py_DECREF(retval);
2418
2419 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, msg);
2420 return NULL;
2421 }
2422
2423 if (PyErr_ExceptionMatches(PyExc_StopIteration) || PyErr_ExceptionMatches(PyExc_GeneratorExit)) {
2424 CLEAR_ERROR_OCCURRED(tstate);
2425
2426 Py_INCREF_IMMORTAL(Py_None);
2427 return Py_None;
2428 }
2429 return NULL;
2430}
2431
2432#endif
2433
2434// Part of "Nuitka", an optimizing Python compiler that is compatible and
2435// integrates with CPython, but also works on its own.
2436//
2437// Licensed under the GNU Affero General Public License, Version 3 (the "License");
2438// you may not use this file except in compliance with the License.
2439// You may obtain a copy of the License at
2440//
2441// http://www.gnu.org/licenses/agpl.txt
2442//
2443// Unless required by applicable law or agreed to in writing, software
2444// distributed under the License is distributed on an "AS IS" BASIS,
2445// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2446// See the License for the specific language governing permissions and
2447// limitations under the License.
Nuitka_ExceptionPreservationItem
Definition exceptions.h:712