src/ast.cpp

@@ -61,13 +61,6 @@ namespace AST {
         return out.str();
     }
 
-    std::string IndexAccessExpression::formatted() {
-        std::stringstream out{ "" };
-        out << this->m_expr->formatted();
-        out << "[" << this->m_num << "]";
-        return out.str();
-    }
-
     std::string ExpressionStatement::formatted() {
         std::stringstream out{ "" };
         out << this->m_expr->formatted();

src/ast.h

@@ -211,30 +211,6 @@ namespace AST {
         ) override;
     };
 
-    /// @brief Same as value[num]
-    class IndexAccessExpression : public Expression {
-    private:
-        std::unique_ptr<Expression> m_expr;
-        uint32_t m_num;
-    public:
-        IndexAccessExpression(
-            token::Metadata meta,
-            std::unique_ptr<Expression> expr,
-            uint32_t num)
-            : Expression{ meta }
-            , m_expr{ std::move(expr) }
-            , m_num{ num } {
-        }
-        virtual ~IndexAccessExpression() override = default;
-        virtual std::string formatted() override;
-        virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
-        virtual std::shared_ptr<types::Type> typecheck(
-            typecheck::State& state,
-            typecheck::Scope& scope,
-            std::optional<std::shared_ptr<types::Type>> expected_ty
-        ) override;
-    };
-
 
     class ReturnStatement : public Statement {
     private:

src/casting.cpp

@@ -53,25 +53,6 @@ namespace types {
         std::shared_ptr<Type> casted_ty,
         std::shared_ptr<Type> target_ty) {
 
-        if (casted_ty->m_kind == types::TypeKind::Array && target_ty->m_kind == types::TypeKind::Pointer) {
-            auto array_ty = dynamic_cast<types::ArrayType*>(casted_ty.get());
-            auto ptr_ty = dynamic_cast<types::PointerType*>(target_ty.get());
-            if (!types_equal(array_ty->m_inner, ptr_ty->m_inner))
-                return {};
-            return CastDefinition{ casted_ty, target_ty, true,
-                [](codegen::Builder&, std::shared_ptr<Type>, llvm::Value* value) {
-                    // auto ptr_ty = dynamic_cast<types::PointerType*>(target.get());
-
-                    // std::vector<llvm::Value*> indices {};
-                    // indices.push_back(llvm::ConstantInt::get(
-                    //     builder.builder->getInt32Ty(),
-                    //     0
-                    // ));
-                    // return builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder), value, indices, "arraydecay");
-                    return value;
-            } };
-        }
-
         for (auto& cast : casts) {
             if (types_equal(cast.casted_ty, casted_ty) && types_equal(cast.target_ty, target_ty)) {
                 return cast;

src/codegen.cpp

@@ -26,16 +26,13 @@ namespace AST {
     }
 
     codegen::StackValue StringLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope&) {
-        auto stack_type = new types::ArrayType{
-            std::make_unique<types::FundamentalType>(types::FundamentalTypeKind::Char),
-            static_cast<uint32_t>(this->m_value.size()) + 1
-        };
+
+        auto stack_type = new types::PointerType{ std::make_unique<types::FundamentalType>(types::FundamentalTypeKind::Char) };
 
         auto str = llvm::StringRef{ this->m_value.c_str() };
-        auto global_str = builder.builder->CreateGlobalString(str);
 
         return codegen::StackValue{
-            builder.builder->CreateLoad(stack_type->codegen(builder), global_str, "literal"),
+            builder.builder->CreateGlobalString(str),
             std::unique_ptr<types::Type>{stack_type},
         };
     }
@@ -106,14 +103,6 @@ namespace AST {
         auto expr = this->m_expr->codegen(builder, scope);
         auto cast = types::find_cast(scope.casts, expr.ty, this->m_ty);
         if (cast) {
-            if (cast->target_ty->m_kind == types::TypeKind::Pointer && cast->casted_ty->m_kind == types::TypeKind::Array) {
-                auto allocated = builder.builder->CreateAlloca(cast->casted_ty->codegen(builder));
-                builder.builder->CreateStore(expr.value, allocated);
-                return codegen::StackValue{
-                    cast->codegen(builder, cast->target_ty, allocated),
-                    cast->target_ty
-                };
-            }
             return codegen::StackValue{
                 cast->codegen(builder, cast->target_ty, expr.value),
                 cast->target_ty
@@ -142,59 +131,6 @@ namespace AST {
     }
 
 
-    codegen::StackValue IndexAccessExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
-        auto lvalue_scope = scope.with_lvalue();
-        auto value = this->m_expr->codegen(builder, lvalue_scope);
-        std::shared_ptr<types::Type> inner_ty{};
-
-        std::vector<llvm::Value*> idx_list{ };
-        idx_list.push_back(llvm::ConstantInt::get(builder.builder->getInt32Ty(), this->m_num));
-
-        if (value.ty->m_kind == types::TypeKind::Pointer) {
-            auto ptr_ty = dynamic_cast<types::PointerType*>(value.ty.get());
-
-            if (ptr_ty->m_inner->m_kind == types::TypeKind::Pointer) {
-                auto inner_ptr_ty = dynamic_cast<types::PointerType*>(ptr_ty->m_inner.get());
-
-                auto gep_value = builder.builder->CreateGEP(inner_ptr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
-                if (scope.is_lvalue) {
-                    return codegen::StackValue{
-                        gep_value,
-                        value.ty,
-                    };
-                }
-                else {
-                    auto loaded = value.ty->load(builder, gep_value);
-                    return codegen::StackValue{
-                        loaded.first,
-                        loaded.second
-                    };
-                }
-            }
-
-            // Must be an array otherwise
-            auto arr_ty = dynamic_cast<types::ArrayType*>(ptr_ty->m_inner.get());
-            auto gep_value = builder.builder->CreateGEP(arr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
-            if (scope.is_lvalue) {
-                return codegen::StackValue{
-                    gep_value,
-                    value.ty,
-                };
-            }
-            else {
-                auto inner_ptr_ty = types::PointerType{ arr_ty->m_inner };
-                auto loaded = inner_ptr_ty.load(builder, gep_value);
-                return codegen::StackValue{
-                    loaded.first,
-                    loaded.second
-                };
-            }
-        }
-
-        throw CompileError("Tried indexing a non-pointer", this->m_meta);
-    }
-
-
     void ReturnStatement::codegen(codegen::Builder& builder, codegen::Scope& scope) {
         if (!builder.block)
             return;
@@ -355,8 +291,4 @@ namespace types {
     llvm::Type* PointerType::codegen(codegen::Builder& builder) {
         return llvm::PointerType::get(*builder.context, 0);
     }
-
-    llvm::Type* ArrayType::codegen(codegen::Builder& builder) {
-        return llvm::ArrayType::get(this->m_inner->codegen(builder), this->m_size);
-    }
 }

src/main.cpp

@@ -162,8 +162,6 @@ std::optional<CompileOutput> compile(std::string_view in_filename) {
     builder.mod->print(llvm_ir_dest, nullptr);
     llvm_ir_dest.flush();
 
-    std::cout << llvm_ir_string << std::endl;
-
     // Print output to obj-file
     std::error_code EC;
     std::string obj_string;

src/parsing.cpp

@@ -49,28 +49,6 @@ namespace parsing {
             }
         }
 
-        Result<std::optional<uint32_t>, std::string> parse_array_postfix(token::TokenStream& stream, bool allow_empty) {
-            token::TokenStream inner{ stream };
-            try {
-                std::optional<uint32_t> returned{};
-
-                inner.expect(token::Type::Symbol, "[");
-                if (inner.peek().type == token::Type::LiteralInt) {
-                    returned = std::stoi(inner.next().content);
-                }
-                if (!allow_empty && !returned.has_value()) {
-                    throw std::runtime_error("Expected array size");
-                }
-                inner.expect(token::Type::Symbol, "]");
-
-                stream.m_position = inner.m_position;
-                return returned;
-            }
-            catch (std::runtime_error& error) {
-                return std::string{ error.what() };
-            }
-        }
-
         Result<std::unique_ptr<AST::Expression>, std::string> parse_plain_expression(token::TokenStream& stream) {
             token::TokenStream inner{ stream };
             try {
@@ -123,9 +101,16 @@ namespace parsing {
             try {
                 auto before_meta = inner.metadata();
 
+                if (inner.peek().content == "(") {
+                    inner.next();
+                    auto expr = parse_expression(inner).unwrap();
+                    inner.expect(token::Type::Symbol, ")");
+                    stream.m_position = inner.m_position;
+                    return expr;
+                }
 
                 if (auto cast = parse_cast(inner); cast.ok()) {
-                    auto expr = parse_primary_expression(inner).unwrap();
+                    auto expr = parse_expression(inner).unwrap();
                     stream.m_position = inner.m_position;
                     return std::unique_ptr<AST::Expression>{
                         new AST::CastExpression{
@@ -135,13 +120,6 @@ namespace parsing {
                         }
                     };
                 }
-                else if (inner.peek().content == "(") {
-                    inner.next();
-                    auto expr = parse_expression(inner).unwrap();
-                    inner.expect(token::Type::Symbol, ")");
-                    stream.m_position = inner.m_position;
-                    return expr;
-                }
                 else if (inner.peek().content == "&") {
                     inner.next();
                     auto expr = parse_primary_expression(inner).unwrap();
@@ -160,8 +138,7 @@ namespace parsing {
                 }
 
                 auto plain_expr = parse_plain_expression(inner);
-                while (inner.peek().content == "(" || inner.peek().content == "[") {
-                    if (inner.peek().content == "(") {
+                while (inner.peek().content == "(") {
                     inner.next();
 
                     std::vector<std::unique_ptr<AST::Expression>> args{};
@@ -178,12 +155,6 @@ namespace parsing {
                     auto fn_call = new AST::FunctionCallExpression{ before_meta + inner.metadata(), plain_expr.unwrap(), std::move(args) };
                     plain_expr = std::unique_ptr<AST::Expression>{ fn_call };
                 }
-                    else if (auto postfix = parse_array_postfix(inner, false); postfix.ok()) {
-                        auto idx_expr = new AST::IndexAccessExpression{
-                            before_meta + inner.metadata(), plain_expr.unwrap(), *postfix.unwrap() };
-                        plain_expr = std::unique_ptr<AST::Expression>{ idx_expr };
-                    }
-                }
 
 
                 stream.m_position = inner.m_position;
@@ -273,22 +244,6 @@ namespace parsing {
                 auto ty = parse_type(inner).unwrap();
                 auto name = inner.expect(token::Type::Ident);
 
-                auto array_postfix = parse_array_postfix(inner, false);
-                while (array_postfix.ok()) {
-                    auto postfix = array_postfix.unwrap();
-                    if (postfix) {
-                        ty = std::shared_ptr<types::Type>{
-                            new types::ArrayType(ty, *postfix)
-                        };
-                    }
-                    else {
-                        ty = std::shared_ptr<types::Type>{
-                            new types::PointerType(ty)
-                        };
-                    }
-                    array_postfix = parse_array_postfix(inner, false);
-                }
-
                 std::optional<std::unique_ptr<AST::Expression>> expr = {};
                 if (inner.peek().type == token::Type::Symbol && inner.peek().content == "=") {
                     inner.expect(token::Type::Symbol, "=");

src/tokens.cpp

@@ -159,13 +159,13 @@ namespace token {
                 i++; // Skip second "
                 tokens.push_back(token::Token{ token::Type::LiteralStr, content, meta + (content.size() + 2) });
             }
-            else if (std::isalpha(c) || c == '_') {
+            else if (std::isalpha(c)) {
                 std::string content{};
                 do {
                     content += c;
                     if ((i + 1) >= text_length) break;
                     c = text[++i];
-                } while (std::isalnum(c) || c == '_');
+                } while (std::isalnum(c));
 
                 token::Type type = token::Type::Ident;
                 if (content == "return") {

src/typechecker.cpp

@@ -89,7 +89,7 @@ namespace AST {
         auto char_ty = std::shared_ptr<types::Type>{
             new types::FundamentalType{ types::FundamentalTypeKind::Char }
         };
-        auto ptr_ty = new types::ArrayType{ char_ty, static_cast<uint32_t>(this->m_value.size()) + 1 };
+        auto ptr_ty = new types::PointerType{ char_ty };
         return std::shared_ptr<types::Type>{ptr_ty};
     }
 
@@ -281,34 +281,6 @@ namespace AST {
         return ptr_ty->m_inner;
     }
 
-    std::shared_ptr<types::Type> IndexAccessExpression::typecheck(
-        typecheck::State& state,
-        typecheck::Scope& scope,
-        std::optional<std::shared_ptr<types::Type>>
-    ) {
-        auto expr_ty = this->m_expr->typecheck(state, scope, {});
-        if (expr_ty->m_kind != types::TypeKind::Pointer && expr_ty->m_kind != types::TypeKind::Array) {
-            state.errors.push_back(
-                CompileError("Tried to index " + expr_ty->formatted(), this->m_meta));
-            return std::shared_ptr<types::Type> {
-                new types::FundamentalType{ types::FundamentalTypeKind::Void }
-            };
-        }
-        if (expr_ty->m_kind == types::TypeKind::Pointer) {
-            auto ptr_ty = dynamic_cast<types::PointerType*>(expr_ty.get());
-            return ptr_ty->m_inner;
-        }
-        else if (expr_ty->m_kind == types::TypeKind::Array) {
-            auto ptr_ty = dynamic_cast<types::ArrayType*>(expr_ty.get());
-            return ptr_ty->m_inner;
-        }
-
-        // Default return type
-        return std::shared_ptr<types::Type> {
-            new types::FundamentalType{ types::FundamentalTypeKind::Void }
-        };
-    }
-
 
     void ReturnStatement::typecheck(typecheck::State& state, typecheck::Scope& scope) {
         auto res_ty = this->m_expr->typecheck(state, scope, scope.return_ty);
@@ -320,9 +292,7 @@ namespace AST {
 
     void InitializationStatement::typecheck(typecheck::State& state, typecheck::Scope& scope) {
         if (this->m_expr) {
-            auto expr_ty = (*this->m_expr)->typecheck(state, scope, this->m_type);
-            auto check_res = check_type(state, expr_ty, this->m_type);
-            this->m_expr = handle_res(std::move(*this->m_expr), check_res, state);
+            (*this->m_expr)->typecheck(state, scope, this->m_type);
         }
         scope.symbols[this->m_name] = this->m_type;
     }

src/types.cpp

@@ -1,6 +1,5 @@
 
 #include <sstream>
-#include <iostream>
 
 #include "types.h"
 #include "binops.h"
@@ -55,6 +54,23 @@ namespace types {
         }
     }
 
+
+    llvm::Value* Type::add(codegen::Builder&, llvm::Value*, llvm::Value*) {
+        throw std::runtime_error("Invalid operation for this type");
+    }
+
+    llvm::Value* Type::sub(codegen::Builder&, llvm::Value*, llvm::Value*) {
+        throw std::runtime_error("Invalid operation for this type");
+    }
+
+    llvm::Value* Type::lt(codegen::Builder&, llvm::Value*, llvm::Value*) {
+        throw std::runtime_error("Invalid operation for this type");
+    }
+
+    llvm::Value* Type::gt(codegen::Builder&, llvm::Value*, llvm::Value*) {
+        throw std::runtime_error("Invalid operation for this type");
+    }
+
     std::optional<std::shared_ptr<Type>> Type::return_type() {
         return {};
     }
@@ -68,6 +84,50 @@ namespace types {
         return std::pair(ptr, self);
     }
 
+    llvm::Value* FundamentalType::add(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) {
+        switch (this->m_ty) {
+        case FundamentalTypeKind::Int:
+        case FundamentalTypeKind::Bool:
+        case FundamentalTypeKind::Char:
+            return builder.builder->CreateAdd(lhs, rhs, "add");
+        default:
+            throw std::runtime_error("Invalid type for add");
+        }
+    }
+
+    llvm::Value* FundamentalType::sub(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) {
+        switch (this->m_ty) {
+        case FundamentalTypeKind::Int:
+        case FundamentalTypeKind::Bool:
+        case FundamentalTypeKind::Char:
+            return builder.builder->CreateSub(lhs, rhs, "sub");
+        default:
+            throw std::runtime_error("Invalid type");
+        }
+    }
+
+    llvm::Value* FundamentalType::lt(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) {
+        switch (this->m_ty) {
+        case FundamentalTypeKind::Int:
+        case FundamentalTypeKind::Bool:
+        case FundamentalTypeKind::Char:
+            return builder.builder->CreateCmp(llvm::CmpInst::Predicate::ICMP_SLT, lhs, rhs, "cmp");
+        default:
+            throw std::runtime_error("Invalid type");
+        }
+    }
+
+    llvm::Value* FundamentalType::gt(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) {
+        switch (this->m_ty) {
+        case FundamentalTypeKind::Int:
+        case FundamentalTypeKind::Bool:
+        case FundamentalTypeKind::Char:
+            return builder.builder->CreateCmp(llvm::CmpInst::Predicate::ICMP_SGT, lhs, rhs);
+        default:
+            throw std::runtime_error("Invalid type");
+        }
+    }
+
     bool FundamentalType::is_signed() {
         switch (this->m_ty) {
         case FundamentalTypeKind::Int:
@@ -144,34 +204,7 @@ namespace types {
         return 64;
     }
 
-    std::string ArrayType::formatted() {
-        std::stringstream out{ "" };
-        out << this->m_inner->formatted();
-        out << "[" << this->m_size << "]";
-        return out.str();
-    }
-
-    std::pair<llvm::Value*, std::shared_ptr<Type>> ArrayType::load(codegen::Builder&, llvm::Value* ptr) {
-        auto self = std::make_shared<ArrayType>(*this);
-        return std::pair(ptr, self);
-    }
-
-    uint32_t ArrayType::size() {
-        return this->m_size * this->m_inner->size();
-    }
-
     bool types_equal(std::shared_ptr<types::Type> type1, std::shared_ptr<types::Type> type2) {
-        // if (type1->m_kind == TypeKind::Array && type2->m_kind == TypeKind::Pointer) {
-        //     auto ty1 = dynamic_cast<ArrayType*>(type1.get());
-        //     auto ty2 = dynamic_cast<PointerType*>(type2.get());
-        //     return types_equal(ty1->m_inner, ty2->m_inner);
-        // }
-        // else if (type1->m_kind == TypeKind::Pointer && type2->m_kind == TypeKind::Array) {
-        //     auto ty1 = dynamic_cast<PointerType*>(type1.get());
-        //     auto ty2 = dynamic_cast<ArrayType*>(type2.get());
-        //     return types_equal(ty1->m_inner, ty2->m_inner);
-        // }
-
         if (type1->m_kind != type2->m_kind)
             return false;
 
@@ -206,12 +239,6 @@ namespace types {
 
             return types_equal(ty1->m_inner, ty2->m_inner);
         }
-        else if (type1->m_kind == TypeKind::Array) {
-            auto ty1 = dynamic_cast<ArrayType*>(type1.get());
-            auto ty2 = dynamic_cast<ArrayType*>(type2.get());
-
-            return types_equal(ty1->m_inner, ty2->m_inner) && ty1->m_size == ty2->m_size;
-        }
         else {
             return false;
         }

src/types.h

@@ -11,7 +11,6 @@ namespace types {
         Fundamental,
         Function,
         Pointer,
-        Array,
     };
 
     enum FundamentalTypeKind {
@@ -32,6 +31,10 @@ namespace types {
         virtual llvm::Type* codegen(codegen::Builder& builder) = 0;
         virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) = 0;
         virtual std::optional<std::shared_ptr<Type>> return_type();
+        virtual llvm::Value* add(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs);
+        virtual llvm::Value* sub(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs);
+        virtual llvm::Value* lt(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs);
+        virtual llvm::Value* gt(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs);
         virtual bool is_signed();
         virtual uint32_t size() = 0;
     };
@@ -44,6 +47,10 @@ namespace types {
         virtual std::string formatted() override;
         virtual llvm::Type* codegen(codegen::Builder& builder) override;
         virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) override;
+        virtual llvm::Value* add(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) override;
+        virtual llvm::Value* sub(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) override;
+        virtual llvm::Value* lt(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) override;
+        virtual llvm::Value* gt(codegen::Builder& builder, llvm::Value* lhs, llvm::Value* rhs) override;
         virtual bool is_signed() override;
         virtual uint32_t size() override;
     };
@@ -68,10 +75,11 @@ namespace types {
         virtual uint32_t size() override;
     };
 
+
+
     class PointerType : public Type {
     public:
         std::shared_ptr<Type> m_inner;
-
         PointerType(std::shared_ptr<Type> inner)
             : Type(TypeKind::Pointer), m_inner{ std::move(inner) } {
         }
@@ -82,21 +90,6 @@ namespace types {
         virtual uint32_t size() override;
     };
 
-    class ArrayType : public Type {
-    public:
-        std::shared_ptr<Type> m_inner;
-        uint32_t m_size;
-
-        ArrayType(std::shared_ptr<Type> inner, uint32_t size)
-            : Type(TypeKind::Array), m_inner{ std::move(inner) }, m_size{ size } {
-        }
-        virtual ~ArrayType() override = default;
-        virtual std::string formatted() override;
-        virtual llvm::Type* codegen(codegen::Builder& builder) override;
-        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) override;
-        virtual uint32_t size() override;
-    };
-
     bool types_equal(std::shared_ptr<types::Type> type1, std::shared_ptr<types::Type> type2);
 }
 

test.c

@@ -6,19 +6,13 @@ int fibonacci(int n) {
     return fibonacci(n - 1) + fibonacci(n - 2);
 }
 
-void modify_value(char* otus) {
+void modifyvalue(char* otus) {
     *otus = 20;
 }
 
 int main() {
-    char text[29] = "10th fibonacci number is %d!";
-    printf(text, fibonacci(10));
-
-    char somelist[5];
-
-    somelist[0] = 15;
-    somelist[1] = 20;
-    somelist[2] = 25;
-
-    return somelist[0];
+    printf("10th fibonacci number is %d!", fibonacci(10));
+    char res = 10;
+    modifyvalue(&res);
+    return res;
 }