Add va_list typedef and variadic function support

This commit adds va_list typedef for basic variadic function support and
implement typedef pointer handling in parser (typedef char *string).

In addition, this fixes *(++p) expression parsing in dereference context
and corrects pointer arithmetic to increment by type size instead of 1.

Close #202

Author: jserv

lib/c.c

@@ -45,6 +45,9 @@
 
 typedef int FILE;
 
+/* va_list support for variadic functions */
+typedef int *va_list;
+
 void abort(void);
 
 int strlen(char *str)

src/defs.h

@@ -372,6 +372,7 @@ struct type {
     int size;
     var_t fields[MAX_FIELDS];
     int num_fields;
+    int is_ptr; /* pointer level for typedef pointer types */
 };
 
 /* lvalue details */

src/parser.c

@@ -715,6 +715,11 @@ void read_full_var_decl(var_t *vd, int anon, int is_param)
     }
 
     vd->type = type;
+
+    /* Inherit pointer level from typedef */
+    if (type->is_ptr > 0)
+        vd->is_ptr = type->is_ptr;
+
     read_inner_var_decl(vd, anon, is_param);
 }
 
@@ -963,21 +968,33 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
         lvalue_t lvalue;
 
         int open_bracket = lex_accept(T_open_bracket);
-        lex_peek(T_identifier, token);
-        var_t *var = find_var(token, parent);
-        read_lvalue(&lvalue, var, parent, bb, true, OP_generic);
-        if (open_bracket)
+        if (open_bracket) {
+            /* Handle expressions like *(++p) */
+            read_expr(parent, bb);
             lex_expect(T_close_bracket);
+            rs1 = opstack_pop();
+            /* Create a temporary variable for the dereferenced result */
+            vd = require_var(parent);
+            vd->type = TY_int; /* Default to int type for now */
+            vd->is_ptr = 0;
+            gen_name_to(vd->var_name);
+            opstack_push(vd);
+            add_insn(parent, *bb, OP_read, vd, rs1, NULL, vd->type->size, NULL);
+        } else {
+            lex_peek(T_identifier, token);
+            var_t *var = find_var(token, parent);
+            read_lvalue(&lvalue, var, parent, bb, true, OP_generic);
 
-        rs1 = opstack_pop();
-        vd = require_deref_var(parent, var->type, var->is_ptr);
-        if (lvalue.is_ptr > 1)
-            sz = PTR_SIZE;
-        else
-            sz = lvalue.type->size;
-        gen_name_to(vd->var_name);
-        opstack_push(vd);
-        add_insn(parent, *bb, OP_read, vd, rs1, NULL, sz, NULL);
+            rs1 = opstack_pop();
+            vd = require_deref_var(parent, var->type, var->is_ptr);
+            if (lvalue.is_ptr > 1)
+                sz = PTR_SIZE;
+            else
+                sz = lvalue.type->size;
+            gen_name_to(vd->var_name);
+            opstack_push(vd);
+            add_insn(parent, *bb, OP_read, vd, rs1, NULL, sz, NULL);
+        }
     } else if (lex_accept(T_open_bracket)) {
         read_expr(parent, bb);
         read_ternary_operation(parent, bb);
@@ -1529,7 +1546,12 @@ void read_lvalue(lvalue_t *lvalue,
         if (prefix_op != OP_generic) {
             vd = require_var(parent);
             gen_name_to(vd->var_name);
-            vd->init_val = 1;
+            /* For pointer arithmetic, increment by the size of pointed-to type
+             */
+            if (lvalue->is_ptr)
+                vd->init_val = lvalue->type->size;
+            else
+                vd->init_val = 1;
             opstack_push(vd);
             add_insn(parent, *bb, OP_load_constant, vd, NULL, NULL, 0, NULL);
 
@@ -1550,6 +1572,8 @@ void read_lvalue(lvalue_t *lvalue,
                  */
                 add_insn(parent, *bb, OP_write, NULL, vd, rs1, lvalue->size,
                          NULL);
+                /* Push the new value onto the operand stack */
+                opstack_push(rs1);
             } else {
                 rs1 = vd;
                 vd = operand_stack[operand_stack_idx - 1];
@@ -3037,6 +3061,14 @@ void read_global_statement(void)
             type->base_type = base->base_type;
             type->size = base->size;
             type->num_fields = 0;
+            type->is_ptr = 0;
+
+            /* Handle pointer types in typedef: typedef char *string; */
+            while (lex_accept(T_asterisk)) {
+                type->is_ptr++;
+                type->size = PTR_SIZE;
+            }
+
             lex_ident(T_identifier, type->type_name);
             lex_expect(T_semicolon);
         }

tests/driver.sh

@@ -1342,7 +1342,7 @@ int main()
 }
 EOF
 
-# Logical-and, for loop condition 
+# Logical-and, for loop condition
 try_output 0 "10" << EOF
 int main()
 {
@@ -1940,4 +1940,266 @@ int main()
 }
 EOF
 
+# va_list and variadic function tests
+# Note: Basic variadic functions now work with the typedef pointer fix.
+# These tests use direct pointer arithmetic since shecc has limitations
+# with va_list typedef forwarding between functions.
+
+# Test 1: Sum calculation using variadic arguments
+try_output 0 "Sum: 15" << EOF
+int calculate_sum(int count, ...)
+{
+    int sum = 0;
+    int i;
+    int *p;
+
+    p = &count;
+    p++;
+
+    for (i = 0; i < count; i++)
+        sum += p[i];
+
+    return sum;
+}
+
+int main()
+{
+    int result = calculate_sum(5, 1, 2, 3, 4, 5);
+    printf("Sum: %d", result);
+    return 0;
+}
+EOF
+
+# Test 2: Multiple integer arguments
+try_output 0 "Multi: 10 20 255" << EOF
+void multi_arg_test(int first, ...)
+{
+    int *p;
+    int val1, val2;
+
+    /* Point to variadic arguments */
+    p = &first;
+    p++;
+
+    /* Get integer values */
+    val1 = p[0];
+    val2 = p[1];
+
+    printf("Multi: %d %d %d", first, val1, val2);
+}
+
+int main()
+{
+    multi_arg_test(10, 20, 255);
+    return 0;
+}
+EOF
+
+# Test 3: Variable argument count with different values
+try_output 0 "Args: 1=100 2=200 3=300" << EOF
+void print_args(int count, ...)
+{
+    int *p = &count;
+    int i;
+
+    p++;
+    printf("Args:");
+    for (i = 0; i < count; i++)
+        printf(" %d=%d", i + 1, p[i]);
+}
+
+int main()
+{
+    print_args(3, 100, 200, 300);
+    return 0;
+}
+EOF
+
+# Test 4: Mixed argument types (integers with different sizes)
+try_output 0 "Values: 42 -17 0 999" << EOF
+void mixed_args(int first, ...)
+{
+    int *p = &first;
+
+    printf("Values: %d", first);
+    printf(" %d", *(++p));
+    printf(" %d", *(++p));
+    printf(" %d", *(++p));
+}
+
+int main()
+{
+    mixed_args(42, -17, 0, 999);
+    return 0;
+}
+EOF
+
+# Test 5: Minimum and maximum finder
+try_output 0 "Min: 5, Max: 50" << EOF
+void find_min_max(int count, ...)
+{
+    int *p = &count;
+    int i, min, max;
+
+    p++;
+    min = p[0];
+    max = p[0];
+
+    for (i = 1; i < count; i++) {
+        if (p[i] < min) min = p[i];
+        if (p[i] > max) max = p[i];
+    }
+
+    printf("Min: %d, Max: %d", min, max);
+}
+
+int main()
+{
+    find_min_max(4, 10, 50, 5, 25);
+    return 0;
+}
+EOF
+
+# Test 6: Simple printf-like function
+try_output 0 "ERROR: Failed with code 42" << EOF
+void error_log(int code, ...)
+{
+    printf("ERROR: Failed with code %d", code);
+}
+
+int main()
+{
+    error_log(42);
+    return 0;
+}
+EOF
+
+# Test 7: Function with single variadic argument
+try_output 0 "Single extra: 123" << EOF
+void single_extra(int base, ...)
+{
+    int *p = &base;
+    p++;
+    printf("Single extra: %d", *p);
+}
+
+int main()
+{
+    single_extra(0, 123);
+    return 0;
+}
+EOF
+
+# Test 8: Zero additional arguments
+try_output 0 "Only required: 77" << EOF
+void only_required(int value, ...)
+{
+    printf("Only required: %d", value);
+}
+
+int main()
+{
+    only_required(77);
+    return 0;
+}
+EOF
+
+# Test 9: Arithmetic operations on variadic arguments
+try_output 0 "Result: 25" << EOF
+int arithmetic_va(int count, ...)
+{
+    int *p = &count;
+    int result = 0;
+    int i;
+
+    p++;
+    for (i = 0; i < count; i++) {
+        if (i % 2 == 0)
+            result += p[i];
+        else
+            result -= p[i];
+    }
+    return result;
+}
+
+int main()
+{
+    int res = arithmetic_va(4, 20, 5, 15, 5);  /* 20 - 5 + 15 - 5 = 25 */
+    printf("Result: %d", res);
+    return 0;
+}
+EOF
+
+# Test 10: Simple working variadic function test
+try_output 0 "Variadic: 60" << EOF
+int sum_three(int a, ...)
+{
+    int *p = &a;
+    int v1 = p[0];
+    int v2 = p[1];
+    int v3 = p[2];
+    return v1 + v2 + v3;
+}
+
+int main()
+{
+    printf("Variadic: %d", sum_three(10, 20, 30));
+    return 0;
+}
+EOF
+
+# typedef pointer tests
+try_ 42 << EOF
+typedef int *int_ptr;
+
+int main(void)
+{
+    int x = 42;
+    int_ptr p = &x;
+    return *p;
+}
+EOF
+
+try_output 0 "Hello" << EOF
+typedef char *string;
+
+int main(void)
+{
+    char buf[] = "Hello";
+    string str = buf;
+    printf("%s", str);
+    return 0;
+}
+EOF
+
+try_output 0 "Pointer arithmetic: 10 20 30" << EOF
+typedef int *int_ptr;
+
+int main(void)
+{
+    int a = 10, b = 20, c = 30;
+    int_ptr ptr = &a;
+
+    printf("Pointer arithmetic:");
+    printf(" %d", *ptr);
+    ptr = &b;
+    printf(" %d", *ptr);
+    ptr = &c;
+    printf(" %d", *ptr);
+    return 0;
+}
+EOF
+
+try_output 0 "Value: 42" << EOF
+typedef int *int_ptr;
+
+int main(void)
+{
+    int value = 42;
+    int_ptr iptr = &value;
+    printf("Value: %d", *iptr);
+    return 0;
+}
+EOF
+
 echo OK