aboutsummaryrefslogtreecommitdiff
path: root/lib/CodeGen
diff options
context:
space:
mode:
Diffstat (limited to 'lib/CodeGen')
-rw-r--r--lib/CodeGen/ArithmeticHandler.cc7
-rw-r--r--lib/CodeGen/ArrayHandler.cc109
-rw-r--r--lib/CodeGen/CodeGen.cc121
-rw-r--r--lib/CodeGen/FunctionGen.cc11
-rw-r--r--lib/CodeGen/StringHandler.cc6
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);
generated by cgit v1.3.1-4-g156e (git 2.54.0) at 2026-11-14 18:24:07 +0000