Pushes a hash on top of the Lua stack.
178094
def stack_push_hash(h)

      Lib.lua_createtable(@pointer, 0, h.size)
        # since we already know the size of the table...

      h.each do |k, v|
        stack_push(k)
        stack_push(v)
        Lib.lua_settable(@pointer, -3)
      end
    end
344940
def push(self, *items):
        
        if self.serialized:
            items = list(map(self._dumps, items))
        return self._client.lpush(self.key_prefix, *items)
51521
def push(new_scope = {})
      @scopes.unshift(new_scope)
      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > Block::MAX_DEPTH
    end
64950
def insert_before_each(middleware, *args, &block)
      self.stack = stack.reduce([]) do |carry, item|
        carry.push([middleware, args, block], item)
      end
    end
728441
def add(hash, &func)
      raise ArgumentError.new('Expecting hash of arguments') unless hash.is_a?(Hash)
      raise ArgumentError.new('A period must be provided for timed action') unless hash[:period]
      raise ArgumentError.new('Block must be provided') unless block_given?
      raise ArgumentError.new('Block must accept data value') if hash[:data] && func.arity == 0
      args = {:once => false, :data => nil, :owner => nil}.merge(hash)
      action = Action.new(args.merge(:timer => self), &func)
      @add_lock.synchronize{ @new_actions << action }
      wakeup if running?
      action
    end
414177
def stack(options={}, &block)
      @stack ||= begin
        if block_given?
          Faraday::RackBuilder.new(&block)
        else
          Faraday::RackBuilder.new(&default_middleware(options))
        end
      end
    end
1137312
function ensureArrayAndPush(object, key, value) {
            if (!Array.isArray(object[key])) {
                object[key] = [];
            }
            object[key].push(value);
        }
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
65987
def push_gem(file, options = {})
      ensure_ready!(:authorization)
      push_api = connection(:url => self.pushpoint)
      response = push_api.post('uploads', options.merge(:file => file))
      checked_response_body(response)
    end
1152320
function Hash (blockSize, finalSize) {
	  this._block = Buffer$4.alloc(blockSize);
	  this._finalSize = finalSize;
	  this._blockSize = blockSize;
	  this._len = 0;
	}
347397
def _push_textbuffer(self):
        """"""
        if self._textbuffer:
            self._stack.append(tokens.Text(text="".join(self._textbuffer)))
            self._textbuffer = []
970765
def set_hash(self, algo, digest):
        """"""
        self.algo = algo
        self.digest = digest
628818
def push(*what)
      if what.length.zero?
        primitive 'push graphic-context'
      else
        # to_s allows a Symbol to be used instead of a String
        primitive 'push ' + what.map(&:to_s).join(' ')
      end
    end
497727
def push_buffer
      raise Shells::NotRunning unless running?
      # push the buffer so we can get the output of a command.
      debug 'Pushing buffer >>'
      sync do
        output_stack.push [ stdout, stderr, output ]
        self.stdout = ''
        self.stderr = ''
        self.output = ''
      end
    end
472968
def PushState(self, **_):
    """"""
    if self.verbose:
      logging.debug("Storing state %r", self.state)
    self.state_stack.append(self.state)
581043
private void push(final int type) {
        // creates and/or resizes the output stack array if necessary
        if (outputStack == null) {
            outputStack = new int[10];
        }
        int n = outputStack.length;
        if (outputStackTop >= n) {
            int[] t = new int[Math.max(outputStackTop + 1, 2 * n)];
            System.arraycopy(outputStack, 0, t, 0, n);
            outputStack = t;
        }
        // pushes the type on the output stack
        outputStack[outputStackTop++] = type;
        // updates the maximun height reached by the output stack, if needed
        int top = owner.inputStackTop + outputStackTop;
        if (top > owner.outputStackMax) {
            owner.outputStackMax = top;
        }
    }
1257644
function(key) {
      var value = this.popStack();

      if (this.options.stringParams) {
        var type = this.popStack();
        this.popStack();
        this.source.push("hashTypes['" + key + "'] = " + type + ";");
      }

      var hash = this.topStack();

      this.source.push(hash + "['" + key + "'] = " + value + ";");
    }