Add ArrayType

src/codegen.cpp

@@ -291,4 +291,11 @@ namespace types {
     llvm::Type* PointerType::codegen(codegen::Builder& builder) {
         return llvm::PointerType::get(*builder.context, 0);
     }
+
+    llvm::Type* ArrayType::codegen(codegen::Builder& builder) {
+        if (this->m_size) {
+            return llvm::ArrayType::get(this->m_inner->codegen(builder), *this->m_size);
+        }
+        return llvm::PointerType::get(*builder.context, 0);
+    }
 }

src/types.cpp

@@ -143,6 +143,26 @@ namespace types {
         return 64;
     }
 
+    std::string ArrayType::formatted() {
+        std::stringstream out{ "" };
+        out << this->m_inner->formatted();
+        if (this->m_size)
+            out << "[" << *this->m_size << "]";
+        else
+            out << "[]";
+        return out.str();
+    }
+
+    uint32_t ArrayType::size() {
+        if (this->m_size) {
+            return (*this->m_size) * this->m_inner->size();
+        }
+        else {
+            // Acts as a pointer type otherwise
+            return 64;
+        }
+    }
+
     bool types_equal(std::shared_ptr<types::Type> type1, std::shared_ptr<types::Type> type2) {
         if (type1->m_kind != type2->m_kind)
             return false;

src/types.h

@@ -11,6 +11,7 @@ namespace types {
         Fundamental,
         Function,
         Pointer,
+        Array,
     };
 
     enum FundamentalTypeKind {
@@ -67,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) } {
         }
@@ -82,6 +82,20 @@ namespace types {
         virtual uint32_t size() override;
     };
 
+    class ArrayType : public Type {
+    public:
+        std::shared_ptr<Type> m_inner;
+        std::optional<uint32_t> m_size;
+
+        ArrayType(std::shared_ptr<Type> inner, std::optional<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 uint32_t size() override;
+    };
+
     bool types_equal(std::shared_ptr<types::Type> type1, std::shared_ptr<types::Type> type2);
 }
 

test.c

@@ -12,6 +12,9 @@ void modify_value(char* otus) {
 
 int main() {
     printf("10th fibonacci number is %d!", fibonacci(10));
+
+    char somelist[5];
+
     char res = 10;
     modify_value(&res);
     return res;