FunctionCall ::= Identifier '(' ')' || Identifier '(' ArgumentList ')'
337609
function parseFunctionCall(name) {
                    var token, expr, args = [];

                    token = lexer.next();
                    if (!matchOp(token, '(')) {
                        throw new SyntaxError('Expecting ( in a function call "' + name + '"');
                    }

                    token = lexer.peek();
                    if (!matchOp(token, ')')) {
                        args = parseArgumentList();
                    }

                    token = lexer.next();
                    if (!matchOp(token, ')')) {
                        throw new SyntaxError('Expecting ) in a function call "' + name + '"');
                    }

                    expr = new MathLib.Expression({
                        subtype: 'functionCall',
                        value: name,
                        content: args
                    });

                    if (name in MathLib && MathLib[name].type === 'functn') {
                        if (MathLib[name].expression.content[0].hasOwnProperty('cdgroup')) {
                            expr.cdgroup = MathLib[name].expression.content[0].cdgroup;
                        }

                        if (MathLib[name].expression.content[0].hasOwnProperty('contentMathMLName')) {
                            expr.contentMathMLName = MathLib[name].expression.content[0].contentMathMLName;
                        }

                        if (MathLib[name].expression.content[0].hasOwnProperty('toContentMathML')) {
                            expr.toContentMathML = MathLib[name].expression.content[0].toContentMathML;
                        }

                        if (MathLib[name].expression.content[0].hasOwnProperty('toLaTeX')) {
                            expr.toLaTeX = MathLib[name].expression.content[0].toLaTeX;
                        }

                        if (MathLib[name].expression.content[0].hasOwnProperty('toMathML')) {
                            expr.toMathML = MathLib[name].expression.content[0].toMathML;
                        }

                        if (MathLib[name].expression.content[0].hasOwnProperty('toString')) {
                            expr.toString = MathLib[name].expression.content[0].toString;
                        }
                    }

                    return expr;
                }
916292
def p_funcall_expr(p):
    
    if (len(p) == 5 and len(p[3]) == 1 and p[3][0].__class__ is node.expr and
            p[3][0].op == ":" and not p[3][0].args):
        # foo(:) => ravel(foo)
        p[0] = node.funcall(
            func_expr=node.ident("ravel"), args=node.expr_list([p[1]]))
    else:
        args = node.expr_list() if len(p) == 4 else p[3]
        assert isinstance(args, node.expr_list)
        p[0] = node.funcall(func_expr=p[1], args=args)
655874
function CallArguments_Argument(&$res, $sub)
    {
        if (!empty($res['php'])) {
            $res['php'] .= ', ';
        }

        $res['php'] .= ($sub['ArgumentMode'] == 'default') ? $sub['string_php'] :
            str_replace('$$FINAL', 'XML_val', $sub['php']);
    }
1356865
def callable_check(func, arg_count=1, arg_value=None, allow_none=False):
        """"""
        if func is None:
            if not allow_none:
                raise ValueError('callable cannot be None')
        elif not arg_checker(func, *[arg_value for _ in range(arg_count)]):
            raise ValueError('callable %s invalid (for %d arguments)' % (func, arg_count))
169481
function extractFunctionCall(str) {
      var match = /(\w+)\((.*)\)/.exec(str);
      if (!match) throw new Error("Invalid click handler '"+str+"'");

      return {
        "method": match[1],
        "args": match[2].split(',')
      };
    }
276648
def call(self, fn, *args, **kwargs):
        
        return self.default_call_chain.call(fn, *args, **kwargs)
55242
def _internal_function_call(self, call_conf):
        '''
        
        '''
        def stub(*args, **kwargs):
            message = 'Function {} is not available'.format(call_conf['fun'])
            self.out.error(message)
            log.debug(
                'Attempt to run "%s" with %s arguments and %s parameters.',
                call_conf['fun'], call_conf['arg'], call_conf['kwargs']
            )
            return message

        return getattr(salt.cli.support.intfunc,
                       call_conf['fun'], stub)(self.collector,
                                               *call_conf['arg'],
                                               **call_conf['kwargs'])
888045
def p_function_call(p):
    
    # FIXME: This production also matches NodeType() or
    # processing-instruction("foo"), which are technically NodeTest
    qname = p[1]
    p[0] = ast.FunctionCall(qname[0], qname[1], p[2])
588404
function reduceFunctionCall(string, functionRE, callback) {
  var call = string
  return getFunctionCalls(string, functionRE).reduce(function(string, obj) {
    return string.replace(obj.functionIdentifier + "(" + obj.matches.body + ")", evalFunctionCall(obj.matches.body, obj.functionIdentifier, callback, call, functionRE))
  }, string)
}
633173
function isArguments(value) {
      var str = _toString.call(value);
      var result = str === '[object Arguments]';
      if (!result) {
        result = str !== '[object Array]' &&
          value !== null &&
          typeof value === 'object' &&
          typeof value.length === 'number' &&
          value.length >= 0 &&
          _toString.call(value.callee) === '[object Function]';
      }
      return result;
    }
