refactor: batch 1 - correctness and error contract

- MID/RIGHT/LEFT integer args now coerced at call sites (RIGHT(s, n/2)
  no longer emits invalid IR); drop emitLeft's private conversion
- FOR loop direction decided at run time via select on STEP sign;
  descending FOR works, STEP evaluated once per iteration
- ArrayHandler: extract emitCheckedIndices/loadElement; index count is
  validated before emission, fixing a compiler-crash (vector OOB UB) on
  OUTPUT with too many indices
- Error contract: Lexer/Parser/CodeGen track errors; all silent failure
  paths now print Error: diagnostics with line numbers; unterminated
  char literal no longer truncates the rest of the program; module is
  verified with verifyModule; driver exits non-zero on any error

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

5 files changed, 129 insertions, 125 deletions

diff --git a/lib/CodeGen/ArithmeticHandler.cc b/lib/CodeGen/ArithmeticHandler.cc
index 585104d..b909abc 100644
--- a/lib/CodeGen/ArithmeticHandler.cc
+++ b/lib/CodeGen/ArithmeticHandler.cc
@@ -49,7 +49,8 @@ Value *ArithmeticHandler::emitBinaryOp(int Op, Value *LHS, Value *RHS, int Line)
 
     if (Op == tok_div || Op == tok_mod) {
         if (!LIsInt || !RIsInt) {
-            fprintf(stderr, "Error: DIV and MOD operators require INTEGER operands.\n");
+            fprintf(stderr, "Error: DIV and MOD operators require INTEGER operands (line %d).\n", Line);
+            HadError = true;
             return nullptr;
         }
         if (Op == tok_div) return Builder.CreateSDiv(LHS, RHS, "div_int_tmp");
@@ -106,6 +107,8 @@ Value *ArithmeticHandler::emitBinaryOp(int Op, Value *LHS, Value *RHS, int Line)
             case tok_ge: return Builder.CreateICmpSGE(LHS, RHS, "sgetmp");
         }
     }
-    
+
+    fprintf(stderr, "Error: Unsupported operand types for binary operator (line %d).\n", Line);
+    HadError = true;
     return nullptr;
 }
