Support complex pointer arithmetic in dereference

Previously, the parser only handled simple identifier dereference (*var)
and would crash on complex expressions like *(ptr + offset). This change
extends the dereference operator handling to accept general expressions
in parentheses.

This enables compilation of previously failing patterns:
- *(p + 4) - direct offset
- *(p + i + 2) - variable in expression
- *(p + i * 2) - arithmetic in expression

It also handles consecutive asterisks ('**pp', '***ppp') by counting
dereference levels and applying them iteratively.

Author: jserv

src/parser.c

@@ -964,23 +964,63 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
         }
     } else if (lex_accept(T_asterisk)) {
         /* dereference */
-        char token[MAX_VAR_LEN];
-        lvalue_t lvalue;
-
-        int open_bracket = lex_accept(T_open_bracket);
-        if (open_bracket) {
-            /* Handle expressions like *(++p) */
+        if (lex_peek(T_open_bracket, NULL)) {
+            /* Handle general expression dereference: *(expr) */
+            lex_expect(T_open_bracket);
             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;
+            /* For pointer dereference, we need to determine the target type and
+             * size. Since we do not have full type tracking in expressions, use
+             * defaults
+             */
+            type_t *deref_type = rs1->type ? rs1->type : TY_int;
+            int deref_ptr = rs1->is_ptr > 0 ? rs1->is_ptr - 1 : 0;
+
+            vd = require_deref_var(parent, deref_type, deref_ptr);
+            if (deref_ptr > 0)
+                sz = PTR_SIZE;
+            else
+                sz = deref_type->size;
             gen_name_to(vd->var_name);
             opstack_push(vd);
-            add_insn(parent, *bb, OP_read, vd, rs1, NULL, vd->type->size, NULL);
+            add_insn(parent, *bb, OP_read, vd, rs1, NULL, sz, NULL);
+        } else if (lex_peek(T_asterisk, NULL)) {
+            /* Handle consecutive asterisks for multiple dereference: **pp,
+             * ***ppp
+             */
+            int deref_count = 1; /* We already consumed one asterisk */
+            while (lex_accept(T_asterisk))
+                deref_count++;
+
+            /* Now read the base expression (should be an identifier) */
+            char token[MAX_VAR_LEN];
+            lvalue_t lvalue;
+
+            lex_peek(T_identifier, token);
+            var_t *var = find_var(token, parent);
+            read_lvalue(&lvalue, var, parent, bb, true, OP_generic);
+
+            /* Apply dereferences one by one */
+            for (int i = 0; i < deref_count; i++) {
+                rs1 = opstack_pop();
+                vd = require_deref_var(
+                    parent, var->type,
+                    lvalue.is_ptr > i ? lvalue.is_ptr - i - 1 : 0);
+                if (lvalue.is_ptr > i + 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 {
+            /* Handle simple identifier dereference: *var */
+            char token[MAX_VAR_LEN];
+            lvalue_t lvalue;
+
             lex_peek(T_identifier, token);
             var_t *var = find_var(token, parent);
             read_lvalue(&lvalue, var, parent, bb, true, OP_generic);