Merge branch 'feature/nestes-expressions' into 'master'

Feature/nested expressions

See merge request mkais001/klang!2

.gitignore

@@ -16,3 +16,9 @@ src/main/antlr4/de/hsrm/compiler/Klang/.antlr
 
 # assembly files
 *.s
+
+# other sourcecode files
+*.c
+
+# build output
+out

src/main/antlr4/de/hsrm/compiler/Klang/Klang.g4

@@ -44,14 +44,21 @@ return_statement
   ;
 
 expression
-  : atom MULT atom #multiplicationExpression
-  | atom op=(ADD | SUB) atom #additiveExpression
-  | atom MOD atom #moduloExpression
-  | SUB atom #unaryNegateExpression
-  | atom #atomExpression
+  : atom #atomExpression
+  | OPAR lhs=expression ADD rhs=expression CPAR #additionExpression
+  | OPAR lhs=expression SUB rhs=expression CPAR #substractionExpression
+  | OPAR lhs=expression MUL rhs=expression CPAR #multiplicationExpression
+  | OPAR lhs=expression DIV rhs=expression CPAR #divisionExpression
+  | OPAR lhs=expression MOD rhs=expression CPAR #moduloExpression
+  | SUB expression #negateExpression
   | functionCall #functionCallExpression
   ;
 
+atom
+  : INTEGER_LITERAL #intAtom
+  | IDENT # variable
+  ;
+
 functionCall
   : IDENT OPAR arguments CPAR
   ;
@@ -60,11 +67,6 @@ arguments
   : (expression (COMMA expression)*)?
   ;
 
-atom
-  : INTEGER_LITERAL #intAtom
-  | IDENT # variable
-  ;
-
 PRINT: 'print';
 IF: 'if';
 ELSE: 'else';
@@ -79,10 +81,11 @@ CPAR: ')';
 COMMA: ',';
 EQUAL: '=';
 
-MULT: '*';
+MUL: '*';
 ADD: '+';
 SUB: '-';
 MOD: '%';
+DIV: '/';
 
 INTEGER_LITERAL
   : [0-9]+

src/main/java/de/hsrm/compiler/Klang/ContextAnalysis.java

@@ -66,38 +66,33 @@ public class ContextAnalysis extends KlangBaseVisitor<Node> {
   }
 
   @Override
