Made it so that arrays are padded

TheDevConnor · TheDevConnor · commit 7ea404541090 · 2025-11-10T09:07:54.000-05:00
diff --git a/src/ast/ast.h b/src/ast/ast.h
@@ -234,6 +234,7 @@ struct AstNode {
         struct {
           AstNode **elements; // Changed from Expr** to AstNode**
           size_t element_count;
+          size_t target_size;
         } array;
 
         // Deref expression
diff --git a/src/ast/ast_definistions/expr.c b/src/ast/ast_definistions/expr.c
@@ -131,6 +131,7 @@ AstNode *create_array_expr(ArenaAllocator *arena, AstNode **elements,
   AstNode *node = create_expr(arena, AST_EXPR_ARRAY, line, column);
   node->expr.array.elements = elements;
   node->expr.array.element_count = element_count;
+  node->expr.array.target_size = 0; // Default to 0 (no explicit size)
   return node;
 }
 
diff --git a/src/helper/run.c b/src/helper/run.c
@@ -128,8 +128,13 @@ bool link_object_files(const char *output_dir, const char *executable_name, int
   char command[2048];
 
   // Build the linking command with PIE-compatible flags
-  snprintf(command, sizeof(command), "cc -O%d -pie %s/*.o -o %s", 
-         opt_level, output_dir, executable_name);
+  if (opt_level > 0) { // If optimization level is specified
+    snprintf(command, sizeof(command), "cc -O%d -pie %s/*.o -o %s", 
+        opt_level, output_dir, executable_name);
+  } else { // No optimization
+    snprintf(command, sizeof(command), "cc -pie %s/*.o -o %s", 
+        output_dir, executable_name);
+  }
 
   int result = system(command);
   if (result != 0) {
diff --git a/src/llvm/expr.c b/src/llvm/expr.c
@@ -874,6 +874,7 @@ LLVMValueRef codegen_expr_array(CodeGenContext *ctx, AstNode *node) {
 
   AstNode **elements = node->expr.array.elements;
   size_t element_count = node->expr.array.element_count;
+  size_t target_size = node->expr.array.target_size; // NEW: Get target size for padding
 
   if (element_count == 0) {
     fprintf(stderr, "Error: Empty array literals not supported\n");
@@ -888,16 +889,21 @@ LLVMValueRef codegen_expr_array(CodeGenContext *ctx, AstNode *node) {
   }
 
   LLVMTypeRef element_type = LLVMTypeOf(first_element);
-  LLVMTypeRef array_type = LLVMArrayType(element_type, element_count);
+  
+  // NEW: Use target_size if set (for padding), otherwise use actual element_count
+  size_t actual_array_size = (target_size > 0) ? target_size : element_count;
+  LLVMTypeRef array_type = LLVMArrayType(element_type, actual_array_size);
 
   // Check if all elements are constants
   bool all_constants = LLVMIsConstant(first_element);
+  
+  // NEW: Allocate for the FULL size (including padding)
   LLVMValueRef *element_values = (LLVMValueRef *)arena_alloc(
-      ctx->arena, sizeof(LLVMValueRef) * element_count, alignof(LLVMValueRef));
+      ctx->arena, sizeof(LLVMValueRef) * actual_array_size, alignof(LLVMValueRef));
 
   element_values[0] = first_element;
 
-  // Generate remaining elements and check for constants
+  // Generate provided elements
   for (size_t i = 1; i < element_count; i++) {
     element_values[i] = codegen_expr(ctx, elements[i]);
     if (!element_values[i]) {
@@ -922,9 +928,21 @@ LLVMValueRef codegen_expr_array(CodeGenContext *ctx, AstNode *node) {
     }
   }
 
-  // *** ADD THE NEW CODE HERE ***
+  // NEW: Pad remaining elements with zeros if target_size > element_count
+  if (target_size > element_count) {
+    LLVMValueRef zero_value = LLVMConstNull(element_type);
+    
+    for (size_t i = element_count; i < target_size; i++) {
+      element_values[i] = zero_value;
+    }
+    
+    // If we're padding, we can't be all constants unless zeros count
+    // (which they do, so keep checking)
+    // zero_value is always constant, so all_constants remains unchanged
+  }
+
   // Check if any element references a global from another module
-  for (size_t i = 0; i < element_count && all_constants; i++) {
+  for (size_t i = 0; i < actual_array_size && all_constants; i++) {
     if (LLVMIsConstant(element_values[i]) &&
         LLVMIsAGlobalVariable(element_values[i])) {
       // Check if it's from a different module
@@ -937,17 +955,16 @@ LLVMValueRef codegen_expr_array(CodeGenContext *ctx, AstNode *node) {
       }
     }
   }
-  // *** END NEW CODE ***
 
   if (all_constants) {
-    // Create constant array
-    return LLVMConstArray(element_type, element_values, element_count);
+    // Create constant array (now with padding)
+    return LLVMConstArray(element_type, element_values, actual_array_size);
   } else {
-    // Create runtime array
+    // Create runtime array (now with padding)
     LLVMValueRef array_alloca =
         LLVMBuildAlloca(ctx->builder, array_type, "array_literal");
 
-    for (size_t i = 0; i < element_count; i++) {
+    for (size_t i = 0; i < actual_array_size; i++) {
       // Create GEP to element
       LLVMValueRef indices[2];
       indices[0] = LLVMConstInt(LLVMInt32TypeInContext(ctx->context), 0, false);
diff --git a/src/typechecker/expr.c b/src/typechecker/expr.c
@@ -457,6 +457,57 @@ AstNode *typecheck_call_expr(AstNode *expr, Scope *scope,
     }
 
     TypeMatchResult match = types_match(param_types[i], arg_type);
+    
+    // NEW: Special handling for array argument padding
+    // If the parameter expects a larger array than provided, allow it with padding
+    if (match == TYPE_MATCH_NONE && 
+        param_types[i]->type == AST_TYPE_ARRAY && 
+        arg_type->type == AST_TYPE_ARRAY) {
+      
+      // Check if element types match
+      TypeMatchResult element_match = 
+          types_match(param_types[i]->type_data.array.element_type,
+                      arg_type->type_data.array.element_type);
+      
+      if (element_match != TYPE_MATCH_NONE) {
+        // Element types match, check sizes
+        AstNode *param_size = param_types[i]->type_data.array.size;
+        AstNode *arg_size = arg_type->type_data.array.size;
+        
+        if (param_size && arg_size &&
+            param_size->type == AST_EXPR_LITERAL && 
+            arg_size->type == AST_EXPR_LITERAL &&
+            param_size->expr.literal.lit_type == LITERAL_INT &&
+            arg_size->expr.literal.lit_type == LITERAL_INT) {
+          
+          long long param_size_val = param_size->expr.literal.value.int_val;
+          long long arg_size_val = arg_size->expr.literal.value.int_val;
+          
+          // If argument array is smaller than parameter, allow it with padding
+          if (arg_size_val <= param_size_val) {
+            // Set a flag on the argument node to indicate it needs padding
+            // This will be handled by the code generator
+            if (arguments[i]->type == AST_EXPR_ARRAY) {
+              // Mark this array for padding to param_size_val elements
+              // Store the target size for the code generator to use
+              arguments[i]->expr.array.target_size = (size_t)param_size_val;
+            }
+            
+            // Continue to next argument - this is valid
+            continue;
+          } else {
+            // Argument array is LARGER than parameter - this is an error
+            tc_error_help(
+                expr, "Array Size Mismatch",
+                "Cannot pass larger array to function expecting smaller array",
+                "Argument %zu: parameter expects array of size %lld, got size %lld",
+                i + 1, param_size_val, arg_size_val);
+            return NULL;
+          }
+        }
+      }
+    }
+    
     if (match == TYPE_MATCH_NONE) {
       const char *param_str = type_to_string(param_types[i], arena);
       const char *arg_str = type_to_string(arg_type, arena);
@@ -1301,7 +1352,12 @@ AstNode *typecheck_array_expr(AstNode *expr, Scope *scope,
     }
   }
 
-  // Create array size literal
+  // NEW: Check if this array is being used in a context with an expected size
+  // This happens during function call argument checking
+  // We'll set a flag on the array expression to indicate it should be padded
+  
+  // For now, just create the array type with the actual element count
+  // The padding will be handled during code generation or in a separate pass
   long long size_val = (long long)element_count;
   AstNode *size_expr = create_literal_expr(arena, LITERAL_INT, &size_val,
                                            expr->line, expr->column);
diff --git a/std/string.lx b/std/string.lx
@@ -1,5 +1,8 @@
 @module "string"
 
+pub const cat -> fn (dest: *char, s1: *char, s2: *char) *char;
+pub const strlen -> fn (s: *char) int;
+
 #returns_ownership 
 pub const from_char -> fn (c: char) *char {
   let s: *char = cast<*char>(alloc(2 * sizeof<char>));
@@ -45,6 +48,34 @@ pub const from_int -> fn (n: int) *char {
   return s;
 }
 
+#returns_ownership
+pub const from_float -> fn (f: float, precision: int) *char {
+  let int_part: int = cast<int>(f);
+  let frac_part: float = f - cast<float>(int_part);
+  
+  let int_str: *char = from_int(int_part);
+  defer { free(int_str); }
+  
+  let frac_str: *char = cast<*char>(alloc((precision + 2) * sizeof<char>)); // +1 for '.' +1 for null
+  frac_str[0] = '.';
+  
+  loop [i: int = 1](i <= precision) : (++i) {
+    frac_part = frac_part * 10.0;
+    let digit: int = cast<int>(frac_part);
+    frac_str[i] = cast<char>(digit + cast<int>('0'));
+    frac_part = frac_part - cast<float>(digit);
+  }
+  
+  frac_str[precision + 1] = cast<char>(0); // null terminator
+  
+  let result_len: int = strlen(int_str) + strlen(frac_str) + 1;
+  let result: *char = cast<*char>(alloc(result_len * sizeof<char>));
+  
+  cat(result, int_str, frac_str);
+  
+  return result;
+}
+
 pub const int_to_str -> fn (num: int, buf: *char, buf_size: int) void {
   let idx: int = 0;
   let temp: int = num;
diff --git a/std/sys.lx b/std/sys.lx
@@ -18,6 +18,8 @@
  */
 @module "sys"
 
+@use "string" as string
+
 // TODO: Allow enums to have a custom assigned value
 // Syscall numbers (Linux x86_64)
 pub const SYS_READ: int = 0;
@@ -296,8 +298,88 @@ pub const write_str -> fn (fd: int, s: *char) int {
 }
 
 // Print to stdout
-pub const print -> fn (s: *char) int {
-    return write_str(STDOUT, s);
+// This takes in a msg and an array of args to format into the msg
+pub const print_int -> fn (s: *char, args: [int; 256]) int {
+    // Simple implementation: only supports %d for integers
+    let buffer: *char = cast<*char>(alloc(1024 * sizeof<char>));
+    let buf_index: int = 0;
+    let arg_index: int = 0;
+    defer { free(buffer); }
+    
+    let i: int = 0;
+    loop (s[i] != cast<char>(0)) : (++i) {
+        if (s[i] == '%' && s[i + 1] == 'd' && arg_index < 256) {
+            let num_str: *char = string::from_int(args[arg_index]);
+            defer { free(num_str); }
+
+            loop [j: int = 0](num_str[j] != cast<char>(0)) : (++j) {
+                buffer[buf_index] = num_str[j];
+                buf_index = buf_index + 1;
+            }
+            arg_index = arg_index + 1;
+            i = i + 1; // Skip 'd'
+        } else {
+            buffer[buf_index] = s[i];
+            buf_index = buf_index + 1;
+        }
+    }
+    buffer[buf_index] = cast<char>(0); // Null-terminate
+
+    let written: int = write_str(STDOUT, buffer);
+    return written;
+}
+
+pub const print_str -> fn (s: *char, args: [*char; 256]) int {
+    // Simple implementation: only supports %s for strings
+    let buffer: *char = cast<*char>(alloc(1024 * sizeof<char>));
+    let buf_index: int = 0;
+    let arg_index: int = 0;
+    defer { free(buffer); }
+    
+    let i: int = 0;
+    loop (s[i] != cast<char>(0)) : (++i) {
+        if (s[i] == '%' && s[i + 1] == 's' && arg_index < 256) {
+            let str_arg: *char = args[arg_index];
+            loop [j: int = 0](str_arg[j] != cast<char>(0)) : (++j) {
+                buffer[buf_index] = str_arg[j];
+                buf_index = buf_index + 1;
+            }
+            arg_index = arg_index + 1;
+            i = i + 1; // Skip 's'
+        } else {
+            buffer[buf_index] = s[i];
+            buf_index = buf_index + 1;
+        }
+    }
+    buffer[buf_index] = cast<char>(0); // Null-terminate
+
+    let written: int = write_str(STDOUT, buffer);
+    return written;
+}
+
+pub const print_char -> fn (s: *char, args: [char; 256]) int {
+    // Simple implementation: only supports %c for characters
+    let buffer: *char = cast<*char>(alloc(1024 * sizeof<char>));
+    let buf_index: int = 0;
+    let arg_index: int = 0;
+    defer { free(buffer); }
+    
+    let i: int = 0;
+    loop (s[i] != cast<char>(0)) : (++i) {
+        if (s[i] == '%' && s[i + 1] == 'c' && arg_index < 256) {
+            buffer[buf_index] = args[arg_index];
+            buf_index = buf_index + 1;
+            arg_index = arg_index + 1;
+            i = i + 1; // Skip 'c'
+        } else {
+            buffer[buf_index] = s[i];
+            buf_index = buf_index + 1;
+        }
+    }
+    buffer[buf_index] = cast<char>(0); // Null-terminate
+
+    let written: int = write_str(STDOUT, buffer);
+    return written;
 }
 
 // Print to stderr
diff --git a/std/termfx.lx b/std/termfx.lx
@@ -48,11 +48,11 @@ pub const INVERT: *char        = "\x1b[7m";  // swap fg/bg
 pub const HIDDEN: *char        = "\x1b[8m";  // invisible text
 pub const STRIKETHROUGH: *char = "\x1b[9m";
 
-pub const CLEAR_SCREEN: *char     = "\x1b[2J";
-pub const CLEAR_LINE: *char       = "\x1b[2K";
-pub const CURSOR_HOME: *char      = "\x1b[H";
-pub const CURSOR_HIDE: *char      = "\x1b[?25l";
-pub const CURSOR_SHOW: *char      = "\x1b[?25h";
+pub const CLEAR_SCREEN: *char  = "\x1b[2J";
+pub const CLEAR_LINE: *char    = "\x1b[2K";
+pub const CURSOR_HOME: *char   = "\x1b[H";
+pub const CURSOR_HIDE: *char   = "\x1b[?25l";
+pub const CURSOR_SHOW: *char   = "\x1b[?25h";
 
 pub const SAVE_CURSOR: *char    = "\x1b[s";
 pub const RESTORE_CURSOR: *char = "\x1b[u";
diff --git a/tests/chess_engine/board.lx b/tests/chess_engine/board.lx
@@ -15,9 +15,9 @@ pub const Board -> struct {
   length_fen: int,
   squares: *char,
 
-  white_can_castle_kingside: int,
+  white_can_castle_kingside:  int,
   white_can_castle_queenside: int,
-  black_can_castle_kingside: int,
+  black_can_castle_kingside:  int,
   black_can_castle_queenside: int,
 };
 
diff --git a/tests/test.lx b/tests/test.lx
@@ -1,9 +1,19 @@
 @module "main"
 
-const Point -> struct { x: int, y: int };
+@use "sys" as sys
+
+pub const Point -> struct {
+  vertex: *char,
+  x: int,
+  y: int
+};
 
 pub const main -> fn () int { 
-  let y: Point = Point { x: 50, y: 10 };
-  output(y.x, " ", y.y, "\n");
+  let y: Point = Point { vertex: "A" ,x: 50, y: 10 };
+
+  sys::print_int("Point coordinates: (%d, %d)\n", [y.x, y.y]);
+  sys::print_str("Point vertex: %s\n", [y.vertex]);
+  sys::print_char("Point vertex first char: %c\n", [y.vertex[0]]);
+
   return 0; 
 }

Original file line number	Diff line number	Diff line change
`@@ -131,6 +131,7 @@ AstNode create_array_expr(ArenaAllocator arena, AstNode **elements,`
`131`	`131`	`AstNode *node = create_expr(arena, AST_EXPR_ARRAY, line, column);`
`132`	`132`	`node->expr.array.elements = elements;`
`133`	`133`	`node->expr.array.element_count = element_count;`
	`134`	`+ node->expr.array.target_size = 0; // Default to 0 (no explicit size)`
`134`	`135`	`return node;`
`135`	`136`	`}`
`136`	`137`