============Call============
976503
protected void callStart(final HttpCallback<?> callback, final Request request) {
        if (callback == null)
            return;
        callback.dispatchStart(request);
    }
1187107
function call() {
		$args = func_get_args(); $fn = array_shift($args);
		try {
			$val = call_user_func_array($fn, $args);
			if ($val instanceof \Generator) return $this->spawn($val);
			$val = Promise::interpret( $val );
			if ($val instanceof PromiseInterface) {
				if ( $val->getState() === self::REJECTED ) $this->reject( GP\inspect($val)['reason'] );
				else $val->then( array($this,'resolve'), array($this,'reject') );
			} else {
				$this->resolve($val);
				return $val;
			}
		} catch (\Exception $e) {
			$this->reject($e);
		} catch (\Throwable $t) {
			$this->reject($t);
		}
		return $this;
	}
958546
public function errorAllPendingCalls()
    {
        foreach ($this->calls as $call) {
            $call->getCallerSession()->sendMessage(ErrorMessage::createErrorMessageFromMessage($call->getCallMessage(), 'wamp.error.canceled'));
        }
    }
168581
function processCall(msg) {
      var route = msg.route;
      if(!!route) {
        if (!!msg.body) {
          var body = msg.body.body;
          if (!body) {body = msg.body;}
          pomelo.emit(route, body);
        } else {
          pomelo.emit(route,msg);
        }
      } else {
          pomelo.emit(msg.body.route,msg.body);
      }
    }
663032
public V call() throws Exception {
        if (Tracy.isEnabled(this.tracyWorkerContext))   {
            Tracy.setContext(this.tracyWorkerContext);
        }
        else    {
            Tracy.clearContext();
        }
        return userCallable.call();
    }
1042909
public static <ReqT, RespT> void asyncServerStreamingCall(
      ClientCall<ReqT, RespT> call, ReqT req, StreamObserver<RespT> responseObserver) {
    asyncUnaryRequestCall(call, req, responseObserver, true);
  }
222260
public <T> ApiResponse<T> execute(Call call) throws ApiException {
        return execute(call, null);
    }
724939
def call(self, callname, data=None, **args):
        
        url = f"{self.url_base}/{callname}"
        payload = self.payload.copy()
        payload.update(**args)

        if data is not None:
            payload.update(data)

        res = self.session.post(url, data=payload)

        if res.status_code > 299:
            self.log.error(f"URL: {url}")
            self.log.error(f"Payload: {payload}")
            self.log.error(f"STATUS: {res.status_code}")
            self.log.error(f"RESPONSE: {res.text}")
            return
        elif 'error' in res.json():
            self.log.error(res.json()['error'])
            return

        return res.json()
1354419
public function call($call, $data = [], $options = [])
  {
    list($name, $function) = explode('.', $call, 2);

    return $this->client($name, function ($client) use ($function, $data, $options) {
      /** @var Client $client */
      return $client->SoapCall($function, $data, $options);
    });
  }
586558
public static void assertAnswered(String msg, SipCall call) {
    assertNotNull("Null assert object passed in", call);
    assertTrue(msg, call.isCallAnswered());
  }
338530
public function fromCall(Call $call): CallVerifier
    {
        return new CallVerifier(
            $call,
            $this->matcherFactory,
            $this->matcherVerifier,
            $this->generatorVerifierFactory,
            $this->iterableVerifierFactory,
            $this->assertionRecorder,
            $this->assertionRenderer
        );
    }
1174138
void callback(boolean ask) {
        if (viStatusCallback != null) {
            if (states.remove(callState.toString().toLowerCase())) {
                if (logger.isInfoEnabled()) {
                    logger.info("About to execute viStatusCallback: " + viStatusCallback.toString());
                }
                if (viStatusCallbackMethod == null) {
                    viStatusCallbackMethod = "POST";
                }
                final List<NameValuePair> parameters = parameters();
                requestCallback = new HttpRequestDescriptor(viStatusCallback, viStatusCallbackMethod, parameters);
                if (!ask) {
                    downloader.tell(requestCallback, null);
                } else if (ask) {
                    final Timeout timeout = new Timeout(Duration.create(5, TimeUnit.SECONDS));
                    Future<Object> future = (Future<Object>) ask(downloader, requestCallback, timeout);
                    DownloaderResponse downloaderResponse = null;
                    try {
                        downloaderResponse = (DownloaderResponse) Await.result(future, Duration.create(10, TimeUnit.SECONDS));
                    } catch (Exception e) {
                        logger.error("Exception during callback with ask pattern");
                    }
                }
            } else {
                if (logger.isInfoEnabled()) {
                    logger.info("Status Callback has been already executed for state: ",callState.toString());
                }
            }
        } else if(logger.isInfoEnabled()){
            logger.info("status callback is null");
        }

    }
483876
private void processObjectCreateCall(Node callNode) {
    Node curParam = callNode.getSecondChild();
    if (canOptimizeObjectCreate(curParam)) {
      Node objNode = IR.objectlit().srcref(callNode);
      while (curParam != null) {
        Node keyNode = curParam;
        Node valueNode = curParam.getNext();
        curParam = valueNode.getNext();

        callNode.removeChild(keyNode);
        callNode.removeChild(valueNode);

        addKeyValueToObjLit(objNode, keyNode, valueNode);
      }
      callNode.replaceWith(objNode);
      compiler.reportChangeToEnclosingScope(objNode);
    }
  }
583087
@ObjectiveCName("checkCall:withAttempt:")
    public void checkCall(long callId, int attempt) {
        if (modules.getCallsModule() != null) {
            modules.getCallsModule().checkCall(callId, attempt);
        }
    }
366573
private void processInheritsCall(Node n) {
    if (n.getChildCount() == 3) {
      Node subClass = n.getSecondChild();
      Node superClass = subClass.getNext();
      if (subClass.isUnscopedQualifiedName() && superClass.isUnscopedQualifiedName()) {
        knownClosureSubclasses.add(subClass.getQualifiedName());
      }
    }
  }
48281
public static function _call($reference, $call)
    {
        $static = false;
        if (preg_match('/^::.*/', $call['name'])) {
            $call['name'] = substr($call['name'], 2);
            $call['static'] = true;
        }
        if (is_object($reference)) {
            $call += ['instance' => $reference, 'class' => get_class($reference), 'static' => $static, 'method' => null];
        } elseif ($reference) {
            $call += ['instance' => null, 'class' => $reference, 'static' => $static, 'method' => null];
        } else {
            $call += ['instance' => null, 'class' => null, 'static' => false, 'method' => null];
        }
        return $call;
    }
462611
def call(function, args, pseudo_type=None):
    ''''''

    if not isinstance(function, Node):
        function = local(function)
    return Node('call', function=function, args=args, pseudo_type=pseudo_type)