Succcessful generation of functions

.vscode/launch.json

@@ -64,6 +64,22 @@
       "miDebuggerPath": "/usr/bin/gdb",
       "cwd": "${workspaceFolder}",
       "preLaunchTask": "Run Parser Test"
+    },
+    {
+      "name": "Run Generator Test",
+      "type": "cppdbg",
+      "request": "launch",
+      "program": "${workspaceFolder}/src/backend/generator/generator_test",
+      "args": [
+        "${workspaceFolder}/examples/a.glx"
+      ],
+      "stopAtEntry": false,
+      "environment": [],
+      "externalConsole": false,
+      "MIMode": "gdb",
+      "miDebuggerPath": "/usr/bin/gdb",
+      "cwd": "${workspaceFolder}",
+      "preLaunchTask": "Run Generator Test"
     }
   ]
 }

.vscode/tasks.json

@@ -63,6 +63,24 @@
         "cwd": "${workspaceFolder}"
       }
     },
+    {
+      "label": "Run Generator Test",
+      "type": "shell",
+      "command": "./src/backend/generator/generator_test",
+      "args": [
+        "./examples/a.glx"
+      ],
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "problemMatcher": [
+        "$gcc"
+      ],
+      "options": {
+        "cwd": "${workspaceFolder}"
+      }
+    },
     {
       "type": "cppbuild",
       "label": "C/C++: gcc build active file",

README.md

@@ -25,14 +25,14 @@ Take a look at our [contributors guide](https://github.com/galaxy-lang/galaxy/bl
 
 ---
 
-### Installation
+### Build the project
 
 Install all the dependencies:
 ```bash
 sudo apt install clang cmake make llvm llvm-dev zlib1g-dev
 ```
 
-Or you can [compile LLVM from source](https://github.com/llvm/llvm-project).
+Or you can [download the built LLVM](https://github.com/llvm/llvm-project/releases/tag/llvmorg-18.1.8).
 
 Clone the repo and compile the code:
 

examples/a.glx

@@ -1 +1,7 @@
-string oi := makonha == 3 ? "true" : "false";
+def my_return( int i) -> int: 
+  return i; 
+end; 
+
+def main( ) -> int: 
+  return my_return( 10) ; 
+end;

include/backend/generator/expressions/generate_call.hpp

@@ -0,0 +1,12 @@
+#ifndef GENERATE_CALL_H
+#define GENERATE_CALL_H
+
+extern "C" {
+  #include "frontend/ast/definitions.h"
+}
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IR/IRBuilder.h>
+
+llvm::Value *generate_call(CallNode *node, llvm::LLVMContext &Context, llvm::IRBuilder<> &Builder, llvm::Module &TheModule);
+
+#endif // GENERATE_CALL_H

include/backend/generator/statements/generate_function_declaration_stmt.hpp

@@ -1,6 +1,7 @@
 #ifndef GENERATE_FUNCTION_DECLARATION_STMT_H
 #define GENERATE_FUNCTION_DECLARATION_STMT_H
 
+#include <map>
 extern "C" {
   #include "frontend/ast/definitions.h"
 }

include/backend/generator/symbols/function_symbol_table.hpp

@@ -0,0 +1,10 @@
+#ifndef FUNCTION_SYMBOL_TABLE_H
+#define FUNCTION_SYMBOL_TABLE_H
+
+#include <unordered_map>
+#include <string>
+#include <llvm/IR/Function.h>
+
+extern std::unordered_map<std::string, llvm::Function *> function_symbol_table;
+
+#endif // FUNCTION_SYMBOL_TABLE_H

include/backend/generator/symbols/identifier_symbol_table.hpp

@@ -0,0 +1,11 @@
+#ifndef IDENTIFIER_SYMBOL_TABLE_H
+#define IDENTIFIER_SYMBOL_TABLE_H
+
+#include <unordered_map>
+#include <string>
+#include <llvm/IR/Function.h>
+
+llvm::Value* find_identifier(const std::string &name);
+void add_identifier(const std::string &name, llvm::Value *value);
+
+#endif // IDENTIFIER_SYMBOL_TABLE_H

include/backend/generator/symbols/symbol_stack.hpp

@@ -0,0 +1,15 @@
+#ifndef SYMBOL_STACK_H
+#define SYMBOL_STACK_H
+
+#include <string>
+#include <unordered_map>
+#include <stack>
+#include <llvm/IR/Value.h>
+
+using SymbolTable = std::unordered_map<std::string, llvm::Value*>;
+
+extern std::stack<SymbolTable> symbol_stack;
+void enter_scope(void);
+void exit_scope(void);
+
+#endif // SYMBOL_STACK_H

include/frontend/ast/definitions.h

@@ -31,10 +31,20 @@ typedef enum {
     NODE_ARRAY_ACCESS,
     NODE_TERNARY,
     NODE_STRING,
+    NODE_RETURN,
+    NODE_BOOLEAN_LITERAL,
 } NodeType;
 
 typedef struct AstNode AstNode; 
 
+typedef struct {
+    char *value;
+} BooleanLiteralNode;
+
+typedef struct {
+    AstNode *value;
+} ReturnNode;
+
 typedef struct {
     AstNode *condition;
     AstNode *consequent;
@@ -49,6 +59,7 @@ typedef struct {
 typedef struct {
     AstNode *caller;
     AstNode **args;
+    size_t arg_count;
 } CallNode;
 
 typedef struct {

include/frontend/parser/printer/nodes/expressions/print_boolean.h

@@ -0,0 +1,8 @@
+#ifndef PRINT_BOOLEAN_H
+#define PRINT_BOOLEAN_H
+
+#include "frontend/ast/definitions.h"
+
+void print_boolean(const AstNode *node, int depth);
+
+#endif // PRINT_BOOLEAN_H

include/frontend/parser/printer/nodes/expressions/print_call.h

@@ -0,0 +1,9 @@
+#ifndef PRINT_CALL_H
+#define PRINT_CALL_H
+
+#include "frontend/ast/definitions.h"
+#include "frontend/parser/printer/visited.h"
+
+void print_call(const AstNode *node, int depth, VisitedNodes *visited);
+
+#endif // PRINT_CALL_H

include/frontend/parser/printer/nodes/expressions/print_return.h

@@ -0,0 +1,9 @@
+#ifndef PRINT_RETURN_H
+#define PRINT_RETURN_H
+
+#include "frontend/ast/definitions.h"
+#include "frontend/parser/printer/visited.h"
+
+void print_return(const AstNode *node, int depth, VisitedNodes *visited);
+
+#endif // PRINT_RETURN_H

src/backend/generator/expressions/generate_call.cpp

@@ -0,0 +1,50 @@
+#include "backend/generator/statements/generate_function_declaration_stmt.hpp"
+#include "backend/generator/statements/generate_stmt.hpp"
+#include "backend/generator/expressions/generate_expr.hpp"
+#include "backend/generator/types/generate_type.hpp"
+#include "backend/generator/symbols/function_symbol_table.hpp"
+
+llvm::Value *generate_call(CallNode *call_node, llvm::LLVMContext &Context, llvm::IRBuilder<> &Builder, llvm::Module &Module) {
+    if (!call_node || !call_node->caller) {
+        throw std::runtime_error("Invalid call expression: missing caller.");
+    }
+
+    // Assume the caller is a function name (e.g., NODE_IDENTIFIER)
+    IdentifierNode *identifier = static_cast<IdentifierNode *>(call_node->caller->data);
+    const std::string &function_name = identifier->symbol;
+
+    // Lookup the function in the symbol table
+    auto it = function_symbol_table.find(function_name);
+    if (it == function_symbol_table.end()) {
+        throw std::runtime_error("Function not found in symbol table: " + function_name);
+    }
+
+    llvm::Function *function = it->second;
+    llvm::FunctionType *func_type = function->getFunctionType();
+
+    // Generate arguments
+    std::vector<llvm::Value *> args;
+    for (size_t i = 0; i < call_node->arg_count; ++i) {
+        llvm::Value *arg = generate_expr(call_node->args[i], Context, Builder, Module);
+        if (!arg) {
+            throw std::runtime_error("Failed to generate call argument.");
+        }
+
+        // Ensure the argument type matches the function parameter type
+        llvm::Type *expected_type = func_type->getParamType(i);
+        if (arg->getType() != expected_type) {
+            if (arg->getType()->isIntegerTy() && expected_type->isIntegerTy()) {
+                arg = Builder.CreateIntCast(arg, expected_type, true);
+            } else if (arg->getType()->isFloatingPointTy() && expected_type->isFloatingPointTy()) {
+                arg = Builder.CreateFPCast(arg, expected_type);
+            } else {
+                throw std::runtime_error("Argument type mismatch.");
+            }
+        }
+
+        args.push_back(arg);
+    }
+
+    // Create the call instruction
+    return Builder.CreateCall(function, args);
+}

src/backend/generator/expressions/generate_expr.cpp

@@ -8,6 +8,7 @@
 #include "backend/generator/expressions/generate_pre_increment.hpp"
 #include "backend/generator/expressions/generate_pre_decrement.hpp"
 #include "backend/generator/expressions/generate_assignment_expr.hpp"
+#include "backend/generator/expressions/generate_call.hpp"
 
 llvm::Value *generate_expr(AstNode *node, llvm::LLVMContext &Context, llvm::IRBuilder<> &Builder, llvm::Module &Module) {
     // Checks the node kind, casts the node data into
@@ -17,6 +18,10 @@ llvm::Value *generate_expr(AstNode *node, llvm::LLVMContext &Context, llvm::IRBu
             NumericLiteralNode *num_node = (NumericLiteralNode *)node->data;
             return generate_numeric_literal(num_node, Context);
         }
+        case NODE_CALL: {
+            CallNode *call_node = (CallNode *)node->data;
+            return generate_call(call_node, Context, Builder, Module);
+        }
         case NODE_IDENTIFIER: {
             IdentifierNode *id_node = (IdentifierNode *)node->data;
             return generate_identifier(id_node);

src/backend/generator/expressions/generate_identifier.cpp

@@ -1,17 +1,15 @@
 #include "backend/generator/expressions/generate_identifier.hpp"
-
-// A map that associates variable names (symbols) with their corresponding LLVM values.
-std::map<std::string, llvm::Value *> NamedValues;
+#include "backend/generator/symbols/identifier_symbol_table.hpp"
 
 llvm::Value *generate_identifier(IdentifierNode *node) {
-    // Search for the identifier in the NamedValues map using the symbol name
-    auto it = NamedValues.find(node->symbol);
-    
-    // If the identifier is not found in the map
-    if (it == NamedValues.end()) {
-        // TODO: Handle the case where the identifier is not found (e.g., variable not declared)
+    // Usa find_identifier para buscar o valor associado ao símbolo no escopo atual
+    llvm::Value *value = find_identifier(node->symbol);
+
+    // Verifica se o identificador foi encontrado
+    if (!value) {
+        throw std::runtime_error("Error: identifier not found!");
     }
 
-    // Return the LLVM Value associated with the found identifier
-    return it->second; 
+    // Retorna o LLVM Value associado ao identificador
+    return value;
 }

src/backend/generator/generator.test.cpp

@@ -77,14 +77,6 @@ int main(int argc, char **argv) {
     llvm::Module TheModule("GalaxyJIT", TheContext);
     llvm::IRBuilder<> Builder(TheContext);
 
-    // Create the main function in the LLVM module (returns void)
-    llvm::FunctionType* funcType = llvm::FunctionType::get(llvm::Type::getVoidTy(TheContext), false);
-    llvm::Function* mainFunc = llvm::Function::Create(funcType, llvm::Function::ExternalLinkage, "main", &TheModule);
-
-    // Create the entry basic block for the main function
-    llvm::BasicBlock* entry = llvm::BasicBlock::Create(TheContext, "entry", mainFunc);
-    Builder.SetInsertPoint(entry);
-
     // Generate the LLVM IR from the AST
     std::vector<llvm::Value*> values = generate_ir(ast, TheContext, TheModule, Builder);
 
@@ -98,9 +90,6 @@ int main(int argc, char **argv) {
         }
     }
 
-    // End the main function with a return statement (for void functions)
-    Builder.CreateRetVoid();
-
     // Verify the generated module for correctness
     std::string errorMsg;
     llvm::raw_string_ostream errorStream(errorMsg);