Lines Matching refs:stack
49 /* A soft limit for stack use, to avoid excessive
53 * Code that could use more stack than this is
238 /* Exception stack at start of block, used by assembler to create the exception handling table */
251 /* depth of stack upon entry of block, computed by stackdepth() */
376 // i items off of the stack. The end result looks like this (with each block
386 // The number of items on top of the stack that need to *stay* on top of the
387 // stack. Variable captures go beneath these. All of them will be popped on
934 /* Return the stack effect of opcode with argument oparg.
936 Some opcodes have different stack effect when jump to the target and
1082 * Restore the stack position and push 1 value before jumping to
1090 * Restore the stack position to the position before the result
1167 /* If there's a fmt_spec on the stack, we go from 2->1,
1784 /* Push the old compiler_unit on the stack. */
1838 "stack item", NULL);
1994 * (exception_unwind clears the stack)
2110 /** Unwind block stack. If loop is not NULL, then stop when the first loop is encountered. */
3330 The special instructions use the block stack. Each block
3331 stack entry contains the instruction that created it (here
3332 SETUP_FINALLY), the level of the value stack at the time the
3333 block stack entry was created, and a label (here L).
3336 Pushes the current value stack level and the label
3337 onto the block stack.
3339 Pops en entry from the block stack.
3341 The block stack is unwound when an exception is raised:
3343 exceptions are pushed onto the value stack (and the exception
3345 gotten from the block stack.
3451 (The contents of the value stack is shown in [], with the top
3455 Value stack Label Instruction Argument
3609 (The contents of the value stack is shown in [], with the top
3613 Value stack Label Instruction Argument
3725 /* Push the original EG into the stack */
4810 scope stack every time this function is called, it will
5161 nseen = 0; /* the number of keyword arguments on the stack following */
5745 T: POP_TOP (remove exception from stack)
6294 // of the stack: they will be popped on failure, and any name captures will be
6335 // Pop any items on the top of the stack, plus any objects we were going to
6440 // We've now got a bunch of new subjects on the stack. They need to remain
6717 // So far so good. Use that tuple of values on the stack to match
6771 // the order in which extracted elements are placed on the stack.
6814 // Reorder the names on the stack to match the order of the
6839 // Do the same thing to the stack, using several
6867 // There's a bunch of stuff on the stack between where the new stores
6871 // - Anything else that may be on top of the stack.
6872 // - Any previous stores we've already stashed away on the stack.
6875 // Rotate this capture to its proper place on the stack:
7049 // It's a match! Store all of the captured names (they're on the stack).
7151 /* Find the flow path that needs the largest stack. We assume that
7152 * cycles in the flow graph have no net effect on the stack depth.
7158 basicblock **stack, **sp;
7166 stack = (basicblock **)PyObject_Malloc(sizeof(basicblock *) * nblocks);
7167 if (!stack) {
7172 sp = stack;
7178 while (sp != stack) {
7225 PyObject_Free(stack);
7283 push_except_block(ExceptStack *stack, struct instr *setup) {
7290 stack->handlers[++stack->depth] = target;
7295 pop_except_block(ExceptStack *stack) {
7296 assert(stack->depth > 0);
7297 return stack->handlers[--stack->depth];
7301 except_stack_top(ExceptStack *stack) {
7302 return stack->handlers[stack->depth];
7318 copy_except_stack(ExceptStack *stack) {
7324 memcpy(copy, stack, sizeof(ExceptStack));
8607 // maximum depth of the stack manipulations:
8628 int *stack = PyMem_Malloc(depth * sizeof(int));
8629 if (stack == NULL) {
8634 stack[i] = i;
8637 // our "stack":
8641 int top = stack[0];
8643 stack[0] = stack[oparg - 1];
8644 stack[oparg - 1] = top;
8650 // "un-shuffle" our stack. By performing the moves in *reverse* order,
8658 if (stack[i] == VISITED || stack[i] == i) {
8676 if (stack[j] == VISITED) {
8681 int next_j = stack[j];
8682 stack[j] = VISITED;
8690 PyMem_Free(stack);
8727 // stack items. For example, we can replace SWAP(2), POP_TOP, STORE_FAST(42)
9181 basicblock **stack, **sp;
9182 sp = stack = (basicblock **)PyObject_Malloc(sizeof(basicblock *) * a->a_nblocks);
9183 if (stack == NULL) {
9188 while (sp > stack) {
9208 PyObject_Free(stack);