Add const qualifier support

The implementation allows shecc to parse and handle const qualifiers in
C code, improving type safety and C standard compliance.

The parser can now handle const qualifiers after pointer asterisks,
enabling declarations like 'int * const ptr' where the pointer itself
is const (but the pointed-to value can change).

Note: This is still partial support as patterns like 'int const *ptr'
are not yet handled. Full const qualifier support would require tracking
const-ness of pointers separately from const-ness of pointed-to data.

Author: jserv

src/arm-codegen.c

@@ -188,9 +188,9 @@ void emit(int code)
 void emit_ph2_ir(ph2_ir_t *ph2_ir)
 {
     func_t *func;
-    int rd = ph2_ir->dest;
-    int rn = ph2_ir->src0;
-    int rm = ph2_ir->src1;
+    const int rd = ph2_ir->dest;
+    const int rn = ph2_ir->src0;
+    const int rm = ph2_ir->src1;
     int ofs;
 
     /* Prepare this variable to reuse code for:

src/defs.h

@@ -179,6 +179,7 @@ typedef enum {
     T_break,
     T_default,
     T_continue,
+    T_const, /* const qualifier */
     /* C pre-processor directives */
     T_cppd_include,
     T_cppd_define,
@@ -353,7 +354,8 @@ struct var {
     int ptr_level;
     bool is_func;
     bool is_global;
-    bool address_taken; /* true if variable address was taken (&var) */
+    bool is_const_qualified; /* true if variable has const qualifier */
+    bool address_taken;      /* true if variable address was taken (&var) */
     int array_size;
     int array_dim1, array_dim2; /* first/second dimension size for 2D arrays */
     int offset;   /* offset from stack or frame, index 0 is reserved */

src/elf.c

@@ -13,7 +13,7 @@
 
 int elf_symbol_index;
 
-void elf_write_str(strbuf_t *elf_array, char *vals)
+void elf_write_str(strbuf_t *elf_array, const char *vals)
 {
     /*
      * Note that strbuf_puts() does not push the null character.
@@ -348,7 +348,7 @@ void elf_align(void)
         elf_write_byte(elf_strtab, 0);
 }
 
-void elf_add_symbol(char *symbol, int pc)
+void elf_add_symbol(const char *symbol, int pc)
 {
     /* Check for null pointers to prevent crashes */
     if (!symbol || !elf_symtab || !elf_strtab) {
@@ -366,7 +366,7 @@ void elf_add_symbol(char *symbol, int pc)
     elf_symbol_index++;
 }
 
-void elf_generate(char *outfile)
+void elf_generate(const char *outfile)
 {
     elf_align();
     elf_generate_header();

src/globals.c

@@ -173,16 +173,16 @@ void *arena_alloc(arena_t *arena, int size)
     }
 
     /* Align to sizeof(void*) bytes for host compatibility */
-    int alignment = sizeof(void *);
+    const int alignment = sizeof(void *);
     size = (size + alignment - 1) & ~(alignment - 1);
 
     if (!arena->head || arena->head->offset + size > arena->head->capacity) {
         /* Need a new block: choose capacity = max(DEFAULT_ARENA_SIZE,
          * arena->block_size, size) */
-        int base =
+        const int base =
             (arena->block_size > DEFAULT_ARENA_SIZE ? arena->block_size
                                                     : DEFAULT_ARENA_SIZE);
-        int new_capacity = (size > base ? size : base);
+        const int new_capacity = (size > base ? size : base);
         arena_block_t *new_block = arena_block_create(new_capacity);
         new_block->next = arena->head;
         arena->head = new_block;
@@ -282,7 +282,7 @@ void *arena_realloc(arena_t *arena, char *oldptr, int oldsz, int newsz)
  */
 char *arena_strdup(arena_t *arena, char *str)
 {
-    int n = strlen(str);
+    const int n = strlen(str);
     char *dup = arena_alloc(arena, n + 1);
     memcpy(dup, str, n);
     dup[n] = '\0';
@@ -368,14 +368,14 @@ void arena_free(arena_t *arena)
  */
 int hashmap_hash_index(int size, char *key)
 {
-    int hash = 0x811c9dc5, mask;
+    int hash = 0x811c9dc5;
 
     for (; *key; key++) {
         hash ^= *key;
         hash *= 0x01000193;
     }
 
-    mask = hash >> 31;
+    const int mask = hash >> 31;
     return ((hash ^ mask) - mask) & (size - 1);
 }
 
@@ -431,7 +431,7 @@ hashmap_node_t *hashmap_node_new(char *key, void *val)
     if (!key)
         return NULL;
 
-    int len = strlen(key);
+    const int len = strlen(key);
     hashmap_node_t *node = arena_alloc(HASHMAP_ARENA, sizeof(hashmap_node_t));
 
 
@@ -1159,7 +1159,7 @@ bool strbuf_putc(strbuf_t *src, char value)
     return true;
 }
 
-bool strbuf_puts(strbuf_t *src, char *value)
+bool strbuf_puts(strbuf_t *src, const char *value)
 {
     int len = strlen(value);
 

src/lexer.c

@@ -12,7 +12,7 @@
 
 /* Hash table constants */
 #define NUM_DIRECTIVES 11
-#define NUM_KEYWORDS 16
+#define NUM_KEYWORDS 17
 
 /* Token mapping structure for elegant initialization */
 typedef struct {
@@ -86,6 +86,7 @@ void lex_init_keywords()
         {"default", T_default},
         {"continue", T_continue},
         {"union", T_union},
+        {"const", T_const},
     };
 
     /* hashmap insertion */
@@ -787,13 +788,15 @@ token_t lex_token_impl(bool aliasing)
                 keyword = T_case;
             break;
 
-        case 5: /* 5-letter keywords: while, break, union */
+        case 5: /* 5-letter keywords: while, break, union, const */
             if (token_str[0] == 'w' && !memcmp(token_str, "while", 5))
                 keyword = T_while;
             else if (token_str[0] == 'b' && !memcmp(token_str, "break", 5))
                 keyword = T_break;
             else if (token_str[0] == 'u' && !memcmp(token_str, "union", 5))
                 keyword = T_union;
+            else if (token_str[0] == 'c' && !memcmp(token_str, "const", 5))
+                keyword = T_const;
             break;
 
         case 6: /* 6-letter keywords: return, struct, switch, sizeof */

src/opt-sccp.c

@@ -122,7 +122,7 @@ bool simple_sccp(func_t *func)
                 if (insn->rs1 && insn->rs1->is_const && insn->rs2 &&
                     insn->rs2->is_const && !insn->rd->is_global) {
                     int result = 0;
-                    int l = insn->rs1->init_val, r = insn->rs2->init_val;
+                    const int l = insn->rs1->init_val, r = insn->rs2->init_val;
 
                     /* Compute result based on operation type */
                     switch (insn->opcode) {

src/parser.c

@@ -130,9 +130,9 @@ var_t *opstack_pop(void)
 
 void read_expr(block_t *parent, basic_block_t **bb);
 
-int write_symbol(char *data)
+int write_symbol(const char *data)
 {
-    int start_len = elf_data->size;
+    const int start_len = elf_data->size;
     elf_write_str(elf_data, data);
     elf_write_byte(elf_data, 0);
     return start_len;
@@ -1191,11 +1191,19 @@ void parse_array_init(var_t *var,
 
 void read_inner_var_decl(var_t *vd, bool anon, bool is_param)
 {
-    vd->init_val = 0;
     /* Preserve typedef pointer level - don't reset if already inherited */
+    vd->init_val = 0;
 
-    while (lex_accept(T_asterisk))
+    while (lex_accept(T_asterisk)) {
         vd->ptr_level++;
+        /* Check for const after asterisk (e.g., int * const ptr).
+         * For now, we just consume const qualifiers after pointer.
+         * Full support would require tracking const-ness of the pointer
+         * itself vs the pointed-to data separately.
+         */
+        while (lex_peek(T_const, NULL))
+            lex_accept(T_const);
+    }
 
     /* is it function pointer declaration? */
     if (lex_accept(T_open_bracket)) {
@@ -1325,8 +1333,15 @@ void read_parameter_list_decl(func_t *func, bool anon)
         lex_accept(T_comma);
     }
 
-    while (lex_peek(T_identifier, NULL) == 1) {
-        read_full_var_decl(&func->param_defs[vn++], anon, true);
+    while (lex_peek(T_identifier, NULL) == 1 || lex_peek(T_const, NULL)) {
+        /* Check for const qualifier */
+        bool is_const = false;
+        if (lex_accept(T_const))
+            is_const = true;
+
+        read_full_var_decl(&func->param_defs[vn], anon, true);
+        func->param_defs[vn].is_const_qualified = is_const;
+        vn++;
         lex_accept(T_comma);
     }
     func->num_params = vn;
@@ -1360,7 +1375,7 @@ void read_literal_param(block_t *parent, basic_block_t *bb)
         combined_len += literal_len;
     }
 
-    int index = write_symbol(combined);
+    const int index = write_symbol(combined);
 
     var_t *vd = require_typed_ptr_var(parent, TY_char, true);
     gen_name_to(vd->var_name);
@@ -3808,6 +3823,7 @@ basic_block_t *read_body_statement(block_t *parent, basic_block_t *bb)
     type_t *type;
     var_t *vd, *rs1, *rs2, *var;
     opcode_t prefix_op = OP_generic;
+    bool is_const = false;
 
     if (!bb)
         printf("Warning: unreachable code detected\n");
@@ -4127,6 +4143,7 @@ basic_block_t *read_body_statement(block_t *parent, basic_block_t *bb)
         type = find_type(token, find_type_flag);
         if (type) {
             var = require_typed_var(parent, type);
+            var->is_const_qualified = is_const;
             read_partial_var_decl(var, NULL);
             add_insn(parent, bb, OP_allocat, var, NULL, NULL, 0, NULL);
             add_symbol(bb, var);
@@ -4332,14 +4349,22 @@ basic_block_t *read_body_statement(block_t *parent, basic_block_t *bb)
         error("Unknown struct/union type");
     }
 
+    /* Handle const qualifier for local variable declarations */
+    if (lex_accept(T_const)) {
+        is_const = true;
+        /* After const, we expect a type */
+        if (!lex_peek(T_identifier, token))
+            error("Expected type after const");
+    }
+
     /* statement with prefix */
-    if (lex_accept(T_increment))
+    if (!is_const && lex_accept(T_increment))
         prefix_op = OP_add;
-    else if (lex_accept(T_decrement))
+    else if (!is_const && lex_accept(T_decrement))
         prefix_op = OP_sub;
     /* must be an identifier or asterisk (for pointer dereference) */
     bool has_asterisk = lex_peek(T_asterisk, NULL);
-    if (!lex_peek(T_identifier, token) && !has_asterisk)
+    if (!is_const && !lex_peek(T_identifier, token) && !has_asterisk)
         error("Unexpected token");
 
     /* handle macro parameter substitution for statements */
@@ -4411,6 +4436,7 @@ basic_block_t *read_body_statement(block_t *parent, basic_block_t *bb)
 
     if (type) {
         var = require_typed_var(parent, type);
+        var->is_const_qualified = is_const;
         read_full_var_decl(var, false, false);
         add_insn(parent, bb, OP_allocat, var, NULL, NULL, 0, NULL);
         add_symbol(bb, var);
@@ -4729,10 +4755,11 @@ void read_func_body(func_t *func)
 }
 
 /* if first token is type */
-void read_global_decl(block_t *block)
+void read_global_decl(block_t *block, bool is_const)
 {
     var_t *var = require_var(block);
     var->is_global = true;
+    var->is_const_qualified = is_const;
 
     /* new function, or variables under parent */
     read_full_var_decl(var, false, false);
@@ -4818,6 +4845,7 @@ void initialize_struct_field(var_t *nv, var_t *v, int offset)
     nv->ptr_level = 0;
     nv->is_func = false;
     nv->is_global = false;
+    nv->is_const_qualified = false;
     nv->array_size = 0;
     nv->offset = offset;
     nv->init_val = 0;
@@ -4832,6 +4860,11 @@ void read_global_statement(void)
 {
     char token[MAX_ID_LEN];
     block_t *block = GLOBAL_BLOCK; /* global block */
+    bool is_const = false;
+
+    /* Handle const qualifier */
+    if (lex_accept(T_const))
+        is_const = true;
 
     if (lex_accept(T_struct)) {
         int i = 0, size = 0;
@@ -4847,6 +4880,7 @@ void read_global_statement(void)
             /* one or more declarators */
             var_t *var = require_typed_var(block, decl_type);
             var->is_global = true; /* Global struct variable */
+            var->is_const_qualified = is_const;
             read_partial_var_decl(var, NULL);
             add_insn(block, GLOBAL_FUNC->bbs, OP_allocat, var, NULL, NULL, 0,
                      NULL);
@@ -5144,7 +5178,7 @@ void read_global_statement(void)
             lex_expect(T_semicolon);
         }
     } else if (lex_peek(T_identifier, NULL)) {
-        read_global_decl(block);
+        read_global_decl(block, is_const);
     } else
         error("Syntax error in global statement");
 }
@@ -5155,6 +5189,7 @@ void parse_internal(void)
     GLOBAL_FUNC = add_func("", true);
     GLOBAL_FUNC->stack_size = 4;
     GLOBAL_FUNC->bbs = arena_calloc(BB_ARENA, 1, sizeof(basic_block_t));
+    GLOBAL_FUNC->bbs->belong_to = GLOBAL_FUNC; /* Prevent nullptr deref in RA */
 
     /* built-in types */
     TY_void = add_named_type("void");

src/reg-alloc.c

@@ -887,9 +887,9 @@ void dump_ph2_ir(void)
     for (int i = 0; i < ph2_ir_idx; i++) {
         ph2_ir_t *ph2_ir = PH2_IR_FLATTEN[i];
 
-        int rd = ph2_ir->dest + 48;
-        int rs1 = ph2_ir->src0 + 48;
-        int rs2 = ph2_ir->src1 + 48;
+        const int rd = ph2_ir->dest + 48;
+        const int rs1 = ph2_ir->src0 + 48;
+        const int rs2 = ph2_ir->src1 + 48;
 
         switch (ph2_ir->op) {
         case OP_define: