v3 step 3.7 — hardening: BoundPair END fix, 4 edge tests (68/68 tests green)

compiler/run_tests.sh

@@ -61,6 +61,7 @@ expect_run t_case.mod 103
 expect_run t_bool.mod 42
 expect_run t_real.mod 31
 expect_run t_array.mod 108
+expect_run t_charbounds.mod 3
 expect_run t_record.mod 160
 expect_run t_with.mod 114
 expect_run t_set.mod 131
@@ -102,6 +103,8 @@ expect_fail t_bad_setbase.mod "not supported yet"
 expect_fail t_bad_in.mod "set operand mismatch"
 expect_fail t_bad_index.mod "array index must be integer"
 expect_fail t_bad_bounds.mod "not supported yet"
+expect_fail t_bad_varbound.mod "not supported yet"
+expect_fail t_bad_manydims.mod "not supported yet"
 expect_fail t_openformal.mod "not supported yet"
 expect_fail t_bad_open.mod "not supported yet"
 
@@ -129,6 +132,7 @@ expect_trap() {
 expect_trap t_trap_index.mod
 expect_trap t_trap_count.mod
 expect_trap t_trap_setspan.mod
+expect_trap t_trap_emptystr.mod
 expect_fail t_defunit.mod "not supported yet"
 expect_fail t_implunit.mod "not supported yet"
 expect_fail t_nested.mod "not supported yet"

compiler/src/M2.atg

@@ -251,9 +251,10 @@ PRODUCTIONS
                                               OR ~SymTab.ConstInt(qhi, hi)
                                               OR (lo > hi) THEN
                                              SemError(230); ok := FALSE
-                                           ELSIF ~SymTab.BoundAdd(lo, hi) THEN
-                                             SemError(230); ok := FALSE
-                                           END; .) .
+                                            ELSIF ~SymTab.BoundAdd(lo, hi) THEN
+                                              SemError(230); ok := FALSE
+                                            END;
+                                          END; .) .
   (* Sets: multi-word masks over bases ≤ 256 values (bool, char,
      bounded subranges; enums wait for ordinals, INTEGER is
      unbounded). Literals are SET OF [0..255]; assignment and

compiler/src/M2.lst

@@ -268,1244 +268,1245 @@ Listing:
   251                                                OR ~SymTab.ConstInt(qhi, hi)
   252                                                OR (lo > hi) THEN
   253                                               SemError(230); ok := FALSE
-  254                                             ELSIF ~SymTab.BoundAdd(lo, hi) THEN
-  255                                               SemError(230); ok := FALSE
-  256                                             END; .) .
-  257    (* Sets: multi-word masks over bases ≤ 256 values (bool, char,
-  258       bounded subranges; enums wait for ordinals, INTEGER is
-  259       unbounded). Literals are SET OF [0..255]; assignment and
-  260       comparison across suitable bases are lenient (masks over min
-  261       words + zero-check extras), out-of-span literals are 222. *)
-  262    SetType<VAR t: SymTab.TypeIndex>      (. VAR base: SymTab.TypeIndex;
-  263                                               blo, bhi, bspan: INTEGER;
-  264                                               bcls: INTEGER; .)
-  265      = "SET" "OF" Type<base, FALSE>
-  266                                          (. IF base = SymTab.InvalidType THEN
-  267                                               t := SymTab.InvalidType
-  268                                             ELSE bcls :=
-  269                                                    SymTab.ClassOf(base);
-  270                                               IF bcls = SymTab.ClBool THEN
-  271                                                 blo := 0; bspan := 2
-  272                                               ELSIF bcls = SymTab.ClChar THEN
-  273                                                 blo := 0; bspan := 256
-  274                                               ELSIF SymTab.SubBounds(base,
-  275                                                       blo, bhi) THEN
-  276                                                 bspan := bhi - blo + 1
-  277                                               ELSE bspan := 0 END;
-  278                                               IF (bspan <= 0)
-  279                                                  OR (bspan > 256) THEN
-  280                                                 SemError(230);
-  281                                                 t := SymTab.InvalidType
-  282                                               ELSE t := SymTab.NewSet(base)
-  283                                               END
-  284                                             END; .) .
-  285    (* Records: flat blobs; array fields are pointers to static
-  286       descriptors (locked amendment), nested records inline. Field
-  287       offsets static and declaration-ordered. *)
-  288    RecordType<VAR t: SymTab.TypeIndex>   (. VAR t2: SymTab.TypeIndex; .)
-  289      = "RECORD"                          (. t := SymTab.NewRecord(); .)
-  290        [ RecField<t> { ";" RecField<t> } ]
-  291        "END" .
-  292    RecField<rec: SymTab.TypeIndex>       (. VAR n: SymTab.Name;
-  293                                               t2: SymTab.TypeIndex; .)
-  294      = RecIdents<rec> ":" Type<t2, FALSE>(. SymTab.FixPendingF(rec, t2); .) .
-  295    RecIdents<rec: SymTab.TypeIndex>      (. VAR n: SymTab.Name; .)
-  296      = GetIdent<n>                       (. IF ~SymTab.FieldPending(rec,
-  297                                               n) THEN
-  298                                               SemError(200) END; .)
-  299        { "," GetIdent<n>                 (. IF ~SymTab.FieldPending(rec,
-  300                                               n) THEN
-  301                                               SemError(200) END; .) } .
-  302    TypeIdent<VAR t: SymTab.TypeIndex>    (. VAR n: SymTab.Name;
-  303                                               k: INTEGER; .)
-  304      = GetIdent<n>                       (. IF ~SymTab.Lookup(n) THEN
-  305                                               SemError(201);
-  306                                               t := SymTab.InvalidType
-  307                                             ELSE k := SymTab.SymKind(n);
-  308                                               IF (k = SymTab.KindType)
-  309                                                  OR (k = SymTab.KindPredef) THEN
-  310                                                 t := SymTab.SymType(n)
-  311                                               ELSIF k = SymTab.KindImport THEN
-  312                                                 t := SymTab.InvalidType
-  313                                               ELSE SemError(221);
-  314                                                 t := SymTab.InvalidType
-  315                                               END
-  316                                             END; .) .
-  317    Subrange<VAR t: SymTab.TypeIndex>     (. VAR tlo, thi: SymTab.TypeIndex;
-  318                                               qlo, qhi: QbeGen.QVal;
-  319                                               lo, hi: INTEGER; .)
-  320      = "[" Expr<tlo, qlo> ".." Expr<thi, qhi>
-  321                                          (. IF (tlo = SymTab.InvalidType)
-  322                                              OR (thi = SymTab.InvalidType) THEN
-  323                                             t := SymTab.InvalidType
-  324                                           ELSIF (SymTab.ClassOf(tlo) #
-  325                                                  SymTab.ClInt)
-  326                                              OR (SymTab.ClassOf(thi) #
-  327                                                  SymTab.ClInt) THEN
-  328                                             SemError(230);
-  329                                             t := SymTab.InvalidType
-  330                                           ELSIF ~SymTab.ConstInt(qlo, lo)
-  331                                              OR ~SymTab.ConstInt(qhi, hi)
-  332                                              OR (lo > hi) THEN
-  333                                             SemError(230);
-  334                                             t := SymTab.InvalidType
-  335                                           ELSE t := SymTab.NewSubR(lo, hi)
-  336                                           END; .)
-  337        "]" .
-  338    Enum<VAR t: SymTab.TypeIndex>         (. VAR n: SymTab.Name; .)
-  339      = "("                               (. t := SymTab.NewEnum(); .)
-  340        GetIdent<n>                       (. IF ~SymTab.Enter(n,
-  341                                               SymTab.KindConst) THEN
-  342                                               SemError(200) END;
-  343                                             SymTab.SetSymType(n, t); .)
-  344        { "," GetIdent<n>                 (. IF ~SymTab.Enter(n,
-  345                                               SymTab.KindConst) THEN
-  346                                               SemError(200) END;
-  347                                             SymTab.SetSymType(n, t); .) }
-  348        ")" .
-  349    (* Clarion-form classes (docs/OOP.txt): declaration + single
-  350       inheritance + IMPLEMENTATION blocks. Scopes and member checks
-  351       now; lowering (vtable, dispatch, THIS) later — one 230 per
-  352       class/impl block. Methods end with ";" per the Table example
-  353       (not "," as in the sketch). No underscores in identifiers. *)
-  354    (* Single CLASS item in both loops: separating declaration from
-  355       IMPLEMENTATION at the loop level needs 2-token lookahead
-  356       (CLASS ident vs CLASS IMPLEMENTATION), which LL(1) cannot do.
-  357       The second token decides after CLASS is consumed. A misplaced
-  358       CLASS IMPLEMENTATION inside TYPE still parses (harmless: the
-  359       whole unit ends 230 until lowering). *)
-  360    ClassItem
-  361      = "CLASS" ( "IMPLEMENTATION" ClassImplRest | ClassRest ) .
-  362    ClassRest                             (. VAR cn, m2, pn: SymTab.Name;
-  363                                               ct: SymTab.TypeIndex; .)
-  364      = GetIdent<cn>                      (. IF ~SymTab.Enter(cn,
-  365                                               SymTab.KindType) THEN
-  366                                               SemError(200) END;
-  367                                             ct := SymTab.NewClass();
-  368                                             SymTab.SetSymType(cn, ct);
-  369                                             SymTab.PushClassScope(ct); .)
-  370        [ Parents<ct> ]
-  371        ";"
-  372        { ClassField<ct> ";" }
-  373        { MethodHeading<pn> ";"           (. SymTab.CloseProc; .) }
-  374        "END"
-  375        GetIdent<m2>                      (. IF ~SymTab.Equal(cn, m2) THEN
-  376                                               SemError(202) END;
-  377                                             SymTab.PopScope;
-  378                                             SemError(230); .) .
-  379    Parents<ct: SymTab.TypeIndex>         (. VAR p: SymTab.Name; .)
-  380      = "(" Parent1<ct>
-  381        { "," GetIdent<p>                 (. SemError(230); .) }
-  382        ")" .
-  383    Parent1<ct: SymTab.TypeIndex>         (. VAR p: SymTab.Name;
-  384                                               pt: SymTab.TypeIndex; .)
-  385      = GetIdent<p>                       (. IF ~SymTab.Lookup(p) THEN
-  386                                               SemError(201)
-  387                                             ELSE pt := SymTab.SymType(p);
-  388                                               IF SymTab.ClassOf(pt) #
-  389                                                  SymTab.ClClass THEN
-  390                                                 SemError(230)
-  391                                               ELSE SymTab.SetParent(ct, pt)
-  392                                               END
-  393                                             END; .) .
-  394    ClassField<ct: SymTab.TypeIndex>      (. VAR n, rhs: SymTab.Name;
-  395                                               t: SymTab.TypeIndex; .)
-  396      = GetIdent<n>
-  397        ( "=" GetIdent<rhs>               (. IF ~SymTab.Enter(n,
-  398                                               SymTab.KindConst) THEN
-  399                                               SemError(200) END;
-  400                                             IF SymTab.Lookup(rhs) THEN
-  401                                               SymTab.SetSymType(n,
-  402                                                 SymTab.SymType(rhs))
-  403                                             END; .)
-  404        |                                 (. IF ~SymTab.FieldPending(ct,
-  405                                               n) THEN
-  406                                               SemError(200) END; .)
-  407          { "," GetIdent<n>               (. IF ~SymTab.FieldPending(ct,
-  408                                               n) THEN
-  409                                               SemError(200) END; .) }
-  410          ":" Type<t, FALSE>              (. SymTab.FixPendingF(ct, t); .) ) .
-  411    MethodHeading<VAR pn: SymTab.Name>    (. VAR wantVirt: BOOLEAN; .)
-  412      =                                   (. wantVirt := FALSE; .)
-  413        [ "VIRTUAL"                       (. wantVirt := TRUE; .) ]
-  414        ProcHeading<pn>                   (. IF wantVirt THEN
-  415                                               SymTab.MarkVirtual END; .) .
-  416    ClassImplRest                         (. VAR cn, m2: SymTab.Name;
-  417                                               ct: SymTab.TypeIndex; .)
-  418      = GetIdent<cn>                      (. IF ~SymTab.Lookup(cn) THEN
-  419                                               SemError(201);
-  420                                               ct := SymTab.InvalidType
-  421                                             ELSE ct := SymTab.SymType(cn);
-  422                                               IF SymTab.ClassOf(ct) #
-  423                                                  SymTab.ClClass THEN
-  424                                                 SemError(230);
-  425                                                 ct := SymTab.InvalidType
-  426                                               END
-  427                                             END;
-  428                                             IF ct #
-  429                                                SymTab.InvalidType THEN
-  430                                               IF ~SymTab.PushClassMembers(
-  431                                                      ct) THEN
-  432                                                 SemError(230) END
-  433                                             END; .)
-  434        ";" { MethodImpl<ct> ";" }
-  435        [ "BEGIN"
-  436          [ StatSeq ] ]
-  437        "END"
-  438        GetIdent<m2>                      (. IF ~SymTab.Equal(cn, m2) THEN
-  439                                               SemError(202) END;
-  440                                             SymTab.PopScope;
-  441                                             SemError(230); .) .
-  442    MethodImpl<ct: SymTab.TypeIndex>      (. VAR pn: SymTab.Name; .)
-  443      = MethodHeading<pn> ";"
-  444                                          (. IF (ct #
-  445                                                SymTab.InvalidType)
-  446                                               & ~SymTab.MethodExists(ct,
-  447                                                    pn) THEN
-  448                                               SemError(201) END; .)
-  449        ( "FORWARD"                       (. SymTab.MarkFwd;
-  450                                             SymTab.CloseProc; .)
-  451        | Block<pn>                       (. SymTab.CloseProc;
-  452                                             SemError(230); .) ) .
-  453    ConstBlock
-  454      = "CONST" { ConstDecl ";" } .
-  455    ConstDecl                             (. VAR n: SymTab.Name;
-  456                                               t: SymTab.TypeIndex;
-  457                                               qv: QbeGen.QVal;
-  458                                               cls: INTEGER; .)
-  459      = GetIdent<n>                       (. IF ~SymTab.Enter(n,
-  460                                               SymTab.KindConst) THEN
-  461                                               SemError(200) END; .)
-  462        "="
-  463        Expr<t, qv>                       (. SymTab.SetSymType(n, t);
-  464                                             cls := SymTab.ClassOf(t);
-  465                                             IF cls = SymTab.ClStr THEN
-  466                                               SemError(230)
-  467                                             ELSIF ~QbeGen.IsImm(qv) THEN
-  468                                               SemError(230) END;
-  469                                             QbeGen.DeclConst(n, qv, t); .) .
-  470    VarBlock
-  471      = "VAR" { VarDecl ";" } .
-  472    VarDecl                               (. VAR nm: SymTab.Name;
-  473                                               t: SymTab.TypeIndex;
-  474                                               i: CARDINAL;
-  475                                               cls: INTEGER; .)
-  476      = VarIdents ":"
-  477        Type<t, FALSE>                    (. cls := SymTab.ClassOf(t);
-  478                                             IF (t # SymTab.InvalidType)
-  479                                                & (cls # SymTab.ClInt)
-  480                                                & (cls # SymTab.ClBool)
-  481                                                & (cls # SymTab.ClChar)
-  482                                                & (cls # SymTab.ClReal)
-  483                                                & (cls # SymTab.ClArray)
-  484                                                & (cls # SymTab.ClSet)
-  485                                                & (cls # SymTab.ClRecord)
-  486                                                & (cls # SymTab.ClPtr) THEN
-  487                                               SemError(230) END;
-  488                                             i := 0;
-  489                                             WHILE i < SymTab.PendCount() DO
-  490                                               SymTab.PendName(i, nm);
-  491                                               QbeGen.DeclVar(nm, t);
-  492                                               INC(i)
-  493                                             END;
-  494                                             SymTab.FixPending(t); .) .
-  495    VarIdents                             (. VAR n: SymTab.Name; .)
-  496      = GetIdent<n>                       (. IF ~SymTab.EnterPending(n,
-  497                                               SymTab.KindVar) THEN
-  498                                               SemError(200) END; .)
-  499        { ","
-  500          GetIdent<n>                     (. IF ~SymTab.EnterPending(n,
-  501                                               SymTab.KindVar) THEN
-  502                                               SemError(200) END; .) } .
-  503    ParIdents<isV: BOOLEAN>               (. VAR n: SymTab.Name; .)
-  504      = GetIdent<n>                       (. IF ~SymTab.EnterParam(n, isV) THEN
-  505                                               SemError(200) END; .)
-  506        { "," GetIdent<n>                 (. IF ~SymTab.EnterParam(n, isV) THEN
-  507                                               SemError(200) END; .) } .
-  508    (* Procedure headings enter now (scopes, params, result); bodies
-  509       parse + check with one 230 at END (lowering = step 4).
-  510       FORWARD marks; the body heading re-enters (signature compare
-  511       tightens in step 4). *)
-  512    ProcHeading<VAR pn: SymTab.Name>      (. VAR t: SymTab.TypeIndex; .)
-  513      = "PROCEDURE"
-  514        GetIdent<pn>                      (. IF ~SymTab.EnterProc(pn) THEN
-  515                                             IF ~SymTab.ReenterProc(pn) THEN
-  516                                               SemError(200) END
-  517                                             END; .)
-  518        [ FormalParams ]
-  519        [ ":" TypeIdent<t>                (. SymTab.SetProcRes(t);
-  520                                             IF (t #
-  521                                                SymTab.InvalidType)
-  522                                                & (SymTab.ClassOf(t)
-  523                                                   = SymTab.ClArray) THEN
-  524                                               SemError(230) END; .) ] .
-  525    FormalParams
-  526      = "(" [ ParamSection { ";" ParamSection } ] ")" .
-  527    ParamSection                          (. VAR t: SymTab.TypeIndex;
-  528                                               isV: BOOLEAN; .)
-  529      =                                   (. isV := FALSE; .)
-  530        [ "VAR"                           (. isV := TRUE; .) ]
-  531        ParIdents<isV> ":" Type<t, TRUE>  (. SymTab.FixPending(t); .) .
-  532    ProcDecl                              (. VAR pn, m2: SymTab.Name; .)
-  533      = ProcHeading<pn> ";"
-  534        ( "FORWARD"                       (. SymTab.MarkFwd;
-  535                                             SymTab.CloseProc; .)
-  536        | Block<pn>                       (. SymTab.CloseProc;
-  537                                             SemError(230); .) ) .
-  538    Block<pn: SymTab.Name>                (. VAR m2: SymTab.Name; .)
-  539      = DeclSeq
-  540        [ "BEGIN"
-  541          [ StatSeq ] ]
-  542        "END"
-  543        GetIdent<m2>                      (. IF ~SymTab.Equal(pn, m2) THEN
-  544                                               SemError(202) END; .) .
-  545    StatSeq
-  546      = Statement { ";" Statement } .
-  547    Statement                             (. VAR lx: QbeGen.QVal; .)
-  548      = Assign
-  549      | IfStat
-  550      | WhileStat
-  551      | RepeatStat
-  552      | LoopStat
-  553      | ForStat
-  554      | CaseStat
-  555      | WithStat
-  556      | ReturnStat
-  557      | NewStat
-  558      | DisposeStat
-  559      | "EXIT"                            (. IF QbeGen.TopLoop(lx) THEN
-  560                                               QbeGen.Jmp(lx)
-  561                                             ELSE SemError(230) END; .) .
-  562    (* NEW/DISPOSE as builtin statements (no call syntax until step 4).
-  563       Targets are pointer designators; DISPOSE nils afterwards (safer
-  564       than Wirth-undefined; documented). DISPOSE is shallow. *)
-  565    NewStat                               (. VAR dt: SymTab.TypeIndex;
-  566                                               dk: INTEGER;
-  567                                               qd, qm: QbeGen.QVal;
-  568                                               qn: SymTab.Name;
-  569                                               sfx: BOOLEAN;
-  570                                               bt: SymTab.TypeIndex; .)
-  571      = "NEW" "(" Design<dt, dk, qd, qn, sfx> ")"
-  572                                          (. IF dt = SymTab.InvalidType THEN
-  573                                             ELSIF (dk # SymTab.KindVar)
-  574                                                & (dk # SymTab.KindParam)
-  575                                                & (dk # SymTab.KindField) THEN
-  576                                               SemError(210)
-  577                                             ELSIF SymTab.ClassOf(dt) #
-  578                                                   SymTab.ClPtr THEN
-  579                                               SemError(219)
-  580                                             ELSE bt := SymTab.PtrBase(dt);
-  581                                               IF bt #
-  582                                                  SymTab.InvalidType THEN
-  583                                                 QbeGen.NewHeap(bt, qm);
-  584                                                 QbeGen.InitHeap(qm, bt);
-  585                                                 IF sfx
-  586                                                    OR (dk =
-  587                                                       SymTab.KindField) THEN
-  588                                                   QbeGen.ElemStore(qd, qm,
-  589                                                     dt)
-  590                                                 ELSE QbeGen.StorePtr(qn,
-  591                                                   qm)
-  592                                                 END
-  593                                               END
-  594                                             END; .) .
-  595    DisposeStat                           (. VAR dt: SymTab.TypeIndex;
-  596                                               dk: INTEGER;
-  597                                               qd, qv: QbeGen.QVal;
-  598                                               qn: SymTab.Name;
-  599                                               sfx: BOOLEAN; .)
-  600      = "DISPOSE" "(" Design<dt, dk, qd, qn, sfx> ")"
-  601                                          (. IF dt = SymTab.InvalidType THEN
-  602                                             ELSIF (dk # SymTab.KindVar)
-  603                                                & (dk # SymTab.KindParam)
-  604                                                & (dk # SymTab.KindField) THEN
-  605                                               SemError(210)
-  606                                             ELSIF SymTab.ClassOf(dt) #
-  607                                                   SymTab.ClPtr THEN
-  608                                               SemError(219)
-  609                                             ELSE
-  610                                               IF sfx
-  611                                                  OR (dk =
-  612                                                     SymTab.KindField) THEN
-  613                                                 QbeGen.ElemLoad(qd, dt,
-  614                                                   qv)
-  615                                               ELSE QbeGen.LoadPtr(qn, qv)
-  616                                               END;
-  617                                               QbeGen.FreeHeap(qv);
-  618                                               IF sfx
-  619                                                  OR (dk =
-  620                                                     SymTab.KindField) THEN
-  621                                                 QbeGen.ElemStore(qd, "0",
-  622                                                   dt)
-  623                                               ELSE QbeGen.StorePtr(qn,
-  624                                                 "0")
-  625                                               END
-  626                                             END; .) .
-  627    (* WITH pushes each record's fields (inner wins) plus its base
-  628       address; field designators resolve through both stacks. *)
-  629    WithStat                              (. VAR nW: CARDINAL; .)
-  630      = "WITH"                            (. nW := 0; .)
-  631        WithItem<nW> { "," WithItem<nW> }
-  632        "DO" StatSeq "END"
-  633                                          (. WHILE nW > 0 DO
-  634                                               SymTab.PopScope;
-  635                                               QbeGen.PopWith;
-  636                                               DEC(nW)
-  637                                             END; .) .
-  638    WithItem<VAR nW: CARDINAL>            (. VAR dt: SymTab.TypeIndex;
-  639                                               dk: INTEGER;
-  640                                               qd, qe: QbeGen.QVal;
-  641                                               qn: SymTab.Name;
-  642                                               sfx: BOOLEAN; .)
-  643      = Design<dt, dk, qd, qn, sfx>
-  644                                          (. IF dt = SymTab.InvalidType THEN
-  645                                             ELSIF (SymTab.ClassOf(dt) #
-  646                                                    SymTab.ClRecord)
-  647                                                & (SymTab.ClassOf(dt) #
-  648                                                   SymTab.ClClass) THEN
-  649                                               SemError(215)
-  650                                             ELSIF SymTab.PushRecord(dt) THEN
-  651                                               QbeGen.PushWith(qd);
-  652                                               INC(nW)
-  653                                             END; .) .
-  654    Assign                                (. VAR dt, et: SymTab.TypeIndex;
-  655                                               dk: INTEGER;
-  656                                               qd, qe, qt: QbeGen.QVal;
-  657                                               qn: SymTab.Name;
-  658                                               isR, conv: BOOLEAN;
-  659                                               sfx: BOOLEAN; .)
-  660      = Design<dt, dk, qd, qn, sfx> ":="
-  661        Expr<et, qe>                      (. IF (dt # SymTab.InvalidType)
-  662                                             & (dk # SymTab.KindVar)
-  663                                             & (dk # SymTab.KindParam)
-  664                                             & (dk # SymTab.KindField) THEN
-  665                                             SemError(210)
-  666                                           ELSIF ~SymTab.Assignable(et,
-  667                                                    dt) THEN
-  668                                             SemError(210)
-  669                                           ELSIF (dt # SymTab.InvalidType)
-  670                                              & (SymTab.ClassOf(dt) =
-  671                                                 SymTab.ClClass) THEN
-  672                                             SemError(230) END;
-  673                                           isR := (dt #
-  674                                                   SymTab.InvalidType)
-  675                                                  & (SymTab.ClassOf(dt)
-  676                                                     = SymTab.ClReal);
-  677                                           conv := isR
-  678                                                   & SymTab.IsIntFamily(et);
-  679                                           IF ((dk = SymTab.KindVar)
-  680                                               OR (dk = SymTab.KindParam)
-  681                                               OR (dk = SymTab.KindField))
-  682                                              & (dt # SymTab.InvalidType)
-  683                                              & (et # SymTab.InvalidType)
-  684                                              & (SymTab.ClassOf(dt) #
-  685                                                 SymTab.ClClass) THEN
-  686                                             IF sfx
-  687                                                OR (dk = SymTab.KindField) THEN
-  688                                               IF SymTab.ClassOf(dt) =
-  689                                                  SymTab.ClArray THEN
-  690                                                 QbeGen.CopyArray(qd, qe,
-  691                                                   dt)
-  692                                               ELSIF SymTab.ClassOf(dt) =
-  693                                                   SymTab.ClSet THEN
-  694                                                 QbeGen.CopySet(qd, qe,
-  695                                                   SymTab.SetWords(dt),
-  696                                                   SymTab.SetWords(et))
-  697                                               ELSIF SymTab.ClassOf(dt) =
-  698                                                   SymTab.ClRecord THEN
-  699                                                 QbeGen.CopyRecord(qd, qe,
-  700                                                   dt)
-  701                                               ELSIF conv THEN
-  702                                                 QbeGen.ConvIR(qe, qt);
-  703                                                 QbeGen.ElemStore(qd, qt,
-  704                                                   dt)
-  705                                               ELSE QbeGen.ElemStore(qd, qe,
-  706                                                 dt)
-  707                                               END
-  708                                             ELSIF SymTab.ClassOf(dt) =
-  709                                                   SymTab.ClArray THEN
-  710                                               QbeGen.CopyArray(qd, qe, dt)
-  711                                             ELSIF SymTab.ClassOf(dt) =
-  712                                                   SymTab.ClSet THEN
-  713                                               QbeGen.CopySet(qd, qe,
-  714                                                 SymTab.SetWords(dt),
-  715                                                 SymTab.SetWords(et))
-  716                                             ELSIF SymTab.ClassOf(dt) =
-  717                                                   SymTab.ClRecord THEN
-  718                                               QbeGen.CopyRecord(qd, qe, dt)
-  719                                             ELSIF SymTab.ClassOf(dt) =
-  720                                                   SymTab.ClPtr THEN
-  721                                               QbeGen.StorePtr(qn, qe)
-  722                                             ELSIF conv THEN
-  723                                               QbeGen.ConvIR(qe, qt);
-  724                                               QbeGen.StoreVar(qn, qt, TRUE)
-  725                                             ELSE
-  726                                               QbeGen.StoreVar(qn, qe, isR)
-  727                                             END
-  728                                           END; .) .
-  729    IfStat                                (. VAR t: SymTab.TypeIndex;
-  730                                               q, lThen, lElse, lEnd:
-  731                                                 QbeGen.QVal;
-  732                                               hasElse: BOOLEAN; .)
-  733      = "IF"                              (. hasElse := FALSE; .)
-  734        Expr<t, q>                        (. IF ~SymTab.BoolCheck(t) THEN
-  735                                               SemError(214) END;
-  736                                             QbeGen.NewLabel(lThen);
-  737                                             QbeGen.NewLabel(lElse);
-  738                                             QbeGen.NewLabel(lEnd);
-  739                                             QbeGen.Jnz(q, lThen, lElse);
-  740                                             QbeGen.EmitLabel(lThen); .)
-  741        "THEN" StatSeq                    (. QbeGen.Jmp(lEnd); .)
-  742        { "ELSIF"                         (. QbeGen.EmitLabel(lElse);
-  743                                             QbeGen.NewLabel(lElse); .)
-  744          Expr<t, q>                      (. IF ~SymTab.BoolCheck(t) THEN
-  745                                               SemError(214) END;
-  746                                             QbeGen.NewLabel(lThen);
-  747                                             QbeGen.Jnz(q, lThen, lElse);
-  748                                             QbeGen.EmitLabel(lThen); .)
-  749          "THEN" StatSeq                  (. QbeGen.Jmp(lEnd); .) }
-  750        [ "ELSE"                          (. QbeGen.EmitLabel(lElse);
-  751                                             hasElse := TRUE; .)
-  752          StatSeq ]
-  753        "END"                             (. IF hasElse THEN
-  754                                               QbeGen.EmitLabel(lEnd)
-  755                                             ELSE QbeGen.EmitLabel(lElse);
-  756                                               QbeGen.EmitLabel(lEnd)
-  757                                             END; .) .
-  758    WhileStat                             (. VAR t: SymTab.TypeIndex;
-  759                                               q, lTop, lBody, lEnd:
-  760                                                 QbeGen.QVal; .)
-  761      = "WHILE"                           (. QbeGen.NewLabel(lTop);
-  762                                             QbeGen.NewLabel(lBody);
-  763                                             QbeGen.NewLabel(lEnd);
-  764                                             QbeGen.EmitLabel(lTop); .)
-  765        Expr<t, q>                        (. IF ~SymTab.BoolCheck(t) THEN
-  766                                               SemError(214) END;
-  767                                             QbeGen.Jnz(q, lBody, lEnd);
-  768                                             QbeGen.EmitLabel(lBody); .)
-  769        "DO" StatSeq                      (. QbeGen.Jmp(lTop); .)
-  770        "END"                             (. QbeGen.EmitLabel(lEnd); .) .
-  771    RepeatStat                            (. VAR t: SymTab.TypeIndex;
-  772                                               q, lTop, lEnd: QbeGen.QVal; .)
-  773      = "REPEAT"                          (. QbeGen.NewLabel(lTop);
-  774                                             QbeGen.NewLabel(lEnd);
-  775                                             QbeGen.EmitLabel(lTop); .)
-  776        StatSeq
-  777        "UNTIL" Expr<t, q>                (. IF ~SymTab.BoolCheck(t) THEN
-  778                                               SemError(214) END;
-  779                                             QbeGen.Jnz(q, lEnd, lTop);
-  780                                             QbeGen.EmitLabel(lEnd); .) .
-  781    LoopStat                              (. VAR lTop, lEnd: QbeGen.QVal; .)
-  782      = "LOOP"                            (. QbeGen.NewLabel(lTop);
-  783                                             QbeGen.NewLabel(lEnd);
-  784                                             QbeGen.PushLoop(lEnd);
-  785                                             QbeGen.EmitLabel(lTop); .)
-  786        StatSeq
-  787        "END"                             (. QbeGen.Jmp(lTop);
-  788                                             QbeGen.PopLoop;
-  789                                             QbeGen.EmitLabel(lEnd); .) .
-  790    (* FOR with static-sign BY (literal, non-zero; 220 otherwise).
-  791       Runtime direction would need a compare-select; the literal
-  792       sign picks cslew/csegew at "DO" time. *)
-  793    ForStat                               (. VAR lv: SymTab.Name;
-  794                                               tlo, thi, tby:
-  795                                                 SymTab.TypeIndex;
-  796                                               qlo, qhi, qby, qt, qk, qb:
-  797                                                 QbeGen.QVal;
-  798                                               lTop, lBody, lEnd:
-  799                                                 QbeGen.QVal;
-  800                                               by: INTEGER;
-  801                                               ok: BOOLEAN; .)
-  802      = "FOR"                             (. by := 1; .)
-  803        GetIdent<lv>                      (. ok := SymTab.Lookup(lv);
-  804                                             IF ~ok THEN
-  805                                               SemError(201)
-  806                                             ELSIF (SymTab.SymKind(lv) #
-  807                                                    SymTab.KindVar)
-  808                                                & (SymTab.SymKind(lv) #
-  809                                                   SymTab.KindParam) THEN
-  810                                               SemError(220); ok := FALSE
-  811                                             ELSIF ~SymTab.IsIntFamily(
-  812                                                     SymTab.SymType(lv)) THEN
-  813                                               SemError(220); ok := FALSE
-  814                                             END; .)
-  815        ":=" Expr<tlo, qlo>               (. IF ~SymTab.IsIntFamily(tlo) THEN
-  816                                               SemError(220); ok := FALSE
-  817                                             END; .)
-  818        "TO" Expr<thi, qhi>               (. IF ~SymTab.IsIntFamily(thi) THEN
-  819                                               SemError(220); ok := FALSE
-  820                                             END; .)
-  821        [ "BY" Expr<tby, qby>             (. IF (tby #
-  822                                               SymTab.InvalidType)
-  823                                              & ~SymTab.IsIntFamily(tby) THEN
-  824                                               SemError(220); ok := FALSE
-  825                                             END;
-  826                                             IF ~SymTab.ConstInt(qby, by) THEN
-  827                                               SemError(230); by := 1
-  828                                             ELSIF by = 0 THEN
-  829                                               SemError(220); by := 1
-  830                                             END; .) ]
-  831        "DO"                              (. IF ok THEN
-  832                                               QbeGen.StoreVar(lv, qlo,
-  833                                                 FALSE) END;
-  834                                             QbeGen.NewLabel(lTop);
-  835                                             QbeGen.NewLabel(lBody);
-  836                                             QbeGen.NewLabel(lEnd);
-  837                                             QbeGen.EmitLabel(lTop);
-  838                                             QbeGen.LoadVar(lv, FALSE, qt);
-  839                                             QbeGen.NewTemp(qk);
-  840                                             IF by > 0 THEN
-  841                                               QbeGen.Op3("cslew", qk,
-  842                                                 qt, qhi, FALSE)
-  843                                             ELSE QbeGen.Op3("csgew", qk,
-  844                                               qt, qhi, FALSE)
-  845                                             END;
-  846                                             QbeGen.Jnz(qk, lBody, lEnd);
-  847                                             QbeGen.EmitLabel(lBody); .)
-  848        StatSeq
-  849        "END"                             (. IF ok THEN
-  850                                               QbeGen.LoadVar(lv, FALSE,
-  851                                                 qt);
-  852                                               QbeGen.IntStr(by, qb);
-  853                                               QbeGen.NewTemp(qk);
-  854                                               QbeGen.Op3("add", qk,
-  855                                                 qt, qb, FALSE);
-  856                                               QbeGen.StoreVar(lv, qk,
-  857                                                 FALSE) END;
-  858                                             QbeGen.Jmp(lTop);
-  859                                             QbeGen.EmitLabel(lEnd); .) .
-  860    CaseStat                              (. VAR tsel: SymTab.TypeIndex;
-  861                                               qsel, lEnd: QbeGen.QVal; .)
-  862      = "CASE" Expr<tsel, qsel>           (. QbeGen.NewLabel(lEnd); .)
-  863        "OF" CaseAlt<tsel, qsel, lEnd>
-  864        { "|" CaseAlt<tsel, qsel, lEnd> }
-  865        [ "ELSE" StatSeq ]
-  866        "END"                             (. QbeGen.EmitLabel(lEnd); .) .
-  867    (* Compare-chain lowering: each alternative ends its match-tests
-  868       with "jmp lAfter", so the no-match fallthrough skips the body:
-  869       "cmp; jnz(lBody,lF); lF: ... ; jmp lAfter; lBody: S; jmp lEnd;
-  870       lAfter:". Falls into the next alternative, ELSE, or END. *)
-  871    CaseAlt<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
-  872            lEnd: QbeGen.QVal>            (. VAR lBody, lAfter: QbeGen.QVal; .)
-  873      =                                   (. QbeGen.NewLabel(lBody);
-  874                                             QbeGen.NewLabel(lAfter); .)
-  875        CaseLabel<tsel, qsel, lBody>
-  876        { "," CaseLabel<tsel, qsel, lBody> }
-  877        ":"                               (. QbeGen.Jmp(lAfter);
-  878                                             QbeGen.EmitLabel(lBody); .)
-  879        StatSeq                           (. QbeGen.Jmp(lEnd);
-  880                                             QbeGen.EmitLabel(lAfter); .) .
-  881    CaseLabel<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
-  882              lBody: QbeGen.QVal>         (. VAR t2, t3: SymTab.TypeIndex;
-  883                                               q2, q3, qc, qd, qe:
-  884                                                 QbeGen.QVal;
-  885                                               lNext: QbeGen.QVal; .)
-  886      = Expr<t2, q2>                      (. IF (t2 #
-  887                                               SymTab.InvalidType)
-  888                                              & (tsel #
-  889                                                 SymTab.InvalidType)
-  890                                              & ((SymTab.ClassOf(t2) =
-  891                                                  SymTab.ClSet)
-  892                                                 OR (SymTab.ClassOf(tsel) =
-  893                                                     SymTab.ClSet)) THEN
-  894                                               SemError(230)
-  895                                             ELSIF (t2 #
-  896                                               SymTab.InvalidType)
-  897                                              & (tsel #
-  898                                                 SymTab.InvalidType)
-  899                                              & ~SymTab.EqCheck(t2,
-  900                                                   tsel) THEN
-  901                                               SemError(213) END;
-  902                                             IF ~QbeGen.IsImm(q2) THEN
-  903                                               SemError(230);
-  904                                               QbeGen.CopyOp("0", q2)
-  905                                             END;
-  906                                             QbeGen.NewLabel(lNext);
-  907                                             QbeGen.Cmp(SymTab.OpEq,
-  908                                               qsel, q2, qc, FALSE);
-  909                                             QbeGen.Jnz(qc, lBody, lNext);
-  910                                             QbeGen.EmitLabel(lNext); .)
-  911        [ ".." Expr<t3, q3>               (. IF (t3 #
-  912                                               SymTab.InvalidType)
-  913                                              & (tsel #
-  914                                                 SymTab.InvalidType)
-  915                                              & ~SymTab.EqCheck(t3,
-  916                                                   tsel) THEN
-  917                                               SemError(213) END;
-  918                                             IF ~QbeGen.IsImm(q3) THEN
-  919                                               SemError(230);
-  920                                               QbeGen.CopyOp("0", q3)
-  921                                             END;
-  922                                             QbeGen.Cmp(SymTab.OpGe,
-  923                                               qsel, q2, qc, FALSE);
-  924                                             QbeGen.Cmp(SymTab.OpLe,
-  925                                               qsel, q3, qd, FALSE);
-  926                                             QbeGen.NewTemp(qe);
-  927                                             QbeGen.Op3("and", qe, qc, qd,
-  928                                               FALSE);
-  929                                             QbeGen.NewLabel(lNext);
-  930                                             QbeGen.Jnz(qe, lBody, lNext);
-  931                                             QbeGen.EmitLabel(lNext); .) ] .
-  932    ReturnStat                            (. VAR t: SymTab.TypeIndex;
-  933                                               q: QbeGen.QVal;
-  934                                               res: SymTab.TypeIndex;
-  935                                               hadE: BOOLEAN; .)
-  936      = "RETURN"                          (. hadE := FALSE; .)
-  937        [ Expr<t, q>                      (. hadE := TRUE; .) ]
-  938                                          (. IF ~SymTab.InProc() THEN
-  939                                               SemError(232)
-  940                                             ELSE res := SymTab.CurRes();
-  941                                               IF ~hadE THEN
-  942                                                 IF res #
-  943                                                    SymTab.InvalidType THEN
-  944                                                   SemError(232) END
-  945                                               ELSIF (res =
-  946                                                      SymTab.InvalidType)
-  947                                                  OR (t #
-  948                                                      SymTab.InvalidType)
-  949                                                  & ~SymTab.Assignable(t,
-  950                                                       res) THEN
-  951                                                 SemError(232)
-  952                                               END
-  953                                             END; .) .
-  954    (* Designator: scalar loads, array addresses, and index suffixes.
-  955       Each index descends one level (bounds-checked, trap on breach);
-  956       nested levels reload the inner descriptor address. q ends as the
-  957       value (scalars), the descriptor address (plain arrays), or the
-  958       element address (indexed); sfx marks the indexed form. *)
-  959    Design<VAR t: SymTab.TypeIndex; VAR k: INTEGER;
-  960           VAR q: QbeGen.QVal; VAR qn: SymTab.Name; VAR sfx: BOOLEAN>
-  961                                          (. VAR n, fn: SymTab.Name;
-  962                                               cls: INTEGER;
-  963                                               curT, it, eT, bt:
-  964                                                 SymTab.TypeIndex;
-  965                                               iq, ql, qlo, qhi, qe:
-  966                                                 QbeGen.QVal;
-  967                                               lo, hi: INTEGER;
-  968                                               fo: INTEGER;
-  969                                               isOpen: BOOLEAN;
-  970                                               qb: QbeGen.QVal; .)
-  971      = GetIdent<n>                       (. QbeGen.CopyOp(n, qn);
-  972                                             sfx := FALSE;
-  973                                             IF ~SymTab.Lookup(n) THEN
-  974                                               SemError(201);
-  975                                               t := SymTab.InvalidType;
-  976                                               k := -1;
-  977                                               QbeGen.CopyOp("0", q)
-  978                                             ELSE
-  979                                               t := SymTab.SymType(n);
-  980                                               k := SymTab.SymKind(n);
-  981                                               IF k = SymTab.KindConst THEN
-  982                                                 IF SymTab.Equal(n,
-  983                                                    "TRUE") THEN
-  984                                                   t := SymTab.BoolType();
-  985                                                   QbeGen.CopyOp("1", q)
-  986                                                 ELSIF SymTab.Equal(n,
-  987                                                    "FALSE") THEN
-  988                                                   t := SymTab.BoolType();
-  989                                                   QbeGen.CopyOp("0", q)
-  990                                                 ELSIF SymTab.Equal(n,
-  991                                                    "NIL") THEN
-  992                                                   QbeGen.CopyOp("0", q)
-  993                                                 ELSE
-  994                                                   cls :=
-  995                                                     SymTab.ClassOf(t);
-  996                                                   IF (t #
-  997                                                       SymTab.InvalidType)
-  998                                                      & ((cls = SymTab.ClInt)
-  999                                                      OR (cls
- 1000                                                          = SymTab.ClChar)
- 1001                                                      OR (cls
- 1002                                                          = SymTab.ClReal)
- 1003                                                      OR (cls
- 1004                                                          = SymTab.ClNil)) THEN
- 1005                                                     IF cls = SymTab.ClNil THEN
- 1006                                                       QbeGen.CopyOp("0", q)
- 1007                                                     ELSE
- 1008                                                       QbeGen.LoadVar(n,
- 1009                                                         cls = SymTab.ClReal,
- 1010                                                         q)
- 1011                                                     END
- 1012                                                   ELSE
- 1013                                                     IF t #
- 1014                                                        SymTab.InvalidType THEN
- 1015                                                       SemError(230)
- 1016                                                     END;
- 1017                                                     QbeGen.CopyOp("0", q)
- 1018                                                   END
- 1019                                                 END
- 1020                                               ELSIF (k = SymTab.KindVar)
- 1021                                                  OR (k = SymTab.KindParam) THEN
- 1022                                                 cls :=
- 1023                                                   SymTab.ClassOf(t);
- 1024                                                 IF (cls = SymTab.ClInt)
- 1025                                                    OR (cls = SymTab.ClBool)
- 1026                                                    OR (cls = SymTab.ClChar)
- 1027                                                    OR (cls
- 1028                                                        = SymTab.ClReal) THEN
- 1029                                                   QbeGen.LoadVar(n,
- 1030                                                     cls = SymTab.ClReal, q)
- 1031                                                 ELSIF cls = SymTab.ClPtr THEN
- 1032                                                   QbeGen.LoadPtr(n, q)
- 1033                                                 ELSIF (cls
- 1034                                                         = SymTab.ClArray)
- 1035                                                    OR (cls
- 1036                                                        = SymTab.ClSet)
- 1037                                                    OR (cls
- 1038                                                        = SymTab.ClRecord)
- 1039                                                    OR (cls
- 1040                                                        = SymTab.ClClass) THEN
- 1041                                                   QbeGen.AddrOf(n, q)
- 1042                                                 ELSE SemError(230);
- 1043                                                   QbeGen.CopyOp("0", q)
- 1044                                                 END
- 1045                                               ELSE QbeGen.CopyOp("0", q);
- 1046                                                 IF (k = SymTab.KindImport)
- 1047                                                    OR (k = SymTab.KindProc) THEN
- 1048                                                   SemError(230)
- 1049                                                 ELSE
- 1050                                                   IF k = SymTab.KindField THEN
- 1051                                                     IF QbeGen.TopWith(qb) THEN
- 1052                                                       fo :=
- 1053                                                         SymTab.FieldOffset(
- 1054                                                         SymTab.FieldOwner(n),
- 1055                                                         n);
- 1056                                                       QbeGen.FieldAddr(qb,
- 1057                                                         fo, q);
- 1058                                                       sfx := TRUE
- 1059                                                     ELSE SemError(230);
- 1060                                                       QbeGen.CopyOp("0", q)
- 1061                                                     END
- 1062                                                   END
- 1063                                                 END
- 1064                                               END
- 1065                                             END; .)
- 1066        { "[" Expr<it, iq>
- 1067                                          (. IF t = SymTab.InvalidType THEN
- 1068                                             ELSIF SymTab.ClassOf(t) #
- 1069                                                   SymTab.ClArray THEN
- 1070                                               SemError(217);
- 1071                                               t := SymTab.InvalidType
- 1072                                             ELSIF ~SymTab.IsIntFamily(it)
- 1073                                                & (SymTab.ClassOf(it) #
- 1074                                                   SymTab.ClChar) THEN
- 1075                                               SemError(218);
- 1076                                               t := SymTab.InvalidType
- 1077                                             ELSE
- 1078                                               QbeGen.WidenIndex(iq, ql);
- 1079                                               isOpen :=
- 1080                                                 SymTab.IsOpenArray(t);
- 1081                                               IF isOpen THEN
- 1082                                                 QbeGen.CopyOp("0", qlo);
- 1083                                                 QbeGen.OpenHi(q, qhi)
- 1084                                               ELSE
- 1085                                                 lo := SymTab.ArrayLo(t);
- 1086                                                 hi := SymTab.ArrayHi(t);
- 1087                                                 QbeGen.IntStr(lo, qlo);
- 1088                                                 QbeGen.IntStr(hi, qhi)
- 1089                                               END;
- 1090                                               QbeGen.CheckRange(ql, qlo,
- 1091                                                 qhi);
- 1092                                               eT := SymTab.ArrayElem(t);
- 1093                                               QbeGen.ElemAddr(q, ql, qlo,
- 1094                                                 t, qe);
- 1095                                               IF SymTab.ClassOf(eT) =
- 1096                                                  SymTab.ClArray THEN
- 1097                                                 QbeGen.ElemLoad(qe, eT, q)
- 1098                                               ELSE QbeGen.CopyOp(qe, q)
- 1099                                               END;
- 1100                                               t := eT; sfx := TRUE
- 1101                                             END; .)
- 1102          { "," Expr<it, iq>
- 1103                                          (. IF t = SymTab.InvalidType THEN
- 1104                                             ELSIF SymTab.ClassOf(t) #
- 1105                                                   SymTab.ClArray THEN
- 1106                                               SemError(217);
- 1107                                               t := SymTab.InvalidType
- 1108                                             ELSIF ~SymTab.IsIntFamily(it)
- 1109                                                & (SymTab.ClassOf(it) #
- 1110                                                   SymTab.ClChar) THEN
- 1111                                               SemError(218);
- 1112                                               t := SymTab.InvalidType
- 1113                                             ELSE
- 1114                                               QbeGen.WidenIndex(iq, ql);
- 1115                                               isOpen :=
- 1116                                                 SymTab.IsOpenArray(t);
- 1117                                               IF isOpen THEN
- 1118                                                 QbeGen.CopyOp("0", qlo);
- 1119                                                 QbeGen.OpenHi(q, qhi)
- 1120                                               ELSE
- 1121                                                 lo := SymTab.ArrayLo(t);
- 1122                                                 hi := SymTab.ArrayHi(t);
- 1123                                                 QbeGen.IntStr(lo, qlo);
- 1124                                                 QbeGen.IntStr(hi, qhi)
- 1125                                               END;
- 1126                                               QbeGen.CheckRange(ql, qlo,
- 1127                                                 qhi);
- 1128                                               eT := SymTab.ArrayElem(t);
- 1129                                               QbeGen.ElemAddr(q, ql, qlo,
- 1130                                                 t, qe);
- 1131                                               IF SymTab.ClassOf(eT) =
- 1132                                                  SymTab.ClArray THEN
- 1133                                                 QbeGen.ElemLoad(qe, eT, q)
- 1134                                               ELSE QbeGen.CopyOp(qe, q)
- 1135                                               END;
- 1136                                               t := eT; sfx := TRUE
- 1137                                             END; .) }
- 1138          "]"
- 1139        | "." GetIdent<fn>
- 1140                                          (. IF t = SymTab.InvalidType THEN
- 1141                                             ELSIF (SymTab.ClassOf(t) #
- 1142                                                    SymTab.ClRecord)
- 1143                                                & (SymTab.ClassOf(t) #
- 1144                                                   SymTab.ClClass) THEN
- 1145                                               SemError(215);
- 1146                                               t := SymTab.InvalidType
- 1147                                             ELSIF ~SymTab.FieldExists(t,
- 1148                                                      fn) THEN
- 1149                                               SemError(216);
- 1150                                               t := SymTab.InvalidType
- 1151                                             ELSE
- 1152                                               fo := SymTab.FieldOffset(t,
- 1153                                                 fn);
- 1154                                               t := SymTab.FieldType(t, fn);
- 1155                                               QbeGen.FieldAddr(q, fo, qe);
- 1156                                               IF SymTab.ClassOf(t) =
- 1157                                                  SymTab.ClArray THEN
- 1158                                                 QbeGen.ElemLoad(qe, t, q)
- 1159                                               ELSE QbeGen.CopyOp(qe, q)
- 1160                                               END;
- 1161                                               sfx := TRUE
- 1162                                             END; .)
- 1163        | "^"
- 1164                                          (. IF t = SymTab.InvalidType THEN
- 1165                                             ELSIF SymTab.ClassOf(t) #
- 1166                                                   SymTab.ClPtr THEN
- 1167                                               SemError(219);
- 1168                                               t := SymTab.InvalidType
- 1169                                             ELSE
- 1170                                               bt := SymTab.PtrBase(t);
- 1171                                               IF bt = SymTab.InvalidType THEN
- 1172                                               ELSE
- 1173                                                 IF sfx THEN
- 1174                                                   QbeGen.ElemLoad(q, t,
- 1175                                                     qb);
- 1176                                                   QbeGen.CopyOp(qb, q)
- 1177                                                 END;
- 1178                                                 t := bt;
- 1179                                                 IF (SymTab.ClassOf(bt) =
- 1180                                                    SymTab.ClInt)
- 1181                                                    OR (SymTab.ClassOf(bt) =
- 1182                                                        SymTab.ClBool)
- 1183                                                    OR (SymTab.ClassOf(bt) =
- 1184                                                        SymTab.ClChar)
- 1185                                                    OR (SymTab.ClassOf(bt) =
- 1186                                                        SymTab.ClReal) THEN
- 1187                                                   sfx := TRUE
- 1188                                                 ELSE sfx := FALSE
- 1189                                                 END
- 1190                                               END
- 1191                                             END; .) } .
- 1192    Expr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
- 1193                                          (. VAR t2: SymTab.TypeIndex;
- 1194                                               op: INTEGER;
- 1195                                               q2, qt: QbeGen.QVal;
- 1196                                               isR: BOOLEAN; .)
- 1197      = SimExpr<t, q>
- 1198        [ Rel<op> SimExpr<t2, q2>
- 1199          (. IF op = SymTab.OpIn THEN
- 1200               IF SymTab.InCheck(t, t2) THEN
- 1201                 IF (t = SymTab.InvalidType)
- 1202                    OR (t2 = SymTab.InvalidType) THEN
- 1203                   t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
- 1204                 ELSE
- 1205                   QbeGen.InSet(q, q2, SymTab.SetBaseLo(t2),
- 1206                     SymTab.SetCount(t2), qt);
- 1207                   t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
- 1208                 END
- 1209               ELSE SemError(222); t := SymTab.InvalidType;
- 1210                 QbeGen.CopyOp("0", q)
- 1211               END
- 1212             ELSIF SymTab.RelCheck(t, t2, op) THEN
- 1213               IF (t = SymTab.InvalidType)
- 1214                  OR (t2 = SymTab.InvalidType) THEN
- 1215                 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
- 1216               ELSIF (SymTab.ClassOf(t) = SymTab.ClPtr)
- 1217                  OR (SymTab.ClassOf(t2) = SymTab.ClPtr) THEN
- 1218                 IF (op # SymTab.OpEq) & (op # SymTab.OpNeq1)
- 1219                    & (op # SymTab.OpNeq2) THEN
- 1220                   SemError(213); t := SymTab.InvalidType;
- 1221                   QbeGen.CopyOp("0", q)
- 1222                 ELSE
- 1223                   QbeGen.CmpL(op, q, q2, qt);
- 1224                   t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
- 1225                 END
- 1226               ELSIF (SymTab.ClassOf(t) = SymTab.ClSet)
- 1227                  OR (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
- 1228                 QbeGen.CmpSet(op, q, q2,
- 1229                   SymTab.SetWords(t), SymTab.SetWords(t2), qt);
- 1230                 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
- 1231               ELSE
- 1232                 isR := SymTab.ClassOf(t) = SymTab.ClReal;
- 1233                 t := SymTab.BoolType();
- 1234                 QbeGen.Cmp(op, q, q2, qt, isR);
- 1235                 QbeGen.CopyOp(qt, q)
- 1236               END
- 1237             ELSE SemError(213); t := SymTab.InvalidType;
- 1238               QbeGen.CopyOp("0", q)
- 1239             END; .) ] .
- 1240    Rel<VAR op: INTEGER>
- 1241      = "="                               (. op := SymTab.OpEq; .)
- 1242      | "#"                               (. op := SymTab.OpNeq1; .)
- 1243      | "<"                               (. op := SymTab.OpLt; .)
- 1244      | "<="                              (. op := SymTab.OpLe; .)
- 1245      | ">"                               (. op := SymTab.OpGt; .)
- 1246      | ">="                              (. op := SymTab.OpGe; .)
- 1247      | "IN"                              (. op := SymTab.OpIn; .) .
- 1248    SimExpr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
- 1249                                          (. VAR t2, res2: SymTab.TypeIndex;
- 1250                                               op: INTEGER;
- 1251                                               q2, qt: QbeGen.QVal;
- 1252                                               neg, isR: BOOLEAN;
- 1253                                               lw, rw, mw: CARDINAL; .)
- 1254      =                                   (. neg := FALSE; .)
- 1255        [ "+" | "-"                       (. neg := TRUE; .) ]
- 1256        Term<t, q>                        (. IF neg THEN
- 1257                                             IF QbeGen.IsImm(q) THEN
- 1258                                               QbeGen.NegFold(q, q)
- 1259                                             ELSE QbeGen.NewTemp(qt);
- 1260                                               QbeGen.NegQ(q, qt,
- 1261                                                 SymTab.ClassOf(t)
- 1262                                                 = SymTab.ClReal);
- 1263                                               QbeGen.CopyOp(qt, q)
- 1264                                             END
- 1265                                           END; .)
- 1266        { AddOp<op> Term<t2, q2>
- 1267          (. IF op = SymTab.OpOr THEN
- 1268               IF SymTab.BoolCheck(t) & SymTab.BoolCheck(t2) THEN
- 1269                 t := SymTab.BoolType()
- 1270               ELSE SemError(212); t := SymTab.InvalidType END;
- 1271               IF t # SymTab.InvalidType THEN
- 1272                 QbeGen.NewTemp(qt);
- 1273                 QbeGen.Op3("or", qt, q, q2, FALSE);
- 1274                 QbeGen.CopyOp(qt, q)
- 1275               ELSE QbeGen.CopyOp("0", q)
- 1276               END
- 1277             ELSIF (t # SymTab.InvalidType) & (t2 # SymTab.InvalidType)
- 1278                & (SymTab.ClassOf(t) = SymTab.ClSet)
- 1279                & (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
- 1280               lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
- 1281               mw := lw;
- 1282               IF rw > mw THEN mw := rw END;
- 1283               IF op = SymTab.OpAdd THEN
- 1284                 QbeGen.SetBinOp(0, q, q2, lw, rw, qt)
- 1285               ELSE
- 1286                 QbeGen.SetBinOp(2, q, q2, lw, rw, qt)
- 1287               END;
- 1288               t := SymTab.NewSet(
- 1289                      SymTab.NewSubR(0,
- 1290                        VAL(INTEGER, mw) * 32 - 1));
- 1291               QbeGen.CopyOp(qt, q)
- 1292             ELSE
- 1293               IF SymTab.ArithCheck(t, t2, FALSE, res2) THEN
- 1294                 t := res2
- 1295               ELSE SemError(211); t := SymTab.InvalidType END;
- 1296               isR := SymTab.ClassOf(t) = SymTab.ClReal;
- 1297               IF t # SymTab.InvalidType THEN
- 1298                 QbeGen.NewTemp(qt);
- 1299                 IF op = SymTab.OpAdd THEN
- 1300                   QbeGen.Op3("add", qt, q, q2, isR)
- 1301                 ELSE
- 1302                   QbeGen.Op3("sub", qt, q, q2, isR)
- 1303                 END;
- 1304                 QbeGen.CopyOp(qt, q)
- 1305               ELSE QbeGen.CopyOp("0", q)
- 1306               END
- 1307             END; .) } .
- 1308    AddOp<VAR op: INTEGER>
- 1309      = "+"                               (. op := SymTab.OpAdd; .)
- 1310      | "-"                               (. op := SymTab.OpSub; .)
- 1311      | "OR"                              (. op := SymTab.OpOr; .) .
- 1312    Term<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
- 1313                                          (. VAR t2, res2: SymTab.TypeIndex;
- 1314                                               op: INTEGER;
- 1315                                               q2, qt: QbeGen.QVal;
- 1316                                               isR: BOOLEAN;
- 1317                                               lw, rw, mw: CARDINAL; .)
- 1318      = Fact<t, q> { MulOp<op> Fact<t2, q2>
- 1319        (. IF op = SymTab.OpAnd THEN
- 1320             IF SymTab.BoolCheck(t) & SymTab.BoolCheck(t2) THEN
- 1321               t := SymTab.BoolType()
- 1322             ELSE SemError(212); t := SymTab.InvalidType END;
- 1323             IF t # SymTab.InvalidType THEN
- 1324               QbeGen.NewTemp(qt);
- 1325               QbeGen.Op3("and", qt, q, q2, FALSE);
- 1326               QbeGen.CopyOp(qt, q)
- 1327             ELSE QbeGen.CopyOp("0", q)
- 1328             END
- 1329           ELSIF (t # SymTab.InvalidType) & (t2 # SymTab.InvalidType)
- 1330              & (SymTab.ClassOf(t) = SymTab.ClSet)
- 1331              & (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
- 1332             lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
- 1333             mw := lw;
- 1334             IF rw > mw THEN mw := rw END;
- 1335             IF op = SymTab.OpTimes THEN
- 1336               QbeGen.SetBinOp(1, q, q2, lw, rw, qt)
- 1337             ELSE
- 1338               QbeGen.SetBinOp(3, q, q2, lw, rw, qt)
- 1339             END;
- 1340             t := SymTab.NewSet(
- 1341                    SymTab.NewSubR(0,
- 1342                      VAL(INTEGER, mw) * 32 - 1));
- 1343             QbeGen.CopyOp(qt, q)
- 1344           ELSE
- 1345             IF SymTab.ArithCheck(t, t2,
- 1346                  (op = SymTab.OpDiv) OR (op = SymTab.OpMod),
- 1347                  res2) THEN t := res2
- 1348             ELSE SemError(211); t := SymTab.InvalidType END;
- 1349             isR := SymTab.ClassOf(t) = SymTab.ClReal;
- 1350             IF t # SymTab.InvalidType THEN
- 1351               QbeGen.NewTemp(qt);
- 1352               IF op = SymTab.OpTimes THEN
- 1353                 QbeGen.Op3("mul", qt, q, q2, isR)
- 1354               ELSIF (op = SymTab.OpDiv)
- 1355                  OR (op = SymTab.OpSlash) THEN
- 1356                 QbeGen.Op3("div", qt, q, q2, isR)
- 1357               ELSE
- 1358                 QbeGen.Op3("rem", qt, q, q2, isR)
- 1359               END;
- 1360               QbeGen.CopyOp(qt, q)
- 1361             ELSE QbeGen.CopyOp("0", q)
- 1362             END
- 1363           END; .) } .
- 1364    MulOp<VAR op: INTEGER>
- 1365      = "*"                               (. op := SymTab.OpTimes; .)
- 1366      | "/"                               (. op := SymTab.OpSlash; .)
- 1367      | "DIV"                             (. op := SymTab.OpDiv; .)
- 1368      | "MOD"                             (. op := SymTab.OpMod; .)
- 1369      | "AND"                             (. op := SymTab.OpAnd; .) .
- 1370    Fact<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
- 1371                                          (. VAR s: ARRAY [0 .. 255] OF CHAR;
- 1372                                               et, dt, t2, st: SymTab.TypeIndex;
- 1373                                               dk: INTEGER;
- 1374                                               qd, q2, sq: QbeGen.QVal;
- 1375                                               qn: SymTab.Name;
- 1376                                               sfx: BOOLEAN; .)
- 1377      = integer                           (. LexString(s);
- 1378                                             QbeGen.NormInt(s, q);
- 1379                                             t := SymTab.IntType(); .)
- 1380      | real                              (. LexString(s);
- 1381                                             QbeGen.NormReal(s, q);
- 1382                                             t := SymTab.RealType(); .)
- 1383      | string                            (. LexString(s);
- 1384                                             IF SymTab.StrLen(s) = 3 THEN
- 1385                                               t := SymTab.CharType();
- 1386                                               QbeGen.IntStr(
- 1387                                                 QbeGen.CharVal(s), q)
- 1388                                             ELSE t := SymTab.NewStr();
- 1389                                               QbeGen.DeclStr(s, q)
- 1390                                             END; .)
- 1391      | Design<dt, dk, qd, qn, sfx>       (. t := dt;
- 1392                                             IF sfx THEN
- 1393                                               IF dt =
- 1394                                                  SymTab.InvalidType THEN
- 1395                                                 QbeGen.CopyOp("0", q)
- 1396                                               ELSIF (SymTab.ClassOf(dt) =
- 1397                                                      SymTab.ClRecord)
- 1398                                                  OR (SymTab.ClassOf(dt) =
- 1399                                                      SymTab.ClSet)
- 1400                                                  OR (SymTab.ClassOf(dt) =
- 1401                                                      SymTab.ClClass) THEN
- 1402                                                 QbeGen.CopyOp(qd, q)
- 1403                                               ELSE QbeGen.ElemLoad(qd, dt,
- 1404                                                 q)
- 1405                                               END
- 1406                                             ELSE QbeGen.CopyOp(qd, q)
- 1407                                             END; .)
- 1408      | "(" Expr<et, q> ")"               (. t := et; .)
- 1409      | SetLit<st, sq>                    (. t := st;
- 1410                                             QbeGen.CopyOp(sq, q); .)
- 1411      | "NOT" Fact<t2, q2>                (. IF SymTab.BoolCheck(t2) THEN
- 1412                                               t := SymTab.BoolType()
- 1413                                             ELSE SemError(212);
- 1414                                               t := SymTab.InvalidType END;
- 1415                                             IF t # SymTab.InvalidType THEN
- 1416                                               QbeGen.NotQ(q2, q)
- 1417                                             ELSE QbeGen.CopyOp("0", q)
- 1418                                             END; .) .
- 1419    (* Set literals are SET OF [0..255] (8 words); elements validated
- 1420       0..255 statically when foldable (222 otherwise), runtime trap
- 1421       for computed elements. Ranges always lower via SetRange. *)
- 1422    SetLit<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
- 1423      = "{"                               (. t := SymTab.NewSet(
- 1424                                               SymTab.NewSubR(0, 255));
- 1425                                             QbeGen.NewSetTemp(8, q);
- 1426                                             QbeGen.SetZero(q, 8); .)
- 1427        [ SetElem<t, q> { "," SetElem<t, q> } ]
- 1428        "}" .
- 1429    SetElem<st: SymTab.TypeIndex; sq: QbeGen.QVal>         (. VAR et, et2: SymTab.TypeIndex;
- 1430                                               qe, q2: QbeGen.QVal;
- 1431                                               v, v2: INTEGER;
- 1432                                               lo: INTEGER;
- 1433                                               span: CARDINAL;
- 1434                                               cl, cl2: INTEGER;
- 1435                                               hasR: BOOLEAN; .)
- 1436      =                                   (. hasR := FALSE; .)
- 1437        Expr<et, qe>
- 1438        [ ".." Expr<et2, q2>              (. hasR := TRUE; .) ]
- 1439                                          (. lo := SymTab.SetBaseLo(st);
- 1440                                             span := SymTab.SetCount(st);
- 1441                                             IF (et = SymTab.InvalidType)
- 1442                                                OR (hasR & (et2 =
- 1443                                                   SymTab.InvalidType)) THEN
- 1444                                             ELSE cl :=
- 1445                                                    SymTab.ClassOf(et);
- 1446                                               IF hasR THEN
- 1447                                                 cl2 :=
- 1448                                                   SymTab.ClassOf(et2)
- 1449                                               ELSE cl2 := SymTab.ClInt
- 1450                                               END;
- 1451                                               IF ((cl # SymTab.ClInt)
- 1452                                                  & (cl # SymTab.ClChar)
- 1453                                                  & (cl # SymTab.ClBool))
- 1454                                                  OR (hasR &
- 1455                                                     ((cl2
- 1456                                                       # SymTab.ClInt)
- 1457                                                     & (cl2
- 1458                                                        # SymTab.ClChar)
- 1459                                                     & (cl2
- 1460                                                        # SymTab.ClBool))) THEN
- 1461                                                 SemError(222)
- 1462                                               ELSIF hasR
- 1463                                                  & SymTab.ConstInt(qe, v)
- 1464                                                  & SymTab.ConstInt(q2,
- 1465                                                     v2)
- 1466                                                  & ((v < lo)
- 1467                                                     OR (v2 < lo)
- 1468                                                     OR (v >= lo +
- 1469                                                        VAL(INTEGER, span))
- 1470                                                     OR (v2 >= lo +
- 1471                                                        VAL(INTEGER, span))
- 1472                                                     OR (v > v2)) THEN
- 1473                                                 SemError(222)
- 1474                                                ELSIF hasR THEN
- 1475                                                  QbeGen.SetRange(sq, qe, q2,
- 1476                                                    lo, span)
- 1477                                                ELSIF SymTab.ConstInt(qe,
- 1478                                                        v)
- 1479                                                   & ((v < lo)
- 1480                                                      OR (v >= lo +
- 1481                                                         VAL(INTEGER,
- 1482                                                           span))) THEN
- 1483                                                  SemError(222)
- 1484                                                ELSE QbeGen.SetBit(sq, qe,
- 1485                                                  lo, span)
- 1486                                               END
- 1487                                             END; .) .
- 1488    GetIdent<VAR n: SymTab.Name>
- 1489      = ident                             (. LexName(n); .) .
- 1490  
- 1491  END M2.
+  254                                              ELSIF ~SymTab.BoundAdd(lo, hi) THEN
+  255                                                SemError(230); ok := FALSE
+  256                                              END;
+  257                                            END; .) .
+  258    (* Sets: multi-word masks over bases ≤ 256 values (bool, char,
+  259       bounded subranges; enums wait for ordinals, INTEGER is
+  260       unbounded). Literals are SET OF [0..255]; assignment and
+  261       comparison across suitable bases are lenient (masks over min
+  262       words + zero-check extras), out-of-span literals are 222. *)
+  263    SetType<VAR t: SymTab.TypeIndex>      (. VAR base: SymTab.TypeIndex;
+  264                                               blo, bhi, bspan: INTEGER;
+  265                                               bcls: INTEGER; .)
+  266      = "SET" "OF" Type<base, FALSE>
+  267                                          (. IF base = SymTab.InvalidType THEN
+  268                                               t := SymTab.InvalidType
+  269                                             ELSE bcls :=
+  270                                                    SymTab.ClassOf(base);
+  271                                               IF bcls = SymTab.ClBool THEN
+  272                                                 blo := 0; bspan := 2
+  273                                               ELSIF bcls = SymTab.ClChar THEN
+  274                                                 blo := 0; bspan := 256
+  275                                               ELSIF SymTab.SubBounds(base,
+  276                                                       blo, bhi) THEN
+  277                                                 bspan := bhi - blo + 1
+  278                                               ELSE bspan := 0 END;
+  279                                               IF (bspan <= 0)
+  280                                                  OR (bspan > 256) THEN
+  281                                                 SemError(230);
+  282                                                 t := SymTab.InvalidType
+  283                                               ELSE t := SymTab.NewSet(base)
+  284                                               END
+  285                                             END; .) .
+  286    (* Records: flat blobs; array fields are pointers to static
+  287       descriptors (locked amendment), nested records inline. Field
+  288       offsets static and declaration-ordered. *)
+  289    RecordType<VAR t: SymTab.TypeIndex>   (. VAR t2: SymTab.TypeIndex; .)
+  290      = "RECORD"                          (. t := SymTab.NewRecord(); .)
+  291        [ RecField<t> { ";" RecField<t> } ]
+  292        "END" .
+  293    RecField<rec: SymTab.TypeIndex>       (. VAR n: SymTab.Name;
+  294                                               t2: SymTab.TypeIndex; .)
+  295      = RecIdents<rec> ":" Type<t2, FALSE>(. SymTab.FixPendingF(rec, t2); .) .
+  296    RecIdents<rec: SymTab.TypeIndex>      (. VAR n: SymTab.Name; .)
+  297      = GetIdent<n>                       (. IF ~SymTab.FieldPending(rec,
+  298                                               n) THEN
+  299                                               SemError(200) END; .)
+  300        { "," GetIdent<n>                 (. IF ~SymTab.FieldPending(rec,
+  301                                               n) THEN
+  302                                               SemError(200) END; .) } .
+  303    TypeIdent<VAR t: SymTab.TypeIndex>    (. VAR n: SymTab.Name;
+  304                                               k: INTEGER; .)
+  305      = GetIdent<n>                       (. IF ~SymTab.Lookup(n) THEN
+  306                                               SemError(201);
+  307                                               t := SymTab.InvalidType
+  308                                             ELSE k := SymTab.SymKind(n);
+  309                                               IF (k = SymTab.KindType)
+  310                                                  OR (k = SymTab.KindPredef) THEN
+  311                                                 t := SymTab.SymType(n)
+  312                                               ELSIF k = SymTab.KindImport THEN
+  313                                                 t := SymTab.InvalidType
+  314                                               ELSE SemError(221);
+  315                                                 t := SymTab.InvalidType
+  316                                               END
+  317                                             END; .) .
+  318    Subrange<VAR t: SymTab.TypeIndex>     (. VAR tlo, thi: SymTab.TypeIndex;
+  319                                               qlo, qhi: QbeGen.QVal;
+  320                                               lo, hi: INTEGER; .)
+  321      = "[" Expr<tlo, qlo> ".." Expr<thi, qhi>
+  322                                          (. IF (tlo = SymTab.InvalidType)
+  323                                              OR (thi = SymTab.InvalidType) THEN
+  324                                             t := SymTab.InvalidType
+  325                                           ELSIF (SymTab.ClassOf(tlo) #
+  326                                                  SymTab.ClInt)
+  327                                              OR (SymTab.ClassOf(thi) #
+  328                                                  SymTab.ClInt) THEN
+  329                                             SemError(230);
+  330                                             t := SymTab.InvalidType
+  331                                           ELSIF ~SymTab.ConstInt(qlo, lo)
+  332                                              OR ~SymTab.ConstInt(qhi, hi)
+  333                                              OR (lo > hi) THEN
+  334                                             SemError(230);
+  335                                             t := SymTab.InvalidType
+  336                                           ELSE t := SymTab.NewSubR(lo, hi)
+  337                                           END; .)
+  338        "]" .
+  339    Enum<VAR t: SymTab.TypeIndex>         (. VAR n: SymTab.Name; .)
+  340      = "("                               (. t := SymTab.NewEnum(); .)
+  341        GetIdent<n>                       (. IF ~SymTab.Enter(n,
+  342                                               SymTab.KindConst) THEN
+  343                                               SemError(200) END;
+  344                                             SymTab.SetSymType(n, t); .)
+  345        { "," GetIdent<n>                 (. IF ~SymTab.Enter(n,
+  346                                               SymTab.KindConst) THEN
+  347                                               SemError(200) END;
+  348                                             SymTab.SetSymType(n, t); .) }
+  349        ")" .
+  350    (* Clarion-form classes (docs/OOP.txt): declaration + single
+  351       inheritance + IMPLEMENTATION blocks. Scopes and member checks
+  352       now; lowering (vtable, dispatch, THIS) later — one 230 per
+  353       class/impl block. Methods end with ";" per the Table example
+  354       (not "," as in the sketch). No underscores in identifiers. *)
+  355    (* Single CLASS item in both loops: separating declaration from
+  356       IMPLEMENTATION at the loop level needs 2-token lookahead
+  357       (CLASS ident vs CLASS IMPLEMENTATION), which LL(1) cannot do.
+  358       The second token decides after CLASS is consumed. A misplaced
+  359       CLASS IMPLEMENTATION inside TYPE still parses (harmless: the
+  360       whole unit ends 230 until lowering). *)
+  361    ClassItem
+  362      = "CLASS" ( "IMPLEMENTATION" ClassImplRest | ClassRest ) .
+  363    ClassRest                             (. VAR cn, m2, pn: SymTab.Name;
+  364                                               ct: SymTab.TypeIndex; .)
+  365      = GetIdent<cn>                      (. IF ~SymTab.Enter(cn,
+  366                                               SymTab.KindType) THEN
+  367                                               SemError(200) END;
+  368                                             ct := SymTab.NewClass();
+  369                                             SymTab.SetSymType(cn, ct);
+  370                                             SymTab.PushClassScope(ct); .)
+  371        [ Parents<ct> ]
+  372        ";"
+  373        { ClassField<ct> ";" }
+  374        { MethodHeading<pn> ";"           (. SymTab.CloseProc; .) }
+  375        "END"
+  376        GetIdent<m2>                      (. IF ~SymTab.Equal(cn, m2) THEN
+  377                                               SemError(202) END;
+  378                                             SymTab.PopScope;
+  379                                             SemError(230); .) .
+  380    Parents<ct: SymTab.TypeIndex>         (. VAR p: SymTab.Name; .)
+  381      = "(" Parent1<ct>
+  382        { "," GetIdent<p>                 (. SemError(230); .) }
+  383        ")" .
+  384    Parent1<ct: SymTab.TypeIndex>         (. VAR p: SymTab.Name;
+  385                                               pt: SymTab.TypeIndex; .)
+  386      = GetIdent<p>                       (. IF ~SymTab.Lookup(p) THEN
+  387                                               SemError(201)
+  388                                             ELSE pt := SymTab.SymType(p);
+  389                                               IF SymTab.ClassOf(pt) #
+  390                                                  SymTab.ClClass THEN
+  391                                                 SemError(230)
+  392                                               ELSE SymTab.SetParent(ct, pt)
+  393                                               END
+  394                                             END; .) .
+  395    ClassField<ct: SymTab.TypeIndex>      (. VAR n, rhs: SymTab.Name;
+  396                                               t: SymTab.TypeIndex; .)
+  397      = GetIdent<n>
+  398        ( "=" GetIdent<rhs>               (. IF ~SymTab.Enter(n,
+  399                                               SymTab.KindConst) THEN
+  400                                               SemError(200) END;
+  401                                             IF SymTab.Lookup(rhs) THEN
+  402                                               SymTab.SetSymType(n,
+  403                                                 SymTab.SymType(rhs))
+  404                                             END; .)
+  405        |                                 (. IF ~SymTab.FieldPending(ct,
+  406                                               n) THEN
+  407                                               SemError(200) END; .)
+  408          { "," GetIdent<n>               (. IF ~SymTab.FieldPending(ct,
+  409                                               n) THEN
+  410                                               SemError(200) END; .) }
+  411          ":" Type<t, FALSE>              (. SymTab.FixPendingF(ct, t); .) ) .
+  412    MethodHeading<VAR pn: SymTab.Name>    (. VAR wantVirt: BOOLEAN; .)
+  413      =                                   (. wantVirt := FALSE; .)
+  414        [ "VIRTUAL"                       (. wantVirt := TRUE; .) ]
+  415        ProcHeading<pn>                   (. IF wantVirt THEN
+  416                                               SymTab.MarkVirtual END; .) .
+  417    ClassImplRest                         (. VAR cn, m2: SymTab.Name;
+  418                                               ct: SymTab.TypeIndex; .)
+  419      = GetIdent<cn>                      (. IF ~SymTab.Lookup(cn) THEN
+  420                                               SemError(201);
+  421                                               ct := SymTab.InvalidType
+  422                                             ELSE ct := SymTab.SymType(cn);
+  423                                               IF SymTab.ClassOf(ct) #
+  424                                                  SymTab.ClClass THEN
+  425                                                 SemError(230);
+  426                                                 ct := SymTab.InvalidType
+  427                                               END
+  428                                             END;
+  429                                             IF ct #
+  430                                                SymTab.InvalidType THEN
+  431                                               IF ~SymTab.PushClassMembers(
+  432                                                      ct) THEN
+  433                                                 SemError(230) END
+  434                                             END; .)
+  435        ";" { MethodImpl<ct> ";" }
+  436        [ "BEGIN"
+  437          [ StatSeq ] ]
+  438        "END"
+  439        GetIdent<m2>                      (. IF ~SymTab.Equal(cn, m2) THEN
+  440                                               SemError(202) END;
+  441                                             SymTab.PopScope;
+  442                                             SemError(230); .) .
+  443    MethodImpl<ct: SymTab.TypeIndex>      (. VAR pn: SymTab.Name; .)
+  444      = MethodHeading<pn> ";"
+  445                                          (. IF (ct #
+  446                                                SymTab.InvalidType)
+  447                                               & ~SymTab.MethodExists(ct,
+  448                                                    pn) THEN
+  449                                               SemError(201) END; .)
+  450        ( "FORWARD"                       (. SymTab.MarkFwd;
+  451                                             SymTab.CloseProc; .)
+  452        | Block<pn>                       (. SymTab.CloseProc;
+  453                                             SemError(230); .) ) .
+  454    ConstBlock
+  455      = "CONST" { ConstDecl ";" } .
+  456    ConstDecl                             (. VAR n: SymTab.Name;
+  457                                               t: SymTab.TypeIndex;
+  458                                               qv: QbeGen.QVal;
+  459                                               cls: INTEGER; .)
+  460      = GetIdent<n>                       (. IF ~SymTab.Enter(n,
+  461                                               SymTab.KindConst) THEN
+  462                                               SemError(200) END; .)
+  463        "="
+  464        Expr<t, qv>                       (. SymTab.SetSymType(n, t);
+  465                                             cls := SymTab.ClassOf(t);
+  466                                             IF cls = SymTab.ClStr THEN
+  467                                               SemError(230)
+  468                                             ELSIF ~QbeGen.IsImm(qv) THEN
+  469                                               SemError(230) END;
+  470                                             QbeGen.DeclConst(n, qv, t); .) .
+  471    VarBlock
+  472      = "VAR" { VarDecl ";" } .
+  473    VarDecl                               (. VAR nm: SymTab.Name;
+  474                                               t: SymTab.TypeIndex;
+  475                                               i: CARDINAL;
+  476                                               cls: INTEGER; .)
+  477      = VarIdents ":"
+  478        Type<t, FALSE>                    (. cls := SymTab.ClassOf(t);
+  479                                             IF (t # SymTab.InvalidType)
+  480                                                & (cls # SymTab.ClInt)
+  481                                                & (cls # SymTab.ClBool)
+  482                                                & (cls # SymTab.ClChar)
+  483                                                & (cls # SymTab.ClReal)
+  484                                                & (cls # SymTab.ClArray)
+  485                                                & (cls # SymTab.ClSet)
+  486                                                & (cls # SymTab.ClRecord)
+  487                                                & (cls # SymTab.ClPtr) THEN
+  488                                               SemError(230) END;
+  489                                             i := 0;
+  490                                             WHILE i < SymTab.PendCount() DO
+  491                                               SymTab.PendName(i, nm);
+  492                                               QbeGen.DeclVar(nm, t);
+  493                                               INC(i)
+  494                                             END;
+  495                                             SymTab.FixPending(t); .) .
+  496    VarIdents                             (. VAR n: SymTab.Name; .)
+  497      = GetIdent<n>                       (. IF ~SymTab.EnterPending(n,
+  498                                               SymTab.KindVar) THEN
+  499                                               SemError(200) END; .)
+  500        { ","
+  501          GetIdent<n>                     (. IF ~SymTab.EnterPending(n,
+  502                                               SymTab.KindVar) THEN
+  503                                               SemError(200) END; .) } .
+  504    ParIdents<isV: BOOLEAN>               (. VAR n: SymTab.Name; .)
+  505      = GetIdent<n>                       (. IF ~SymTab.EnterParam(n, isV) THEN
+  506                                               SemError(200) END; .)
+  507        { "," GetIdent<n>                 (. IF ~SymTab.EnterParam(n, isV) THEN
+  508                                               SemError(200) END; .) } .
+  509    (* Procedure headings enter now (scopes, params, result); bodies
+  510       parse + check with one 230 at END (lowering = step 4).
+  511       FORWARD marks; the body heading re-enters (signature compare
+  512       tightens in step 4). *)
+  513    ProcHeading<VAR pn: SymTab.Name>      (. VAR t: SymTab.TypeIndex; .)
+  514      = "PROCEDURE"
+  515        GetIdent<pn>                      (. IF ~SymTab.EnterProc(pn) THEN
+  516                                             IF ~SymTab.ReenterProc(pn) THEN
+  517                                               SemError(200) END
+  518                                             END; .)
+  519        [ FormalParams ]
+  520        [ ":" TypeIdent<t>                (. SymTab.SetProcRes(t);
+  521                                             IF (t #
+  522                                                SymTab.InvalidType)
+  523                                                & (SymTab.ClassOf(t)
+  524                                                   = SymTab.ClArray) THEN
+  525                                               SemError(230) END; .) ] .
+  526    FormalParams
+  527      = "(" [ ParamSection { ";" ParamSection } ] ")" .
+  528    ParamSection                          (. VAR t: SymTab.TypeIndex;
+  529                                               isV: BOOLEAN; .)
+  530      =                                   (. isV := FALSE; .)
+  531        [ "VAR"                           (. isV := TRUE; .) ]
+  532        ParIdents<isV> ":" Type<t, TRUE>  (. SymTab.FixPending(t); .) .
+  533    ProcDecl                              (. VAR pn, m2: SymTab.Name; .)
+  534      = ProcHeading<pn> ";"
+  535        ( "FORWARD"                       (. SymTab.MarkFwd;
+  536                                             SymTab.CloseProc; .)
+  537        | Block<pn>                       (. SymTab.CloseProc;
+  538                                             SemError(230); .) ) .
+  539    Block<pn: SymTab.Name>                (. VAR m2: SymTab.Name; .)
+  540      = DeclSeq
+  541        [ "BEGIN"
+  542          [ StatSeq ] ]
+  543        "END"
+  544        GetIdent<m2>                      (. IF ~SymTab.Equal(pn, m2) THEN
+  545                                               SemError(202) END; .) .
+  546    StatSeq
+  547      = Statement { ";" Statement } .
+  548    Statement                             (. VAR lx: QbeGen.QVal; .)
+  549      = Assign
+  550      | IfStat
+  551      | WhileStat
+  552      | RepeatStat
+  553      | LoopStat
+  554      | ForStat
+  555      | CaseStat
+  556      | WithStat
+  557      | ReturnStat
+  558      | NewStat
+  559      | DisposeStat
+  560      | "EXIT"                            (. IF QbeGen.TopLoop(lx) THEN
+  561                                               QbeGen.Jmp(lx)
+  562                                             ELSE SemError(230) END; .) .
+  563    (* NEW/DISPOSE as builtin statements (no call syntax until step 4).
+  564       Targets are pointer designators; DISPOSE nils afterwards (safer
+  565       than Wirth-undefined; documented). DISPOSE is shallow. *)
+  566    NewStat                               (. VAR dt: SymTab.TypeIndex;
+  567                                               dk: INTEGER;
+  568                                               qd, qm: QbeGen.QVal;
+  569                                               qn: SymTab.Name;
+  570                                               sfx: BOOLEAN;
+  571                                               bt: SymTab.TypeIndex; .)
+  572      = "NEW" "(" Design<dt, dk, qd, qn, sfx> ")"
+  573                                          (. IF dt = SymTab.InvalidType THEN
+  574                                             ELSIF (dk # SymTab.KindVar)
+  575                                                & (dk # SymTab.KindParam)
+  576                                                & (dk # SymTab.KindField) THEN
+  577                                               SemError(210)
+  578                                             ELSIF SymTab.ClassOf(dt) #
+  579                                                   SymTab.ClPtr THEN
+  580                                               SemError(219)
+  581                                             ELSE bt := SymTab.PtrBase(dt);
+  582                                               IF bt #
+  583                                                  SymTab.InvalidType THEN
+  584                                                 QbeGen.NewHeap(bt, qm);
+  585                                                 QbeGen.InitHeap(qm, bt);
+  586                                                 IF sfx
+  587                                                    OR (dk =
+  588                                                       SymTab.KindField) THEN
+  589                                                   QbeGen.ElemStore(qd, qm,
+  590                                                     dt)
+  591                                                 ELSE QbeGen.StorePtr(qn,
+  592                                                   qm)
+  593                                                 END
+  594                                               END
+  595                                             END; .) .
+  596    DisposeStat                           (. VAR dt: SymTab.TypeIndex;
+  597                                               dk: INTEGER;
+  598                                               qd, qv: QbeGen.QVal;
+  599                                               qn: SymTab.Name;
+  600                                               sfx: BOOLEAN; .)
+  601      = "DISPOSE" "(" Design<dt, dk, qd, qn, sfx> ")"
+  602                                          (. IF dt = SymTab.InvalidType THEN
+  603                                             ELSIF (dk # SymTab.KindVar)
+  604                                                & (dk # SymTab.KindParam)
+  605                                                & (dk # SymTab.KindField) THEN
+  606                                               SemError(210)
+  607                                             ELSIF SymTab.ClassOf(dt) #
+  608                                                   SymTab.ClPtr THEN
+  609                                               SemError(219)
+  610                                             ELSE
+  611                                               IF sfx
+  612                                                  OR (dk =
+  613                                                     SymTab.KindField) THEN
+  614                                                 QbeGen.ElemLoad(qd, dt,
+  615                                                   qv)
+  616                                               ELSE QbeGen.LoadPtr(qn, qv)
+  617                                               END;
+  618                                               QbeGen.FreeHeap(qv);
+  619                                               IF sfx
+  620                                                  OR (dk =
+  621                                                     SymTab.KindField) THEN
+  622                                                 QbeGen.ElemStore(qd, "0",
+  623                                                   dt)
+  624                                               ELSE QbeGen.StorePtr(qn,
+  625                                                 "0")
+  626                                               END
+  627                                             END; .) .
+  628    (* WITH pushes each record's fields (inner wins) plus its base
+  629       address; field designators resolve through both stacks. *)
+  630    WithStat                              (. VAR nW: CARDINAL; .)
+  631      = "WITH"                            (. nW := 0; .)
+  632        WithItem<nW> { "," WithItem<nW> }
+  633        "DO" StatSeq "END"
+  634                                          (. WHILE nW > 0 DO
+  635                                               SymTab.PopScope;
+  636                                               QbeGen.PopWith;
+  637                                               DEC(nW)
+  638                                             END; .) .
+  639    WithItem<VAR nW: CARDINAL>            (. VAR dt: SymTab.TypeIndex;
+  640                                               dk: INTEGER;
+  641                                               qd, qe: QbeGen.QVal;
+  642                                               qn: SymTab.Name;
+  643                                               sfx: BOOLEAN; .)
+  644      = Design<dt, dk, qd, qn, sfx>
+  645                                          (. IF dt = SymTab.InvalidType THEN
+  646                                             ELSIF (SymTab.ClassOf(dt) #
+  647                                                    SymTab.ClRecord)
+  648                                                & (SymTab.ClassOf(dt) #
+  649                                                   SymTab.ClClass) THEN
+  650                                               SemError(215)
+  651                                             ELSIF SymTab.PushRecord(dt) THEN
+  652                                               QbeGen.PushWith(qd);
+  653                                               INC(nW)
+  654                                             END; .) .
+  655    Assign                                (. VAR dt, et: SymTab.TypeIndex;
+  656                                               dk: INTEGER;
+  657                                               qd, qe, qt: QbeGen.QVal;
+  658                                               qn: SymTab.Name;
+  659                                               isR, conv: BOOLEAN;
+  660                                               sfx: BOOLEAN; .)
+  661      = Design<dt, dk, qd, qn, sfx> ":="
+  662        Expr<et, qe>                      (. IF (dt # SymTab.InvalidType)
+  663                                             & (dk # SymTab.KindVar)
+  664                                             & (dk # SymTab.KindParam)
+  665                                             & (dk # SymTab.KindField) THEN
+  666                                             SemError(210)
+  667                                           ELSIF ~SymTab.Assignable(et,
+  668                                                    dt) THEN
+  669                                             SemError(210)
+  670                                           ELSIF (dt # SymTab.InvalidType)
+  671                                              & (SymTab.ClassOf(dt) =
+  672                                                 SymTab.ClClass) THEN
+  673                                             SemError(230) END;
+  674                                           isR := (dt #
+  675                                                   SymTab.InvalidType)
+  676                                                  & (SymTab.ClassOf(dt)
+  677                                                     = SymTab.ClReal);
+  678                                           conv := isR
+  679                                                   & SymTab.IsIntFamily(et);
+  680                                           IF ((dk = SymTab.KindVar)
+  681                                               OR (dk = SymTab.KindParam)
+  682                                               OR (dk = SymTab.KindField))
+  683                                              & (dt # SymTab.InvalidType)
+  684                                              & (et # SymTab.InvalidType)
+  685                                              & (SymTab.ClassOf(dt) #
+  686                                                 SymTab.ClClass) THEN
+  687                                             IF sfx
+  688                                                OR (dk = SymTab.KindField) THEN
+  689                                               IF SymTab.ClassOf(dt) =
+  690                                                  SymTab.ClArray THEN
+  691                                                 QbeGen.CopyArray(qd, qe,
+  692                                                   dt)
+  693                                               ELSIF SymTab.ClassOf(dt) =
+  694                                                   SymTab.ClSet THEN
+  695                                                 QbeGen.CopySet(qd, qe,
+  696                                                   SymTab.SetWords(dt),
+  697                                                   SymTab.SetWords(et))
+  698                                               ELSIF SymTab.ClassOf(dt) =
+  699                                                   SymTab.ClRecord THEN
+  700                                                 QbeGen.CopyRecord(qd, qe,
+  701                                                   dt)
+  702                                               ELSIF conv THEN
+  703                                                 QbeGen.ConvIR(qe, qt);
+  704                                                 QbeGen.ElemStore(qd, qt,
+  705                                                   dt)
+  706                                               ELSE QbeGen.ElemStore(qd, qe,
+  707                                                 dt)
+  708                                               END
+  709                                             ELSIF SymTab.ClassOf(dt) =
+  710                                                   SymTab.ClArray THEN
+  711                                               QbeGen.CopyArray(qd, qe, dt)
+  712                                             ELSIF SymTab.ClassOf(dt) =
+  713                                                   SymTab.ClSet THEN
+  714                                               QbeGen.CopySet(qd, qe,
+  715                                                 SymTab.SetWords(dt),
+  716                                                 SymTab.SetWords(et))
+  717                                             ELSIF SymTab.ClassOf(dt) =
+  718                                                   SymTab.ClRecord THEN
+  719                                               QbeGen.CopyRecord(qd, qe, dt)
+  720                                             ELSIF SymTab.ClassOf(dt) =
+  721                                                   SymTab.ClPtr THEN
+  722                                               QbeGen.StorePtr(qn, qe)
+  723                                             ELSIF conv THEN
+  724                                               QbeGen.ConvIR(qe, qt);
+  725                                               QbeGen.StoreVar(qn, qt, TRUE)
+  726                                             ELSE
+  727                                               QbeGen.StoreVar(qn, qe, isR)
+  728                                             END
+  729                                           END; .) .
+  730    IfStat                                (. VAR t: SymTab.TypeIndex;
+  731                                               q, lThen, lElse, lEnd:
+  732                                                 QbeGen.QVal;
+  733                                               hasElse: BOOLEAN; .)
+  734      = "IF"                              (. hasElse := FALSE; .)
+  735        Expr<t, q>                        (. IF ~SymTab.BoolCheck(t) THEN
+  736                                               SemError(214) END;
+  737                                             QbeGen.NewLabel(lThen);
+  738                                             QbeGen.NewLabel(lElse);
+  739                                             QbeGen.NewLabel(lEnd);
+  740                                             QbeGen.Jnz(q, lThen, lElse);
+  741                                             QbeGen.EmitLabel(lThen); .)
+  742        "THEN" StatSeq                    (. QbeGen.Jmp(lEnd); .)
+  743        { "ELSIF"                         (. QbeGen.EmitLabel(lElse);
+  744                                             QbeGen.NewLabel(lElse); .)
+  745          Expr<t, q>                      (. IF ~SymTab.BoolCheck(t) THEN
+  746                                               SemError(214) END;
+  747                                             QbeGen.NewLabel(lThen);
+  748                                             QbeGen.Jnz(q, lThen, lElse);
+  749                                             QbeGen.EmitLabel(lThen); .)
+  750          "THEN" StatSeq                  (. QbeGen.Jmp(lEnd); .) }
+  751        [ "ELSE"                          (. QbeGen.EmitLabel(lElse);
+  752                                             hasElse := TRUE; .)
+  753          StatSeq ]
+  754        "END"                             (. IF hasElse THEN
+  755                                               QbeGen.EmitLabel(lEnd)
+  756                                             ELSE QbeGen.EmitLabel(lElse);
+  757                                               QbeGen.EmitLabel(lEnd)
+  758                                             END; .) .
+  759    WhileStat                             (. VAR t: SymTab.TypeIndex;
+  760                                               q, lTop, lBody, lEnd:
+  761                                                 QbeGen.QVal; .)
+  762      = "WHILE"                           (. QbeGen.NewLabel(lTop);
+  763                                             QbeGen.NewLabel(lBody);
+  764                                             QbeGen.NewLabel(lEnd);
+  765                                             QbeGen.EmitLabel(lTop); .)
+  766        Expr<t, q>                        (. IF ~SymTab.BoolCheck(t) THEN
+  767                                               SemError(214) END;
+  768                                             QbeGen.Jnz(q, lBody, lEnd);
+  769                                             QbeGen.EmitLabel(lBody); .)
+  770        "DO" StatSeq                      (. QbeGen.Jmp(lTop); .)
+  771        "END"                             (. QbeGen.EmitLabel(lEnd); .) .
+  772    RepeatStat                            (. VAR t: SymTab.TypeIndex;
+  773                                               q, lTop, lEnd: QbeGen.QVal; .)
+  774      = "REPEAT"                          (. QbeGen.NewLabel(lTop);
+  775                                             QbeGen.NewLabel(lEnd);
+  776                                             QbeGen.EmitLabel(lTop); .)
+  777        StatSeq
+  778        "UNTIL" Expr<t, q>                (. IF ~SymTab.BoolCheck(t) THEN
+  779                                               SemError(214) END;
+  780                                             QbeGen.Jnz(q, lEnd, lTop);
+  781                                             QbeGen.EmitLabel(lEnd); .) .
+  782    LoopStat                              (. VAR lTop, lEnd: QbeGen.QVal; .)
+  783      = "LOOP"                            (. QbeGen.NewLabel(lTop);
+  784                                             QbeGen.NewLabel(lEnd);
+  785                                             QbeGen.PushLoop(lEnd);
+  786                                             QbeGen.EmitLabel(lTop); .)
+  787        StatSeq
+  788        "END"                             (. QbeGen.Jmp(lTop);
+  789                                             QbeGen.PopLoop;
+  790                                             QbeGen.EmitLabel(lEnd); .) .
+  791    (* FOR with static-sign BY (literal, non-zero; 220 otherwise).
+  792       Runtime direction would need a compare-select; the literal
+  793       sign picks cslew/csegew at "DO" time. *)
+  794    ForStat                               (. VAR lv: SymTab.Name;
+  795                                               tlo, thi, tby:
+  796                                                 SymTab.TypeIndex;
+  797                                               qlo, qhi, qby, qt, qk, qb:
+  798                                                 QbeGen.QVal;
+  799                                               lTop, lBody, lEnd:
+  800                                                 QbeGen.QVal;
+  801                                               by: INTEGER;
+  802                                               ok: BOOLEAN; .)
+  803      = "FOR"                             (. by := 1; .)
+  804        GetIdent<lv>                      (. ok := SymTab.Lookup(lv);
+  805                                             IF ~ok THEN
+  806                                               SemError(201)
+  807                                             ELSIF (SymTab.SymKind(lv) #
+  808                                                    SymTab.KindVar)
+  809                                                & (SymTab.SymKind(lv) #
+  810                                                   SymTab.KindParam) THEN
+  811                                               SemError(220); ok := FALSE
+  812                                             ELSIF ~SymTab.IsIntFamily(
+  813                                                     SymTab.SymType(lv)) THEN
+  814                                               SemError(220); ok := FALSE
+  815                                             END; .)
+  816        ":=" Expr<tlo, qlo>               (. IF ~SymTab.IsIntFamily(tlo) THEN
+  817                                               SemError(220); ok := FALSE
+  818                                             END; .)
+  819        "TO" Expr<thi, qhi>               (. IF ~SymTab.IsIntFamily(thi) THEN
+  820                                               SemError(220); ok := FALSE
+  821                                             END; .)
+  822        [ "BY" Expr<tby, qby>             (. IF (tby #
+  823                                               SymTab.InvalidType)
+  824                                              & ~SymTab.IsIntFamily(tby) THEN
+  825                                               SemError(220); ok := FALSE
+  826                                             END;
+  827                                             IF ~SymTab.ConstInt(qby, by) THEN
+  828                                               SemError(230); by := 1
+  829                                             ELSIF by = 0 THEN
+  830                                               SemError(220); by := 1
+  831                                             END; .) ]
+  832        "DO"                              (. IF ok THEN
+  833                                               QbeGen.StoreVar(lv, qlo,
+  834                                                 FALSE) END;
+  835                                             QbeGen.NewLabel(lTop);
+  836                                             QbeGen.NewLabel(lBody);
+  837                                             QbeGen.NewLabel(lEnd);
+  838                                             QbeGen.EmitLabel(lTop);
+  839                                             QbeGen.LoadVar(lv, FALSE, qt);
+  840                                             QbeGen.NewTemp(qk);
+  841                                             IF by > 0 THEN
+  842                                               QbeGen.Op3("cslew", qk,
+  843                                                 qt, qhi, FALSE)
+  844                                             ELSE QbeGen.Op3("csgew", qk,
+  845                                               qt, qhi, FALSE)
+  846                                             END;
+  847                                             QbeGen.Jnz(qk, lBody, lEnd);
+  848                                             QbeGen.EmitLabel(lBody); .)
+  849        StatSeq
+  850        "END"                             (. IF ok THEN
+  851                                               QbeGen.LoadVar(lv, FALSE,
+  852                                                 qt);
+  853                                               QbeGen.IntStr(by, qb);
+  854                                               QbeGen.NewTemp(qk);
+  855                                               QbeGen.Op3("add", qk,
+  856                                                 qt, qb, FALSE);
+  857                                               QbeGen.StoreVar(lv, qk,
+  858                                                 FALSE) END;
+  859                                             QbeGen.Jmp(lTop);
+  860                                             QbeGen.EmitLabel(lEnd); .) .
+  861    CaseStat                              (. VAR tsel: SymTab.TypeIndex;
+  862                                               qsel, lEnd: QbeGen.QVal; .)
+  863      = "CASE" Expr<tsel, qsel>           (. QbeGen.NewLabel(lEnd); .)
+  864        "OF" CaseAlt<tsel, qsel, lEnd>
+  865        { "|" CaseAlt<tsel, qsel, lEnd> }
+  866        [ "ELSE" StatSeq ]
+  867        "END"                             (. QbeGen.EmitLabel(lEnd); .) .
+  868    (* Compare-chain lowering: each alternative ends its match-tests
+  869       with "jmp lAfter", so the no-match fallthrough skips the body:
+  870       "cmp; jnz(lBody,lF); lF: ... ; jmp lAfter; lBody: S; jmp lEnd;
+  871       lAfter:". Falls into the next alternative, ELSE, or END. *)
+  872    CaseAlt<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
+  873            lEnd: QbeGen.QVal>            (. VAR lBody, lAfter: QbeGen.QVal; .)
+  874      =                                   (. QbeGen.NewLabel(lBody);
+  875                                             QbeGen.NewLabel(lAfter); .)
+  876        CaseLabel<tsel, qsel, lBody>
+  877        { "," CaseLabel<tsel, qsel, lBody> }
+  878        ":"                               (. QbeGen.Jmp(lAfter);
+  879                                             QbeGen.EmitLabel(lBody); .)
+  880        StatSeq                           (. QbeGen.Jmp(lEnd);
+  881                                             QbeGen.EmitLabel(lAfter); .) .
+  882    CaseLabel<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
+  883              lBody: QbeGen.QVal>         (. VAR t2, t3: SymTab.TypeIndex;
+  884                                               q2, q3, qc, qd, qe:
+  885                                                 QbeGen.QVal;
+  886                                               lNext: QbeGen.QVal; .)
+  887      = Expr<t2, q2>                      (. IF (t2 #
+  888                                               SymTab.InvalidType)
+  889                                              & (tsel #
+  890                                                 SymTab.InvalidType)
+  891                                              & ((SymTab.ClassOf(t2) =
+  892                                                  SymTab.ClSet)
+  893                                                 OR (SymTab.ClassOf(tsel) =
+  894                                                     SymTab.ClSet)) THEN
+  895                                               SemError(230)
+  896                                             ELSIF (t2 #
+  897                                               SymTab.InvalidType)
+  898                                              & (tsel #
+  899                                                 SymTab.InvalidType)
+  900                                              & ~SymTab.EqCheck(t2,
+  901                                                   tsel) THEN
+  902                                               SemError(213) END;
+  903                                             IF ~QbeGen.IsImm(q2) THEN
+  904                                               SemError(230);
+  905                                               QbeGen.CopyOp("0", q2)
+  906                                             END;
+  907                                             QbeGen.NewLabel(lNext);
+  908                                             QbeGen.Cmp(SymTab.OpEq,
+  909                                               qsel, q2, qc, FALSE);
+  910                                             QbeGen.Jnz(qc, lBody, lNext);
+  911                                             QbeGen.EmitLabel(lNext); .)
+  912        [ ".." Expr<t3, q3>               (. IF (t3 #
+  913                                               SymTab.InvalidType)
+  914                                              & (tsel #
+  915                                                 SymTab.InvalidType)
+  916                                              & ~SymTab.EqCheck(t3,
+  917                                                   tsel) THEN
+  918                                               SemError(213) END;
+  919                                             IF ~QbeGen.IsImm(q3) THEN
+  920                                               SemError(230);
+  921                                               QbeGen.CopyOp("0", q3)
+  922                                             END;
+  923                                             QbeGen.Cmp(SymTab.OpGe,
+  924                                               qsel, q2, qc, FALSE);
+  925                                             QbeGen.Cmp(SymTab.OpLe,
+  926                                               qsel, q3, qd, FALSE);
+  927                                             QbeGen.NewTemp(qe);
+  928                                             QbeGen.Op3("and", qe, qc, qd,
+  929                                               FALSE);
+  930                                             QbeGen.NewLabel(lNext);
+  931                                             QbeGen.Jnz(qe, lBody, lNext);
+  932                                             QbeGen.EmitLabel(lNext); .) ] .
+  933    ReturnStat                            (. VAR t: SymTab.TypeIndex;
+  934                                               q: QbeGen.QVal;
+  935                                               res: SymTab.TypeIndex;
+  936                                               hadE: BOOLEAN; .)
+  937      = "RETURN"                          (. hadE := FALSE; .)
+  938        [ Expr<t, q>                      (. hadE := TRUE; .) ]
+  939                                          (. IF ~SymTab.InProc() THEN
+  940                                               SemError(232)
+  941                                             ELSE res := SymTab.CurRes();
+  942                                               IF ~hadE THEN
+  943                                                 IF res #
+  944                                                    SymTab.InvalidType THEN
+  945                                                   SemError(232) END
+  946                                               ELSIF (res =
+  947                                                      SymTab.InvalidType)
+  948                                                  OR (t #
+  949                                                      SymTab.InvalidType)
+  950                                                  & ~SymTab.Assignable(t,
+  951                                                       res) THEN
+  952                                                 SemError(232)
+  953                                               END
+  954                                             END; .) .
+  955    (* Designator: scalar loads, array addresses, and index suffixes.
+  956       Each index descends one level (bounds-checked, trap on breach);
+  957       nested levels reload the inner descriptor address. q ends as the
+  958       value (scalars), the descriptor address (plain arrays), or the
+  959       element address (indexed); sfx marks the indexed form. *)
+  960    Design<VAR t: SymTab.TypeIndex; VAR k: INTEGER;
+  961           VAR q: QbeGen.QVal; VAR qn: SymTab.Name; VAR sfx: BOOLEAN>
+  962                                          (. VAR n, fn: SymTab.Name;
+  963                                               cls: INTEGER;
+  964                                               curT, it, eT, bt:
+  965                                                 SymTab.TypeIndex;
+  966                                               iq, ql, qlo, qhi, qe:
+  967                                                 QbeGen.QVal;
+  968                                               lo, hi: INTEGER;
+  969                                               fo: INTEGER;
+  970                                               isOpen: BOOLEAN;
+  971                                               qb: QbeGen.QVal; .)
+  972      = GetIdent<n>                       (. QbeGen.CopyOp(n, qn);
+  973                                             sfx := FALSE;
+  974                                             IF ~SymTab.Lookup(n) THEN
+  975                                               SemError(201);
+  976                                               t := SymTab.InvalidType;
+  977                                               k := -1;
+  978                                               QbeGen.CopyOp("0", q)
+  979                                             ELSE
+  980                                               t := SymTab.SymType(n);
+  981                                               k := SymTab.SymKind(n);
+  982                                               IF k = SymTab.KindConst THEN
+  983                                                 IF SymTab.Equal(n,
+  984                                                    "TRUE") THEN
+  985                                                   t := SymTab.BoolType();
+  986                                                   QbeGen.CopyOp("1", q)
+  987                                                 ELSIF SymTab.Equal(n,
+  988                                                    "FALSE") THEN
+  989                                                   t := SymTab.BoolType();
+  990                                                   QbeGen.CopyOp("0", q)
+  991                                                 ELSIF SymTab.Equal(n,
+  992                                                    "NIL") THEN
+  993                                                   QbeGen.CopyOp("0", q)
+  994                                                 ELSE
+  995                                                   cls :=
+  996                                                     SymTab.ClassOf(t);
+  997                                                   IF (t #
+  998                                                       SymTab.InvalidType)
+  999                                                      & ((cls = SymTab.ClInt)
+ 1000                                                      OR (cls
+ 1001                                                          = SymTab.ClChar)
+ 1002                                                      OR (cls
+ 1003                                                          = SymTab.ClReal)
+ 1004                                                      OR (cls
+ 1005                                                          = SymTab.ClNil)) THEN
+ 1006                                                     IF cls = SymTab.ClNil THEN
+ 1007                                                       QbeGen.CopyOp("0", q)
+ 1008                                                     ELSE
+ 1009                                                       QbeGen.LoadVar(n,
+ 1010                                                         cls = SymTab.ClReal,
+ 1011                                                         q)
+ 1012                                                     END
+ 1013                                                   ELSE
+ 1014                                                     IF t #
+ 1015                                                        SymTab.InvalidType THEN
+ 1016                                                       SemError(230)
+ 1017                                                     END;
+ 1018                                                     QbeGen.CopyOp("0", q)
+ 1019                                                   END
+ 1020                                                 END
+ 1021                                               ELSIF (k = SymTab.KindVar)
+ 1022                                                  OR (k = SymTab.KindParam) THEN
+ 1023                                                 cls :=
+ 1024                                                   SymTab.ClassOf(t);
+ 1025                                                 IF (cls = SymTab.ClInt)
+ 1026                                                    OR (cls = SymTab.ClBool)
+ 1027                                                    OR (cls = SymTab.ClChar)
+ 1028                                                    OR (cls
+ 1029                                                        = SymTab.ClReal) THEN
+ 1030                                                   QbeGen.LoadVar(n,
+ 1031                                                     cls = SymTab.ClReal, q)
+ 1032                                                 ELSIF cls = SymTab.ClPtr THEN
+ 1033                                                   QbeGen.LoadPtr(n, q)
+ 1034                                                 ELSIF (cls
+ 1035                                                         = SymTab.ClArray)
+ 1036                                                    OR (cls
+ 1037                                                        = SymTab.ClSet)
+ 1038                                                    OR (cls
+ 1039                                                        = SymTab.ClRecord)
+ 1040                                                    OR (cls
+ 1041                                                        = SymTab.ClClass) THEN
+ 1042                                                   QbeGen.AddrOf(n, q)
+ 1043                                                 ELSE SemError(230);
+ 1044                                                   QbeGen.CopyOp("0", q)
+ 1045                                                 END
+ 1046                                               ELSE QbeGen.CopyOp("0", q);
+ 1047                                                 IF (k = SymTab.KindImport)
+ 1048                                                    OR (k = SymTab.KindProc) THEN
+ 1049                                                   SemError(230)
+ 1050                                                 ELSE
+ 1051                                                   IF k = SymTab.KindField THEN
+ 1052                                                     IF QbeGen.TopWith(qb) THEN
+ 1053                                                       fo :=
+ 1054                                                         SymTab.FieldOffset(
+ 1055                                                         SymTab.FieldOwner(n),
+ 1056                                                         n);
+ 1057                                                       QbeGen.FieldAddr(qb,
+ 1058                                                         fo, q);
+ 1059                                                       sfx := TRUE
+ 1060                                                     ELSE SemError(230);
+ 1061                                                       QbeGen.CopyOp("0", q)
+ 1062                                                     END
+ 1063                                                   END
+ 1064                                                 END
+ 1065                                               END
+ 1066                                             END; .)
+ 1067        { "[" Expr<it, iq>
+ 1068                                          (. IF t = SymTab.InvalidType THEN
+ 1069                                             ELSIF SymTab.ClassOf(t) #
+ 1070                                                   SymTab.ClArray THEN
+ 1071                                               SemError(217);
+ 1072                                               t := SymTab.InvalidType
+ 1073                                             ELSIF ~SymTab.IsIntFamily(it)
+ 1074                                                & (SymTab.ClassOf(it) #
+ 1075                                                   SymTab.ClChar) THEN
+ 1076                                               SemError(218);
+ 1077                                               t := SymTab.InvalidType
+ 1078                                             ELSE
+ 1079                                               QbeGen.WidenIndex(iq, ql);
+ 1080                                               isOpen :=
+ 1081                                                 SymTab.IsOpenArray(t);
+ 1082                                               IF isOpen THEN
+ 1083                                                 QbeGen.CopyOp("0", qlo);
+ 1084                                                 QbeGen.OpenHi(q, qhi)
+ 1085                                               ELSE
+ 1086                                                 lo := SymTab.ArrayLo(t);
+ 1087                                                 hi := SymTab.ArrayHi(t);
+ 1088                                                 QbeGen.IntStr(lo, qlo);
+ 1089                                                 QbeGen.IntStr(hi, qhi)
+ 1090                                               END;
+ 1091                                               QbeGen.CheckRange(ql, qlo,
+ 1092                                                 qhi);
+ 1093                                               eT := SymTab.ArrayElem(t);
+ 1094                                               QbeGen.ElemAddr(q, ql, qlo,
+ 1095                                                 t, qe);
+ 1096                                               IF SymTab.ClassOf(eT) =
+ 1097                                                  SymTab.ClArray THEN
+ 1098                                                 QbeGen.ElemLoad(qe, eT, q)
+ 1099                                               ELSE QbeGen.CopyOp(qe, q)
+ 1100                                               END;
+ 1101                                               t := eT; sfx := TRUE
+ 1102                                             END; .)
+ 1103          { "," Expr<it, iq>
+ 1104                                          (. IF t = SymTab.InvalidType THEN
+ 1105                                             ELSIF SymTab.ClassOf(t) #
+ 1106                                                   SymTab.ClArray THEN
+ 1107                                               SemError(217);
+ 1108                                               t := SymTab.InvalidType
+ 1109                                             ELSIF ~SymTab.IsIntFamily(it)
+ 1110                                                & (SymTab.ClassOf(it) #
+ 1111                                                   SymTab.ClChar) THEN
+ 1112                                               SemError(218);
+ 1113                                               t := SymTab.InvalidType
+ 1114                                             ELSE
+ 1115                                               QbeGen.WidenIndex(iq, ql);
+ 1116                                               isOpen :=
+ 1117                                                 SymTab.IsOpenArray(t);
+ 1118                                               IF isOpen THEN
+ 1119                                                 QbeGen.CopyOp("0", qlo);
+ 1120                                                 QbeGen.OpenHi(q, qhi)
+ 1121                                               ELSE
+ 1122                                                 lo := SymTab.ArrayLo(t);
+ 1123                                                 hi := SymTab.ArrayHi(t);
+ 1124                                                 QbeGen.IntStr(lo, qlo);
+ 1125                                                 QbeGen.IntStr(hi, qhi)
+ 1126                                               END;
+ 1127                                               QbeGen.CheckRange(ql, qlo,
+ 1128                                                 qhi);
+ 1129                                               eT := SymTab.ArrayElem(t);
+ 1130                                               QbeGen.ElemAddr(q, ql, qlo,
+ 1131                                                 t, qe);
+ 1132                                               IF SymTab.ClassOf(eT) =
+ 1133                                                  SymTab.ClArray THEN
+ 1134                                                 QbeGen.ElemLoad(qe, eT, q)
+ 1135                                               ELSE QbeGen.CopyOp(qe, q)
+ 1136                                               END;
+ 1137                                               t := eT; sfx := TRUE
+ 1138                                             END; .) }
+ 1139          "]"
+ 1140        | "." GetIdent<fn>
+ 1141                                          (. IF t = SymTab.InvalidType THEN
+ 1142                                             ELSIF (SymTab.ClassOf(t) #
+ 1143                                                    SymTab.ClRecord)
+ 1144                                                & (SymTab.ClassOf(t) #
+ 1145                                                   SymTab.ClClass) THEN
+ 1146                                               SemError(215);
+ 1147                                               t := SymTab.InvalidType
+ 1148                                             ELSIF ~SymTab.FieldExists(t,
+ 1149                                                      fn) THEN
+ 1150                                               SemError(216);
+ 1151                                               t := SymTab.InvalidType
+ 1152                                             ELSE
+ 1153                                               fo := SymTab.FieldOffset(t,
+ 1154                                                 fn);
+ 1155                                               t := SymTab.FieldType(t, fn);
+ 1156                                               QbeGen.FieldAddr(q, fo, qe);
+ 1157                                               IF SymTab.ClassOf(t) =
+ 1158                                                  SymTab.ClArray THEN
+ 1159                                                 QbeGen.ElemLoad(qe, t, q)
+ 1160                                               ELSE QbeGen.CopyOp(qe, q)
+ 1161                                               END;
+ 1162                                               sfx := TRUE
+ 1163                                             END; .)
+ 1164        | "^"
+ 1165                                          (. IF t = SymTab.InvalidType THEN
+ 1166                                             ELSIF SymTab.ClassOf(t) #
+ 1167                                                   SymTab.ClPtr THEN
+ 1168                                               SemError(219);
+ 1169                                               t := SymTab.InvalidType
+ 1170                                             ELSE
+ 1171                                               bt := SymTab.PtrBase(t);
+ 1172                                               IF bt = SymTab.InvalidType THEN
+ 1173                                               ELSE
+ 1174                                                 IF sfx THEN
+ 1175                                                   QbeGen.ElemLoad(q, t,
+ 1176                                                     qb);
+ 1177                                                   QbeGen.CopyOp(qb, q)
+ 1178                                                 END;
+ 1179                                                 t := bt;
+ 1180                                                 IF (SymTab.ClassOf(bt) =
+ 1181                                                    SymTab.ClInt)
+ 1182                                                    OR (SymTab.ClassOf(bt) =
+ 1183                                                        SymTab.ClBool)
+ 1184                                                    OR (SymTab.ClassOf(bt) =
+ 1185                                                        SymTab.ClChar)
+ 1186                                                    OR (SymTab.ClassOf(bt) =
+ 1187                                                        SymTab.ClReal) THEN
+ 1188                                                   sfx := TRUE
+ 1189                                                 ELSE sfx := FALSE
+ 1190                                                 END
+ 1191                                               END
+ 1192                                             END; .) } .
+ 1193    Expr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
+ 1194                                          (. VAR t2: SymTab.TypeIndex;
+ 1195                                               op: INTEGER;
+ 1196                                               q2, qt: QbeGen.QVal;
+ 1197                                               isR: BOOLEAN; .)
+ 1198      = SimExpr<t, q>
+ 1199        [ Rel<op> SimExpr<t2, q2>
+ 1200          (. IF op = SymTab.OpIn THEN
+ 1201               IF SymTab.InCheck(t, t2) THEN
+ 1202                 IF (t = SymTab.InvalidType)
+ 1203                    OR (t2 = SymTab.InvalidType) THEN
+ 1204                   t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
+ 1205                 ELSE
+ 1206                   QbeGen.InSet(q, q2, SymTab.SetBaseLo(t2),
+ 1207                     SymTab.SetCount(t2), qt);
+ 1208                   t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
+ 1209                 END
+ 1210               ELSE SemError(222); t := SymTab.InvalidType;
+ 1211                 QbeGen.CopyOp("0", q)
+ 1212               END
+ 1213             ELSIF SymTab.RelCheck(t, t2, op) THEN
+ 1214               IF (t = SymTab.InvalidType)
+ 1215                  OR (t2 = SymTab.InvalidType) THEN
+ 1216                 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
+ 1217               ELSIF (SymTab.ClassOf(t) = SymTab.ClPtr)
+ 1218                  OR (SymTab.ClassOf(t2) = SymTab.ClPtr) THEN
+ 1219                 IF (op # SymTab.OpEq) & (op # SymTab.OpNeq1)
+ 1220                    & (op # SymTab.OpNeq2) THEN
+ 1221                   SemError(213); t := SymTab.InvalidType;
+ 1222                   QbeGen.CopyOp("0", q)
+ 1223                 ELSE
+ 1224                   QbeGen.CmpL(op, q, q2, qt);
+ 1225                   t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
+ 1226                 END
+ 1227               ELSIF (SymTab.ClassOf(t) = SymTab.ClSet)
+ 1228                  OR (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
+ 1229                 QbeGen.CmpSet(op, q, q2,
+ 1230                   SymTab.SetWords(t), SymTab.SetWords(t2), qt);
+ 1231                 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
+ 1232               ELSE
+ 1233                 isR := SymTab.ClassOf(t) = SymTab.ClReal;
+ 1234                 t := SymTab.BoolType();
+ 1235                 QbeGen.Cmp(op, q, q2, qt, isR);
+ 1236                 QbeGen.CopyOp(qt, q)
+ 1237               END
+ 1238             ELSE SemError(213); t := SymTab.InvalidType;
+ 1239               QbeGen.CopyOp("0", q)
+ 1240             END; .) ] .
+ 1241    Rel<VAR op: INTEGER>
+ 1242      = "="                               (. op := SymTab.OpEq; .)
+ 1243      | "#"                               (. op := SymTab.OpNeq1; .)
+ 1244      | "<"                               (. op := SymTab.OpLt; .)
+ 1245      | "<="                              (. op := SymTab.OpLe; .)
+ 1246      | ">"                               (. op := SymTab.OpGt; .)
+ 1247      | ">="                              (. op := SymTab.OpGe; .)
+ 1248      | "IN"                              (. op := SymTab.OpIn; .) .
+ 1249    SimExpr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
+ 1250                                          (. VAR t2, res2: SymTab.TypeIndex;
+ 1251                                               op: INTEGER;
+ 1252                                               q2, qt: QbeGen.QVal;
+ 1253                                               neg, isR: BOOLEAN;
+ 1254                                               lw, rw, mw: CARDINAL; .)
+ 1255      =                                   (. neg := FALSE; .)
+ 1256        [ "+" | "-"                       (. neg := TRUE; .) ]
+ 1257        Term<t, q>                        (. IF neg THEN
+ 1258                                             IF QbeGen.IsImm(q) THEN
+ 1259                                               QbeGen.NegFold(q, q)
+ 1260                                             ELSE QbeGen.NewTemp(qt);
+ 1261                                               QbeGen.NegQ(q, qt,
+ 1262                                                 SymTab.ClassOf(t)
+ 1263                                                 = SymTab.ClReal);
+ 1264                                               QbeGen.CopyOp(qt, q)
+ 1265                                             END
+ 1266                                           END; .)
+ 1267        { AddOp<op> Term<t2, q2>
+ 1268          (. IF op = SymTab.OpOr THEN
+ 1269               IF SymTab.BoolCheck(t) & SymTab.BoolCheck(t2) THEN
+ 1270                 t := SymTab.BoolType()
+ 1271               ELSE SemError(212); t := SymTab.InvalidType END;
+ 1272               IF t # SymTab.InvalidType THEN
+ 1273                 QbeGen.NewTemp(qt);
+ 1274                 QbeGen.Op3("or", qt, q, q2, FALSE);
+ 1275                 QbeGen.CopyOp(qt, q)
+ 1276               ELSE QbeGen.CopyOp("0", q)
+ 1277               END
+ 1278             ELSIF (t # SymTab.InvalidType) & (t2 # SymTab.InvalidType)
+ 1279                & (SymTab.ClassOf(t) = SymTab.ClSet)
+ 1280                & (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
+ 1281               lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
+ 1282               mw := lw;
+ 1283               IF rw > mw THEN mw := rw END;
+ 1284               IF op = SymTab.OpAdd THEN
+ 1285                 QbeGen.SetBinOp(0, q, q2, lw, rw, qt)
+ 1286               ELSE
+ 1287                 QbeGen.SetBinOp(2, q, q2, lw, rw, qt)
+ 1288               END;
+ 1289               t := SymTab.NewSet(
+ 1290                      SymTab.NewSubR(0,
+ 1291                        VAL(INTEGER, mw) * 32 - 1));
+ 1292               QbeGen.CopyOp(qt, q)
+ 1293             ELSE
+ 1294               IF SymTab.ArithCheck(t, t2, FALSE, res2) THEN
+ 1295                 t := res2
+ 1296               ELSE SemError(211); t := SymTab.InvalidType END;
+ 1297               isR := SymTab.ClassOf(t) = SymTab.ClReal;
+ 1298               IF t # SymTab.InvalidType THEN
+ 1299                 QbeGen.NewTemp(qt);
+ 1300                 IF op = SymTab.OpAdd THEN
+ 1301                   QbeGen.Op3("add", qt, q, q2, isR)
+ 1302                 ELSE
+ 1303                   QbeGen.Op3("sub", qt, q, q2, isR)
+ 1304                 END;
+ 1305                 QbeGen.CopyOp(qt, q)
+ 1306               ELSE QbeGen.CopyOp("0", q)
+ 1307               END
+ 1308             END; .) } .
+ 1309    AddOp<VAR op: INTEGER>
+ 1310      = "+"                               (. op := SymTab.OpAdd; .)
+ 1311      | "-"                               (. op := SymTab.OpSub; .)
+ 1312      | "OR"                              (. op := SymTab.OpOr; .) .
+ 1313    Term<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
+ 1314                                          (. VAR t2, res2: SymTab.TypeIndex;
+ 1315                                               op: INTEGER;
+ 1316                                               q2, qt: QbeGen.QVal;
+ 1317                                               isR: BOOLEAN;
+ 1318                                               lw, rw, mw: CARDINAL; .)
+ 1319      = Fact<t, q> { MulOp<op> Fact<t2, q2>
+ 1320        (. IF op = SymTab.OpAnd THEN
+ 1321             IF SymTab.BoolCheck(t) & SymTab.BoolCheck(t2) THEN
+ 1322               t := SymTab.BoolType()
+ 1323             ELSE SemError(212); t := SymTab.InvalidType END;
+ 1324             IF t # SymTab.InvalidType THEN
+ 1325               QbeGen.NewTemp(qt);
+ 1326               QbeGen.Op3("and", qt, q, q2, FALSE);
+ 1327               QbeGen.CopyOp(qt, q)
+ 1328             ELSE QbeGen.CopyOp("0", q)
+ 1329             END
+ 1330           ELSIF (t # SymTab.InvalidType) & (t2 # SymTab.InvalidType)
+ 1331              & (SymTab.ClassOf(t) = SymTab.ClSet)
+ 1332              & (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
+ 1333             lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
+ 1334             mw := lw;
+ 1335             IF rw > mw THEN mw := rw END;
+ 1336             IF op = SymTab.OpTimes THEN
+ 1337               QbeGen.SetBinOp(1, q, q2, lw, rw, qt)
+ 1338             ELSE
+ 1339               QbeGen.SetBinOp(3, q, q2, lw, rw, qt)
+ 1340             END;
+ 1341             t := SymTab.NewSet(
+ 1342                    SymTab.NewSubR(0,
+ 1343                      VAL(INTEGER, mw) * 32 - 1));
+ 1344             QbeGen.CopyOp(qt, q)
+ 1345           ELSE
+ 1346             IF SymTab.ArithCheck(t, t2,
+ 1347                  (op = SymTab.OpDiv) OR (op = SymTab.OpMod),
+ 1348                  res2) THEN t := res2
+ 1349             ELSE SemError(211); t := SymTab.InvalidType END;
+ 1350             isR := SymTab.ClassOf(t) = SymTab.ClReal;
+ 1351             IF t # SymTab.InvalidType THEN
+ 1352               QbeGen.NewTemp(qt);
+ 1353               IF op = SymTab.OpTimes THEN
+ 1354                 QbeGen.Op3("mul", qt, q, q2, isR)
+ 1355               ELSIF (op = SymTab.OpDiv)
+ 1356                  OR (op = SymTab.OpSlash) THEN
+ 1357                 QbeGen.Op3("div", qt, q, q2, isR)
+ 1358               ELSE
+ 1359                 QbeGen.Op3("rem", qt, q, q2, isR)
+ 1360               END;
+ 1361               QbeGen.CopyOp(qt, q)
+ 1362             ELSE QbeGen.CopyOp("0", q)
+ 1363             END
+ 1364           END; .) } .
+ 1365    MulOp<VAR op: INTEGER>
+ 1366      = "*"                               (. op := SymTab.OpTimes; .)
+ 1367      | "/"                               (. op := SymTab.OpSlash; .)
+ 1368      | "DIV"                             (. op := SymTab.OpDiv; .)
+ 1369      | "MOD"                             (. op := SymTab.OpMod; .)
+ 1370      | "AND"                             (. op := SymTab.OpAnd; .) .
+ 1371    Fact<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
+ 1372                                          (. VAR s: ARRAY [0 .. 255] OF CHAR;
+ 1373                                               et, dt, t2, st: SymTab.TypeIndex;
+ 1374                                               dk: INTEGER;
+ 1375                                               qd, q2, sq: QbeGen.QVal;
+ 1376                                               qn: SymTab.Name;
+ 1377                                               sfx: BOOLEAN; .)
+ 1378      = integer                           (. LexString(s);
+ 1379                                             QbeGen.NormInt(s, q);
+ 1380                                             t := SymTab.IntType(); .)
+ 1381      | real                              (. LexString(s);
+ 1382                                             QbeGen.NormReal(s, q);
+ 1383                                             t := SymTab.RealType(); .)
+ 1384      | string                            (. LexString(s);
+ 1385                                             IF SymTab.StrLen(s) = 3 THEN
+ 1386                                               t := SymTab.CharType();
+ 1387                                               QbeGen.IntStr(
+ 1388                                                 QbeGen.CharVal(s), q)
+ 1389                                             ELSE t := SymTab.NewStr();
+ 1390                                               QbeGen.DeclStr(s, q)
+ 1391                                             END; .)
+ 1392      | Design<dt, dk, qd, qn, sfx>       (. t := dt;
+ 1393                                             IF sfx THEN
+ 1394                                               IF dt =
+ 1395                                                  SymTab.InvalidType THEN
+ 1396                                                 QbeGen.CopyOp("0", q)
+ 1397                                               ELSIF (SymTab.ClassOf(dt) =
+ 1398                                                      SymTab.ClRecord)
+ 1399                                                  OR (SymTab.ClassOf(dt) =
+ 1400                                                      SymTab.ClSet)
+ 1401                                                  OR (SymTab.ClassOf(dt) =
+ 1402                                                      SymTab.ClClass) THEN
+ 1403                                                 QbeGen.CopyOp(qd, q)
+ 1404                                               ELSE QbeGen.ElemLoad(qd, dt,
+ 1405                                                 q)
+ 1406                                               END
+ 1407                                             ELSE QbeGen.CopyOp(qd, q)
+ 1408                                             END; .)
+ 1409      | "(" Expr<et, q> ")"               (. t := et; .)
+ 1410      | SetLit<st, sq>                    (. t := st;
+ 1411                                             QbeGen.CopyOp(sq, q); .)
+ 1412      | "NOT" Fact<t2, q2>                (. IF SymTab.BoolCheck(t2) THEN
+ 1413                                               t := SymTab.BoolType()
+ 1414                                             ELSE SemError(212);
+ 1415                                               t := SymTab.InvalidType END;
+ 1416                                             IF t # SymTab.InvalidType THEN
+ 1417                                               QbeGen.NotQ(q2, q)
+ 1418                                             ELSE QbeGen.CopyOp("0", q)
+ 1419                                             END; .) .
+ 1420    (* Set literals are SET OF [0..255] (8 words); elements validated
+ 1421       0..255 statically when foldable (222 otherwise), runtime trap
+ 1422       for computed elements. Ranges always lower via SetRange. *)
+ 1423    SetLit<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
+ 1424      = "{"                               (. t := SymTab.NewSet(
+ 1425                                               SymTab.NewSubR(0, 255));
+ 1426                                             QbeGen.NewSetTemp(8, q);
+ 1427                                             QbeGen.SetZero(q, 8); .)
+ 1428        [ SetElem<t, q> { "," SetElem<t, q> } ]
+ 1429        "}" .
+ 1430    SetElem<st: SymTab.TypeIndex; sq: QbeGen.QVal>         (. VAR et, et2: SymTab.TypeIndex;
+ 1431                                               qe, q2: QbeGen.QVal;
+ 1432                                               v, v2: INTEGER;
+ 1433                                               lo: INTEGER;
+ 1434                                               span: CARDINAL;
+ 1435                                               cl, cl2: INTEGER;
+ 1436                                               hasR: BOOLEAN; .)
+ 1437      =                                   (. hasR := FALSE; .)
+ 1438        Expr<et, qe>
+ 1439        [ ".." Expr<et2, q2>              (. hasR := TRUE; .) ]
+ 1440                                          (. lo := SymTab.SetBaseLo(st);
+ 1441                                             span := SymTab.SetCount(st);
+ 1442                                             IF (et = SymTab.InvalidType)
+ 1443                                                OR (hasR & (et2 =
+ 1444                                                   SymTab.InvalidType)) THEN
+ 1445                                             ELSE cl :=
+ 1446                                                    SymTab.ClassOf(et);
+ 1447                                               IF hasR THEN
+ 1448                                                 cl2 :=
+ 1449                                                   SymTab.ClassOf(et2)
+ 1450                                               ELSE cl2 := SymTab.ClInt
+ 1451                                               END;
+ 1452                                               IF ((cl # SymTab.ClInt)
+ 1453                                                  & (cl # SymTab.ClChar)
+ 1454                                                  & (cl # SymTab.ClBool))
+ 1455                                                  OR (hasR &
+ 1456                                                     ((cl2
+ 1457                                                       # SymTab.ClInt)
+ 1458                                                     & (cl2
+ 1459                                                        # SymTab.ClChar)
+ 1460                                                     & (cl2
+ 1461                                                        # SymTab.ClBool))) THEN
+ 1462                                                 SemError(222)
+ 1463                                               ELSIF hasR
+ 1464                                                  & SymTab.ConstInt(qe, v)
+ 1465                                                  & SymTab.ConstInt(q2,
+ 1466                                                     v2)
+ 1467                                                  & ((v < lo)
+ 1468                                                     OR (v2 < lo)
+ 1469                                                     OR (v >= lo +
+ 1470                                                        VAL(INTEGER, span))
+ 1471                                                     OR (v2 >= lo +
+ 1472                                                        VAL(INTEGER, span))
+ 1473                                                     OR (v > v2)) THEN
+ 1474                                                 SemError(222)
+ 1475                                                ELSIF hasR THEN
+ 1476                                                  QbeGen.SetRange(sq, qe, q2,
+ 1477                                                    lo, span)
+ 1478                                                ELSIF SymTab.ConstInt(qe,
+ 1479                                                        v)
+ 1480                                                   & ((v < lo)
+ 1481                                                      OR (v >= lo +
+ 1482                                                         VAL(INTEGER,
+ 1483                                                           span))) THEN
+ 1484                                                  SemError(222)
+ 1485                                                ELSE QbeGen.SetBit(sq, qe,
+ 1486                                                  lo, span)
+ 1487                                               END
+ 1488                                             END; .) .
+ 1489    GetIdent<VAR n: SymTab.Name>
+ 1490      = ident                             (. LexName(n); .) .
+ 1491  
+ 1492  END M2.
 
     0 errors
 

compiler/tests/t_bad_manydims.mod

@@ -0,0 +1,4 @@
+MODULE TBadManyDims;
+TYPE Big = ARRAY [0..1, 0..1, 0..1, 0..1, 0..1, 0..1, 0..1, 0..1, 0..1] OF INTEGER;
+BEGIN
+END TBadManyDims.

compiler/tests/t_bad_varbound.mod

@@ -0,0 +1,5 @@
+MODULE TBadVarBound;
+VAR lo, hi : INTEGER;
+TYPE Bad = ARRAY [lo..hi] OF INTEGER;
+BEGIN
+END TBadVarBound.

compiler/tests/t_charbounds.mod

@@ -0,0 +1,13 @@
+MODULE TCharBounds;
+// CHAR bounds + CHAR indexing. Exit 3.
+TYPE CArr = ARRAY ['a'..'c'] OF INTEGER;
+VAR ExitCode : INTEGER;
+VAR a : CArr;
+VAR c : CHAR;
+BEGIN
+  a['a'] := 1;
+  a['b'] := 2;
+  a['c'] := 3;
+  c := 'b';
+  ExitCode := a[c] + a['a']
+END TCharBounds.

compiler/tests/t_trap_emptystr.mod

@@ -0,0 +1,7 @@
+MODULE TTrapEmptyStr;
+VAR s : ARRAY [0..2] OF CHAR;
+VAR ExitCode : INTEGER;
+BEGIN
+  s := "";
+  ExitCode := 0
+END TTrapEmptyStr.

docs/summary_step3.7.md

@@ -0,0 +1,48 @@
+# V3 step 3.7 — hardening pass over composites (done 2026-09-22)
+
+Blaise v0.12.0 lesson applied: thin-on-features, fuzz the
+bounds/copies/traps/narrowing paths across the suite before
+step 4 calls. Suite 68/68 (32 run — incl. 4 trap-aborts — +
+36 reject). No new syntax, no new lowering.
+
+## Real bug found and fixed
+
+- **BoundPair outer `IF` missing `END`** (`M2.atg`): the
+  `IF invalid THEN ok := FALSE ELSE ... inner IF ... END;`
+  action never closed the outer `IF`. gm2 only warned
+  (`syntax warning, «END» missing`) and still built, so every
+  green tag since 3.1 carried it. Fixed with one `END`; build
+  is now warning-free (apart from the known-benign Coco
+  TypeBlock LL(1) advisory). Lesson: treat gm2 warnings as
+  errors from here on — add a `grep -i warning` gate before
+  step 4.
+
+## New coverage (4 tests, all previously unexercised paths)
+
+- `t_charbounds` → 3: `ARRAY ['a'..'c']` bounds + `CHAR`
+  variable indexing (BoundPair char path, char index checks).
+- `t_bad_varbound` → 230: non-foldable `ARRAY [lo..hi]`
+  bounds (ConstInt-fail path).
+- `t_bad_manydims` → 230: 9 dimensions (BoundAdd 8-limit,
+  pins the bound as specified behavior).
+- `t_trap_emptystr` → abort: `s := ""` into a 3-char array
+  (pins the equal-count rule for strings — no silent
+  truncation, consistent with `t_trap_count`).
+
+## Verified already-covered (no duplicates added)
+
+Set narrowing trap (`t_trap_setspan`), static 222s, deep-copy
+independence, `WITH` stacking, cross-span copies, opaque
+pointers — all present; audit confirmed no gaps there.
+
+## Incidental
+
+- Removed stray `compiler/src/essai` + `essai.mod` (scratch
+  experiment + linked binary, untracked). Note for its author:
+  the snippet fails only on the trailing `;` before `END`
+  (strict Wirth `StatSeq`, no trailing separator — same rule
+  as step 1); otherwise the two string assigns are fine.
+- Regenerated `src/M2.lst` committed with the fix.
+
+Deferred (unchanged): enum lowering, `HIGH`/`LEN`, recursive
+`DISPOSE`, nil-deref trap, class lowering. Next: step 4 calls.