Fix array to ptr cast

src/ast.cpp

@@ -61,6 +61,13 @@ 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,6 +211,30 @@ 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,6 +53,25 @@ 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,13 +26,16 @@ namespace AST {
     }
 
     codegen::StackValue StringLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope&) {
-
-        auto stack_type = new types::PointerType{ std::make_unique<types::FundamentalType>(types::FundamentalTypeKind::Char) };
+        auto stack_type = new types::ArrayType{
+            std::make_unique<types::FundamentalType>(types::FundamentalTypeKind::Char),
+            static_cast<uint32_t>(this->m_value.size()) + 1
+        };
 
         auto str = llvm::StringRef{ this->m_value.c_str() };
+        auto global_str = builder.builder->CreateGlobalString(str);
 
         return codegen::StackValue{
-            builder.builder->CreateGlobalString(str),
+            builder.builder->CreateLoad(stack_type->codegen(builder), global_str, "literal"),
             std::unique_ptr<types::Type>{stack_type},
         };
     }
@@ -103,6 +106,14 @@ 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
@@ -131,6 +142,59 @@ 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;
@@ -291,4 +355,8 @@ 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,6 +162,8 @@ 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,6 +49,28 @@ 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 {
@@ -101,16 +123,9 @@ 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_expression(inner).unwrap();
+                    auto expr = parse_primary_expression(inner).unwrap();
                     stream.m_position = inner.m_position;
                     return std::unique_ptr<AST::Expression>{
                         new AST::CastExpression{
@@ -120,6 +135,13 @@ 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();
@@ -138,22 +160,29 @@ namespace parsing {
                 }
 
                 auto plain_expr = parse_plain_expression(inner);
-                while (inner.peek().content == "(") {
-                    inner.next();
+                while (inner.peek().content == "(" || inner.peek().content == "[") {
+                    if (inner.peek().content == "(") {
+                        inner.next();
 
-                    std::vector<std::unique_ptr<AST::Expression>> args{};
+                        std::vector<std::unique_ptr<AST::Expression>> args{};
 
-                    int counter = 0;
-                    while (inner.peek().content != ")") {
-                        if (counter++ > 0)
-                            inner.expect(token::Type::Symbol, ",");
-                        args.push_back(parse_expression(inner).unwrap());
+                        int counter = 0;
+                        while (inner.peek().content != ")") {
+                            if (counter++ > 0)
+                                inner.expect(token::Type::Symbol, ",");
+                            args.push_back(parse_expression(inner).unwrap());
+                        }
+
+                        inner.expect(token::Type::Symbol, ")");
+
+                        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 };
                     }
-
-                    inner.expect(token::Type::Symbol, ")");
-
-                    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 };
                 }
 
 
@@ -244,6 +273,22 @@ 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)) {
+            else if (std::isalpha(c) || c == '_') {
                 std::string content{};
                 do {
                     content += c;
                     if ((i + 1) >= text_length) break;
                     c = text[++i];
-                } while (std::isalnum(c));
+                } while (std::isalnum(c) || 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::PointerType{ char_ty };
+        auto ptr_ty = new types::ArrayType{ char_ty, static_cast<uint32_t>(this->m_value.size()) + 1 };
         return std::shared_ptr<types::Type>{ptr_ty};
     }
 
@@ -281,6 +281,34 @@ 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);
@@ -292,7 +320,9 @@ namespace AST {
 
     void InitializationStatement::typecheck(typecheck::State& state, typecheck::Scope& scope) {
         if (this->m_expr) {
-            (*this->m_expr)->typecheck(state, scope, this->m_type);
+            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);
         }
         scope.symbols[this->m_name] = this->m_type;
     }

src/types.cpp

@@ -1,5 +1,6 @@
 
 #include <sstream>
+#include <iostream>
 
 #include "types.h"
 #include "binops.h"
@@ -54,23 +55,6 @@ 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 {};
     }
@@ -84,50 +68,6 @@ 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:
@@ -204,7 +144,34 @@ 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;
 
@@ -239,6 +206,12 @@ 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,6 +11,7 @@ namespace types {
         Fundamental,
         Function,
         Pointer,
+        Array,
     };
 
     enum FundamentalTypeKind {
@@ -31,10 +32,6 @@ 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;
     };
@@ -47,10 +44,6 @@ 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;
     };
@@ -75,11 +68,10 @@ 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) } {
         }
@@ -90,6 +82,21 @@ 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,13 +6,19 @@ int fibonacci(int n) {
     return fibonacci(n - 1) + fibonacci(n - 2);
 }
 
-void modifyvalue(char* otus) {
+void modify_value(char* otus) {
     *otus = 20;
 }
 
 int main() {
-    printf("10th fibonacci number is %d!", fibonacci(10));
-    char res = 10;
-    modifyvalue(&res);
-    return res;
+    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];
 }