private static boolean rule_assignment(DefaultMutableTreeNode parent) {
boolean error = false;
DefaultMutableTreeNode node;
String iden = tokens.get(currentToken).getWord();
node =
new DefaultMutableTreeNode("identifier" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
String s = tokens.get(currentToken).getWord();
if (SemanticAnalyzer.getSymbolTable().get(s) != null)
SemanticAnalyzer.pushStack(SemanticAnalyzer.getSymbolTable().get(s).firstElement().getType());
else {
SemanticAnalyzer.pushStack("ERROR");
SemanticAnalyzer.error(getgui(), 0, getlineno(), s);
}
currentToken++;
if (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("=")) {
node = new DefaultMutableTreeNode("=");
parent.add(node);
currentToken++;
} else {
error(5);
while (currentToken < tokens.size()
&& !(tokens.get(currentToken).getWord().equals("!")
|| tokens.get(currentToken).getWord().equals("-")
|| tokens.get(currentToken).getToken().equals("INTEGER")
|| tokens.get(currentToken).getToken().equals("OCTAL")
|| tokens.get(currentToken).getToken().equals("HEXADECIMAL")
|| tokens.get(currentToken).getToken().equals("BINARY")
|| tokens.get(currentToken).getToken().equals("STRING")
|| tokens.get(currentToken).getToken().equals("CHARACTER")
|| tokens.get(currentToken).getToken().equals("FLOAT")
|| tokens.get(currentToken).getToken().equals("IDENTIFIER")
|| tokens.get(currentToken).getWord().equals("true")
|| tokens.get(currentToken).getWord().equals("false")
|| tokens.get(currentToken).getWord().equals("(")
|| tokens.get(currentToken).getWord().equals(")")
|| tokens.get(currentToken).getWord().equals(";"))) {
currentToken++;
}
}
node = new DefaultMutableTreeNode("expression");
parent.add(node);
error = rule_expression(node);
String s1 = SemanticAnalyzer.popStack();
String s2 = SemanticAnalyzer.popStack();
String operator = "=";
String res = SemanticAnalyzer.calculateCube(s1, s2, operator);
CodeGenerator.addInstruction("STO", iden, "0");
if (res.equals("ERROR")) SemanticAnalyzer.error(getgui(), 2, getlineno(), "");
return error;
}
private static boolean rule_B(DefaultMutableTreeNode parent) {
boolean error;
DefaultMutableTreeNode node;
int flag = 0;
String operator = "";
if (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("-")) {
node = new DefaultMutableTreeNode("-");
parent.add(node);
currentToken++;
flag = 1;
operator = "-";
CodeGenerator.addInstruction("LIT", "0", "0");
}
node = new DefaultMutableTreeNode("C");
parent.add(node);
error = rule_C(node);
if (flag == 1) {
String s = SemanticAnalyzer.popStack();
SemanticAnalyzer.pushStack(SemanticAnalyzer.calculateCube(s, operator));
CodeGenerator.addInstruction("OPR", "3", "0");
System.out.println("here");
}
return error;
}
private static boolean rule_Y(DefaultMutableTreeNode parent) {
// System.out.println("Inside Y");
int flag = 0;
String operator = "";
boolean error = false;
DefaultMutableTreeNode node;
if (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("!")) {
node = new DefaultMutableTreeNode("!");
parent.add(node);
currentToken++;
flag = 1;
operator = "!";
}
node = new DefaultMutableTreeNode("R");
parent.add(node);
error = rule_R(node);
if (flag == 1) {
String s = SemanticAnalyzer.popStack();
SemanticAnalyzer.pushStack(SemanticAnalyzer.calculateCube(s, operator));
CodeGenerator.addInstruction("OPR", "10", "0");
System.out.println("Here in Y");
}
return error;
}
private static boolean rule_X(DefaultMutableTreeNode parent) {
int flag = 1;
String operator = "";
boolean error = false;
DefaultMutableTreeNode node;
node = new DefaultMutableTreeNode("Y");
parent.add(node);
error = rule_Y(node);
while (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("&")) {
node = new DefaultMutableTreeNode("&");
parent.add(node);
currentToken++;
node = new DefaultMutableTreeNode("Y");
parent.add(node);
error = rule_Y(node);
flag++;
operator = "&";
if (flag == 2) {
String type1 = SemanticAnalyzer.popStack();
String type2 = SemanticAnalyzer.popStack();
System.out.println("result: " + SemanticAnalyzer.calculateCube(type1, type2, operator));
SemanticAnalyzer.pushStack(SemanticAnalyzer.calculateCube(type1, type2, operator));
CodeGenerator.addInstruction("OPR", "9", "0");
flag = 1;
} else flag = 1;
}
return error;
}
// div and mult
private static void rule_a(DefaultMutableTreeNode parent) {
int counter = 0;
DefaultMutableTreeNode node = new DefaultMutableTreeNode("B");
parent.add(node);
rule_b(node);
counter++;
String op = "";
while (tokens.get(currentToken).getWord().equals("/")
|| tokens.get(currentToken).getWord().equals("*")) {
op = tokens.get(currentToken).getWord();
// get operator number
String getOpNum = "";
if (op.equals("/")) getOpNum = "5";
else if (op.equals("*")) getOpNum = "4";
node = new DefaultMutableTreeNode(tokens.get(currentToken).getWord());
parent.add(node);
node = new DefaultMutableTreeNode("B");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
rule_b(node);
counter++;
if (counter == 2) {
CodeGenerator.addInstruction("OPR", getOpNum, "0");
codeLine++;
String x = SemanticAnalyzer.popStack();
String y = SemanticAnalyzer.popStack();
String result = SemanticAnalyzer.calculateCube(x, y, op);
SemanticAnalyzer.pushStack(result);
counter--;
}
}
}
// and
private static void rule_x(DefaultMutableTreeNode parent) {
int counter = 0;
DefaultMutableTreeNode node = new DefaultMutableTreeNode("Y");
parent.add(node);
rule_y(node);
counter++;
while (tokens.get(currentToken).getWord().equals("&")) {
node = new DefaultMutableTreeNode("&");
parent.add(node);
node = new DefaultMutableTreeNode("Y");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
rule_y(node);
counter++;
// if visited twice
if (counter == 2) {
CodeGenerator.addInstruction("OPR", "9", "0");
codeLine++;
String x = SemanticAnalyzer.popStack();
String y = SemanticAnalyzer.popStack();
String result = SemanticAnalyzer.calculateCube(x, y, "&");
SemanticAnalyzer.pushStack(result);
counter--;
}
}
}
private static boolean rule_R(DefaultMutableTreeNode parent) {
int flag = 1;
String operator = "";
String operator_num = "";
boolean error = false;
DefaultMutableTreeNode node;
node = new DefaultMutableTreeNode("E");
parent.add(node);
error = rule_E(node);
while (currentToken < tokens.size()
&& (tokens.get(currentToken).getWord().equals("<")
|| tokens.get(currentToken).getWord().equals(">")
|| tokens.get(currentToken).getWord().equals("==")
|| tokens.get(currentToken).getWord().equals("!="))) {
if (tokens.get(currentToken).getWord().equals("<")) {
node = new DefaultMutableTreeNode("<");
parent.add(node);
operator = "<";
operator_num = "12";
}
if (tokens.get(currentToken).getWord().equals(">")) {
node = new DefaultMutableTreeNode(">");
parent.add(node);
operator = ">";
operator_num = "11";
}
if (tokens.get(currentToken).getWord().equals("==")) {
node = new DefaultMutableTreeNode("==");
parent.add(node);
operator = "==";
operator_num = "15";
}
if (tokens.get(currentToken).getWord().equals("!=")) {
node = new DefaultMutableTreeNode("!=");
parent.add(node);
operator = "!=";
operator_num = "16";
}
currentToken++;
node = new DefaultMutableTreeNode("E");
parent.add(node);
error = rule_E(node);
flag++;
if (flag == 2) {
String type1 = SemanticAnalyzer.popStack();
String type2 = SemanticAnalyzer.popStack();
System.out.println("result: " + SemanticAnalyzer.calculateCube(type1, type2, operator));
SemanticAnalyzer.pushStack(SemanticAnalyzer.calculateCube(type1, type2, operator));
CodeGenerator.addInstruction("OPR", operator_num, "0");
flag = 1;
} else flag = 1;
}
return error;
}
private static boolean rule_E(DefaultMutableTreeNode parent) {
boolean error;
DefaultMutableTreeNode node;
node = new DefaultMutableTreeNode("A");
parent.add(node);
error = rule_A(node);
int flag = 1;
String operator = new String();
String operator_num = "";
while (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("+")
|| currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("-")) {
if (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("+")) {
operator = tokens.get(currentToken).getWord();
node = new DefaultMutableTreeNode("+");
parent.add(node);
currentToken++;
node = new DefaultMutableTreeNode("A");
parent.add(node);
error = rule_A(node);
operator = "+";
operator_num = "2";
flag++;
} else if (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("-")) {
operator = tokens.get(currentToken).getWord();
node = new DefaultMutableTreeNode("-");
parent.add(node);
currentToken++;
node = new DefaultMutableTreeNode("A");
parent.add(node);
error = rule_A(node);
operator = "-";
operator_num = "3";
flag++;
}
if (flag == 2) {
String type1 = SemanticAnalyzer.popStack();
String type2 = SemanticAnalyzer.popStack();
System.out.println("result: " + SemanticAnalyzer.calculateCube(type1, type2, operator));
SemanticAnalyzer.pushStack(SemanticAnalyzer.calculateCube(type1, type2, operator));
CodeGenerator.addInstruction("OPR", operator_num, "0");
flag = 1;
} else flag = 1;
}
return error;
}
// not
private static void rule_y(DefaultMutableTreeNode parent) {
DefaultMutableTreeNode node = new DefaultMutableTreeNode("R");
boolean b = false;
if (tokens.get(currentToken).getWord().equals("!")) {
node = new DefaultMutableTreeNode("!");
parent.add(node);
b = true;
if (currentToken < tokens.size() - 1) currentToken++;
}
node = new DefaultMutableTreeNode("R");
parent.add(node);
rule_r(node);
if (b) {
CodeGenerator.addInstruction("OPR", "10", "0");
codeLine++;
String x = SemanticAnalyzer.popStack();
String result = SemanticAnalyzer.calculateCube(x, "!");
SemanticAnalyzer.pushStack(result);
}
}
/** Add token to stack */
public static void addTokenToStack() {
SemanticAnalyzer.pushStack(tokens.get(currentToken).getToken());
}
private static boolean rule_C(DefaultMutableTreeNode parent) {
boolean error = false;
DefaultMutableTreeNode node;
if (currentToken < tokens.size() && tokens.get(currentToken).getToken().equals("INTEGER")) {
node = new DefaultMutableTreeNode("integer" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("int");
CodeGenerator.addInstruction("LIT", tokens.get(currentToken).getWord(), "0");
currentToken++;
} else if (currentToken < tokens.size()
&& tokens.get(currentToken).getToken().equals("OCTAL")) {
node = new DefaultMutableTreeNode("octal" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("int");
CodeGenerator.addInstruction("LIT", tokens.get(currentToken).getWord(), "0");
currentToken++;
} else if (currentToken < tokens.size()
&& tokens.get(currentToken).getToken().equals("HEXADECIMAL")) {
node =
new DefaultMutableTreeNode(
"hexadecimal" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("int");
CodeGenerator.addInstruction("LIT", tokens.get(currentToken).getWord(), "0");
currentToken++;
} else if (currentToken < tokens.size()
&& tokens.get(currentToken).getToken().equals("BINARY")) {
node = new DefaultMutableTreeNode("binary" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("int");
CodeGenerator.addInstruction("LIT", tokens.get(currentToken).getWord(), "0");
currentToken++;
} else if (currentToken < tokens.size()
&& tokens.get(currentToken).getToken().equals("STRING")) {
node = new DefaultMutableTreeNode("string" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("string");
CodeGenerator.addInstruction("LIT", tokens.get(currentToken).getWord(), "0");
currentToken++;
} else if (currentToken < tokens.size()
&& tokens.get(currentToken).getToken().equals("CHARACTER")) {
node =
new DefaultMutableTreeNode("character" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("char");
CodeGenerator.addInstruction("LIT", tokens.get(currentToken).getWord(), "0");
currentToken++;
} else if (currentToken < tokens.size()
&& tokens.get(currentToken).getToken().equals("FLOAT")) {
node = new DefaultMutableTreeNode("float" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("float");
CodeGenerator.addInstruction("LIT", tokens.get(currentToken).getWord(), "0");
currentToken++;
} else if (currentToken < tokens.size()
&& tokens.get(currentToken).getWord().equalsIgnoreCase("true")) {
node = new DefaultMutableTreeNode("boolean" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("boolean");
CodeGenerator.addInstruction("LIT", tokens.get(currentToken).getWord(), "0");
currentToken++;
} else if (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("false")) {
node = new DefaultMutableTreeNode("boolean" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("boolean");
CodeGenerator.addInstruction("LIT", tokens.get(currentToken).getWord(), "0");
currentToken++;
} else if (currentToken < tokens.size()
&& tokens.get(currentToken).getToken().equals("IDENTIFIER")) {
node =
new DefaultMutableTreeNode("identifier" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
if (SemanticAnalyzer.getSymbolTable().get(tokens.get(currentToken).getWord()) != null)
SemanticAnalyzer.pushStack(
SemanticAnalyzer.getSymbolTable()
.get(tokens.get(currentToken).getWord())
.firstElement()
.getType());
else {
SemanticAnalyzer.error(getgui(), 0, getlineno(), tokens.get(currentToken).getWord());
SemanticAnalyzer.pushStack("ERROR");
}
CodeGenerator.addInstruction("LOD", tokens.get(currentToken).getWord(), "0");
currentToken++;
} else if (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("(")) {
node = new DefaultMutableTreeNode("(");
parent.add(node);
currentToken++;
//
node = new DefaultMutableTreeNode("expression");
parent.add(node);
error = rule_expression(node);
//
if (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals(")")) {
node = new DefaultMutableTreeNode(")");
parent.add(node);
currentToken++;
} else error(7);
} else {
error(9);
}
return false;
}
private static void rule_c(DefaultMutableTreeNode parent) {
String id = tokens.get(currentToken).getWord();
String type = SemanticAnalyzer.doesExist(id);
int n = tokens.get(currentToken).getLine();
DefaultMutableTreeNode node = null;
if (tokens.get(currentToken).getToken().equals("INTEGER")) {
node = new DefaultMutableTreeNode("integer(" + id + ")");
parent.add(node);
SemanticAnalyzer.pushStack(tokens.get(currentToken).getToken());
CodeGenerator.addInstruction("LIT", id, "0");
codeLine++;
if (currentToken < tokens.size() - 1) currentToken++;
} else if (tokens.get(currentToken).getToken().equals("OCTAL")) {
node = new DefaultMutableTreeNode("octal(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("INTEGER");
CodeGenerator.addInstruction("LIT", id, "0");
codeLine++;
if (currentToken < tokens.size() - 1) currentToken++;
} else if (tokens.get(currentToken).getToken().equals("HEXADECIMAL")) {
node = new DefaultMutableTreeNode("hexadecimal(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("INTEGER");
CodeGenerator.addInstruction("LIT", id, "0");
codeLine++;
if (currentToken < tokens.size() - 1) currentToken++;
} else if (tokens.get(currentToken).getToken().equals("BINARY")) {
node = new DefaultMutableTreeNode("binary(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("INTEGER");
CodeGenerator.addInstruction("LIT", id, "0");
codeLine++;
if (currentToken < tokens.size() - 1) currentToken++;
} else if (tokens.get(currentToken).getWord().equals("true")) {
node = new DefaultMutableTreeNode("true");
parent.add(node);
SemanticAnalyzer.pushStack("BOOLEAN");
CodeGenerator.addInstruction("LIT", "true", "0");
codeLine++;
if (currentToken < tokens.size() - 1) currentToken++;
} else if (tokens.get(currentToken).getWord().equals("false")) {
node = new DefaultMutableTreeNode("false");
parent.add(node);
SemanticAnalyzer.pushStack("BOOLEAN");
CodeGenerator.addInstruction("LIT", "false", "0");
codeLine++;
if (currentToken < tokens.size() - 1) currentToken++;
} else if (tokens.get(currentToken).getToken().equals("STRING")) {
node = new DefaultMutableTreeNode("string(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("STRING");
CodeGenerator.addInstruction("LIT", id, "0");
codeLine++;
if (currentToken < tokens.size() - 1) currentToken++;
} else if (tokens.get(currentToken).getToken().equals("CHARACTER")) {
node = new DefaultMutableTreeNode("char(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("CHARACTER");
CodeGenerator.addInstruction("LIT", id, "0");
codeLine++;
if (currentToken < tokens.size() - 1) currentToken++;
} else if (tokens.get(currentToken).getToken().equals("FLOAT")) {
node = new DefaultMutableTreeNode("float(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
SemanticAnalyzer.pushStack("FLOAT");
CodeGenerator.addInstruction("LIT", id, "0");
codeLine++;
if (currentToken < tokens.size() - 1) currentToken++;
} else if (tokens.get(currentToken).getToken().equals("IDENTIFIER")) {
node = new DefaultMutableTreeNode("identifier(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
CodeGenerator.addInstruction("LOD", id, "0");
codeLine++;
if (type.equals("void")) SemanticAnalyzer.pushStack("VOID");
else if (type.equals("float")) SemanticAnalyzer.pushStack("FLOAT");
else if (type.equals("boolean")) SemanticAnalyzer.pushStack("BOOLEAN");
else if (type.equals("int")) SemanticAnalyzer.pushStack("INTEGER");
else if (type.equals("char")) SemanticAnalyzer.pushStack("CHARACTER");
else if (type.equals("string")) SemanticAnalyzer.pushStack("STRING");
else {
SemanticAnalyzer.pushStack("other");
SemanticAnalyzer.error(gui, 0, n, id);
}
if (currentToken < tokens.size() - 1) currentToken++;
} else if (tokens.get(currentToken).getWord().equals("(")) {
node = new DefaultMutableTreeNode("(");
parent.add(node);
node = new DefaultMutableTreeNode("expression");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
rule_expression(node);
if (tokens.get(currentToken).getWord().equals(")")) {
node = new DefaultMutableTreeNode(")");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
}
}
}
// body
private static void rule_body(DefaultMutableTreeNode parent) {
DefaultMutableTreeNode node = null;
while (!tokens.get(currentToken).getWord().equals("}")
&& !(currentToken >= tokens.size() - 1)) {
String name = tokens.get(currentToken).getWord();
// call print
if (tokens.get(currentToken).getWord().equals("print")) {
node = new DefaultMutableTreeNode("print");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
rule_print(node);
if (tokens.get(currentToken).getWord().equals(";")) {
node = new DefaultMutableTreeNode(";");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
}
}
// call assignment
else if (tokens.get(currentToken).getToken().equals("IDENTIFIER")) {
String id = tokens.get(currentToken).getWord();
int line = tokens.get(currentToken).getLine();
String type = SemanticAnalyzer.doesExist(id);
if (type.equals("int")) type = "INTEGER";
else if (type.equals("float")) type = "FLOAT";
else if (type.equals("string")) type = "STRING";
else if (type.equals("char")) type = "CHARACTER";
else if (type.equals("octal")) type = "OCTAL";
else if (type.equals("binary")) type = "BINARY";
else if (type.equals("hexadecimal")) type = "HEXADECIMAL";
else if (type.equals("void")) type = "VOID";
else if (type.equals("boolean")) type = "BOOLEAN";
else {
SemanticAnalyzer.error(gui, 0, line, id);
// SemanticAnalyzer.error(gui, 2, line, "");
}
SemanticAnalyzer.pushStack(type);
node = new DefaultMutableTreeNode("assignment");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
rule_assignment(node);
if (tokens.get(currentToken).getWord().equals(";")) {
node = new DefaultMutableTreeNode(";");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
}
if (tokens.get(currentToken).getWord().equals(")")) currentToken++;
}
// call variable
else if (tokens.get(currentToken).getWord().equals("int")
| tokens.get(currentToken).getWord().equals("float")
| tokens.get(currentToken).getWord().equals("boolean")
| tokens.get(currentToken).getWord().equals("char")
| tokens.get(currentToken).getWord().equals("string")
| tokens.get(currentToken).getWord().equals("void")) {
node = new DefaultMutableTreeNode("variable");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
rule_variable(node);
if (tokens.get(currentToken).getWord().equals(";")) {
node = new DefaultMutableTreeNode(";");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
}
}
// call while
else if (tokens.get(currentToken).getWord().equals("while")) {
node = new DefaultMutableTreeNode("while");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
rule_while(node);
}
// call if
else if (tokens.get(currentToken).getWord().equals("if")) {
node = new DefaultMutableTreeNode("if");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
rule_if(node);
}
// call switch
else if (tokens.get(currentToken).getWord().equals("switch")) {
node = new DefaultMutableTreeNode("switch");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
rule_switch(node);
}
// call return
else if (tokens.get(currentToken).getWord().equals("return")) {
node = new DefaultMutableTreeNode("return");
parent.add(node);
DefaultMutableTreeNode node1 = new DefaultMutableTreeNode("return");
node.add(node1);
if (currentToken < tokens.size() - 1) currentToken++;
if (tokens.get(currentToken).getWord().equals(";")) {
node = new DefaultMutableTreeNode(";");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
}
CodeGenerator.addInstruction("OPR", "1", "0");
codeLine++;
}
}
}
