internal.h (20714B)
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 KitCgTypeId int_type; 237 KitCgTypeId size_type; 238 KitCgTypeId int_ptr_type; 239 KitCgTypeId va_list_type; 240 KitTargetSpec target; 241 242 /* Durable cross-snippet state lives in the module; the parser borrows it 243 * for one compile and stages/commits/rolls back through it. */ 244 ToyModule* module; 245 246 ToyVar* vars; 247 size_t nvars; 248 size_t cap_vars; 249 250 /* Per-compile symbol environment: the KitCgSym each durable fn/global 251 * resolves to in the *current* KitCg object, indexed in lockstep with 252 * module->fns / module->globals. Seeded from committed decls and extended 253 * as new decls are staged; never durable identity. */ 254 KitCgSym* fn_syms; 255 size_t cap_fn_syms; 256 KitCgSym* global_syms; 257 size_t cap_global_syms; 258 259 ToyTxn txn; 260 261 ToyScope* scopes; 262 size_t nscopes; 263 size_t cap_scopes; 264 265 ToyLabel* labels; 266 size_t nlabels; 267 size_t cap_labels; 268 269 KitCgLabel* goto_targets; 270 size_t cap_goto_targets; 271 272 KitCgTypeId cur_fn_ret; 273 ToyTypeId cur_fn_ret_toy; 274 KitDiagSink* diag; 275 const char* input_name; 276 uint32_t file_id; 277 int has_error; 278 uint32_t expr_island_mask; 279 ToyTypeId last_type; 280 int allow_tail_call_expr; 281 int tail_call_expr; 282 ToyTypeId tail_call_ret_toy; 283 KitFrontendInputKind input_kind; 284 } ToyParser; 285 286 KitCgTypeId toy_builtin_type(ToyParser* p, KitCgBuiltinType ty); 287 KitCgTypeId toy_cg_record_type(ToyParser* p, KitSym tag, 288 const KitCgFieldDesc* fields, uint32_t nfields, 289 int is_union, uint32_t align_override); 290 int toy_cg_record_complete(ToyParser* p, KitCgTypeId record, KitSym tag, 291 const KitCgFieldDesc* fields, uint32_t nfields, 292 int is_union, uint32_t align_override); 293 /* The toy frontend models a single return value: the function's first result 294 * type, or void when it has no results. */ 295 KitCgTypeId toy_cg_func_ret(ToyParser* p, KitCgTypeId fn_ty); 296 void toy_parser_init(ToyParser* p, KitCompiler* c, KitCg* cg, ToyModule* module, 297 const uint8_t* data, size_t len, const char* input_name); 298 void toy_parser_reinit(ToyParser* p, KitCompiler* c, KitCg* cg, 299 const uint8_t* data, size_t len, const char* input_name, 300 KitFrontendInputKind input_kind); 301 void toy_parser_dispose(ToyParser* p); 302 /* Frees the durable module arrays. Called once at frontend teardown. */ 303 void toy_module_dispose(ToyModule* m, KitCompiler* c); 304 305 /* Transaction over the durable module for one compile. begin captures 306 * watermarks; commit keeps staged appends and drops the journal; abort 307 * truncates staged appends and replays the undo journal. commit/abort are 308 * idempotent (no-op unless a transaction is open). The record_* helpers 309 * snapshot a committed entry before it is mutated in place; they no-op for 310 * staged entries and for already-recorded ones, and return 0 only on OOM. */ 311 void toy_txn_begin(ToyParser* p); 312 void toy_txn_commit(ToyParser* p); 313 void toy_txn_abort(ToyParser* p); 314 int toy_txn_record_named(ToyParser* p, size_t index); 315 int toy_txn_record_type(ToyParser* p, size_t index); 316 void* toy_parser_zalloc(ToyParser* p, size_t count, size_t elem_size, 317 const char* what); 318 void toy_parser_free_mem(ToyParser* p, void* items, size_t size); 319 int toy_parser_reserve(ToyParser* p, void** items, size_t* cap, size_t want, 320 size_t elem_size, const char* what); 321 void toy_parser_advance(ToyParser* p); 322 int toy_parser_match(ToyParser* p, ToyTokenKind kind); 323 int toy_parser_expect(ToyParser* p, ToyTokenKind kind); 324 void toy_error(ToyParser* p, KitSrcLoc loc, const char* fmt, ...); 325 void toy_set_loc(ToyParser* p); 326 KitSym toy_tok_sym(ToyParser* p, ToyToken tok); 327 int toy_sym_is(ToyParser* p, KitSym sym, const char* name); 328 329 /* A single ".name" -> value row for the dot-const tables. The value is widened 330 * to uint64_t so one table type serves every enum/flag domain; thin typed 331 * wrappers narrow it back at the call site. */ 332 typedef struct { 333 const char* name; 334 uint64_t value; 335 } ToyConstRow; 336 337 /* Map an already-interned token sym against a const table, interning each row 338 * name once. On a hit, sets *out and returns 1; on a miss, raises 339 * "unknown <what>" and returns 0. */ 340 int toy_lookup_const(ToyParser* p, KitSym tok, const ToyConstRow* rows, 341 size_t n, const char* what, uint64_t* out); 342 343 /* Parse a ".name" dot-const and resolve it via `rows`. When `strict_ident` is 344 * set the name must be a bare identifier ("expected <expected>" on failure); 345 * otherwise keyword tokens are also accepted (via toy_parse_attr_dot_name). On 346 * an unknown name, raises "unknown <unknown>". */ 347 int toy_parse_dot_const(ToyParser* p, const ToyConstRow* rows, size_t n, 348 int strict_ident, const char* expected, 349 const char* unknown, uint64_t* out); 350 351 /* Parse a comma-separated run of ".name" flags, OR-ing each matched row value 352 * into *mask. When `comma_prefixed` is set, every item must be introduced by a 353 * comma and the loop stops at the first non-comma (the mem-flags tail form). 354 * Otherwise the run continues until ')' or EOF with comma separators (the asm 355 * group form); the caller owns the surrounding parentheses. Unknown names raise 356 * "unknown <unknown>". */ 357 int toy_parse_flag_set(ToyParser* p, const ToyConstRow* rows, size_t n, 358 const char* unknown, int comma_prefixed, uint32_t* mask); 359 360 int toy_expect_comma(ToyParser* p); 361 int toy_skip_attr_list_ex(ToyParser* p, int* has_static); 362 int toy_skip_attr_list(ToyParser* p); 363 void toy_emit_int_bytes(ToyParser* p, uint64_t v, uint8_t* buf, size_t n); 364 int toy_parse_number_arg(ToyParser* p, int64_t* out); 365 int toy_parse_string_sym(ToyParser* p, KitSym* out, size_t* len_out); 366 int toy_parse_string_bytes(ToyParser* p, uint8_t* out, size_t cap, 367 size_t* len_out); 368 int toy_parse_attr_dot_name(ToyParser* p, KitSym* out); 369 int toy_parse_attr_int_arg(ToyParser* p, int64_t* out); 370 int toy_parse_callconv_const(ToyParser* p, KitCgCallConv* out); 371 int toy_parse_symbol_feature_const(ToyParser* p, KitCgSymbolFeature* out); 372 int toy_parse_backend_feature_const(ToyParser* p, uint64_t* out); 373 int toy_parse_intrinsic_const(ToyParser* p, KitCgIntrinsic* out); 374 int toy_parse_rounding_const(ToyParser* p, KitCgRounding* out); 375 int toy_parse_attr_list(ToyParser* p, ToyAttrSet* attrs, 376 KitSymBind default_bind); 377 int toy_validate_attr_placement(ToyParser* p, const ToyAttrSet* attrs, 378 uint32_t allowed, const char* message); 379 int toy_parse_abi_attr_list(ToyParser* p, KitCgAbiAttrs* attrs); 380 int toy_parse_field_attr_list(ToyParser* p, KitCgFieldDesc* field); 381 int toy_parse_record_attr_list(ToyParser* p, int* packed_out, 382 uint32_t* align_out); 383 KitCgTypeId toy_parse_type(ToyParser* p); 384 KitCgTypeId toy_parse_expr(ToyParser* p); 385 int toy_emit_cast(ToyParser* p, KitCgTypeId src, KitCgTypeId dst); 386 int toy_type_can_implicitly_cast(ToyParser* p, KitCgTypeId src, 387 KitCgTypeId dst); 388 int toy_emit_implicit_cast(ToyParser* p, KitCgTypeId src, KitCgTypeId dst); 389 int toy_emit_checked_cast(ToyParser* p, KitCgTypeId src, KitCgTypeId dst); 390 KitCgTypeId toy_push_named_rvalue(ToyParser* p, KitSym name); 391 int toy_parse_call_args(ToyParser* p, ToyToken call_tok, KitCgTypeId fn_ty, 392 const ToyTypeId* toy_params, size_t toy_nparams, 393 size_t* out_nargs); 394 int toy_emit_truthy(ToyParser* p, KitCgTypeId type); 395 int toy_parse_switch_label_value(ToyParser* p, KitCgTypeId selector_ty, 396 int64_t* out); 397 KitCgTypeId toy_parse_builtin_call(ToyParser* p, KitSym name, int* recognized); 398 KitCgTypeId toy_parse_generic_builtin(ToyParser* p, KitSym name, 399 int* recognized); 400 KitCgTypeId toy_parse_memory_builtin_call(ToyParser* p, KitSym name, 401 int* recognized); 402 KitCgTypeId toy_parse_atomic_generic_builtin(ToyParser* p, KitSym name, 403 int* recognized); 404 KitCgTypeId toy_parse_low_level_builtin_call(ToyParser* p, KitSym name, 405 int* recognized); 406 KitCgTypeId toy_parse_low_level_generic_builtin(ToyParser* p, KitSym name, 407 int* recognized); 408 KitCgMemAccess toy_mem_access(ToyParser* p, KitCgTypeId type); 409 KitCgLocalAttrs toy_slot_attrs(KitSym name); 410 KitSym toy_c_linkage_name(ToyParser* p, KitSym source_name); 411 void toy_inline_asm(ToyParser* p, KitSym tmpl, const KitCgAsmOperand* outputs, 412 uint32_t noutputs, const KitCgAsmOperand* inputs, 413 uint32_t ninputs, const KitSym* clobbers, 414 uint32_t nclobbers, uint32_t flags, 415 uint32_t clobber_abi_sets); 416 int toy_parse_arch_string(ToyParser* p, KitSym* out, size_t* len_out); 417 int toy_parse_typed_asm_tail(ToyParser* p, KitCgTypeId result_ty, KitSym tmpl, 418 size_t tmpl_len); 419 int toy_parse_data_array_builtin(ToyParser* p, KitCgTypeId elem_ty, 420 uint64_t total_size, uint64_t* pos); 421 int toy_parse_global_record_initializer(ToyParser* p, KitCgSym sym, 422 KitCgTypeId record_ty, 423 KitCgDataDefAttrs data_attrs); 424 int toy_parse_global_var(ToyParser* p, int is_extern, int is_pub); 425 int toy_parse_type_alias_decl(ToyParser* p); 426 int toy_parse_record_decl(ToyParser* p); 427 int toy_parse_tuple_decl(ToyParser* p); 428 int toy_parse_enum_decl(ToyParser* p); 429 int toy_parse_alias_decl(ToyParser* p, int is_pub); 430 int toy_parse_fn(ToyParser* p, int is_extern, int is_pub); 431 int toy_parse_block(ToyParser* p); 432 KitCgTypeId toy_emit_var_lvalue(ToyParser* p, KitSym name); 433 int toy_type_is_intlike(ToyParser* p, KitCgTypeId ty); 434 int toy_type_is_float(ToyParser* p, KitCgTypeId ty); 435 int toy_type_is_ptr(ToyParser* p, KitCgTypeId ty); 436 uint32_t toy_type_int_width(ToyParser* p, KitCgTypeId ty); 437 int toy_validate_bit_range(ToyParser* p, KitCgTypeId ty, int64_t lo, 438 int64_t width, int allow_full_width); 439 int toy_target_code(ToyParser* p); 440 int toy_parse_va_list_addr_arg(ToyParser* p); 441 KitCgTypeId toy_ptr_pointee_func_type(ToyParser* p, KitCgTypeId ptr_ty); 442 void toy_type_register_builtins(ToyParser* p); 443 const ToyType* toy_type_get(ToyParser* p, ToyTypeId id); 444 KitCgTypeId toy_type_cg(ToyParser* p, ToyTypeId id); 445 ToyTypeId toy_type_from_cg(ToyParser* p, KitCgTypeId cg); 446 ToyTypeId toy_type_register_alias(ToyParser* p, KitSym name, KitCgTypeId cg, 447 KitCgTypeId base); 448 ToyTypeId toy_type_register_named_record(ToyParser* p, KitSym name, 449 KitCgTypeId cg, int is_tuple); 450 ToyTypeId toy_type_register_enum(ToyParser* p, KitSym name, KitCgTypeId cg, 451 KitCgTypeId base); 452 ToyTypeId toy_type_register_qualified(ToyParser* p, KitCgTypeId cg, 453 KitCgTypeId base, uint32_t quals); 454 ToyTypeId toy_type_register_ptr(ToyParser* p, KitCgTypeId cg, ToyTypeId pointee, 455 uint32_t address_space); 456 ToyTypeId toy_type_register_slice(ToyParser* p, KitCgTypeId elem_cg, 457 ToyTypeId elem); 458 ToyTypeId toy_type_register_func(ToyParser* p, KitCgTypeId cg, ToyTypeId ret, 459 const ToyTypeId* params, size_t nparams, 460 int variadic); 461 int toy_type_accepts_storage(ToyParser* p, ToyTypeId expected, 462 ToyTypeId actual); 463 int toy_type_accepts_type(ToyParser* p, ToyTypeId expected, ToyTypeId actual); 464 KitCgTypeId toy_type_resolved_cg(ToyParser* p, ToyTypeId id); 465 ToyTypeId toy_type_pointee(ToyParser* p, ToyTypeId id); 466 ToyTypeId toy_type_array_elem(ToyParser* p, ToyTypeId id); 467 ToyTypeId toy_type_slice_elem(ToyParser* p, ToyTypeId id); 468 int toy_type_is_slice(ToyParser* p, ToyTypeId id); 469 KitCgTypeId toy_emit_slice_index_lvalue(ToyParser* p, KitCgTypeId slice_ty, 470 ToyTypeId slice_toy_type, 471 ToyTypeId* elem_toy_out); 472 KitCgTypeId toy_emit_slice_value(ToyParser* p, KitCgTypeId base_ty, 473 ToyTypeId base_toy_type, KitCgTypeId start_ty, 474 KitCgTypeId end_ty, ToyTypeId* slice_toy_out); 475 int toy_record_field_index(ToyParser* p, KitCgTypeId record_ty, 476 KitSym field_name, uint32_t* index_out, 477 KitCgFieldLayout* field_out); 478 int toy_add_named_type(ToyParser* p, KitSym name, KitCgTypeId type, 479 ToyNamedTypeKind kind, KitCgTypeId base_type); 480 int toy_set_named_type_fields(ToyParser* p, ToyNamedType* named, 481 const ToyRecordFieldInfo* fields, size_t nfields); 482 int toy_set_named_type_enum_values(ToyParser* p, ToyNamedType* named, 483 const ToyEnumConst* values, size_t nvalues); 484 485 ToyVar* toy_find_var(ToyParser* p, KitSym name); 486 int toy_add_local_typed(ToyParser* p, KitSym name, KitCgTypeId ty, 487 ToyTypeId toy_type, KitCgLocal slot, int mutable); 488 int toy_add_static_local_typed(ToyParser* p, KitSym name, KitCgTypeId ty, 489 ToyTypeId toy_type, KitCgSym sym, int mutable); 490 ToyFn* toy_find_fn(ToyParser* p, KitSym name); 491 ToyFn* toy_add_fn_typed(ToyParser* p, KitSym name, KitCgSym sym, 492 KitCgTypeId type, ToyTypeId toy_type, KitCgTypeId ret, 493 ToyTypeId toy_ret, const KitCgTypeId* params, 494 const ToyTypeId* toy_params, size_t nparams, 495 int variadic); 496 ToyGlobal* toy_find_global(ToyParser* p, KitSym name); 497 int toy_add_global_typed(ToyParser* p, KitSym name, KitCgSym sym, 498 KitCgTypeId type, ToyTypeId toy_type, int mutable); 499 ToyNamedType* toy_find_named_type(ToyParser* p, KitSym name); 500 ToyNamedType* toy_find_named_type_by_type(ToyParser* p, KitCgTypeId type); 501 ToyLabel* toy_find_label(ToyParser* p, KitSym name); 502 ToyLabel* toy_declare_label(ToyParser* p, KitSym name); 503 ToyScope* toy_find_scope(ToyParser* p, KitSym name); 504 ToyScope* toy_find_innermost_loop_scope(ToyParser* p); 505 void toy_push_var_lvalue(ToyParser* p, const ToyVar* v); 506 void toy_push_var_addr(ToyParser* p, const ToyVar* v); 507 /* Chain helpers: see comments in symbols.c. Both consume and produce 508 * pointer-rvalue TOS. */ 509 void toy_addr_offset(ToyParser* p, int64_t offset, KitCgTypeId result_ptr_ty); 510 void toy_addr_index(ToyParser* p, uint64_t elem_size, 511 KitCgTypeId result_ptr_ty); 512 KitCgSym toy_find_decl_sym(ToyParser* p, KitSym name); 513 514 /* Per-compile symbol-environment accessors. *_cur_sym map a durable 515 * fn/global (a pointer into module->fns / module->globals) to its KitCgSym 516 * in the current object; *_set_cur_sym reserve and record that mapping by 517 * index (returns 0 on OOM). */ 518 KitCgSym toy_fn_cur_sym(ToyParser* p, const ToyFn* fn); 519 KitCgSym toy_global_cur_sym(ToyParser* p, const ToyGlobal* g); 520 int toy_fn_set_cur_sym(ToyParser* p, size_t index, KitCgSym sym); 521 int toy_global_set_cur_sym(ToyParser* p, size_t index, KitCgSym sym); 522 523 int toy_parse_program(ToyParser* p); 524 525 #endif