{$e err.log.text}
{$setc foros := true}
PROGRAM DumpIcode;

   USES {$u SysCall} SysCall,
      {$u PasLibCall} PasLibCall,
      {$u SULib} StdUnit,
      {$u Primitives/io} IOPrimitives,
      {$u Primitives/tools} ToolsPrimitives;

   CONST
      Version = '8.8';

   TYPE
      String8 = String[8];

   VAR
      Hexch: PACKED ARRAY [1..16] OF Char;
      FN, GN, FN2: SUStr;
      B: PACKED ARRAY [1..1024] OF 0..255;
      BB: PACKED ARRAY [1..512] OF 0..255;
      bIndex, NexTok, k, i, m, Space, BlkNum, BlkIndx: Integer;
      Flag, BlkFlag, IsConsole, FOpen, GOpen: Boolean;
      F: FILE;
      G: IOFCBP;
      S1, S2: String[10];
      TD: String[20];

   PROCEDURE Operator;
      FORWARD;

   PROCEDURE Stop;

      BEGIN {Stop}
         WriteLn;
         IF FOpen THEN Close(F);
         EndTool(False, True);
         Exit(DumpIcode);
      END; {Stop}

   PROCEDURE Dot;

      BEGIN {Dot}
         IF NOT IsConsole THEN Write('.');
         m := m+1;
         IF m=35 THEN
            BEGIN
            m := 0;
            IF NOT IsConsole THEN WriteLn;
            END;
      END; {Dot}

   PROCEDURE WrtErr;

      BEGIN {WrtErr}
         WriteLn(SUBell, 'Error in writing to output file');
         Stop;
      END; {WrtErr}

   PROCEDURE Header;

      BEGIN {Header}
         PutLineS(G, Concat('I-Code Dump (Ver ', Version, ') - ', TD));
         IF NOT Flag THEN
            PutLineS(G, Concat('File: ', FN))
         ELSE
            PutLineS(G, Concat('File: ', FN2));
         PutcF(G, IONewline);
      END; {Header}

   PROCEDURE PrintHex(Num: Integer);

      VAR
         i, j: Integer;

      BEGIN {PrintHex}
         FOR i := 0 TO (Num DIV 2)-1 DO
            BEGIN
            j := B[bIndex+i];
            PutcF(G, Hexch[(j DIV 16)+1]);
            PutcF(G, Hexch[(j MOD 16)+1]);
            END;
      END; {PrintHex}

   PROCEDURE PrintASCII(Num: Integer);

      VAR
         i, j: Integer;

      BEGIN {PrintASCII}
         PutcF(G, '''');
         FOR i := 0 TO Num-1 DO
            BEGIN
            j := B[bIndex+i];
            PutcF(G, Chr(j));
            END;
         PutcF(G, '''');
      END; {PrintASCII}

   PROCEDURE Incr(Num: Integer);

      VAR
         i: Integer;

      BEGIN {Incr}
         bIndex := bIndex+Num;
         IF bIndex>512 THEN
            BEGIN
            BlkNum := BlkNum+1;
            BlkFlag := True;
            bIndex := bIndex-512;
            k := BlockRead(F, BB, 1); Dot;
            FOR i := 1 TO 512 DO
               BEGIN
               B[i] := B[i+512]; B[i+512] := BB[i];
               END;
            END;
      END; {Incr}

   PROCEDURE Indent(Num: Integer);

      VAR
         i: Integer;

      BEGIN {Indent}
         FOR i := 1 TO Num DO PutcF(G, ' ');
      END; {Indent}

   FUNCTION Token: Integer;

      VAR
         i: Integer;

      BEGIN {Token}
         i := B[bIndex];
         Token := i;
      END; {Token}

   PROCEDURE Unknown;

      VAR
         Num: Integer;

      BEGIN {Unknown}
         PutLineS(G, '....IS AN UNKNOWN OPERATOR');
         PutLineS(G, 'Listed below are the 16 bytes that succeed the Unknown operator');
         PutLineS(G, ' 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16');
         Num := 1;
         REPEAT
            Incr(1);
            PrintHex(2);
            Indent(1);
            Num := Num+1;
         UNTIL Num>16;
         PutcF(G, IONewline);
         IF NOT IsConsole THEN WriteLn(SUBell, 'Unknown operator detected!');
         Stop;
      END; {Unknown}

   PROCEDURE F0;

      VAR
         Index: Integer;

      BEGIN {F0}
         Indent(28-Space);
         PutLineS(G, '  Begin Module');
         Index := Space;
         Incr(1);
         Indent(Index);
         PrintHex(16); Indent(1);
         PrintASCII(8); PutLineS(G, ' Linker Name');
         Incr(8); Indent(Index);
         PrintHex(16); Indent(1);
         PrintASCII(8); PutLineS(G, ' User Name');
         Incr(8); Indent(Index);
         PrintHex(16); Indent(1);
         PrintASCII(8); PutLineS(G, ' Class (father) Name');
         Incr(8); Indent(Index);
         PrintHex(16); Indent(1);
         PrintASCII(8); PutLineS(G, ' Segment Name');
         Incr(8); Indent(Index);
         PrintHex(2); Indent(28-Space); PutLineS(G, 'Function switch (1)');
         Incr(1); Indent(Index);
         PrintHex(2); Indent(28-Space); PutLineS(G, 'Level');
         Incr(1); Indent(Index);
         PrintHex(4); Indent(26-Space); PutLineS(G, 'Number of bytes of local variables');
         Incr(2); Indent(Index);
         PrintHex(4); Indent(26-Space); PutLineS(G, 'Bytes of parameters');
         Incr(2); Indent(Index);
         PrintHex(2); Indent(28-Space); PutLineS(G, 'Global Label headflag');
         Incr(1); Indent(Index);
         PrintHex(4); Indent(26-Space); PutLineS(G, 'Regmask');
         Incr(2);
      END; {F0}

   PROCEDURE F1;

      VAR
         Index: Integer;

      BEGIN {F1}
         Indent(30-Space);
         PutLineS(G, 'External Ref. Definition');
         Index := Space;
         Incr(1);
         Indent(Index);
         PrintHex(16);  Indent(1);
         PrintASCII(8); PutLineS(G, ' Linker Name');
         Incr(8); Indent(Index);
         PrintHex(16); Indent(1);
         PrintASCII(8); PutLineS(G, ' User Name');
         Incr(8); Indent(Index);
         PrintHex(4); Indent(26-Space); PutLineS(G, 'Nbr');
         Incr(2); Indent(Index);
         PrintHex(2); Indent(28-Space); PutLineS(G, 'Level');
         Incr(1);
      END; {F1}

   PROCEDURE F2;

      VAR
         Index: Integer;

      BEGIN {F2}
         Indent(30-Space);
         PutLineS(G, 'Common Reference Definition');
         Index := Space;
         Incr(1);
         Indent(Index);
         PrintHex(16); Indent(1);
         PrintASCII(8); Incr(8); PutLineS(G, ' Linker Name');
         Indent(Index); PrintHex(2); Incr(1); Indent(1);
         PrintHex(2); Incr(1); Indent(25-Space); PutLineS(G, 'Num & Kind');
      END; {F2}

   PROCEDURE F4;

      VAR
         Index: Integer;

      BEGIN {F4}
         Indent(30-Space);
         PutLineS(G, 'Unit File Header');
         Index := Space;
         Incr(1);
         Indent(Index);
         PrintHex(16); Indent(1);
         PrintASCII(8); Incr(8); PutLineS(G, ' Unit Name'); Indent(Index);
         PrintHex(2); Incr(1); PutcF(G, IONewline);
         Indent(Index); PrintHex(4); Incr(2); Indent(1);
         PrintHex(2); Incr(1); Indent(1); PrintHex(2); Incr(1);
         Indent(20-Space); PutLineS(G, 'Text Address');
         Indent(Index); PrintHex(4); Incr(2); Indent(1); PrintHex(2); Incr(1);
         Indent(23-Space); PutLineS(G, 'Text Size');
         Indent(Index); PrintHex(4); Incr(2); Indent(1); PrintHex(2); Incr(1);
         Indent(23-Space); PutLineS(G, 'Global Data Size & Unit Kind');
      END; {F4}

   PROCEDURE FE;

      VAR
         Index: Integer;

      BEGIN {FE}
         Indent(28-Space);
         PutLineS(G, '  End of Module');
         Index := Space; Indent(Index); Incr(1);
         PrintHex(2); Indent(28-Space); PutLineS(G, 'Debug Flag');
         PutLineS(G, '*******************************************************************');
         PutcF(G, IONewline); Incr(1);
      END; {FE}

   PROCEDURE AssignOp; {Process hex digits 20 -> 2F}

      VAR
         Index: Integer;

      FUNCTION InlineAsg(Size: String8): Boolean;

         BEGIN {InlineAsg}
            Incr(1); Index := Space;
            NexTok := Token;
            CASE NexTok OF {@=3}
               0, 1: InlineAsg := False;
               2: BEGIN
                  InlineAsg := True;
                  PutLineS(G, Concat('Inline Assignment of ', Size, 'expr.'));
                  Indent(Index); PrintHex(2);
                  Indent(28-Space); PutLineS(G, 'addr := expr, return expr');
                  Indent(Index); Incr(1);
                  Operator; Indent(Index); Space := Index; {addr}
                  Operator; {expr}
                  END;
               3: BEGIN
                  InlineAsg := True;
                  PutLineS(G, Concat('Inline Assignment of ', Size, 'expr.'));
                  Indent(Index); PrintHex(2);
                  Indent(28-Space); PutLineS(G, 'addr := 2nd expr, return 1st expr');
                  Indent(Index); Incr(1);
                  Operator; Indent(Index); Space := Index; {expr 1}
                  Operator; Indent(Index); Space := Index; {addr}
                  Operator; {expr2}
                  END;
               OTHERWISE Unknown;
            END;
         END; {InlineAsg}

      BEGIN {AssignOp}
         Indent(30-Space);
         PutStrS(G, 'Assignment Operator - ', 0);
         IF NexTok IN [32..47] THEN
            CASE NexTok OF {[@=4]}
               32: IF NOT InlineAsg('byte') THEN
                      BEGIN {20}
                      PutLineS(G, '1-byte assignment');
                      Indent(Index); PrintHex(2);
                      Indent(28-Space); PutLineS(G, 'Flippable (1 ==> right side --> left)');
                      Indent(Index); Incr(1);
                      Operator; Indent(Index); Space := Index; {addr}
                      Operator; {expr}
                      END;
               33: IF NOT InlineAsg('word') THEN
                      BEGIN {21}
                      PutLineS(G, '2-byte assignment');
                      Indent(Index); PrintHex(2);
                      Indent(28-Space); PutLineS(G, 'Flippable (1 ==> right side --> left)');
                      Indent(Index); Incr(1);
                      Operator; Indent(Index); Space := Index; {addr}
                      Operator; {expr}
                      END;
               34: IF NOT InlineAsg('long') THEN
                      BEGIN {22}
                      PutLineS(G, ' 4-byte assignment');
                      Indent(Index); PrintHex(2);
                      Indent(28-Space); PutLineS(G, 'Flippable (1 ==> right side --> left)');
                      Indent(Index); Incr(1);
                      Operator; Indent(Index); Space := Index; {addr}
                      Operator; {expr}
                      END;
               35: BEGIN {23}
                   PutLineS(G, ' 8-byte assignment');
                   Incr(1); Index := Space;
                   Indent(Index); PrintHex(2);
                   Indent(28-Space); PutLineS(G, 'Flippable (1 ==> right side --> left)');
                   Indent(Index); Incr(1);
                   Operator; Indent(Index); Space := Index; {addr}
                   Operator; {expr}
                   END;
               36: BEGIN {24}
                   PutLineS(G, 'Multiple byte assignment');
                   Incr(1); Index := Space;
                   Indent(Index);
                   PrintHex(2); Indent(28-Space); PutLineS(G, 'Byte size');
                   Incr(1); Indent(Index);
                   PrintHex(4); Incr(2); Indent(26-Space); PutLineS(G, 'Word size');
                   Indent(Index); Operator; Indent(Index); Space := Index;
                   Operator;
                   END;
               37: BEGIN {25}
                   PutLineS(G, ' Set assignment');
                   Incr(1); Index := Space;
                   Indent(Index); PrintHex(2); Indent(28-Space); PutLineS(G, 'Byte size');
                   Indent(Index); Incr(1);
                   Operator; Indent(Index); Space := Index; {addr}
                   Operator; {expr}
                   END;
               38: BEGIN {26}
                   PutLineS(G, 'Packed assignment');
                   Incr(1); Index := Space;
                   Indent(Index); NexTok := Token;
                   PrintHex(2); Indent(28-Space);
                   PutLineS(G, '1st operand type'); Indent(Index); Incr(1);
                   PrintHex(2); Indent(28-Space);
                   PutLineS(G, '2nd operand type'); Indent(Index); Incr(1);
                   PrintHex(4); Indent(26-Space);
                   PutLineS(G, 'Right operand word size'); Indent(Index); Incr(2);
                   IF NexTok=21 THEN
                      BEGIN
                      Operator; Indent(Index); Space := Index;
                      Operator; Indent(Index); Space := Index;
                      Operator;
                      END
                   ELSE
                      BEGIN
                      PrintHex(2); Indent(28-Space);
                      PutLineS(G, '3rd ?'); Indent(Index); Incr(1);
                      Operator; Indent(Index); Space := Index;
                      Operator;
                      END;
                   END;
               39: BEGIN {27}
                   PutLineS(G, ' String assignment');
                   Incr(1); Index := Space;
                   Indent(Index); PrintHex(2); Indent(28-Space); PutLineS(G, 'Length');
                   Indent(Index); Incr(1);
                   Operator; Indent(Index); Space := Index; {addr}
                   Operator; {expr}
                   END;
               40: BEGIN {28}
                   PutLineS(G, 'PAOC assignment');
                   Incr(1); Index := Space;
                   Indent(Index);
                   PrintHex(2); Indent(28-Space);
                   PutLineS(G, '1st length'); Incr(1);
                   Indent(Index);
                   PrintHex(2); Indent(28-Space);
                   PutLineS(G, '2nd length'); Incr(1); Indent(Index);
                   Operator; Indent(Index); Space := Index;
                   Operator;
                   END;
               41: BEGIN {29}
                   PutLineS(G, ' Add to assignment (:=+)');
                   Incr(1); Index := Space;
                   Indent(Index); PrintHex(2); Indent(28-Space); PutLineS(G, 'Size');
                   Indent(Index); Incr(1);
                   Operator; Indent(Index); Space := Index; {addr}
                   Operator; {expr}
                   END;
               42: BEGIN {2A}
                   PutLineS(G, ' Subtract from assignment (:=-)');
                   Incr(1); Index := Space;
                   Indent(Index); PrintHex(2); Indent(28-Space); PutLineS(G, 'Size');
                   Indent(Index); Incr(1);
                   Operator; Indent(Index); Space := Index; {addr}
                   Operator; {expr}
                   END;
               43: BEGIN {2B}
                   PutLineS(G, 'WITH field reference, level nnn');
                   Incr(1); Index := Space;
                   Indent(Index);
                   PrintHex(2); Incr(1);
                   Indent(28-Space); PutLineS(G, 'Level');
                   END;
               44: BEGIN {2C}
                   PutLineS(G, 'Begin WITH statement, level nnn');
                   Incr(1); Index := Space;
                   Indent(Index); PrintHex(2);
                   Indent(28-Space); PutLineS(G, 'Level');
                   Incr(1); Indent(Index);
                   PrintHex(2); Indent(28-Space);
                   PutLineS(G, 'Is a pointer (boolean)');
                   Incr(1); Indent(Index);
                   Operator;
                   END;
               45: BEGIN {2D}
                   PutLineS(G, 'End WITH statement, level nnn');
                   Incr(1); Index := Space;
                   Indent(Index); PrintHex(2); Incr(1);
                   Indent(28-Space); PutLineS(G, 'Level');
                   END;
               46: BEGIN {2E}
                   PutLineS(G, '2-byte range check');
                   Incr(1); Index := Space;
                   Indent(Index); PrintHex(4); Indent(26-Space); PutLineS(G, 'Low');
                   Incr(2);
                   Indent(Index); PrintHex(4); Indent(26-Space); PutLineS(G, 'Hi');
                   Incr(2); Indent(Index);
                   Operator; {expr}
                   END;
               47: BEGIN {2F}
                   PutLineS(G, 'String range check');
                   Incr(1); Index := Space;
                   Indent(Index);
                   PrintHex(2); Indent(28-Space); PutLineS(G, 'Size (Hi)');
                   Incr(1); Indent(Index);
                   Operator; {expr}
                   END;
            END {case}
         ELSE
            Unknown;
      END; {AssignOp}

   PROCEDURE VarRef; {Process hex operators 01 -> 0B}

      VAR
         Index: Integer;

      BEGIN {VarRef}
         Index := Space;
         Incr(1); Indent(1);
         IF NexTok IN [1..5, 8..11] THEN
            CASE NexTok OF
               1:  BEGIN {01}
                   PrintHex(4);
                   Indent(25-Space);
                   PutLineS(G, 'Global Variable Reference (offset)');
                   Incr(2);
                   END;
               2:  BEGIN {02}
                   PrintHex(4);
                   Indent(25-Space);
                   PutLineS(G, 'Local Variable Reference (offset)');
                   Incr(2);
                   END;
               3:  BEGIN {03}
                   PrintHex(2);
                   Indent(1); Incr(1);
                   PrintHex(4);
                   Indent(22-Space);
                   PutLineS(G, 'Intermediate Level Variable Reference (level, offset)');
                   Incr(2);
                   END;
               4:  BEGIN {04}
                   PrintHex(2);
                   Indent(1); Incr(1);
                   PrintHex(4);
                   Indent(22-Space);
                   PutLineS(G, 'Common Variable Reference (com, offset)');
                   Incr(2);
                   END;
               5:  BEGIN {05}
                   PrintHex(2); Indent(1); Incr(1); {reg}
                   PrintHex(2); Indent(1); Incr(1); {load count}
                   NexTok := Token; PrintHex(2); Incr(1); {size}
                   Indent(21-Space);
                   PutLineS(G, 'Register Variable Reference (reg, load count, size)');
                   IF NexTok<>0 THEN
                      BEGIN
                      Indent(Index);
                      Operator; {expr}
                      END;
                   END;
               8:  BEGIN
                   PrintHex(2); { 1 byte }
                   Incr(1);
                   Indent(27-Space);
                   PutLineS(G, '1-byte Temp Variable reference');
                   END;
               9:  BEGIN
                   PrintHex(4); { 2 byte }
                   Incr(2);
                   Indent(25-Space);
                   PutLineS(G, '2-byte Temp Variable reference');
                   END;
               10: BEGIN
                   PrintHex(8); { 4 byte }
                   Incr(4);
                   Indent(21-Space);
                   PutLineS(G, '4-byte Temp Variable reference');
                   END;
               11: BEGIN
                   PrintHex(16); { 8 byte }
                   Incr(8);
                   Indent(14-Space);
                   PutLineS(G, '8-byte Temp Variable reference');
                   END;
            END {case}
         ELSE
            Unknown;
      END; {VarRef}

   PROCEDURE AddOp; {Process hex operators 0C -> 16}

      VAR
         Index: Integer;

      BEGIN {AddOp}
         Index := Space; Indent(30-Space);
         PutStrS(G, 'Addressing Operator - ', 0);
         Incr(1);
         IF NexTok IN [12..22] THEN
            CASE NexTok OF
               12: BEGIN {0C}
                   PutLineS(G, 'Dereference operator');
                   Indent(Index); Operator;
                   END;
               13: BEGIN {0D}
                   PutLineS(G, 'File dereference operator');
                   Indent(Index); Operator;
                   END;
               14: BEGIN {0E}
                   PutLineS(G, 'Text file dereference operator');
                   Indent(Index); Operator;
                   END;
               15: BEGIN {0F}
                   PutLineS(G, 'Record field offset (".")');
                   Indent(Index); PrintHex(4); Indent(26-Space); PutLineS(G, 'Offset');
                   Incr(2); Indent(Index);
                   Operator;
                   END;
               16: BEGIN {10}
                   PutLineS(G, '1-byte array index ([])');
                   Indent(Index); PrintHex(4); Indent(26-Space);
                   PutLineS(G, 'Word size'); Indent(Index);
                   Incr(2);
                   Operator; Indent(Index); Space := Index;
                   Operator;
                   END;
               17: BEGIN {11}
                   PutLineS(G, '2-byte array index ([])');
                   Indent(Index); PrintHex(4); Indent(26-Space);
                   PutLineS(G, 'Word size'); Indent(Index);
                   Incr(2);
                   Operator; Indent(Index); Space := Index;
                   Operator;
                   END;
               18: BEGIN {12}
                   PutLineS(G, '4-byte array index ([])');
                   Indent(Index); PrintHex(4); Indent(26-Space);
                   PutLineS(G, 'Word size'); Indent(Index);
                   Incr(2);
                   Operator; Indent(Index); Space := Index;
                   Operator;
                   END;
               19: BEGIN {13}
                   PutLineS(G, '8-byte array index ([])');
                   Indent(Index); PrintHex(4); Indent(26-Space);
                   PutLineS(G, 'Word size'); Indent(Index);
                   Incr(2);
                   Operator; Indent(Index); Space := Index;
                   Operator;
                   END;
               20: BEGIN {14}
                   PutLineS(G, 'Long array index ([])');
                   Indent(Index); PrintHex(4); Indent(26-Space);
                   PutLineS(G, 'Word size'); Indent(Index);
                   Incr(2);
                   PrintHex(4); Indent(26-Space);
                   PutLineS(G, 'Word size'); Indent(Index);
                   Incr(2);
                   Operator; Indent(Index); Space := Index;
                   Operator;
                   END;
               21: BEGIN {15}
                   PutLineS(G, 'Packed array access');
                   Indent(Index); PrintHex(2); Indent(28-Space);
                   PutLineS(G, 'Byte size'); Indent(Index);
                   Incr(1);
                   PrintHex(4); Indent(26-Space);
                   PutLineS(G, 'Word size'); Indent(Index);
                   Incr(2);
                   Operator; Indent(Index); Space := Index;
                   Operator;
                   END;
               22: BEGIN {16}
                   PutLineS(G, '@-operator');
                   Indent(Index); Operator;
                   END;

            (* 22, 16:
                   BEGIN
                   PrintHex(2); NexTok := Token;
                   PutcF(G, IONewline); Indent(Index); Incr(1);
                   IF NexTok = 241 { EXTREF } THEN
                      BEGIN
                      PrintHex(2);
                      PutcF(G, IONewline); Indent(Index); Incr(1);
                      END;
                   IF (NexTok = 176 {UFUNC} ) OR (NexTok = 177 {UPROC} ) THEN
                      BEGIN
                      PrintHex(4);
                      PutcF(G, IONewline); Indent(Index); Incr(2);
                      END
                   ELSE
                      Operator;
                   END; *)
            END {case}
         ELSE
            Unknown;
      END; {AddOp}

   PROCEDURE Cont; {Process hex operators 17 -> 1F }

      VAR
         Index, i: Integer;

      BEGIN {Cont}
         IF NexTok IN [23..31] THEN
            CASE NexTok OF
               23: BEGIN {17}
                   Incr(1); Indent(1);
                   PutStrS(G, 'NIL', 0);
                   Indent(26-Space); PutLineS(G, 'Constant');
                   END;
               24: BEGIN {18}
                   Incr(1); Indent(1);
                   PrintHex(2); { 1 byte }
                   Incr(1);
                   Indent(27-Space); PutLineS(G, 'Constant');
                   END;
               25: BEGIN {19}
                   Incr(1); Indent(1);
                   PrintHex(4); { 2 byte }
                   Incr(2);
                   Indent(25-Space); PutLineS(G, 'Constant');
                   END;
               26: BEGIN {1A}
                   Incr(1); Indent(1);
                   PrintHex(8); { 4 byte }
                   Incr(4);
                   Indent(21-Space); PutLineS(G, 'Constant');
                   END;
               27: BEGIN {1B}
                   Incr(1); Indent(1);
                   PrintHex(16); { 8 byte }
                   Incr(8);
                   Indent(13-Space); PutLineS(G, 'Constant');
                   END;
               28: BEGIN {1C}
                   Indent(30-Space);
                   PutLineS(G, 'String Constant');
                   Index := Space;
                   Incr(1); Indent(Index);
                   PrintHex(2); Indent(1); NexTok := Token;
                   Incr(1); PrintASCII(NexTok); Indent(25-NexTok-Space);
                   PutLineS(G, 'Size & string'); Incr(NexTok);
                   END;
               29: BEGIN {1D}
                   Indent(30-Space);
                   PutLineS(G, 'PAOC Constant');
                   Index := Space;
                   Incr(1); Indent(Index);
                   PrintHex(2); Indent(1); NexTok := Token;
                   Incr(1); PrintASCII(NexTok); Indent(25-NexTok-Space);
                   PutLineS(G, 'Size & string'); Incr(NexTok);
                   END;
               30: BEGIN {1E}
                   Incr(1); Indent(1);
                   PrintHex(2); NexTok := Token;
                   Indent(27-Space); PutLineS(G, 'Set Constant');
                   Index := Space+2; Incr(1);
                   FOR i := 1 TO NexTok DO
                      BEGIN
                      Indent(Index); PrintHex(2); PutcF(G, IONewline);
                      Incr(1);
                      END;
                   END;
               31: BEGIN {1F}
                   Indent(30-Space);
                   PutLineS(G, 'Null Set');
                   Incr(1);
                   END;
            END {case}
         ELSE
            Unknown;
      END; {Cont}

   PROCEDURE Control; {Process hex operators C0 -> FE, except FC, FD}

      VAR
         Index, i, j, lo, hi, LineNbr: Integer;

      BEGIN {Control}
         IF NexTok IN [240, 241, 242, 242, 244, 254] THEN
            CASE NexTok OF {[@=5]}
               240: F0; {Begin Module}
               241: F1; {Ext. Ref. Definition}
               242: F2; {Com. Ref. Definition}
               244: F4; {Unit File Header}
               254: FE; {End of File}
            END
         ELSE
            BEGIN
            Indent(30-Space);
            PutStrS(G, 'Control - ', 0);
            Index := Space; Incr(1);
            IF NexTok IN [192..206] THEN
               CASE NexTok OF
                  192: BEGIN {C0}
                       PutLineS(G, 'Define Internal Label');
                       Indent(Index); PrintHex(4); Incr(2); PutcF(G, IONewline);
                       END;
                  193: BEGIN {C1}
                       PutLineS(G, 'Jump');
                       Indent(Index); PrintHex(4); Incr(2); PutcF(G, IONewline);
                       END;
                  194: BEGIN {C2}
                       PutLineS(G, 'Jump False');
                       Indent(Index); PrintHex(4); Incr(2); PutcF(G, IONewline);
                       Indent(Index);
                       Operator;
                       END;
                  195: BEGIN {C3}
                       PutLineS(G, 'Jump True');
                       Indent(Index); PrintHex(4); Incr(2); PutcF(G, IONewline);
                       Indent(Index);
                       Operator;
                       END;
                  196: BEGIN {C4}
                       PutLineS(G, 'Define Local User Label');
                       Indent(Index); PrintHex(4); Incr(2); PutcF(G, IONewline);
                       Indent(Index);
                       PrintHex(4); Incr(2); PutcF(G, IONewline);
                       END;
                  197: BEGIN {C5}
                       PutLineS(G, 'Define Global User Label');
                       Indent(Index); PrintHex(4); Incr(2); PutcF(G, IONewline);
                       Indent(Index);
                       PrintHex(4); Incr(2); PutcF(G, IONewline);
                       Indent(Index);
                       PrintHex(4); Incr(2); PutcF(G, IONewline);
                       END;
                  198: BEGIN {C6}
                       PutLineS(G, 'Jump to Local User Label');
                       Indent(Index); PrintHex(4); Incr(2); PutcF(G, IONewline);
                       Indent(Index);
                       PrintHex(4); Incr(2); PutcF(G, IONewline);
                       END;
                  199: BEGIN {C7}
                       PutLineS(G, 'Jump to Global User Label');
                       Indent(Index); PrintHex(2); Incr(1); Indent(1);
                       PrintHex(4); Incr(2); PutcF(G, IONewline);
                       END;
                  {NOT SURE ABOUT C8 & C9}
                  200: BEGIN {C8}
                       PutLineS(G, 'Case Jump');
                       Indent(Index); Operator;
                       END;
                  201: BEGIN {C9}
                       PutLineS(G, 'If expr list (must follow case jump)');
                       Indent(Index); PrintHex(2); NexTok := Token;
                       Incr(1); PutcF(G, IONewline); Indent(Index);
                       IF NexTok=0 THEN
                          BEGIN
                          PrintHex(4); Incr(1); lo := Token; Incr(1);
                          Indent(26-Space); PutLineS(G, 'Low bound');
                          Indent(Index); PrintHex(4); Incr(1); hi := Token;
                          Incr(1);
                          Indent(26-Space); PutLineS(G, 'Hi Bound'); Indent(Index);
                          PrintHex(4); Incr(2);
                          Indent(26-Space); PutLineS(G, 'Otherwise label');
                          FOR i := lo TO hi DO
                             BEGIN
                             Indent(Index);
                             PrintHex(4); Incr(2); {lo--lab..hi--lab}
                             Indent(26-Space); PutLineS(G, PutIntP(i, 1)^);
                             END;
                          END
                       ELSE
                          BEGIN
                          PrintHex(4); Incr(1); lo := Token; Incr(1);
                          Indent(26-Space); PutLineS(G, 'Low bound');
                          Indent(Index); PrintHex(4); Incr(1); hi := Token;
                          Incr(1);
                          Indent(26-Space); PutLineS(G, 'Hi bound');
                          Indent(Index); PrintHex(4); Incr(2);
                          Indent(26-Space); PutLineS(G, 'Otherwise label');
                          Indent(Index); PrintHex(4); Incr(1); j := Token; Incr(1);
                          Indent(26-Space); PutLineS(G, 'Count');
                          FOR i := 1 TO j DO
                             BEGIN
                             Indent(Index);
                             PrintHex(4); Incr(2); {value,label}
                             Indent(26-Space);
                             PutLineS(G, Concat('Value  ', PutIntP(i, 1)^));
                             Indent(Index);
                             PrintHex(4); Incr(2); {value,label}
                             Indent(26-Space); PutLineS(G, 'Label');
                             END;
                          END;
                       END;
                  202: BEGIN {CA}
                       PutLineS(G, 'FOR Statement');
                       Indent(Index); PrintHex(2); Incr(1);
                       Indent(28-Space); PutLineS(G, 'Size');
                       Indent(Space);
                       Operator; Indent(Index); Space := Index;
                       Operator; Indent(Index); Space := Index;
                       Operator; Indent(Index); Space := Index;
                       Operator;
                       END;
                  203: BEGIN {CB}
                       PutLineS(G, 'FOR End');
                       PutcF(G, IONewline);
                       END;
                  204: BEGIN {CC}
                       PutLineS(G, 'CASE End');
                       PutcF(G, IONewline);
                       END;
                  205: BEGIN {CD}
                       PutLineS(G, 'Line Number');
                       Indent(Index); PrintHex(4);
                       LineNbr := Token; Incr(1);
                       LineNbr := LineNbr*256+Token; Incr(1);
                       IF LineNbr=-1 THEN
                          BEGIN
                          Indent(1); PrintHex(2); Indent(1); NexTok := Token;
                          Incr(1);
                          PrintASCII(NexTok); Incr(NexTok);
                          END
                       ELSE IF LineNbr=-2 THEN
                          BEGIN
                          Indent(1); PrintHex(2); Incr(1);
                          Indent(23-Space); PutStrS(G, '1 ==> Show asm code', 0);
                          END
                       ELSE IF LineNbr=-3 THEN
                         BEGIN
                         Indent(1); PrintHex(4); Incr(2);
                         Indent(21-Space); PutStrS(G, 'Flush listing to line nbr', 0);
                         END;
                       PutcF(G, IONewline);
                       END;
                  206: BEGIN {CE}
                       PutLineS(G, 'Temp registers statement');
                       Indent(Index); PrintHex(4); Incr(2);
                       Indent(26-Space); PutLineS(G, 'Register mask');
                       END;
               END {case}
            ELSE
               Unknown;
            END;
      END; {Control}

   PROCEDURE DatCon; {Process hex operators 30 -> 3F }

      VAR
         Index: Integer;

      BEGIN {DatCon}
         Indent(30-Space);
         PutStrS(G, 'Data Conversion - ', 0);
         Index := Space; Incr(1);
         IF NexTok IN [48..63] THEN
            CASE NexTok OF {[@=4]}
               48: BEGIN {30}
                   PutLineS(G, '1 --> 2');
                   Indent(Index); Operator;
                   END; {expr}
               49: BEGIN {31}
                   PutLineS(G, '2 --> 4');
                   Indent(Index); Operator;
                   END; {expr}
               50: BEGIN {32}
                   PutLineS(G, '1 --> 4');
                   Indent(Index); Operator;
                   END; {expr}
               51: BEGIN {33}
                   PutLineS(G, '2 --> 1');
                   Indent(Index); Operator;
                   END; {expr}
               52: BEGIN {34}
                   PutLineS(G, '4 --> 2');
                   Indent(Index); Operator;
                   END; {expr}
               53: BEGIN {35}
                   PutLineS(G, '4 --> 1');
                   Indent(Index); Operator;
                   END; {expr}
               54: BEGIN {36}
                   PutLineS(G, '4 --> 8');
                   Indent(Index); Operator;
                   END; {expr}
               55: BEGIN {37}
                   PutLineS(G, '8 --> 4');
                   Indent(Index); Operator;
                   END; {expr}
               56: BEGIN {38}
                   PutLineS(G, '4 --> 4 Float');
                   Indent(Index); Operator;
                   END; {expr}
               57: BEGIN {39}
                   PutLineS(G, '4 --> 8 Float');
                   Indent(Index); Operator;
                   END; {expr}
               58: BEGIN {3A}
                   PutLineS(G, '4 --> 4 Trunc');
                   Indent(Index); Operator;
                   END; {expr}
               59: BEGIN {3B}
                   PutLineS(G, '8 --> 4 Trunc');
                   Indent(Index); Operator;
                   END; {expr}
               60: BEGIN {3C}
                   PutLineS(G, '4 --> 4 Round');
                   Indent(Index); Operator;
                   END; {expr}
               61: BEGIN {3D}
                   PutLineS(G, '8 --> 4 Round');
                   Indent(Index); Operator;
                   END; {expr}
               62: BEGIN {3E}
                   PutLineS(G, 'Extract unsigned field');
                   Indent(Index); PrintHex(2); Incr(1);
                   PutcF(G, IONewline); Indent(Index);
                   Operator;
                   END;
               63: BEGIN {3F}
                   PutLineS(G, 'Extract signed field');
                   Indent(Index); PrintHex(2); Incr(1);
                   PutcF(G, IONewline); Indent(Index);
                   Operator;
                   END;
            END {case}
         ELSE
            Unknown;
      END; {DatCon}

   PROCEDURE ScalOp; {Process hex operators 40 -> 8F}

      VAR
         Index: Integer;

      BEGIN {ScalOp}
         Indent(30-Space);
         PutStrS(G, 'Scalar Operator - ', 0);
         Index := Space; Incr(1);
         IF NexTok IN [64..140] THEN
            CASE NexTok OF {[@=5]}
               064: BEGIN {40}
                    PutLineS(G, '2-byte Scalar Addition');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               065: BEGIN {41}
                    PutLineS(G, '4-byte Scalar Addition');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               066: BEGIN {42}
                    PutLineS(G, '2-byte Scalar Subtraction');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               067: BEGIN {43}
                    PutLineS(G, '4-byte Scalar Subtraction');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               068: BEGIN {44}
                    PutLineS(G, '2-byte Scalar Multiplication');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               069: BEGIN {45}
                    PutLineS(G, '4-byte Scalar Multiplication');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               070: BEGIN {46}
                    PutLineS(G, '2-byte Scalar Division');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               071: BEGIN {47}
                    PutLineS(G, '4-byte Scalar Division');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               072: BEGIN {48}
                    PutLineS(G, '2-byte Scalar MOD');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               073: BEGIN {49}
                    PutLineS(G, '4-byte Scalar MOD');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               074: BEGIN {4A}
                    PutLineS(G, '2-byte Scalar Negate');
                    Indent(Index); Operator;
                    END;
               075: BEGIN {4B}
                    PutLineS(G, '4-byte Scalar Negate');
                    Indent(Index); Operator;
                    END;
               076: BEGIN {4C}
                    PutLineS(G, '2-byte Scalar ABS');
                    Indent(Index); Operator;
                    END;
               077: BEGIN {4D}
                    PutLineS(G, '4-byte Scalar ABS');
                    Indent(Index); Operator;
                    END;
               078: BEGIN {4E}
                    PutLineS(G, '2-byte Scalar SQR');
                    Indent(Index); Operator;
                    END;
               079: BEGIN {4F}
                    PutLineS(G, '4-byte Scalar SQR');
                    Indent(Index); Operator;
                    END;
               080: BEGIN {50}
                    PutLineS(G, '1-byte Scalar AND');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               081: BEGIN {51}
                    PutLineS(G, '2-byte Scalar AND');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               082: BEGIN {52}
                    PutLineS(G, '4-byte Scalar AND');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               083: BEGIN {53}
                    PutLineS(G, '1-byte Scalar OR');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               084: BEGIN {54}
                    PutLineS(G, '2-byte Scalar OR');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               085: BEGIN {55}
                    PutLineS(G, '4-byte Scalar OR');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               086: BEGIN {56}
                    PutLineS(G, '1-byte Scalar XOR');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               087: BEGIN {57}
                    PutLineS(G, '2-byte Scalar XOR');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               088: BEGIN {58}
                    PutLineS(G, '4-byte Scalar XOR');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               089: BEGIN {59}
                    PutLineS(G, '1-byte Scalar NOT');
                    Indent(Index); Operator;
                    END;
               090: BEGIN {5A}
                    PutLineS(G, '2-byte Scalar NOT');
                    Indent(Index); Operator;
                    END;
               091: BEGIN {5B}
                    PutLineS(G, '4-byte Scalar NOT');
                    Indent(Index); Operator;
                    END;
               092: BEGIN {5C}
                    PutLineS(G, '1-byte Scalar <');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               093: BEGIN {5D}
                    PutLineS(G, '2-byte Scalar <');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               094: BEGIN {5E}
                    PutLineS(G, '4-byte Scalar <');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               095: BEGIN {5F}
                    PutLineS(G, '1-byte Scalar >');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               096: BEGIN {60}
                    PutLineS(G, '2-byte Scalar >');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               097: BEGIN {61}
                    PutLineS(G, '4-byte Scalar >');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               098: BEGIN {62}
                    PutLineS(G, '1-byte Scalar <=');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               099: BEGIN {63}
                    PutLineS(G, '2-byte Scalar <=');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               100: BEGIN {64}
                    PutLineS(G, '4-byte Scalar <=');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               101: BEGIN {65}
                    PutLineS(G, '1-byte Scalar >=');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               102: BEGIN {66}
                    PutLineS(G, '2-byte Scalar >=');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               103: BEGIN {67}
                    PutLineS(G, '4-byte Scalar >=');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               104: BEGIN {68}
                    PutLineS(G, '1-byte Scalar =');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               105: BEGIN {69}
                    PutLineS(G, '2-byte Scalar =');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               106: BEGIN {6A}
                    PutLineS(G, '4-byte Scalar =');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               107: BEGIN {6B}
                    PutLineS(G, '1-byte Scalar <>');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               108: BEGIN {6C}
                    PutLineS(G, '2-byte Scalar <>');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               109: BEGIN {6D}
                    PutLineS(G, '4-byte Scalar <>');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               110: BEGIN {6E}
                    PutLineS(G, 'Boolean NOT');
                    Indent(Index); Operator;
                    END;
               111: BEGIN {6F}
                    PutLineS(G, 'ODD');
                    Indent(Index); Operator;
                    END;
               112: BEGIN {70}
                    PutLineS(G, '4-byte Real Addition');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               113: BEGIN {71}
                    PutLineS(G, '8-byte Real Addition');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               114: BEGIN {72}
                    PutLineS(G, '4-byte Real Subtraction');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               115: BEGIN {73}
                    PutLineS(G, '8-byte Real Subtraction');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               116: BEGIN {74}
                    PutLineS(G, '4-byte Real Multiplication');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               117: BEGIN {75}
                    PutLineS(G, '8-byte Real Multiplication');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               118: BEGIN {76}
                    PutLineS(G, '4-byte Real Division');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               119: BEGIN {77}
                    PutLineS(G, '8-byte Real Division');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               120: BEGIN {78}
                    PutLineS(G, '4-byte Real MOD');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               121: BEGIN {79}
                    PutLineS(G, '8-byte Real MOD');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               122: BEGIN {7A}
                    PutLineS(G, '4-byte Real <');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               123: BEGIN {7B}
                    PutLineS(G, '8-byte Real <');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               124: BEGIN {7C}
                    PutLineS(G, '4-byte Real >');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               125: BEGIN {7D}
                    PutLineS(G, '8-byte Real >');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               126: BEGIN {7E}
                    PutLineS(G, '4-byte Real <=');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               127: BEGIN {7F}
                    PutLineS(G, '8-byte Real <=');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               128: BEGIN {80}
                    PutLineS(G, '4-byte Real >=');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               129: BEGIN {81}
                    PutLineS(G, '8-byte Real >=');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               130: BEGIN {82}
                    PutLineS(G, '4-byte Real =');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               131: BEGIN {83}
                    PutLineS(G, '8-byte Real =');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               132: BEGIN {84}
                    PutLineS(G, '4-byte Real <>');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               133: BEGIN {85}
                    PutLineS(G, '8-byte Real <>');
                    Indent(Index); Operator; {expr}
                    Indent(Index); Space := Index;
                    Operator; {expr}
                    END;
               134: BEGIN {86}
                    PutLineS(G, '4-byte Real Negation');
                    Indent(Index); Operator;
                    END;
               135: BEGIN {87}
                    PutLineS(G, '8-byte Real Negation');
                    Indent(Index); Operator;
                    END;
               136: BEGIN {88}
                    PutLineS(G, '4-byte Real ABS');
                    Indent(Index); Operator;
                    END;
               137: BEGIN {89}
                    PutLineS(G, '8-byte Real ABS');
                    Indent(Index); Operator;
                    END;
               138: BEGIN {8A}
                    PutLineS(G, '4-byte Real SQR');
                    Indent(Index); Operator;
                    END;
               139: BEGIN {8B}
                    PutLineS(G, '8-byte Real SQR');
                    Indent(Index); Operator;
                    END;
               140: BEGIN {8C}
                    PutLineS(G, 'TrapV');
                    Indent(Index); Operator;
                    END;
            END {case}
         ELSE
            Unknown;
      END; {ScalOp}

   PROCEDURE StrgOp; {Process hex operators 90 -> 9F}

      VAR
         Index: Integer;

      BEGIN {StrgOp}
         Index := Space; Indent(30-Space);
         PutStrS(G, 'String Operator - ', 0);
         Incr(1);
         IF NexTok IN [144..155] THEN
            CASE NexTok OF
               144: BEGIN {90}
                    PutLineS(G, 'String <');
                    Indent(Index); Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               145: BEGIN {91}
                    PutLineS(G, 'String >');
                    Indent(Index); Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               146: BEGIN {92}
                    PutLineS(G, 'String <=');
                    Indent(Index); Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               147: BEGIN {93}
                    PutLineS(G, 'String >=');
                    Indent(Index); Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               148: BEGIN {94}
                    PutLineS(G, 'String =');
                    Indent(Index); Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               149: BEGIN {95}
                    PutLineS(G, 'String <>');
                    Indent(Index); Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               150: BEGIN {96}
                    PutLineS(G, 'PAOC <');
                    Indent(Index); PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               151: BEGIN {97}
                    PutLineS(G, 'PAOC >');
                    Indent(Index); PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               152: BEGIN {98}
                    PutLineS(G, 'PAOC <=');
                    Indent(Index); PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               153: BEGIN {99}
                    PutLineS(G, 'PAOC >=');
                    Indent(Index); PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               154: BEGIN {9A}
                    PutLineS(G, 'PAOC =');
                    Indent(Index); PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               155: BEGIN {9B}
                    PutLineS(G, 'PAOC <>');
                    Indent(Index); PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    PrintHex(2); PutcF(G, IONewline); Incr(1);
                    Indent(Index);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
            END {case}
         ELSE
            Unknown;
      END; {StrgOp}

   PROCEDURE SetOp; {Process hex operators A0 -> AF}

      VAR
         Index: Integer;

      BEGIN {SetOp}
         Index := Space; Indent(30-Space);
         PutStrS(G, 'Set Operator - ', 0);
         Incr(1);
         IF NexTok IN [160..170] THEN
            CASE NexTok OF
               160: BEGIN {A0}
                    PutLineS(G, 'Set +');
                    Indent(Index); PrintHex(2);
                    PutcF(G, IONewline); Indent(Index);
                    Incr(1);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               161: BEGIN {A1}
                    PutLineS(G, 'Set -');
                    Indent(Index); PrintHex(2);
                    PutcF(G, IONewline); Indent(Index);
                    Incr(1);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               162: BEGIN {A2}
                    PutLineS(G, 'Set *');
                    Indent(Index); PrintHex(2);
                    PutcF(G, IONewline); Indent(Index);
                    Incr(1);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               163: BEGIN {A3}
                    PutLineS(G, 'IN');
                    Indent(Index); PrintHex(2);
                    PutcF(G, IONewline); Indent(Index);
                    Incr(1);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               164: BEGIN {A4}
                    PutLineS(G, 'Set <=');
                    Indent(Index); PrintHex(2);
                    PutcF(G, IONewline); Indent(Index);
                    Incr(1);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               165: BEGIN {A5}
                    PutLineS(G, 'Set >=');
                    Indent(Index); PrintHex(2);
                    PutcF(G, IONewline); Indent(Index);
                    Incr(1);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               166: BEGIN {A6}
                    PutLineS(G, 'Set =');
                    Indent(Index); PrintHex(2);
                    PutcF(G, IONewline); Indent(Index);
                    Incr(1);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               167: BEGIN {A7}
                    PutLineS(G, 'Set <>');
                    Indent(Index); PrintHex(2);
                    PutcF(G, IONewline); Indent(Index);
                    Incr(1);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               168: BEGIN {A8}
                    PutLineS(G, 'Singleton Set');
                    Indent(Index); PrintHex(2); PutcF(G, IONewline);
                    Incr(1); Indent(Index);
                    Operator;
                    END;
               169: BEGIN {A9}
                    PutLineS(G, 'Set Range');
                    Indent(Index); PrintHex(2);
                    PutcF(G, IONewline); Indent(Index);
                    Incr(1);
                    Operator; Indent(Index); Space := Index;
                    Operator;
                    END;
               170: BEGIN {AA}
                    PutLineS(G, 'Adjust Set');
                    Indent(Index); PrintHex(2); PutcF(G, IONewline);
                    Indent(Index); Incr(1);
                    PrintHex(2); PutcF(G, IONewline);
                    Indent(Index); Incr(1);
                    Operator;
                    END;
            END {case}
         ELSE
            Unknown;
      END; {SetOp}

   PROCEDURE BE; {Process hex operator BE}

      VAR
         Index: Integer;

      BEGIN {BE}
         Index := Space;
         PutLineS(G, 'Begin Parameter list');
         Incr(1); NexTok := Token;
         IF NexTok IN [176..189, 191, 251..253] THEN
            REPEAT
               Indent(Index);
               Operator;
               Space := Index;
               NexTok := Token;
            UNTIL NOT (NexTok IN [176..189, 191, 251..253])
         ELSE
            Unknown;
      END; {BE}

   PROCEDURE ProFun; {Process hex operators B0 -> BF, FB, FC, FD}

      VAR
         i, N, Index: Integer;

      BEGIN {ProFun}
         Index := Space; Indent(30-Space);
         IF NexTok=190 THEN
            BE
         ELSE IF NexTok=251 THEN
           BEGIN {FB}
           PutLineS(G, 'C call');
           Indent(Index); Incr(1); PrintHex(2); Indent(1); Incr(1);
           PrintHex(4); Indent(1); Incr(2);
           PrintHex(4); Incr(2);
           Indent(18-Space); PutLineS(G, 'Result size, index, stack space');
           END {FB}
         ELSE IF NexTok=252 THEN
            BEGIN {FC}
            PutLineS(G, 'Inline code');
            Indent(Index); Incr(1); PrintHex(2); Indent(1);
            Incr(1); PrintHex(4); N := Token; Incr(1); N := N*256+Token; Incr(1);
            Indent(23-Space); PutLineS(G, 'Funct, nbr of words');
            FOR i := 1 TO N DO
              BEGIN
              Indent(Index); PrintHex(4); Incr(2);
              Indent(26-Space); PutLineS(G, Concat('Word ', PutIntP(i, 1)^));
              END;
            END {FC}
         ELSE IF NexTok=253 THEN
            BEGIN {FD}
            PutLineS(G, 'Method call for an object');
            Indent(Index); Incr(1); PrintHex(2); Indent(1);
            Incr(1); PrintHex(2); Indent(1); Incr(1); PrintHex(2); Incr(1);
            Indent(22-Space); PutLineS(G, 'Funct, Level Nbr, Method Nbr');
            END {FD}
         ELSE IF NexTok IN [176..191] THEN
            CASE NexTok OF
               176: BEGIN {B0}
                    PutLineS(G, 'User Function Call');
                    Indent(Index); Incr(1);
                    PrintHex(4); Incr(2); PutcF(G, IONewline);
                    END;
               177: BEGIN {B1}
                    PutLineS(G, 'User Procedure Call');
                    Indent(Index); Incr(1);
                    PrintHex(4); Incr(2); PutcF(G, IONewline);
                    END;
               178: BEGIN {B2}
                    PutLineS(G, 'Standard Function Call');
                    Indent(Index); Incr(1);
                    PrintHex(2); Incr(1); PutcF(G, IONewline);
                    END;
               179: BEGIN {B3}
                    PutLineS(G, 'Standard Procedure Call');
                    Indent(Index); Incr(1);
                    PrintHex(2); Incr(1); PutcF(G, IONewline);
                    END;
               180: BEGIN {B4}
                    PutLineS(G, 'Parametric Function Call');
                    Incr(1); Indent(Index);
                    Operator;
                    END;
               181: BEGIN {B5}
                    PutLineS(G, 'Parametric Procedure Call');
                    Incr(1); Indent(Index);
                    Operator;
                    END;
               182: BEGIN {B6}
                    PutLineS(G, 'Make room for Function Result');
                    Indent(Index); Incr(1);
                    PrintHex(2); Incr(1); PutcF(G, IONewline);
                    END;
               183: BEGIN {B7}
                    PutLineS(G, 'Reference Parameter');
                    Incr(1); Indent(Index);
                    Operator;
                    END;
               184: BEGIN {B8}
                    PutLineS(G, '1-byte Value Parameter');
                    Incr(1); Indent(Index);
                    Operator;
                    END;
               185: BEGIN {B9}
                    PutLineS(G, '2-byte Value Parameter');
                    Incr(1); Indent(Index);
                    Operator;
                    END;
               186: BEGIN {BA}
                    PutLineS(G, '4-byte Value Parameter');
                    Incr(1); Indent(Index);
                    Operator;
                    END;
               187: BEGIN {BB}
                    PutLineS(G, '8-byte Value Parameter');
                    Incr(1); Indent(Index);
                    Operator;
                    END;
               188: BEGIN {BC}
                    PutLineS(G, 'Large Value Parameter');
                    Incr(1); Indent(Index);
                    PrintHex(4); Incr(2); PutcF(G, IONewline);
                    Indent(Index);
                    Operator;
                    END;
               189: BEGIN {BD}
                    PutLineS(G, 'Set Value Parameter');
                    Incr(1); Indent(Index);
                    PrintHex(2); Incr(1); PutcF(G, IONewline);
                    Indent(Index);
                    Operator;
                    END;
               191: BEGIN {BF}
                    PutLineS(G, 'User Function/Procedure Parameter');
                    Indent(Index); Incr(1);
                    PrintHex(4); Incr(2); PutcF(G, IONewline);
                    END;
            END {case}
         ELSE
            Unknown;
      END; {ProFun}

   PROCEDURE Operator;

      VAR
         other: Boolean;

      BEGIN {Operator}
         IF pAbortFlag THEN Stop;
         NexTok := Token;
         PrintHex(2);
         Space := Space+2;
         other := True;
         IF NexTok IN [0..63, 144..191, 251..253] THEN
            CASE NexTok OF
               0:   Unknown;
               1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11:
                    VarRef;
               12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22:
                    AddOp;
               23, 24, 25, 26, 27, 28, 29, 30, 31:
                    Cont;
               32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47:
                    AssignOp;
               48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63:
                    DatCon;
               144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159:
                    StrgOp;
               160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175:
                    SetOp;
               176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 251, 252, 253:
                    ProFun;
            END {case}
         ELSE IF (NexTok>=64) AND (NexTok<=143) THEN
            ScalOp
         ELSE IF (NexTok>=192) AND (NexTok<=254) THEN
            Control
         ELSE IF (NexTok=255) THEN
            BEGIN
            Flag := True;
            Indent(30-Space);
            PutLineS(G, '***** End of File *****');
            Incr(1);
            END;
         IF BlkFlag THEN
            BEGIN
            PutcF(G, IONewline);
            Indent(20);
            PutLineS(G, Concat('****** I-CODE BLOCK ', PutIntP(BlkNum, 1)^,
                               ' ******'));
            PutcF(G, IONewline);
            BlkFlag := False;
            END;
      END; {Operator}

   PROCEDURE Inface;

      VAR
         i: Integer;
         Ok: Boolean;
         Ch: Char;

      BEGIN {Inface}
         FN := '';
         REPEAT
            Write('Input file: [.I] ', FN);
            ReadKeyboard(@FN, [Chr(0)..Chr(255)], [SUCr, SUEsc], Ch, SUMaxStrLeng);
            IF Ch=SUEsc THEN Stop;
            WriteLn;
            SUTrimBlanks(@FN);
            FN2 := FN;
            Reset(F, FN);
            Ok := (IOResult<=0);
            IF NOT Ok THEN
               BEGIN
               FN2 := Concat(FN, '.I');
               Flag := True;
               Reset(F, FN2);
               Ok := NOT IOError(IOResult, 'Can''t open input file.');
               IF NOT Ok THEN
                  BEGIN
                  ScreenCtr(CupArrow); ScreenCtr(CupArrow); ScreenCtr(CupArrow); {3 VT's}
                  HaveError := True;
                  END;
               END;
         UNTIL Ok;
         FOpen := True;

         GN := '';
         REPEAT
            Write('Output file? [-CONSOLE] [.TEXT] ', GN);
            ReadKeyboard(@GN, [Chr(0)..Chr(255)], [SUCr, SUEsc], Ch, SUMaxStrLeng);
            IF Ch=SUEsc THEN Stop;
            WriteLn;
            SUTrimBlanks(@GN);
            IF Length(GN)=0 THEN GN := '-CONSOLE';
            Ok := NOT IOError(OpenF(GN, G, IOWrite, NIL), 'Can''t open output file');
            IF NOT Ok THEN
               BEGIN
               ScreenCtr(CupArrow); ScreenCtr(CupArrow); ScreenCtr(CupArrow); {3 VT's}
               HaveError := True;
               END;
         UNTIL Ok;
         GOpen := True;

         IsConsole := (G^.DevType=IOConsDev);
         WriteLn;
      END; {Inface}

   BEGIN {DumpIcode}
      GetTD(@TD);
      WriteLn;
      WriteLn('Lisa Pascal I-Code Dump, (C) 1984 Apple Computer, Inc. (Ver ',
              Version, ') - ', TD);
      WriteLn;
      WriteLn;

      FOpen := False;
      GOpen := False;
      G := NIL;

      IF NOT InitTool(False, '', '') THEN Exit(DumpIcode);

      Hexch := '0123456789ABCDEF';
      bIndex := 0; m := 0;
      Flag := False; BlkFlag := False;
      BlkNum := 0;
      Space := 0;

      Inface;

      Header;
      PutcF(G, IONewline);
      Indent(20);
      PutLineS(G, Concat('****** I-CODE BLOCK ', PutIntP(BlkNum, 1)^, ' ******'));
      PutcF(G, IONewline);
      k := BlockRead(F, B, 2); Dot; Dot;
      Incr(1); { same as bindex := 1 }
      Flag := False;

      REPEAT
         IF bIndex>512 THEN
            BlkIndx := (bIndex-512)-1
         ELSE
            BlkIndx := bIndex-1;
         S1 := PutIntP(BlkNum, 1)^; S2 := PutIntP(BlkIndx, 1)^;
         PutStrS(G, Concat('** I-CODE BLOCK [', S1, ', ', S2, ']'), 0);
         PutcF(G, IONewline);
         Operator;
         Space := 0;
      UNTIL Flag;

      Stop;
   END. {DumpIcode}

