/**
* Rule: X
*
* @param DefaultMutableTreeNode parent
* @return String
*/
public static String rule_x(DefaultMutableTreeNode parent) {
Boolean operatorFlag = false;
String type, type2 = "";
DefaultMutableTreeNode node;
node = new DefaultMutableTreeNode("Y");
parent.add(node);
addTokenToStack();
type = rule_y(node);
while (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("&")) {
node = new DefaultMutableTreeNode("&");
parent.add(node);
addTokenToStack();
currentToken++;
node = new DefaultMutableTreeNode("Y");
parent.add(node);
addTokenToStack();
type2 = rule_y(node);
operatorFlag = true;
}
if (operatorFlag) {
SemanticAnalyzer.calculateCube(type, "&");
SemanticAnalyzer.calculateCube(type2, "&");
}
return type;
}
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;
}
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;
}
/**
* Rule: B
*
* @param DefaultMutableTreeNode parent
* @return String
*/
private static String rule_b(DefaultMutableTreeNode parent) {
Boolean operatorFlag = false;
String type;
DefaultMutableTreeNode node;
if (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("-")) {
node = new DefaultMutableTreeNode("-");
parent.add(node);
addTokenToStack();
currentToken++;
operatorFlag = true;
}
node = new DefaultMutableTreeNode("C");
parent.add(node);
addTokenToStack();
type = rule_c(node);
if (operatorFlag) {
SemanticAnalyzer.calculateCube(type, "-");
}
return type;
}
/**
* Rule: A
*
* @param DefaultMutableTreeNode parent
* @return String
*/
private static String rule_a(DefaultMutableTreeNode parent) {
Boolean operatorFlag = false;
String type, type2 = "", typeOp = "";
DefaultMutableTreeNode node;
node = new DefaultMutableTreeNode("B");
parent.add(node);
addTokenToStack();
type = rule_b(node);
currentWord = tokens.get(currentToken).getWord();
while (currentToken < tokens.size() && (currentWord.equals("*") || currentWord.equals("/"))) {
node = new DefaultMutableTreeNode(currentWord);
parent.add(node);
addTokenToStack();
typeOp = currentWord;
currentToken++;
node = new DefaultMutableTreeNode("B");
parent.add(node);
addTokenToStack();
type2 = rule_b(node);
currentWord = tokens.get(currentToken).getWord();
operatorFlag = true;
}
if (operatorFlag) {
SemanticAnalyzer.calculateCube(type, type2, typeOp);
}
return type;
}
/**
* Rule: Assignment
*
* @param DefaultMutableTreeNode parent
* @return boolean
*/
public static void rule_assignment(DefaultMutableTreeNode parent) {
DefaultMutableTreeNode node;
String type1, type2;
// identifier
type1 = tokens.get(currentToken).getWord();
node = new DefaultMutableTreeNode("identifier" + "(" + type1 + ")");
parent.add(node);
addTokenToStack();
currentToken++;
// '='
if (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("=")) {
node = new DefaultMutableTreeNode("=");
parent.add(node);
addTokenToStack();
currentToken++;
} else {
error(5); // expected =
return;
}
// <expression>
node = new DefaultMutableTreeNode("expression");
parent.add(node);
addTokenToStack();
type2 = rule_expression(node);
// check for type equivalence
SemanticAnalyzer.calculateCube(type1, type2, "=");
}
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;
}
// 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_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;
}
// 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);
}
}
/**
* Rule: R
*
* @param DefaultMutableTreeNode parent
* @return String
*/
public static String rule_r(DefaultMutableTreeNode parent) {
Boolean operatorFlag = false;
String type, type2 = "", typeOp = "";
DefaultMutableTreeNode node;
node = new DefaultMutableTreeNode("E");
parent.add(node);
addTokenToStack();
type = rule_e(node);
currentWord = tokens.get(currentToken).getWord();
while (currentToken < tokens.size()
&& (currentWord.equals("<")
|| currentWord.equals(">")
|| currentWord.equals("==")
|| currentWord.equals("!="))) {
node =
new DefaultMutableTreeNode(
currentWord); // we've already checked that currentWord is valid
parent.add(node);
addTokenToStack();
typeOp = currentWord;
currentToken++;
node = new DefaultMutableTreeNode("E");
parent.add(node);
addTokenToStack();
type2 = rule_e(node);
currentWord = tokens.get(currentToken).getWord();
operatorFlag = true;
}
if (operatorFlag) {
SemanticAnalyzer.calculateCube(type, type2, typeOp);
}
return type;
}
// assignment
private static void rule_assignment(DefaultMutableTreeNode parent) {
String id = tokens.get(currentToken - 1).getWord();
DefaultMutableTreeNode node = new DefaultMutableTreeNode("identifier(" + id + ")");
parent.add(node);
if (tokens.get(currentToken).getWord().equals("=")) {
node = new DefaultMutableTreeNode("=");
parent.add(node);
}
node = new DefaultMutableTreeNode("expression");
parent.add(node);
int line = tokens.get(currentToken).getLine();
if (currentToken < tokens.size() - 1 && !tokens.get(currentToken).getWord().equals(")"))
currentToken++;
rule_expression(node);
CodeGenerator.addInstruction("STO", id, "0");
codeLine++;
String x = SemanticAnalyzer.popStack();
String y = SemanticAnalyzer.popStack();
String result = SemanticAnalyzer.calculateCube(x, y, "=");
if (!result.equals("ok")) SemanticAnalyzer.error(gui, 2, line, "");
}
