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/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

@@ -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/parser.c

@@ -130,7 +130,7 @@ 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;
     elf_write_str(elf_data, data);
@@ -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;
@@ -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");