224684
function (functionName, arguments) {
                var self = this;
                var args = self._getArgs(arguments);
                var callback = self._getCallback(arguments);

                return self._generic(functionName, args)
                    .nodeify(callback);
            }
547697
def func_call_as_str(name, *args, **kwds):
    
    return '{0}({1})'.format(
        name,
        ', '.join(itertools.chain(
            map('{0!r}'.format, args),
            map('{0[0]!s}={0[1]!r}'.format, sorted(kwds.items())))))
816184
def visit_Call(self, node):
        
        func_aliases = self.aliases[node.func]
        if len(func_aliases) == 1:
            function_def = next(iter(func_aliases))
            if (isinstance(function_def, ast.FunctionDef) and
                    function_def.name in self.inlinable):
                self.update = True
                to_inline = copy.deepcopy(self.inlinable[function_def.name])
                arg_to_value = dict()
                values = node.args
                values += to_inline.args.defaults[len(node.args) -
                                                  len(to_inline.args.args):]
                for arg_fun, arg_call in zip(to_inline.args.args, values):
                    v_name = "__pythran_inline{}{}{}".format(function_def.name,
                                                             arg_fun.id,
                                                             self.call_count)
                    new_var = ast.Name(id=v_name,
                                       ctx=ast.Store(),
                                       annotation=None)
                    self.defs.append(ast.Assign(targets=[new_var],
                                                value=arg_call))
                    arg_to_value[arg_fun.id] = ast.Name(id=v_name,
                                                        ctx=ast.Load(),
                                                        annotation=None)
                self.call_count += 1
                return Inliner(arg_to_value).visit(to_inline.body[0])
        return node
783851
def split_func_name_args_params_handle(tokens):
    """"""
    internal_assert(len(tokens) == 2, "invalid function definition splitting tokens", tokens)
    func_name = tokens[0]
    func_args = []
    func_params = []
    for arg in tokens[1]:
        if len(arg) > 1 and arg[0] in ("*", "**"):
            func_args.append(arg[1])
        elif arg[0] != "*":
            func_args.append(arg[0])
        func_params.append("".join(arg))
    return [
        func_name,
        ", ".join(func_args),
        "(" + ", ".join(func_params) + ")",
    ]
1288398
protected Expression functionCall() {
        FunctionCall call = new FunctionCall();
        Token funToken = tokenizer.consume();
        Function fun = functionTable.get(funToken.getContents());
        if (fun == null) {
            errors.add(ParseError.error(funToken, String.format("Unknown function: '%s'", funToken.getContents())));
        }
        call.setFunction(fun);
        tokenizer.consume();
        while (!tokenizer.current().isSymbol(")") && tokenizer.current().isNotEnd()) {
            if (!call.getParameters().isEmpty()) {
                expect(Token.TokenType.SYMBOL, ",");
            }
            call.addParameter(expression());
        }
        expect(Token.TokenType.SYMBOL, ")");
        if (fun == null) {
            return Constant.EMPTY;
        }
        if (call.getParameters().size() != fun.getNumberOfArguments() && fun.getNumberOfArguments() >= 0) {
            errors.add(ParseError.error(funToken,
                                        String.format(
                                                "Number of arguments for function '%s' do not match. Expected: %d, Found: %d",
                                                funToken.getContents(),
                                                fun.getNumberOfArguments(),
                                                call.getParameters().size())));
            return Constant.EMPTY;
        }
        return call;
    }
571099
function getArguments(f, amended)
{
  var functionCode = f.toString();
  if(amended){
    //This is a fix for when we are passed anonymous functions (which are passed to us as unassigned)
    //ex: "function (a, b, c) { }"
    //These are actually parse errors so we'll try adding an assignment to fix the parse error
    functionCode = 'var a=' + functionCode;
  }
  try{
    var ast = babylon.parse(functionCode);
    var functionDecl = findFunctionDecl(ast);

    if(!functionDecl) return [];

    return functionDecl.params.map(p => p.name);
  }catch(e){
    //try one more time
    if(!amended){
      return getArguments(f, true);
    }

    throw new Error('Could not parse:\n' + functionCode + '\n' + e);
  }
}
808778
function func(ast) {
  var params = list(ast["params"])
  var id = ast["id"] ? to_s(ast["id"]) : ""
  return "function " + id + "(" + params + ") " + to_s(ast["body"])
}