Add support for DIM statement

jbreams · jbreams · commit ed3e21b0c801 · 2017-12-27T10:04:02.000-05:00
diff --git a/ast.cpp b/ast.cpp
@@ -132,6 +132,8 @@ std::unique_ptr<ExprAST> StatementAST::parse(const Token& tok, BasicContext* ctx
             }
         case Token::Let:
             return LetAST::parse(tok, ctx);
+        case Token::Dim:
+            return DimAST::parse(tok, ctx);
         case Token::String: {
             const auto& name = tok.strValue;
             if (ctx->externFunctions.find(name) != ctx->externFunctions.end()) {
@@ -448,6 +450,56 @@ std::unique_ptr<ExprAST> LetAST::parse(const Token& tok, BasicContext* ctx, bool
     return std::make_unique<LetAST>(tok, ctx, name, type, std::move(value), global);
 }
 
+std::unique_ptr<ExprAST> DimAST::parse(const Token& tok, BasicContext* ctx) {
+    Token nameTok = ctx->lexer.lex();
+    if (nameTok.tag != Token::String && nameTok.tag != Token::Variable) {
+        throw AssignException(AssignException::NotString);
+    }
+
+    auto nextTok = ctx->lexer.lex();
+    std::vector<int> dimensions;
+    VariableType type = Integer;
+    if (nextTok.tag == Token::LParens) {
+        nextTok = ctx->lexer.lex();
+        while (nextTok.tag != Token::RParens) {
+            if (nextTok.tag == Token::Integer) {
+                dimensions.push_back(boost::get<int64_t>(nextTok.value));
+            } else if (nextTok.tag == Token::Comma) {
+                nextTok = ctx->lexer.lex();
+            } else {
+                throw ParseException("Invalid token while parsing dimensions list");
+            }
+            nextTok = ctx->lexer.lex();
+        }
+
+        // Consume the RParens
+        nextTok = ctx->lexer.lex();
+    }
+
+    if (nextTok.tag == Token::As) {
+        nextTok = ctx->lexer.lex();
+        switch (nextTok.tag) {
+            case Token::IntegerType:
+                type = Integer;
+                break;
+            case Token::StringType:
+                type = String;
+                break;
+            case Token::DoubleType:
+                type = Double;
+                break;
+            default:
+                throw ParseException("Invalid token while parsing variable type");
+        }
+    } else {
+        ctx->lexer.putBack(nextTok);
+    }
+    bool global = (ctx->currentFunction == nullptr);
+
+    return std::make_unique<DimAST>(
+        tok, ctx, nameTok.strValue, type, std::move(dimensions), global);
+}
+
 std::string lexString(Lexer* lexer) {
     auto labelTok = lexer->lex();
     std::string gotoName;
@@ -606,6 +658,8 @@ std::unique_ptr<ExprAST> ProtoDefAST::parse(const Token& tok, BasicContext* ctx)
             type = Double;
         } else if (argTypeTok.tag == Token::StringType) {
             type = String;
+        } else if (argTypeTok.tag == Token::IntegerType) {
+            type = Integer;
         } else {
             throw ParseException("Unknown type for argument in extern def");
         }
diff --git a/ast.h b/ast.h
@@ -256,6 +256,34 @@ class LetAST : public ExprAST {
     llvm::AllocaInst* _alloca;
 };
 
+class DimAST : public ExprAST {
+public:
+    DimAST(Token tok,
+           BasicContext* ctx,
+           std::string name,
+           VariableType type,
+           std::vector<int> dimensions,
+           bool global)
+        : ExprAST(std::move(tok), ctx),
+          _name(std::move(name)),
+          _type(type),
+          _dimensions(std::move(dimensions)),
+          _global(global) {}
+
+    llvm::Value* codegen() override;
+    static std::unique_ptr<ExprAST> parse(const Token& tok, BasicContext* ctx);
+
+    llvm::AllocaInst* allocaInst() const;
+    const std::string& name() const;
+
+private:
+    std::string _name;
+    VariableType _type;
+    std::vector<int> _dimensions;
+    bool _global;
+    llvm::AllocaInst* _alloca;
+};
+
 class BinaryExprAST : public ExprAST {
 public:
     BinaryExprAST(Token tok,
diff --git a/cli.cpp b/cli.cpp
@@ -30,13 +30,19 @@ Options Options::parseOptions(int argc, char** argv) {
         llvm::cl::cat(CompilerCategory),
         llvm::cl::init(ObjectCode));
 
+    static llvm::cl::opt<bool> verifyModule(
+        "verify",
+        llvm::cl::desc("Run verification on module before writing output"),
+        llvm::cl::cat(CompilerCategory),
+        llvm::cl::init(true));
+
     llvm::cl::HideUnrelatedOptions(CompilerCategory);
 
     llvm::cl::ParseCommandLineOptions(argc, argv);
 
-
     return Options{inputFilename.getValue(),
                    outputFilename.getValue(),
                    mainFunctionName.getValue(),
-                   outputType.getValue()};
+                   outputType.getValue(),
+                   verifyModule.getValue()};
 }
diff --git a/cli.h b/cli.h
@@ -12,5 +12,6 @@ struct Options {
         ObjectCode,
     };
     OutputType outputType;
+    bool verifyModule;
     static Options parseOptions(int argc, char** argv);
 };
diff --git a/codegen.cpp b/codegen.cpp
@@ -44,11 +44,11 @@ bool BasicContext::codegenAllProtos() {
     return true;
 }
 
-llvm::Value* makeLiteralDouble(BasicContext* ctx, double val) {
+llvm::Constant* makeLiteralDouble(BasicContext* ctx, double val) {
     return llvm::ConstantFP::get(ctx->context, llvm::APFloat(val));
 }
 
-llvm::Value* makeLiteralInteger(BasicContext* ctx, int64_t val) {
+llvm::Constant* makeLiteralInteger(BasicContext* ctx, int64_t val) {
     return llvm::ConstantInt::getSigned(ctx->builder.getInt64Ty(), val);
 }
 
@@ -140,6 +140,62 @@ llvm::Value* VariableExprAST::codegen() {
     return builder.CreateLoad(it->second, it->first);
 }
 
+llvm::Value* DimAST::codegen() {
+    auto& builder = ctx()->builder;
+
+    int numElements = 0;
+    for (auto dimensions : _dimensions) {
+        numElements += dimensions + 1;
+    }
+
+    llvm::Constant* initV;
+    llvm::Type* type = nullptr;
+    if (_type == Double) {
+        initV = makeLiteralDouble(ctx(), 0.0);
+        type = builder.getDoubleTy();
+    } else if (_type == Integer) {
+        initV = makeLiteralInteger(ctx(), 0);
+        type = builder.getInt64Ty();
+    } else if (_type == String) {
+        initV = llvm::ConstantPointerNull::get(llvm::Type::getInt8PtrTy(ctx()->context));
+        type = builder.getInt8PtrTy();
+    } else {
+        std::cerr << "Cannot find initial value for variable " << _name << std::endl;
+        return nullptr;
+    }
+
+    if (numElements > 0) {
+        type = llvm::ArrayType::get(type, numElements);
+        initV = llvm::ConstantAggregateZero::get(type);
+    }
+
+    if (_global) {
+        auto globalPtr = ctx()->module->getOrInsertGlobal(_name, type);
+        auto global = ctx()->module->getGlobalVariable(_name);
+        if (!global->hasInitializer()) {
+            global->setInitializer(initV);
+            global->setLinkage(llvm::GlobalValue::CommonLinkage);
+        }
+
+        return globalPtr;
+    }
+
+    auto alloc = CreateEntryBlockAlloca(ctx(), _name, type);
+
+    _alloca = alloc;
+    ctx()->namedVariables[_name] = alloc;
+
+    return alloc;
+}
+
+const std::string& DimAST::name() const {
+    return _name;
+}
+
+llvm::AllocaInst* DimAST::allocaInst() const {
+    return _alloca;
+}
+
 llvm::Value* LetAST::codegen() {
     auto& builder = ctx()->builder;
 
@@ -342,7 +398,9 @@ llvm::Value* GotoAST::codegen() {
         return nullptr;
     }
     builder.CreateBr(static_cast<llvm::BasicBlock*>(labelIt->second.label->value()));
-    return llvm::ConstantFP::get(builder.getDoubleTy(), 0);
+    auto newBB = llvm::BasicBlock::Create(ctx()->context, "afterGoto", ctx()->getCurrentFunction());
+    builder.SetInsertPoint(newBB);
+    return newBB;
 }
 
 llvm::Value* GosubAST::codegen() {
diff --git a/lexer.cpp b/lexer.cpp
@@ -10,28 +10,18 @@
 using StringToTagMap = std::unordered_map<std::string, Token::Tag>;
 const StringToTagMap& stringToTagMap() {
     static const StringToTagMap _stringToTag = {
-        {"AND", Token::And},
-        {"AS", Token::As},
-        {"DOUBLE", Token::DoubleType},
-        {"ELSE", Token::Else},
-        {"END", Token::End},
-        {"EXTERN", Token::Extern},
-        {"FOR", Token::For},
-        {"FUNCTION", Token::Function},
-        {"GOSUB", Token::Gosub},
-        {"GOTO", Token::Goto},
-        {"IF", Token::If},
-        {"INPUT", Token::Input},
-        {"LET", Token::Let},
-        {"OR", Token::Or},
-        {"NEXT", Token::Next},
-        {"PRINT", Token::Print},
-        {"RETURN", Token::Return},
-        {"STEP", Token::Step},
-        {"STRING", Token::StringType},
-        {"SUB", Token::Sub},
-        {"THEN", Token::Then},
-        {"TO", Token::To},
+        {"AND", Token::And},           {"AS", Token::As},
+        {"DIM", Token::Dim},           {"DOUBLE", Token::DoubleType},
+        {"ELSE", Token::Else},         {"END", Token::End},
+        {"EXTERN", Token::Extern},     {"FOR", Token::For},
+        {"FUNCTION", Token::Function}, {"GOSUB", Token::Gosub},
+        {"GOTO", Token::Goto},         {"IF", Token::If},
+        {"INPUT", Token::Input},       {"INTEGER", Token::IntegerType},
+        {"LET", Token::Let},           {"OR", Token::Or},
+        {"NEXT", Token::Next},         {"PRINT", Token::Print},
+        {"RETURN", Token::Return},     {"STEP", Token::Step},
+        {"STRING", Token::StringType}, {"SUB", Token::Sub},
+        {"THEN", Token::Then},         {"TO", Token::To},
     };
     return _stringToTag;
 }
diff --git a/lexer.h b/lexer.h
@@ -23,7 +23,9 @@ struct Token {
         Sub,
         Function,
         Variable,
+        Dim,
 
+        IntegerType,
         StringType,
         DoubleType,
 
diff --git a/main.cpp b/main.cpp
@@ -75,7 +75,7 @@ int main(int argc, char** argv) {
         return 1;
 
     llvm::raw_os_ostream errStream(std::cerr);
-    if (llvm::verifyModule(*ctx.module, &errStream))
+    if (opts.verifyModule && llvm::verifyModule(*ctx.module, &errStream))
         return 1;
 
     std::unique_ptr<llvm::raw_fd_ostream> output;
