Added a ton of new tests and hopefully fixed a bit of the egregious error checks.

Author: Joshua Crotts

src/main/java/edu/joshuacrotts/littlec/exec/Launcher.java

@@ -16,6 +16,8 @@ public static void usage() {
     System.out.print("where [optinfile] is a .lc file or standard input (leave blank)\n\n");
     System.out.print("where \"flags\" is zero or more of the following:\n");
     System.out.print("   -o enables optimizations (in progress)\n");
+    System.out.print("   -w enables warnings (displayed even if none exist) (in progress)\n");
+    System.out.print("   -e enables errors (displayed even if none exist) (in progress)\n");
     System.out.print("   -d enables comments in assembly code generation (in progress)\n\n");
     System.out.print("where \"mode\" is one of the following:\n");
     System.out.print("   -lt runs LexerTest\n");

src/main/java/edu/joshuacrotts/littlec/icinterp/ICInterp.java

@@ -494,9 +494,9 @@ else if (parts[si + 1].equals("=="))
           else if (parts[si + 1].equals("!="))
             return new SimValue(4, (val1.iVal != val2.iVal) ? 1 : 0);
           else if (parts[si + 1].equals("<>"))
-            return new SimValue(4, (~(val1.iVal ^ val2.iVal) > 0) ? 1 : 0);
+            return new SimValue(4, (val1.iVal == val2.iVal) ? 1 : 0);
           else if (parts[si + 1].equals("->"))
-            return new SimValue(4, ((~val1.iVal | val2.iVal) > 0) ? 1 : 0);
+            return new SimValue(4, (!(val1.iVal !=0) || (val2.iVal!=0)) ? 1 : 0);
           else if (parts[si + 1].equals("ldidx4")) {
             return new SimValue(4, ptrGetInt(val1.iVal, 4 + 4 * val2.iVal));
           } else if (parts[si + 1].equals("ldidx1")) {

src/main/java/edu/joshuacrotts/littlec/main/LCErrorListener.java

@@ -141,7 +141,7 @@ public static boolean sawError() {
    * @return true if a warning was seen.
    */
   public static boolean sawWarning() {
-    return gotError;
+    return gotWarning;
   }
 
   /**

src/main/java/edu/joshuacrotts/littlec/main/LCListener.java

@@ -145,6 +145,8 @@ public void enterIfStatement(LittleCParser.IfStatementContext ctx) {
    */
   @Override
   public void exitIfStatement(LittleCParser.IfStatementContext ctx) {
+    if (LCErrorListener.sawError())
+      return;
     LCSyntaxTree condPortion = this.values.get(ctx.ruleIfStatementCond());
     LCSyntaxTree thenPortion = this.syntaxTree.getChildren().remove(this.syntaxTree.getChildren().size() - 1);
     LCSyntaxTree elsePortion = this.values.get(ctx.ruleElseStatement());
@@ -189,7 +191,7 @@ public void exitElseStatement(LittleCParser.ElseStatementContext ctx) {
     if (this.syntaxTree.getChildren().isEmpty()) {
       return;
     }
-    
+
     LCSyntaxTree lastChild = this.syntaxTree.getChildren().remove(this.syntaxTree.getChildren().size() - 1);
     this.values.put(ctx, lastChild);
   }
@@ -218,7 +220,6 @@ public void exitWhileStatement(LittleCParser.WhileStatementContext ctx) {
     // we can just remove it from the main tree and add it to the cond tree.
     LCSyntaxTree loopBody = this.syntaxTree.getChildren().remove(this.syntaxTree.getChildren().size() - 1);
     LCSyntaxTree condPortion = this.values.get(ctx.ruleWhileStatementCond());
-
     this.syntaxTree.addChild(new LCLoopStatementNode(ctx, condPortion, loopBody));
 
     // Turn off the flag for being in a loop.
@@ -592,6 +593,10 @@ public void enterReturnStatement(LittleCParser.ReturnStatementContext ctx) {
    */
   @Override
   public void exitReturnStatement(LittleCParser.ReturnStatementContext ctx) {
+    if (LCErrorListener.sawError()) {
+      return;
+    }
+
     LCSyntaxTree retExpr = this.values.get(ctx.expr());
     String fnRetType = "";
 
@@ -844,6 +849,7 @@ public void exitExprPreOp(LittleCParser.ExprPreOpContext ctx) {
    */
   @Override
   public void exitExprPostOp(LittleCParser.ExprPostOpContext ctx) {
+    if (LCErrorListener.sawError()) return;
     // First check if the symbol exists.
     String id = ctx.ID().getText();
     String idType = this.symbolTable.getSymbolEntry(id).getVarType();
@@ -1033,8 +1039,11 @@ public void exitExprParen(LittleCParser.ExprParenContext ctx) {
    */
   @Override
   public void exitExprArray(LittleCParser.ExprArrayContext ctx) {
-    String id = ctx.ID().getText();
+    if (LCErrorListener.sawError()) {
+      return;
+    }
 
+    String id = ctx.ID().getText();
     if (!this.symbolTable.hasSymbol(id)) {
       LCErrorListener.syntaxError(ctx, "array object was not previously declared.");
       return;
@@ -1236,6 +1245,10 @@ public void exitStringRefDeclaration(LittleCParser.StringRefDeclarationContext c
    * @return a syntax tree, or null if an error was detected.
    */
   public LCSyntaxTree getSyntaxTree() {
+    if (LCErrorListener.sawWarning()) {
+      LCErrorListener.printWarnings();
+    }
+
     if (LCErrorListener.sawError()) {
       LCErrorListener.printErrors();
       return null;

src/main/java/edu/joshuacrotts/littlec/mipsgen/CodeGeneration.java

@@ -575,12 +575,20 @@ public static String emitBinaryOp(ProgState progState, ICAddress res, ICAddress
     progState.copyVal(op2Reg, op2);
 
     // Perform the binary op (power op uses different code).
-    if (!op.equals("**")) 
-      sb.append(MIPSInstruction.genBinaryOp(getMIPSBinaryOp(op), "" + resReg, "" + op1Reg, "" + op2Reg));
-    else {
+    if (op.equals("**")){
       MIPSReg op3Reg = progState.getNextAvailableRegister();
       sb.append(MIPSInstruction.genPowerBinaryOp("" + resReg, "" + op1Reg, "" + op2Reg, "" + op3Reg));
       progState.invalidate(op3Reg);
+    } else if (op.equals("<>")) {
+      MIPSReg op3Reg = progState.getNextAvailableRegister();
+      sb.append(MIPSInstruction.genBiconditionalBinaryOp("" + resReg, "" + op1Reg, "" + op2Reg, "" + op3Reg));
+      progState.invalidate(op3Reg);
+    } else if (op.equals("->")) {
+      MIPSReg op3Reg = progState.getNextAvailableRegister();
+      sb.append(MIPSInstruction.genImplicationBinaryOp("" + resReg, "" + op1Reg, "" + op2Reg, "" + op3Reg));
+      progState.invalidate(op3Reg);
+    } else {
+      sb.append(MIPSInstruction.genBinaryOp(getMIPSBinaryOp(op), "" + resReg, "" + op1Reg, "" + op2Reg));
     }
 
     // Store the result if we loaded in a new temporary for the destination.
@@ -859,6 +867,10 @@ private static String getMIPSBinaryOp(String op) {
       return "sll";
     case ">>":
       return "sra";
+    case "<<<":
+      return "rol";
+    case ">>>":
+      return "ror";
     case "^":
       return "xor";
     default:
@@ -881,6 +893,8 @@ private static String getMIPSUnaryOp(String op) {
       return "move";
     case "~":
       return "not";
+    case "@":
+      return "abs";
     case "-":
     case "!":
       return "negu";

src/main/java/edu/joshuacrotts/littlec/mipsgen/MIPSInstruction.java

@@ -186,6 +186,38 @@ protected static String genPowerBinaryOp(String dest, String op1, String op2, St
     sb.append(cl2 + ":\n");
     return sb.toString();
   }
+  
+  /**
+   * 
+   * @param dest
+   * @param op1
+   * @param op2
+   * @param tmpOp3
+   * @return
+   */
+  protected static String genImplicationBinaryOp(String dest, String op1, String op2, String tmpOp3) {
+    StringBuilder sb = new StringBuilder();
+    sb.append(MIPSInstruction.genUnaryOp("not", tmpOp3, op1));
+    sb.append(MIPSInstruction.genBinaryOp("addi", tmpOp3, tmpOp3, "2"));
+    sb.append(MIPSInstruction.genBinaryOp("or", dest, tmpOp3, op2));
+    return sb.toString();
+  }
+  
+  /**
+   * 
+   * @param dest
+   * @param op1
+   * @param op2
+   * @param tmpOp3
+   * @return
+   */
+  protected static String genBiconditionalBinaryOp(String dest, String op1, String op2, String tmpOp3) {
+    StringBuilder sb = new StringBuilder();
+    sb.append(MIPSInstruction.genBinaryOp("xor", tmpOp3, op1, op2));
+    sb.append(MIPSInstruction.genUnaryOp("not", dest, tmpOp3));
+    sb.append(MIPSInstruction.genBinaryOp("addi", dest, dest, "2"));
+    return sb.toString();
+  }
 
   /**
    * Generates a binary operator in MIPS.

src/main/java/edu/joshuacrotts/littlec/syntaxtree/LCBinaryOperatorNode.java

@@ -10,7 +10,9 @@
 
 public class LCBinaryOperatorNode extends LCSyntaxTree {
 
-  /** Binary operator that we're using. */
+  /** 
+   * Binary operator that we're using. 
+   */
   private String op;
 
   /**

src/main/java/edu/joshuacrotts/littlec/syntaxtree/LCFunctionArgsListNode.java

@@ -7,7 +7,9 @@
 
 public class LCFunctionArgsListNode extends LCSyntaxTree {
 
-  /** List of LCSyntaxTree arguments. */
+  /** 
+   * List of LCSyntaxTree arguments. 
+   */
   private List<LCSyntaxTree> args;
 
   /**

src/main/java/edu/joshuacrotts/littlec/syntaxtree/LCFunctionCallNode.java

@@ -12,7 +12,9 @@
 
 public class LCFunctionCallNode extends LCSyntaxTree {
 
-  /* Identifier of function. */
+  /**
+   * Identifier of function. 
+   */
   private String id;
 
   /**

src/main/java/edu/joshuacrotts/littlec/syntaxtree/LCIfStatementNode.java

@@ -5,6 +5,7 @@
 import edu.joshuacrotts.littlec.icode.ActivationRecord;
 import edu.joshuacrotts.littlec.icode.ICInhAttr;
 import edu.joshuacrotts.littlec.icode.ICode;
+import edu.joshuacrotts.littlec.main.LCErrorListener;
 
 public class LCIfStatementNode extends LCSyntaxTree {
 
@@ -28,14 +29,15 @@ public class LCIfStatementNode extends LCSyntaxTree {
   public LCIfStatementNode(ParserRuleContext ctx, LCSyntaxTree ifPart, LCSyntaxTree thenPart, LCSyntaxTree elsePart) {
     super("IF", "void");// No third parameter.
 
-    /* Two or three children. */
-    /* Child 1 is the conditions. */
+    // Child 1 is the conditions.
     super.addChild(ifPart);
 
-    /* Child 2 is the "then" portion of the condition. */
+    this.testConditional(ctx, ifPart);
+
+    // Child 2 is the "then" portion of the condition.
     super.addChild(thenPart);
 
-    /* Child 3 is the "else" part. */
+    // Child 3 is the "else" part.
     if (elsePart != null) {
       super.addChild(elsePart);
     }
@@ -80,7 +82,18 @@ public void genCode(ICInhAttr s) {
       this.getChildren().get(2).genCode(s2);
     }
     ICode.quad.addLabel(b.NEXT + ":");
-
+  }
+  
+  /**
+   * Since using terms, literals, or array indexing may not evaluate correctly (to be honest,
+   * it DOESN'T evalutate correctly, we can display a warning if the user attempts to. 
+   */
+  private void testConditional(ParserRuleContext ctx, LCSyntaxTree cond) {
+    if (cond instanceof LCVariableIdentifierNode || cond instanceof LCConstantLiteralNode
+        || cond instanceof LCArrayIndexNode) {
+      LCErrorListener.syntaxWarning(ctx,
+          "using only an identifier or literal in the condition may not evaluate correctly.");
+    }
   }
 
   @Override

src/main/java/edu/joshuacrotts/littlec/syntaxtree/LCLoopStatementNode.java

@@ -57,6 +57,7 @@ public void genCode(ICInhAttr s) {
 
     // ...then the conditional.
     this.getChildren().get(0).genCode(b);
+    
     // The label to go to if it's true.
     ICode.quad.addLabel(b.TRUE + ":");
     this.getChildren().get(1).genCode(s);

src/main/java/edu/joshuacrotts/littlec/syntaxtree/LCPrePostOperatorNode.java

@@ -27,7 +27,7 @@ public LCPrePostOperatorNode(ParserRuleContext ctx, SymbolTable symbolTable, Str
       LCSyntaxTree lvar) {
     super(type, lvarType);
 
-    /* One child for the lvalue being incremented or decremented. */
+    // One child for the lvalue being incremented or decremented.
     super.addChild(lvar);
   }
 

src/main/java/edu/joshuacrotts/littlec/syntaxtree/LCReturnStatementNode.java

@@ -41,14 +41,12 @@ public void genCode(ICInhAttr info) {
     String returnStr = "return";
 
     // If there is a return expression, then we have to append a data width to it.
-    // Otherwise,
     if (!this.getChildren().isEmpty()) {
       this.getChildren().get(0).genCode(info);
       int retWidth = LCUtilities.getDataWidth(this.getChildren().get(0).getType());
       returnStr += retWidth;
     }
 
-    // addLine(resAddr, op1, op2, op), "return" is the op, return val is op1.
     ICode.quad.addLine("", (!this.getChildren().isEmpty() ? info.ADDR : ""), "", returnStr);
   }
 

src/main/java/edu/joshuacrotts/littlec/syntaxtree/LCVariableDeclarationNode.java

@@ -11,13 +11,19 @@
 
 public class LCVariableDeclarationNode extends LCSyntaxTree {
 
-  /** Name of the variable for later reference. */
+  /** 
+   * Name of the variable for later reference. 
+   */
   private String id;
 
-  /** Type of variable that we're declaring. */
+  /** 
+   * Type of variable that we're declaring. 
+   */
   private String varType;
 
-  /** The literal value that we're assigning. Null if no lit. */
+  /** 
+   * The literal value that we're assigning. Null if no lit. 
+   */
   private Object literalValue;
 
   /**
@@ -38,7 +44,6 @@ public LCVariableDeclarationNode(ParserRuleContext ctx, SymbolTable symbolTable,
     this.id = id;
     this.varType = varType;
     this.literalValue = literalValue;
-
     // If we don't have the symbol in the current environment table (which defines
     // the current scope, then we're good to add it (we can shadow it). 
     if (!symbolTable.hasSymbolInCurrentEnvironment(this.id)) {
@@ -111,7 +116,7 @@ public void genCode(ICInhAttr info) {
         info.ADDR = lLabel;
       }
     }
-    /* Otherwise, we insert the value as normal. */
+    // Otherwise, we insert the value as normal.
     else {
       int dataWidth = LCUtilities.getDataWidth(this.varType);
       String lit = this.literalValue == null ? "0" : this.literalValue.toString();