diff options
Diffstat (limited to 'tests/lexers/c/example2.txt')
| -rw-r--r-- | tests/lexers/c/example2.txt | 23177 |
1 files changed, 23177 insertions, 0 deletions
diff --git a/tests/lexers/c/example2.txt b/tests/lexers/c/example2.txt new file mode 100644 index 00000000..fe4d6c06 --- /dev/null +++ b/tests/lexers/c/example2.txt @@ -0,0 +1,23177 @@ +---input--- + +/* Execute compiled code */ + +/* XXX TO DO: + XXX speed up searching for keywords by using a dictionary + XXX document it! + */ + +/* enable more aggressive intra-module optimizations, where available */ +#define PY_LOCAL_AGGRESSIVE + +#include "Python.h" + +#include "code.h" +#include "frameobject.h" +#include "eval.h" +#include "opcode.h" +#include "structmember.h" + +#include <ctype.h> + +#ifndef WITH_TSC + +#define READ_TIMESTAMP(var) + +#else + +typedef unsigned long long uint64; + +#if defined(__ppc__) /* <- Don't know if this is the correct symbol; this + section should work for GCC on any PowerPC platform, + irrespective of OS. POWER? Who knows :-) */ + +#define READ_TIMESTAMP(var) ppc_getcounter(&var) + +static void +ppc_getcounter(uint64 *v) +{ + register unsigned long tbu, tb, tbu2; + + loop: + asm volatile ("mftbu %0" : "=r" (tbu) ); + asm volatile ("mftb %0" : "=r" (tb) ); + asm volatile ("mftbu %0" : "=r" (tbu2)); + if (__builtin_expect(tbu != tbu2, 0)) goto loop; + + /* The slightly peculiar way of writing the next lines is + compiled better by GCC than any other way I tried. */ + ((long*)(v))[0] = tbu; + ((long*)(v))[1] = tb; +} + +#else /* this is for linux/x86 (and probably any other GCC/x86 combo) */ + +#define READ_TIMESTAMP(val) \ + __asm__ __volatile__("rdtsc" : "=A" (val)) + +#endif + +void dump_tsc(int opcode, int ticked, uint64 inst0, uint64 inst1, + uint64 loop0, uint64 loop1, uint64 intr0, uint64 intr1) +{ + uint64 intr, inst, loop; + PyThreadState *tstate = PyThreadState_Get(); + if (!tstate->interp->tscdump) + return; + intr = intr1 - intr0; + inst = inst1 - inst0 - intr; + loop = loop1 - loop0 - intr; + fprintf(stderr, "opcode=%03d t=%d inst=%06lld loop=%06lld\n", + opcode, ticked, inst, loop); +} + +#endif + +/* Turn this on if your compiler chokes on the big switch: */ +/* #define CASE_TOO_BIG 1 */ + +#ifdef Py_DEBUG +/* For debugging the interpreter: */ +#define LLTRACE 1 /* Low-level trace feature */ +#define CHECKEXC 1 /* Double-check exception checking */ +#endif + +typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *); + +/* Forward declarations */ +#ifdef WITH_TSC +static PyObject * call_function(PyObject ***, int, uint64*, uint64*); +#else +static PyObject * call_function(PyObject ***, int); +#endif +static PyObject * fast_function(PyObject *, PyObject ***, int, int, int); +static PyObject * do_call(PyObject *, PyObject ***, int, int); +static PyObject * ext_do_call(PyObject *, PyObject ***, int, int, int); +static PyObject * update_keyword_args(PyObject *, int, PyObject ***,PyObject *); +static PyObject * update_star_args(int, int, PyObject *, PyObject ***); +static PyObject * load_args(PyObject ***, int); +#define CALL_FLAG_VAR 1 +#define CALL_FLAG_KW 2 + +#ifdef LLTRACE +static int lltrace; +static int prtrace(PyObject *, char *); +#endif +static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *, + int, PyObject *); +static void call_trace_protected(Py_tracefunc, PyObject *, + PyFrameObject *, int, PyObject *); +static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *); +static int maybe_call_line_trace(Py_tracefunc, PyObject *, + PyFrameObject *, int *, int *, int *); + +static PyObject * apply_slice(PyObject *, PyObject *, PyObject *); +static int assign_slice(PyObject *, PyObject *, + PyObject *, PyObject *); +static PyObject * cmp_outcome(int, PyObject *, PyObject *); +static PyObject * import_from(PyObject *, PyObject *); +static int import_all_from(PyObject *, PyObject *); +static PyObject * build_class(PyObject *, PyObject *, PyObject *); +static int exec_statement(PyFrameObject *, + PyObject *, PyObject *, PyObject *); +static void set_exc_info(PyThreadState *, PyObject *, PyObject *, PyObject *); +static void reset_exc_info(PyThreadState *); +static void format_exc_check_arg(PyObject *, char *, PyObject *); +static PyObject * string_concatenate(PyObject *, PyObject *, + PyFrameObject *, unsigned char *); + +#define NAME_ERROR_MSG \ + "name '%.200s' is not defined" +#define GLOBAL_NAME_ERROR_MSG \ + "global name '%.200s' is not defined" +#define UNBOUNDLOCAL_ERROR_MSG \ + "local variable '%.200s' referenced before assignment" +#define UNBOUNDFREE_ERROR_MSG \ + "free variable '%.200s' referenced before assignment" \ + " in enclosing scope" + +/* Dynamic execution profile */ +#ifdef DYNAMIC_EXECUTION_PROFILE +#ifdef DXPAIRS +static long dxpairs[257][256]; +#define dxp dxpairs[256] +#else +static long dxp[256]; +#endif +#endif + +/* Function call profile */ +#ifdef CALL_PROFILE +#define PCALL_NUM 11 +static int pcall[PCALL_NUM]; + +#define PCALL_ALL 0 +#define PCALL_FUNCTION 1 +#define PCALL_FAST_FUNCTION 2 +#define PCALL_FASTER_FUNCTION 3 +#define PCALL_METHOD 4 +#define PCALL_BOUND_METHOD 5 +#define PCALL_CFUNCTION 6 +#define PCALL_TYPE 7 +#define PCALL_GENERATOR 8 +#define PCALL_OTHER 9 +#define PCALL_POP 10 + +/* Notes about the statistics + + PCALL_FAST stats + + FAST_FUNCTION means no argument tuple needs to be created. + FASTER_FUNCTION means that the fast-path frame setup code is used. + + If there is a method call where the call can be optimized by changing + the argument tuple and calling the function directly, it gets recorded + twice. + + As a result, the relationship among the statistics appears to be + PCALL_ALL == PCALL_FUNCTION + PCALL_METHOD - PCALL_BOUND_METHOD + + PCALL_CFUNCTION + PCALL_TYPE + PCALL_GENERATOR + PCALL_OTHER + PCALL_FUNCTION > PCALL_FAST_FUNCTION > PCALL_FASTER_FUNCTION + PCALL_METHOD > PCALL_BOUND_METHOD +*/ + +#define PCALL(POS) pcall[POS]++ + +PyObject * +PyEval_GetCallStats(PyObject *self) +{ + return Py_BuildValue("iiiiiiiiii", + pcall[0], pcall[1], pcall[2], pcall[3], + pcall[4], pcall[5], pcall[6], pcall[7], + pcall[8], pcall[9]); +} +#else +#define PCALL(O) + +PyObject * +PyEval_GetCallStats(PyObject *self) +{ + Py_INCREF(Py_None); + return Py_None; +} +#endif + + +#ifdef WITH_THREAD + +#ifdef HAVE_ERRNO_H +#include <errno.h> +#endif +#include "pythread.h" + +static PyThread_type_lock interpreter_lock = 0; /* This is the GIL */ +static long main_thread = 0; + +int +PyEval_ThreadsInitialized(void) +{ + return interpreter_lock != 0; +} + +void +PyEval_InitThreads(void) +{ + if (interpreter_lock) + return; + interpreter_lock = PyThread_allocate_lock(); + PyThread_acquire_lock(interpreter_lock, 1); + main_thread = PyThread_get_thread_ident(); +} + +void +PyEval_AcquireLock(void) +{ + PyThread_acquire_lock(interpreter_lock, 1); +} + +void +PyEval_ReleaseLock(void) +{ + PyThread_release_lock(interpreter_lock); +} + +void +PyEval_AcquireThread(PyThreadState *tstate) +{ + if (tstate == NULL) + Py_FatalError("PyEval_AcquireThread: NULL new thread state"); + /* Check someone has called PyEval_InitThreads() to create the lock */ + assert(interpreter_lock); + PyThread_acquire_lock(interpreter_lock, 1); + if (PyThreadState_Swap(tstate) != NULL) + Py_FatalError( + "PyEval_AcquireThread: non-NULL old thread state"); +} + +void +PyEval_ReleaseThread(PyThreadState *tstate) +{ + if (tstate == NULL) + Py_FatalError("PyEval_ReleaseThread: NULL thread state"); + if (PyThreadState_Swap(NULL) != tstate) + Py_FatalError("PyEval_ReleaseThread: wrong thread state"); + PyThread_release_lock(interpreter_lock); +} + +/* This function is called from PyOS_AfterFork to ensure that newly + created child processes don't hold locks referring to threads which + are not running in the child process. (This could also be done using + pthread_atfork mechanism, at least for the pthreads implementation.) */ + +void +PyEval_ReInitThreads(void) +{ + if (!interpreter_lock) + return; + /*XXX Can't use PyThread_free_lock here because it does too + much error-checking. Doing this cleanly would require + adding a new function to each thread_*.h. Instead, just + create a new lock and waste a little bit of memory */ + interpreter_lock = PyThread_allocate_lock(); + PyThread_acquire_lock(interpreter_lock, 1); + main_thread = PyThread_get_thread_ident(); +} +#endif + +/* Functions save_thread and restore_thread are always defined so + dynamically loaded modules needn't be compiled separately for use + with and without threads: */ + +PyThreadState * +PyEval_SaveThread(void) +{ + PyThreadState *tstate = PyThreadState_Swap(NULL); + if (tstate == NULL) + Py_FatalError("PyEval_SaveThread: NULL tstate"); +#ifdef WITH_THREAD + if (interpreter_lock) + PyThread_release_lock(interpreter_lock); +#endif + return tstate; +} + +void +PyEval_RestoreThread(PyThreadState *tstate) +{ + if (tstate == NULL) + Py_FatalError("PyEval_RestoreThread: NULL tstate"); +#ifdef WITH_THREAD + if (interpreter_lock) { + int err = errno; + PyThread_acquire_lock(interpreter_lock, 1); + errno = err; + } +#endif + PyThreadState_Swap(tstate); +} + + +/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX + signal handlers or Mac I/O completion routines) can schedule calls + to a function to be called synchronously. + The synchronous function is called with one void* argument. + It should return 0 for success or -1 for failure -- failure should + be accompanied by an exception. + + If registry succeeds, the registry function returns 0; if it fails + (e.g. due to too many pending calls) it returns -1 (without setting + an exception condition). + + Note that because registry may occur from within signal handlers, + or other asynchronous events, calling malloc() is unsafe! + +#ifdef WITH_THREAD + Any thread can schedule pending calls, but only the main thread + will execute them. +#endif + + XXX WARNING! ASYNCHRONOUSLY EXECUTING CODE! + There are two possible race conditions: + (1) nested asynchronous registry calls; + (2) registry calls made while pending calls are being processed. + While (1) is very unlikely, (2) is a real possibility. + The current code is safe against (2), but not against (1). + The safety against (2) is derived from the fact that only one + thread (the main thread) ever takes things out of the queue. + + XXX Darn! With the advent of thread state, we should have an array + of pending calls per thread in the thread state! Later... +*/ + +#define NPENDINGCALLS 32 +static struct { + int (*func)(void *); + void *arg; +} pendingcalls[NPENDINGCALLS]; +static volatile int pendingfirst = 0; +static volatile int pendinglast = 0; +static volatile int things_to_do = 0; + +int +Py_AddPendingCall(int (*func)(void *), void *arg) +{ + static volatile int busy = 0; + int i, j; + /* XXX Begin critical section */ + /* XXX If you want this to be safe against nested + XXX asynchronous calls, you'll have to work harder! */ + if (busy) + return -1; + busy = 1; + i = pendinglast; + j = (i + 1) % NPENDINGCALLS; + if (j == pendingfirst) { + busy = 0; + return -1; /* Queue full */ + } + pendingcalls[i].func = func; + pendingcalls[i].arg = arg; + pendinglast = j; + + _Py_Ticker = 0; + things_to_do = 1; /* Signal main loop */ + busy = 0; + /* XXX End critical section */ + return 0; +} + +int +Py_MakePendingCalls(void) +{ + static int busy = 0; +#ifdef WITH_THREAD + if (main_thread && PyThread_get_thread_ident() != main_thread) + return 0; +#endif + if (busy) + return 0; + busy = 1; + things_to_do = 0; + for (;;) { + int i; + int (*func)(void *); + void *arg; + i = pendingfirst; + if (i == pendinglast) + break; /* Queue empty */ + func = pendingcalls[i].func; + arg = pendingcalls[i].arg; + pendingfirst = (i + 1) % NPENDINGCALLS; + if (func(arg) < 0) { + busy = 0; + things_to_do = 1; /* We're not done yet */ + return -1; + } + } + busy = 0; + return 0; +} + + +/* The interpreter's recursion limit */ + +#ifndef Py_DEFAULT_RECURSION_LIMIT +#define Py_DEFAULT_RECURSION_LIMIT 1000 +#endif +static int recursion_limit = Py_DEFAULT_RECURSION_LIMIT; +int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT; + +int +Py_GetRecursionLimit(void) +{ + return recursion_limit; +} + +void +Py_SetRecursionLimit(int new_limit) +{ + recursion_limit = new_limit; + _Py_CheckRecursionLimit = recursion_limit; +} + +/* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall() + if the recursion_depth reaches _Py_CheckRecursionLimit. + If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit + to guarantee that _Py_CheckRecursiveCall() is regularly called. + Without USE_STACKCHECK, there is no need for this. */ +int +_Py_CheckRecursiveCall(char *where) +{ + PyThreadState *tstate = PyThreadState_GET(); + +#ifdef USE_STACKCHECK + if (PyOS_CheckStack()) { + --tstate->recursion_depth; + PyErr_SetString(PyExc_MemoryError, "Stack overflow"); + return -1; + } +#endif + if (tstate->recursion_depth > recursion_limit) { + --tstate->recursion_depth; + PyErr_Format(PyExc_RuntimeError, + "maximum recursion depth exceeded%s", + where); + return -1; + } + _Py_CheckRecursionLimit = recursion_limit; + return 0; +} + +/* Status code for main loop (reason for stack unwind) */ +enum why_code { + WHY_NOT = 0x0001, /* No error */ + WHY_EXCEPTION = 0x0002, /* Exception occurred */ + WHY_RERAISE = 0x0004, /* Exception re-raised by 'finally' */ + WHY_RETURN = 0x0008, /* 'return' statement */ + WHY_BREAK = 0x0010, /* 'break' statement */ + WHY_CONTINUE = 0x0020, /* 'continue' statement */ + WHY_YIELD = 0x0040 /* 'yield' operator */ +}; + +static enum why_code do_raise(PyObject *, PyObject *, PyObject *); +static int unpack_iterable(PyObject *, int, PyObject **); + +/* for manipulating the thread switch and periodic "stuff" - used to be + per thread, now just a pair o' globals */ +int _Py_CheckInterval = 100; +volatile int _Py_Ticker = 100; + +PyObject * +PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals) +{ + /* XXX raise SystemError if globals is NULL */ + return PyEval_EvalCodeEx(co, + globals, locals, + (PyObject **)NULL, 0, + (PyObject **)NULL, 0, + (PyObject **)NULL, 0, + NULL); +} + + +/* Interpreter main loop */ + +PyObject * +PyEval_EvalFrame(PyFrameObject *f) { + /* This is for backward compatibility with extension modules that + used this API; core interpreter code should call PyEval_EvalFrameEx() */ + return PyEval_EvalFrameEx(f, 0); +} + +PyObject * +PyEval_EvalFrameEx(PyFrameObject *f, int throwflag) +{ +#ifdef DXPAIRS + int lastopcode = 0; +#endif + register PyObject **stack_pointer; /* Next free slot in value stack */ + register unsigned char *next_instr; + register int opcode; /* Current opcode */ + register int oparg; /* Current opcode argument, if any */ + register enum why_code why; /* Reason for block stack unwind */ + register int err; /* Error status -- nonzero if error */ + register PyObject *x; /* Result object -- NULL if error */ + register PyObject *v; /* Temporary objects popped off stack */ + register PyObject *w; + register PyObject *u; + register PyObject *t; + register PyObject *stream = NULL; /* for PRINT opcodes */ + register PyObject **fastlocals, **freevars; + PyObject *retval = NULL; /* Return value */ + PyThreadState *tstate = PyThreadState_GET(); + PyCodeObject *co; + + /* when tracing we set things up so that + + not (instr_lb <= current_bytecode_offset < instr_ub) + + is true when the line being executed has changed. The + initial values are such as to make this false the first + time it is tested. */ + int instr_ub = -1, instr_lb = 0, instr_prev = -1; + + unsigned char *first_instr; + PyObject *names; + PyObject *consts; +#if defined(Py_DEBUG) || defined(LLTRACE) + /* Make it easier to find out where we are with a debugger */ + char *filename; +#endif + +/* Tuple access macros */ + +#ifndef Py_DEBUG +#define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i)) +#else +#define GETITEM(v, i) PyTuple_GetItem((v), (i)) +#endif + +#ifdef WITH_TSC +/* Use Pentium timestamp counter to mark certain events: + inst0 -- beginning of switch statement for opcode dispatch + inst1 -- end of switch statement (may be skipped) + loop0 -- the top of the mainloop + loop1 -- place where control returns again to top of mainloop + (may be skipped) + intr1 -- beginning of long interruption + intr2 -- end of long interruption + + Many opcodes call out to helper C functions. In some cases, the + time in those functions should be counted towards the time for the + opcode, but not in all cases. For example, a CALL_FUNCTION opcode + calls another Python function; there's no point in charge all the + bytecode executed by the called function to the caller. + + It's hard to make a useful judgement statically. In the presence + of operator overloading, it's impossible to tell if a call will + execute new Python code or not. + + It's a case-by-case judgement. I'll use intr1 for the following + cases: + + EXEC_STMT + IMPORT_STAR + IMPORT_FROM + CALL_FUNCTION (and friends) + + */ + uint64 inst0, inst1, loop0, loop1, intr0 = 0, intr1 = 0; + int ticked = 0; + + READ_TIMESTAMP(inst0); + READ_TIMESTAMP(inst1); + READ_TIMESTAMP(loop0); + READ_TIMESTAMP(loop1); + + /* shut up the compiler */ + opcode = 0; +#endif + +/* Code access macros */ + +#define INSTR_OFFSET() ((int)(next_instr - first_instr)) +#define NEXTOP() (*next_instr++) +#define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2]) +#define PEEKARG() ((next_instr[2]<<8) + next_instr[1]) +#define JUMPTO(x) (next_instr = first_instr + (x)) +#define JUMPBY(x) (next_instr += (x)) + +/* OpCode prediction macros + Some opcodes tend to come in pairs thus making it possible to predict + the second code when the first is run. For example, COMPARE_OP is often + followed by JUMP_IF_FALSE or JUMP_IF_TRUE. And, those opcodes are often + followed by a POP_TOP. + + Verifying the prediction costs a single high-speed test of register + variable against a constant. If the pairing was good, then the + processor has a high likelihood of making its own successful branch + prediction which results in a nearly zero overhead transition to the + next opcode. + + A successful prediction saves a trip through the eval-loop including + its two unpredictable branches, the HASARG test and the switch-case. + + If collecting opcode statistics, turn off prediction so that + statistics are accurately maintained (the predictions bypass + the opcode frequency counter updates). +*/ + +#ifdef DYNAMIC_EXECUTION_PROFILE +#define PREDICT(op) if (0) goto PRED_##op +#else +#define PREDICT(op) if (*next_instr == op) goto PRED_##op +#endif + +#define PREDICTED(op) PRED_##op: next_instr++ +#define PREDICTED_WITH_ARG(op) PRED_##op: oparg = PEEKARG(); next_instr += 3 + +/* Stack manipulation macros */ + +/* The stack can grow at most MAXINT deep, as co_nlocals and + co_stacksize are ints. */ +#define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack)) +#define EMPTY() (STACK_LEVEL() == 0) +#define TOP() (stack_pointer[-1]) +#define SECOND() (stack_pointer[-2]) +#define THIRD() (stack_pointer[-3]) +#define FOURTH() (stack_pointer[-4]) +#define SET_TOP(v) (stack_pointer[-1] = (v)) +#define SET_SECOND(v) (stack_pointer[-2] = (v)) +#define SET_THIRD(v) (stack_pointer[-3] = (v)) +#define SET_FOURTH(v) (stack_pointer[-4] = (v)) +#define BASIC_STACKADJ(n) (stack_pointer += n) +#define BASIC_PUSH(v) (*stack_pointer++ = (v)) +#define BASIC_POP() (*--stack_pointer) + +#ifdef LLTRACE +#define PUSH(v) { (void)(BASIC_PUSH(v), \ + lltrace && prtrace(TOP(), "push")); \ + assert(STACK_LEVEL() <= co->co_stacksize); } +#define POP() ((void)(lltrace && prtrace(TOP(), "pop")), BASIC_POP()) +#define STACKADJ(n) { (void)(BASIC_STACKADJ(n), \ + lltrace && prtrace(TOP(), "stackadj")); \ + assert(STACK_LEVEL() <= co->co_stacksize); } +#define EXT_POP(STACK_POINTER) (lltrace && prtrace(*(STACK_POINTER), "ext_pop"), *--(STACK_POINTER)) +#else +#define PUSH(v) BASIC_PUSH(v) +#define POP() BASIC_POP() +#define STACKADJ(n) BASIC_STACKADJ(n) +#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER)) +#endif + +/* Local variable macros */ + +#define GETLOCAL(i) (fastlocals[i]) + +/* The SETLOCAL() macro must not DECREF the local variable in-place and + then store the new value; it must copy the old value to a temporary + value, then store the new value, and then DECREF the temporary value. + This is because it is possible that during the DECREF the frame is + accessed by other code (e.g. a __del__ method or gc.collect()) and the + variable would be pointing to already-freed memory. */ +#define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \ + GETLOCAL(i) = value; \ + Py_XDECREF(tmp); } while (0) + +/* Start of code */ + + if (f == NULL) + return NULL; + + /* push frame */ + if (Py_EnterRecursiveCall("")) + return NULL; + + tstate->frame = f; + + if (tstate->use_tracing) { + if (tstate->c_tracefunc != NULL) { + /* tstate->c_tracefunc, if defined, is a + function that will be called on *every* entry + to a code block. Its return value, if not + None, is a function that will be called at + the start of each executed line of code. + (Actually, the function must return itself + in order to continue tracing.) The trace + functions are called with three arguments: + a pointer to the current frame, a string + indicating why the function is called, and + an argument which depends on the situation. + The global trace function is also called + whenever an exception is detected. */ + if (call_trace(tstate->c_tracefunc, tstate->c_traceobj, + f, PyTrace_CALL, Py_None)) { + /* Trace function raised an error */ + goto exit_eval_frame; + } + } + if (tstate->c_profilefunc != NULL) { + /* Similar for c_profilefunc, except it needn't + return itself and isn't called for "line" events */ + if (call_trace(tstate->c_profilefunc, + tstate->c_profileobj, + f, PyTrace_CALL, Py_None)) { + /* Profile function raised an error */ + goto exit_eval_frame; + } + } + } + + co = f->f_code; + names = co->co_names; + consts = co->co_consts; + fastlocals = f->f_localsplus; + freevars = f->f_localsplus + co->co_nlocals; + first_instr = (unsigned char*) PyString_AS_STRING(co->co_code); + /* An explanation is in order for the next line. + + f->f_lasti now refers to the index of the last instruction + executed. You might think this was obvious from the name, but + this wasn't always true before 2.3! PyFrame_New now sets + f->f_lasti to -1 (i.e. the index *before* the first instruction) + and YIELD_VALUE doesn't fiddle with f_lasti any more. So this + does work. Promise. */ + next_instr = first_instr + f->f_lasti + 1; + stack_pointer = f->f_stacktop; + assert(stack_pointer != NULL); + f->f_stacktop = NULL; /* remains NULL unless yield suspends frame */ + +#ifdef LLTRACE + lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL; +#endif +#if defined(Py_DEBUG) || defined(LLTRACE) + filename = PyString_AsString(co->co_filename); +#endif + + why = WHY_NOT; + err = 0; + x = Py_None; /* Not a reference, just anything non-NULL */ + w = NULL; + + if (throwflag) { /* support for generator.throw() */ + why = WHY_EXCEPTION; + goto on_error; + } + + for (;;) { +#ifdef WITH_TSC + if (inst1 == 0) { + /* Almost surely, the opcode executed a break + or a continue, preventing inst1 from being set + on the way out of the loop. + */ + READ_TIMESTAMP(inst1); + loop1 = inst1; + } + dump_tsc(opcode, ticked, inst0, inst1, loop0, loop1, + intr0, intr1); + ticked = 0; + inst1 = 0; + intr0 = 0; + intr1 = 0; + READ_TIMESTAMP(loop0); +#endif + assert(stack_pointer >= f->f_valuestack); /* else underflow */ + assert(STACK_LEVEL() <= co->co_stacksize); /* else overflow */ + + /* Do periodic things. Doing this every time through + the loop would add too much overhead, so we do it + only every Nth instruction. We also do it if + ``things_to_do'' is set, i.e. when an asynchronous + event needs attention (e.g. a signal handler or + async I/O handler); see Py_AddPendingCall() and + Py_MakePendingCalls() above. */ + + if (--_Py_Ticker < 0) { + if (*next_instr == SETUP_FINALLY) { + /* Make the last opcode before + a try: finally: block uninterruptable. */ + goto fast_next_opcode; + } + _Py_Ticker = _Py_CheckInterval; + tstate->tick_counter++; +#ifdef WITH_TSC + ticked = 1; +#endif + if (things_to_do) { + if (Py_MakePendingCalls() < 0) { + why = WHY_EXCEPTION; + goto on_error; + } + if (things_to_do) + /* MakePendingCalls() didn't succeed. + Force early re-execution of this + "periodic" code, possibly after + a thread switch */ + _Py_Ticker = 0; + } +#ifdef WITH_THREAD + if (interpreter_lock) { + /* Give another thread a chance */ + + if (PyThreadState_Swap(NULL) != tstate) + Py_FatalError("ceval: tstate mix-up"); + PyThread_release_lock(interpreter_lock); + + /* Other threads may run now */ + + PyThread_acquire_lock(interpreter_lock, 1); + if (PyThreadState_Swap(tstate) != NULL) + Py_FatalError("ceval: orphan tstate"); + + /* Check for thread interrupts */ + + if (tstate->async_exc != NULL) { + x = tstate->async_exc; + tstate->async_exc = NULL; + PyErr_SetNone(x); + Py_DECREF(x); + why = WHY_EXCEPTION; + goto on_error; + } + } +#endif + } + + fast_next_opcode: + f->f_lasti = INSTR_OFFSET(); + + /* line-by-line tracing support */ + + if (tstate->c_tracefunc != NULL && !tstate->tracing) { + /* see maybe_call_line_trace + for expository comments */ + f->f_stacktop = stack_pointer; + + err = maybe_call_line_trace(tstate->c_tracefunc, + tstate->c_traceobj, + f, &instr_lb, &instr_ub, + &instr_prev); + /* Reload possibly changed frame fields */ + JUMPTO(f->f_lasti); + if (f->f_stacktop != NULL) { + stack_pointer = f->f_stacktop; + f->f_stacktop = NULL; + } + if (err) { + /* trace function raised an exception */ + goto on_error; + } + } + + /* Extract opcode and argument */ + + opcode = NEXTOP(); + oparg = 0; /* allows oparg to be stored in a register because + it doesn't have to be remembered across a full loop */ + if (HAS_ARG(opcode)) + oparg = NEXTARG(); + dispatch_opcode: +#ifdef DYNAMIC_EXECUTION_PROFILE +#ifdef DXPAIRS + dxpairs[lastopcode][opcode]++; + lastopcode = opcode; +#endif + dxp[opcode]++; +#endif + +#ifdef LLTRACE + /* Instruction tracing */ + + if (lltrace) { + if (HAS_ARG(opcode)) { + printf("%d: %d, %d\n", + f->f_lasti, opcode, oparg); + } + else { + printf("%d: %d\n", + f->f_lasti, opcode); + } + } +#endif + + /* Main switch on opcode */ + READ_TIMESTAMP(inst0); + + switch (opcode) { + + /* BEWARE! + It is essential that any operation that fails sets either + x to NULL, err to nonzero, or why to anything but WHY_NOT, + and that no operation that succeeds does this! */ + + /* case STOP_CODE: this is an error! */ + + case NOP: + goto fast_next_opcode; + + case LOAD_FAST: + x = GETLOCAL(oparg); + if (x != NULL) { + Py_INCREF(x); + PUSH(x); + goto fast_next_opcode; + } + format_exc_check_arg(PyExc_UnboundLocalError, + UNBOUNDLOCAL_ERROR_MSG, + PyTuple_GetItem(co->co_varnames, oparg)); + break; + + case LOAD_CONST: + x = GETITEM(consts, oparg); + Py_INCREF(x); + PUSH(x); + goto fast_next_opcode; + + PREDICTED_WITH_ARG(STORE_FAST); + case STORE_FAST: + v = POP(); + SETLOCAL(oparg, v); + goto fast_next_opcode; + + PREDICTED(POP_TOP); + case POP_TOP: + v = POP(); + Py_DECREF(v); + goto fast_next_opcode; + + case ROT_TWO: + v = TOP(); + w = SECOND(); + SET_TOP(w); + SET_SECOND(v); + goto fast_next_opcode; + + case ROT_THREE: + v = TOP(); + w = SECOND(); + x = THIRD(); + SET_TOP(w); + SET_SECOND(x); + SET_THIRD(v); + goto fast_next_opcode; + + case ROT_FOUR: + u = TOP(); + v = SECOND(); + w = THIRD(); + x = FOURTH(); + SET_TOP(v); + SET_SECOND(w); + SET_THIRD(x); + SET_FOURTH(u); + goto fast_next_opcode; + + case DUP_TOP: + v = TOP(); + Py_INCREF(v); + PUSH(v); + goto fast_next_opcode; + + case DUP_TOPX: + if (oparg == 2) { + x = TOP(); + Py_INCREF(x); + w = SECOND(); + Py_INCREF(w); + STACKADJ(2); + SET_TOP(x); + SET_SECOND(w); + goto fast_next_opcode; + } else if (oparg == 3) { + x = TOP(); + Py_INCREF(x); + w = SECOND(); + Py_INCREF(w); + v = THIRD(); + Py_INCREF(v); + STACKADJ(3); + SET_TOP(x); + SET_SECOND(w); + SET_THIRD(v); + goto fast_next_opcode; + } + Py_FatalError("invalid argument to DUP_TOPX" + " (bytecode corruption?)"); + break; + + case UNARY_POSITIVE: + v = TOP(); + x = PyNumber_Positive(v); + Py_DECREF(v); + SET_TOP(x); + if (x != NULL) continue; + break; + + case UNARY_NEGATIVE: + v = TOP(); + x = PyNumber_Negative(v); + Py_DECREF(v); + SET_TOP(x); + if (x != NULL) continue; + break; + + case UNARY_NOT: + v = TOP(); + err = PyObject_IsTrue(v); + Py_DECREF(v); + if (err == 0) { + Py_INCREF(Py_True); + SET_TOP(Py_True); + continue; + } + else if (err > 0) { + Py_INCREF(Py_False); + SET_TOP(Py_False); + err = 0; + continue; + } + STACKADJ(-1); + break; + + case UNARY_CONVERT: + v = TOP(); + x = PyObject_Repr(v); + Py_DECREF(v); + SET_TOP(x); + if (x != NULL) continue; + break; + + case UNARY_INVERT: + v = TOP(); + x = PyNumber_Invert(v); + Py_DECREF(v); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_POWER: + w = POP(); + v = TOP(); + x = PyNumber_Power(v, w, Py_None); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_MULTIPLY: + w = POP(); + v = TOP(); + x = PyNumber_Multiply(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_DIVIDE: + if (!_Py_QnewFlag) { + w = POP(); + v = TOP(); + x = PyNumber_Divide(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + } + /* -Qnew is in effect: fall through to + BINARY_TRUE_DIVIDE */ + case BINARY_TRUE_DIVIDE: + w = POP(); + v = TOP(); + x = PyNumber_TrueDivide(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_FLOOR_DIVIDE: + w = POP(); + v = TOP(); + x = PyNumber_FloorDivide(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_MODULO: + w = POP(); + v = TOP(); + x = PyNumber_Remainder(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_ADD: + w = POP(); + v = TOP(); + if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) { + /* INLINE: int + int */ + register long a, b, i; + a = PyInt_AS_LONG(v); + b = PyInt_AS_LONG(w); + i = a + b; + if ((i^a) < 0 && (i^b) < 0) + goto slow_add; + x = PyInt_FromLong(i); + } + else if (PyString_CheckExact(v) && + PyString_CheckExact(w)) { + x = string_concatenate(v, w, f, next_instr); + /* string_concatenate consumed the ref to v */ + goto skip_decref_vx; + } + else { + slow_add: + x = PyNumber_Add(v, w); + } + Py_DECREF(v); + skip_decref_vx: + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_SUBTRACT: + w = POP(); + v = TOP(); + if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) { + /* INLINE: int - int */ + register long a, b, i; + a = PyInt_AS_LONG(v); + b = PyInt_AS_LONG(w); + i = a - b; + if ((i^a) < 0 && (i^~b) < 0) + goto slow_sub; + x = PyInt_FromLong(i); + } + else { + slow_sub: + x = PyNumber_Subtract(v, w); + } + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_SUBSCR: + w = POP(); + v = TOP(); + if (PyList_CheckExact(v) && PyInt_CheckExact(w)) { + /* INLINE: list[int] */ + Py_ssize_t i = PyInt_AsSsize_t(w); + if (i < 0) + i += PyList_GET_SIZE(v); + if (i >= 0 && i < PyList_GET_SIZE(v)) { + x = PyList_GET_ITEM(v, i); + Py_INCREF(x); + } + else + goto slow_get; + } + else + slow_get: + x = PyObject_GetItem(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_LSHIFT: + w = POP(); + v = TOP(); + x = PyNumber_Lshift(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_RSHIFT: + w = POP(); + v = TOP(); + x = PyNumber_Rshift(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_AND: + w = POP(); + v = TOP(); + x = PyNumber_And(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_XOR: + w = POP(); + v = TOP(); + x = PyNumber_Xor(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case BINARY_OR: + w = POP(); + v = TOP(); + x = PyNumber_Or(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case LIST_APPEND: + w = POP(); + v = POP(); + err = PyList_Append(v, w); + Py_DECREF(v); + Py_DECREF(w); + if (err == 0) { + PREDICT(JUMP_ABSOLUTE); + continue; + } + break; + + case INPLACE_POWER: + w = POP(); + v = TOP(); + x = PyNumber_InPlacePower(v, w, Py_None); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case INPLACE_MULTIPLY: + w = POP(); + v = TOP(); + x = PyNumber_InPlaceMultiply(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case INPLACE_DIVIDE: + if (!_Py_QnewFlag) { + w = POP(); + v = TOP(); + x = PyNumber_InPlaceDivide(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + } + /* -Qnew is in effect: fall through to + INPLACE_TRUE_DIVIDE */ + case INPLACE_TRUE_DIVIDE: + w = POP(); + v = TOP(); + x = PyNumber_InPlaceTrueDivide(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case INPLACE_FLOOR_DIVIDE: + w = POP(); + v = TOP(); + x = PyNumber_InPlaceFloorDivide(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case INPLACE_MODULO: + w = POP(); + v = TOP(); + x = PyNumber_InPlaceRemainder(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case INPLACE_ADD: + w = POP(); + v = TOP(); + if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) { + /* INLINE: int + int */ + register long a, b, i; + a = PyInt_AS_LONG(v); + b = PyInt_AS_LONG(w); + i = a + b; + if ((i^a) < 0 && (i^b) < 0) + goto slow_iadd; + x = PyInt_FromLong(i); + } + else if (PyString_CheckExact(v) && + PyString_CheckExact(w)) { + x = string_concatenate(v, w, f, next_instr); + /* string_concatenate consumed the ref to v */ + goto skip_decref_v; + } + else { + slow_iadd: + x = PyNumber_InPlaceAdd(v, w); + } + Py_DECREF(v); + skip_decref_v: + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case INPLACE_SUBTRACT: + w = POP(); + v = TOP(); + if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) { + /* INLINE: int - int */ + register long a, b, i; + a = PyInt_AS_LONG(v); + b = PyInt_AS_LONG(w); + i = a - b; + if ((i^a) < 0 && (i^~b) < 0) + goto slow_isub; + x = PyInt_FromLong(i); + } + else { + slow_isub: + x = PyNumber_InPlaceSubtract(v, w); + } + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case INPLACE_LSHIFT: + w = POP(); + v = TOP(); + x = PyNumber_InPlaceLshift(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case INPLACE_RSHIFT: + w = POP(); + v = TOP(); + x = PyNumber_InPlaceRshift(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case INPLACE_AND: + w = POP(); + v = TOP(); + x = PyNumber_InPlaceAnd(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case INPLACE_XOR: + w = POP(); + v = TOP(); + x = PyNumber_InPlaceXor(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case INPLACE_OR: + w = POP(); + v = TOP(); + x = PyNumber_InPlaceOr(v, w); + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case SLICE+0: + case SLICE+1: + case SLICE+2: + case SLICE+3: + if ((opcode-SLICE) & 2) + w = POP(); + else + w = NULL; + if ((opcode-SLICE) & 1) + v = POP(); + else + v = NULL; + u = TOP(); + x = apply_slice(u, v, w); + Py_DECREF(u); + Py_XDECREF(v); + Py_XDECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case STORE_SLICE+0: + case STORE_SLICE+1: + case STORE_SLICE+2: + case STORE_SLICE+3: + if ((opcode-STORE_SLICE) & 2) + w = POP(); + else + w = NULL; + if ((opcode-STORE_SLICE) & 1) + v = POP(); + else + v = NULL; + u = POP(); + t = POP(); + err = assign_slice(u, v, w, t); /* u[v:w] = t */ + Py_DECREF(t); + Py_DECREF(u); + Py_XDECREF(v); + Py_XDECREF(w); + if (err == 0) continue; + break; + + case DELETE_SLICE+0: + case DELETE_SLICE+1: + case DELETE_SLICE+2: + case DELETE_SLICE+3: + if ((opcode-DELETE_SLICE) & 2) + w = POP(); + else + w = NULL; + if ((opcode-DELETE_SLICE) & 1) + v = POP(); + else + v = NULL; + u = POP(); + err = assign_slice(u, v, w, (PyObject *)NULL); + /* del u[v:w] */ + Py_DECREF(u); + Py_XDECREF(v); + Py_XDECREF(w); + if (err == 0) continue; + break; + + case STORE_SUBSCR: + w = TOP(); + v = SECOND(); + u = THIRD(); + STACKADJ(-3); + /* v[w] = u */ + err = PyObject_SetItem(v, w, u); + Py_DECREF(u); + Py_DECREF(v); + Py_DECREF(w); + if (err == 0) continue; + break; + + case DELETE_SUBSCR: + w = TOP(); + v = SECOND(); + STACKADJ(-2); + /* del v[w] */ + err = PyObject_DelItem(v, w); + Py_DECREF(v); + Py_DECREF(w); + if (err == 0) continue; + break; + + case PRINT_EXPR: + v = POP(); + w = PySys_GetObject("displayhook"); + if (w == NULL) { + PyErr_SetString(PyExc_RuntimeError, + "lost sys.displayhook"); + err = -1; + x = NULL; + } + if (err == 0) { + x = PyTuple_Pack(1, v); + if (x == NULL) + err = -1; + } + if (err == 0) { + w = PyEval_CallObject(w, x); + Py_XDECREF(w); + if (w == NULL) + err = -1; + } + Py_DECREF(v); + Py_XDECREF(x); + break; + + case PRINT_ITEM_TO: + w = stream = POP(); + /* fall through to PRINT_ITEM */ + + case PRINT_ITEM: + v = POP(); + if (stream == NULL || stream == Py_None) { + w = PySys_GetObject("stdout"); + if (w == NULL) { + PyErr_SetString(PyExc_RuntimeError, + "lost sys.stdout"); + err = -1; + } + } + /* PyFile_SoftSpace() can exececute arbitrary code + if sys.stdout is an instance with a __getattr__. + If __getattr__ raises an exception, w will + be freed, so we need to prevent that temporarily. */ + Py_XINCREF(w); + if (w != NULL && PyFile_SoftSpace(w, 0)) + err = PyFile_WriteString(" ", w); + if (err == 0) + err = PyFile_WriteObject(v, w, Py_PRINT_RAW); + if (err == 0) { + /* XXX move into writeobject() ? */ + if (PyString_Check(v)) { + char *s = PyString_AS_STRING(v); + Py_ssize_t len = PyString_GET_SIZE(v); + if (len == 0 || + !isspace(Py_CHARMASK(s[len-1])) || + s[len-1] == ' ') + PyFile_SoftSpace(w, 1); + } +#ifdef Py_USING_UNICODE + else if (PyUnicode_Check(v)) { + Py_UNICODE *s = PyUnicode_AS_UNICODE(v); + Py_ssize_t len = PyUnicode_GET_SIZE(v); + if (len == 0 || + !Py_UNICODE_ISSPACE(s[len-1]) || + s[len-1] == ' ') + PyFile_SoftSpace(w, 1); + } +#endif + else + PyFile_SoftSpace(w, 1); + } + Py_XDECREF(w); + Py_DECREF(v); + Py_XDECREF(stream); + stream = NULL; + if (err == 0) + continue; + break; + + case PRINT_NEWLINE_TO: + w = stream = POP(); + /* fall through to PRINT_NEWLINE */ + + case PRINT_NEWLINE: + if (stream == NULL || stream == Py_None) { + w = PySys_GetObject("stdout"); + if (w == NULL) + PyErr_SetString(PyExc_RuntimeError, + "lost sys.stdout"); + } + if (w != NULL) { + err = PyFile_WriteString("\n", w); + if (err == 0) + PyFile_SoftSpace(w, 0); + } + Py_XDECREF(stream); + stream = NULL; + break; + + +#ifdef CASE_TOO_BIG + default: switch (opcode) { +#endif + case RAISE_VARARGS: + u = v = w = NULL; + switch (oparg) { + case 3: + u = POP(); /* traceback */ + /* Fallthrough */ + case 2: + v = POP(); /* value */ + /* Fallthrough */ + case 1: + w = POP(); /* exc */ + case 0: /* Fallthrough */ + why = do_raise(w, v, u); + break; + default: + PyErr_SetString(PyExc_SystemError, + "bad RAISE_VARARGS oparg"); + why = WHY_EXCEPTION; + break; + } + break; + + case LOAD_LOCALS: + if ((x = f->f_locals) != NULL) { + Py_INCREF(x); + PUSH(x); + continue; + } + PyErr_SetString(PyExc_SystemError, "no locals"); + break; + + case RETURN_VALUE: + retval = POP(); + why = WHY_RETURN; + goto fast_block_end; + + case YIELD_VALUE: + retval = POP(); + f->f_stacktop = stack_pointer; + why = WHY_YIELD; + goto fast_yield; + + case EXEC_STMT: + w = TOP(); + v = SECOND(); + u = THIRD(); + STACKADJ(-3); + READ_TIMESTAMP(intr0); + err = exec_statement(f, u, v, w); + READ_TIMESTAMP(intr1); + Py_DECREF(u); + Py_DECREF(v); + Py_DECREF(w); + break; + + case POP_BLOCK: + { + PyTryBlock *b = PyFrame_BlockPop(f); + while (STACK_LEVEL() > b->b_level) { + v = POP(); + Py_DECREF(v); + } + } + continue; + + case END_FINALLY: + v = POP(); + if (PyInt_Check(v)) { + why = (enum why_code) PyInt_AS_LONG(v); + assert(why != WHY_YIELD); + if (why == WHY_RETURN || + why == WHY_CONTINUE) + retval = POP(); + } + else if (PyExceptionClass_Check(v) || PyString_Check(v)) { + w = POP(); + u = POP(); + PyErr_Restore(v, w, u); + why = WHY_RERAISE; + break; + } + else if (v != Py_None) { + PyErr_SetString(PyExc_SystemError, + "'finally' pops bad exception"); + why = WHY_EXCEPTION; + } + Py_DECREF(v); + break; + + case BUILD_CLASS: + u = TOP(); + v = SECOND(); + w = THIRD(); + STACKADJ(-2); + x = build_class(u, v, w); + SET_TOP(x); + Py_DECREF(u); + Py_DECREF(v); + Py_DECREF(w); + break; + + case STORE_NAME: + w = GETITEM(names, oparg); + v = POP(); + if ((x = f->f_locals) != NULL) { + if (PyDict_CheckExact(x)) + err = PyDict_SetItem(x, w, v); + else + err = PyObject_SetItem(x, w, v); + Py_DECREF(v); + if (err == 0) continue; + break; + } + PyErr_Format(PyExc_SystemError, + "no locals found when storing %s", + PyObject_REPR(w)); + break; + + case DELETE_NAME: + w = GETITEM(names, oparg); + if ((x = f->f_locals) != NULL) { + if ((err = PyObject_DelItem(x, w)) != 0) + format_exc_check_arg(PyExc_NameError, + NAME_ERROR_MSG ,w); + break; + } + PyErr_Format(PyExc_SystemError, + "no locals when deleting %s", + PyObject_REPR(w)); + break; + + PREDICTED_WITH_ARG(UNPACK_SEQUENCE); + case UNPACK_SEQUENCE: + v = POP(); + if (PyTuple_CheckExact(v) && PyTuple_GET_SIZE(v) == oparg) { + PyObject **items = ((PyTupleObject *)v)->ob_item; + while (oparg--) { + w = items[oparg]; + Py_INCREF(w); + PUSH(w); + } + Py_DECREF(v); + continue; + } else if (PyList_CheckExact(v) && PyList_GET_SIZE(v) == oparg) { + PyObject **items = ((PyListObject *)v)->ob_item; + while (oparg--) { + w = items[oparg]; + Py_INCREF(w); + PUSH(w); + } + } else if (unpack_iterable(v, oparg, + stack_pointer + oparg)) + stack_pointer += oparg; + else { + if (PyErr_ExceptionMatches(PyExc_TypeError)) + PyErr_SetString(PyExc_TypeError, + "unpack non-sequence"); + why = WHY_EXCEPTION; + } + Py_DECREF(v); + break; + + case STORE_ATTR: + w = GETITEM(names, oparg); + v = TOP(); + u = SECOND(); + STACKADJ(-2); + err = PyObject_SetAttr(v, w, u); /* v.w = u */ + Py_DECREF(v); + Py_DECREF(u); + if (err == 0) continue; + break; + + case DELETE_ATTR: + w = GETITEM(names, oparg); + v = POP(); + err = PyObject_SetAttr(v, w, (PyObject *)NULL); + /* del v.w */ + Py_DECREF(v); + break; + + case STORE_GLOBAL: + w = GETITEM(names, oparg); + v = POP(); + err = PyDict_SetItem(f->f_globals, w, v); + Py_DECREF(v); + if (err == 0) continue; + break; + + case DELETE_GLOBAL: + w = GETITEM(names, oparg); + if ((err = PyDict_DelItem(f->f_globals, w)) != 0) + format_exc_check_arg( + PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w); + break; + + case LOAD_NAME: + w = GETITEM(names, oparg); + if ((v = f->f_locals) == NULL) { + PyErr_Format(PyExc_SystemError, + "no locals when loading %s", + PyObject_REPR(w)); + break; + } + if (PyDict_CheckExact(v)) { + x = PyDict_GetItem(v, w); + Py_XINCREF(x); + } + else { + x = PyObject_GetItem(v, w); + if (x == NULL && PyErr_Occurred()) { + if (!PyErr_ExceptionMatches(PyExc_KeyError)) + break; + PyErr_Clear(); + } + } + if (x == NULL) { + x = PyDict_GetItem(f->f_globals, w); + if (x == NULL) { + x = PyDict_GetItem(f->f_builtins, w); + if (x == NULL) { + format_exc_check_arg( + PyExc_NameError, + NAME_ERROR_MSG ,w); + break; + } + } + Py_INCREF(x); + } + PUSH(x); + continue; + + case LOAD_GLOBAL: + w = GETITEM(names, oparg); + if (PyString_CheckExact(w)) { + /* Inline the PyDict_GetItem() calls. + WARNING: this is an extreme speed hack. + Do not try this at home. */ + long hash = ((PyStringObject *)w)->ob_shash; + if (hash != -1) { + PyDictObject *d; + PyDictEntry *e; + d = (PyDictObject *)(f->f_globals); + e = d->ma_lookup(d, w, hash); + if (e == NULL) { + x = NULL; + break; + } + x = e->me_value; + if (x != NULL) { + Py_INCREF(x); + PUSH(x); + continue; + } + d = (PyDictObject *)(f->f_builtins); + e = d->ma_lookup(d, w, hash); + if (e == NULL) { + x = NULL; + break; + } + x = e->me_value; + if (x != NULL) { + Py_INCREF(x); + PUSH(x); + continue; + } + goto load_global_error; + } + } + /* This is the un-inlined version of the code above */ + x = PyDict_GetItem(f->f_globals, w); + if (x == NULL) { + x = PyDict_GetItem(f->f_builtins, w); + if (x == NULL) { + load_global_error: + format_exc_check_arg( + PyExc_NameError, + GLOBAL_NAME_ERROR_MSG, w); + break; + } + } + Py_INCREF(x); + PUSH(x); + continue; + + case DELETE_FAST: + x = GETLOCAL(oparg); + if (x != NULL) { + SETLOCAL(oparg, NULL); + continue; + } + format_exc_check_arg( + PyExc_UnboundLocalError, + UNBOUNDLOCAL_ERROR_MSG, + PyTuple_GetItem(co->co_varnames, oparg) + ); + break; + + case LOAD_CLOSURE: + x = freevars[oparg]; + Py_INCREF(x); + PUSH(x); + if (x != NULL) continue; + break; + + case LOAD_DEREF: + x = freevars[oparg]; + w = PyCell_Get(x); + if (w != NULL) { + PUSH(w); + continue; + } + err = -1; + /* Don't stomp existing exception */ + if (PyErr_Occurred()) + break; + if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) { + v = PyTuple_GET_ITEM(co->co_cellvars, + oparg); + format_exc_check_arg( + PyExc_UnboundLocalError, + UNBOUNDLOCAL_ERROR_MSG, + v); + } else { + v = PyTuple_GET_ITEM( + co->co_freevars, + oparg - PyTuple_GET_SIZE(co->co_cellvars)); + format_exc_check_arg( + PyExc_NameError, + UNBOUNDFREE_ERROR_MSG, + v); + } + break; + + case STORE_DEREF: + w = POP(); + x = freevars[oparg]; + PyCell_Set(x, w); + Py_DECREF(w); + continue; + + case BUILD_TUPLE: + x = PyTuple_New(oparg); + if (x != NULL) { + for (; --oparg >= 0;) { + w = POP(); + PyTuple_SET_ITEM(x, oparg, w); + } + PUSH(x); + continue; + } + break; + + case BUILD_LIST: + x = PyList_New(oparg); + if (x != NULL) { + for (; --oparg >= 0;) { + w = POP(); + PyList_SET_ITEM(x, oparg, w); + } + PUSH(x); + continue; + } + break; + + case BUILD_MAP: + x = PyDict_New(); + PUSH(x); + if (x != NULL) continue; + break; + + case LOAD_ATTR: + w = GETITEM(names, oparg); + v = TOP(); + x = PyObject_GetAttr(v, w); + Py_DECREF(v); + SET_TOP(x); + if (x != NULL) continue; + break; + + case COMPARE_OP: + w = POP(); + v = TOP(); + if (PyInt_CheckExact(w) && PyInt_CheckExact(v)) { + /* INLINE: cmp(int, int) */ + register long a, b; + register int res; + a = PyInt_AS_LONG(v); + b = PyInt_AS_LONG(w); + switch (oparg) { + case PyCmp_LT: res = a < b; break; + case PyCmp_LE: res = a <= b; break; + case PyCmp_EQ: res = a == b; break; + case PyCmp_NE: res = a != b; break; + case PyCmp_GT: res = a > b; break; + case PyCmp_GE: res = a >= b; break; + case PyCmp_IS: res = v == w; break; + case PyCmp_IS_NOT: res = v != w; break; + default: goto slow_compare; + } + x = res ? Py_True : Py_False; + Py_INCREF(x); + } + else { + slow_compare: + x = cmp_outcome(oparg, v, w); + } + Py_DECREF(v); + Py_DECREF(w); + SET_TOP(x); + if (x == NULL) break; + PREDICT(JUMP_IF_FALSE); + PREDICT(JUMP_IF_TRUE); + continue; + + case IMPORT_NAME: + w = GETITEM(names, oparg); + x = PyDict_GetItemString(f->f_builtins, "__import__"); + if (x == NULL) { + PyErr_SetString(PyExc_ImportError, + "__import__ not found"); + break; + } + v = POP(); + u = TOP(); + if (PyInt_AsLong(u) != -1 || PyErr_Occurred()) + w = PyTuple_Pack(5, + w, + f->f_globals, + f->f_locals == NULL ? + Py_None : f->f_locals, + v, + u); + else + w = PyTuple_Pack(4, + w, + f->f_globals, + f->f_locals == NULL ? + Py_None : f->f_locals, + v); + Py_DECREF(v); + Py_DECREF(u); + if (w == NULL) { + u = POP(); + x = NULL; + break; + } + READ_TIMESTAMP(intr0); + x = PyEval_CallObject(x, w); + READ_TIMESTAMP(intr1); + Py_DECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case IMPORT_STAR: + v = POP(); + PyFrame_FastToLocals(f); + if ((x = f->f_locals) == NULL) { + PyErr_SetString(PyExc_SystemError, + "no locals found during 'import *'"); + break; + } + READ_TIMESTAMP(intr0); + err = import_all_from(x, v); + READ_TIMESTAMP(intr1); + PyFrame_LocalsToFast(f, 0); + Py_DECREF(v); + if (err == 0) continue; + break; + + case IMPORT_FROM: + w = GETITEM(names, oparg); + v = TOP(); + READ_TIMESTAMP(intr0); + x = import_from(v, w); + READ_TIMESTAMP(intr1); + PUSH(x); + if (x != NULL) continue; + break; + + case JUMP_FORWARD: + JUMPBY(oparg); + goto fast_next_opcode; + + PREDICTED_WITH_ARG(JUMP_IF_FALSE); + case JUMP_IF_FALSE: + w = TOP(); + if (w == Py_True) { + PREDICT(POP_TOP); + goto fast_next_opcode; + } + if (w == Py_False) { + JUMPBY(oparg); + goto fast_next_opcode; + } + err = PyObject_IsTrue(w); + if (err > 0) + err = 0; + else if (err == 0) + JUMPBY(oparg); + else + break; + continue; + + PREDICTED_WITH_ARG(JUMP_IF_TRUE); + case JUMP_IF_TRUE: + w = TOP(); + if (w == Py_False) { + PREDICT(POP_TOP); + goto fast_next_opcode; + } + if (w == Py_True) { + JUMPBY(oparg); + goto fast_next_opcode; + } + err = PyObject_IsTrue(w); + if (err > 0) { + err = 0; + JUMPBY(oparg); + } + else if (err == 0) + ; + else + break; + continue; + + PREDICTED_WITH_ARG(JUMP_ABSOLUTE); + case JUMP_ABSOLUTE: + JUMPTO(oparg); + continue; + + case GET_ITER: + /* before: [obj]; after [getiter(obj)] */ + v = TOP(); + x = PyObject_GetIter(v); + Py_DECREF(v); + if (x != NULL) { + SET_TOP(x); + PREDICT(FOR_ITER); + continue; + } + STACKADJ(-1); + break; + + PREDICTED_WITH_ARG(FOR_ITER); + case FOR_ITER: + /* before: [iter]; after: [iter, iter()] *or* [] */ + v = TOP(); + x = (*v->ob_type->tp_iternext)(v); + if (x != NULL) { + PUSH(x); + PREDICT(STORE_FAST); + PREDICT(UNPACK_SEQUENCE); + continue; + } + if (PyErr_Occurred()) { + if (!PyErr_ExceptionMatches(PyExc_StopIteration)) + break; + PyErr_Clear(); + } + /* iterator ended normally */ + x = v = POP(); + Py_DECREF(v); + JUMPBY(oparg); + continue; + + case BREAK_LOOP: + why = WHY_BREAK; + goto fast_block_end; + + case CONTINUE_LOOP: + retval = PyInt_FromLong(oparg); + if (!retval) { + x = NULL; + break; + } + why = WHY_CONTINUE; + goto fast_block_end; + + case SETUP_LOOP: + case SETUP_EXCEPT: + case SETUP_FINALLY: + /* NOTE: If you add any new block-setup opcodes that are not try/except/finally + handlers, you may need to update the PyGen_NeedsFinalizing() function. */ + + PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg, + STACK_LEVEL()); + continue; + + case WITH_CLEANUP: + { + /* TOP is the context.__exit__ bound method. + Below that are 1-3 values indicating how/why + we entered the finally clause: + - SECOND = None + - (SECOND, THIRD) = (WHY_{RETURN,CONTINUE}), retval + - SECOND = WHY_*; no retval below it + - (SECOND, THIRD, FOURTH) = exc_info() + In the last case, we must call + TOP(SECOND, THIRD, FOURTH) + otherwise we must call + TOP(None, None, None) + + In addition, if the stack represents an exception, + *and* the function call returns a 'true' value, we + "zap" this information, to prevent END_FINALLY from + re-raising the exception. (But non-local gotos + should still be resumed.) + */ + + x = TOP(); + u = SECOND(); + if (PyInt_Check(u) || u == Py_None) { + u = v = w = Py_None; + } + else { + v = THIRD(); + w = FOURTH(); + } + /* XXX Not the fastest way to call it... */ + x = PyObject_CallFunctionObjArgs(x, u, v, w, NULL); + if (x == NULL) + break; /* Go to error exit */ + if (u != Py_None && PyObject_IsTrue(x)) { + /* There was an exception and a true return */ + Py_DECREF(x); + x = TOP(); /* Again */ + STACKADJ(-3); + Py_INCREF(Py_None); + SET_TOP(Py_None); + Py_DECREF(x); + Py_DECREF(u); + Py_DECREF(v); + Py_DECREF(w); + } else { + /* Let END_FINALLY do its thing */ + Py_DECREF(x); + x = POP(); + Py_DECREF(x); + } + break; + } + + case CALL_FUNCTION: + { + PyObject **sp; + PCALL(PCALL_ALL); + sp = stack_pointer; +#ifdef WITH_TSC + x = call_function(&sp, oparg, &intr0, &intr1); +#else + x = call_function(&sp, oparg); +#endif + stack_pointer = sp; + PUSH(x); + if (x != NULL) + continue; + break; + } + + case CALL_FUNCTION_VAR: + case CALL_FUNCTION_KW: + case CALL_FUNCTION_VAR_KW: + { + int na = oparg & 0xff; + int nk = (oparg>>8) & 0xff; + int flags = (opcode - CALL_FUNCTION) & 3; + int n = na + 2 * nk; + PyObject **pfunc, *func, **sp; + PCALL(PCALL_ALL); + if (flags & CALL_FLAG_VAR) + n++; + if (flags & CALL_FLAG_KW) + n++; + pfunc = stack_pointer - n - 1; + func = *pfunc; + + if (PyMethod_Check(func) + && PyMethod_GET_SELF(func) != NULL) { + PyObject *self = PyMethod_GET_SELF(func); + Py_INCREF(self); + func = PyMethod_GET_FUNCTION(func); + Py_INCREF(func); + Py_DECREF(*pfunc); + *pfunc = self; + na++; + n++; + } else + Py_INCREF(func); + sp = stack_pointer; + READ_TIMESTAMP(intr0); + x = ext_do_call(func, &sp, flags, na, nk); + READ_TIMESTAMP(intr1); + stack_pointer = sp; + Py_DECREF(func); + + while (stack_pointer > pfunc) { + w = POP(); + Py_DECREF(w); + } + PUSH(x); + if (x != NULL) + continue; + break; + } + + case MAKE_FUNCTION: + v = POP(); /* code object */ + x = PyFunction_New(v, f->f_globals); + Py_DECREF(v); + /* XXX Maybe this should be a separate opcode? */ + if (x != NULL && oparg > 0) { + v = PyTuple_New(oparg); + if (v == NULL) { + Py_DECREF(x); + x = NULL; + break; + } + while (--oparg >= 0) { + w = POP(); + PyTuple_SET_ITEM(v, oparg, w); + } + err = PyFunction_SetDefaults(x, v); + Py_DECREF(v); + } + PUSH(x); + break; + + case MAKE_CLOSURE: + { + v = POP(); /* code object */ + x = PyFunction_New(v, f->f_globals); + Py_DECREF(v); + if (x != NULL) { + v = POP(); + err = PyFunction_SetClosure(x, v); + Py_DECREF(v); + } + if (x != NULL && oparg > 0) { + v = PyTuple_New(oparg); + if (v == NULL) { + Py_DECREF(x); + x = NULL; + break; + } + while (--oparg >= 0) { + w = POP(); + PyTuple_SET_ITEM(v, oparg, w); + } + err = PyFunction_SetDefaults(x, v); + Py_DECREF(v); + } + PUSH(x); + break; + } + + case BUILD_SLICE: + if (oparg == 3) + w = POP(); + else + w = NULL; + v = POP(); + u = TOP(); + x = PySlice_New(u, v, w); + Py_DECREF(u); + Py_DECREF(v); + Py_XDECREF(w); + SET_TOP(x); + if (x != NULL) continue; + break; + + case EXTENDED_ARG: + opcode = NEXTOP(); + oparg = oparg<<16 | NEXTARG(); + goto dispatch_opcode; + + default: + fprintf(stderr, + "XXX lineno: %d, opcode: %d\n", + PyCode_Addr2Line(f->f_code, f->f_lasti), + opcode); + PyErr_SetString(PyExc_SystemError, "unknown opcode"); + why = WHY_EXCEPTION; + break; + +#ifdef CASE_TOO_BIG + } +#endif + + } /* switch */ + + on_error: + + READ_TIMESTAMP(inst1); + + /* Quickly continue if no error occurred */ + + if (why == WHY_NOT) { + if (err == 0 && x != NULL) { +#ifdef CHECKEXC + /* This check is expensive! */ + if (PyErr_Occurred()) + fprintf(stderr, + "XXX undetected error\n"); + else { +#endif + READ_TIMESTAMP(loop1); + continue; /* Normal, fast path */ +#ifdef CHECKEXC + } +#endif + } + why = WHY_EXCEPTION; + x = Py_None; + err = 0; + } + + /* Double-check exception status */ + + if (why == WHY_EXCEPTION || why == WHY_RERAISE) { + if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_SystemError, + "error return without exception set"); + why = WHY_EXCEPTION; + } + } +#ifdef CHECKEXC + else { + /* This check is expensive! */ + if (PyErr_Occurred()) { + char buf[1024]; + sprintf(buf, "Stack unwind with exception " + "set and why=%d", why); + Py_FatalError(buf); + } + } +#endif + + /* Log traceback info if this is a real exception */ + + if (why == WHY_EXCEPTION) { + PyTraceBack_Here(f); + + if (tstate->c_tracefunc != NULL) + call_exc_trace(tstate->c_tracefunc, + tstate->c_traceobj, f); + } + + /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */ + + if (why == WHY_RERAISE) + why = WHY_EXCEPTION; + + /* Unwind stacks if a (pseudo) exception occurred */ + +fast_block_end: + while (why != WHY_NOT && f->f_iblock > 0) { + PyTryBlock *b = PyFrame_BlockPop(f); + + assert(why != WHY_YIELD); + if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) { + /* For a continue inside a try block, + don't pop the block for the loop. */ + PyFrame_BlockSetup(f, b->b_type, b->b_handler, + b->b_level); + why = WHY_NOT; + JUMPTO(PyInt_AS_LONG(retval)); + Py_DECREF(retval); + break; + } + + while (STACK_LEVEL() > b->b_level) { + v = POP(); + Py_XDECREF(v); + } + if (b->b_type == SETUP_LOOP && why == WHY_BREAK) { + why = WHY_NOT; + JUMPTO(b->b_handler); + break; + } + if (b->b_type == SETUP_FINALLY || + (b->b_type == SETUP_EXCEPT && + why == WHY_EXCEPTION)) { + if (why == WHY_EXCEPTION) { + PyObject *exc, *val, *tb; + PyErr_Fetch(&exc, &val, &tb); + if (val == NULL) { + val = Py_None; + Py_INCREF(val); + } + /* Make the raw exception data + available to the handler, + so a program can emulate the + Python main loop. Don't do + this for 'finally'. */ + if (b->b_type == SETUP_EXCEPT) { + PyErr_NormalizeException( + &exc, &val, &tb); + set_exc_info(tstate, + exc, val, tb); + } + if (tb == NULL) { + Py_INCREF(Py_None); + PUSH(Py_None); + } else + PUSH(tb); + PUSH(val); + PUSH(exc); + } + else { + if (why & (WHY_RETURN | WHY_CONTINUE)) + PUSH(retval); + v = PyInt_FromLong((long)why); + PUSH(v); + } + why = WHY_NOT; + JUMPTO(b->b_handler); + break; + } + } /* unwind stack */ + + /* End the loop if we still have an error (or return) */ + + if (why != WHY_NOT) + break; + READ_TIMESTAMP(loop1); + + } /* main loop */ + + assert(why != WHY_YIELD); + /* Pop remaining stack entries. */ + while (!EMPTY()) { + v = POP(); + Py_XDECREF(v); + } + + if (why != WHY_RETURN) + retval = NULL; + +fast_yield: + if (tstate->use_tracing) { + if (tstate->c_tracefunc) { + if (why == WHY_RETURN || why == WHY_YIELD) { + if (call_trace(tstate->c_tracefunc, + tstate->c_traceobj, f, + PyTrace_RETURN, retval)) { + Py_XDECREF(retval); + retval = NULL; + why = WHY_EXCEPTION; + } + } + else if (why == WHY_EXCEPTION) { + call_trace_protected(tstate->c_tracefunc, + tstate->c_traceobj, f, + PyTrace_RETURN, NULL); + } + } + if (tstate->c_profilefunc) { + if (why == WHY_EXCEPTION) + call_trace_protected(tstate->c_profilefunc, + tstate->c_profileobj, f, + PyTrace_RETURN, NULL); + else if (call_trace(tstate->c_profilefunc, + tstate->c_profileobj, f, + PyTrace_RETURN, retval)) { + Py_XDECREF(retval); + retval = NULL; + why = WHY_EXCEPTION; + } + } + } + + if (tstate->frame->f_exc_type != NULL) + reset_exc_info(tstate); + else { + assert(tstate->frame->f_exc_value == NULL); + assert(tstate->frame->f_exc_traceback == NULL); + } + + /* pop frame */ + exit_eval_frame: + Py_LeaveRecursiveCall(); + tstate->frame = f->f_back; + + return retval; +} + + +---tokens--- +'/* Execute compiled code */' Comment.Multiline +'\n' Text + +'\n' Text + +'/* XXX TO DO:\n XXX speed up searching for keywords by using a dictionary\n XXX document it!\n */' Comment.Multiline +'\n' Text + +'\n' Text + +'/* enable more aggressive intra-module optimizations, where available */' Comment.Multiline +'\n' Text + +'#' Comment.Preproc +'define PY_LOCAL_AGGRESSIVE' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'include' Comment.Preproc +' ' Text +'"Python.h"' Comment.PreprocFile +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'include' Comment.Preproc +' ' Text +'"code.h"' Comment.PreprocFile +'\n' Comment.Preproc + +'#' Comment.Preproc +'include' Comment.Preproc +' ' Text +'"frameobject.h"' Comment.PreprocFile +'\n' Comment.Preproc + +'#' Comment.Preproc +'include' Comment.Preproc +' ' Text +'"eval.h"' Comment.PreprocFile +'\n' Comment.Preproc + +'#' Comment.Preproc +'include' Comment.Preproc +' ' Text +'"opcode.h"' Comment.PreprocFile +'\n' Comment.Preproc + +'#' Comment.Preproc +'include' Comment.Preproc +' ' Text +'"structmember.h"' Comment.PreprocFile +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'include' Comment.Preproc +' ' Text +'<ctype.h>' Comment.PreprocFile +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'ifndef WITH_TSC' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'define READ_TIMESTAMP(var)' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'else' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'typedef' Keyword +' ' Text +'unsigned' Keyword.Type +' ' Text +'long' Keyword.Type +' ' Text +'long' Keyword.Type +' ' Text +'uint64' Name +';' Punctuation +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'if defined(__ppc__) ' Comment.Preproc +"/* <- Don't know if this is the correct symbol; this\n\t\t\t section should work for GCC on any PowerPC platform,\n\t\t\t irrespective of OS. POWER? Who knows :-) */" Comment.Multiline +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'define READ_TIMESTAMP(var) ppc_getcounter(&var)' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'static' Keyword +' ' Text +'void' Keyword.Type +'\n' Text + +'ppc_getcounter' Name +'(' Punctuation +'uint64' Name +' ' Text +'*' Operator +'v' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'unsigned' Keyword.Type +' ' Text +'long' Keyword.Type +' ' Text +'tbu' Name +',' Punctuation +' ' Text +'tb' Name +',' Punctuation +' ' Text +'tbu2' Name +';' Punctuation +'\n' Text + +'\n' Text + +' ' Text +'loop' Name.Label +':' Punctuation +'\n' Text + +'\t' Text +'asm' Keyword +' ' Text +'volatile' Keyword +' ' Text +'(' Punctuation +'"' Literal.String +'mftbu %0' Literal.String +'"' Literal.String +' ' Text +':' Operator +' ' Text +'"' Literal.String +'=r' Literal.String +'"' Literal.String +' ' Text +'(' Punctuation +'tbu' Name +')' Punctuation +' ' Text +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'asm' Keyword +' ' Text +'volatile' Name.Function +' ' Text +'(' Punctuation +'"' Literal.String +'mftb %0' Literal.String +'"' Literal.String +' ' Text +':' Operator +' ' Text +'"' Literal.String +'=r' Literal.String +'"' Literal.String +' ' Text +'(' Punctuation +'tb' Name +')' Punctuation +' ' Text +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'asm' Keyword +' ' Text +'volatile' Name.Function +' ' Text +'(' Punctuation +'"' Literal.String +'mftbu %0' Literal.String +'"' Literal.String +' ' Text +':' Operator +' ' Text +'"' Literal.String +'=r' Literal.String +'"' Literal.String +' ' Text +'(' Punctuation +'tbu2' Name +')' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'__builtin_expect' Name +'(' Punctuation +'tbu' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'tbu2' Name +',' Punctuation +' ' Text +'0' Literal.Number.Integer +')' Punctuation +')' Punctuation +' ' Text +'goto' Keyword +' ' Text +'loop' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'/* The slightly peculiar way of writing the next lines is\n\t compiled better by GCC than any other way I tried. */' Comment.Multiline +'\n' Text + +'\t' Text +'(' Punctuation +'(' Punctuation +'long' Keyword.Type +'*' Operator +')' Punctuation +'(' Punctuation +'v' Name +')' Punctuation +')' Punctuation +'[' Punctuation +'0' Literal.Number.Integer +']' Punctuation +' ' Text +'=' Operator +' ' Text +'tbu' Name +';' Punctuation +'\n' Text + +'\t' Text +'(' Punctuation +'(' Punctuation +'long' Keyword.Type +'*' Operator +')' Punctuation +'(' Punctuation +'v' Name +')' Punctuation +')' Punctuation +'[' Punctuation +'1' Literal.Number.Integer +']' Punctuation +' ' Text +'=' Operator +' ' Text +'tb' Name +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'else ' Comment.Preproc +'/* this is for linux/x86 (and probably any other GCC/x86 combo) */' Comment.Multiline +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'define READ_TIMESTAMP(val) \\' Comment.Preproc +'\n' Comment.Preproc + +' __asm__ __volatile__("rdtsc" : "=A" (val))' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'void' Keyword.Type +' ' Text +'dump_tsc' Name +'(' Punctuation +'int' Keyword.Type +' ' Text +'opcode' Name +',' Punctuation +' ' Text +'int' Keyword.Type +' ' Text +'ticked' Name +',' Punctuation +' ' Text +'uint64' Name +' ' Text +'inst0' Name +',' Punctuation +' ' Text +'uint64' Name +' ' Text +'inst1' Name +',' Punctuation +'\n' Text + +'\t ' Text +'uint64' Name +' ' Text +'loop0' Name +',' Punctuation +' ' Text +'uint64' Name +' ' Text +'loop1' Name +',' Punctuation +' ' Text +'uint64' Name +' ' Text +'intr0' Name +',' Punctuation +' ' Text +'uint64' Name +' ' Text +'intr1' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'uint64' Name +' ' Text +'intr' Name +',' Punctuation +' ' Text +'inst' Name +',' Punctuation +' ' Text +'loop' Name +';' Punctuation +'\n' Text + +'\t' Text +'PyThreadState' Name +' ' Text +'*' Operator +'tstate' Name +' ' Text +'=' Operator +' ' Text +'PyThreadState_Get' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'!' Operator +'tstate' Name +'-' Operator +'>' Operator +'interp' Name +'-' Operator +'>' Operator +'tscdump' Name +')' Punctuation +'\n' Text + +'\t\t' Text +'return' Keyword +';' Punctuation +'\n' Text + +'\t' Text +'intr' Name +' ' Text +'=' Operator +' ' Text +'intr1' Name +' ' Text +'-' Operator +' ' Text +'intr0' Name +';' Punctuation +'\n' Text + +'\t' Text +'inst' Name +' ' Text +'=' Operator +' ' Text +'inst1' Name +' ' Text +'-' Operator +' ' Text +'inst0' Name +' ' Text +'-' Operator +' ' Text +'intr' Name +';' Punctuation +'\n' Text + +'\t' Text +'loop' Name +' ' Text +'=' Operator +' ' Text +'loop1' Name +' ' Text +'-' Operator +' ' Text +'loop0' Name +' ' Text +'-' Operator +' ' Text +'intr' Name +';' Punctuation +'\n' Text + +'\t' Text +'fprintf' Name +'(' Punctuation +'stderr' Name +',' Punctuation +' ' Text +'"' Literal.String +'opcode=%03d t=%d inst=%06lld loop=%06lld' Literal.String +'\\n' Literal.String.Escape +'"' Literal.String +',' Punctuation +'\n' Text + +'\t\t' Text +'opcode' Name +',' Punctuation +' ' Text +'ticked' Name +',' Punctuation +' ' Text +'inst' Name +',' Punctuation +' ' Text +'loop' Name +')' Punctuation +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'/* Turn this on if your compiler chokes on the big switch: */' Comment.Multiline +'\n' Text + +'/* #define CASE_TOO_BIG 1 */' Comment.Multiline +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'ifdef Py_DEBUG' Comment.Preproc +'\n' Comment.Preproc + +'/* For debugging the interpreter: */' Comment.Multiline +'\n' Text + +'#' Comment.Preproc +'define LLTRACE 1\t' Comment.Preproc +'/* Low-level trace feature */' Comment.Multiline +'\n' Comment.Preproc + +'#' Comment.Preproc +'define CHECKEXC 1\t' Comment.Preproc +'/* Double-check exception checking */' Comment.Multiline +'\n' Comment.Preproc + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'typedef' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'(' Punctuation +'*' Operator +'callproc' Name +')' Punctuation +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'/* Forward declarations */' Comment.Multiline +'\n' Text + +'#' Comment.Preproc +'ifdef WITH_TSC' Comment.Preproc +'\n' Comment.Preproc + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'call_function' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +',' Punctuation +' ' Text +'uint64' Name +'*' Operator +',' Punctuation +' ' Text +'uint64' Name +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'else' Comment.Preproc +'\n' Comment.Preproc + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'call_function' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +')' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'fast_function' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +',' Punctuation +' ' Text +'int' Keyword.Type +',' Punctuation +' ' Text +'int' Keyword.Type +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'do_call' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +',' Punctuation +' ' Text +'int' Keyword.Type +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'ext_do_call' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +',' Punctuation +' ' Text +'int' Keyword.Type +',' Punctuation +' ' Text +'int' Keyword.Type +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'update_keyword_args' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'*' Operator +',' Punctuation +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'update_star_args' Name +'(' Punctuation +'int' Keyword.Type +',' Punctuation +' ' Text +'int' Keyword.Type +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'load_args' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +')' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'define CALL_FLAG_VAR 1' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define CALL_FLAG_KW 2' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'ifdef LLTRACE' Comment.Preproc +'\n' Comment.Preproc + +'static' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'lltrace' Name +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'prtrace' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'char' Keyword.Type +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'static' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'call_trace' Name +'(' Punctuation +'Py_tracefunc' Name +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyFrameObject' Name +' ' Text +'*' Operator +',' Punctuation +'\n' Text + +'\t\t ' Text +'int' Keyword.Type +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'void' Keyword.Type +' ' Text +'call_trace_protected' Name +'(' Punctuation +'Py_tracefunc' Name +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'PyFrameObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'void' Keyword.Type +' ' Text +'call_exc_trace' Name +'(' Punctuation +'Py_tracefunc' Name +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyFrameObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'maybe_call_line_trace' Name +'(' Punctuation +'Py_tracefunc' Name +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'PyFrameObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +' ' Text +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +' ' Text +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'apply_slice' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'assign_slice' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +'\n' Text + +'\t\t\t' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'cmp_outcome' Name +'(' Punctuation +'int' Keyword.Type +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'import_from' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'import_all_from' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'build_class' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'exec_statement' Name +'(' Punctuation +'PyFrameObject' Name +' ' Text +'*' Operator +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'void' Keyword.Type +' ' Text +'set_exc_info' Name +'(' Punctuation +'PyThreadState' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'void' Keyword.Type +' ' Text +'reset_exc_info' Name +'(' Punctuation +'PyThreadState' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'void' Keyword.Type +' ' Text +'format_exc_check_arg' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'char' Keyword.Type +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +' ' Text +'string_concatenate' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'PyFrameObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'unsigned' Keyword.Type +' ' Text +'char' Keyword.Type +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'define NAME_ERROR_MSG \\' Comment.Preproc +'\n' Comment.Preproc + +'\t"name \'%.200s\' is not defined"' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define GLOBAL_NAME_ERROR_MSG \\' Comment.Preproc +'\n' Comment.Preproc + +'\t"global name \'%.200s\' is not defined"' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define UNBOUNDLOCAL_ERROR_MSG \\' Comment.Preproc +'\n' Comment.Preproc + +'\t"local variable \'%.200s\' referenced before assignment"' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define UNBOUNDFREE_ERROR_MSG \\' Comment.Preproc +'\n' Comment.Preproc + +'\t"free variable \'%.200s\' referenced before assignment" \\' Comment.Preproc +'\n' Comment.Preproc + +' " in enclosing scope"' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'/* Dynamic execution profile */' Comment.Multiline +'\n' Text + +'#' Comment.Preproc +'ifdef DYNAMIC_EXECUTION_PROFILE' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'ifdef DXPAIRS' Comment.Preproc +'\n' Comment.Preproc + +'static' Keyword +' ' Text +'long' Keyword.Type +' ' Text +'dxpairs' Name +'[' Punctuation +'257' Literal.Number.Integer +']' Punctuation +'[' Punctuation +'256' Literal.Number.Integer +']' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'define dxp dxpairs[256]' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'else' Comment.Preproc +'\n' Comment.Preproc + +'static' Keyword +' ' Text +'long' Keyword.Type +' ' Text +'dxp' Name +'[' Punctuation +'256' Literal.Number.Integer +']' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'/* Function call profile */' Comment.Multiline +'\n' Text + +'#' Comment.Preproc +'ifdef CALL_PROFILE' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL_NUM 11' Comment.Preproc +'\n' Comment.Preproc + +'static' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'pcall' Name +'[' Punctuation +'PCALL_NUM' Name +']' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'define PCALL_ALL 0' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL_FUNCTION 1' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL_FAST_FUNCTION 2' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL_FASTER_FUNCTION 3' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL_METHOD 4' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL_BOUND_METHOD 5' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL_CFUNCTION 6' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL_TYPE 7' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL_GENERATOR 8' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL_OTHER 9' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL_POP 10' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'/* Notes about the statistics\n\n PCALL_FAST stats\n\n FAST_FUNCTION means no argument tuple needs to be created.\n FASTER_FUNCTION means that the fast-path frame setup code is used.\n\n If there is a method call where the call can be optimized by changing\n the argument tuple and calling the function directly, it gets recorded\n twice.\n\n As a result, the relationship among the statistics appears to be\n PCALL_ALL == PCALL_FUNCTION + PCALL_METHOD - PCALL_BOUND_METHOD +\n PCALL_CFUNCTION + PCALL_TYPE + PCALL_GENERATOR + PCALL_OTHER\n PCALL_FUNCTION > PCALL_FAST_FUNCTION > PCALL_FASTER_FUNCTION\n PCALL_METHOD > PCALL_BOUND_METHOD\n*/' Comment.Multiline +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'define PCALL(POS) pcall[POS]++' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'PyObject' Name +' ' Text +'*' Operator +'\n' Text + +'PyEval_GetCallStats' Name.Function +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +'self' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'return' Keyword +' ' Text +'Py_BuildValue' Name +'(' Punctuation +'"' Literal.String +'iiiiiiiiii' Literal.String +'"' Literal.String +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'pcall' Name +'[' Punctuation +'0' Literal.Number.Integer +']' Punctuation +',' Punctuation +' ' Text +'pcall' Name +'[' Punctuation +'1' Literal.Number.Integer +']' Punctuation +',' Punctuation +' ' Text +'pcall' Name +'[' Punctuation +'2' Literal.Number.Integer +']' Punctuation +',' Punctuation +' ' Text +'pcall' Name +'[' Punctuation +'3' Literal.Number.Integer +']' Punctuation +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'pcall' Name +'[' Punctuation +'4' Literal.Number.Integer +']' Punctuation +',' Punctuation +' ' Text +'pcall' Name +'[' Punctuation +'5' Literal.Number.Integer +']' Punctuation +',' Punctuation +' ' Text +'pcall' Name +'[' Punctuation +'6' Literal.Number.Integer +']' Punctuation +',' Punctuation +' ' Text +'pcall' Name +'[' Punctuation +'7' Literal.Number.Integer +']' Punctuation +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'pcall' Name +'[' Punctuation +'8' Literal.Number.Integer +']' Punctuation +',' Punctuation +' ' Text +'pcall' Name +'[' Punctuation +'9' Literal.Number.Integer +']' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'else' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PCALL(O)' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'PyObject' Name +' ' Text +'*' Operator +'\n' Text + +'PyEval_GetCallStats' Name.Function +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +'self' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'Py_INCREF' Name +'(' Punctuation +'Py_None' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'return' Keyword +' ' Text +'Py_None' Name +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'ifdef WITH_THREAD' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'ifdef HAVE_ERRNO_H' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'include' Comment.Preproc +' ' Text +'<errno.h>' Comment.PreprocFile +'\n' Comment.Preproc + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'include' Comment.Preproc +' ' Text +'"pythread.h"' Comment.PreprocFile +'\n' Comment.Preproc + +'\n' Text + +'static' Keyword +' ' Text +'PyThread_type_lock' Name +' ' Text +'interpreter_lock' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +' ' Text +'/* This is the GIL */' Comment.Multiline +'\n' Text + +'static' Keyword +' ' Text +'long' Keyword.Type +' ' Text +'main_thread' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\n' Text + +'int' Keyword.Type +'\n' Text + +'PyEval_ThreadsInitialized' Name.Function +'(' Punctuation +'void' Keyword.Type +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'return' Keyword +' ' Text +'interpreter_lock' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'void' Keyword.Type +'\n' Text + +'PyEval_InitThreads' Name.Function +'(' Punctuation +'void' Keyword.Type +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'interpreter_lock' Name +')' Punctuation +'\n' Text + +'\t\t' Text +'return' Keyword +';' Punctuation +'\n' Text + +'\t' Text +'interpreter_lock' Name +' ' Text +'=' Operator +' ' Text +'PyThread_allocate_lock' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'PyThread_acquire_lock' Name +'(' Punctuation +'interpreter_lock' Name +',' Punctuation +' ' Text +'1' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'main_thread' Name +' ' Text +'=' Operator +' ' Text +'PyThread_get_thread_ident' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'void' Keyword.Type +'\n' Text + +'PyEval_AcquireLock' Name.Function +'(' Punctuation +'void' Keyword.Type +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'PyThread_acquire_lock' Name +'(' Punctuation +'interpreter_lock' Name +',' Punctuation +' ' Text +'1' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'void' Keyword.Type +'\n' Text + +'PyEval_ReleaseLock' Name.Function +'(' Punctuation +'void' Keyword.Type +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'PyThread_release_lock' Name +'(' Punctuation +'interpreter_lock' Name +')' Punctuation +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'void' Keyword.Type +'\n' Text + +'PyEval_AcquireThread' Name.Function +'(' Punctuation +'PyThreadState' Name +' ' Text +'*' Operator +'tstate' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t' Text +'Py_FatalError' Name +'(' Punctuation +'"' Literal.String +'PyEval_AcquireThread: NULL new thread state' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'/* Check someone has called PyEval_InitThreads() to create the lock */' Comment.Multiline +'\n' Text + +'\t' Text +'assert' Name +'(' Punctuation +'interpreter_lock' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'PyThread_acquire_lock' Name +'(' Punctuation +'interpreter_lock' Name +',' Punctuation +' ' Text +'1' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyThreadState_Swap' Name +'(' Punctuation +'tstate' Name +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t' Text +'Py_FatalError' Name +'(' Punctuation +'\n' Text + +'\t\t\t' Text +'"' Literal.String +'PyEval_AcquireThread: non-NULL old thread state' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'void' Keyword.Type +'\n' Text + +'PyEval_ReleaseThread' Name.Function +'(' Punctuation +'PyThreadState' Name +' ' Text +'*' Operator +'tstate' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t' Text +'Py_FatalError' Name +'(' Punctuation +'"' Literal.String +'PyEval_ReleaseThread: NULL thread state' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyThreadState_Swap' Name +'(' Punctuation +'NULL' Name.Builtin +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'tstate' Name +')' Punctuation +'\n' Text + +'\t\t' Text +'Py_FatalError' Name +'(' Punctuation +'"' Literal.String +'PyEval_ReleaseThread: wrong thread state' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'PyThread_release_lock' Name +'(' Punctuation +'interpreter_lock' Name +')' Punctuation +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +"/* This function is called from PyOS_AfterFork to ensure that newly\n created child processes don't hold locks referring to threads which\n are not running in the child process. (This could also be done using\n pthread_atfork mechanism, at least for the pthreads implementation.) */" Comment.Multiline +'\n' Text + +'\n' Text + +'void' Keyword.Type +'\n' Text + +'PyEval_ReInitThreads' Name.Function +'(' Punctuation +'void' Keyword.Type +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'!' Operator +'interpreter_lock' Name +')' Punctuation +'\n' Text + +'\t\t' Text +'return' Keyword +';' Punctuation +'\n' Text + +'\t' Text +"/*XXX Can't use PyThread_free_lock here because it does too\n\t much error-checking. Doing this cleanly would require\n\t adding a new function to each thread_*.h. Instead, just\n\t create a new lock and waste a little bit of memory */" Comment.Multiline +'\n' Text + +'\t' Text +'interpreter_lock' Name +' ' Text +'=' Operator +' ' Text +'PyThread_allocate_lock' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'PyThread_acquire_lock' Name +'(' Punctuation +'interpreter_lock' Name +',' Punctuation +' ' Text +'1' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'main_thread' Name +' ' Text +'=' Operator +' ' Text +'PyThread_get_thread_ident' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +"/* Functions save_thread and restore_thread are always defined so\n dynamically loaded modules needn't be compiled separately for use\n with and without threads: */" Comment.Multiline +'\n' Text + +'\n' Text + +'PyThreadState' Name +' ' Text +'*' Operator +'\n' Text + +'PyEval_SaveThread' Name.Function +'(' Punctuation +'void' Keyword.Type +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'PyThreadState' Name +' ' Text +'*' Operator +'tstate' Name +' ' Text +'=' Operator +' ' Text +'PyThreadState_Swap' Name +'(' Punctuation +'NULL' Name.Builtin +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t' Text +'Py_FatalError' Name +'(' Punctuation +'"' Literal.String +'PyEval_SaveThread: NULL tstate' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef WITH_THREAD' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'interpreter_lock' Name +')' Punctuation +'\n' Text + +'\t\t' Text +'PyThread_release_lock' Name +'(' Punctuation +'interpreter_lock' Name +')' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'return' Keyword +' ' Text +'tstate' Name +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'void' Keyword.Type +'\n' Text + +'PyEval_RestoreThread' Name.Function +'(' Punctuation +'PyThreadState' Name +' ' Text +'*' Operator +'tstate' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t' Text +'Py_FatalError' Name +'(' Punctuation +'"' Literal.String +'PyEval_RestoreThread: NULL tstate' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef WITH_THREAD' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'interpreter_lock' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t' Text +'int' Keyword.Type +' ' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'errno' Name +';' Punctuation +'\n' Text + +'\t\t' Text +'PyThread_acquire_lock' Name +'(' Punctuation +'interpreter_lock' Name +',' Punctuation +' ' Text +'1' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'errno' Name +' ' Text +'=' Operator +' ' Text +'err' Name +';' Punctuation +'\n' Text + +'\t' Text +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'PyThreadState_Swap' Name +'(' Punctuation +'tstate' Name +')' Punctuation +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'\n' Text + +'/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX\n signal handlers or Mac I/O completion routines) can schedule calls\n to a function to be called synchronously.\n The synchronous function is called with one void* argument.\n It should return 0 for success or -1 for failure -- failure should\n be accompanied by an exception.\n\n If registry succeeds, the registry function returns 0; if it fails\n (e.g. due to too many pending calls) it returns -1 (without setting\n an exception condition).\n\n Note that because registry may occur from within signal handlers,\n or other asynchronous events, calling malloc() is unsafe!\n\n#ifdef WITH_THREAD\n Any thread can schedule pending calls, but only the main thread\n will execute them.\n#endif\n\n XXX WARNING! ASYNCHRONOUSLY EXECUTING CODE!\n There are two possible race conditions:\n (1) nested asynchronous registry calls;\n (2) registry calls made while pending calls are being processed.\n While (1) is very unlikely, (2) is a real possibility.\n The current code is safe against (2), but not against (1).\n The safety against (2) is derived from the fact that only one\n thread (the main thread) ever takes things out of the queue.\n\n XXX Darn! With the advent of thread state, we should have an array\n of pending calls per thread in the thread state! Later...\n*/' Comment.Multiline +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'define NPENDINGCALLS 32' Comment.Preproc +'\n' Comment.Preproc + +'static' Keyword +' ' Text +'struct' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t' Text +'int' Keyword.Type +' ' Text +'(' Punctuation +'*' Operator +'func' Name +')' Punctuation +'(' Punctuation +'void' Keyword.Type +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'void' Keyword.Type +' ' Text +'*' Operator +'arg' Name +';' Punctuation +'\n' Text + +'}' Punctuation +' ' Text +'pendingcalls' Name +'[' Punctuation +'NPENDINGCALLS' Name +']' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'volatile' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'pendingfirst' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'volatile' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'pendinglast' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'volatile' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'things_to_do' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\n' Text + +'int' Keyword.Type +'\n' Text + +'Py_AddPendingCall' Name.Function +'(' Punctuation +'int' Keyword.Type +' ' Text +'(' Punctuation +'*' Operator +'func' Name +')' Punctuation +'(' Punctuation +'void' Keyword.Type +' ' Text +'*' Operator +')' Punctuation +',' Punctuation +' ' Text +'void' Keyword.Type +' ' Text +'*' Operator +'arg' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'static' Keyword +' ' Text +'volatile' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'busy' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'int' Keyword.Type +' ' Text +'i' Name +',' Punctuation +' ' Text +'j' Name +';' Punctuation +'\n' Text + +'\t' Text +'/* XXX Begin critical section */' Comment.Multiline +'\n' Text + +'\t' Text +"/* XXX If you want this to be safe against nested\n\t XXX asynchronous calls, you'll have to work harder! */" Comment.Multiline +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'busy' Name +')' Punctuation +'\n' Text + +'\t\t' Text +'return' Keyword +' ' Text +'-1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'busy' Name +' ' Text +'=' Operator +' ' Text +'1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'i' Name +' ' Text +'=' Operator +' ' Text +'pendinglast' Name +';' Punctuation +'\n' Text + +'\t' Text +'j' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'i' Name +' ' Text +'+' Operator +' ' Text +'1' Literal.Number.Integer +')' Punctuation +' ' Text +'%' Operator +' ' Text +'NPENDINGCALLS' Name +';' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'j' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'pendingfirst' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t' Text +'busy' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t' Text +'return' Keyword +' ' Text +'-1' Literal.Number.Integer +';' Punctuation +' ' Text +'/* Queue full */' Comment.Multiline +'\n' Text + +'\t' Text +'}' Punctuation +'\n' Text + +'\t' Text +'pendingcalls' Name +'[' Punctuation +'i' Name +']' Punctuation +'.' Punctuation +'func' Name +' ' Text +'=' Operator +' ' Text +'func' Name +';' Punctuation +'\n' Text + +'\t' Text +'pendingcalls' Name +'[' Punctuation +'i' Name +']' Punctuation +'.' Punctuation +'arg' Name +' ' Text +'=' Operator +' ' Text +'arg' Name +';' Punctuation +'\n' Text + +'\t' Text +'pendinglast' Name +' ' Text +'=' Operator +' ' Text +'j' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'_Py_Ticker' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'things_to_do' Name +' ' Text +'=' Operator +' ' Text +'1' Literal.Number.Integer +';' Punctuation +' ' Text +'/* Signal main loop */' Comment.Multiline +'\n' Text + +'\t' Text +'busy' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'/* XXX End critical section */' Comment.Multiline +'\n' Text + +'\t' Text +'return' Keyword +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'int' Keyword.Type +'\n' Text + +'Py_MakePendingCalls' Name.Function +'(' Punctuation +'void' Keyword.Type +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'static' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'busy' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef WITH_THREAD' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'main_thread' Name +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyThread_get_thread_ident' Name +'(' Punctuation +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'main_thread' Name +')' Punctuation +'\n' Text + +'\t\t' Text +'return' Keyword +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'busy' Name +')' Punctuation +'\n' Text + +'\t\t' Text +'return' Keyword +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'busy' Name +' ' Text +'=' Operator +' ' Text +'1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'things_to_do' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'for' Keyword +' ' Text +'(' Punctuation +';' Punctuation +';' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t' Text +'int' Keyword.Type +' ' Text +'i' Name +';' Punctuation +'\n' Text + +'\t\t' Text +'int' Keyword.Type +' ' Text +'(' Punctuation +'*' Operator +'func' Name +')' Punctuation +'(' Punctuation +'void' Keyword.Type +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'void' Keyword.Type +' ' Text +'*' Operator +'arg' Name +';' Punctuation +'\n' Text + +'\t\t' Text +'i' Name +' ' Text +'=' Operator +' ' Text +'pendingfirst' Name +';' Punctuation +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'i' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'pendinglast' Name +')' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +' ' Text +'/* Queue empty */' Comment.Multiline +'\n' Text + +'\t\t' Text +'func' Name +' ' Text +'=' Operator +' ' Text +'pendingcalls' Name +'[' Punctuation +'i' Name +']' Punctuation +'.' Punctuation +'func' Name +';' Punctuation +'\n' Text + +'\t\t' Text +'arg' Name +' ' Text +'=' Operator +' ' Text +'pendingcalls' Name +'[' Punctuation +'i' Name +']' Punctuation +'.' Punctuation +'arg' Name +';' Punctuation +'\n' Text + +'\t\t' Text +'pendingfirst' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'i' Name +' ' Text +'+' Operator +' ' Text +'1' Literal.Number.Integer +')' Punctuation +' ' Text +'%' Operator +' ' Text +'NPENDINGCALLS' Name +';' Punctuation +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'func' Name +'(' Punctuation +'arg' Name +')' Punctuation +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'busy' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t\t' Text +'things_to_do' Name +' ' Text +'=' Operator +' ' Text +'1' Literal.Number.Integer +';' Punctuation +' ' Text +"/* We're not done yet */" Comment.Multiline +'\n' Text + +'\t\t\t' Text +'return' Keyword +' ' Text +'-1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\t' Text +'}' Punctuation +'\n' Text + +'\t' Text +'busy' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'return' Keyword +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'\n' Text + +"/* The interpreter's recursion limit */" Comment.Multiline +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'ifndef Py_DEFAULT_RECURSION_LIMIT' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define Py_DEFAULT_RECURSION_LIMIT 1000' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'static' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'recursion_limit' Name +' ' Text +'=' Operator +' ' Text +'Py_DEFAULT_RECURSION_LIMIT' Name +';' Punctuation +'\n' Text + +'int' Keyword.Type +' ' Text +'_Py_CheckRecursionLimit' Name +' ' Text +'=' Operator +' ' Text +'Py_DEFAULT_RECURSION_LIMIT' Name +';' Punctuation +'\n' Text + +'\n' Text + +'int' Keyword.Type +'\n' Text + +'Py_GetRecursionLimit' Name.Function +'(' Punctuation +'void' Keyword.Type +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'return' Keyword +' ' Text +'recursion_limit' Name +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'void' Keyword.Type +'\n' Text + +'Py_SetRecursionLimit' Name.Function +'(' Punctuation +'int' Keyword.Type +' ' Text +'new_limit' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'recursion_limit' Name +' ' Text +'=' Operator +' ' Text +'new_limit' Name +';' Punctuation +'\n' Text + +' ' Text +'_Py_CheckRecursionLimit' Name +' ' Text +'=' Operator +' ' Text +'recursion_limit' Name +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'/* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()\n if the recursion_depth reaches _Py_CheckRecursionLimit.\n If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit\n to guarantee that _Py_CheckRecursiveCall() is regularly called.\n Without USE_STACKCHECK, there is no need for this. */' Comment.Multiline +'\n' Text + +'int' Keyword.Type +'\n' Text + +'_Py_CheckRecursiveCall' Name.Function +'(' Punctuation +'char' Keyword.Type +' ' Text +'*' Operator +'where' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'PyThreadState' Name +' ' Text +'*' Operator +'tstate' Name +' ' Text +'=' Operator +' ' Text +'PyThreadState_GET' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'ifdef USE_STACKCHECK' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyOS_CheckStack' Name +'(' Punctuation +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t' Text +'-' Operator +'-' Operator +'tstate' Name +'-' Operator +'>' Operator +'recursion_depth' Name +';' Punctuation +'\n' Text + +'\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_MemoryError' Name +',' Punctuation +' ' Text +'"' Literal.String +'Stack overflow' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'return' Keyword +' ' Text +'-1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'recursion_depth' Name +' ' Text +'>' Operator +' ' Text +'recursion_limit' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t' Text +'-' Operator +'-' Operator +'tstate' Name +'-' Operator +'>' Operator +'recursion_depth' Name +';' Punctuation +'\n' Text + +'\t\t' Text +'PyErr_Format' Name +'(' Punctuation +'PyExc_RuntimeError' Name +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'"' Literal.String +'maximum recursion depth exceeded%s' Literal.String +'"' Literal.String +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'where' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'return' Keyword +' ' Text +'-1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'}' Punctuation +'\n' Text + +' ' Text +'_Py_CheckRecursionLimit' Name +' ' Text +'=' Operator +' ' Text +'recursion_limit' Name +';' Punctuation +'\n' Text + +'\t' Text +'return' Keyword +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'/* Status code for main loop (reason for stack unwind) */' Comment.Multiline +'\n' Text + +'enum' Keyword +' ' Text +'why_code' Name +' ' Text +'{' Punctuation +'\n' Text + +'\t\t' Text +'WHY_NOT' Name +' ' Text +'=' Operator +'\t' Text +'0x0001' Literal.Number.Hex +',' Punctuation +'\t' Text +'/* No error */' Comment.Multiline +'\n' Text + +'\t\t' Text +'WHY_EXCEPTION' Name +' ' Text +'=' Operator +' ' Text +'0x0002' Literal.Number.Hex +',' Punctuation +'\t' Text +'/* Exception occurred */' Comment.Multiline +'\n' Text + +'\t\t' Text +'WHY_RERAISE' Name +' ' Text +'=' Operator +'\t' Text +'0x0004' Literal.Number.Hex +',' Punctuation +'\t' Text +"/* Exception re-raised by 'finally' */" Comment.Multiline +'\n' Text + +'\t\t' Text +'WHY_RETURN' Name +' ' Text +'=' Operator +'\t' Text +'0x0008' Literal.Number.Hex +',' Punctuation +'\t' Text +"/* 'return' statement */" Comment.Multiline +'\n' Text + +'\t\t' Text +'WHY_BREAK' Name +' ' Text +'=' Operator +'\t' Text +'0x0010' Literal.Number.Hex +',' Punctuation +'\t' Text +"/* 'break' statement */" Comment.Multiline +'\n' Text + +'\t\t' Text +'WHY_CONTINUE' Name +' ' Text +'=' Operator +'\t' Text +'0x0020' Literal.Number.Hex +',' Punctuation +'\t' Text +"/* 'continue' statement */" Comment.Multiline +'\n' Text + +'\t\t' Text +'WHY_YIELD' Name +' ' Text +'=' Operator +'\t' Text +'0x0040' Literal.Number.Hex +'\t' Text +"/* 'yield' operator */" Comment.Multiline +'\n' Text + +'}' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'static' Keyword +' ' Text +'enum' Keyword +' ' Text +'why_code' Name +' ' Text +'do_raise' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'static' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'unpack_iterable' Name +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +',' Punctuation +' ' Text +'int' Keyword.Type +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'/* for manipulating the thread switch and periodic "stuff" - used to be\n per thread, now just a pair o\' globals */' Comment.Multiline +'\n' Text + +'int' Keyword.Type +' ' Text +'_Py_CheckInterval' Name +' ' Text +'=' Operator +' ' Text +'100' Literal.Number.Integer +';' Punctuation +'\n' Text + +'volatile' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'_Py_Ticker' Name +' ' Text +'=' Operator +' ' Text +'100' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\n' Text + +'PyObject' Name +' ' Text +'*' Operator +'\n' Text + +'PyEval_EvalCode' Name.Function +'(' Punctuation +'PyCodeObject' Name +' ' Text +'*' Operator +'co' Name +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'globals' Name +',' Punctuation +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'locals' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'\t' Text +'/* XXX raise SystemError if globals is NULL */' Comment.Multiline +'\n' Text + +'\t' Text +'return' Keyword +' ' Text +'PyEval_EvalCodeEx' Name +'(' Punctuation +'co' Name +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'globals' Name +',' Punctuation +' ' Text +'locals' Name +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +')' Punctuation +'NULL' Name.Builtin +',' Punctuation +' ' Text +'0' Literal.Number.Integer +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +')' Punctuation +'NULL' Name.Builtin +',' Punctuation +' ' Text +'0' Literal.Number.Integer +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +')' Punctuation +'NULL' Name.Builtin +',' Punctuation +' ' Text +'0' Literal.Number.Integer +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'NULL' Name.Builtin +')' Punctuation +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'\n' Text + +'/* Interpreter main loop */' Comment.Multiline +'\n' Text + +'\n' Text + +'PyObject' Name +' ' Text +'*' Operator +'\n' Text + +'PyEval_EvalFrame' Name.Function +'(' Punctuation +'PyFrameObject' Name +' ' Text +'*' Operator +'f' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t' Text +'/* This is for backward compatibility with extension modules that\n used this API; core interpreter code should call PyEval_EvalFrameEx() */' Comment.Multiline +'\n' Text + +'\t' Text +'return' Keyword +' ' Text +'PyEval_EvalFrameEx' Name +'(' Punctuation +'f' Name +',' Punctuation +' ' Text +'0' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text + +'\n' Text + +'PyObject' Name +' ' Text +'*' Operator +'\n' Text + +'PyEval_EvalFrameEx' Name.Function +'(' Punctuation +'PyFrameObject' Name +' ' Text +'*' Operator +'f' Name +',' Punctuation +' ' Text +'int' Keyword.Type +' ' Text +'throwflag' Name +')' Punctuation +'\n' Text + +'{' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef DXPAIRS' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'int' Keyword.Type +' ' Text +'lastopcode' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'register' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'stack_pointer' Name +';' Punctuation +' ' Text +'/* Next free slot in value stack */' Comment.Multiline +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'unsigned' Keyword.Type +' ' Text +'char' Keyword.Type +' ' Text +'*' Operator +'next_instr' Name +';' Punctuation +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'opcode' Name +';' Punctuation +'\t' Text +'/* Current opcode */' Comment.Multiline +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'oparg' Name +';' Punctuation +'\t' Text +'/* Current opcode argument, if any */' Comment.Multiline +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'enum' Keyword +' ' Text +'why_code' Name +' ' Text +'why' Name +';' Punctuation +' ' Text +'/* Reason for block stack unwind */' Comment.Multiline +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'err' Name +';' Punctuation +'\t' Text +'/* Error status -- nonzero if error */' Comment.Multiline +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'x' Name +';' Punctuation +'\t' Text +'/* Result object -- NULL if error */' Comment.Multiline +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'v' Name +';' Punctuation +'\t' Text +'/* Temporary objects popped off stack */' Comment.Multiline +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'w' Name +';' Punctuation +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'u' Name +';' Punctuation +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'t' Name +';' Punctuation +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'stream' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +' ' Text +'/* for PRINT opcodes */' Comment.Multiline +'\n' Text + +'\t' Text +'register' Keyword +' ' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'fastlocals' Name +',' Punctuation +' ' Text +'*' Operator +'*' Operator +'freevars' Name +';' Punctuation +'\n' Text + +'\t' Text +'PyObject' Name +' ' Text +'*' Operator +'retval' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\t' Text +'/* Return value */' Comment.Multiline +'\n' Text + +'\t' Text +'PyThreadState' Name +' ' Text +'*' Operator +'tstate' Name +' ' Text +'=' Operator +' ' Text +'PyThreadState_GET' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'PyCodeObject' Name +' ' Text +'*' Operator +'co' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'/* when tracing we set things up so that\n\n not (instr_lb <= current_bytecode_offset < instr_ub)\n\n\t is true when the line being executed has changed. The\n initial values are such as to make this false the first\n time it is tested. */' Comment.Multiline +'\n' Text + +'\t' Text +'int' Keyword.Type +' ' Text +'instr_ub' Name +' ' Text +'=' Operator +' ' Text +'-1' Literal.Number.Integer +',' Punctuation +' ' Text +'instr_lb' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +',' Punctuation +' ' Text +'instr_prev' Name +' ' Text +'=' Operator +' ' Text +'-1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'unsigned' Keyword.Type +' ' Text +'char' Keyword.Type +' ' Text +'*' Operator +'first_instr' Name +';' Punctuation +'\n' Text + +'\t' Text +'PyObject' Name +' ' Text +'*' Operator +'names' Name +';' Punctuation +'\n' Text + +'\t' Text +'PyObject' Name +' ' Text +'*' Operator +'consts' Name +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'if defined(Py_DEBUG) || defined(LLTRACE)' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'/* Make it easier to find out where we are with a debugger */' Comment.Multiline +'\n' Text + +'\t' Text +'char' Keyword.Type +' ' Text +'*' Operator +'filename' Name +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'/* Tuple access macros */' Comment.Multiline +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'ifndef Py_DEBUG' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'else' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define GETITEM(v, i) PyTuple_GetItem((v), (i))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'ifdef WITH_TSC' Comment.Preproc +'\n' Comment.Preproc + +"/* Use Pentium timestamp counter to mark certain events:\n inst0 -- beginning of switch statement for opcode dispatch\n inst1 -- end of switch statement (may be skipped)\n loop0 -- the top of the mainloop\n loop1 -- place where control returns again to top of mainloop\n (may be skipped)\n intr1 -- beginning of long interruption\n intr2 -- end of long interruption\n\n Many opcodes call out to helper C functions. In some cases, the\n time in those functions should be counted towards the time for the\n opcode, but not in all cases. For example, a CALL_FUNCTION opcode\n calls another Python function; there's no point in charge all the\n bytecode executed by the called function to the caller.\n\n It's hard to make a useful judgement statically. In the presence\n of operator overloading, it's impossible to tell if a call will\n execute new Python code or not.\n\n It's a case-by-case judgement. I'll use intr1 for the following\n cases:\n\n EXEC_STMT\n IMPORT_STAR\n IMPORT_FROM\n CALL_FUNCTION (and friends)\n\n */" Comment.Multiline +'\n' Text + +'\t' Text +'uint64' Name +' ' Text +'inst0' Name +',' Punctuation +' ' Text +'inst1' Name +',' Punctuation +' ' Text +'loop0' Name +',' Punctuation +' ' Text +'loop1' Name +',' Punctuation +' ' Text +'intr0' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +',' Punctuation +' ' Text +'intr1' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'int' Keyword.Type +' ' Text +'ticked' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'inst0' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'inst1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'loop0' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'loop1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'/* shut up the compiler */' Comment.Multiline +'\n' Text + +'\t' Text +'opcode' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'/* Code access macros */' Comment.Multiline +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'define INSTR_OFFSET()\t((int)(next_instr - first_instr))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define NEXTOP()\t(*next_instr++)' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define NEXTARG()\t(next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PEEKARG()\t((next_instr[2]<<8) + next_instr[1])' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define JUMPTO(x)\t(next_instr = first_instr + (x))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define JUMPBY(x)\t(next_instr += (x))' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'/* OpCode prediction macros\n\tSome opcodes tend to come in pairs thus making it possible to predict\n\tthe second code when the first is run. For example, COMPARE_OP is often\n\tfollowed by JUMP_IF_FALSE or JUMP_IF_TRUE. And, those opcodes are often\n\tfollowed by a POP_TOP.\n\n\tVerifying the prediction costs a single high-speed test of register\n\tvariable against a constant. If the pairing was good, then the\n\tprocessor has a high likelihood of making its own successful branch\n\tprediction which results in a nearly zero overhead transition to the\n\tnext opcode.\n\n\tA successful prediction saves a trip through the eval-loop including\n\tits two unpredictable branches, the HASARG test and the switch-case.\n\n If collecting opcode statistics, turn off prediction so that\n\tstatistics are accurately maintained (the predictions bypass\n\tthe opcode frequency counter updates).\n*/' Comment.Multiline +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'ifdef DYNAMIC_EXECUTION_PROFILE' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PREDICT(op)\t\tif (0) goto PRED_##op' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'else' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PREDICT(op)\t\tif (*next_instr == op) goto PRED_##op' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'define PREDICTED(op)\t\tPRED_##op: next_instr++' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PREDICTED_WITH_ARG(op)\tPRED_##op: oparg = PEEKARG(); next_instr += 3' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'/* Stack manipulation macros */' Comment.Multiline +'\n' Text + +'\n' Text + +'/* The stack can grow at most MAXINT deep, as co_nlocals and\n co_stacksize are ints. */' Comment.Multiline +'\n' Text + +'#' Comment.Preproc +'define STACK_LEVEL()\t((int)(stack_pointer - f->f_valuestack))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define EMPTY()\t\t(STACK_LEVEL() == 0)' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define TOP()\t\t(stack_pointer[-1])' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define SECOND()\t(stack_pointer[-2])' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define THIRD() \t(stack_pointer[-3])' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define FOURTH()\t(stack_pointer[-4])' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define SET_TOP(v)\t(stack_pointer[-1] = (v))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define SET_SECOND(v)\t(stack_pointer[-2] = (v))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define SET_THIRD(v)\t(stack_pointer[-3] = (v))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define SET_FOURTH(v)\t(stack_pointer[-4] = (v))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define BASIC_STACKADJ(n)\t(stack_pointer += n)' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define BASIC_PUSH(v)\t(*stack_pointer++ = (v))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define BASIC_POP()\t(*--stack_pointer)' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'ifdef LLTRACE' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PUSH(v)\t\t{ (void)(BASIC_PUSH(v), \\' Comment.Preproc +'\n' Comment.Preproc + +' lltrace && prtrace(TOP(), "push")); \\' Comment.Preproc +'\n' Comment.Preproc + +' assert(STACK_LEVEL() <= co->co_stacksize); }' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define POP()\t\t((void)(lltrace && prtrace(TOP(), "pop")), BASIC_POP())' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define STACKADJ(n)\t{ (void)(BASIC_STACKADJ(n), \\' Comment.Preproc +'\n' Comment.Preproc + +' lltrace && prtrace(TOP(), "stackadj")); \\' Comment.Preproc +'\n' Comment.Preproc + +' assert(STACK_LEVEL() <= co->co_stacksize); }' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define EXT_POP(STACK_POINTER) (lltrace && prtrace(*(STACK_POINTER), "ext_pop"), *--(STACK_POINTER))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'else' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define PUSH(v)\t\tBASIC_PUSH(v)' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define POP()\t\tBASIC_POP()' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define STACKADJ(n)\tBASIC_STACKADJ(n)' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'/* Local variable macros */' Comment.Multiline +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'define GETLOCAL(i)\t(fastlocals[i])' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'/* The SETLOCAL() macro must not DECREF the local variable in-place and\n then store the new value; it must copy the old value to a temporary\n value, then store the new value, and then DECREF the temporary value.\n This is because it is possible that during the DECREF the frame is\n accessed by other code (e.g. a __del__ method or gc.collect()) and the\n variable would be pointing to already-freed memory. */' Comment.Multiline +'\n' Text + +'#' Comment.Preproc +'define SETLOCAL(i, value)\tdo { PyObject *tmp = GETLOCAL(i); \\' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t\t GETLOCAL(i) = value; \\' Comment.Preproc +'\n' Comment.Preproc + +' Py_XDECREF(tmp); } while (0)' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'/* Start of code */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'f' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t' Text +'return' Keyword +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'/* push frame */' Comment.Multiline +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'Py_EnterRecursiveCall' Name +'(' Punctuation +'"' Literal.String +'"' Literal.String +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t' Text +'return' Keyword +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'tstate' Name +'-' Operator +'>' Operator +'frame' Name +' ' Text +'=' Operator +' ' Text +'f' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'use_tracing' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_tracefunc' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'/* tstate->c_tracefunc, if defined, is a\n\t\t\t function that will be called on *every* entry\n\t\t\t to a code block. Its return value, if not\n\t\t\t None, is a function that will be called at\n\t\t\t the start of each executed line of code.\n\t\t\t (Actually, the function must return itself\n\t\t\t in order to continue tracing.) The trace\n\t\t\t functions are called with three arguments:\n\t\t\t a pointer to the current frame, a string\n\t\t\t indicating why the function is called, and\n\t\t\t an argument which depends on the situation.\n\t\t\t The global trace function is also called\n\t\t\t whenever an exception is detected. */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'call_trace' Name +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_tracefunc' Name +',' Punctuation +' ' Text +'tstate' Name +'-' Operator +'>' Operator +'c_traceobj' Name +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'f' Name +',' Punctuation +' ' Text +'PyTrace_CALL' Name +',' Punctuation +' ' Text +'Py_None' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* Trace function raised an error */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'exit_eval_frame' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_profilefunc' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'/* Similar for c_profilefunc, except it needn\'t\n\t\t\t return itself and isn\'t called for "line" events */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'call_trace' Name +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_profilefunc' Name +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'tstate' Name +'-' Operator +'>' Operator +'c_profileobj' Name +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'f' Name +',' Punctuation +' ' Text +'PyTrace_CALL' Name +',' Punctuation +' ' Text +'Py_None' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* Profile function raised an error */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'exit_eval_frame' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'co' Name +' ' Text +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_code' Name +';' Punctuation +'\n' Text + +'\t' Text +'names' Name +' ' Text +'=' Operator +' ' Text +'co' Name +'-' Operator +'>' Operator +'co_names' Name +';' Punctuation +'\n' Text + +'\t' Text +'consts' Name +' ' Text +'=' Operator +' ' Text +'co' Name +'-' Operator +'>' Operator +'co_consts' Name +';' Punctuation +'\n' Text + +'\t' Text +'fastlocals' Name +' ' Text +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_localsplus' Name +';' Punctuation +'\n' Text + +'\t' Text +'freevars' Name +' ' Text +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_localsplus' Name +' ' Text +'+' Operator +' ' Text +'co' Name +'-' Operator +'>' Operator +'co_nlocals' Name +';' Punctuation +'\n' Text + +'\t' Text +'first_instr' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'unsigned' Keyword.Type +' ' Text +'char' Keyword.Type +'*' Operator +')' Punctuation +' ' Text +'PyString_AS_STRING' Name +'(' Punctuation +'co' Name +'-' Operator +'>' Operator +'co_code' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +"/* An explanation is in order for the next line.\n\n\t f->f_lasti now refers to the index of the last instruction\n\t executed. You might think this was obvious from the name, but\n\t this wasn't always true before 2.3! PyFrame_New now sets\n\t f->f_lasti to -1 (i.e. the index *before* the first instruction)\n\t and YIELD_VALUE doesn't fiddle with f_lasti any more. So this\n\t does work. Promise. */" Comment.Multiline +'\n' Text + +'\t' Text +'next_instr' Name +' ' Text +'=' Operator +' ' Text +'first_instr' Name +' ' Text +'+' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_lasti' Name +' ' Text +'+' Operator +' ' Text +'1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'stack_pointer' Name +' ' Text +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_stacktop' Name +';' Punctuation +'\n' Text + +'\t' Text +'assert' Name +'(' Punctuation +'stack_pointer' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'f' Name +'-' Operator +'>' Operator +'f_stacktop' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\t' Text +'/* remains NULL unless yield suspends frame */' Comment.Multiline +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'ifdef LLTRACE' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'lltrace' Name +' ' Text +'=' Operator +' ' Text +'PyDict_GetItemString' Name +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_globals' Name +',' Punctuation +' ' Text +'"' Literal.String +'__lltrace__' Literal.String +'"' Literal.String +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'if defined(Py_DEBUG) || defined(LLTRACE)' Comment.Preproc +'\n' Comment.Preproc + +'\t' Text +'filename' Name +' ' Text +'=' Operator +' ' Text +'PyString_AsString' Name +'(' Punctuation +'co' Name +'-' Operator +'>' Operator +'co_filename' Name +')' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_NOT' Name +';' Punctuation +'\n' Text + +'\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'Py_None' Name +';' Punctuation +'\t' Text +'/* Not a reference, just anything non-NULL */' Comment.Multiline +'\n' Text + +'\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'throwflag' Name +')' Punctuation +' ' Text +'{' Punctuation +' ' Text +'/* support for generator.throw() */' Comment.Multiline +'\n' Text + +'\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\t\t' Text +'goto' Keyword +' ' Text +'on_error' Name +';' Punctuation +'\n' Text + +'\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'for' Keyword +' ' Text +'(' Punctuation +';' Punctuation +';' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef WITH_TSC' Comment.Preproc +'\n' Comment.Preproc + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'inst1' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'/* Almost surely, the opcode executed a break\n\t\t\t or a continue, preventing inst1 from being set\n\t\t\t on the way out of the loop.\n\t\t\t*/' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'inst1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'loop1' Name +' ' Text +'=' Operator +' ' Text +'inst1' Name +';' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'dump_tsc' Name +'(' Punctuation +'opcode' Name +',' Punctuation +' ' Text +'ticked' Name +',' Punctuation +' ' Text +'inst0' Name +',' Punctuation +' ' Text +'inst1' Name +',' Punctuation +' ' Text +'loop0' Name +',' Punctuation +' ' Text +'loop1' Name +',' Punctuation +'\n' Text + +'\t\t\t ' Text +'intr0' Name +',' Punctuation +' ' Text +'intr1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'ticked' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t' Text +'inst1' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t' Text +'intr0' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t' Text +'intr1' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'loop0' Name +')' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t\t' Text +'assert' Name +'(' Punctuation +'stack_pointer' Name +' ' Text +'>' Operator +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_valuestack' Name +')' Punctuation +';' Punctuation +' ' Text +'/* else underflow */' Comment.Multiline +'\n' Text + +'\t\t' Text +'assert' Name +'(' Punctuation +'STACK_LEVEL' Name +'(' Punctuation +')' Punctuation +' ' Text +'<' Operator +'=' Operator +' ' Text +'co' Name +'-' Operator +'>' Operator +'co_stacksize' Name +')' Punctuation +';' Punctuation +' ' Text +'/* else overflow */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +"/* Do periodic things. Doing this every time through\n\t\t the loop would add too much overhead, so we do it\n\t\t only every Nth instruction. We also do it if\n\t\t ``things_to_do'' is set, i.e. when an asynchronous\n\t\t event needs attention (e.g. a signal handler or\n\t\t async I/O handler); see Py_AddPendingCall() and\n\t\t Py_MakePendingCalls() above. */" Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'-' Operator +'-' Operator +'_Py_Ticker' Name +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'*' Operator +'next_instr' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'SETUP_FINALLY' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +' ' Text +'/* Make the last opcode before\n a try: finally: block uninterruptable. */' Comment.Multiline +'\n' Text + +' ' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +' ' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'_Py_Ticker' Name +' ' Text +'=' Operator +' ' Text +'_Py_CheckInterval' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'tstate' Name +'-' Operator +'>' Operator +'tick_counter' Name +'+' Operator +'+' Operator +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef WITH_TSC' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t' Text +'ticked' Name +' ' Text +'=' Operator +' ' Text +'1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'things_to_do' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'Py_MakePendingCalls' Name +'(' Punctuation +')' Punctuation +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'goto' Keyword +' ' Text +'on_error' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'things_to_do' Name +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'/* MakePendingCalls() didn\'t succeed.\n\t\t\t\t\t Force early re-execution of this\n\t\t\t\t\t "periodic" code, possibly after\n\t\t\t\t\t a thread switch */' Comment.Multiline +'\n' Text + +'\t\t\t\t\t' Text +'_Py_Ticker' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef WITH_THREAD' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'interpreter_lock' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* Give another thread a chance */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyThreadState_Swap' Name +'(' Punctuation +'NULL' Name.Builtin +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'tstate' Name +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'Py_FatalError' Name +'(' Punctuation +'"' Literal.String +'ceval: tstate mix-up' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyThread_release_lock' Name +'(' Punctuation +'interpreter_lock' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t\t\t' Text +'/* Other threads may run now */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t\t\t' Text +'PyThread_acquire_lock' Name +'(' Punctuation +'interpreter_lock' Name +',' Punctuation +' ' Text +'1' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyThreadState_Swap' Name +'(' Punctuation +'tstate' Name +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'Py_FatalError' Name +'(' Punctuation +'"' Literal.String +'ceval: orphan tstate' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t\t\t' Text +'/* Check for thread interrupts */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'async_exc' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'tstate' Name +'-' Operator +'>' Operator +'async_exc' Name +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'tstate' Name +'-' Operator +'>' Operator +'async_exc' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyErr_SetNone' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'goto' Keyword +' ' Text +'on_error' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'fast_next_opcode' Name.Label +':' Punctuation +'\n' Text + +'\t\t' Text +'f' Name +'-' Operator +'>' Operator +'f_lasti' Name +' ' Text +'=' Operator +' ' Text +'INSTR_OFFSET' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'/* line-by-line tracing support */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_tracefunc' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +' ' Text +'&' Operator +'&' Operator +' ' Text +'!' Operator +'tstate' Name +'-' Operator +'>' Operator +'tracing' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'/* see maybe_call_line_trace\n\t\t\t for expository comments */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'f' Name +'-' Operator +'>' Operator +'f_stacktop' Name +' ' Text +'=' Operator +' ' Text +'stack_pointer' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'maybe_call_line_trace' Name +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_tracefunc' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'tstate' Name +'-' Operator +'>' Operator +'c_traceobj' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'f' Name +',' Punctuation +' ' Text +'&' Operator +'instr_lb' Name +',' Punctuation +' ' Text +'&' Operator +'instr_ub' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'&' Operator +'instr_prev' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'/* Reload possibly changed frame fields */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'JUMPTO' Name +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_lasti' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_stacktop' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'stack_pointer' Name +' ' Text +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_stacktop' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'f' Name +'-' Operator +'>' Operator +'f_stacktop' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* trace function raised an exception */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'on_error' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'/* Extract opcode and argument */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'opcode' Name +' ' Text +'=' Operator +' ' Text +'NEXTOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'oparg' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +' ' Text +"/* allows oparg to be stored in a register because\n\t\t\tit doesn't have to be remembered across a full loop */" Comment.Multiline +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'HAS_ARG' Name +'(' Punctuation +'opcode' Name +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t\t' Text +'oparg' Name +' ' Text +'=' Operator +' ' Text +'NEXTARG' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t ' Text +'dispatch_opcode' Name.Label +':' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef DYNAMIC_EXECUTION_PROFILE' Comment.Preproc +'\n' Comment.Preproc + +'#' Comment.Preproc +'ifdef DXPAIRS' Comment.Preproc +'\n' Comment.Preproc + +'\t\t' Text +'dxpairs' Name +'[' Punctuation +'lastopcode' Name +']' Punctuation +'[' Punctuation +'opcode' Name +']' Punctuation +'+' Operator +'+' Operator +';' Punctuation +'\n' Text + +'\t\t' Text +'lastopcode' Name +' ' Text +'=' Operator +' ' Text +'opcode' Name +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t\t' Text +'dxp' Name +'[' Punctuation +'opcode' Name +']' Punctuation +'+' Operator +'+' Operator +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'#' Comment.Preproc +'ifdef LLTRACE' Comment.Preproc +'\n' Comment.Preproc + +'\t\t' Text +'/* Instruction tracing */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'lltrace' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'HAS_ARG' Name +'(' Punctuation +'opcode' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'printf' Name +'(' Punctuation +'"' Literal.String +'%d: %d, %d' Literal.String +'\\n' Literal.String.Escape +'"' Literal.String +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'f' Name +'-' Operator +'>' Operator +'f_lasti' Name +',' Punctuation +' ' Text +'opcode' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'printf' Name +'(' Punctuation +'"' Literal.String +'%d: %d' Literal.String +'\\n' Literal.String.Escape +'"' Literal.String +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'f' Name +'-' Operator +'>' Operator +'f_lasti' Name +',' Punctuation +' ' Text +'opcode' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'\t\t' Text +'/* Main switch on opcode */' Comment.Multiline +'\n' Text + +'\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'inst0' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'switch' Keyword +' ' Text +'(' Punctuation +'opcode' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'/* BEWARE!\n\t\t It is essential that any operation that fails sets either\n\t\t x to NULL, err to nonzero, or why to anything but WHY_NOT,\n\t\t and that no operation that succeeds does this! */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'/* case STOP_CODE: this is an error! */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'NOP' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'LOAD_FAST' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'GETLOCAL' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'format_exc_check_arg' Name +'(' Punctuation +'PyExc_UnboundLocalError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t' Text +'UNBOUNDLOCAL_ERROR_MSG' Name +',' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyTuple_GetItem' Name +'(' Punctuation +'co' Name +'-' Operator +'>' Operator +'co_varnames' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'LOAD_CONST' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'consts' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'PREDICTED_WITH_ARG' Name +'(' Punctuation +'STORE_FAST' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'STORE_FAST' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SETLOCAL' Name +'(' Punctuation +'oparg' Name +',' Punctuation +' ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'PREDICTED' Name +'(' Punctuation +'POP_TOP' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'POP_TOP' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'ROT_TWO' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'SECOND' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_SECOND' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'ROT_THREE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'SECOND' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'THIRD' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_SECOND' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_THIRD' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'ROT_FOUR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'SECOND' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'THIRD' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'FOURTH' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_SECOND' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_THIRD' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_FOURTH' Name +'(' Punctuation +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'DUP_TOP' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PUSH' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'DUP_TOPX' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'oparg' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'2' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'SECOND' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'STACKADJ' Name +'(' Punctuation +'2' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SET_SECOND' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +' ' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'oparg' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'3' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'SECOND' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'THIRD' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'STACKADJ' Name +'(' Punctuation +'3' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SET_SECOND' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SET_THIRD' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_FatalError' Name +'(' Punctuation +'"' Literal.String +'invalid argument to DUP_TOPX' Literal.String +'"' Literal.String +'\n' Text + +'\t\t\t\t ' Text +'"' Literal.String +' (bytecode corruption?)' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'UNARY_POSITIVE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Positive' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'UNARY_NEGATIVE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Negative' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'UNARY_NOT' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyObject_IsTrue' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'Py_True' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'Py_True' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'>' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'Py_False' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'Py_False' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'STACKADJ' Name +'(' Punctuation +'-1' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'UNARY_CONVERT' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyObject_Repr' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'UNARY_INVERT' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Invert' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_POWER' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Power' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'Py_None' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_MULTIPLY' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Multiply' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_DIVIDE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'!' Operator +'_Py_QnewFlag' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Divide' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'/* -Qnew is in effect:\tfall through to\n\t\t\t BINARY_TRUE_DIVIDE */' Comment.Multiline +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_TRUE_DIVIDE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_TrueDivide' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_FLOOR_DIVIDE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_FloorDivide' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_MODULO' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Remainder' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_ADD' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyInt_CheckExact' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyInt_CheckExact' Name +'(' Punctuation +'w' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* INLINE: int + int */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'register' Keyword +' ' Text +'long' Keyword.Type +' ' Text +'a' Name +',' Punctuation +' ' Text +'b' Name +',' Punctuation +' ' Text +'i' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'a' Name +' ' Text +'=' Operator +' ' Text +'PyInt_AS_LONG' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'b' Name +' ' Text +'=' Operator +' ' Text +'PyInt_AS_LONG' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'i' Name +' ' Text +'=' Operator +' ' Text +'a' Name +' ' Text +'+' Operator +' ' Text +'b' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'i' Name +'^' Operator +'a' Name +')' Punctuation +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +' ' Text +'&' Operator +'&' Operator +' ' Text +'(' Punctuation +'i' Name +'^' Operator +'b' Name +')' Punctuation +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'goto' Keyword +' ' Text +'slow_add' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyInt_FromLong' Name +'(' Punctuation +'i' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyString_CheckExact' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'&' Operator +'&' Operator +'\n' Text + +'\t\t\t\t ' Text +'PyString_CheckExact' Name +'(' Punctuation +'w' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'string_concatenate' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'f' Name +',' Punctuation +' ' Text +'next_instr' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* string_concatenate consumed the ref to v */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'skip_decref_vx' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t ' Text +'slow_add' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Add' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t ' Text +'skip_decref_vx' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_SUBTRACT' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyInt_CheckExact' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyInt_CheckExact' Name +'(' Punctuation +'w' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* INLINE: int - int */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'register' Keyword +' ' Text +'long' Keyword.Type +' ' Text +'a' Name +',' Punctuation +' ' Text +'b' Name +',' Punctuation +' ' Text +'i' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'a' Name +' ' Text +'=' Operator +' ' Text +'PyInt_AS_LONG' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'b' Name +' ' Text +'=' Operator +' ' Text +'PyInt_AS_LONG' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'i' Name +' ' Text +'=' Operator +' ' Text +'a' Name +' ' Text +'-' Operator +' ' Text +'b' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'i' Name +'^' Operator +'a' Name +')' Punctuation +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +' ' Text +'&' Operator +'&' Operator +' ' Text +'(' Punctuation +'i' Name +'^' Operator +'~' Operator +'b' Name +')' Punctuation +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'goto' Keyword +' ' Text +'slow_sub' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyInt_FromLong' Name +'(' Punctuation +'i' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t ' Text +'slow_sub' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Subtract' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_SUBSCR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyList_CheckExact' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyInt_CheckExact' Name +'(' Punctuation +'w' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* INLINE: list[int] */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'Py_ssize_t' Name +' ' Text +'i' Name +' ' Text +'=' Operator +' ' Text +'PyInt_AsSsize_t' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'i' Name +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'i' Name +' ' Text +'+' Operator +'=' Operator +' ' Text +'PyList_GET_SIZE' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'i' Name +' ' Text +'>' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +' ' Text +'&' Operator +'&' Operator +' ' Text +'i' Name +' ' Text +'<' Operator +' ' Text +'PyList_GET_SIZE' Name +'(' Punctuation +'v' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyList_GET_ITEM' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'i' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t\t' Text +'goto' Keyword +' ' Text +'slow_get' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t ' Text +'slow_get' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyObject_GetItem' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_LSHIFT' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Lshift' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_RSHIFT' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Rshift' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_AND' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_And' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_XOR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Xor' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BINARY_OR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_Or' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'LIST_APPEND' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyList_Append' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PREDICT' Name +'(' Punctuation +'JUMP_ABSOLUTE' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_POWER' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlacePower' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'Py_None' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_MULTIPLY' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceMultiply' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_DIVIDE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'!' Operator +'_Py_QnewFlag' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceDivide' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'/* -Qnew is in effect:\tfall through to\n\t\t\t INPLACE_TRUE_DIVIDE */' Comment.Multiline +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_TRUE_DIVIDE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceTrueDivide' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_FLOOR_DIVIDE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceFloorDivide' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_MODULO' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceRemainder' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_ADD' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyInt_CheckExact' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyInt_CheckExact' Name +'(' Punctuation +'w' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* INLINE: int + int */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'register' Keyword +' ' Text +'long' Keyword.Type +' ' Text +'a' Name +',' Punctuation +' ' Text +'b' Name +',' Punctuation +' ' Text +'i' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'a' Name +' ' Text +'=' Operator +' ' Text +'PyInt_AS_LONG' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'b' Name +' ' Text +'=' Operator +' ' Text +'PyInt_AS_LONG' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'i' Name +' ' Text +'=' Operator +' ' Text +'a' Name +' ' Text +'+' Operator +' ' Text +'b' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'i' Name +'^' Operator +'a' Name +')' Punctuation +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +' ' Text +'&' Operator +'&' Operator +' ' Text +'(' Punctuation +'i' Name +'^' Operator +'b' Name +')' Punctuation +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'goto' Keyword +' ' Text +'slow_iadd' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyInt_FromLong' Name +'(' Punctuation +'i' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyString_CheckExact' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'&' Operator +'&' Operator +'\n' Text + +'\t\t\t\t ' Text +'PyString_CheckExact' Name +'(' Punctuation +'w' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'string_concatenate' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'f' Name +',' Punctuation +' ' Text +'next_instr' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* string_concatenate consumed the ref to v */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'skip_decref_v' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t ' Text +'slow_iadd' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceAdd' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t ' Text +'skip_decref_v' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_SUBTRACT' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyInt_CheckExact' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyInt_CheckExact' Name +'(' Punctuation +'w' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* INLINE: int - int */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'register' Keyword +' ' Text +'long' Keyword.Type +' ' Text +'a' Name +',' Punctuation +' ' Text +'b' Name +',' Punctuation +' ' Text +'i' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'a' Name +' ' Text +'=' Operator +' ' Text +'PyInt_AS_LONG' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'b' Name +' ' Text +'=' Operator +' ' Text +'PyInt_AS_LONG' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'i' Name +' ' Text +'=' Operator +' ' Text +'a' Name +' ' Text +'-' Operator +' ' Text +'b' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'i' Name +'^' Operator +'a' Name +')' Punctuation +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +' ' Text +'&' Operator +'&' Operator +' ' Text +'(' Punctuation +'i' Name +'^' Operator +'~' Operator +'b' Name +')' Punctuation +' ' Text +'<' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'goto' Keyword +' ' Text +'slow_isub' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyInt_FromLong' Name +'(' Punctuation +'i' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t ' Text +'slow_isub' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceSubtract' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_LSHIFT' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceLshift' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_RSHIFT' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceRshift' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_AND' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceAnd' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_XOR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceXor' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'INPLACE_OR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyNumber_InPlaceOr' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'SLICE' Name +'+' Operator +'0' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'SLICE' Name +'+' Operator +'1' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'SLICE' Name +'+' Operator +'2' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'SLICE' Name +'+' Operator +'3' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'opcode' Name +'-' Operator +'SLICE' Name +')' Punctuation +' ' Text +'&' Operator +' ' Text +'2' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'opcode' Name +'-' Operator +'SLICE' Name +')' Punctuation +' ' Text +'&' Operator +' ' Text +'1' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'apply_slice' Name +'(' Punctuation +'u' Name +',' Punctuation +' ' Text +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'STORE_SLICE' Name +'+' Operator +'0' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'STORE_SLICE' Name +'+' Operator +'1' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'STORE_SLICE' Name +'+' Operator +'2' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'STORE_SLICE' Name +'+' Operator +'3' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'opcode' Name +'-' Operator +'STORE_SLICE' Name +')' Punctuation +' ' Text +'&' Operator +' ' Text +'2' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'opcode' Name +'-' Operator +'STORE_SLICE' Name +')' Punctuation +' ' Text +'&' Operator +' ' Text +'1' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'t' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'assign_slice' Name +'(' Punctuation +'u' Name +',' Punctuation +' ' Text +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'t' Name +')' Punctuation +';' Punctuation +' ' Text +'/* u[v:w] = t */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'t' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'DELETE_SLICE' Name +'+' Operator +'0' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'DELETE_SLICE' Name +'+' Operator +'1' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'DELETE_SLICE' Name +'+' Operator +'2' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'DELETE_SLICE' Name +'+' Operator +'3' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'opcode' Name +'-' Operator +'DELETE_SLICE' Name +')' Punctuation +' ' Text +'&' Operator +' ' Text +'2' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'opcode' Name +'-' Operator +'DELETE_SLICE' Name +')' Punctuation +' ' Text +'&' Operator +' ' Text +'1' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'assign_slice' Name +'(' Punctuation +'u' Name +',' Punctuation +' ' Text +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +'NULL' Name.Builtin +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t\t' Text +'/* del u[v:w] */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'STORE_SUBSCR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'SECOND' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'THIRD' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'STACKADJ' Name +'(' Punctuation +'-3' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'/* v[w] = u */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyObject_SetItem' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'DELETE_SUBSCR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'SECOND' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'STACKADJ' Name +'(' Punctuation +'-2' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'/* del v[w] */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyObject_DelItem' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'PRINT_EXPR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'PySys_GetObject' Name +'(' Punctuation +'"' Literal.String +'displayhook' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_RuntimeError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'"' Literal.String +'lost sys.displayhook' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'-1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyTuple_Pack' Name +'(' Punctuation +'1' Literal.Number.Integer +',' Punctuation +' ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'-1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'PyEval_CallObject' Name +'(' Punctuation +'w' Name +',' Punctuation +' ' Text +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'-1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'PRINT_ITEM_TO' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'stream' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'/* fall through to PRINT_ITEM */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'PRINT_ITEM' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'stream' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +' ' Text +'|' Operator +'|' Operator +' ' Text +'stream' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'Py_None' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'PySys_GetObject' Name +'(' Punctuation +'"' Literal.String +'stdout' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_RuntimeError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t\t' Text +'"' Literal.String +'lost sys.stdout' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'-1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'/* PyFile_SoftSpace() can exececute arbitrary code\n\t\t\t if sys.stdout is an instance with a __getattr__.\n\t\t\t If __getattr__ raises an exception, w will\n\t\t\t be freed, so we need to prevent that temporarily. */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'Py_XINCREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyFile_SoftSpace' Name +'(' Punctuation +'w' Name +',' Punctuation +' ' Text +'0' Literal.Number.Integer +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyFile_WriteString' Name +'(' Punctuation +'"' Literal.String +' ' Literal.String +'"' Literal.String +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyFile_WriteObject' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'Py_PRINT_RAW' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t ' Text +'/* XXX move into writeobject() ? */' Comment.Multiline +'\n' Text + +'\t\t\t ' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyString_Check' Name +'(' Punctuation +'v' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'char' Keyword.Type +' ' Text +'*' Operator +'s' Name +' ' Text +'=' Operator +' ' Text +'PyString_AS_STRING' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_ssize_t' Name +' ' Text +'len' Name +' ' Text +'=' Operator +' ' Text +'PyString_GET_SIZE' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'len' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +' ' Text +'|' Operator +'|' Operator +'\n' Text + +'\t\t\t\t ' Text +'!' Operator +'isspace' Name +'(' Punctuation +'Py_CHARMASK' Name +'(' Punctuation +'s' Name +'[' Punctuation +'len' Name +'-1' Literal.Number.Integer +']' Punctuation +')' Punctuation +')' Punctuation +' ' Text +'|' Operator +'|' Operator +'\n' Text + +'\t\t\t\t ' Text +'s' Name +'[' Punctuation +'len' Name +'-1' Literal.Number.Integer +']' Punctuation +' ' Text +'=' Operator +'=' Operator +' ' Text +"'" Literal.String.Char +' ' Literal.String.Char +"'" Literal.String.Char +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyFile_SoftSpace' Name +'(' Punctuation +'w' Name +',' Punctuation +' ' Text +'1' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef Py_USING_UNICODE' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t ' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyUnicode_Check' Name +'(' Punctuation +'v' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_UNICODE' Name +' ' Text +'*' Operator +'s' Name +' ' Text +'=' Operator +' ' Text +'PyUnicode_AS_UNICODE' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_ssize_t' Name +' ' Text +'len' Name +' ' Text +'=' Operator +' ' Text +'PyUnicode_GET_SIZE' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'len' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +' ' Text +'|' Operator +'|' Operator +'\n' Text + +'\t\t\t\t ' Text +'!' Operator +'Py_UNICODE_ISSPACE' Name +'(' Punctuation +'s' Name +'[' Punctuation +'len' Name +'-1' Literal.Number.Integer +']' Punctuation +')' Punctuation +' ' Text +'|' Operator +'|' Operator +'\n' Text + +'\t\t\t\t ' Text +'s' Name +'[' Punctuation +'len' Name +'-1' Literal.Number.Integer +']' Punctuation +' ' Text +'=' Operator +'=' Operator +' ' Text +"'" Literal.String.Char +' ' Literal.String.Char +"'" Literal.String.Char +')' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'PyFile_SoftSpace' Name +'(' Punctuation +'w' Name +',' Punctuation +' ' Text +'1' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t ' Text +'else' Keyword +'\n' Text + +'\t\t\t \t' Text +'PyFile_SoftSpace' Name +'(' Punctuation +'w' Name +',' Punctuation +' ' Text +'1' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'stream' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'stream' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'PRINT_NEWLINE_TO' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'stream' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'/* fall through to PRINT_NEWLINE */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'PRINT_NEWLINE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'stream' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +' ' Text +'|' Operator +'|' Operator +' ' Text +'stream' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'Py_None' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'PySys_GetObject' Name +'(' Punctuation +'"' Literal.String +'stdout' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_RuntimeError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t\t' Text +'"' Literal.String +'lost sys.stdout' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyFile_WriteString' Name +'(' Punctuation +'"' Literal.String +'\\n' Literal.String.Escape +'"' Literal.String +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyFile_SoftSpace' Name +'(' Punctuation +'w' Name +',' Punctuation +' ' Text +'0' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'stream' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'stream' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'ifdef CASE_TOO_BIG' Comment.Preproc +'\n' Comment.Preproc + +'\t\t' Text +'default' Keyword +':' Operator +' ' Text +'switch' Keyword +' ' Text +'(' Punctuation +'opcode' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t\t' Text +'case' Keyword +' ' Text +'RAISE_VARARGS' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'switch' Keyword +' ' Text +'(' Punctuation +'oparg' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'case' Keyword +' ' Text +'3' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +' ' Text +'/* traceback */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'/* Fallthrough */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'case' Keyword +' ' Text +'2' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +' ' Text +'/* value */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'/* Fallthrough */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'case' Keyword +' ' Text +'1' Literal.Number.Integer +':' Operator +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +' ' Text +'/* exc */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'case' Keyword +' ' Text +'0' Literal.Number.Integer +':' Operator +' ' Text +'/* Fallthrough */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'do_raise' Name +'(' Punctuation +'w' Name +',' Punctuation +' ' Text +'v' Name +',' Punctuation +' ' Text +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'default' Keyword +':' Operator +'\n' Text + +'\t\t\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_SystemError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'"' Literal.String +'bad RAISE_VARARGS oparg' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'LOAD_LOCALS' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'x' Name +' ' Text +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_locals' Name +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_SystemError' Name +',' Punctuation +' ' Text +'"' Literal.String +'no locals' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'RETURN_VALUE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'retval' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_RETURN' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_block_end' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'YIELD_VALUE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'retval' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'f' Name +'-' Operator +'>' Operator +'f_stacktop' Name +' ' Text +'=' Operator +' ' Text +'stack_pointer' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_YIELD' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_yield' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'EXEC_STMT' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'SECOND' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'THIRD' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'STACKADJ' Name +'(' Punctuation +'-3' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'intr0' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'exec_statement' Name +'(' Punctuation +'f' Name +',' Punctuation +' ' Text +'u' Name +',' Punctuation +' ' Text +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'intr1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'POP_BLOCK' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyTryBlock' Name +' ' Text +'*' Operator +'b' Name +' ' Text +'=' Operator +' ' Text +'PyFrame_BlockPop' Name +'(' Punctuation +'f' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'while' Keyword +' ' Text +'(' Punctuation +'STACK_LEVEL' Name +'(' Punctuation +')' Punctuation +' ' Text +'>' Operator +' ' Text +'b' Name +'-' Operator +'>' Operator +'b_level' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'END_FINALLY' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyInt_Check' Name +'(' Punctuation +'v' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'enum' Keyword +' ' Text +'why_code' Name +')' Punctuation +' ' Text +'PyInt_AS_LONG' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'assert' Name +'(' Punctuation +'why' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'WHY_YIELD' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_RETURN' Name +' ' Text +'|' Operator +'|' Operator +'\n' Text + +'\t\t\t\t ' Text +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_CONTINUE' Name +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'retval' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyExceptionClass_Check' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'|' Operator +'|' Operator +' ' Text +'PyString_Check' Name +'(' Punctuation +'v' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyErr_Restore' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_RERAISE' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'v' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'Py_None' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_SystemError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'"' Literal.String +"'finally' pops bad exception" Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BUILD_CLASS' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'SECOND' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'THIRD' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'STACKADJ' Name +'(' Punctuation +'-2' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'build_class' Name +'(' Punctuation +'u' Name +',' Punctuation +' ' Text +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'STORE_NAME' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'names' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'x' Name +' ' Text +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_locals' Name +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyDict_CheckExact' Name +'(' Punctuation +'x' Name +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyDict_SetItem' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyObject_SetItem' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'PyErr_Format' Name +'(' Punctuation +'PyExc_SystemError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'"' Literal.String +'no locals found when storing %s' Literal.String +'"' Literal.String +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'PyObject_REPR' Name +'(' Punctuation +'w' Name +')' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'DELETE_NAME' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'names' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'x' Name +' ' Text +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_locals' Name +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'err' Name +' ' Text +'=' Operator +' ' Text +'PyObject_DelItem' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'format_exc_check_arg' Name +'(' Punctuation +'PyExc_NameError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t\t\t' Text +'NAME_ERROR_MSG' Name +' ' Text +',' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'PyErr_Format' Name +'(' Punctuation +'PyExc_SystemError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'"' Literal.String +'no locals when deleting %s' Literal.String +'"' Literal.String +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'PyObject_REPR' Name +'(' Punctuation +'w' Name +')' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'PREDICTED_WITH_ARG' Name +'(' Punctuation +'UNPACK_SEQUENCE' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'UNPACK_SEQUENCE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyTuple_CheckExact' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyTuple_GET_SIZE' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'=' Operator +'=' Operator +' ' Text +'oparg' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'items' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'(' Punctuation +'PyTupleObject' Name +' ' Text +'*' Operator +')' Punctuation +'v' Name +')' Punctuation +'-' Operator +'>' Operator +'ob_item' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'while' Keyword +' ' Text +'(' Punctuation +'oparg' Name +'-' Operator +'-' Operator +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'items' Name +'[' Punctuation +'oparg' Name +']' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +' ' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyList_CheckExact' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyList_GET_SIZE' Name +'(' Punctuation +'v' Name +')' Punctuation +' ' Text +'=' Operator +'=' Operator +' ' Text +'oparg' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'items' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'(' Punctuation +'PyListObject' Name +' ' Text +'*' Operator +')' Punctuation +'v' Name +')' Punctuation +'-' Operator +'>' Operator +'ob_item' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'while' Keyword +' ' Text +'(' Punctuation +'oparg' Name +'-' Operator +'-' Operator +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'items' Name +'[' Punctuation +'oparg' Name +']' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +' ' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'unpack_iterable' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'oparg' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'stack_pointer' Name +' ' Text +'+' Operator +' ' Text +'oparg' Name +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'stack_pointer' Name +' ' Text +'+' Operator +'=' Operator +' ' Text +'oparg' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyErr_ExceptionMatches' Name +'(' Punctuation +'PyExc_TypeError' Name +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_TypeError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'"' Literal.String +'unpack non-sequence' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'STORE_ATTR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'names' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'SECOND' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'STACKADJ' Name +'(' Punctuation +'-2' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyObject_SetAttr' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'u' Name +')' Punctuation +';' Punctuation +' ' Text +'/* v.w = u */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'DELETE_ATTR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'names' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyObject_SetAttr' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'(' Punctuation +'PyObject' Name +' ' Text +'*' Operator +')' Punctuation +'NULL' Name.Builtin +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t\t' Text +'/* del v.w */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'STORE_GLOBAL' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'names' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyDict_SetItem' Name +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_globals' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'DELETE_GLOBAL' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'names' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'err' Name +' ' Text +'=' Operator +' ' Text +'PyDict_DelItem' Name +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_globals' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'format_exc_check_arg' Name +'(' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'PyExc_NameError' Name +',' Punctuation +' ' Text +'GLOBAL_NAME_ERROR_MSG' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'LOAD_NAME' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'names' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'v' Name +' ' Text +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_locals' Name +')' Punctuation +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyErr_Format' Name +'(' Punctuation +'PyExc_SystemError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'"' Literal.String +'no locals when loading %s' Literal.String +'"' Literal.String +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'PyObject_REPR' Name +'(' Punctuation +'w' Name +')' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyDict_CheckExact' Name +'(' Punctuation +'v' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyDict_GetItem' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_XINCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyObject_GetItem' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyErr_Occurred' Name +'(' Punctuation +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'!' Operator +'PyErr_ExceptionMatches' Name +'(' Punctuation +'PyExc_KeyError' Name +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyErr_Clear' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyDict_GetItem' Name +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_globals' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyDict_GetItem' Name +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_builtins' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'format_exc_check_arg' Name +'(' Punctuation +'\n' Text + +'\t\t\t\t\t\t\t ' Text +'PyExc_NameError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t\t ' Text +'NAME_ERROR_MSG' Name +' ' Text +',' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'LOAD_GLOBAL' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'names' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyString_CheckExact' Name +'(' Punctuation +'w' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* Inline the PyDict_GetItem() calls.\n\t\t\t\t WARNING: this is an extreme speed hack.\n\t\t\t\t Do not try this at home. */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'long' Keyword.Type +' ' Text +'hash' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'(' Punctuation +'PyStringObject' Name +' ' Text +'*' Operator +')' Punctuation +'w' Name +')' Punctuation +'-' Operator +'>' Operator +'ob_shash' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'hash' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'-1' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyDictObject' Name +' ' Text +'*' Operator +'d' Name +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyDictEntry' Name +' ' Text +'*' Operator +'e' Name +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'d' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'PyDictObject' Name +' ' Text +'*' Operator +')' Punctuation +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_globals' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'e' Name +' ' Text +'=' Operator +' ' Text +'d' Name +'-' Operator +'>' Operator +'ma_lookup' Name +'(' Punctuation +'d' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'hash' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'e' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'e' Name +'-' Operator +'>' Operator +'me_value' Name +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'d' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'PyDictObject' Name +' ' Text +'*' Operator +')' Punctuation +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_builtins' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'e' Name +' ' Text +'=' Operator +' ' Text +'d' Name +'-' Operator +'>' Operator +'ma_lookup' Name +'(' Punctuation +'d' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'hash' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'e' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'e' Name +'-' Operator +'>' Operator +'me_value' Name +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'goto' Keyword +' ' Text +'load_global_error' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'/* This is the un-inlined version of the code above */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyDict_GetItem' Name +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_globals' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyDict_GetItem' Name +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_builtins' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'load_global_error' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'format_exc_check_arg' Name +'(' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'PyExc_NameError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'GLOBAL_NAME_ERROR_MSG' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'DELETE_FAST' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'GETLOCAL' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SETLOCAL' Name +'(' Punctuation +'oparg' Name +',' Punctuation +' ' Text +'NULL' Name.Builtin +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'format_exc_check_arg' Name +'(' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyExc_UnboundLocalError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t' Text +'UNBOUNDLOCAL_ERROR_MSG' Name +',' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyTuple_GetItem' Name +'(' Punctuation +'co' Name +'-' Operator +'>' Operator +'co_varnames' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'LOAD_CLOSURE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'freevars' Name +'[' Punctuation +'oparg' Name +']' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'LOAD_DEREF' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'freevars' Name +'[' Punctuation +'oparg' Name +']' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'PyCell_Get' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'-1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t\t' Text +"/* Don't stomp existing exception */" Comment.Multiline +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyErr_Occurred' Name +'(' Punctuation +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'oparg' Name +' ' Text +'<' Operator +' ' Text +'PyTuple_GET_SIZE' Name +'(' Punctuation +'co' Name +'-' Operator +'>' Operator +'co_cellvars' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'PyTuple_GET_ITEM' Name +'(' Punctuation +'co' Name +'-' Operator +'>' Operator +'co_cellvars' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'format_exc_check_arg' Name +'(' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'PyExc_UnboundLocalError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'UNBOUNDLOCAL_ERROR_MSG' Name +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +' ' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t ' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'PyTuple_GET_ITEM' Name +'(' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'co' Name +'-' Operator +'>' Operator +'co_freevars' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'oparg' Name +' ' Text +'-' Operator +' ' Text +'PyTuple_GET_SIZE' Name +'(' Punctuation +'co' Name +'-' Operator +'>' Operator +'co_cellvars' Name +')' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'format_exc_check_arg' Name +'(' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'PyExc_NameError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'UNBOUNDFREE_ERROR_MSG' Name +',' Punctuation +'\n' Text + +'\t\t\t\t ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'STORE_DEREF' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'freevars' Name +'[' Punctuation +'oparg' Name +']' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PyCell_Set' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BUILD_TUPLE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyTuple_New' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'for' Keyword +' ' Text +'(' Punctuation +';' Punctuation +' ' Text +'-' Operator +'-' Operator +'oparg' Name +' ' Text +'>' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyTuple_SET_ITEM' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'oparg' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BUILD_LIST' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyList_New' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'for' Keyword +' ' Text +'(' Punctuation +';' Punctuation +' ' Text +'-' Operator +'-' Operator +'oparg' Name +' ' Text +'>' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyList_SET_ITEM' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'oparg' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BUILD_MAP' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyDict_New' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'LOAD_ATTR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'names' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyObject_GetAttr' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'COMPARE_OP' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyInt_CheckExact' Name +'(' Punctuation +'w' Name +')' Punctuation +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyInt_CheckExact' Name +'(' Punctuation +'v' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* INLINE: cmp(int, int) */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'register' Keyword +' ' Text +'long' Keyword.Type +' ' Text +'a' Name +',' Punctuation +' ' Text +'b' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'register' Keyword +' ' Text +'int' Keyword.Type +' ' Text +'res' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'a' Name +' ' Text +'=' Operator +' ' Text +'PyInt_AS_LONG' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'b' Name +' ' Text +'=' Operator +' ' Text +'PyInt_AS_LONG' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'switch' Keyword +' ' Text +'(' Punctuation +'oparg' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'case' Keyword +' ' Text +'PyCmp_LT' Name.Label +':' Punctuation +' ' Text +'res' Name +' ' Text +'=' Operator +' ' Text +'a' Name +' ' Text +'<' Operator +' ' Text +'b' Name +';' Punctuation +' ' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'case' Keyword +' ' Text +'PyCmp_LE' Name.Label +':' Punctuation +' ' Text +'res' Name +' ' Text +'=' Operator +' ' Text +'a' Name +' ' Text +'<' Operator +'=' Operator +' ' Text +'b' Name +';' Punctuation +' ' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'case' Keyword +' ' Text +'PyCmp_EQ' Name.Label +':' Punctuation +' ' Text +'res' Name +' ' Text +'=' Operator +' ' Text +'a' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'b' Name +';' Punctuation +' ' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'case' Keyword +' ' Text +'PyCmp_NE' Name.Label +':' Punctuation +' ' Text +'res' Name +' ' Text +'=' Operator +' ' Text +'a' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'b' Name +';' Punctuation +' ' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'case' Keyword +' ' Text +'PyCmp_GT' Name.Label +':' Punctuation +' ' Text +'res' Name +' ' Text +'=' Operator +' ' Text +'a' Name +' ' Text +'>' Operator +' ' Text +'b' Name +';' Punctuation +' ' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'case' Keyword +' ' Text +'PyCmp_GE' Name.Label +':' Punctuation +' ' Text +'res' Name +' ' Text +'=' Operator +' ' Text +'a' Name +' ' Text +'>' Operator +'=' Operator +' ' Text +'b' Name +';' Punctuation +' ' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'case' Keyword +' ' Text +'PyCmp_IS' Name.Label +':' Punctuation +' ' Text +'res' Name +' ' Text +'=' Operator +' ' Text +'v' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'w' Name +';' Punctuation +' ' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'case' Keyword +' ' Text +'PyCmp_IS_NOT' Name.Label +':' Punctuation +' ' Text +'res' Name +' ' Text +'=' Operator +' ' Text +'v' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'w' Name +';' Punctuation +' ' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'default' Keyword +':' Operator +' ' Text +'goto' Keyword +' ' Text +'slow_compare' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'res' Name +' ' Text +'?' Operator +' ' Text +'Py_True' Name.Label +' ' Text +':' Punctuation +' ' Text +'Py_False' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t ' Text +'slow_compare' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'cmp_outcome' Name +'(' Punctuation +'oparg' Name +',' Punctuation +' ' Text +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PREDICT' Name +'(' Punctuation +'JUMP_IF_FALSE' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PREDICT' Name +'(' Punctuation +'JUMP_IF_TRUE' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'IMPORT_NAME' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'names' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyDict_GetItemString' Name +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_builtins' Name +',' Punctuation +' ' Text +'"' Literal.String +'__import__' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_ImportError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'"' Literal.String +'__import__ not found' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyInt_AsLong' Name +'(' Punctuation +'u' Name +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'-1' Literal.Number.Integer +' ' Text +'|' Operator +'|' Operator +' ' Text +'PyErr_Occurred' Name +'(' Punctuation +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'PyTuple_Pack' Name +'(' Punctuation +'5' Literal.Number.Integer +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'w' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'f' Name +'-' Operator +'>' Operator +'f_globals' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'f' Name +'-' Operator +'>' Operator +'f_locals' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +' ' Text +'?' Operator +'\n' Text + +'\t\t\t\t\t\t ' Text +'Py_None' Name.Label +' ' Text +':' Punctuation +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_locals' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'v' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'PyTuple_Pack' Name +'(' Punctuation +'4' Literal.Number.Integer +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'w' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'f' Name +'-' Operator +'>' Operator +'f_globals' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'f' Name +'-' Operator +'>' Operator +'f_locals' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +' ' Text +'?' Operator +'\n' Text + +'\t\t\t\t\t\t ' Text +'Py_None' Name.Label +' ' Text +':' Punctuation +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_locals' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'intr0' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyEval_CallObject' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'intr1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'IMPORT_STAR' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PyFrame_FastToLocals' Name +'(' Punctuation +'f' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'(' Punctuation +'x' Name +' ' Text +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_locals' Name +')' Punctuation +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_SystemError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'"' Literal.String +"no locals found during 'import *'" Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'intr0' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'import_all_from' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'intr1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PyFrame_LocalsToFast' Name +'(' Punctuation +'f' Name +',' Punctuation +' ' Text +'0' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'IMPORT_FROM' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'GETITEM' Name +'(' Punctuation +'names' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'intr0' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'import_from' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'intr1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'JUMP_FORWARD' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'JUMPBY' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'PREDICTED_WITH_ARG' Name +'(' Punctuation +'JUMP_IF_FALSE' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'JUMP_IF_FALSE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'Py_True' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PREDICT' Name +'(' Punctuation +'POP_TOP' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'Py_False' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'JUMPBY' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyObject_IsTrue' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'>' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'JUMPBY' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'PREDICTED_WITH_ARG' Name +'(' Punctuation +'JUMP_IF_TRUE' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'JUMP_IF_TRUE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'Py_False' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PREDICT' Name +'(' Punctuation +'POP_TOP' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'w' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'Py_True' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'JUMPBY' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'goto' Keyword +' ' Text +'fast_next_opcode' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyObject_IsTrue' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'>' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'JUMPBY' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'PREDICTED_WITH_ARG' Name +'(' Punctuation +'JUMP_ABSOLUTE' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'JUMP_ABSOLUTE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'JUMPTO' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'GET_ITER' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'/* before: [obj]; after [getiter(obj)] */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyObject_GetIter' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PREDICT' Name +'(' Punctuation +'FOR_ITER' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'STACKADJ' Name +'(' Punctuation +'-1' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'PREDICTED_WITH_ARG' Name +'(' Punctuation +'FOR_ITER' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'FOR_ITER' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'/* before: [iter]; after: [iter, iter()] *or* [] */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'*' Operator +'v' Name +'-' Operator +'>' Operator +'ob_type' Name +'-' Operator +'>' Operator +'tp_iternext' Name +')' Punctuation +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PREDICT' Name +'(' Punctuation +'STORE_FAST' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PREDICT' Name +'(' Punctuation +'UNPACK_SEQUENCE' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyErr_Occurred' Name +'(' Punctuation +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'!' Operator +'PyErr_ExceptionMatches' Name +'(' Punctuation +'PyExc_StopIteration' Name +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyErr_Clear' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'/* iterator ended normally */' Comment.Multiline +'\n' Text + +' \t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'JUMPBY' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BREAK_LOOP' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_BREAK' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_block_end' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'CONTINUE_LOOP' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'retval' Name +' ' Text +'=' Operator +' ' Text +'PyInt_FromLong' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'!' Operator +'retval' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_CONTINUE' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'fast_block_end' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'SETUP_LOOP' Name.Label +':' Punctuation +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'SETUP_EXCEPT' Name.Label +':' Punctuation +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'SETUP_FINALLY' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'/* NOTE: If you add any new block-setup opcodes that are not try/except/finally\n\t\t\t handlers, you may need to update the PyGen_NeedsFinalizing() function. */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t\t' Text +'PyFrame_BlockSetup' Name +'(' Punctuation +'f' Name +',' Punctuation +' ' Text +'opcode' Name +',' Punctuation +' ' Text +'INSTR_OFFSET' Name +'(' Punctuation +')' Punctuation +' ' Text +'+' Operator +' ' Text +'oparg' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'STACK_LEVEL' Name +'(' Punctuation +')' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'WITH_CLEANUP' Name.Label +':' Punctuation +'\n' Text + +'\t\t' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'/* TOP is the context.__exit__ bound method.\n\t\t\t Below that are 1-3 values indicating how/why\n\t\t\t we entered the finally clause:\n\t\t\t - SECOND = None\n\t\t\t - (SECOND, THIRD) = (WHY_{RETURN,CONTINUE}), retval\n\t\t\t - SECOND = WHY_*; no retval below it\n\t\t\t - (SECOND, THIRD, FOURTH) = exc_info()\n\t\t\t In the last case, we must call\n\t\t\t TOP(SECOND, THIRD, FOURTH)\n\t\t\t otherwise we must call\n\t\t\t TOP(None, None, None)\n\n\t\t\t In addition, if the stack represents an exception,\n\t\t\t *and* the function call returns a \'true\' value, we\n\t\t\t "zap" this information, to prevent END_FINALLY from\n\t\t\t re-raising the exception. (But non-local gotos\n\t\t\t should still be resumed.)\n\t\t\t*/' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'SECOND' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyInt_Check' Name +'(' Punctuation +'u' Name +')' Punctuation +' ' Text +'|' Operator +'|' Operator +' ' Text +'u' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'Py_None' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'Py_None' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'THIRD' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'FOURTH' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'/* XXX Not the fastest way to call it... */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyObject_CallFunctionObjArgs' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'u' Name +',' Punctuation +' ' Text +'v' Name +',' Punctuation +' ' Text +'w' Name +',' Punctuation +' ' Text +'NULL' Name.Builtin +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +' ' Text +'/* Go to error exit */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'u' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'Py_None' Name +' ' Text +'&' Operator +'&' Operator +' ' Text +'PyObject_IsTrue' Name +'(' Punctuation +'x' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* There was an exception and a true return */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +' ' Text +'/* Again */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'STACKADJ' Name +'(' Punctuation +'-3' Literal.Number.Integer +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'Py_None' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'Py_None' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +' ' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'/* Let END_FINALLY do its thing */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'CALL_FUNCTION' Name.Label +':' Punctuation +'\n' Text + +'\t\t' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'sp' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PCALL' Name +'(' Punctuation +'PCALL_ALL' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'sp' Name +' ' Text +'=' Operator +' ' Text +'stack_pointer' Name +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef WITH_TSC' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'call_function' Name +'(' Punctuation +'&' Operator +'sp' Name +',' Punctuation +' ' Text +'oparg' Name +',' Punctuation +' ' Text +'&' Operator +'intr0' Name +',' Punctuation +' ' Text +'&' Operator +'intr1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'else' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'call_function' Name +'(' Punctuation +'&' Operator +'sp' Name +',' Punctuation +' ' Text +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t' Text +'stack_pointer' Name +' ' Text +'=' Operator +' ' Text +'sp' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'CALL_FUNCTION_VAR' Name.Label +':' Punctuation +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'CALL_FUNCTION_KW' Name.Label +':' Punctuation +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'CALL_FUNCTION_VAR_KW' Name.Label +':' Punctuation +'\n' Text + +'\t\t' Text +'{' Punctuation +'\n' Text + +'\t\t ' Text +'int' Keyword.Type +' ' Text +'na' Name +' ' Text +'=' Operator +' ' Text +'oparg' Name +' ' Text +'&' Operator +' ' Text +'0xff' Literal.Number.Hex +';' Punctuation +'\n' Text + +'\t\t ' Text +'int' Keyword.Type +' ' Text +'nk' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'oparg' Name +'>' Operator +'>' Operator +'8' Literal.Number.Integer +')' Punctuation +' ' Text +'&' Operator +' ' Text +'0xff' Literal.Number.Hex +';' Punctuation +'\n' Text + +'\t\t ' Text +'int' Keyword.Type +' ' Text +'flags' Name +' ' Text +'=' Operator +' ' Text +'(' Punctuation +'opcode' Name +' ' Text +'-' Operator +' ' Text +'CALL_FUNCTION' Name +')' Punctuation +' ' Text +'&' Operator +' ' Text +'3' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t ' Text +'int' Keyword.Type +' ' Text +'n' Name +' ' Text +'=' Operator +' ' Text +'na' Name +' ' Text +'+' Operator +' ' Text +'2' Literal.Number.Integer +' ' Text +'*' Operator +' ' Text +'nk' Name +';' Punctuation +'\n' Text + +'\t\t ' Text +'PyObject' Name +' ' Text +'*' Operator +'*' Operator +'pfunc' Name +',' Punctuation +' ' Text +'*' Operator +'func' Name +',' Punctuation +' ' Text +'*' Operator +'*' Operator +'sp' Name +';' Punctuation +'\n' Text + +'\t\t ' Text +'PCALL' Name +'(' Punctuation +'PCALL_ALL' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t ' Text +'if' Keyword +' ' Text +'(' Punctuation +'flags' Name +' ' Text +'&' Operator +' ' Text +'CALL_FLAG_VAR' Name +')' Punctuation +'\n' Text + +'\t\t\t ' Text +'n' Name +'+' Operator +'+' Operator +';' Punctuation +'\n' Text + +'\t\t ' Text +'if' Keyword +' ' Text +'(' Punctuation +'flags' Name +' ' Text +'&' Operator +' ' Text +'CALL_FLAG_KW' Name +')' Punctuation +'\n' Text + +'\t\t\t ' Text +'n' Name +'+' Operator +'+' Operator +';' Punctuation +'\n' Text + +'\t\t ' Text +'pfunc' Name +' ' Text +'=' Operator +' ' Text +'stack_pointer' Name +' ' Text +'-' Operator +' ' Text +'n' Name +' ' Text +'-' Operator +' ' Text +'1' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t ' Text +'func' Name +' ' Text +'=' Operator +' ' Text +'*' Operator +'pfunc' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t ' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyMethod_Check' Name +'(' Punctuation +'func' Name +')' Punctuation +'\n' Text + +'\t\t\t' Text +'&' Operator +'&' Operator +' ' Text +'PyMethod_GET_SELF' Name +'(' Punctuation +'func' Name +')' Punctuation +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t ' Text +'PyObject' Name +' ' Text +'*' Operator +'self' Name +' ' Text +'=' Operator +' ' Text +'PyMethod_GET_SELF' Name +'(' Punctuation +'func' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'Py_INCREF' Name +'(' Punctuation +'self' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'func' Name +' ' Text +'=' Operator +' ' Text +'PyMethod_GET_FUNCTION' Name +'(' Punctuation +'func' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'Py_INCREF' Name +'(' Punctuation +'func' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'Py_DECREF' Name +'(' Punctuation +'*' Operator +'pfunc' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'*' Operator +'pfunc' Name +' ' Text +'=' Operator +' ' Text +'self' Name +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'na' Name +'+' Operator +'+' Operator +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'n' Name +'+' Operator +'+' Operator +';' Punctuation +'\n' Text + +'\t\t ' Text +'}' Punctuation +' ' Text +'else' Keyword +'\n' Text + +'\t\t\t ' Text +'Py_INCREF' Name +'(' Punctuation +'func' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t ' Text +'sp' Name +' ' Text +'=' Operator +' ' Text +'stack_pointer' Name +';' Punctuation +'\n' Text + +'\t\t ' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'intr0' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t ' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'ext_do_call' Name +'(' Punctuation +'func' Name +',' Punctuation +' ' Text +'&' Operator +'sp' Name +',' Punctuation +' ' Text +'flags' Name +',' Punctuation +' ' Text +'na' Name +',' Punctuation +' ' Text +'nk' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t ' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'intr1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t ' Text +'stack_pointer' Name +' ' Text +'=' Operator +' ' Text +'sp' Name +';' Punctuation +'\n' Text + +'\t\t ' Text +'Py_DECREF' Name +'(' Punctuation +'func' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t ' Text +'while' Keyword +' ' Text +'(' Punctuation +'stack_pointer' Name +' ' Text +'>' Operator +' ' Text +'pfunc' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t ' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t ' Text +'Py_DECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t ' Text +'}' Punctuation +'\n' Text + +'\t\t ' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t ' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t\t ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t ' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'MAKE_FUNCTION' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +' ' Text +'/* code object */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyFunction_New' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_globals' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'/* XXX Maybe this should be a separate opcode? */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +' ' Text +'&' Operator +'&' Operator +' ' Text +'oparg' Name +' ' Text +'>' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'PyTuple_New' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'v' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'while' Keyword +' ' Text +'(' Punctuation +'-' Operator +'-' Operator +'oparg' Name +' ' Text +'>' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyTuple_SET_ITEM' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'oparg' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyFunction_SetDefaults' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'MAKE_CLOSURE' Name.Label +':' Punctuation +'\n' Text + +'\t\t' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +' ' Text +'/* code object */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PyFunction_New' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_globals' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyFunction_SetClosure' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +' ' Text +'&' Operator +'&' Operator +' ' Text +'oparg' Name +' ' Text +'>' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'PyTuple_New' Name +'(' Punctuation +'oparg' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'v' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'while' Keyword +' ' Text +'(' Punctuation +'-' Operator +'-' Operator +'oparg' Name +' ' Text +'>' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyTuple_SET_ITEM' Name +'(' Punctuation +'v' Name +',' Punctuation +' ' Text +'oparg' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'PyFunction_SetDefaults' Name +'(' Punctuation +'x' Name +',' Punctuation +' ' Text +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'PUSH' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'BUILD_SLICE' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'oparg' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'3' Literal.Number.Integer +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +'\n' Text + +'\t\t\t\t' Text +'w' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'u' Name +' ' Text +'=' Operator +' ' Text +'TOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'PySlice_New' Name +'(' Punctuation +'u' Name +',' Punctuation +' ' Text +'v' Name +',' Punctuation +' ' Text +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'u' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'w' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'SET_TOP' Name +'(' Punctuation +'x' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'continue' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'case' Keyword +' ' Text +'EXTENDED_ARG' Name.Label +':' Punctuation +'\n' Text + +'\t\t\t' Text +'opcode' Name +' ' Text +'=' Operator +' ' Text +'NEXTOP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'oparg' Name +' ' Text +'=' Operator +' ' Text +'oparg' Name +'<' Operator +'<' Operator +'16' Literal.Number.Integer +' ' Text +'|' Operator +' ' Text +'NEXTARG' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'goto' Keyword +' ' Text +'dispatch_opcode' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'default' Keyword +':' Operator +'\n' Text + +'\t\t\t' Text +'fprintf' Name +'(' Punctuation +'stderr' Name +',' Punctuation +'\n' Text + +'\t\t\t\t' Text +'"' Literal.String +'XXX lineno: %d, opcode: %d' Literal.String +'\\n' Literal.String.Escape +'"' Literal.String +',' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyCode_Addr2Line' Name +'(' Punctuation +'f' Name +'-' Operator +'>' Operator +'f_code' Name +',' Punctuation +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_lasti' Name +')' Punctuation +',' Punctuation +'\n' Text + +'\t\t\t\t' Text +'opcode' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_SystemError' Name +',' Punctuation +' ' Text +'"' Literal.String +'unknown opcode' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\n' Text + +'#' Comment.Preproc +'ifdef CASE_TOO_BIG' Comment.Preproc +'\n' Comment.Preproc + +'\t\t' Text +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'\t\t' Text +'}' Punctuation +' ' Text +'/* switch */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t ' Text +'on_error' Name.Label +':' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'inst1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'/* Quickly continue if no error occurred */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_NOT' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'err' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'0' Literal.Number.Integer +' ' Text +'&' Operator +'&' Operator +' ' Text +'x' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef CHECKEXC' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t\t' Text +'/* This check is expensive! */' Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyErr_Occurred' Name +'(' Punctuation +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'fprintf' Name +'(' Punctuation +'stderr' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'"' Literal.String +'XXX undetected error' Literal.String +'\\n' Literal.String.Escape +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'loop1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'continue' Keyword +';' Punctuation +' ' Text +'/* Normal, fast path */' Comment.Multiline +'\n' Text + +'#' Comment.Preproc +'ifdef CHECKEXC' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'x' Name +' ' Text +'=' Operator +' ' Text +'Py_None' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'err' Name +' ' Text +'=' Operator +' ' Text +'0' Literal.Number.Integer +';' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'/* Double-check exception status */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +' ' Text +'|' Operator +'|' Operator +' ' Text +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_RERAISE' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'!' Operator +'PyErr_Occurred' Name +'(' Punctuation +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'PyErr_SetString' Name +'(' Punctuation +'PyExc_SystemError' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'"' Literal.String +'error return without exception set' Literal.String +'"' Literal.String +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'ifdef CHECKEXC' Comment.Preproc +'\n' Comment.Preproc + +'\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'/* This check is expensive! */' Comment.Multiline +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'PyErr_Occurred' Name +'(' Punctuation +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'char' Keyword.Type +' ' Text +'buf' Name +'[' Punctuation +'1024' Literal.Number.Integer +']' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'sprintf' Name +'(' Punctuation +'buf' Name +',' Punctuation +' ' Text +'"' Literal.String +'Stack unwind with exception ' Literal.String +'"' Literal.String +'\n' Text + +'\t\t\t\t\t' Text +'"' Literal.String +'set and why=%d' Literal.String +'"' Literal.String +',' Punctuation +' ' Text +'why' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_FatalError' Name +'(' Punctuation +'buf' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'#' Comment.Preproc +'endif' Comment.Preproc +'\n' Comment.Preproc + +'\n' Text + +'\t\t' Text +'/* Log traceback info if this is a real exception */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'PyTraceBack_Here' Name +'(' Punctuation +'f' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_tracefunc' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'call_exc_trace' Name +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_tracefunc' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'tstate' Name +'-' Operator +'>' Operator +'c_traceobj' Name +',' Punctuation +' ' Text +'f' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'/* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_RERAISE' Name +')' Punctuation +'\n' Text + +'\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t' Text +'/* Unwind stacks if a (pseudo) exception occurred */' Comment.Multiline +'\n' Text + +'\n' Text + +'fast_block_end' Name.Label +':' Punctuation +'\n' Text + +'\t\t' Text +'while' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'WHY_NOT' Name +' ' Text +'&' Operator +'&' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_iblock' Name +' ' Text +'>' Operator +' ' Text +'0' Literal.Number.Integer +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'PyTryBlock' Name +' ' Text +'*' Operator +'b' Name +' ' Text +'=' Operator +' ' Text +'PyFrame_BlockPop' Name +'(' Punctuation +'f' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'\t\t\t' Text +'assert' Name +'(' Punctuation +'why' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'WHY_YIELD' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'b' Name +'-' Operator +'>' Operator +'b_type' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'SETUP_LOOP' Name +' ' Text +'&' Operator +'&' Operator +' ' Text +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_CONTINUE' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +"/* For a continue inside a try block,\n\t\t\t\t don't pop the block for the loop. */" Comment.Multiline +'\n' Text + +'\t\t\t\t' Text +'PyFrame_BlockSetup' Name +'(' Punctuation +'f' Name +',' Punctuation +' ' Text +'b' Name +'-' Operator +'>' Operator +'b_type' Name +',' Punctuation +' ' Text +'b' Name +'-' Operator +'>' Operator +'b_handler' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'b' Name +'-' Operator +'>' Operator +'b_level' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_NOT' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'JUMPTO' Name +'(' Punctuation +'PyInt_AS_LONG' Name +'(' Punctuation +'retval' Name +')' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_DECREF' Name +'(' Punctuation +'retval' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t\t\t' Text +'while' Keyword +' ' Text +'(' Punctuation +'STACK_LEVEL' Name +'(' Punctuation +')' Punctuation +' ' Text +'>' Operator +' ' Text +'b' Name +'-' Operator +'>' Operator +'b_level' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'b' Name +'-' Operator +'>' Operator +'b_type' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'SETUP_LOOP' Name +' ' Text +'&' Operator +'&' Operator +' ' Text +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_BREAK' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_NOT' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'JUMPTO' Name +'(' Punctuation +'b' Name +'-' Operator +'>' Operator +'b_handler' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'b' Name +'-' Operator +'>' Operator +'b_type' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'SETUP_FINALLY' Name +' ' Text +'|' Operator +'|' Operator +'\n' Text + +'\t\t\t ' Text +'(' Punctuation +'b' Name +'-' Operator +'>' Operator +'b_type' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'SETUP_EXCEPT' Name +' ' Text +'&' Operator +'&' Operator +'\n' Text + +'\t\t\t ' Text +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyObject' Name +' ' Text +'*' Operator +'exc' Name +',' Punctuation +' ' Text +'*' Operator +'val' Name +',' Punctuation +' ' Text +'*' Operator +'tb' Name +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PyErr_Fetch' Name +'(' Punctuation +'&' Operator +'exc' Name +',' Punctuation +' ' Text +'&' Operator +'val' Name +',' Punctuation +' ' Text +'&' Operator +'tb' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'val' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'val' Name +' ' Text +'=' Operator +' ' Text +'Py_None' Name +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'val' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +"/* Make the raw exception data\n\t\t\t\t\t available to the handler,\n\t\t\t\t\t so a program can emulate the\n\t\t\t\t\t Python main loop. Don't do\n\t\t\t\t\t this for 'finally'. */" Comment.Multiline +'\n' Text + +'\t\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'b' Name +'-' Operator +'>' Operator +'b_type' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'SETUP_EXCEPT' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'PyErr_NormalizeException' Name +'(' Punctuation +'\n' Text + +'\t\t\t\t\t\t\t' Text +'&' Operator +'exc' Name +',' Punctuation +' ' Text +'&' Operator +'val' Name +',' Punctuation +' ' Text +'&' Operator +'tb' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'set_exc_info' Name +'(' Punctuation +'tstate' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t\t ' Text +'exc' Name +',' Punctuation +' ' Text +'val' Name +',' Punctuation +' ' Text +'tb' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tb' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'Py_INCREF' Name +'(' Punctuation +'Py_None' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'Py_None' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'}' Punctuation +' ' Text +'else' Keyword +'\n' Text + +'\t\t\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'tb' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'val' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'exc' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'&' Operator +' ' Text +'(' Punctuation +'WHY_RETURN' Name +' ' Text +'|' Operator +' ' Text +'WHY_CONTINUE' Name +')' Punctuation +')' Punctuation +'\n' Text + +'\t\t\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'retval' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'PyInt_FromLong' Name +'(' Punctuation +'(' Punctuation +'long' Keyword.Type +')' Punctuation +'why' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'PUSH' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_NOT' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'JUMPTO' Name +'(' Punctuation +'b' Name +'-' Operator +'>' Operator +'b_handler' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +' ' Text +'/* unwind stack */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'/* End the loop if we still have an error (or return) */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'WHY_NOT' Name +')' Punctuation +'\n' Text + +'\t\t\t' Text +'break' Keyword +';' Punctuation +'\n' Text + +'\t\t' Text +'READ_TIMESTAMP' Name +'(' Punctuation +'loop1' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'}' Punctuation +' ' Text +'/* main loop */' Comment.Multiline +'\n' Text + +'\n' Text + +'\t' Text +'assert' Name +'(' Punctuation +'why' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'WHY_YIELD' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'/* Pop remaining stack entries. */' Comment.Multiline +'\n' Text + +'\t' Text +'while' Keyword +' ' Text +'(' Punctuation +'!' Operator +'EMPTY' Name +'(' Punctuation +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t' Text +'v' Name +' ' Text +'=' Operator +' ' Text +'POP' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'v' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'WHY_RETURN' Name +')' Punctuation +'\n' Text + +'\t\t' Text +'retval' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\n' Text + +'fast_yield' Name.Label +':' Punctuation +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'use_tracing' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_tracefunc' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_RETURN' Name +' ' Text +'|' Operator +'|' Operator +' ' Text +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_YIELD' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'call_trace' Name +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_tracefunc' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'tstate' Name +'-' Operator +'>' Operator +'c_traceobj' Name +',' Punctuation +' ' Text +'f' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'PyTrace_RETURN' Name +',' Punctuation +' ' Text +'retval' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'retval' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'retval' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'call_trace_protected' Name +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_tracefunc' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'tstate' Name +'-' Operator +'>' Operator +'c_traceobj' Name +',' Punctuation +' ' Text +'f' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'PyTrace_RETURN' Name +',' Punctuation +' ' Text +'NULL' Name.Builtin +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_profilefunc' Name +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'why' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +')' Punctuation +'\n' Text + +'\t\t\t\t' Text +'call_trace_protected' Name +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_profilefunc' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'tstate' Name +'-' Operator +'>' Operator +'c_profileobj' Name +',' Punctuation +' ' Text +'f' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t\t ' Text +'PyTrace_RETURN' Name +',' Punctuation +' ' Text +'NULL' Name.Builtin +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t' Text +'else' Keyword +' ' Text +'if' Keyword +' ' Text +'(' Punctuation +'call_trace' Name +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'c_profilefunc' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'tstate' Name +'-' Operator +'>' Operator +'c_profileobj' Name +',' Punctuation +' ' Text +'f' Name +',' Punctuation +'\n' Text + +'\t\t\t\t\t ' Text +'PyTrace_RETURN' Name +',' Punctuation +' ' Text +'retval' Name +')' Punctuation +')' Punctuation +' ' Text +'{' Punctuation +'\n' Text + +'\t\t\t\t' Text +'Py_XDECREF' Name +'(' Punctuation +'retval' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'retval' Name +' ' Text +'=' Operator +' ' Text +'NULL' Name.Builtin +';' Punctuation +'\n' Text + +'\t\t\t\t' Text +'why' Name +' ' Text +'=' Operator +' ' Text +'WHY_EXCEPTION' Name +';' Punctuation +'\n' Text + +'\t\t\t' Text +'}' Punctuation +'\n' Text + +'\t\t' Text +'}' Punctuation +'\n' Text + +'\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'if' Keyword +' ' Text +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'frame' Name +'-' Operator +'>' Operator +'f_exc_type' Name +' ' Text +'!' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +'\n' Text + +'\t\t' Text +'reset_exc_info' Name +'(' Punctuation +'tstate' Name +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'else' Keyword +' ' Text +'{' Punctuation +'\n' Text + +'\t\t' Text +'assert' Name +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'frame' Name +'-' Operator +'>' Operator +'f_exc_value' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +';' Punctuation +'\n' Text + +'\t\t' Text +'assert' Name +'(' Punctuation +'tstate' Name +'-' Operator +'>' Operator +'frame' Name +'-' Operator +'>' Operator +'f_exc_traceback' Name +' ' Text +'=' Operator +'=' Operator +' ' Text +'NULL' Name.Builtin +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'}' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'/* pop frame */' Comment.Multiline +'\n' Text + +' ' Text +'exit_eval_frame' Name.Label +':' Punctuation +'\n' Text + +'\t' Text +'Py_LeaveRecursiveCall' Name +'(' Punctuation +')' Punctuation +';' Punctuation +'\n' Text + +'\t' Text +'tstate' Name +'-' Operator +'>' Operator +'frame' Name +' ' Text +'=' Operator +' ' Text +'f' Name +'-' Operator +'>' Operator +'f_back' Name +';' Punctuation +'\n' Text + +'\n' Text + +'\t' Text +'return' Keyword +' ' Text +'retval' Name +';' Punctuation +'\n' Text + +'}' Punctuation +'\n' Text |