home *** CD-ROM | disk | FTP | other *** search
/ CBM Funet Archive / cbm-funet-archive-2003.iso / cbm / programming / msdos / xa214f.lzh / xa214f / src / xat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-26  |  42.9 KB  |  1,361 lines
  1.  
  2. /*
  3.     XA65 - 6502 CROSS ASSEMBLER AND UTILITY SUITE
  4.     cOPYRIGHT (c) 1989-1998 aNDR{$e9} fACHAT (A.FACHAT@PHYSIK.TU-CHEMNITZ.DE)
  5.  
  6.     tHIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
  7.     IT UNDER THE TERMS OF THE gnu gENERAL pUBLIC lICENSE AS PUBLISHED BY
  8.     THE fREE sOFTWARE fOUNDATION; EITHER VERSION 2 OF THE lICENSE, OR
  9.     (AT YOUR OPTION) ANY LATER VERSION.
  10.  
  11.     tHIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
  12.     BUT without any warranty; WITHOUT EVEN THE IMPLIED WARRANTY OF
  13.     merchantability OR fitness for a particular purpose.  sEE THE
  14.     gnu gENERAL pUBLIC lICENSE FOR MORE DETAILS.
  15.  
  16.     yOU SHOULD HAVE RECEIVED A COPY OF THE gnu gENERAL pUBLIC lICENSE
  17.     ALONG WITH THIS PROGRAM; IF NOT, WRITE TO THE fREE sOFTWARE
  18.     fOUNDATION, iNC., 675 mASS aVE, cAMBRIDGE, ma 02139, usa.
  19. */
  20.  
  21.  
  22. #INCLUDE <CTYPE.H>
  23. #INCLUDE <STDIO.H>
  24.  
  25. #INCLUDE "XAH.H"
  26. #INCLUDE "XAH2.H"
  27.  
  28. #INCLUDE "XAR.H"
  29. #INCLUDE "XA.H"
  30. #INCLUDE "XAA.H"
  31. #INCLUDE "XAL.H"
  32. #INCLUDE "XAT.H"
  33. #INCLUDE "XAO.H"
  34. #INCLUDE "XAP.H"
  35.  
  36. INT DSB_LEN = 0;
  37.  
  38. STATIC INT T_CONV(SIGNED CHAR*,SIGNED CHAR*,INT*,INT,INT*,INT*,INT*,INT);
  39. STATIC INT T_KEYWORD(SIGNED CHAR*,INT*,INT*);
  40. STATIC INT TG_ASC(SIGNED CHAR*,SIGNED CHAR*,INT*,INT*,INT*,INT*);
  41. STATIC VOID TG_DEZ(SIGNED CHAR*,INT*,INT*);
  42. STATIC VOID TG_HEX(SIGNED CHAR*,INT*,INT*);
  43. STATIC VOID TG_OCT(SIGNED CHAR*,INT*,INT*);
  44. STATIC VOID TG_BIN(SIGNED CHAR*,INT*,INT*);
  45.  
  46. STATIC CHAR *KT[] ={$7b} 
  47.      "ADC","AND","ASL","BBR","BBS","BCC","BCS","BEQ",
  48.      "BIT","BMI",
  49.      "BNE","BPL","BRA","BRK","BVC","BVS","CLC","CLD",
  50.      "CLI",
  51.      "CLV","CMP","CPX","CPY","DEC","DEX","DEY","EOR",
  52.      "INC","INX","INY","JMP","JSR","LDA","LDX","LDY",
  53.      "LSR","NOP","ORA","PHA","PHP","PHX","PHY","PLA",
  54.      "PLP","PLX","PLY","RMB","ROL",
  55.      "ROR","RTI","RTS","SBC","SEC","SED","SEI","SMB",
  56.      "STA",
  57.      "STX","STY","STZ","TAX","TAY","TRB","TSB","TSX",
  58.      "TXA","TXS","TYA",
  59.      ".BYT",".WORD",".ASC",".DSB",
  60.      ".(",".)","*=", ".TEXT", ".DATA", ".BSS", ".ZERO",
  61.      ".FOPT", ".BYTE", ".END", ".LIST", ".XLIST", 
  62.      ".DUPB", ".BLKB", ".DB", ".DW", ".ALIGN",
  63.      ".BLOCK", ".BEND"
  64. {$7d};
  65.  
  66. STATIC INT LP[]= {$7b} 0,1,1,1,1,2,2,1,1,1,2,2,2,1,1,1,2,2 {$7d};
  67.  
  68. #DEFINE   lASTBEF   67 
  69. #DEFINE   aNZKEY    91
  70.  
  71. #DEFINE   kBYT      68
  72. #DEFINE   kWORD     69
  73. #DEFINE   kASC      70
  74. #DEFINE   kDSB      71
  75. #DEFINE   kOPEN     72   /* .(      */
  76. #DEFINE   kCLOSE    73   /* .)      */
  77. #DEFINE   kPCDEF    74   /* *=VALUE */
  78. #DEFINE  kTEXT    75
  79. #DEFINE  kDATA     76
  80. #DEFINE  kBSS      77
  81. #DEFINE  kZERO     78
  82. #DEFINE  kFOPT     79
  83. #DEFINE  kBYTE    80/* GETS REMAPPED TO kBYT */
  84. #DEFINE  kEND      81/* IGNORED (masm COMPAT.) */
  85. #DEFINE  kLIST     82/* IGNORED (masm COMPAT.) */
  86. #DEFINE  kXLIST    83/* IGNORED (masm COMPAT.) */
  87. #DEFINE  kDUPB     84/* GETS REMAPPED TO kDSB */
  88. #DEFINE  kBLKB     85/* GETS REMAPPED TO kDSB */
  89. #DEFINE  kDB       86/* GETS REMAPPED TO kBYT */
  90. #DEFINE  kDW       87/* GETS REMAPPED TO kWORD */
  91. #DEFINE  kALIGN    88
  92. #DEFINE  kBLOCK    89/* GETS REMAPPED TO .( */
  93. #DEFINE  kBEND    90/* GETS REMAPPED TO .) */
  94. #DEFINE   kRELOC    aNZKEY   /* *= (RELOCATION MODE) */
  95. #DEFINE   kSEGMENT  aNZKEY+1 
  96.  
  97. STATIC INT KTP[]={$7b} 0,3,16,23,26,27,27,27,27,30,32,32,36,36,37,38,46,
  98.                46,51,60,68,68,68,68,68,68,68,aNZKEY {$7d};
  99.  
  100. STATIC INT CT[68][16] ={$7b}
  101. /*     0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15  */
  102. {$7b}     -1,  0X65,0X75,-1,  0X172,0X61,0X71,0X69,0X6D,0X7D,0X79,-1,  -1,  -1,  -1,  -1 {$7d},  /*ADC*/
  103. {$7b}     -1,  0X25,0X35,-1,  0X132,0X21,0X31,0X29,0X2D,0X3D,0X39,-1,  -1,  -1,  -1,  -1 {$7d},  /*AND*/
  104. {$7b}     0X0A,0X06,0X16,-1,  -1,  -1,  -1,  -1,  0X0E,0X1E,-1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*ASL*/
  105. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0X10F,-1 {$7d},  /*BBR*/
  106. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0X18F,-1 {$7d},  /*BBS*/
  107. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0X90,-1,  -1,  -1,  -1 {$7d},  /*BCC*/
  108. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0XB0,-1,  -1,  -1,  -1 {$7d},  /*BCS*/
  109. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0XF0,-1,  -1,  -1,  -1 {$7d},  /*BEQ*/
  110. {$7b}     -1,  0X24,0X134,-1,  -1,  -1,  -1,  0X189,0X2C,0X13C,-1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*BIT*/
  111. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0X30,-1,  -1,  -1,  -1 {$7d},  /*BMI*/
  112. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0XD0,-1,  -1,  -1,  -1 {$7d},  /*BNE*/
  113. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0X10,-1,  -1,  -1,  -1 {$7d},  /*BPL*/
  114. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0X180,-1,  -1,  -1,  -1 {$7d},  /*BRA*/
  115. {$7b}     0X00,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*BRK*/
  116. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0X50,-1,  -1,  -1,  -1 {$7d},  /*BVC*/
  117. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0X70,-1,  -1,  -1,  -1 {$7d},  /*BVS*/
  118. {$7b}     0X18,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*CLC*/
  119. {$7b}     0XD8,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*CLD*/
  120. {$7b}     0X58,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*CLI*/
  121. {$7b}     0XB8,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*CLV*/
  122. {$7b}     -1,  0XC5,0XD5,-1,  0X1D2,0XC1,0XD1,0XC9,0XCD,0XDD,0XD9,-1,  -1,  -1,  -1,  -1 {$7d},  /*CMP*/
  123. {$7b}     -1,  0XE4,-1,  -1,  -1,  -1,  -1,  0XE0,0XEC,-1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*CPX*/
  124. {$7b}     -1,  0XC4,-1,  -1,  -1,  -1,  -1,  0XC0,0XCC,-1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*CPY*/
  125. {$7b}     0X13A,0XC6,0XD6,-1,  -1,  -1,  -1,  -1,  0XCE,0XDE,-1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*DEC*/
  126. {$7b}     0XCA,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*DEX*/
  127. {$7b}     0X88,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*DEY*/
  128. {$7b}     -1,  0X45,0X55,-1,  0X152,0X41,0X51,0X49,0X4D,0X5D,0X59,-1,  -1,  -1,  -1,  -1 {$7d},  /*EOR*/
  129. {$7b}     0X11A,0XE6,0XF6,-1,  -1,  -1,  -1,  -1,  0XEE,0XFE,-1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*INC*/
  130. {$7b}     0XE8,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*INX*/
  131. {$7b}     0XC8,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*INY*/
  132. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0X4C,-1,  -1,  -1,  0X6C,0X17C,-1,  -1 {$7d},  /*JMP*/
  133. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  0X20,-1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*JSR*/
  134. {$7b}     -1,  0XA5,0XB5,-1,  0X1B2,0XA1,0XB1,0XA9,0XAD,0XBD,0XB9,-1,  -1,  -1,  -1,  -1 {$7d},  /*LDA*/
  135. {$7b}     -1,  0XA6,-1,  0XB6,-1,  -1,  -1,  0XA2,0XAE,-1,  0XBE,-1,  -1,  -1,  -1,  -1 {$7d},  /*LDX*/
  136. {$7b}     -1,  0XA4,0XB4,-1,  -1,  -1,  -1,  0XA0,0XAC,0XBC,-1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*LDY*/
  137. {$7b}     0X4A,0X46,0X56,-1,  -1,  -1,  -1,  -1,  0X4E,0X5E,-1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*LSR*/
  138. {$7b}     0XEA,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*NOP*/
  139. {$7b}     -1,  0X05,0X15,-1,  0X112,0X01,0X11,0X09,0X0D,0X1D,0X19,-1,  -1,  -1,  -1,  -1 {$7d},  /*ORA*/
  140. {$7b}     0X48,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*PHA*/
  141. {$7b}     0X08,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*PHP*/
  142. {$7b}     0X1DA,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*PHX*/
  143. {$7b}     0X15A,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*PHY*/
  144. {$7b}     0X68,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*PLA*/
  145. {$7b}     0X28,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*PLP*/
  146. {$7b}     0X1FA,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*PLX*/
  147. {$7b}     0X17A,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*PLY*/
  148. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,0X107 {$7d},  /*RMB*/
  149. {$7b}     0X2A,0X26,0X36,-1,  -1,  -1,  -1,  -1,  0X2E,0X3E,-1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*ROL*/
  150. {$7b}     0X6A,0X66,0X76,-1,  -1,  -1,  -1,  -1,  0X6E,0X7E,-1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*ROR*/
  151. {$7b}     0X40,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*RTI*/
  152. {$7b}     0X60,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*RTS*/
  153. {$7b}     -1,  0XE5,0XF5,-1,  0X1F2,0XE1,0XF1,0XE9,0XED,0XFD,0XF9,-1,  -1,  -1,  -1,  -1 {$7d},  /*SBC*/
  154. {$7b}     0X38,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*SEC*/
  155. {$7b}     0XF8,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*SED*/
  156. {$7b}     0X78,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*SEI*/
  157. {$7b}     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,0X187 {$7d},  /*SMB*/
  158. {$7b}     -1,  0X85,0X95,-1,  0X192,0X81,0X91,-1,  0X8D,0X9D,0X99,-1,  -1,  -1,  -1,  -1 {$7d},  /*STA*/
  159. {$7b}     -1,  0X86,-1,  0X96,-1,  -1,  -1,  -1,  0X8E,-1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*STX*/
  160. {$7b}     -1,  0X84,0X94,-1,  -1,  -1,  -1,  -1,  0X8C,-1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*STY*/
  161. {$7b}     -1,  0X164,0X174,-1,  -1,  -1,  -1,  -1,  0X19C,0X19E,-1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*STZ*/
  162. {$7b}     0XAA,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*TAX*/
  163. {$7b}     0XA8,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*TAY*/
  164. {$7b}     -1,  0X114,-1,  -1,  -1,  -1,  -1,  -1,  0X11C,-1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*TRB*/
  165. {$7b}     -1,  0X104,-1,  -1,  -1,  -1,  -1,  -1,  0X10C,-1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*TSB*/
  166. {$7b}     0XBA,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*TSX*/
  167. {$7b}     0X8A,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*TXA*/
  168. {$7b}     0X9A,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d},  /*TXS*/
  169. {$7b}     0X98,-1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1 {$7d}  /*TYA*/
  170. {$7d} ;
  171.  
  172. #IF 0
  173. STATIC INT CF[] ={$7b} 0,0,0,1,1,0,0,0,0,0,0,0,1,  /* 1= cmos     */
  174.             0,0,0,0,0,0,0,0,0,0,
  175.             0,0,0,0,0,0,0,0,0,0,
  176.             0,0,0,0,0,0,0,1,1,0,0,1,1,1,
  177.             0,0,0,0,0,0,0,0,1,0,0,0,
  178.             1,0,0,1,1,0,0,0,0 {$7d};
  179. #ENDIF
  180.  
  181. #DEFINE   sYNTAX    10
  182.  
  183. STATIC INT AT[sYNTAX][3] ={$7b}    
  184. {$7b}     0,   -1,  -1  {$7d},
  185. {$7b}     -1,  7,   -1  {$7d},
  186. {$7b}     -1,  15,  -1  {$7d},
  187. {$7b}     -1,  -1,  14  {$7d},
  188. {$7b}     -1,  1,   8  {$7d},
  189. {$7b}     -1,  2,   9  {$7d},
  190. {$7b}     -1,  3,   10  {$7d},
  191. {$7b}     -1,  4,   12  {$7d},
  192. {$7b}     -1,  5,   13  {$7d},
  193. {$7b}     -1,  6,   -1  {$7d}
  194. {$7d};
  195.  
  196. #DEFINE   aNZaLT    4
  197.  
  198. STATIC INT XT[aNZaLT][2] ={$7b} /* aLTERNATIV aDR-mODES  */
  199. {$7b}     8,   11 {$7d},      /* ABS -> REL  */
  200. {$7b}     2,   3  {$7d},      /* Z,X -> Z,Y  */
  201. {$7b}     5,   6  {$7d},      /* ,X) -> ),Y  */
  202. {$7b}     9,   10 {$7d}       /* A,X -> A,Y  */
  203. {$7d};
  204.  
  205. STATIC INT LE[] ={$7b} 1,2,2,2,2,2,2,2,3,3,3,2,3,3,3,2 {$7d};
  206.  
  207. STATIC INT OPT[] ={$7b} -1,-1,-1,-1,-1,-1,-1,-1,1,2,3,-1,4,5,-1,-1 {$7d}; /* ABS -> ZP */
  208.  
  209. #DEFINE   CVAL(S)   256*((S)[1]&255)+((S)[0]&255)
  210. #DEFINE   WVAL(I,V) T[I++]=t_value;T[I++]=(V)&255;T[I++]=((V)>>8)&255
  211.  
  212. /* PASS 1 */
  213. INT T_P1(SIGNED CHAR *S, SIGNED CHAR *T, INT *LL, INT *AL)
  214. {$7b}
  215.      STATIC INT ER,L,N,V,NK,NA1,NA2,BL,AM,SY,I,LABEL; /*,J,V2 ;*/
  216.      INT AFL = 0;
  217.  
  218.      BL=0;
  219.      *AL = 0;
  220.  
  221. /*     PRINTF("\N"); */
  222.  
  223.      ER=T_CONV(S,T,&L,PC[SEGMENT],&NK,&NA1,&NA2,0);
  224.  
  225.      *LL=L;
  226. /*
  227.      PRINTF("T_CONV (ER=%D):",ER);
  228.      FOR(I=0;I<L;I++)
  229.           PRINTF("%02X,",T[I]);
  230.      PRINTF("\N");
  231. */
  232.      /* IF TEXT/DATA PRODUCED, THEN NO MORE FOPT ALLOWED IN ROMABLE MODE */
  233.      IF((ROMABLE>1) && (T[0]<kOPEN {$7c}{$7c} T[0]==kBYTE {$7c}{$7c} T[0]==kPCDEF)) {$7b}
  234.        AFILE->BASE[seg_text] = PC[seg_text] = ROMADR + H_LENGTH();
  235.        ROMABLE=1;
  236.      {$7d}
  237.  
  238.      IF(!ER)
  239.      {$7b}
  240.           N=T[0];
  241.   /* todo: MAKE THAT A BIG SWITCH STATEMENT... */
  242.   IF(N==kEND {$7c}{$7c} N==kLIST {$7c}{$7c} N==kXLIST) {$7b}
  243.     *LL = 0;/* IGNORE */
  244.   {$7d} ELSE
  245.   IF(N==kFOPT) {$7b}
  246.     IF(ROMABLE==1) ER=e_romopt;
  247.     T[0] = kBYT;
  248.     SET_FOPT(L,T,NK+1-NA1+NA2);
  249.     *LL = 0;
  250.   {$7d} ELSE
  251.           IF(N==kPCDEF)
  252.           {$7b}
  253.        INT TMP;
  254.                IF(!(ER=A_TERM(T+1,&TMP /*&PC[seg_abs]*/,&L,PC[SEGMENT],&AFL,&LABEL,0)))
  255.                {$7b}
  256.                     I=1;
  257.                     WVAL(I,TMP /*PC[seg_abs]*/);
  258.                     T[I++]=t_end;
  259.                     *LL=5;
  260.                     ER=e_okdef;
  261. /*PRINTF("SET PC=%04X, OLDSEGMENT=%D, PC[SEGM]=%04X, ", 
  262. PC[seg_abs], SEGMENT, PC[SEGMENT]);
  263. PRINTF(" WROTE %02X %02X %02X %02X %02X %02X\N",
  264. T[0],T[1],T[2],T[3],T[4],T[5]);*/
  265.     IF(SEGMENT==seg_text) {$7b}
  266.       PC[seg_abs] = TMP;
  267.       R_MODE(rmode_abs);
  268.     {$7d} ELSE {$7b}
  269.       IF(!RELMODE) {$7b}
  270.         PC[SEGMENT] = TMP;
  271.       {$7d} ELSE {$7b}
  272. ER = e_illsegment;
  273.       {$7d}
  274.     {$7d}
  275. /*PRINTF("NEWSEGMENT=%D, PC[abs]=%04X\N", SEGMENT, PC[seg_abs]);*/
  276.                {$7d} ELSE {$7b}/* todo: DIFFERENT ERROR CODE */
  277.          IF((SEGMENT==seg_abs) && (ER==e_syntax && L==0)) {$7b}
  278. /*PRINTF("RELOC: OLDSEG=%D, PC[OLDSEG]=%04X, PC[ABS]=%04X, PC[TEXT]=%04X\N",
  279. SEGMENT, PC[SEGMENT], PC[seg_abs], PC[seg_text]);*/
  280.    T[0]=kRELOC;
  281.    I=1;
  282.    WVAL(I,PC[seg_text]);
  283.    T[I++]=t_end;
  284.    *LL=5;
  285.      ER=e_okdef;
  286.    R_MODE(rmode_reloc);
  287. /*PRINTF("     : NEWSEG=%D, PC[NEWSEG]=%04X, PC[ABS]=%04X, PC[TEXT]=%04X\N",
  288. SEGMENT, PC[SEGMENT], PC[seg_abs], PC[seg_text]);*/
  289.          {$7d}
  290.        {$7d}
  291.           {$7d} ELSE
  292.           IF(N==kOPEN)
  293.           {$7b}
  294.        IF(SHOWBLK) FPRINTF(STDERR, "%S LINE %D: .(\N", PP_GETIDAT()->FNAME, PP_GETIDAT()->FLINE);
  295.                B_OPEN();
  296.                ER=e_noline;
  297.           {$7d} ELSE
  298.           IF(N==kCLOSE)
  299.           {$7b}
  300.        IF(SHOWBLK) FPRINTF(STDERR, "%S LINE %D: .)\N", PP_GETIDAT()->FNAME, PP_GETIDAT()->FLINE);
  301.                ER=B_CLOSE();
  302.                IF(!ER) ER=e_noline;
  303.           {$7d} ELSE
  304.           IF(N==kDSB)
  305.           {$7b}
  306.        DSB_LEN = 1;
  307.                IF(!(ER=A_TERM(T+1,&BL,&L,PC[SEGMENT],&AFL,&LABEL,0))) {$7b}
  308.                     ER=e_okdef;
  309.        {$7d}
  310.        DSB_LEN = 0;
  311.           {$7d} ELSE
  312.   IF(N==kTEXT) {$7b}
  313. /*    IF(SEGMENT!=seg_abs) {$7b}*/
  314.       SEGMENT = RELMODE ? seg_text : seg_abs;
  315.       T[0]=kSEGMENT;
  316.       T[1]=SEGMENT;
  317.       *LL=2;
  318.               ER=e_okdef;
  319. /*    {$7d} ELSE {$7b}
  320.       ER=e_illsegment;
  321.     {$7d}*/
  322.   {$7d} ELSE
  323.   IF(N==kDATA) {$7b}
  324. /*      IF(SEGMENT!=seg_abs) {$7b}*/
  325.       SEGMENT = seg_data;
  326.       T[0]=kSEGMENT;
  327.       T[1]=seg_data;
  328.       *LL=2;
  329.               ER=e_okdef;
  330. /*    {$7d} ELSE {$7b}
  331.       ER=e_illsegment;
  332.     {$7d}*/
  333.   {$7d} ELSE
  334.   IF(N==kBSS) {$7b}
  335. /*      IF(SEGMENT!=seg_abs) {$7b}*/
  336.       SEGMENT = seg_bss;
  337.       T[0]=kSEGMENT;
  338.       T[1]=seg_bss;
  339.       *LL=2;
  340.               ER=e_okdef;
  341. /*    {$7d} ELSE {$7b}
  342.       ER=e_illsegment;
  343.     {$7d}*/
  344.   {$7d} ELSE
  345.   IF(N==kZERO) {$7b}
  346. /*      IF(SEGMENT!=seg_abs) {$7b}*/
  347.       SEGMENT = seg_zero;
  348.       T[0]=kSEGMENT;
  349.       T[1]=seg_zero;
  350.       *LL=2;
  351.               ER=e_okdef;
  352. /*    {$7d} ELSE {$7b}
  353.       ER=e_illsegment;
  354.     {$7d}*/
  355.   {$7d} ELSE
  356.   IF(N==kALIGN) {$7b}
  357.     INT TMP;
  358.     IF(SEGMENT!=seg_abs) {$7b}
  359.               IF(!(ER=A_TERM(T+1,&TMP,&L,PC[SEGMENT],&AFL,&LABEL,0))) {$7b}
  360. IF(TMP == 1 {$7c}{$7c} TMP == 2 {$7c}{$7c} TMP == 4 {$7c}{$7c} TMP == 256) {$7b}
  361.   SET_ALIGN(TMP);
  362.   IF(PC[SEGMENT] & (TMP-1)) {$7b} /* NOT ALIGNED */
  363.     INT TMP2;
  364.     T[0]=kDSB;
  365.     I=1;
  366.     BL=TMP=(TMP - (PC[SEGMENT] & (TMP-1))) & (TMP-1);
  367.     WVAL(I,TMP);
  368.                     T[I++]=',';
  369.     TMP2= 0XEA;
  370.     WVAL(I,TMP2);/* NOP OPCODE */
  371.                     T[I++]=t_end;
  372.     *LL=9;
  373.     ER=e_okdef;
  374.   {$7d} ELSE {$7b}
  375.     *LL=0;/* IGNORE IF ALIGNED RIGHT */
  376.   {$7d}
  377. {$7d} ELSE {$7b}
  378.   ER=e_illalign;
  379. {$7d}
  380.       {$7d}
  381.     {$7d} ELSE {$7b}
  382.       ER=e_illsegment;
  383.     {$7d}
  384.   {$7d} ELSE
  385.                ER=T_P2(T,LL,1, AL);
  386.           
  387.      {$7d} ELSE
  388.      IF(ER==e_nodef)
  389.      {$7b}
  390.           ER=e_ok;
  391.           N=T[0];
  392.  
  393.           IF(N>=0 && N<=lASTBEF)
  394.           {$7b}
  395.                IF(T[1]==t_end)
  396.                {$7b}
  397.                     SY=0;
  398.                {$7d} ELSE
  399.                IF(T[1]=='#')
  400.                {$7b}
  401.                     SY=1+NK;
  402.                {$7d} ELSE
  403.                IF(T[1]=='(')
  404.                {$7b}
  405.                     SY=7+NK;
  406.                {$7d} ELSE
  407.                     SY=4+NK;
  408.  
  409.                BL=4;
  410.                
  411.                WHILE(--BL)
  412.                {$7b}
  413.                     IF((AM=AT[SY][BL-1])>=0)
  414.                     {$7b}
  415.                          IF(AM>15)
  416.                          {$7b}
  417.                               ER=e_syntax;
  418.                               BREAK;
  419.                          {$7d}
  420.                          IF(CT[N][AM]>=0)
  421.                               BREAK;
  422.  
  423.                          FOR(V=0;V<aNZaLT;V++)
  424.                               IF(XT[V][0]==AM && CT[N][XT[V][1]]>=0)
  425.                                    BREAK;
  426.                          IF(V<aNZaLT) 
  427.                          {$7b}
  428.                               AM=XT[V][1];
  429.                               BREAK;
  430.                          {$7d}
  431.                     {$7d}
  432.                {$7d}
  433.           
  434.                IF(!BL)
  435.                     ER=e_syntax;
  436.                ELSE
  437.                     BL=LE[AM];
  438.  
  439.           {$7d} ELSE
  440.           IF(N==kBYT {$7c}{$7c} N==kASC)
  441.           {$7b}
  442.                BL=NK+1-NA1+NA2;
  443.           {$7d} ELSE
  444.           IF(N==kWORD)
  445.           {$7b}
  446.                BL=2*NK+2;
  447.           {$7d} ELSE
  448.           IF(N==kDSB)
  449.           {$7b}
  450.                ER=A_TERM(T+1,&BL,&L,PC[SEGMENT],&AFL,&LABEL,0);
  451.           {$7d} ELSE
  452.   IF(N==kFOPT) 
  453.   {$7b}
  454.     SET_FOPT(L-1,T+1, NK+1-NA1+NA2);
  455.     *LL = 0;
  456.   {$7d} ELSE
  457.           IF(N==t_op)
  458.           {$7b}
  459.                ER=e_okdef;
  460.           {$7d} ELSE
  461.                ER=e_nodef;
  462.           
  463.           IF(!ER)
  464.                ER=e_okdef;
  465.      {$7d}
  466.      IF(ER==e_noline)
  467.      {$7b}
  468.           ER=e_ok;
  469.           *LL=0;
  470.      {$7d}
  471.  
  472.      *AL += BL;
  473.      PC[SEGMENT]+=BL;
  474.      IF(SEGMENT==seg_text) PC[seg_abs]+=BL;
  475.      IF(SEGMENT==seg_abs) PC[seg_text]+=BL;
  476.  
  477.      RETURN(ER);
  478. {$7d}
  479.  
  480. INT T_P2(SIGNED CHAR *T, INT *LL, INT FL, INT *AL)
  481. {$7b}
  482.      STATIC INT AFL,NAFL, I,J,K,ER,V,N,L,BL,SY,AM,C,VV[3],V2,LABEL;
  483.      STATIC INT RLT[3];/* RELOCATION TABLE */
  484.      STATIC INT LAB[3];/* UNDEF. LABEL TABLE */
  485.  
  486.      ER=e_ok;
  487.      BL=0;
  488.      IF(*LL<0) /* <0 BEI e_ok, >0 BEI e_okdef     */
  489.      {$7b}
  490.           *LL=-*LL;
  491.           BL=*LL;
  492.           ER=e_ok;
  493.      {$7d} ELSE
  494.      {$7b}
  495.           N=T[0];
  496.           IF(N==t_op)
  497.           {$7b}
  498.                N=CVAL(T+1);
  499.                ER=A_TERM(T+4,&V,&L,PC[SEGMENT],&NAFL,&LABEL,0);
  500.  
  501.                IF(!ER)
  502.                {$7b}
  503.                     IF(T[3]=='=')
  504.                     {$7b}
  505.                       V2=V;
  506.                     {$7d} ELSE {$7b}
  507.                       IF( (!(ER=L_GET(N,&V2, &AFL))) 
  508. && ((AFL & a_fmask)!=(seg_undef<<8)) )
  509.                       {$7b}
  510.                          IF(T[3]=='+')
  511.                          {$7b}
  512.       IF(AFL && NAFL) {$7b} ERROUT(e_wpointer); NAFL=0; {$7d}
  513.       NAFL = AFL;
  514.                               V2+=V;
  515.                          {$7d} ELSE
  516.                          IF(T[3]=='-')
  517.                          {$7b}
  518.       IF( (((NAFL & a_fmask)>>8) != AFL) 
  519. {$7c}{$7c} ((NAFL & a_mask)==a_high) ) {$7b}
  520.         ERROUT(e_wpointer); 
  521. NAFL=0; 
  522.       {$7d} ELSE {$7b}
  523. NAFL = AFL;
  524.       {$7d}
  525.                               V2-=V;
  526.                          {$7d} ELSE
  527.                          IF(T[3]=='*')
  528.                          {$7b}
  529.       IF(AFL {$7c}{$7c} NAFL) {$7b} ERROUT(e_wpointer); NAFL=0; {$7d}
  530.                               V2*=V;
  531.                          {$7d} ELSE
  532.                          IF(T[3]=='/')
  533.                          {$7b}
  534.       IF(AFL {$7c}{$7c} NAFL) {$7b} ERROUT(e_wpointer); NAFL=0; {$7d}
  535.                               IF(V)
  536.                                    V2/=V;
  537.                               ELSE
  538.                                    ER=e_div;
  539.                          {$7d} ELSE
  540.                          IF(T[3]=='{$7c}')
  541.                          {$7b}
  542.       IF(AFL {$7c}{$7c} NAFL) {$7b} ERROUT(e_wpointer); NAFL=0; {$7d}
  543.                               V2=V{$7c}V2;
  544.                          {$7d} ELSE
  545.                          IF(T[3]=='&')
  546.                          {$7b}
  547.       IF(AFL {$7c}{$7c} NAFL) {$7b} ERROUT(e_wpointer); NAFL=0; {$7d}
  548.                               V2=V2&V;
  549.                          {$7d}
  550.                       {$7d}
  551.     {$7d}
  552.                     L_SET(N,V2,NAFL>>8);
  553.  
  554.                     *LL=0;
  555.                     IF(!ER)
  556.                          ER=e_noline;
  557.                {$7d}
  558.           {$7d} ELSE
  559.           IF(N==kWORD)
  560.           {$7b}
  561.                I=1;
  562.                J=0;
  563.                WHILE(!ER && T[I]!=t_end)
  564.                {$7b}
  565.                     IF(!(ER=A_TERM(T+I,&V,&L,PC[SEGMENT],&AFL,&LABEL,1)))
  566.                     {$7b}   
  567. /*IF(AFL) PRINTF("RELOCATION 1 %04X AT PC=$%04X, VALUE NOW =$%04X\N",
  568. AFL,PC[SEGMENT],V); */
  569.  IF(AFL) U_SET(PC[SEGMENT]+J, AFL, LABEL, 2);
  570.                          T[J++]=V&255;
  571.                          T[J++]=(V>>8)&255;
  572.  
  573.                          I+=L;     
  574.                          IF(T[I]!=t_end && T[I]!=',')
  575.                               ER=e_syntax;
  576.                          ELSE
  577.                          IF(T[I]==',')
  578.                               I++;
  579.  
  580.                     {$7d}
  581.                {$7d}
  582.                *LL=J;
  583.                BL=J;
  584.           {$7d} ELSE
  585.           IF(N==kASC {$7c}{$7c} N==kBYT)
  586.           {$7b}
  587.                I=1;
  588.                J=0;
  589.                WHILE(!ER && T[I]!=t_end)
  590.                {$7b}
  591.                     IF(T[I]=='\"')
  592.                     {$7b}
  593.                          I++;
  594.                          K=T[I]+I+1;
  595.                          I++;
  596.                          WHILE(I<K)
  597.                               T[J++]=T[I++];
  598.                     {$7d} ELSE
  599.                     {$7b}
  600.                          IF(!(ER=A_TERM(T+I,&V,&L,PC[SEGMENT],&AFL,&LABEL,1)))
  601.                          {$7b}
  602. /*IF(AFL) PRINTF("RELOCATION 2 %04X AT PC=$%04X, VALUE NOW =$%04X\N",AFL,PC[SEGMENT]+J,V); */
  603.       IF(AFL) U_SET(PC[SEGMENT]+J, AFL, LABEL, 1);
  604.                               IF(V&0XFF00)
  605.                                    ER=e_overflow;
  606.                               ELSE
  607.                               {$7b}
  608.                                    T[J++]=V;                        
  609.                                    I+=L;     
  610.                               {$7d}
  611.                          {$7d}
  612.                     {$7d}
  613.                     IF(T[I]!=t_end && T[I]!=',')
  614.                          ER=e_syntax;
  615.                     ELSE
  616.                          IF(T[I]==',')
  617.                               I++;
  618.                {$7d}
  619.                *LL=J;
  620.                BL=J;
  621.           {$7d} ELSE
  622.           IF(N==kPCDEF)
  623.           {$7b}
  624.        INT NPC;
  625.                ER=A_TERM(T+1,&NPC,&L,PC[SEGMENT],&AFL,&LABEL,0);
  626.                BL=0;     
  627.                *LL=0;
  628.        IF(SEGMENT==seg_text) {$7b}
  629.          R_MODE(rmode_abs);
  630.        {$7d}
  631.        PC[SEGMENT] = NPC;
  632.           {$7d} ELSE
  633.           IF(N==kRELOC) {$7b}
  634.        INT NPC;
  635.                ER=A_TERM(T+1,&NPC,&L,PC[SEGMENT],&AFL,&LABEL,0);
  636. /*PRINTF("kRELOC: SEGMENT=%D, PC[SEG]=%04X\N", SEGMENT, PC[SEGMENT]);*/
  637.                BL=0;     
  638.                *LL=0;
  639.        R_MODE(rmode_reloc);
  640.        PC[SEGMENT] = NPC;
  641. /*PRINTF("kRELOC: NEWSEGMENT=%D, PC[SEG]=%04X\N", SEGMENT, PC[SEGMENT]);*/
  642.   {$7d} ELSE
  643.   IF(N==kSEGMENT) {$7b}
  644.        SEGMENT = T[1];
  645.        *LL=0;
  646.        BL =0;
  647.   {$7d} ELSE
  648.           IF(N==kDSB)
  649.           {$7b}
  650.        DSB_LEN = 1;
  651.                IF(!(ER=A_TERM(T+1,&J,&I,PC[SEGMENT],&AFL,&LABEL,0)))
  652.                {$7b}
  653. /*
  654.                     IF(T[I+1]!=',')
  655.                          ER=e_syntax;
  656.                     ELSE
  657. */
  658. /*
  659.     IF((SEGMENT!=seg_abs) && AFL) 
  660.  ER=e_illpointer;
  661.     ELSE
  662. */
  663.                     {$7b}
  664.  DSB_LEN = 0;
  665.  
  666.  IF(T[I+1]==',') {$7b}
  667.                            ER=A_TERM(T+2+I,&V,&L,PC[SEGMENT],&AFL,&LABEL,0);
  668.  {$7d} ELSE {$7b}
  669.    V=0;
  670.  {$7d}
  671.                          IF(!ER && V>>8)
  672.                               ER=e_overflow;
  673.                          T[0]=V&255;
  674.                          IF(!ER)
  675.                          {$7b}
  676.                               *LL=J;
  677.                               BL=J;
  678.                               ER=e_dsb;
  679.                          {$7d}
  680.                     {$7d}
  681.                     IF(!ER)
  682.                          BL=J;
  683.                {$7d}
  684.        DSB_LEN = 0;
  685.           {$7d} ELSE
  686.           IF(N<=lASTBEF)
  687.           {$7b}
  688.                IF((C=T[1])=='#')
  689.                {$7b}
  690.                     I=2;
  691.                     SY=1;
  692.                     IF(!(ER=A_TERM(T+I,VV,&L,PC[SEGMENT],&AFL,&LABEL,1)))
  693.                     {$7b}
  694. /* IF(1) PRINTF("A_TERM RETURNS AFL=%04X\N",AFL); */
  695.  
  696.  RLT[0] = AFL;
  697.  LAB[0] = LABEL;
  698.                          I+=L;
  699.                          IF(T[I]!=t_end)
  700.                          {$7b}
  701.                               IF(T[I]!=',')
  702.                                    ER=e_syntax;
  703.                               ELSE
  704.                               {$7b}
  705.                                    I++;
  706.                                    SY++;
  707.                                    IF(!(ER=A_TERM(T+I,VV+1,&L,PC[SEGMENT],&AFL,&LABEL,1)))
  708.                                    {$7b}
  709.                 RLT[1] = AFL;
  710. LAB[1] = LABEL;
  711.                                         I+=L;
  712.                                         IF(T[I]!=t_end)
  713.                                         {$7b}
  714.                                              IF(T[I]!=',')
  715.                                                   ER=e_syntax;
  716.                                              ELSE
  717.                                              {$7b}
  718.                                                   I++;
  719.                                                   SY++;
  720.                                                   IF(!(ER=A_TERM(T+I,VV+2,&L,PC[SEGMENT],&AFL,&LABEL,1)))
  721.                                                   {$7b}
  722.                                RLT[2] = AFL;
  723.        LAB[2] = LABEL;
  724.                                                        I+=L;
  725.                                                        IF(T[I]!=t_end)
  726.                                                             ER=e_syntax;
  727.                                                   {$7d}
  728.                                              {$7d}
  729.                                         {$7d}
  730.                                    {$7d}
  731.                               {$7d}
  732.                          {$7d}
  733.                     {$7d}
  734.                {$7d} ELSE
  735.                IF(C==t_end)
  736.                {$7b}
  737.                     SY=0;
  738.                {$7d} ELSE
  739.                IF(C=='(')
  740.                {$7b}
  741.                     SY=7;
  742.                     IF(!(ER=A_TERM(T+2,VV,&L,PC[SEGMENT],&AFL,&LABEL,1)))
  743.                     {$7b}
  744.  RLT[0] = AFL;
  745.  LAB[0] = LABEL;
  746.  
  747.                          IF(T[2+L]!=t_end)
  748.                          {$7b}
  749.                               IF(T[2+L]==',' && TOLOWER(T[3+L])=='X')
  750.                                    SY=8;
  751.                               ELSE
  752.                               IF(T[2+L]==')')
  753.                               {$7b}
  754.                                    IF(T[3+L]==',')
  755.                                    {$7b}
  756.                                         IF(TOLOWER(T[4+L])=='Y')
  757.                                              SY=9;
  758.                                         ELSE
  759.                                              ER=e_syntax;
  760.                                    {$7d} ELSE
  761.                                    IF(T[3+L]!=t_end)
  762.                                         ER=e_syntax;
  763.                               {$7d} 
  764.                          {$7d} ELSE
  765.                               ER=e_syntax;
  766.                     {$7d}
  767.                {$7d} ELSE
  768.                {$7b}
  769.                     SY=4;
  770.                     IF(!(ER=A_TERM(T+1,VV,&L,PC[SEGMENT],&AFL,&LABEL,1)))
  771.                     {$7b}
  772.  RLT[0] = AFL;
  773.  LAB[0] = LABEL;
  774.                          IF(T[1+L]!=t_end)
  775.                          {$7b}
  776.                               IF(T[1+L]==',')
  777.                               {$7b}
  778.                                    IF(TOLOWER(T[2+L])=='Y')
  779.                                         SY=6;
  780.                                    ELSE
  781.                                         SY=5;
  782.                               {$7d} ELSE
  783.                                    ER=e_syntax;
  784.                          {$7d}
  785.                     {$7d}
  786.                {$7d}
  787.                 
  788.                BL=4;
  789.                
  790.                WHILE(--BL)
  791.                {$7b}
  792.                     IF((AM=AT[SY][BL-1])>=0)
  793.                     {$7b}
  794.                          IF(AM>15)
  795.                          {$7b}
  796.                               ER=e_syntax;
  797.                               BREAK;
  798.                          {$7d}
  799.                          IF(CT[N][AM]>=0)
  800.                               BREAK;
  801.  
  802.                          FOR(V=0;V<aNZaLT;V++)
  803.                               IF(XT[V][0]==AM && CT[N][XT[V][1]]>=0)
  804.                                    BREAK;
  805.                          IF(V<aNZaLT) 
  806.                          {$7b}
  807.                               AM=XT[V][1];
  808.                               BREAK;
  809.                          {$7d}
  810.                     {$7d}
  811.                {$7d}
  812.  
  813.                IF(FL && BL && !ER && !(VV[0]&0XFF00) && OPT[AM]>=0)
  814.                     IF(CT[N][OPT[AM]]>=0)
  815.                          AM=OPT[AM];
  816.  
  817.                IF(!BL)
  818.                     ER=e_syntax;
  819.                ELSE
  820.                {$7b}
  821.                     BL=LE[AM];
  822.                     *LL=BL;
  823.                {$7d}
  824.  
  825.  
  826.                IF(!ER)
  827.                {$7b}
  828.                     T[0]=CT[N][AM]&0X00FF;
  829.                     IF(CT[N][AM]&0X0100)
  830.                     {$7b}
  831.                          NCMOS++;
  832.                          IF(!CMOSFL)
  833.                               ER=e_cmos;
  834.                     {$7d}
  835.                     IF(AM!=0)
  836.                     {$7b}
  837.                          IF(AM<8)
  838.                          {$7b}
  839.                               IF(VV[0]&0XFF00)
  840.                                    ER=e_overflow;
  841.                               ELSE
  842.                                    T[1]=VV[0];
  843. /*IF(RLT[0]) PRINTF("RELOCATION 1 BYTE %04X AT PC=$%04X, VALUE NOW =$%04X\N",RLT[0],PC[SEGMENT]+1,*VV); */
  844.       IF(RLT[0]) U_SET(PC[SEGMENT]+1, RLT[0], LAB[0], 1);
  845.                          {$7d} ELSE
  846.                          IF(AM<14 && AM!=11)
  847.                          {$7b}
  848.                               T[1]=VV[0]&255;
  849.                               T[2]=(VV[0]>>8)&255;
  850. /*IF(RLT[0]) PRINTF("RELOCATION 2 BYTE %04X AT PC=$%04X, VALUE NOW =$%04X\N",RLT[0],PC[SEGMENT]+1,*VV); */
  851.       IF(RLT[0]) U_SET(PC[SEGMENT]+1, RLT[0], LAB[0], 2);
  852.                          {$7d} ELSE
  853.                          IF(AM==11) {$7b}
  854.    IF((SEGMENT!=seg_abs) && (!RLT[0])) {$7b}
  855.      ER=e_illpointer;
  856.    {$7d} ELSE {$7b}
  857. /*PRINTF("AM=11, PC=%04X, VV[0]=%04X, SEGMENT=%D\N",PC[SEGMENT],VV[0], SEGMENT);*/
  858.                               V=VV[0]-PC[SEGMENT]-2;
  859.                               IF(((V&0XFF80)!=0XFF80) && (V&0XFF80))
  860.                                    ER=e_range;
  861.                               ELSE
  862.                                    T[1]=V;
  863.    {$7d}
  864.                          {$7d} ELSE
  865.                          IF(AM==14) {$7b}
  866.                               IF(VV[0]&0XFFF8 {$7c}{$7c} VV[1]&0XFF00)
  867.                                    ER=e_range;
  868.                               ELSE
  869.       IF((SEGMENT!=seg_abs) && (RLT[0] {$7c}{$7c} !RLT[2])) {$7b}
  870.    ER=e_illpointer;
  871.       {$7d} ELSE {$7b}
  872. /*IF(RLT[1]) PRINTF("RELOCATION 1 BYTE %04X AT PC=$%04X, VALUE NOW =$%04X\N",RLT[1],PC[SEGMENT]+1,*VV); */
  873.            IF(RLT[1]) U_SET(PC[SEGMENT]+1, RLT[1], LAB[1], 1);
  874.                                    T[0]=T[0]{$7c}(VV[0]<<4);
  875.                                    T[1]=VV[1];
  876.                                    V=VV[2]-PC[SEGMENT]-3;
  877.                                    IF((V&0XFF80) && ((V&0XFF80)!=0XFF80))
  878.                                         ER=e_overflow;
  879.                                    ELSE
  880.                                         T[2]=V;
  881.                               {$7d}
  882.                          {$7d} ELSE
  883.                          IF(AM==15)
  884.                          {$7b}
  885. /*IF(RLT[1]) PRINTF("RELOCATION 1 BYTE %04X AT PC=$%04X, VALUE NOW =$%04X\N",RLT[1],PC[SEGMENT]+1,*VV); */
  886.       IF(RLT[1]) U_SET(PC[SEGMENT]+1, RLT[1], LAB[1], 1);
  887.                               IF(VV[0]&0XFFF8 {$7c}{$7c} VV[1]&0XFF00)
  888.                                    ER=e_overflow;
  889.                               ELSE
  890.                               {$7b}
  891.                                    T[0]=T[0]{$7c}(VV[0]<<4);
  892.                                    T[1]=VV[1];
  893.                               {$7d}
  894.                          {$7d} ELSE
  895.                               ER=e_syntax;
  896.                     {$7d}
  897.                {$7d}          
  898.                     
  899.           {$7d} ELSE
  900.                ER=e_syntax;
  901.      {$7d}
  902.      PC[SEGMENT]+=BL;
  903.      IF(SEGMENT==seg_text) PC[seg_abs]+=BL;
  904.      IF(SEGMENT==seg_abs) PC[seg_text]+=BL;
  905.      *AL = BL;
  906.      RETURN(ER);
  907. {$7d}
  908.  
  909. INT B_TERM(CHAR *S, INT *V, INT *L, INT PC)
  910. {$7b}
  911.      STATIC SIGNED CHAR T[maxline];
  912.      INT ER,I,AFL, LABEL;
  913.  
  914.      IF(!(ER=T_CONV((SIGNED CHAR*)S,T,L,PC,&I,&I,&I,1)))
  915.      {$7b}
  916.           ER=A_TERM(T,V,&I,PC,&AFL,&LABEL,0);
  917.      
  918.      {$7d}
  919.      RETURN(ER);
  920. {$7d}
  921.      
  922. STATIC INT T_CONV(SIGNED CHAR *S, SIGNED CHAR *T, INT *L, INT PC, INT *NK, 
  923. INT *NA1, INT *NA2, INT AF)  /* pASS1 VON S NACH T */
  924. {$7b}
  925.      STATIC INT P,Q,UD,N,V,LL,MK,ER,F;
  926.      STATIC INT OPERAND,O,FL,AFL;
  927.  
  928.      *NK=0;         /* aNZAHL kOMMA               */
  929.      *NA1=0;        /* aNZAHL "ASC-TEXTE"         */
  930.      *NA2=0;        /* UND aNZAHL bYTE IN DIESEN  */
  931.      LL=0;
  932.      ER=e_ok;
  933.      P=0;
  934.      Q=0;
  935.      UD=0;
  936.      MK=0;          /* 0 = MEHRERE kOMMAS ERLAUBT */
  937.      FL=0;          /* 1 = TEXT EINFACH WEITERGEBEN */
  938.      AFL=0;    /* POINTER FLAG FOR LABEL */
  939.  
  940.      WHILE(S[P]==' ') P++;
  941.  
  942.      N=t_end;
  943.  
  944.      IF(!AF)
  945.      {$7b}
  946.           WHILE(S[P]!='\0' && S[P]!=';')
  947.           {$7b}
  948.  
  949.                IF(!(ER=T_KEYWORD(S+P,&LL,&N)))
  950.                     BREAK;
  951.  
  952.                IF(ER && ER!=e_nokey)
  953.                     BREAK;
  954.  
  955.                IF((ER=L_DEF((CHAR*)S+P,&LL,&N,&F)))
  956.                     BREAK;
  957.  
  958.                P+=LL;
  959.  
  960.                WHILE(S[P]==' ') P++;
  961.  
  962.                IF(S[P]=='=')
  963.                {$7b}
  964.                     T[Q++]=t_op;
  965.                     T[Q++]=N&255;
  966.                     T[Q++]=(N>>8)&255;  
  967.                     T[Q++]='=';
  968.                     P++;
  969.                     LL=N=0;
  970.                     BREAK;
  971.                {$7d} ELSE
  972.                IF(F && S[P]!='\0' && S[P+1]=='=')
  973.                {$7b}
  974.                     T[Q++]=t_op;
  975.                     T[Q++]=N&255;
  976.                     T[Q++]=(N>>8)&255;
  977.                     T[Q++]=S[P];
  978.                     P+=2;
  979.                     LL=N=0;
  980.                     BREAK;
  981.                {$7d} ELSE
  982.                {$7b}
  983.                     L_SET(N,PC,SEGMENT);/* SET AS ADDRESS VALUE */
  984.                     N=0;
  985.                {$7d}
  986.  
  987.           {$7d}
  988.    
  989.  
  990.           IF(N<=lASTBEF)
  991.                MK=1;     /* 1= NUR 1 kOMMA ERLAUBT     */
  992.      {$7d}
  993.      IF(S[P]=='\0' {$7c}{$7c} S[P]==';')
  994.      {$7b}
  995.           ER=e_noline;
  996.           LL=0;
  997.      {$7d} ELSE
  998.      IF(!ER)
  999.      {$7b}
  1000.  
  1001.           P+=LL;
  1002.           IF(LL)
  1003.                T[Q++]=N;
  1004.  
  1005.           OPERAND=1;
  1006.           
  1007.           WHILE(S[P]==' ') P++;
  1008.  
  1009.           IF(S[P]=='#')
  1010.           {$7b}
  1011.                MK=0;
  1012.                T[Q++]=S[P++];
  1013.                WHILE(S[P]==' ')
  1014.                     P++;
  1015.           {$7d}
  1016.           WHILE(S[P]!='\0' && S[P]!=';' && !ER)
  1017.           {$7b}
  1018.                IF(FL)
  1019.                {$7b}
  1020.                     T[Q++]=S[P++];
  1021.                {$7d} ELSE
  1022.                {$7b}
  1023.                  IF(OPERAND) 
  1024.                  {$7b}
  1025.                     IF(S[P]=='(' {$7c}{$7c} S[P]=='-' {$7c}{$7c} S[P]=='>' {$7c}{$7c} S[P]=='<')
  1026.                     {$7b}
  1027.                          T[Q++]=S[P++];
  1028.                          OPERAND= -OPERAND+1;
  1029.                     {$7d} ELSE
  1030.                     IF(S[P]=='*')
  1031.                     {$7b}
  1032.                          T[Q++]=S[P++];
  1033.                     {$7d} ELSE
  1034.                     IF(ISALPHA(S[P]) {$7c}{$7c} S[P]=='_')
  1035.                     {$7b}
  1036.                          ER=L_SUCH((CHAR*)S+P,&LL,&N,&V,&AFL);
  1037.                          IF(!ER)
  1038.                          {$7b}
  1039.    IF(AFL) {$7b}
  1040.      T[Q++]=t_pointer;
  1041.                              T[Q++]=AFL & 255;
  1042.                              T[Q++]=V & 255;
  1043.                              T[Q++]=(V>>8) & 255;
  1044.    {$7d} ELSE {$7b}
  1045.                              WVAL(Q,V);
  1046.    {$7d}
  1047.                          {$7d}
  1048.                          ELSE
  1049.                          IF(ER==e_nodef)
  1050.                          {$7b}
  1051.                               T[Q++]=t_label;
  1052.                               T[Q++]=N & 255;
  1053.                               T[Q++]=(N>>8) & 255;
  1054.                               UD++;
  1055.                               ER=e_ok;
  1056.                          {$7d}
  1057.                          P+=LL;
  1058.                     {$7d}
  1059.                     ELSE
  1060.                     IF(S[P]<='9' && S[P]>='0')
  1061.                     {$7b}
  1062.                          TG_DEZ(S+P,&LL,&V);
  1063.                          P+=LL;
  1064.                          WVAL(Q,V);
  1065.                     {$7d}
  1066.                     ELSE
  1067.                     SWITCH(S[P]) {$7b}
  1068.                     CASE '$':
  1069.                          TG_HEX(S+P+1,&LL,&V);
  1070.                          P+=1+LL;
  1071.                          WVAL(Q,V);
  1072.                          BREAK;
  1073.                     CASE '%':
  1074.                          TG_BIN(S+P+1,&LL,&V);
  1075.                          P+=1+LL;
  1076.                          WVAL(Q,V);
  1077.                          BREAK;
  1078.                     CASE '&':
  1079.                          TG_OCT(S+P+1,&LL,&V);
  1080.                          P+=1+LL;
  1081.                          WVAL(Q,V);
  1082.                          BREAK;
  1083.                     CASE '\"':
  1084.                          ER=TG_ASC(S+P,T+Q,&Q,&P,NA1,NA2);
  1085.                          BREAK;
  1086.                     CASE ',':
  1087.                          IF(MK)
  1088.                               WHILE(S[P]!='\0' && S[P]!=';')
  1089.                               {$7b}
  1090.                                    WHILE(S[P]==' ') P++;
  1091.                                    *NK+=(S[P]==',');
  1092.                                    T[Q++]=S[P++];
  1093.                               {$7d}
  1094.                          ELSE
  1095.                          {$7b}
  1096.                               *NK+=1;
  1097.                               T[Q++]=S[P++];
  1098.                          {$7d}
  1099.                          BREAK;
  1100.                     DEFAULT :
  1101.                          ER=e_syntax;
  1102.                          BREAK;
  1103.                     {$7d}
  1104.                     OPERAND= -OPERAND+1;
  1105.  
  1106.                  {$7d} ELSE    /* OPERATOR    */
  1107.                  {$7b} 
  1108.                     O=0;
  1109.                     IF(S[P]==')')
  1110.                     {$7b}
  1111.                          T[Q++]=S[P++];
  1112.                          OPERAND =-OPERAND+1;
  1113.                     {$7d} ELSE
  1114.                     IF(S[P]==',')
  1115.                     {$7b}
  1116.                          T[Q++]=S[P++];
  1117.                          IF(MK)
  1118.                               FL++;
  1119.                          *NK+=1;
  1120.                     {$7d} ELSE
  1121.                     SWITCH(S[P]) {$7b}
  1122.                     CASE '+':
  1123.                          O=1;
  1124.                          BREAK;
  1125.                     CASE '-':
  1126.                          O=2;
  1127.                          BREAK;
  1128.                     CASE '*':
  1129.                          O=3;
  1130.                          BREAK;
  1131.                     CASE '/':
  1132.                          O=4;
  1133.                          BREAK;
  1134.                     CASE '<':
  1135.                          SWITCH (S[P+1]) {$7b}
  1136.                          CASE '<':
  1137.                               O=6;
  1138.                               BREAK;
  1139.                          CASE '>':
  1140.                               O=12;
  1141.                               BREAK;
  1142.                          CASE '=':
  1143.                               O=10;
  1144.                               BREAK;
  1145.                          DEFAULT :
  1146.                               O=7;
  1147.                               BREAK;
  1148.                          {$7d}
  1149.                          BREAK;
  1150.                     CASE '>':
  1151.                          SWITCH (S[P+1]) {$7b}
  1152.                          CASE '>':
  1153.                               O=5;
  1154.                               BREAK;
  1155.                          CASE '<':
  1156.                               O=12;
  1157.                               BREAK;
  1158.                          CASE '=':
  1159.                               O=11;
  1160.                               BREAK;
  1161.                          DEFAULT:
  1162.                               O=8;
  1163.                               BREAK;
  1164.                          {$7d}
  1165.                          BREAK;
  1166.                     CASE '=':
  1167.                          SWITCH (S[P+1]) {$7b}
  1168.                          CASE '<':
  1169.                               O=10;
  1170.                               BREAK;
  1171.                          CASE '>':
  1172.                               O=11;
  1173.                               BREAK;
  1174.                          DEFAULT:
  1175.                               O=9;
  1176.                               BREAK;
  1177.                          {$7d}
  1178.                          BREAK;
  1179.                     CASE '&':
  1180.                          IF (S[P+1]=='&')
  1181.                               O=16;
  1182.                          ELSE
  1183.                               O=13;
  1184.                          BREAK;
  1185.                     CASE '{$7c}':
  1186.                          IF (S[P+1]=='{$7c}')
  1187.                               O=17;
  1188.                          ELSE   
  1189.                               O=15;
  1190.                          BREAK;
  1191.                     CASE '^':
  1192.                          O=14;
  1193.                          BREAK;
  1194.                     DEFAULT:
  1195.                          ER=e_syntax;
  1196.                          BREAK;
  1197.                     {$7d}
  1198.                     IF(O)
  1199.                     {$7b}
  1200.                          T[Q++]=O;
  1201.                          P+=LP[O];
  1202.                     {$7d}
  1203.                     OPERAND= -OPERAND+1;
  1204.                  {$7d}
  1205.  
  1206.                  WHILE(S[P]==' ') P++;
  1207.                {$7d}
  1208.           {$7d}
  1209.      {$7d}
  1210.      IF(!ER)
  1211.      {$7b}
  1212.           T[Q++]=t_end;
  1213.           IF(UD)
  1214.                ER=e_nodef;
  1215.      {$7d}
  1216.      *L=Q;
  1217.  
  1218.      RETURN(ER);
  1219. {$7d}
  1220.  
  1221. STATIC INT T_KEYWORD(SIGNED CHAR *S, INT *L, INT *N)
  1222. {$7b}
  1223.      INT I=0,J,HASH;
  1224.  
  1225.      IF(!ISALPHA(S[0]) && S[0]!='.' && S[0]!='*' )
  1226.           RETURN(e_nokey);
  1227.  
  1228.      IF(ISALPHA(S[0]))
  1229.           HASH=TOLOWER(S[0])-'A';
  1230.      ELSE
  1231.           HASH=26;
  1232.      
  1233.  
  1234.      IF(S[0]=='*') {$7b}
  1235.  J=1;
  1236. WHILE(S[J] && ISSPACE(S[J])) J++;
  1237. IF(S[J]=='=') {$7b}
  1238.   I=kPCDEF;
  1239.   J++;
  1240. {$7d}
  1241.      {$7d} 
  1242.      IF(!I) {$7b}    
  1243.        I=KTP[HASH];
  1244.        HASH=KTP[HASH+1];
  1245.        WHILE(I<HASH)
  1246.        {$7b}
  1247.           J=0;
  1248.           WHILE(KT[I][J]!='\0' && KT[I][J]==TOLOWER(S[J]))
  1249.                J++;
  1250.  
  1251.           IF((KT[I][J]=='\0') && ((I==kPCDEF) {$7c}{$7c} ((S[J]!='_') && !ISALNUM(S[J]))))
  1252.                BREAK;
  1253.           I++;
  1254.        {$7d}
  1255.      {$7d}    
  1256.      IF(I==kBYTE) I=kBYT;
  1257.      IF(I==kDUPB) I=kDSB;
  1258.      IF(I==kBLKB) I=kDSB;
  1259.      IF(I==kDB) I=kBYT;
  1260.      IF(I==kDW) I=kWORD;
  1261.      IF(I==kBLOCK) I=kOPEN;
  1262.      IF(I==kBEND) I=kCLOSE;
  1263.      *L=J;
  1264.      *N=I;
  1265.      RETURN( I==HASH ? e_nokey : e_ok );
  1266. {$7d}
  1267.  
  1268. STATIC VOID TG_DEZ(S,L,V)
  1269. SIGNED CHAR *S;
  1270. INT *L,*V;
  1271. {$7b}
  1272.      INT I=0,VAL=0;
  1273.  
  1274.      WHILE(ISDIGIT(S[I]))
  1275.           VAL=VAL*10+(S[I++]-'0');
  1276.  
  1277.      *L=I;
  1278.      *V=VAL;
  1279. {$7d}
  1280.  
  1281. STATIC VOID TG_BIN(SIGNED CHAR *S, INT *L, INT *V)
  1282. {$7b}
  1283.      INT I=0,VAL=0;
  1284.  
  1285.      WHILE(S[I]=='0' {$7c}{$7c} S[I]=='1')
  1286.           VAL=VAL*2+(S[I++]-'0');
  1287.  
  1288.      *L=I;
  1289.      *V=VAL;
  1290. {$7d}
  1291.  
  1292. STATIC VOID TG_OCT(SIGNED CHAR *S, INT *L, INT *V)
  1293. {$7b}
  1294.      INT I=0,VAL=0;
  1295.  
  1296.      WHILE(S[I]<'8' && S[I]>='0')
  1297.           VAL=VAL*8+(S[I++]-'0');
  1298.  
  1299.      *L=I;
  1300.      *V=VAL;
  1301. {$7d}
  1302.  
  1303. STATIC VOID TG_HEX(SIGNED CHAR *S, INT *L, INT *V)
  1304. {$7b}
  1305.      INT I=0,VAL=0;
  1306.  
  1307.      WHILE((S[I]>='0' && S[I]<='9') {$7c}{$7c} (TOLOWER(S[I])<='F' && TOLOWER(S[I])>='A'))
  1308.      {$7b}
  1309.           VAL=VAL*16+(S[I]<='9' ? S[I]-'0' : TOLOWER(S[I])-'A'+10);
  1310.           I++;
  1311.      {$7d}
  1312.      *L=I;
  1313.      *V=VAL;
  1314. {$7d}
  1315.  
  1316. STATIC INT TG_ASC(SIGNED CHAR *S, SIGNED CHAR *T, INT *Q, INT *P, INT *NA1, INT *NA2)
  1317. {$7b}
  1318.      INT ER=e_ok,I=0,J=0;
  1319.      
  1320.      T[J++]=S[I++];      /* " */
  1321.      J++;
  1322.      WHILE(S[I]!='\0' && S[I]!='\"')
  1323.      {$7b}
  1324.           IF(S[I]!='^')
  1325.                T[J++]=S[I];
  1326.           ELSE 
  1327.           SWITCH(S[I+1]) {$7b}
  1328.           CASE '\0':
  1329.           CASE '\"':
  1330.                ER=e_syntax;
  1331.                BREAK;
  1332.           CASE '^':
  1333.                T[J++]='^';
  1334.                I++;
  1335.                BREAK;
  1336.           DEFAULT:
  1337.                T[J++]=S[I+1]&0X1F;
  1338.                I++;
  1339.                BREAK;
  1340.           {$7d}
  1341.           I++;
  1342.      {$7d}
  1343.      IF(J==3)
  1344.      {$7b}
  1345.           T[0]=t_value;
  1346.           T[1]=T[2];
  1347.           T[2]=0;
  1348.      {$7d} ELSE
  1349.      {$7b}
  1350.           T[1]=J-2;
  1351.           *NA1 +=1;
  1352.           *NA2 +=J-2;
  1353.      {$7d}
  1354.      IF(S[I]=='\"')
  1355.           I++;
  1356.      *Q +=J;
  1357.      *P +=I;
  1358.      RETURN(ER);
  1359. {$7d}
  1360.  
  1361.