Started making a chess engine and made a make file for the chess program. I will make one for all the test file soon

Author: TheDevConnor

LPBS/ast.lx

@@ -57,8 +57,8 @@ pub const Group -> struct {
 };
 
 #returns_ownership
-pub const create_program_node -> fn (nodes: *Expr) *Stmt {
-  let node: *Program = cast<*Program>(alloc(sizeof<Program>));
+pub const create_program_node -> fn (nodes: *Expr, size: int) *Stmt {
+  let node: *Program = cast<*Program>(alloc(size * sizeof<Program>));
   let base_node: *Stmt = cast<*Stmt>(node);  
 
   base_node.type = StmtKind::STMT_PROGRAM;
@@ -134,7 +134,7 @@ pub const free_expr -> fn (node: *Expr) void {
   if (node == cast<*Expr>(0)) { return; }
 
   switch(node.type) {
-    ExprKind::EXPR_NUMBER, ExprKind::EXPR_IDENT, ExprKind::EXPR_STRING -> {}
+    ExprKind::EXPR_NUMBER, ExprKind::EXPR_IDENT, ExprKind::EXPR_STRING -> { /* No child nodes to free */ }
     ExprKind::EXPR_BINARY -> {
       let bin_node: *Binary = cast<*Binary>(node);
       free_expr(bin_node.left); free_expr(bin_node.right);

LPBS/main.lx

@@ -10,7 +10,7 @@
 pub const main -> fn () int {
   let speed: Timer = time::timer_start();
 
-  let path: *char = "/home/connor/Projects/Luma/LPBS/build.lmb";
+  let path: *char = "/home/thedevconnor/Projects/Luma/LPBS/build.lmb";
   let file: *char = io::read_file(path);
   let lex: *Token = lexer::scan(file);
 

LPBS/parser.lx

@@ -147,5 +147,5 @@ pub const parse -> fn (tks: *Token, path: *char) *Stmt {
 
   let node: *Expr = parse_expr(&psr, BindingPower::BP_NONE);
 
-  return ast::create_program_node(node); 
+  return ast::create_program_node(node, tks.size); 
 }

src/llvm/expr.c

@@ -88,28 +88,28 @@ LLVMValueRef codegen_expr_literal(CodeGenContext *ctx, AstNode *node) {
   case LITERAL_INT:
     return LLVMConstInt(LLVMInt64TypeInContext(ctx->context),
                         node->expr.literal.value.int_val, false);
-                        
+
   case LITERAL_FLOAT:
     return LLVMConstReal(LLVMDoubleTypeInContext(ctx->context),
                          node->expr.literal.value.float_val);
 
   case LITERAL_BOOL:
     return LLVMConstInt(LLVMInt1TypeInContext(ctx->context),
                         node->expr.literal.value.bool_val ? 1 : 0, false);
-                        
+
   case LITERAL_CHAR:
     return LLVMConstInt(LLVMInt8TypeInContext(ctx->context),
                         (unsigned char)node->expr.literal.value.char_val,
                         false);
-                        
+
   case LITERAL_STRING: {
     char *processed_str =
         process_escape_sequences(node->expr.literal.value.string_val);
-    
+
     // String literals must be created in the current module
     LLVMModuleRef current_llvm_module =
         ctx->current_module ? ctx->current_module->module : ctx->module;
-    
+
     // Create the global string in the current module
     LLVMValueRef global_str =
         LLVMAddGlobal(current_llvm_module,
@@ -145,9 +145,10 @@ LLVMValueRef codegen_expr_literal(CodeGenContext *ctx, AstNode *node) {
   case LITERAL_NULL:
     return LLVMConstNull(
         LLVMPointerType(LLVMInt8TypeInContext(ctx->context), 0));
-        
+
   default:
-    fprintf(stderr, "ERROR: Unknown literal type: %d\n", node->expr.literal.lit_type);
+    fprintf(stderr, "ERROR: Unknown literal type: %d\n",
+            node->expr.literal.lit_type);
     return NULL;
   }
 }
@@ -1063,7 +1064,14 @@ LLVMValueRef codegen_expr_index(CodeGenContext *ctx, AstNode *node) {
 
           // If this is the last field in the chain, get its element type
           if (i == chain_length - 1) {
-            element_type = current_struct->field_element_types[field_idx];
+            LLVMTypeRef field_type = current_struct->field_types[field_idx];
+
+            // Check if this field is an array - if so, get its element type
+            if (LLVMGetTypeKind(field_type) == LLVMArrayTypeKind) {
+              element_type = LLVMGetElementType(field_type);
+            } else {
+              element_type = current_struct->field_element_types[field_idx];
+            }
             break;
           }
 

src/llvm/struct.c

@@ -479,7 +479,7 @@ LLVMValueRef codegen_expr_struct_access(CodeGenContext *ctx, AstNode *node) {
     }
 
   } else if (object->type == AST_EXPR_MEMBER) {
-    // **NEW: Handle chained member access like psr.tks.list**
+    // **Handle chained member access like psr.tks.list**
     // First, recursively resolve the base member access
     LLVMValueRef base_value = codegen_expr_struct_access(ctx, object);
     if (!base_value) {
@@ -693,7 +693,20 @@ LLVMValueRef codegen_expr_struct_access(CodeGenContext *ctx, AstNode *node) {
       LLVMBuildStructGEP2(ctx->builder, struct_info->llvm_type, struct_ptr,
                           field_index, "field_ptr");
 
-  // Load the element value
+  // **CRITICAL FIX: Check if this field is an array**
+  LLVMTypeRef field_type = struct_info->field_types[field_index];
+  if (LLVMGetTypeKind(field_type) == LLVMArrayTypeKind) {
+    // For array fields, return a pointer to the first element
+    // This allows subsequent indexing operations to work correctly
+    // Example: rule.move_offsets[i] where move_offsets is [int; 16]
+    LLVMValueRef zero =
+        LLVMConstInt(LLVMInt32TypeInContext(ctx->context), 0, false);
+    LLVMValueRef indices[2] = {zero, zero};
+    return LLVMBuildGEP2(ctx->builder, field_type, field_ptr, indices, 2,
+                         "array_field_ptr");
+  }
+
+  // Load the element value (for non-array fields)
   LLVMValueRef result =
       LLVMBuildLoad2(ctx->builder, struct_info->field_types[field_index],
                      field_ptr, "field_val");

std/terminal.lx

@@ -180,3 +180,16 @@ pub const get_terminal_size -> fn () void {
     system("tput lines > /tmp/luma_lines");
     // Read back from files...
 }
+
+pub const get_line -> fn (prompt: *char, buffer: *char, size: int) void {
+  output(prompt);
+  let i: int = 0;
+  loop (i < size - 1) : (++i) {
+    let c: char = getch();
+    if (c == '\n' || c == '\r') {
+      break;
+    }
+    buffer[i] = c;
+  }
+  buffer[i] = '\0';
+}