definition
| call
542079
function() {
    var parens = 1
      , i = 2
      , tok;

    // Lookahead and determine if we are dealing
    // with a function call or definition. Here
    // we pair parens to prevent false negatives
    out:
    while (tok = this.lookahead(i++)) {
      switch (tok.type) {
        case 'function':
        case '(':
          ++parens;
          break;
        case ')':
          if (!--parens) break out;
          break;
        case 'eos':
          this.error('failed to find closing paren ")"');
      }
    }

    // Definition or call
    switch (this.currentState()) {
      case 'expression':
        return this.functionCall();
      default:
        return this.looksLikeFunctionDefinition(i)
          ? this.functionDefinition()
          : this.expression();
    }
  }
1030940
public function lastCall(): Call
    {
        if ($count = count($this->calls)) {
            return $this->calls[$count - 1];
        }

        throw new UndefinedCallException(0);
    }
618393
def answer(call)
      cmd = "ALTER CALL #{call.call_id} ANSWER"
      r = Skype.send_command cmd
      raise RuntimeError("Failed to answer call.  Skype returned '#{r}'") unless r == cmd
    end
1371406
def call(value, type)
      return type.call(value) if type.respond_to?(:call)

      self[type].call(value)
    end
51993
def called_from
      location = caller.detect('unknown:0') do |line|
        line.match(/\/liquid(-|\/)ext/).nil?
      end
      file, line, _ = location.split(':')
      { :file => file, :line => line }
    end
159848
func Call(ctx context.Context, request Request, response interface{}, opts ...CallOption) error {
	return DefaultClient.Call(ctx, request, response, opts...)
}
690041
def _call(self, method, url, params, uploads):
        
        try:
            data = self._request(method, url, params, uploads)
        except Exception, e:
            self._failed_cb(e)
        else:
            self._completed_cb(data)
384334
private boolean invokeCall(RTMPConnection conn, IServiceCall call, Object service) {
        final IScope scope = conn.getScope();
        final IContext context = scope.getContext();
        if (log.isTraceEnabled()) {
            log.trace("Scope: {} context: {} service: {}", scope, context, service);
        }
        return context.getServiceInvoker().invoke(call, service);
    }
812075
func call(v reflect.Value, method reflect.Method) reflect.Value {
    funcType := method.Type
    // Method must take no arguments, meaning as a func it has one argument (the receiver)
    if funcType.NumIn() != 1 {
        return reflect.Value{}
    }
    // Method must return a single value.
    if funcType.NumOut() == 0 {
        return reflect.Value{}
    }
    // Result will be the zeroth element of the returned slice.
    return method.Func.Call([]reflect.Value{v})[0]
}
69506
public static Object callN(Callable fun, Scriptable thisObj,
                               Object[] args,
                               Context cx, Scriptable scope)
    {
        return fun.call(cx, scope, thisObj, args);
    }
827013
def on_call(receiver, dot, method)
      if rcv = resolve_receiver(receiver)
        method_call(method, [rcv])
      end
       
      keep_walking(receiver)
    end
22706
function callOnce(fn) {
  var called = false

  return calledOnceShim

  //-----------------------------------
  function calledOnceShim() {
    if (called) return
    called = true

    fn.apply(this, arguments)
  }
}
669994
function SpyCall( scope, args, spy ) {
	var self = this;

	if ( ! ( self instanceof SpyCall ) ) {
		return new SpyCall( args );
	}

	self.scope = scope;
	self.args = args;
	self.time = new Date();
	self.order = spy.assert._spyOrder++;
	self.overall = Spy.overall++;
	self.trace = ( new Error( "" ) ).stack;
}
579003
def _handleCallInitiated(self, regexMatch, callId=None, callType=1):
        
        if self._dialEvent:
            if regexMatch:
                groups = regexMatch.groups()
                # Set self._dialReponse to (callId, callType)
                if len(groups) >= 2:
                    self._dialResponse = (int(groups[0]) , int(groups[1]))
                else:
                    self._dialResponse = (int(groups[0]), 1) # assume call type: VOICE
            else:
                self._dialResponse = callId, callType
            self._dialEvent.set()
909882
@CanIgnoreReturnValue
  public <V> V call(Callable<V> c) throws Exception {
    Context previous = attach();
    try {
      return c.call();
    } finally {
      detach(previous);
    }
  }
87583
def _handle_calls(self, alts, format_, format_str, arr):
        """"""
        if format_str not in self._format_cache:
            self._format_cache[format_str] = list(map(self.header.get_format_field_info, format_))
        # per-sample calls
        calls = []
        for sample, raw_data in zip(self.samples.names, arr[9:]):
            if self.samples.is_parsed(sample):
                data = self._parse_calls_data(format_, self._format_cache[format_str], raw_data)
                call = record.Call(sample, data)
                self._format_checker.run(call, len(alts))
                self._check_filters(call.data.get("FT"), "FORMAT/FT", call.sample)
                calls.append(call)
            else:
                calls.append(record.UnparsedCall(sample, raw_data))
        return calls
656503
def call(method, *args)
      ok, param = call2(method, *args) 
      if ok
        param
      else
        raise param
      end
    end