/**
* Parse according to the grammar statement. statement: ID '=' expression ;
*
* <p>match(ID); match('='); expr()
*/
public void parserRuleAssignmentStatement(final AbstractSyntaxTree ast) {
final LangType p1 = this.parserLookAhead(1);
final LangType p2 = this.parserLookAhead(2);
boolean checkRuleSymbol = p1 != null && p1.eqlt(new LangTypeTokenSymbol("<none>"));
boolean checkRuleAssignment = p2 != null && p2.eql(new LangTypeToken("="));
if (checkRuleSymbol && checkRuleAssignment) {
this.parserMatchType(new LangTypeTokenSymbol("<none>"));
this.parserMatch(new LangTypeToken("="));
AbstractSyntaxTree continueWithAssignTree = null;
final AbstractSyntaxTree assignTree = new AssignmentNode(p2);
assignTree.addChildToAbstractSyntaxTree(new SymbolNode(p1));
ast.addChildToAbstractSyntaxTree(assignTree);
continueWithAssignTree = assignTree;
// Continue with rule for numbers
this.parserRuleNumberExpression(continueWithAssignTree);
} else if (checkRuleSymbol) {
this.parserMatchType(new LangTypeTokenSymbol("<none>"));
} else {
System.out.println(
"Parser rule fail - "
+ checkRuleSymbol
+ " // "
+ checkRuleAssignment
+ " $ "
+ p1
+ "/"
+ p2);
} // End of if - check for assignment rule
}
/** Visitor dispatch based on node token type */
@Override
public Object visit(final ProgramRootNode nodeOnVisit) {
compiler.writeClassFile(nodeOnVisit);
if (nodeOnVisit.children() == null || nodeOnVisit.children().size() == 0) {
return new Object();
}
for (final AbstractSyntaxTree node : nodeOnVisit.children()) {
if (node instanceof AssignmentNode) {
node.visit(this);
} // End of if sub nodes //
} // End of the for //
return new Object();
} // End of program dispatch //
/** Parse according to the grammar statement. expressionRest: +/- NUMBER {expressionRest} */
public void parserRuleNumberExpressionRest(
final AbstractSyntaxTree ast, final LangType numberValLhs) {
final LangType p1 = this.parserLookAhead(1);
final boolean checkRulePlus = p1 != null && p1.eql(new LangTypeToken("+"));
if (checkRulePlus) {
final LangType plus = new LangTypeToken("+");
final AbstractSyntaxTree newNodePlus = new PlusNode(plus);
final AbstractSyntaxTree valnode = new NumberNode(numberValLhs);
newNodePlus.addChildToAbstractSyntaxTree(valnode);
this.parserMatch(plus);
final LangType numberValRhs = this.parserLookAhead(1);
this.parserMatchType(new LangTypeTokenDouble(-1));
this.parserRuleNumberExpressionRest(newNodePlus, numberValRhs);
ast.addChildToAbstractSyntaxTree(newNodePlus);
} else {
final AbstractSyntaxTree valnode = new NumberNode(numberValLhs);
ast.addChildToAbstractSyntaxTree(valnode);
} // End of the if - check rule for plus
}
public static ArrayList<String> withdrawVariablesInRule(
AbstractSyntaxTree<DataTypeEnum, IValue> booleanRule) {
ArrayList<String> ret = new ArrayList<String>();
AbstractSyntaxTreeNode<DataTypeEnum, IValue> root = null;
if (booleanRule != null && booleanRule.getRootNode() != null) root = booleanRule.getRootNode();
else return ret;
Queue<AbstractSyntaxTreeNode<DataTypeEnum, IValue>> nodeQueue =
new LinkedList<AbstractSyntaxTreeNode<DataTypeEnum, IValue>>();
nodeQueue.offer(root);
while (!nodeQueue.isEmpty()) {
AbstractSyntaxTreeNode<DataTypeEnum, IValue> currentNode = nodeQueue.poll();
for (int i = 0; i < currentNode.getNumberOfChildren(); i++)
nodeQueue.offer(currentNode.getChildAt(i));
if (currentNode.isLeaf()) ret.add(currentNode.toString());
}
return ret;
}