#line 1
#include <perms.h>
// Edinburgh IMP77 Compiler - Version 8.4
//
// 1 !! %option stack=40
// 2 !!!!!! 19-Feb-82!!!! 26/6/78 - IMPASEMS412
// 3 {Modified to run on new subsystem so that old supervisor can be supported}
// 4
// 5 %own %integer FREE SPACE = 65536
#line 5 "test-new/asems412.imp"
static int FREESPACE = 65536;
// 6
// 7 %OWNSTRING(4) P2VERSION = "4.13"
#line 7 "test-new/asems412.imp"
static _imp_string4 P2VERSION = _imp_str_init("4.13");
// 8
// 9
// 10 !!!!!!%CONTROL 3; ! CHECK SWITCHES AND STACK LIMIT
// 11 %BEGIN; ! INTERDATA 7/32 IMP ASSEMBLER !
#line 11 "test-new/asems412.imp"
int main(int argc, char **argv) { /*%begin*/
#line 11 "test-new/asems412.imp"
_imp_initialise(argc, argv);
// 12
// 13 ! SIZE CONSTANTS
// 14
// 15 %CONSTINTEGER MAX ENVIRS = 13
// 16 ! %CONSTINTEGER MAX VARS = 490
// 17 %CONSTINTEGER MAX LABELS = 80
// 18 %CONSTINTEGER MAX DEPTH = 16
// 19 %CONSTINTEGER MAX STACK = 31
// 20 %CONSTINTEGER INIT GLA = 32; ! **USED LOCALLY AND IN PASS 3**
// 21 %CONSTINTEGER LAST PERM = -24; ! MUST MATCH PERM TABLE IN PASS 3
// 22
// 23 ! STATIC GLA LAYOUT
// 24 !
// 25 ! 0: STACK LIMIT
// 26 ! 4: @diag tables (zero if missing)
// 27 ! 8: IOCP switch base
// 28 ! 12: IOCP gla base
// 29 ! 16: IOCP code base
// 30 ! 20: IOCP base level locals
// 31 ! 24: -spare-
// 32 ! 28: -spare-
// 33 !
// 34
// 35
// 36 %CONSTINTEGER INITIAL FREE = 5120; ! INITIAL FREE STACK(BYTES)
// 37 %CONSTINTEGER MIN FREE = 600; ! LOWER LIMIT ON FREE STACK SPACE
// 38
// 39 ! ON THE 32-BIT SERIES, EFFICIENT(RX1) BASE+DISPLACEMENT ADDRESSING
// 40 ! IS ONLY AVAILABLE FOR VALUES OF DISPLACEMENT < 16*1024.
// 41 ! ARRAYS WITH FIXED BOUNDS ARE PUT INTO THE STATIC STACK FRAME
// 42 ! UNTIL THE FRAME SIZE > 'MAX STATIC' LEAVING [16*1024 - MAX STATIC]
// 43 ! BYTES AVAILABLE FOR SCALARS. THERE MAY STILL BE PROBLEMS WITH
// 44 ! LARGE RECORDS (WHICH CAN CONTAIN ARRAYS).
// 45
// 46 %CONSTINTEGER MAX STATIC = 13000
// 47
// 48
// 49
// 50 ! WORDLENGTH DEPENDENT VALUES:
// 51
// 52 %CONSTINTEGER REGLEN=4; ! REGISTER LENGTH(IN 8-BIT BYTES)
// 53
// 54
// 55
// 56 ! COMPILER CONTROL OPTIONS (DEFAULT MARKED *)
// 57 %CONSTINTEGER TEST SWITCH = 1; !* CHECK SWITCH JUMPS
// 58 %CONSTINTEGER STKDIAG = 2; !* CHECK EXTENT OF STACK
// 59 %CONSTINTEGER ARRAY DIAG = 4; !* CHECK ARRAY BOUNDS
// 60 %CONSTINTEGER FORDIAG = 8; !* VALIDATE %FOR PARAMETERS
// 61 %CONSTINTEGER ASS DIAG =16; !* TEST FOR TRUNCATION
// 62 %CONSTINTEGER UNASS DIAG =32; !* CHECK FOR UNASSIGNED VARIABLES
// 63 !
// 64 %CONSTINTEGER TRUSTED =4096; ! ENABLE DIRTY OPTIMISATIONS
// 65
// 66 ! %CONTROL 0 GIVES TIGHTEST CODE (NO CHECKING AT ALL!)
// 67
// 68
// 69
// 70
// 71 ! COMPILER ERROR CODES
// 72 ! --------------------
// 73 ! CODE ROUTINE MEANING
// 74 ! ---- ------- -------
// 75 ! 1 RELEASE TOO MANY CALLS ON 'RELEASE'
// 76 ! 2 CHECK RELEASED TOO FEW CALLS ON 'RELEASE'
// 77 ! 3 HAZARD FAULTY PARAM. SUPPLIED TO HAZARD??
// 78 ! 4 "" "" ????
// 79 ! 5 RX, RI2, RI3 ILLEGAL ADDRESS FIELD GENERATE
// 80 ! 6 LOOKUP UNDEFINED NAME IN INTERMEDIATE COD
// 81 ! 7 STACK, SSTACK ETC DESCRIPTOR STACK OVERFLO
// 82 ! 8 SET BOTH, POP LHS, ASSIGN DESCRIPTOR STACK UNDERFLO
// 83 ! 9 AMAP FAULTY PARAM. SUPPLIED TO 'AMAP'
// 84 ! 10 LOAD 'REAL' AS ADDRESS?
// 85 ! 11 LOAD FLOATING REG. REQ'D
// 86 ! 12 " "
// 87 ! 13 COP FAULTY PARAM. SUPPLIED TO 'COP'
// 88 ! 14 ASSEMBLE DESCRIPTOR STACK NON-EMPTY AT 'O
// 89 ! 15 ASSIGN FAULTY PARAM. SUPPLIED TO 'ASSIGN'
// 90 ! 16 LOAD 'REAL', INTEGER REQ''D
// 91 ! 17 DESCRIPTOR NO FREE DESCRIPTORS
// 92 ! 18 DROP DESCRIPTOR NOT IN USE
// 93 ! 19 ASSEMBLE DANGLING DESCRIPTOR
// 94
// 95 ! REGISTERS
// 96
// 97 %CONSTINTEGER R0 = 1
// 98 %CONSTINTEGER R1 = 2
// 99 %CONSTINTEGER R2 = 3
// 100 %CONSTINTEGER R3 = 4
// 101 %CONSTINTEGER R4 = 5
// 102 %CONSTINTEGER P2 = 6
// 103 %CONSTINTEGER P1 = 7
// 104 %CONSTINTEGER R9 = 8
// 105 %CONSTINTEGER R10 = 9
// 106 %CONSTINTEGER R11 = 10
// 107 %CONSTINTEGER R12 = 11
// 108 %CONSTINTEGER LINK = 12
// 109 %CONSTINTEGER FPR0 = 13
// 110 %CONSTINTEGER FPR2 = 14
// 111 ! FPR4 = 15
// 112 ! FPR6 = 16
// 113 ! FPR8 = 17
// 114 ! FPR10= 18
// 115 ! FPR12= 19
// 116 %CONSTINTEGER FPR14= 20
// 117
// 118 ! 21 - 40 ARE STORE EQUIVALENTS OF ABOVE
// 119
// 120 %CONSTINTEGER R15 = 41
// 121 %CONSTINTEGER GLA = 42
// 122 %CONSTINTEGER WSP = 43
// 123 %CONSTINTEGER CODE = 44
// 124
// 125 %CONSTINTEGER ANY = 45
// 126 %CONSTINTEGER ANY0 = 46
// 127 %CONSTINTEGER ANYF = 47
// 128 %CONSTINTEGER PARAM= 48
// 129
// 130 %CONSTINTEGER STORE= 20
// 131
// 132 %CONSTBYTEINTEGERARRAY BASE REG(0:5) = R0, R15, R9, R10, R11, R12
#line 132 "test-new/asems412.imp"
const unsigned char BASEREG[6] = {1, 41, 8, 9, 10, 11};
// 133 %CONSTBYTEINTEGERARRAY ACTUAL(0:44) = 0,
#line 133 "test-new/asems412.imp"
const unsigned char ACTUAL[45] = {
0, 0, 1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 8, 0, 2, 4, 6, 8, 10, 12, 14, [21 ... 40] = 0, 15, 13, 7, 14};
// 134+ 0, 1, 2, 3, 4, 5, 6, 9,
// 135+ 10,11,12, 8,
// 136+ 0, 2, 4, 6, 8,10,12,14,
// 137+ 0(20), 15, 13, 7, 14
// 138
// 139
// 140 ! DATA FORMS
// 141
// 142 ! EXTERNAL
// 143
// 144 %CONSTINTEGER SWITCH = 6
// 145 %CONSTINTEGER ARRAY = 11
// 146 %CONSTINTEGER ARRAYNAME = 12
// 147
// 148 ! INTERNAL
// 149
// 150 %CONSTINTEGER CONSTANT = 0
// 151 %CONSTINTEGER V IN R = 1
// 152 %CONSTINTEGER A IN S = 2
// 153 %CONSTINTEGER V IN S = 3
// 154 %CONSTINTEGER A IN REC = 4
// 155 %CONSTINTEGER V IN REC = 5
// 156 %CONSTINTEGER AV IN S = 6
// 157 %CONSTINTEGER AV IN REC= 7
// 158
// 159 ! LABEL CONSTANTS
// 160
// 161 %CONSTINTEGER DEFINE = 0
// 162 %CONSTINTEGER REDEFINE = 1
// 163
// 164 ! DATA TYPES
// 165
// 166 %CONSTINTEGER INTEGER = 1
// 167 %CONSTINTEGER BYTE = 2
// 168 %CONSTINTEGER SHORT = 3
// 169 %CONSTINTEGER STRING = 4
// 170 %CONSTINTEGER RECORD = 5
// 171 %CONSTINTEGER REALS = 6
// 172 %CONSTINTEGER LONG = 7
// 173
// 174 %CONSTINTEGER UNSIGNED HALFWORD = 255; ! INTERNAL TO PASS 2
// 175
// 176 ! OWN INFO
// 177
// 178 ! %CONSTINTEGER OWN = 1
// 179 %CONSTINTEGER CON = 2
// 180 %CONSTINTEGER PERMRT = 7
// 181
// 182 ! PROC INFO
// 183
// 184 %CONSTINTEGER FORMATS = '2'
// 185 %CONSTINTEGER PROCEDURE = '1'
// 186 %CONSTINTEGER SPEC = '0'
// 187
// 188 ! OBJECT FILE DIRECTIVES
// 189
// 190 %CONSTINTEGER START = 1
// 191 %CONSTINTEGER LOAD CODE = 2
// 192 %CONSTINTEGER LOAD GLA = 3
// 193 %CONSTINTEGER LINE FLAG = 4
// 194 %CONSTINTEGER C END = 5
// 195 ! %CONSTINTEGER L DATA = 6
// 196 %CONSTINTEGER DLINE = 10
// 197 %CONSTINTEGER DIAGS = 11
// 198
// 199 ! DIRECTIVE FILE COMMANDS
// 200
// 201 %CONSTINTEGER TAG DEF = 1
// 202 %CONSTINTEGER C REF = 2; ! CONDITIONAL JUMP REF.
// 203 %CONSTINTEGER J REF = 3; ! UNCONDITIONAL JUMP REF.
// 204 %CONSTINTEGER R REF = 4; ! ROUTINE REF. (UNCONDITIONAL)
// 205 %CONSTINTEGER P REF = 5; ! PERM REF. (UNCONDITIONAL)
// 206 %CONSTINTEGER PATCH GLA = 6
// 207 %CONSTINTEGER PATCHCODE = 7
// 208 %CONSTINTEGER D END = 8; ! END OF DIRECTIVES FILE
// 209
// 210 ! FILE DEFINITION
// 211
// 212 %CONSTINTEGER INSTREAM = 2
// 213 %CONSTINTEGER REPORT = 0; ! ...ERROR MESSAGE STREAM
// 214 %CONSTINTEGER LIST = 1
// 215 %CONSTINTEGER OBJECT = 2
// 216 %CONSTINTEGER DIRECT = 3
// 217
// 218
// 219 ! SYMBOLS
// 220
// 221 %CONSTINTEGER COMMA = ','
// 222 %CONSTINTEGER MINUS = '-'
// 223
// 224 ! PERM ROUTINES (FPR4, FPR2,P1,P2,R4, R3,R2,R1,R0)
// 225
// 226 %CONSTINTEGER MONITOR = X'1EF01'
// 227 %CONSTINTEGER R COPY = X'00902'
// 228 %CONSTINTEGER R CLEAR = X'00903'
// 229 %CONSTINTEGER SWJUMP = X'1EF04'
// 230 %CONSTINTEGER ASET = X'06F05'
// 231 %CONSTINTEGER IEXP = X'00B07'
// 232 %CONSTINTEGER REXP = X'18108'
// 233 %CONSTINTEGER ALLOC = X'02E09'
// 234 %CONSTINTEGER SMOVE = X'0090B', CONC1 = X'0090B'
// 235 %CONSTINTEGER CONC2 = X'0630C'
// 236 %CONSTINTEGER SCOMP = X'06B0D'
// 237 %CONSTINTEGER RSYM = X'1EF0E'
// 238 ! PERM ITEMS TO PERFORM VARIOUS RUN-TIME CHECKS
// 239 %CONSTINTEGER EXBUNASS = X'01112'
// 240 %CONSTINTEGER EXB = X'00113'
// 241 %CONSTINTEGER A REF = X'00314'
// 242 %CONSTINTEGER STRINGASS = X'00015'; ! ASSIGN TEST FOR STRINGS
// 243 %CONSTINTEGER ASSTH = X'00016'; ! ASSIGN TEST FOR SHORTS
// 244 %CONSTINTEGER ASSTB = X'00017'; ! ASSIGN TEST FOR BYTES
// 245 %CONSTINTEGER FORTEST = X'1EF18'
// 246
// 247 ! FIXED GLA WORDS
// 248
// 249 ! (WORD 0 IS STACK LIMIT POINTER)
// 250 %CONSTINTEGER SIGNAL EP = 4; ! ADDRESS OF %SIGNAL
// 251
// 252
// 253 ! NOTEWORTHY CODE BLOCK DISPLACEMENTS
// 254
// 255 %CONSTINTEGER UNASS PAT = 16; ! UNASSIGNED VARIABLE PATTERN (80808080)
// 256
// 257 ! OPERATIONS
// 258
// 259 %CONSTINTEGER NOT = 1
// 260 %CONSTINTEGER NEG = 2
// 261 %CONSTINTEGER ADD = 3
// 262 %CONSTINTEGER SUB = 4
// 263 %CONSTINTEGER MUL = 6
// 264 %CONSTINTEGER DIV = 7
// 265 %CONSTINTEGER AND = 8
// 266 %CONSTINTEGER IOR = 9
// 267 %CONSTINTEGER XOR = 10
// 268 %CONSTINTEGER LSH = 11
// 269 %CONSTINTEGER RSH = 12
// 270 %CONSTINTEGER EXP = 13
// 271 %CONSTINTEGER CONC= 14
// 272 %CONSTINTEGER SADD= 15; ! SPECIAL ADD (V=V+??)
// 273 %CONSTINTEGER RDIV= 16
// 274 %CONSTINTEGER REM = 17
// 275
// 276 ! OPCODES
// 277
// 278 %CONSTINTEGER LIS = X'2400', LCS = X'2500'
// 279 %CONSTINTEGER LR = X'0800'
// 280 %CONSTINTEGER LH = X'4800', STH = X'4000'
// 281 %CONSTINTEGER LHI = X'C800'
// 282 %CONSTINTEGER LM = X'D100', STM = X'D000'
// 283 %CONSTINTEGER LHL = X'7300'
// 284
// 285
// 286 %CONSTINTEGER AIS=X'2600', AHI=X'CA00', AH=X'4A00', AR=X'0A00'
// 287 %CONSTINTEGER SIS=X'2700', SHI=X'CB00', SH=X'4B00', SR=X'0B00'
// 288 %CONSTINTEGER AM = X'5100'
// 289 %CONSTINTEGER AHM = X'6100'
// 290
// 291 %CONSTINTEGER C = X'5900', CH =X'4900', CI =X'F900', CR =X'0900'
// 292 %CONSTINTEGER CL = X'5500', CLH=X'4500', CLI=X'F500', CLR=X'0500'
// 293 %CONSTINTEGER CHI=X'C900'
// 294 %CONSTINTEGER CLHI=X'C500'
// 295 %CONSTINTEGER CHVR = X'1200'
// 296
// 297
// 298
// 299
// 300 %CONSTINTEGER TI = X'F300', THI = X'C300'
// 301
// 302 %CONSTINTEGER LBR = X'9300', LB = X'D300', STB = X'D200'
// 303 %CONSTINTEGER CLB = X'D400'
// 304
// 305 %CONSTINTEGER SRA = X'EE00'
// 306
// 307 %CONSTINTEGER BAL = X'4100'
// 308 %CONSTINTEGER JUMP= 12
// 309 %CONSTINTEGER BFCR= X'0300'
// 310
// 311 %CONSTINTEGER SVC = X'E100'
// 312 %CONSTINTEGER LME = X'7200', STME= X'7100'
// 313 %CONSTINTEGER LER = X'2800'
// 314 %CONSTINTEGER LE = X'6800', STE = X'6000'
// 315 %CONSTINTEGER CER = X'2900'
// 316 %CONSTINTEGER CE = X'6900'
// 317 %CONSTINTEGER AER=X'2A00', SER=X'2B00', MER=X'2C00', DER=X'2D00'
// 318 %CONSTINTEGER AE =X'6A00', SE =X'6B00', ME =X'6C00', DE =X'6D00'
// 319 %CONSTINTEGER FXR = X'2E00', FLR = X'2F00'
// 320
// 321 ! FULLWORD OPCODES
// 322 %CONSTINTEGER LW = X'5800', ST = X'5000'
// 323 %CONSTINTEGER LI = X'F800'
// 324 %CONSTINTEGER LA = X'E600'
// 325
// 326 %CONSTINTEGER SLLS= X'1100'
// 327 %CONSTINTEGER SRLS= X'1000'
// 328 %CONSTINTEGER SLL = X'ED00'
// 329 %CONSTINTEGER SRL = X'EC00'
// 330
// 331 %CONSTINTEGER AW = X'5A00'
// 332 %CONSTINTEGER SW = X'5B00'
// 333 %CONSTINTEGER AI = X'FA00'
// 334 %CONSTINTEGER SI = X'FB00'
// 335
// 336 %CONSTINTEGER MW = X'5C00'
// 337 %CONSTINTEGER MR = X'1C00'
// 338 %CONSTINTEGER DW = X'5D00'
// 339 %CONSTINTEGER DR = X'1D00'
// 340
// 341 %CONSTINTEGER OR=X'0600', OW=X'5600', OH=X'4600', OI=X'F600'
// 342 %CONSTINTEGER XR=X'0700', XW=X'5700', XH=X'4700', XI=X'F700'
// 343 %CONSTINTEGER NR=X'0400', NW=X'5400', NH=X'4400', NI=X'F400'
// 344 %CONSTINTEGER OHI = X'C600', XHI = X'C700', NHI = X'C400'
// 345
// 346
// 347 %RECORDFORMAT VARFM(%INTEGER DISP, %SHORTINTEGER FORMAT, EXTRA, %C
#line 347 "test-new/asems412.imp"
struct VARFM {
union {
struct {
#line 347 "test-new/asems412.imp"
int DISP;
#line 347 "test-new/asems412.imp"
short int FORMAT;
#line 347 "test-new/asems412.imp"
short int EXTRA;
#line 347 "test-new/asems412.imp"
short int ID;
#line 347 "test-new/asems412.imp"
short int LENGTH;
#line 347 "test-new/asems412.imp"
unsigned char BASE;
#line 347 "test-new/asems412.imp"
unsigned char TYPE;
#line 347 "test-new/asems412.imp"
unsigned char FORM;
#line 347 "test-new/asems412.imp"
unsigned char SIZE;
#line 347 "test-new/asems412.imp"
};
};
};
// 348+ ID, LENGTH, %BYTEINTEGER BASE, TYPE, FORM, SIZE)
// 349 %RECORDFORMAT STACKFM(%INTEGER DISP, FORMAT, EXTRA, LENGTH, DV, %C
#line 349 "test-new/asems412.imp"
struct STACKFM {
union {
struct {
#line 349 "test-new/asems412.imp"
int DISP;
#line 349 "test-new/asems412.imp"
int FORMAT;
#line 349 "test-new/asems412.imp"
int EXTRA;
#line 349 "test-new/asems412.imp"
int LENGTH;
#line 349 "test-new/asems412.imp"
int DV;
#line 349 "test-new/asems412.imp"
short int BASE;
#line 349 "test-new/asems412.imp"
short int LOP;
#line 349 "test-new/asems412.imp"
short int TYPE;
#line 349 "test-new/asems412.imp"
short int FORM;
#line 349 "test-new/asems412.imp"
struct STACKFM *LINK;
#line 349 "test-new/asems412.imp"
};
};
};
// 350+ %SHORTINTEGER BASE, LOP,TYPE, FORM, %C
// 351+ %RECORD(STACKFM)%NAME LINK)
// 352 %RECORDFORMAT SPTFM(%RECORD(STACKFM)%NAME V)
#line 352 "test-new/asems412.imp"
struct SPTFM {
union {
struct {
#line 352 "test-new/asems412.imp"
struct STACKFM *V;
#line 352 "test-new/asems412.imp"
};
};
};
// 353 %RECORDFORMAT LABELFM(%SHORTINTEGER ID, TAG, %C
#line 353 "test-new/asems412.imp"
struct LABELFM {
union {
struct {
#line 353 "test-new/asems412.imp"
short int ID;
#line 353 "test-new/asems412.imp"
short int TAG;
#line 353 "test-new/asems412.imp"
unsigned char REG;
#line 353 "test-new/asems412.imp"
unsigned char BASE;
#line 353 "test-new/asems412.imp"
int LIMIT;
#line 353 "test-new/asems412.imp"
int DISP;
#line 353 "test-new/asems412.imp"
};
};
};
// 354+ %BYTEINTEGER REG, BASE, %C
// 355+ %INTEGER LIMIT, DISP)
// 356 %RECORDFORMAT USEFM(%INTEGER DISP, CA, %C
#line 356 "test-new/asems412.imp"
struct USEFM {
union {
struct {
#line 356 "test-new/asems412.imp"
int DISP;
#line 356 "test-new/asems412.imp"
int CA;
#line 356 "test-new/asems412.imp"
short int BASE;
#line 356 "test-new/asems412.imp"
unsigned char TYPE;
#line 356 "test-new/asems412.imp"
unsigned char FORM;
#line 356 "test-new/asems412.imp"
};
};
};
// 357+ %SHORTINTEGER BASE, %C
// 358+ %BYTEINTEGER TYPE,FORM)
// 359 %RECORDFORMAT ENVFM(%INTEGER LABEL, LIMEN, %C
#line 359 "test-new/asems412.imp"
struct ENVFM {
union {
struct {
#line 359 "test-new/asems412.imp"
int LABEL;
#line 359 "test-new/asems412.imp"
int LIMEN;
#line 359 "test-new/asems412.imp"
struct USEFM E[40];
#line 359 "test-new/asems412.imp"
};
};
};
// 360+ %RECORD(USEFM)%ARRAY E(1:40))
// 361
// 362 ! DATA ARRAYS
// 363
// 364 %RECORD(USEFM)%ARRAY USE(1 : 44);! REGISTER USAGE
#line 364 "test-new/asems412.imp"
struct USEFM USE[44];
// 365 %RECORD(USEFM) KNOWN
#line 365 "test-new/asems412.imp"
struct USEFM KNOWN;
// 366 %INTEGERARRAY ACTIVITY(0 : 44);! REGISTER ACTIVITY
#line 366 "test-new/asems412.imp"
int ACTIVITY[45];
// 367 %RECORD(LABELFM)%ARRAY LABELS(1 : MAX LABELS)
#line 367 "test-new/asems412.imp"
struct LABELFM LABELS[80];
// 368 %RECORD(SPTFM)%ARRAY STACKED(1 : MAX DEPTH);! MAIN STACK
#line 368 "test-new/asems412.imp"
struct SPTFM STACKED[16];
// 369 %RECORD(STACKFM)%ARRAY STAK(0 : MAX STACK); ! STACK ELEMENTS
#line 369 "test-new/asems412.imp"
struct STACKFM STAK[32];
// 370 %INTEGERARRAY USED(0:20)
#line 370 "test-new/asems412.imp"
int USED[21];
// 371 %RECORDFORMAT DFM(%RECORD(STACKFM)%NAME D, %RECORD(DFM)%NAME LINK)
#line 371 "test-new/asems412.imp"
struct DFM {
union {
struct {
#line 371 "test-new/asems412.imp"
struct STACKFM *D;
#line 371 "test-new/asems412.imp"
struct DFM *LINK;
#line 371 "test-new/asems412.imp"
};
};
};
// 372 %RECORD(STACKFM)%NAME DESC ASL
#line 372 "test-new/asems412.imp"
struct STACKFM *DESCASL;
// 373 %RECORD(DFM)%ARRAY DLIST(0:MAX STACK)
#line 373 "test-new/asems412.imp"
struct DFM DLIST[32];
// 374 %RECORD(DFM)%NAME DASL
#line 374 "test-new/asems412.imp"
struct DFM *DASL;
// 375 %RECORD(DFM) USING
#line 375 "test-new/asems412.imp"
struct DFM USING;
// 376
// 377 %OWNBYTEINTEGERARRAY VBUF(1:10)
#line 377 "test-new/asems412.imp"
static unsigned char VBUF[10];
// 378 %OWNINTEGER VP = 0
#line 378 "test-new/asems412.imp"
static int VP = 0;
// 379 %OWNINTEGER XLEVEL = 0
#line 379 "test-new/asems412.imp"
static int XLEVEL = 0;
// 380 %INTEGER BLOCK WORD
#line 380 "test-new/asems412.imp"
int BLOCKWORD;
// 381 %OWNRECORD(VARFM) BEGIN
#line 381 "test-new/asems412.imp"
static struct VARFM BEGIN;
// 382 %RECORD(ENVFM) NULL ENV
#line 382 "test-new/asems412.imp"
struct ENVFM NULLENV;
// 383 { %constrecord(*)%name null == (0) { %OWNRECORD(STACKFM) NULL }
// 384 %ownrecord(*)%name null == 0
#line 384 "test-new/asems412.imp"
static struct LINK *NULL = 0;
// 385 %RECORD(VARFM)%NAME DECVAR
#line 385 "test-new/asems412.imp"
struct VARFM *DECVAR;
// 386
// 387 %OWNINTEGER CONTROL = B'11111111'; ! ALL CHECKS ENABLED INITIALLY
#line 387 "test-new/asems412.imp"
static int CONTROL = 255;
// 388 %OWNINTEGER PERMS = LAST PERM
#line 388 "test-new/asems412.imp"
static int PERMS = -24;
// 389 %INTEGER DYNAMIC, DOPE
#line 389 "test-new/asems412.imp"
int DYNAMIC;
#line 389 "test-new/asems412.imp"
int DOPE;
// 390 %SHORTINTEGER HALF
#line 390 "test-new/asems412.imp"
short int HALF;
// 391 %INTEGER J
#line 391 "test-new/asems412.imp"
int J;
// 392 %INTEGER CA; ! CODE ADDRESS
#line 392 "test-new/asems412.imp"
int CA;
// 393 %INTEGER GA, DIAG GLA; ! GLA ADDRESS
#line 393 "test-new/asems412.imp"
int GA;
#line 393 "test-new/asems412.imp"
int DIAGGLA;
// 394 %INTEGER DA
#line 394 "test-new/asems412.imp"
int DA;
// 395 %INTEGER LINE SIZE
#line 395 "test-new/asems412.imp"
int LINESIZE;
// 396 %OWNINTEGER REALGA; ! FRIG FOR OWNREALARRAY
#line 396 "test-new/asems412.imp"
static int REALGA;
// 397 %INTEGER LIMEN; ! BACKWARD EXTENT OF KNOWLEDGE
#line 397 "test-new/asems412.imp"
int LIMEN;
// 398 %INTEGER CURRENT LINE
#line 398 "test-new/asems412.imp"
int CURRENTLINE;
// 399 %INTEGER ENVP; ! LAST ENVIRONMENT USED (CIRCULAR)
#line 399 "test-new/asems412.imp"
int ENVP;
// 400 %INTEGER STP; ! STACK POINTER
#line 400 "test-new/asems412.imp"
int STP;
// 401 %INTEGER STACK ASL; ! STACK DESCRIPTOR POINTER
#line 401 "test-new/asems412.imp"
int STACKASL;
// 402 %ownINTEGER FRAME = 0; ! LOCAL STACK FRAME EXTENT
#line 402 "test-new/asems412.imp"
static int FRAME = 0;
// 403 %OWNINTEGER MIN TEMP = 0
#line 403 "test-new/asems412.imp"
static int MINTEMP = 0;
// 404 %INTEGER PARMS; ! START OF PARAMETER STACK
#line 404 "test-new/asems412.imp"
int PARMS;
// 405 %INTEGER LOCAL
#line 405 "test-new/asems412.imp"
int LOCAL;
// 406 %INTEGER INVERT,SWOPPED;! CONDITION INVERSION FLAG
#line 406 "test-new/asems412.imp"
int INVERT;
#line 406 "test-new/asems412.imp"
int SWOPPED;
// 407 %INTEGER UNCOND JUMP; ! ADDRESS OF CODE HOLE
#line 407 "test-new/asems412.imp"
int UNCONDJUMP;
// 408 %RECORD(LABELFM)%NAME FLAB; ! %FOR LABEL
#line 408 "test-new/asems412.imp"
struct LABELFM *FLAB;
// 409 %INTEGER GTYPE,GMODE; ! PARAMETER FLIP-FLOP
#line 409 "test-new/asems412.imp"
int GTYPE;
#line 409 "test-new/asems412.imp"
int GMODE;
// 410 %INTEGER OTYPE=0, OWNTYPE, OWNFORM, OWNVAL
#line 410 "test-new/asems412.imp"
int OTYPE;
#line 410 "test-new/asems412.imp"
OTYPE = 0;
#line 410 "test-new/asems412.imp"
int OWNTYPE;
#line 410 "test-new/asems412.imp"
int OWNFORM;
#line 410 "test-new/asems412.imp"
int OWNVAL;
// 411 %INTEGER FAULTY, ENTER UNASS
#line 411 "test-new/asems412.imp"
int FAULTY;
#line 411 "test-new/asems412.imp"
int ENTERUNASS;
// 412
// 413 %RECORD(STACKFM) ST WORK
#line 413 "test-new/asems412.imp"
struct STACKFM STWORK;
// 414 %RECORD(STACKFM) CCV
#line 414 "test-new/asems412.imp"
struct STACKFM CCV;
// 415 %INTEGER CCREG, CCCA=-1; ! CONDITION-CODE INFO
#line 415 "test-new/asems412.imp"
int CCREG;
#line 415 "test-new/asems412.imp"
int CCCA;
#line 415 "test-new/asems412.imp"
CCCA = -1;
// 416
// 417 %RECORD(STACKFM)%NAME ACTIVE STRING
#line 417 "test-new/asems412.imp"
struct STACKFM *ACTIVESTRING;
// 418 %BYTEINTEGERNAME CSLEN
#line 418 "test-new/asems412.imp"
unsigned char *CSLEN;
// 419 %BYTEINTEGERARRAY CURRENT STRING(0 : 255)
#line 419 "test-new/asems412.imp"
unsigned char CURRENTSTRING[256];
// 420
// 421 %RECORD(ENVFM)%ARRAY ENVIR(0:MAX ENVIRS);! WELL AWAY FROM ALL
#line 421 "test-new/asems412.imp"
struct ENVFM ENVIR[14];
// 422
// 423 %INTEGER MAX VARS; MAX VARS = FREE SPACE - INITIAL FREE
#line 423 "test-new/asems412.imp"
int MAXVARS;
#line 423 "test-new/asems412.imp"
MAXVARS = FREESPACE - 5120;
// 424 %BEGIN
#line 424 "test-new/asems412.imp"
{ /*%begin*/
// 425 MAX VARS = MAX VARS + INITIAL FREE//4 %IF MAX VARS <= 0
#line 425 "test-new/asems412.imp"
if (MAXVARS > 0) goto L_0001;
#line 425 "test-new/asems412.imp"
MAXVARS = MAXVARS + ((long)5120 / (long)4);
#line 425 "test-new/asems412.imp"
L_0001:;
// 426 MAX VARS = 16 %IF MAX VARS <= 0
#line 426 "test-new/asems412.imp"
if (MAXVARS > 0) goto L_0002;
#line 426 "test-new/asems412.imp"
MAXVARS = 16;
#line 426 "test-new/asems412.imp"
L_0002:;
// 427 MAX VARS = MAX VARS>>4; ! BYTE LENGTH OF 'VARFM'
#line 427 "test-new/asems412.imp"
MAXVARS = (unsigned int)MAXVARS >> 4;
// 428 ! SELECT OUTPUT(LIST)
// 429 ! PRINTSTRING("PASS 2 VERSION ");! PRINTSTRING(P2VERSION)
// 430 ! WRITE(MAX VARS, 1);! PRINTSTRING(" VARS");! NEWLINE
// 431 %END
#line 431 "test-new/asems412.imp"
goto end_1000;
#line 431 "test-new/asems412.imp"
end_1000:;
#line 431 "test-new/asems412.imp"
}
// 432
// 433 %RECORD(VARFM)%ARRAY VAR(1:MAX VARS)
#line 433 "test-new/asems412.imp"
struct VARFM VAR[MAXVARS - 1 + 1];
#line 433 "test-new/asems412.imp"
auto void RX(int OP, int R, int X, int D);
// 434
// 435
// 436 %ROUTINESPEC RX(%INTEGER OP, R, X, D)
// 437
// 438
// 439 %ROUTINE PHEX(%INTEGER N)
#line 439 "test-new/asems412.imp"
void PHEX(int N) {
// 440 %INTEGER J,K
#line 440 "test-new/asems412.imp"
int J;
#line 440 "test-new/asems412.imp"
int K;
// 441 %CYCLE J = 1,1,4
#line 441 "test-new/asems412.imp"
// %for J = 1, 1, 4 %cycle
#line 441 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = 4;
#line 441 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 1, 1, 4");
_control = J = _initial - _increment;
#line 441 "test-new/asems412.imp"
L_0003:
#line 441 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 441 "test-new/asems412.imp"
if (J == _final) goto L_0004;
#line 441 "test-new/asems412.imp"
_control += _increment;
J += _increment;
// 442 K = (N>>12)&15; N = N<<4
#line 442 "test-new/asems412.imp"
K = (unsigned int)N >> 12 & 15;
#line 442 "test-new/asems412.imp"
N = N << 4;
// 443 %IF K > 9 %THEN K = K-10+'A' %ELSE K = K+'0'
#line 443 "test-new/asems412.imp"
if (K <= 9) goto L_0006;
#line 443 "test-new/asems412.imp"
K = K - 10 + 65;
#line 443 "test-new/asems412.imp"
goto L_0007;
#line 443 "test-new/asems412.imp"
L_0006:;
#line 443 "test-new/asems412.imp"
K = K + 48;
#line 443 "test-new/asems412.imp"
L_0007:;
// 444 PRINTSYMBOL(K)
#line 444 "test-new/asems412.imp"
_imp_PRINTSYMBOL(K);
// 445 %REPEAT
#line 445 "test-new/asems412.imp"
goto L_0003;
#line 445 "test-new/asems412.imp"
}
#line 445 "test-new/asems412.imp"
L_0004:;
// 446 %END
#line 446 "test-new/asems412.imp"
return;
#line 446 "test-new/asems412.imp"
} /* end of PHEX */
// 447
// 448 %ROUTINE DECODE(%INTEGER WORD)
#line 448 "test-new/asems412.imp"
void DECODE(int WORD) {
// 449 %OWNINTEGER LAST,N
#line 449 "test-new/asems412.imp"
static int LAST;
#line 449 "test-new/asems412.imp"
static int N;
// 450 SELECTOUTPUT(LIST)
#line 450 "test-new/asems412.imp"
_imp_SELECTOUTPUT(1);
// 451 %IF LAST # CURRENT LINE %START
#line 451 "test-new/asems412.imp"
if (LAST == CURRENTLINE) goto L_0008;
// 452 LAST = CURRENT LINE
#line 452 "test-new/asems412.imp"
LAST = CURRENTLINE;
// 453 NEWLINE %UNLESS N = 0
#line 453 "test-new/asems412.imp"
if (N == 0) goto L_0009;
#line 453 "test-new/asems412.imp"
_imp_NEWLINE();
#line 453 "test-new/asems412.imp"
L_0009:;
// 454 N = 16
#line 454 "test-new/asems412.imp"
N = 16;
// 455 WRITE(CURRENT LINE, 4); SPACE
#line 455 "test-new/asems412.imp"
_imp_WRITE(CURRENTLINE, 4);
#line 455 "test-new/asems412.imp"
_imp_SPACE();
// 456 PHEX(CA); PRINTSYMBOL(':')
#line 456 "test-new/asems412.imp"
PHEX(CA);
#line 456 "test-new/asems412.imp"
_imp_PRINTSYMBOL(58);
// 457 %ELSE
#line 457 "test-new/asems412.imp"
goto L_000A;
#line 457 "test-new/asems412.imp"
L_0008:;
// 458 SPACES(11) %IF N = 16
#line 458 "test-new/asems412.imp"
if (N != 16) goto L_000B;
#line 458 "test-new/asems412.imp"
_imp_SPACES(11);
#line 458 "test-new/asems412.imp"
L_000B:;
// 459 %FINISH
#line 459 "test-new/asems412.imp"
L_000A:;
// 460 SPACES(2); PHEX(WORD)
#line 460 "test-new/asems412.imp"
_imp_SPACES(2);
#line 460 "test-new/asems412.imp"
PHEX(WORD);
// 461 N = N-1
#line 461 "test-new/asems412.imp"
N = N - 1;
// 462 N = 16 %AND NEWLINE %IF N <= 0
#line 462 "test-new/asems412.imp"
if (N > 0) goto L_000C;
#line 462 "test-new/asems412.imp"
N = 16;
#line 462 "test-new/asems412.imp"
_imp_NEWLINE();
#line 462 "test-new/asems412.imp"
L_000C:;
// 463 SELECTOUTPUT(OBJECT)
#line 463 "test-new/asems412.imp"
_imp_SELECTOUTPUT(2);
// 464 %END
#line 464 "test-new/asems412.imp"
return;
#line 464 "test-new/asems412.imp"
} /* end of DECODE */
// 465 %ROUTINE SHOW(%RECORD(STACKFM)%NAME V)
#line 465 "test-new/asems412.imp"
void SHOW(struct STACKFM * V) {
// 466 SELECTOUTPUT(REPORT) %IF CONTROL < 0
#line 466 "test-new/asems412.imp"
if (CONTROL >= 0) goto L_000D;
#line 466 "test-new/asems412.imp"
_imp_SELECTOUTPUT(0);
#line 466 "test-new/asems412.imp"
L_000D:;
// 467 WRITE(V_TYPE, 1); WRITE(V_FORM, 2)
#line 467 "test-new/asems412.imp"
_imp_WRITE(V->TYPE, 1);
#line 467 "test-new/asems412.imp"
_imp_WRITE(V->FORM, 2);
// 468 WRITE(V_BASE, 2); WRITE(V_DISP, 5)
#line 468 "test-new/asems412.imp"
_imp_WRITE(V->BASE, 2);
#line 468 "test-new/asems412.imp"
_imp_WRITE(V->DISP, 5);
// 469 WRITE(V_EXTRA, 5); WRITE(V_LENGTH, 5)
#line 469 "test-new/asems412.imp"
_imp_WRITE(V->EXTRA, 5);
#line 469 "test-new/asems412.imp"
_imp_WRITE(V->LENGTH, 5);
// 470 %IF V_LOP # 0 %START
#line 470 "test-new/asems412.imp"
if (V->LOP == 0) goto L_000E;
// 471 WRITE(V_LOP, 2); PRINTSYMBOL(':')
#line 471 "test-new/asems412.imp"
_imp_WRITE(V->LOP, 2);
#line 471 "test-new/asems412.imp"
_imp_PRINTSYMBOL(58);
// 472 SHOW(V_LINK)
#line 472 "test-new/asems412.imp"
SHOW(V->LINK);
// 473 %ELSE
#line 473 "test-new/asems412.imp"
goto L_000F;
#line 473 "test-new/asems412.imp"
L_000E:;
// 474 NEWLINE
#line 474 "test-new/asems412.imp"
_imp_NEWLINE();
// 475 %FINISH
#line 475 "test-new/asems412.imp"
L_000F:;
// 476 SELECTOUTPUT(OBJECT) %IF CONTROL < 0
#line 476 "test-new/asems412.imp"
if (CONTROL >= 0) goto L_0010;
#line 476 "test-new/asems412.imp"
_imp_SELECTOUTPUT(2);
#line 476 "test-new/asems412.imp"
L_0010:;
// 477 %END
#line 477 "test-new/asems412.imp"
return;
#line 477 "test-new/asems412.imp"
} /* end of SHOW */
// 478 %ROUTINE ABORT(%INTEGER CODE)
#line 478 "test-new/asems412.imp"
void ABORT(int CODE) {
// 479 %INTEGER I,J,L,FATAL
#line 479 "test-new/asems412.imp"
int I;
#line 479 "test-new/asems412.imp"
int J;
#line 479 "test-new/asems412.imp"
int L;
#line 479 "test-new/asems412.imp"
int FATAL;
// 480 %SWITCH SW(-15:0)
#line 480 "test-new/asems412.imp"
int SW_index;
#line 480 "test-new/asems412.imp"
int SW_line;
#line 480 "test-new/asems412.imp"
char *SW_file;
#line 480 "test-new/asems412.imp"
static const void *SW[16] = {&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing,
&&case_SW_missing, &&case_SW_missing, &&case_SW_missing, &&case_SW_missing};
// 481 %RECORD(DFM)%NAME DD
#line 481 "test-new/asems412.imp"
struct DFM *DD;
// 482 I = REPORT; FATAL = 1
#line 482 "test-new/asems412.imp"
I = 0;
#line 482 "test-new/asems412.imp"
FATAL = 1;
// 483 CONTROL = 0
#line 483 "test-new/asems412.imp"
CONTROL = 0;
// 484 %CYCLE
#line 484 "test-new/asems412.imp"
L_0011:;
// 485 SELECT OUTPUT(I)
#line 485 "test-new/asems412.imp"
_imp_SELECTOUTPUT(I);
// 486 %IF CODE > 0 %START; ! ... IT'S A COMPILER FAULT
#line 486 "test-new/asems412.imp"
if (CODE <= 0) goto L_0012;
// 487 PRINT STRING("*COMPILER ERROR"); WRITE(CODE,1)
#line 487 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("*COMPILER ERROR"));
#line 487 "test-new/asems412.imp"
_imp_WRITE(CODE, 1);
// 488 PRINT STRING(" AT LINE"); WRITE(CURRENT LINE,1)
#line 488 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal(" AT LINE"));
#line 488 "test-new/asems412.imp"
_imp_WRITE(CURRENTLINE, 1);
// 489 NEWLINE
#line 489 "test-new/asems412.imp"
_imp_NEWLINE();
// 490 %IF STP > 0 %START
#line 490 "test-new/asems412.imp"
if (STP <= 0) goto L_0013;
// 491 PRINT STRING("STACK"); NEWLINE
#line 491 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("STACK"));
#line 491 "test-new/asems412.imp"
_imp_NEWLINE();
// 492 SHOW(STACKED(J)_V) %FOR J = 1,1,STP
#line 492 "test-new/asems412.imp"
// %for J = 1, 1, STP %cycle
#line 492 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = STP;
#line 492 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 1, 1, STP");
_control = J = _initial - _increment;
#line 492 "test-new/asems412.imp"
L_0014:
#line 492 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 492 "test-new/asems412.imp"
if (J == _final) goto L_0015;
#line 492 "test-new/asems412.imp"
_control += _increment;
J += _increment;
#line 492 "test-new/asems412.imp"
SHOW(STACKED[J - 1].V);
#line 492 "test-new/asems412.imp"
goto L_0014;
#line 492 "test-new/asems412.imp"
}
#line 492 "test-new/asems412.imp"
L_0015:;
// 493 %FINISH
#line 493 "test-new/asems412.imp"
L_0013:;
// 494 %UNLESS USING_LINK == NULL %START
#line 494 "test-new/asems412.imp"
if (_imp_ADDR((void *)(USING.LINK)) == _imp_ADDR((void *)(NULL))) goto L_0017;
// 495 PRINTSTRING("USING:"); NEWLINE
#line 495 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("USING:"));
#line 495 "test-new/asems412.imp"
_imp_NEWLINE();
// 496 DD == USING_LINK
#line 496 "test-new/asems412.imp"
DD = (struct DFM *)USING.LINK;
// 497 %CYCLE
#line 497 "test-new/asems412.imp"
L_0018:;
// 498 SHOW(DD_D); DD == DD_LINK
#line 498 "test-new/asems412.imp"
SHOW(DD->D);
#line 498 "test-new/asems412.imp"
DD = (struct DFM *)DD->LINK;
// 499 %EXIT %IF DD == NULL
#line 499 "test-new/asems412.imp"
if (_imp_ADDR((void *)(DD)) != _imp_ADDR((void *)(NULL))) goto L_0019;
#line 499 "test-new/asems412.imp"
goto L_001A;
#line 499 "test-new/asems412.imp"
L_0019:;
// 500 %REPEAT
#line 500 "test-new/asems412.imp"
goto L_0018;
#line 500 "test-new/asems412.imp"
L_001A:;
// 501 %FINISH
#line 501 "test-new/asems412.imp"
L_0017:;
// 502 ->CONT %IF I = REPORT
#line 502 "test-new/asems412.imp"
if (I != 0) goto L_001B;
#line 502 "test-new/asems412.imp"
goto U_1000;
#line 502 "test-new/asems412.imp"
L_001B:;
// 503 %SIGNAL 15,1; ! ... SIGNAL COMPILER FAULT
#line 503 "test-new/asems412.imp"
_imp_signal(15, 1, 0, "");
// 504 %FINISH
#line 504 "test-new/asems412.imp"
L_0012:;
// 505 PRINT SYMBOL('*'); WRITE(CURRENT LINE,1); PRINT STRING(": ")
#line 505 "test-new/asems412.imp"
_imp_PRINTSYMBOL(42);
#line 505 "test-new/asems412.imp"
_imp_WRITE(CURRENTLINE, 1);
#line 505 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal(": "));
// 506 -> SW(CODE)
#line 506 "test-new/asems412.imp"
SW_line = __LINE__;
SW_file = __FILE__;
SW_index = CODE;
goto case_SW_dispatch;
// 507
// 508 SW(0):
#line 508 "test-new/asems412.imp"
case_SW_0:;
// 509 PRINT STRING("MORE STORE PLEASE!!"); -> CONT
#line 509 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("MORE STORE PLEASE!!"));
#line 509 "test-new/asems412.imp"
goto U_1000;
// 510 SW(-1):
#line 510 "test-new/asems412.imp"
case_SW_M1:;
// 511 SW(-2):
#line 511 "test-new/asems412.imp"
case_SW_M2:;
// 512 PRINT STRING("MORE STORE REQ'D FOR THIS COMPILATION"); -> CONT
#line 512 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("MORE STORE REQ'D FOR THIS COMPILATION"));
#line 512 "test-new/asems412.imp"
goto U_1000;
// 513 SW(-3):
#line 513 "test-new/asems412.imp"
case_SW_M3:;
// 514 PRINT STRING("BLOCKS TOO DEEPLY NESTED"); -> CONT
#line 514 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("BLOCKS TOO DEEPLY NESTED"));
#line 514 "test-new/asems412.imp"
goto U_1000;
// 515 SW(-4):
#line 515 "test-new/asems412.imp"
case_SW_M4:;
// 516 PRINT STRING("TOO MANY NAMES"); -> CONT
#line 516 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("TOO MANY NAMES"));
#line 516 "test-new/asems412.imp"
goto U_1000;
// 517 SW(-5):
#line 517 "test-new/asems412.imp"
case_SW_M5:;
// 518 PRINT STRING("TOO MANY LABELS"); -> CONT
#line 518 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("TOO MANY LABELS"));
#line 518 "test-new/asems412.imp"
goto U_1000;
// 519 SW(-6):
#line 519 "test-new/asems412.imp"
case_SW_M6:;
// 520 PRINT STRING("DIVISION BY ZERO"); -> NON FATAL
#line 520 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("DIVISION BY ZERO"));
#line 520 "test-new/asems412.imp"
goto U_1001;
// 521 SW(-7):
#line 521 "test-new/asems412.imp"
case_SW_M7:;
// 522 SW(-8):
#line 522 "test-new/asems412.imp"
case_SW_M8:;
// 523 PRINT STRING("ARRAY INSIDE OUT"); -> NON FATAL
#line 523 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("ARRAY INSIDE OUT"));
#line 523 "test-new/asems412.imp"
goto U_1001;
// 524 SW(-9):
#line 524 "test-new/asems412.imp"
case_SW_M9:;
// 525 PRINT STRING("DECLARATION OUT OF CONTEXT"); -> NON FATAL
#line 525 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("DECLARATION OUT OF CONTEXT"));
#line 525 "test-new/asems412.imp"
goto U_1001;
// 526 SW(-10):
#line 526 "test-new/asems412.imp"
case_SW_M10:;
// 527 PRINT STRING("FAULTY SWITCH DECLARATION"); -> NON FATAL
#line 527 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("FAULTY SWITCH DECLARATION"));
#line 527 "test-new/asems412.imp"
goto U_1001;
// 528 SW(-11):
#line 528 "test-new/asems412.imp"
case_SW_M11:;
// 529 PRINT STRING("%RESULT UNSPECIFIED"); -> NON FATAL
#line 529 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("%RESULT UNSPECIFIED"));
#line 529 "test-new/asems412.imp"
goto U_1001;
// 530 SW(-12):
#line 530 "test-new/asems412.imp"
case_SW_M12:;
// 531 PRINT STRING("ILLEGAL %FOR PARAMETERS"); ->WARNING
#line 531 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("ILLEGAL %FOR PARAMETERS"));
#line 531 "test-new/asems412.imp"
goto U_1002;
// 532 SW(-13):
#line 532 "test-new/asems412.imp"
case_SW_M13:;
// 533 PRINTSTRING("STRING CONSTANT TOO LONG"); ->WARNING
#line 533 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("STRING CONSTANT TOO LONG"));
#line 533 "test-new/asems412.imp"
goto U_1002;
// 534 SW(-14):
#line 534 "test-new/asems412.imp"
case_SW_M14:;
// 535 PRINTSTRING("UNASSIGNED CHECK INHIBITED")
#line 535 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("UNASSIGNED CHECK INHIBITED"));
// 536 CONTROL = CONTROL&(\UNASS DIAG); ->WARNING
#line 536 "test-new/asems412.imp"
CONTROL = CONTROL & (~32);
#line 536 "test-new/asems412.imp"
goto U_1002;
// 537 SW(-15):
#line 537 "test-new/asems412.imp"
case_SW_M15:;
// 538 PRINTSTRING("LOCALS > 16K ???")
#line 538 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal("LOCALS > 16K ???"));
// 539
// 540 WARNING:
#line 540 "test-new/asems412.imp"
U_1002:;
// 541 L = 0
#line 541 "test-new/asems412.imp"
L = 0;
// 542
// 543 NON FATAL:
#line 543 "test-new/asems412.imp"
U_1001:;
// 544 FATAL = 0
#line 544 "test-new/asems412.imp"
FATAL = 0;
// 545 CONT:
#line 545 "test-new/asems412.imp"
U_1000:;
// 546 NEWLINE
#line 546 "test-new/asems412.imp"
_imp_NEWLINE();
// 547 %IF I = LIST %START
#line 547 "test-new/asems412.imp"
if (I != 1) goto L_001D;
// 548 %SIGNAL 15,2 %IF FATAL # 0
#line 548 "test-new/asems412.imp"
if (FATAL == 0) goto L_001E;
#line 548 "test-new/asems412.imp"
_imp_signal(15, 2, 0, "");
#line 548 "test-new/asems412.imp"
L_001E:;
// 549 FAULTY = FAULTY+L; SELECT OUTPUT(OBJECT); %RETURN
#line 549 "test-new/asems412.imp"
FAULTY = FAULTY + L;
#line 549 "test-new/asems412.imp"
_imp_SELECTOUTPUT(2);
#line 549 "test-new/asems412.imp"
return;
// 550 %FINISH
#line 550 "test-new/asems412.imp"
L_001D:;
// 551 I = LIST
#line 551 "test-new/asems412.imp"
I = 1;
// 552
// 553 %REPEAT
#line 553 "test-new/asems412.imp"
goto L_0011;
// 554 %END
#line 554 "test-new/asems412.imp"
case_SW_dispatch:
#line 554 "test-new/asems412.imp"
if (SW_index < -15 || SW_index > 0)
_imp_signalf(6, 3, SW_index, "->SW(%d) out of bounds at %s line %d", SW_index, SW_file, SW_line);
#line 554 "test-new/asems412.imp"
goto *SW[SW_index - -15];
#line 554 "test-new/asems412.imp"
case_SW_missing:
_imp_signalf(8, 2, SW_index, "switch jump to undefined label SW(%d): at %s line %d", SW_index, SW_file, SW_line);
#line 554 "test-new/asems412.imp"
} /* end of ABORT */
// 555 %ROUTINE DISPLAY VAR(%RECORD(VARFM)%NAME V)
#line 555 "test-new/asems412.imp"
void DISPLAYVAR(struct VARFM * V) {
// 556 SELECTOUTPUT(LIST)
#line 556 "test-new/asems412.imp"
_imp_SELECTOUTPUT(1);
// 557 WRITE(V_ID, 3); PRINTSYMBOL(':')
#line 557 "test-new/asems412.imp"
_imp_WRITE(V->ID, 3);
#line 557 "test-new/asems412.imp"
_imp_PRINTSYMBOL(58);
// 558 WRITE(V_TYPE, 2); WRITE(V_FORM, 2)
#line 558 "test-new/asems412.imp"
_imp_WRITE(V->TYPE, 2);
#line 558 "test-new/asems412.imp"
_imp_WRITE(V->FORM, 2);
// 559 WRITE(V_BASE, 3); WRITE(V_DISP, 4)
#line 559 "test-new/asems412.imp"
_imp_WRITE(V->BASE, 3);
#line 559 "test-new/asems412.imp"
_imp_WRITE(V->DISP, 4);
// 560 WRITE(V_EXTRA, 4); WRITE(V_FORMAT, 4)
#line 560 "test-new/asems412.imp"
_imp_WRITE(V->EXTRA, 4);
#line 560 "test-new/asems412.imp"
_imp_WRITE(V->FORMAT, 4);
// 561 NEWLINE
#line 561 "test-new/asems412.imp"
_imp_NEWLINE();
// 562 SELECTOUTPUT(OBJECT)
#line 562 "test-new/asems412.imp"
_imp_SELECTOUTPUT(2);
// 563 %END
#line 563 "test-new/asems412.imp"
return;
#line 563 "test-new/asems412.imp"
} /* end of DISPLAYVAR */
// 564 %ROUTINE REAL ERROR(%INTEGER N)
#line 564 "test-new/asems412.imp"
void REALERROR(int N) {
// 565 %INTEGER I
#line 565 "test-new/asems412.imp"
int I;
// 566 %CONSTSHORTINTEGERARRAY SYM(1:14) = '\', '?', '?', '?', '@',
#line 566 "test-new/asems412.imp"
const short int SYM[14] = {92, 63, 63, 63, 64, 63, 63, 38, 33, -33, -60, -62, 63, 46};
// 567+ '?', '?', '&', '!',-'!',
// 568+ -'<', -'>', '?', '.'
// 569 I = REPORT
#line 569 "test-new/asems412.imp"
I = 0;
// 570 %CYCLE
#line 570 "test-new/asems412.imp"
L_001F:;
// 571 SELECT OUTPUT(I)
#line 571 "test-new/asems412.imp"
_imp_SELECTOUTPUT(I);
// 572 PRINTSYMBOL('*'); WRITE(CURRENT LINE, 4)
#line 572 "test-new/asems412.imp"
_imp_PRINTSYMBOL(42);
#line 572 "test-new/asems412.imp"
_imp_WRITE(CURRENTLINE, 4);
// 573 PRINTSTRING(" ILLEGAL REAL OPERATION '")
#line 573 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal(" ILLEGAL REAL OPERATION '"));
// 574 N = SYM(N)
#line 574 "test-new/asems412.imp"
N = SYM[N - 1];
// 575 PRINTSYMBOL(-N) %IF N < 0
#line 575 "test-new/asems412.imp"
if (N >= 0) goto L_0020;
#line 575 "test-new/asems412.imp"
_imp_PRINTSYMBOL(-N);
#line 575 "test-new/asems412.imp"
L_0020:;
// 576 PRINTSYMBOL(|N|); PRINTSYMBOL(''''); NEWLINE
#line 576 "test-new/asems412.imp"
_imp_PRINTSYMBOL(_imp_IMOD(N));
#line 576 "test-new/asems412.imp"
_imp_PRINTSYMBOL(39);
#line 576 "test-new/asems412.imp"
_imp_NEWLINE();
// 577 %EXIT %IF I = LIST
#line 577 "test-new/asems412.imp"
if (I != 1) goto L_0021;
#line 577 "test-new/asems412.imp"
goto L_0022;
#line 577 "test-new/asems412.imp"
L_0021:;
// 578 I = LIST
#line 578 "test-new/asems412.imp"
I = 1;
// 579 %REPEAT
#line 579 "test-new/asems412.imp"
goto L_001F;
#line 579 "test-new/asems412.imp"
L_0022:;
// 580 FAULTY = FAULTY+1
#line 580 "test-new/asems412.imp"
FAULTY = FAULTY + 1;
// 581 SELECTOUTPUT(OBJECT)
#line 581 "test-new/asems412.imp"
_imp_SELECTOUTPUT(2);
// 582 %END
#line 582 "test-new/asems412.imp"
return;
#line 582 "test-new/asems412.imp"
} /* end of REALERROR */
// 583 %PREDICATE FLOATING(%RECORD(STACKFM)%NAME V)
#line 583 "test-new/asems412.imp"
int FLOATING(struct STACKFM * V) {
// 584 %TRUE %IF V_TYPE = REALS %OR (V_LOP # 0 %C
#line 584 "test-new/asems412.imp"
if (V->TYPE == 6) goto L_0005;
#line 584 "test-new/asems412.imp"
if (V->LOP == 0) goto L_0023;
#line 584 "test-new/asems412.imp"
if (V->LOP == 16) goto L_0005;
#line 584 "test-new/asems412.imp"
if (_imp_ADDR((void *)(V->LINK)) == _imp_ADDR((void *)(NULL))) goto L_0023;
#line 584 "test-new/asems412.imp"
if (V->LINK->TYPE != 6) goto L_0023;
#line 584 "test-new/asems412.imp"
L_0005:;
#line 584 "test-new/asems412.imp"
return 1 /*TRUE*/;
#line 584 "test-new/asems412.imp"
L_0023:;
// 585+ %AND (V_LOP = RDIV %OR (v_link ## NULL %and V_LINK_TYPE = REALS)))
// 586 %FALSE
#line 586 "test-new/asems412.imp"
return 0 /*FALSE*/;
// 587 %END
#line 587 "test-new/asems412.imp"
} /* end of FLOATING */
// 588 %PREDICATE SAME(%RECORD(STACKFM)%NAME L, R)
#line 588 "test-new/asems412.imp"
int SAME(struct STACKFM * L, struct STACKFM * R) {
// 589 %FALSE %IF L_BASE # R_BASE %OR L_DISP # R_DISP
#line 589 "test-new/asems412.imp"
if (L->BASE != R->BASE) goto L_0024;
#line 589 "test-new/asems412.imp"
if (L->DISP == R->DISP) goto L_0025;
#line 589 "test-new/asems412.imp"
L_0024:;
#line 589 "test-new/asems412.imp"
return 0 /*FALSE*/;
#line 589 "test-new/asems412.imp"
L_0025:;
// 590 %FALSE %IF L_TYPE # R_TYPE %OR L_FORM # R_FORM
#line 590 "test-new/asems412.imp"
if (L->TYPE != R->TYPE) goto L_0026;
#line 590 "test-new/asems412.imp"
if (L->FORM == R->FORM) goto L_0027;
#line 590 "test-new/asems412.imp"
L_0026:;
#line 590 "test-new/asems412.imp"
return 0 /*FALSE*/;
#line 590 "test-new/asems412.imp"
L_0027:;
// 591 %FALSE %IF L_EXTRA # R_EXTRA
#line 591 "test-new/asems412.imp"
if (L->EXTRA == R->EXTRA) goto L_0028;
#line 591 "test-new/asems412.imp"
return 0 /*FALSE*/;
#line 591 "test-new/asems412.imp"
L_0028:;
// 592 %TRUE
#line 592 "test-new/asems412.imp"
return 1 /*TRUE*/;
// 593 %END
#line 593 "test-new/asems412.imp"
} /* end of SAME */
// 594 %PREDICATE ZERO(%RECORD(STACKFM)%NAME V)
#line 594 "test-new/asems412.imp"
int ZERO(struct STACKFM * V) {
// 595 %FALSE %IF V_DISP # 0 %OR V_BASE # 0 %OR V_FORM # CONSTANT
#line 595 "test-new/asems412.imp"
if (V->DISP != 0) goto L_0029;
#line 595 "test-new/asems412.imp"
if (V->BASE != 0) goto L_0029;
#line 595 "test-new/asems412.imp"
if (V->FORM == 0) goto L_002A;
#line 595 "test-new/asems412.imp"
L_0029:;
#line 595 "test-new/asems412.imp"
return 0 /*FALSE*/;
#line 595 "test-new/asems412.imp"
L_002A:;
// 596 %FALSE %IF V_LOP # 0
#line 596 "test-new/asems412.imp"
if (V->LOP == 0) goto L_002B;
#line 596 "test-new/asems412.imp"
return 0 /*FALSE*/;
#line 596 "test-new/asems412.imp"
L_002B:;
// 597 %TRUE
#line 597 "test-new/asems412.imp"
return 1 /*TRUE*/;
// 598 %END
#line 598 "test-new/asems412.imp"
} /* end of ZERO */
// 599 %PREDICATE CONST(%RECORD(STACKFM)%NAME V)
#line 599 "test-new/asems412.imp"
int CONST(struct STACKFM * V) {
// 600 %FALSE %UNLESS V_FORM = CONSTANT %AND V_LOP = 0
#line 600 "test-new/asems412.imp"
if (V->FORM != 0) goto L_002C;
#line 600 "test-new/asems412.imp"
if (V->LOP == 0) goto L_002D;
#line 600 "test-new/asems412.imp"
L_002C:;
#line 600 "test-new/asems412.imp"
return 0 /*FALSE*/;
#line 600 "test-new/asems412.imp"
L_002D:;
// 601 %FALSE %IF V_TYPE > SHORT
#line 601 "test-new/asems412.imp"
if (V->TYPE <= 3) goto L_002E;
#line 601 "test-new/asems412.imp"
return 0 /*FALSE*/;
#line 601 "test-new/asems412.imp"
L_002E:;
// 602 %TRUE
#line 602 "test-new/asems412.imp"
return 1 /*TRUE*/;
// 603 %END
#line 603 "test-new/asems412.imp"
} /* end of CONST */
// 604 %INTEGERFN POWER(%INTEGER N)
#line 604 "test-new/asems412.imp"
int POWER(int N) {
// 605 %INTEGER MASK, J
#line 605 "test-new/asems412.imp"
int MASK;
#line 605 "test-new/asems412.imp"
int J;
// 606 MASK = 1
#line 606 "test-new/asems412.imp"
MASK = 1;
// 607 %FOR J = 0, 1, 14 %CYCLE
#line 607 "test-new/asems412.imp"
// %for J = 0, 1, 14 %cycle
#line 607 "test-new/asems412.imp"
{
int _control, _initial = 0, _increment = 1, _final = 14;
#line 607 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 0, 1, 14");
_control = J = _initial - _increment;
#line 607 "test-new/asems412.imp"
L_002F:
#line 607 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 607 "test-new/asems412.imp"
if (J == _final) goto L_0030;
#line 607 "test-new/asems412.imp"
_control += _increment;
J += _increment;
// 608 %RESULT = J %IF N = MASK
#line 608 "test-new/asems412.imp"
if (N != MASK) goto L_0032;
#line 608 "test-new/asems412.imp"
return J;
#line 608 "test-new/asems412.imp"
L_0032:;
// 609 MASK = MASK<<1
#line 609 "test-new/asems412.imp"
MASK = MASK << 1;
// 610 %REPEAT
#line 610 "test-new/asems412.imp"
goto L_002F;
#line 610 "test-new/asems412.imp"
}
#line 610 "test-new/asems412.imp"
L_0030:;
// 611 %RESULT = -1
#line 611 "test-new/asems412.imp"
return -1;
// 612 %END
#line 612 "test-new/asems412.imp"
} /* end of POWER */
// 613 %INTEGERFN TEMP
#line 613 "test-new/asems412.imp"
int TEMP(void) {
// 614 %INTEGER T
#line 614 "test-new/asems412.imp"
int T;
// 615 T = (FRAME+(REGLEN-1))&(\(REGLEN-1))
#line 615 "test-new/asems412.imp"
T = FRAME + (4 - 1) & ~(4 - 1);
// 616 FRAME = T+REGLEN
#line 616 "test-new/asems412.imp"
FRAME = T + 4;
// 617 %RESULT = T
#line 617 "test-new/asems412.imp"
return T;
// 618 %END
#line 618 "test-new/asems412.imp"
} /* end of TEMP */
// 619 %INTEGERFN TAG
#line 619 "test-new/asems412.imp"
int TAG(void) {
// 620 %INTEGER N, S
#line 620 "test-new/asems412.imp"
int N;
#line 620 "test-new/asems412.imp"
int S;
// 621 N = 0
#line 621 "test-new/asems412.imp"
N = 0;
// 622 %CYCLE
#line 622 "test-new/asems412.imp"
L_0033:;
// 623 S = NEXTSYMBOL
#line 623 "test-new/asems412.imp"
S = _imp_NEXTSYMBOL();
// 624 %RESULT = N %UNLESS '0' <= S <= '9'
#line 624 "test-new/asems412.imp"
{
// Double-sided test on S (Part I)
#line 624 "test-new/asems412.imp"
int tmp;
#line 624 "test-new/asems412.imp"
if (48 > (tmp = S)) goto L_0034;
// Double-sided test on S (Part II)
#line 624 "test-new/asems412.imp"
if (tmp <= 57) goto L_0035;
#line 624 "test-new/asems412.imp"
}
#line 624 "test-new/asems412.imp"
L_0034:;
#line 624 "test-new/asems412.imp"
return N;
#line 624 "test-new/asems412.imp"
L_0035:;
// 625 N = N*10+S-'0'
#line 625 "test-new/asems412.imp"
N = N * 10 + S - 48;
// 626 SKIPSYMBOL
#line 626 "test-new/asems412.imp"
_imp_SKIPSYMBOL();
// 627 %REPEAT
#line 627 "test-new/asems412.imp"
goto L_0033;
// 628 %END
#line 628 "test-new/asems412.imp"
} /* end of TAG */
// 629 %INTEGERFN EVAL(%INTEGER L)
#line 629 "test-new/asems412.imp"
int EVAL(int L) {
// 630 %INTEGER J, N, B, S, MOD
#line 630 "test-new/asems412.imp"
int J;
#line 630 "test-new/asems412.imp"
int N;
#line 630 "test-new/asems412.imp"
int B;
#line 630 "test-new/asems412.imp"
int S;
#line 630 "test-new/asems412.imp"
int MOD;
// 631 %CONSTBYTEINTEGERARRAY BASIS('V' : 'Z') = 3, 1, 8, 4, 0
#line 631 "test-new/asems412.imp"
const unsigned char BASIS[5] = {3, 1, 8, 4, 0};
// 632 %RESULT = 0 %IF L < 2
#line 632 "test-new/asems412.imp"
if (L >= 2) goto L_0036;
#line 632 "test-new/asems412.imp"
return 0;
#line 632 "test-new/asems412.imp"
L_0036:;
// 633 READSYMBOL(B); B = BASIS(B)
#line 633 "test-new/asems412.imp"
_imp_READSYMBOL(/*?*/ &B);
#line 633 "test-new/asems412.imp"
B = BASIS[B - 86];
// 634 N = 0
#line 634 "test-new/asems412.imp"
N = 0;
// 635 %IF B = 0 %START
#line 635 "test-new/asems412.imp"
if (B != 0) goto L_0037;
// 636 %FOR J = 2,1,L %CYCLE
#line 636 "test-new/asems412.imp"
// %for J = 2, 1, L %cycle
#line 636 "test-new/asems412.imp"
{
int _control, _initial = 2, _increment = 1, _final = L;
#line 636 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 2, 1, L");
_control = J = _initial - _increment;
#line 636 "test-new/asems412.imp"
L_0038:
#line 636 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 636 "test-new/asems412.imp"
if (J == _final) goto L_0039;
#line 636 "test-new/asems412.imp"
_control += _increment;
J += _increment;
// 637 READ SYMBOL(S)
#line 637 "test-new/asems412.imp"
_imp_READSYMBOL(/*?*/ &S);
// 638 N = (N*4+N)*2 + S-'A'
#line 638 "test-new/asems412.imp"
N = (N * 4 + N) * 2 + S - 65;
// 639 %REPEAT
#line 639 "test-new/asems412.imp"
goto L_0038;
#line 639 "test-new/asems412.imp"
}
#line 639 "test-new/asems412.imp"
L_0039:;
// 640 %ELSE
#line 640 "test-new/asems412.imp"
goto L_003B;
#line 640 "test-new/asems412.imp"
L_0037:;
// 641 MOD = 'A'; MOD = 0 %IF B = 8
#line 641 "test-new/asems412.imp"
MOD = 65;
#line 641 "test-new/asems412.imp"
if (B != 8) goto L_003C;
#line 641 "test-new/asems412.imp"
MOD = 0;
#line 641 "test-new/asems412.imp"
L_003C:;
// 642 %FOR J = 2,1,L %CYCLE
#line 642 "test-new/asems412.imp"
// %for J = 2, 1, L %cycle
#line 642 "test-new/asems412.imp"
{
int _control, _initial = 2, _increment = 1, _final = L;
#line 642 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 2, 1, L");
_control = J = _initial - _increment;
#line 642 "test-new/asems412.imp"
L_003D:
#line 642 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 642 "test-new/asems412.imp"
if (J == _final) goto L_003E;
#line 642 "test-new/asems412.imp"
_control += _increment;
J += _increment;
// 643 READ SYMBOL(S)
#line 643 "test-new/asems412.imp"
_imp_READSYMBOL(/*?*/ &S);
// 644 N = N<<B + (S-MOD)
#line 644 "test-new/asems412.imp"
N = (N << B) + (S - MOD);
// 645 %REPEAT
#line 645 "test-new/asems412.imp"
goto L_003D;
#line 645 "test-new/asems412.imp"
}
#line 645 "test-new/asems412.imp"
L_003E:;
// 646 %FINISH
#line 646 "test-new/asems412.imp"
L_003B:;
// 647 %RESULT = N
#line 647 "test-new/asems412.imp"
return N;
// 648 %END
#line 648 "test-new/asems412.imp"
} /* end of EVAL */
// 649 %REALFN REAL CONSTANT
#line 649 "test-new/asems412.imp"
float REALCONSTANT(void) {
// 650 %INTEGER I,L,S,J,M
#line 650 "test-new/asems412.imp"
int I;
#line 650 "test-new/asems412.imp"
int L;
#line 650 "test-new/asems412.imp"
int S;
#line 650 "test-new/asems412.imp"
int J;
#line 650 "test-new/asems412.imp"
int M;
// 651 %REAL N,FACTOR,TEN,ONE
#line 651 "test-new/asems412.imp"
float N;
#line 651 "test-new/asems412.imp"
float FACTOR;
#line 651 "test-new/asems412.imp"
float TEN;
#line 651 "test-new/asems412.imp"
float ONE;
// 652 I = 10; TEN = I; ! ...TO PREVENT COMPILE-TIME FLOATING
#line 652 "test-new/asems412.imp"
I = 10;
#line 652 "test-new/asems412.imp"
TEN = I;
// 653 I = 1; ONE = I; ! ... AND AGAIN
#line 653 "test-new/asems412.imp"
I = 1;
#line 653 "test-new/asems412.imp"
ONE = I;
// 654 M = 0; N = 0; L = TAG; SKIP SYMBOL
#line 654 "test-new/asems412.imp"
M = 0;
#line 654 "test-new/asems412.imp"
N = 0;
#line 654 "test-new/asems412.imp"
L = TAG();
#line 654 "test-new/asems412.imp"
_imp_SKIPSYMBOL();
// 655 %CYCLE J = 1,1,L
#line 655 "test-new/asems412.imp"
// %for J = 1, 1, L %cycle
#line 655 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = L;
#line 655 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 1, 1, L");
_control = J = _initial - _increment;
#line 655 "test-new/asems412.imp"
L_003F:
#line 655 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 655 "test-new/asems412.imp"
if (J == _final) goto L_0040;
#line 655 "test-new/asems412.imp"
_control += _increment;
J += _increment;
// 656 READ SYMBOL(S)
#line 656 "test-new/asems412.imp"
_imp_READSYMBOL(/*?*/ &S);
// 657 %IF S = '.' %START
#line 657 "test-new/asems412.imp"
if (S != 46) goto L_0041;
// 658 FACTOR = 1; M = 1
#line 658 "test-new/asems412.imp"
FACTOR = 1;
#line 658 "test-new/asems412.imp"
M = 1;
// 659 %ELSE
#line 659 "test-new/asems412.imp"
goto L_0042;
#line 659 "test-new/asems412.imp"
L_0041:;
// 660 I = S-'A'
#line 660 "test-new/asems412.imp"
I = S - 65;
// 661 %IF M = 0 %START
#line 661 "test-new/asems412.imp"
if (M != 0) goto L_0043;
// 662 N = N*TEN + I
#line 662 "test-new/asems412.imp"
N = N * TEN + I;
// 663 %ELSE
#line 663 "test-new/asems412.imp"
goto L_0044;
#line 663 "test-new/asems412.imp"
L_0043:;
// 664 FACTOR = FACTOR/TEN
#line 664 "test-new/asems412.imp"
FACTOR = (double)(FACTOR / TEN);
// 665 N = N + I*FACTOR
#line 665 "test-new/asems412.imp"
N = N + I * FACTOR;
// 666 %FINISH
#line 666 "test-new/asems412.imp"
L_0044:;
// 667 %FINISH
#line 667 "test-new/asems412.imp"
L_0042:;
// 668 %REPEAT
#line 668 "test-new/asems412.imp"
goto L_003F;
#line 668 "test-new/asems412.imp"
}
#line 668 "test-new/asems412.imp"
L_0040:;
// 669 %RESULT = N
#line 669 "test-new/asems412.imp"
return N;
// 670 %END
#line 670 "test-new/asems412.imp"
} /* end of REALCONSTANT */
// 671 %ROUTINE RELEASE(%INTEGER REG)
#line 671 "test-new/asems412.imp"
void RELEASE(int REG) {
// 672 %RETURN %IF REG = 0 %OR ACTIVITY(REG) < 0;! LOCKED
#line 672 "test-new/asems412.imp"
if (REG == 0) goto L_0031;
#line 672 "test-new/asems412.imp"
if (ACTIVITY[REG] >= 0) goto L_0045;
#line 672 "test-new/asems412.imp"
L_0031:;
#line 672 "test-new/asems412.imp"
return;
#line 672 "test-new/asems412.imp"
L_0045:;
// 673 ACTIVITY(REG) = ACTIVITY(REG)-1
#line 673 "test-new/asems412.imp"
ACTIVITY[REG] = ACTIVITY[REG] - 1;
// 674 ABORT(1) %IF ACTIVITY(REG) < 0
#line 674 "test-new/asems412.imp"
if (ACTIVITY[REG] >= 0) goto L_0046;
#line 674 "test-new/asems412.imp"
ABORT(1);
#line 674 "test-new/asems412.imp"
L_0046:;
// 675 %END
#line 675 "test-new/asems412.imp"
return;
#line 675 "test-new/asems412.imp"
} /* end of RELEASE */
// 676 %ROUTINE CLAIM(%INTEGER REG)
#line 676 "test-new/asems412.imp"
void CLAIM(int REG) {
// 677 %RETURN %IF REG = 0 %OR ACTIVITY(REG) < 0
#line 677 "test-new/asems412.imp"
if (REG == 0) goto L_0047;
#line 677 "test-new/asems412.imp"
if (ACTIVITY[REG] >= 0) goto L_0048;
#line 677 "test-new/asems412.imp"
L_0047:;
#line 677 "test-new/asems412.imp"
return;
#line 677 "test-new/asems412.imp"
L_0048:;
// 678 USED(REG) = CA
#line 678 "test-new/asems412.imp"
USED[REG] = CA;
// 679 ACTIVITY(REG) = ACTIVITY(REG)+1
#line 679 "test-new/asems412.imp"
ACTIVITY[REG] = ACTIVITY[REG] + 1;
// 680 %END
#line 680 "test-new/asems412.imp"
return;
#line 680 "test-new/asems412.imp"
} /* end of CLAIM */
// 681 %ROUTINE FORGET(%INTEGER REG)
#line 681 "test-new/asems412.imp"
void FORGET(int REG) {
// 682 USE(REG)_CA = LIMEN; USE(REG+STORE)_CA = LIMEN
#line 682 "test-new/asems412.imp"
USE[REG - 1].CA = LIMEN;
#line 682 "test-new/asems412.imp"
USE[REG + 20 - 1].CA = LIMEN;
// 683 %END
#line 683 "test-new/asems412.imp"
return;
#line 683 "test-new/asems412.imp"
} /* end of FORGET */
// 684 %ROUTINE FORGET DEST(%RECORD(STACKFM)%NAME V)
#line 684 "test-new/asems412.imp"
void FORGETDEST(struct STACKFM * V) {
// 685 %CONSTBYTEINTEGERARRAY BITS(0:7) = 15,15,8,12,12,12,15,15
#line 685 "test-new/asems412.imp"
const unsigned char BITS[8] = {15, 15, 8, 12, 12, 12, 15, 15};
// 686 %INTEGER R, MASK, ADDR, TYPE
#line 686 "test-new/asems412.imp"
int R;
#line 686 "test-new/asems412.imp"
int MASK;
#line 686 "test-new/asems412.imp"
int ADDR;
#line 686 "test-new/asems412.imp"
int TYPE;
// 687 %RECORD(USEFM)%NAME U
#line 687 "test-new/asems412.imp"
struct USEFM *U;
// 688
// 689 ADDR = V_DISP!3; MASK = BITS(V_TYPE)>>(V_DISP&3)
#line 689 "test-new/asems412.imp"
ADDR = V->DISP | 3;
#line 689 "test-new/asems412.imp"
MASK = (unsigned int)BITS[V->TYPE] >> (V->DISP & 3);
// 690
// 691 %FOR R = 1, 1, 40 %CYCLE
#line 691 "test-new/asems412.imp"
// %for R = 1, 1, 40 %cycle
#line 691 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = 40;
#line 691 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle R = 1, 1, 40");
_control = R = _initial - _increment;
#line 691 "test-new/asems412.imp"
L_0049:
#line 691 "test-new/asems412.imp"
if (R != _control) _imp_signal(4, 2, 0, "Corrupt control variable R");
#line 691 "test-new/asems412.imp"
if (R == _final) goto L_004A;
#line 691 "test-new/asems412.imp"
_control += _increment;
R += _increment;
// 692 U == USE(R)
#line 692 "test-new/asems412.imp"
U = (struct USEFM *)/*?*/ &USE[R - 1];
// 693 %IF U_CA > LIMEN %START
#line 693 "test-new/asems412.imp"
if (U->CA <= LIMEN) goto L_004C;
// 694 %IF U_BASE&255 = V_BASE %AND U_FORM # A V IN S %START
#line 694 "test-new/asems412.imp"
if (U->BASE & 255 != V->BASE) goto L_004D;
#line 694 "test-new/asems412.imp"
if (U->FORM == 6) goto L_004D;
// 695 %IF U_DISP!3 = ADDR %START
#line 695 "test-new/asems412.imp"
if (U->DISP | 3 != ADDR) goto L_004E;
// 696 TYPE = U_TYPE
#line 696 "test-new/asems412.imp"
TYPE = U->TYPE;
// 697 TYPE = 7 %IF U_FORM&128 # 0
#line 697 "test-new/asems412.imp"
if (U->FORM & 128 == 0) goto L_004F;
#line 697 "test-new/asems412.imp"
TYPE = 7;
#line 697 "test-new/asems412.imp"
L_004F:;
// 698 type = 0 %if type = 255 {unsigned halfword}
#line 698 "test-new/asems412.imp"
if (TYPE != 255) goto L_0050;
#line 698 "test-new/asems412.imp"
TYPE = 0;
#line 698 "test-new/asems412.imp"
L_0050:;
// 699 %IF BITS(TYPE)>>(U_DISP&3) & MASK # 0 %START
#line 699 "test-new/asems412.imp"
if ((unsigned int)BITS[TYPE] >> (U->DISP & 3) & MASK == 0) goto L_0051;
// 700 U_CA = LIMEN; ! FORGET IT
#line 700 "test-new/asems412.imp"
U->CA = LIMEN;
// 701 %FINISH
#line 701 "test-new/asems412.imp"
L_0051:;
// 702 %FINISH
#line 702 "test-new/asems412.imp"
L_004E:;
// 703 %FINISH
#line 703 "test-new/asems412.imp"
L_004D:;
// 704 %FINISH
#line 704 "test-new/asems412.imp"
L_004C:;
// 705 %REPEAT
#line 705 "test-new/asems412.imp"
goto L_0049;
#line 705 "test-new/asems412.imp"
}
#line 705 "test-new/asems412.imp"
L_004A:;
// 706 %END
#line 706 "test-new/asems412.imp"
return;
#line 706 "test-new/asems412.imp"
} /* end of FORGETDEST */
// 707 %ROUTINE HAZARD(%INTEGER REG)
#line 707 "test-new/asems412.imp"
void HAZARD(int REG) {
// 708 %RECORD(DFM)%NAME P
#line 708 "test-new/asems412.imp"
struct DFM *P;
// 709 %INTEGER N, T, OP
#line 709 "test-new/asems412.imp"
int N;
#line 709 "test-new/asems412.imp"
int T;
#line 709 "test-new/asems412.imp"
int OP;
// 710 %ROUTINE MOD(%RECORD(STACKFM)%NAME V)
#line 710 "test-new/asems412.imp"
void MOD(struct STACKFM * V) {
// 711 %SWITCH S(0:7)
#line 711 "test-new/asems412.imp"
int S_index;
#line 711 "test-new/asems412.imp"
int S_line;
#line 711 "test-new/asems412.imp"
char *S_file;
#line 711 "test-new/asems412.imp"
static const void *S[8] = {&&case_S_missing, &&case_S_missing, &&case_S_missing, &&case_S_missing,
&&case_S_missing, &&case_S_missing, &&case_S_missing, &&case_S_missing};
// 712 N = N-1
#line 712 "test-new/asems412.imp"
N = N - 1;
// 713 ->S(V_FORM)
#line 713 "test-new/asems412.imp"
S_line = __LINE__;
S_file = __FILE__;
S_index = V->FORM;
goto case_S_dispatch;
// 714 S(CONSTANT):
#line 714 "test-new/asems412.imp"
case_S_0:;
// 715 S(A IN REC):
#line 715 "test-new/asems412.imp"
case_S_4:;
// 716 S(V IN REC):
#line 716 "test-new/asems412.imp"
case_S_5:;
// 717 S(AV IN REC): ABORT(3)
#line 717 "test-new/asems412.imp"
case_S_7:;
#line 717 "test-new/asems412.imp"
ABORT(3);
// 718 S(A IN S): V_FORM = A IN REC; V_EXTRA = T; ->DONE
#line 718 "test-new/asems412.imp"
case_S_2:;
#line 718 "test-new/asems412.imp"
V->FORM = 4;
#line 718 "test-new/asems412.imp"
V->EXTRA = T;
#line 718 "test-new/asems412.imp"
goto U_1003;
// 719 S(AV IN S): V_FORM = AV IN REC; V_EXTRA = T; ->DONE
#line 719 "test-new/asems412.imp"
case_S_6:;
#line 719 "test-new/asems412.imp"
V->FORM = 7;
#line 719 "test-new/asems412.imp"
V->EXTRA = T;
#line 719 "test-new/asems412.imp"
goto U_1003;
// 720 S(V IN S): V_FORM = V IN REC; V_EXTRA = T; ->DONE
#line 720 "test-new/asems412.imp"
case_S_3:;
#line 720 "test-new/asems412.imp"
V->FORM = 5;
#line 720 "test-new/asems412.imp"
V->EXTRA = T;
#line 720 "test-new/asems412.imp"
goto U_1003;
// 721 S(V IN R): V_FORM = V IN S; V_DISP = T
#line 721 "test-new/asems412.imp"
case_S_1:;
#line 721 "test-new/asems412.imp"
V->FORM = 3;
#line 721 "test-new/asems412.imp"
V->DISP = T;
// 722 DONE: V_BASE = LOCAL
#line 722 "test-new/asems412.imp"
U_1003:;
#line 722 "test-new/asems412.imp"
V->BASE = LOCAL;
// 723 %END
#line 723 "test-new/asems412.imp"
return;
#line 723 "test-new/asems412.imp"
case_S_dispatch:
#line 723 "test-new/asems412.imp"
if (S_index < 0 || S_index > 7)
_imp_signalf(6, 3, S_index, "->S(%d) out of bounds at %s line %d", S_index, S_file, S_line);
#line 723 "test-new/asems412.imp"
goto *S[S_index - 0];
#line 723 "test-new/asems412.imp"
case_S_missing:
_imp_signalf(8, 2, S_index, "switch jump to undefined label S(%d): at %s line %d", S_index, S_file, S_line);
#line 723 "test-new/asems412.imp"
} /* end of MOD */
// 724 N = ACTIVITY(REG)
#line 724 "test-new/asems412.imp"
N = ACTIVITY[REG];
// 725 %RETURN %IF N <= 0
#line 725 "test-new/asems412.imp"
if (N > 0) goto L_0053;
#line 725 "test-new/asems412.imp"
return;
#line 725 "test-new/asems412.imp"
L_0053:;
// 726 ACTIVITY(REG) = 0
#line 726 "test-new/asems412.imp"
ACTIVITY[REG] = 0;
// 727 T = TEMP
#line 727 "test-new/asems412.imp"
T = TEMP();
// 728 %IF FPR0 <= REG <= FPR14 %THEN OP = STE %ELSE OP = ST
#line 728 "test-new/asems412.imp"
{
// Double-sided test on REG (Part I)
#line 728 "test-new/asems412.imp"
int tmp;
#line 728 "test-new/asems412.imp"
if (13 > (tmp = REG)) goto L_0054;
// Double-sided test on REG (Part II)
#line 728 "test-new/asems412.imp"
if (tmp > 20) goto L_0054;
#line 728 "test-new/asems412.imp"
}
#line 728 "test-new/asems412.imp"
OP = 24576;
#line 728 "test-new/asems412.imp"
goto L_0055;
#line 728 "test-new/asems412.imp"
L_0054:;
#line 728 "test-new/asems412.imp"
OP = 20480;
#line 728 "test-new/asems412.imp"
L_0055:;
// 729 RX(OP, REG, LOCAL, T)
#line 729 "test-new/asems412.imp"
RX(OP, REG, LOCAL, T);
// 730 P == USING_LINK
#line 730 "test-new/asems412.imp"
P = (struct DFM *)USING.LINK;
// 731 %CYCLE
#line 731 "test-new/asems412.imp"
L_0056:;
// 732 %EXIT %IF P == NULL
#line 732 "test-new/asems412.imp"
if (_imp_ADDR((void *)(P)) != _imp_ADDR((void *)(NULL))) goto L_0057;
#line 732 "test-new/asems412.imp"
goto L_0058;
#line 732 "test-new/asems412.imp"
L_0057:;
// 733 MOD(P_D) %IF P_D_BASE = REG
#line 733 "test-new/asems412.imp"
if (P->D->BASE != REG) goto L_0059;
#line 733 "test-new/asems412.imp"
MOD(P->D);
#line 733 "test-new/asems412.imp"
L_0059:;
// 734 P == P_LINK
#line 734 "test-new/asems412.imp"
P = (struct DFM *)P->LINK;
// 735 %REPEAT
#line 735 "test-new/asems412.imp"
goto L_0056;
#line 735 "test-new/asems412.imp"
L_0058:;
// 736 ABORT(4) %IF N # 0
#line 736 "test-new/asems412.imp"
if (N == 0) goto L_005A;
#line 736 "test-new/asems412.imp"
ABORT(4);
#line 736 "test-new/asems412.imp"
L_005A:;
// 737 %END
#line 737 "test-new/asems412.imp"
return;
#line 737 "test-new/asems412.imp"
} /* end of HAZARD */
// 738 %ROUTINE HAZARD ALL
#line 738 "test-new/asems412.imp"
void HAZARDALL(void) {
// 739 %INTEGER J
#line 739 "test-new/asems412.imp"
int J;
// 740 HAZARD(J) %FOR J = 1, 1, 20
#line 740 "test-new/asems412.imp"
// %for J = 1, 1, 20 %cycle
#line 740 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = 20;
#line 740 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 1, 1, 20");
_control = J = _initial - _increment;
#line 740 "test-new/asems412.imp"
L_005B:
#line 740 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 740 "test-new/asems412.imp"
if (J == _final) goto L_005C;
#line 740 "test-new/asems412.imp"
_control += _increment;
J += _increment;
#line 740 "test-new/asems412.imp"
HAZARD(J);
#line 740 "test-new/asems412.imp"
goto L_005B;
#line 740 "test-new/asems412.imp"
}
#line 740 "test-new/asems412.imp"
L_005C:;
// 741 %END
#line 741 "test-new/asems412.imp"
return;
#line 741 "test-new/asems412.imp"
} /* end of HAZARDALL */
// 742 %ROUTINE REMEMBER(%INTEGER REG, %RECORD(STACKFM)%NAME V)
#line 742 "test-new/asems412.imp"
void REMEMBER(int REG, struct STACKFM *V) {
// 743 %RECORD(USEFM)%NAME U
#line 743 "test-new/asems412.imp"
struct USEFM *U;
// 744 REMEMBER(REG+STORE,V) %IF REG <= STORE
#line 744 "test-new/asems412.imp"
if (REG > 20) goto L_005D;
#line 744 "test-new/asems412.imp"
REMEMBER(REG + 20, V);
#line 744 "test-new/asems412.imp"
L_005D:;
// 745 U == USE(REG)
#line 745 "test-new/asems412.imp"
U = (struct USEFM *)/*?*/ &USE[REG - 1];
// 746 U_BASE = V_BASE
#line 746 "test-new/asems412.imp"
U->BASE = V->BASE;
// 747 U_DISP = V_DISP
#line 747 "test-new/asems412.imp"
U->DISP = V->DISP;
// 748 U_TYPE = V_TYPE
#line 748 "test-new/asems412.imp"
U->TYPE = V->TYPE;
// 749 U_FORM = V_FORM
#line 749 "test-new/asems412.imp"
U->FORM = V->FORM;
// 750 U_CA = CA
#line 750 "test-new/asems412.imp"
U->CA = CA;
// 751 %IF CONTROL < 0 %START
#line 751 "test-new/asems412.imp"
if (CONTROL >= 0) goto L_005E;
// 752 SELECTOUTPUT(LIST)
#line 752 "test-new/asems412.imp"
_imp_SELECTOUTPUT(1);
// 753 PRINTSTRING(" REMEMBER:")
#line 753 "test-new/asems412.imp"
_imp_PRINTSTRING(_imp_str_literal(" REMEMBER:"));
// 754 WRITE(U_TYPE, 1); WRITE(U_FORM, 1); WRITE(U_BASE, 3)
#line 754 "test-new/asems412.imp"
_imp_WRITE(U->TYPE, 1);
#line 754 "test-new/asems412.imp"
_imp_WRITE(U->FORM, 1);
#line 754 "test-new/asems412.imp"
_imp_WRITE(U->BASE, 3);
// 755 WRITE(U_DISP,5)
#line 755 "test-new/asems412.imp"
_imp_WRITE(U->DISP, 5);
// 756 NEWLINE
#line 756 "test-new/asems412.imp"
_imp_NEWLINE();
// 757 SELECTOUTPUT(OBJECT)
#line 757 "test-new/asems412.imp"
_imp_SELECTOUTPUT(2);
// 758 %FINISH
#line 758 "test-new/asems412.imp"
L_005E:;
// 759 %END
#line 759 "test-new/asems412.imp"
return;
#line 759 "test-new/asems412.imp"
} /* end of REMEMBER */
// 760 %INTEGERFN FIND USE(%INTEGER TYPE, FORM, BASE, DISP)
#line 760 "test-new/asems412.imp"
int FINDUSE(int TYPE, int FORM, int BASE, int DISP) {
// 761 %RECORD(USEFM)%NAME U
#line 761 "test-new/asems412.imp"
struct USEFM *U;
// 762 %INTEGER J, B, BB, BCA, BBCA
#line 762 "test-new/asems412.imp"
int J;
#line 762 "test-new/asems412.imp"
int B;
#line 762 "test-new/asems412.imp"
int BB;
#line 762 "test-new/asems412.imp"
int BCA;
#line 762 "test-new/asems412.imp"
int BBCA;
// 763 B = BASE&255; BB = BASE>>8
#line 763 "test-new/asems412.imp"
B = BASE & 255;
#line 763 "test-new/asems412.imp"
BB = (unsigned int)BASE >> 8;
// 764 %IF ACTIVITY(B) < 0 %THEN BCA = LIMEN+1 %ELSE BCA = USE(B)_CA
#line 764 "test-new/asems412.imp"
if (ACTIVITY[B] >= 0) goto L_005F;
#line 764 "test-new/asems412.imp"
BCA = LIMEN + 1;
#line 764 "test-new/asems412.imp"
goto L_0060;
#line 764 "test-new/asems412.imp"
L_005F:;
#line 764 "test-new/asems412.imp"
BCA = USE[B - 1].CA;
#line 764 "test-new/asems412.imp"
L_0060:;
// 765 %IF ACTIVITY(BB)< 0 %THEN BBCA= LIMEN+1 %ELSE BBCA= USE(BB)_CA
#line 765 "test-new/asems412.imp"
if (ACTIVITY[BB] >= 0) goto L_0061;
#line 765 "test-new/asems412.imp"
BBCA = LIMEN + 1;
#line 765 "test-new/asems412.imp"
goto L_0062;
#line 765 "test-new/asems412.imp"
L_0061:;
#line 765 "test-new/asems412.imp"
BBCA = USE[BB - 1].CA;
#line 765 "test-new/asems412.imp"
L_0062:;
// 766 %RESULT = 0 %IF BCA <= LIMEN %OR BBCA <= LIMEN
#line 766 "test-new/asems412.imp"
if (BCA <= LIMEN) goto L_004B;
#line 766 "test-new/asems412.imp"
if (BBCA > LIMEN) goto L_0063;
#line 766 "test-new/asems412.imp"
L_004B:;
#line 766 "test-new/asems412.imp"
return 0;
#line 766 "test-new/asems412.imp"
L_0063:;
// 767 %FOR J = 1, 1, 40 %CYCLE
#line 767 "test-new/asems412.imp"
// %for J = 1, 1, 40 %cycle
#line 767 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = 40;
#line 767 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 1, 1, 40");
_control = J = _initial - _increment;
#line 767 "test-new/asems412.imp"
L_0064:
#line 767 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 767 "test-new/asems412.imp"
if (J == _final) goto L_0065;
#line 767 "test-new/asems412.imp"
_control += _increment;
J += _increment;
// 768 U == USE(J)
#line 768 "test-new/asems412.imp"
U = (struct USEFM *)/*?*/ &USE[J - 1];
// 769 %IF BCA < U_CA %AND BBCA < U_CA %START
#line 769 "test-new/asems412.imp"
if (BCA >= U->CA) goto L_0067;
#line 769 "test-new/asems412.imp"
if (BBCA >= U->CA) goto L_0067;
// 770 %IF U_BASE = BASE %AND U_DISP = DISP %START
#line 770 "test-new/asems412.imp"
if (U->BASE != BASE) goto L_0068;
#line 770 "test-new/asems412.imp"
if (U->DISP != DISP) goto L_0068;
// 771 %IF U_TYPE = TYPE %AND U_FORM = FORM %START
#line 771 "test-new/asems412.imp"
if (U->TYPE != TYPE) goto L_0069;
#line 771 "test-new/asems412.imp"
if (U->FORM != FORM) goto L_0069;
// 772 %IF J > STORE %START
#line 772 "test-new/asems412.imp"
if (J <= 20) goto L_006A;
// 773 J = J-STORE
#line 773 "test-new/asems412.imp"
J = J - 20;
// 774 USE(J) = U %IF USE(J)_CA <= LIMEN
#line 774 "test-new/asems412.imp"
if (USE[J - 1].CA > LIMEN) goto L_006B;
#line 774 "test-new/asems412.imp"
USE[J - 1] = *U;
#line 774 "test-new/asems412.imp"
L_006B:;
// 775 %FINISH
#line 775 "test-new/asems412.imp"
L_006A:;
// 776 CLAIM(J)
#line 776 "test-new/asems412.imp"
CLAIM(J);
// 777 RELEASE(B); RELEASE(BB)
#line 777 "test-new/asems412.imp"
RELEASE(B);
#line 777 "test-new/asems412.imp"
RELEASE(BB);
// 778 %RESULT = J
#line 778 "test-new/asems412.imp"
return J;
// 779 %FINISH
#line 779 "test-new/asems412.imp"
L_0069:;
// 780 %FINISH
#line 780 "test-new/asems412.imp"
L_0068:;
// 781 %FINISH
#line 781 "test-new/asems412.imp"
L_0067:;
// 782 %REPEAT
#line 782 "test-new/asems412.imp"
goto L_0064;
#line 782 "test-new/asems412.imp"
}
#line 782 "test-new/asems412.imp"
L_0065:;
// 783 %RESULT = 0
#line 783 "test-new/asems412.imp"
return 0;
// 784 %END
#line 784 "test-new/asems412.imp"
} /* end of FINDUSE */
// 785 %INTEGERFN GPR(%INTEGER ADDR)
#line 785 "test-new/asems412.imp"
int GPR(int ADDR) {
// 786 %RECORD(USEFM)%NAME UR, US
#line 786 "test-new/asems412.imp"
struct USEFM *UR;
#line 786 "test-new/asems412.imp"
struct USEFM *US;
// 787 %INTEGER R, BESTR, BESTCA, BOOTR, BOOTCA, REG, MAXCA
#line 787 "test-new/asems412.imp"
int R;
#line 787 "test-new/asems412.imp"
int BESTR;
#line 787 "test-new/asems412.imp"
int BESTCA;
#line 787 "test-new/asems412.imp"
int BOOTR;
#line 787 "test-new/asems412.imp"
int BOOTCA;
#line 787 "test-new/asems412.imp"
int REG;
#line 787 "test-new/asems412.imp"
int MAXCA;
// 788 %CONSTBYTEINTEGERARRAY PREF(0:11) =
#line 788 "test-new/asems412.imp"
const unsigned char PREF[12] = {7, 10, 8, 6, 9, 11, 5, 4, 2, 3, 12, 1};
// 789+ P1, R11, R9, P2,
// 790+ R10, R12, R4, R3, R1, R2, LINK, R0
// 791
// 792 BESTR = -1; BOOTR = -1
#line 792 "test-new/asems412.imp"
BESTR = -1;
#line 792 "test-new/asems412.imp"
BOOTR = -1;
// 793 BESTCA = CA; BOOTCA = CA
#line 793 "test-new/asems412.imp"
BESTCA = CA;
#line 793 "test-new/asems412.imp"
BOOTCA = CA;
// 794
// 795 %CYCLE R = 0, 1, 11-ADDR
#line 795 "test-new/asems412.imp"
// %for R = 0, 1, 11 - ADDR %cycle
#line 795 "test-new/asems412.imp"
{
int _control, _initial = 0, _increment = 1, _final = 11 - ADDR;
#line 795 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle R = 0, 1, 11 - ADDR");
_control = R = _initial - _increment;
#line 795 "test-new/asems412.imp"
L_006C:
#line 795 "test-new/asems412.imp"
if (R != _control) _imp_signal(4, 2, 0, "Corrupt control variable R");
#line 795 "test-new/asems412.imp"
if (R == _final) goto L_006D;
#line 795 "test-new/asems412.imp"
_control += _increment;
R += _increment;
// 796 REG = PREF(R)
#line 796 "test-new/asems412.imp"
REG = PREF[R];
// 797 %IF ACTIVITY(REG) = 0 %START;! FREE
#line 797 "test-new/asems412.imp"
if (ACTIVITY[REG] != 0) goto L_006E;
// 798 UR == USE(REG); US == USE(REG+STORE)
#line 798 "test-new/asems412.imp"
UR = (struct USEFM *)/*?*/ &USE[REG - 1];
#line 798 "test-new/asems412.imp"
US = (struct USEFM *)/*?*/ &USE[REG + 20 - 1];
// 799 MAXCA = UR_CA
#line 799 "test-new/asems412.imp"
MAXCA = UR->CA;
// 800 MAXCA = US_CA %IF US_CA > MAXCA
#line 800 "test-new/asems412.imp"
if (US->CA <= MAXCA) goto L_006F;
#line 800 "test-new/asems412.imp"
MAXCA = US->CA;
#line 800 "test-new/asems412.imp"
L_006F:;
// 801 %RESULT = REG %IF MAXCA <= LIMEN;! NOT KNOWN
#line 801 "test-new/asems412.imp"
if (MAXCA > LIMEN) goto L_0070;
#line 801 "test-new/asems412.imp"
return REG;
#line 801 "test-new/asems412.imp"
L_0070:;
// 802 %IF MAXCA < BESTCA %START
#line 802 "test-new/asems412.imp"
if (MAXCA >= BESTCA) goto L_0071;
// 803 BESTCA = MAXCA; BESTR = REG
#line 803 "test-new/asems412.imp"
BESTCA = MAXCA;
#line 803 "test-new/asems412.imp"
BESTR = REG;
// 804 %FINISH
#line 804 "test-new/asems412.imp"
L_0071:;
// 805 %ELSE %IF 0 < ACTIVITY(REG) < 2 %AND USED(REG) < BOOTCA
#line 805 "test-new/asems412.imp"
goto L_0072;
#line 805 "test-new/asems412.imp"
L_006E:;
#line 805 "test-new/asems412.imp"
{
// Double-sided test on ACTIVITY[REG] (Part I)
#line 805 "test-new/asems412.imp"
int tmp;
#line 805 "test-new/asems412.imp"
if (0 >= (tmp = ACTIVITY[REG])) goto L_0073;
// Double-sided test on ACTIVITY[REG] (Part II)
#line 805 "test-new/asems412.imp"
if (tmp >= 2) goto L_0073;
#line 805 "test-new/asems412.imp"
}
#line 805 "test-new/asems412.imp"
if (USED[REG] >= BOOTCA) goto L_0073;
// 806 BOOTR = REG; BOOTCA = USED(REG)
#line 806 "test-new/asems412.imp"
BOOTR = REG;
#line 806 "test-new/asems412.imp"
BOOTCA = USED[REG];
// 807 %FINISH
#line 807 "test-new/asems412.imp"
L_0073:;
#line 807 "test-new/asems412.imp"
L_0072:;
// 808 %REPEAT
#line 808 "test-new/asems412.imp"
goto L_006C;
#line 808 "test-new/asems412.imp"
}
#line 808 "test-new/asems412.imp"
L_006D:;
// 809 %RESULT = BESTR %IF BESTR >= 0
#line 809 "test-new/asems412.imp"
if (BESTR < 0) goto L_0074;
#line 809 "test-new/asems412.imp"
return BESTR;
#line 809 "test-new/asems412.imp"
L_0074:;
// 810 ! NONE FREE SO BOOT ONE OUT
// 811 BOOTR = R1 %IF BOOTR < 0;! NONE BETTER
#line 811 "test-new/asems412.imp"
if (BOOTR >= 0) goto L_0075;
#line 811 "test-new/asems412.imp"
BOOTR = 2;
#line 811 "test-new/asems412.imp"
L_0075:;
// 812 HAZARD(BOOTR); USED(BOOTR) = CA
#line 812 "test-new/asems412.imp"
HAZARD(BOOTR);
#line 812 "test-new/asems412.imp"
USED[BOOTR] = CA;
// 813 %RESULT = BOOTR
#line 813 "test-new/asems412.imp"
return BOOTR;
// 814 %END
#line 814 "test-new/asems412.imp"
} /* end of GPR */
// 815 %INTEGERFN EVEN ODD PAIR
#line 815 "test-new/asems412.imp"
int EVENODDPAIR(void) {
// 816 %CONSTBYTEINTEGERARRAY PAIRS(1:5) = R0, R10, R2, R4, LINK
#line 816 "test-new/asems412.imp"
const unsigned char PAIRS[5] = {1, 9, 3, 5, 12};
// 817 %CONSTBYTEINTEGERARRAY NEXT(1:5) = R1, R11, R3, P2, R9
#line 817 "test-new/asems412.imp"
const unsigned char NEXT[5] = {2, 10, 4, 6, 8};
// 818 %INTEGER J, BEST, BESTCA, MAX, HELP, REG, NREG
#line 818 "test-new/asems412.imp"
int J;
#line 818 "test-new/asems412.imp"
int BEST;
#line 818 "test-new/asems412.imp"
int BESTCA;
#line 818 "test-new/asems412.imp"
int MAX;
#line 818 "test-new/asems412.imp"
int HELP;
#line 818 "test-new/asems412.imp"
int REG;
#line 818 "test-new/asems412.imp"
int NREG;
// 819 %RECORD(USEFM)%NAME U1, U2
#line 819 "test-new/asems412.imp"
struct USEFM *U1;
#line 819 "test-new/asems412.imp"
struct USEFM *U2;
// 820 BEST = 0; BESTCA = CA; HELP = 0
#line 820 "test-new/asems412.imp"
BEST = 0;
#line 820 "test-new/asems412.imp"
BESTCA = CA;
#line 820 "test-new/asems412.imp"
HELP = 0;
// 821 %CYCLE J = 1, 1, 5
#line 821 "test-new/asems412.imp"
// %for J = 1, 1, 5 %cycle
#line 821 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = 5;
#line 821 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 1, 1, 5");
_control = J = _initial - _increment;
#line 821 "test-new/asems412.imp"
L_0076:
#line 821 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 821 "test-new/asems412.imp"
if (J == _final) goto L_0077;
#line 821 "test-new/asems412.imp"
_control += _increment;
J += _increment;
// 822 REG = PAIRS(J); NREG = NEXT(J)
#line 822 "test-new/asems412.imp"
REG = PAIRS[J - 1];
#line 822 "test-new/asems412.imp"
NREG = NEXT[J - 1];
// 823 U1 == USE(REG); U2 == USE(NREG)
#line 823 "test-new/asems412.imp"
U1 = (struct USEFM *)/*?*/ &USE[REG - 1];
#line 823 "test-new/asems412.imp"
U2 = (struct USEFM *)/*?*/ &USE[NREG - 1];
// 824 %IF ACTIVITY(REG) = 0 %START
#line 824 "test-new/asems412.imp"
if (ACTIVITY[REG] != 0) goto L_0078;
// 825 %IF ACTIVITY(NREG) = 0 %START
#line 825 "test-new/asems412.imp"
if (ACTIVITY[NREG] != 0) goto L_0079;
// 826 MAX = U1_CA
#line 826 "test-new/asems412.imp"
MAX = U1->CA;
// 827 MAX = U2_CA %IF U2_CA > MAX
#line 827 "test-new/asems412.imp"
if (U2->CA <= MAX) goto L_007A;
#line 827 "test-new/asems412.imp"
MAX = U2->CA;
#line 827 "test-new/asems412.imp"
L_007A:;
// 828 %IF MAX < BESTCA %START
#line 828 "test-new/asems412.imp"
if (MAX >= BESTCA) goto L_007B;
// 829 BESTCA = MAX; BEST = J
#line 829 "test-new/asems412.imp"
BESTCA = MAX;
#line 829 "test-new/asems412.imp"
BEST = J;
// 830 %FINISH
#line 830 "test-new/asems412.imp"
L_007B:;
// 831 %ELSE
#line 831 "test-new/asems412.imp"
goto L_007C;
#line 831 "test-new/asems412.imp"
L_0079:;
// 832 HELP = J
#line 832 "test-new/asems412.imp"
HELP = J;
// 833 %FINISH
#line 833 "test-new/asems412.imp"
L_007C:;
// 834 %ELSE
#line 834 "test-new/asems412.imp"
goto L_007D;
#line 834 "test-new/asems412.imp"
L_0078:;
// 835 HELP = J %IF ACTIVITY(NREG) = 0
#line 835 "test-new/asems412.imp"
if (ACTIVITY[NREG] != 0) goto L_007E;
#line 835 "test-new/asems412.imp"
HELP = J;
#line 835 "test-new/asems412.imp"
L_007E:;
// 836 %FINISH
#line 836 "test-new/asems412.imp"
L_007D:;
// 837 %REPEAT
#line 837 "test-new/asems412.imp"
goto L_0076;
#line 837 "test-new/asems412.imp"
}
#line 837 "test-new/asems412.imp"
L_0077:;
// 838 %RESULT = NEXT(BEST) %IF BEST # 0
#line 838 "test-new/asems412.imp"
if (BEST == 0) goto L_007F;
#line 838 "test-new/asems412.imp"
return NEXT[BEST - 1];
#line 838 "test-new/asems412.imp"
L_007F:;
// 839 HELP = 2 %IF HELP = 0
#line 839 "test-new/asems412.imp"
if (HELP != 0) goto L_0080;
#line 839 "test-new/asems412.imp"
HELP = 2;
#line 839 "test-new/asems412.imp"
L_0080:;
// 840 REG = PAIRS(HELP); NREG = NEXT(HELP)
#line 840 "test-new/asems412.imp"
REG = PAIRS[HELP - 1];
#line 840 "test-new/asems412.imp"
NREG = NEXT[HELP - 1];
// 841 HAZARD(REG); HAZARD(NREG)
#line 841 "test-new/asems412.imp"
HAZARD(REG);
#line 841 "test-new/asems412.imp"
HAZARD(NREG);
// 842 %RESULT = NREG
#line 842 "test-new/asems412.imp"
return NREG;
// 843 %END
#line 843 "test-new/asems412.imp"
} /* end of EVENODDPAIR */
// 844 %INTEGERFN FPR
#line 844 "test-new/asems412.imp"
int FPR(void) {
// 845 %RECORD(USEFM)%NAME UR, US
#line 845 "test-new/asems412.imp"
struct USEFM *UR;
#line 845 "test-new/asems412.imp"
struct USEFM *US;
// 846 %INTEGER R, BESTR, BESTCA, BOOTR, BOOTCA, MAXCA, BOOTA
#line 846 "test-new/asems412.imp"
int R;
#line 846 "test-new/asems412.imp"
int BESTR;
#line 846 "test-new/asems412.imp"
int BESTCA;
#line 846 "test-new/asems412.imp"
int BOOTR;
#line 846 "test-new/asems412.imp"
int BOOTCA;
#line 846 "test-new/asems412.imp"
int MAXCA;
#line 846 "test-new/asems412.imp"
int BOOTA;
// 847 BESTR = -1; BESTCA = CA
#line 847 "test-new/asems412.imp"
BESTR = -1;
#line 847 "test-new/asems412.imp"
BESTCA = CA;
// 848 BOOTR = -1; BOOTCA = CA; BOOTA = CA
#line 848 "test-new/asems412.imp"
BOOTR = -1;
#line 848 "test-new/asems412.imp"
BOOTCA = CA;
#line 848 "test-new/asems412.imp"
BOOTA = CA;
// 849 %CYCLE R = FPR0, 1, FPR14
#line 849 "test-new/asems412.imp"
// %for R = 13, 1, 20 %cycle
#line 849 "test-new/asems412.imp"
{
int _control, _initial = 13, _increment = 1, _final = 20;
#line 849 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle R = 13, 1, 20");
_control = R = _initial - _increment;
#line 849 "test-new/asems412.imp"
L_0081:
#line 849 "test-new/asems412.imp"
if (R != _control) _imp_signal(4, 2, 0, "Corrupt control variable R");
#line 849 "test-new/asems412.imp"
if (R == _final) goto L_0082;
#line 849 "test-new/asems412.imp"
_control += _increment;
R += _increment;
// 850 UR == USE(R); US == USE(R+STORE)
#line 850 "test-new/asems412.imp"
UR = (struct USEFM *)/*?*/ &USE[R - 1];
#line 850 "test-new/asems412.imp"
US = (struct USEFM *)/*?*/ &USE[R + 20 - 1];
// 851 %IF ACTIVITY(R) = 0 %START
#line 851 "test-new/asems412.imp"
if (ACTIVITY[R] != 0) goto L_0083;
// 852 MAXCA = UR_CA; MAXCA = US_CA %IF US_CA > MAXCA
#line 852 "test-new/asems412.imp"
MAXCA = UR->CA;
#line 852 "test-new/asems412.imp"
if (US->CA <= MAXCA) goto L_0084;
#line 852 "test-new/asems412.imp"
MAXCA = US->CA;
#line 852 "test-new/asems412.imp"
L_0084:;
// 853 %RESULT = R %IF MAXCA <= LIMEN
#line 853 "test-new/asems412.imp"
if (MAXCA > LIMEN) goto L_0085;
#line 853 "test-new/asems412.imp"
return R;
#line 853 "test-new/asems412.imp"
L_0085:;
// 854 %IF MAXCA < BESTCA %START
#line 854 "test-new/asems412.imp"
if (MAXCA >= BESTCA) goto L_0086;
// 855 BESTR = R; BESTCA = MAXCA
#line 855 "test-new/asems412.imp"
BESTR = R;
#line 855 "test-new/asems412.imp"
BESTCA = MAXCA;
// 856 %FINISH
#line 856 "test-new/asems412.imp"
L_0086:;
// 857 %ELSE %IF 0 < ACTIVITY(R) < 2 %AND USED(R) < BOOTCA
#line 857 "test-new/asems412.imp"
goto L_0087;
#line 857 "test-new/asems412.imp"
L_0083:;
#line 857 "test-new/asems412.imp"
{
// Double-sided test on ACTIVITY[R] (Part I)
#line 857 "test-new/asems412.imp"
int tmp;
#line 857 "test-new/asems412.imp"
if (0 >= (tmp = ACTIVITY[R])) goto L_0088;
// Double-sided test on ACTIVITY[R] (Part II)
#line 857 "test-new/asems412.imp"
if (tmp >= 2) goto L_0088;
#line 857 "test-new/asems412.imp"
}
#line 857 "test-new/asems412.imp"
if (USED[R] >= BOOTCA) goto L_0088;
// 858 BOOTCA = USED(R); BOOTR = R
#line 858 "test-new/asems412.imp"
BOOTCA = USED[R];
#line 858 "test-new/asems412.imp"
BOOTR = R;
// 859 %FINISH
#line 859 "test-new/asems412.imp"
L_0088:;
#line 859 "test-new/asems412.imp"
L_0087:;
// 860 %REPEAT
#line 860 "test-new/asems412.imp"
goto L_0081;
#line 860 "test-new/asems412.imp"
}
#line 860 "test-new/asems412.imp"
L_0082:;
// 861 %RESULT = BESTR %UNLESS BESTR < 0
#line 861 "test-new/asems412.imp"
if (BESTR < 0) goto L_0089;
#line 861 "test-new/asems412.imp"
return BESTR;
#line 861 "test-new/asems412.imp"
L_0089:;
// 862 BOOTR = FPR0 %IF BOOTR < 0
#line 862 "test-new/asems412.imp"
if (BOOTR >= 0) goto L_008A;
#line 862 "test-new/asems412.imp"
BOOTR = 13;
#line 862 "test-new/asems412.imp"
L_008A:;
// 863 HAZARD(BOOTR)
#line 863 "test-new/asems412.imp"
HAZARD(BOOTR);
// 864 %RESULT = BOOTR
#line 864 "test-new/asems412.imp"
return BOOTR;
// 865 %END
#line 865 "test-new/asems412.imp"
} /* end of FPR */
// 866 %ROUTINE CHECK RELEASED
#line 866 "test-new/asems412.imp"
void CHECKRELEASED(void) {
// 867 %INTEGER J
#line 867 "test-new/asems412.imp"
int J;
// 868 %FOR J = 1, 1, 20 %CYCLE
#line 868 "test-new/asems412.imp"
// %for J = 1, 1, 20 %cycle
#line 868 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = 20;
#line 868 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 1, 1, 20");
_control = J = _initial - _increment;
#line 868 "test-new/asems412.imp"
L_008B:
#line 868 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 868 "test-new/asems412.imp"
if (J == _final) goto L_008C;
#line 868 "test-new/asems412.imp"
_control += _increment;
J += _increment;
// 869 ABORT(2) %IF ACTIVITY(J) > 0
#line 869 "test-new/asems412.imp"
if (ACTIVITY[J] <= 0) goto L_008D;
#line 869 "test-new/asems412.imp"
ABORT(2);
#line 869 "test-new/asems412.imp"
L_008D:;
// 870 %REPEAT
#line 870 "test-new/asems412.imp"
goto L_008B;
#line 870 "test-new/asems412.imp"
}
#line 870 "test-new/asems412.imp"
L_008C:;
// 871 %END
#line 871 "test-new/asems412.imp"
return;
#line 871 "test-new/asems412.imp"
} /* end of CHECKRELEASED */
// 872
// 873
// 874 ! OBJECT FILE HANDLING ROUTINES
// 875
// 876 %ROUTINE COUNT DIAGS
#line 876 "test-new/asems412.imp"
void COUNTDIAGS(void) {
// 877 %OWNINTEGER HERE = 0
#line 877 "test-new/asems412.imp"
static int HERE = 0;
// 878 LINE SIZE = LINE SIZE+4 %IF HERE # CURRENT LINE
#line 878 "test-new/asems412.imp"
if (HERE == CURRENTLINE) goto L_008E;
#line 878 "test-new/asems412.imp"
LINESIZE = LINESIZE + 4;
#line 878 "test-new/asems412.imp"
L_008E:;
// 879 HERE = CURRENT LINE
#line 879 "test-new/asems412.imp"
HERE = CURRENTLINE;
// 880 %END
#line 880 "test-new/asems412.imp"
return;
#line 880 "test-new/asems412.imp"
} /* end of COUNTDIAGS */
// 881
// 882 %ROUTINE PUT(%SHORTINTEGER N)
#line 882 "test-new/asems412.imp"
void PUT(short int N) {
// 883 PRINT SYMBOL(N>>8); PRINT SYMBOL(N&255)
#line 883 "test-new/asems412.imp"
_imp_PRINTSYMBOL((unsigned int)N >> 8);
#line 883 "test-new/asems412.imp"
_imp_PRINTSYMBOL(N & 255);
// 884 %END
#line 884 "test-new/asems412.imp"
return;
#line 884 "test-new/asems412.imp"
} /* end of PUT */
// 885 %ROUTINE DUMP(%SHORTINTEGER N)
#line 885 "test-new/asems412.imp"
void DUMP(short int N) {
// 886 PRINT SYMBOL(LOAD CODE); PUT(N)
#line 886 "test-new/asems412.imp"
_imp_PRINTSYMBOL(2);
#line 886 "test-new/asems412.imp"
PUT(N);
// 887 DECODE(N) %IF CONTROL < 0
#line 887 "test-new/asems412.imp"
if (CONTROL >= 0) goto L_008F;
#line 887 "test-new/asems412.imp"
DECODE(N);
#line 887 "test-new/asems412.imp"
L_008F:;
// 888 CA = CA+2
#line 888 "test-new/asems412.imp"
CA = CA + 2;
// 889 %END
#line 889 "test-new/asems412.imp"
return;
#line 889 "test-new/asems412.imp"
} /* end of DUMP */
// 890 %ROUTINE GHALF(%SHORTINTEGER N)
#line 890 "test-new/asems412.imp"
void GHALF(short int N) {
// 891 PRINT SYMBOL(LOAD GLA); PUT(N)
#line 891 "test-new/asems412.imp"
_imp_PRINTSYMBOL(3);
#line 891 "test-new/asems412.imp"
PUT(N);
// 892 GA = GA+2
#line 892 "test-new/asems412.imp"
GA = GA + 2;
// 893 %END
#line 893 "test-new/asems412.imp"
return;
#line 893 "test-new/asems412.imp"
} /* end of GHALF */
// 894 %ROUTINE GWORD(%INTEGER N)
#line 894 "test-new/asems412.imp"
void GWORD(int N) {
// 895 GHALF(N>>16); GHALF(N&X'FFFF')
#line 895 "test-new/asems412.imp"
GHALF((unsigned int)N >> 16);
#line 895 "test-new/asems412.imp"
GHALF(N & 65535);
// 896 %END
#line 896 "test-new/asems412.imp"
return;
#line 896 "test-new/asems412.imp"
} /* end of GWORD */
// 897 %ROUTINE GBYTE(%SHORTINTEGER N)
#line 897 "test-new/asems412.imp"
void GBYTE(short int N) {
// 898 %OWNINTEGER V=0, F=0
#line 898 "test-new/asems412.imp"
static int V = 0;
#line 898 "test-new/asems412.imp"
static int F = 0;
// 899 F = \F
#line 899 "test-new/asems412.imp"
F = (~F);
// 900 %IF F=0 %START
#line 900 "test-new/asems412.imp"
if (F != 0) goto L_0090;
// 901 PRINT SYMBOL(LOAD GLA); PUT(V<<8+N)
#line 901 "test-new/asems412.imp"
_imp_PRINTSYMBOL(3);
#line 901 "test-new/asems412.imp"
PUT((V << 8) + N);
// 902 %ELSE
#line 902 "test-new/asems412.imp"
goto L_0091;
#line 902 "test-new/asems412.imp"
L_0090:;
// 903 V = N
#line 903 "test-new/asems412.imp"
V = N;
// 904 %finish
#line 904 "test-new/asems412.imp"
L_0091:;
// 905 GA = GA+1
#line 905 "test-new/asems412.imp"
GA = GA + 1;
// 906 %END
#line 906 "test-new/asems412.imp"
return;
#line 906 "test-new/asems412.imp"
} /* end of GBYTE */
// 907 %ROUTINE PATCH(%INTEGER WHAT, WHERE)
#line 907 "test-new/asems412.imp"
void PATCH(int WHAT, int WHERE) {
// 908 SELECT OUTPUT(DIRECT)
#line 908 "test-new/asems412.imp"
_imp_SELECTOUTPUT(3);
// 909 PRINT SYMBOL(PATCH CODE); PUT(WHAT); PUT(WHERE)
#line 909 "test-new/asems412.imp"
_imp_PRINTSYMBOL(7);
#line 909 "test-new/asems412.imp"
PUT(WHAT);
#line 909 "test-new/asems412.imp"
PUT(WHERE);
// 910 SELECT OUTPUT(OBJECT)
#line 910 "test-new/asems412.imp"
_imp_SELECTOUTPUT(2);
// 911 %END
#line 911 "test-new/asems412.imp"
return;
#line 911 "test-new/asems412.imp"
} /* end of PATCH */
// 912 %ROUTINE GPATCH(%INTEGER WHAT, WHERE)
#line 912 "test-new/asems412.imp"
void GPATCH(int WHAT, int WHERE) {
// 913 SELECT OUTPUT(DIRECT)
#line 913 "test-new/asems412.imp"
_imp_SELECTOUTPUT(3);
// 914 PRINT SYMBOL(PATCH GLA); PUT(WHAT); PUT(WHERE)
#line 914 "test-new/asems412.imp"
_imp_PRINTSYMBOL(6);
#line 914 "test-new/asems412.imp"
PUT(WHAT);
#line 914 "test-new/asems412.imp"
PUT(WHERE);
// 915 SELECT OUTPUT(OBJECT)
#line 915 "test-new/asems412.imp"
_imp_SELECTOUTPUT(2);
// 916 %END
#line 916 "test-new/asems412.imp"
return;
#line 916 "test-new/asems412.imp"
} /* end of GPATCH */
// 917 %ROUTINE GFIX(%INTEGER ALIGNMENT)
#line 917 "test-new/asems412.imp"
void GFIX(int ALIGNMENT) {
// 918 GBYTE(0) %WHILE GA&(ALIGNMENT-1) # 0
#line 918 "test-new/asems412.imp"
L_0092:;
#line 918 "test-new/asems412.imp"
if (GA & ALIGNMENT - 1 == 0) goto L_0093;
#line 918 "test-new/asems412.imp"
GBYTE(0);
#line 918 "test-new/asems412.imp"
goto L_0092;
#line 918 "test-new/asems412.imp"
L_0093:;
// 919 %END
#line 919 "test-new/asems412.imp"
return;
#line 919 "test-new/asems412.imp"
} /* end of GFIX */
// 920 %ROUTINE SF(%SHORTINTEGER OP, R, L)
#line 920 "test-new/asems412.imp"
void SF(short int OP, short int R, short int L) {
// 921 DUMP(OP + ACTUAL(R)<<4 + L)
#line 921 "test-new/asems412.imp"
DUMP(OP + (ACTUAL[R] << 4) + L);
// 922 %END
#line 922 "test-new/asems412.imp"
return;
#line 922 "test-new/asems412.imp"
} /* end of SF */
// 923 %ROUTINE RR(%SHORTINTEGER OP, R1, R2)
#line 923 "test-new/asems412.imp"
void RR(short int OP, short int R1, short int R2) {
// 924 DUMP(OP + ACTUAL(R1)<<4 + ACTUAL(R2))
#line 924 "test-new/asems412.imp"
DUMP(OP + (ACTUAL[R1] << 4) + ACTUAL[R2]);
// 925 RELEASE(R2)
#line 925 "test-new/asems412.imp"
RELEASE(R2);
// 926 %END
#line 926 "test-new/asems412.imp"
return;
#line 926 "test-new/asems412.imp"
} /* end of RR */
// 927 %ROUTINE RX(%INTEGER OP, R, X, D)
#line 927 "test-new/asems412.imp"
void RX(int OP, int R, int X, int D) {
// 928 ABORT(5) %IF X=R0 %OR D<0 %OR D>X'3FFF'
#line 928 "test-new/asems412.imp"
if (X == 1) goto L_0066;
#line 928 "test-new/asems412.imp"
if (D < 0) goto L_0066;
#line 928 "test-new/asems412.imp"
if (D <= 16383) goto L_0094;
#line 928 "test-new/asems412.imp"
L_0066:;
#line 928 "test-new/asems412.imp"
ABORT(5);
#line 928 "test-new/asems412.imp"
L_0094:;
// 929 RELEASE(X)
#line 929 "test-new/asems412.imp"
RELEASE(X);
// 930 DUMP(OP + ACTUAL(R)<<4 + ACTUAL(X)); DUMP(D)
#line 930 "test-new/asems412.imp"
DUMP(OP + (ACTUAL[R] << 4) + ACTUAL[X]);
#line 930 "test-new/asems412.imp"
DUMP(D);
// 931 COUNT DIAGS %IF OP = BAL
#line 931 "test-new/asems412.imp"
if (OP != 16640) goto L_0095;
#line 931 "test-new/asems412.imp"
COUNTDIAGS();
#line 931 "test-new/asems412.imp"
L_0095:;
// 932 %IF CONTROL&UNASS DIAG # 0 %START
#line 932 "test-new/asems412.imp"
if (CONTROL & 32 == 0) goto L_0096;
// 933 %RETURN %IF OP # LW %AND OP # LE
#line 933 "test-new/asems412.imp"
if (OP == 22528) goto L_0097;
#line 933 "test-new/asems412.imp"
if (OP == 26624) goto L_0097;
#line 933 "test-new/asems412.imp"
return;
#line 933 "test-new/asems412.imp"
L_0097:;
// 934 %RETURN %IF X = LOCAL %AND D >= MIN TEMP
#line 934 "test-new/asems412.imp"
if (X != LOCAL) goto L_0098;
#line 934 "test-new/asems412.imp"
if (D < MINTEMP) goto L_0098;
#line 934 "test-new/asems412.imp"
return;
#line 934 "test-new/asems412.imp"
L_0098:;
// 935 %IF OP = LW %THEN OP = CL %ELSE OP = CE
#line 935 "test-new/asems412.imp"
if (OP != 22528) goto L_0099;
#line 935 "test-new/asems412.imp"
OP = 21760;
#line 935 "test-new/asems412.imp"
goto L_009A;
#line 935 "test-new/asems412.imp"
L_0099:;
#line 935 "test-new/asems412.imp"
OP = 26880;
#line 935 "test-new/asems412.imp"
L_009A:;
// 936 DUMP(OP+ACTUAL(R)<<4+ACTUAL(CODE))
#line 936 "test-new/asems412.imp"
DUMP(OP + (ACTUAL[R] << 4) + ACTUAL[44]);
// 937 DUMP(UNASS PAT)
#line 937 "test-new/asems412.imp"
DUMP(16);
// 938 PRINTSYMBOL(DLINE); ! INFORM DIAGS OF 'BALR'
#line 938 "test-new/asems412.imp"
_imp_PRINTSYMBOL(10);
// 939 DUMP(ENTER UNASS)
#line 939 "test-new/asems412.imp"
DUMP(ENTERUNASS);
// 940 COUNT DIAGS
#line 940 "test-new/asems412.imp"
COUNTDIAGS();
// 941 %FINISH
#line 941 "test-new/asems412.imp"
L_0096:;
// 942 %END
#line 942 "test-new/asems412.imp"
return;
#line 942 "test-new/asems412.imp"
} /* end of RX */
// 943 %ROUTINE RI2(%INTEGER OP, R, X, D)
#line 943 "test-new/asems412.imp"
void RI2(int OP, int R, int X, int D) {
// 944 ABORT(5) %IF X=R0
#line 944 "test-new/asems412.imp"
if (X != 1) goto L_009B;
#line 944 "test-new/asems412.imp"
ABORT(5);
#line 944 "test-new/asems412.imp"
L_009B:;
// 945 RELEASE(X)
#line 945 "test-new/asems412.imp"
RELEASE(X);
// 946 DUMP(OP + ACTUAL(R)<<4 + ACTUAL(X)); DUMP(D)
#line 946 "test-new/asems412.imp"
DUMP(OP + (ACTUAL[R] << 4) + ACTUAL[X]);
#line 946 "test-new/asems412.imp"
DUMP(D);
// 947 COUNT DIAGS %IF OP = BAL; ! IF PERM REFERENCE
#line 947 "test-new/asems412.imp"
if (OP != 16640) goto L_009C;
#line 947 "test-new/asems412.imp"
COUNTDIAGS();
#line 947 "test-new/asems412.imp"
L_009C:;
// 948 %END
#line 948 "test-new/asems412.imp"
return;
#line 948 "test-new/asems412.imp"
} /* end of RI2 */
// 949 %ROUTINE RI3(%INTEGER OP, R, X, D)
#line 949 "test-new/asems412.imp"
void RI3(int OP, int R, int X, int D) {
// 950 ABORT(5) %IF X=R0
#line 950 "test-new/asems412.imp"
if (X != 1) goto L_009D;
#line 950 "test-new/asems412.imp"
ABORT(5);
#line 950 "test-new/asems412.imp"
L_009D:;
// 951 RELEASE(X)
#line 951 "test-new/asems412.imp"
RELEASE(X);
// 952 DUMP(OP + ACTUAL(R)<<4 + ACTUAL(X)); DUMP(D>>16); DUMP(D&X'FFFF')
#line 952 "test-new/asems412.imp"
DUMP(OP + (ACTUAL[R] << 4) + ACTUAL[X]);
#line 952 "test-new/asems412.imp"
DUMP((unsigned int)D >> 16);
#line 952 "test-new/asems412.imp"
DUMP(D & 65535);
// 953 %END
#line 953 "test-new/asems412.imp"
return;
#line 953 "test-new/asems412.imp"
} /* end of RI3 */
// 954 %ROUTINE DEFINE TAG(%SHORTINTEGER REF)
#line 954 "test-new/asems412.imp"
void DEFINETAG(short int REF) {
// 955 SELECT OUTPUT(DIRECT)
#line 955 "test-new/asems412.imp"
_imp_SELECTOUTPUT(3);
// 956 PRINT SYMBOL(TAG DEF); PUT(REF); PUT(CA)
#line 956 "test-new/asems412.imp"
_imp_PRINTSYMBOL(1);
#line 956 "test-new/asems412.imp"
PUT(REF);
#line 956 "test-new/asems412.imp"
PUT(CA);
// 957 SELECT OUTPUT(OBJECT)
#line 957 "test-new/asems412.imp"
_imp_SELECTOUTPUT(2);
// 958 %END
#line 958 "test-new/asems412.imp"
return;
#line 958 "test-new/asems412.imp"
} /* end of DEFINETAG */
// 959 %ROUTINE DEFINE REFERENCE(%INTEGER REF, TYPE)
#line 959 "test-new/asems412.imp"
void DEFINEREFERENCE(int REF, int TYPE) {
// 960 SELECT OUTPUT(DIRECT)
#line 960 "test-new/asems412.imp"
_imp_SELECTOUTPUT(3);
// 961 PRINT SYMBOL(TYPE); PUT(REF); PUT(CA)
#line 961 "test-new/asems412.imp"
_imp_PRINTSYMBOL(TYPE);
#line 961 "test-new/asems412.imp"
PUT(REF);
#line 961 "test-new/asems412.imp"
PUT(CA);
// 962 SELECT OUTPUT(OBJECT)
#line 962 "test-new/asems412.imp"
_imp_SELECTOUTPUT(2);
// 963 %END
#line 963 "test-new/asems412.imp"
return;
#line 963 "test-new/asems412.imp"
} /* end of DEFINEREFERENCE */
// 964 %ROUTINE SET LINE
#line 964 "test-new/asems412.imp"
void SETLINE(void) {
// 965 %OWNINTEGER HERE = 0
#line 965 "test-new/asems412.imp"
static int HERE = 0;
// 966 CURRENT LINE = TAG
#line 966 "test-new/asems412.imp"
CURRENTLINE = TAG();
// 967 %WHILE CURRENT LINE > HERE %CYCLE
#line 967 "test-new/asems412.imp"
L_009E:;
#line 967 "test-new/asems412.imp"
if (CURRENTLINE <= HERE) goto L_009F;
// 968 HERE = HERE+1; PRINT SYMBOL(LINE FLAG)
#line 968 "test-new/asems412.imp"
HERE = HERE + 1;
#line 968 "test-new/asems412.imp"
_imp_PRINTSYMBOL(4);
// 969 %REPEAT
#line 969 "test-new/asems412.imp"
goto L_009E;
#line 969 "test-new/asems412.imp"
L_009F:;
// 970 %END
#line 970 "test-new/asems412.imp"
return;
#line 970 "test-new/asems412.imp"
} /* end of SETLINE */
// 971
// 972 ! ENVIRONMENT CONTROL
// 973
// 974 %RECORD(ENVFM)%MAP ENVIRONMENT(%SHORTINTEGER LABEL)
#line 974 "test-new/asems412.imp"
struct ENVFM *ENVIRONMENT(short int LABEL)
#line 974 "test-new/asems412.imp"
{
// 975 %INTEGER J
#line 975 "test-new/asems412.imp"
int J;
// 976 %RECORD(ENVFM)%NAME E
#line 976 "test-new/asems412.imp"
struct ENVFM *E;
// 977 %RESULT == NULL ENV %IF LABEL <= 0
#line 977 "test-new/asems412.imp"
if (LABEL > 0) goto L_00A0;
#line 977 "test-new/asems412.imp"
return /*?*/ &NULLENV;
#line 977 "test-new/asems412.imp"
L_00A0:;
// 978 %FOR J = MAX ENVIRS, -1, 0 %CYCLE
#line 978 "test-new/asems412.imp"
// %for J = 13, -1, 0 %cycle
#line 978 "test-new/asems412.imp"
{
int _control, _initial = 13, _increment = -1, _final = 0;
#line 978 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 13, -1, 0");
_control = J = _initial - _increment;
#line 978 "test-new/asems412.imp"
L_00A1:
#line 978 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 978 "test-new/asems412.imp"
if (J == _final) goto L_00A2;
#line 978 "test-new/asems412.imp"
_control += _increment;
J -= 1;
// 979 E == ENVIR(J)
#line 979 "test-new/asems412.imp"
E = (struct ENVFM *)/*?*/ &ENVIR[J];
// 980 %RESULT == E %IF E_LABEL = LABEL
#line 980 "test-new/asems412.imp"
if (E->LABEL != LABEL) goto L_00A4;
#line 980 "test-new/asems412.imp"
return E;
#line 980 "test-new/asems412.imp"
L_00A4:;
// 981 %REPEAT
#line 981 "test-new/asems412.imp"
goto L_00A1;
#line 981 "test-new/asems412.imp"
}
#line 981 "test-new/asems412.imp"
L_00A2:;
// 982 %RESULT == NULL ENV
#line 982 "test-new/asems412.imp"
return /*?*/ &NULLENV;
// 983 %END
#line 983 "test-new/asems412.imp"
} /* end of ENVIRONMENT */
// 984 %ROUTINE REMEMBER ENVIRONMENT(%SHORTINTEGER LABEL)
#line 984 "test-new/asems412.imp"
void REMEMBERENVIRONMENT(short int LABEL) {
// 985 %INTEGER K
#line 985 "test-new/asems412.imp"
int K;
// 986 %RECORD(ENVFM)%NAME E
#line 986 "test-new/asems412.imp"
struct ENVFM *E;
// 987 %RETURN %IF LABEL <= 0
#line 987 "test-new/asems412.imp"
if (LABEL > 0) goto L_00A5;
#line 987 "test-new/asems412.imp"
return;
#line 987 "test-new/asems412.imp"
L_00A5:;
// 988 E == ENVIRONMENT(LABEL)
#line 988 "test-new/asems412.imp"
E = (struct ENVFM *)ENVIRONMENT(LABEL);
// 989 E_LABEL = 0
#line 989 "test-new/asems412.imp"
E->LABEL = 0;
// 990 ENVP = ENVP+1; ENVP = 0 %IF ENVP > MAX ENVIRS
#line 990 "test-new/asems412.imp"
ENVP = ENVP + 1;
#line 990 "test-new/asems412.imp"
if (ENVP <= 13) goto L_00A6;
#line 990 "test-new/asems412.imp"
ENVP = 0;
#line 990 "test-new/asems412.imp"
L_00A6:;
// 991 E == ENVIR(ENVP)
#line 991 "test-new/asems412.imp"
E = (struct ENVFM *)/*?*/ &ENVIR[ENVP];
// 992 E_LABEL = LABEL
#line 992 "test-new/asems412.imp"
E->LABEL = LABEL;
// 993 E_LIMEN = LIMEN
#line 993 "test-new/asems412.imp"
E->LIMEN = LIMEN;
// 994 E_E(K) = USE(K) %FOR K = 1, 1, 40
#line 994 "test-new/asems412.imp"
// %for K = 1, 1, 40 %cycle
#line 994 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = 40;
#line 994 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle K = 1, 1, 40");
_control = K = _initial - _increment;
#line 994 "test-new/asems412.imp"
L_00A7:
#line 994 "test-new/asems412.imp"
if (K != _control) _imp_signal(4, 2, 0, "Corrupt control variable K");
#line 994 "test-new/asems412.imp"
if (K == _final) goto L_00A8;
#line 994 "test-new/asems412.imp"
_control += _increment;
K += _increment;
#line 994 "test-new/asems412.imp"
E->E[K - 1] = USE[K - 1];
#line 994 "test-new/asems412.imp"
goto L_00A7;
#line 994 "test-new/asems412.imp"
}
#line 994 "test-new/asems412.imp"
L_00A8:;
// 995 %END
#line 995 "test-new/asems412.imp"
return;
#line 995 "test-new/asems412.imp"
} /* end of REMEMBERENVIRONMENT */
// 996 %ROUTINE MERGE ENVIRONMENT(%SHORTINTEGER LABEL)
#line 996 "test-new/asems412.imp"
void MERGEENVIRONMENT(short int LABEL) {
// 997 %INTEGER J
#line 997 "test-new/asems412.imp"
int J;
// 998 %RECORD(ENVFM)%NAME E
#line 998 "test-new/asems412.imp"
struct ENVFM *E;
// 999 %RECORD(USEFM)%NAME U, V
#line 999 "test-new/asems412.imp"
struct USEFM *U;
#line 999 "test-new/asems412.imp"
struct USEFM *V;
// 1000 E == ENVIRONMENT(LABEL)
#line 1000 "test-new/asems412.imp"
E = (struct ENVFM *)ENVIRONMENT(LABEL);
// 1001 %UNLESS E == NULL ENV %START
#line 1001 "test-new/asems412.imp"
if (_imp_ADDR((void *)(E)) == _imp_ADDR((void *)(/*?*/ &NULLENV))) goto L_00A9;
// 1002 %FOR J = 1, 1, 40 %CYCLE
#line 1002 "test-new/asems412.imp"
// %for J = 1, 1, 40 %cycle
#line 1002 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = 40;
#line 1002 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 1, 1, 40");
_control = J = _initial - _increment;
#line 1002 "test-new/asems412.imp"
L_00AA:
#line 1002 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 1002 "test-new/asems412.imp"
if (J == _final) goto L_00AB;
#line 1002 "test-new/asems412.imp"
_control += _increment;
J += _increment;
// 1003 U == USE(J)
#line 1003 "test-new/asems412.imp"
U = (struct USEFM *)/*?*/ &USE[J - 1];
// 1004 V == E_E(J)
#line 1004 "test-new/asems412.imp"
V = (struct USEFM *)/*?*/ &E->E[J - 1];
// 1005 V_CA = E_LIMEN %UNLESS U_BASE = V_BASE %C
#line 1005 "test-new/asems412.imp"
if (U->BASE != V->BASE) goto L_00AC;
#line 1005 "test-new/asems412.imp"
if (U->DISP != V->DISP) goto L_00AC;
#line 1005 "test-new/asems412.imp"
if (U->FORM != V->FORM) goto L_00AC;
#line 1005 "test-new/asems412.imp"
if (U->TYPE != V->TYPE) goto L_00AC;
#line 1005 "test-new/asems412.imp"
if (U->CA > LIMEN) goto L_00AD;
#line 1005 "test-new/asems412.imp"
L_00AC:;
#line 1005 "test-new/asems412.imp"
V->CA = E->LIMEN;
#line 1005 "test-new/asems412.imp"
L_00AD:;
// 1006+ %AND U_DISP = V_DISP %C
// 1007+ %AND U_FORM = V_FORM %C
// 1008+ %AND U_TYPE = V_TYPE %C
// 1009+ %AND U_CA > LIMEN
// 1010 %REPEAT
#line 1010 "test-new/asems412.imp"
goto L_00AA;
#line 1010 "test-new/asems412.imp"
}
#line 1010 "test-new/asems412.imp"
L_00AB:;
// 1011 %FINISH
#line 1011 "test-new/asems412.imp"
L_00A9:;
// 1012 %END
#line 1012 "test-new/asems412.imp"
return;
#line 1012 "test-new/asems412.imp"
} /* end of MERGEENVIRONMENT */
// 1013 %ROUTINE RESTORE ENVIRONMENT(%SHORTINTEGER LABEL)
#line 1013 "test-new/asems412.imp"
void RESTOREENVIRONMENT(short int LABEL) {
// 1014 %INTEGER J
#line 1014 "test-new/asems412.imp"
int J;
// 1015 %RECORD(ENVFM)%NAME E
#line 1015 "test-new/asems412.imp"
struct ENVFM *E;
// 1016 E == ENVIRONMENT(LABEL)
#line 1016 "test-new/asems412.imp"
E = (struct ENVFM *)ENVIRONMENT(LABEL);
// 1017 %IF E == NULL ENV %START
#line 1017 "test-new/asems412.imp"
if (_imp_ADDR((void *)(E)) != _imp_ADDR((void *)(/*?*/ &NULLENV))) goto L_00AE;
// 1018 LIMEN = CA
#line 1018 "test-new/asems412.imp"
LIMEN = CA;
// 1019 %ELSE
#line 1019 "test-new/asems412.imp"
goto L_00AF;
#line 1019 "test-new/asems412.imp"
L_00AE:;
// 1020 E_LABEL = 0
#line 1020 "test-new/asems412.imp"
E->LABEL = 0;
// 1021 LIMEN = E_LIMEN
#line 1021 "test-new/asems412.imp"
LIMEN = E->LIMEN;
// 1022 USE(J) = E_E(J) %FOR J = 1, 1, 40
#line 1022 "test-new/asems412.imp"
// %for J = 1, 1, 40 %cycle
#line 1022 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = 40;
#line 1022 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 1, 1, 40");
_control = J = _initial - _increment;
#line 1022 "test-new/asems412.imp"
L_00B0:
#line 1022 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 1022 "test-new/asems412.imp"
if (J == _final) goto L_00B1;
#line 1022 "test-new/asems412.imp"
_control += _increment;
J += _increment;
#line 1022 "test-new/asems412.imp"
USE[J - 1] = E->E[J - 1];
#line 1022 "test-new/asems412.imp"
goto L_00B0;
#line 1022 "test-new/asems412.imp"
}
#line 1022 "test-new/asems412.imp"
L_00B1:;
// 1023 %FINISH
#line 1023 "test-new/asems412.imp"
L_00AF:;
// 1024 %END
#line 1024 "test-new/asems412.imp"
return;
#line 1024 "test-new/asems412.imp"
} /* end of RESTOREENVIRONMENT */
// 1025
// 1026 %ROUTINE PERM(%INTEGER N)
#line 1026 "test-new/asems412.imp"
void PERM(int N) {
// 1027 %INTEGER MASK, J, R
#line 1027 "test-new/asems412.imp"
int MASK;
#line 1027 "test-new/asems412.imp"
int J;
#line 1027 "test-new/asems412.imp"
int R;
// 1028 %CONSTBYTEINTEGERARRAY REG(1:15) =
#line 1028 "test-new/asems412.imp"
const unsigned char REG[15] = {1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19, 20};
// 1029+ R0, R1, R2, R3, R4, P2, P1, FPR0, FPR2,15,16,17,18,19,20
// 1030 MASK = X'80'
#line 1030 "test-new/asems412.imp"
MASK = 128;
// 1031 N = N!X'FFFF0000'
#line 1031 "test-new/asems412.imp"
N = N | -65536;
// 1032 %CYCLE J = 1, 1, 15
#line 1032 "test-new/asems412.imp"
// %for J = 1, 1, 15 %cycle
#line 1032 "test-new/asems412.imp"
{
int _control, _initial = 1, _increment = 1, _final = 15;
#line 1032 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle J = 1, 1, 15");
_control = J = _initial - _increment;
#line 1032 "test-new/asems412.imp"
L_00B2:
#line 1032 "test-new/asems412.imp"
if (J != _control) _imp_signal(4, 2, 0, "Corrupt control variable J");
#line 1032 "test-new/asems412.imp"
if (J == _final) goto L_00B3;
#line 1032 "test-new/asems412.imp"
_control += _increment;
J += _increment;
// 1033 MASK = MASK<<1
#line 1033 "test-new/asems412.imp"
MASK = MASK << 1;
// 1034 %IF N&MASK # 0 %START
#line 1034 "test-new/asems412.imp"
if (N & MASK == 0) goto L_00B4;
// 1035 R = REG(J)
#line 1035 "test-new/asems412.imp"
R = REG[J - 1];
// 1036 HAZARD(R); FORGET(R)
#line 1036 "test-new/asems412.imp"
HAZARD(R);
#line 1036 "test-new/asems412.imp"
FORGET(R);
// 1037 %FINISH
#line 1037 "test-new/asems412.imp"
L_00B4:;
// 1038 %REPEAT
#line 1038 "test-new/asems412.imp"
goto L_00B2;
#line 1038 "test-new/asems412.imp"
}
#line 1038 "test-new/asems412.imp"
L_00B3:;
// 1039 HAZARD(LINK); FORGET(LINK)
#line 1039 "test-new/asems412.imp"
HAZARD(12);
#line 1039 "test-new/asems412.imp"
FORGET(12);
// 1040 DEFINE REFERENCE(N&255, P REF)
#line 1040 "test-new/asems412.imp"
DEFINEREFERENCE(N & 255, 5);
// 1041 RI2(BAL, LINK, CODE, N&255)
#line 1041 "test-new/asems412.imp"
RI2(16640, 12, 44, N & 255);
// 1042 %END
#line 1042 "test-new/asems412.imp"
return;
#line 1042 "test-new/asems412.imp"
} /* end of PERM */
// 1043 %ROUTINE SET DIAG(%INTEGER BASE, DISP, TYPE, FORM)
#line 1043 "test-new/asems412.imp"
void SETDIAG(int BASE, int DISP, int TYPE, int FORM) {
// 1044 !! PROC<1><1>LEVEL<3>NAME<1>BASE<3>TYPE<3>DISP<20>
// 1045 %INTEGER V1, V2, P, MARK
#line 1045 "test-new/asems412.imp"
int V1;
#line 1045 "test-new/asems412.imp"
int V2;
#line 1045 "test-new/asems412.imp"
int P;
#line 1045 "test-new/asems412.imp"
int MARK;
// 1046 %ROUTINE FILL(%INTEGERNAME V)
#line 1046 "test-new/asems412.imp"
void FILL(int *V) {
// 1047 %INTEGER SHIFT
#line 1047 "test-new/asems412.imp"
int SHIFT;
// 1048 SHIFT = 0; V = 0
#line 1048 "test-new/asems412.imp"
SHIFT = 0;
#line 1048 "test-new/asems412.imp"
*V = 0;
// 1049 %CYCLE
#line 1049 "test-new/asems412.imp"
L_00B5:;
// 1050 %RETURN %IF P = VP %OR SHIFT = 30
#line 1050 "test-new/asems412.imp"
if (P == VP) goto L_003A;
#line 1050 "test-new/asems412.imp"
if (SHIFT != 30) goto L_00B6;
#line 1050 "test-new/asems412.imp"
L_003A:;
#line 1050 "test-new/asems412.imp"
return;
#line 1050 "test-new/asems412.imp"
L_00B6:;
// 1051 P = P+1
#line 1051 "test-new/asems412.imp"
P = P + 1;
// 1052 V = V+(VBUF(P)-32)<<SHIFT
#line 1052 "test-new/asems412.imp"
*V = *V + (VBUF[P - 1] - 32 << SHIFT);
// 1053 SHIFT = SHIFT+6
#line 1053 "test-new/asems412.imp"
SHIFT = SHIFT + 6;
// 1054 %REPEAT
#line 1054 "test-new/asems412.imp"
goto L_00B5;
// 1055 %END
#line 1055 "test-new/asems412.imp"
} /* end of FILL */
// 1056 P = 0; MARK = 0
#line 1056 "test-new/asems412.imp"
P = 0;
#line 1056 "test-new/asems412.imp"
MARK = 0;
// 1057 FILL(V1); FILL(V2)
#line 1057 "test-new/asems412.imp"
FILL(/*?*/ &V1);
#line 1057 "test-new/asems412.imp"
FILL(/*?*/ &V2);
// 1058 %IF FORM = 0 %START; ! NON-VARIABLE
#line 1058 "test-new/asems412.imp"
if (FORM != 0) goto L_00B7;
// 1059 PRINT SYMBOL(DLINE)
#line 1059 "test-new/asems412.imp"
_imp_PRINTSYMBOL(10);
// 1060 MARK = 16; FORM = 1
#line 1060 "test-new/asems412.imp"
MARK = 16;
#line 1060 "test-new/asems412.imp"
FORM = 1;
// 1061 %IF BASE = 0 %START; ! %BEGIN
#line 1061 "test-new/asems412.imp"
if (BASE != 0) goto L_00B8;
// 1062 V2 = 0; V1 = BLOCK WORD;! 'BLOCK'
#line 1062 "test-new/asems412.imp"
V2 = 0;
#line 1062 "test-new/asems412.imp"
V1 = BLOCKWORD;
// 1063 %FINISH
#line 1063 "test-new/asems412.imp"
L_00B8:;
// 1064 %FINISH
#line 1064 "test-new/asems412.imp"
L_00B7:;
// 1065 BASE = ACTUAL(BASE)
#line 1065 "test-new/asems412.imp"
BASE = ACTUAL[BASE];
// 1066 BASE = BASE-8 %IF BASE >= 8
#line 1066 "test-new/asems412.imp"
if (BASE < 8) goto L_00B9;
#line 1066 "test-new/asems412.imp"
BASE = BASE - 8;
#line 1066 "test-new/asems412.imp"
L_00B9:;
// 1067 PRINTSYMBOL(DIAGS)
#line 1067 "test-new/asems412.imp"
_imp_PRINTSYMBOL(11);
// 1068 %IF FORM = -1 %START; ! END OF BLOCK
#line 1068 "test-new/asems412.imp"
if (FORM != -1) goto L_00BA;
// 1069 PUT(-1); PUT(-1); DA = DA+4; %RETURN
#line 1069 "test-new/asems412.imp"
PUT(-1);
#line 1069 "test-new/asems412.imp"
PUT(-1);
#line 1069 "test-new/asems412.imp"
DA = DA + 4;
#line 1069 "test-new/asems412.imp"
return;
// 1070 %FINISH
#line 1070 "test-new/asems412.imp"
L_00BA:;
// 1071 PUT(((((MARK+XLEVEL)<<1+FORM-1)<<3+BASE)<<3+TYPE)<<4)
#line 1071 "test-new/asems412.imp"
PUT((((MARK + XLEVEL << 1) + FORM - 1 << 3) + BASE << 3) + TYPE << 4);
// 1072 PUT(DISP)
#line 1072 "test-new/asems412.imp"
PUT(DISP);
// 1073 PUT(V1>>16); PUT(V1&X'FFFF')
#line 1073 "test-new/asems412.imp"
PUT((unsigned int)V1 >> 16);
#line 1073 "test-new/asems412.imp"
PUT(V1 & 65535);
// 1074 PUT(V2>>16); PUT(V2&X'FFFF')
#line 1074 "test-new/asems412.imp"
PUT((unsigned int)V2 >> 16);
#line 1074 "test-new/asems412.imp"
PUT(V2 & 65535);
// 1075 DA = DA+12
#line 1075 "test-new/asems412.imp"
DA = DA + 12;
// 1076 %END
#line 1076 "test-new/asems412.imp"
return;
#line 1076 "test-new/asems412.imp"
} /* end of SETDIAG */
// 1077 %ROUTINE ASSEMBLE(%SHORTINTEGER AMODE, LABS, NAMES)
#line 1077 "test-new/asems412.imp"
void ASSEMBLE(short int AMODE, short int LABS, short int NAMES) {
// 1078 %OWNINTEGER ASS LEVEL = 0
#line 1078 "test-new/asems412.imp"
static int ASSLEVEL = 0;
// 1079 %SWITCH Z(33:126)
#line 1079 "test-new/asems412.imp"
int Z_index;
#line 1079 "test-new/asems412.imp"
int Z_line;
#line 1079 "test-new/asems412.imp"
char *Z_file;
#line 1079 "test-new/asems412.imp"
static const void *Z[94] = {
&&case_Z_33, &&case_Z_34, &&case_Z_35, &&case_Z_36, &&case_Z_37, &&case_Z_38,
&&case_Z_39, &&case_Z_40, &&case_Z_41, &&case_Z_42, &&case_Z_43, &&case_Z_missing,
&&case_Z_45, &&case_Z_46, &&case_Z_47, &&case_Z_missing, &&case_Z_missing, &&case_Z_missing,
&&case_Z_missing, &&case_Z_missing, &&case_Z_missing, &&case_Z_missing, &&case_Z_missing, &&case_Z_missing,
&&case_Z_missing, &&case_Z_58, &&case_Z_59, &&case_Z_60, &&case_Z_61, &&case_Z_62,
&&case_Z_63, &&case_Z_64, &&case_Z_65, &&case_Z_66, &&case_Z_67, &&case_Z_68,
&&case_Z_69, &&case_Z_70, &&case_Z_71, &&case_Z_72, &&case_Z_73, &&case_Z_74,
&&case_Z_75, &&case_Z_76, &&case_Z_77, &&case_Z_78, &&case_Z_79, &&case_Z_80,
&&case_Z_81, &&case_Z_82, &&case_Z_83, &&case_Z_84, &&case_Z_85, &&case_Z_86,
&&case_Z_87, &&case_Z_88, &&case_Z_missing, &&case_Z_90, &&case_Z_91, &&case_Z_92,
&&case_Z_93, &&case_Z_missing, &&case_Z_95, &&case_Z_missing, &&case_Z_97, &&case_Z_98,
&&case_Z_99, &&case_Z_100, &&case_Z_101, &&case_Z_102, &&case_Z_missing, &&case_Z_104,
&&case_Z_missing, &&case_Z_missing, &&case_Z_107, &&case_Z_missing, &&case_Z_missing, &&case_Z_missing,
&&case_Z_missing, &&case_Z_112, &&case_Z_113, &&case_Z_missing, &&case_Z_115, &&case_Z_116,
&&case_Z_117, &&case_Z_118, &&case_Z_119, &&case_Z_120, &&case_Z_missing, &&case_Z_122,
&&case_Z_missing, &&case_Z_missing, &&case_Z_missing, &&case_Z_126};
// 1080 %RECORD(VARFM)%NAME V, GVAR, FP, AP
#line 1080 "test-new/asems412.imp"
struct VARFM *V;
#line 1080 "test-new/asems412.imp"
struct VARFM *GVAR;
#line 1080 "test-new/asems412.imp"
struct VARFM *FP;
#line 1080 "test-new/asems412.imp"
struct VARFM *AP;
// 1081 %RECORD(STACKFM)%NAME LHS, RHS, X
#line 1081 "test-new/asems412.imp"
struct STACKFM *LHS;
#line 1081 "test-new/asems412.imp"
struct STACKFM *RHS;
#line 1081 "test-new/asems412.imp"
struct STACKFM *X;
// 1082 %INTEGER SYM; ! CURRENT CODE ITEM
#line 1082 "test-new/asems412.imp"
int SYM;
// 1083 %INTEGER VLB, VUB
#line 1083 "test-new/asems412.imp"
int VLB;
#line 1083 "test-new/asems412.imp"
int VUB;
// 1084 %INTEGER DATA SIZE, OLD FRAME, GSTART, WDISP, NEW DISP, SDISP
#line 1084 "test-new/asems412.imp"
int DATASIZE;
#line 1084 "test-new/asems412.imp"
int OLDFRAME;
#line 1084 "test-new/asems412.imp"
int GSTART;
#line 1084 "test-new/asems412.imp"
int WDISP;
#line 1084 "test-new/asems412.imp"
int NEWDISP;
#line 1084 "test-new/asems412.imp"
int SDISP;
// 1085 %INTEGER OPR, N
#line 1085 "test-new/asems412.imp"
int OPR;
#line 1085 "test-new/asems412.imp"
int N;
// 1086 %INTEGER SIZE PATCH, WARNING
#line 1086 "test-new/asems412.imp"
int SIZEPATCH;
#line 1086 "test-new/asems412.imp"
int WARNING;
// 1087 %OWNINTEGER GG = 0
#line 1087 "test-new/asems412.imp"
static int GG = 0;
// 1088 %INTEGER J,K, LEN, VAL, APARM, SPS
#line 1088 "test-new/asems412.imp"
int J;
#line 1088 "test-new/asems412.imp"
int K;
#line 1088 "test-new/asems412.imp"
int LEN;
#line 1088 "test-new/asems412.imp"
int VAL;
#line 1088 "test-new/asems412.imp"
int APARM;
#line 1088 "test-new/asems412.imp"
int SPS;
// 1089 %INTEGER LABEL START;! FIRST LABEL FOR THIS LEVEL
#line 1089 "test-new/asems412.imp"
int LABELSTART;
// 1090 %INTEGER RT LAB; ! ROUTINE JUMP ADDRESS
#line 1090 "test-new/asems412.imp"
int RTLAB;
// 1091
// 1092 %CONSTBYTEINTEGERARRAY COMM(1:17)= 0, 0, 1, 0, 1, 1, 0,
#line 1092 "test-new/asems412.imp"
const unsigned char COMM[17] = {0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0};
#line 1092 "test-new/asems412.imp"
auto void AMAP(struct STACKFM * V);
#line 1092 "test-new/asems412.imp"
auto void LOAD(struct STACKFM * V, int R);
#line 1092 "test-new/asems412.imp"
auto int NEWTAG(void);
#line 1092 "test-new/asems412.imp"
auto void JOIN(struct STACKFM * W);
#line 1092 "test-new/asems412.imp"
auto void OPERATE(int OPER);
#line 1092 "test-new/asems412.imp"
auto void COMPARE(struct STACKFM * L, struct STACKFM * R);
#line 1092 "test-new/asems412.imp"
auto void HEADER(struct VARFM * V);
// 1093+ 1, 1, 1, 0, 0, 0, 0, 1, 0, 0
// 1094
// 1095 %ROUTINESPEC AMAP(%RECORD(STACKFM)%NAME V)
// 1096 %ROUTINESPEC LOAD(%RECORD(STACKFM)%NAME V, %INTEGER REG)
// 1097 %INTEGERFNSPEC NEW TAG
// 1098 %ROUTINESPEC JOIN(%RECORD(STACKFM)%NAME W)
// 1099 %ROUTINESPEC OPERATE(%INTEGER N)
// 1100 %ROUTINESPEC COMPARE(%RECORD(STACKFM)%NAME L, R)
// 1101 %ROUTINESPEC HEADER(%RECORD(VARFM)%NAME V)
// 1102
// 1103 ABORT(-1) %IF FREE SPACE < MIN FREE; ! ...STACK OVERFLOW?
#line 1103 "test-new/asems412.imp"
if (FREESPACE >= 600) goto L_00BB;
#line 1103 "test-new/asems412.imp"
ABORT(-1);
#line 1103 "test-new/asems412.imp"
L_00BB:;
// 1104
// 1105 XLEVEL = XLEVEL+1
#line 1105 "test-new/asems412.imp"
XLEVEL = XLEVEL + 1;
// 1106 RT LAB = 0; LABEL START = LABS; OLD FRAME = FRAME
#line 1106 "test-new/asems412.imp"
RTLAB = 0;
#line 1106 "test-new/asems412.imp"
LABELSTART = LABS;
#line 1106 "test-new/asems412.imp"
OLDFRAME = FRAME;
// 1107 WDISP = 0; WARNING = 0
#line 1107 "test-new/asems412.imp"
WDISP = 0;
#line 1107 "test-new/asems412.imp"
WARNING = 0;
// 1108 GVAR == DECVAR; GSTART = NAMES
#line 1108 "test-new/asems412.imp"
GVAR = (struct VARFM *)DECVAR;
#line 1108 "test-new/asems412.imp"
GSTART = NAMES;
// 1109 %IF AMODE > 0 %START
#line 1109 "test-new/asems412.imp"
if (AMODE <= 0) goto L_00BC;
// 1110 %IF AMODE = 1 %THEN FRAME = REGLEN %ELSE FRAME = 11*REGLEN
#line 1110 "test-new/asems412.imp"
if (AMODE != 1) goto L_00BD;
#line 1110 "test-new/asems412.imp"
FRAME = 4;
#line 1110 "test-new/asems412.imp"
goto L_00BE;
#line 1110 "test-new/asems412.imp"
L_00BD:;
#line 1110 "test-new/asems412.imp"
FRAME = 11 * 4;
#line 1110 "test-new/asems412.imp"
L_00BE:;
// 1111 ABORT(-3) %IF ASS LEVEL = 5
#line 1111 "test-new/asems412.imp"
if (ASSLEVEL != 5) goto L_00BF;
#line 1111 "test-new/asems412.imp"
ABORT(-3);
#line 1111 "test-new/asems412.imp"
L_00BF:;
// 1112 ASS LEVEL = ASS LEVEL+1; LOCAL = BASE REG(ASS LEVEL)
#line 1112 "test-new/asems412.imp"
ASSLEVEL = ASSLEVEL + 1;
#line 1112 "test-new/asems412.imp"
LOCAL = BASEREG[ASSLEVEL];
// 1113 ACTIVITY(LOCAL) = -1
#line 1113 "test-new/asems412.imp"
ACTIVITY[LOCAL] = -1;
// 1114 %IF AMODE = 2 %START
#line 1114 "test-new/asems412.imp"
if (AMODE != 2) goto L_00C0;
// 1115 SET DIAG(R15, 0, 0, 0)
#line 1115 "test-new/asems412.imp"
SETDIAG(41, 0, 0, 0);
// 1116 %FINISH
#line 1116 "test-new/asems412.imp"
L_00C0:;
// 1117 %IF OTYPE = PERMRT %START
#line 1117 "test-new/asems412.imp"
if (OTYPE != 7) goto L_00C1;
// 1118 PERMS = PERMS-1; GVAR_DISP = PERMS
#line 1118 "test-new/asems412.imp"
PERMS = PERMS - 1;
#line 1118 "test-new/asems412.imp"
GVAR->DISP = PERMS;
// 1119 %FINISH
#line 1119 "test-new/asems412.imp"
L_00C1:;
// 1120 SET DIAG(LOCAL, 0, 0, 0) %IF GG = PROCEDURE
#line 1120 "test-new/asems412.imp"
if (GG != 49) goto L_00C2;
#line 1120 "test-new/asems412.imp"
SETDIAG(LOCAL, 0, 0, 0);
#line 1120 "test-new/asems412.imp"
L_00C2:;
// 1121 %ELSE %IF AMODE < 0
#line 1121 "test-new/asems412.imp"
goto L_00C3;
#line 1121 "test-new/asems412.imp"
L_00BC:;
#line 1121 "test-new/asems412.imp"
if (AMODE >= 0) goto L_00C4;
// 1122 FRAME = 0
#line 1122 "test-new/asems412.imp"
FRAME = 0;
// 1123 %ELSE
#line 1123 "test-new/asems412.imp"
goto L_00C3;
#line 1123 "test-new/asems412.imp"
L_00C4:;
// 1124 SET DIAG(0, 0, 0 ,0); ! BLOCK
#line 1124 "test-new/asems412.imp"
SETDIAG(0, 0, 0, 0);
// 1125 %FINISH
#line 1125 "test-new/asems412.imp"
L_00C3:;
// 1126
// 1127 ! DESCRIPTOR PROCESSING
// 1128
// 1129 %INTEGERFN LOOKUP(%INTEGER NAME)
#line 1129 "test-new/asems412.imp"
int LOOKUP(int NAME) {
// 1130 %INTEGER P, P1, P2
#line 1130 "test-new/asems412.imp"
int P;
#line 1130 "test-new/asems412.imp"
int P1;
#line 1130 "test-new/asems412.imp"
int P2;
// 1131 %RECORD(VARFM)%NAME V
#line 1131 "test-new/asems412.imp"
struct VARFM *V;
// 1132 P1 = 1; P2 = NAMES
#line 1132 "test-new/asems412.imp"
P1 = 1;
#line 1132 "test-new/asems412.imp"
P2 = NAMES;
// 1133 %WHILE P2 >= P1 %CYCLE
#line 1133 "test-new/asems412.imp"
L_00C5:;
#line 1133 "test-new/asems412.imp"
if (P2 < P1) goto L_00C6;
// 1134 P = (P1+P2)>>1
#line 1134 "test-new/asems412.imp"
P = (unsigned int)P1 + P2 >> 1;
// 1135 V == VAR(P)
#line 1135 "test-new/asems412.imp"
V = (struct VARFM *)/*?*/ &VAR[P - 1];
// 1136 %RESULT = P %IF V_ID = NAME
#line 1136 "test-new/asems412.imp"
if (V->ID != NAME) goto L_00C7;
#line 1136 "test-new/asems412.imp"
return P;
#line 1136 "test-new/asems412.imp"
L_00C7:;
// 1137 %IF V_ID > NAME %THEN P2 = P-1 %ELSE P1 = P+1
#line 1137 "test-new/asems412.imp"
if (V->ID <= NAME) goto L_00C8;
#line 1137 "test-new/asems412.imp"
P2 = P - 1;
#line 1137 "test-new/asems412.imp"
goto L_00C9;
#line 1137 "test-new/asems412.imp"
L_00C8:;
#line 1137 "test-new/asems412.imp"
P1 = P + 1;
#line 1137 "test-new/asems412.imp"
L_00C9:;
// 1138 %REPEAT
#line 1138 "test-new/asems412.imp"
goto L_00C5;
#line 1138 "test-new/asems412.imp"
L_00C6:;
// 1139 ABORT(6)
#line 1139 "test-new/asems412.imp"
ABORT(6);
// 1140 %STOP
#line 1140 "test-new/asems412.imp"
_imp_stop(0);
// 1141 %END
#line 1141 "test-new/asems412.imp"
} /* end of LOOKUP */
// 1142 %ROUTINE DEFINE VAR
#line 1142 "test-new/asems412.imp"
void DEFINEVAR(void) {
// 1143 %CONSTBYTEINTEGERARRAY VSIZE(0:7) = 0, 4, 1, 2, 0, 4, 4, 0
#line 1143 "test-new/asems412.imp"
const unsigned char VSIZE[8] = {0, 4, 1, 2, 0, 4, 4, 0};
// 1144 %CONSTBYTEINTEGERARRAY ROUND(0:7) = 3,3,0,1,1,3,3,3
#line 1144 "test-new/asems412.imp"
const unsigned char ROUND[8] = {3, 3, 0, 1, 1, 3, 3, 3};
// 1145 %INTEGER TYPE, FORM, TF, F, SIZE, FORMAT, S
#line 1145 "test-new/asems412.imp"
int TYPE;
#line 1145 "test-new/asems412.imp"
int FORM;
#line 1145 "test-new/asems412.imp"
int TF;
#line 1145 "test-new/asems412.imp"
int F;
#line 1145 "test-new/asems412.imp"
int SIZE;
#line 1145 "test-new/asems412.imp"
int FORMAT;
#line 1145 "test-new/asems412.imp"
int S;
// 1146 %OWNINTEGER PERM NO = -1
#line 1146 "test-new/asems412.imp"
static int PERMNO = -1;
// 1147
// 1148 NAMES = NAMES+1; ABORT(-4) %IF NAMES >= PARMS
#line 1148 "test-new/asems412.imp"
NAMES = NAMES + 1;
#line 1148 "test-new/asems412.imp"
if (NAMES < PARMS) goto L_00CA;
#line 1148 "test-new/asems412.imp"
ABORT(-4);
#line 1148 "test-new/asems412.imp"
L_00CA:;
// 1149 DECVAR == VAR(NAMES); DECVAR = 0
#line 1149 "test-new/asems412.imp"
DECVAR = (struct VARFM *)/*?*/ &VAR[NAMES - 1];
#line 1149 "test-new/asems412.imp"
*DECVAR = (struct VARFM){0};
// 1150 DECVAR_ID = TAG
#line 1150 "test-new/asems412.imp"
DECVAR->ID = TAG();
// 1151 VP = 0
#line 1151 "test-new/asems412.imp"
VP = 0;
// 1152 %CYCLE
#line 1152 "test-new/asems412.imp"
L_00CB:;
// 1153 READSYMBOL(S); %EXIT %IF S = COMMA
#line 1153 "test-new/asems412.imp"
_imp_READSYMBOL(/*?*/ &S);
#line 1153 "test-new/asems412.imp"
if (S != 44) goto L_00CC;
#line 1153 "test-new/asems412.imp"
goto L_00CD;
#line 1153 "test-new/asems412.imp"
L_00CC:;
// 1154 %IF VP # 10 %START
#line 1154 "test-new/asems412.imp"
if (VP == 10) goto L_00CE;
// 1155 VP = VP+1; VBUF(VP) = S
#line 1155 "test-new/asems412.imp"
VP = VP + 1;
#line 1155 "test-new/asems412.imp"
VBUF[VP - 1] = S;
// 1156 %FINISH
#line 1156 "test-new/asems412.imp"
L_00CE:;
// 1157 %REPEAT
#line 1157 "test-new/asems412.imp"
goto L_00CB;
#line 1157 "test-new/asems412.imp"
L_00CD:;
// 1158
// 1159 TF = TAG; TYPE = TF>>4; FORM = TF&15; SKIPSYMBOL
#line 1159 "test-new/asems412.imp"
TF = TAG();
#line 1159 "test-new/asems412.imp"
TYPE = (unsigned int)TF >> 4;
#line 1159 "test-new/asems412.imp"
FORM = TF & 15;
#line 1159 "test-new/asems412.imp"
_imp_SKIPSYMBOL();
// 1160 %IF TYPE = LONG %START
#line 1160 "test-new/asems412.imp"
if (TYPE != 7) goto L_00CF;
// 1161 TYPE = REALS
#line 1161 "test-new/asems412.imp"
TYPE = 6;
// 1162 %FINISH
#line 1162 "test-new/asems412.imp"
L_00CF:;
// 1163 SIZE = TAG
#line 1163 "test-new/asems412.imp"
SIZE = TAG();
// 1164 DECVAR_TYPE = TYPE
#line 1164 "test-new/asems412.imp"
DECVAR->TYPE = TYPE;
// 1165 DECVAR_FORM = FORM
#line 1165 "test-new/asems412.imp"
DECVAR->FORM = FORM;
// 1166 SKIPSYMBOL
#line 1166 "test-new/asems412.imp"
_imp_SKIPSYMBOL();
// 1167 OTYPE = TAG
#line 1167 "test-new/asems412.imp"
OTYPE = TAG();
// 1168 %IF NEXTSYMBOL = COMMA %START
#line 1168 "test-new/asems412.imp"
if (_imp_NEXTSYMBOL() != 44) goto L_00D0;
// 1169 SKIPSYMBOL
#line 1169 "test-new/asems412.imp"
_imp_SKIPSYMBOL();
// 1170 FORMAT = TAG; F = LOOKUP(FORMAT)
#line 1170 "test-new/asems412.imp"
FORMAT = TAG();
#line 1170 "test-new/asems412.imp"
F = LOOKUP(FORMAT);
// 1171 DECVAR_FORMAT = F; SIZE = VAR(F)_LENGTH;! IN BYTES
#line 1171 "test-new/asems412.imp"
DECVAR->FORMAT = F;
#line 1171 "test-new/asems412.imp"
SIZE = VAR[F - 1].LENGTH;
// 1172 DECVAR_LENGTH = SIZE
#line 1172 "test-new/asems412.imp"
DECVAR->LENGTH = SIZE;
// 1173 %ELSE %IF TYPE = STRING
#line 1173 "test-new/asems412.imp"
goto L_00D1;
#line 1173 "test-new/asems412.imp"
L_00D0:;
#line 1173 "test-new/asems412.imp"
if (TYPE != 4) goto L_00D2;
// 1174 DECVAR_SIZE = SIZE
#line 1174 "test-new/asems412.imp"
DECVAR->SIZE = SIZE;
// 1175 SIZE = SIZE+1
#line 1175 "test-new/asems412.imp"
SIZE = SIZE + 1;
// 1176 SIZE = (SIZE+1)&(\1) %IF FORM = ARRAY
#line 1176 "test-new/asems412.imp"
if (FORM != 11) goto L_00D3;
#line 1176 "test-new/asems412.imp"
SIZE = SIZE + 1 & (~1);
#line 1176 "test-new/asems412.imp"
L_00D3:;
// 1177 %ELSE
#line 1177 "test-new/asems412.imp"
goto L_00D1;
#line 1177 "test-new/asems412.imp"
L_00D2:;
// 1178 SIZE = VSIZE(TYPE)
#line 1178 "test-new/asems412.imp"
SIZE = VSIZE[TYPE];
// 1179 %FINISH
#line 1179 "test-new/asems412.imp"
L_00D1:;
// 1180 %IF 7 <= FORM <= 10 %START;! PROCEDURE
#line 1180 "test-new/asems412.imp"
{
// Double-sided test on FORM (Part I)
#line 1180 "test-new/asems412.imp"
int tmp;
#line 1180 "test-new/asems412.imp"
if (7 > (tmp = FORM)) goto L_00D4;
// Double-sided test on FORM (Part II)
#line 1180 "test-new/asems412.imp"
if (tmp > 10) goto L_00D4;
#line 1180 "test-new/asems412.imp"
}
// 1181 GTYPE = 1
#line 1181 "test-new/asems412.imp"
GTYPE = 1;
// 1182 F = LOOKUP(DECVAR_ID)
#line 1182 "test-new/asems412.imp"
F = LOOKUP(DECVAR->ID);
// 1183 %IF F # NAMES %START;! SPEC GIVEN
#line 1183 "test-new/asems412.imp"
if (F == NAMES) goto L_00D5;
// 1184 NAMES = NAMES-1; DECVAR == VAR(F); %RETURN
#line 1184 "test-new/asems412.imp"
NAMES = NAMES - 1;
#line 1184 "test-new/asems412.imp"
DECVAR = (struct VARFM *)/*?*/ &VAR[F - 1];
#line 1184 "test-new/asems412.imp"
return;
// 1185 %FINISH
#line 1185 "test-new/asems412.imp"
L_00D5:;
// 1186 %IF OTYPE # 0 %AND OTYPE # 7 %START;! TREAT AS INTRINSIC
#line 1186 "test-new/asems412.imp"
if (OTYPE == 0) goto L_00D6;
#line 1186 "test-new/asems412.imp"
if (OTYPE == 7) goto L_00D6;
// 1187 PERMNO = PERMNO+1
#line 1187 "test-new/asems412.imp"
PERMNO = PERMNO + 1;
// 1188 DECVAR_DISP = PERMNO; DECVAR_BASE = LINK
#line 1188 "test-new/asems412.imp"
DECVAR->DISP = PERMNO;
#line 1188 "test-new/asems412.imp"
DECVAR->BASE = 12;
// 1189 %RETURN
#line 1189 "test-new/asems412.imp"
return;
// 1190 %FINISH
#line 1190 "test-new/asems412.imp"
L_00D6:;
// 1191 DECVAR_DISP = NEW TAG!X'4000'
#line 1191 "test-new/asems412.imp"
DECVAR->DISP = NEWTAG() | 16384;
// 1192 DECVAR_BASE = CODE
#line 1192 "test-new/asems412.imp"
DECVAR->BASE = 44;
// 1193 DECVAR_TYPE=INTEGER %IF FORM=8 %AND (TYPE=BYTE %OR TYPE=SHORT)
#line 1193 "test-new/asems412.imp"
if (FORM != 8) goto L_00D7;
#line 1193 "test-new/asems412.imp"
if (TYPE == 2) goto L_00D8;
#line 1193 "test-new/asems412.imp"
if (TYPE != 3) goto L_00D7;
#line 1193 "test-new/asems412.imp"
L_00D8:;
#line 1193 "test-new/asems412.imp"
DECVAR->TYPE = 1;
#line 1193 "test-new/asems412.imp"
L_00D7:;
// 1194 %RETURN %UNLESS AMODE = 1 %AND GMODE # 0;! PARAMETER
#line 1194 "test-new/asems412.imp"
if (AMODE != 1) goto L_00D9;
#line 1194 "test-new/asems412.imp"
if (GMODE != 0) goto L_00DA;
#line 1194 "test-new/asems412.imp"
L_00D9:;
#line 1194 "test-new/asems412.imp"
return;
#line 1194 "test-new/asems412.imp"
L_00DA:;
// 1195 OTYPE = 0; TYPE = 0; FORM = 1; SIZE = 2*REGLEN
#line 1195 "test-new/asems412.imp"
OTYPE = 0;
#line 1195 "test-new/asems412.imp"
TYPE = 0;
#line 1195 "test-new/asems412.imp"
FORM = 1;
#line 1195 "test-new/asems412.imp"
SIZE = 2 * 4;
// 1196 %FINISH
#line 1196 "test-new/asems412.imp"
L_00D4:;
// 1197
// 1198 DATA SIZE = SIZE
#line 1198 "test-new/asems412.imp"
DATASIZE = SIZE;
// 1199 DECVAR_LENGTH = DATA SIZE
#line 1199 "test-new/asems412.imp"
DECVAR->LENGTH = DATASIZE;
// 1200
// 1201 %IF FORM # 1 %START
#line 1201 "test-new/asems412.imp"
if (FORM == 1) goto L_00DB;
// 1202 %IF TYPE = 0 %START
#line 1202 "test-new/asems412.imp"
if (TYPE != 0) goto L_00DC;
// 1203 TYPE = 10; SIZE = 2*REGLEN; DECVAR_TYPE = 10
#line 1203 "test-new/asems412.imp"
TYPE = 10;
#line 1203 "test-new/asems412.imp"
SIZE = 2 * 4;
#line 1203 "test-new/asems412.imp"
DECVAR->TYPE = 10;
// 1204 %ELSE %IF FORM = ARRAYNAME
#line 1204 "test-new/asems412.imp"
goto L_00DD;
#line 1204 "test-new/asems412.imp"
L_00DC:;
#line 1204 "test-new/asems412.imp"
if (FORM != 12) goto L_00DE;
// 1205 SIZE = 2*REGLEN; DECVAR_EXTRA = -1
#line 1205 "test-new/asems412.imp"
SIZE = 2 * 4;
#line 1205 "test-new/asems412.imp"
DECVAR->EXTRA = -1;
// 1206 %ELSE %IF FORM = ARRAY
#line 1206 "test-new/asems412.imp"
goto L_00DD;
#line 1206 "test-new/asems412.imp"
L_00DE:;
#line 1206 "test-new/asems412.imp"
if (FORM != 11) goto L_00DF;
// 1207 SIZE = 0
#line 1207 "test-new/asems412.imp"
SIZE = 0;
// 1208 %ELSE
#line 1208 "test-new/asems412.imp"
goto L_00DD;
#line 1208 "test-new/asems412.imp"
L_00DF:;
// 1209 SIZE = REGLEN
#line 1209 "test-new/asems412.imp"
SIZE = 4;
// 1210 %FINISH
#line 1210 "test-new/asems412.imp"
L_00DD:;
// 1211 %FINISH
#line 1211 "test-new/asems412.imp"
L_00DB:;
// 1212 %IF OTYPE # 0 %START;! OWN DATA
#line 1212 "test-new/asems412.imp"
if (OTYPE == 0) goto L_00E0;
// 1213 %IF OTYPE = CON %START;! CONSTINTEGER ETC.
#line 1213 "test-new/asems412.imp"
if (OTYPE != 2) goto L_00E1;
// 1214 DATA SIZE = 0 %IF TF = X'41';! CONSTSTRING
#line 1214 "test-new/asems412.imp"
if (TF != 65) goto L_00E2;
#line 1214 "test-new/asems412.imp"
DATASIZE = 0;
#line 1214 "test-new/asems412.imp"
L_00E2:;
// 1215 OTYPE = 0 %IF (TYPE<=SHORT %AND (FORM<=2 %OR FORM = 5)) %C
#line 1215 "test-new/asems412.imp"
if (TYPE > 3) goto L_00E3;
#line 1215 "test-new/asems412.imp"
if (FORM <= 2) goto L_00E4;
#line 1215 "test-new/asems412.imp"
if (FORM == 5) goto L_00E4;
#line 1215 "test-new/asems412.imp"
L_00E3:;
#line 1215 "test-new/asems412.imp"
if (TF == 82) goto L_00E4;
#line 1215 "test-new/asems412.imp"
if (FORM != 12) goto L_00E5;
#line 1215 "test-new/asems412.imp"
L_00E4:;
#line 1215 "test-new/asems412.imp"
OTYPE = 0;
#line 1215 "test-new/asems412.imp"
L_00E5:;
// 1216+ %OR TF = X'52' %OR FORM = ARRAYNAME
// 1217 %FINISH
#line 1217 "test-new/asems412.imp"
L_00E1:;
// 1218 OWNTYPE = TYPE; OWNFORM = FORM
#line 1218 "test-new/asems412.imp"
OWNTYPE = TYPE;
#line 1218 "test-new/asems412.imp"
OWNFORM = FORM;
// 1219 %IF FORM = ARRAY %START
#line 1219 "test-new/asems412.imp"
if (FORM != 11) goto L_00E6;
// 1220 GFIX(4)
#line 1220 "test-new/asems412.imp"
GFIX(4);
// 1221 DECVAR_EXTRA=GA; GWORD(VLB); GWORD(VUB); GWORD(DATASIZE)
#line 1221 "test-new/asems412.imp"
DECVAR->EXTRA = GA;
#line 1221 "test-new/asems412.imp"
GWORD(VLB);
#line 1221 "test-new/asems412.imp"
GWORD(VUB);
#line 1221 "test-new/asems412.imp"
GWORD(DATASIZE);
// 1222 DECVAR_BASE = GLA; DECVAR_DISP = GA-VLB*DATASIZE
#line 1222 "test-new/asems412.imp"
DECVAR->BASE = 42;
#line 1222 "test-new/asems412.imp"
DECVAR->DISP = GA - VLB * DATASIZE;
// 1223 %ELSE
#line 1223 "test-new/asems412.imp"
goto L_00E7;
#line 1223 "test-new/asems412.imp"
L_00E6:;
// 1224 OWNTYPE = INTEGER %AND DATA SIZE = REGLEN %IF FORM # 1
#line 1224 "test-new/asems412.imp"
if (FORM == 1) goto L_00E8;
#line 1224 "test-new/asems412.imp"
OWNTYPE = 1;
#line 1224 "test-new/asems412.imp"
DATASIZE = 4;
#line 1224 "test-new/asems412.imp"
L_00E8:;
// 1225 %IF OTYPE # 0 %START
#line 1225 "test-new/asems412.imp"
if (OTYPE == 0) goto L_00E9;
// 1226 %IF TF # X'21' %START
#line 1226 "test-new/asems412.imp"
if (TF == 33) goto L_00EA;
// 1227 %IF TF = X'31' %OR TF = X'41' %THEN GFIX(2) %C
#line 1227 "test-new/asems412.imp"
if (TF == 49) goto L_00EB;
#line 1227 "test-new/asems412.imp"
if (TF != 65) goto L_00EC;
#line 1227 "test-new/asems412.imp"
L_00EB:;
#line 1227 "test-new/asems412.imp"
GFIX(2);
#line 1227 "test-new/asems412.imp"
goto L_00ED;
#line 1227 "test-new/asems412.imp"
L_00EC:;
#line 1227 "test-new/asems412.imp"
GFIX(4);
#line 1227 "test-new/asems412.imp"
L_00ED:;
// 1228+ %ELSE GFIX(4)
// 1229 %FINISH
#line 1229 "test-new/asems412.imp"
L_00EA:;
// 1230 %IF OWNFORM <= 2 %AND TYPE # RECORD %START
#line 1230 "test-new/asems412.imp"
if (OWNFORM > 2) goto L_00EE;
#line 1230 "test-new/asems412.imp"
if (TYPE == 5) goto L_00EE;
// 1231 SET DIAG(GLA, GA+DIAG GLA, TYPE, FORM)
#line 1231 "test-new/asems412.imp"
SETDIAG(42, GA + DIAGGLA, TYPE, FORM);
// 1232 DIAG GLA = DIAG GLA+DATA SIZE
#line 1232 "test-new/asems412.imp"
DIAGGLA = DIAGGLA + DATASIZE;
// 1233 %FINISH
#line 1233 "test-new/asems412.imp"
L_00EE:;
// 1234 %FINISH
#line 1234 "test-new/asems412.imp"
L_00E9:;
// 1235 %FINISH
#line 1235 "test-new/asems412.imp"
L_00E7:;
// 1236 %RETURN
#line 1236 "test-new/asems412.imp"
return;
// 1237 %FINISH
#line 1237 "test-new/asems412.imp"
L_00E0:;
// 1238
// 1239 %IF FORM = SWITCH %START
#line 1239 "test-new/asems412.imp"
if (FORM != 6) goto L_00EF;
// 1240 GFIX(2)
#line 1240 "test-new/asems412.imp"
GFIX(2);
// 1241 DECVAR_BASE = GLA; DECVAR_DISP = GA
#line 1241 "test-new/asems412.imp"
DECVAR->BASE = 42;
#line 1241 "test-new/asems412.imp"
DECVAR->DISP = GA;
// 1242 GHALF(VLB); GHALF(VUB)
#line 1242 "test-new/asems412.imp"
GHALF(VLB);
#line 1242 "test-new/asems412.imp"
GHALF(VUB);
// 1243 DECVAR_EXTRA = GA-VLB*2
#line 1243 "test-new/asems412.imp"
DECVAR->EXTRA = GA - VLB * 2;
// 1244 GHALF(0) %FOR F = VLB, 1, VUB
#line 1244 "test-new/asems412.imp"
// %for F = VLB, 1, VUB %cycle
#line 1244 "test-new/asems412.imp"
{
int _control, _initial = VLB, _increment = 1, _final = VUB;
#line 1244 "test-new/asems412.imp"
if (((_final - _initial) % _increment) != 0) _imp_signal(5, 1, 0, "Illegal cycle F = VLB, 1, VUB");
_control = F = _initial - _increment;
#line 1244 "test-new/asems412.imp"
L_00F0:
#line 1244 "test-new/asems412.imp"
if (F != _control) _imp_signal(4, 2, 0, "Corrupt control variable F");
#line 1244 "test-new/asems412.imp"
if (F == _final) goto L_00F1;
#line 1244 "test-new/asems412.imp"
_control += _increment;
F += _increment;
#line 1244 "test-new/asems412.imp"
GHALF(0);
#line 1244 "test-new/asems412.imp"
goto L_00F0;
#line 1244 "test-new/asems412.imp"
}
#line 1244 "test-new/asems412.imp"
L_00F1:;
// 1245 %RETURN
#line 1245 "test-new/asems412.imp"
return;
// 1246 %FINISH
#line 1246 "test-new/asems412.imp"
L_00EF:;
// 1247
// 1248 %IF FORM = 4 %START
#line 1248 "test-new/asems412.imp"
if (FORM != 4) goto L_00F3;
// 1249 GTYPE = -1; %RETURN
#line 1249 "test-new/asems412.imp"
GTYPE = -1;
#line 1249 "test-new/asems412.imp"
return;
// 1250 %FINISH
#line 1250 "test-new/asems412.imp"
L_00F3:;
// 1251
// 1252 %IF FORM = 1 %THEN F = ROUND(TYPE) %ELSE F = REGLEN-1
#line 1252 "test-new/asems412.imp"
if (FORM != 1) goto L_00F4;
#line 1252 "test-new/asems412.imp"
F = ROUND[TYPE];
#line 1252 "test-new/asems412.imp"
goto L_00F5;
#line 1252 "test-new/asems412.imp"
L_00F4:;
#line 1252 "test-new/asems412.imp"
F = 4 - 1;
#line 1252 "test-new/asems412.imp"
L_00F5:;
// 1253 FRAME = (FRAME+F)&(\F)
#line 1253 "test-new/asems412.imp"
FRAME = FRAME + F & (~F);
// 1254 %IF FRAME <= REGLEN %START;! SPECIAL PARAMETER ?
#line 1254 "test-new/asems412.imp"
if (FRAME > 4) goto L_00F6;
// 1255 %IF AMODE = 1 %AND GMODE # 0 %START;! IN FP LIST
#line 1255 "test-new/asems412.imp"
if (AMODE != 1) goto L_00F7;
#line 1255 "test-new/asems412.imp"
if (GMODE == 0) goto L_00F7;
// 1256 %IF (FORM = 2 %AND TYPE # 10) %OR TF = X'11' %C
#line 1256 "test-new/asems412.imp"
if (FORM != 2) goto L_00F8;
#line 1256 "test-new/asems412.imp"
if (TYPE != 10) goto L_00F9;
#line 1256 "test-new/asems412.imp"
L_00F8:;
#line 1256 "test-new/asems412.imp"
if (TF == 17) goto L_00F9;
#line 1256 "test-new/asems412.imp"
if (TF != 49) goto L_00FA;
#line 1256 "test-new/asems412.imp"
L_00F9:;
// 1257+ %OR TF = X'31' %START;! TO A REG
// 1258 DECVAR_BASE = PARAM; DECVAR_DISP = FRAME
#line 1258 "test-new/asems412.imp"
DECVAR->BASE = 48;
#line 1258 "test-new/asems412.imp"
DECVAR->DISP = FRAME;
// 1259 DECVAR_DISP = DECVAR_DISP+(REGLEN-2) %IF TF = X'31'
#line 1259 "test-new/asems412.imp"
if (TF != 49) goto L_00FB;
#line 1259 "test-new/asems412.imp"
DECVAR->DISP = DECVAR->DISP + (4 - 2);
#line 1259 "test-new/asems412.imp"
L_00FB:;
// 1260 FRAME = FRAME-REGLEN; FRAME = 11*REGLEN %IF FRAME < 0
#line 1260 "test-new/asems412.imp"
FRAME = FRAME - 4;
#line 1260 "test-new/asems412.imp"
if (FRAME >= 0) goto L_00FC;
#line 1260 "test-new/asems412.imp"
FRAME = 11 * 4;
#line 1260 "test-new/asems412.imp"
L_00FC:;
// 1261 -> DECD; ! ...GO DUMP DIAG. ENTRY
#line 1261 "test-new/asems412.imp"
goto U_1004;
// 1262 %FINISH
#line 1262 "test-new/asems412.imp"
L_00FA:;
// 1263 %FINISH
#line 1263 "test-new/asems412.imp"
L_00F7:;
// 1264 FRAME = 11*REGLEN %IF AMODE >= 0
#line 1264 "test-new/asems412.imp"
if (AMODE < 0) goto L_00FD;
#line 1264 "test-new/asems412.imp"
FRAME = 11 * 4;
#line 1264 "test-new/asems412.imp"
L_00FD:;
// 1265 %FINISH
#line 1265 "test-new/asems412.imp"
L_00F6:;
// 1266 DECVAR_BASE = LOCAL; DECVAR_DISP = FRAME
#line 1266 "test-new/asems412.imp"
DECVAR->BASE = LOCAL;
#line 1266 "test-new/asems412.imp"
DECVAR->DISP = FRAME;
// 1267 FRAME = FRAME+SIZE
#line 1267 "test-new/asems412.imp"
FRAME = FRAME + SIZE;
// 1268 DECD: %IF AMODE = 0 %OR (AMODE = 1 %AND GG # SPEC) %START
#line 1268 "test-new/asems412.imp"
U_1004:;
#line 1268 "test-new/asems412.imp"
if (AMODE == 0) goto L_00A3;
#line 1268 "test-new/asems412.imp"
if (AMODE != 1) goto L_00FE;
#line 1268 "test-new/asems412.imp"
if (GG == 48) goto L_00FE;
#line 1268 "test-new/asems412.imp"
L_00A3:;
// 1269 %IF TYPE # RECORD %AND TYPE # 10 %START
#line 1269 "test-new/asems412.imp"
if (TYPE == 5) goto L_00FF;
#line 1269 "test-new/asems412.imp"
if (TYPE == 10) goto L_00FF;
// 1270 %IF FORM = 1 %OR FORM = 2 %START
#line 1270 "test-new/asems412.imp"
if (FORM == 1) goto L_0100;
#line 1270 "test-new/asems412.imp"
if (FORM != 2) goto L_0101;
#line 1270 "test-new/asems412.imp"
L_0100:;
// 1271 SET DIAG(LOCAL, DECVAR_DISP, TYPE, FORM)
#line 1271 "test-new/asems412.imp"
SETDIAG(LOCAL, DECVAR->DISP, TYPE, FORM);
// 1272 %FINISH
#line 1272 "test-new/asems412.imp"
L_0101:;
// 1273 %FINISH
#line 1273 "test-new/asems412.imp"
L_00FF:;
// 1274 %FINISH
#line 1274 "test-new/asems412.imp"
L_00FE:;
// 1275 %END
#line 1275 "test-new/asems412.imp"
return;
#line 1275 "test-new/asems412.imp"
} /* end of DEFINEVAR */
// 1276 %RECORD(STACKFM)%MAP DESCRIPTOR
#line 1276 "test-new/asems412.imp"
struct STACKFM *DESCRIPTOR(void)
#line 1276 "test-new/asems412.imp"
{
// 1277 %RECORD(STACKFM)%NAME V; %RECORD(DFM)%NAME D
#line 1277 "test-new/asems412.imp"
struct STACKFM *V;
#line 1277 "test-new/asems412.imp"
struct DFM *D;
// 1278 V == DESC ASL; ABORT(17) %IF V == NULL
#line 1278 "test-new/asems412.imp"
V = (struct STACKFM *)DESCASL;
#line 1278 "test-new/asems412.imp"
if (_imp_ADDR((void *)(V)) != _imp_ADDR((void *)(NULL))) goto L_0102;
#line 1278 "test-new/asems412.imp"
ABORT(17);
#line 1278 "test-new/asems412.imp"
L_0102:;
// 1279 D == DASL; ABORT(17) %IF D == NULL
#line 1279 "test-new/asems412.imp"
D = (struct DFM *)DASL;
#line 1279 "test-new/asems412.imp"
if (_imp_ADDR((void *)(D)) != _imp_ADDR((void *)(NULL))) goto L_0103;
#line 1279 "test-new/asems412.imp"
ABORT(17);
#line 1279 "test-new/asems412.imp"
L_0103:;
// 1280 DESC ASL == V_LINK; V = 0
#line 1280 "test-new/asems412.imp"
DESCASL = (struct STACKFM *)V->LINK;
#line 1280 "test-new/asems412.imp"
*V = (struct STACKFM){0};
// 1281 DASL == D_LINK; D_LINK == USING_LINK; USING_LINK == D
#line 1281 "test-new/asems412.imp"
DASL = (struct DFM *)D->LINK;
#line 1281 "test-new/asems412.imp"
D->LINK = (struct DFM *)USING.LINK;
#line 1281 "test-new/asems412.imp"
USING.LINK = (struct DFM *)D;
// 1282 D_D == V
#line 1282 "test-new/asems412.imp"
D->D = (struct DFM *)V;
// 1283 V_LINK ==NULL
#line 1283 "test-new/asems412.imp"
V->LINK = (struct STACKFM *)NULL;
// 1284 %RESULT == V
#line 1284 "test-new/asems412.imp"
return V;
// 1285 %END
#line 1285 "test-new/asems412.imp"
} /* end of DESCRIPTOR */
// 1286 %ROUTINE DROP(%RECORD(STACKFM)%NAME D)
#line 1286 "test-new/asems412.imp"
void DROP(struct STACKFM * D) {
// 1287 %RECORD(DFM)%NAME P, Q
#line 1287 "test-new/asems412.imp"
struct DFM *P;
#line 1287 "test-new/asems412.imp"
struct DFM *Q;
// 1288 P == USING
#line 1288 "test-new/asems412.imp"
P = (struct DFM *)/*?*/ &USING;
// 1289 %CYCLE
#line 1289 "test-new/asems412.imp"
L_0104:;
// 1290 Q == P_LINK
#line 1290 "test-new/asems412.imp"
Q = (struct DFM *)P->LINK;
// 1291 ABORT(18) %IF Q == NULL
#line 1291 "test-new/asems412.imp"
if (_imp_ADDR((void *)(Q)) != _imp_ADDR((void *)(NULL))) goto L_0105;
#line 1291 "test-new/asems412.imp"
ABORT(18);
#line 1291 "test-new/asems412.imp"
L_0105:;
// 1292 %EXIT %IF Q_D == D
#line 1292 "test-new/asems412.imp"
if (_imp_ADDR((void *)(Q->D)) != _imp_ADDR((void *)(D))) goto L_0106;
#line 1292 "test-new/asems412.imp"
goto L_0107;
#line 1292 "test-new/asems412.imp"
L_0106:;
// 1293 P == Q
#line 1293 "test-new/asems412.imp"
P = (struct DFM *)Q;
// 1294 %REPEAT
#line 1294 "test-new/asems412.imp"
goto L_0104;
#line 1294 "test-new/asems412.imp"
L_0107:;
// 1295 P_LINK == Q_LINK
#line 1295 "test-new/asems412.imp"
P->LINK = (struct DFM *)Q->LINK;
// 1296 Q_LINK == DASL; DASL == Q
#line 1296 "test-new/asems412.imp"
Q->LINK = (struct DFM *)DASL;
#line 1296 "test-new/asems412.imp"
DASL = (struct DFM *)Q;
// 1297 D_LINK == DESC ASL; DESC ASL == D
#line 1297 "test-new/asems412.imp"
D->LINK = (struct STACKFM *)DESCASL;
#line 1297 "test-new/asems412.imp"
DESCASL = (struct STACKFM *)D;
// 1298 %END
#line 1298 "test-new/asems412.imp"
return;
#line 1298 "test-new/asems412.imp"
} /* end of DROP */
// 1299 %ROUTINE STACK(%INTEGER DISP, BASE, TYPE, FORM, FORMAT, EXTRA, LENGTH)
#line 1299 "test-new/asems412.imp"
void STACK(int DISP, int BASE, int TYPE, int FORM, int FORMAT, int EXTRA, int LENGTH) {
// 1300 %CONSTBYTEINTEGERARRAY FMAP(0:15) = CONSTANT, V IN S, A IN S,0(4),
#line 1300 "test-new/asems412.imp"
const unsigned char FMAP[16] = {0, 3, 2, [3 ... 6] = 0, 16, 17, 19, 19, 3, 2, [13 ... 15] = 0};
// 1301+ 16,17,19,19,
// 1302+ !0, V IN R, V IN S, V IN S,
// 1303+ V IN S, A IN S,
// 1304+ 0(3)
// 1305 %RECORD(STACKFM)%NAME V
#line 1305 "test-new/asems412.imp"
struct STACKFM *V;
// 1306 STP = STP+1; ABORT(7) %IF STP > MAX DEPTH
#line 1306 "test-new/asems412.imp"
STP = STP + 1;
#line 1306 "test-new/asems412.imp"
if (STP <= 16) goto L_0108;
#line 1306 "test-new/asems412.imp"
ABORT(7);
#line 1306 "test-new/asems412.imp"
L_0108:;
// 1307 V == DESCRIPTOR
#line 1307 "test-new/asems412.imp"
V = (struct STACKFM *)DESCRIPTOR();
// 1308 V_BASE = BASE
#line 1308 "test-new/asems412.imp"
V->BASE = BASE;
// 1309 V_DISP = DISP
#line 1309 "test-new/asems412.imp"
V->DISP = DISP;
// 1310 V_FORMAT = FORMAT
#line 1310 "test-new/asems412.imp"
V->FORMAT = FORMAT;
// 1311 V_EXTRA = EXTRA; V_DV = EXTRA
#line 1311 "test-new/asems412.imp"
V->EXTRA = EXTRA;
#line 1311 "test-new/asems412.imp"
V->DV = EXTRA;
// 1312 V_TYPE = TYPE
#line 1312 "test-new/asems412.imp"
V->TYPE = TYPE;
// 1313 V_LENGTH = LENGTH
#line 1313 "test-new/asems412.imp"
V->LENGTH = LENGTH;
// 1314 V_FORM = FMAP(FORM)
#line 1314 "test-new/asems412.imp"
V->FORM = FMAP[FORM];
// 1315 STACKED(STP)_V == V
#line 1315 "test-new/asems412.imp"
STACKED[STP - 1].V = (struct SPTFM *)V;
// 1316 LHS == V
#line 1316 "test-new/asems412.imp"
LHS = (struct STACKFM *)V;
// 1317 SHOW(V) %IF CONTROL < 0
#line 1317 "test-new/asems412.imp"
if (CONTROL >= 0) goto L_0109;
#line 1317 "test-new/asems412.imp"
SHOW(V);
#line 1317 "test-new/asems412.imp"
L_0109:;
// 1318 %END
#line 1318 "test-new/asems412.imp"
return;
#line 1318 "test-new/asems412.imp"
} /* end of STACK */
// 1319 %ROUTINE VSTACK(%RECORD(VARFM)%NAME V)
#line 1319 "test-new/asems412.imp"
void VSTACK(struct VARFM * V) {
// 1320 STACK(V_DISP, V_BASE, V_TYPE, V_FORM, V_FORMAT, V_EXTRA, V_LENGTH)
#line 1320 "test-new/asems412.imp"
STACK(V->DISP, V->BASE, V->TYPE, V->FORM, V->FORMAT, V->EXTRA, V->LENGTH);
// 1321 %END
#line 1321 "test-new/asems412.imp"
return;
#line 1321 "test-new/asems412.imp"
} /* end of VSTACK */
// 1322 %ROUTINE SSTACK(%RECORD(STACKFM)%NAME V)
#line 1322 "test-new/asems412.imp"
void SSTACK(struct STACKFM * V) {
// 1323 %RECORD(STACKFM)%NAME T
#line 1323 "test-new/asems412.imp"
struct STACKFM *T;
// 1324 STP = STP+1; ABORT(7) %IF STP > MAX DEPTH
#line 1324 "test-new/asems412.imp"
STP = STP + 1;
#line 1324 "test-new/asems412.imp"
if (STP <= 16) goto L_010A;
#line 1324 "test-new/asems412.imp"
ABORT(7);
#line 1324 "test-new/asems412.imp"
L_010A:;
// 1325 T == DESCRIPTOR; T = V
#line 1325 "test-new/asems412.imp"
T = (struct STACKFM *)DESCRIPTOR();
#line 1325 "test-new/asems412.imp"
*T = *V;
// 1326 STACKED(STP)_V == T; CLAIM(T_BASE)
#line 1326 "test-new/asems412.imp"
STACKED[STP - 1].V = (struct SPTFM *)T;
#line 1326 "test-new/asems412.imp"
CLAIM(T->BASE);
// 1327 SHOW(T) %IF CONTROL < 0
#line 1327 "test-new/asems412.imp"
if (CONTROL >= 0) goto L_010B;
#line 1327 "test-new/asems412.imp"
SHOW(T);
#line 1327 "test-new/asems412.imp"
L_010B:;
// 1328 %END
#line 1328 "test-new/asems412.imp"
return;
#line 1328 "test-new/asems412.imp"
} /* end of SSTACK */
// 1329 %ROUTINE C STACK(%INTEGER N)
#line 1329 "test-new/asems412.imp"
void CSTACK(int N) {
// 1330 RHS == DESCRIPTOR
#line 1330 "test-new/asems412.imp"
RHS = (struct STACKFM *)DESCRIPTOR();
// 1331 RHS_BASE = 0
#line 1331 "test-new/asems412.imp"
RHS->BASE = 0;
// 1332 RHS_DISP = N
#line 1332 "test-new/asems412.imp"
RHS->DISP = N;
// 1333 RHS_TYPE = INTEGER
#line 1333 "test-new/asems412.imp"
RHS->TYPE = 1;
// 1334 RHS_FORM = CONSTANT
#line 1334 "test-new/asems412.imp"
RHS->FORM = 0;
// 1335 STP = STP+1; ABORT(7) %IF STP > MAX DEPTH
#line 1335 "test-new/asems412.imp"
STP = STP + 1;
#line 1335 "test-new/asems412.imp"
if (STP <= 16) goto L_010C;
#line 1335 "test-new/asems412.imp"
ABORT(7);
#line 1335 "test-new/asems412.imp"
L_010C:;
// 1336 STACKED(STP)_V == RHS
#line 1336 "test-new/asems412.imp"
STACKED[STP - 1].V = (struct SPTFM *)RHS;
// 1337 SHOW(RHS) %IF CONTROL < 0
#line 1337 "test-new/asems412.imp"
if (CONTROL >= 0) goto L_010D;
#line 1337 "test-new/asems412.imp"
SHOW(RHS);
#line 1337 "test-new/asems412.imp"
L_010D:;
// 1338 %END
#line 1338 "test-new/asems412.imp"
return;
#line 1338 "test-new/asems412.imp"
} /* end of CSTACK */
// 1339 %ROUTINE FP CSTACK(%REAL X, %RECORD(STACK FM)%NAME R)
#line 1339 "test-new/asems412.imp"
void FPCSTACK(float X, struct STACKFM *R) {
// 1340 %RECORDFORMAT F(%INTEGER VAL, GDISP)
#line 1340 "test-new/asems412.imp"
struct F {
union {
struct {
#line 1340 "test-new/asems412.imp"
int VAL;
#line 1340 "test-new/asems412.imp"
int GDISP;
#line 1340 "test-new/asems412.imp"
};
};
};
// 1341 %CONSTINTEGER L=31; ! ... MUST BE 2\\N - 1
// 1342 %OWNRECORD(F)%ARRAY CONST LIST(0:L)
#line 1342 "test-new/asems412.imp"
static struct F CONSTLIST[32];
// 1343 %OWNSHORTINTEGER LAST PNTR = 0, NEXT PNTR = 0
#line 1343 "test-new/asems412.imp"
static short int LASTPNTR = 0;
#line 1343 "test-new/asems412.imp"
static short int NEXTPNTR = 0;
// 1344 %INTEGER N; %SHORTINTEGER I
#line 1344 "test-new/asems412.imp"
int N;
#line 1344 "test-new/asems412.imp"
short int I;
// 1345 !!! %RECORDFORMAT FI(%INTEGER X)
// 1346 !!! %RECORDFORMAT FR(%REAL X)
// 1347 !!! %RECORD(FR) RV; %RECORD(FI)%NAME IV
// 1348 !!! RV_X = X; IV == RV; N = IV_X
// 1349
// 1350 %recordformat convfm(%integer n %or %real x)
#line 1350 "test-new/asems412.imp"
struct CONVFM {
union {
struct {
#line 1350 "test-new/asems412.imp"
int N;
#line 1350 "test-new/asems412.imp"
};
struct {
#line 1350 "test-new/asems412.imp"
float X;
#line 1350 "test-new/asems412.imp"
};
};
};
// 1351 %record(convfm) conv
#line 1351 "test-new/asems412.imp"
struct CONVFM CONV;
// 1352 conv_x = x; n = conv_n
#line 1352 "test-new/asems412.imp"