  (*$p**************************************************************************)
  (*                                                                           *)
  (*                          File: CODE.4.TEXT                                *)
  (*                                                                           *)
  (*              (C) Copyright 1981 Silicon Valley Software, Inc.             *)
  (*                            1983, 1984 Apple Computer, Inc.                *)
  (*                                                                           *)
  (*                            All rights reserved.               2-Dec-82    *)
  (*  2-Dec-82 nil ptr bugs fixed in assignstring and assignalfa               *)
  (* 31-Mar-83 Longint overflow checking in for-loops   A.H.                   *)
  (* 23-Sep-83 Macintosh change (no TST.B on access to string params)          *)
  (* 27-Dec-83 I-code 253 added for special method call sequence               *)
  (* 02-Feb-84 I-code 252 added for inline code                                *)
  (* 03-Mar-84 I-code 251 added for C call                                     *)
  (*****************************************************************************)
  {[j=0/0/80!,@=6,i=1]}
  {$S SEG2}

  PROCEDURE WithStmt;

    VAR
      A: Register;
      lCAttr: CAttr;
      IsPtr, i: Integer;

    BEGIN {IsPtr is used to flag the with P^ do ... end; and with VPRec ( var
           parameter ) do ... end; constructs for which the with statement should
           just be treated as a cosmetic construct}
      i := NextByte; IsPtr := NextByte;
      Expression(NextByte, - 1, False); WithLevel := WithLevel + 1;
      IF (gCAttr.cKind = VARB) AND ((gCAttr.VLev <= 1) OR (gCAttr.VLev =
         ProcLvl)) THEN
        BEGIN
        WithCAttr[WithLevel].Cat := gCAttr;
        WithCAttr[WithLevel].Indirect := IsPtr <> 0;
        END
      ELSE
        BEGIN
        WithCAttr[WithLevel].Indirect := True;
        IF (gCAttr.cKind = EXPR) AND (((gCAttr.ExReg >= D1st) AND
           (gCAttr.ExReg <= Dnth)) OR ((gCAttr.ExReg >= A1st) AND
           (gCAttr.ExReg <= Anth))) THEN
          BEGIN
          WithCAttr[WithLevel].Cat := gCAttr;
          END
        ELSE
          BEGIN
          GetTemp(lCAttr, 4);
          WithCAttr[WithLevel].Cat := lCAttr; A := LoadAddress(gCAttr);
          WITH gCAttr DO
            BEGIN
            cKind := EXPR; ExReg := A;
            END;
          Store(gCAttr, lCAttr, LongOp);
          END;
        END;
    END; {withstmt}

  PROCEDURE Assign1248;

    VAR
      ExReg: Register;
      Flippable: Integer;
      lSize: Integer;
      SaveAttr, lCAttr: CAttr;

    BEGIN
      lSize := Op - 31; Flippable := NextByte;
      IF Flippable <> 0 THEN
        BEGIN
        Expression(NextByte, - 1, False); lCAttr := gCAttr;
        Expression(NextByte, - 1, False); Store(lCAttr, gCAttr, lSize);
        END
      ELSE
        BEGIN
        Expression(NextByte, - 1, False); lCAttr := gCAttr;
        IF lCAttr.cKind = EXPR THEN { optimize those moves to register! }
          BEGIN
          ExReg := lCAttr.ExReg; Expression(NextByte, ExReg, False);
          IF (gCAttr.cKind <> EXPR) OR (ExReg <> gCAttr.ExReg) THEN
            BEGIN
            lCAttr := gCAttr; LoadAOrd(ExReg, lCAttr, lSize);
            END;
          END
        ELSE
          BEGIN
          Expression(NextByte, - 1, False); Store(gCAttr, lCAttr, lSize);
          END;
        END;
    END; {assign1248}

  PROCEDURE AddToSubFrom(fOp: Integer);

    VAR
      lBytes, lSize, lLOp, lOp, iMMValLo, iMMValHi: Integer;
      lCAttr: CAttr;
      lHsReg: Register;
      D: Register;
      AddQuick, iMMFlag, FreeLhs, FreeDFlag: Boolean;

    BEGIN
      lBytes := NextByte; iMMFlag := False; FreeDFlag := False;
      FreeLhs := False;
      IF lBytes = 2 THEN
        lSize := WordOp
      ELSE
        lSize := LongOp;
      Expression(NextByte, - 1, False); lCAttr := gCAttr;
      Expression(NextByte, - 1, False);

      {optimize  ADDI.L #d,<ea> to MOVEQ #d,Di
                                   ADD.L Di,<ea> where -128 <= d <= 127}

      IF gCAttr.cKind = CNST THEN
        WITH gCAttr.CValu DO
          BEGIN
          AddQuick := (IValu[1] > 0) AND (IValu[0] = 0) AND (IValu[1] <= 8);
          IF ((lSize = LongOp) AND IsQuickCnst(gCAttr.CValu)) AND
             (NOT AddQuick) THEN
            BEGIN
            D := LoadInt(IValu[0], IValu[1], LongOp);
            gCAttr.cKind := EXPR;
            gCAttr.ExReg := D;
            END;
          END;
      IF gCAttr.cKind = CNST THEN
        BEGIN
        IF AddQuick THEN
          BEGIN
          IF fOp = 41 {ADDTO} THEN
            lOp := $5040 { ADDQ.W }
          ELSE
            lOp := $5140; { SUBQ.W }
          lOp := lOp + (gCAttr.CValu.IValu[1] MOD 8) * 512;
          END
        ELSE IF lCAttr.cKind = EXPR THEN { LHS is a register }
          BEGIN
          IF fOp = 41 {ADDTO} THEN
            lOp := $D000 { ADD }
          ELSE
            lOp := $9000; {SUB}
          FreeLhs := True; lHsReg := lCAttr.ExReg; lCAttr := gCAttr;
          IF lHsReg <= D7 THEN
            BEGIN { ADD/SUB.W/L <ea>,D }
            lOp := lOp + ($40 + lHsReg * 512);
            IF lSize = LongOp THEN lOp := lOp + $40; { .L }
            END
          ELSE
            BEGIN { ADDA/SUBA.W <ea>,A }
            lOp := lOp + ($C0 + (lHsReg - 8) * 512);
            IF lSize = LongOp THEN
              IF (gCAttr.CValu.IValu[0] = 0) OR (gCAttr.CValu.IValu[0] = - 1) THEN
                lSize := WordOp
              ELSE
                lOp := lOp + $100; { .L }
            END;
          END
        ELSE { lhs a variable }
          BEGIN
          IF fOp = 41 {ADDTO} THEN
            lOp := $640 { ADDI.W }
          ELSE
            lOp := $440; { SUBI.W }
          iMMFlag := True;
          iMMValLo := gCAttr.CValu.IValu[1];
          iMMValHi := gCAttr.CValu.IValu[0];
          END
        END
      ELSE
        BEGIN
        IF lCAttr.cKind = EXPR THEN { LHS is a register }
          BEGIN
          IF fOp = 41 {ADDTO} THEN
            lOp := $D000 { ADD }
          ELSE
            lOp := $9000; {SUB}
          FreeLhs := True; lHsReg := lCAttr.ExReg; lCAttr := gCAttr;
          IF lHsReg <= D7 THEN
            BEGIN { ADD/SUB.W/L <ea>,D }
            lOp := lOp + ($40 + lHsReg * 512);
            IF lSize = LongOp THEN lOp := lOp + $40; { .L }
            END
          ELSE
            BEGIN { ADDA/SUBA.W <ea>,A }
            lOp := lOp + ($C0 + (lHsReg - 8) * 512);
            IF lSize = LongOp THEN lOp := lOp + $100; { .L }
            END;
          END
        ELSE { lhs a variable }
          BEGIN
          FreeDFlag := True;
          D := LoadD(gCAttr, lSize, False);
          IF fOp = 41 {ADDTO} THEN
            lOp := $D140 { ADD.W D,<ea> }
          ELSE
            lOp := $9140; { SUB.W D,<ea> }
          lOp := lOp + D * 512;
          END;
        END;
      IF (lSize = LongOp) AND NOT FreeLhs THEN lOp := lOp + 64;
      GenEffAddr(lOp, lCAttr, lSize, iMMFlag, iMMValHi, iMMValLo);
      IF FreeDFlag THEN FreeReg(D);
      IF FreeLhs THEN FreeReg(lHsReg);
    END; {addtosubfrom}

  PROCEDURE CopyLong(VAR FromCAttr, TocAttr: CAttr; fBytes: Integer;
                     Tst: Boolean);

    VAR
      lWords: Integer;
      A, A2: Register;
      D: Register;

    BEGIN
      A := LoadAddress(TocAttr); A2 := LoadAddress(FromCAttr);
      CheckClobber(A); CheckClobber(A2);
      IF Tst THEN
        IF NOT MacFlag THEN
          BEGIN
          GenR($4A10, A2); { TST.B (a) }
          END;
      lWords := fBytes DIV 2;
      IF lWords <= 8 THEN
        WHILE lWords >= 2 DO
          BEGIN
          GenRR($20D8, A, A2); { MOVE.L (A2)+,(A)+ }
          lWords := lWords - 2;
          END
      ELSE
        BEGIN
        D := LoadInt(0, lWords DIV 2, WordOp);
        GenRR($20D8, A, A2); { MOVE.L (A2)+,(A)+ }
        GenR($5340, D); { SUBQ.W #1,D }
        Gen($6EFA); { BGT $-6 }
        FreeReg(D); lWords := lWords MOD 2;
        END;
      IF lWords > 0 THEN GenRR($3090, A, A2); { MOVE.W (A2),(A) }
      FreeReg(A); FreeReg(A2);
    END; {copylong}

  PROCEDURE AssignLong(fBytes: Integer; Tst: Boolean);

    VAR
      lCAttr: CAttr;

    BEGIN
      Expression(NextByte, - 1, False); lCAttr := gCAttr;
      Expression(NextByte, - 1, False);
      CopyLong(gCAttr, lCAttr, fBytes, Tst);
    END; {assignlong}

  PROCEDURE AssignSet;

    VAR
      SetSize, lSize: Integer;
      lCAttr: CAttr;
      OnStack: Boolean;
      A: Register;
      D: Register;

    BEGIN
      SetSize := NextByte; Expression(NextByte, - 1, False); lCAttr := gCAttr;
      SetExpression(NextByte, OnStack);
      IF OnStack THEN
        BEGIN
        Gen($548F); { ADDQ.L #2,SP }
        IF SetSize = 1 THEN
          BEGIN
          D := GetReg(Dlow, Dhigh);
          GenR($301F, D); { MOVE.W (SP)+,d }
          gCAttr.cKind := EXPR; gCAttr.ExReg := D;
          Store(gCAttr, lCAttr, ByteOp);
          END
        ELSE IF SetSize <= 4 THEN
          BEGIN
          gCAttr.cKind := STCK;
          IF SetSize <= 2 THEN
            lSize := WordOp
          ELSE
            lSize := LongOp;
          Store(gCAttr, lCAttr, lSize);
          END
        ELSE
          BEGIN
          A := LoadAddress(lCAttr);
          CheckClobber(A);
          D := LoadInt(0, SetSize DIV 2, WordOp);
          GenRR($30DF, A, 0); { MOVE.W (SP)+,(A)+ }
          GenR($5340, D); { SUBQ.W #1,D }
          Gen($6EFA); { BGT $-6 }
          FreeReg(A); FreeReg(D);
          END;
        END
      ELSE { not OnStack }
      IF SetSize > 4 THEN
        BEGIN
        IF gCAttr.cKind = CNST THEN gCAttr.CValu.FrontAddress := True;
        CopyLong(gCAttr, lCAttr, SetSize, False);
        END
      ELSE
        BEGIN
        IF SetSize = 1 THEN
          lSize := ByteOp
        ELSE IF SetSize = 2 THEN
          lSize := WordOp
        ELSE
          lSize := LongOp;
        IF gCAttr.cKind = CNST THEN MakeSetConst(gCAttr);
        Store(gCAttr, lCAttr, lSize);
        END;
    END; {assignset}

  PROCEDURE AssignPacked;

    VAR
      lOp, mOp, NumBits, rightbit, DataMask, i, Lo, ShiftCount, AddrMask: Integer;
      lCAttr: CAttr;
      Signed, ShortFlag, AddFlag: Boolean;
      D, D2, D3: Register;
      A: Register;
      lOffset, Bit, lValue: Integer;

    BEGIN
      lOp := NextByte;
      IF lOp = 21 {PCKDARR} THEN
        BEGIN
        AddFlag := False; NumBits := NextByte; Lo := NextWord;
        Expression(NextByte, - 1, False); lCAttr := gCAttr;
        Expression(NextByte, - 1, False);
        D := LoadD(gCAttr, WordOp, False); CheckClobber(D);
        WITH lCAttr DO
          CASE cKind OF
            ADDR: BEGIN
                  A := AdReg; lOffset := AOffset; cKind := INDX;
                  InOffset := lOffset; InxRReg := D; InxAReg := A;
                  LongIndex := False;
                  END;
            INDX: AddFlag := True;
            VARB: IF VLev < 0 THEN
                    BEGIN
                    InxAReg := LoadAddress(lCAttr); cKind := INDX;
                    InxRReg := D; LongIndex := False; InOffset := 0;
                    END
                  ELSE
                    BEGIN
                    lOffset := VOffset; A := GetBase(VLev);
                    cKind := INDX; InxAReg := A; InxRReg := D;
                    InOffset := lOffset; LongIndex := False;
                    END;
          END; {case}
        Expression(NextByte, - 1, False);
        IF NumBits = 8 THEN
          BEGIN
          IF AddFlag THEN
            WITH lCAttr DO
              BEGIN
              GenRR($D040, D, InxRReg); { ADD.W inxrreg,D }
              FreeReg(InxRReg); InxRReg := D;
              END;
          IncOffset(lCAttr, - Lo); Store(gCAttr, lCAttr, ByteOp);
          END
        ELSE
          BEGIN
          D3 := LoadD(gCAttr, ByteOp, False); CheckClobber(D3);
          IF Lo <> 0 THEN
            IF Abs(Lo) <= 8 THEN
              IF Lo > 0 THEN
                GenRR($5140, Lo, D) { SUBQ.W #lo,D }
              ELSE
                GenRR($5040, - Lo, D) { ADDQ.W #-lo,D }
            ELSE
              BEGIN
              GenR($440, D); Gen(Lo); { SUBI.W #lo,D }
              END;
          DataMask := 0;
          FOR i := 1 TO NumBits DO DataMask := DataMask * 2 + 1;
          ShiftCount := 0;
          WHILE NumBits < 8 DO
            BEGIN
            NumBits := NumBits * 2; ShiftCount := ShiftCount + 1;
            END;
          AddrMask := 0;
          FOR i := 1 TO ShiftCount DO AddrMask := AddrMask * 2 + 1;
          GenR($240, D3); Gen(DataMask); { ANDI.W #datamask,D3 }
          D2 := GetReg(Dlow, Dhigh); GenRR($3000, D2, D); { MOVE.W D,D2 }
          GenR($240, D2); Gen(AddrMask); { ANDI.W #addrmask,D2 }
          IF ShiftCount < 3 THEN GenRR($E148, 3 - ShiftCount, D2); { LSL.W #3-sc,D2 }
          GenRR($E048, ShiftCount, D); { LSR.W #sc,D }
          IF AddFlag THEN
            WITH lCAttr DO
              BEGIN
              CheckClobber(D);
              GenRR($D040, D, InxRReg); { ADD.W inxrreg,D }
              FreeReg(InxRReg); InxRReg := D;
              END;
          A := LoadAddress(lCAttr);
          D := LoadInt( - 1, - DataMask - 1, ByteOp); { MOVEQ #~datamask,D }
          GenRR($E138, D2, D); { ROL.B D2,D }
          GenRR($E128, D2, D3); { LSL.B D2,D3 }
          GenRR($C110, D, A); { AND.B D,(A) }
          GenRR($8110, D3, A); { OR.B D3,(A) }
          FreeReg(A); FreeReg(D2); FreeReg(D3); FreeReg(D);
          END;
        END
      ELSE
        BEGIN {62 = UPCKFLD, 63 = SPCKFLD}
        rightbit := NextByte; NumBits := rightbit DIV 16;
        rightbit := rightbit MOD 16;
        DataMask := 0;
        FOR i := 1 TO NumBits DO DataMask := DataMask * 2 + 1;
        Expression(NextByte, - 1, False); lCAttr := gCAttr;
        Expression(NextByte, - 1, False);
        IF ((rightbit = 8) OR (rightbit = 0)) AND (NumBits = 8) THEN
          BEGIN
          IF rightbit = 0 THEN IncOffset(lCAttr, 1);
          CASE gCAttr.cKind OF
            EXPR, ADDR, INDX, VARB:
                  IncOffset(gCAttr, 1);
            OTHERWISE
                  D := LoadD(gCAttr, WordOp, False);
          END;
          Store(gCAttr, lCAttr, ByteOp);
          END
        ELSE
          BEGIN
          IF gCAttr.cKind = CNST THEN
            BEGIN
            Bit := 1;
            FOR i := 1 TO NumBits DO Bit := Bit + Bit;
            lValue := gCAttr.CValu.IValu[1];
            IF lValue >= 0 THEN
              lValue := lValue MOD Bit
            ELSE
              lValue := lValue + Bit;
            FOR i := 1 TO rightbit DO
              BEGIN
              lValue := lValue + lValue;
              DataMask := DataMask + DataMask;
              END;
            IF lValue = 0 THEN
              BEGIN { ANDI.W #~dm,ea }
              IF lCAttr.cKind = EXPR THEN CheckClobber(lCAttr.ExReg);
              GenEffAddr($240, lCAttr, WordOp, True, 0, - DataMask - 1)
              END
            ELSE
              BEGIN
              A := LoadAddress(lCAttr);
              GenR($250, A); Gen( - DataMask - 1); { ANDI.W #~dm,(A) }
              GenR($50, A); Gen(lValue); { ORI.W #lval,(A) }
              FreeReg(A);
              END;
            END
          ELSE
            BEGIN
            IF EMITDEPOSIT THEN
              BEGIN
              PushAddress(lCAttr); D := LoadD(gCAttr, WordOp, False);
              Gen($A080 + (NumBits MOD 16) * $100 + D * $10 + rightbit);
              FreeReg(D);
              END
            ELSE
              BEGIN
              IF rightbit > 7 THEN
                BEGIN
                rightbit := rightbit - 8; ShortFlag := True;
                mOp := $210; { ANDI.B #x,(A) }
                lOp := $8110; { OR.B D,(A) }
                END
              ELSE
                BEGIN
                ShortFlag := False;
                lOp := $8150; { OR.W D,(A) }
                mOp := $250; { ANDI.W #x,(A) }
                END;
              A := LoadAddress(lCAttr); D := LoadD(gCAttr, WordOp, False);
              CheckClobber(D);
              GenR($240, D); Gen(DataMask); { ANDI.W #mask,D }
              IF rightbit > 0 THEN GenRR($E148, rightbit, D); { LSL.W #rb,D }
              FOR i := 1 TO rightbit DO DataMask := DataMask * 2;
              GenR(mOp, A); Gen( - DataMask - 1); { ANDI.? #~dm,(A) }
              GenRR(lOp, D, A); { OR.? D,(A) }
              FreeReg(D); FreeReg(A);
              END;
            END;
          END;
        END;
    END; {assignpacked}

  PROCEDURE AssignString;

    VAR
      lBytes, lSize: Integer;
      lCAttr: CAttr;
      lStr: Alfa8;

    BEGIN
      lBytes := NextByte;
      IF lBytes > 3 THEN
        BEGIN
        lBytes := lBytes + 1;
        IF Odd(lBytes) THEN lBytes := lBytes + 1;
        AssignLong(lBytes, False);
        END
      ELSE
        BEGIN
        Expression(NextByte, - 1, False); lCAttr := gCAttr;
        Expression(NextByte, - 1, False);
        IF lBytes = 0 THEN
          lSize := ByteOp
        ELSE IF lBytes = 1 THEN
          lSize := WordOp
        ELSE
          lSize := LongOp;
        IF gCAttr.cKind = CNST THEN
          BEGIN
          IF gCAttr.CValu.StrValu <> NIL THEN
            lStr := gCAttr.CValu.StrValu^.StrVal;
          gCAttr.CValu.CstKind := SCALCNST; gCAttr.CValu.IValu[1] := 0;
          IF lBytes > 0 THEN
            BEGIN
            gCAttr.CValu.IValu[1] := lBytes * 256 + Ord(lStr[1]);
            IF lBytes > 1 THEN
              BEGIN
              gCAttr.CValu.IValu[0] := gCAttr.CValu.IValu[1];
              gCAttr.CValu.IValu[1] := Ord(lStr[2]) * 256 + Ord(lStr[3]);
              END;
            END;
          END;
        Store(gCAttr, lCAttr, lSize);
        END;
    END; {assignstring}

  PROCEDURE AssignAlfa;

    VAR
      lBytes, lSize, mBytes: Integer;
      lCAttr: CAttr;
      lStr: Alfa8;

    BEGIN
      lBytes := NextByte; mBytes := NextByte;
      IF lBytes <> mBytes THEN CodError(2010);
      IF lBytes > 4 THEN
        BEGIN
        IF Odd(lBytes) THEN lBytes := lBytes + 1;
        AssignLong(lBytes, False);
        END
      ELSE
        BEGIN
        Expression(NextByte, - 1, False); lCAttr := gCAttr;
        Expression(NextByte, - 1, False);
        IF lBytes = 1 THEN
          lSize := ByteOp
        ELSE IF lBytes = 2 THEN
          lSize := WordOp
        ELSE
          lSize := LongOp;
        IF gCAttr.cKind = CNST THEN
          BEGIN
          IF gCAttr.CValu.StrValu <> NIL THEN
            lStr := gCAttr.CValu.StrValu^.StrVal;
          gCAttr.CValu.CstKind := SCALCNST; gCAttr.CValu.IValu[1] := 0;
          gCAttr.CValu.IValu[1] := Ord(lStr[1]) * 256 + Ord(lStr[2]);
          IF lBytes > 2 THEN
            BEGIN
            gCAttr.CValu.IValu[0] := gCAttr.CValu.IValu[1];
            gCAttr.CValu.IValu[1] := Ord(lStr[3]) * 256 + Ord(lStr[4]);
            END;
          END;
        Store(gCAttr, lCAttr, lSize);
        END;
    END; {assignalfa}

  PROCEDURE StdProcCall;

    VAR
      lOp: Integer;
      D: Register;

    BEGIN
      lOp := NextByte;
      IF lOp < 100 THEN
        CASE lOp OF
          001:  GenJSR('%_NEW   ');
          002:  GenJSR('%_MARK  ');
          003:  GenJSR('%_RELSE ');
          004:  GenJSR('%_GET   ');
          005:  GenJSR('%_PUT   ');
          006:  GenJSR('%_RESET ');
          007:  GenJSR('%_REWRT ');
          012:  GenJSR('%_PAGE  ');
          015:  GenJSR('%_CLOSE ');
          016:  GenJSR('%_DEL   ');
          017:  GenJSR('%_INS   ');
          018:  GenJSR('%_UREAD ');
          019:  GenJSR('%_UWRIT ');
          020:  GenJSR('%_SEEK  ');
          021:  GenJSR('%_HALT  ');
          022:  GenJSR('%_MOVEL ');
          023:  GenJSR('%_MOVER ');
          024:  GenJSR('%_FILLC ');
          025:  GenJSR('%_UCLR  ');
          026:  GenJSR('%_GOTOXY');
          027:  GenJSR('%_DISP  ');
          028:  GenJSR('%_UNITST');
        END {case}
      ELSE
        CASE lOp OF
          100:  GenJSR('%W_C    ');
          101:  GenJSR('%W_B    ');
          102:  GenJSR('%W_I    ');
          103:  GenJSR('%W_E    ');
          104:  GenJSR('%W_F    ');
          105:  GenJSR('%W_STR  ');
          106:  GenJSR('%W_PAOC ');
          107:  GenJSR('%W_LN   ');
          110:  GenJSR('%R_C    ');
          111:  GenJSR('%R_I    ');
          112:  GenJSR('%R_R    ');
          113:  GenJSR('%R_STR  ');
          114:  GenJSR('%R_PAOC ');
          115:  GenJSR('%R_LN   ');
        END; {case}
      IF (lOp >= 110) AND (lOp <= 112) THEN
        BEGIN
        gCAttr.cKind := STCK;
        IF lOp = 110 THEN
          BEGIN
          D := GetReg(Dlow, Dhigh);
          GenR($4240, D); { CLR.W D }
          GenRR($101F, D, 0); { MOVE.B (SP)+,D }
          gCAttr.cKind := EXPR; gCAttr.ExReg := D;
          END;
        END;
    END; {stdproccall}

  PROCEDURE StdFuncCall;

    VAR
      lOp: Integer;

    BEGIN
      lOp := NextByte;
      CASE lOp OF                                                              {!}{[f-]}
      (*01: { ABS } *)
        02:   GenJSR('%_ATAN  ');
      (*03: { CHR } *)
        04:   GenJSR('%_COS   ');
        05:   GenJSR('%_EOF   ');
        06:   GenJSR('%_EOLN  ');
        07:   GenJSR('%_EXP   ');
        08:   GenJSR('%_LN    ');
      (*09: { ODD } *)
      (*10: { ORD } *)
      (*11: { PRED } *)
        12:   GenJSR('%_ROUND ');
        13:   GenJSR('%_SIN   ');
      (*14: { SQR } *)
        15:   GenJSR('%_SQRT  ');
      (*16: { SUCC } *)
        17:   GenJSR('%_TRUNC ');
      (*18: { POINTER } *)
      (*19: { LENGTH } *)
        20:   GenJSR('%_POS   ');
        21, { CONCAT }
        22: { COPY}
              BEGIN
              IF lOp = 21 THEN
                GenJSR('%_CAT   ')
              ELSE
                GenJSR('%_COPY  ');
              Expression(NextByte, - 1, False);
              FCAllInfo[FCAllLevel].OnStack := False;
              END;
        23:   GenJSR('%_BLKRD ');
        24:   GenJSR('%_BLKWR ');
        25:   GenJSR('%_IORES ');
      (*26: { SIZEOF } *)
        27:   GenJSR('%_PWR10 ');
        28:   GenJSR('%_SCANE ');
        29:   GenJSR('%_SCANN ');
        30:   GenJSR('%_UBUSY ');
        31:   GenJSR('%_MEMAV ');
      (*32: { ORD4 } *)
        33:   GenJSR('%_HEAPRE');
        34:   GenJSR('%_KEYPRE');
      END; {case}                                                              {!}{[f+]}
      IF lOp IN [2, 4..8, 12, 13, 15, 17, 20, 23..25, 27..31, 33, 34] THEN
        gCAttr.cKind := STCK;
    END; {stdfunccall}

  PROCEDURE JumpILabel;

    VAR
      lOp, lLab: Integer;
      D: Register;

    BEGIN
      lOp := Op; lLab := NextWord;
      IF lOp = 193 {JUMP} THEN
        lOp := $6000
      ELSE
        BEGIN
        Expression(NextByte, - 1, False);
        IF lOp = 194 THEN
          IF gCAttr.cKind = COND {FJUMP}
             THEN
            CASE gCAttr.CC OF
              LT:   lOp := $6C00; {BGE}
              LE:   lOp := $6E00; {BGT}
              GT:   lOp := $6F00; {BLE}
              GE:   lOp := $6D00; {BLT}
              EQ:   lOp := $6600; {BNE}
              NE:   lOp := $6700; {BEQ}
              HI:   lOp := $6300; {BLS}
              LS:   lOp := $6200; {BHI}
            END {case}
          ELSE
            BEGIN
            IF gCAttr.cKind = BOOL THEN
              D := gCAttr.ExReg
            ELSE
              D := LoadD(gCAttr, ByteOp, True);
            FreeReg(D); lOp := $6700; {BEQ}
            END
        ELSE IF gCAttr.cKind = COND THEN {TJUMP}
          CASE gCAttr.CC OF
            LT:   lOp := $6D00; {BLT}
            LE:   lOp := $6F00; {BLE}
            GT:   lOp := $6E00; {BGT}
            GE:   lOp := $6C00; {BGE}
            EQ:   lOp := $6700; {BEQ}
            NE:   lOp := $6600; {BNE}
            HI:   lOp := $6200; {BHI}
            LS:   lOp := $6300; {BLS}
          END {case}
        ELSE
          BEGIN
          IF gCAttr.cKind = BOOL THEN
            D := gCAttr.ExReg
          ELSE
            D := LoadD(gCAttr, ByteOp, True);
          FreeReg(D); lOp := $6600; {BNE}
          END
        END;
      GenJump(lOp, lLab);
    END; {jumpilabel}

  PROCEDURE GenCall;

    VAR
      N, lSize, lOp, SetSize, lRegMask: Integer;
      Base, A, D: Register;
      ExitFlag, OnStack, Funct: Boolean;
      lCAttr: CAttr;

    PROCEDURE FctEnd;

      VAR
        D: Register;

      BEGIN
        WITH FCAllInfo[FCAllLevel] DO
          BEGIN
          IF OnStack THEN
            IF RegMask = 0 THEN
              gCAttr.cKind := STCK
            ELSE
              BEGIN
              D := GetReg(Dlow, Dhigh);
              IF Size = 1 THEN
                GenRR($101F, D, 0) { MOVE.B (SP)+,D }
              ELSE IF Size = 2 THEN
                GenRR($301F, D, 0) { MOVE.W (SP)+,D }
              ELSE
                GenRR($201F, D, 0); { MOVE.L (SP)+,D }
              gCAttr.cKind := EXPR; gCAttr.ExReg := D;
              END;
          IF RegMask <> 0 THEN RestoreRegs(RegMask);
          END;
        FCAllLevel := FCAllLevel - 1;
      END; {fctend}

    BEGIN {gencall}
      ExitFlag := False;
      REPEAT
        Op := NextByte;
        CASE Op OF
          176, { UFCALL }
          177: { UPCALL }
                BEGIN
                N := NextWord;
                WITH UserProcs[N]^ DO
                  BEGIN
                  IF PFLev > 2 THEN
                    IF PFLev = ProcLvl + 1 THEN
                      Gen($2F0E) { MOVE.L A6,-(SP) }
                    ELSE
                      BEGIN
                      Base := GetBase(PFLev); FreeReg(Base);
                      GenR($2F28, Base); Gen(8); {MOVE.L 8(base),-(SP)}
                      END;
                  GenJSR(LinkName);
                  END;
                IF Op = 176 {UFCTCALL} THEN FctEnd;
                ExitFlag := True;
                END;
          178: { SFCALL }
                BEGIN
                StdFuncCall;
                FctEnd;
                ExitFlag := True;
                END;
          179: { SPCALL }
                BEGIN
                StdProcCall;
                ExitFlag := True;
                END;
          180, { PFCALL }
          181: { PPCALL }
                BEGIN
                Expression(NextByte, - 1, False);
                A := LoadAddress(gCAttr);
                CheckClobber(A);
                D := GetReg(Dlow, Dhigh);
                GenRR($2018, A, D); { MOVE.L (A)+,D }
                Gen(26370); { BEQ.S $+4 }
                GenR($2F00, D); { MOVE.L D,-(SP) }
                GenRR($2050, A, A); { MOVE.L (A),A }
                GenR($4E90, A); { JSR (A) }
                FreeReg(A); FreeReg(D);
                IF Op = 180 {UFCTCALL}
                   THEN
                  FctEnd;
                ExitFlag := True;
                END;
          182: { FCTRSLT }
                BEGIN
                N := NextByte;
                FCAllLevel := FCAllLevel + 1;
                WITH FCAllInfo[FCAllLevel] DO
                  BEGIN
                  Size := N MOD 16; RegMask := SaveRegs; OnStack := True;
                  END;
                IF (N > 0) AND (N < 16) THEN
                  IF N <= 2 THEN
                    Gen($4267) { CLR.W -(SP) }
                  ELSE
                    Gen($42A7); { CLR.L -(SP) }
                END;
          183, { REFPARM }
          188: { VPRMBIG }
                BEGIN
                IF Op = 188 { VPARMBIG } THEN lSize := NextWord;
                lOp := NextByte;
                IF lOp = 12 {UPARROW}
                   THEN
                  BEGIN
                  Expression(NextByte, - 1, False); PushValue(gCAttr, LongOp);
                  END
                ELSE
                  BEGIN
                  Expression(lOp, - 1, False); PushAddress(gCAttr);
                  END;
                END; {refparam}
          184, { VPARM1 }
          185, { VPARM2 }
          186, { VPARM4 }
          187: { VPARM8 }
                BEGIN
                lSize := Op - 183; Expression(NextByte, - 1, False);
                PushValue(gCAttr, lSize);
                END;
          189: { SETVPRM }
                BEGIN
                SetSize := NextByte; SetExpression(NextByte, OnStack);
                IF NOT OnStack THEN
                  PushSet(gCAttr, SetSize, False)
                ELSE
                  Gen($548F); { ADDQ.L #2,SP }
                END;
          190: { BEGCALL }
                GenCall;
          191: { PFPARM }
                BEGIN
                N := NextWord;
                WITH UserProcs[N]^ DO
                  BEGIN
                  GlobRef(LinkName, UserName, Ic + 2);
                  IF ShortCalls THEN
                    Gen($487A) { PEA $+xxx }
                  ELSE
                    BEGIN
                    Gen($4879); Gen(0); { PEA xxx.L }
                    END;
                  Gen(0);
                  IF PFLev > 2 THEN
                    IF PFLev = ProcLvl + 1 THEN
                      Gen($2F0E) { MOVE.L A6,-(SP) }
                    ELSE
                      BEGIN
                      Base := GetBase(PFLev); FreeReg(Base);
                      GenR($2F28, Base); Gen(8); { MOVE.L 8(base),-(SP) }
                      END
                  ELSE
                    Gen($42A7); { CLR.L -(SP) }
                  END;
                END;
          241: { EXTREF }
                BEGIN
                ExtRef;         { The front end was fixed so that this   }
                CodError(2007); { only appears at the statement proclvl! }
                END;
          251: { CCALL }                                                       {!03-29-84}
                BEGIN                                                          {!03-29-84}
                lRegMask := SaveRegs;                                          {!03-29-84}
                lSize := NextByte;                                             {!03-29-84}
                GenJSR(UserProcs[NextWord]^.LinkName);                         {!03-29-84}
                N := NextWord;                                                 {!03-29-84}
                IF N <= 8 THEN                                                 {!03-29-84}
                  GenRR($508F, N MOD 8, 0) {ADDQ.L #N,SP}                      {!03-29-84}
                ELSE                                                           {!03-29-84}
                  BEGIN                                                        {!03-29-84}
                  Gen($4FEF); Gen(N); {LEA  #N(SP),SP}                         {!03-29-84}
                  END;                                                         {!03-29-84}
                IF lSize > 0 THEN                                              {!03-29-84}
                  BEGIN                                                        {!03-29-84}
                  IF lSize = 4 THEN                                            {!03-29-84}
                    BEGIN {integer funct result returned in D0}                {!03-29-84}
                    D := GetReg(Dlow, Dhigh);                                  {!03-29-84}
                    IF D <> D0 THEN GenRR($2000, D, D0); { MOVE.L D0,D }       {!03-29-84}
                    gCAttr.cKind := EXPR; gCAttr.ExReg := D;                   {!03-29-84}
                    END                                                        {!03-29-84}
                  ELSE                                                         {!03-29-84}
                    BEGIN {real funct result returned in D0, D1}               {!03-29-84}
                    IF NOT HaveExtTmp THEN                                     {!03-29-84}
                      BEGIN {allocate an extended real temp for conversions}   {!03-29-84}
                      GetTemp(ExtTmp, 10); HaveExtTmp := True;                 {!03-29-84}
                      END; {this is done once per procedure}                   {!03-29-84}
                    IF NOT HaveDblTmp THEN                                     {!03-29-84}
                      BEGIN {allocate one dbl real temp for conversion}        {!03-29-84}
                      GetTemp(DblTmp, 8); HaveDblTmp := True;                  {!03-29-84}
                      END; {need only one per proc}                            {!03-29-84}
                    IF DblTmp.VLev <= 1 THEN                                   {!03-29-84}
                      lOp := $2B40 { MOVE.L D0,DblTmp(A5) }                    {!03-29-84}
                    ELSE                                                       {!03-29-84}
                      lOp := $2D40; { MOVE.L D0,DblTmp(A6) }                   {!03-29-84}
                    Gen(lOp); Gen(DblTmp.VOffset);                             {!03-29-84}
                    Gen(lOp + 1);                                              {!03-29-84}
                    Gen(DblTmp.VOffset + 4); { MOVE.L D1,DblTmp+4(A5 or A6) }  {!03-29-84}
                    PushAddress(DblTmp);                                       {!03-29-84}
                    PushAddress(ExtTmp);                                       {!03-29-84}
                    Gen($3F3C); Gen($080E); { MOVE.W #FFDBL+FOZ2X,-(SP) ; real to ext}
                    IF MacFlag THEN                                            {!03-29-84}
                      Gen($A9EB) { _FP68K trap }                               {!03-29-84}
                    ELSE                                                       {!03-29-84}
                      GenJSR('FP68K   ');                                      {!03-29-84}
                    GetTemp(lCAttr, 4);                                        {!03-29-84}
                    PushAddress(ExtTmp);                                       {!03-29-84}
                    PushAddress(lCattr);                                       {!03-29-84}
                    Gen($3F3C); Gen($1010); { MOVE.W #FFSGL+FOX2Z,-(SP) ; ext to dbl }
                    IF MacFlag THEN                                            {!03-29-84}
                      Gen($A9EB) { _FP68K trap }                               {!03-29-84}
                    ELSE                                                       {!03-29-84}
                      GenJSR('FP68K   ');                                      {!03-29-84}
                    gCAttr := lCAttr; {leave result in 4-byte temp}            {!03-29-84}
                    END;                                                       {!03-29-84}
                  END;                                                         {!03-29-84}
                IF lRegMask <> 0 THEN RestoreRegs(lRegMask);                   {!03-29-84}
                ExitFlag := True;                                              {!03-29-84}
                END;                                                           {!03-29-84}
          252: { INLINE }                                                      {!02-06-84}
                BEGIN                                                          {!02-06-84}
                Funct := (NextByte = 1);                                       {!02-06-84}
                FOR N := 1 TO NextWord DO                                      {!02-06-84}
                  BEGIN                                                        {!02-06-84}
                  Gen(NextWord);                                               {!02-06-84}
                  pLineNumber^[CurrCode] := - LNum; {==> Inline}               {!02-06-84}
                  END;                                                         {!02-06-84}
                IF Funct THEN FctEnd;                                          {!02-06-84}
                ExitFlag := True;                                              {!02-06-84}
                END;                                                           {!02-06-84}
          253: { METHCALL }                                                    {!C 12-27-83}
                BEGIN                                                          {!C 12-27-83}
                Funct := (NextByte = 1);                                       {!C 12-27-83}
                GenR($4E90, A5);                                               {!C 12-27-83}
                Gen(NextWord);                                                 {!C 12-27-83}
                IF Funct THEN FctEnd;                                          {!C 12-27-83}
                ExitFlag := True;                                              {!C 12-27-83}
                END;                                                           {!C 12-27-83}
        END; {case}
      UNTIL ExitFlag;
    END; {gencall}

  PROCEDURE StmtList(EndOp: Integer);
    FORWARD;

  PROCEDURE ForStmt;

    VAR
      VarCAttr, StepCAttr, LimitCAttr, InitCAttr: CAttr;
      N, lSize, TopLabel, BottomLabel, ExitLabel, lOp: Integer;
      OverFlag: Boolean;

    BEGIN
      N := NextByte;
      IF N = 1 THEN
        lSize := ByteOp
      ELSE IF N = 2 THEN
        lSize := WordOp
      ELSE
        lSize := LongOp;
      Expression(NextByte, - 1, False); VarCAttr := gCAttr;
      Expression(NextByte, - 1, False); InitCAttr := gCAttr;
      Expression(NextByte, - 1, False);
      IF gCAttr.cKind = CNST THEN
        LimitCAttr := gCAttr
      ELSE
        BEGIN
        GetTemp(LimitCAttr, N); Store(gCAttr, LimitCAttr, lSize);
        END;
      Expression(NextByte, - 1, False);
      IF gCAttr.cKind = CNST THEN
        StepCAttr := gCAttr
      ELSE
        BEGIN
        GetTemp(StepCAttr, N); Store(gCAttr, StepCAttr, lSize);
        END;
      Store(InitCAttr, VarCAttr, lSize);
      TopLabel := NewLabel; BottomLabel := NewLabel; ExitLabel := NewLabel;
      GenJump($6000, BottomLabel);
      DefILabel(TopLabel);
      StmtList(203 {FOREND} );
      IF StepCAttr.cKind = CNST THEN
        BEGIN
        IF StepCAttr.CValu.IValu[1] > 0 THEN
          lOp := $5200 { ADDQ }
        ELSE
          lOp := $5300; { SUBQ }
        IF lSize = WordOp THEN
          lOp := lOp + 64
        ELSE IF lSize = LongOp THEN lOp := lOp + 128;
        GenEffAddr(lOp, VarCAttr, lSize, False, 0, 0);
                                                                               {!3-31-83 Longint overflow
                                                                                checking added -a.h.}
        OverFlag := True;
        IF LimitCAttr.cKind = CNST THEN
          IF StepCAttr.CValu.IValu[1] > 0 THEN
            IF lSize = ByteOp THEN
              OverFlag := LimitCAttr.CValu.IValu[1] >= 127
            ELSE IF lSize = WordOp THEN
              OverFlag := LimitCAttr.CValu.IValu[1] >= 32767
            ELSE
              OverFlag := LimitCAttr.CValu.lInt >= 2147483647
          ELSE IF lSize = ByteOp THEN
            OverFlag := LimitCAttr.CValu.IValu[1] <= - 128
          ELSE IF lSize = WordOp THEN
            OverFlag := LimitCAttr.CValu.IValu[1] <= - 32767 - 1
          ELSE
            OverFlag := LimitCAttr.CValu.lInt <= - 2147483647 - 1;
        IF OverFlag THEN GenJump($6900, ExitLabel); { BVS }
        DefILabel(BottomLabel);
        IF GenCompare(VarCAttr, LimitCAttr, lSize) THEN
          IF StepCAttr.CValu.IValu[1] > 0 THEN
            lOp := $6C00 { BGE }
          ELSE
            lOp := $6F00 { BLE }
        ELSE IF StepCAttr.CValu.IValu[1] > 0 THEN
          lOp := $6F00 { BLE }
        ELSE
          lOp := $6C00; { BGE }
        GenJump(lOp, TopLabel);
        DefILabel(ExitLabel);
        END
      ELSE
        CodError(2009);
    END; {forstmt}

  PROCEDURE CaseStmt;

    VAR
      IfThenElseFlag, Junk, Lo, HI, ElseLabel, i, j, LoIc, lIc, HiIc, v,
      lv: Integer;
      D: Register;
      lLab: pLabelRec;

    PROCEDURE SubFromD(N: Integer);

      BEGIN
        IF N <> 0 THEN
          BEGIN
          IF (N <= 8) AND (N > 0) THEN
            GenR($5140 + (N MOD 8) * 512, D) {SUBQ.W #n,D }
          ELSE IF (N >= - 8) AND (N < 0) THEN
            GenR($5040 + ( - N MOD 8) * 512, D) {ADDQ.W #-n,D}
          ELSE
            BEGIN
            GenR($440, D); Gen(N); { SUBI.W }
            END;
          END;
      END; {subfromd}

    BEGIN
      Expression(NextByte, - 1, False); D := LoadD(gCAttr, WordOp, True);
      Junk := NextByte; {C9}
      IfThenElseFlag := NextByte;
      CheckClobber(D);
      Lo := NextWord; HI := NextWord; ElseLabel := NextWord;
      IF IfThenElseFlag = 0 THEN
        BEGIN
        SubFromD(Lo);
        GenJump($6B00, ElseLabel); { BMI }
        GenR($C40, D); Gen(HI - Lo); { CPI.W }
        GenJump($6E00, ElseLabel); { BGT }
        GenR($E348, D); { LSL.W #1 }
        GenRR($303B, D, 0); Gen(D * 4096 + 6); { MOVE.W table(D.W),D }
        Gen($4EFB); Gen(D * 4096); { JMP $(d) }
        LoIc := Ic; FreeReg(D);
        FOR i := Lo TO HI DO
          BEGIN
          GenWord(NextWord, CASJ); pLineNumber^[CurrCode] := - LNum;
          END;
        HiIc := Ic; StmtList(204 {ENDCASE} ); lIc := LoIc;
        WHILE lIc < HiIc DO
          BEGIN
          i := lIc DIV 2;
          lLab := LookUpILabel(CodeBuff[i]);
          CodeBuff[i] := lLab^.Loc;
          lIc := lIc + 2;
          END;
        END
      ELSE
        BEGIN
        lv := 0;
        j := NextWord; {count}
        FOR i := 1 TO j DO
          BEGIN
          v := NextWord;
          SubFromD(v - lv);
          GenJump($6700, NextWord); { BEQ }
          lv := v;
          END;
        FreeReg(D);
        GenJump($6000, ElseLabel); { BRA }
        StmtList(204 {ENDCASE} );
        END;
    END; {casestmt}

  PROCEDURE LineStmt;

    VAR
      i, j, k: Integer;
      Dummy: Boolean;
      WhatUserTyped: PromptState;
      CListFName, Str1, Str2, Str3, Str4: SUStr;

    BEGIN
      IF ListingOk THEN
        BEGIN {process line number i-codes and act upon them}
        i := NextWord;
        IF i = - 1 THEN
          BEGIN
          j := NextByte;
          CListFName[0] := Chr(j);
          FOR i := 1 TO j DO CListFName[i] := Chr(NextByte);

          IF CListOpen THEN CloseF(CListFile, IONormal);
          CListOpen := False;
          Listing := False;
          ConsListing := False;

          IF IOError(OpenF(CListFName, CListFile, IORead, CListBufr),
                     Concat('Cannot open Compiler''s listing file: ', CListFName)) THEN
            BEGIN
            KillExec;
            WriteLn;
            Write('Ignore listing and continue with code generation? ');
            IF NOT SUGetBool(True) THEN
              BEGIN
              Aborted := True;
              GOTO 999;
              END;
            WriteLn; FirstOnCons := False;
            IF ListOpen THEN CloseF(ListFile, IOLock);
            ListOpen := False;
            ListingOk := False; {master override}
            END
          ELSE
            BEGIN
            CListOpen := True;
            Listing := (CListFile^.DevType = IOBlkDev); {safety test}
            END;

          IF Listing THEN
            IF AltListing THEN
              BEGIN
              SUSplitFN(@CListFName, @Str1, @Str2, @Str3);
              SUMakeFN(@Str4, @Str1, @Str2, '', Dummy);
              IF NOT FirstOnCons THEN WriteLn;
              REPEAT
                Write('New list file - ');
                SUGetFN(@CListFName, WhatUserTyped, '', Str4, '.TEXT');
                IF WhatUserTyped = SUEscape THEN
                  BEGIN
                  Aborted := True;
                  GOTO 999;
                  END;
                IF WhatUserTyped = SUInvalid THEN WriteLn('Bad file name');
                IF WhatUserTyped IN [SUValid, SUNone, SUDefault] THEN
                  BEGIN
                  IF ListOpen THEN
                    BEGIN
                    Str1 := CListFName; SUUpStr(@Str1);
                    Str2 := ListFile^.Filename; SUUpStr(@Str2);
                    IF Str1 <> Str2 THEN
                      BEGIN
                      CloseF(ListFile, IOLock); ListOpen := False;
                      END;
                    END;

                  IF NOT ListOpen THEN
                    IF IOError(OpenF(CListFName, ListFile, IOWrite, ListBufr),
                               Concat('Cannot open listing file: ', CListFName)) THEN
                      WhatUserTyped := SUInvalid;
                  END;
                IF WhatUserTyped = SUInvalid THEN KillExec;
              UNTIL WhatUserTyped IN [SUValid, SUNone, SUDefault];
              ConsListing := (ListFile^.DevType = IOConsDev);
              ListOpen := True;
              WriteLn; FirstOnCons := False;
              END
            ELSE
              BEGIN
              IF ListOpen THEN CloseF(ListFile, IOLock);
              ListOpen := False;
              IF IOError(OpenF(CListFName, ListFile, IOWrite, ListBufr),
                         Concat('Cannot open listing file: ', CListFName)) THEN
                BEGIN
                KillExec;
                WriteLn;
                Write('Ignore listing and continue with code generation? ');
                IF NOT SUGetBool(True) THEN
                  BEGIN
                  Aborted := True;
                  GOTO 999;
                  END;
                WriteLn; FirstOnCons := False;
                Listing := False;
                ConsListing := False;
                ListingOk := False; {master override}
                END
              ELSE
                BEGIN
                ListOpen := True;
                ConsListing := (ListFile^.DevType = IOConsDev);
                IF NOT FirstOnCons THEN WriteLn;
                WriteLn('Listing file is ', ListFile^.Filename);
                WriteLn; FirstOnCons := False;
                END;
              END;

          IF NOT Listing THEN
            BEGIN
            IF ListOpen THEN CloseF(ListFile, IOLock);
            ListOpen := False;
            ConsListing := False;
            CloseF(CListFile, IONormal); CListOpen := False;
            ListingOk := False; {master override}
            END;
          END {i = -1}
        ELSE IF i = - 2 THEN
          IF UseAsmIcode THEN
            ShowAsmCode := (NextByte = 1)
          ELSE
            i := NextByte
        ELSE IF i = - 3 THEN
          EndLineNbr := NextWord
        ELSE
          BEGIN
          LNum := i;
          IF i < 0 THEN LNum := LNum + 65536; {integers > 32767}
          IF FirstLNum = 0 THEN FirstLNum := LNum;
          IF LNum > MAXLNUM THEN LnOvflo := True; {once on, it stays on!}
          END;
        END {processing line number i-codes and acting upon them}
      ELSE
        BEGIN {ListingOk=False ==> $L- ==> just skip over line number i-codes}
        i := NextWord;
        IF i = - 1 THEN
          BEGIN
          j := NextByte;
          FOR i := 1 TO j DO k := NextByte;
          END
        ELSE IF i = - 2 THEN
          i := NextByte
        ELSE IF i = - 3 THEN i := NextWord;
        END; {skipping over line number i-codes}
    END; {linestmt}

  PROCEDURE StmtList{endop: integer};

    VAR
      i, UserLabNo, IntLabNo, lLev, LabLinkNo: Integer;
      Base, D, A: Register;
      lName: Alfa8;
      lpULab: pUserLabel;
      lCAttr: CAttr;
      t: Boolean;
      Temps: RECORD
               CASE Boolean OF
                 True:
                   (TempSet: SET OF Register);
                 False:
                   (TempInt: Integer);
             END;

    BEGIN
      Op := NextByte;
      WHILE Op <> EndOp DO
        BEGIN
        CASE Op OF
          032, 033, 034, 035:
                Assign1248;
          036:  BEGIN
                t := Odd(NextByte); AssignLong(NextWord, t);
                END;
          037:  AssignSet;
          038:  AssignPacked;
          039:  AssignString;
          040:  AssignAlfa;
          041, { ADDTO }
          042: { SUBFROM }
                AddToSubFrom(Op);
          044:  WithStmt;
          045:  BEGIN
                FreeTemp(WithCAttr[WithLevel].Cat, 4);
                WithLevel := WithLevel - 1;
                i := NextByte;
                END;
          190:  GenCall;
          192:  DefILabel(NextWord);
          193, 194, 195:
                JumpILabel;
          196, { LULAB }
          197: { GULAB }
                BEGIN
                UserLabNo := NextWord; IntLabNo := NextWord;
                DefILabel(IntLabNo); New(lpULab);
                WITH lpULab^ DO
                  BEGIN
                  UserNo := UserLabNo; IntNo := IntLabNo;
                  LinkerNo := - 1; {-1 = not global }
                  Next := ULabelList; ULabelList := lpULab;
                  END;
                IF Op = 197 {GULAB} THEN
                  BEGIN
                  LabLinkNo := NextWord; lpULab^.LinkerNo := LabLinkNo;
                  IF ProcLvl > 1 THEN
                    BEGIN
                    Gen($4FEE); Gen(0); { LEA -lc(A6),SP }
                    END
                  ELSE
                    BEGIN
                    Gen($2E6D); Gen(SaveSpCAttr.VOffset); { MOVE.L savesp(A5),SP }
                    Gen($2C6D); Gen(SaveA6CAttr.VOffset); { MOVE.L saveA6(A5),A6 }
                    END;
                  lCAttr := GotoCAttr; D := LoadD(lCAttr, LongOp, False);
                  GenR($2F00, D); { MOVE.L D,-(SP) }
                  FreeReg(D);
                  GenJSR('%_GOTO  ');
                  END;
                END;
          198: { LGOTO }
                BEGIN
                UserLabNo := NextWord; GenJump($6000, NextWord);
                END;
          199: { GGOTO }
                BEGIN
                lLev := NextByte; UserLabNo := NextWord;
                IF lLev > 1 THEN
                  BEGIN
                  Base := GetBase(lLev); FreeReg(Base);
                  GenR($2C48, Base); { MOVE.L A,A6 }
                  END;
                Gen($4EF9); Gen(0); Gen(0); { JMP x.L }
                MakeLName(UserLabNo, lName);
                GlobRef(lName, '***Label', Ic - 4);
                END;
          200:  CaseStmt;
          202:  ForStmt;
          205:  LineStmt;
          206: { TEMPSTMT }
                BEGIN
                Temps.TempInt := NextWord;
                FOR A := D0 TO A1st - 1 DO
                  IF A IN Temps.TempSet THEN
                    Reg[A].Count := 1
                  ELSE
                    Reg[A].Count := 0;
                END;
          241:  ExtRef;
          242:  ComRef;
        END; {case}
        Op := NextByte;
        END;
    END; {stmtlist}

