Merge feat/ci-for-tests into develop

.github/workflows/ci.yml

@@ -0,0 +1,35 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - "**"
+      - "!main"
+  pull_request:
+    branches:
+      - "**"
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y wget lsb-release software-properties-common gnupg catch2
+
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 22
+
+          echo "LLVM_DIR=/usr/lib/llvm-22/lib/cmake/llvm" >> $GITHUB_ENV
+
+      - name: Build and Test
+        run: |
+          cmake .
+          make
+          ./bin/tests

CMakeLists.txt

@@ -0,0 +1,74 @@
+cmake_minimum_required(VERSION 3.31.6)
+
+project(alpha)
+
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+include_directories(${CMAKE_SOURCE_DIR}/src)
+
+find_package(LLVM REQUIRED CONFIG)
+
+add_definitions(${LLVM_DEFINITIONS})
+llvm_map_components_to_libnames(llvm_libs 
+    core 
+    support 
+    irreader
+    codegen
+    asmprinter
+    target
+    native
+    TargetParser
+)
+
+
+file(GLOB_RECURSE ALL_SRC_CPP CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
+list(FILTER ALL_SRC_CPP EXCLUDE REGEX ".*main\\.cpp$")
+
+file(GLOB_RECURSE ALL_SRC_HPP CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp")
+
+add_library(alpha_lib STATIC ${ALL_SRC_CPP} ${ALL_SRC_HPP})
+
+target_include_directories(alpha_lib PUBLIC 
+    ${CMAKE_SOURCE_DIR}/src
+    ${LLVM_INCLUDE_DIRS}
+)
+target_link_libraries(alpha_lib PUBLIC ${llvm_libs})
+
+# Main compiler
+
+add_executable(main src/main.cpp)
+
+target_link_libraries(main PRIVATE alpha_lib)
+
+set_target_properties(main PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin
+)
+
+# Tests
+find_package(Catch2 3 REQUIRED)
+
+enable_testing()
+file(GLOB_RECURSE ALL_TEST_CPP CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/tests/*.cpp")
+
+
+add_executable(tests 
+    ${ALL_TEST_CPP}
+)
+
+target_link_libraries(tests PRIVATE 
+    alpha_lib
+    Catch2::Catch2WithMain
+)
+
+get_target_property(Catch2_INCLUDE_DIR Catch2::Catch2 INTERFACE_INCLUDE_DIRECTORIES)
+target_include_directories(tests PRIVATE ${Catch2_INCLUDE_DIR})
+
+include(Catch)
+catch_discover_tests(tests)
+
+set_target_properties(tests PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin
+)

README.md

@@ -8,9 +8,12 @@ The goal of this langauge is to allow for the build up highly nested types, and
 
 The primitves aim to be informative to ensure that there is no ambiguity on how the primitive will function.
 
-| Keyword | Full Name               | Size     |
-| ------- | ----------------------- | -------- |
-| `uint8` | Unsigned Integer 8-bits | `1 byte` |
+| Keyword  | Full Name                | Size (bytes) |
+| -------- | ------------------------ | ------------ |
+| `uint8`  | Unsigned Integer 8-bits  | `1`          |
+| `uint16` | Unsigned Integer 16-bits | `2`          |
+| `uint32` | Unsigned Integer 32-bits | `4`          |
+| `uint64` | Unsigned Integer 64-bits | `8`          |
 
 # Syntax
 

examples/integer_primitives.lang

@@ -0,0 +1,4 @@
+uint8 a = 255;
+uint16 b = 65535;
+uint32 c = 4294967295;
+uint64 d = 18446744073709551615;

examples/print.lang

@@ -0,0 +1,4 @@
+print 1;
+
+uint8 a = 2;
+print a;

src/generation/builder/builder.hpp

@@ -3,6 +3,7 @@
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
@@ -24,6 +25,9 @@ class Builder {
   }
 
   llvm::IntegerType* getUint8() const { return llvm::Type::getInt8Ty(context); }
+  llvm::PointerType* getUint8Ptr() const {
+    return llvm::PointerType::get(this->context, 0);
+  }
 
   llvm::ConstantInt* createConst8(uint8_t value) {
     return llvm::ConstantInt::get(this->getUint8(), value);
@@ -45,6 +49,14 @@ class Builder {
     return llvm::ConstantInt::get(this->getUint32(), value);
   };
 
+  llvm::IntegerType* getUint64() const {
+    return llvm::Type::getInt64Ty(context);
+  }
+
+  llvm::ConstantInt* createConst64(uint64_t value) {
+    return llvm::ConstantInt::get(this->getUint64(), value);
+  };
+
   llvm::ReturnInst* createReturn(llvm::Value* value) {
     return this->irBuilder.CreateRet(value);
   };
@@ -57,15 +69,24 @@ class Builder {
     return this->irBuilder.CreateStore(value, out);
   };
 
-  llvm::LoadInst* load(llvm::Type* type, llvm::Value* value) {
-    return this->irBuilder.CreateLoad(type, value);
+  llvm::LoadInst* load(llvm::Type* type, llvm::Value* value, std::string name) {
+    return this->irBuilder.CreateLoad(type, value, name);
   };
 
-  llvm::Value* add(llvm::Value* lhs, llvm::Value* rhs) {
-    return this->irBuilder.CreateAdd(lhs, rhs);
+  llvm::Value* add(llvm::Value* lhs, llvm::Value* rhs, std::string name) {
+    return this->irBuilder.CreateAdd(lhs, rhs, name);
   };
 
   llvm::Value* zext(llvm::Value* in, llvm::Type* outType) {
     return this->irBuilder.CreateZExt(in, outType);
   };
+
+  llvm::Value* createGlobalStringPtr(std::string str) {
+    return this->irBuilder.CreateGlobalString(str);
+  };
+
+  llvm::CallInst* createCall(llvm::Function* function,
+                             std::vector<llvm::Value*> args) {
+    return this->irBuilder.CreateCall(function, args);
+  }
 };