rpg_source.zig, rpg_source_shared.zig, rpg_source_render_emit.zig, rpg_source_decl_emit.zig: the based structures of one length share one qualified template and are one likeds line each #799

Manually merged
binjovi-bot merged 1 commit from lkds into trunk 2026-11-14 09:34:58 +00:00
Owner

rpg_source.zig, rpg_source_shared.zig, rpg_source_render_emit.zig, rpg_source_decl_emit.zig: the based structures of one length share one qualified template and are one likeds line each

The object does not show the template, so the battery requests/lkds/tmpl (24 compiles, captured 2026-11-14 in
captures/lkds-tmpl, 23 of 24: lkds-nest-w was refused with RNF3222 RNF7031) decided what text is safe. Read against its
README (readout at the end of it): likeds of a template is the structure written out (b1: a based structure; inzl: a static
one with inz(*likeds): the same symbols and instructions), the name of the template numbers no symbol (name-first,
name-last), and a structure symbol has word 28 0x80100000 and flags 0xe0000000 with a pointer subfield and 0x80010000
and 0x60000000 without one, in a based, an automatic and a static structure. My predictions failed in one way: every number
in a declaration is a constant of the object, so a template whose fillers have other widths than the structures written
out (b2-wp against b2-l, fill-typed against b2-l) changes the constant pool and the numbering of the symbols behind it, and
the opcodes stay the same. Because of that the rule shares a group only where the object proves the written-out text wrong
(below); any other group may match today and keeps its text.

The Async programs declare dcl-ds t likeds(task_t) based(p); in every procedure. The emitter wrote each structure out, the
subfields a statement names and a filler for each gap. In asyncage 18 local structures took 100 emitted lines where the source
spends 18, so the declarations did not fit before the first statement (declarations do not fit before source line 568).
Now the based structures of one length that do not conflict are one template that holds the union of their proved subfields,
and each structure is one line:

before:  dcl-ds STARTTHREAD_00465 qualified based(NEWTASK_00391);
           G0 char(100);
           F100 char(1);
           G101 char(2081);
         end-ds;
after:   dcl-ds STARTTHREAD_00465 likeds(DSTMPL2182) based(NEWTASK_00391);
         (one template of 16 lines, before the globals, for the 13 structures of the program)

