/**
* Create Header for the jasmin assembler code and add the code of the input file as assembler
* code
*/
private static String createOutput(CodeGenerator codeGenerator, String fileName) {
int size = codeGenerator.getSymbolTable().size() + 1;
return ".bytecode 50.0\n"
+ ".class public "
+ fileName
+ "\n"
+ ".super java/lang/Object\n"
+ ".method public <init>()V\n"
+ "\t.limit stack 1\n"
+ "\t.limit locals 1\n"
+ "\taload_0\n"
+ "\tinvokespecial java/lang/Object/<init>()V\n"
+ "\treturn\n"
+ ".end method\n"
+ "\t.method public static main([Ljava/lang/String;)V\n"
+ "\t.limit stack "
+ codeGenerator.getStackHeight()
+ "\n"
+ // May work...
"\t.limit locals "
+ size
+ "\n"
+ codeGenerator.getCode()
+ "\treturn\n"
+ ".end method\n";
}
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;
}
// 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);
}
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;
}
@Override
protected void genRecognizerHeaderFile(
Tool tool, CodeGenerator generator, Grammar grammar, ST headerFileST, String extName)
throws IOException {
// Its better we remove the EOF Token, as it would have been defined everywhere in C.
// we define it later as "EOF_TOKEN" instead of "EOF"
List<?> tokens = (List<?>) headerFileST.getAttribute("tokens");
for (int i = 0; i < tokens.size(); ++i) {
boolean can_break = false;
Object tok = tokens.get(i);
if (tok instanceof Aggregate) {
Aggregate atok = (Aggregate) tok;
for (Map.Entry<String, Object> pairs : atok.properties.entrySet()) {
if (pairs.getValue().equals("EOF")) {
tokens.remove(i);
can_break = true;
break;
}
}
}
if (can_break) break;
}
// Pick up the file name we are generating. This method will return a
// a file suffixed with .c, so we must substring and add the extName
// to it as we cannot assign into strings in Java.
///
String fileName = generator.getRecognizerFileName(grammar.name, grammar.type);
fileName = fileName.substring(0, fileName.length() - 4) + extName;
generator.write(headerFileST, fileName);
}
// 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);
}
@Override
protected void genRecognizerFile(
Tool tool, CodeGenerator generator, Grammar grammar, ST outputFileST) throws IOException {
// Before we write this, and cause it to generate its string,
// we need to add all the string literals that we are going to match
//
outputFileST.add("literals", strings);
String fileName = generator.getRecognizerFileName(grammar.name, grammar.type);
generator.write(outputFileST, fileName);
}
public static void main(String[] args) {
Symbol result = null;
AST root = null;
CodeGenerator cg = new CodeGenerator();
ArrayList<ErrorObject> scannerErrors, parserErrors;
int nbExceptions = 0;
try {
FileReader myFile = new FileReader(args[0]);
mScanner = new Scanner(myFile);
mParser = new Parser(mScanner);
} catch (Exception e) {
nbExceptions++;
System.err.println("Invalid file");
}
try {
result = mParser.parse();
} catch (Exception e) {
nbExceptions++;
if (DEBUG) {
System.err.println("Parse error: " + e);
e.printStackTrace();
} else System.err.println("A parsing error has occured.");
}
scannerErrors = mScanner.getErrors();
for (ErrorObject err : scannerErrors) System.err.println("\t" + args[0] + err);
parserErrors = mParser.errors;
for (ErrorObject err : parserErrors) System.err.println("\t" + args[0] + err);
if (scannerErrors.size() == 0 && parserErrors.size() == 0) {
try {
root = (AST) result.value;
} catch (Exception e) {
nbExceptions++;
if (DEBUG) {
System.err.println("Result error: " + e);
} else System.err.println("An internal error has occured.");
}
cg.setRoot(root);
if (nbExceptions == 0) cg.generateCode("tests/output/" + args[1] + "/src/gen/Main.java");
}
if (scannerErrors.size() != 0 || parserErrors.size() != 0 || nbExceptions != 0) {
System.err.println(
"\n\t>> Code generation aborted; see the compiler error output for details.");
}
}
public static DefaultMutableTreeNode run(Vector<Token> t, Gui gui) {
Parser.gui = gui;
tokens = t;
currentToken = 0;
root = new DefaultMutableTreeNode("program");
CodeGenerator.clear(gui);
//
rule_program(root);
CodeGenerator.addInstruction("OPR", "0", "0");
codeLine++;
gui.writeSymbolTable(SemanticAnalyzer.getSymbolTable());
CodeGenerator.writeCode(gui);
//
return root;
}
// 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--;
}
}
}
/**
* Generate the classfile instructions for this operand
*
* @param codeGen the code generator
*/
public void generateInstructions(CodeGenerator codeGen) {
int opcode;
switch (getType()) {
case ClassfileConstants2.TYP_REFERENCE:
opcode = ClassfileConstants2.opc_aload;
break;
case ClassfileConstants2.TYP_DOUBLE:
opcode = ClassfileConstants2.opc_dload;
break;
case ClassfileConstants2.TYP_FLOAT:
opcode = ClassfileConstants2.opc_fload;
break;
case ClassfileConstants2.TYP_INT:
opcode = ClassfileConstants2.opc_iload;
break;
case ClassfileConstants2.TYP_LONG:
opcode = ClassfileConstants2.opc_lload;
break;
case ClassfileConstants2.TYP_ADDRESS:
opcode = ClassfileConstants2.opc_aload;
break;
default:
throw new InconsistencyException("unknows type : " + getType());
}
codeGen.addInstruction(new LocalVarInstruction(opcode, register));
}
public List<DirtyBicycle> getDirtyBicycles(final Year year, final String file)
throws PriceReaderException {
List<DirtyBicycle> toReturn = new ArrayList<DirtyBicycle>();
HSSFSheet sheet = getSheet(file, 0);
List<PriceRow> rows = getPriceRows(sheet, Brand.STELS);
for (PriceRow row : rows) {
String dirtyName = row.getModelName().trim();
List<SimpleBicycle> km;
if (year.equals(Year.YEAR_2016)) {
km = knownModels;
} else if (year.equals(Year.YEAR_2015)) {
km = knownModels2015;
} else {
LOGGER.error("YEAR is not defined");
return Collections.emptyList();
}
for (SimpleBicycle simpleBicycle : km) {
if (simpleBicycle.getDirtyModel().equals(dirtyName.trim())) {
DirtyBicycle bicycle = new DirtyBicycle(simpleBicycle);
bicycle.setPrice(getRoundedPrice(row.getRetailPrice()));
bicycle.setDescription(row.getDescription());
bicycle.setProdCode(CodeGenerator.generateCode(bicycle));
toReturn.add(bicycle);
}
}
}
return toReturn;
}
// 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--;
}
}
}
public static void main(String[] args) {
try {
Scanner consoleInput = new Scanner(System.in);
System.out.println("Enter file name: ");
String fileName = consoleInput.next();
if (!fileName.endsWith(".t")) {
System.out.println("Expecting a LOGO file");
return;
}
Root program = Parser.parse(Lexer.tokenise(FileManager.contentsOfFile(fileName)));
System.out.println("Enter output file name");
String outFileName = consoleInput.next();
if (!outFileName.endsWith(".ps") && !outFileName.endsWith(".eps")) {
outFileName += ".ps";
}
String output = CodeGenerator.generateCodeText(program);
if (ErrorLog.containsErrors()) {
ErrorLog.displayErrors();
return;
} else {
FileManager.writeStringToFile(output, outFileName);
}
} catch (FileNotFoundException e) {
System.out.println(e.getMessage());
} catch (IOException IO) {
System.out.println(IO.getMessage());
}
}
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_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_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;
}
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_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_return(DefaultMutableTreeNode parent) {
boolean error = false;
DefaultMutableTreeNode node;
node = new DefaultMutableTreeNode(tokens.get(currentToken).getWord());
parent.add(node);
currentToken++;
CodeGenerator.addInstruction("OPR", "1", "0");
return error;
}
// default
private static void rule_default(DefaultMutableTreeNode parent) {
DefaultMutableTreeNode node = null;
node = new DefaultMutableTreeNode("default");
parent.add(node);
if (tokens.get(currentToken).getWord().equals(":")) {
node = new DefaultMutableTreeNode(":");
parent.add(node);
currentToken++;
}
CodeGenerator.addLabel("labelD", codeLine);
rule_program(parent);
}
// 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);
}
}
}
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;
}
public CompiledScript compile(Script script, String className) {
try (CodeSizeAnalysis analysis = new CodeSizeAnalysis()) {
analysis.submit(script);
} catch (CodeSizeException e) {
e.printStackTrace();
throw new CompilationException(e.getMessage());
}
// set-up
// prepend '#' to mark generated classes, cf. ErrorPrototype
String clazzName = "#" + className;
String superClassName = Types.CompiledScript.getInternalName();
Code code = new Code(clazzName, superClassName, script.getSourceFile(), sourceMap(script));
// generate code
try (CodeGenerator codegen = new CodeGenerator(code, script.getOptions())) {
codegen.compile(script);
}
// finalize
CodeLoader loader = new CodeLoader();
List<ClassCode> classes = code.getClasses();
for (ClassCode classCode : classes) {
byte[] bytes = classCode.toByteArray();
if (compilerOptions.contains(Option.Debug)) {
debug(bytes);
}
// System.out.printf("define class '%s'%n", classCode.className);
loader.defineClass(classCode.className, bytes);
}
try {
Class<?> c = loader.loadClass(clazzName);
return (CompiledScript) c.newInstance();
} catch (ReflectiveOperationException e) {
throw new RuntimeException(e);
}
}
// negative
private static void rule_b(DefaultMutableTreeNode parent) {
DefaultMutableTreeNode node = null;
boolean b = false;
if (tokens.get(currentToken).getWord().equals("-")) {
b = true;
node = new DefaultMutableTreeNode(tokens.get(currentToken).getWord());
parent.add(node);
if (currentToken < tokens.size() - 1) currentToken++;
CodeGenerator.addInstruction("LIT", "0", "0");
codeLine++;
}
node = new DefaultMutableTreeNode("C");
parent.add(node);
if (b) {
String x = SemanticAnalyzer.popStack();
String result = SemanticAnalyzer.calculateCube(x, "-");
SemanticAnalyzer.pushStack(result);
}
rule_c(node);
if (b) {
CodeGenerator.addInstruction("OPR", "3", "0");
codeLine++;
}
}
private CompiledFunction compile(FunctionNode function, String className) {
try (CodeSizeAnalysis analysis = new CodeSizeAnalysis()) {
analysis.submit(function);
} catch (CodeSizeException e) {
throw new CompilationException(e.getMessage());
}
// set-up
// prepend '#' to mark generated classes, cf. ErrorPrototype
String clazzName = "#" + className;
String superClassName = Types.CompiledFunction.getInternalName();
Code code = new Code(clazzName, superClassName, "<Function>", null);
// generate code
try (CodeGenerator codegen = new CodeGenerator(code, optionsFrom(function))) {
codegen.compileFunction(function);
}
// finalize
CodeLoader loader = new CodeLoader();
List<ClassCode> classes = code.getClasses();
for (ClassCode classCode : classes) {
byte[] bytes = classCode.toByteArray();
if (compilerOptions.contains(Option.Debug)) {
debug(bytes);
}
loader.defineClass(classCode.className, bytes);
}
try {
Class<?> c = loader.loadClass(clazzName);
return (CompiledFunction) c.newInstance();
} catch (ReflectiveOperationException e) {
throw new RuntimeException(e);
}
}
@Override
void add(Node n, Context context) {
Node parent = n.getParent();
if (parent != null && (parent.isBlock() || parent.isScript())) {
if (n.isFunction()) {
add(getFunctionAnnotation(n));
} else if (n.isExprResult() && n.getFirstChild().isAssign()) {
Node rhs = n.getFirstChild().getLastChild();
add(getTypeAnnotation(rhs));
} else if (n.isVar() && n.getFirstChild().getFirstChild() != null) {
add(getTypeAnnotation(n.getFirstChild().getFirstChild()));
}
}
super.add(n, context);
}
// 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);
}
}
@Test
public void runCodegen() throws IOException {
final Rule rule = parser.parseRule(ruleForTest(), true).withId("1");
final String sourceCode = CodeGenerator.sourceCodeForRule(rule);
Files.write(sourceCode, OUTFILE.toFile(), StandardCharsets.UTF_8);
log.info("Code:\n{}", sourceCode);
try {
ClassLoader ruleClassloader = new ClassLoader() {};
//noinspection unchecked
Class<GeneratedRule> rule$1 =
(Class<GeneratedRule>)
JCC.loadFromJava(
ruleClassloader,
"org.graylog.plugins.pipelineprocessor.$dynamic.rules.rule$1",
sourceCode);
//noinspection unchecked
final Set<Constructor> constructors =
ReflectionUtils.getConstructors(rule$1, input -> input.getParameterCount() == 1);
final Constructor onlyElement = Iterables.getOnlyElement(constructors);
final GeneratedRule generatedRule = (GeneratedRule) onlyElement.newInstance(functionRegistry);
final Message message = new Message("hello", "jenkins.torch.sh", Tools.nowUTC());
message.addField("message", "#1234");
message.addField("something_that_doesnt_exist", "foo");
final EvaluationContext context = new EvaluationContext(message);
final boolean when = generatedRule.when(context);
if (when) {
generatedRule.then(context);
}
log.info("created dynamic rule {} matches: {}", generatedRule.name(), when);
assertThat(context.currentMessage().hasField("some_identifier")).isTrue();
} catch (InvocationTargetException
| ClassNotFoundException
| InstantiationException
| IllegalAccessException e) {
log.error("Cannot load dynamically created class!", e);
}
}
public void writeBody(CodeGenerator generator) {
generator.writeType(getTypeName());
generator.writeType(" ");
generator.write(getName());
if (getInitialValue() != null) {
generator.write(" = ");
generator.write(getInitialValue());
}
generator.write(";");
}
