internal.h (20309B)
1 #ifndef KIT_TOY_INTERNAL_H 2 #define KIT_TOY_INTERNAL_H 3 4 #include <kit/frontend.h> 5 #include <stddef.h> 6 #include <stdint.h> 7 8 #include "lexer.h" 9 10 typedef uint32_t ToyTypeId; 11 12 #define TOY_TYPE_NONE ((ToyTypeId)0) 13 14 typedef struct ToyVar { 15 KitSym name; 16 KitCgTypeId type; 17 ToyTypeId toy_type; 18 KitCgLocal local; 19 KitCgSym static_sym; 20 int is_static; 21 int mutable; 22 } ToyVar; 23 24 typedef struct ToyFn { 25 KitSym name; 26 KitCgTypeId type; 27 ToyTypeId toy_type; 28 KitCgTypeId ret; 29 ToyTypeId toy_ret; 30 KitCgSymbolAttrs sym_attrs; 31 KitCgFuncAttrs func_attrs; 32 KitCgTypeId* params; 33 ToyTypeId* toy_params; 34 size_t nparams; 35 int variadic; 36 } ToyFn; 37 38 typedef struct ToyGlobal { 39 KitSym name; 40 KitCgTypeId type; 41 ToyTypeId toy_type; 42 KitCgSymbolAttrs sym_attrs; 43 KitCgObjectAttrs object_attrs; 44 int mutable; 45 } ToyGlobal; 46 47 typedef struct ToyAttrSet { 48 KitCgSymbolAttrs sym; 49 KitCgFuncAttrs func; 50 KitCgObjectAttrs object; 51 KitCgDataDefAttrs data; 52 KitCgCallConv call_conv; 53 uint32_t attr_kinds; 54 int has_call_conv; 55 int has_static; 56 int is_common; 57 } ToyAttrSet; 58 59 enum { 60 TOY_ATTR_SYMBOL = 1u << 0, 61 TOY_ATTR_FUNC = 1u << 1, 62 TOY_ATTR_OBJECT = 1u << 2, 63 TOY_ATTR_DATA = 1u << 3, 64 TOY_ATTR_SECTION = 1u << 4, 65 TOY_ATTR_OBJECT_DATA = 1u << 5, 66 }; 67 68 typedef enum ToyNamedTypeKind { 69 TOY_NAMED_ALIAS, 70 TOY_NAMED_RECORD, 71 TOY_NAMED_TUPLE, 72 TOY_NAMED_ENUM, 73 } ToyNamedTypeKind; 74 75 typedef struct ToyEnumConst { 76 KitSym name; 77 int64_t value; 78 } ToyEnumConst; 79 80 typedef struct ToyRecordFieldInfo { 81 KitSym name; 82 KitCgTypeId storage_type; 83 ToyTypeId toy_type; 84 } ToyRecordFieldInfo; 85 86 typedef enum ToyTypeKind { 87 TOY_TYPE_BUILTIN, 88 TOY_TYPE_ALIAS, 89 TOY_TYPE_NOMINAL_RECORD, 90 TOY_TYPE_TUPLE_RECORD, 91 TOY_TYPE_ENUM, 92 TOY_TYPE_ARRAY, 93 TOY_TYPE_SLICE, 94 TOY_TYPE_PTR, 95 TOY_TYPE_FUNC, 96 TOY_TYPE_QUALIFIED, 97 TOY_TYPE_ANON_RECORD, 98 } ToyTypeKind; 99 100 typedef enum ToyTypeQual { 101 TOY_TYPE_QUAL_CONST = 1u << 0, 102 TOY_TYPE_QUAL_VOLATILE = 1u << 1, 103 TOY_TYPE_QUAL_RESTRICT = 1u << 2, 104 } ToyTypeQual; 105 106 typedef struct ToyType { 107 ToyTypeKind kind; 108 KitCgTypeId cg; 109 KitSym name; 110 ToyTypeId base; 111 ToyTypeId elem; 112 ToyTypeId pointee; 113 ToyTypeId ret; 114 ToyTypeId* params; 115 size_t nparams; 116 uint64_t count; 117 uint32_t address_space; 118 uint32_t quals; 119 int variadic; 120 } ToyType; 121 122 typedef struct ToyNamedType { 123 KitSym name; 124 KitCgTypeId type; 125 ToyTypeId toy_type; 126 ToyNamedTypeKind kind; 127 KitCgTypeId base_type; 128 ToyEnumConst* enum_values; 129 size_t nenum_values; 130 size_t cap_enum_values; 131 ToyRecordFieldInfo* fields; 132 size_t nfields; 133 size_t cap_fields; 134 } ToyNamedType; 135 136 typedef struct ToyTypeTable { 137 ToyType* types; 138 size_t ntypes; 139 size_t cap_types; 140 ToyNamedType* named; 141 size_t count; 142 size_t cap; 143 } ToyTypeTable; 144 145 /* Durable Toy frontend state. Owned by the frontend, it survives across every 146 * successful REPL snippet and holds the persistent declarations: functions, 147 * globals, named types, the structural type table, and counters. It holds 148 * declaration *identity* only — names, types, attrs — never per-object CG 149 * symbol handles, which are rebuilt per compile in the parser's symbol env. 150 * 151 * Each of fns/globals/type_table.types/type_table.named is an append-only 152 * array; ToyTypeId values are 1-based indices into type_table.types and stay 153 * valid across snippets because the table is never compacted. A per-compile 154 * transaction (see ToyParser) stages appends in place and rolls back to the 155 * watermarks captured at compile start if the snippet fails. */ 156 typedef struct ToyModule { 157 ToyFn* fns; 158 size_t nfns; 159 size_t cap_fns; 160 161 ToyGlobal* globals; 162 size_t nglobals; 163 size_t cap_globals; 164 165 ToyTypeTable type_table; 166 167 uint32_t static_counter; 168 } ToyModule; 169 170 typedef enum ToyUndoKind { 171 TOY_UNDO_NAMED, 172 TOY_UNDO_TYPE, 173 } ToyUndoKind; 174 175 /* Before-image of a committed module entry that a transaction mutates in 176 * place (forward-declaration completion). Restored verbatim on rollback. */ 177 typedef struct ToyUndo { 178 ToyUndoKind kind; 179 size_t index; 180 union { 181 ToyNamedType named; 182 ToyType type; 183 } saved; 184 } ToyUndo; 185 186 /* Per-compile transaction over the durable module. Watermarks capture the 187 * committed table sizes at compile start; staged appends past them are 188 * truncated on rollback. The undo journal restores committed entries that 189 * were mutated in place. Commit keeps the staged appends (they are already in 190 * the module) and drops the journal; abort does both undos. */ 191 typedef struct ToyTxn { 192 int open; 193 size_t fns; 194 size_t globals; 195 size_t types; 196 size_t named; 197 ToyUndo* undo; 198 size_t nundo; 199 size_t cap_undo; 200 } ToyTxn; 201 202 typedef enum ToyScopeKind { 203 TOY_SCOPE_LOOP, 204 TOY_SCOPE_SWITCH, 205 } ToyScopeKind; 206 207 typedef struct ToyScope { 208 KitSym name; 209 ToyScopeKind kind; 210 KitCgScope cg_scope; 211 KitCgTypeId result_type; 212 ToyTypeId result_toy_type; 213 } ToyScope; 214 215 typedef struct ToyLabel { 216 KitSym name; 217 KitCgLabel label; 218 } ToyLabel; 219 220 typedef enum ToyExprIsland { 221 TOY_EXPR_ISLAND_ARITH = 1u << 0, 222 TOY_EXPR_ISLAND_SHIFT = 1u << 1, 223 TOY_EXPR_ISLAND_CMP = 1u << 2, 224 TOY_EXPR_ISLAND_BIT_AND = 1u << 3, 225 TOY_EXPR_ISLAND_BIT_XOR = 1u << 4, 226 TOY_EXPR_ISLAND_BIT_OR = 1u << 5, 227 TOY_EXPR_ISLAND_LOGIC_AND = 1u << 6, 228 TOY_EXPR_ISLAND_LOGIC_OR = 1u << 7, 229 } ToyExprIsland; 230 231 typedef struct ToyParser { 232 ToyLexer lex; 233 ToyToken cur; 234 KitCompiler* c; 235 KitCg* cg; 236 KitCgBuiltinTypes types; 237 KitCgTypeId int_type; 238 KitCgTypeId size_type; 239 KitCgTypeId int_ptr_type; 240 KitCgTypeId va_list_type; 241 KitTargetSpec target; 242 243 /* Durable cross-snippet state lives in the module; the parser borrows it 244 * for one compile and stages/commits/rolls back through it. */ 245 ToyModule* module; 246 247 ToyVar* vars; 248 size_t nvars; 249 size_t cap_vars; 250 251 /* Per-compile symbol environment: the KitCgSym each durable fn/global 252 * resolves to in the *current* KitCg object, indexed in lockstep with 253 * module->fns / module->globals. Seeded from committed decls and extended 254 * as new decls are staged; never durable identity. */ 255 KitCgSym* fn_syms; 256 size_t cap_fn_syms; 257 KitCgSym* global_syms; 258 size_t cap_global_syms; 259 260 ToyTxn txn; 261 262 ToyScope* scopes; 263 size_t nscopes; 264 size_t cap_scopes; 265 266 ToyLabel* labels; 267 size_t nlabels; 268 size_t cap_labels; 269 270 KitCgLabel* goto_targets; 271 size_t cap_goto_targets; 272 273 KitCgTypeId cur_fn_ret; 274 ToyTypeId cur_fn_ret_toy; 275 KitDiagSink* diag; 276 const char* input_name; 277 uint32_t file_id; 278 int has_error; 279 uint32_t expr_island_mask; 280 ToyTypeId last_type; 281 int allow_tail_call_expr; 282 int tail_call_expr; 283 ToyTypeId tail_call_ret_toy; 284 KitFrontendInputKind input_kind; 285 } ToyParser; 286 287 KitCgTypeId toy_builtin_type(ToyParser* p, KitCgBuiltinType ty); 288 /* The toy frontend models a single return value: the function's first result 289 * type, or void when it has no results. */ 290 KitCgTypeId toy_cg_func_ret(ToyParser* p, KitCgTypeId fn_ty); 291 void toy_parser_init(ToyParser* p, KitCompiler* c, KitCg* cg, ToyModule* module, 292 const uint8_t* data, size_t len, const char* input_name); 293 void toy_parser_reinit(ToyParser* p, KitCompiler* c, KitCg* cg, 294 const uint8_t* data, size_t len, const char* input_name, 295 KitFrontendInputKind input_kind); 296 void toy_parser_dispose(ToyParser* p); 297 /* Frees the durable module arrays. Called once at frontend teardown. */ 298 void toy_module_dispose(ToyModule* m, KitCompiler* c); 299 300 /* Transaction over the durable module for one compile. begin captures 301 * watermarks; commit keeps staged appends and drops the journal; abort 302 * truncates staged appends and replays the undo journal. commit/abort are 303 * idempotent (no-op unless a transaction is open). The record_* helpers 304 * snapshot a committed entry before it is mutated in place; they no-op for 305 * staged entries and for already-recorded ones, and return 0 only on OOM. */ 306 void toy_txn_begin(ToyParser* p); 307 void toy_txn_commit(ToyParser* p); 308 void toy_txn_abort(ToyParser* p); 309 int toy_txn_record_named(ToyParser* p, size_t index); 310 int toy_txn_record_type(ToyParser* p, size_t index); 311 void* toy_parser_zalloc(ToyParser* p, size_t count, size_t elem_size, 312 const char* what); 313 void toy_parser_free_mem(ToyParser* p, void* items, size_t size); 314 int toy_parser_reserve(ToyParser* p, void** items, size_t* cap, size_t want, 315 size_t elem_size, const char* what); 316 void toy_parser_advance(ToyParser* p); 317 int toy_parser_match(ToyParser* p, ToyTokenKind kind); 318 int toy_parser_expect(ToyParser* p, ToyTokenKind kind); 319 void toy_error(ToyParser* p, KitSrcLoc loc, const char* fmt, ...); 320 void toy_set_loc(ToyParser* p); 321 KitSym toy_tok_sym(ToyParser* p, ToyToken tok); 322 int toy_sym_is(ToyParser* p, KitSym sym, const char* name); 323 324 /* A single ".name" -> value row for the dot-const tables. The value is widened 325 * to uint64_t so one table type serves every enum/flag domain; thin typed 326 * wrappers narrow it back at the call site. */ 327 typedef struct { 328 const char* name; 329 uint64_t value; 330 } ToyConstRow; 331 332 /* Map an already-interned token sym against a const table, interning each row 333 * name once. On a hit, sets *out and returns 1; on a miss, raises 334 * "unknown <what>" and returns 0. */ 335 int toy_lookup_const(ToyParser* p, KitSym tok, const ToyConstRow* rows, size_t n, 336 const char* what, uint64_t* out); 337 338 /* Parse a ".name" dot-const and resolve it via `rows`. When `strict_ident` is 339 * set the name must be a bare identifier ("expected <expected>" on failure); 340 * otherwise keyword tokens are also accepted (via toy_parse_attr_dot_name). On 341 * an unknown name, raises "unknown <unknown>". */ 342 int toy_parse_dot_const(ToyParser* p, const ToyConstRow* rows, size_t n, 343 int strict_ident, const char* expected, 344 const char* unknown, uint64_t* out); 345 346 /* Parse a comma-separated run of ".name" flags, OR-ing each matched row value 347 * into *mask. When `comma_prefixed` is set, every item must be introduced by a 348 * comma and the loop stops at the first non-comma (the mem-flags tail form). 349 * Otherwise the run continues until ')' or EOF with comma separators (the asm 350 * group form); the caller owns the surrounding parentheses. Unknown names raise 351 * "unknown <unknown>". */ 352 int toy_parse_flag_set(ToyParser* p, const ToyConstRow* rows, size_t n, 353 const char* unknown, int comma_prefixed, uint32_t* mask); 354 355 int toy_expect_comma(ToyParser* p); 356 int toy_skip_attr_list_ex(ToyParser* p, int* has_static); 357 int toy_skip_attr_list(ToyParser* p); 358 void toy_emit_int_bytes(ToyParser* p, uint64_t v, uint8_t* buf, size_t n); 359 int toy_parse_number_arg(ToyParser* p, int64_t* out); 360 int toy_parse_string_sym(ToyParser* p, KitSym* out, size_t* len_out); 361 int toy_parse_string_bytes(ToyParser* p, uint8_t* out, size_t cap, 362 size_t* len_out); 363 int toy_parse_attr_dot_name(ToyParser* p, KitSym* out); 364 int toy_parse_attr_int_arg(ToyParser* p, int64_t* out); 365 int toy_parse_callconv_const(ToyParser* p, KitCgCallConv* out); 366 int toy_parse_symbol_feature_const(ToyParser* p, KitCgSymbolFeature* out); 367 int toy_parse_backend_feature_const(ToyParser* p, uint64_t* out); 368 int toy_parse_intrinsic_const(ToyParser* p, KitCgIntrinsic* out); 369 int toy_parse_rounding_const(ToyParser* p, KitCgRounding* out); 370 int toy_parse_attr_list(ToyParser* p, ToyAttrSet* attrs, 371 KitSymBind default_bind); 372 int toy_validate_attr_placement(ToyParser* p, const ToyAttrSet* attrs, 373 uint32_t allowed, const char* message); 374 int toy_parse_abi_attr_list(ToyParser* p, KitCgAbiAttrs* attrs); 375 int toy_parse_field_attr_list(ToyParser* p, KitCgField* field); 376 int toy_parse_record_attr_list(ToyParser* p, int* packed_out, 377 uint32_t* align_out); 378 KitCgTypeId toy_parse_type(ToyParser* p); 379 KitCgTypeId toy_parse_expr(ToyParser* p); 380 int toy_emit_cast(ToyParser* p, KitCgTypeId src, KitCgTypeId dst); 381 int toy_type_can_implicitly_cast(ToyParser* p, KitCgTypeId src, 382 KitCgTypeId dst); 383 int toy_emit_implicit_cast(ToyParser* p, KitCgTypeId src, KitCgTypeId dst); 384 int toy_emit_checked_cast(ToyParser* p, KitCgTypeId src, KitCgTypeId dst); 385 KitCgTypeId toy_push_named_rvalue(ToyParser* p, KitSym name); 386 int toy_parse_call_args(ToyParser* p, ToyToken call_tok, KitCgTypeId fn_ty, 387 const ToyTypeId* toy_params, size_t toy_nparams, 388 size_t* out_nargs); 389 int toy_emit_truthy(ToyParser* p, KitCgTypeId type); 390 int toy_parse_switch_label_value(ToyParser* p, KitCgTypeId selector_ty, 391 int64_t* out); 392 KitCgTypeId toy_parse_builtin_call(ToyParser* p, KitSym name, int* recognized); 393 KitCgTypeId toy_parse_generic_builtin(ToyParser* p, KitSym name, 394 int* recognized); 395 KitCgTypeId toy_parse_memory_builtin_call(ToyParser* p, KitSym name, 396 int* recognized); 397 KitCgTypeId toy_parse_atomic_generic_builtin(ToyParser* p, KitSym name, 398 int* recognized); 399 KitCgTypeId toy_parse_low_level_builtin_call(ToyParser* p, KitSym name, 400 int* recognized); 401 KitCgTypeId toy_parse_low_level_generic_builtin(ToyParser* p, KitSym name, 402 int* recognized); 403 KitCgMemAccess toy_mem_access(ToyParser* p, KitCgTypeId type); 404 KitCgLocalAttrs toy_slot_attrs(KitSym name); 405 KitSym toy_c_linkage_name(ToyParser* p, KitSym source_name); 406 void toy_inline_asm(ToyParser* p, KitSym tmpl, const KitCgAsmOperand* outputs, 407 uint32_t noutputs, const KitCgAsmOperand* inputs, 408 uint32_t ninputs, const KitSym* clobbers, 409 uint32_t nclobbers, uint32_t flags, 410 uint32_t clobber_abi_sets); 411 int toy_parse_arch_string(ToyParser* p, KitSym* out, size_t* len_out); 412 int toy_parse_typed_asm_tail(ToyParser* p, KitCgTypeId result_ty, KitSym tmpl, 413 size_t tmpl_len); 414 int toy_parse_data_array_builtin(ToyParser* p, KitCgTypeId elem_ty, 415 uint64_t total_size, uint64_t* pos); 416 int toy_parse_global_record_initializer(ToyParser* p, KitCgSym sym, 417 KitCgTypeId record_ty, 418 KitCgDataDefAttrs data_attrs); 419 int toy_parse_global_var(ToyParser* p, int is_extern, int is_pub); 420 int toy_parse_type_alias_decl(ToyParser* p); 421 int toy_parse_record_decl(ToyParser* p); 422 int toy_parse_tuple_decl(ToyParser* p); 423 int toy_parse_enum_decl(ToyParser* p); 424 int toy_parse_alias_decl(ToyParser* p, int is_pub); 425 int toy_parse_fn(ToyParser* p, int is_extern, int is_pub); 426 int toy_parse_block(ToyParser* p); 427 KitCgTypeId toy_emit_var_lvalue(ToyParser* p, KitSym name); 428 int toy_type_is_intlike(ToyParser* p, KitCgTypeId ty); 429 int toy_type_is_float(ToyParser* p, KitCgTypeId ty); 430 int toy_type_is_ptr(ToyParser* p, KitCgTypeId ty); 431 uint32_t toy_type_int_width(ToyParser* p, KitCgTypeId ty); 432 int toy_validate_bit_range(ToyParser* p, KitCgTypeId ty, int64_t lo, 433 int64_t width, int allow_full_width); 434 int toy_target_code(ToyParser* p); 435 int toy_parse_va_list_addr_arg(ToyParser* p); 436 KitCgTypeId toy_ptr_pointee_func_type(ToyParser* p, KitCgTypeId ptr_ty); 437 void toy_type_register_builtins(ToyParser* p); 438 const ToyType* toy_type_get(ToyParser* p, ToyTypeId id); 439 KitCgTypeId toy_type_cg(ToyParser* p, ToyTypeId id); 440 ToyTypeId toy_type_from_cg(ToyParser* p, KitCgTypeId cg); 441 ToyTypeId toy_type_register_alias(ToyParser* p, KitSym name, KitCgTypeId cg, 442 KitCgTypeId base); 443 ToyTypeId toy_type_register_named_record(ToyParser* p, KitSym name, 444 KitCgTypeId cg, int is_tuple); 445 ToyTypeId toy_type_register_enum(ToyParser* p, KitSym name, KitCgTypeId cg, 446 KitCgTypeId base); 447 ToyTypeId toy_type_register_qualified(ToyParser* p, KitCgTypeId cg, 448 KitCgTypeId base, uint32_t quals); 449 ToyTypeId toy_type_register_ptr(ToyParser* p, KitCgTypeId cg, ToyTypeId pointee, 450 uint32_t address_space); 451 ToyTypeId toy_type_register_slice(ToyParser* p, KitCgTypeId elem_cg, 452 ToyTypeId elem); 453 ToyTypeId toy_type_register_func(ToyParser* p, KitCgTypeId cg, ToyTypeId ret, 454 const ToyTypeId* params, size_t nparams, 455 int variadic); 456 int toy_type_accepts_storage(ToyParser* p, ToyTypeId expected, 457 ToyTypeId actual); 458 int toy_type_accepts_type(ToyParser* p, ToyTypeId expected, ToyTypeId actual); 459 KitCgTypeId toy_type_resolved_cg(ToyParser* p, ToyTypeId id); 460 ToyTypeId toy_type_pointee(ToyParser* p, ToyTypeId id); 461 ToyTypeId toy_type_array_elem(ToyParser* p, ToyTypeId id); 462 ToyTypeId toy_type_slice_elem(ToyParser* p, ToyTypeId id); 463 int toy_type_is_slice(ToyParser* p, ToyTypeId id); 464 KitCgTypeId toy_emit_slice_index_lvalue(ToyParser* p, KitCgTypeId slice_ty, 465 ToyTypeId slice_toy_type, 466 ToyTypeId* elem_toy_out); 467 KitCgTypeId toy_emit_slice_value(ToyParser* p, KitCgTypeId base_ty, 468 ToyTypeId base_toy_type, KitCgTypeId start_ty, 469 KitCgTypeId end_ty, ToyTypeId* slice_toy_out); 470 int toy_record_field_index(ToyParser* p, KitCgTypeId record_ty, 471 KitSym field_name, uint32_t* index_out, 472 KitCgField* field_out); 473 int toy_add_named_type(ToyParser* p, KitSym name, KitCgTypeId type, 474 ToyNamedTypeKind kind, KitCgTypeId base_type); 475 int toy_set_named_type_fields(ToyParser* p, ToyNamedType* named, 476 const ToyRecordFieldInfo* fields, size_t nfields); 477 int toy_set_named_type_enum_values(ToyParser* p, ToyNamedType* named, 478 const ToyEnumConst* values, size_t nvalues); 479 480 ToyVar* toy_find_var(ToyParser* p, KitSym name); 481 int toy_add_local_typed(ToyParser* p, KitSym name, KitCgTypeId ty, 482 ToyTypeId toy_type, KitCgLocal slot, int mutable); 483 int toy_add_static_local_typed(ToyParser* p, KitSym name, KitCgTypeId ty, 484 ToyTypeId toy_type, KitCgSym sym, int mutable); 485 ToyFn* toy_find_fn(ToyParser* p, KitSym name); 486 ToyFn* toy_add_fn_typed(ToyParser* p, KitSym name, KitCgSym sym, 487 KitCgTypeId type, ToyTypeId toy_type, KitCgTypeId ret, 488 ToyTypeId toy_ret, const KitCgTypeId* params, 489 const ToyTypeId* toy_params, size_t nparams, 490 int variadic); 491 ToyGlobal* toy_find_global(ToyParser* p, KitSym name); 492 int toy_add_global_typed(ToyParser* p, KitSym name, KitCgSym sym, 493 KitCgTypeId type, ToyTypeId toy_type, int mutable); 494 ToyNamedType* toy_find_named_type(ToyParser* p, KitSym name); 495 ToyNamedType* toy_find_named_type_by_type(ToyParser* p, KitCgTypeId type); 496 ToyLabel* toy_find_label(ToyParser* p, KitSym name); 497 ToyLabel* toy_declare_label(ToyParser* p, KitSym name); 498 ToyScope* toy_find_scope(ToyParser* p, KitSym name); 499 ToyScope* toy_find_innermost_loop_scope(ToyParser* p); 500 void toy_push_var_lvalue(ToyParser* p, const ToyVar* v); 501 void toy_push_var_addr(ToyParser* p, const ToyVar* v); 502 /* Chain helpers: see comments in symbols.c. Both consume and produce 503 * pointer-rvalue TOS. */ 504 void toy_addr_offset(ToyParser* p, int64_t offset, KitCgTypeId result_ptr_ty); 505 void toy_addr_index(ToyParser* p, uint64_t elem_size, 506 KitCgTypeId result_ptr_ty); 507 KitCgSym toy_find_decl_sym(ToyParser* p, KitSym name); 508 509 /* Per-compile symbol-environment accessors. *_cur_sym map a durable 510 * fn/global (a pointer into module->fns / module->globals) to its KitCgSym 511 * in the current object; *_set_cur_sym reserve and record that mapping by 512 * index (returns 0 on OOM). */ 513 KitCgSym toy_fn_cur_sym(ToyParser* p, const ToyFn* fn); 514 KitCgSym toy_global_cur_sym(ToyParser* p, const ToyGlobal* g); 515 int toy_fn_set_cur_sym(ToyParser* p, size_t index, KitCgSym sym); 516 int toy_global_set_cur_sym(ToyParser* p, size_t index, KitCgSym sym); 517 518 int toy_parse_program(ToyParser* p); 519 520 #endif