diff options
Diffstat (limited to 'tests')
20 files changed, 323 insertions, 22 deletions
diff --git a/tests/actor/reject/drop_message.zc b/tests/actor/reject/drop_message.zc new file mode 100644 index 0000000..fb37d5f --- /dev/null +++ b/tests/actor/reject/drop_message.zc @@ -0,0 +1,13 @@ +// destructors 7: copying a value with a drop into an actor message is an error; two processes would drop it twice +namespace; +include rt, actor; +struct res { int fd; void drop() { rt.put_s("closed"); } } +actor Keeper { int total; int handle(res* r) { return r.fd; } } +fn main() { + Keeper* k = rt.new(Keeper); + res* r = rt.new(res); r.fd = 3; + k.spawn(); + k.send(r); + k.close(); + return 0; +} diff --git a/tests/actor/reject/drop_value.zc b/tests/actor/reject/drop_value.zc new file mode 100644 index 0000000..10e941d --- /dev/null +++ b/tests/actor/reject/drop_value.zc @@ -0,0 +1,12 @@ +// destructors 7: a value whose own drop is set can't be copied into an actor message either +namespace; +include rt, actor; +actor Echo { int handle(int* p) { return *p; } } +fn main() { + Echo* e = rt.new(Echo); + int* p = rt.new(int); p.drop = fn() { rt.put_s("dropped"); }; + e.spawn(); + e.send(p); + e.close(); + return 0; +} diff --git a/tests/conformance/6-ownership/drop_ends_in_o3_rejected.zc b/tests/conformance/6-ownership/drop_ends_in_o3_rejected.zc new file mode 100644 index 0000000..4f29537 --- /dev/null +++ b/tests/conformance/6-ownership/drop_ends_in_o3_rejected.zc @@ -0,0 +1,9 @@ +// expect error: r: has drop and can't end inside an o3 region +// destructors, o3: a droppable value's lifetime can't end inside an o3 scope +include rt; +struct res { int fd; void drop() { rt.put_s("closed"); } } +fn main() { + o3 { res* r = rt.new(res); r.fd = 1; } + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_forms.zc b/tests/conformance/6-ownership/drop_forms.zc new file mode 100644 index 0000000..e9e4c07 --- /dev/null +++ b/tests/conformance/6-ownership/drop_forms.zc @@ -0,0 +1,14 @@ +// expect: 15i'm free as a bird! 15/body y7 x g +// destructors 2: drop(v, f) and v.drop(f) return v, v.drop = f; is a statement; this is the value. the spec example drops its temporary at the end of the statement +include rt; +fn main() { + rt.put_n(*heap(15).drop(fn() { rt.put_s("i'm free as a bird! "); rt.put_n(*this); })); + rt.put_c(10); + let g = drop(heap(1), fn() { rt.put_s("g "); }); + let x = rt.new(int).drop(fn() { rt.put_s("x "); }); + let y = rt.new(int); y.drop = fn() { rt.put_s("y"); rt.put_n(*this); rt.put_s(" "); }; + *y = 7; + rt.put_s("body "); + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_free_in_o3_rejected.zc b/tests/conformance/6-ownership/drop_free_in_o3_rejected.zc new file mode 100644 index 0000000..b318d1f --- /dev/null +++ b/tests/conformance/6-ownership/drop_free_in_o3_rejected.zc @@ -0,0 +1,10 @@ +// expect error: x: has drop and can't end inside an o3 region +// destructors, o3: an explicit free of a droppable value inside o3 is an error +include rt; +fn main() { + int* x = rt.new(int); + x.drop = fn() { rt.put_s("a"); }; + o3 { rt.free(x); } + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_gc_once.zc b/tests/conformance/6-ownership/drop_gc_once.zc new file mode 100644 index 0000000..abe1d95 --- /dev/null +++ b/tests/conformance/6-ownership/drop_gc_once.zc @@ -0,0 +1,17 @@ +// expect: 0 drop 7 1 1 1 0/ +// destructors 6: the collector runs an unreachable value's drop after the sweep, exactly once; later collections never run it again +include rt; +int n; +word g; +fn make() { g = drop(heap(7), fn() { n++; rt.put_s("drop "); rt.put_n(*this); rt.put_c(32); }); return 0; } +fn main() { + make(); + rt.gc(); rt.put_n(n); rt.put_c(32); + g = 0; + rt.gc(); rt.put_n(n); rt.put_c(32); + rt.gc(); rt.put_n(n); rt.put_c(32); + rt.gc(); rt.put_n(n); rt.put_c(32); + rt.put_n(rt.dcount); rt.put_c(10); // its entry is gone with the block + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_gc_resurrect.zc b/tests/conformance/6-ownership/drop_gc_resurrect.zc new file mode 100644 index 0000000..d964eba --- /dev/null +++ b/tests/conformance/6-ownership/drop_gc_resurrect.zc @@ -0,0 +1,21 @@ +// expect: drop 8 alive 8 1 gone 1/ +// destructors 6: a drop that stores this somewhere reachable revives the value; it stays usable, its drop never runs again, and a later collection reclaims it +include rt; +int n; +word g, saved; +unchecked int keep(word p) { saved = p; return 0; } +fn make() { g = drop(heap(8), fn() { n++; keep(this); rt.put_s("drop "); rt.put_n(*this); rt.put_c(32); }); return 0; } +fn main() { + make(); + g = 0; + rt.gc(); + rt.gc(); + unchecked { word p = saved; rt.put_s("alive "); rt.put_n(p[0]); rt.put_c(32); } + rt.put_n(n); rt.put_c(32); + saved = 0; + rt.gc(); rt.gc(); + rt.put_s("gone "); rt.put_n(n); + rt.put_c(10); + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_heap_values.zc b/tests/conformance/6-ownership/drop_heap_values.zc new file mode 100644 index 0000000..63d07c9 --- /dev/null +++ b/tests/conformance/6-ownership/drop_heap_values.zc @@ -0,0 +1,15 @@ +// expect: 10 hi 2 4 9 / +// destructors 1: heap(v) boxes an int, a string and a struct into a fresh owned block sized to the value +include rt; +struct foo { int bar; int baz; } +fn main() { + int* a = heap(10); + char* s = heap("hi"); + foo v; v.bar = 4; v.baz = 9; + foo* f = heap(v); + rt.put_n(*a); rt.put_c(32); rt.put_s(s); rt.put_c(32); rt.put_n(rt.len_w(s)); rt.put_c(32); + rt.put_n(f.bar); rt.put_c(32); rt.put_n(f.baz); rt.put_c(32); + rt.put_c(10); + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_in_o3_rejected.zc b/tests/conformance/6-ownership/drop_in_o3_rejected.zc new file mode 100644 index 0000000..9095269 --- /dev/null +++ b/tests/conformance/6-ownership/drop_in_o3_rejected.zc @@ -0,0 +1,9 @@ +// expect error: a drop can't be set inside an o3 region +// destructors, o3: setting a drop inside o3 is an error +include rt; +fn main() { + int* x = rt.new(int); + o3 { x.drop = fn() { rt.put_s("a"); }; } + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_parent_before_child.zc b/tests/conformance/6-ownership/drop_parent_before_child.zc new file mode 100644 index 0000000..9f68c52 --- /dev/null +++ b/tests/conformance/6-ownership/drop_parent_before_child.zc @@ -0,0 +1,17 @@ +// expect: parent sees 5 child / +// destructors 3: a child owned by a field drops after its parent's drop returns, so the parent still sees it +include rt; +struct node { int* kid; } +int* seen; +fn main() { + { + node* p = rt.new(node); + p.drop = fn() { rt.put_s("parent sees "); rt.put_n(*this.kid); rt.put_c(32); }; + int* k = rt.new(int); k.drop = fn() { rt.put_s("child "); }; + *k = 5; + p.kid = k; + } + rt.put_c(10); + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_reused_address.zc b/tests/conformance/6-ownership/drop_reused_address.zc new file mode 100644 index 0000000..97ef21d --- /dev/null +++ b/tests/conformance/6-ownership/drop_reused_address.zc @@ -0,0 +1,22 @@ +// expect: drop 1 same 1 1 0/ +// destructors 9: a freed block's drop and its bits are cleared, so a block reused at the same address runs no old drop +include rt; +int n, first; +int addr(int* p) { return p as int; } +int clean(int* p) { unbounded { return (p[-4] & (rt.F_HASDROP | rt.F_DROPPED)) == 0; } } +// the drop is set in a helper, so main has no closure and its locals take no cells from the heap +int* .u armed() { int* p = rt.new(int); p.drop = fn() { n++; rt.put_s("drop "); }; return p; } +fn main() { + { int* p = armed(); *p = 1; first = addr(p); } + rt.put_n(n); rt.put_c(32); + { + int* q = rt.new(int); *q = 2; + if (addr(q) == first) rt.put_s("same "); else rt.put_s("moved "); + rt.put_n(clean(q)); rt.put_c(32); + } + rt.put_n(n); rt.put_c(32); + rt.put_n(rt.dcount); + rt.put_c(10); + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_set_late.zc b/tests/conformance/6-ownership/drop_set_late.zc new file mode 100644 index 0000000..9bd8310 --- /dev/null +++ b/tests/conformance/6-ownership/drop_set_late.zc @@ -0,0 +1,10 @@ +// expect error: x: drop set after the value was used +// destructors 2: the drop must be set before the value is first read, reassigned or passed +include rt; +fn main() { + int* x = rt.new(int); + *x = 4; + x.drop = fn() { rt.put_s("a"); }; + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_set_twice.zc b/tests/conformance/6-ownership/drop_set_twice.zc new file mode 100644 index 0000000..843694a --- /dev/null +++ b/tests/conformance/6-ownership/drop_set_twice.zc @@ -0,0 +1,10 @@ +// expect error: x: drop is already set +// destructors 2: a value's drop can be set only once +include rt; +fn main() { + int* x = rt.new(int); + x.drop = fn() { rt.put_s("a"); }; + x.drop = fn() { rt.put_s("b"); }; + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_temporary_statement.zc b/tests/conformance/6-ownership/drop_temporary_statement.zc new file mode 100644 index 0000000..fd27623 --- /dev/null +++ b/tests/conformance/6-ownership/drop_temporary_statement.zc @@ -0,0 +1,13 @@ +// expect: unlocked a b unlocked c / +// destructors 3: a value nothing holds drops at the end of its full statement; a bound guard drops at block end +include rt; +void unlock() { rt.put_s("unlocked "); } +fn main() { + heap(0).drop = fn() { unlock(); }; + rt.put_s("a "); + { let guard = drop(heap(0), fn() { unlock(); }); rt.put_s("b "); } + rt.put_s("c "); + rt.put_c(10); + return 0; +} +// zc0: skip diff --git a/tests/conformance/6-ownership/drop_value_and_type.zc b/tests/conformance/6-ownership/drop_value_and_type.zc new file mode 100644 index 0000000..2979e4f --- /dev/null +++ b/tests/conformance/6-ownership/drop_value_and_type.zc @@ -0,0 +1,11 @@ +// expect: body value type only-type / +// destructors 2: a struct body's drop is the default for its type; a value's own drop runs first, then the type's +include rt; +struct res { int fd; void drop() { if (this.fd) rt.put_s("type "); else rt.put_s("only-type "); } } +fn main() { + { res* r = rt.new(res); r.drop = fn() { rt.put_s("value "); }; r.fd = 1; rt.put_s("body "); } + { res* q = rt.new(res); q.fd = 0; } + rt.put_c(10); + return 0; +} +// zc0: skip diff --git a/tests/conformance/8-runtime/o3_no_gc_inside.zc b/tests/conformance/8-runtime/o3_no_gc_inside.zc new file mode 100644 index 0000000..532765c --- /dev/null +++ b/tests/conformance/8-runtime/o3_no_gc_inside.zc @@ -0,0 +1,39 @@ +// expect: 0 1 0 1 0 1/ +// spec 4.10.3: no collection runs inside an o3 region; an allocation that would collect grows the heap, and leaving the outermost region runs the pending collection once +include rt; +word sink; +int inside; +o3 int churn(int n) { + int i = 0; + while (i < n) { sink = rt.new(64); i++; } + rt.gc(); + return 0; +} +int early(int base) { + o3 { + int i = 0; + while (i < 20000) { sink = rt.new(64); i++; } + rt.gc(); + inside = rt.gc_runs - base; + return 0; + } + return 1; +} +fn main() { + int before = rt.gc_runs; + o3 { + int i = 0; + while (i < 20000) { sink = rt.new(64); i++; } + inside = rt.gc_runs - before; + } + rt.put_n(inside); rt.put_c(32); rt.put_n(rt.gc_runs - before); rt.put_c(32); + before = rt.gc_runs; + churn(20000); + rt.put_n(0); rt.put_c(32); rt.put_n(rt.gc_runs - before); rt.put_c(32); + before = rt.gc_runs; + early(before); + rt.put_n(inside); rt.put_c(32); rt.put_n(rt.gc_runs - before); + rt.put_c(10); + return 0; +} +// zc0: skip diff --git a/tests/data/drop_hint.zc b/tests/data/drop_hint.zc new file mode 100644 index 0000000..c690bc5 --- /dev/null +++ b/tests/data/drop_hint.zc @@ -0,0 +1,2 @@ +include rt; +fn main() { heap(0).drop = fn() { rt.put_s("u"); }; return 0; } diff --git a/tests/drivers/actor_test.py b/tests/drivers/actor_test.py index 0cfa51f..929bbf4 100644 --- a/tests/drivers/actor_test.py +++ b/tests/drivers/actor_test.py @@ -23,7 +23,7 @@ for case in sorted((root / 'tests/actor').glob('*/*.zc')): proc = subprocess.run([str(root / args.vm)], input=source, text=True, capture_output=True, cwd=root, timeout=15) elapsed = time.monotonic() - start if case.parent.name == 'reject': - required = {'no_include': "actor: isn't a type", 'input_type': 'type error:', 'output_type': 'type error:', 'explicit_this': 'this is implicit', 'nested_missing_import': 'module access requires `include rt;`', 'generic_input': 'type error:', 'generic_method_return': 'type error:'}[case.stem] + required = {'no_include': "actor: isn't a type", 'input_type': 'type error:', 'output_type': 'type error:', 'explicit_this': 'this is implicit', 'nested_missing_import': 'module access requires `include rt;`', 'generic_input': 'type error:', 'generic_method_return': 'type error:', 'drop_message': "r: has drop and can't be copied into a message", 'drop_value': "p: has drop and can't be copied into a message"}[case.stem] assert required in proc.stdout, f'{case}: expected {required!r}, got {proc.stdout!r}' else: actual = proc.stdout diff --git a/tests/test.sh b/tests/test.sh index 1be4557..a3370f2 100755 --- a/tests/test.sh +++ b/tests/test.sh @@ -347,7 +347,7 @@ s_small() { # code literals can look like pointers on a compact map. test collection and # the retained root without assuming the default map's exact reclaim count. for vm in $T/zyms $T/zys; do - out=$(sed 's/f >= 990/f > 0/' tests/programs/gc.zc | $vm | tr '\n' '/') + out=$(sed -E 's/f >= [0-9]+/f > 0/' tests/programs/gc.zc | $vm | tr '\n' '/') chk "$out" "1000 1 900 1 199900/" "small collector makes progress and preserves its root" done @@ -578,6 +578,7 @@ s_lsp() { case "$h" in *"$w"*) chk 1 1 "lsp hint: $w";; *) chk 0 1 "lsp hint: $w";; esac done chk "$($lsp < examples/struct_closure_opt.zc | grep -c error)" "0" "lsp: methods and closures check clean" + case "$($lsp < tests/data/drop_hint.zc)" in *"value with drop is never bound; it drops at the end of this statement"*) chk 1 1 "lsp hint: a value with drop that is never bound";; *) chk 0 1 "lsp hint: a value with drop that is never bound";; esac # a file of a larger build checks on its own: its bodyless declarations are not errors in check mode for f in src/runtime/rt.zc src/runtime/run.zc src/lsp/server.zc; do chk "$($lsp < $f | grep -c ': error:')" "0" "lsp: $f checks alone"; done # the compiler is several files that only make sense together: check them as one document diff --git a/tests/xref.baseline b/tests/xref.baseline index 985f9c7..8731091 100644 --- a/tests/xref.baseline +++ b/tests/xref.baseline @@ -35,12 +35,18 @@ asm_sites reserve_asm_labels bincap reserve_binary blen add_binop reserve_binary bname add_binop reserve_binary +bnxt chk_reset fn_begin topitem1 borrow_depth call ctx_pop fn_begin borrow_entry borrow_prologue ctx_pop fn_begin borrow_jump borrow_prologue ctx_pop fn_begin borrow_pending ctx_pop emit_borrow_hold fn_begin borrow_slots ctx_pop emit_borrow_hold fn_begin +bound_on chk_reset topitem1 bprec add_binop reserve_binary +bs_pk body_scan bs_adv +bs_pk2 body_scan bs_adv +bs_pv body_scan bs_adv +bs_pv2 body_scan bs_adv bseq add_binop reserve_binary bxdepth blockexpr chk_reset ctx_pop fn_begin callpos chk_reset primary @@ -76,6 +82,7 @@ clo_via clocap_at reserve_captures reserve_closures clo_via_initial closure_cap reserve_closures closure_expected args closure zc_init +closure_this closure drop_attach cmode chk_begin chk_end code_chunk chk_reset reserve_code syntax_resident ctxsp ctx_pop ctx_push zc_init @@ -109,9 +116,10 @@ dnmb_initial docbufcap doc_char docnamecap doc_name_room docpending chk_reset docblock doccomment lex1 -docs_on capture_scan chk_reset kw_docs +docs_on body_scan capture_scan chk_reset kw_docs docsnapcap topitem0 -dry capture_scan chk_reset hl_begin hl_end prescan typearg +drop_tail drop_call drop_member +dry body_scan capture_scan chk_reset hl_begin hl_end prescan typearg dsect chk_reset docblock doccomment dsn chk_reset doc_attach topitem0 dsnap topitem0 @@ -128,7 +136,8 @@ effect_edges effect_arg zc_init effect_floor compile_list_context ctx_pop unit_top zc_init effect_requirements effect_finish effect_require_mode zc_init effect_symbols effect_record reserve_symbols zc_init -effect_value array_cap array_len array_pop arrvalue bin call ctx_pop field fn_begin kw_share_value methcall postfix_tail primary ternary unary +effect_value array_cap array_len array_pop arrvalue bin call ctx_pop drop_attach field fn_begin heap_box kw_share_value methcall postfix_tail primary ternary unary +enum_open kw_enum epichain chk_reset ctx_pop fn_begin kw_return evcap ev_put evn chk_unit ev_put @@ -138,6 +147,7 @@ export_path export_owner export_tail export_add export_owners extop chk_reset exit_rec loop_end factcap putfact +fbnd chk_reset closure ctx_pop fn_begin kw_unbounded fchk chk_reset ctx_pop defer_one fn_begin kw_unchecked fdepth block blockexpr casebody chk_reset ctx_pop fn_begin kw_for kw_switch substmt fframe chk_reset ctx_pop prologue @@ -170,8 +180,9 @@ fortest bin chk_reset kw_for fret chk_reset ctx_pop fn_begin retcheck fs_ok expr incdec kw_for fsite fixnew reserve_fixes -fslots array_dynamic_literal array_literal_tokens chk_reset closure ctx_pop embed_bind emit_borrow_hold field fn_begin fndef kw_switch localdecl o3mkcache +fslots array_dynamic_literal array_literal_tokens chk_reset closure ctx_pop embed_bind emit_borrow_hold field fn_begin fndef hoist_guard kw_switch localdecl o3mkcache ft_bd bin +ft_ck bin kw_for ft_ir bin ft_iv bin kw_for ft_nops bin @@ -194,7 +205,7 @@ gnew_nm gnew_np gng gcompile gnm -grec capture_scan chk_reset topitem +grec body_scan capture_scan chk_reset topitem gt_imports ginit gtmake reserve_generics gt_module ginit gtmake reserve_generics gt_n chk_reset gtmake @@ -261,7 +272,7 @@ kops addkop reserve_operators kw_expr chk_reset ctx_pop kwcall laaddr array_literal_tokens localdecl newloc reserve_locals unary laaddr_initial -lafact af_forget af_store array_literal_tokens expr incdec localdecl newloc reserve_locals +lafact af_forget af_store array_literal_tokens expr incdec lafact_keep localdecl newloc reserve_locals lafact_initial larr array_literal_tokens embed_bind localdecl newloc reserve_locals lbase ctx_pop fn_begin zc_init @@ -271,6 +282,7 @@ lheads defer_one local_bind local_drop lheads_initial lhome block_close join newloc reserve_locals snap_restore touch line chk_reset nextch src_pop src_push +lines_on kw_lines lt_apply_marks literal_doc_cap literal_doc_note literal_doc_n chk_unit literal_doc_note literal_docs literal_doc_note @@ -286,6 +298,7 @@ lnsz assigncheck embed_bind localdecl reserve_locals lnsz_initial local_captured clocap_at newloc reserve_locals local_cell capture_cell newloc reserve_locals +local_dropset drop_attach localdecl newloc reserve_locals local_end_info assigncheck end_owner newloc reserve_locals local_ended assigncheck end_owner newloc reserve_locals local_origin assigncheck newloc reserve_locals @@ -297,6 +310,7 @@ lown assigncheck closure fndef newloc reserve_locals touch lowner assigncheck join newloc reserve_locals snap_restore lpfact bpoison kw_for loop_push reserve_R_LOOP lpfact_initial +lpinfo linfo_new loop_push lpos closure embed_bind fndef localdecl newloc reserve_locals lpos_initial lprev local_bind reserve_locals @@ -314,10 +328,24 @@ lslot newloc reserve_locals lsp ctx_pop loop_end loop_push zc_init lstate alias_end assigncheck backedge block_close closure end_owner fndef handup join newloc recast reserve_locals retcheck snap_cmp snap_restore touch lt_at lt_note +lt_base lt_begin lt_end +lt_buf lt_begin lt_room lt_stmt +lt_cap lt_room +lt_file build_image_grow lt_file_data +lt_file_at build_image_grow lt_file_data +lt_file_img lt_file_data +lt_head build_image_grow lt_end lt_len lt_note +lt_mark_base build_image_grow lt_apply_marks +lt_mark_file build_image_grow lt_apply_marks +lt_markcap mark_line +lt_marks mark_line lt_n lt_note +lt_next_mark build_image_grow lt_apply_marks +lt_nmarks build_image_grow mark_line lt_off lt_note lt_on +lt_top lt_begin lt_end lt_stmt lt_type lt_note ltag asmblock embed_bind expr fndef incdec kw_o3 localdecl luse newloc o3mkcache o3promote reserve_locals rval setflt setstr touch unary ltcap lt_note @@ -326,10 +354,10 @@ ltxt lt_note ltxtcap lt_note ltype array_literal_tokens closure embed_bind fndef kw_switch localdecl newloc reserve_locals lused assigncheck luse newloc reserve_locals -lv array_dynamic_literal array_literal_tokens bin blockexpr call chk_reset closure ctx_pop enhcall expr field fn_begin incdec kwcall methcall newtyped postfix_tail primary rval ternary unary +lv array_dynamic_literal array_literal_tokens bin blockexpr call chk_reset closure ctx_pop drop_attach enhcall expr field fn_begin heap_box incdec kwcall methcall newtyped postfix_tail primary rval ternary unary lvescaped closure newloc reserve_locals unary lvi chk_reset ctx_pop field postfix_tail primary -lvk array_dynamic_literal array_literal_tokens bin blockexpr call chk_reset closure ctx_pop enhcall expr field fn_begin incdec kwcall methcall newtyped postfix_tail primary ternary unary +lvk array_dynamic_literal array_literal_tokens bin blockexpr call chk_reset closure ctx_pop drop_attach enhcall expr field fn_begin heap_box incdec kwcall methcall newtyped postfix_tail primary ternary unary lvkind closure expr incdec newloc reserve_locals unary vf_effect vf_store lvvalue newloc reserve_locals vf_store mdbg chk_reset kw_memdebug @@ -351,8 +379,8 @@ nclo chk_reset closure ndfr defer_drop kw_defer nenh blob_load build_image_grow chk_reset enhdef nerr chk_begin chk_reset errat prescan replace_function -newleaf array_dynamic_literal array_pop call localdecl newtyped -newsz array_dynamic_literal array_pop call chk_reset localdecl newtyped +newleaf array_dynamic_literal array_pop call heap_box localdecl newtyped +newsz array_dynamic_literal array_pop call chk_reset heap_box localdecl newtyped nfact chk_reset fdrop putfact nfixu fixnew zc_init ngbind call chk_reset primary @@ -377,6 +405,7 @@ ntok next ntp chk_reset ctx_pop fndef fndone genparams kw_struct methdef ptype1 topitem1 numops types_init nun add_unop zc_init +o3blk kw_o3 o3cache kw_o3 newloc o3mkcache reserve_locals o3cache_initial o3dsc o3region @@ -393,7 +422,7 @@ o3pend_initial o3pendcap kw_o3 o3rg o3promote o3sl o3promote -panic chk_begin chk_reset die diefound dien effect_finish expect hl_begin prescan replace_function resync topsync unit_end +panic body_scan capture_scan chk_begin chk_reset die diefound dien effect_finish expect hl_begin prescan replace_function resync topsync unit_end pe_first enum_tagged reserve_tagged_enums pe_first_initial pe_n enum_tagged reserve_tagged_enums @@ -433,7 +462,7 @@ poolend intern zc_init pooltop intern zc_init pq_gl next peekat src_pop pq_ln next peekat src_pop -pq_n capture_scan chk_reset hl_begin hl_end next peekat src_pop src_push +pq_n body_scan capture_scan chk_reset hl_begin hl_end next peekat src_pop src_push pq_tk next peekat src_pop pq_tv next peekat src_pop probe_cap probe_add @@ -465,6 +494,8 @@ s_andand zc_init s_arrow zc_init s_as zc_init s_at_s types_init +s_bchk types_init +s_bnd types_init s_case zc_init s_cat_s types_init s_check zc_init @@ -520,6 +551,7 @@ s_le types_init s_le_s types_init s_len_s types_init s_lfa types_init +s_lines types_init s_lk zc_init s_lp zc_init s_lt types_init @@ -574,12 +606,14 @@ s_type types_init s_typecheck types_init s_typedef types_init s_u zc_init +s_unbounded zc_init s_unchecked zc_init s_var zc_init s_vm zc_init s_while zc_init sdoff addsym def_note reserve_symbols sdsrc addsym def_note reserve_symbols +send_check args field seqtop seqasm zc_init sfix addsym enhdef fndef fnref reserve_symbols sflag add_kw addsym blob_load call enhdef fndef fndone fwdfn_at ginstance kw_extern kw_struct methcall methdecl prescan_fn reserve_symbols retcheck @@ -600,6 +634,23 @@ stype addsym embed_bind enum_tagged fndef gdecl2 kw_enum reserve_symbols retchec sval addsym blob_emit fndef reserve_symbols svkind expr reserve_symbols vf_symbols svvalue expr reserve_symbols vf_symbols +sx_asm types_init +sx_bool types_init +sx_char types_init +sx_defer types_init +sx_do types_init +sx_else types_init +sx_float types_init +sx_for types_init +sx_if types_init +sx_int types_init +sx_new types_init +sx_pop types_init +sx_push types_init +sx_quote types_init +sx_resize types_init +sx_switch types_init +sx_while types_init symcap reserve_symbols syntax_host_floor syntax_resident syntax_host_from syntax_resident @@ -618,7 +669,7 @@ tfloat types_init tglue chk_reset lex1 next peekat src_pop tunpack tint types_init tk chk_reset floatok lex1 next next0 oplex peekat src_pop -tline chk_reset lex1 tunpack +tline chk_reset docblock lex1 tunpack toff chk_reset lex1 tunpack token_block_doc lex1 toklen chk_reset lex tunpack @@ -640,19 +691,24 @@ uname add_unop reserve_unary uncap reserve_unary useq add_unop reserve_unary vislo build_image_grow chk_unit start syntax_resident -xaf af_forget args array_cap array_dynamic_literal array_len array_literal_tokens array_pop bin call chk_reset expr field incdec kw_share_value kwcall methcall newtyped postfix_tail primary ternary unary -xbor array_cap array_dynamic_literal array_len array_literal_tokens array_pop assigncheck bin blockexpr call chk_reset closure discard enhcall field fn_begin kw_share_value kwcall methcall postfix_tail primary ternary typearg unary +xaf af_forget args array_cap array_dynamic_literal array_len array_literal_tokens array_pop bin call chk_reset drop_attach drop_member expr field heap_box incdec kw_share_value kwcall methcall newtyped postfix_tail primary ternary unary +xbor array_cap array_dynamic_literal array_len array_literal_tokens array_pop assigncheck bin blockexpr call chk_reset closure discard drop_attach drop_member enhcall field fn_begin heap_box kw_share_value kwcall methcall postfix_tail primary ternary typearg unary +xc_file xc_init +xc_fn closure fndef +xc_hook xc_init +xc_on xc_init +xc_src unit_stdin xcls array_cap array_len array_pop array_push array_resize chk_reset ctx_pop kw_asm kwcall quote_tokens -xconst array_dynamic_literal array_literal_tokens bin call chk_reset closure kw_share_value methcall postfix_tail primary unary +xconst array_dynamic_literal array_literal_tokens bin call chk_reset closure drop_attach heap_box kw_share_value methcall postfix_tail primary unary xcval array_literal_tokens primary unary -xfloat array_dynamic_literal array_len array_literal_tokens array_pop array_push array_resize bin blockexpr call closure expr fcoerce femit ftest incdec kw_cfunc kw_for methcall postfix_tail primary ternary unary +xfloat array_dynamic_literal array_len array_literal_tokens array_pop array_push array_resize bin blockexpr call closure drop_attach expr fcoerce femit ftest heap_box incdec kw_cfunc kw_for methcall postfix_tail primary ternary unary xgive argcheck args chk_reset xlend assigncheck expr unary xlenloc array_len bin call closure enhcall methcall postfix_tail primary unary xprojection ctx_pop field postfix_tail primary xstamp array_dynamic_literal array_len bin call closure enhcall methcall newtyped postfix_tail primary unary -xstr array_dynamic_literal array_len array_literal_tokens bin blockexpr call closure incdec methcall postfix_tail primary unary -xty args array_cap array_dynamic_literal array_len array_literal_tokens array_pop array_push array_resize bin blockexpr call closure ctx_pop enhcall expr fcoerce field ftest kw_cfunc kw_share_value kw_sizeof kw_typeof kwcall methcall newtyped postfix_tail primary ternary unary +xstr array_dynamic_literal array_len array_literal_tokens bin blockexpr call closure drop_attach heap_box incdec methcall postfix_tail primary unary +xty args array_cap array_dynamic_literal array_len array_literal_tokens array_pop array_push array_resize bin blockexpr call closure ctx_pop drop_attach drop_member enhcall expr fcoerce field ftest heap_box kw_cfunc kw_share_value kw_sizeof kw_typeof kwcall methcall newtyped postfix_tail primary ternary unary xvk array_dynamic_literal array_literal_tokens bin blockexpr chk_reset ctx_pop expr field fn_begin incdec kw_share_value kwcall postfix_tail primary ternary unary vf_coerce vf_effect vf_forget xvv blockexpr primary unary vf_coerce -xzero array_dynamic_literal array_literal_tokens bin blockexpr call closure enhcall expr field incdec kwcall methcall newtyped postfix_tail primary ternary unary +xzero array_dynamic_literal array_literal_tokens bin blockexpr call closure drop_attach enhcall expr field heap_box incdec kwcall methcall newtyped postfix_tail primary ternary unary |