diff options
Diffstat (limited to 'code/simpleSableCCCalulator')
14 files changed, 424 insertions, 0 deletions
diff --git a/code/simpleSableCCCalulator/Makefile b/code/simpleSableCCCalulator/Makefile new file mode 100644 index 0000000..477422b --- /dev/null +++ b/code/simpleSableCCCalulator/Makefile @@ -0,0 +1,13 @@ +all: + java -jar ../../../sablecc-3.7/lib/sablecc.jar sableCCCalculator.grammar + javac sableCCCalculator/*.java + javac sableCCCalculator/types/*.java + + +clean: + rm -vf sableCCCalculator/*.class + rm -vf sableCCCalculator/types/*class + rm -rfv sableCCCalculator/analysis/ + rm -rfv sableCCCalculator/lexer/ + rm -rfv sableCCCalculator/node/ + rm -rvf sableCCCalculator/parser/ diff --git a/code/simpleSableCCCalulator/README.md b/code/simpleSableCCCalulator/README.md new file mode 100644 index 0000000..4878685 --- /dev/null +++ b/code/simpleSableCCCalulator/README.md @@ -0,0 +1,22 @@ +# simpleSableCCCalculator + +sableCC is a too used to parse .grammar files (containing a BNF, and lexer information) +into a lexer and parser. We can do a depth first traversal of the produced abstract syntax tree +to parse in the correct order. This is in the file `Translation.java`. + +You produce a lexer and parser by running the sablecc .jar file you can download [here](http://downloads.sourceforge.net/sablecc/sablecc-3.7.zip). Then run it with the first argument as the grammar file: + +`java -jar sablecc-3.7/lib/sablecc.jar sableCCCalculator.grammar` + +(changing the paths as appropriate). The produced java files are not included in git since they're unnessicary. We compile the compiler, program stack and translator: + +`javac sableCCCalculator/*.java` + +I setup a makefil that can be used. First make sure that sablecc is extracted in the directory below `EsotericProject` and just run `make`. + +Then we can run the program. For now it only works by reading files. There are some example maths questions in the examples folder: + +`java sableCCCalculator.Compiler examples/maths.txt` + + + diff --git a/code/simpleSableCCCalulator/examples/maths.txt b/code/simpleSableCCCalulator/examples/maths.txt new file mode 100644 index 0000000..36726f5 --- /dev/null +++ b/code/simpleSableCCCalulator/examples/maths.txt @@ -0,0 +1 @@ +(36/2 + 45.2) * 3
\ No newline at end of file diff --git a/code/simpleSableCCCalulator/examples/maths2.txt b/code/simpleSableCCCalulator/examples/maths2.txt new file mode 100644 index 0000000..313296b --- /dev/null +++ b/code/simpleSableCCCalulator/examples/maths2.txt @@ -0,0 +1 @@ +sin(45 * 2) / 3 diff --git a/code/simpleSableCCCalulator/examples/maths3.txt b/code/simpleSableCCCalulator/examples/maths3.txt new file mode 100644 index 0000000..e092af1 --- /dev/null +++ b/code/simpleSableCCCalulator/examples/maths3.txt @@ -0,0 +1 @@ +3-1+2
\ No newline at end of file diff --git a/code/simpleSableCCCalulator/examples/maths4.txt b/code/simpleSableCCCalulator/examples/maths4.txt new file mode 100644 index 0000000..a922b77 --- /dev/null +++ b/code/simpleSableCCCalulator/examples/maths4.txt @@ -0,0 +1 @@ +2 + 2 diff --git a/code/simpleSableCCCalulator/sableCCCalculator.grammar b/code/simpleSableCCCalulator/sableCCCalculator.grammar new file mode 100644 index 0000000..426fac1 --- /dev/null +++ b/code/simpleSableCCCalulator/sableCCCalculator.grammar @@ -0,0 +1,35 @@ +Package sableCCCalculator; +Helpers + digit = ['0' .. '9']; +Tokens + number = digit+; + double = ((digit)+ '.' (digit)*) | ((digit)* '.' (digit)+); + plus = '+'; + minus = '-'; + mult = '*'; + div = '/'; + mod = '%'; + l_par = '('; + r_par = ')'; + sin = 'sin'; + blank = (' ' | 13 | 10)+; +Ignored Tokens + blank; +Productions + expr = + {factor} factor | + {plus} expr plus factor | + {minus} expr minus factor + ; + factor = + {term} term | + {mult} factor mult term | + {div} factor div term | + {mod} factor mod term + ; + term = + {number} number | + {double} double | + {expr} l_par expr r_par | + {sine} sin l_par expr r_par + ;
\ No newline at end of file diff --git a/code/simpleSableCCCalulator/sableCCCalculator/Compiler.java b/code/simpleSableCCCalulator/sableCCCalculator/Compiler.java new file mode 100644 index 0000000..7430cfe --- /dev/null +++ b/code/simpleSableCCCalulator/sableCCCalculator/Compiler.java @@ -0,0 +1,27 @@ +package sableCCCalculator; +import sableCCCalculator.parser.*; +import sableCCCalculator.lexer.*; +import sableCCCalculator.node.*; +import java.io.*; + +public class Compiler +{ + public static void main(String[] args) + { + try + { + System.out.println("Using source file: " + args[0]); + // Create a Parser instance. + Parser p = new Parser(new Lexer(new PushbackReader(new InputStreamReader(new FileInputStream(args[0])), 1024))); + // Parse the input. + Start tree = p.parse(); + // Apply the translation. + tree.apply(new Translation()); + System.out.println(""); + } + catch(Exception e) + { + System.out.println(e.getMessage()); + } + } +}
\ No newline at end of file diff --git a/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java b/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java new file mode 100644 index 0000000..b49c0d1 --- /dev/null +++ b/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java @@ -0,0 +1,31 @@ +package sableCCCalculator; +import sableCCCalculator.SymbolTable.SymbolTableIndex; +import sableCCCalculator.types.*; +import java.util.Stack; + +public class ProgramStack extends Stack<SymbolTableIndex> { + + public String toString(SymbolTable table) { + String out = "Stack is now: ["; + for (int i = 0; i < this.size(); i++) { + // String theStr = this.elementAt(i).toString(); + // out += String.format("%s, ", theStr.substring(0, theStr.length() - 1)); + out += String.format("%s, ", table.get(this.elementAt(i))); + } + return out.substring(0, out.length() - 2) + "]"; + } + + public static void main(String[] args) { + ProgramStack myStack = new ProgramStack(); + SymbolTable table = new SymbolTable(); + myStack.add(table.addConstant(new Int(2))); + myStack.add(table.addConstant(new Int(4))); + myStack.add(table.addConstant(new Int(6))); + myStack.add(table.addConstant(new Int(0))); + myStack.add(table.addConstant(new Int(1))); + myStack.add(table.addConstant(new Decimal(24601.10642))); + + System.out.println(table.get(myStack.pop())); + System.out.println(myStack.toString(table)); + } +} diff --git a/code/simpleSableCCCalulator/sableCCCalculator/SymbolTable.java b/code/simpleSableCCCalulator/sableCCCalculator/SymbolTable.java new file mode 100644 index 0000000..992e873 --- /dev/null +++ b/code/simpleSableCCCalulator/sableCCCalculator/SymbolTable.java @@ -0,0 +1,63 @@ +package sableCCCalculator; +import java.util.HashMap; +import sableCCCalculator.types.*; + +public class SymbolTable { + + public interface SymbolTableIndex {} + + public abstract class Name implements SymbolTableIndex { + // can be used for functions too hopefully one day... + protected String name; + + String getName() { + return this.name; + } + } + + public class Constant implements SymbolTableIndex { + int index; + + public Constant(int index) { + this.index = index; + } + } + + public class Variable extends Name { + public Variable(String name) { + this.name = name; + } + } + + private HashMap<SymbolTableIndex, Type> theSymbolTable = new HashMap<>(); + + public SymbolTableIndex addConstant(Type item) { + SymbolTableIndex index = new Constant(item.hashCode()); + theSymbolTable.put(index, item); + return index; + } + + public SymbolTableIndex addVariable(Type item, String name) { + SymbolTableIndex index = new Variable(name); + theSymbolTable.put(index, item); + return index; + } + + public void updateVariable(Type newItem, SymbolTableIndex index) { + theSymbolTable.replace(index, newItem); + } + + public Type get(SymbolTableIndex index) { + return theSymbolTable.get(index); + } + + public static void main(String[] args) { + SymbolTable symbolTable = new SymbolTable(); + symbolTable.addConstant(new Int(3)); + SymbolTableIndex i_var = symbolTable.addVariable(new Int(0), "i"); + System.out.println(symbolTable.get(i_var)); + symbolTable.updateVariable(symbolTable.get(i_var).add(new Int(1)), i_var); + System.out.println(symbolTable.get(i_var)); + } +} +
\ No newline at end of file diff --git a/code/simpleSableCCCalulator/sableCCCalculator/Translation.java b/code/simpleSableCCCalulator/sableCCCalculator/Translation.java new file mode 100644 index 0000000..737ecbd --- /dev/null +++ b/code/simpleSableCCCalulator/sableCCCalculator/Translation.java @@ -0,0 +1,90 @@ +package sableCCCalculator; +import sableCCCalculator.SymbolTable.SymbolTableIndex; +import sableCCCalculator.analysis.*; +import sableCCCalculator.types.*; +import sableCCCalculator.node.*; + +class Translation extends DepthFirstAdapter +{ + private ProgramStack programStack = new ProgramStack(); + private SymbolTable symbolTable = new SymbolTable(); + + public void caseTNumber(TNumber node) + { + System.out.println("Pushing " + Integer.parseInt(node.getText()) + " to stack"); + programStack.push(symbolTable.addConstant(new Int(node.getText()))); + System.out.println(programStack.toString(symbolTable)); + } + + public void caseTDouble(TDouble node) + { + System.out.println("Pushing a double: " + Double.parseDouble(node.getText())); + programStack.push(symbolTable.addConstant(new Decimal(node.getText()))); + System.out.println(programStack.toString(symbolTable)); + } + + public void outASineTerm(ASineTerm node) + { + Double num = Double.parseDouble(symbolTable.get(programStack.pop()).toString()); + System.out.println("Popped " + num); + Double out = Math.sin(Math.toRadians(num)); + programStack.push(symbolTable.addConstant(new Decimal(out))); + System.out.println("Pushed sin(" + num + ") = " + out + " to stack"); + System.out.println(programStack.toString(symbolTable)); + } + + public void outAPlusExpr(APlusExpr node) + { + Type op2 = symbolTable.get(programStack.pop()); + Type op1 = symbolTable.get(programStack.pop()); + System.out.println("Popped " + op1 + " and " + op2 + " from stack"); + Type out = op1.add(op2); + programStack.push(symbolTable.addConstant(out)); + System.out.println("Pushed " + op1 + "+" + op2 + "=" + out + " to stack"); + System.out.println(programStack.toString(symbolTable)); + } + + public void outAMinusExpr(AMinusExpr node) + { + Type op2 = symbolTable.get(programStack.pop()); + Type op1 = symbolTable.get(programStack.pop()); + System.out.println("Popped " + op1 + " and " + op2 + " from stack"); + Type out = op1.sub(op2); + programStack.push(symbolTable.addConstant(out)); + System.out.println("Pushed " + op1 + "-" + op2 + "=" + out + " to stack"); + System.out.println(programStack.toString(symbolTable)); + } + + public void outAMultFactor(AMultFactor node) + { + Type op2 = symbolTable.get(programStack.pop()); + Type op1 = symbolTable.get(programStack.pop()); + System.out.println("Popped " + op1 + " and " + op2 + " from stack"); + Type out = op1.mult(op2); + programStack.push(symbolTable.addConstant(out)); + System.out.println("Pushed " + op1 + "*" + op2 + "=" + out + " to stack"); + System.out.println(programStack.toString(symbolTable)); + } + + public void outADivFactor(ADivFactor node) + { + Type op2 = symbolTable.get(programStack.pop()); + Type op1 = symbolTable.get(programStack.pop()); + System.out.println("Popped " + op1 + " and " + op2 + " from stack"); + Type out = op1.div(op2); + programStack.push(symbolTable.addConstant(out)); + System.out.println("Pushed " + op1 + "/" + op2 + "=" + out + " to stack"); + System.out.println(programStack.toString(symbolTable)); + } + + public void outAModFactor(AModFactor node) + { + Type op2 = symbolTable.get(programStack.pop()); + Type op1 = symbolTable.get(programStack.pop()); + System.out.println("Popped " + op1 + " and " + op2 + " from stack"); + Type out = op1.mod(op2); + programStack.push(symbolTable.addConstant(out)); + System.out.println("Pushed " + op1 + "%" + op2 + "=" + out + " to stack"); + System.out.println(programStack.toString(symbolTable)); + } +} diff --git a/code/simpleSableCCCalulator/sableCCCalculator/types/Decimal.java b/code/simpleSableCCCalulator/sableCCCalculator/types/Decimal.java new file mode 100644 index 0000000..5836ff1 --- /dev/null +++ b/code/simpleSableCCCalulator/sableCCCalculator/types/Decimal.java @@ -0,0 +1,57 @@ +package sableCCCalculator.types; + +public class Decimal extends Type { + + public Decimal(Double toDecimal) { + javaObject = (Double)toDecimal; + } + + public Decimal(String toDecimal) { + javaObject = (Double)Double.parseDouble(toDecimal); + } + + public Decimal add(Type toAdd) { + if (toAdd.getClass().getSimpleName().equals("Decimal")) { + return new Decimal((Double)this.javaObject + (double)toAdd.javaObject); + } else { + return new Decimal((Double)this.javaObject + Double.parseDouble(String.format("%d", (int)toAdd.javaObject))); + } + } + + public Decimal sub(Type toAdd) { + if (toAdd.getClass().getSimpleName().equals("Decimal")) { + return new Decimal((Double)this.javaObject - (double)toAdd.javaObject); + } else { + return new Decimal((Double)this.javaObject - Double.parseDouble(String.format("%d", (int)toAdd.javaObject))); + } + } + + public Decimal mult(Type toAdd) { + if (toAdd.getClass().getSimpleName().equals("Decimal")) { + return new Decimal((Double)this.javaObject * (double)toAdd.javaObject); + } else { + return new Decimal((Double)this.javaObject * Double.parseDouble(String.format("%d", (int)toAdd.javaObject))); + } + } + + public Decimal div(Type toAdd) { + if (toAdd.getClass().getSimpleName().equals("Decimal")) { + return new Decimal((Double)this.javaObject / (double)toAdd.javaObject); + } else { + return new Decimal((Double)this.javaObject / Double.parseDouble(String.format("%d", (int)toAdd.javaObject))); + } + } + + public Decimal mod(Type toAdd) { + if (toAdd.getClass().getSimpleName().equals("Decimal")) { + return new Decimal((Double)this.javaObject % (double)toAdd.javaObject); + } else { + return new Decimal((Double)this.javaObject % Double.parseDouble(String.format("%d", (int)toAdd.javaObject))); + } + } + + public static void main(String[] args) { + Decimal aDec = new Decimal(3.1); + System.out.println(aDec.sub(new Int(2))); + } +} diff --git a/code/simpleSableCCCalulator/sableCCCalculator/types/Int.java b/code/simpleSableCCCalulator/sableCCCalculator/types/Int.java new file mode 100644 index 0000000..1ccd20e --- /dev/null +++ b/code/simpleSableCCCalulator/sableCCCalculator/types/Int.java @@ -0,0 +1,60 @@ +package sableCCCalculator.types; + +public class Int extends Type { + + public Int(int toInt) { + javaObject = (Integer)toInt; + } + + public Int(String toInt) { + javaObject = (Integer)Integer.parseInt(toInt); + } + + public Type add(Type toAdd) { + if (toAdd.getClass().getSimpleName().equals("Int")) { + return new Int((int)this.javaObject + (int)toAdd.javaObject); + } else { + return new Decimal(Double.parseDouble(String.format("%d", (int)this.javaObject)) + (Double)toAdd.javaObject); + } + } + + public Type sub(Type toAdd) { + if (toAdd.getClass().getSimpleName().equals("Int")) { + return new Int((int)this.javaObject - (int)toAdd.javaObject); + } else { + return new Decimal(Double.parseDouble(String.format("%d", (int)this.javaObject)) - (Double)toAdd.javaObject); + } + } + + public Type mult(Type toAdd) { + if (toAdd.getClass().getSimpleName().equals("Int")) { + return new Int((int)this.javaObject * (int)toAdd.javaObject); + } else { + return new Decimal(Double.parseDouble(String.format("%d", (int)this.javaObject)) * (Double)toAdd.javaObject); + } + } + + public Type div(Type toAdd) { + if (toAdd.getClass().getSimpleName().equals("Int")) { + return new Int((int)this.javaObject / (int)toAdd.javaObject); + } else { + return new Decimal(Double.parseDouble(String.format("%d", (int)this.javaObject)) / (Double)toAdd.javaObject); + } + } + + public Type mod(Type toAdd) { + if (toAdd.getClass().getSimpleName().equals("Int")) { + return new Int((int)this.javaObject % (int)toAdd.javaObject); + } else { + return new Decimal(Double.parseDouble(String.format("%d", (int)this.javaObject)) % (Double)toAdd.javaObject); + } + } + + public static void main(String[] args) { + Int int1 = new Int(3); + System.out.println(int1.add(new Int(4))); + + Int int2 = new Int(3); + System.out.println(int2.mult(new Decimal(2.2))); + } +} diff --git a/code/simpleSableCCCalulator/sableCCCalculator/types/Type.java b/code/simpleSableCCCalulator/sableCCCalculator/types/Type.java new file mode 100644 index 0000000..359f2b8 --- /dev/null +++ b/code/simpleSableCCCalulator/sableCCCalculator/types/Type.java @@ -0,0 +1,22 @@ +package sableCCCalculator.types; + +// not happy with the amount of polymorphism +// using generics would be better but idk how that'd work in this context... +public abstract class Type { + + protected Object javaObject; + + public abstract Type add(Type toAdd); + public abstract Type sub(Type toSub); + public abstract Type mult(Type toMult); + public abstract Type div(Type toDiv); + public abstract Type mod(Type toMod); + + public String toString() { + return javaObject.toString(); + } + + public String getText() { + return this.toString(); + } +}
\ No newline at end of file |