parseExpression function
lang-core parseExpression: a Pratt parser over one statement's tokens.
Implementation
Ast parseExpression(List<Token> tokens) {
var pos = 0;
Token cur() => pos < tokens.length ? tokens[pos] : const Token(T.eof);
Token adv() {
final tok = cur();
pos++;
return tok;
}
void eat(T kind) {
if (cur().t == kind) pos++;
}
int infixPrec(Token tok) => switch (tok.t) {
T.question => 1,
T.or => 2,
T.and => 3,
T.eqEq || T.notEq => 4,
T.greater || T.less || T.greaterEq || T.lessEq => 5,
T.plus || T.minus => 6,
T.star || T.slash || T.percent => 7,
T.dot || T.lBracket => 9,
_ => 0,
};
late Ast Function(int minPrec) parseExpr;
Ast parseComp() {
final name = cur().v as String;
adv();
eat(T.lParen);
final args = <Ast>[];
while (cur().t != T.rParen && cur().t != T.eof) {
args.add(parseExpr(0));
if (cur().t == T.comma) adv();
}
eat(T.rParen);
return CompNode(name, args);
}
Ast parseArr() {
adv();
final els = <Ast>[];
while (cur().t != T.rBracket && cur().t != T.eof) {
els.add(parseExpr(0));
if (cur().t == T.comma) adv();
}
eat(T.rBracket);
return ArrNode(els);
}
String keyOf(Token kt) => switch (kt.t) {
T.ident || T.str || T.type => kt.v as String,
T.num => _numberKey(kt.v as num),
T.stateVar => (kt.v as String).substring(1),
_ => '?',
};
Ast parseObj() {
adv();
final entries = <(String, Ast)>[];
while (cur().t != T.rBrace && cur().t != T.eof) {
final key = keyOf(cur());
adv();
eat(T.colon);
entries.add((key, parseExpr(0)));
if (cur().t == T.comma) adv();
}
eat(T.rBrace);
return ObjNode(entries);
}
Ast parsePrefix() {
final tok = cur();
switch (tok.t) {
case T.str:
adv();
return StrNode(tok.v as String);
case T.num:
adv();
return NumNode(tok.v as num);
case T.trueKw:
adv();
return const BoolNode(true);
case T.falseKw:
adv();
return const BoolNode(false);
case T.nullKw:
adv();
return const NullNode();
case T.lBracket:
return parseArr();
case T.lBrace:
return parseObj();
case T.stateVar:
adv();
if (cur().t == T.equals) {
adv();
return AssignNode(tok.v as String, parseExpr(0));
}
return StateRefNode(tok.v as String);
case T.type:
final name = tok.v as String;
final calls = pos + 1 < tokens.length && tokens[pos + 1].t == T.lParen;
if (calls && (!builtinNames.contains(name) || name == 'Action')) {
return parseComp();
}
adv();
return RefNode(name);
case T.builtinCall:
if (pos + 1 < tokens.length && tokens[pos + 1].t == T.lParen) {
final call = parseComp() as CompNode;
return builtinNames.contains(call.name)
? call
: CompNode(call.name, call.args, isAtCall: true);
}
adv();
return RefNode(tok.v as String);
case T.ident:
adv();
return RefNode(tok.v as String);
case T.not:
adv();
return UnaryOpNode('!', parseExpr(8));
case T.minus:
adv();
return UnaryOpNode('-', parseExpr(8));
case T.lParen:
adv();
final inner = parseExpr(0);
eat(T.rParen);
return inner;
default:
adv();
return const NullNode();
}
}
Ast parseInfix(Ast left) {
final tok = cur();
final binary = switch (tok.t) {
T.plus => ('+', 6),
T.minus => ('-', 6),
T.star => ('*', 7),
T.slash => ('/', 7),
T.percent => ('%', 7),
T.eqEq => ('==', 4),
T.notEq => ('!=', 4),
T.greater => ('>', 5),
T.less => ('<', 5),
T.greaterEq => ('>=', 5),
T.lessEq => ('<=', 5),
T.and => ('&&', 3),
T.or => ('||', 2),
_ => null,
};
if (binary != null) {
adv();
return BinOpNode(binary.$1, left, parseExpr(binary.$2));
}
switch (tok.t) {
case T.question:
adv();
final then = parseExpr(0);
eat(T.colon);
return TernaryNode(left, then, parseExpr(0));
case T.dot:
adv();
final f = cur();
adv();
return MemberNode(left, keyOf(f));
case T.lBracket:
adv();
final index = parseExpr(0);
eat(T.rBracket);
return IndexNode(left, index);
default:
return left;
}
}
parseExpr = (int minPrec) {
var left = parsePrefix();
while (infixPrec(cur()) > minPrec) {
left = parseInfix(left);
}
return left;
};
return parseExpr(0);
}