Merge branch 'main' of https://github.com/AlfieEagleton/EsotericProject

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