Push an item onto the stack.
337955
def push(self, value: Union[int, bytes]) -> None:
        
        if len(self.values) > 1023:
            raise FullStack('Stack limit reached')

        validate_stack_item(value)

        self.values.append(value)
334171
def push(self, obj):
        
        if isinstance(obj, str):
            obj = KQMLToken(obj)
        self.data.insert(0, obj)
1036195
def _add_to_stack(self, item, value):
        
        p_value = (item, value)
        if p_value not in self.stack:
            self.stack.append(p_value)
1018637
public function push($value, $key = null)
    {
        if (is_null($key)) {
            $this->items[] = $value;
        } else {
            $this->items[$key] = $value;
        }
    }
873392
def append(self, item):
        """"""
        if len(self) == 0:
            # Special case, we make this the current item
            self.index = 0

        self.items.append(item)
1167424
def add_item(self, item):
        """"""
        _idx = len(self.items)
        self.items.update({"item_" + str(_idx + 1): item})
1151369
def push(self, record, shard):
        
        heapq.heappush(self.heap, heap_item(self.clock, record, shard))
327614
public void push(ICMLModule item) {
        if (sp == stack.length) {
            ICMLModule[] temp = new ICMLModule[2 * sp];
            System.arraycopy(stack, 0, temp, 0, sp);
            stack = temp;
        }
        stack[sp++] = item;
    }
928630
public boolean push(String newText) {
        if (stackTop < stack.length - 1) {
            stack[stackTop++] = newText;
            return true;
        } else {
            return false;
        }
    }
1127801
def add(self, item):
        """"""
        if not item in self.items:
            self.items.append(item)
230166
public function push($item): bool {
        if (!$this->isValid()) return false;

        $this->stack[$this->size] = $item;
        $this->size++;
        return true;
    }
61766
private void pushState(Node<K,V>[] t, int i, int n) {
            TableStack<K,V> s = spare;  // reuse if possible
            if (s != null)
                spare = s.next;
            else
                s = new TableStack<K,V>();
            s.tab = t;
            s.length = n;
            s.index = i;
            s.next = stack;
            stack = s;
        }
320310
def put(self, item):
        '''
        
        '''
        if self.isfini:
            return False

        self.fifo.append(item)

        if len(self.fifo) == 1:
            self.event.set()

        return True
613975
private void push(final LazyNode token){
		stackTop.addChild(token);
		// The stack allocation strategy here is to increase it in increments
		// of a power of two. This lets us check when all low bits are set and
		// its time to increase the stack again.
		// This lets us do a compare between a constant and a variable instead
		// of between two variables.
		if((stackPointer & STACK_INCREASE)==STACK_INCREASE){
			LazyNode[] newStack=new LazyNode[STACK_SIZE+STACK_INCREASE+1];
			System.arraycopy(stack,0,newStack,0,STACK_SIZE);
			STACK_SIZE=STACK_SIZE+STACK_INCREASE+1;
			stack=newStack;
		}
		stack[stackPointer++]=token;
		stackTop=token;
	}
924046
def push(self, x):
        
        if isinstance(x, Frame):
            frame = x
        else:
            frame = Frame(x)
        self.stack.append(frame)
        #log.debug('push: (%s)\n%s', Repr(frame), Repr(self.stack))
        return frame
1305260
function pushStack(stack, node) {
  stack.type = node.type;
  stack.children = [];
  stack.instance = typeof node.type === 'function' ? node.stateNode : stack;
}
379516
function push(obj, prop, value) {
    (obj[prop] = (obj[prop] || [])).push(value);
  }