private void print(StringBuilder builder, int indent, Predicate<GExpansion> filter) {
if (!filter.test(this)) return;
builder.append("\n");
Utils.printIndent(builder, indent);
String kindString = kind.toString();
if (negativeLookahead) kindString = "negative" + kindString;
builder.append(Utils.lowerCaseFirst(kindString)).append("(");
switch (kind) {
case LookAhead:
if (semanticLookahead != null) {
builder.append("{ ");
builder.append(Printer.printToString(semanticLookahead, true).trim());
builder.append(" }");
break;
}
if (amount != -1) {
builder.append(amount);
break;
}
case Choice:
case Sequence:
case ZeroOrOne:
case ZeroOrMore:
case OneOrMore:
for (GExpansion child : children) {
child.print(builder, indent + 1, filter);
}
builder.append("\n");
Utils.printIndent(builder, indent);
break;
case NonTerminal:
if (this.name != null) builder.append(this.name).append(", ");
builder.append(symbol);
break;
case Terminal:
if (this.name != null) builder.append(this.name).append(", ");
builder.append(symbol);
break;
case Action:
builder.append("{");
if (action.size() == 1 && action.first().kind() != org.jlato.tree.Kind.IfStmt) {
builder.append(" ");
builder.append(Printer.printToString(action.first(), true).trim());
builder.append(" ");
} else {
builder.append("\n");
Utils.printIndented(action, builder, indent + 1);
Utils.printIndent(builder, indent);
}
builder.append("}");
break;
default:
}
builder.append(")");
}
private MethodDecl matchMethod(
String methodName,
NodeList<Stmt> stmts,
GExpansion expansion,
NodeList<FormalParameter> params) {
return methodDecl(primitiveType(Primitive.Int), name(methodName))
.withModifiers(listOf(Modifier.Private))
.withParams(
listOf(
formalParameter(primitiveType(Primitive.Int))
.withId(variableDeclaratorId(LOOKAHEAD)))
.appendAll(params))
.withBody(blockStmt().withStmts(stmts))
.appendLeadingComment(expansion.toString(e -> e.kind != GExpansion.Kind.Action), true);
}
private Expr buildLookaheadWithAmountCondition(
String symbol,
GExpansion expansion,
int amount,
NodeList<FormalParameter> params,
NodeList<Expr> args) {
String matchMethodName = "match" + symbol + "_lookahead" + incrementCount(symbol);
NodeList<Stmt> stmts =
buildLookaheadWithAmountCondition(
Collections.singletonList(expansion.location()), 0, amount, params, args);
stmts = stmts.append(returnStmt().withExpr(FAILED_LOOKAHEAD));
createMatchMethod(symbol, matchMethodName, expansion, stmts, emptyList());
return binaryExpr(
matchMethodCall(matchMethodName, literalExpr(0), emptyList()),
BinaryOp.NotEqual,
FAILED_LOOKAHEAD);
}
private List<String> firstTerminalsOf(GExpansion expansion) {
GContinuations c = new GContinuations(expansion.location(), productions, false);
c.next();
return c.terminals();
}
private Expr createMatchMethodAndCallFor(
String symbol,
String namePrefix,
GExpansion expansion,
Expr outerLookahead,
NodeList<FormalParameter> params,
NodeList<Expr> args,
boolean memoize) {
switch (expansion.kind) {
case LookAhead:
Expr semanticLookahead = expansion.semanticLookahead;
if (semanticLookahead != null) {
if (semanticLookahead.equals(methodInvocationExpr(name("isLambda")))) {
semanticLookahead =
methodInvocationExpr(name("isLambda")).withArgs(listOf(outerLookahead));
} else if (semanticLookahead.equals(methodInvocationExpr(name("isCast")))) {
semanticLookahead =
methodInvocationExpr(name("isCast")).withArgs(listOf(outerLookahead));
}
return conditionalExpr(semanticLookahead, outerLookahead, FAILED_LOOKAHEAD);
}
return null;
case Sequence:
{
int index = memoize ? memoizationIndex++ : -1;
NodeList<Stmt> stmts = emptyList();
int count = 0;
for (GExpansion child : expansion.children) {
Expr childCall =
createMatchMethodAndCallFor(
symbol,
namePrefix + "_" + ++count,
child,
LOOKAHEAD,
params,
params.map(p -> p.id().get().name()),
false);
if (childCall == null) continue;
stmts = stmts.append(expressionStmt(assignExpr(LOOKAHEAD, AssignOp.Normal, childCall)));
stmts =
stmts.append(
ifStmt(
binaryExpr(LOOKAHEAD, BinaryOp.Equal, FAILED_LOOKAHEAD),
memoize
? stmt("return memoizeMatch(initialLookahead, " + index + ", -1);")
.build()
: stmt("return -1;").build()));
}
if (memoize) {
stmts =
stmts.prependAll(
listOf(
stmt("int initialLookahead = lookahead;").build(),
stmt("int memoizedMatch = memoizedMatch(initialLookahead, " + index + ");")
.build(),
stmt("if (memoizedMatch > -2) return memoizedMatch;").build()));
}
stmts =
stmts.append(
memoize
? stmt("return memoizeMatch(initialLookahead, " + index + ", lookahead);")
.build()
: stmt("return lookahead;").build());
createMatchMethod(symbol, namePrefix, expansion, stmts, params);
return matchMethodCall(namePrefix, outerLookahead, args);
}
case Choice:
{
NodeList<Stmt> stmts = emptyList();
stmts =
stmts.append(
expressionStmt(
variableDeclarationExpr(
localVariableDecl(primitiveType(Primitive.Int))
.withVariables(
listOf(
variableDeclarator(variableDeclaratorId(LOOKAHEAD_NEW)))))));
int count = 0;
for (GExpansion child : expansion.children) {
Expr childCall =
createMatchMethodAndCallFor(
symbol,
namePrefix + "_" + ++count,
child,
LOOKAHEAD,
params,
params.map(p -> p.id().get().name()),
false);
if (childCall == null) continue;
stmts =
stmts.append(expressionStmt(assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall)));
stmts =
stmts.append(
ifStmt(
binaryExpr(LOOKAHEAD_NEW, BinaryOp.NotEqual, FAILED_LOOKAHEAD),
returnStmt().withExpr(LOOKAHEAD_NEW)));
}
stmts = stmts.append(returnStmt().withExpr(FAILED_LOOKAHEAD));
createMatchMethod(symbol, namePrefix, expansion, stmts, params);
return matchMethodCall(namePrefix, outerLookahead, args);
}
case ZeroOrOne:
{
NodeList<Stmt> stmts = emptyList();
stmts =
stmts.append(
expressionStmt(
variableDeclarationExpr(
localVariableDecl(primitiveType(Primitive.Int))
.withVariables(
listOf(
variableDeclarator(variableDeclaratorId(LOOKAHEAD_NEW)))))));
Expr childCall =
createMatchMethodAndCallFor(
symbol,
namePrefix + "_" + 1,
GExpansion.sequence(expansion.children),
LOOKAHEAD,
params,
params.map(p -> p.id().get().name()),
false);
stmts =
stmts.append(expressionStmt(assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall)));
stmts =
stmts.append(
ifStmt(
binaryExpr(LOOKAHEAD_NEW, BinaryOp.NotEqual, FAILED_LOOKAHEAD),
returnStmt().withExpr(LOOKAHEAD_NEW)));
stmts = stmts.append(returnStmt().withExpr(LOOKAHEAD));
createMatchMethod(symbol, namePrefix, expansion, stmts, params);
return matchMethodCall(namePrefix, outerLookahead, args);
}
case ZeroOrMore:
{
NodeList<Stmt> stmts = emptyList();
stmts =
stmts.append(
expressionStmt(
variableDeclarationExpr(
localVariableDecl(primitiveType(Primitive.Int))
.withVariables(
listOf(
variableDeclarator(variableDeclaratorId(LOOKAHEAD_NEW)))))));
Expr childCall =
createMatchMethodAndCallFor(
symbol,
namePrefix + "_" + 1,
GExpansion.sequence(expansion.children),
LOOKAHEAD,
params,
params.map(p -> p.id().get().name()),
false);
stmts =
stmts.append(expressionStmt(assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall)));
stmts =
stmts.append(
whileStmt(
binaryExpr(LOOKAHEAD_NEW, BinaryOp.NotEqual, FAILED_LOOKAHEAD),
blockStmt()
.withStmts(
listOf(
expressionStmt(
assignExpr(LOOKAHEAD, AssignOp.Normal, LOOKAHEAD_NEW)),
expressionStmt(
assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall))))));
stmts = stmts.append(returnStmt().withExpr(LOOKAHEAD));
createMatchMethod(symbol, namePrefix, expansion, stmts, params);
return matchMethodCall(namePrefix, outerLookahead, args);
}
case OneOrMore:
{
NodeList<Stmt> stmts = emptyList();
stmts =
stmts.append(
expressionStmt(
variableDeclarationExpr(
localVariableDecl(primitiveType(Primitive.Int))
.withVariables(
listOf(
variableDeclarator(variableDeclaratorId(LOOKAHEAD_NEW)))))));
Expr childCall =
createMatchMethodAndCallFor(
symbol,
namePrefix + "_" + 1,
GExpansion.sequence(expansion.children),
LOOKAHEAD,
params,
params.map(p -> p.id().get().name()),
false);
stmts =
stmts.append(expressionStmt(assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall)));
stmts =
stmts.append(
ifStmt(
binaryExpr(LOOKAHEAD_NEW, BinaryOp.Equal, FAILED_LOOKAHEAD),
returnStmt().withExpr(FAILED_LOOKAHEAD)));
stmts =
stmts.append(
whileStmt(
binaryExpr(LOOKAHEAD_NEW, BinaryOp.NotEqual, FAILED_LOOKAHEAD),
blockStmt()
.withStmts(
listOf(
expressionStmt(
assignExpr(LOOKAHEAD, AssignOp.Normal, LOOKAHEAD_NEW)),
expressionStmt(
assignExpr(LOOKAHEAD_NEW, AssignOp.Normal, childCall))))));
stmts = stmts.append(returnStmt().withExpr(LOOKAHEAD));
createMatchMethod(symbol, namePrefix, expansion, stmts, params);
return matchMethodCall(namePrefix, outerLookahead, args);
}
case NonTerminal:
{
return createMatchMethodAndCallFor(expansion.symbol, outerLookahead, expansion.hints);
}
case Terminal:
{
return matchCall(expansion.symbol, LOOKAHEAD);
}
case Action:
{
return null;
}
default:
}
return null;
}
private Expr matchCondition(
String symbol, GExpansion expansion, NodeList<FormalParameter> params, NodeList<Expr> args) {
if (expansion.children != null && !expansion.children.isEmpty()) {
GExpansion firstChild = expansion.children.get(0);
if (firstChild.kind == GExpansion.Kind.LookAhead) {
Expr lookaheadCondition = null;
Expr semanticLookaheadCondition = firstChild.semanticLookahead;
int amount = firstChild.amount;
List<GExpansion> children = firstChild.children;
boolean negativeLookahead = firstChild.negativeLookahead;
if (semanticLookaheadCondition != null) {
if (semanticLookaheadCondition.equals(methodInvocationExpr(name("isLambda")))) {
semanticLookaheadCondition =
methodInvocationExpr(name("isLambda")).withArgs(listOf(literalExpr(0)));
} else if (semanticLookaheadCondition.equals(methodInvocationExpr(name("isCast")))) {
semanticLookaheadCondition =
methodInvocationExpr(name("isCast")).withArgs(listOf(literalExpr(0)));
}
lookaheadCondition =
negativeLookahead
? unaryExpr(UnaryOp.Not, semanticLookaheadCondition)
: semanticLookaheadCondition;
}
if (amount != -1) {
Expr amountLookaheadCondition =
buildLookaheadWithAmountCondition(symbol, expansion, amount, params, args);
lookaheadCondition =
lookaheadCondition == null
? amountLookaheadCondition
: binaryExpr(lookaheadCondition, BinaryOp.And, amountLookaheadCondition);
}
if (children != null) {
String matchMethodName = "match" + symbol + "_lookahead" + incrementCount(symbol);
Expr call =
createMatchMethodAndCallFor(
symbol,
matchMethodName,
GExpansion.sequence(children),
literalExpr(0),
params,
args,
false);
Expr descriptiveLookaheadCondition =
binaryExpr(
call, negativeLookahead ? BinaryOp.Equal : BinaryOp.NotEqual, literalExpr(-1));
lookaheadCondition =
lookaheadCondition == null
? descriptiveLookaheadCondition
: binaryExpr(
lookaheadCondition,
negativeLookahead ? BinaryOp.Or : BinaryOp.And,
descriptiveLookaheadCondition);
}
return lookaheadCondition;
}
}
return binaryExpr(
matchCall(firstTerminalsOf(expansion), literalExpr(0)),
BinaryOp.NotEqual,
FAILED_LOOKAHEAD);
}