kit

parser_core.c (18287B)

---

 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "internal.h"
 
 KitCgTypeId toy_builtin_type(ToyParser* p, KitCgBuiltinType ty) {
   return kit_cg_type_builtin(p->c, ty);
 }
 
 KitCgTypeId toy_cg_record_type(ToyParser* p, KitSym tag,
                                const KitCgFieldDesc* fields, uint32_t nfields,
                                int is_union, uint32_t align_override) {
   KitCgRecordDesc desc;
   memset(&desc, 0, sizeof desc);
   desc.tag = tag;
   desc.fields = fields;
   desc.nfields = nfields;
   desc.is_union = is_union;
   desc.align_override = align_override;
   return kit_cg_type_record(p->c, &desc);
 }
 
 int toy_cg_record_complete(ToyParser* p, KitCgTypeId record, KitSym tag,
                            const KitCgFieldDesc* fields, uint32_t nfields,
                            int is_union, uint32_t align_override) {
   KitCgRecordDesc desc;
   memset(&desc, 0, sizeof desc);
   desc.tag = tag;
   desc.fields = fields;
   desc.nfields = nfields;
   desc.is_union = is_union;
   desc.align_override = align_override;
   return kit_cg_type_record_complete(p->c, record, &desc) == KIT_OK;
 }
 
 KitCgTypeId toy_cg_func_ret(ToyParser* p, KitCgTypeId fn_ty) {
   KitCgTypeId rt = kit_cg_type_func_result(p->c, fn_ty).type;
   return rt ? rt : toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
 }
 
 void* toy_parser_zalloc(ToyParser* p, size_t count, size_t elem_size,
                         const char* what) {
   KitHeap* h = kit_compiler_context(p->c)->heap;
   size_t size = count * elem_size;
   void* items;
   if (count != 0 && size / count != elem_size) {
     toy_error(p, p->cur.loc, "out of memory growing %.*s",
               KIT_SLICE_ARG(kit_slice_cstr(what)));
     return NULL;
   }
   items = h->alloc(h, size ? size : 1u, 1);
   if (!items) {
     toy_error(p, p->cur.loc, "out of memory growing %.*s",
               KIT_SLICE_ARG(kit_slice_cstr(what)));
     return NULL;
   }
   memset(items, 0, size ? size : 1u);
   return items;
 }
 
 void toy_parser_free_mem(ToyParser* p, void* items, size_t size) {
   KitHeap* h;
   if (!items) return;
   h = kit_compiler_context(p->c)->heap;
   h->free(h, items, size ? size : 1u);
 }
 
 static uint32_t toy_source_file_id(KitCompiler* c, const char* name) {
   uint32_t file_id = 0;
   if (name && *name)
     (void)kit_source_add_memory(c, kit_slice_cstr(name), &file_id);
   return file_id;
 }
 
 void toy_parser_init(ToyParser* p, KitCompiler* c, KitCg* cg, ToyModule* module,
                      const uint8_t* data, size_t len, const char* input_name) {
   memset(p, 0, sizeof *p);
   p->module = module;
   p->file_id = toy_source_file_id(c, input_name);
   p->input_name = input_name;
   toy_lexer_init(&p->lex, data, len, p->file_id);
   p->cur = toy_lexer_next(&p->lex);
   p->c = c;
   p->cg = cg;
   p->target = kit_compiler_target_spec(c);
   p->int_type = toy_builtin_type(p, KIT_CG_BUILTIN_I64);
   p->size_type = toy_builtin_type(
       p, p->target.ptr_size <= 4u ? KIT_CG_BUILTIN_I32 : KIT_CG_BUILTIN_I64);
   p->int_ptr_type = kit_cg_type_ptr(c, p->int_type, 0);
   p->va_list_type = toy_builtin_type(p, KIT_CG_BUILTIN_VARARG_STATE);
   p->nvars = 0;
   p->cap_vars = 0;
   p->vars = NULL;
   /* The durable module is zero-initialized by the frontend; register the
    * builtin types into it exactly once, on this first compile. */
   toy_type_register_builtins(p);
   p->nscopes = 0;
   p->cap_scopes = 0;
   p->scopes = NULL;
   p->nlabels = 0;
   p->cap_labels = 0;
   p->labels = NULL;
   p->goto_targets = NULL;
   p->cap_goto_targets = 0;
   p->cur_fn_ret = toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   p->cur_fn_ret_toy = toy_type_from_cg(p, p->cur_fn_ret);
   p->diag = kit_compiler_context(c)->diag;
   p->input_name = input_name;
   p->has_error = 0;
   p->expr_island_mask = 0;
   p->last_type = TOY_TYPE_NONE;
   p->allow_tail_call_expr = 0;
   p->tail_call_expr = 0;
   p->tail_call_ret_toy = TOY_TYPE_NONE;
   p->input_kind = KIT_FRONTEND_INPUT_TRANSLATION_UNIT;
 }
 
 void toy_parser_reinit(ToyParser* p, KitCompiler* c, KitCg* cg,
                        const uint8_t* data, size_t len, const char* input_name,
                        KitFrontendInputKind input_kind) {
   p->file_id = toy_source_file_id(c, input_name);
   p->input_name = input_name;
   toy_lexer_init(&p->lex, data, len, p->file_id);
   p->cur = toy_lexer_next(&p->lex);
   p->c = c;
   p->cg = cg;
   p->target = kit_compiler_target_spec(c);
   p->int_type = toy_builtin_type(p, KIT_CG_BUILTIN_I64);
   p->size_type = toy_builtin_type(
       p, p->target.ptr_size <= 4u ? KIT_CG_BUILTIN_I32 : KIT_CG_BUILTIN_I64);
   p->int_ptr_type = kit_cg_type_ptr(c, p->int_type, 0);
   p->va_list_type = toy_builtin_type(p, KIT_CG_BUILTIN_VARARG_STATE);
   p->nvars = 0;
   p->nscopes = 0;
   p->nlabels = 0;
   p->cur_fn_ret = toy_builtin_type(p, KIT_CG_BUILTIN_VOID);
   p->cur_fn_ret_toy = toy_type_from_cg(p, p->cur_fn_ret);
   p->diag = kit_compiler_context(c)->diag;
   p->input_name = input_name;
   p->has_error = 0;
   p->expr_island_mask = 0;
   p->last_type = TOY_TYPE_NONE;
   p->allow_tail_call_expr = 0;
   p->tail_call_expr = 0;
   p->tail_call_ret_toy = TOY_TYPE_NONE;
   p->input_kind = input_kind;
 }
 
 /* Frees one heap block sized for the module owner. Mirrors
  * toy_parser_free_mem but does not need a live parser, so the durable module
  * can be torn down independently of any compile. */
 static void toy_mem_free(KitCompiler* c, void* items, size_t size) {
   KitHeap* h;
   if (!items) return;
   h = kit_compiler_context(c)->heap;
   h->free(h, items, size ? size : 1u);
 }
 
 void toy_parser_dispose(ToyParser* p) {
   /* Per-compile scratch only; the durable arrays belong to the module and
    * are freed by toy_module_dispose. */
   toy_parser_free_mem(p, p->vars, p->cap_vars * sizeof *p->vars);
   toy_parser_free_mem(p, p->scopes, p->cap_scopes * sizeof *p->scopes);
   toy_parser_free_mem(p, p->labels, p->cap_labels * sizeof *p->labels);
   toy_parser_free_mem(p, p->goto_targets,
                       p->cap_goto_targets * sizeof *p->goto_targets);
   toy_parser_free_mem(p, p->fn_syms, p->cap_fn_syms * sizeof *p->fn_syms);
   toy_parser_free_mem(p, p->global_syms,
                       p->cap_global_syms * sizeof *p->global_syms);
   toy_parser_free_mem(p, p->txn.undo, p->txn.cap_undo * sizeof *p->txn.undo);
   p->txn.undo = NULL;
   p->txn.cap_undo = 0;
   p->txn.nundo = 0;
   p->txn.open = 0;
   p->vars = NULL;
   p->scopes = NULL;
   p->labels = NULL;
   p->goto_targets = NULL;
   p->fn_syms = NULL;
   p->global_syms = NULL;
   p->cap_fn_syms = 0;
   p->cap_global_syms = 0;
   p->nvars = 0;
   p->nscopes = p->nlabels = 0;
   p->cap_vars = 0;
   p->cap_scopes = p->cap_labels = 0;
   p->cap_goto_targets = 0;
   p->last_type = TOY_TYPE_NONE;
 }
 
 void toy_module_dispose(ToyModule* m, KitCompiler* c) {
   size_t i;
   ToyTypeTable* tt = &m->type_table;
   /* Only free per-element pointer arrays when their companion count is
    * non-zero — allocation only happens in that case, so a zero count means
    * the pointer field was never written by an allocation. This guards
    * against rare paths that leave a pointer slot uninitialized while
    * leaving the count at 0; without it, freeing a garbage pointer aborts
    * libc malloc with "pointer being freed was not allocated". */
   for (i = 0; i < m->nfns; ++i) {
     if (m->fns[i].nparams) {
       toy_mem_free(c, m->fns[i].params,
                    m->fns[i].nparams * sizeof *m->fns[i].params);
       toy_mem_free(c, m->fns[i].toy_params,
                    m->fns[i].nparams * sizeof *m->fns[i].toy_params);
     }
   }
   toy_mem_free(c, m->fns, m->cap_fns * sizeof *m->fns);
   toy_mem_free(c, m->globals, m->cap_globals * sizeof *m->globals);
   for (i = 0; i < tt->ntypes; ++i) {
     if (tt->types[i].nparams) {
       toy_mem_free(c, tt->types[i].params,
                    tt->types[i].nparams * sizeof *tt->types[i].params);
     }
   }
   toy_mem_free(c, tt->types, tt->cap_types * sizeof *tt->types);
   for (i = 0; i < tt->count; ++i) {
     if (tt->named[i].cap_enum_values) {
       toy_mem_free(
           c, tt->named[i].enum_values,
           tt->named[i].cap_enum_values * sizeof *tt->named[i].enum_values);
     }
     if (tt->named[i].cap_fields) {
       toy_mem_free(c, tt->named[i].fields,
                    tt->named[i].cap_fields * sizeof *tt->named[i].fields);
     }
   }
   toy_mem_free(c, tt->named, tt->cap * sizeof *tt->named);
   m->fns = NULL;
   m->globals = NULL;
   tt->types = NULL;
   tt->named = NULL;
   m->nfns = m->nglobals = 0;
   tt->count = tt->ntypes = 0;
   m->cap_fns = m->cap_globals = 0;
   tt->cap = tt->cap_types = 0;
 }
 
 void toy_txn_begin(ToyParser* p) {
   ToyModule* m = p->module;
   p->txn.open = 1;
   p->txn.fns = m->nfns;
   p->txn.globals = m->nglobals;
   p->txn.types = m->type_table.ntypes;
   p->txn.named = m->type_table.count;
   p->txn.nundo = 0; /* reuse the journal buffer; cap_undo persists */
 }
 
 void toy_txn_commit(ToyParser* p) {
   if (!p->txn.open) return;
   /* Staged appends are already in the module; just drop the journal. */
   p->txn.open = 0;
   p->txn.nundo = 0;
 }
 
 int toy_txn_record_named(ToyParser* p, size_t index) {
   size_t i;
   if (!p->txn.open || index >= p->txn.named) return 1; /* staged or no txn */
   for (i = 0; i < p->txn.nundo; ++i) {
     if (p->txn.undo[i].kind == TOY_UNDO_NAMED && p->txn.undo[i].index == index)
       return 1; /* keep the earliest before-image */
   }
   if (!toy_parser_reserve(p, (void**)&p->txn.undo, &p->txn.cap_undo,
                           p->txn.nundo + 1u, sizeof *p->txn.undo,
                           "undo journal")) {
     return 0;
   }
   p->txn.undo[p->txn.nundo].kind = TOY_UNDO_NAMED;
   p->txn.undo[p->txn.nundo].index = index;
   p->txn.undo[p->txn.nundo].saved.named = p->module->type_table.named[index];
   p->txn.nundo++;
   return 1;
 }
 
 int toy_txn_record_type(ToyParser* p, size_t index) {
   size_t i;
   if (!p->txn.open || index >= p->txn.types) return 1; /* staged or no txn */
   for (i = 0; i < p->txn.nundo; ++i) {
     if (p->txn.undo[i].kind == TOY_UNDO_TYPE && p->txn.undo[i].index == index)
       return 1;
   }
   if (!toy_parser_reserve(p, (void**)&p->txn.undo, &p->txn.cap_undo,
                           p->txn.nundo + 1u, sizeof *p->txn.undo,
                           "undo journal")) {
     return 0;
   }
   p->txn.undo[p->txn.nundo].kind = TOY_UNDO_TYPE;
   p->txn.undo[p->txn.nundo].index = index;
   p->txn.undo[p->txn.nundo].saved.type = p->module->type_table.types[index];
   p->txn.nundo++;
   return 1;
 }
 
 void toy_txn_abort(ToyParser* p) {
   ToyModule* m = p->module;
   ToyTypeTable* tt = &m->type_table;
   size_t i;
   if (!p->txn.open) return;
   p->txn.open = 0;
   /* 1. Restore committed entries that were mutated in place, newest first.
    * The current entry may have allocated a fields/enum/params array since the
    * snapshot; free it before restoring the (typically NULL) saved pointer. A
    * committed entry is only mutated when completing a forward declaration, so
    * the saved array is NULL and there is no realloc-of-saved hazard. */
   while (p->txn.nundo > 0) {
     ToyUndo* u = &p->txn.undo[--p->txn.nundo];
     if (u->kind == TOY_UNDO_NAMED) {
       ToyNamedType* cur = &tt->named[u->index];
       if (cur->fields != u->saved.named.fields) {
         toy_mem_free(p->c, cur->fields, cur->cap_fields * sizeof *cur->fields);
       }
       if (cur->enum_values != u->saved.named.enum_values) {
         toy_mem_free(p->c, cur->enum_values,
                      cur->cap_enum_values * sizeof *cur->enum_values);
       }
       *cur = u->saved.named;
     } else {
       ToyType* cur = &tt->types[u->index];
       if (cur->params != u->saved.type.params) {
         toy_mem_free(p->c, cur->params, cur->nparams * sizeof *cur->params);
       }
       *cur = u->saved.type;
     }
   }
   /* 2. Truncate staged appends, freeing each dropped entry's sub-arrays. */
   for (i = p->txn.fns; i < m->nfns; ++i) {
     if (m->fns[i].nparams) {
       toy_mem_free(p->c, m->fns[i].params,
                    m->fns[i].nparams * sizeof *m->fns[i].params);
       toy_mem_free(p->c, m->fns[i].toy_params,
                    m->fns[i].nparams * sizeof *m->fns[i].toy_params);
     }
   }
   m->nfns = p->txn.fns;
   m->nglobals = p->txn.globals; /* globals own no sub-arrays */
   for (i = p->txn.types; i < tt->ntypes; ++i) {
     if (tt->types[i].nparams) {
       toy_mem_free(p->c, tt->types[i].params,
                    tt->types[i].nparams * sizeof *tt->types[i].params);
     }
   }
   tt->ntypes = p->txn.types;
   for (i = p->txn.named; i < tt->count; ++i) {
     if (tt->named[i].cap_fields) {
       toy_mem_free(p->c, tt->named[i].fields,
                    tt->named[i].cap_fields * sizeof *tt->named[i].fields);
     }
     if (tt->named[i].cap_enum_values) {
       toy_mem_free(
           p->c, tt->named[i].enum_values,
           tt->named[i].cap_enum_values * sizeof *tt->named[i].enum_values);
     }
   }
   tt->count = p->txn.named;
 }
 
 int toy_parser_reserve(ToyParser* p, void** items, size_t* cap, size_t want,
                        size_t elem_size, const char* what) {
   KitHeap* h;
   size_t new_cap;
   size_t old_size;
   size_t new_size;
   size_t old_cap;
   void* new_items;
   if (want <= *cap) return 1;
   old_cap = *cap;
   new_cap = old_cap ? old_cap * 2u : 8u;
   while (new_cap < want) new_cap *= 2u;
   old_size = old_cap * elem_size;
   new_size = new_cap * elem_size;
   if (new_cap != 0 && new_size / new_cap != elem_size) {
     toy_error(p, p->cur.loc, "out of memory growing %.*s",
               KIT_SLICE_ARG(kit_slice_cstr(what)));
     return 0;
   }
   h = kit_compiler_context(p->c)->heap;
   /* Allocate fresh and copy old contents over (rather than realloc'ing in
    * place and only zeroing the tail). Zeroing the whole buffer guarantees
    * any slot the writer doesn't fully initialize has NULL pointers, so the
    * dispose path never sees stale bytes — a previous realloc-in-place
    * variant left under-initialized slots holding the realloc'd pages'
    * prior contents, which manifested as a "pointer being freed was not
    * allocated" abort in lib c malloc when the dispose loop walked the
    * type table. */
   new_items = h->alloc(h, new_size ? new_size : 1u, 1);
   if (!new_items) {
     toy_error(p, p->cur.loc, "out of memory growing %.*s",
               KIT_SLICE_ARG(kit_slice_cstr(what)));
     return 0;
   }
   memset(new_items, 0, new_size ? new_size : 1u);
   if (*items && old_size) memcpy(new_items, *items, old_size);
   if (*items) h->free(h, *items, old_size ? old_size : 1u);
   *items = new_items;
   *cap = new_cap;
   return 1;
 }
 
 void toy_parser_advance(ToyParser* p) { p->cur = toy_lexer_next(&p->lex); }
 
 int toy_parser_match(ToyParser* p, ToyTokenKind kind) {
   if (p->cur.kind == kind) {
     toy_parser_advance(p);
     return 1;
   }
   return 0;
 }
 
 int toy_parser_expect(ToyParser* p, ToyTokenKind kind) {
   if (p->cur.kind == kind) {
     toy_parser_advance(p);
     return 1;
   }
   return 0;
 }
 
 void toy_error(ToyParser* p, KitSrcLoc loc, const char* fmt, ...) {
   va_list ap;
   p->has_error = 1;
   if (!p->diag) return;
   va_start(ap, fmt);
   p->diag->emit(p->diag, KIT_DIAG_ERROR, loc, fmt, ap);
   va_end(ap);
 }
 
 void toy_set_loc(ToyParser* p) {
   if (p->cg) kit_cg_set_loc(p->cg, p->cur.loc);
 }
 
 KitSym toy_tok_sym(ToyParser* p, ToyToken tok) {
   char buf[64];
   if (tok.text_len >= sizeof(buf)) {
     toy_error(p, tok.loc, "identifier too long");
     return 0;
   }
   memcpy(buf, tok.text, tok.text_len);
   buf[tok.text_len] = '\0';
   return kit_sym_intern(p->c, (KitSlice){.s = buf, .len = tok.text_len});
 }
 
 int toy_sym_is(ToyParser* p, KitSym sym, const char* name) {
   return sym == kit_sym_intern(p->c, kit_slice_cstr(name));
 }
 
 int toy_lookup_const(ToyParser* p, KitSym tok, const ToyConstRow* rows,
                      size_t n, const char* what, uint64_t* out) {
   size_t i;
   for (i = 0; i < n; ++i) {
     if (tok == kit_sym_intern(p->c, kit_slice_cstr(rows[i].name))) {
       *out = rows[i].value;
       return 1;
     }
   }
   toy_error(p, p->cur.loc, "unknown %s", what);
   return 0;
 }
 
 int toy_parse_dot_const(ToyParser* p, const ToyConstRow* rows, size_t n,
                         int strict_ident, const char* expected,
                         const char* unknown, uint64_t* out) {
   KitSym tok;
   if (strict_ident) {
     if (!toy_parser_expect(p, TOK_DOT) || p->cur.kind != TOK_IDENT) {
       toy_error(p, p->cur.loc, "expected %s", expected);
       return 0;
     }
     tok = toy_tok_sym(p, p->cur);
     toy_parser_advance(p);
   } else {
     (void)expected;
     if (!toy_parse_attr_dot_name(p, &tok)) return 0;
   }
   return toy_lookup_const(p, tok, rows, n, unknown, out);
 }
 
 int toy_parse_flag_set(ToyParser* p, const ToyConstRow* rows, size_t n,
                        const char* unknown, int comma_prefixed,
                        uint32_t* mask) {
   for (;;) {
     KitSym name;
     uint64_t value;
     if (comma_prefixed) {
       if (!toy_parser_match(p, TOK_COMMA)) break;
     } else if (p->cur.kind == TOK_RPAREN || p->cur.kind == TOK_EOF) {
       break;
     }
     if (!toy_parse_attr_dot_name(p, &name)) return 0;
     if (!toy_lookup_const(p, name, rows, n, unknown, &value)) return 0;
     *mask |= (uint32_t)value;
     if (!comma_prefixed && !toy_parser_match(p, TOK_COMMA)) break;
   }
   return 1;
 }
 
 int toy_skip_attr_list_ex(ToyParser* p, int* has_static) {
   int bracket_depth = 0;
   int paren_depth = 0;
   if (has_static) *has_static = 0;
   if (!toy_parser_match(p, TOK_AT)) return 1;
   if (!toy_parser_expect(p, TOK_LBRACKET)) {
     toy_error(p, p->cur.loc, "expected '[' after '@'");
     return 0;
   }
   bracket_depth = 1;
   while (p->cur.kind != TOK_EOF && bracket_depth > 0) {
     if (p->cur.kind == TOK_DOT) {
       toy_parser_advance(p);
       if (p->cur.kind == TOK_IDENT && has_static && p->cur.text_len == 6 &&
           memcmp(p->cur.text, "static", 6) == 0) {
         *has_static = 1;
       }
       continue;
     }
     if (p->cur.kind == TOK_LBRACKET && paren_depth == 0)
       bracket_depth++;
     else if (p->cur.kind == TOK_RBRACKET && paren_depth == 0)
       bracket_depth--;
     else if (p->cur.kind == TOK_LPAREN)
       paren_depth++;
     else if (p->cur.kind == TOK_RPAREN && paren_depth > 0)
       paren_depth--;
     toy_parser_advance(p);
   }
   if (bracket_depth != 0) {
     toy_error(p, p->cur.loc, "unterminated attribute list");
     return 0;
   }
   return 1;
 }
 
 int toy_skip_attr_list(ToyParser* p) { return toy_skip_attr_list_ex(p, NULL); }