{

 History
 -------

 11/09/85 - ecodes inserted, const MaxImpstr & type ImpStr defined, 
            field Adid inserted in RuntimeAddress & BlockLabel.
 23/09/85 - Pascal specific ecodes inserted.
 25/09/85 - PlabelId,GlaOffset,StatOffset,GSTOffset defined.
 07/10/85 - insert Ecodes LOADCAP & INDEXCAP.
 08/10/85 - modify IdRecord to fix variant access error. (agh)
 15/10/85 - add InputSpelling, OutputSpelling for file binding. (agh)
 16/10/85 - History tidied. (agh)
 16/10/85 - Value ForChar added to Repkind, TypeRepresentation
            simplified for ForSelector. CAPList removed and 
            StackOffset, ParamOffset re-typed to ByteRange in 
            FrameRecord. (agh)
 17/10/85 - declared LastFlowLine for diagnostics module. (agh)
 18/10/85 - declare FirstChoice for better error recovery. (agh)
 22/10/85 - simplify FrameRecord and ManualList for file
            initialisations. Delete ItemShapes. (agh)
 22/10/85 - Add Pascal ecodes PRESETFILE and POSTSETFILE. 
            Interim definition of MCFCBSize. (agh)
 22/10/85 - Remove PresetCode and PostsetCode from Type-
            Representation. (agh)
 23/10/85 - Add ParamCount field to FrameRecord for proc declaration/
            call consistency check. (agh)
 23/10/85 - Add declarations of 5-, 11-, 16-, 22-Value for default
            write field-widths. (agh)
 25/10/85 - Simplify heap-request records. (agh)
 25/10/85 - Add interim Pascal Special E-codes. (agh)
 25/10/85 - Add ParamSpace mods to simplify procedure call. (agh)
 28/10/85 - Delete TypeActions, simplify BpRecord, modify 
            ActualRecord. (agh)
 28/10/85 - Add E-codes CHKUNDEF, CHKNEW2 and LAZYOP for heap-checks 
            and lazy i/o. Remove all declarations ralating to ancillary
             check-operations. (agh)
 28/10/85 - Delete redundant declaration of AccessCodes. (agh)
 06/11/85 - Extend stack node for ICL standard operations. (agh)
 06/11/85 - Add ICL special E-codes ICLPDT, ICLPTM, ICLPSH,
            ICLPROT. (agh)
 07/11/85 - Add unary operation ConvertOp for integer-integer
            conversion. (agh)
 08/11/85 - Replace Jump field for Conditions by BooleanOp field
            for easier manipulation of compound Boolean expressions. 
            Remove IfFalseConditional and IfTrueConditional. (agh)
 08/11/85 - Add ShortCircuit as Boolean control option. (agh)
 11/11/85 - Add IsCheck ActualKind value for range-check control
            when passing a bounded-conformant array to an unbounded
            conformant array. (agh)
 12/11/85 - Modify Offset field of RuntimeAddress to take negative
            offsets when negative stack model is used. (agh)
 15/11/85 - Modify CaseLabelRecord and CaseRecord for label ranges
            otherwise clause. (agh)
 22/11/85 - Set ICLWord to word, add WordBounds flag to IndexRecord
            and BpRecord. (agh)
 23/11/85 - Add E-codes for unsigned arithmetic and array access.
            (agh)
 29/11/85 - Add HeapRef to identify p^ factors. (agh)
 01/12/85 - Changes to TypeRepresentation, FieldOffset, StackNode
            and OptionType to support bit-level packing.
 04/12/85 - Remove CHKLWD, CHKUPD, CHKATFR, CHKCTFR. (agh)
 04/12/85 - Add CAPOp as a binary operation. Change CAPLoad to
            CAPSize. (agh)
 04/12/85 - Remove all conformant array E-codes. Add INDEXP and
            CAPMOVE. (agh)
 05/12/85 - Add type Intrinsic defining run-time system routines.
            (agh)
 08/12/85 - Remove redundant E-codes. (agh)
 09/12/85 - Re-name Pascal Op-codes for consistency. (agh)
 ----------------------------------------------------------------------
 12/12/85 - Add complete set of string E-codes and re-order. (agh)
 12/12/85 - Improve option-handling for real-precision. (agh)
 13/12/85 - Adjust E-code definitions agains. (agh)
 ----------------------------------------------------------------------
 04/02/86 - Add BNOT to E-machine instruction set
                                                                        }
{


                           MODULE 2
 
 
                      Global Definitions
                       and Declarations
 
 
 
 
 
 Because of the rigid order of definitions and declarations imposed
 by  Pascal, this module contains all of the global definitions and
 declarations on which the procedures  in  the  subsequent  modules
 depend.  In  this  module,  only a brief indication of the overall
 nature of the constants, types and variables introduced is  given,
 together  with a reference to the module in which they are used. A
 more detailed explanation of the nature and  purpose  of  each  is
 given in the referenced module itself.

                                                                     }

const

   { constants used by pnx-dependent code in modules 3 and 4 }

   MaxArgString   = 80 ;                { maximum size of argument string }
   MaxArgs        = 6 ;                 { maximum number of arguments }
   BufferSize     = 512 ;               { disk buffer size in bytes }
   Null           = 0 ;                 { ASCII null character }
   BackSpace      = 8 ;                 { ASCII back-space character }
   Tab            = 9 ;                 { ASCII tab character }
   NewLine        = 10 ;                { ASCII new line character }
   FormFeed       = 12 ;                { ASCII form-feed character }
   CarriageReturn = 13 ;                { ASCII carriage-return character }
   BackSlash      = 92 ;                { ASCII  back-slash character }

   { constants used by the option-handler, module 3 }

   Level0         = 0 ;                 { conform to ISO 7185, level 0 }
   Level1         = 1 ;                 { conform to ISO 7185, level 1 }
   Level2         = 2 ;                 { conform to ICL Pascal, level 2 }
   Level3         = 3 ;                 { conform to ICL Pascal, level 3 }
   OptionFlag     = '$' ;               { introduce option-list }
   OptionSize     = 12 ;                { size of string below }
   UnknownOption  = '            ' ;    { denotes unknown option }
   FileWarning    = 'Error summary not found.' ;

   { constants used by the source handler, module 5 }

   LinesPerPage   = 60 ;                { source-text lines per page }
   BannerTitleSize = 24 ;               { length of banner titles }
   ProgName       = 'ICL Pascal - Version v.r' ;
   VerNumPos      = 22 ;                { position of 'v' in above }
   RelNumPos      = 24 ;                { position of 'r' in above }
   VerNum         = 4 ;                 { compiler version }
   RelNum         = 1 ;                 { compiler release }
   LineMax        = 132 ;               { maximum length of source line }
   StartCode      = 0 ;                 { analysis error code base }
   MaxCode        = 499 ;               { total error range:     0..499 }
   AnalysisBase   = StartCode ;         { analysis errors:       1..300 }
   PredictedBase  = 300 ;               { runtime errors :     301..400 }
   SystemBase     = 400 ;               { system limit errors: 401..420 }
   FatalBase      = 420 ;               { fatal errors:        421..450 }
   OptionBase     = 450 ;               { option errors:       451..470 }
   PragmaticBase  = 470 ;               { pragmatic errors:    471..490 }
   WarningBase    = 490 ;               { warning errors:      491..500 }
   LinesPerText   = 2 ;                 { lines per error text }

   { constant used by the diagnostics handler, module 7 }

   NilSerial = 0 ;                      { unallocated serial number }

   { constants used by the lexical analyser, module 8 }

   NoWords = 54 ;                       { upper bound of word symbol table }
   AlfaSize       = 12 ;                { size of alfa header string }
   EquivSize      = AlfaSize ;          { identifier equivalence measure }
   ChunkLength    = 4 ;                 { size of trailing alfa chunks }
   DefaultSpelling = '????????????' ;   { default alfa-header }

   { constants used in semantic analysis, module 10 }

   DispLimit = 20 ;                     { upper bound of display }
   GlobalLevel = 1 ;                    { scope level of program block }


