Rewrote grammar, implemented two visitors

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

@@ -0,0 +1,71 @@
+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/Klang.java

@@ -19,8 +19,9 @@ public class Klang {
     KlangParser parser = new KlangParser(tokens);
 
     ParseTree tree = parser.parse(); // begin parsing at init rule
-    Visitor visitor = new Visitor();
-    int result = visitor.visit(tree);
-    System.out.println(result);
+    StringBuilder sb = new StringBuilder();
+    JSVisitor visitor = new JSVisitor(sb);
+    visitor.visit(tree);
+    System.out.println(sb.toString());
   }
 }

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

@@ -0,0 +1,55 @@
+package de.hsrm.compiler.Klang;
+
+public class Value {
+
+  public static Value VOID = new Value(new Object());
+
+  final Object value;
+
+  public Value(Object value) {
+      this.value = value;
+  }
+
+  public Integer asInteger() {
+    return (Integer)value;
+  }
+
+  public String asString() {
+      return String.valueOf(value);
+  }
+
+  public boolean isDouble() {
+      return value instanceof Double;
+  }
+
+  @Override
+  public int hashCode() {
+
+      if(value == null) {
+          return 0;
+      }
+
+      return this.value.hashCode();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+
+      if(value == o) {
+          return true;
+      }
+
+      if(value == null || o == null || o.getClass() != value.getClass()) {
+          return false;
+      }
+
+      Value that = (Value)o;
+
+      return this.value.equals(that.value);
+  }
+
+  @Override
+  public String toString() {
+      return String.valueOf(value);
+  }
+}

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

@@ -1,19 +1,51 @@
 package de.hsrm.compiler.Klang;
 
-public class Visitor extends KlangBaseVisitor<Integer> {
-    @Override
-    public Integer visitMultiplicativeExpr(KlangParser.MultiplicativeExprContext ctx) {
-        int result = 1;
-        
-        for (var expr: ctx.unaryExpression()) {
-            result *= this.visit(expr);
-        }
-        
-        return result;
-    }
-    
-    @Override
-    public Integer visitUnaryExpression(KlangParser.UnaryExpressionContext ctx) {
-        return Integer.parseInt(ctx.getText());
+public class Visitor extends KlangBaseVisitor<Value> {
+
+  @Override
+  public Value visitPrint(KlangParser.PrintContext ctx) {
+    Value value = this.visit(ctx.expression());
+    System.out.println(value);
+    return value;
+  }
+
+  @Override
+  public Value visitMultiplicationExpression(KlangParser.MultiplicationExpressionContext ctx) {
+    Value left = this.visit(ctx.atom(0));
+    Value right = this.visit(ctx.atom(1));
+    return new Value(left.asInteger() * right.asInteger());
+  }
+
+  @Override
+  public Value visitAdditiveExpression(KlangParser.AdditiveExpressionContext ctx) {
+    Value left = this.visit(ctx.atom(0));
+    Value right = this.visit(ctx.atom(1));
+
+    switch (ctx.op.getType()) {
+    case KlangParser.ADD:
+      return new Value(left.asInteger() + right.asInteger());
+    case KlangParser.SUB:
+      return new Value(left.asInteger() - right.asInteger());
+    default:
+      throw new RuntimeException("Unknown operator for additive expression: "+ KlangParser.VOCABULARY.getDisplayName(ctx.op.getType()));
     }
+  }
+
+  @Override
+  public Value visitModuloExpression(KlangParser.ModuloExpressionContext ctx) {
+    Value left = this.visit(ctx.atom(0));
+    Value right = this.visit(ctx.atom(1));
+    return new Value(left.asInteger() % right.asInteger());
+  }
+
+  @Override
+  public Value visitUnaryNegateExpression(KlangParser.UnaryNegateExpressionContext ctx) {
+    Value value = this.visit(ctx.atom());
+    return new Value(-value.asInteger());
+  }
+
+  @Override
+  public Value visitIntAtom(KlangParser.IntAtomContext ctx) {
+    return new Value(Integer.parseInt(ctx.getText()));
+  }
 }