The rule (core/rpg_source_shared.zig, pure): a candidate is a structure with a pointer (based), qualified, with no initial
value, no array, no decimal subfield, not static, 16 bytes or longer, and at least one proved subfield. Candidates of one
length and one word 28 are put in groups in order of symbol; a candidate joins the first group whose union it does not conflict
with (the same byte has the same type and width; no two subfields overlap) and opens another group otherwise. A group of two or
more is kept when (1) its word 28 is 0x80100000 (the object says a pointer subfield), (2) at least one member's proved
subfields hold no pointer (its written-out text is another symbol than the object's, so the program cannot match as it is), and
(3) the template and one line for each member are fewer lines than the members written out. A group in which every member holds
the pointer, or whose symbols say none, stays written out: it may match today, and the template changes its filler widths,
which are constants of the object. A member lacks the pointer that the object has, so the template gives it the pointer that
another member names; when none names one the template is no more wrong than the text it replaces. The name is
DSTMPL<length>, then DSTMPL<length>_<n>: the parameter template TMPL<length> (paramTemplates) keeps its name and layout.
Everything else is as before: automatic and static structures, parameters, structures with an initial value, the fixed and the
mixed forms. The statements are unchanged: NAME.F<offset> is a subfield of the template by construction. The plan is made at
the first call after failUndeclared (fitGlobals), when the declarations are final.

What the object shows (2026-11-13, v0.1.513, the six Async captures)

  • The creation data of the stripped and the observable object have the same symbols: the dumps (kind, class, length, owner,
    flags and words) are equal in all six programs (asyncage 1898 symbols and 54 procedures; asyncdemo 1998; asyncbg 1993;
    asynccncl 1972; asyncprom 1972; asynctime 2030). A template has no symbol: asyncage has 32 symbols of 2182 bytes, one is a
    constant, and the 31 data symbols are the 21 based structures (23 class 0 symbols with the 2 parameters) and the 8
    automatic structures of the source, so none is left for task_t.
  • The name is in the debug data of the observable image only: the 8 template names of the source (TASK_T, PTHREAD_T, ...)
    are found as cp037 strings in the image of the observable object (11 of 11 for asyncprom), none in the stripped one. They
    are in the string pool, followed by their subfield names (HANDLE, KIND, ... ERRTEXT), and a likeds structure is a
    bare name there. No reader of that data exists in src/core and the emitter reads the stripped object, so no emit can
    name task_t; the synthetic name DSTMPL2182 is the answer where the object has no name.
  • Layout facts of the stripped object: structures of one template have one length and one word 28. Word 28 of a data
    structure symbol is 0x80100000 when the structure has a pointer subfield and 0x80010000 when it has none (a based
    structure of 20 bytes with buf pointer, lext-based-ptr-c, against the structures of 8, 15 and 23 bytes with char,
    int(10) and packed of lv-based-read-int, lpar-lk-set-local and lv-sf-packed50). Host-measured on our own emit: the rebuilt
    object of the v0.1.512 emit of asyncage (runs/pub-l10-async-asyncage-173618/cases/1/capture, 13 based structures written
    out, 12 of them without a pointer subfield) has 14 symbols of 2182 bytes at 0x80010000 and 1 at 0x80100000, where the
    object of the source has all 31 at 0x80100000 (checked in the six Async programs). So the written-out text of a structure
    that names no pointer cannot give the symbol of the object, in a program that cannot match for other reasons too, and the
    shared template, which holds the pointer(*proc) that one structure names, gives the word to every member (battery b2,
    a2, s2, b2t, twolen: the structure written out without the pointer has 0x80010000 and flags 0x60000000, 0x70008000
    or 0x7000c000; the likeds structure and the one written with the pointer have 0x80100000 and 0xe0000000,
    0xf0008000, 0xf000c000). Only structures of one word 28 share a template. No object fact gives the subfields that no
    statement names.
  • Every number of a declaration is a constant of the object (battery: b2-l has the decimal constants 0 1 10 2 20 2081 2182 3
    44 8, b2-w has 0 1 10 12 2 20 2081 2126 2182 3 4 92, fill-typed 0 1 10 1024 2 20 2182 3 4 7 8), and the symbols are
    numbered behind them. The pool of asyncage holds 1024, 7, 20 and 2182 among 35 decimal constants and none of the filler
    widths of the v0.1.513 emit (2178, 2170, 2080, ...): each is a constant that the object lacks, and the field widths of
    task_t (1024, 7, 20) are in the pool and could be recovered from it, a next change.

Measure (2026-11-14, emits of the stripped twins with v0.1.513 and with this branch)

program structures (based + automatic) structure lines before structure lines after (+ template) distinct bodies of the based ones first line that moved lines missing
asyncage 18 (13 + 5) 100 19 + 16 13 -> 1 template 568 -> 870 50 -> 5
asyncdemo 18 (13 + 5) 100 19 + 16 13 -> 1 641 -> 943 50 -> 5
asyncbg 18 (13 + 5) 100 19 + 16 13 -> 1 645 -> 947 50 -> 5
asynccncl 18 (13 + 5) 100 19 + 16 13 -> 1 631 -> 933 50 -> 5
asyncprom 20 (13 + 7) 116 35 + 16 13 -> 1 523 -> 523 56 -> 11
asynctime 19 (13 + 6) 104 23 + 16 13 -> 1 655 -> 957 50 -> 5

(The four lengths of the 18 structures of asyncage: 2182 for the 13 based ones, and 272, 8, 8, 4, 4 bytes for the 5
automatic ones, which are alone or shorter than 16 bytes and stay written out. The 13 bodies are 13 partial views of one
2182-byte layout, 12 of them without the pointer. "Lines missing" is the
count of the lane ldfit (Layout.missing, 83a64769, not in the base of this branch), computed here from the receipt rows with the same rule:
the count of the six programs before, 50, 50, 50, 50, 56, 50, is the one of the lane's table, so the same script gives the
"after" column. The six Async programs are one library: one sample, not six.) The statements, the emitted statements and the
failure lines of every program are equal (asyncage 584 / 309 / 278). The 5 or 11 lines that remain are the automatic
structures and the interfaces of procedures whose source has no structure there (NEWTASK_00388 qualified; F0 int(10)),
the next change; the battery pairs lkds-a2 and lkds-s2 read like the based ones, so an automatic or a static structure
with a pointer in its symbol can take the same rule.

The distinct char(n) widths of the emit that no integer constant of the original object has (each is a constant that the
object lacks, see above): asyncage 16 -> 7, asyncdemo 15 -> 7, asyncbg 15 -> 6, asynccncl 16 -> 7, asyncprom 17 -> 10,
asynctime 15 -> 7. The template has fewer distinct filler widths than the 13 structures written out had.

The coordinator's fact of 2026-11-13 (ldfit/place, ldfit-m-s-mid): the compiler refuses a declaration after a statement of
the cycle main (RNF0724), so for the main procedure a short emit is the only route; this change is that route for the
structures of a procedure. Whether a local procedure takes a declaration between statements is still being measured there.

Proof

  • src/rpg_shared_template_test.zig (registered in src/root.zig): the planner (union with fillers, a conflict of type or
    of bytes keeps the structures written out, another word 28, a group is shared only where a member lacks the pointer of its
    symbol (the object says none, or every member holds it: written out), a length under 16, a lone structure, a second layout
    of one length is DSTMPL<n>_2); ldsv-asyncprom (committed twin of the Async program asyncprom): exactly one
    dcl-ds DSTMPL2182 qualified template;, at least 13 lines likeds(DSTMPL2182) based(, the template text, and every
    NAME.F<n> of a shared structure is a subfield of the template. It is red on the base (expected 1, found 0, run against
    the unchanged core files) and green on the branch. lv-qpair-int3 (matches on the host): a lone based structure is
    written as before. The counts of statements, emitted statements and failures are not asserted: the emit-all rows below
    prove them and other lanes move them.
  • emit-all.sh with v0.1.513 and with this branch, 854 programs: one emit differs (ldsv-asyncprom, different in the
    matrix); no matching twin changes; the summary line is equal (failures 928, emitted 8422, clean 593) and so are
    statements, emitted and failures of every row. capture-emit-diff.sh over the six Async captures and the 19 scout2
    captures: 6 changed (the Async programs), the 19 others same, statements, emitted and failures equal in all 25, and no
    changed head emit without a failure line. The five public development captures captures/dev5/p1 to p5: 0 changed
    (the emits are byte-identical with both binaries; dev-hash.sh itself was not run, and the sealed ids and L10-test were
    not read, so the L10-test direction is unknown here). agree.sh on the 25 (base and head): suspect 82 and 82, same 1463 and 1463,
    equivalent 23 and 23; the declaration counters move as read: ds_emit 122 -> 128, ds_sub_extra 300 -> 76 (fewer
    fillers than the source has subfields), ds_sub_missing 220 -> 242 (the multiset of emitted subfield types is smaller
    where 13 structures became one template). WATCH, read: a count of subfield types, not a statement.
  • Not run by the lane: gate.sh and pub-roundtrip.sh (no host; the coordinator runs them). The change adds no reader of
    an operation number (docs/OPERATIONS.md is not touched) and rpg_statements.zig is not touched.

Gate

>   F52 int(10);
>   G56 char(44);
>   F100 char(1);
>   F101 char(1);
>   G102 char(1);
>   F103 char(7);
>   G110 char(2072);
> end-ds;
500,515d515
< 
forms projection differs:
311c311
< {"twin":"savf/SC-ILE/EXPERIMENTS/ldsv-asyncprom/stripped","object":"P389F4503S","status":"done","statements":619,"emitted":316,"failures":305,"lines":1612,"form_counts":{"array_element_v1":16,"compiler_policy_marks_v1":43,"context_character_literal_v1":44,"context_pointer_store_v1":44,"context_procedure_pointer_store_v1":44,"context_zero_fill_v1":44,"direct_branch_v1":39,"emit_assign_based_v1":7,"emit_assign_field_v1":34,"emit_assign_part_v1":11,"emit_callp_v1":51,"emit_ctl_opt_v1":1,"emit_dcl_ds_v1":21,"emit_dcl_pi_v1":45,"emit_dcl_proc_v1":37,"emit_dcl_s_based_v1":1,"emit_dcl_s_v1":48,"emit_dow_v1":2,"emit_ds_filler_v1":42,"emit_ds_subfield_v1":37,"emit_else_v1":7,"emit_elseif_v1":2,"emit_end_ds_v1":21,"emit_end_pi_v1":45,"emit_end_proc_v1":29,"emit_enddo_v1":2,"emit_endfor_v1":2,"emit_endif_v1":56,"emit_for_v1":2,"emit_free_v1":1,"emit_if_v1":56,"emit_leave_v1":2,"emit_pi_parameter_v1":73,"emit_return_value_v1":20,"emit_summary_v1":2,"fail_declaration_v1":2,"fail_procedure_boundary_v1":34,"fail_statement_v1":265,"fail_trailer_v1":4,"initialization_entry_v1":43,"initialization_resume_v1":43,"integer_store_v1":44,"layout_blank_v1":650,"local_pointer_store_v1":38,"null_pointer_literal_v1":58,"placeholder_block_condition_v1":4,"placeholder_parameter_type_v1":11,"placeholder_return_value_v1":6,"procedure_blank_fill_v1":14,"procedure_character_literal_v1":26,"procedure_end_guard_v1":32,"procedure_exit_transfer_v1":50,"procedure_null_pointer_v1":3,"procedure_return_v1":43},"text_sha256":"5901c79e096e9ec83261d29512257017eda7693d0ade11da31a9e3a733b15c89"}
---
== d. captures (capture-emit-diff)
l10-async-asyncage base=[584,309,278] head=[584,309,278] CHANGED fail-lines=278
l10-async-asyncdemo base=[621,333,291] head=[621,333,291] CHANGED fail-lines=291
l10-async-asyncbg base=[597,314,285] head=[597,314,285] CHANGED fail-lines=285
l10-async-asynccncl base=[608,324,287] head=[608,324,287] CHANGED fail-lines=287
l10-async-asyncprom base=[619,316,305] head=[619,316,305] CHANGED fail-lines=305
l10-async-asynctime base=[630,340,294] head=[630,340,294] CHANGED fail-lines=294
capture-emit-diff: 34 cases, 6 changed, 2 with no failure line in the head emit
== e. source agreement (agree)
suspect        base=80 head=80
conflict       base=0 head=0
params_wrong   base=17 head=17
decl_missing   base=81 head=81
decl_extra     base=25 head=25
type_unmarked  base=47 head=47
gate: PASS
## rpg_source.zig, rpg_source_shared.zig, rpg_source_render_emit.zig, rpg_source_decl_emit.zig: the based structures of one length share one `qualified template` and are one `likeds` line each The object does not show the template, so the battery `requests/lkds/tmpl` (24 compiles, captured 2026-11-14 in `captures/lkds-tmpl`, 23 of 24: `lkds-nest-w` was refused with RNF3222 RNF7031) decided what text is safe. Read against its README (readout at the end of it): `likeds` of a template is the structure written out (b1: a based structure; inzl: a static one with `inz(*likeds)`: the same symbols and instructions), the name of the template numbers no symbol (name-first, name-last), and a structure symbol has word 28 `0x80100000` and flags `0xe0000000` with a pointer subfield and `0x80010000` and `0x60000000` without one, in a based, an automatic and a static structure. My predictions failed in one way: every number in a declaration is a constant of the object, so a template whose fillers have other widths than the structures written out (b2-wp against b2-l, fill-typed against b2-l) changes the constant pool and the numbering of the symbols behind it, and the opcodes stay the same. Because of that the rule shares a group only where the object proves the written-out text wrong (below); any other group may match today and keeps its text. The Async programs declare `dcl-ds t likeds(task_t) based(p);` in every procedure. The emitter wrote each structure out, the subfields a statement names and a filler for each gap. In asyncage 18 local structures took 100 emitted lines where the source spends 18, so the declarations did not fit before the first statement (`declarations do not fit before source line 568`). Now the based structures of one length that do not conflict are one template that holds the union of their proved subfields, and each structure is one line: before: dcl-ds STARTTHREAD_00465 qualified based(NEWTASK_00391); G0 char(100); F100 char(1); G101 char(2081); end-ds; after: dcl-ds STARTTHREAD_00465 likeds(DSTMPL2182) based(NEWTASK_00391); (one template of 16 lines, before the globals, for the 13 structures of the program) The rule (`core/rpg_source_shared.zig`, pure): a candidate is a structure with a pointer (`based`), qualified, with no initial value, no array, no decimal subfield, not `static`, 16 bytes or longer, and at least one proved subfield. Candidates of one length and one word 28 are put in groups in order of symbol; a candidate joins the first group whose union it does not conflict with (the same byte has the same type and width; no two subfields overlap) and opens another group otherwise. A group of two or more is kept when (1) its word 28 is `0x80100000` (the object says a pointer subfield), (2) at least one member's proved subfields hold no pointer (its written-out text is another symbol than the object's, so the program cannot match as it is), and (3) the template and one line for each member are fewer lines than the members written out. A group in which every member holds the pointer, or whose symbols say none, stays written out: it may match today, and the template changes its filler widths, which are constants of the object. A member lacks the pointer that the object has, so the template gives it the pointer that another member names; when none names one the template is no more wrong than the text it replaces. The name is `DSTMPL<length>`, then `DSTMPL<length>_<n>`: the parameter template `TMPL<length>` (`paramTemplates`) keeps its name and layout. Everything else is as before: automatic and static structures, parameters, structures with an initial value, the fixed and the mixed forms. The statements are unchanged: `NAME.F<offset>` is a subfield of the template by construction. The plan is made at the first call after `failUndeclared` (`fitGlobals`), when the declarations are final. ### What the object shows (2026-11-13, v0.1.513, the six Async captures) - The creation data of the stripped and the observable object have the same symbols: the dumps (kind, class, length, owner, flags and words) are equal in all six programs (asyncage 1898 symbols and 54 procedures; asyncdemo 1998; asyncbg 1993; asynccncl 1972; asyncprom 1972; asynctime 2030). A template has no symbol: asyncage has 32 symbols of 2182 bytes, one is a constant, and the 31 data symbols are the 21 based structures (23 class 0 symbols with the 2 parameters) and the 8 automatic structures of the source, so none is left for `task_t`. - The name is in the debug data of the observable image only: the 8 template names of the source (`TASK_T`, `PTHREAD_T`, ...) are found as cp037 strings in the image of the observable object (11 of 11 for asyncprom), none in the stripped one. They are in the string pool, followed by their subfield names (`HANDLE`, `KIND`, ... `ERRTEXT`), and a `likeds` structure is a bare name there. No reader of that data exists in `src/core` and the emitter reads the stripped object, so no emit can name `task_t`; the synthetic name `DSTMPL2182` is the answer where the object has no name. - Layout facts of the stripped object: structures of one template have one length and one word 28. Word 28 of a data structure symbol is `0x80100000` when the structure has a pointer subfield and `0x80010000` when it has none (a based structure of 20 bytes with `buf pointer`, lext-based-ptr-c, against the structures of 8, 15 and 23 bytes with char, int(10) and packed of lv-based-read-int, lpar-lk-set-local and lv-sf-packed50). Host-measured on our own emit: the rebuilt object of the v0.1.512 emit of asyncage (`runs/pub-l10-async-asyncage-173618/cases/1/capture`, 13 based structures written out, 12 of them without a pointer subfield) has 14 symbols of 2182 bytes at `0x80010000` and 1 at `0x80100000`, where the object of the source has all 31 at `0x80100000` (checked in the six Async programs). So the written-out text of a structure that names no pointer cannot give the symbol of the object, in a program that cannot match for other reasons too, and the shared template, which holds the `pointer(*proc)` that one structure names, gives the word to every member (battery b2, a2, s2, b2t, twolen: the structure written out without the pointer has `0x80010000` and flags `0x60000000`, `0x70008000` or `0x7000c000`; the `likeds` structure and the one written with the pointer have `0x80100000` and `0xe0000000`, `0xf0008000`, `0xf000c000`). Only structures of one word 28 share a template. No object fact gives the subfields that no statement names. - Every number of a declaration is a constant of the object (battery: b2-l has the decimal constants 0 1 10 2 20 2081 2182 3 44 8, b2-w has 0 1 10 12 2 20 2081 2126 2182 3 4 92, fill-typed 0 1 10 1024 2 20 2182 3 4 7 8), and the symbols are numbered behind them. The pool of asyncage holds 1024, 7, 20 and 2182 among 35 decimal constants and none of the filler widths of the v0.1.513 emit (2178, 2170, 2080, ...): each is a constant that the object lacks, and the field widths of `task_t` (1024, 7, 20) are in the pool and could be recovered from it, a next change. ### Measure (2026-11-14, emits of the stripped twins with v0.1.513 and with this branch) | program | structures (based + automatic) | structure lines before | structure lines after (+ template) | distinct bodies of the based ones | first line that moved | lines missing | |---|---|---|---|---|---|---| | asyncage | 18 (13 + 5) | 100 | 19 + 16 | 13 -> 1 template | 568 -> 870 | 50 -> 5 | | asyncdemo | 18 (13 + 5) | 100 | 19 + 16 | 13 -> 1 | 641 -> 943 | 50 -> 5 | | asyncbg | 18 (13 + 5) | 100 | 19 + 16 | 13 -> 1 | 645 -> 947 | 50 -> 5 | | asynccncl | 18 (13 + 5) | 100 | 19 + 16 | 13 -> 1 | 631 -> 933 | 50 -> 5 | | asyncprom | 20 (13 + 7) | 116 | 35 + 16 | 13 -> 1 | 523 -> 523 | 56 -> 11 | | asynctime | 19 (13 + 6) | 104 | 23 + 16 | 13 -> 1 | 655 -> 957 | 50 -> 5 | (The four lengths of the 18 structures of asyncage: 2182 for the 13 based ones, and 272, 8, 8, 4, 4 bytes for the 5 automatic ones, which are alone or shorter than 16 bytes and stay written out. The 13 bodies are 13 partial views of one 2182-byte layout, 12 of them without the pointer. "Lines missing" is the count of the lane ldfit (`Layout.missing`, 83a64769, not in the base of this branch), computed here from the receipt rows with the same rule: the count of the six programs before, 50, 50, 50, 50, 56, 50, is the one of the lane's table, so the same script gives the "after" column. The six Async programs are one library: one sample, not six.) The statements, the emitted statements and the failure lines of every program are equal (asyncage 584 / 309 / 278). The 5 or 11 lines that remain are the automatic structures and the interfaces of procedures whose source has no structure there (`NEWTASK_00388 qualified; F0 int(10)`), the next change; the battery pairs `lkds-a2` and `lkds-s2` read like the based ones, so an automatic or a static structure with a pointer in its symbol can take the same rule. The distinct `char(n)` widths of the emit that no integer constant of the original object has (each is a constant that the object lacks, see above): asyncage 16 -> 7, asyncdemo 15 -> 7, asyncbg 15 -> 6, asynccncl 16 -> 7, asyncprom 17 -> 10, asynctime 15 -> 7. The template has fewer distinct filler widths than the 13 structures written out had. The coordinator's fact of 2026-11-13 (ldfit/place, `ldfit-m-s-mid`): the compiler refuses a declaration after a statement of the cycle main (RNF0724), so for the main procedure a short emit is the only route; this change is that route for the structures of a procedure. Whether a local procedure takes a declaration between statements is still being measured there. ### Proof - `src/rpg_shared_template_test.zig` (registered in `src/root.zig`): the planner (union with fillers, a conflict of type or of bytes keeps the structures written out, another word 28, a group is shared only where a member lacks the pointer of its symbol (the object says none, or every member holds it: written out), a length under 16, a lone structure, a second layout of one length is `DSTMPL<n>_2`); `ldsv-asyncprom` (committed twin of the Async program asyncprom): exactly one `dcl-ds DSTMPL2182 qualified template;`, at least 13 lines `likeds(DSTMPL2182) based(`, the template text, and every `NAME.F<n>` of a shared structure is a subfield of the template. It is red on the base (`expected 1, found 0`, run against the unchanged core files) and green on the branch. `lv-qpair-int3` (matches on the host): a lone based structure is written as before. The counts of statements, emitted statements and failures are not asserted: the `emit-all` rows below prove them and other lanes move them. - `emit-all.sh` with v0.1.513 and with this branch, 854 programs: one emit differs (`ldsv-asyncprom`, `different` in the matrix); no matching twin changes; the summary line is equal (`failures` 928, `emitted` 8422, `clean` 593) and so are `statements`, `emitted` and `failures` of every row. `capture-emit-diff.sh` over the six Async captures and the 19 scout2 captures: 6 changed (the Async programs), the 19 others `same`, statements, emitted and failures equal in all 25, and no changed head emit without a failure line. The five public development captures `captures/dev5/p1` to `p5`: 0 changed (the emits are byte-identical with both binaries; `dev-hash.sh` itself was not run, and the sealed ids and L10-test were not read, so the L10-test direction is unknown here). `agree.sh` on the 25 (base and head): `suspect` 82 and 82, `same` 1463 and 1463, `equivalent` 23 and 23; the declaration counters move as read: `ds_emit` 122 -> 128, `ds_sub_extra` 300 -> 76 (fewer fillers than the source has subfields), `ds_sub_missing` 220 -> 242 (the multiset of emitted subfield types is smaller where 13 structures became one template). WATCH, read: a count of subfield types, not a statement. - Not run by the lane: `gate.sh` and `pub-roundtrip.sh` (no host; the coordinator runs them). The change adds no reader of an operation number (`docs/OPERATIONS.md` is not touched) and `rpg_statements.zig` is not touched. ## Gate ``` > F52 int(10); > G56 char(44); > F100 char(1); > F101 char(1); > G102 char(1); > F103 char(7); > G110 char(2072); > end-ds; 500,515d515 < forms projection differs: 311c311 < {"twin":"savf/SC-ILE/EXPERIMENTS/ldsv-asyncprom/stripped","object":"P389F4503S","status":"done","statements":619,"emitted":316,"failures":305,"lines":1612,"form_counts":{"array_element_v1":16,"compiler_policy_marks_v1":43,"context_character_literal_v1":44,"context_pointer_store_v1":44,"context_procedure_pointer_store_v1":44,"context_zero_fill_v1":44,"direct_branch_v1":39,"emit_assign_based_v1":7,"emit_assign_field_v1":34,"emit_assign_part_v1":11,"emit_callp_v1":51,"emit_ctl_opt_v1":1,"emit_dcl_ds_v1":21,"emit_dcl_pi_v1":45,"emit_dcl_proc_v1":37,"emit_dcl_s_based_v1":1,"emit_dcl_s_v1":48,"emit_dow_v1":2,"emit_ds_filler_v1":42,"emit_ds_subfield_v1":37,"emit_else_v1":7,"emit_elseif_v1":2,"emit_end_ds_v1":21,"emit_end_pi_v1":45,"emit_end_proc_v1":29,"emit_enddo_v1":2,"emit_endfor_v1":2,"emit_endif_v1":56,"emit_for_v1":2,"emit_free_v1":1,"emit_if_v1":56,"emit_leave_v1":2,"emit_pi_parameter_v1":73,"emit_return_value_v1":20,"emit_summary_v1":2,"fail_declaration_v1":2,"fail_procedure_boundary_v1":34,"fail_statement_v1":265,"fail_trailer_v1":4,"initialization_entry_v1":43,"initialization_resume_v1":43,"integer_store_v1":44,"layout_blank_v1":650,"local_pointer_store_v1":38,"null_pointer_literal_v1":58,"placeholder_block_condition_v1":4,"placeholder_parameter_type_v1":11,"placeholder_return_value_v1":6,"procedure_blank_fill_v1":14,"procedure_character_literal_v1":26,"procedure_end_guard_v1":32,"procedure_exit_transfer_v1":50,"procedure_null_pointer_v1":3,"procedure_return_v1":43},"text_sha256":"5901c79e096e9ec83261d29512257017eda7693d0ade11da31a9e3a733b15c89"} --- == d. captures (capture-emit-diff) l10-async-asyncage base=[584,309,278] head=[584,309,278] CHANGED fail-lines=278 l10-async-asyncdemo base=[621,333,291] head=[621,333,291] CHANGED fail-lines=291 l10-async-asyncbg base=[597,314,285] head=[597,314,285] CHANGED fail-lines=285 l10-async-asynccncl base=[608,324,287] head=[608,324,287] CHANGED fail-lines=287 l10-async-asyncprom base=[619,316,305] head=[619,316,305] CHANGED fail-lines=305 l10-async-asynctime base=[630,340,294] head=[630,340,294] CHANGED fail-lines=294 capture-emit-diff: 34 cases, 6 changed, 2 with no failure line in the head emit == e. source agreement (agree) suspect base=80 head=80 conflict base=0 head=0 params_wrong base=17 head=17 decl_missing base=81 head=81 decl_extra base=25 head=25 type_unmarked base=47 head=47 gate: PASS ```
Write the based structures of one length as one template and one likeds line each
Some checks reported errors
binjovi/ci A newer source or plan superseded this Build
9b9523979e
The Async programs declare dcl-ds t likeds(task_t) based(p) in every procedure and the
emitter wrote each structure out in full, so the declarations did not fit before the first
statement. Based structures of one length and one word 28 whose proved subfields do not
conflict are now the union in one qualified template DSTMPL<length>, and each structure is
one dcl-ds NAME likeds(DSTMPL<length>) based(P) line. Asyncage: 100 structure lines become
19 and one template of 16 lines, and the lines that the declarations lack fall from 50 to 5.

The battery requests/lkds/tmpl (captures/lkds-tmpl) shows that likeds of a template is the
structure written out, that the symbol of a structure has the pointer word only when the
structure holds a pointer, and that every number of a declaration is a constant of the
object. So a group is shared only where the object proves a member's written-out text wrong:
the symbols say a pointer subfield and a member's proved subfields hold none.
sean force-pushed lkds from 9b9523979e
Some checks reported errors
binjovi/ci A newer source or plan superseded this Build
to 43ab0ba17e
All checks were successful
binjovi/ci Binjovi completed the frozen plan
2026-11-14 09:18:28 +00:00
Compare
binjovi-bot manually merged commit 43ab0ba17e into trunk 2026-11-14 09:34:58 +00:00
Sign in to join this conversation.
No reviewers
No labels
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
sean/sourcerer!799
No description provided.