{************************************************************************}
{*****        constants used by the object program generator       ******}
{************************************************************************}

   Pascal = 14 ;                        { language code }

   { constants describing the E-machine }

   MCBitsPerWord  = 32 ;                { bits per memory-word }
   MCBitsPerHalfWord = 16 ;            { mcbitsperword div 2 }
   MCWordSetBits  = 31 ;                { bits per set-word }
   MCBitsPerByte  = 8  ;                { bits per memory-byte }
   MCBytesPerWord = 4  ;                { mcbitsperword div mcbitsperbyte }
   MCBytesPerHalfWord = 2 ;             { mcbytesperword div 2 }
   MCMaxBitNum    = 31 ;                { mcbitsperword-1 }
   MCMaxSetBit    = 30 ;                { mcwordsetbits-1 }
   MCMaxByteNum   = 3 ;                 { mcbytesperword-1 }

   MCMaxint       = 2147483647 ;        { max mc-integer value }
   MCMaxDigits    = 10 ;                { digits in mcmaxint }
   MCMaxintDiv10  = 214748364 ;         { mcmaxint div 10 }
   MCMaxintMod10  = 7 ;                 { mcmaxint mod 10 }

   MCMaxHalfWord  = 65535 ;             { halfword: 2**16 - 1 }
   MCMaxWord      = 16#FFFFFFFF;        { assumes MCBitsPerWord = 32 }
   MCMaxReal      = maxint ;            { interim value }
   MCMaxRealSize  = 2 ;                 { max real size (words) }
   MCMaxByte      = 255 ;               { max mc-byte value }
   MCUndefinedChar= 255 ;               { 'undefined' character value }
   MCMaxChar      = 255 ;               { max mc-char value }
   MCMaxSet       = 256 ;               { maximum members per set }
   MCMaxMemByte   = 16777215;           { max byte address: 2**24 - 1 }
   MCMaxMemWord   = 4194303 ;           { max word address }

   MCNegativeStackFlag = 0 ;            { control stack layout }
   MCPfParamSize  = MCBytesPerWord ;    { formal proc/func param-size }
   MCFCBSize      = 32 ;                { byte size of file control block }
   MCFirstOffset  = 0 ;                 { first available frame offset }
   MCCAPBpSize    = 3 ;                 { conformant array parameter }
                                        { bound pair block size (words) }
   MCBufferOffset = 8 ;                 { buffer-variable offset in text }
                                        { file variable control block    }



{************************************************************************}
{*****                  E-machine instruction set                  ******}
{************************************************************************}

{00}     HALT =   0 ;
{00}     NOOP =   0 ; 

{ -------------------------- 32-bit (Etos) ----------------------------- }
 
{01}     IADD =   1;     { (Etos-1) + (Etos) => (Etos)   }
{02}     ISUB =   2;     { (Etos-1) - (Etos) => (Etos)   }
{03}    IMULT =   3;     { (Etos-1) * (Etos) => (Etos)   }
{04}    INDIV =   4;     { (Etos-1) / (Etos) => (Etos)   }
{05}     INEG =   5;     {          - (Etos) => (Etos)   }
{06}     IABS =   6;     {     abs( (Etos) ) => (Etos)   }
{07}     IREM =   7;     { remainder from                }
                         {  (Etos-1) / (Etos)=> (Etos)   }
 
{08}     IAND =   8;     { (Etos-1) & (Etos) => (Etos)   }
{09}      IOR =   9;     { (Etos-1)   (Etos) => (Etos)   }
{0A}     INOT =  10;     {          ~ (Etos) => (Etos)   }
{0B}     IXOR =  11;     { (Etos-1)    (Etos) => (Etos)  }
{0C}    ISHLL =  12;     { (Etos-1) << (Etos) => (Etos)  }
{0D}    ISHRL =  13;     { (Etos-1) >> (Etos) => (Etos)  }
{0E}    ISHLA =  14;     { arithmetic left shift         }
{0F}    ISHRA =  15;     { arithmetic right shift        }
 
{10}      IGT =  16;     { if                            }
{11}      ILT =  17;     {    (Etos-1) <relop> (Etos)    }
{12}      IEQ =  18;     { then                          }
{13}      INE =  19;     {    true  (1) => (Etos)        }
{14}      IGE =  20;     { else                          }
{15}      ILE =  21;     {    false (0) => (Etos)        }
{16}	 BNOT =  22;	 {  (Etos) = BNOT (Etos) 0<->1   } 
{18}     JIGT =  24;     { if                            }
{19}     JILT =  25;     {    (Etos-1) <relop> (Etos)    }
{1A}     JIEQ =  26;     { then                          }
{1B}     JINE =  27;     {    -> <label>                 }
{1C}     JIGE =  28;     { else                          }
{1D}     JILE =  29;     {    continue                   }
 
{ -------------------------- generic (Etos) ---------------------------- }
 
