@Test
public void test() throws Exception {
WordTree root = new WordTree(new String[] {});
String noun = "noun:Đất nước\n" + "noun:tôi\n" + "noun:thon thả\n" + "noun:giọt đàn bầu";
for (String n : noun.split("\n")) {
SemanticWord w = new SemanticWord();
w.tranform(n);
root.addEntity(w);
}
String s = "Đất nước<i> tôi thon thả</i> giọt đàn bầu";
TokenParser parser = new TokenParser();
List<Token> tokens = parser.parse(s);
Assert.assertEquals(17, tokens.size());
SemanticAnalyzer analyzer = new SemanticAnalyzer(tokens, root);
tokens = analyzer.analyze();
Assert.assertEquals(9, tokens.size());
Assert.assertEquals("Đất nước", tokens.get(0).getOriginal());
Assert.assertEquals("<i>", tokens.get(1).getOriginal());
Assert.assertEquals(" ", tokens.get(2).getOriginal());
Assert.assertEquals("tôi", tokens.get(3).getOriginal());
Assert.assertEquals(" ", tokens.get(4).getOriginal());
Assert.assertEquals("thon thả", tokens.get(5).getOriginal());
Assert.assertEquals("</i>", tokens.get(6).getOriginal());
Assert.assertEquals(" ", tokens.get(7).getOriginal());
Assert.assertEquals("giọt đàn bầu", tokens.get(8).getOriginal());
}
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--;
}
}
}
// while
private static void rule_while(DefaultMutableTreeNode parent) {
DefaultMutableTreeNode node = new DefaultMutableTreeNode("while");
parent.add(node);
String start = "whileS" + labelNum;
final int num = labelNum;
String end = "whileE" + labelNum;
labelNum++;
CodeGenerator.addLabel(start, codeLine);
if (tokens.get(currentToken).getWord().equals("(")) {
node = new DefaultMutableTreeNode("(");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
}
node = new DefaultMutableTreeNode("expression");
parent.add(node);
rule_expression(node);
CodeGenerator.addInstruction("JMC", "#" + end, "false");
codeLine++;
int n = tokens.get(currentToken).getLine();
String x = SemanticAnalyzer.popStack();
if (!x.equals("BOOLEAN")) SemanticAnalyzer.error(gui, 3, n, "");
if (tokens.get(currentToken).getWord().equals(")")) {
node = new DefaultMutableTreeNode(")");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
}
node = new DefaultMutableTreeNode("program");
parent.add(node);
rule_program(node);
CodeGenerator.addInstruction("JMP", "#" + start, "0");
codeLine++;
CodeGenerator.addLabel("whileE" + num, codeLine);
}
// 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_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;
}
public static void main(String[] args) throws InterruptedException {
ArrayList<File> fileList = Utils.listFiles(IN_DIR);
for (File file : fileList) {
System.out.println("Scanning file " + file.getPath());
LexIO io = new LexIO(file);
LexIO noTrash = Lexer.removeTrash(io);
LexIO noComments = Lexer.removeComments(noTrash);
LexIO noMalformed = Lexer.removeMalformed(noComments);
LexIO tokens = Lexer.getValidTokens(noMalformed);
// tokens.writeOutput(OUT_DIR + "/" + file.getName());
// for(Token token: tokens.getTokens()) {
// System.out.println( token.getRepresentation() + " " + token.getType() + " " +
// token.getLine());
// }
//
// Thread.sleep(100); // used for debug
// for(TokenError error : tokens.getErrors()) {
// System.err.println( error.getRepresentation() + " " + error.getType() + " " + " " +
// error.getLine());
// }
SemanticAnalyzer analyzer = new SemanticAnalyzer(tokens);
analyzer.parseProgram();
analyzer.writeErrorOutput(OUT_DIR + "/" + file.getName());
}
}
private void analyzeSelectStatement() throws SemanticAnalyzerException {
SemanticAnalyzer selectAnalzyer =
SemanticAnalyzerFactory.createAnalyzer(multiInsert.getSelects(), getAllSchemas());
SelectWithOutFromAnalyzer sAnalyzer = (SelectWithOutFromAnalyzer) selectAnalzyer;
sAnalyzer.setFromAnalyzeContext(getFromAnalyzeContext());
context.setSelectContext((SelectWithOutFromAnalyzeContext) selectAnalzyer.analyze());
}
/**
* 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_while(DefaultMutableTreeNode parent) {
boolean error = false;
DefaultMutableTreeNode node;
node = new DefaultMutableTreeNode("while");
parent.add(node);
currentToken++;
if (currentToken < tokens.size() && tokens.get(currentToken).getWord().equals("(")) {
node = new DefaultMutableTreeNode("(");
parent.add(node);
currentToken++;
} else {
error(8);
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(")"))) {
currentToken++;
}
}
node = new DefaultMutableTreeNode("expression");
parent.add(node);
error = rule_expression(node);
String type = SemanticAnalyzer.popStack();
if (!type.equals("boolean")) SemanticAnalyzer.error(getgui(), 3, getlineno(), "");
if (tokens.get(currentToken).getWord().equals(")")) {
node = new DefaultMutableTreeNode(")");
parent.add(node);
currentToken++;
} else {
error(7);
while (currentToken < tokens.size() && !tokens.get(currentToken).getWord().equals("{")) {
currentToken++;
}
}
CodeGenerator.addInstruction("JMC", "e" + label_count, "false");
label_count++;
node = new DefaultMutableTreeNode("program");
parent.add(node);
error = rule_program(node);
CodeGenerator.addInstruction("JMP", "e" + label_count, "0");
label_count++;
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;
}
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 void analyzeSelectStatement() throws SemanticAnalyzerException {
SemanticAnalyzer selectAnalzyer =
SemanticAnalyzerFactory.createAnalyzer(insertContext.getSelect(), getAllSchemas());
if (selectAnalzyer instanceof SelectStatementAnalyzer) {
((SelectStatementAnalyzer) selectAnalzyer).setOutputStreamName(context.getOutputStreamName());
}
context.setSelectContext((SelectAnalyzeContext) selectAnalzyer.analyze());
}
// switch
private static void rule_switch(DefaultMutableTreeNode parent) {
DefaultMutableTreeNode node = null;
DefaultMutableTreeNode parentS = parent;
node = new DefaultMutableTreeNode("switch");
parent.add(node);
String id = "";
if (tokens.get(currentToken).getWord().equals("(")) {
node = new DefaultMutableTreeNode("(");
parent.add(node);
currentToken++;
}
if (tokens.get(currentToken).getToken().equals("IDENTIFIER")) {
node = new DefaultMutableTreeNode("identifier(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
int line = tokens.get(currentToken).getLine();
id = tokens.get(currentToken).getWord();
String type = SemanticAnalyzer.doesExist(id);
String value = SemanticAnalyzer.getValue(id);
if (type.equals("error")) SemanticAnalyzer.error(gui, 0, line, id);
currentToken++;
}
if (tokens.get(currentToken).getWord().equals(")")) {
node = new DefaultMutableTreeNode(")");
parent.add(node);
currentToken++;
}
if (tokens.get(currentToken).getWord().equals("{")) {
node = new DefaultMutableTreeNode("{");
parent.add(node);
currentToken++;
}
if (tokens.get(currentToken).getWord().equals("case")) {
node = new DefaultMutableTreeNode("case");
parentS.add(node);
currentToken++;
}
rule_cases(parentS, node, id);
if (tokens.get(currentToken).getWord().equals("default")) {
node = new DefaultMutableTreeNode("default");
parent.add(node);
currentToken++;
CodeGenerator.addInstruction("JMP", "#labelD", "0");
codeLine++;
rule_default(node);
}
if (tokens.get(currentToken).getWord().equals("}")) {
node = new DefaultMutableTreeNode("}");
parent.add(node);
currentToken++;
}
// codeLine++;
// codeLine++;
CodeGenerator.addLabel("labelES", codeLine);
}
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_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;
}
/**
* Run
*
* @param Vector<Token> t, Gui gui
* @return DefaultMutableTreeNode
*/
public static DefaultMutableTreeNode run(Vector<A2.Token> t, Gui gui) {
Parser.gui = gui;
tokens = t;
currentToken = 0;
SemanticAnalyzer.reset(); // reset the data structures
root = new DefaultMutableTreeNode("program");
rule_program(root);
gui.writeSymbolTable(SemanticAnalyzer.getSymbolTable());
return root;
}
private static boolean rule_variable(DefaultMutableTreeNode parent) {
boolean error = false;
DefaultMutableTreeNode node;
String type = tokens.get(currentToken).getWord();
String iden = "";
node = new DefaultMutableTreeNode(tokens.get(currentToken).getWord());
parent.add(node);
currentToken++;
if (currentToken < tokens.size()
&& tokens.get(currentToken).getToken().equalsIgnoreCase("identifier")) {
SemanticAnalyzer.checkVariable(
tokens.get(currentToken - 1).getWord(), tokens.get(currentToken).getWord());
node =
new DefaultMutableTreeNode("identifier" + "(" + tokens.get(currentToken).getWord() + ")");
iden = tokens.get(currentToken).getWord();
CodeGenerator.addVariable(type, iden);
parent.add(node);
currentToken++;
} else {
error(6);
}
return error;
}
/**
* 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, "=");
}
/**
* 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;
}
// 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);
}
}
// 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, "");
}
public static DefaultMutableTreeNode run(Vector<Token> t, Gui gui) {
Parser.gui = gui;
tokens = t;
currentToken = 0;
root = new DefaultMutableTreeNode("program");
//
rule_program(root);
CodeGenerator.addInstruction("OPR", "0", "0");
//
gui.writeSymbolTable(SemanticAnalyzer.getSymbolTable());
CodeGenerator.writeCode(gui);
SemanticAnalyzer.getSymbolTable().clear();
SemanticAnalyzer.getStack().clear();
CodeGenerator.clear(gui);
return root;
}
// if
private static void rule_if(DefaultMutableTreeNode parent) {
DefaultMutableTreeNode node = new DefaultMutableTreeNode("if");
parent.add(node);
String end = "ifE" + ifNum;
int num = ifNum;
ifNum++;
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);
CodeGenerator.addInstruction("JMC", "#ifE" + ifNum, "false");
codeLine++;
int n = tokens.get(currentToken).getLine();
String x = SemanticAnalyzer.popStack();
if (!x.equals("BOOLEAN")) SemanticAnalyzer.error(gui, 3, n, "");
if (tokens.get(currentToken).getWord().equals(")")) {
node = new DefaultMutableTreeNode(")");
parent.add(node);
node = new DefaultMutableTreeNode("program");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
rule_program(node);
CodeGenerator.addInstruction("JMP", "#ifE" + num, "0");
codeLine++;
CodeGenerator.addLabel("ifE" + ifNum, codeLine);
if (tokens.get(currentToken).getWord().equals("else")) {
node = new DefaultMutableTreeNode("else");
parent.add(node);
node = new DefaultMutableTreeNode("program");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
rule_program(node);
}
CodeGenerator.addLabel("ifE" + num, codeLine);
}
}
}
@Test
public void testSetLimit() {
SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer(builder);
semanticAnalyzer.setLimit(0);
assertEquals(
"Unexpected Category.",
SemanticCategoryEnum.COUNTRY.getId(),
getSuggestedCategorys(semanticAnalyzer));
semanticAnalyzer.setLimit(1);
assertEquals(
"Unexpected Category.",
SemanticCategoryEnum.ANIMAL.getId(),
getSuggestedCategorys(semanticAnalyzer));
semanticAnalyzer.setLimit(3);
assertEquals(
"Unexpected Category.",
SemanticCategoryEnum.COUNTRY.getId(),
getSuggestedCategorys(semanticAnalyzer));
}
// variable
private static void rule_variable(DefaultMutableTreeNode parent) {
String type = tokens.get(currentToken - 1).getWord();
String id = tokens.get(currentToken).getWord();
DefaultMutableTreeNode node = new DefaultMutableTreeNode(type);
parent.add(node);
if (tokens.get(currentToken).getToken().equals("IDENTIFIER")) {
SemanticAnalyzer.checkVariable(
tokens.get(currentToken - 1).getWord(),
tokens.get(currentToken).getWord(),
tokens.get(currentToken).getLine(),
gui);
node = new DefaultMutableTreeNode("identifier(" + id + ")");
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
CodeGenerator.addVariable(type, id);
}
}
// TODO: 1) How to handle collisions? 2) Should we be cloning ColumnInfo or not?
private static boolean add(
RowResolver rrToAddTo, RowResolver rrToAddFrom, IntRef outputColPosRef, int numColumns)
throws SemanticException {
boolean hasDuplicates = false;
String tabAlias;
String colAlias;
String[] qualifiedColName;
int i = 0;
int outputColPos = outputColPosRef == null ? 0 : outputColPosRef.val;
for (ColumnInfo cInfoFrmInput : rrToAddFrom.getRowSchema().getSignature()) {
if (numColumns >= 0 && i == numColumns) {
break;
}
ColumnInfo newCI = null;
String internalName = cInfoFrmInput.getInternalName();
qualifiedColName = rrToAddFrom.reverseLookup(internalName);
tabAlias = qualifiedColName[0];
colAlias = qualifiedColName[1];
newCI = new ColumnInfo(cInfoFrmInput);
newCI.setInternalName(SemanticAnalyzer.getColumnInternalName(outputColPos));
outputColPos++;
boolean isUnique = rrToAddTo.putWithCheck(tabAlias, colAlias, internalName, newCI);
hasDuplicates |= (!isUnique);
qualifiedColName = rrToAddFrom.getAlternateMappings(internalName);
if (qualifiedColName != null) {
tabAlias = qualifiedColName[0];
colAlias = qualifiedColName[1];
rrToAddTo.put(tabAlias, colAlias, newCI);
}
i++;
}
if (outputColPosRef != null) {
outputColPosRef.val = outputColPos;
}
return !hasDuplicates;
}
/**
* 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;
}
/**
* Rule: Variable
*
* @param DefaultMutableTreeNode parent
* @return boolean
*/
public static void rule_variable(DefaultMutableTreeNode parent) {
DefaultMutableTreeNode node;
// type
node = new DefaultMutableTreeNode(tokens.get(currentToken).getWord());
parent.add(node);
currentToken++;
// identifier
if (tokens.get(currentToken).getToken().equals("IDENTIFIER")) {
SemanticAnalyzer.checkVariable(
tokens.get(currentToken - 1).getWord(), tokens.get(currentToken).getWord());
node =
new DefaultMutableTreeNode("identifier" + "(" + tokens.get(currentToken).getWord() + ")");
parent.add(node);
currentToken++;
} else {
error(6); // expected identifier
}
}
