Push the frame cf onto the stack. Return the new stack.
546501
def push(self, cf):
        
        cf.next = self
        if self.state is not None:
            self.state.register_plugin('callstack', cf)
            self.state.history.recent_stack_actions.append(CallStackAction(
                hash(cf), len(cf), 'push', callframe=cf.copy({}, with_tail=False)
            ))

        return cf
906750
def _push_writer(self):
        """"""

        buf = util.FastEncodingBuffer()
        self._buffer_stack.append(buf)
        return buf.write
1036195
def _add_to_stack(self, item, value):
        
        p_value = (item, value)
        if p_value not in self.stack:
            self.stack.append(p_value)
1045553
def push(self, item):
        '''
        '''
        hash(item)
        heapq.heappush(self._items, item)
40609
public Matrix4fStack pushMatrix() {
        if (curr == mats.length) {
            throw new IllegalStateException("max stack size of " + (curr + 1) + " reached"); //$NON-NLS-1$ //$NON-NLS-2$
        }
        mats[curr++].set(this);
        return this;
    }
51521
def push(new_scope = {})
      @scopes.unshift(new_scope)
      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > Block::MAX_DEPTH
    end
347397
def _push_textbuffer(self):
        """"""
        if self._textbuffer:
            self._stack.append(tokens.Text(text="".join(self._textbuffer)))
            self._textbuffer = []
683594
function pushFrame(resultSet, options, frameElement, frameSelector) {
	'use strict';
	var frameXpath = axe.utils.getXpath(frameElement);
	var frameSpec = {
		element: frameElement,
		selector: frameSelector,
		xpath: frameXpath
	};

	resultSet.forEach(function(res) {
		res.node = axe.utils.DqElement.fromFrame(res.node, options, frameSpec);

		var checks = axe.utils.getAllChecks(res);
		if (checks.length) {
			checks.forEach(function(check) {
				check.relatedNodes = check.relatedNodes.map(node =>
					axe.utils.DqElement.fromFrame(node, options, frameSpec)
				);
			});
		}
	});
}
574203
def _get_stack_frame(stacklevel):
    
    stacklevel = stacklevel + 1
    if stacklevel <= 1 or _is_internal_frame(sys._getframe(1)):
        # If frame is too small to care or if the warning originated in
        # internal code, then do not try to hide any frames.
        frame = sys._getframe(stacklevel)
    else:
        frame = sys._getframe(1)
        # Look for one frame less since the above line starts us off.
        for x in range(stacklevel-1):
            frame = _next_external_frame(frame)
            if frame is None:
                raise ValueError
    return frame
370490
def PushSection(self, name, pre_formatters):
        
        if name == '@':
            value = self.stack[-1].context
        else:
            value = self.stack[-1].context.get(name)
        
        # Apply pre-formatters
        for i, (f, args, formatter_type) in enumerate(pre_formatters):
            if formatter_type == ENHANCED_FUNC:
                value = f(value, self, args)
            elif formatter_type == SIMPLE_FUNC:
                value = f(value)
            else:
                assert False, 'Invalid formatter type %r' % formatter_type
        
        self.stack.append(_Frame(value))
        return value
170798
def stack_push(self, key, value):
        
        task = Task.current_task()
        try:
            context = task._context_stack
        except AttributeError:
            task._context_stack = context = {}
        if key not in context:
            context[key] = []
        context[key].append(value)
1231408
def add_stack_frame(self, stack_frame):
        """"""
        if len(self.stack_frames) >= MAX_FRAMES:
            self.dropped_frames_count += 1
        else:
            self.stack_frames.append(stack_frame.format_stack_frame_json())
593514
public void push()
    {
        Map<String, Iterable<? extends WindupVertexFrame>> newFrame = new HashMap<>();
        deque.push(newFrame);
    }
1151096
def push(self, obj):
        """"""
        rv = getattr(self._local, "stack", None)
        if rv is None:
            self._local.stack = rv = []
        rv.append(obj)
        return rv
976707
private final void push() {
    if (ptr >= stack.length) {
      // doubling here is probably overkill, but anything that needs to double more than
      // once (32 levels deep) is very atypical anyway.
      byte[] newstack = new byte[stack.length<<1];
      System.arraycopy(stack,0,newstack,0,stack.length);
      stack = newstack;
    }
    stack[ptr++] = state;
  }
272501
def push_frame(self, offset):
        
        self._frames.append((offset, self.tell()))
        self._total_offset += offset

        self.seek_in_frame(0)
489653
private void pushProductOfIntArrayOnStack() {
    Label beginScopeLabel = new Label();
    Label endScopeLabel = new Label();

    int dimsArrayIndex = newLocal("[I", beginScopeLabel, endScopeLabel);
    int counterIndex = newLocal("I", beginScopeLabel, endScopeLabel);
    int productIndex = newLocal("I", beginScopeLabel, endScopeLabel);
    Label loopLabel = new Label();
    Label endLabel = new Label();

    super.visitLabel(beginScopeLabel);

    // stack: ... intArray
    super.visitVarInsn(Opcodes.ASTORE, dimsArrayIndex);
    // -> stack: ...

    // counter = 0
    super.visitInsn(Opcodes.ICONST_0);
    super.visitVarInsn(Opcodes.ISTORE, counterIndex);
    // product = 1
    super.visitInsn(Opcodes.ICONST_1);
    super.visitVarInsn(Opcodes.ISTORE, productIndex);
    // loop:
    super.visitLabel(loopLabel);
    // if index >= arraylength goto end:
    super.visitVarInsn(Opcodes.ILOAD, counterIndex);
    super.visitVarInsn(Opcodes.ALOAD, dimsArrayIndex);
    super.visitInsn(Opcodes.ARRAYLENGTH);
    super.visitJumpInsn(Opcodes.IF_ICMPGE, endLabel);
    // product = product * max(array[counter],1)
    super.visitVarInsn(Opcodes.ALOAD, dimsArrayIndex);
    super.visitVarInsn(Opcodes.ILOAD, counterIndex);
    super.visitInsn(Opcodes.IALOAD);
    super.visitInsn(Opcodes.DUP);
    Label nonZeroDimension = new Label();
    super.visitJumpInsn(Opcodes.IFNE, nonZeroDimension);
    super.visitInsn(Opcodes.POP);
    super.visitInsn(Opcodes.ICONST_1);
    super.visitLabel(nonZeroDimension);
    super.visitVarInsn(Opcodes.ILOAD, productIndex);
    super.visitInsn(Opcodes.IMUL); // if overflow happens it happens.
    super.visitVarInsn(Opcodes.ISTORE, productIndex);
    // iinc counter 1
    super.visitIincInsn(counterIndex, 1);
    // goto loop
    super.visitJumpInsn(Opcodes.GOTO, loopLabel);
    // end:
    super.visitLabel(endLabel);
    // re-push dimensions array
    super.visitVarInsn(Opcodes.ALOAD, dimsArrayIndex);
    // push product
    super.visitVarInsn(Opcodes.ILOAD, productIndex);

    super.visitLabel(endScopeLabel);
  }