{1E}   JINTGZ =  30;     { if (Etos) > 0 %then -> <lab>  }
{1F}   JINTLZ =  31;     { if (Etos) < 0 %then -> <lab>  }
{20}    JINTZ =  32;     { if (Etos) = 0 %then -> <lab>  }
{21}   JINTNZ =  33;     { if (Etos) # 0 %then -> <lab>  }
{22}  JINTGEZ =  34;     { if (Etos) >=0 %then -> <lab>  }
{23}  JINTLEZ =  35;     { if (Etos) <=0 %then -> <lab>  }
  
{24}     ITWB =  36;     { if (Etos) < 0 then -> <lab1>  } 
                         {           = 0 then -> <lab2>  }
                         {           > 0 then -> <lab3>  }
 
{26}     JUMP =  38;     { -> <label>                    }
{29}      SFA =  41;     { SF => (Etos)                  }
{2A}   RETURN =  42;     { procedure exit                }
{2B}     ASF  =  43;     { SF = SF + (Etos)              }
 
{2C}    IPUSH =  44;     { (Etos) => (Mstack)            }
{2D}     IPOP =  45;     { (Mstack) => (Etos)            }
{2E}     EXCH =  46;     { (Etos-1) <=> (Etos)           }
{2F}     DUPL =  47;     { replicate (Etos)              }
{30}  DISCARD =  48;     { discard (Etos)                }
 
{33}   INDEX1 =  51;     { (@ Etos-1) + (Etos)           }
                         {               => (@ Etos)     }
{34}   INDEX2 =  52;     { (@ Etos-1) + (Etos)*2         }
                         {               => (@ Etos)     }
{35}   INDEX4 =  53;     { (@ Etos-1) + (Etos)*4         }
                         {               => (@ Etos)     }
{36}   INDEX8 =  54;     { (@ Etos-1) + (Etos)*8         }
                         {               => (@ Etos)     }
{37}    INDEX =  55;     { (@ Etos-2)                    }
                         {     + (Etos-1)*(Etos)         }
                         {               => (@ Etos)     }
 
{38}      MVB =  56;     { move (Etos) bytes             }
                         {  ((@ Etos-2)) => ((@ Etos-1)) }
 
{39}      CHK =  57;     { check that                    }
                         { (Etos-1)<=(Etos-2)<=(Etos)    }
                         { (Etos-2) => (Etos)            }
 
{3A}    TMASK =  58;     { (Etos-1) & (Etos)             }
                         { - to be followed by JI[N]Z    }
 
{3E}    CPBGT =  62;     { if (Etos) bytes               }
{3F}    CPBLT =  63;     {  ((Etos-2)) <relop> ((Etos-1))}
{40}    CPBEQ =  64;     { then                          }
{41}    CPBNE =  65;     {    true  (1) => (Etos)        }
{42}    CPBGE =  66;     { else                          }
{43}    CPBLE =  67;     {    false (0) => (Etos)        }

{ --------------------- generic unsigned operations -------------------- }

{50}     UADD =  80;     { (Etos-1) + (Etos) => (Etos)   }
{51}     USUB =  81;     { (Etos-1) - (Etos) => (Etos)   }

{52}      UGT =  82;     { if                            }
{53}      ULT =  83;     {    (Etos-1) <relop> (Etos)    }
{54}      UEQ =  84;     { then                          }
{55}      UNE =  85;     {    1 => (Etos)                }
{56}      UGE =  86;     { else                          }
{57}      ULE =  87;     {    0 => (Etos)                }
 
{58}     JUGT =  88;     { if                            }
{59}     JULT =  89;     {    (Etos-1) <relop> (Etos)    }
{5A}     JUEQ =  90;     { then                          }
{5B}     JUNE =  91;     {    -> <label>                 }
{5C}     JUGE =  92;     { else                          }
{5D}     JULE =  93;     {    continue                   }

{5E}    JUGTZ =  94;     { if (Etos) > 0 %then -> <lab>  }
{5F}    JULTZ =  95;     { if (Etos) < 0 %then -> <lab>  }
{60}    JUEQZ =  96;     { if (Etos) = 0 %then -> <lab>  }
{61}    JUNEZ =  97;     { if (Etos) # 0 %then -> <lab>  }
{62}    JUGEZ =  98;     { if (Etos) >=0 %then -> <lab>  }
{63}    JULEZ =  99;     { if (Etos) <=0 %then -> <lab>  }

{ ----------------------- generic real operations ---------------------- }
 
{71}     RADD = 113;     { (Etos-1) + (Etos) => (Etos)    }
{72}     RSUB = 114;     { (Etos-1) - (Etos) => (Etos)    }
{73}    RMULT = 115;     { (Etos-1) * (Etos) => (Etos)    }
{74}    RLDIV = 116;     { (Etos-1) / (Etos) => (Etos)    }
{75}     RNEG = 117;     {        - (Etos) => (Etos)      }
{76}     RABS = 118;     {   abs( (Etos) ) => (Etos)      }
 
{88}    CVTII = 136;     { (int Etos-1) => int size(Etos) }
{89}    CVTIR = 137;     { (int Etos-1) => real size(Etos)}
{8A}    CVTRR = 138;     { (real Etos-1)=> real size(Etos)}
{8B}    TNCRI = 139;     { (real Etos-1)=> int size(Etos) }
{8C}    RNDRI = 140;     { (real Etos-1)=> int size(Etos) }
 
{ ----------------------- generic real operations --------------------- }
 
{90}      RGT = 144;     { if                            }
{91}      RLT = 145;     {    (Etos-1) <relop> (Etos)    }
{92}      REQ = 146;     { then                          }
{93}      RNE = 147;     {    1 => (Etos)                }
{94}      RGE = 148;     { else                          }
{95}      RLE = 149;     {    0 => (Etos)                }
 
{96}     JRGT = 150;     { if                            }
{97}     JRLT = 151;     {    (Etos-1) <relop> (Etos)    }
{98}     JREQ = 152;     { then                          }
{99}     JRNE = 153;     {    -> <label>                 }
{9A}     JRGE = 154;     { else                          }
{9B}     JRLE = 155;     {    continue                   }
 
{9C}     JRGZ = 156;     { if (Etos) > 0 then -> <lab>   }
{9D}     JRLZ = 157;     { if (Etos) < 0 then -> <lab>   }
{9E}      JRZ = 158;     { if (Etos) = 0 then -> <lab>   }
{9F}     JRNZ = 159;     { if (Etos) # 0 then -> <lab>   }
{A0}    JRGEZ = 160;     { if (Etos) >=0 then -> <lab>   }
{A1}    JRLEZ = 161;     { if (Etos) <=0 then -> <lab>   }
 
{A2}     RTWB = 162;     { if (Etos) < 0 then -> <lab1>  }
                         {           = 0 then -> <lab2>  }
                         {           > 0 then -> <lab3>  }
{A3}    JTRUE = 163;     { if (Etos) true  then -> <lab  }
{A4}   JFALSE = 164;     { if (Etos) false then -> <lab> }
 
{ ---------------------------------------------------------------------- }
 
{B1}   UCHECK = 177;     { if (Etos) unassigned diagnose  }
{B8}   ESTORE = 184;     { ((Etos)) = (Etos-1)            }
{B9}   EDUPSTORE = 185;  { ((Etos)) = (Etos-1)            }
                         { retain (Etos-1) as new (Etos)  }
{BA}   PUSHVAL = 186;    { push (Etos) as value param     }
{BB}   PUSHADDR = 187;   { push (Etos) as ref param       }
{BC}   EVAL = 188;       { force load of (Etos)           }
{BD}   EVALADDR = 189;   { force load of @ at (Etos)      }
{BE}   EADDRESS = 190;   { address(Etos) is required      }
{BF}   EINTRES = 191;    { (Etos) is integer fn result    }
{C0}   EREALRES = 192;   { (Etos) is real fn result       }
{C1}   ESIZE = 193;      { size of (Etos-1) is (Etos)     }

{C2}   EPOWER = 194;     { (Etos-3) @ result if cx        }
                         { (Etos-2) base (@ base if cx)   }
                         { (Etos-1) power(@ power if cx)  }
                         { (Etos)   procindex             }

{C3}  EPOWERI = 195;    { (Etos-2) base                  }
                        { (Etos-1) power (int)           }
                        { (Etos)   procindex (0-3)       }

                        { procindex =  0  powii          }
                        {              1  powri          }
                        {              2  powdi          }
                        {              3  powqi          }
                        {              4  powci          }
                        {              5  powzi          }
                        {              6  powzzi         }
                        {              9  powrr          }
                        {             10  powdd          }
                        {             11  powqq          }
                        {             12  powcc          }
                        {             13  powzz          }
                        {             14  powzzz         }

{C4}  ARGPROC = 196;    { call formal procedure in (Etos)}
{C5}  PUSHBYTES = 197;  { push (Etos) bytes from         }
                        { (@ Etos-1) as value parameter  }
 
{************************************************************************}
{***** 		   Pascal specific codes		           ******}
{************************************************************************}

   { String operations }

   STRGT = 511;         { if                             }
   STRLT = 512;         {    (Etos-1) <relop> (Etos)     }
   STREQ = 513;         { then                           }
   STRNE = 514;         {    1 => (Etos)                 }
   STRGE = 515;         { else                           }
   STRLE = 516;         {    0 => (Etos)                 }

   { Pointer operations }

   PTREQ = 520;         { if                             }
   PTRNE = 521;         {    (Etos-1) <relop> (Etos)     }
                        { then                           }
                        {   1 => (Etos)                  }
                        { else                           }
                        {   0 => (Etos)                  }

   { Set operations }

   SETI     = 530;      {  (Etos-1) * (Etos) => (Etos)   }
   SETU     = 531;      {  (Etos-1) + (Etos) => (Etos)   }
   SETD     = 532;      {  (Etos-1) - (Etos) => (Etos)   }
   SETLE    = 533;      {  if                            }
   SETEQ    = 534;      {     (Etos-1) <relop> (Etos)    }
   SETNE    = 535;      {  then                          }
   SETIN    = 536;      {     1 => (Etos)                }
                        {  else                          }
                        {     0 => (Etos)                }

   SETSING  = 537;      {  [(Etos)] => (Etos)            }
   SETRANGE = 538;      {  [(Etos-1)..(Etos)] => (Etos)  }

   { Array operations }

   CAPMOVE  = 547;      {  move (Etos-1) bytes from      }
                        {  ((@ Etos-2)) => ((@ Etos))    }
   INDEXP   = 548;      {  construct packed field        }
                        {  descriptor from               }
                        {  (@ Etos-2)- array base        }
                        {  (Etos-1)  - index value       }
                        {  (Etos)    - elements per word }

   { File and i/o operations }

   EOFOP       = 559;   { if                             }
   EOLOP       = 560;   {    fn((@ Etos))                }
                        { then                           }
                        {    1 => (Etos)                 }
                        { else                           }
                        {    0 => (Etos)                 }
   LAZYOP      = 574;   { fn((@ Etos)) => (Etos)         }
   
   { Standard ordinal procedures }

   ISQR   = 601;        {  fn(Etos)   => (Etos)          }
   IODD   = 602;        {  fn(Etos)   => (Etos)          } 
   ISUCC  = 603;        {  (Etos) + 1 => (Etos)          }
   IPRED  = 604;        {  (Etos) - 1 => (Etos)          }
   UODD   = 605;        {  fn(Etos)   => (Etos)          }
   USUCC  = 606;        {  (Etos) + 1 => (Etos)          }
   UPRED  = 607;        {  (Etos) - 1 => (Etos)          }

   { Standard real procedures }

   RSQR   = 611;        {  fn(Etos)   => (Etos)          }

   { Integer range-checking operations }

   CHKLT     = 620;     {  if                            }
   CHKGT     = 621;     {    (Etos-2) <relop> (Etos-1)   }
   CHKNE     = 629;     {  then                          }
                        {    trap((Etos))                }
                        {  else                          }
                        {    (Etos-2) => (Etos)          }
   CHKRNG    = 622;     {  if                            }
                        {    (Etos-3) < (Etos-2) or      }
                        {    (Etos-3) > (Etos-1)         }
                        {  then                          }
                        {    trap((Etos))                }
                        {  else                          }
                        {    [(Etos-3)] => [(Etos)]      }

   { Set range-checking operations }

   CHKSETGT  = 623;     {  if                            }
                        {    max([(Etos-2)]) > (Etos-1)  }
                        {  then                          }
                        {    trap((Etos))                }
                        {  else                          }
                        {    (Etos-2) => (Etos)          }
   CHKSETRNG = 624;     {  if                            }
                        {    min([(Etos-3)]) < (Etos-2)  }
                        {  or                            }
                        {    max([Etos-3)]) > (Etos-1)   }
                        {  then                          }
                        {    trap((Etos))                }
                        {  else                          }
                        {    [(Etos-3)] => [(Etos)]      }

   { Unsigned range-checking operations }

   UCHKLT   = 625;      {  if                            }
   UCHKGT   = 626;      {    (Etos-2) <relop> (Etos-1)   }
   UCHKNE   = 627;      {  then                          }
                        {    trap((Etos))                }
                        {  else                          }
                        {    (Etos-2) => (Etos)          }
   UCHKRNG  = 628;      {  if                            }
                        {    (Etos-3) < (Etos-2) or      }
                        {    (Etos-3) > (Etos-1)         }
                        {  then                          }
                        {    trap((Etos))                }
                        {  else                          }
                        {    [(Etos-3)] => [(Etos)]      }

   { Other checking operations }

   CHKNEW2  = 630;      {  if                            }
                        {    ((@ Etos)-2) <> 0           }
                        {  then                          }
                        {    trap(325)                   }
   CHKUNDEF = 631;      {  if  (Etos) undefined          }
                        {  then trap(343)                }
   SETUNDEF = 632;      {  ((@ Etos)) <- undefined       }
   TRAP     = 633;      {  trap((Etos))                  }

   { ICL Standard operations }

   ICLPSH   = 642;      { (Etos-1) shift (Etos) => (Etos) }
   ICLPROT  = 643;      { (Etos-1) rotate (Etos)=> (Etos) }


{************************************************************************}
{*****                   end of instruction set                    ******}
{************************************************************************}

   { constants used by the object-program generator, modules 12 - 27 }

   MaxLiteral     = 64;                 { max literal constant word length }
   MaxImpStr 	  = 255 ;		{ max size of Imp string }
   MaxCaseGap     = 10 ;                { max permissable discontinuity }


type


{************************************************************************}
{*****          types used by the source program analyser          ******}
{************************************************************************}


   { types used by pnx-dependent code in modules 4 and 5 }

   ArgIndex       = 1..MaxArgString;
   ArgSize        = 0..MaxArgString;
   ArgString      = packed array[ArgIndex] of char;
   ArgStringPtr  = ^ ArgString;
   ArgArray       = array[0..MaxArgs] of ArgStringPtr;
   ArgPointer     = ^ ArgArray;
   FileMode       = (ForReading, ForWriting, ForBoth);
   BufferPosition = 1..BufferSize;
   FileBuffer     = packed array[BufferPosition] of char;

   UnixFile       = record
                      Buffer: FileBuffer;
                      Descriptor, FileAddress: integer;
                      StartOfLine, EndOfLine, EndOfBuffer,
                      BufferIndex: BufferPosition;
                      Mode: FileMode;
                      EofFlag: Boolean
                    end;

   ImportEntry    = ^ ImportRecord;
   ImportRecord   = record
                      FileName: ArgString;
                      Next: ImportEntry
                    end;

   { types applied globally }

   HostWord       = integer ;
   Scalar         = 0..maxint ;

   DeclKind       = ( Predefined,Declared ) ;

   StdProcFuncs = (Getp,Putp,Closep,Resetp,Rewritep,Appendp,
                   Readp,Writep,Readlnp,Writelnp,Pagep,
                   Newp,Disposep,Packp,Unpackp,Linesp,Datep,Timep,
                   Absf,Sqrf,Oddf,Succf,Predf,Ordf,Chrf,Truncf,Roundf,
                   Sinf,Cosf,Expf,Lnf,Sqrtf,Arctanf,Eoff,Eolnf,
                   Sizef,Ptrf,CPtrf,Wrdf,Intf,MinValf,MaxValf,
                   AndWf,OrWf,NeqWf,NotWf,ShWf,RotWf,Floatf,
                   Recastf,CAPSizef) ;

   TypeForm = (Scalars,Subranges,Pointers,Arrays,CAPSchema,
               Records,Sets,Files,VariantPart,Variant) ;

   SetForms       = ( Unpacked,IsPacked,Constructed ) ;

   IdClass        = ( Domain,Types,Consts,Vars,Bound,
                      PresetVars,ReadOnlyVars,Field,Proc,Func,Prog);

   { types describing the E-machine }

   MCBit          = 0..1 ;
   MCByte         = 0..MCMaxByte ;
   MCHalfWord     = 0..MCMaxHalfWord ;
   MCWord         = HostWord ;          { target=host }
   MCScalar       = 0..MCMaxint ;
   MCIntegerForm  = HostWord ;          { MC-integer-space: target=host }
   MCRealForm     = real ;              { MC-real-space:    target=host }
   MCCharSet      = 0..MCMaxChar ;
   MCBitRange     = 0..MCBitsPerWord ;
   MCByteRange    = 0..MCBytesPerWord ;
   MCBitIndex     = 0..MCMaxBitNum ;
   MCSetBits      = 0..MCMaxSetBit ;
   MCBitSet       = set of MCBitIndex ;
   MCByteIndex    = 0..MCMaxByteNum ;
   MCByteArray    = packed array[MCByteIndex] of MCByte ;
   MCWordSet      = set of MCSetBits ;

   WordCast       = ( AsSet,AsBits,AsBytes,AsReal,AsValue ) ;
   MCWordForm     =  record
                       case WordCast of
                          AsSet   : ( WSet : MCWordSet ) ;
                          AsBits  : ( WBits : MCBitSet ) ;
                          AsBytes : ( WBytes : MCByteArray ) ;
                          AsReal  : ( WReal : MCRealForm ) ;
                          AsValue : ( WValue : MCWord ) 
                    end ;
   WordEntry      = ^ ListWord ;
   ListWord       = record
                       Word : MCWordForm ; Next : WordEntry
                    end ;
   LiteralIndex   = 1..MaxLiteral;
   LiteralBuffer  = array[LiteralIndex] of MCWord;

   ByteRange      = 0..MCMaxMemByte;
   WordRange      = 0..MCMaxMemWord;
   ByteOffsets    = -MCMaxMemByte..MCMaxMemByte;

   { types used by the option-handler, module 3 }

   OptionContext  = ( Locally,Globally) ;
   OptionClass    = ( BoolClass,IntClass ) ;
   OptionType     = ( Listing,Directives,Imports,Warnings,
                      RChecks,PChecks,UChecks,VChecks,HChecks,EChecks,
                      BitsPacked,ShortCircuit,Map,PMDump,
                      Level,Precision,Margin,Other ) ;
   BoolOptions    = Listing..PMDump ;
   IntOptions     = Level..Margin ;
   OptionIndex    = 1..OptionSize ;
   OptionString   = packed array[OptionIndex] of char ;
   SetOfOptions   = set of OptionType ;

   ICLDirectives  = (DoInclude,DoRead,DoPage,DoLines,
                     DoHeading,DoList,DoNothing);
   DirectiveString = OptionString;

   { types used by the source-handler, module 5 }

   PageDepth = 0..LinesPerPage;
   BannerPositions = 1..BannerTitleSize ;
   BannerString   = packed array[BannerPositions] of char ;
   DateString = packed array[1..8] of char ;
   ErrorSpan      = 0..MaxCode ;
   LinePosition = 1..LineMax ;

   TextPosition = record
                     LineNumber : Scalar ;
                     CharNumber : LinePosition
                  end ;

   ErrorEntry = ^ErrorRecord ;
   ErrorRecord = record
                   ErrorCode : ErrorSpan ;
                   ErrorPosition : TextPosition ;
                   Next : ErrorEntry
                 end ;

   ErrorList = record
                  First,Last : ErrorEntry
               end ;

   SourceEntry = ^ SourceRecord;
   SourceRecord = record
                    SourceFile: UnixFile;
                    FirstLine,BlankLine : Boolean ;
                    FirstRead,FirstNonBlank,LastNonBlank,
                    LastSignificant : BufferPosition ;
                    Position : TextPosition ;
                    ErrorsToReport,ErrorStarted,WarningsToReport: Boolean ;
                    ErrorsOnThisLine,EarlierErrors : ErrorList ;
                    Control: SetOfOptions;
                    Next: SourceEntry
                end ;


   { types used by the object-program generator interface, module 6 }

   ICLWord = word;

   ValueKind   = (OrdValue,IntValue,BoolValue,CharValue,RealValue,
                  BaseValue,SetValue,StringValue,PntrValue) ;
   ObjectValue    = record
                       WordSize : WordRange ;
                       case Kind : ValueKind of
                          OrdValue,
                          IntValue,
                          BoolValue,
                          CharValue :
                             ( Ival : MCIntegerForm ) ;
                          RealValue :
                             ( Rval : MCRealForm ) ;
                          BaseValue: 
                             ( Wval : ICLWord ) ;
                          SetValue :
                             ( Setval : WordEntry ) ;
                          StringValue :
                             ( Length : MCScalar ;
                               Stringval : WordEntry )   ;
                          PntrValue :
                             ( Pval : WordEntry )
                    end ;

   ValueDetails = record
                     Velue : ObjectValue ;
                     case Kind : ValueKind of
                        OrdValue   :
                           ( IVal : integer ) ;
                        BaseValue,
                        IntValue,
                        BoolValue,
                        CharValue,
                        RealValue,
                        SetValue,
                        StringValue:
                           ( Length : 0..LineMax ;
                             String : packed array [1..LineMax] of char) ;
                        PntrValue : ( )
                  end ;

   AddressLevel   = 0..DispLimit ;
   DataArea       = (Stack, Code, Gla, Parameter, SST, GST, Diagnostic,
                     Static, Iotables, Spare, Constants);
   RuntimeAddress = packed record
                       BlockLevel : AddressLevel ;
                       ByteOffset : ByteOffsets;
                       Area : DataArea ;
		       Adid : integer;
                    end ;
   AccessUnit = (Bits, Bytes, Words);
   FieldOffset    = packed record
                       ByteOffset : ByteRange ;
                       case FieldKind: AccessUnit of
                          Words : ( WordSize : WordRange ) ;
                          Bytes : ( ByteSize : MCByteRange ) ;
                          Bits  : ( BitSize : MCBitRange;
                                    BitOffset : MCBitIndex )
                    end ;

   BlockLabel     = packed record
                      BlockLevel: AddressLevel; LabelId, Adid: integer;
                    end;
   StatementLabel = integer ;
   CodeLabel      = integer ;

   ParamSpace = packed record
                  Number: Scalar; Size: ByteRange
                end ; 

   RepKind        = (ForScalar,ForChar,ForWord,ForSet,ForArray,
                     ForARecord,ForVntRecord,ForFile,ForPnter,
                     ForVariant,ForSelector,ForCAP, ForReal,ForString,
                     ForOther);

   TypeRepresentation = packed record
                           WordSize: WordRange ;
                           ByteSize : MCByteRange ;
                           BitSize : MCBitRange ;
                           case Kind : RepKind of
                             ForSet,
                             ForChar,
                             ForScalar:
                               ( Min,Max : MCIntegerForm );
                             ForWord:
                               ( WMin,WMax : ICLWord );
                           otherwise
                              ( )
                        end ;

   JumpType        = ( IfFalse,IfTrue,Absolute );

   StackTop        = (TopOfStack,NextToTop) ;
   OutputKind      = (IntKind,RealKind,CharKind,BoolKind,
                      WordKind,StringKind,CAPKind,DefaultKind ) ;
   InputKind       =  IntKind..CharKind ;
   FormatKind      = (Default,Floating,Fixed) ;
   IOFormat        = (Standard,Named,Flagged,Repeated,Full);

   { types used by the diagnostics handler, module 7 }

   SerialRange = Scalar ;

   { types used by the lexical analyser, module 8 }

   SymbolType = (Ident,IntConst,RealConst,CharConst,StringConst,NilSy,
                 NotSy,MulOp,AddOp,RelOp,
                 LeftParent,RightParent,LeftBracket,RightBracket,
                 Comma,Semicolon,Period,Arrow,Colon,Becomes,Thru,
                 LabelSy,ConstSy,TypeSy,VarSy,FuncSy,ProcSy,
                 PackedSy,ArraySy,RecordSy,SetSy,FileSy,
                 BeginSy,IfSy,CaseSy,RepeatSy,WhileSy,ForSy,WithSy,GoToSy,
                 EndSy,ThenSy,ElseSy,UntilSy,OfSy,DoSy,ToSy,
                 ProgramSy,PresetOp,
                 BasedConst,ExternSy,VisibleSy,PresetSy,ReadOnlySy,
                 PragmaSy,OccupiesSy,OtherwiseSy,Bar,Shriek,OtherSy) ;

   OpType     = ( Mul,RDiv,AndOp,IDiv,IMod,Plus,Minus,OrOp,
                  LtOp,LeOp,GeOp,GtOp,NeOp,EqOp,InOp,NotOp,
                  SingleOp,RangeOp,CAPOp ) ;

   AlfaIndex      = 1..AlfaSize ;
   AlfaHead       = packed array[AlfaIndex] of char ;
   AlfaEntry = ^AlfaRecord ;
   AlfaRecord = record
                   Chunk : packed array[1..ChunkLength] of char ;
                   NextChunk : AlfaEntry
                end ;
   Alfa = record
             Head, Copy : AlfaHead ;
             Tail : AlfaEntry
          end ;
   CharSet = set of char;
   BaseValues = 2..16;

   { type used by syntax analysis and recovery, module 9 }

   SetOfSymbols = set of SymbolType ;

   { types used in static semantic analysis, modules 10,11 }

   TypEntry = ^TypeRecord ;
   IdEntry = ^IdRecord ;
   FormalEntry = ^FormalRecord ;
   LabelEntry = ^LabelRecord ;
   ScopeCopy = ^ScopeRecord ;

   ListEntry  = ^ListRecord ;
   ListRecord = record Id : IdEntry ; Next : ListEntry end ;
   IdList = record FirstEntry,LastEntry : ListEntry end ;

   IdSet = IdList ;

   CAPBound = record
                Address: RuntimeAddress;
                case Fixed: Boolean of
                  false : ( );
                  true :  (Value: ObjectValue)
              end;
   TypeRecord = record
                   Serial : SerialRange ;
                   Occupying : TypEntry;
                   Next : TypEntry ;
                   Representation : TypeRepresentation ;
                   case Form : TypeForm of
                      Scalars :
                         (case ScalarKind : DeclKind of
                             Predefined : ( ) ;
                             Declared : (FirstConst : IdEntry)) ;
                      Subranges :
                         (RangeType : TypEntry ;
                          Min,Max : ObjectValue) ;
                      Pointers :
                         (DomainType : TypEntry) ;
                      Sets :
                         (FormOfset : SetForms ;
                          BaseType : TypEntry ) ;
                      Arrays :
                         (PackedArray,StringConstant : Boolean ;
                          AelType,InxType : TypEntry) ;
                      CAPSchema :
                         (PackedSchema,ValueSchema,
                          FirstIndex, Bounded : Boolean ;
                          CompType,InxSpec : TypEntry ;
                          LowBound, HighBound: CAPBound ) ;
                      Records :
                         (FileFree,PackedRecord : Boolean ;
                          FieldScope : IdEntry ;
                          FixedPart : IdEntry ;
                          VarPart : TypEntry) ;
                      Files :
                         (PackedFile,TextFile : Boolean ;
                          FelType : TypEntry) ;
                      VariantPart :
                         (TagType : TypEntry ;
                          VntFileFree: Boolean ;
                          TagField,SelectorField : IdEntry ;
                          DefaultVariant,FirstVariant : TypEntry) ;
                      Variant :
                         (VarFileFree,Distinct : Boolean ;
                          SubFixedPart : IdEntry ;
                          NextVariant,SubVarPart : TypEntry ;
                          VariantValue1, VariantValue2: ObjectValue)
                end ;

   SetOfIdClass = set of IdClass ;
   IdKind = (Actual,Formal) ;
   KindOfVar = (ValueParam,VarParam,LocalVar,
                ReadOnlyParam, ExternalVar, VisibleVar) ;
   KindOfBlock = (LocalBlock, VisibleBlock, ExternalBlock, InternalBlock);
   ScopeNumber = integer ;

   IdRecord = record
                 Serial : SerialRange ;
                 Name : Alfa ;
                 LastUse : ScopeNumber ;
                 LeftLink,RightLink : IdEntry ;
                 IdType : TypEntry ;
                 Referenced : Boolean ;
                 case Klass : IdClass of
                    Domain,
                    Types :
                       ( ) ;
                    Consts:
                       ( Values : ObjectValue ;
                         SuccId : IdEntry ) ;
                    PresetVars, ReadOnlyVars,
                    Vars:
                       ( VarKind : KindOfVar ;
                         VarAddress : RunTimeAddress ) ;
                    Field:
                       ( Offset : FieldOffset ;
                         Tag : Boolean ; NextField : IdEntry ) ;
                    Bound :
                       ( BdAddress : RunTimeAddress ;
                         NextBound : IdEntry ) ;
                    Proc,
                    Func:
                       ( case PfDecKind : DeclKind of
                            Predefined:
                               ( PfIndex : StdProcFuncs ) ;
                            Declared:
                               ( Formals : FormalEntry ;
                                 FSpace: ParamSpace ;
                                 case PfKind : IdKind of
                                    Actual:
                                       ( CodeBody : BlockLabel ;
                                         Assignable : Boolean ;
                                         Assigned : Boolean ;
                                         BlockKind: KindOfBlock;
                                         FormalScope : ScopeCopy;
                                         case Forwrd : Boolean of
                                            false:
                                               ( Result : RunTimeAddress ) ;
                                            true :
                                               ( Declaration: TextPosition));
                                    Formal:
                                       ( FAddress : RunTimeAddress ))) ;
                    Prog:
                       ( ProgBody : BlockLabel )
              end ;

   ParmKind = (BoundParm,ValueParm,VarParm,ProcParm,FuncParm,ReadOnlyParm) ;
   FormalRecord = packed record
                     Next : FormalEntry ;
                     Section : Scalar ;
                     FormalType : TypEntry ;
                     case Parm : ParmKind of
                        ReadOnlyParm,
                        BoundParm,
                        ValueParm,
                        VarParm   : ( ) ;
                        ProcParm,
                        FuncParm  : ( ItsFormals : FormalEntry )
                  end ;

   LabelDepth = 1..maxint ;

   LabelRecord = record
                    LabelValue : ObjectValue ;
                    NextLabel : LabelEntry ;
                    LabelledCode : StatementLabel ;
                    case Defined : Boolean of
                       false :
                          (Declaration : TextPosition ;
                           MaxDepth : LabelDepth ) ;
                       true :
                          (case Accessible : Boolean of
                              false : ( ) ;
                              true : (DefinedDepth : LabelDepth ) )
                 end ;

   ProgPmEntry = ^ ProgPmRecord ;
   ProgPmRecord = record
                     Name : Alfa ;
                     Declaration : TextPosition ;
                     ParamId : IdEntry ;
                     NextParam : ProgPmEntry
                  end ;

   FrameEntry = ^ FrameRecord ;

   ScopeKind = ( ActualBlock,FormalBlock,RecordScope ) ;
   ScopeRecord = record
                    ScopeNo : ScopeNumber ;
                    Locals : IdEntry ;
                    case Scope : ScopeKind of
                       ActualBlock,
                       FormalBlock :
                          ( Threatened : IdSet ;
                            TypeChain : TypEntry ;
                            LabelChain : LabelEntry ;
                            SavedFrame: FrameEntry ) ;
                       RecordScope :
                          ( RecordType : TypEntry ;
                            ReadOnlyScope,
                            FieldsPacked : Boolean )
                 end ;

   DispRange = 0..DispLimit ;

   RefSecurity = ( Secure,MayBeInsecure ) ;



{************************************************************************}
{*****           types used by the object program generator        ******}
{************************************************************************}

   Ecodes         = Scalar;
   Pointer        = ^integer;

   { types used by the Imp interface }

   ImpStr 	  = packed array[0..MaxImpStr] of char;

   Intrinsic = (p_presetf, p_postsetf, p_bindf, p_get, p_put, p_close,
                p_resetf, p_rewritef, p_appendf, p_eof, p_eol, p_readi,
                p_readr, p_wri, p_wrfx, p_wrc, p_wrb, p_wrfl, p_wrw,
                p_wrst, p_rdln, p_wrln, p_lines, p_page, p_pack, p_unpack,
                p_new1, p_new2, p_dispose1, p_dispose2, p_sin, p_cos,
                p_exp, p_log, p_sqrt, p_arctan, p_icldate, p_icltime,
                p_mon, p_trap, p_init, p_end);

   { types used by the storage allocator, module 14 }

   ManualEntry    = ^ ManualItem ;
   ManualItem     = record
                       ItsType: TypEntry;
                       ItsOffset: FieldOffset ;
                       Repeated : Scalar ;
                       NextItem : ManualEntry
                     end ;
   ManualList     = record FirstEntry,LastEntry : ManualEntry end ;

   FrameRecord     = record
                        StackOffset, ParamOffset: ByteRange;
                        ParamCount: Scalar;
                        FileList: ManualList ;
                        Next: FrameEntry
                     end ;

   { types used by the object-program generator, modules 11 - 28 }

   StackEntry     = ^ StackNode ;
   IOFileEntry    = ^ IOFileRecord ;

   BoundTest      = (NoTest, LtTest, LtdTest, GtTest, GtdTest, 
                     NeTest, RngError);
   BpEntry        = ^ BpRecord ;
   BpRecord       = record
                       Size : ByteRange ;
                       Lower, Upper : MCIntegerForm ;
                       LowerTest, UpperTest: BoundTest;
                       WordBounds: Boolean;
                       case CAPBounds : Boolean of
                          false : ( ) ;
                          true  : ( BpAddress : RuntimeAddress )
                    end ;

   BoundForm = record
                 case Constant: Boolean of
                   false : ( Address : RuntimeAddress ) ;
                   true  : ( Value : MCIntegerForm )
               end ;
   RangeChkRecord = record
                      Lower, Upper: BoundForm
                    end;
   RangeEntry     = ^ RangeChkRecord ;

   ActualKind     = ( IsValue,IsVar,IsBlock,IsBounds,IsRef,IsCheck ) ;
   ActualEntry    = ^ ActualRecord ;
   ActualRecord   = record
                       Next : ActualEntry ;
                       case Kind : ActualKind of
                          IsValue,
                          IsRef,
                          IsVar,
                          IsBlock :
                             ( ActualParam: StackEntry ;
                               FormalRep: TypeRepresentation ) ;
                          IsBounds, IsCheck :
                             ( BdPair: BpEntry )
                    end ;

   IndexEntry     = ^ IndexRecord ;
   IndexRecord    = record
                       TheIndex : StackEntry ;
                       Factor : MCIntegerForm ;
                       Next : IndexEntry ;
                       WordBounds : Boolean;
                       case CAPIndex : Boolean of
                          false : ( Lower, Upper : MCIntegerForm ) ;
                          true  : ( BpAddress : RuntimeAddress ;
                                    LastLevel : Boolean )
                    end ;

   RefClasses     = ( VarRef, PnterRef, HeapRef, FileRef ) ;
   OperatorKind   = ( Unary, Binary, Stdrd, Condition, BlockCall, CAPSize,
                      RangeChk, ReadOp, ICLStdrd ) ;
   Unaries        = ( NegateOp, FloatOp, ConvertOp ) ;
   OperandKind    = ( AnInteger, AReal, ABoolean, ASet, AString, APointer,
                      AFile, AWord, ACAP );
   NodeKind       = ( Reference, BlockRef, Result, Address,
                      AConstant, Operation ) ;
   KindOfRangeCheck = (SubrangeChecks, WSubRangeChecks, 
                       TransferChecks, WTransferChecks,
                       MemberChecks) ;

   StackNode      = record
                       NextNode : StackEntry ;
                       DataRep : TypeRepresentation ;
                       StringBytes : MCScalar ;
                       MayHaveOverflowed : Boolean ;
                       RunError : Scalar ;
                       case Kind : NodeKind of
                          Reference :
                             ( BaseAddress : RuntimeAddress ;
                               Adjustment : ByteOffsets ;
                               Indirect : Boolean ;
                               AccessList : StackEntry ;
                               Class : RefClasses ;
                               case AccessKind: AccessUnit of
                                 Words, Bytes :
                                   ( ByteSize : ByteRange;
                                     case Indexed: Boolean of
                                       false : ( );
                                       true : ( Indices : IndexEntry ) ) ;
                                 Bits :
                                   ( BitSize, BitOffset : MCBitRange ;
                                     case IndexedBitField: Boolean of
                                       false : ( );
                                       true : (FieldIndex : IndexEntry)));
                          BlockRef :
                             ( CallToBeGenerated : Boolean ;
                               First, Last : ActualEntry ;
                               PSpace: ParamSpace ;
                               case BlockKind : IdKind of
                                  Actual : (BlockBase : BlockLabel) ;
                                  Formal : (FormalAddress: RuntimeAddress));
                          Result :
                             ( ) ;
                          Address :
                             ( case Loaded : Boolean of
                                  false : 
                                     ( ABitField: Boolean ;
                                       Descriptor : integer );
                                  true  : ( ) ) ;
                          AConstant :
                             ( TheConst : ObjectValue ) ;
                          Operation :
                             ( OpGroup : OperandKind ;
                               case OpForm : OperatorKind of
                                  Unary :
                                     ( UnaryEntry : StackEntry ;
                                       UnaryOp : Unaries ) ;
                                  Binary :
                                     ( LeftEntry,RightEntry : StackEntry ;
                                       BinaryOp : OpType ) ;
                                  Condition :
                                     ( BooleanOp : OpType ;
                                       OpList : StackEntry ) ;
                                  BlockCall :
                                     ( FnBlockEntry : StackEntry ) ;
                                  RangeChk :
                                     ( CheckKind : KindOfRangeCheck ;
                                       RequiredRange,TransferRange:
                                         RangeEntry;
                                       EntryToCheck : StackEntry ) ;
                                  ReadOp :
                                     ( Mode : IntKind..RealKind ) ;
                                  CAPSize :
                                     ( BpAddress : RuntimeAddress ;
                                       WordBounds, SizeKnown : Boolean ) ;
                                  Stdrd :
                                     ( StdOp : StdProcFuncs ;
                                       case Boolean of
                                          false : (StdEntry : StackEntry);
                                          true : (IOEntry : IOFileEntry));
                                  ICLStdrd :
                                     ( ICLOp: StdProcFuncs ;
                                       FirstEntry, SecondEntry:StackEntry));
                    end ;

   { types used by the with-statement controller, module 21 }

   WithEntry      = ^ WithRecord ;
   WithRecord     = record
                        BaseNum : DispRange ;
                        Entry : StackEntry ;
                        Next : WithEntry
                     end ;

   { types used by the standard procedures generator, module 22 }

   IOFileRecord   = record
                       FileType : TypEntry ;
                       FileEntry : StackEntry ;
                       Next : IOFileEntry
                    end ;

   { types used by the case and for-statement controllers, module 22 }

   CaseLabelEntry  = ^ CaseLabelRecord ;
   CaseLabelRecord = record
                        NextLabel : CaseLabelEntry;
                        LimbLabel : CodeLabel ;
                        case IsRange: Boolean of
                          false: (LabelValue : MCIntegerForm) ;
                          true: (MinValue, MaxValue: MCIntegerForm)
                    end ;

   CaseEntry      = ^ CaseRecord ;
   CaseRecord     = record
                       Next : CaseEntry;
                       Selector : StackEntry ;
                       WordLabels : Boolean;
                       CaseCode : CodeLabel ;
                       MinLabel,MaxLabel : CaseLabelEntry ;
                       case HasOtherwiseLimb: Boolean of
                         false: ( );
                         true: (OtherwiseLabel: CodeLabel)
                    end ;

   ForEntry       = ^ ForRecord ;
   ForRecord      = record
                       Incrementing, WordLimits : Boolean ;
                       ControlVar,FinalEntry : StackEntry ;
                       StartOfLoop,EndOfLoop : CodeLabel ;
                       Next : ForEntry
                    end ;



var
   
   
   
   {  The compiler will generate object-code subject to the     }
   {  condition that the Boolean variable CodeIsToBeGenerated   }
   {  has the value true.  On the first occurrence of any       }
   {  error (be it syntactic, semantic, or predicted), the      }
   {  source-handler procedure Error resets this value to       }
   {  false, thereby suppressing the generation of any          }
   {  further executable code.  Program analysis continues      }
   {  however, and the compiler will check the syntax and       }
   {  static semantics of the remaining program text.           }
   
   CodeIsToBeGenerated: Boolean;
      visible;
   
   
{************************************************************************}
{*****       variables used by the source program analyser         ******}
{************************************************************************}


   { variables used by pnx-dependent code in modules 3 and 4 }
   
   Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, BlankString: ArgString;
      visible;
   pargc: integer;
      visible;
   pargv: ArgPointer;
      visible;

   { global variables used by the option-handler, module 3 }
   
   OptionCh: char;
      visible;
   Requested, LocallyRequested: SetOfOptions;
      visible;
   OptionFile: text;
      visible;
   AnyWarningsToReport: Boolean;
      visible;
   OptionWarning: BannerString;
      visible;
   OptionValue: array [IntOptions] of integer;
      visible;
   OptionMap:
      array [OptionType] of
         record
            Name: OptionString;
            Option: OptionType;
            Class: OptionClass
         end;
      visible;
   InHousePascal, ICLPascal: Boolean;
      visible;
   Directive: ICLDirectives;
      visible;
   DirChars: CharSet;
      visible;
   DirName: array [ICLDirectives] of DirectiveString;
      visible;
   
   { global variables used by the source-handler, module 5 }
   
   Heading, SubHeading: BannerString;
      visible;
   PageLayout:
      record
         Title, SubTitle, BoolOps, IntOps: BannerString;
         Today, Now: DateString;
         PageNum: Scalar;
         LinesLeft: PageDepth
      end;
      visible;
   Ch: char;
      visible;
   Source: SourceEntry;
      visible;
   ImportList: ImportEntry;
      visible;
   ErrorCount: Scalar;
      visible;
   Reported: packed array [ErrorSpan] of Boolean;
      visible;
   SourceFile, ListFile, WarnFile, ErrorFile: text;
      visible;
   
   { global variables provided for use with the object  }
   { code generator interface, module 6                 }
   
   EmptyRepresentation, RealRepresentation, BooleanRepresentation,
   CharRepresentation, IntegerRepresentation, PtrRepresentation,
   DefaultRepresentation, WordRepresentation: TypeRepresentation;
      visible;
   EightValue, NilValue, EmptyValue, FalseValue, TrueValue, ZeroValue,
   OneValue, MaxintValue, MinLabValue, MaxLabValue, MinCharValue, 
   MaxCharValue, MaxWordValue, MaxRealValue, MaxSetValue, DftValue,
   ZeroReal, FiveValue, ElevenValue, SixteenValue, TwentyTwoValue, 
   MinintValue: ObjectValue;
      visible;
   DftAddress: RunTimeAddress;
      visible;
   DftOffset: FieldOffset;
      visible;
   DftLabel: BlockLabel;
      visible;
   DftSpace: ParamSpace;
      visible;
   
   { global variables used by the diagnostics handler, module 6 }
   
   NextSerial: SerialRange;
      visible;

   { global variables used by the lexical analyser, module 8 }
   
   PrecedingPeriod, TailToBeDisposed: Boolean;
      visible;
   Symbol: SymbolType;
      visible;
   Operator: OpType;
      visible;
   Constant: ValueDetails;
      visible;
   Spelling: Alfa;
      visible;
   StartOfSymbol: TextPosition;
      visible;
   WordSymbol:
      array [1..NoWords] of
         record
            Spelling: AlfaHead;
            SymbolValue: SymbolType;
            OpValue: OpType
         end;
      visible;
   LastOfLength: array [0..AlfaSize] of 0..NoWords;
      visible;
   Letters, Digits, LettersAndDigits, UnixSpecials, LowerCaseLetters,
   SymbolStarters:
      CharSet;
      visible;
   DigitsForBase: array [BaseValues] of CharSet;
      visible;
   
   { global variables used in syntax analysis, modules 9,11 }
   
   ConstFacBegSys, BlockBegSys, TypeBegSys, ConstBegSys, SimpTypeBegSys,
   TypeDels, StatBegSys, FacBegSys, SelectSymbols, ParamBegSys,
   ConformantParamBegSys, IndexSpecBegSys:
      SetOfSymbols;
      visible;
   SymbolsSkipped, Recovering, ErrorReported: Boolean;
      visible;
   
   { global variables used by semantic analysis, modules 10,11 }
   
   IntType, RealType, BoolType, CharType, PtrType, TextType, NilType,
   EmptyType, WordType, NaturalType, Unknown: TypEntry;
      visible;
   ScopeLevel, BlockLevel, LevelFound: DispRange;
      visible;
   Display: array [DispRange] of ScopeRecord;
      visible;
   DummyVarId: IdEntry;
      visible;
   ControlVars: IdSet;
      visible;
   NextScopeNo: ScopeNumber;
      visible;
   Depth: LabelDepth;
      visible;
   ExpType, VarType: TypEntry;
      visible;
   VntSelector: TypEntry;
      visible;
   PackedVar, SimpleVar, TagVar, NewRecVar, ProtectedVar: Boolean;
      visible;
   FirstChoice: IdClass;
     visible;
   InputFile, OutputFile: IdEntry;
      visible;
   SystemSpelling, InputSpelling, OutputSpelling: Alfa;
      visible;
   
   
{************************************************************************}
{*****       variables used by the object program generator        ******}
{************************************************************************}

   { variables used by the E-code interface }

   RtSystem: array[Intrinsic] of
               record
                 Adid, LabelId: integer;
                 PNumber, PSize: Scalar
               end;
      visible;
   SystemRoutine: array[StdProcFuncs] of Intrinsic;
      visible;

   { variables used by the storage allocator, module 15 }
   
   FrameLevel: AddressLevel;
      visible;
   TopFrameEntry: FrameEntry;
      visible;
   GlaOffset, StatOffset, GSTOffset: ByteRange;
      visible;
   GlobScalarArea, GlobStructureArea: DataArea;
     visible;
   Area: array[DataArea] of integer;
     visible;
   NegativeStack: Boolean;
     visible;
   LinkableAreas: set of DataArea;
     visible;
   
   { variables used by the object program generator, modules 12 - 28 }

   MCRealSize: Scalar;
     visible;
   SelectedFile: IOFileEntry;
      visible;
   HpRequests:
      record
         Request: TypeRepresentation;
         RequestLevel: Scalar;
         PointerEntry: StackEntry
      end;
      visible;
   ZeroEntry, DftWidth, TopStackEntry: StackEntry;
      visible;
   TopWithEntry: WithEntry;
      visible;
   TopCaseEntry: CaseEntry;
      visible;
   TopForEntry: ForEntry;
      visible;
   BufferOffset: FieldOffset;
      visible;
   Overflow: record Occurred, Positive: Boolean end;
      visible;
   IntOps, RealOps, PtrOps, SetOps, StringOps, WordOps:
      array [OpType] of Ecodes;
      visible;
   WordFns: array[Andwf..RotWf] of Ecodes;
      visible;
   CAPIndexOps: array[Boolean, Boolean] of Ecodes;
      visible;
   BoundCheck: array[Boolean, BoundTest] of Ecodes;
      visible;
   ContextOfCheck: (IsSucc, IsPred, IsUnknown);
      visible;
   TransferOps, CheckOps, UCheckOps: array [Boolean, Boolean] of Ecodes;
      visible;
   ProgPmCount: Scalar;
      visible;
   PlabelId: integer;
      visible;
   LastFlowLine: Scalar;
     visible;