-  public Node visitMultiplicationExpression(KlangParser.MultiplicationExpressionContext ctx) {
-    Node left = this.visit(ctx.atom(0));
-    Node right = this.visit(ctx.atom(1));
-    Node result = new MultiplicativeExpression((Expression) left, (Expression) right);
-    result.type = left.type; // We have to actually compute this in the future
-    return result;
+  public Node visitAdditionExpression(KlangParser.AdditionExpressionContext ctx) {
+    return new AdditionExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
   }
 
   @Override
-  public Node visitAdditiveExpression(KlangParser.AdditiveExpressionContext ctx) {
-    Node left = this.visit(ctx.atom(0));
-    Node right = this.visit(ctx.atom(1));
-    Node result = new AdditiveExpression((Expression) left, (Expression) right);
-    result.type = left.type; // We have to actually compute this in the future
-    return result;
+  public Node visitSubstractionExpression(KlangParser.SubstractionExpressionContext ctx) {
+    return new SubstractionExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+  }
+
+  @Override
+  public Node visitMultiplicationExpression(KlangParser.MultiplicationExpressionContext ctx) {
+    return new MultiplicationExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
+  }
+
+  @Override
+  public Node visitDivisionExpression(KlangParser.DivisionExpressionContext ctx) {
+    return new DivisionExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
   }
 
   @Override
   public Node visitModuloExpression(KlangParser.ModuloExpressionContext ctx) {
-    Node left = this.visit(ctx.atom(0));
-    Node right = this.visit(ctx.atom(1));
-    Node result = new ModuloExpression((Expression) left, (Expression) right);
-    result.type = left.type; // We have to actually compute this in the future
-    return result;
+    return new ModuloExpression((Expression) this.visit(ctx.lhs), (Expression) this.visit(ctx.rhs));
   }
 
   @Override
-  public Node visitUnaryNegateExpression(KlangParser.UnaryNegateExpressionContext ctx) {
-    Node atom = this.visit(ctx.atom());
-    Node result = new NegateExpression((Expression) atom);
-    result.type = atom.type;
-    return result;
+  public Node visitNegateExpression(KlangParser.NegateExpressionContext ctx) {
+    return new NegateExpression((Expression) this.visit(ctx.expression()));
   }
 
   @Override

src/main/java/de/hsrm/compiler/Klang/JSVisitor.java

@@ -1,71 +0,0 @@
-package de.hsrm.compiler.Klang;
-
-public class JSVisitor extends KlangBaseVisitor<Void> {
-  private final StringBuilder sb;
-
-  public JSVisitor(StringBuilder sb) {
-    this.sb = sb;
-  }
-
-  @Override
-  public Void visitStatement(KlangParser.StatementContext ctx) {
-    for (int i = 0; i < ctx.children.size(); i++) {
-      this.visit(ctx.children.get(i));
-      sb.append("\n");
-    }
-    return null;
-  }
-
-  @Override
-  public Void visitPrint(KlangParser.PrintContext ctx) {
-    sb.append("console.log(");
-    this.visit(ctx.expression());
-    sb.append(");");
-    return null;
-  }
-
-  @Override
-  public Void visitMultiplicationExpression(KlangParser.MultiplicationExpressionContext ctx) {
-    this.visit(ctx.atom(0));
-    sb.append(" * ");
-    this.visit(ctx.atom(1));
-    return null;
-  }
-
-  @Override
-  public Void visitAdditiveExpression(KlangParser.AdditiveExpressionContext ctx) {
-    this.visit(ctx.atom(0));
-
-    switch (ctx.op.getType()) {
-    case KlangParser.ADD:
-      sb.append(" + ");
-      break;
-    case KlangParser.SUB:
-      sb.append(" - ");
-      break;
-    }
-    this.visit(ctx.atom(1));
-    return null;
-  }
-
-  @Override
-  public Void visitModuloExpression(KlangParser.ModuloExpressionContext ctx) {
-    this.visit(ctx.atom(0));
-    sb.append(" % ");
-    this.visit(ctx.atom(1));
-    return null;
-  }
-
-  @Override
-  public Void visitUnaryNegateExpression(KlangParser.UnaryNegateExpressionContext ctx) {
-    sb.append("-");
-    this.visit(ctx.atom());
-    return null;
-  }
-
-  @Override
-  public Void visitIntAtom(KlangParser.IntAtomContext ctx) {
-    sb.append(ctx.getText());
-    return null;
-  }
-}

src/main/java/de/hsrm/compiler/Klang/nodes/expressions/AdditionExpression.java

@@ -2,9 +2,8 @@ package de.hsrm.compiler.Klang.nodes.expressions;
 
 import de.hsrm.compiler.Klang.visitors.Visitor;
 
-public class AdditiveExpression extends BinaryExpression {
-
-    public AdditiveExpression(Expression lhs, Expression rhs) {
+public class AdditionExpression extends BinaryExpression {
+    public AdditionExpression(Expression lhs, Expression rhs) {
         super(lhs, rhs);
     }
 
@@ -12,5 +11,4 @@ public class AdditiveExpression extends BinaryExpression {
     public <R> R welcome(Visitor<R> v) {
         return v.visit(this);
     }
-
 }

src/main/java/de/hsrm/compiler/Klang/nodes/expressions/BinaryExpression.java

@@ -1,7 +1,6 @@
 package de.hsrm.compiler.Klang.nodes.expressions;
 
 public abstract class BinaryExpression extends Expression {
-
     public Expression lhs;
     public Expression rhs;
 

src/main/java/de/hsrm/compiler/Klang/nodes/expressions/DivisionExpression.java

@@ -0,0 +1,14 @@
+package de.hsrm.compiler.Klang.nodes.expressions;
+
+import de.hsrm.compiler.Klang.visitors.Visitor;
+
+public class DivisionExpression extends BinaryExpression {
+    public DivisionExpression(Expression lhs, Expression rhs) {
+        super(lhs, rhs);
+    }
+
+    @Override
+    public <R> R welcome(Visitor<R> v) {
+        return v.visit(this);
+    }
+}

src/main/java/de/hsrm/compiler/Klang/nodes/expressions/ModuloExpression.java

@@ -3,7 +3,6 @@ package de.hsrm.compiler.Klang.nodes.expressions;
 import de.hsrm.compiler.Klang.visitors.Visitor;
 
 public class ModuloExpression extends BinaryExpression {
-
     public ModuloExpression(Expression lhs, Expression rhs) {
         super(lhs, rhs);
     }
@@ -12,5 +11,4 @@ public class ModuloExpression extends BinaryExpression {
     public <R> R welcome(Visitor<R> v) {
         return v.visit(this);
     }
-
 }

src/main/java/de/hsrm/compiler/Klang/nodes/expressions/MultiplicationExpression.java

@@ -1,9 +1,9 @@
 package de.hsrm.compiler.Klang.nodes.expressions;
 
-import de.hsrm.compiler.Klang.visitors.Visitor;;
+import de.hsrm.compiler.Klang.visitors.Visitor;
 
-public class MultiplicativeExpression extends BinaryExpression {
-    public MultiplicativeExpression(Expression lhs, Expression rhs) {
+public class MultiplicationExpression extends BinaryExpression {
+    public MultiplicationExpression(Expression lhs, Expression rhs) {
         super(lhs, rhs);
     }
 

src/main/java/de/hsrm/compiler/Klang/nodes/expressions/SubstractionExpression.java

@@ -0,0 +1,14 @@
+package de.hsrm.compiler.Klang.nodes.expressions;
+
+import de.hsrm.compiler.Klang.visitors.Visitor;
+
+public class SubstractionExpression extends BinaryExpression {
+    public SubstractionExpression(Expression lhs, Expression rhs) {
+        super(lhs, rhs);
+    }
+
+    @Override
+    public <R> R welcome(Visitor<R> v) {
+        return v.visit(this);
+    }
+}

src/main/java/de/hsrm/compiler/Klang/visitors/EvalVisitor.java

@@ -21,24 +21,38 @@ public class EvalVisitor implements Visitor<Value> {
   }
 
   @Override
-  public Value visit(MultiplicativeExpression e) {
-    Value a = e.lhs.welcome(this);
-    Value b = e.rhs.welcome(this);
-    return new Value(a.asInteger() * b.asInteger());
+  public Value visit(AdditionExpression e) {
+    Value lhs = e.lhs.welcome(this);
+    Value rhs = e.rhs.welcome(this);
+    return new Value(lhs.asInteger() + rhs.asInteger());
   }
 
   @Override
-  public Value visit(AdditiveExpression e) {
-    Value a = e.lhs.welcome(this);
-    Value b = e.rhs.welcome(this);
-    return new Value(a.asInteger() + b.asInteger());
+  public Value visit(SubstractionExpression e) {
+    Value lhs = e.lhs.welcome(this);
+    Value rhs = e.rhs.welcome(this);
+    return new Value(lhs.asInteger() - rhs.asInteger());
+  }
+
+  @Override
+  public Value visit(MultiplicationExpression e) {
+    Value lhs = e.lhs.welcome(this);
+    Value rhs = e.rhs.welcome(this);
+    return new Value(lhs.asInteger() * rhs.asInteger());
+  }
+
+  @Override
+  public Value visit(DivisionExpression e) {
+    Value lhs = e.lhs.welcome(this);
+    Value rhs = e.rhs.welcome(this);
+    return new Value(lhs.asInteger() / rhs.asInteger());
   }
 
   @Override
   public Value visit(ModuloExpression e) {
-    Value a = e.lhs.welcome(this);
-    Value b = e.rhs.welcome(this);
-    return new Value(a.asInteger() % b.asInteger());
+    Value lhs = e.lhs.welcome(this);
+    Value rhs = e.rhs.welcome(this);
+    return new Value(lhs.asInteger() % rhs.asInteger());
   }
 
   @Override

src/main/java/de/hsrm/compiler/Klang/visitors/GenASM.java

@@ -6,20 +6,9 @@ import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
 
-import de.hsrm.compiler.Klang.nodes.Block;
-import de.hsrm.compiler.Klang.nodes.FunctionDefinition;
-import de.hsrm.compiler.Klang.nodes.Program;
-import de.hsrm.compiler.Klang.nodes.expressions.AdditiveExpression;
-import de.hsrm.compiler.Klang.nodes.expressions.FunctionCall;
-import de.hsrm.compiler.Klang.nodes.expressions.IntegerExpression;
-import de.hsrm.compiler.Klang.nodes.expressions.ModuloExpression;
-import de.hsrm.compiler.Klang.nodes.expressions.MultiplicativeExpression;
-import de.hsrm.compiler.Klang.nodes.expressions.NegateExpression;
-import de.hsrm.compiler.Klang.nodes.expressions.Variable;
-import de.hsrm.compiler.Klang.nodes.statements.IfStatement;
-import de.hsrm.compiler.Klang.nodes.statements.PrintStatement;
-import de.hsrm.compiler.Klang.nodes.statements.ReturnStatement;
-import de.hsrm.compiler.Klang.nodes.statements.VariableAssignment;
+import de.hsrm.compiler.Klang.nodes.*;
+import de.hsrm.compiler.Klang.nodes.expressions.*;
+import de.hsrm.compiler.Klang.nodes.statements.*;
 
 public class GenASM implements Visitor<Void> {
 
@@ -86,20 +75,56 @@ public class GenASM implements Visitor<Void> {
   }
 
   @Override
-    public Void visit(MultiplicativeExpression e) {
+  public Void visit(AdditionExpression e) {
     e.lhs.welcome(this);
-        this.ex.write("    movq  %rax, %rbx\n");
+    this.ex.write("    pushq %rax\n");
     e.rhs.welcome(this);
+    this.ex.write("    popq %rbx\n");
+    this.ex.write("    addq %rbx, %rax\n");
+    return null;
+  }
+
+  @Override
+  public Void visit(SubstractionExpression e) {
+    e.lhs.welcome(this);
+    this.ex.write("    pushq %rax\n");
+    e.rhs.welcome(this);
+    this.ex.write("    popq %rbx\n");
+    this.ex.write("    subq %rbx, %rax\n");
+    return null;
+  }
+
+  @Override
+  public Void visit(MultiplicationExpression e) {
+    e.lhs.welcome(this);
+    this.ex.write("    pushq %rax\n");
+    e.rhs.welcome(this);
+    this.ex.write("    popq %rbx\n");
     this.ex.write("    imulq %rbx, %rax\n");
     return null;
   }
 
   @Override
-    public Void visit(AdditiveExpression e) {
+  public Void visit(DivisionExpression e) {
     e.lhs.welcome(this);
-        this.ex.write("    movq  %rax, %rbx\n");
+    this.ex.write("    pushq %rax\n");
     e.rhs.welcome(this);
-        this.ex.write("    addq %rbx, %rax\n");
+    this.ex.write("    movq %rax, %rbx\n");
+    this.ex.write("    popq %rax\n");
+    this.ex.write("    xor %rdx, %rdx\n"); // clear upper part of division
+    this.ex.write("    idiv %rbx\n"); // %rax/%rbx, quotient now in %rax
+    return null;
+  }
+
+  @Override
+  public Void visit(ModuloExpression e) {
+    this.ex.write("    pushq %rax\n");
+    e.rhs.welcome(this);
+    this.ex.write("    movq %rax, %rbx\n");
+    this.ex.write("    popq %rax\n");
+    this.ex.write("    xor %rdx, %rdx\n"); // clear upper part of division
+    this.ex.write("    idiv %rbx\n"); // %rax/%rbx, remainder now in %rdx
+    this.ex.write("    movq %rdx, %rax\n");
     return null;
   }
 
@@ -110,17 +135,6 @@ public class GenASM implements Visitor<Void> {
     return null;
   }
 
-    @Override
-    public Void visit(ModuloExpression e) {
-        e.rhs.welcome(this);
-        this.ex.write("    movq %rax, %rbx\n");
-        e.lhs.welcome(this);
-        this.ex.write("    xor %rdx, %rdx\n"); // clear remainder register
-        this.ex.write("    idiv %ebx\n"); // %rax/%rbx, remainder now in %rdx
-        this.ex.write("    movq %rdx, %rax\n");
-        return null;
-    }
-
   @Override
   public Void visit(IfStatement e) {
     int then = ++lCount;

src/main/java/de/hsrm/compiler/Klang/visitors/GetVars.java

@@ -2,20 +2,9 @@ package de.hsrm.compiler.Klang.visitors;
 
 import java.util.Set;
 
-import de.hsrm.compiler.Klang.nodes.Block;
-import de.hsrm.compiler.Klang.nodes.FunctionDefinition;
-import de.hsrm.compiler.Klang.nodes.Program;
-import de.hsrm.compiler.Klang.nodes.expressions.AdditiveExpression;
-import de.hsrm.compiler.Klang.nodes.expressions.FunctionCall;
-import de.hsrm.compiler.Klang.nodes.expressions.IntegerExpression;
-import de.hsrm.compiler.Klang.nodes.expressions.ModuloExpression;
-import de.hsrm.compiler.Klang.nodes.expressions.MultiplicativeExpression;
-import de.hsrm.compiler.Klang.nodes.expressions.NegateExpression;
-import de.hsrm.compiler.Klang.nodes.expressions.Variable;
-import de.hsrm.compiler.Klang.nodes.statements.IfStatement;
-import de.hsrm.compiler.Klang.nodes.statements.PrintStatement;
-import de.hsrm.compiler.Klang.nodes.statements.ReturnStatement;
-import de.hsrm.compiler.Klang.nodes.statements.VariableAssignment;
+import de.hsrm.compiler.Klang.nodes.*;
+import de.hsrm.compiler.Klang.nodes.expressions.*;
+import de.hsrm.compiler.Klang.nodes.statements.*;
 
 class GetVars implements Visitor<Void> {
 
@@ -36,14 +25,35 @@ class GetVars implements Visitor<Void> {
   }
 
   @Override
-  public Void visit(MultiplicativeExpression e) {
+  public Void visit(AdditionExpression e) {
     e.lhs.welcome(this);
     e.rhs.welcome(this);
     return null;
   }
 
   @Override
-  public Void visit(AdditiveExpression e) {
+  public Void visit(SubstractionExpression e) {
+    e.lhs.welcome(this);
+    e.rhs.welcome(this);
+    return null;
+  }
+
+  @Override
+  public Void visit(MultiplicationExpression e) {
+    e.lhs.welcome(this);
+    e.rhs.welcome(this);
+    return null;
+  }
+
+  @Override
+  public Void visit(DivisionExpression e) {
+    e.lhs.welcome(this);
+    e.rhs.welcome(this);
+    return null;
+  }
+
+  @Override
+  public Void visit(ModuloExpression e) {
     e.lhs.welcome(this);
     e.rhs.welcome(this);
     return null;
@@ -55,13 +65,6 @@ class GetVars implements Visitor<Void> {
     return null;
   }
 
-  @Override
-  public Void visit(ModuloExpression e) {
-    e.lhs.welcome(this);
-    e.rhs.welcome(this);
-    return null;
-  }
-
   @Override
   public Void visit(IfStatement e) {
     e.cond.welcome(this);

src/main/java/de/hsrm/compiler/Klang/visitors/PrettyPrintVisitor.java

@@ -72,33 +72,60 @@ public class PrettyPrintVisitor implements Visitor<Void> {
     }
 
     @Override
-    public Void visit(MultiplicativeExpression e) {
-        e.lhs.welcome(this);
-        ex.write(" * ");
-        e.rhs.welcome(this);
-        return null;
-    }
-
-    @Override
-    public Void visit(AdditiveExpression e) {
+    public Void visit(AdditionExpression e) {
+        ex.write("(");
         e.lhs.welcome(this);
         ex.write(" + ");
         e.rhs.welcome(this);
+        ex.write(")");
         return null;
     }
 
     @Override
-    public Void visit(NegateExpression e) {
-        ex.write(" - ");
+    public Void visit(SubstractionExpression e) {
+        ex.write("(");
         e.lhs.welcome(this);
+        ex.write(" - ");
+        e.rhs.welcome(this);
+        ex.write(")");
+        return null;
+    }
+
+    @Override
+    public Void visit(MultiplicationExpression e) {
+        ex.write("(");
+        e.lhs.welcome(this);
+        ex.write(" * ");
+        e.rhs.welcome(this);
+        ex.write(")");
+        return null;
+    }
+
+    @Override
+    public Void visit(DivisionExpression e) {
+        ex.write("(");
+        e.lhs.welcome(this);
+        ex.write(" / ");
+        e.rhs.welcome(this);
+        ex.write(")");
         return null;
     }
 
     @Override
     public Void visit(ModuloExpression e) {
+        ex.write("(");
         e.lhs.welcome(this);
         ex.write(" % ");
         e.rhs.welcome(this);
+        ex.write(")");
+        return null;
+    }
+
+
+    @Override
+    public Void visit(NegateExpression e) {
+        ex.write(" - ");
+        e.lhs.welcome(this);
         return null;
     }
 

src/main/java/de/hsrm/compiler/Klang/visitors/Visitor.java

@@ -9,10 +9,12 @@ import de.hsrm.compiler.Klang.nodes.statements.*;
 public interface Visitor<R> {
     R visit(IntegerExpression e);
     R visit(Variable e);
-    R visit(MultiplicativeExpression e);
-    R visit(AdditiveExpression e);
-    R visit(NegateExpression e);
+    R visit(AdditionExpression e);
+    R visit(SubstractionExpression e);
+    R visit(MultiplicationExpression e);
+    R visit(DivisionExpression e);
     R visit(ModuloExpression e);
+    R visit(NegateExpression e);
     R visit(IfStatement e);
     R visit(PrintStatement e);
     R visit(VariableAssignment e);