diff --git a/lib/CodeGen/ArrayHandler.cc b/lib/CodeGen/ArrayHandler.cc
index fd55009..aa7230a 100644
--- a/lib/CodeGen/ArrayHandler.cc
+++ b/lib/CodeGen/ArrayHandler.cc
@@ -88,7 +88,7 @@ void ArrayHandler::emitArrayDeclare(ArrayDeclareStmtAST *Stmt, CodeGen &CG) {
 
     const TypeInfo *ElemInfo = Types.resolve(Stmt->getType());
     if (!ElemInfo || !ElemInfo->LLVMType || ElemInfo->isVoid()) {
-        fprintf(stderr, "Error: Unknown array element type %s\n", Stmt->getType().c_str());
+        CG.reportError("Unknown array element type %s", Stmt->getType().c_str());
         return;
     }
 
@@ -148,30 +148,39 @@ void ArrayHandler::emitArrayDeclare(ArrayDeclareStmtAST *Stmt, CodeGen &CG) {
     CG.registerSymbol(Name, Alloca, ElemInfo->Name, true);
 }
 
-Value *ArrayHandler::emitArrayAccess(ArrayAccessExprAST *Expr, CodeGen &CG) {
-    std::string Name = Expr->getName();
+bool ArrayHandler::emitCheckedIndices(const std::string &Name,
+                                      const std::vector<std::unique_ptr<ExprAST>> &IndexExprs,
+                                      int Line,
+                                      bool RequireExact,
+                                      CodeGen &CG,
+                                      std::vector<Value*> &Out) {
     const ArrayMetadata *Meta = getMetadata(Name);
     if (!Meta) {
-        fprintf(stderr, "Error: Undeclared array %s\n", Name.c_str());
-        return nullptr;
+        CG.reportError("Undeclared array %s", Name.c_str());
+        return false;
     }
 
-    if (Expr->getIndices().size() != static_cast<size_t>(Meta->Rank)) {
-        fprintf(stderr, "Error: Incorrect number of indices for %s\n", Name.c_str());
-        return nullptr;
+    size_t Rank = static_cast<size_t>(Meta->Rank);
+    if (IndexExprs.size() > Rank || (RequireExact && IndexExprs.size() != Rank)) {
+        CG.reportError("Incorrect number of indices for %s", Name.c_str());
+        return false;
     }
 
-    std::vector<Value*> Indices;
-    for (size_t i = 0; i < Expr->getIndices().size(); ++i) {
-        Value *Idx = CG.emitExpr(Expr->getIndices()[i].get());
+    for (size_t i = 0; i < IndexExprs.size(); ++i) {
+        Value *Idx = CG.emitExpr(IndexExprs[i].get());
         Idx = CG.coerceValueToType(Idx, CG.resolveType("INTEGER"));
-        if (!Idx) return nullptr;
+        if (!Idx) return false;
 
-        Indices.push_back(Idx);
-        RuntimeChecker.emitIndexCheck(Idx, Meta->LowerBounds[i], Meta->UpperBounds[i], Expr->getLine());
+        Out.push_back(Idx);
+        RuntimeChecker.emitIndexCheck(Idx, Meta->LowerBounds[i], Meta->UpperBounds[i], Line);
     }
+    return true;
+}
+
+Value *ArrayHandler::loadElement(const std::string &Name, Value *Offset, CodeGen &CG) {
+    const ArrayMetadata *Meta = getMetadata(Name);
+    if (!Meta) return nullptr;
 
-    Value *Offset = computeFlatIndex(Name, Indices);
     Value *ElemPtr = getElementPointer(Name, Offset);
     if (!ElemPtr) return nullptr;
 
@@ -185,29 +194,23 @@ Value *ArrayHandler::emitArrayAccess(ArrayAccessExprAST *Expr, CodeGen &CG) {
     return Val;
 }
 
-void ArrayHandler::emitArrayAssign(ArrayAssignStmtAST *Stmt, CodeGen &CG) {
-    std::string Name = Stmt->getName();
-    const ArrayMetadata *Meta = getMetadata(Name);
-    if (!Meta) {
-        fprintf(stderr, "Error: Undeclared array %s\n", Name.c_str());
-        return;
-    }
+Value *ArrayHandler::emitArrayAccess(ArrayAccessExprAST *Expr, CodeGen &CG) {
+    std::string Name = Expr->getName();
+    std::vector<Value*> Indices;
+    if (!emitCheckedIndices(Name, Expr->getIndices(), Expr->getLine(), true, CG, Indices))
+        return nullptr;
 
-    if (Stmt->getIndices().size() != static_cast<size_t>(Meta->Rank)) {
-        fprintf(stderr, "Error: Incorrect number of indices for %s\n", Name.c_str());
-        return;
-    }
+    Value *Offset = computeFlatIndex(Name, Indices);
+    return loadElement(Name, Offset, CG);
+}
 
+void ArrayHandler::emitArrayAssign(ArrayAssignStmtAST *Stmt, CodeGen &CG) {
+    std::string Name = Stmt->getName();
     std::vector<Value*> Indices;
-    for (size_t i = 0; i < Stmt->getIndices().size(); ++i) {
-        Value *Idx = CG.emitExpr(Stmt->getIndices()[i].get());
-        Idx = CG.coerceValueToType(Idx, CG.resolveType("INTEGER"));
-        if (!Idx) return;
-
-        Indices.push_back(Idx);
-        RuntimeChecker.emitIndexCheck(Idx, Meta->LowerBounds[i], Meta->UpperBounds[i], Stmt->getLine());
-    }
+    if (!emitCheckedIndices(Name, Stmt->getIndices(), Stmt->getLine(), true, CG, Indices))
+        return;
 
+    const ArrayMetadata *Meta = getMetadata(Name);
     const TypeInfo *ElemInfo = Types.resolve(Meta->ElementTypeName);
     Value *Val = CG.emitExpr(Stmt->getExpr());
     Val = CG.coerceValueToType(Val, ElemInfo);
@@ -222,7 +225,8 @@ void ArrayHandler::emitArrayAssign(ArrayAssignStmtAST *Stmt, CodeGen &CG) {
 
 bool ArrayHandler::tryEmitArrayOutput(ExprAST *Expr, CodeGen &CG) {
     std::string Name;
-    std::vector<Value*> Indices;
+    const std::vector<std::unique_ptr<ExprAST>> *IndexExprs = nullptr;
+    int Line = 0;
 
     if (auto *Var = dynamic_cast<VariableExprAST*>(Expr)) {
         Name = Var->getName();
@@ -231,27 +235,18 @@ bool ArrayHandler::tryEmitArrayOutput(ExprAST *Expr, CodeGen &CG) {
         Name = Acc->getName();
         const ArrayMetadata *Meta = getMetadata(Name);
         if (!Meta) return false;
-
-        for (size_t i = 0; i < Acc->getIndices().size(); ++i) {
-            Value *Idx = CG.emitExpr(Acc->getIndices()[i].get());
-            Idx = CG.coerceValueToType(Idx, CG.resolveType("INTEGER"));
-            if (!Idx) return false;
-            Indices.push_back(Idx);
-            RuntimeChecker.emitIndexCheck(Idx, Meta->LowerBounds[i], Meta->UpperBounds[i], Acc->getLine());
-        }
-
-        if (Indices.size() > static_cast<size_t>(Meta->Rank)) {
-            fprintf(stderr, "Error: Incorrect number of indices for %s\n", Name.c_str());
-            return true;
+        if (Acc->getIndices().size() == static_cast<size_t>(Meta->Rank)) {
+            return false; // full element access: handled by the normal expression path
         }
+        IndexExprs = &Acc->getIndices();
+        Line = Acc->getLine();
     } else {
         return false;
     }
 
-    const ArrayMetadata *Meta = getMetadata(Name);
-    if (!Meta) return false;
-    if (Indices.size() == static_cast<size_t>(Meta->Rank)) {
-        return false;
+    std::vector<Value*> Indices;
+    if (IndexExprs && !emitCheckedIndices(Name, *IndexExprs, Line, false, CG, Indices)) {
+        return true; // diagnosed
     }
 
     emitPrintLoop(Name, static_cast<int>(Indices.size()), Indices, CG);
@@ -267,16 +262,8 @@ void ArrayHandler::emitPrintLoop(const std::string &Name,
 
     if (CurrentDim == Meta->Rank) {
         Value *Offset = computeFlatIndex(Name, CurrentIndices);
-        Value *ElemPtr = getElementPointer(Name, Offset);
-        if (!ElemPtr) return;
-
-        Value *Val = Builder->CreateLoad(Meta->ElementType, ElemPtr, Name + "_print_val");
-        if (Meta->ElementTypeName == "STRING") {
-            Value *IsNull = Builder->CreateICmpEQ(Val,
-                                                  ConstantPointerNull::get(cast<PointerType>(Meta->ElementType)),
-                                                  Name + "_print_str_is_null");
-            Val = Builder->CreateSelect(IsNull, CG.EmptyStringStr, Val, Name + "_print_safe_str");
-        }
+        Value *Val = loadElement(Name, Offset, CG);
+        if (!Val) return;
 
         CG.emitOutputValue(Val, Types.resolve(Meta->ElementTypeName), true);
         return;
diff --git a/lib/CodeGen/CodeGen.cc b/lib/CodeGen/CodeGen.cc
index c77f5d8..439e894 100644
--- a/lib/CodeGen/CodeGen.cc
+++ b/lib/CodeGen/CodeGen.cc
@@ -3,6 +3,7 @@
 #include "cps/Lexer.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Verifier.h"
+#include <cstdarg>
 #include <cstdio>
 
 using namespace llvm;
@@ -10,6 +11,16 @@ using namespace cps;
 
 CodeGen::~CodeGen() = default;
 
+void CodeGen::reportError(const char *Fmt, ...) {
+    va_list Args;
+    va_start(Args, Fmt);
+    fprintf(stderr, "Error: ");
+    vfprintf(stderr, Fmt, Args);
+    fprintf(stderr, "\n");
+    va_end(Args);
+    HadError = true;
+}
+
 CodeGen::CodeGen() {
     TheContext = std::make_unique<LLVMContext>();
     TheModule = std::make_unique<Module>("cps_module", *TheContext);
@@ -31,12 +42,13 @@ CodeGen::CodeGen() {
                                             *Builder,
                                             *Types,
                                             NamedValues,
-                                            Symbols);
+                                            Symbols,
+                                            HadError);
 
     IntHandler = std::make_unique<IntegerHandler>(*TheContext, *Builder, *TheModule, NamedValues);
     RealHelper = std::make_unique<RealHandler>(*TheContext, *Builder, *TheModule, NamedValues);
     BoolHandler = std::make_unique<BooleanHandler>(*TheContext, *Builder, *TheModule, NamedValues);
-    ArithHandler = std::make_unique<ArithmeticHandler>(*TheContext, *Builder);
+    ArithHandler = std::make_unique<ArithmeticHandler>(*TheContext, *Builder, HadError);
     StrHandler = std::make_unique<StringHandler>(*TheContext, *Builder, *TheModule, NamedValues);
     ChrHandler = std::make_unique<CharHandler>(*TheContext, *Builder, *TheModule);
     StrConvHandler = std::make_unique<StringConversionHandler>(*TheContext, *Builder, *TheModule);
@@ -282,8 +294,7 @@ Value *CodeGen::coerceValueToType(Value *Val, const TypeInfo *TargetInfo) {
             break;
     }
 
-    fprintf(stderr,
-            "Error: Cannot coerce value of LLVM type to target type %s\n",
+    reportError("Cannot coerce value of LLVM type to target type %s",
             TargetInfo->Name.c_str());
     return nullptr;
 }
@@ -291,7 +302,7 @@ Value *CodeGen::coerceValueToType(Value *Val, const TypeInfo *TargetInfo) {
 void CodeGen::emitDeclareStmt(DeclareStmtAST *Stmt) {
     const TypeInfo *Info = resolveType(Stmt->getType());
     if (!Info || !Info->LLVMType || Info->isVoid()) {
-        fprintf(stderr, "Error: Unknown type %s\n", Stmt->getType().c_str());
+        reportError("Unknown type %s", Stmt->getType().c_str());
         return;
     }
 
@@ -315,7 +326,7 @@ void CodeGen::emitDeclareStmt(DeclareStmtAST *Stmt) {
 void CodeGen::emitOutputValue(Value *Val, const TypeInfo *Info, bool AppendNewline) {
     if (!Val || !Info) return;
     if (!Info->Printable && Info->Kind == TypeKind::Custom) {
-        fprintf(stderr, "Error: OUTPUT for custom type %s is not implemented yet\n", Info->Name.c_str());
+        reportError("OUTPUT for custom type %s is not implemented yet", Info->Name.c_str());
         return;
     }
 
@@ -382,7 +393,9 @@ void CodeGen::compile(const std::vector<std::unique_ptr<StmtAST>> &Statements) {
         Builder->CreateRet(ConstantInt::get(*TheContext, APInt(32, 0)));
     }
 
-    verifyFunction(*F);
+    if (verifyModule(*TheModule, &errs())) {
+        HadError = true;
+    }
 }
 
 void CodeGen::print() {
@@ -415,7 +428,7 @@ Value *CodeGen::emitExpr(ExprAST *Expr) {
     if (auto *Var = dynamic_cast<VariableExprAST*>(Expr)) {
         const SymbolInfo *Info = getSymbolInfo(Var->getName());
         if (!Info) {
-            fprintf(stderr, "Error: Unknown variable name %s\n", Var->getName().c_str());
+            reportError("Unknown variable name %s", Var->getName().c_str());
             return nullptr;
         }
         if (Info->IsArray) {
@@ -424,7 +437,7 @@ Value *CodeGen::emitExpr(ExprAST *Expr) {
 
         const TypeInfo *TypeInfo = resolveType(Info->TypeName);
         if (!TypeInfo || !TypeInfo->LLVMType) {
-            fprintf(stderr, "Error: Unknown type for variable %s\n", Var->getName().c_str());
+            reportError("Unknown type for variable %s", Var->getName().c_str());
             return nullptr;
         }
 
@@ -462,35 +475,41 @@ Value *CodeGen::emitExpr(ExprAST *Expr) {
     if (auto *Call = dynamic_cast<CallExprAST*>(Expr)) {
         std::string Name = Call->getCallee();
         if (Name == "LENGTH") {
-            if (Call->getArgs().size() != 1) { fprintf(stderr, "LENGTH expects 1 arg\n"); return nullptr; }
+            if (Call->getArgs().size() != 1) { reportError("LENGTH expects 1 arg"); return nullptr; }
             return StrHandler->emitLength(emitExpr(Call->getArgs()[0].get()));
         }
         if (Name == "MID") {
-            if (Call->getArgs().size() != 3) { fprintf(stderr, "MID expects 3 args\n"); return nullptr; }
-            return StrHandler->emitMid(emitExpr(Call->getArgs()[0].get()),
-                                       emitExpr(Call->getArgs()[1].get()),
-                                       emitExpr(Call->getArgs()[2].get()));
+            if (Call->getArgs().size() != 3) { reportError("MID expects 3 args"); return nullptr; }
+            Value *Str = emitExpr(Call->getArgs()[0].get());
+            Value *Start = coerceValueToType(emitExpr(Call->getArgs()[1].get()), resolveType("INTEGER"));
+            Value *Len = coerceValueToType(emitExpr(Call->getArgs()[2].get()), resolveType("INTEGER"));
+            if (!Str || !Start || !Len) return nullptr;
+            return StrHandler->emitMid(Str, Start, Len);
         }
         if (Name == "RIGHT") {
-            if (Call->getArgs().size() != 2) { fprintf(stderr, "RIGHT expects 2 args\n"); return nullptr; }
-            return StrHandler->emitRight(emitExpr(Call->getArgs()[0].get()),
-                                         emitExpr(Call->getArgs()[1].get()));
+            if (Call->getArgs().size() != 2) { reportError("RIGHT expects 2 args"); return nullptr; }
+            Value *Str = emitExpr(Call->getArgs()[0].get());
+            Value *Len = coerceValueToType(emitExpr(Call->getArgs()[1].get()), resolveType("INTEGER"));
+            if (!Str || !Len) return nullptr;
+            return StrHandler->emitRight(Str, Len);
         }
         if (Name == "LEFT") {
-            if (Call->getArgs().size() != 2) { fprintf(stderr, "LEFT expects 2 args\n"); return nullptr; }
-            return StrHandler->emitLeft(emitExpr(Call->getArgs()[0].get()),
-                                        emitExpr(Call->getArgs()[1].get()));
+            if (Call->getArgs().size() != 2) { reportError("LEFT expects 2 args"); return nullptr; }
+            Value *Str = emitExpr(Call->getArgs()[0].get());
+            Value *Len = coerceValueToType(emitExpr(Call->getArgs()[1].get()), resolveType("INTEGER"));
+            if (!Str || !Len) return nullptr;
+            return StrHandler->emitLeft(Str, Len);
         }
         if (Name == "LCASE") {
-            if (Call->getArgs().size() != 1) { fprintf(stderr, "LCASE expects 1 arg\n"); return nullptr; }
+            if (Call->getArgs().size() != 1) { reportError("LCASE expects 1 arg"); return nullptr; }
             return StrHandler->emitLCase(emitExpr(Call->getArgs()[0].get()));
         }
         if (Name == "UCASE") {
-            if (Call->getArgs().size() != 1) { fprintf(stderr, "UCASE expects 1 arg\n"); return nullptr; }
+            if (Call->getArgs().size() != 1) { reportError("UCASE expects 1 arg"); return nullptr; }
             return StrHandler->emitUCase(emitExpr(Call->getArgs()[0].get()));
         }
         if (Name == "ASC") {
-            if (Call->getArgs().size() != 1) return nullptr;
+            if (Call->getArgs().size() != 1) { reportError("ASC expects 1 arg"); return nullptr; }
             Value *ArgVal = emitExpr(Call->getArgs()[0].get());
             const TypeInfo *ArgType = getExprTypeInfo(Call->getArgs()[0].get());
             Value *CharVal = nullptr;
@@ -503,7 +522,7 @@ Value *CodeGen::emitExpr(ExprAST *Expr) {
             return coerceValueToType(AscVal, resolveType("INTEGER"));
         }
         if (Name == "CHR") {
-            if (Call->getArgs().size() != 1) return nullptr;
+            if (Call->getArgs().size() != 1) { reportError("CHR expects 1 arg"); return nullptr; }
             Value *IntVal = coerceValueToType(emitExpr(Call->getArgs()[0].get()), resolveType("INTEGER"));
             Value *CharVal = ChrHandler->emitChr(IntVal);
             Function *MallocF = TheModule->getFunction("malloc");
@@ -516,11 +535,11 @@ Value *CodeGen::emitExpr(ExprAST *Expr) {
             return Mem;
         }
         if (Name == "IS_NUM") {
-            if (Call->getArgs().size() != 1) return nullptr;
+            if (Call->getArgs().size() != 1) { reportError("IS_NUM expects 1 arg"); return nullptr; }
             return StrConvHandler->emitIsNum(emitExpr(Call->getArgs()[0].get()));
         }
         if (Name == "NUM_TO_STR") {
-            if (Call->getArgs().size() != 1) return nullptr;
+            if (Call->getArgs().size() != 1) { reportError("NUM_TO_STR expects 1 arg"); return nullptr; }
             Value *NumV = emitExpr(Call->getArgs()[0].get());
             bool IsReal = NumV->getType()->isDoubleTy();
             if (NumV->getType()->isIntegerTy(8)) {
@@ -529,7 +548,7 @@ Value *CodeGen::emitExpr(ExprAST *Expr) {
             return StrConvHandler->emitNumToStr(NumV, IsReal);
         }
         if (Name == "STR_TO_NUM") {
-            if (Call->getArgs().size() != 1) return nullptr;
+            if (Call->getArgs().size() != 1) { reportError("STR_TO_NUM expects 1 arg"); return nullptr; }
             return StrConvHandler->emitStrToNum(emitExpr(Call->getArgs()[0].get()), true);
         }
 
@@ -550,12 +569,12 @@ Value *CodeGen::emitExpr(ExprAST *Expr) {
                 if (auto *Var = dynamic_cast<VariableExprAST*>(ArgExpr)) {
                     Value *Ptr = getNamedValue(Var->getName());
                     if (!Ptr) {
-                        fprintf(stderr, "Error: Unknown variable %s in BYREF call\n", Var->getName().c_str());
+                        reportError("Unknown variable %s in BYREF call", Var->getName().c_str());
                         return nullptr;
                     }
                     Args.push_back(Ptr);
                 } else {
-                    fprintf(stderr, "Error: BYREF argument must be a variable.\n");
+                    reportError("BYREF argument must be a variable.");
                     return nullptr;
                 }
             } else {
@@ -647,11 +666,11 @@ void CodeGen::emitForStmt(ForStmtAST *Stmt) {
 
     const SymbolInfo *Symbol = getSymbolInfo(VarName);
     if (!Symbol) {
-        fprintf(stderr, "Error: Unknown variable in FOR loop %s\n", VarName.c_str());
+        reportError("Unknown variable in FOR loop %s", VarName.c_str());
         return;
     }
     if (Symbol->TypeName != "INTEGER") {
-        fprintf(stderr, "Error: FOR loop variable %s must be INTEGER\n", VarName.c_str());
+        reportError("FOR loop variable %s must be INTEGER", VarName.c_str());
         return;
     }
 
@@ -673,16 +692,21 @@ void CodeGen::emitForStmt(ForStmtAST *Stmt) {
     Value *EndVal = coerceValueToType(emitExpr(Stmt->getEnd()), resolveType("INTEGER"));
     if (!EndVal) return;
 
-    bool IsNegativeStep = false;
+    Value *StepVal = nullptr;
     if (Stmt->getStep()) {
-        if (auto *Num = dynamic_cast<IntegerExprAST*>(Stmt->getStep())) {
-            if (Num->getVal() < 0) IsNegativeStep = true;
-        }
+        StepVal = coerceValueToType(emitExpr(Stmt->getStep()), resolveType("INTEGER"));
+        if (!StepVal) return;
+    } else {
+        StepVal = ConstantInt::get(*TheContext, APInt(64, 1));
     }
 
-    Value *CondV = IsNegativeStep
-        ? Builder->CreateICmpSGE(CurVar, EndVal, "forcond_ge")
-        : Builder->CreateICmpSLE(CurVar, EndVal, "forcond_le");
+    // The loop direction depends on the STEP value at run time.
+    Value *StepNonNeg = Builder->CreateICmpSGE(StepVal,
+                                               ConstantInt::get(*TheContext, APInt(64, 0)),
+                                               "step_nonneg");
+    Value *CondUp = Builder->CreateICmpSLE(CurVar, EndVal, "forcond_le");
+    Value *CondDown = Builder->CreateICmpSGE(CurVar, EndVal, "forcond_ge");
+    Value *CondV = Builder->CreateSelect(StepNonNeg, CondUp, CondDown, "forcond");
 
     Builder->CreateCondBr(CondV, LoopBB, AfterBB);
 
@@ -692,13 +716,6 @@ void CodeGen::emitForStmt(ForStmtAST *Stmt) {
         Builder->CreateBr(IncBB);
 
     Builder->SetInsertPoint(IncBB);
-    Value *StepVal = nullptr;
-    if (Stmt->getStep()) {
-        StepVal = coerceValueToType(emitExpr(Stmt->getStep()), resolveType("INTEGER"));
-    } else {
-        StepVal = ConstantInt::get(*TheContext, APInt(64, 1));
-    }
-
     Value *CurValForInc = Builder->CreateLoad(Type::getInt64Ty(*TheContext), Alloca, VarName.c_str());
     Value *NextVal = Builder->CreateAdd(CurValForInc, StepVal, "nextval");
     Builder->CreateStore(NextVal, Alloca);
@@ -749,12 +766,12 @@ void CodeGen::emitStmt(StmtAST *Stmt) {
                 if (auto *Var = dynamic_cast<VariableExprAST*>(ArgExpr)) {
                     Value *Ptr = getNamedValue(Var->getName());
                     if (!Ptr) {
-                        fprintf(stderr, "Error: Unknown variable %s in BYREF call\n", Var->getName().c_str());
+                        reportError("Unknown variable %s in BYREF call", Var->getName().c_str());
                         return;
                     }
                     Args.push_back(Ptr);
                 } else {
-                    fprintf(stderr, "Error: BYREF argument must be a variable.\n");
+                    reportError("BYREF argument must be a variable.");
                     return;
                 }
             } else {
@@ -782,11 +799,11 @@ void CodeGen::emitStmt(StmtAST *Stmt) {
     if (auto *Assign = dynamic_cast<AssignStmtAST*>(Stmt)) {
         const SymbolInfo *Info = getSymbolInfo(Assign->getName());
         if (!Info) {
-            fprintf(stderr, "Error: Unknown variable name %s\n", Assign->getName().c_str());
+            reportError("Unknown variable name %s", Assign->getName().c_str());
             return;
         }
         if (Info->IsArray) {
-            fprintf(stderr, "Error: Cannot assign array %s without indices\n", Assign->getName().c_str());
+            reportError("Cannot assign array %s without indices", Assign->getName().c_str());
             return;
         }
 
@@ -802,17 +819,17 @@ void CodeGen::emitStmt(StmtAST *Stmt) {
     if (auto *In = dynamic_cast<InputStmtAST*>(Stmt)) {
         const SymbolInfo *Info = getSymbolInfo(In->getName());
         if (!Info) {
-            fprintf(stderr, "Error: Unknown variable name %s\n", In->getName().c_str());
+            reportError("Unknown variable name %s", In->getName().c_str());
             return;
         }
         if (Info->IsArray) {
-            fprintf(stderr, "Error: INPUT for entire array %s is not supported\n", In->getName().c_str());
+            reportError("INPUT for entire array %s is not supported", In->getName().c_str());
             return;
         }
 
         const TypeInfo *TypeInfo = resolveType(Info->TypeName);
         if (!TypeInfo) {
-            fprintf(stderr, "Error: Unknown type for INPUT %s\n", In->getName().c_str());
+            reportError("Unknown type for INPUT %s", In->getName().c_str());
             return;
         }
 
diff --git a/lib/CodeGen/FunctionGen.cc b/lib/CodeGen/FunctionGen.cc
index 89aa3d8..0a22278 100644
--- a/lib/CodeGen/FunctionGen.cc
+++ b/lib/CodeGen/FunctionGen.cc
@@ -9,6 +9,7 @@ Type *FunctionGen::getLLVMType(const std::string &TypeName) {
     Type *Resolved = Types.getLLVMType(TypeName);
     if (!Resolved) {
         fprintf(stderr, "Error: Unknown type %s\n", TypeName.c_str());
+        HadError = true;
         return Type::getInt64Ty(Context);
     }
     return Resolved;
@@ -78,6 +79,7 @@ Function *FunctionGen::emitFunctionDef(FunctionDefAST *FuncAST,
     if (!TheFunction) return nullptr;
     if (!TheFunction->empty()) {
         fprintf(stderr, "Error: Function %s cannot be redefined.\n", Proto->getName().c_str());
+        HadError = true;
         return nullptr;
     }
 
@@ -103,7 +105,6 @@ Function *FunctionGen::emitFunctionDef(FunctionDefAST *FuncAST,
         }
     }
 
-    verifyFunction(*TheFunction);
     NamedValues = OldNamedValues;
     Symbols = OldSymbols;
     return TheFunction;
@@ -113,7 +114,8 @@ static Value *GenerateCall(llvm::Module &Module,
                            llvm::IRBuilder<> &Builder,
                            llvm::LLVMContext &Context,
                            const std::string &CalleeName,
-                           const std::vector<llvm::Value*> &Args) {
+                           const std::vector<llvm::Value*> &Args,
+                           bool &HadError) {
     Function *CalleeF = Module.getFunction(CalleeName);
     if (!CalleeF) {
         std::vector<Type*> ArgTypes;
@@ -124,6 +126,7 @@ static Value *GenerateCall(llvm::Module &Module,
 
     if (CalleeF->arg_size() != Args.size()) {
         fprintf(stderr, "Error: Incorrect # arguments passed to %s\n", CalleeName.c_str());
+        HadError = true;
         return nullptr;
     }
 
@@ -135,11 +138,11 @@ static Value *GenerateCall(llvm::Module &Module,
 }
 
 llvm::Value *FunctionGen::emitCallExpr(CallExprAST *Call, const std::vector<llvm::Value*> &Args) {
-    return GenerateCall(Module, Builder, Context, Call->getCallee(), Args);
+    return GenerateCall(Module, Builder, Context, Call->getCallee(), Args, HadError);
 }
 
 void FunctionGen::emitCallStmt(CallStmtAST *Call, const std::vector<llvm::Value*> &Args) {
-    GenerateCall(Module, Builder, Context, Call->getCallee(), Args);
+    GenerateCall(Module, Builder, Context, Call->getCallee(), Args, HadError);
 }
 
 void FunctionGen::emitReturn(ReturnStmtAST *Ret, llvm::Value *RetVal) {
diff --git a/lib/CodeGen/StringHandler.cc b/lib/CodeGen/StringHandler.cc
index f777059..e5971d0 100644
--- a/lib/CodeGen/StringHandler.cc
+++ b/lib/CodeGen/StringHandler.cc
@@ -114,12 +114,6 @@ Value *StringHandler::emitRight(Value *Str, Value *Len) {
 
 Value *StringHandler::emitLeft(Value *Str, Value *Len) {
     Value *FullLen = emitLength(Str);
-    if (Len->getType()->isIntegerTy() && Len->getType()->getIntegerBitWidth() != 64) {
-        Len = Builder.CreateSExt(Len, Type::getInt64Ty(Context), "len_ext");
-    } 
-    else if (Len->getType()->isDoubleTy()) {
-        Len = Builder.CreateFPToSI(Len, Type::getInt64Ty(Context), "len_int");
-    }
 
     Value *Zero = ConstantInt::get(Context, APInt(64, 0));
     Value *IsNeg = Builder.CreateICmpSLT(Len, Zero);