From e09b0bb865bbb0087c46b4acd90b759f14dfa824 Mon Sep 17 00:00:00 2001 From: jwansek Date: Mon, 18 Oct 2021 16:40:56 +0100 Subject: added sableCC calculator --- code/simpleSableCCCalulator/README.md | 20 ++++ code/simpleSableCCCalulator/examples/maths.txt | 1 + code/simpleSableCCCalulator/examples/maths2.txt | 1 + code/simpleSableCCCalulator/examples/maths3.txt | 1 + .../sableCCCalculator.grammar | 35 ++++++ .../sableCCCalculator/Compiler.java | 27 +++++ .../sableCCCalculator/ProgramStack.java | 28 +++++ .../sableCCCalculator/Translation.java | 132 +++++++++++++++++++++ 8 files changed, 245 insertions(+) create mode 100644 code/simpleSableCCCalulator/README.md create mode 100644 code/simpleSableCCCalulator/examples/maths.txt create mode 100644 code/simpleSableCCCalulator/examples/maths2.txt create mode 100644 code/simpleSableCCCalulator/examples/maths3.txt create mode 100644 code/simpleSableCCCalulator/sableCCCalculator.grammar create mode 100644 code/simpleSableCCCalulator/sableCCCalculator/Compiler.java create mode 100644 code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java create mode 100644 code/simpleSableCCCalulator/sableCCCalculator/Translation.java (limited to 'code') diff --git a/code/simpleSableCCCalulator/README.md b/code/simpleSableCCCalulator/README.md new file mode 100644 index 0000000..4c75421 --- /dev/null +++ b/code/simpleSableCCCalulator/README.md @@ -0,0 +1,20 @@ +# 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` + +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..f3b3bd9 --- /dev/null +++ b/code/simpleSableCCCalulator/examples/maths.txt @@ -0,0 +1 @@ +(36/2 + 45) * 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..1f1d63e --- /dev/null +++ b/code/simpleSableCCCalulator/examples/maths2.txt @@ -0,0 +1 @@ +sin(45 * 3) / 3 \ No newline at end of file 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/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..1875e57 --- /dev/null +++ b/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java @@ -0,0 +1,28 @@ +package sableCCCalculator; +import sableCCCalculator.node.*; +import java.util.Stack; + +public class ProgramStack extends Stack { + + public String toString() { + 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)); + } + return out.substring(0, out.length() - 2) + "]"; + } + + public static void main(String[] args) { + ProgramStack myStack = new ProgramStack<>(); + myStack.add(new TNumber("2")); + myStack.add(new TNumber("4")); + myStack.add(new TNumber("6")); + myStack.add(new TNumber("0")); + myStack.add(new TNumber("1")); + myStack.add(new TDouble("24601.10642")); + + System.out.println(myStack.pop().getText()); + System.out.println(myStack); + } +} diff --git a/code/simpleSableCCCalulator/sableCCCalculator/Translation.java b/code/simpleSableCCCalulator/sableCCCalculator/Translation.java new file mode 100644 index 0000000..d8fd74d --- /dev/null +++ b/code/simpleSableCCCalulator/sableCCCalculator/Translation.java @@ -0,0 +1,132 @@ +package sableCCCalculator; +import sableCCCalculator.analysis.*; +import sableCCCalculator.node.*; + +class Translation extends DepthFirstAdapter +{ + private ProgramStack programStack = new ProgramStack<>(); + + public void caseTNumber(TNumber node) + { + System.out.println("Pushing " + Integer.parseInt(node.getText()) + " to stack"); + programStack.push(node); + System.out.println(programStack); + } + + public void caseTDouble(TDouble node) + { + System.out.println("Pushing a double: " + Double.parseDouble(node.getText())); + programStack.push(node); + System.out.println(programStack); + } + + public void outASineTerm(ASineTerm node) + { + Double num = Double.parseDouble(programStack.pop().getText()); + System.out.println("Popped " + num); + Double out = Math.sin(Math.toRadians(num)); + programStack.push(new TDouble(String.format("%f", out))); + System.out.println("Pushed sin(" + num + ") = " + out + " to stack"); + System.out.println(programStack); + } + + public void outAPlusExpr(APlusExpr node) + { + Double num2 = Double.parseDouble(programStack.pop().getText()); + Double num1 = Double.parseDouble(programStack.pop().getText()); + System.out.println("Popped " + num1 + " and " + num2 + " from stack"); + Double out = num1 + num2; + if ((out % 1) == 0) + { + // the output is an integer, change types to save memory + programStack.push(new TNumber(String.format("%d", out.intValue()))); + } + else + { + programStack.push(new TDouble(String.format("%f", out))); + } + + System.out.println("Pushed " + num1 + "+" + num2 + "=" + out + " to stack"); + System.out.println(programStack); + } + + public void outAMinusExpr(AMinusExpr node) + { + Double num2 = Double.parseDouble(programStack.pop().getText()); + Double num1 = Double.parseDouble(programStack.pop().getText()); + System.out.println("Popped " + num1 + " and " + num2 + " from stack"); + Double out = num1 - num2; + if ((out % 1) == 0) + { + // the output is an integer, change types to save memory + programStack.push(new TNumber(String.format("%d", out.intValue()))); + } + else + { + programStack.push(new TDouble(String.format("%f", out))); + } + + System.out.println("Pushed " + num1 + "-" + num2 + "=" + out + " to stack"); + System.out.println(programStack); + } + + public void outAMultFactor(AMultFactor node) + { + Double num2 = Double.parseDouble(programStack.pop().getText()); + Double num1 = Double.parseDouble(programStack.pop().getText()); + System.out.println("Popped " + num1 + " and " + num2 + " from stack"); + Double out = num1 * num2; + if ((out % 1) == 0) + { + // the output is an integer, change types to save memory + programStack.push(new TNumber(String.format("%d", out.intValue()))); + } + else + { + programStack.push(new TDouble(String.format("%f", out))); + } + + System.out.println("Pushed " + num1 + "*" + num2 + "=" + out + " to stack"); + System.out.println(programStack); + } + + public void outADivFactor(ADivFactor node) + { + Double num2 = Double.parseDouble(programStack.pop().getText()); + Double num1 = Double.parseDouble(programStack.pop().getText()); + System.out.println("Popped " + num1 + " and " + num2 + " from stack"); + Double out = num1 / num2; + if ((out % 1) == 0) + { + // the output is an integer, change types to save memory + programStack.push(new TNumber(String.format("%d", out.intValue()))); + } + else + { + programStack.push(new TDouble(String.format("%f", out))); + } + + System.out.println("Pushed " + num1 + "/" + num2 + "=" + out + " to stack"); + System.out.println(programStack); + } + + public void outAModFactor(AModFactor node) + { + Double num2 = Double.parseDouble(programStack.pop().getText()); + Double num1 = Double.parseDouble(programStack.pop().getText()); + System.out.println("Popped " + num1 + " and " + num2 + " from stack"); + Double out = num1 % num2; + if ((out % 1) == 0) + { + // the output is an integer, change types to save memory + programStack.push(new TNumber(String.format("%d", out.intValue()))); + } + else + { + programStack.push(new TDouble(String.format("%f", out))); + } + + System.out.println("Pushed " + num1 + "%" + num2 + "=" + out + " to stack"); + System.out.println(programStack); + } +} -- cgit v1.2.3 From 8f50e4d189bad9dbd180fd945881950769c3a989 Mon Sep 17 00:00:00 2001 From: jwansek Date: Sun, 24 Oct 2021 14:07:29 +0100 Subject: added the start of a type system --- code/simpleSableCCCalulator/Makefile | 8 ++ code/simpleSableCCCalulator/examples/maths.txt | 2 +- code/simpleSableCCCalulator/examples/maths4.txt | 1 + .../sableCCCalculator/ProgramStack.java | 23 +++-- .../sableCCCalculator/Translation.java | 114 +++++++-------------- .../sableCCCalculator/types/Decimal.java | 57 +++++++++++ .../sableCCCalculator/types/Int.java | 60 +++++++++++ .../sableCCCalculator/types/Type.java | 22 ++++ 8 files changed, 196 insertions(+), 91 deletions(-) create mode 100644 code/simpleSableCCCalulator/Makefile create mode 100644 code/simpleSableCCCalulator/examples/maths4.txt create mode 100644 code/simpleSableCCCalulator/sableCCCalculator/types/Decimal.java create mode 100644 code/simpleSableCCCalulator/sableCCCalculator/types/Int.java create mode 100644 code/simpleSableCCCalulator/sableCCCalculator/types/Type.java (limited to 'code') diff --git a/code/simpleSableCCCalulator/Makefile b/code/simpleSableCCCalulator/Makefile new file mode 100644 index 0000000..7c6962b --- /dev/null +++ b/code/simpleSableCCCalulator/Makefile @@ -0,0 +1,8 @@ +all: + javac sableCCCalculator/*.java + javac sableCCCalculator/types/*.java + + +clean: + rm -vf sableCCCalculator/*.class + rm -vf sableCCCalculator/types/*class diff --git a/code/simpleSableCCCalulator/examples/maths.txt b/code/simpleSableCCCalulator/examples/maths.txt index f3b3bd9..36726f5 100644 --- a/code/simpleSableCCCalulator/examples/maths.txt +++ b/code/simpleSableCCCalulator/examples/maths.txt @@ -1 +1 @@ -(36/2 + 45) * 3 \ No newline at end of file +(36/2 + 45.2) * 3 \ 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..5b3e67d --- /dev/null +++ b/code/simpleSableCCCalulator/examples/maths4.txt @@ -0,0 +1 @@ +2 + 3.1 diff --git a/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java b/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java index 1875e57..c1046ee 100644 --- a/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java +++ b/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java @@ -1,26 +1,27 @@ package sableCCCalculator; -import sableCCCalculator.node.*; +import sableCCCalculator.types.*; import java.util.Stack; -public class ProgramStack extends Stack { +public class ProgramStack extends Stack { public String toString() { 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)); + // String theStr = this.elementAt(i).toString(); + // out += String.format("%s, ", theStr.substring(0, theStr.length() - 1)); + out += String.format("%s, ", this.elementAt(i).toString()); } return out.substring(0, out.length() - 2) + "]"; } public static void main(String[] args) { - ProgramStack myStack = new ProgramStack<>(); - myStack.add(new TNumber("2")); - myStack.add(new TNumber("4")); - myStack.add(new TNumber("6")); - myStack.add(new TNumber("0")); - myStack.add(new TNumber("1")); - myStack.add(new TDouble("24601.10642")); + ProgramStack myStack = new ProgramStack<>(); + myStack.add(new Int(2)); + myStack.add(new Int(4)); + myStack.add(new Int(6)); + myStack.add(new Int(0)); + myStack.add(new Int(1)); + myStack.add(new Decimal(24601.10642)); System.out.println(myStack.pop().getText()); System.out.println(myStack); diff --git a/code/simpleSableCCCalulator/sableCCCalculator/Translation.java b/code/simpleSableCCCalulator/sableCCCalculator/Translation.java index d8fd74d..a673edb 100644 --- a/code/simpleSableCCCalulator/sableCCCalculator/Translation.java +++ b/code/simpleSableCCCalulator/sableCCCalculator/Translation.java @@ -1,22 +1,23 @@ package sableCCCalculator; import sableCCCalculator.analysis.*; +import sableCCCalculator.types.*; import sableCCCalculator.node.*; class Translation extends DepthFirstAdapter { - private ProgramStack programStack = new ProgramStack<>(); + private ProgramStack programStack = new ProgramStack<>(); public void caseTNumber(TNumber node) { System.out.println("Pushing " + Integer.parseInt(node.getText()) + " to stack"); - programStack.push(node); + programStack.push(new Int(node.getText())); System.out.println(programStack); } public void caseTDouble(TDouble node) { System.out.println("Pushing a double: " + Double.parseDouble(node.getText())); - programStack.push(node); + programStack.push(new Decimal(node.getText())); System.out.println(programStack); } @@ -25,108 +26,63 @@ class Translation extends DepthFirstAdapter Double num = Double.parseDouble(programStack.pop().getText()); System.out.println("Popped " + num); Double out = Math.sin(Math.toRadians(num)); - programStack.push(new TDouble(String.format("%f", out))); + programStack.push(new Decimal(out)); System.out.println("Pushed sin(" + num + ") = " + out + " to stack"); System.out.println(programStack); } public void outAPlusExpr(APlusExpr node) { - Double num2 = Double.parseDouble(programStack.pop().getText()); - Double num1 = Double.parseDouble(programStack.pop().getText()); - System.out.println("Popped " + num1 + " and " + num2 + " from stack"); - Double out = num1 + num2; - if ((out % 1) == 0) - { - // the output is an integer, change types to save memory - programStack.push(new TNumber(String.format("%d", out.intValue()))); - } - else - { - programStack.push(new TDouble(String.format("%f", out))); - } - - System.out.println("Pushed " + num1 + "+" + num2 + "=" + out + " to stack"); + Type op2 = programStack.pop(); + Type op1 = programStack.pop(); + System.out.println("Popped " + op1 + " and " + op2 + " from stack"); + Type out = op1.add(op2); + programStack.push(out); + System.out.println("Pushed " + op1 + "+" + op2 + "=" + out + " to stack"); System.out.println(programStack); } public void outAMinusExpr(AMinusExpr node) { - Double num2 = Double.parseDouble(programStack.pop().getText()); - Double num1 = Double.parseDouble(programStack.pop().getText()); - System.out.println("Popped " + num1 + " and " + num2 + " from stack"); - Double out = num1 - num2; - if ((out % 1) == 0) - { - // the output is an integer, change types to save memory - programStack.push(new TNumber(String.format("%d", out.intValue()))); - } - else - { - programStack.push(new TDouble(String.format("%f", out))); - } - - System.out.println("Pushed " + num1 + "-" + num2 + "=" + out + " to stack"); + Type op2 = programStack.pop(); + Type op1 = programStack.pop(); + System.out.println("Popped " + op1 + " and " + op2 + " from stack"); + Type out = op1.sub(op2); + programStack.push(out); + System.out.println("Pushed " + op1 + "-" + op2 + "=" + out + " to stack"); System.out.println(programStack); } public void outAMultFactor(AMultFactor node) { - Double num2 = Double.parseDouble(programStack.pop().getText()); - Double num1 = Double.parseDouble(programStack.pop().getText()); - System.out.println("Popped " + num1 + " and " + num2 + " from stack"); - Double out = num1 * num2; - if ((out % 1) == 0) - { - // the output is an integer, change types to save memory - programStack.push(new TNumber(String.format("%d", out.intValue()))); - } - else - { - programStack.push(new TDouble(String.format("%f", out))); - } - - System.out.println("Pushed " + num1 + "*" + num2 + "=" + out + " to stack"); + Type op2 = programStack.pop(); + Type op1 = programStack.pop(); + System.out.println("Popped " + op1 + " and " + op2 + " from stack"); + Type out = op1.mult(op2); + programStack.push(out); + System.out.println("Pushed " + op1 + "*" + op2 + "=" + out + " to stack"); System.out.println(programStack); } public void outADivFactor(ADivFactor node) { - Double num2 = Double.parseDouble(programStack.pop().getText()); - Double num1 = Double.parseDouble(programStack.pop().getText()); - System.out.println("Popped " + num1 + " and " + num2 + " from stack"); - Double out = num1 / num2; - if ((out % 1) == 0) - { - // the output is an integer, change types to save memory - programStack.push(new TNumber(String.format("%d", out.intValue()))); - } - else - { - programStack.push(new TDouble(String.format("%f", out))); - } - - System.out.println("Pushed " + num1 + "/" + num2 + "=" + out + " to stack"); + Type op2 = programStack.pop(); + Type op1 = programStack.pop(); + System.out.println("Popped " + op1 + " and " + op2 + " from stack"); + Type out = op1.div(op2); + programStack.push(out); + System.out.println("Pushed " + op1 + "/" + op2 + "=" + out + " to stack"); System.out.println(programStack); } public void outAModFactor(AModFactor node) { - Double num2 = Double.parseDouble(programStack.pop().getText()); - Double num1 = Double.parseDouble(programStack.pop().getText()); - System.out.println("Popped " + num1 + " and " + num2 + " from stack"); - Double out = num1 % num2; - if ((out % 1) == 0) - { - // the output is an integer, change types to save memory - programStack.push(new TNumber(String.format("%d", out.intValue()))); - } - else - { - programStack.push(new TDouble(String.format("%f", out))); - } - - System.out.println("Pushed " + num1 + "%" + num2 + "=" + out + " to stack"); + Type op2 = programStack.pop(); + Type op1 = programStack.pop(); + System.out.println("Popped " + op1 + " and " + op2 + " from stack"); + Type out = op1.mod(op2); + programStack.push(out); + System.out.println("Pushed " + op1 + "%" + op2 + "=" + out + " to stack"); System.out.println(programStack); } } 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 -- cgit v1.2.3 From 814c115d8accedc07e42d218bfdab639148fa836 Mon Sep 17 00:00:00 2001 From: jwansek Date: Sun, 24 Oct 2021 15:59:49 +0100 Subject: started work on the symbol table, preparing for variables --- .../sableCCCalculator/SymbolTable.java | 48 ++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 code/simpleSableCCCalulator/sableCCCalculator/SymbolTable.java (limited to 'code') diff --git a/code/simpleSableCCCalulator/sableCCCalculator/SymbolTable.java b/code/simpleSableCCCalulator/sableCCCalculator/SymbolTable.java new file mode 100644 index 0000000..435e48d --- /dev/null +++ b/code/simpleSableCCCalulator/sableCCCalculator/SymbolTable.java @@ -0,0 +1,48 @@ +package sableCCCalculator; +import java.util.HashMap; +import sableCCCalculator.types.*; + +public class SymbolTable { + + public interface SymbolTableIndex {} + + public abstract class Name implements SymbolTableIndex { + 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 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 Type get(SymbolTableIndex index) { + return theSymbolTable.get(index); + } +} -- cgit v1.2.3 From 3b85d64206d232d12864ec46a8b8d42fe6b464bb Mon Sep 17 00:00:00 2001 From: jwansek Date: Sun, 24 Oct 2021 16:08:45 +0100 Subject: updated readme and makefile --- code/simpleSableCCCalulator/Makefile | 5 +++++ code/simpleSableCCCalulator/README.md | 2 ++ 2 files changed, 7 insertions(+) (limited to 'code') diff --git a/code/simpleSableCCCalulator/Makefile b/code/simpleSableCCCalulator/Makefile index 7c6962b..477422b 100644 --- a/code/simpleSableCCCalulator/Makefile +++ b/code/simpleSableCCCalulator/Makefile @@ -1,4 +1,5 @@ all: + java -jar ../../../sablecc-3.7/lib/sablecc.jar sableCCCalculator.grammar javac sableCCCalculator/*.java javac sableCCCalculator/types/*.java @@ -6,3 +7,7 @@ all: 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 index 4c75421..4878685 100644 --- a/code/simpleSableCCCalulator/README.md +++ b/code/simpleSableCCCalulator/README.md @@ -12,6 +12,8 @@ You produce a lexer and parser by running the sablecc .jar file you can download `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` -- cgit v1.2.3 From aa3a6929584eaa63cafb73353a62effd75d4dd8c Mon Sep 17 00:00:00 2001 From: jwansek Date: Mon, 25 Oct 2021 15:20:30 +0100 Subject: added using symbol table in stack --- code/simpleSableCCCalulator/examples/maths2.txt | 2 +- code/simpleSableCCCalulator/examples/maths4.txt | 2 +- .../sableCCCalculator/ProgramStack.java | 26 +++++----- .../sableCCCalculator/SymbolTable.java | 17 ++++++- .../sableCCCalculator/Translation.java | 58 +++++++++++----------- 5 files changed, 62 insertions(+), 43 deletions(-) (limited to 'code') diff --git a/code/simpleSableCCCalulator/examples/maths2.txt b/code/simpleSableCCCalulator/examples/maths2.txt index 1f1d63e..313296b 100644 --- a/code/simpleSableCCCalulator/examples/maths2.txt +++ b/code/simpleSableCCCalulator/examples/maths2.txt @@ -1 +1 @@ -sin(45 * 3) / 3 \ No newline at end of file +sin(45 * 2) / 3 diff --git a/code/simpleSableCCCalulator/examples/maths4.txt b/code/simpleSableCCCalulator/examples/maths4.txt index 5b3e67d..a922b77 100644 --- a/code/simpleSableCCCalulator/examples/maths4.txt +++ b/code/simpleSableCCCalulator/examples/maths4.txt @@ -1 +1 @@ -2 + 3.1 +2 + 2 diff --git a/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java b/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java index c1046ee..b49c0d1 100644 --- a/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java +++ b/code/simpleSableCCCalulator/sableCCCalculator/ProgramStack.java @@ -1,29 +1,31 @@ package sableCCCalculator; +import sableCCCalculator.SymbolTable.SymbolTableIndex; import sableCCCalculator.types.*; import java.util.Stack; -public class ProgramStack extends Stack { +public class ProgramStack extends Stack { - public String toString() { + 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, ", this.elementAt(i).toString()); + 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<>(); - myStack.add(new Int(2)); - myStack.add(new Int(4)); - myStack.add(new Int(6)); - myStack.add(new Int(0)); - myStack.add(new Int(1)); - myStack.add(new Decimal(24601.10642)); + 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(myStack.pop().getText()); - System.out.println(myStack); + 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 index 435e48d..992e873 100644 --- a/code/simpleSableCCCalulator/sableCCCalculator/SymbolTable.java +++ b/code/simpleSableCCCalulator/sableCCCalculator/SymbolTable.java @@ -6,7 +6,8 @@ public class SymbolTable { public interface SymbolTableIndex {} - public abstract class Name implements SymbolTableIndex { + public abstract class Name implements SymbolTableIndex { + // can be used for functions too hopefully one day... protected String name; String getName() { @@ -42,7 +43,21 @@ public class SymbolTable { 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 index a673edb..737ecbd 100644 --- a/code/simpleSableCCCalulator/sableCCCalculator/Translation.java +++ b/code/simpleSableCCCalulator/sableCCCalculator/Translation.java @@ -1,88 +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 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(new Int(node.getText())); - System.out.println(programStack); + 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(new Decimal(node.getText())); - System.out.println(programStack); + programStack.push(symbolTable.addConstant(new Decimal(node.getText()))); + System.out.println(programStack.toString(symbolTable)); } public void outASineTerm(ASineTerm node) { - Double num = Double.parseDouble(programStack.pop().getText()); + Double num = Double.parseDouble(symbolTable.get(programStack.pop()).toString()); System.out.println("Popped " + num); Double out = Math.sin(Math.toRadians(num)); - programStack.push(new Decimal(out)); + programStack.push(symbolTable.addConstant(new Decimal(out))); System.out.println("Pushed sin(" + num + ") = " + out + " to stack"); - System.out.println(programStack); + System.out.println(programStack.toString(symbolTable)); } public void outAPlusExpr(APlusExpr node) { - Type op2 = programStack.pop(); - Type op1 = programStack.pop(); + 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(out); + programStack.push(symbolTable.addConstant(out)); System.out.println("Pushed " + op1 + "+" + op2 + "=" + out + " to stack"); - System.out.println(programStack); + System.out.println(programStack.toString(symbolTable)); } public void outAMinusExpr(AMinusExpr node) { - Type op2 = programStack.pop(); - Type op1 = programStack.pop(); + 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(out); + programStack.push(symbolTable.addConstant(out)); System.out.println("Pushed " + op1 + "-" + op2 + "=" + out + " to stack"); - System.out.println(programStack); + System.out.println(programStack.toString(symbolTable)); } public void outAMultFactor(AMultFactor node) { - Type op2 = programStack.pop(); - Type op1 = programStack.pop(); + 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(out); + programStack.push(symbolTable.addConstant(out)); System.out.println("Pushed " + op1 + "*" + op2 + "=" + out + " to stack"); - System.out.println(programStack); + System.out.println(programStack.toString(symbolTable)); } public void outADivFactor(ADivFactor node) { - Type op2 = programStack.pop(); - Type op1 = programStack.pop(); + 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(out); + programStack.push(symbolTable.addConstant(out)); System.out.println("Pushed " + op1 + "/" + op2 + "=" + out + " to stack"); - System.out.println(programStack); + System.out.println(programStack.toString(symbolTable)); } public void outAModFactor(AModFactor node) { - Type op2 = programStack.pop(); - Type op1 = programStack.pop(); + 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(out); + programStack.push(symbolTable.addConstant(out)); System.out.println("Pushed " + op1 + "%" + op2 + "=" + out + " to stack"); - System.out.println(programStack); + System.out.println(programStack.toString(symbolTable)); } } -- cgit v1.2.3