static Node *parseIdOrFuncCall(Parser *p)
{
Node *expr = 0;
String id;
stringInit(&id, p->toklen);
stringAdd(&id, p->tokval, p->toklen);
p->tok = lexerGetToken(p->lex, &p->tokval, &p->toklen);
if (p->tok == TK_LP) { // (
ExprList *arg;
p->tok = lexerGetToken(p->lex, &p->tokval, &p->toklen);
arg = parseExprList(p);
if (p->tok == TK_RP) {
#ifdef LOG_PARSE
info("解析得到FuncCall\n");
#endif
expr = (Node *)funcCallNew(&id, arg);
p->tok = lexerGetToken(p->lex, &p->tokval, &p->toklen);
} else {
handleParserError(p, 1, "解析FuncCall,缺少)");
}
} else {
#ifdef LOG_PARSE
info("解析得到IdExpr\n");
#endif
expr = (Node *)idExprNew(&id);
}
return expr;
}
ExprListPtr desugarEvalExpr(EvalExprPtr eval, EnvPtr env, CompilerState* cst)
{
if (eval->evaled)
return eval->value;
else {
SourcePtr source = evalToSource(eval->location, new ExprList(eval->args), env, cst);
eval->value = parseExprList(source, 0, unsigned(source->size()), cst);
eval->evaled = true;
return eval->value;
}
}
/**
Parse a function call expression
call <fun_expr> <arg_tuple_expr>
*/
Tuple parseCallExpr(Input* input)
{
auto funExpr = parseExpr(input);
input->eatWS();
if (!input->matchCh('('))
throw ParseError(input, "expected argument list");
auto argList = parseExprList(input, ')');
return Tuple{
Tuple("call"),
funExpr,
argList
};
}
/**
Implements the parsing of expressions that are part of the core language
The core language supports:
- Functions (but not closures)
- Integer literals (decimal only)
- String literals
- Tuple literals [a,b]
- If-else expressions
- Sequencing blocks with {a;b}
- Function calls fun(a,b)
*/
Tuple coreParseExpr(Input* input)
{
// Consume whitespace
input->eatWS();
// Numerical constant
if (isdigit(input->peekCh()))
{
return parseInt(input);
}
// String literal
if (input->matchCh('\''))
{
return parseStringLit(input, '\'');
}
if (input->matchCh('\"'))
{
return parseStringLit(input, '\"');
}
// Tuple expression
if (input->matchCh('['))
{
return Tuple{
Tuple("tuple"),
parseExprList(input, ']')
};
}
// Block/sequence expression (i.e { a; b; c }
if (input->matchCh('{'))
{
return parseBlockExpr(input, '}');
}
// Keywords
if (isalnum(input->peekCh()))
{
// If expression
if (input->matchStr("if"))
return parseIfExpr(input);
// Let expression
if (input->matchStr("let"))
return parseLetExpr(input);
// Function definition expression
if (input->matchStr("fun"))
return parseFunExpr(input);
// Function call expression
if (input->matchStr("call"))
return parseCallExpr(input);
}
// Host/magic constants
if (input->matchCh('$'))
{
return parseHostRef(input);
}
// Variable references
if (input->peekCh() == '_' || isalpha(input->peekCh()))
{
return parseIdent(input);
}
// Parsing failed
throw ParseError(input, "failed to parse expression");
}
