1 /* generated from v311.sil by genc.sno on 12/08/2021 15:06:25 */
2
3 # include "mlink.h"
4 # include "parms.h"
5 int
BEGIN(ret_t retval)6 BEGIN(ret_t retval) {
7 ENTRY(BEGIN)
8 init();
9 ISTACK();
10 if (D_A(BANRCL) == 0)
11 goto L_NOBANR;
12 io_printf(D_A(PUNCH),TITLEF);
13 io_printf(D_A(PUNCH),TITLEF1);
14 io_printf(D_A(PUNCH),SOURCF);
15 L_NOBANR:
16 D_RV(TIMECL) = mstime();
17 D_F(TIMECL) = D_V(TIMECL) = 0;
18 SAVSTK();
19 PUSH(OCALIM);
20 BLOCK(SCBSCL);
21 D(OCSVCL) = D(SCBSCL);
22 D_F(SCBSCL) &= ~(PTR);
23 D_A(YCL) = D_V(D_A(INITLS));
24 D_F(YCL) = D_V(YCL) = 0;
25 L_SPCNVT:
26 D(XPTR) = D(D_A(INITLS) + D_A(YCL));
27 D_A(XCL) = D_V(D_A(XPTR));
28 D_F(XCL) = D_V(XCL) = 0;
29 L_SPCNV1:
30 D(ZPTR) = D(D_A(XPTR) + D_A(XCL));
31 if (D_A(ZPTR) == 0)
32 goto L_SPCNV2;
33 SAVSTK();
34 PUSH(ZPTR);
35 GENVAR(ZPTR);
36 D(D_A(XPTR) + D_A(XCL)) = D(ZPTR);
37 L_SPCNV2:
38 D_A(XCL) -= 2*DESCR;
39 if (D_A(XCL) > 0)
40 goto L_SPCNV1;
41 D_A(YCL) -= DESCR;
42 if (D_A(YCL) > 0)
43 goto L_SPCNVT;
44 L_INITD1:
45 D(XPTR) = D(D_A(INITB));
46 SAVSTK();
47 PUSH(XPTR);
48 GENVAR(YPTR);
49 D(ZPTR) = D(D_A(INITB) + DESCR);
50 D(D_A(ZPTR)) = D(YPTR);
51 D_A(INITB) += 2*DESCR;
52 if (D_PTR(INITB) < D_PTR(INITE))
53 goto L_INITD1;
54 GETPARM(XSP);
55 SAVSTK();
56 PUSH(XSPPTR);
57 GENVAR(PARMVL);
58 FREEPARM(XSP);
59 D(D_A(ABRTKY) + DESCR) = D(ABOPAT);
60 D(D_A(ARBKY) + DESCR) = D(ARBPAT);
61 D(D_A(BALKY) + DESCR) = D(BALPAT);
62 D(D_A(FAILKY) + DESCR) = D(FALPAT);
63 D(D_A(FNCEKY) + DESCR) = D(FNCPAT);
64 D(D_A(REMKY) + DESCR) = D(REMPAT);
65 D(D_A(SUCCKY) + DESCR) = D(SUCPAT);
66 D_A(VARSYM) = 0;
67 SAVSTK();
68 PUSH(NMOVER);
69 BLOCK(NBSPTR);
70 D(CMBSCL) = D(SCBSCL);
71 D(UNIT) = D(INPUT);
72 D(OCBSCL) = D(CMBSCL);
73 D(OCLIM) = D(CMBSCL);
74 D_A(OCLIM) += D_A(OCALIM);
75 D_A(OCLIM) -= 7*DESCR;
76 D_A(INICOM) = 1;
77 IO_FILE(UNIT,XSP);
78 SAVSTK();
79 PUSH(XSPPTR);
80 GENVAR(FILENM);
81 D_A(TMVAL) = 0;
82 L_AUTLOP:
83 if (!GETPMPROTO(XSP,TMVAL))
84 goto L_XLATRN;
85 SAVSTK();
86 PUSH(XSPPTR);
87 GENVAR(XPTR);
88 D(WPTR) = D(NULVCL);
89 D_A(ERRLCL)++;
90 SAVSTK();
91 LOAD2(NORET);
92 D_A(ERRLCL) = 0;
93 D_A(TMVAL)++;
94 goto L_AUTLOP;
95 /*_*/
96 L_XLATRD:
97 if (D_A(LISTCL) == 0)
98 goto L_XLATRN;
99 IO_PRINT(IOKEY, OUTBLK, LNBFSP);
100 L_XLATRN:
101 _SPEC(TEXTSP) = _SPEC(NEXTSP);
102 switch (IO_READ(UNIT, TEXTSP)) {
103 case IO_EOF:
104 goto L_XLATIN;
105 case IO_ERR:
106 BRANCH(COMP1)
107 }
108 D_A(TMVAL) = S_L(TEXTSP);
109 D_F(TMVAL) = D_V(TMVAL) = 0;
110 D_A(TMVAL) += STNOSZ;
111 S_L(LNBFSP) = D_A(TMVAL);
112 D_A(LNNOCL)++;
113 L_XLATNX:
114 switch (STREAM(XSP, TEXTSP, &CARDTB)) {
115 case ST_ERROR:
116 BRANCH(COMP3)
117 case ST_EOS:
118 goto L_XLATRD;
119 }
120 SAVSTK();
121 switch (NEWCRD(NORET)) {
122 case 1:
123 goto L_XLATRD;
124 }
125 SAVSTK();
126 switch (CMPILE(NORET)) {
127 case 1:
128 BRANCH(COMP3)
129 case 3:
130 goto L_XLATNX;
131 }
132 D_A(CMOFCL) += DESCR;
133 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(ENDCL);
134 if (D_A(LISTCL) == 0)
135 goto L_XLATP;
136 IO_PRINT(IOKEY, OUTBLK, LNBFSP);
137 L_XLATP:
138 if (D_A(STYPE) == EOSTYP)
139 goto L_XLAEND;
140 switch (STREAM(XSP, TEXTSP, &IBLKTB)) {
141 case ST_ERROR:
142 BRANCH(COMP3)
143 case ST_EOS:
144 goto L_XLAEND;
145 }
146 if (D_A(STYPE) == EOSTYP)
147 goto L_XLAEND;
148 if (D_A(STYPE) != NBTYP)
149 BRANCH(COMP7)
150 switch (STREAM(XSP, TEXTSP, &LBLTB)) {
151 case ST_ERROR:
152 case ST_EOS:
153 BRANCH(COMP7)
154 }
155 SAVSTK();
156 PUSH(XSPPTR);
157 GENVUP(XPTR);
158 D(OCBSCL) = D(D_A(XPTR) + ATTRIB);
159 if (D_A(OCBSCL) == 0)
160 BRANCH(COMP7)
161 if (D_A(STYPE) == EOSTYP)
162 goto L_XLAEND;
163 switch (STREAM(XSP, TEXTSP, &IBLKTB)) {
164 case ST_ERROR:
165 case ST_STOP:
166 BRANCH(COMP7)
167 }
168 L_XLAEND:
169 if (D_A(ESAICL) == 0)
170 goto L_XLATSC;
171 io_printf(D_A(PUNCH),ERRCF);
172 if (D_A(NERRCL) == 0)
173 goto L_XLATND;
174 D_A(RETCOD) = 1;
175 BRANCH(FTLEN2)
176 /*_*/
177 L_XLATIN:
178 SAVSTK();
179 FILCHK(NORET);
180 goto L_XLATRN;
181 /*_*/
182 L_XLATSC:
183 if (D_A(BANRCL) == 0)
184 goto L_XLATND;
185 io_printf(D_A(PUNCH),SUCCF);
186 L_XLATND:
187 if (D_A(EXECCL) == 0)
188 BRANCH(END)
189 io_ecomp();
190 D_A(UNIT) = 0;
191 D_A(LPTR) = 0;
192 D_A(OCLIM) = 0;
193 D_A(LNNOCL) = 0;
194 ZERBLK(D_A(COMREG),D_A(COMDCT));
195 D(XCL) = D(CMBSCL);
196 D_A(XCL) += D_A(CMOFCL);
197 SAVSTK();
198 PUSH(XCL);
199 SPLIT(NORET);
200 D_A(LISTCL) = 0;
201 D_A(COMPCL) = 0;
202 D_RV(ETMCL) = mstime();
203 D_F(ETMCL) = D_V(ETMCL) = 0;
204 D_RV(TIMECL) = D_RV(ETMCL) - D_RV(TIMECL);
205 D_F(TIMECL) = D_F(ETMCL);
206 D_V(TIMECL) = D_V(ETMCL);
207 D_A(CNSLCL) = 1;
208 SAVSTK();
209 switch (INTERP(NORET)) {
210 case 1:
211 case 2:
212 case 3:
213 BRANCH(MAIN1)
214 }
215 /*_*/
216 }
217 static int
AUGATL(ret_t retval)218 AUGATL(ret_t retval) {
219 ENTRY(AUGATL)
220 POP(A1PTR);
221 POP(A2PTR);
222 POP(A3PTR);
223 if (!LOCAPT(A4PTR,A1PTR,ZEROCL))
224 goto L_AUG1;
225 D(D_A(A4PTR) + DESCR) = D(A2PTR);
226 D(D_A(A4PTR) + 2*DESCR) = D(A3PTR);
227 D(A5PTR) = D(A1PTR);
228 BRANCH(A5RTN)
229 /*_*/
230 L_AUG1:
231 D_A(A4PTR) = D_V(D_A(A1PTR));
232 D_F(A4PTR) = D_V(A4PTR) = 0;
233 D_A(A4PTR) += 2*DESCR;
234 D_V(A4PTR) = B;
235 SAVSTK();
236 PUSH(A4PTR);
237 BLOCK(A5PTR);
238 D(D_A(A5PTR) + D_A(A4PTR)) = D(A3PTR);
239 D_A(A4PTR) -= DESCR;
240 D(D_A(A5PTR) + D_A(A4PTR)) = D(A2PTR);
241 D_A(A4PTR) -= DESCR;
242 MOVBLK(D_A(A5PTR),D_A(A1PTR),D_A(A4PTR));
243 BRANCH(A5RTN)
244 /*_*/
245 }
246 static int
CODSKP(ret_t retval)247 CODSKP(ret_t retval) {
248 ENTRY(CODSKP)
249 POP(YCL);
250 L_CODCNT:
251 D_A(OCICL) += DESCR;
252 D(XCL) = D(D_A(OCBSCL) + D_A(OCICL));
253 if ((D_F(XCL) & FNC))
254 goto L_CODFNC;
255 L_CODECR:
256 D_A(YCL)--;
257 if (D_A(YCL) < 0)
258 BRANCH(INTR10)
259 if (D_A(YCL) == 0)
260 BRANCH(RTN1)
261 goto L_CODCNT;
262 /*_*/
263 L_CODFNC:
264 PUSH(YCL);
265 D_A(YCL) = D_V(XCL);
266 D_F(YCL) = D_V(YCL) = 0;
267 SAVSTK();
268 PUSH(YCL);
269 CODSKP(NORET);
270 POP(YCL);
271 goto L_CODECR;
272 /*_*/
273 }
274 static int
DTREP(ret_t retval)275 DTREP(ret_t retval) {
276 ENTRY(DTREP)
277 POP(A2PTR);
278 if (D_V(A2PTR) == A)
279 goto L_DTARRY;
280 if (D_V(A2PTR) == T)
281 goto L_DTABLE;
282 if (D_V(A2PTR) != R)
283 goto L_DTREP1;
284 REALST(DPSP,A2PTR);
285 goto L_DTREPR;
286 /*_*/
287 L_DTARRY:
288 D(A3PTR) = D(D_A(A2PTR) + DESCR);
289 X_LOCSP(ZSP,A3PTR);
290 D_A(A3PTR) = S_L(ZSP);
291 D_F(A3PTR) = D_V(A3PTR) = 0;
292 if (D_A(A3PTR) > ARRLEN)
293 goto L_DTREP1;
294 S_L(DTARSP) = 0;
295 APDSP(DTARSP,ARRSP);
296 APDSP(DTARSP,LPRNSP);
297 APDSP(DTARSP,QTSP);
298 APDSP(DTARSP,ZSP);
299 APDSP(DTARSP,QTSP);
300 L_DTARTB:
301 APDSP(DTARSP,RPRNSP);
302 _SPEC(DPSP) = _SPEC(DTARSP);
303 goto L_DTREPR;
304 /*_*/
305 L_DTABLE:
306 D_A(A3PTR) = D_V(D_A(A2PTR));
307 D_F(A3PTR) = D_V(A3PTR) = 0;
308 D(A1PTR) = D(D_A(A2PTR) + D_A(A3PTR));
309 D_A(A3PTR) -= DESCR;
310 D(A2PTR) = D(D_A(A2PTR) + D_A(A3PTR));
311 L_DTABL1:
312 if (D_A(A1PTR) == 1)
313 goto L_DTABL2;
314 D_A(A3PTR) += D_A(A2PTR);
315 D_A(A3PTR) -= 2*DESCR;
316 D(A1PTR) = D(D_A(A1PTR) + D_A(A2PTR));
317 goto L_DTABL1;
318 /*_*/
319 L_DTABL2:
320 D_A(A3PTR) -= DESCR;
321 D_A(A2PTR) -= 2*DESCR;
322 D_A(A3PTR) /= D_A(DSCRTW);
323 INTSPC(ZSP,A3PTR);
324 S_L(DTARSP) = 0;
325 APDSP(DTARSP,ASSCSP);
326 APDSP(DTARSP,LPRNSP);
327 APDSP(DTARSP,ZSP);
328 APDSP(DTARSP,CMASP);
329 D_A(A2PTR) /= D_A(DSCRTW);
330 INTSPC(ZSP,A2PTR);
331 APDSP(DTARSP,ZSP);
332 goto L_DTARTB;
333 /*_*/
334 L_DTREP1:
335 D_V(DT1CL) = D_V(A2PTR);
336 if (!LOCAPT(A3PTR,DTATL,DT1CL))
337 goto L_DTREPE;
338 D(A3PTR) = D(D_A(A3PTR) + 2*DESCR);
339 X_LOCSP(DPSP,A3PTR);
340 L_DTREPR:
341 D(retval) = D(DPSPTR);
342 RETURN(1)
343 /*_*/
344 L_DTREPE:
345 _SPEC(DPSP) = _SPEC(EXDTSP);
346 goto L_DTREPR;
347 /*_*/
348 }
349 static int
FINDEX(ret_t retval)350 FINDEX(ret_t retval) {
351 ENTRY(FINDEX)
352 POP(F1PTR);
353 if (!LOCAPV(F2PTR,FNCPL,F1PTR))
354 goto L_FATNF;
355 D(F2PTR) = D(D_A(F2PTR) + DESCR);
356 L_FATBAK:
357 D(retval) = D(F2PTR);
358 RETURN(1)
359 /*_*/
360 L_FATNF:
361 D_A(NEXFCL) += 2*DESCR;
362 if (D_A(NEXFCL) > FBLKSZ)
363 goto L_FATBLK;
364 L_FATNXT:
365 D(F2PTR) = D(FBLOCK);
366 D_A(F2PTR) += D_A(NEXFCL);
367 SAVSTK();
368 PUSH(F1PTR);
369 PUSH(F2PTR);
370 PUSH(FNCPL);
371 AUGATL(FNCPL);
372 D(D_A(F2PTR)) = D(UNDFCL);
373 D(D_A(F2PTR) + DESCR) = D(F1PTR);
374 goto L_FATBAK;
375 /*_*/
376 L_FATBLK:
377 SAVSTK();
378 PUSH(FBLKRQ);
379 BLOCK(FBLOCK);
380 D_F(FBLOCK) |= FNC;
381 D_V(FBLOCK) = 0;
382 D_A(NEXFCL) = (int_t) DESCR;
383 goto L_FATNXT;
384 /*_*/
385 }
386 static int
BLOCK(ret_t retval)387 BLOCK(ret_t retval) {
388 ENTRY(BLOCK)
389 POP(ARG1CL);
390 if (D_A(ARG1CL) >= D_A(SIZLMT))
391 BRANCH(SIZERR)
392 L_BLOCK1:
393 D(BLOCL) = D(FRSGPT);
394 D_V(BLOCL) = D_V(ARG1CL);
395 D_A(FRSGPT) += DESCR;
396 D_A(FRSGPT) += D_A(ARG1CL);
397 if (D_PTR(TLSGP1) < D_PTR(FRSGPT))
398 goto L_BLOGC;
399 ZERBLK(D_A(BLOCL),D_A(ARG1CL));
400 D_A(D_A(BLOCL)) = D_A(BLOCL);
401 D_F(D_A(BLOCL)) |= TTL;
402 D_V(D_A(BLOCL)) = D_A(ARG1CL);
403 D(retval) = D(BLOCL);
404 RETURN(1)
405 /*_*/
406 L_BLOGC:
407 D_A(FRSGPT) = D_A(BLOCL);
408 SAVSTK();
409 PUSH(ARG1CL);
410 switch (GC(NORET)) {
411 case 1:
412 BRANCH(ALOC2)
413 case 2:
414 goto L_BLOCK1;
415 }
416 /*_*/
417 }
418 static int
GENVAR(ret_t retval)419 GENVAR(ret_t retval) {
420 ENTRY(GENVAR)
421 D_A(CONVSW) = 0;
422 POP(AXPTR);
423 _SPEC(SPECR1) = _SPEC(D_A(AXPTR));
424 if (S_L(SPECR1) == 0)
425 BRANCH(RT1NUL)
426 /* FALL */
427 BRANCH(LOCA1)
428 }
429 static int
LOCA1(ret_t retval)430 LOCA1(ret_t retval) {
431 ENTRY(LOCA1)
432 HASH(EQUVCL,SPECR1);
433 D(BUKPTR) = D(OBPTR);
434 D_A(BUKPTR) += D_A(EQUVCL);
435 L_LOCA2:
436 D(LSTPTR) = D(BUKPTR);
437 D_A(BUKPTR) = D_A(D_A(BUKPTR) + LNKFLD);
438 if (D_A(BUKPTR) == 0)
439 goto L_LOCA5;
440 if (D_V(D_A(BUKPTR) + LNKFLD) < D_V(EQUVCL))
441 goto L_LOCA2;
442 if (D_V(D_A(BUKPTR) + LNKFLD) > D_V(EQUVCL))
443 goto L_LOCA5;
444 X_LOCSP(SPECR2,BUKPTR);
445 if (!LEXEQ(SPECR1,SPECR2))
446 goto L_LOCA2;
447 D(LCPTR) = D(BUKPTR);
448 goto L_LOCRET;
449 /*_*/
450 L_LOCA5:
451 D_A(AXPTR) = S_L(SPECR1);
452 D_F(AXPTR) = D_V(AXPTR) = 0;
453 D_A(BKLTCL) = X_GETLTH(AXPTR);
454 D_F(BKLTCL) = D_V(BKLTCL) = 0;
455 if (D_A(BKLTCL) > D_A(SIZLMT))
456 BRANCH(SIZERR)
457 L_LOCA7:
458 D(LCPTR) = D(FRSGPT);
459 D_V(LCPTR) = S;
460 D_A(FRSGPT) += DESCR;
461 D_A(FRSGPT) += D_A(BKLTCL);
462 if (D_PTR(TLSGP1) < D_PTR(FRSGPT))
463 goto L_LOCA4;
464 D(D_A(LCPTR)) = D(ZEROCL);
465 D_A(D_A(LCPTR)) = D_A(LCPTR);
466 D_F(D_A(LCPTR)) |= TTL+STTL;
467 D_V(D_A(LCPTR)) = D_A(AXPTR);
468 if (D_A(CONVSW) != 0)
469 goto L_LOCA6;
470 D(D_A(LCPTR) + DESCR) = D(NULVCL);
471 D(D_A(LCPTR) + ATTRIB) = D(ZEROCL);
472 X_LOCSP(SPECR2,LCPTR);
473 S_L(SPECR2) = 0;
474 APDSP(SPECR2,SPECR1);
475 L_LOCA6:
476 D_V(D_A(LCPTR) + LNKFLD) = D_V(EQUVCL);
477 D_A(D_A(LCPTR) + LNKFLD) = D_A(BUKPTR);
478 D_A(D_A(LSTPTR) + LNKFLD) = D_A(LCPTR);
479 D_A(VARSYM)++;
480 L_LOCRET:
481 D(retval) = D(LCPTR);
482 RETURN(1)
483 /*_*/
484 L_LOCA4:
485 D_A(FRSGPT) = D_A(LCPTR);
486 SAVSTK();
487 PUSH(BKLTCL);
488 switch (GC(NORET)) {
489 case 1:
490 BRANCH(ALOC2)
491 case 2:
492 goto L_LOCA7;
493 }
494 /*_*/
495 }
496 static int
GNVARI(ret_t retval)497 GNVARI(ret_t retval) {
498 ENTRY(GNVARI)
499 D_A(CONVSW) = 0;
500 POP(AXPTR);
501 INTSPC(SPECR1,AXPTR);
502 BRANCH(LOCA1)
503 /*_*/
504 }
505 static int
GENVUP(ret_t retval)506 GENVUP(ret_t retval) {
507 ENTRY(GENVUP)
508 if (D_A(CASECL) == 0)
509 BRANCH(GENVAR)
510 POP(AXPTR);
511 PUSH(AXPTR);
512 _SPEC(SPECR1) = _SPEC(D_A(AXPTR));
513 RAISE1(SPECR1);
514 BRANCH(GENVAR)
515 /*_*/
516 }
517 static int
CONVAR(ret_t retval)518 CONVAR(ret_t retval) {
519 ENTRY(CONVAR)
520 POP(AXPTR);
521 if (D_A(AXPTR) == 0)
522 BRANCH(RT1NUL)
523 D_A(CONVSW) = 1;
524 D_A(BKLTCL) = X_GETLTH(AXPTR);
525 D_F(BKLTCL) = D_V(BKLTCL) = 0;
526 if (D_A(BKLTCL) > D_A(SIZLMT))
527 BRANCH(SIZERR)
528 D(TEMPCL) = D(FRSGPT);
529 D_A(TEMPCL) += D_A(BKLTCL);
530 D_A(TEMPCL) += DESCR;
531 if (D_PTR(TLSGP1) < D_PTR(TEMPCL))
532 goto L_CONVR4;
533 L_CONVR5:
534 D(D_A(FRSGPT)) = D(ZEROCL);
535 D_A(D_A(FRSGPT)) = D_A(FRSGPT);
536 D_F(D_A(FRSGPT)) |= TTL+STTL;
537 D_V(D_A(FRSGPT)) = D_A(AXPTR);
538 D(D_A(FRSGPT) + DESCR) = D(NULVCL);
539 D(D_A(FRSGPT) + ATTRIB) = D(ZEROCL);
540 D_A(BKLTCL) = D_A(FRSGPT);
541 D(retval) = D(BKLTCL);
542 RETURN(1)
543 /*_*/
544 L_CONVR4:
545 SAVSTK();
546 PUSH(BKLTCL);
547 switch (GC(NORET)) {
548 case 1:
549 BRANCH(ALOC2)
550 case 2:
551 goto L_CONVR5;
552 }
553 /*_*/
554 }
555 static int
GNVARS(ret_t retval)556 GNVARS(ret_t retval) {
557 ENTRY(GNVARS)
558 POP(AXPTR);
559 if (D_A(AXPTR) == 0)
560 BRANCH(RT1NUL)
561 X_LOCSP(SPECR1,FRSGPT);
562 S_L(SPECR1) = D_A(AXPTR);
563 D_V(D_A(FRSGPT)) = D_A(AXPTR);
564 BRANCH(LOCA1)
565 /*_*/
566 }
567 static int
GC(ret_t retval)568 GC(ret_t retval) {
569 ENTRY(GC)
570 D_RV(GCTMCL) = mstime();
571 D_F(GCTMCL) = D_V(GCTMCL) = 0;
572 vm_gc_advise(1);
573 POP(GCREQ);
574 PSTACK(BLOCL);
575 D_A(BLOCL) -= D_A(STKPTR);
576 D_V(D_A(STKPTR)) = D_A(BLOCL);
577 D(BKDXU) = D(PRMDX);
578 L_GCT:
579 D(GCMPTR) = D(D_A(PRMPTR) + D_A(BKDXU));
580 if (D_A(GCMPTR) == 0)
581 goto L_GCTDWN;
582 SAVSTK();
583 PUSH(GCMPTR);
584 GCM(NORET);
585 L_GCTDWN:
586 D_A(BKDXU) -= DESCR;
587 if (D_A(BKDXU) != 0)
588 goto L_GCT;
589 D_A(BKPTR) = (int_t) (OBLIST-DESCR);
590 L_GCBA1:
591 if (D_PTR(BKPTR) > D_PTR(OBEND))
592 goto L_GCLAD;
593 D_A(BKPTR) += DESCR;
594 D(ST1PTR) = D(BKPTR);
595 L_GCBA2:
596 D_A(ST1PTR) = D_A(D_A(ST1PTR) + LNKFLD);
597 if (D_A(ST1PTR) == 0)
598 goto L_GCBA1;
599 if ((D_F(D_A(ST1PTR)) & MARK))
600 goto L_GCBA2;
601 D(ST2PTR) = D(D_A(ST1PTR) + DESCR);
602 if (!DCMP(ST2PTR, NULVCL))
603 goto L_GCBA4;
604 if (D_A(D_A(ST1PTR) + ATTRIB) == (int_t)0)
605 goto L_GCBA2;
606 L_GCBA4:
607 D(D_A(GCBLK) + DESCR) = D(ST1PTR);
608 SAVSTK();
609 PUSH(GCBLK);
610 if (GCM(NORET) == 1)
611 goto L_GCBA2;
612 /*_*/
613 L_GCLAD:
614 D(CPYCL) = D(HDSGPT);
615 D(TTLCL) = D(HDSGPT);
616 L_GCLAD0:
617 D_A(BKDX) = X_BKSIZE(D_A(TTLCL));
618 D_F(BKDX) = D_V(BKDX) = 0;
619 if (!(D_F(D_A(TTLCL)) & MARK))
620 goto L_GCLAD7;
621 D_A(CPYCL) += D_A(BKDX);
622 D_A(TTLCL) += D_A(BKDX);
623 if (D_A(TTLCL) == D_A(FRSGPT))
624 goto L_GCBB1;
625 else
626 goto L_GCLAD0;
627 /*_*/
628 L_GCLAD7:
629 D(MVSGPT) = D(TTLCL);
630 L_GCLAD4:
631 D_A(TTLCL) += D_A(BKDX);
632 if (D_A(TTLCL) == D_A(FRSGPT))
633 goto L_GCBB1;
634 D_A(BKDX) = X_BKSIZE(D_A(TTLCL));
635 D_F(BKDX) = D_V(BKDX) = 0;
636 if (!(D_F(D_A(TTLCL)) & MARK))
637 goto L_GCLAD4;
638 D_A(D_A(TTLCL)) = D_A(CPYCL);
639 D_A(CPYCL) += D_A(BKDX);
640 goto L_GCLAD4;
641 /*_*/
642 L_GCBB1:
643 D_A(BKPTR) = (int_t) (OBLIST-DESCR);
644 D_A(NODPCL) = 1;
645 L_GCBB2:
646 if (D_PTR(BKPTR) > D_PTR(OBEND))
647 goto L_GCLAP;
648 D_A(BKPTR) += DESCR;
649 D(ST1PTR) = D(BKPTR);
650 L_GCBB3:
651 D(ST2PTR) = D(ST1PTR);
652 L_GCBB4:
653 D_A(ST1PTR) = D_A(D_A(ST1PTR) + LNKFLD);
654 if (D_A(ST1PTR) == 0)
655 goto L_GCBB5;
656 if (!(D_F(D_A(ST1PTR)) & MARK))
657 goto L_GCBB4;
658 D_A(BLOCL) = D_A(D_A(ST1PTR));
659 D_A(D_A(ST2PTR) + LNKFLD) = D_A(BLOCL);
660 goto L_GCBB3;
661 /*_*/
662 L_GCBB5:
663 D_A(D_A(ST2PTR) + LNKFLD) = D_A(ZEROCL);
664 goto L_GCBB2;
665 /*_*/
666 L_GCLAP:
667 D(TTLCL) = D(HDSGPT);
668 L_GCLAP0:
669 D_A(BKDXU) = X_BKSIZE(D_A(TTLCL));
670 D_F(BKDXU) = D_V(BKDXU) = 0;
671 if ((D_F(D_A(TTLCL)) & STTL))
672 goto L_GCLAP1;
673 D(BKDX) = D(BKDXU);
674 goto L_GCLAP2;
675 /*_*/
676 L_GCLAP1:
677 D_A(BKDX) = (int_t) (3*DESCR);
678 L_GCLAP2:
679 if (!(D_F(D_A(TTLCL)) & MARK))
680 goto L_GCLAP5;
681 D_A(BKDX) -= DESCR;
682 L_GCLAP3:
683 D(DESCL) = D(D_A(TTLCL) + D_A(BKDX));
684 if (!(D_F(DESCL) & PTR))
685 goto L_GCLAP4;
686 if (D_PTR(DESCL) < D_PTR(MVSGPT))
687 goto L_GCLAP4;
688 TOP(TOPCL,OFSET,DESCL);
689 D_A(DESCL) = D_A(OFSET) + D_A(D_A(TOPCL));
690 D(D_A(TTLCL) + D_A(BKDX)) = D(DESCL);
691 L_GCLAP4:
692 D_A(BKDX) -= DESCR;
693 if (D_A(BKDX) != 0)
694 goto L_GCLAP3;
695 L_GCLAP5:
696 D_A(TTLCL) += D_A(BKDXU);
697 if (D_A(TTLCL) != D_A(FRSGPT))
698 goto L_GCLAP0;
699 D(BKDXU) = D(PRMDX);
700 L_GCLAT1:
701 D(TTLCL) = D(D_A(PRMPTR) + D_A(BKDXU));
702 if (D_A(TTLCL) == 0)
703 goto L_GCLAT4;
704 D_A(BKDX) = D_V(D_A(TTLCL));
705 D_F(BKDX) = D_V(BKDX) = 0;
706 L_GCLAT2:
707 D(DESCL) = D(D_A(TTLCL) + D_A(BKDX));
708 if (!(D_F(DESCL) & PTR))
709 goto L_GCLAT3;
710 if (D_PTR(DESCL) < D_PTR(MVSGPT))
711 goto L_GCLAT3;
712 TOP(TOPCL,OFSET,DESCL);
713 D_A(DESCL) = D_A(OFSET) + D_A(D_A(TOPCL));
714 D(D_A(TTLCL) + D_A(BKDX)) = D(DESCL);
715 L_GCLAT3:
716 D_A(BKDX) -= DESCR;
717 if (D_A(BKDX) != 0)
718 goto L_GCLAT2;
719 L_GCLAT4:
720 D_A(BKDXU) -= DESCR;
721 if (D_A(BKDXU) != 0)
722 goto L_GCLAT1;
723 D(TTLCL) = D(HDSGPT);
724 L_GCLAM0:
725 D_A(BKDXU) = X_BKSIZE(D_A(TTLCL));
726 D_F(BKDXU) = D_V(BKDXU) = 0;
727 if (D_PTR(TTLCL) >= D_PTR(MVSGPT))
728 goto L_GCLAM5;
729 D_A(TOPCL) = D_A(D_A(TTLCL));
730 D(D_A(TOPCL)) = D(D_A(TTLCL));
731 D_F(D_A(TOPCL)) &= ~(MARK);
732 goto L_GCLAM4;
733 /*_*/
734 L_GCLAM5:
735 D_A(BKDX) = D_A(BKDXU);
736 D_A(BKDX) -= DESCR;
737 if (!(D_F(D_A(TTLCL)) & MARK))
738 goto L_GCLAM4;
739 D_A(TOPCL) = D_A(D_A(TTLCL));
740 D(D_A(TOPCL)) = D(D_A(TTLCL));
741 D_F(D_A(TOPCL)) &= ~(MARK);
742 MOVBLK(D_A(TOPCL),D_A(TTLCL),D_A(BKDX));
743 L_GCLAM4:
744 D_A(TTLCL) += D_A(BKDXU);
745 if (D_A(TTLCL) != D_A(FRSGPT))
746 goto L_GCLAM0;
747 vm_gc_advise(0);
748 D_A(GCNO)++;
749 D_A(NODPCL) = 0;
750 D_A(BKDX) = X_BKSIZE(D_A(TOPCL));
751 D_F(BKDX) = D_V(BKDX) = 0;
752 D(FRSGPT) = D(TOPCL);
753 D_A(FRSGPT) += D_A(BKDX);
754 D_F(FRSGPT) &= ~(FNC);
755 D(GCGOT) = D(TLSGP1);
756 D_A(GCGOT) -= D_A(FRSGPT);
757 D_A(GCGOT) -= DESCR;
758 D_F(GCGOT) &= ~(PTR);
759 D_RV(TEMPCL) = mstime();
760 D_F(TEMPCL) = D_V(TEMPCL) = 0;
761 D_RV(TEMPCL) -= D_RV(GCTMCL);
762 D_RV(GCTTTL) += D_RV(TEMPCL);
763 if (D_A(GCTRCL) < 0)
764 goto L_GCTRC;
765 if (D_A(GCTRCL) == 0)
766 goto L_NOGCTR;
767 D_A(GCTRCL)--;
768 L_GCTRC:
769 io_printf(D_A(PUNCH),GCFMT,FILENM,LNNOCL,TEMPCL,GCGOT);
770 L_NOGCTR:
771 if (D_A(GCREQ) > D_A(GCGOT))
772 BRANCH(FAIL)
773 D(retval) = D(GCGOT);
774 RETURN(2)
775 /*_*/
776 }
777 static int
GCM(ret_t retval)778 GCM(ret_t retval) {
779 ENTRY(GCM)
780 POP(BK1CL);
781 PUSH(ZEROCL);
782 L_GCMA1:
783 D_A(BKDX) = D_V(D_A(BK1CL));
784 D_F(BKDX) = D_V(BKDX) = 0;
785 L_GCMA2:
786 D(DESCL) = D(D_A(BK1CL) + D_A(BKDX));
787 if (!(D_F(DESCL) & PTR))
788 goto L_GCMA3;
789 if (D_A(DESCL) == 0)
790 goto L_GCMA3;
791 TOP(TOPCL,OFSET,DESCL);
792 if (!(D_F(D_A(TOPCL)) & MARK))
793 goto L_GCMA4;
794 L_GCMA3:
795 D_A(BKDX) -= DESCR;
796 if (D_A(BKDX) != 0)
797 goto L_GCMA2;
798 POP(BK1CL);
799 if (D_A(BK1CL) == 0)
800 BRANCH(RTN1)
801 D_A(BKDX) = D_V(BK1CL);
802 D_F(BKDX) = D_V(BKDX) = 0;
803 goto L_GCMA2;
804 /*_*/
805 L_GCMA4:
806 D_A(BKDX) -= DESCR;
807 if (D_A(BKDX) == 0)
808 goto L_GCMA9;
809 D_V(BK1CL) = D_A(BKDX);
810 PUSH(BK1CL);
811 L_GCMA9:
812 D(BK1CL) = D(TOPCL);
813 D_F(D_A(BK1CL)) |= MARK;
814 if (!(D_F(D_A(BK1CL)) & STTL))
815 goto L_GCMA1;
816 D(BKDX) = D(TWOCL);
817 goto L_GCMA2;
818 /*_*/
819 }
820 static int
SPLIT(ret_t retval)821 SPLIT(ret_t retval) {
822 ENTRY(SPLIT)
823 POP(A4PTR);
824 TOP(A5PTR,A6PTR,A4PTR);
825 if (D_A(A6PTR) == 0)
826 BRANCH(RTN1)
827 D_A(A7PTR) = D_V(D_A(A5PTR));
828 D_F(A7PTR) = D_V(A7PTR) = 0;
829 D_A(A7PTR) -= D_A(A6PTR);
830 D_A(A7PTR) -= DESCR;
831 if (D_A(A7PTR) <= 0)
832 BRANCH(RTN1)
833 D_V(D_A(A5PTR)) = D_A(A6PTR);
834 D_A(A4PTR) += DESCR;
835 D(D_A(A4PTR)) = D(ZEROCL);
836 D_A(D_A(A4PTR)) = D_A(A4PTR);
837 D_F(D_A(A4PTR)) |= TTL;
838 D_V(D_A(A4PTR)) = D_A(A7PTR);
839 BRANCH(RTN1)
840 /*_*/
841 }
842 static int
BINOP(ret_t retval)843 BINOP(ret_t retval) {
844 ENTRY(BINOP)
845 SAVSTK();
846 if (FORBLK(NORET) == 1)
847 goto L_BINOP1;
848 if (D_A(BRTYPE) == EQTYP)
849 goto L_BINOP2;
850 L_BINOP4:
851 if (D_A(BRTYPE) != NBTYP)
852 BRANCH(RTN2)
853 if (D_A(SPITCL) != 0)
854 goto L_BINOP5;
855 if (D_A(BLOKCL) != 0)
856 goto L_BINOP7;
857 switch (STREAM(XSP, TEXTSP, &BIOPTB)) {
858 case ST_ERROR:
859 goto L_BINCON;
860 }
861 L_BINOP3:
862 D(ZPTR) = D(STYPE);
863 BRANCH(RTZPTR)
864 /*_*/
865 L_BINOP2:
866 if (D_A(SPITCL) == 0)
867 goto L_BINOP4;
868 D_A(STYPE) = (int_t) BIEQFN;
869 goto L_BINOP3;
870 /*_*/
871 L_BINOP1:
872 SAVSTK();
873 if (FORWRD(NORET) == 1)
874 BRANCH(COMP3)
875 switch (D_A(BRTYPE)) {
876 case 2:
877 case 3:
878 case 6:
879 case 7:
880 BRANCH(RTN2)
881 }
882 D_A(EMSGCL) = (int_t) ILLBIN;
883 BRANCH(RTN1)
884 /*_*/
885 L_BINCON:
886 D(ZPTR) = D(CONCL);
887 BRANCH(RTZPTR)
888 /*_*/
889 L_BINOP5:
890 if (D_A(BLOKCL) != 0)
891 goto L_BINOP6;
892 switch (STREAM(XSP, TEXTSP, &SBIPTB)) {
893 case ST_ERROR:
894 goto L_BINCON;
895 }
896 goto L_BINOP3;
897 /*_*/
898 L_BINOP6:
899 switch (STREAM(XSP, TEXTSP, &BSBIPTB)) {
900 case ST_ERROR:
901 goto L_BINCON;
902 }
903 goto L_BINOP3;
904 /*_*/
905 L_BINOP7:
906 switch (STREAM(XSP, TEXTSP, &BBIOPTB)) {
907 case ST_ERROR:
908 goto L_BINCON;
909 }
910 goto L_BINOP3;
911 /*_*/
912 }
913 static int
CMPILE(ret_t retval)914 CMPILE(ret_t retval) {
915 ENTRY(CMPILE)
916 D_A(BRTYPE) = 0;
917 D(BOSCL) = D(CMOFCL);
918 if (D_A(HIDECL) != 0)
919 goto L_CMPIL0;
920 D_A(CSTNCL)++;
921 L_CMPIL0:
922 switch (STREAM(XSP, TEXTSP, &LBLTB)) {
923 case ST_ERROR:
924 goto L_CERR1;
925 }
926 if (S_L(XSP) == 0)
927 goto L_CMPILA;
928 D_A(CMOFCL) += DESCR;
929 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(BASECL);
930 D_A(CMBSCL) += D_A(CMOFCL);
931 if (D_PTR(CMBSCL) < D_PTR(OCLIM))
932 goto L_CMPILO;
933 SAVSTK();
934 PUSH(CODELT);
935 BLOCK(XCL);
936 D(D_A(CMBSCL)) = D(GOTGCL);
937 D(D_A(CMBSCL) + DESCR) = D(LIT1CL);
938 D(D_A(CMBSCL) + 2*DESCR) = D(XCL);
939 D(CMBSCL) = D(XCL);
940 D(OCLIM) = D(CMBSCL);
941 D_A(OCLIM) += D_A(CODELT);
942 D_A(OCLIM) -= 7*DESCR;
943 D(D_A(CMBSCL) + DESCR) = D(BASECL);
944 D_A(CMBSCL) += DESCR;
945 L_CMPILO:
946 D_A(CMOFCL) = 0;
947 D_A(BOSCL) = 0;
948 SAVSTK();
949 PUSH(XSPPTR);
950 GENVUP(LPTR);
951 if (D_A(D_A(LPTR) + ATTRIB) == (int_t)0)
952 goto L_CMPILC;
953 if (D_A(CNSLCL) == 0)
954 goto L_CERR2;
955 L_CMPILC:
956 D(D_A(LPTR) + ATTRIB) = D(CMBSCL);
957 if (DCMP(LPTR, ENDPTR))
958 BRANCH(RTN2)
959 L_CMPILA:
960 SAVSTK();
961 if (FORBLK(NORET) == 1)
962 goto L_CERR12;
963 if (D_A(BRTYPE) == EOSTYP)
964 BRANCH(RTN3)
965 D_A(CMOFCL) += DESCR;
966 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(INITCL);
967 D_A(CMOFCL) += DESCR;
968 D(FRNCL) = D(CMOFCL);
969 D_A(CMOFCL) += DESCR;
970 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(LNNOCL);
971 D_A(CMOFCL) += DESCR;
972 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(FILENM);
973 if (D_A(BRTYPE) == NBTYP)
974 goto L_CMPSUB;
975 if (D_A(BRTYPE) == CLNTYP)
976 goto L_CMPGO;
977 else
978 goto L_CERR3;
979 /*_*/
980 L_CMPSUB:
981 SAVSTK();
982 switch (ELEMNT(SUBJND)) {
983 case 1:
984 goto L_CDIAG;
985 case 2:
986 BRANCH(COMP3)
987 }
988 SAVSTK();
989 if (FORBLK(NORET) == 1)
990 goto L_CERR5;
991 if (D_A(BRTYPE) != NBTYP)
992 goto L_CMPSB1;
993 if (D_A(SPITCL) == 0)
994 goto L_CMPAT2;
995 {
996 /* Sigh; this was in assembler in SNOBOL4+ [PLB32] */
997 register char *cp; /* [PLB33] */
998 cp = S_SP(TEXTSP); /* [PLB33] */
999 if (*cp == '?' && /* is break char '?' [PLB32] */
1000 (S_L(TEXTSP) == 1 || /* yes; is last char? [PLB32] */
1001 cp[1] == ' ' || cp[1] == '\t')) { /* or next is white? [PLB33] */
1002 S_O(TEXTSP)++; /* binary ? found. [PLB32] */
1003 S_L(TEXTSP)--; /* remove from TEXTSP [PLB32] */
1004 } /* [PLB32] */
1005 }
1006 goto L_CMPATN;
1007 /*_*/
1008 L_CMPSB1:
1009 if (D_A(BRTYPE) == EQTYP)
1010 goto L_CMPFRM;
1011 SAVSTK();
1012 PUSH(SUBJND);
1013 TREPUB(NORET);
1014 if (D_A(BRTYPE) == CLNTYP)
1015 goto L_CMPGO;
1016 if (D_A(BRTYPE) == EOSTYP)
1017 goto L_CMPNGO;
1018 else
1019 goto L_CERR5;
1020 /*_*/
1021 L_CMPATN:
1022 SAVSTK();
1023 PUSH(CNDSIZ);
1024 BLOCK(EXOPND);
1025 D(D_A(EXOPND) + CODE) = D(SCANCL);
1026 D_V(D_A(EXOPND) + CODE) = D_V(ZEROCL);
1027 ADDSON(EXOPND,SUBJND);
1028 D(EXPRND) = D(SUBJND);
1029 SAVSTK();
1030 switch (EXPR1(PATND)) {
1031 case 1:
1032 goto L_CDIAG;
1033 case 2:
1034 goto L_CMPAT1;
1035 }
1036 /*_*/
1037 L_CMPAT2:
1038 SAVSTK();
1039 if (EXPR(PATND) == 1)
1040 goto L_CDIAG;
1041 if (D_A(BRTYPE) == EQTYP)
1042 goto L_CMPASP;
1043 D_A(CMOFCL) += DESCR;
1044 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(SCANCL);
1045 SAVSTK();
1046 PUSH(SUBJND);
1047 TREPUB(NORET);
1048 L_CMPAT1:
1049 SAVSTK();
1050 PUSH(PATND);
1051 TREPUB(NORET);
1052 L_CMPTGO:
1053 if (D_A(BRTYPE) == EOSTYP)
1054 goto L_CMPNGO;
1055 if (D_A(BRTYPE) == CLNTYP)
1056 goto L_CMPGO;
1057 else
1058 goto L_CERR5;
1059 /*_*/
1060 L_CMPFRM:
1061 SAVSTK();
1062 if (EXPR(FORMND) == 1)
1063 goto L_CDIAG;
1064 D_A(CMOFCL) += DESCR;
1065 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(ASGNCL);
1066 SAVSTK();
1067 PUSH(SUBJND);
1068 TREPUB(NORET);
1069 goto L_CMPFT;
1070 /*_*/
1071 L_CMPASP:
1072 SAVSTK();
1073 if (EXPR(FORMND) == 1)
1074 goto L_CDIAG;
1075 D_A(CMOFCL) += DESCR;
1076 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(SJSRCL);
1077 SAVSTK();
1078 PUSH(SUBJND);
1079 TREPUB(NORET);
1080 SAVSTK();
1081 PUSH(PATND);
1082 TREPUB(NORET);
1083 L_CMPFT:
1084 SAVSTK();
1085 PUSH(FORMND);
1086 if (TREPUB(NORET) == 1)
1087 goto L_CMPTGO;
1088 /*_*/
1089 L_CMPNGO:
1090 D_V(CSTNCL) = D_A(CMOFCL);
1091 D(D_A(CMBSCL) + D_A(FRNCL)) = D(CSTNCL);
1092 D_V(CSTNCL) = I;
1093 BRANCH(RTN3)
1094 /*_*/
1095 L_CMPGO:
1096 SAVSTK();
1097 if (FORWRD(NORET) == 1)
1098 BRANCH(COMP3)
1099 if (D_A(BRTYPE) == EOSTYP)
1100 goto L_CMPNGO;
1101 if (D_A(BRTYPE) != NBTYP)
1102 goto L_CERR11;
1103 switch (STREAM(XSP, TEXTSP, &GOTOTB)) {
1104 case ST_ERROR:
1105 goto L_CERR11;
1106 case ST_EOS:
1107 goto L_CERR12;
1108 }
1109 D(GOGOCL) = D(GOTLCL);
1110 D_A(GOBRCL) = (int_t) RPTYP;
1111 if (D_A(STYPE) <= D_A(GTOCL))
1112 goto L_CMPGG;
1113 D(GOGOCL) = D(GOTGCL);
1114 D_A(GOBRCL) = (int_t) RBTYP;
1115 L_CMPGG:
1116 switch (D_A(STYPE)) {
1117 case 2:
1118 goto L_CMPSGO;
1119 case 3:
1120 goto L_CMPFGO;
1121 case 5:
1122 goto L_CMPSGO;
1123 case 6:
1124 goto L_CMPFGO;
1125 }
1126 L_CMPUGO:
1127 D_V(CSTNCL) = D_A(CMOFCL);
1128 D(D_A(CMBSCL) + D_A(FRNCL)) = D(CSTNCL);
1129 D_V(CSTNCL) = I;
1130 SAVSTK();
1131 if (EXPR(GOTOND) == 1)
1132 goto L_CDIAG;
1133 if (D_A(BRTYPE) != D_A(GOBRCL))
1134 goto L_CERR11;
1135 D_A(CMOFCL) += DESCR;
1136 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(GOGOCL);
1137 SAVSTK();
1138 PUSH(GOTOND);
1139 TREPUB(NORET);
1140 SAVSTK();
1141 if (FORWRD(NORET) == 1)
1142 BRANCH(COMP3)
1143 if (D_A(BRTYPE) == EOSTYP)
1144 BRANCH(RTN3)
1145 else
1146 goto L_CERR11;
1147 /*_*/
1148 L_CMPSGO:
1149 SAVSTK();
1150 if (EXPR(SGOND) == 1)
1151 goto L_CDIAG;
1152 if (D_A(BRTYPE) != D_A(GOBRCL))
1153 goto L_CERR11;
1154 D_A(CMOFCL) += DESCR;
1155 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(GOGOCL);
1156 SAVSTK();
1157 PUSH(SGOND);
1158 TREPUB(NORET);
1159 SAVSTK();
1160 if (FORWRD(NORET) == 1)
1161 BRANCH(COMP3)
1162 if (D_A(BRTYPE) != EOSTYP)
1163 goto L_CMPILL;
1164 D_V(CSTNCL) = D_A(CMOFCL);
1165 D(D_A(CMBSCL) + D_A(FRNCL)) = D(CSTNCL);
1166 D_V(CSTNCL) = I;
1167 BRANCH(RTN3)
1168 /*_*/
1169 L_CMPILL:
1170 if (D_A(BRTYPE) != NBTYP)
1171 goto L_CERR11;
1172 switch (STREAM(XSP, TEXTSP, &GOTOTB)) {
1173 case ST_ERROR:
1174 goto L_CERR11;
1175 case ST_EOS:
1176 goto L_CERR12;
1177 }
1178 if (D_A(STYPE) != FGOTYP)
1179 goto L_CMPFTC;
1180 D(GOGOCL) = D(GOTLCL);
1181 D_A(GOBRCL) = (int_t) RPTYP;
1182 goto L_CMPUGO;
1183 /*_*/
1184 L_CMPFTC:
1185 if (D_A(STYPE) != FTOTYP)
1186 goto L_CERR11;
1187 D(GOGOCL) = D(GOTGCL);
1188 D_A(GOBRCL) = (int_t) RBTYP;
1189 goto L_CMPUGO;
1190 /*_*/
1191 L_CMPFGO:
1192 SAVSTK();
1193 if (EXPR(FGOND) == 1)
1194 goto L_CDIAG;
1195 if (D_A(BRTYPE) != D_A(GOBRCL))
1196 goto L_CERR11;
1197 SAVSTK();
1198 if (FORWRD(NORET) == 1)
1199 BRANCH(COMP3)
1200 if (D_A(BRTYPE) != EOSTYP)
1201 goto L_CMPILM;
1202 D_A(CMOFCL) += DESCR;
1203 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(GOTOCL);
1204 D_A(CMOFCL) += DESCR;
1205 D(SRNCL) = D(CMOFCL);
1206 D_V(CSTNCL) = D_A(CMOFCL);
1207 D(D_A(CMBSCL) + D_A(FRNCL)) = D(CSTNCL);
1208 D_V(CSTNCL) = I;
1209 D_A(CMOFCL) += DESCR;
1210 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(GOGOCL);
1211 SAVSTK();
1212 PUSH(FGOND);
1213 TREPUB(NORET);
1214 D(D_A(CMBSCL) + D_A(SRNCL)) = D(CMOFCL);
1215 BRANCH(RTN3)
1216 /*_*/
1217 L_CMPILM:
1218 if (D_A(BRTYPE) != NBTYP)
1219 goto L_CERR11;
1220 switch (STREAM(XSP, TEXTSP, &GOTOTB)) {
1221 case ST_ERROR:
1222 goto L_CERR11;
1223 case ST_EOS:
1224 goto L_CERR12;
1225 }
1226 if (D_A(STYPE) != SGOTYP)
1227 goto L_CMPSTC;
1228 PUSH(GOTLCL);
1229 D_A(GOBRCL) = (int_t) RPTYP;
1230 goto L_CMPILN;
1231 /*_*/
1232 L_CMPSTC:
1233 if (D_A(STYPE) != STOTYP)
1234 goto L_CERR11;
1235 PUSH(GOTGCL);
1236 D_A(GOBRCL) = (int_t) RBTYP;
1237 L_CMPILN:
1238 SAVSTK();
1239 if (EXPR(SGOND) == 1)
1240 goto L_CDIAG;
1241 if (D_A(BRTYPE) != D_A(GOBRCL))
1242 goto L_CERR11;
1243 SAVSTK();
1244 if (FORWRD(NORET) == 1)
1245 BRANCH(COMP3)
1246 if (D_A(BRTYPE) != EOSTYP)
1247 goto L_CERR11;
1248 D_A(CMOFCL) += DESCR;
1249 POP(WCL);
1250 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(WCL);
1251 SAVSTK();
1252 PUSH(SGOND);
1253 TREPUB(NORET);
1254 D_V(CSTNCL) = D_A(CMOFCL);
1255 D(D_A(CMBSCL) + D_A(FRNCL)) = D(CSTNCL);
1256 D_V(CSTNCL) = I;
1257 D_A(CMOFCL) += DESCR;
1258 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(GOGOCL);
1259 SAVSTK();
1260 PUSH(FGOND);
1261 if (TREPUB(NORET) == 1)
1262 BRANCH(RTN3)
1263 /*_*/
1264 L_CERR1:
1265 D_A(EMSGCL) = (int_t) EMSG1;
1266 goto L_CDIAG;
1267 /*_*/
1268 L_CERR2:
1269 D_A(EMSGCL) = (int_t) EMSG2;
1270 goto L_CDIAG;
1271 /*_*/
1272 L_CERR3:
1273 D_A(EMSGCL) = (int_t) EMSG3;
1274 goto L_CDIAG;
1275 /*_*/
1276 L_CERR5:
1277 D_A(EMSGCL) = (int_t) ILLBRK;
1278 goto L_CDIAG;
1279 /*_*/
1280 L_CERR12:
1281 D_A(EMSGCL) = (int_t) ILLEOS;
1282 goto L_CDIAG;
1283 /*_*/
1284 L_CERR11:
1285 D_A(EMSGCL) = (int_t) EMSG14;
1286 L_CDIAG:
1287 D_A(BOSCL) += DESCR;
1288 D(D_A(CMBSCL) + D_A(BOSCL)) = D(ERORCL);
1289 D_A(BOSCL) += DESCR;
1290 D(D_A(CMBSCL) + D_A(BOSCL)) = D(CSTNCL);
1291 D_A(BOSCL) += DESCR;
1292 D(D_A(CMBSCL) + D_A(BOSCL)) = D(LNNOCL);
1293 D_A(BOSCL) += DESCR;
1294 D(D_A(CMBSCL) + D_A(BOSCL)) = D(FILENM);
1295 D(CMOFCL) = D(BOSCL);
1296 D_A(ESAICL) += DESCR;
1297 if (D_A(ESAICL) > D_A(ESALIM))
1298 BRANCH(COMP9)
1299 if (D_A(COMPCL) == 0)
1300 goto L_CDIAG4;
1301 {
1302 char *sp, *dp; /* src ptr, desr ptr [PLB40] */
1303 int len; /* src char count [PLB40] */
1304 sp = INBUF + STNOSZ; /* get start of statement buffer [PLB40] */
1305 len = S_O(TEXTSP); /* number of spaces/tabs to skip [PLB77] */
1306 S_L(ERRSP) = len + 1; /* set pointer line length [PLB77] */
1307 dp = ERRBUF + STNOSZ; /* get start of marker buffer [PLB40] */
1308 while (len-- > STNOSZ) { /* for all chars in statement [PLB77] */
1309 if (*sp++ == '\t') /* if tab [PLB77] */
1310 *dp++ = '\t'; /* put tab in errbuf [PLB40] */
1311 else /* else [PLB40] */
1312 *dp++ = ' '; /* put space [PLB40] */
1313 } /* [PLB40] */
1314 *dp++ = '^'; /* store pointer [PLB40] */
1315 }
1316 IO_PRINT(IOKEY, ERRBLK, LNBFSP);
1317 IO_PRINT(IOKEY, ERRBLK, ERRSP);
1318 if (D_A(LISTCL) == 0)
1319 goto L_CDIAG2;
1320 IO_PRINT(IOKEY, OUTBLK, LNBFSP);
1321 IO_PRINT(IOKEY, OUTBLK, ERRSP);
1322 L_CDIAG2:
1323 _SPEC(TSP) = _SPEC(D_A(EMSGCL));
1324 S_L(CERRSP) = 0;
1325 X_LOCSP(XSP,FILENM);
1326 APDSP(CERRSP,XSP);
1327 APDSP(CERRSP,COLSP);
1328 INTSPC(XSP,LNNOCL);
1329 APDSP(CERRSP,XSP);
1330 APDSP(CERRSP,COLSP);
1331 APDSP(CERRSP,SPCSP);
1332 APDSP(CERRSP,STARSP);
1333 APDSP(CERRSP,TSP);
1334 if (D_A(LISTCL) == 0)
1335 goto L_CDIAG1;
1336 IO_PRINT(IOKEY, OUTBLK, CERRSP);
1337 IO_PRINT(IOKEY, OUTBLK, BLSP);
1338 L_CDIAG1:
1339 IO_PRINT(IOKEY, ERRBLK, CERRSP);
1340 IO_PRINT(IOKEY, ERRBLK, BLSP);
1341 L_CDIAG4:
1342 SAVSTK();
1343 PUSH(EMSGCL);
1344 GENVAR(ERRTXT);
1345 if (D_A(UNIT) == 0)
1346 BRANCH(RTN1)
1347 if (D_A(BRTYPE) == EOSTYP)
1348 BRANCH(RTN3)
1349 switch (STREAM(XSP, TEXTSP, &EOSTB)) {
1350 case ST_ERROR:
1351 BRANCH(COMP3)
1352 case ST_STOP:
1353 BRANCH(RTN3)
1354 }
1355 L_DIAGRN:
1356 _SPEC(TEXTSP) = _SPEC(NEXTSP);
1357 switch (IO_READ(UNIT, TEXTSP)) {
1358 case IO_EOF:
1359 goto L_DIAGIN;
1360 case IO_ERR:
1361 BRANCH(COMP1)
1362 }
1363 D_A(TMVAL) = S_L(TEXTSP);
1364 D_F(TMVAL) = D_V(TMVAL) = 0;
1365 D_A(TMVAL) += STNOSZ;
1366 S_L(LNBFSP) = D_A(TMVAL);
1367 D_A(LNNOCL)++;
1368 switch (STREAM(XSP, TEXTSP, &CARDTB)) {
1369 case ST_ERROR:
1370 BRANCH(COMP3)
1371 case ST_EOS:
1372 goto L_CDIAG7;
1373 }
1374 SAVSTK();
1375 switch (NEWCRD(NORET)) {
1376 case 3:
1377 BRANCH(RTN3)
1378 }
1379 L_CDIAG7:
1380 if (D_A(LISTCL) == 0)
1381 goto L_DIAGRN;
1382 IO_PRINT(IOKEY, OUTBLK, LNBFSP);
1383 goto L_DIAGRN;
1384 /*_*/
1385 L_DIAGIN:
1386 SAVSTK();
1387 FILCHK(NORET);
1388 goto L_DIAGRN;
1389 /*_*/
1390 }
1391 static int
ELEMNT(ret_t retval)1392 ELEMNT(ret_t retval) {
1393 ENTRY(ELEMNT)
1394 SAVSTK();
1395 if (UNOP(ELEMND) == 1)
1396 BRANCH(RTN2)
1397 switch (STREAM(XSP, TEXTSP, &ELEMTB)) {
1398 case ST_ERROR:
1399 BRANCH(ELEICH)
1400 case ST_EOS:
1401 BRANCH(ELEILI)
1402 }
1403 /* FALL */
1404 BRANCH(ELEMN9)
1405 }
1406 static int
ELEMN9(ret_t retval)1407 ELEMN9(ret_t retval) {
1408 ENTRY(ELEMN9)
1409 switch (D_A(STYPE)) {
1410 case 2:
1411 goto L_ELEILT;
1412 case 3:
1413 goto L_ELEVBL;
1414 case 4:
1415 goto L_ELENST;
1416 case 5:
1417 goto L_ELEFNC;
1418 case 6:
1419 goto L_ELEFLT;
1420 case 7:
1421 goto L_ELEARY;
1422 }
1423 S_L(XSP)--;
1424 S_O(XSP)++;
1425 S_L(XSP)--;
1426 SAVSTK();
1427 PUSH(XSPPTR);
1428 GENVAR(XPTR);
1429 L_ELEMN5:
1430 SAVSTK();
1431 PUSH(CNDSIZ);
1432 BLOCK(ELEXND);
1433 D(D_A(ELEXND) + CODE) = D(LITCL);
1434 SAVSTK();
1435 PUSH(CNDSIZ);
1436 BLOCK(ELEYND);
1437 D(D_A(ELEYND) + CODE) = D(XPTR);
1438 ADDSON(ELEXND,ELEYND);
1439 L_ELEMN1:
1440 if (D_A(ELEMND) != 0)
1441 goto L_ELEMN6;
1442 D(ZPTR) = D(ELEXND);
1443 goto L_ELEMRR;
1444 /*_*/
1445 L_ELEMN6:
1446 ADDSON(ELEMND,ELEXND);
1447 L_ELEMNR:
1448 D(ZPTR) = D(ELEMND);
1449 L_ELEMRR:
1450 if (D_A(D_A(ZPTR) + FATHER) == (int_t)0)
1451 goto L_ELEM10;
1452 D(ZPTR) = D(D_A(ZPTR) + FATHER);
1453 goto L_ELEMRR;
1454 /*_*/
1455 L_ELEM10:
1456 switch (STREAM(XSP, TEXTSP, &GOTSTB)) {
1457 case ST_ERROR:
1458 case ST_EOS:
1459 BRANCH(RTZPTR)
1460 }
1461 if (D_A(STYPE) == SGOTYP)
1462 BRANCH(ELECMA)
1463 D(ELEMND) = D(ZEROCL);
1464 D(ELEXND) = D(ZPTR);
1465 goto L_ELEAR2;
1466 /*_*/
1467 L_ELEILT:
1468 if (SPCINT(XPTR,XSP))
1469 goto L_ELEMN5;
1470 else
1471 BRANCH(ELEINT)
1472 /*_*/
1473 L_ELEFLT:
1474 if (SPREAL(XPTR,XSP))
1475 goto L_ELEMN5;
1476 else
1477 BRANCH(ELEDEC)
1478 /*_*/
1479 L_ELEVBL:
1480 SAVSTK();
1481 PUSH(XSPPTR);
1482 GENVUP(XPTR);
1483 SAVSTK();
1484 PUSH(CNDSIZ);
1485 BLOCK(ELEXND);
1486 D(D_A(ELEXND) + CODE) = D(XPTR);
1487 goto L_ELEMN1;
1488 /*_*/
1489 L_ELENST:
1490 PUSH(ELEMND);
1491 SAVSTK();
1492 if (EXPR(ELEXND) == 1)
1493 BRANCH(RTN1)
1494 POP(ELEMND);
1495 if (D_A(BRTYPE) == RPTYP)
1496 goto L_ELEMN1;
1497 if (D_A(SPITCL) == 0)
1498 BRANCH(ELECMA)
1499 if (D_A(BRTYPE) != CMATYP)
1500 BRANCH(ELECMA)
1501 SAVSTK();
1502 PUSH(CMACL);
1503 if (ELEARG(NORET) == 1)
1504 BRANCH(RTN1)
1505 if (D_A(BRTYPE) == RPTYP)
1506 goto L_ELEMNR;
1507 else
1508 BRANCH(ELECMA)
1509 /*_*/
1510 L_ELEFNC:
1511 S_L(XSP)--;
1512 SAVSTK();
1513 PUSH(XSPPTR);
1514 GENVUP(XPTR);
1515 SAVSTK();
1516 PUSH(XPTR);
1517 FINDEX(XCL);
1518 SAVSTK();
1519 PUSH(CNDSIZ);
1520 BLOCK(ELEXND);
1521 D(D_A(ELEXND) + CODE) = D(XCL);
1522 if (D_A(ELEMND) == 0)
1523 goto L_ELEMN7;
1524 ADDSON(ELEMND,ELEXND);
1525 L_ELEMN7:
1526 PUSH(ELEXND);
1527 SAVSTK();
1528 if (EXPR(ELEXND) == 1)
1529 BRANCH(RTN1)
1530 POP(ELEMND);
1531 ADDSON(ELEMND,ELEXND);
1532 D(ELEMND) = D(ELEXND);
1533 L_ELEMN2:
1534 if (D_A(BRTYPE) == RPTYP)
1535 goto L_ELEMN3;
1536 if (D_A(BRTYPE) != CMATYP)
1537 BRANCH(ELECMA)
1538 PUSH(ELEMND);
1539 SAVSTK();
1540 if (EXPR(ELEXND) == 1)
1541 BRANCH(RTN1)
1542 POP(ELEMND);
1543 ADDSIB(ELEMND,ELEXND);
1544 D(ELEMND) = D(ELEXND);
1545 goto L_ELEMN2;
1546 /*_*/
1547 L_ELEMN3:
1548 D(ELEXND) = D(D_A(ELEMND) + FATHER);
1549 D(XCL) = D(D_A(ELEXND) + CODE);
1550 D(YCL) = D(D_A(XCL));
1551 if ((D_F(YCL) & FNC))
1552 goto L_ELEMNR;
1553 D_A(XCL) = D_V(XCL);
1554 D_F(XCL) = D_V(XCL) = 0;
1555 D_A(YCL) = D_V(YCL);
1556 D_F(YCL) = D_V(YCL) = 0;
1557 L_ELEMN4:
1558 if (D_A(XCL) >= D_A(YCL))
1559 goto L_ELEMNR;
1560 SAVSTK();
1561 PUSH(CNDSIZ);
1562 BLOCK(ELEYND);
1563 D(D_A(ELEYND) + CODE) = D(LITCL);
1564 SAVSTK();
1565 PUSH(CNDSIZ);
1566 BLOCK(ELEXND);
1567 D(D_A(ELEXND) + CODE) = D(NULVCL);
1568 ADDSON(ELEYND,ELEXND);
1569 ADDSIB(ELEMND,ELEYND);
1570 D(ELEMND) = D(ELEYND);
1571 D_A(XCL)++;
1572 goto L_ELEMN4;
1573 /*_*/
1574 L_ELEARY:
1575 S_L(XSP)--;
1576 SAVSTK();
1577 PUSH(XSPPTR);
1578 GENVUP(XPTR);
1579 SAVSTK();
1580 PUSH(CNDSIZ);
1581 BLOCK(ELEXND);
1582 D(D_A(ELEXND) + CODE) = D(XPTR);
1583 L_ELEAR2:
1584 SAVSTK();
1585 PUSH(ITEMCL);
1586 if (ELEARG(NORET) == 1)
1587 BRANCH(RTN1)
1588 if (D_A(BRTYPE) == RBTYP)
1589 goto L_ELEMNR;
1590 else
1591 BRANCH(ELECMA)
1592 /*_*/
1593 }
1594 static int
ELEARG(ret_t retval)1595 ELEARG(ret_t retval) {
1596 ENTRY(ELEARG)
1597 POP(XCL);
1598 SAVSTK();
1599 PUSH(CNDSIZ);
1600 BLOCK(XPTR);
1601 D(D_A(XPTR) + CODE) = D(XCL);
1602 if (D_A(ELEMND) == 0)
1603 goto L_ELEMN8;
1604 ADDSON(ELEMND,XPTR);
1605 L_ELEMN8:
1606 ADDSON(XPTR,ELEXND);
1607 D(ELEMND) = D(ELEXND);
1608 L_ELEAR1:
1609 PUSH(ELEMND);
1610 SAVSTK();
1611 if (EXPR(ELEXND) == 1)
1612 BRANCH(RTN1)
1613 POP(ELEMND);
1614 ADDSIB(ELEMND,ELEXND);
1615 D(ELEMND) = D(ELEXND);
1616 if (D_A(BRTYPE) == CMATYP)
1617 goto L_ELEAR1;
1618 else
1619 BRANCH(RTN2)
1620 /*_*/
1621 }
1622 static int
ELEICH(ret_t retval)1623 ELEICH(ret_t retval) {
1624 ENTRY(ELEICH)
1625 D_A(EMSGCL) = (int_t) ILCHAR;
1626 BRANCH(RTN1)
1627 /*_*/
1628 }
1629 static int
ELEILI(ret_t retval)1630 ELEILI(ret_t retval) {
1631 ENTRY(ELEILI)
1632 if (D_A(STYPE) == 0)
1633 BRANCH(ELEICH)
1634 if (D_A(STYPE) != QLITYP)
1635 BRANCH(ELEMN9)
1636 D_A(EMSGCL) = (int_t) OPNLIT;
1637 BRANCH(RTN1)
1638 /*_*/
1639 }
1640 static int
ELEINT(ret_t retval)1641 ELEINT(ret_t retval) {
1642 ENTRY(ELEINT)
1643 D_A(EMSGCL) = (int_t) ILLINT;
1644 BRANCH(RTN1)
1645 /*_*/
1646 }
1647 static int
ELEDEC(ret_t retval)1648 ELEDEC(ret_t retval) {
1649 ENTRY(ELEDEC)
1650 D_A(EMSGCL) = (int_t) ILLDEC;
1651 BRANCH(RTN1)
1652 /*_*/
1653 }
1654 static int
ELECMA(ret_t retval)1655 ELECMA(ret_t retval) {
1656 ENTRY(ELECMA)
1657 D_A(EMSGCL) = (int_t) ILLBRK;
1658 BRANCH(RTN1)
1659 /*_*/
1660 }
1661 static int
EXPR(ret_t retval)1662 EXPR(ret_t retval) {
1663 ENTRY(EXPR)
1664 SAVSTK();
1665 switch (ELEMNT(EXELND)) {
1666 case 1:
1667 BRANCH(RTN1)
1668 case 2:
1669 goto L_EXPNUL;
1670 }
1671 D_A(EXPRND) = 0;
1672 BRANCH(EXPR2)
1673 /*_*/
1674 L_EXPNUL:
1675 SAVSTK();
1676 if (NULNOD(XPTR) == 1)
1677 BRANCH(RTXNAM)
1678 /*_*/
1679 }
1680 static int
EXPR1(ret_t retval)1681 EXPR1(ret_t retval) {
1682 ENTRY(EXPR1)
1683 PUSH(EXPRND);
1684 SAVSTK();
1685 switch (ELEMNT(EXELND)) {
1686 case 1:
1687 BRANCH(RTN1)
1688 case 2:
1689 goto L_EXPR12;
1690 }
1691 POP(EXPRND);
1692 BRANCH(EXPR2)
1693 /*_*/
1694 L_EXPR12:
1695 if (D_A(SPITCL) == 0)
1696 goto L_EXPERR;
1697 if (D_A(D_A(EXOPND) + CODE) == (int_t)BISRFN)
1698 goto L_EXPR17;
1699 if (D_A(D_A(EXOPND) + CODE) != (int_t)BIEQFN)
1700 goto L_EXPERR;
1701 L_EXPR17:
1702 SAVSTK();
1703 if (NULNOD(EXELND) == 1)
1704 goto L_EXPR13;
1705 /*_*/
1706 L_EXPR13:
1707 POP(EXPRND);
1708 BRANCH(EXPR7)
1709 /*_*/
1710 L_EXPERR:
1711 D_A(EMSGCL) = (int_t) ILLEOS;
1712 BRANCH(RTN1)
1713 /*_*/
1714 }
1715 static int
EXPR2(ret_t retval)1716 EXPR2(ret_t retval) {
1717 ENTRY(EXPR2)
1718 SAVSTK();
1719 switch (BINOP(EXOPCL)) {
1720 case 1:
1721 BRANCH(RTN1)
1722 case 2:
1723 BRANCH(EXPR7)
1724 }
1725 if (D_A(SPITCL) == 0)
1726 goto L_EXPR14;
1727 if (D_A(EXOPCL) != D_A(ASGNCL))
1728 goto L_EXPR14;
1729 if (D_A(EXPRND) == 0)
1730 goto L_EXPR14;
1731 D(EXOPND) = D(EXPRND);
1732 L_EXPR15:
1733 D(EXEXND) = D(EXOPND);
1734 if (D_A(D_A(EXEXND) + FATHER) == (int_t)0)
1735 goto L_EXPR14;
1736 D(EXOPND) = D(D_A(EXEXND) + FATHER);
1737 if (D_A(D_A(EXOPND) + CODE) != (int_t)BISNFN)
1738 goto L_EXPR15;
1739 D_A(D_A(EXOPND) + CODE) = D_A(SJSRCL);
1740 ADDSIB(EXPRND,EXELND);
1741 D(EXPRND) = D(EXELND);
1742 L_EXPR16:
1743 D(EXOPND) = D(D_A(EXPRND) + FATHER);
1744 if (D_A(D_A(EXOPND) + FATHER) == (int_t)0)
1745 BRANCH(EXPR1)
1746 D(EXPRND) = D(EXOPND);
1747 goto L_EXPR16;
1748 /*_*/
1749 L_EXPR14:
1750 SAVSTK();
1751 PUSH(CNDSIZ);
1752 BLOCK(EXOPND);
1753 D(D_A(EXOPND) + CODE) = D(EXOPCL);
1754 if (D_A(EXPRND) != 0)
1755 goto L_EXPR3;
1756 ADDSON(EXOPND,EXELND);
1757 D(EXPRND) = D(EXELND);
1758 BRANCH(EXPR1)
1759 /*_*/
1760 L_EXPR3:
1761 D(EXOPCL) = D(D_A(EXOPCL) + 2*DESCR);
1762 D_A(EXOPCL) = D_V(EXOPCL);
1763 D_F(EXOPCL) = D_V(EXOPCL) = 0;
1764 D(EXEXND) = D(D_A(EXPRND) + FATHER);
1765 D(XPTR) = D(D_A(EXEXND) + CODE);
1766 D(XPTR) = D(D_A(XPTR) + 2*DESCR);
1767 if (D_A(XPTR) > D_A(EXOPCL))
1768 goto L_EXPR4;
1769 ADDSIB(EXPRND,EXOPND);
1770 D(EXPRND) = D(EXOPND);
1771 ADDSON(EXPRND,EXELND);
1772 D(EXPRND) = D(EXELND);
1773 BRANCH(EXPR1)
1774 /*_*/
1775 L_EXPR4:
1776 ADDSIB(EXPRND,EXELND);
1777 L_EXPR5:
1778 if (D_A(D_A(EXPRND) + FATHER) == (int_t)0)
1779 goto L_EXPR11;
1780 D(EXPRND) = D(D_A(EXPRND) + FATHER);
1781 if (D_A(D_A(EXPRND) + FATHER) == (int_t)0)
1782 goto L_EXPR11;
1783 D(EXEXND) = D(D_A(EXPRND) + FATHER);
1784 D(XPTR) = D(D_A(EXEXND) + CODE);
1785 D(XPTR) = D(D_A(XPTR) + 2*DESCR);
1786 if (D_A(XPTR) > D_A(EXOPCL))
1787 goto L_EXPR5;
1788 X_INSERT(EXPRND,EXOPND);
1789 BRANCH(EXPR1)
1790 /*_*/
1791 L_EXPR11:
1792 ADDSON(EXOPND,EXPRND);
1793 BRANCH(EXPR1)
1794 /*_*/
1795 }
1796 static int
EXPR7(ret_t retval)1797 EXPR7(ret_t retval) {
1798 ENTRY(EXPR7)
1799 if (D_A(EXPRND) != 0)
1800 goto L_EXPR10;
1801 D(XPTR) = D(EXELND);
1802 goto L_EXPR9;
1803 /*_*/
1804 L_EXPR10:
1805 ADDSIB(EXPRND,EXELND);
1806 D(XPTR) = D(EXPRND);
1807 L_EXPR9:
1808 if (D_A(D_A(XPTR) + FATHER) == (int_t)0)
1809 BRANCH(RTXNAM)
1810 D(XPTR) = D(D_A(XPTR) + FATHER);
1811 goto L_EXPR9;
1812 /*_*/
1813 }
1814 static int
NULNOD(ret_t retval)1815 NULNOD(ret_t retval) {
1816 ENTRY(NULNOD)
1817 SAVSTK();
1818 PUSH(CNDSIZ);
1819 BLOCK(EXPRND);
1820 D(D_A(EXPRND) + CODE) = D(LITCL);
1821 SAVSTK();
1822 PUSH(CNDSIZ);
1823 BLOCK(EXEXND);
1824 D(D_A(EXEXND) + CODE) = D(NULVCL);
1825 ADDSON(EXPRND,EXEXND);
1826 D(retval) = D(EXPRND);
1827 RETURN(1)
1828 /*_*/
1829 }
1830 static int
FORWRD(ret_t retval)1831 FORWRD(ret_t retval) {
1832 ENTRY(FORWRD)
1833 switch (STREAM(XSP, TEXTSP, &FRWDTB)) {
1834 case ST_ERROR:
1835 BRANCH(COMP3)
1836 case ST_EOS:
1837 BRANCH(FORRUN)
1838 }
1839 /* FALL */
1840 BRANCH(FORJRN)
1841 }
1842 static int
FORJRN(ret_t retval)1843 FORJRN(ret_t retval) {
1844 ENTRY(FORJRN)
1845 D(BRTYPE) = D(STYPE);
1846 BRANCH(RTN2)
1847 /*_*/
1848 }
1849 static int
FORRUN(ret_t retval)1850 FORRUN(ret_t retval) {
1851 ENTRY(FORRUN)
1852 L_FORRN0:
1853 if (D_A(UNIT) == 0)
1854 goto L_FOREOS;
1855 if (D_A(LISTCL) == 0)
1856 goto L_FORRUR;
1857 IO_PRINT(IOKEY, OUTBLK, LNBFSP);
1858 L_FORRUR:
1859 _SPEC(TEXTSP) = _SPEC(NEXTSP);
1860 switch (IO_READ(UNIT, TEXTSP)) {
1861 case IO_EOF:
1862 goto L_FORINC;
1863 case IO_ERR:
1864 BRANCH(COMP1)
1865 }
1866 D_A(TMVAL) = S_L(TEXTSP);
1867 D_F(TMVAL) = D_V(TMVAL) = 0;
1868 D_A(TMVAL) += STNOSZ;
1869 S_L(LNBFSP) = D_A(TMVAL);
1870 D_A(LNNOCL)++;
1871 switch (STREAM(XSP, TEXTSP, &CARDTB)) {
1872 case ST_ERROR:
1873 BRANCH(COMP3)
1874 case ST_EOS:
1875 goto L_FORRN0;
1876 }
1877 SAVSTK();
1878 switch (NEWCRD(NORET)) {
1879 case 1:
1880 goto L_FORRN0;
1881 case 2:
1882 BRANCH(FORWRD)
1883 }
1884 L_FOREOS:
1885 D(BRTYPE) = D(EOSCL);
1886 BRANCH(RTN2)
1887 /*_*/
1888 L_FORINC:
1889 SAVSTK();
1890 FILCHK(NORET);
1891 goto L_FORRUR;
1892 /*_*/
1893 }
1894 static int
FORBLK(ret_t retval)1895 FORBLK(ret_t retval) {
1896 ENTRY(FORBLK)
1897 switch (STREAM(XSP, TEXTSP, &IBLKTB)) {
1898 case ST_ERROR:
1899 BRANCH(RTN1)
1900 case ST_EOS:
1901 BRANCH(FORRUN)
1902 case ST_STOP:
1903 BRANCH(FORJRN)
1904 }
1905 /*_*/
1906 }
1907 static int
FILCHK(ret_t retval)1908 FILCHK(ret_t retval) {
1909 ENTRY(FILCHK)
1910 if (D_A(INCSTK) == 0)
1911 goto L_FILCK2;
1912 D(LNNOCL) = D(D_A(INCSTK) + 2*DESCR);
1913 D(FILENM) = D(D_A(INCSTK) + 3*DESCR);
1914 D(INCSTK) = D(D_A(INCSTK) + DESCR);
1915 BRANCH(RTN2)
1916 /*_*/
1917 L_FILCK2:
1918 if (!IO_FILE(UNIT,XSP))
1919 BRANCH(RTN1)
1920 SAVSTK();
1921 PUSH(XSPPTR);
1922 GENVAR(FILENM);
1923 D_A(LNNOCL) = 0;
1924 BRANCH(RTN1)
1925 /*_*/
1926 }
1927 static int
NEWCRD(ret_t retval)1928 NEWCRD(ret_t retval) {
1929 ENTRY(NEWCRD)
1930 switch (D_A(STYPE)) {
1931 case 2:
1932 goto L_CMTCRD;
1933 case 3:
1934 goto L_CTLCRD;
1935 case 4:
1936 goto L_CNTCRD;
1937 }
1938 if (D_A(LISTCL) == 0)
1939 BRANCH(RTN3)
1940 D(XCL) = D(CSTNCL);
1941 D_A(XCL)++;
1942 INTSPC(TSP,XCL);
1943 if (D_A(LLIST) != 0)
1944 goto L_CARDL;
1945 IO_PAD(LNBFSP,CARDSZ+DSTSZ);
1946 S_L(RNOSP) = 0;
1947 APDSP(RNOSP,TSP);
1948 BRANCH(RTN3)
1949 /*_*/
1950 L_CARDL:
1951 S_L(LNOSP) = 0;
1952 APDSP(LNOSP,TSP);
1953 BRANCH(RTN3)
1954 /*_*/
1955 L_CMTCRD:
1956 if (D_A(LISTCL) == 0)
1957 BRANCH(RTN1)
1958 L_CMTCLR:
1959 S_L(LNOSP) = 0;
1960 S_L(RNOSP) = 0;
1961 APDSP(LNOSP,BLNSP);
1962 APDSP(RNOSP,BLNSP);
1963 BRANCH(RTN1)
1964 /*_*/
1965 L_CNTCRD:
1966 S_L(TEXTSP)--;
1967 S_O(TEXTSP)++;
1968 if (D_A(LISTCL) == 0)
1969 BRANCH(RTN2)
1970 INTSPC(TSP,CSTNCL);
1971 if (D_A(LLIST) != 0)
1972 goto L_CARDLL;
1973 IO_PAD(LNBFSP,CARDSZ+DSTSZ);
1974 S_L(RNOSP) = 0;
1975 APDSP(RNOSP,TSP);
1976 BRANCH(RTN2)
1977 /*_*/
1978 L_CARDLL:
1979 S_L(LNOSP) = 0;
1980 APDSP(LNOSP,TSP);
1981 BRANCH(RTN2)
1982 /*_*/
1983 L_CTLCRD:
1984 S_L(TEXTSP)--;
1985 S_O(TEXTSP)++;
1986 switch (STREAM(XSP, TEXTSP, &FRWDTB)) {
1987 case ST_ERROR:
1988 BRANCH(COMP3)
1989 case ST_EOS:
1990 goto L_CMTCRD;
1991 }
1992 if (D_A(STYPE) != NBTYP)
1993 goto L_CMTCRD;
1994 switch (STREAM(XSP, TEXTSP, &LBLXTB)) {
1995 case ST_ERROR:
1996 case ST_EOS:
1997 goto L_CMTCLR;
1998 }
1999 RAISE1(XSP);
2000 if (LEXEQ(XSP,UNLSP))
2001 goto L_UNLIST;
2002 if (LEXEQ(XSP,LISTSP))
2003 goto L_LIST;
2004 if (LEXEQ(XSP,EJCTSP))
2005 goto L_EJECT;
2006 if (LEXEQ(XSP,ERORSP))
2007 goto L_ERRORS;
2008 if (LEXEQ(XSP,NERRSP))
2009 goto L_NOERRS;
2010 if (LEXEQ(XSP,CASESP))
2011 goto L_CASE;
2012 if (LEXEQ(XSP,INCLSP))
2013 goto L_INCLUD;
2014 if (LEXEQ(XSP,COPYSP))
2015 goto L_INCLUD;
2016 if (LEXEQ(XSP,SPITSP))
2017 goto L_PLSOPS;
2018 if (LEXEQ(XSP,EXECSP))
2019 goto L_EXEC;
2020 if (LEXEQ(XSP,NEXESP))
2021 goto L_NOEXEC;
2022 if (LEXEQ(XSP,LINESP))
2023 goto L_LINE;
2024 if (LEXEQ(XSP,HIDESP))
2025 goto L_HIDE;
2026 if (LEXEQ(XSP,BLKSSP))
2027 goto L_BLOCKS;
2028 if (LEXEQ(XSP,NOBLSP))
2029 goto L_NOBLKS;
2030 goto L_CMTCLR;
2031 /*_*/
2032 L_HIDE:
2033 D_A(HIDECL) = 1;
2034 L_UNLIST:
2035 D_A(LISTCL) = 0;
2036 BRANCH(RTN1)
2037 /*_*/
2038 L_LIST:
2039 D_A(LISTCL) = 1;
2040 D_A(HIDECL) = 0;
2041 switch (STREAM(XSP, TEXTSP, &FRWDTB)) {
2042 case ST_ERROR:
2043 BRANCH(COMP3)
2044 case ST_EOS:
2045 goto L_CMTCLR;
2046 }
2047 if (D_A(STYPE) != NBTYP)
2048 goto L_CMTCLR;
2049 switch (STREAM(XSP, TEXTSP, &LBLXTB)) {
2050 case ST_ERROR:
2051 case ST_EOS:
2052 goto L_CMTCLR;
2053 }
2054 RAISE1(XSP);
2055 if (!LEXEQ(XSP,LEFTSP))
2056 goto L_CTLCR2;
2057 D_A(LLIST) = 1;
2058 goto L_CMTCLR;
2059 /*_*/
2060 L_CTLCR2:
2061 D_A(LLIST) = 0;
2062 goto L_CMTCLR;
2063 /*_*/
2064 L_EJECT:
2065 if (D_A(LISTCL) == 0)
2066 goto L_CMTCLR;
2067 io_printf(D_A(OUTPUT),EJECTF);
2068 goto L_CMTCLR;
2069 /*_*/
2070 L_ERRORS:
2071 D_A(NERRCL) = 0;
2072 goto L_CMTCLR;
2073 /*_*/
2074 L_NOERRS:
2075 D_A(NERRCL) = 1;
2076 goto L_CMTCLR;
2077 /*_*/
2078 L_CASE:
2079 switch (STREAM(XSP, TEXTSP, &FRWDTB)) {
2080 case ST_ERROR:
2081 BRANCH(COMP3)
2082 case ST_EOS:
2083 goto L_CASE1;
2084 }
2085 if (D_A(STYPE) != NBTYP)
2086 goto L_CMTCLR;
2087 switch (STREAM(XSP, TEXTSP, &ELEMTB)) {
2088 case ST_ERROR:
2089 case ST_EOS:
2090 goto L_CMTCLR;
2091 }
2092 if (D_A(STYPE) != ILITYP)
2093 goto L_CMTCLR;
2094 SPCINT(CASECL,XSP);
2095 goto L_CMTCLR;
2096 /*_*/
2097 L_CASE1:
2098 D_A(CASECL) = 0;
2099 goto L_CMTCLR;
2100 /*_*/
2101 L_INCLUD:
2102 SAVSTK();
2103 switch (CTLADV(NORET)) {
2104 case 1:
2105 case 2:
2106 goto L_COMP10;
2107 }
2108 switch (IO_INCLUDE(UNIT, XSP)) {
2109 case INC_FAIL:
2110 goto L_COMP11;
2111 case INC_SKIP:
2112 goto L_CMTCLR;
2113 }
2114 TRIMSP(XSP,XSP);
2115 SAVSTK();
2116 PUSH(INCLSZ);
2117 BLOCK(XCL);
2118 D(D_A(XCL) + DESCR) = D(INCSTK);
2119 D(D_A(XCL) + 2*DESCR) = D(LNNOCL);
2120 D(D_A(XCL) + 3*DESCR) = D(FILENM);
2121 D(INCSTK) = D(XCL);
2122 SAVSTK();
2123 PUSH(XSPPTR);
2124 GENVAR(FILENM);
2125 D_A(LNNOCL) = 0;
2126 goto L_CMTCLR;
2127 /*_*/
2128 L_COMP10:
2129 D_A(ERRTYP) = 29;
2130 BRANCH(FTLEND)
2131 /*_*/
2132 L_COMP11:
2133 D_A(ERRTYP) = 30;
2134 BRANCH(FTLEND)
2135 /*_*/
2136 L_PLSOPS:
2137 switch (STREAM(XSP, TEXTSP, &FRWDTB)) {
2138 case ST_ERROR:
2139 BRANCH(COMP3)
2140 case ST_EOS:
2141 goto L_PLSOP2;
2142 }
2143 if (D_A(STYPE) != NBTYP)
2144 goto L_CMTCLR;
2145 switch (STREAM(XSP, TEXTSP, &INTGTB)) {
2146 case ST_ERROR:
2147 goto L_CMTCLR;
2148 case ST_EOS:
2149 goto L_PLSOP1;
2150 }
2151 if (D_A(STYPE) != ILITYP)
2152 goto L_CMTCLR;
2153 L_PLSOP1:
2154 SPCINT(SPITCL,XSP);
2155 goto L_PLSOP3;
2156 /*_*/
2157 L_PLSOP2:
2158 D_A(SPITCL) = 0;
2159 L_PLSOP3:
2160 goto L_CMTCLR;
2161 /*_*/
2162 L_EXEC:
2163 D_A(EXECCL) = 1;
2164 goto L_CMTCLR;
2165 /*_*/
2166 L_NOEXEC:
2167 D_A(EXECCL) = 0;
2168 goto L_CMTCLR;
2169 /*_*/
2170 L_LINE:
2171 switch (STREAM(XSP, TEXTSP, &FRWDTB)) {
2172 case ST_ERROR:
2173 BRANCH(COMP3)
2174 case ST_EOS:
2175 goto L_CMTCLR;
2176 }
2177 if (D_A(STYPE) != NBTYP)
2178 goto L_CMTCLR;
2179 switch (STREAM(XSP, TEXTSP, &INTGTB)) {
2180 case ST_ERROR:
2181 goto L_COMP12;
2182 case ST_EOS:
2183 goto L_LINE1;
2184 }
2185 if (D_A(STYPE) != ILITYP)
2186 goto L_COMP12;
2187 L_LINE1:
2188 if (!SPCINT(LNNOCL,XSP))
2189 goto L_COMP12;
2190 D_A(LNNOCL)--;
2191 SAVSTK();
2192 switch (CTLADV(NORET)) {
2193 case 1:
2194 goto L_CMTCLR;
2195 case 2:
2196 goto L_COMP12;
2197 }
2198 SAVSTK();
2199 PUSH(XSPPTR);
2200 GENVAR(FILENM);
2201 goto L_CMTCLR;
2202 /*_*/
2203 L_COMP12:
2204 D_A(ERRTYP) = 31;
2205 BRANCH(FTLEND)
2206 /*_*/
2207 L_BLOCKS:
2208 D_A(BLOKCL) = 1;
2209 goto L_CMTCLR;
2210 /*_*/
2211 L_NOBLKS:
2212 D_A(BLOKCL) = 0;
2213 goto L_CMTCLR;
2214 /*_*/
2215 }
2216 static int
CTLADV(ret_t retval)2217 CTLADV(ret_t retval) {
2218 ENTRY(CTLADV)
2219 switch (STREAM(XSP, TEXTSP, &FRWDTB)) {
2220 case ST_ERROR:
2221 BRANCH(COMP3)
2222 case ST_EOS:
2223 BRANCH(RTN1)
2224 }
2225 if (D_A(STYPE) != NBTYP)
2226 BRANCH(RTN1)
2227 switch (STREAM(XSP, TEXTSP, &ELEMTB)) {
2228 case ST_ERROR:
2229 case ST_EOS:
2230 BRANCH(RTN2)
2231 }
2232 if (D_A(STYPE) != QLITYP)
2233 BRANCH(RTN2)
2234 S_L(XSP)--;
2235 S_O(XSP)++;
2236 S_L(XSP)--;
2237 BRANCH(RTN3)
2238 /*_*/
2239 }
2240 static int
TREPUB(ret_t retval)2241 TREPUB(ret_t retval) {
2242 ENTRY(TREPUB)
2243 POP(YPTR);
2244 L_TREPU1:
2245 D(XPTR) = D(D_A(YPTR) + CODE);
2246 D_A(CMOFCL) += DESCR;
2247 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(XPTR);
2248 D(ZPTR) = D(CMBSCL);
2249 D_A(ZPTR) += D_A(CMOFCL);
2250 if (D_PTR(ZPTR) > D_PTR(OCLIM))
2251 goto L_TREPU5;
2252 L_TREPU4:
2253 if (D_A(D_A(YPTR) + LSON) == (int_t)0)
2254 goto L_TREPU2;
2255 D(YPTR) = D(D_A(YPTR) + LSON);
2256 goto L_TREPU1;
2257 /*_*/
2258 L_TREPU2:
2259 if (D_A(D_A(YPTR) + RSIB) == (int_t)0)
2260 goto L_TREPU3;
2261 D(YPTR) = D(D_A(YPTR) + RSIB);
2262 goto L_TREPU1;
2263 /*_*/
2264 L_TREPU3:
2265 if (D_A(D_A(YPTR) + FATHER) == (int_t)0)
2266 BRANCH(RTN1)
2267 D(YPTR) = D(D_A(YPTR) + FATHER);
2268 goto L_TREPU2;
2269 /*_*/
2270 L_TREPU5:
2271 D(ZPTR) = D(CMOFCL);
2272 D_A(ZPTR) += D_A(CODELT);
2273 D_V(ZPTR) = C;
2274 SAVSTK();
2275 PUSH(ZPTR);
2276 BLOCK(XCL);
2277 if (D_A(LPTR) == 0)
2278 goto L_TREPU6;
2279 D(D_A(LPTR) + ATTRIB) = D(XCL);
2280 L_TREPU6:
2281 MOVBLK(D_A(XCL),D_A(CMBSCL),D_A(CMOFCL));
2282 D(D_A(CMBSCL) + DESCR) = D(GOTGCL);
2283 D(D_A(CMBSCL) + 2*DESCR) = D(LIT1CL);
2284 D(D_A(CMBSCL) + 3*DESCR) = D(XCL);
2285 D_A(CMBSCL) += 3*DESCR;
2286 SAVSTK();
2287 PUSH(CMBSCL);
2288 SPLIT(NORET);
2289 D(CMBSCL) = D(XCL);
2290 D(OCLIM) = D(CMBSCL);
2291 D_A(OCLIM) += D_A(ZPTR);
2292 D_A(OCLIM) -= 7*DESCR;
2293 goto L_TREPU4;
2294 /*_*/
2295 }
2296 static int
UNOP(ret_t retval)2297 UNOP(ret_t retval) {
2298 ENTRY(UNOP)
2299 SAVSTK();
2300 if (FORWRD(NORET) == 1)
2301 BRANCH(COMP3)
2302 D_A(XPTR) = 0;
2303 if (D_A(BRTYPE) != NBTYP)
2304 BRANCH(RTN1)
2305 L_UNOPA:
2306 switch (STREAM(XSP, TEXTSP, &UNOPTB)) {
2307 case ST_ERROR:
2308 case ST_EOS:
2309 BRANCH(RTXNAM)
2310 }
2311 SAVSTK();
2312 PUSH(CNDSIZ);
2313 BLOCK(YPTR);
2314 D(D_A(YPTR) + CODE) = D(STYPE);
2315 if (D_A(XPTR) == 0)
2316 goto L_UNOPB;
2317 ADDSON(XPTR,YPTR);
2318 L_UNOPB:
2319 D(XPTR) = D(YPTR);
2320 goto L_UNOPA;
2321 /*_*/
2322 }
2323 int
BASE(ret_t retval)2324 BASE(ret_t retval) {
2325 ENTRY(BASE)
2326 D_A(OCBSCL) += D_A(OCICL);
2327 D_A(OCICL) = 0;
2328 BRANCH(RTNUL3)
2329 /*_*/
2330 }
2331 int
GOTG(ret_t retval)2332 GOTG(ret_t retval) {
2333 ENTRY(GOTG)
2334 SAVSTK();
2335 if (ARGVAL(OCBSCL) == 1)
2336 BRANCH(INTR5)
2337 if (D_V(OCBSCL) != C)
2338 BRANCH(INTR4)
2339 D_A(OCICL) = 0;
2340 BRANCH(RTNUL3)
2341 /*_*/
2342 }
2343 int
GOTL(ret_t retval)2344 GOTL(ret_t retval) {
2345 ENTRY(GOTL)
2346 D_A(OCICL) += DESCR;
2347 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
2348 if ((D_F(XPTR) & FNC))
2349 goto L_GOTLC;
2350 L_GOTLV:
2351 if (D_A(TRAPCL) <= 0)
2352 goto L_GOTLV1;
2353 if (!LOCAPT(ATPTR,TLABL,XPTR))
2354 goto L_GOTLV1;
2355 PUSH(XPTR);
2356 SAVSTK();
2357 PUSH(ATPTR);
2358 TRPHND(NORET);
2359 POP(XPTR);
2360 L_GOTLV1:
2361 if (!DCMP(XPTR, RETCL))
2362 goto L_GOTL1;
2363 RETURN(6)
2364 /*_*/
2365 L_GOTL1:
2366 if (!DCMP(XPTR, FRETCL))
2367 goto L_GOTL2;
2368 RETURN(4)
2369 /*_*/
2370 L_GOTL2:
2371 if (!DCMP(XPTR, NRETCL))
2372 goto L_GOTL3;
2373 RETURN(5)
2374 /*_*/
2375 L_GOTL3:
2376 if (!DCMP(XPTR, ABORCL))
2377 goto L_GOTL4;
2378 if (D_A(XOCBSC) == 0)
2379 BRANCH(CNTERR)
2380 D(ERRTYP) = D(XERRTY);
2381 D(FILENM) = D(XFILEN);
2382 D(LNNOCL) = D(XLNNOC);
2383 D(STNOCL) = D(XSTNOC);
2384 BRANCH(FTLEND)
2385 /*_*/
2386 L_GOTL4:
2387 if (!DCMP(XPTR, SCNTCL))
2388 goto L_GOTL5;
2389 if (D_A(FATLCL) != 0)
2390 BRANCH(CFTERR)
2391 D(FRTNCL) = D(XOCICL);
2392 goto L_GOTL5B;
2393 /*_*/
2394 L_GOTL5:
2395 if (!DCMP(XPTR, CONTCL))
2396 goto L_GOTL6;
2397 if (D_A(FATLCL) != 0)
2398 BRANCH(CFTERR)
2399 D(FRTNCL) = D(XFRTNC);
2400 L_GOTL5B:
2401 if (D_A(XOCBSC) == 0)
2402 BRANCH(CNTERR)
2403 D(OCBSCL) = D(XOCBSC);
2404 D(FILENM) = D(XFILEN);
2405 D(LNNOCL) = D(XLNNOC);
2406 D(STNOCL) = D(XSTNOC);
2407 D(LSFLNM) = D(XLSFLN);
2408 D(LSLNCL) = D(XLSLNC);
2409 D(LSTNCL) = D(XLNNOC);
2410 D_A(XOCBSC) = 0;
2411 if (D_A(ERRTYP) == 0)
2412 BRANCH(END0)
2413 D(ERRTYP) = D(XERRTY);
2414 BRANCH(FAIL)
2415 /*_*/
2416 L_GOTL6:
2417 D(OCBSCL) = D(D_A(XPTR) + ATTRIB);
2418 if (D_A(OCBSCL) == 0)
2419 BRANCH(INTR4)
2420 D_A(OCICL) = 0;
2421 BRANCH(RTNUL3)
2422 /*_*/
2423 L_GOTLC:
2424 SAVSTK();
2425 PUSH(XPTR);
2426 switch (INVOKE(XPTR)) {
2427 case 1:
2428 BRANCH(INTR5)
2429 case 3:
2430 BRANCH(INTR4)
2431 }
2432 if (D_V(XPTR) == S)
2433 goto L_GOTLV;
2434 else
2435 BRANCH(INTR4)
2436 /*_*/
2437 }
2438 int
GOTO(ret_t retval)2439 GOTO(ret_t retval) {
2440 ENTRY(GOTO)
2441 D_A(OCICL) += DESCR;
2442 D(OCICL) = D(D_A(OCBSCL) + D_A(OCICL));
2443 BRANCH(RTNUL3)
2444 /*_*/
2445 }
2446 int
INIT(ret_t retval)2447 INIT(ret_t retval) {
2448 ENTRY(INIT)
2449 D(LSTNCL) = D(STNOCL);
2450 D_A(LSFLNM) = D_A(FILENM);
2451 D_A(LSLNCL) = D_A(LNNOCL);
2452 if (D_A(UINTCL) != 0)
2453 BRANCH(USRINT)
2454 D_A(OCICL) += DESCR;
2455 D(XCL) = D(D_A(OCBSCL) + D_A(OCICL));
2456 D_A(STNOCL) = D_A(XCL);
2457 D_A(FRTNCL) = D_V(XCL);
2458 D_F(FRTNCL) = D_V(FRTNCL) = 0;
2459 D_A(OCICL) += DESCR;
2460 D(LNNOCL) = D(D_A(OCBSCL) + D_A(OCICL));
2461 D_A(OCICL) += DESCR;
2462 D(FILENM) = D(D_A(OCBSCL) + D_A(OCICL));
2463 D_A(EXN2CL)++;
2464 if (D_A(EXLMCL) < 0)
2465 BRANCH(RTNUL3)
2466 if (D_A(EXNOCL) >= D_A(EXLMCL))
2467 BRANCH(EXEX)
2468 D_A(EXNOCL)++;
2469 if (D_A(TRAPCL) <= 0)
2470 BRANCH(RTNUL3)
2471 if (!chk_break(0))
2472 goto L_INIT1;
2473 if (!LOCAPT(ATPTR,TKEYL,STNOKY))
2474 goto L_INIT1;
2475 SAVSTK();
2476 PUSH(ATPTR);
2477 TRPHND(NORET);
2478 L_INIT1:
2479 if (!LOCAPT(ATPTR,TKEYL,STCTKY))
2480 BRANCH(RTNUL3)
2481 SAVSTK();
2482 PUSH(ATPTR);
2483 TRPHND(NORET);
2484 BRANCH(RTNUL3)
2485 /*_*/
2486 }
2487 static int
INTERP(ret_t retval)2488 INTERP(ret_t retval) {
2489 ENTRY(INTERP)
2490 L_INTRP0:
2491 D_A(OCICL) += DESCR;
2492 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
2493 if (!(D_F(XPTR) & FNC))
2494 goto L_INTRP0;
2495 SAVSTK();
2496 PUSH(XPTR);
2497 switch (INVOKE(XPTR)) {
2498 case 2:
2499 case 3:
2500 goto L_INTRP0;
2501 case 4:
2502 BRANCH(RTN1)
2503 case 5:
2504 BRANCH(RTN2)
2505 case 6:
2506 BRANCH(RTN3)
2507 }
2508 D(OCICL) = D(FRTNCL);
2509 D_A(FALCL)++;
2510 if (D_A(TRAPCL) <= 0)
2511 goto L_INTRP0;
2512 if (!LOCAPT(ATPTR,TKEYL,FALKY))
2513 goto L_INTRP0;
2514 SAVSTK();
2515 PUSH(ATPTR);
2516 TRPHND(NORET);
2517 goto L_INTRP0;
2518 /*_*/
2519 }
2520 static int
INVOKE(ret_t retval)2521 INVOKE(ret_t retval) {
2522 ENTRY(INVOKE)
2523 POP(INCL);
2524 D(XPTR) = D(D_A(INCL));
2525 if (D_V(INCL) != D_V(XPTR))
2526 goto L_INVK2;
2527 L_INVK1:
2528 BRANCH( ((func_t) (D_A(D_A(INCL)))))
2529 /*_*/
2530 L_INVK2:
2531 if ((D_F(XPTR) & FNC))
2532 goto L_INVK1;
2533 else
2534 BRANCH(ARGNER)
2535 /*_*/
2536 }
2537 static int
ARGVAL(ret_t retval)2538 ARGVAL(ret_t retval) {
2539 ENTRY(ARGVAL)
2540 D_A(OCICL) += DESCR;
2541 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
2542 if ((D_F(XPTR) & FNC))
2543 goto L_ARGVC;
2544 L_ARGV1:
2545 if (D_A(INSW) == 0)
2546 goto L_ARGV2;
2547 if (!LOCAPV(ZPTR,INATL,XPTR))
2548 goto L_ARGV2;
2549 D(ZPTR) = D(D_A(ZPTR) + DESCR);
2550 SAVSTK();
2551 PUSH(XPTR);
2552 PUSH(ZPTR);
2553 switch (PUTIN(XPTR)) {
2554 case 1:
2555 BRANCH(FAIL)
2556 case 2:
2557 BRANCH(RTXNAM)
2558 }
2559 /*_*/
2560 L_ARGVC:
2561 SAVSTK();
2562 PUSH(XPTR);
2563 switch (INVOKE(XPTR)) {
2564 case 1:
2565 BRANCH(FAIL)
2566 case 2:
2567 goto L_ARGV1;
2568 case 3:
2569 BRANCH(RTXNAM)
2570 }
2571 /*_*/
2572 L_ARGV2:
2573 D(XPTR) = D(D_A(XPTR) + DESCR);
2574 BRANCH(RTXNAM)
2575 /*_*/
2576 }
2577 static int
EXPVAL(ret_t retval)2578 EXPVAL(ret_t retval) {
2579 ENTRY(EXPVAL)
2580 D_A(SCL) = 1;
2581 /* FALL */
2582 BRANCH(EXPVJN)
2583 }
2584 static int
EXPVJN(ret_t retval)2585 EXPVJN(ret_t retval) {
2586 ENTRY(EXPVJN)
2587 POP(XPTR);
2588 /* FALL */
2589 BRANCH(EXPVJ2)
2590 }
2591 static int
EXPVJ2(ret_t retval)2592 EXPVJ2(ret_t retval) {
2593 ENTRY(EXPVJ2)
2594 PUSH(OCBSCL);
2595 PUSH(OCICL);
2596 PUSH(PATBCL);
2597 PUSH(PATICL);
2598 PUSH(WPTR);
2599 PUSH(XCL);
2600 PUSH(YCL);
2601 PUSH(TCL);
2602 PUSH(MAXLEN);
2603 PUSH(LENFCL);
2604 PUSH(PDLPTR);
2605 PUSH(PDLHED);
2606 PUSH(NAMICL);
2607 PUSH(NHEDCL);
2608 SPUSH(HEADSP);
2609 SPUSH(TSP);
2610 SPUSH(TXSP);
2611 SPUSH(XSP);
2612 D(OCBSCL) = D(XPTR);
2613 D_A(OCICL) = (int_t) DESCR;
2614 D(PDLHED) = D(PDLPTR);
2615 D(NHEDCL) = D(NAMICL);
2616 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
2617 if ((D_F(XPTR) & FNC))
2618 goto L_EXPVC;
2619 L_EXPV11:
2620 if (D_A(SCL) == 0)
2621 goto L_EXPV6;
2622 if (D_A(INSW) == 0)
2623 goto L_EXPV4;
2624 if (!LOCAPV(ZPTR,INATL,XPTR))
2625 goto L_EXPV4;
2626 D(ZPTR) = D(D_A(ZPTR) + DESCR);
2627 SAVSTK();
2628 PUSH(XPTR);
2629 PUSH(ZPTR);
2630 switch (PUTIN(XPTR)) {
2631 case 1:
2632 goto L_EXPV1;
2633 case 2:
2634 goto L_EXPV6;
2635 }
2636 /*_*/
2637 L_EXPV4:
2638 D(XPTR) = D(D_A(XPTR) + DESCR);
2639 L_EXPV6:
2640 D_A(SCL) = 2;
2641 goto L_EXPV7;
2642 /*_*/
2643 L_EXPV9:
2644 POP(SCL);
2645 L_EXPV1:
2646 D_A(SCL) = 1;
2647 L_EXPV7:
2648 SPOP(XSP);
2649 SPOP(TXSP);
2650 SPOP(TSP);
2651 SPOP(HEADSP);
2652 POP(NHEDCL);
2653 POP(NAMICL);
2654 POP(PDLHED);
2655 POP(PDLPTR);
2656 POP(LENFCL);
2657 POP(MAXLEN);
2658 POP(TCL);
2659 POP(YCL);
2660 POP(XCL);
2661 POP(WPTR);
2662 POP(PATICL);
2663 POP(PATBCL);
2664 POP(OCICL);
2665 POP(OCBSCL);
2666 switch (D_A(SCL)) {
2667 case 1:
2668 BRANCH(FAIL)
2669 case 2:
2670 BRANCH(RTXNAM)
2671 case 3:
2672 BRANCH(RTZPTR)
2673 }
2674 /*_*/
2675 L_EXPVC:
2676 PUSH(SCL);
2677 SAVSTK();
2678 PUSH(XPTR);
2679 switch (INVOKE(XPTR)) {
2680 case 1:
2681 goto L_EXPV9;
2682 case 2:
2683 goto L_EXPV5;
2684 }
2685 POP(SCL);
2686 if (D_A(SCL) != 0)
2687 goto L_EXPV6;
2688 D_A(SCL) = 3;
2689 D(ZPTR) = D(XPTR);
2690 goto L_EXPV7;
2691 /*_*/
2692 L_EXPV5:
2693 POP(SCL);
2694 goto L_EXPV11;
2695 /*_*/
2696 }
2697 static int
EXPEVL(ret_t retval)2698 EXPEVL(ret_t retval) {
2699 ENTRY(EXPEVL)
2700 D_A(SCL) = 0;
2701 BRANCH(EXPVJN)
2702 /*_*/
2703 }
2704 int
EVAL(ret_t retval)2705 EVAL(ret_t retval) {
2706 ENTRY(EVAL)
2707 SAVSTK();
2708 if (ARGVAL(XPTR) == 1)
2709 BRANCH(FAIL)
2710 if (D_V(XPTR) == E)
2711 goto L_EVAL1;
2712 if (D_V(XPTR) == I)
2713 BRANCH(RTXPTR)
2714 if (D_V(XPTR) == R)
2715 BRANCH(RTXPTR)
2716 if (D_V(XPTR) != S)
2717 BRANCH(INTR1)
2718 X_LOCSP(XSP,XPTR);
2719 if (S_L(XSP) == 0)
2720 BRANCH(RTXPTR)
2721 if (SPCINT(XPTR,XSP))
2722 BRANCH(RTXPTR)
2723 if (SPREAL(XPTR,XSP))
2724 BRANCH(RTXPTR)
2725 D(ZPTR) = D(XPTR);
2726 SAVSTK();
2727 switch (CONVE(XPTR)) {
2728 case 1:
2729 BRANCH(FAIL)
2730 case 2:
2731 BRANCH(INTR10)
2732 }
2733 L_EVAL1:
2734 D_A(SCL) = 0;
2735 BRANCH(EXPVJ2)
2736 /*_*/
2737 }
2738 static int
INTVAL(ret_t retval)2739 INTVAL(ret_t retval) {
2740 ENTRY(INTVAL)
2741 D_A(OCICL) += DESCR;
2742 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
2743 if ((D_F(XPTR) & FNC))
2744 goto L_INTVC;
2745 L_INTV1:
2746 if (D_A(INSW) == 0)
2747 goto L_INTV3;
2748 if (!LOCAPV(ZPTR,INATL,XPTR))
2749 goto L_INTV3;
2750 D(ZPTR) = D(D_A(ZPTR) + DESCR);
2751 SAVSTK();
2752 PUSH(XPTR);
2753 PUSH(ZPTR);
2754 if (PUTIN(XPTR) == 1)
2755 BRANCH(FAIL)
2756 L_INTV:
2757 X_LOCSP(XSP,XPTR);
2758 if (SPCINT(XPTR,XSP))
2759 BRANCH(RTXNAM)
2760 if (!SPREAL(XPTR,XSP))
2761 BRANCH(INTR1)
2762 L_INTRI:
2763 CLR_MATH_ERROR();
2764 D_A(XPTR) = (int_t) D_RV(XPTR);
2765 D_F(XPTR) = 0;
2766 D_V(XPTR) = I;
2767 if (MATH_ERROR())
2768 BRANCH(INTR1)
2769 BRANCH(RTXNAM)
2770 /*_*/
2771 L_INTV3:
2772 D(XPTR) = D(D_A(XPTR) + DESCR);
2773 L_INTV2:
2774 if (D_V(XPTR) == I)
2775 BRANCH(RTXNAM)
2776 if (D_V(XPTR) == R)
2777 goto L_INTRI;
2778 if (D_V(XPTR) == S)
2779 goto L_INTV;
2780 else
2781 BRANCH(INTR1)
2782 /*_*/
2783 L_INTVC:
2784 SAVSTK();
2785 PUSH(XPTR);
2786 switch (INVOKE(XPTR)) {
2787 case 1:
2788 BRANCH(FAIL)
2789 case 2:
2790 goto L_INTV1;
2791 case 3:
2792 goto L_INTV2;
2793 }
2794 /*_*/
2795 }
2796 static int
PATVAL(ret_t retval)2797 PATVAL(ret_t retval) {
2798 ENTRY(PATVAL)
2799 D_A(OCICL) += DESCR;
2800 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
2801 if ((D_F(XPTR) & FNC))
2802 goto L_PATVC;
2803 L_PATV1:
2804 if (D_A(INSW) == 0)
2805 goto L_PATV2;
2806 if (!LOCAPV(ZPTR,INATL,XPTR))
2807 goto L_PATV2;
2808 D(ZPTR) = D(D_A(ZPTR) + DESCR);
2809 SAVSTK();
2810 PUSH(XPTR);
2811 PUSH(ZPTR);
2812 switch (PUTIN(XPTR)) {
2813 case 1:
2814 BRANCH(FAIL)
2815 case 2:
2816 BRANCH(RTXNAM)
2817 }
2818 /*_*/
2819 L_PATVC:
2820 SAVSTK();
2821 PUSH(XPTR);
2822 switch (INVOKE(XPTR)) {
2823 case 1:
2824 BRANCH(FAIL)
2825 case 2:
2826 goto L_PATV1;
2827 case 3:
2828 goto L_PATV3;
2829 }
2830 /*_*/
2831 L_PATV2:
2832 D(XPTR) = D(D_A(XPTR) + DESCR);
2833 L_PATV3:
2834 if (D_V(XPTR) == P)
2835 BRANCH(RTXNAM)
2836 if (D_V(XPTR) == S)
2837 BRANCH(RTXNAM)
2838 if (D_V(XPTR) == I)
2839 BRANCH(GENVIX)
2840 if (D_V(XPTR) == R)
2841 goto L_PATVR;
2842 if (D_V(XPTR) != E)
2843 BRANCH(INTR1)
2844 SAVSTK();
2845 PUSH(STARSZ);
2846 BLOCK(TPTR);
2847 MOVBLK(D_A(TPTR),D_A(STRPAT),D_A(STARSZ));
2848 D(D_A(TPTR) + 4*DESCR) = D(XPTR);
2849 D(XPTR) = D(TPTR);
2850 BRANCH(RTXNAM)
2851 /*_*/
2852 L_PATVR:
2853 REALST(XSP,XPTR);
2854 SAVSTK();
2855 PUSH(XSPPTR);
2856 if (GENVAR(XPTR) == 1)
2857 BRANCH(RTXNAM)
2858 /*_*/
2859 }
2860 static int
VARVAL(ret_t retval)2861 VARVAL(ret_t retval) {
2862 ENTRY(VARVAL)
2863 D_A(OCICL) += DESCR;
2864 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
2865 if ((D_F(XPTR) & FNC))
2866 goto L_VARVC;
2867 L_VARV1:
2868 if (D_A(INSW) == 0)
2869 goto L_VARV4;
2870 if (!LOCAPV(ZPTR,INATL,XPTR))
2871 goto L_VARV4;
2872 D(ZPTR) = D(D_A(ZPTR) + DESCR);
2873 SAVSTK();
2874 PUSH(XPTR);
2875 PUSH(ZPTR);
2876 switch (PUTIN(XPTR)) {
2877 case 1:
2878 BRANCH(FAIL)
2879 case 2:
2880 BRANCH(RTXNAM)
2881 }
2882 /*_*/
2883 L_VARV4:
2884 D(XPTR) = D(D_A(XPTR) + DESCR);
2885 L_VARV2:
2886 if (D_V(XPTR) == S)
2887 BRANCH(RTXNAM)
2888 if (D_V(XPTR) == I)
2889 BRANCH(GENVIX)
2890 else
2891 BRANCH(INTR1)
2892 /*_*/
2893 L_VARVC:
2894 SAVSTK();
2895 PUSH(XPTR);
2896 switch (INVOKE(XPTR)) {
2897 case 1:
2898 BRANCH(FAIL)
2899 case 2:
2900 goto L_VARV1;
2901 case 3:
2902 goto L_VARV2;
2903 }
2904 /*_*/
2905 }
2906 static int
VARVUP(ret_t retval)2907 VARVUP(ret_t retval) {
2908 ENTRY(VARVUP)
2909 SAVSTK();
2910 if (VARVAL(NORET) == 1)
2911 BRANCH(FAIL)
2912 if (D_A(CASECL) == 0)
2913 BRANCH(RTXNAM)
2914 else
2915 BRANCH(VPXPTR)
2916 /*_*/
2917 }
2918 static int
VPXPTR(ret_t retval)2919 VPXPTR(ret_t retval) {
2920 ENTRY(VPXPTR)
2921 X_LOCSP(SPECR1,XPTR);
2922 if (S_L(SPECR1) == 0)
2923 BRANCH(RTXNAM)
2924 D_A(AXPTR) = S_L(SPECR1);
2925 D_F(AXPTR) = D_V(AXPTR) = 0;
2926 SAVSTK();
2927 PUSH(AXPTR);
2928 CONVAR(NORET);
2929 X_LOCSP(XSP,FRSGPT);
2930 if (!RAISE2(SPECR1,XSP))
2931 BRANCH(RTXNAM)
2932 D(D_A(FRSGPT) + DESCR) = D(D_A(XPTR) + DESCR);
2933 D(D_A(FRSGPT) + ATTRIB) = D(D_A(XPTR) + ATTRIB);
2934 SAVSTK();
2935 PUSH(AXPTR);
2936 if (GNVARS(XPTR) == 1)
2937 BRANCH(RTXNAM)
2938 BRANCH(RTXNAM)
2939 /*_*/
2940 }
2941 static int
XYARGS(ret_t retval)2942 XYARGS(ret_t retval) {
2943 ENTRY(XYARGS)
2944 D_A(SCL) = 0;
2945 L_XYN:
2946 D_A(OCICL) += DESCR;
2947 D(YPTR) = D(D_A(OCBSCL) + D_A(OCICL));
2948 if ((D_F(YPTR) & FNC))
2949 goto L_XYC;
2950 L_XY1:
2951 if (D_A(INSW) == 0)
2952 goto L_XY2;
2953 if (!LOCAPV(ZPTR,INATL,YPTR))
2954 goto L_XY2;
2955 D(ZPTR) = D(D_A(ZPTR) + DESCR);
2956 SAVSTK();
2957 PUSH(YPTR);
2958 PUSH(ZPTR);
2959 if (PUTIN(YPTR) == 1)
2960 BRANCH(FAIL)
2961 L_XY3:
2962 if (D_A(SCL) != 0)
2963 BRANCH(RTN2)
2964 D_A(SCL) = 1;
2965 D(XPTR) = D(YPTR);
2966 goto L_XYN;
2967 /*_*/
2968 L_XY2:
2969 D(YPTR) = D(D_A(YPTR) + DESCR);
2970 goto L_XY3;
2971 /*_*/
2972 L_XYC:
2973 PUSH(SCL);
2974 PUSH(XPTR);
2975 SAVSTK();
2976 PUSH(YPTR);
2977 switch (INVOKE(YPTR)) {
2978 case 1:
2979 BRANCH(FAIL)
2980 case 2:
2981 goto L_XY4;
2982 }
2983 POP(XPTR);
2984 POP(SCL);
2985 goto L_XY3;
2986 /*_*/
2987 L_XY4:
2988 POP(XPTR);
2989 POP(SCL);
2990 goto L_XY1;
2991 /*_*/
2992 }
2993 int
ADD(ret_t retval)2994 ADD(ret_t retval) {
2995 ENTRY(ADD)
2996 D_A(SCL) = 1;
2997 BRANCH(ARITH)
2998 /*_*/
2999 }
3000 int
DIV(ret_t retval)3001 DIV(ret_t retval) {
3002 ENTRY(DIV)
3003 D_A(SCL) = 2;
3004 BRANCH(ARITH)
3005 /*_*/
3006 }
3007 int
EXPOP(ret_t retval)3008 EXPOP(ret_t retval) {
3009 ENTRY(EXPOP)
3010 D_A(SCL) = 3;
3011 BRANCH(ARITH)
3012 /*_*/
3013 }
3014 int
MPY(ret_t retval)3015 MPY(ret_t retval) {
3016 ENTRY(MPY)
3017 D_A(SCL) = 4;
3018 BRANCH(ARITH)
3019 /*_*/
3020 }
3021 int
SUB(ret_t retval)3022 SUB(ret_t retval) {
3023 ENTRY(SUB)
3024 D_A(SCL) = 5;
3025 BRANCH(ARITH)
3026 /*_*/
3027 }
3028 int
EQ(ret_t retval)3029 EQ(ret_t retval) {
3030 ENTRY(EQ)
3031 D_A(SCL) = 6;
3032 BRANCH(ARITH)
3033 /*_*/
3034 }
3035 int
GE(ret_t retval)3036 GE(ret_t retval) {
3037 ENTRY(GE)
3038 D_A(SCL) = 7;
3039 BRANCH(ARITH)
3040 /*_*/
3041 }
3042 int
GT(ret_t retval)3043 GT(ret_t retval) {
3044 ENTRY(GT)
3045 D_A(SCL) = 8;
3046 BRANCH(ARITH)
3047 /*_*/
3048 }
3049 int
LE(ret_t retval)3050 LE(ret_t retval) {
3051 ENTRY(LE)
3052 D_A(SCL) = 9;
3053 BRANCH(ARITH)
3054 /*_*/
3055 }
3056 int
LT(ret_t retval)3057 LT(ret_t retval) {
3058 ENTRY(LT)
3059 D_A(SCL) = 10;
3060 BRANCH(ARITH)
3061 /*_*/
3062 }
3063 int
NE(ret_t retval)3064 NE(ret_t retval) {
3065 ENTRY(NE)
3066 D_A(SCL) = 11;
3067 BRANCH(ARITH)
3068 /*_*/
3069 }
3070 int
REMDR(ret_t retval)3071 REMDR(ret_t retval) {
3072 ENTRY(REMDR)
3073 D_A(SCL) = 12;
3074 BRANCH(ARITH)
3075 /*_*/
3076 }
3077 static int
ARITH(ret_t retval)3078 ARITH(ret_t retval) {
3079 ENTRY(ARITH)
3080 PUSH(SCL);
3081 SAVSTK();
3082 if (XYARGS(NORET) == 1)
3083 BRANCH(FAIL)
3084 POP(SCL);
3085 D_A(DTCL) = D_V(XPTR);
3086 D_F(DTCL) = D_V(DTCL) = 0;
3087 D_V(DTCL) = D_V(YPTR);
3088 if (DCMP(DTCL, IIDTP))
3089 goto L_ARTHII;
3090 if (DCMP(DTCL, IVDTP))
3091 goto L_ARTHIV;
3092 if (DCMP(DTCL, VIDTP))
3093 goto L_ARTHVI;
3094 if (DCMP(DTCL, VVDTP))
3095 goto L_ARTHVV;
3096 if (DCMP(DTCL, RRDTP))
3097 goto L_ARTHRR;
3098 if (DCMP(DTCL, IRDTP))
3099 goto L_ARTHIR;
3100 if (DCMP(DTCL, RIDTP))
3101 goto L_ARTHRI;
3102 if (DCMP(DTCL, VRDTP))
3103 goto L_ARTHVR;
3104 if (DCMP(DTCL, RVDTP))
3105 goto L_ARTHRV;
3106 else
3107 BRANCH(INTR1)
3108 /*_*/
3109 L_ARTHII:
3110 switch (D_A(SCL)) {
3111 case 1:
3112 goto L_AD;
3113 case 2:
3114 goto L_DV;
3115 case 3:
3116 goto L_EX;
3117 case 4:
3118 goto L_MP;
3119 case 5:
3120 goto L_SB;
3121 case 6:
3122 goto L_CEQ;
3123 case 7:
3124 goto L_CGE;
3125 case 8:
3126 goto L_CGT;
3127 case 9:
3128 goto L_CLE;
3129 case 10:
3130 goto L_CLT;
3131 case 11:
3132 goto L_CNE;
3133 case 12:
3134 goto L_RM;
3135 }
3136 /*_*/
3137 L_ARTHVI:
3138 X_LOCSP(XSP,XPTR);
3139 if (SPCINT(XPTR,XSP))
3140 goto L_ARTHII;
3141 if (SPREAL(XPTR,XSP))
3142 goto L_ARTHRI;
3143 else
3144 BRANCH(INTR1)
3145 /*_*/
3146 L_ARTHIV:
3147 X_LOCSP(YSP,YPTR);
3148 if (SPCINT(YPTR,YSP))
3149 goto L_ARTHII;
3150 if (SPREAL(YPTR,YSP))
3151 goto L_ARTHIR;
3152 else
3153 BRANCH(INTR1)
3154 /*_*/
3155 L_ARTHVV:
3156 X_LOCSP(XSP,XPTR);
3157 if (SPCINT(XPTR,XSP))
3158 goto L_ARTHIV;
3159 if (SPREAL(XPTR,XSP))
3160 goto L_ARTHRV;
3161 else
3162 BRANCH(INTR1)
3163 /*_*/
3164 L_ARTHRR:
3165 switch (D_A(SCL)) {
3166 case 1:
3167 goto L_AR;
3168 case 2:
3169 goto L_DR;
3170 case 3:
3171 goto L_EXR;
3172 case 4:
3173 goto L_MR;
3174 case 5:
3175 goto L_SR;
3176 case 6:
3177 goto L_REQ;
3178 case 7:
3179 goto L_RGE;
3180 case 8:
3181 goto L_RGT;
3182 case 9:
3183 goto L_RLE;
3184 case 10:
3185 goto L_RLT;
3186 case 11:
3187 goto L_RNE;
3188 case 12:
3189 BRANCH(INTR1)
3190 }
3191 /*_*/
3192 L_ARTHIR:
3193 D_RV(XPTR) = (real_t)D_A(XPTR);
3194 D_F(XPTR) = 0;
3195 D_V(XPTR) = R;
3196 goto L_ARTHRR;
3197 /*_*/
3198 L_ARTHRI:
3199 D_RV(YPTR) = (real_t)D_A(YPTR);
3200 D_F(YPTR) = 0;
3201 D_V(YPTR) = R;
3202 goto L_ARTHRR;
3203 /*_*/
3204 L_ARTHVR:
3205 X_LOCSP(XSP,XPTR);
3206 if (SPCINT(XPTR,XSP))
3207 goto L_ARTHIR;
3208 if (SPREAL(XPTR,XSP))
3209 goto L_ARTHRR;
3210 else
3211 BRANCH(INTR1)
3212 /*_*/
3213 L_ARTHRV:
3214 X_LOCSP(YSP,YPTR);
3215 if (SPCINT(YPTR,YSP))
3216 goto L_ARTHRI;
3217 if (SPREAL(YPTR,YSP))
3218 goto L_ARTHRR;
3219 else
3220 BRANCH(INTR1)
3221 /*_*/
3222 L_AD:
3223 CLR_MATH_ERROR();
3224 D(ZPTR) = D(XPTR);
3225 D_A(ZPTR) += D_A(YPTR);
3226 if (MATH_ERROR())
3227 BRANCH(AERROR)
3228 BRANCH(ARTN)
3229 /*_*/
3230 L_DV:
3231 if (D_A(YPTR) == 0)
3232 BRANCH(AERROR)
3233 CLR_MATH_ERROR();
3234 D(ZPTR) = D(XPTR);
3235 D_A(ZPTR) /= D_A(YPTR);
3236 if (MATH_ERROR())
3237 BRANCH(AERROR)
3238 BRANCH(ARTN)
3239 /*_*/
3240 L_EX:
3241 if (EXPINT(ZPTR,XPTR,YPTR))
3242 BRANCH(ARTN)
3243 else
3244 BRANCH(AERROR)
3245 /*_*/
3246 L_MP:
3247 CLR_MATH_ERROR();
3248 D(ZPTR) = D(XPTR);
3249 D_A(ZPTR) *= D_A(YPTR);
3250 if (MATH_ERROR())
3251 BRANCH(AERROR)
3252 BRANCH(ARTN)
3253 /*_*/
3254 L_SB:
3255 CLR_MATH_ERROR();
3256 D(ZPTR) = D(XPTR);
3257 D_A(ZPTR) -= D_A(YPTR);
3258 if (MATH_ERROR())
3259 BRANCH(AERROR)
3260 BRANCH(ARTN)
3261 /*_*/
3262 L_CEQ:
3263 if (D_A(XPTR) == D_A(YPTR))
3264 BRANCH(RETNUL)
3265 else
3266 BRANCH(FAIL)
3267 /*_*/
3268 L_CGE:
3269 if (D_A(XPTR) < D_A(YPTR))
3270 BRANCH(FAIL)
3271 else
3272 BRANCH(RETNUL)
3273 /*_*/
3274 L_CGT:
3275 if (D_A(XPTR) <= D_A(YPTR))
3276 BRANCH(FAIL)
3277 else
3278 BRANCH(RETNUL)
3279 /*_*/
3280 L_CLE:
3281 if (D_A(XPTR) <= D_A(YPTR))
3282 BRANCH(RETNUL)
3283 else
3284 BRANCH(FAIL)
3285 /*_*/
3286 L_CLT:
3287 if (D_A(XPTR) < D_A(YPTR))
3288 BRANCH(RETNUL)
3289 else
3290 BRANCH(FAIL)
3291 /*_*/
3292 L_CNE:
3293 if (D_A(XPTR) == D_A(YPTR))
3294 BRANCH(FAIL)
3295 else
3296 BRANCH(RETNUL)
3297 /*_*/
3298 L_AR:
3299 CLR_MATH_ERROR();
3300 D(ZPTR) = D(XPTR);
3301 D_RV(ZPTR) += D_RV(YPTR);
3302 if (RMATH_ERROR(D_RV(ZPTR)))
3303 BRANCH(AERROR)
3304 BRANCH(ARTN)
3305 /*_*/
3306 L_DR:
3307 CLR_MATH_ERROR();
3308 D(ZPTR) = D(XPTR);
3309 D_RV(ZPTR) /= D_RV(YPTR);
3310 if (RMATH_ERROR(D_RV(ZPTR)))
3311 BRANCH(AERROR)
3312 BRANCH(ARTN)
3313 /*_*/
3314 L_EXR:
3315 if (EXREAL(ZPTR,XPTR,YPTR))
3316 BRANCH(ARTN)
3317 else
3318 BRANCH(AERROR)
3319 /*_*/
3320 L_MR:
3321 CLR_MATH_ERROR();
3322 D(ZPTR) = D(XPTR);
3323 D_RV(ZPTR) *= D_RV(YPTR);
3324 if (RMATH_ERROR(D_RV(ZPTR)))
3325 BRANCH(AERROR)
3326 BRANCH(ARTN)
3327 /*_*/
3328 L_SR:
3329 CLR_MATH_ERROR();
3330 D(ZPTR) = D(XPTR);
3331 D_RV(ZPTR) -= D_RV(YPTR);
3332 if (RMATH_ERROR(D_RV(ZPTR)))
3333 BRANCH(AERROR)
3334 BRANCH(ARTN)
3335 /*_*/
3336 L_REQ:
3337 if (D_RV(XPTR) == D_RV(YPTR))
3338 BRANCH(RETNUL)
3339 else
3340 BRANCH(FAIL)
3341 /*_*/
3342 L_RGE:
3343 if (D_RV(XPTR) < D_RV(YPTR))
3344 BRANCH(FAIL)
3345 else
3346 BRANCH(RETNUL)
3347 /*_*/
3348 L_RGT:
3349 if (D_RV(XPTR) <= D_RV(YPTR))
3350 BRANCH(FAIL)
3351 else
3352 BRANCH(RETNUL)
3353 /*_*/
3354 L_RLE:
3355 if (D_RV(XPTR) <= D_RV(YPTR))
3356 BRANCH(RETNUL)
3357 else
3358 BRANCH(FAIL)
3359 /*_*/
3360 L_RLT:
3361 if (D_RV(XPTR) < D_RV(YPTR))
3362 BRANCH(RETNUL)
3363 else
3364 BRANCH(FAIL)
3365 /*_*/
3366 L_RNE:
3367 if (D_RV(XPTR) == D_RV(YPTR))
3368 BRANCH(FAIL)
3369 else
3370 BRANCH(RETNUL)
3371 /*_*/
3372 L_RM:
3373 if (D_A(YPTR) == 0)
3374 BRANCH(AERROR)
3375 CLR_MATH_ERROR();
3376 D(ZPTR) = D(XPTR);
3377 D_A(ZPTR) /= D_A(YPTR);
3378 if (MATH_ERROR())
3379 BRANCH(AERROR)
3380 D(WPTR) = D(ZPTR);
3381 D_A(WPTR) *= D_A(YPTR);
3382 D(ZPTR) = D(XPTR);
3383 D_A(ZPTR) -= D_A(WPTR);
3384 BRANCH(ARTN)
3385 /*_*/
3386 }
3387 int
INTGER(ret_t retval)3388 INTGER(ret_t retval) {
3389 ENTRY(INTGER)
3390 SAVSTK();
3391 if (ARGVAL(XPTR) == 1)
3392 BRANCH(FAIL)
3393 if (D_V(XPTR) == I)
3394 BRANCH(RETNUL)
3395 if (D_V(XPTR) != S)
3396 BRANCH(FAIL)
3397 X_LOCSP(XSP,XPTR);
3398 if (SPCINT(XPTR,XSP))
3399 BRANCH(RETNUL)
3400 else
3401 BRANCH(FAIL)
3402 /*_*/
3403 }
3404 int
MNS(ret_t retval)3405 MNS(ret_t retval) {
3406 ENTRY(MNS)
3407 SAVSTK();
3408 if (ARGVAL(XPTR) == 1)
3409 BRANCH(FAIL)
3410 if (D_V(XPTR) == I)
3411 goto L_MNSM;
3412 if (D_V(XPTR) == S)
3413 goto L_MNSV;
3414 if (D_V(XPTR) == R)
3415 goto L_MNSR;
3416 else
3417 BRANCH(INTR1)
3418 /*_*/
3419 L_MNSM:
3420 CLR_MATH_ERROR();
3421 D(ZPTR) = D(XPTR);
3422 D_A(ZPTR) = -D_A(ZPTR);
3423 if (MATH_ERROR())
3424 BRANCH(AERROR)
3425 BRANCH(ARTN)
3426 /*_*/
3427 L_MNSV:
3428 X_LOCSP(XSP,XPTR);
3429 if (SPCINT(XPTR,XSP))
3430 goto L_MNSM;
3431 if (!SPREAL(XPTR,XSP))
3432 BRANCH(INTR1)
3433 L_MNSR:
3434 D(ZPTR) = D(XPTR);
3435 D_RV(ZPTR) = -D_RV(ZPTR);
3436 BRANCH(ARTN)
3437 /*_*/
3438 }
3439 int
PLS(ret_t retval)3440 PLS(ret_t retval) {
3441 ENTRY(PLS)
3442 SAVSTK();
3443 if (ARGVAL(ZPTR) == 1)
3444 BRANCH(FAIL)
3445 if (D_V(ZPTR) == I)
3446 BRANCH(ARTN)
3447 if (D_V(ZPTR) == S)
3448 goto L_PLSV;
3449 if (D_V(ZPTR) == R)
3450 BRANCH(ARTN)
3451 else
3452 BRANCH(INTR1)
3453 /*_*/
3454 L_PLSV:
3455 X_LOCSP(XSP,ZPTR);
3456 if (SPCINT(ZPTR,XSP))
3457 BRANCH(ARTN)
3458 if (SPREAL(ZPTR,XSP))
3459 BRANCH(ARTN)
3460 else
3461 BRANCH(INTR1)
3462 /*_*/
3463 }
3464 int
ANY(ret_t retval)3465 ANY(ret_t retval) {
3466 ENTRY(ANY)
3467 PUSH(ANYCCL);
3468 BRANCH(CHARZ)
3469 /*_*/
3470 }
3471 int
BREAKX(ret_t retval)3472 BREAKX(ret_t retval) {
3473 ENTRY(BREAKX)
3474 PUSH(BRXCCL);
3475 PUSH(ZEROCL);
3476 BRANCH(ABNSND)
3477 /*_*/
3478 }
3479 int
BREAK(ret_t retval)3480 BREAK(ret_t retval) {
3481 ENTRY(BREAK)
3482 PUSH(BRKCCL);
3483 PUSH(ZEROCL);
3484 BRANCH(ABNSND)
3485 /*_*/
3486 }
3487 int
NOTANY(ret_t retval)3488 NOTANY(ret_t retval) {
3489 ENTRY(NOTANY)
3490 PUSH(NNYCCL);
3491 BRANCH(CHARZ)
3492 /*_*/
3493 }
3494 int
SPAN(ret_t retval)3495 SPAN(ret_t retval) {
3496 ENTRY(SPAN)
3497 PUSH(SPNCCL);
3498 /* FALL */
3499 BRANCH(CHARZ)
3500 }
3501 static int
CHARZ(ret_t retval)3502 CHARZ(ret_t retval) {
3503 ENTRY(CHARZ)
3504 PUSH(CHARCL);
3505 /* FALL */
3506 BRANCH(ABNSND)
3507 }
3508 static int
ABNSND(ret_t retval)3509 ABNSND(ret_t retval) {
3510 ENTRY(ABNSND)
3511 SAVSTK();
3512 if (ARGVAL(XPTR) == 1)
3513 BRANCH(FAIL)
3514 POP(ZCL);
3515 POP(YCL);
3516 if (D_V(XPTR) == S)
3517 BRANCH(PATNOD)
3518 if (D_V(XPTR) == E)
3519 BRANCH(PATNOD)
3520 if (D_V(XPTR) != I)
3521 BRANCH(INTR1)
3522 SAVSTK();
3523 PUSH(XPTR);
3524 GNVARI(XPTR);
3525 /* FALL */
3526 BRANCH(PATNOD)
3527 }
3528 static int
PATNOD(ret_t retval)3529 PATNOD(ret_t retval) {
3530 ENTRY(PATNOD)
3531 if (DCMP(XPTR, NULVCL))
3532 BRANCH(NONAME)
3533 SAVSTK();
3534 PUSH(LNODSZ);
3535 BLOCK(TPTR);
3536 MAKNOD(ZPTR,TPTR,ZCL,ZEROCL,YCL,XPTR);
3537 BRANCH(RTZPTR)
3538 /*_*/
3539 }
3540 int
LEN(ret_t retval)3541 LEN(ret_t retval) {
3542 ENTRY(LEN)
3543 PUSH(LNTHCL);
3544 BRANCH(LPRTND)
3545 /*_*/
3546 }
3547 int
POS(ret_t retval)3548 POS(ret_t retval) {
3549 ENTRY(POS)
3550 PUSH(POSICL);
3551 BRANCH(LPRTND)
3552 /*_*/
3553 }
3554 int
RPOS(ret_t retval)3555 RPOS(ret_t retval) {
3556 ENTRY(RPOS)
3557 PUSH(RPSICL);
3558 BRANCH(LPRTND)
3559 /*_*/
3560 }
3561 int
RTAB(ret_t retval)3562 RTAB(ret_t retval) {
3563 ENTRY(RTAB)
3564 PUSH(RTBCL);
3565 BRANCH(LPRTND)
3566 /*_*/
3567 }
3568 int
TAB(ret_t retval)3569 TAB(ret_t retval) {
3570 ENTRY(TAB)
3571 PUSH(TBCL);
3572 /* FALL */
3573 BRANCH(LPRTND)
3574 }
3575 static int
LPRTND(ret_t retval)3576 LPRTND(ret_t retval) {
3577 ENTRY(LPRTND)
3578 SAVSTK();
3579 if (ARGVAL(XPTR) == 1)
3580 BRANCH(FAIL)
3581 POP(YCL);
3582 D(ZCL) = D(ZEROCL);
3583 if (D_V(XPTR) == I)
3584 goto L_LPRTNI;
3585 if (D_V(XPTR) == E)
3586 BRANCH(PATNOD)
3587 if (D_V(XPTR) != S)
3588 BRANCH(INTR1)
3589 X_LOCSP(ZSP,XPTR);
3590 if (!SPCINT(XPTR,ZSP))
3591 BRANCH(INTR1)
3592 L_LPRTNI:
3593 if (D_A(XPTR) < 0)
3594 BRANCH(LENERR)
3595 if (!DCMP(YCL, LNTHCL))
3596 BRANCH(PATNOD)
3597 D_A(ZCL) = D_A(XPTR);
3598 BRANCH(PATNOD)
3599 /*_*/
3600 }
3601 int
ARBNO(ret_t retval)3602 ARBNO(ret_t retval) {
3603 ENTRY(ARBNO)
3604 SAVSTK();
3605 if (PATVAL(XPTR) == 1)
3606 BRANCH(FAIL)
3607 if (D_V(XPTR) == P)
3608 goto L_ARBP;
3609 if (D_V(XPTR) != S)
3610 BRANCH(INTR1)
3611 X_LOCSP(TSP,XPTR);
3612 D_A(TMVAL) = S_L(TSP);
3613 D_F(TMVAL) = D_V(TMVAL) = 0;
3614 SAVSTK();
3615 PUSH(LNODSZ);
3616 BLOCK(TPTR);
3617 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR);
3618 L_ARBP:
3619 D_A(XSIZ) = D_V(D_A(XPTR));
3620 D_F(XSIZ) = D_V(XSIZ) = 0;
3621 D(TSIZ) = D(XSIZ);
3622 D_A(TSIZ) += D_A(ARBSIZ);
3623 D_V(TSIZ) = P;
3624 SAVSTK();
3625 PUSH(TSIZ);
3626 BLOCK(TPTR);
3627 D(ZPTR) = D(TPTR);
3628 D_A(TSIZ) = D_V(D_A(ARHEAD));
3629 D_F(TSIZ) = D_V(TSIZ) = 0;
3630 CPYPAT(TPTR,ARHEAD,ZEROCL,ZEROCL,ZEROCL,TSIZ);
3631 D(ZSIZ) = D(XSIZ);
3632 D_A(ZSIZ) += D_A(TSIZ);
3633 CPYPAT(TPTR,XPTR,ZEROCL,TSIZ,ZSIZ,XSIZ);
3634 D(TSIZ) = D(NODSIZ);
3635 D_A(TSIZ) += D_A(NODSIZ);
3636 CPYPAT(TPTR,ARTAIL,ZEROCL,ZSIZ,ZEROCL,TSIZ);
3637 D_A(ZSIZ) = D_A(TSIZ) + D_A(ZSIZ);
3638 D_F(ZSIZ) = D_F(TSIZ);
3639 D_V(ZSIZ) = D_V(TSIZ);
3640 CPYPAT(TPTR,ARBACK,ZEROCL,ZSIZ,TSIZ,TSIZ);
3641 BRANCH(RTZPTR)
3642 /*_*/
3643 }
3644 int
ATOP(ret_t retval)3645 ATOP(ret_t retval) {
3646 ENTRY(ATOP)
3647 D_A(OCICL) += DESCR;
3648 D(YPTR) = D(D_A(OCBSCL) + D_A(OCICL));
3649 if (!(D_F(YPTR) & FNC))
3650 goto L_ATOP1;
3651 SAVSTK();
3652 PUSH(YPTR);
3653 switch (INVOKE(YPTR)) {
3654 case 1:
3655 BRANCH(FAIL)
3656 case 2:
3657 goto L_ATOP1;
3658 }
3659 if (D_V(YPTR) != E)
3660 BRANCH(NEMO)
3661 L_ATOP1:
3662 SAVSTK();
3663 PUSH(LNODSZ);
3664 BLOCK(TPTR);
3665 MAKNOD(ZPTR,TPTR,ZEROCL,ZEROCL,ATOPCL,YPTR);
3666 BRANCH(RTZPTR)
3667 /*_*/
3668 }
3669 int
NAM(ret_t retval)3670 NAM(ret_t retval) {
3671 ENTRY(NAM)
3672 PUSH(ENMECL);
3673 BRANCH(NAM5)
3674 /*_*/
3675 }
3676 int
DOL(ret_t retval)3677 DOL(ret_t retval) {
3678 ENTRY(DOL)
3679 PUSH(ENMICL);
3680 /* FALL */
3681 BRANCH(NAM5)
3682 }
3683 static int
NAM5(ret_t retval)3684 NAM5(ret_t retval) {
3685 ENTRY(NAM5)
3686 SAVSTK();
3687 if (PATVAL(XPTR) == 1)
3688 BRANCH(FAIL)
3689 D_A(OCICL) += DESCR;
3690 D(YPTR) = D(D_A(OCBSCL) + D_A(OCICL));
3691 if ((D_F(YPTR) & FNC))
3692 goto L_NAMC2;
3693 L_NAM3:
3694 if (D_V(XPTR) == S)
3695 goto L_NAMV;
3696 if (D_V(XPTR) == P)
3697 goto L_NAMP;
3698 else
3699 BRANCH(INTR1)
3700 /*_*/
3701 L_NAMC2:
3702 PUSH(XPTR);
3703 SAVSTK();
3704 PUSH(YPTR);
3705 switch (INVOKE(YPTR)) {
3706 case 1:
3707 BRANCH(FAIL)
3708 case 2:
3709 goto L_NAM4;
3710 }
3711 if (D_V(YPTR) != E)
3712 BRANCH(NEMO)
3713 L_NAM4:
3714 POP(XPTR);
3715 goto L_NAM3;
3716 /*_*/
3717 L_NAMV:
3718 X_LOCSP(TSP,XPTR);
3719 D_A(TMVAL) = S_L(TSP);
3720 D_F(TMVAL) = D_V(TMVAL) = 0;
3721 SAVSTK();
3722 PUSH(LNODSZ);
3723 BLOCK(TPTR);
3724 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR);
3725 L_NAMP:
3726 SAVSTK();
3727 PUSH(SNODSZ);
3728 BLOCK(TPTR);
3729 MAKNOD(WPTR,TPTR,ZEROCL,ZEROCL,NMECL,NULL);
3730 SAVSTK();
3731 PUSH(LNODSZ);
3732 BLOCK(TPTR);
3733 POP(TVAL);
3734 MAKNOD(YPTR,TPTR,ZEROCL,ZEROCL,TVAL,YPTR);
3735 D_A(XSIZ) = D_V(D_A(XPTR));
3736 D_F(XSIZ) = D_V(XSIZ) = 0;
3737 D(YSIZ) = D(XSIZ);
3738 D_A(YSIZ) += D_A(NODSIZ);
3739 D_A(TSIZ) = D_V(D_A(YPTR));
3740 D_F(TSIZ) = D_V(TSIZ) = 0;
3741 D(ZSIZ) = D(YSIZ);
3742 D_A(ZSIZ) += D_A(TSIZ);
3743 D_V(ZSIZ) = P;
3744 SAVSTK();
3745 PUSH(ZSIZ);
3746 BLOCK(TPTR);
3747 D(ZPTR) = D(TPTR);
3748 LVALUE(TVAL,XPTR);
3749 CPYPAT(TPTR,WPTR,TVAL,ZEROCL,NODSIZ,NODSIZ);
3750 CPYPAT(TPTR,XPTR,ZEROCL,NODSIZ,YSIZ,XSIZ);
3751 CPYPAT(TPTR,YPTR,ZEROCL,YSIZ,ZEROCL,TSIZ);
3752 BRANCH(RTZPTR)
3753 /*_*/
3754 }
3755 int
OR(ret_t retval)3756 OR(ret_t retval) {
3757 ENTRY(OR)
3758 SAVSTK();
3759 if (PATVAL(XPTR) == 1)
3760 BRANCH(FAIL)
3761 PUSH(XPTR);
3762 SAVSTK();
3763 if (PATVAL(YPTR) == 1)
3764 BRANCH(FAIL)
3765 POP(XPTR);
3766 D_A(DTCL) = D_V(XPTR);
3767 D_F(DTCL) = D_V(DTCL) = 0;
3768 D_V(DTCL) = D_V(YPTR);
3769 if (DCMP(DTCL, VVDTP))
3770 goto L_ORVV;
3771 if (DCMP(DTCL, VPDTP))
3772 goto L_ORVP;
3773 if (DCMP(DTCL, PVDTP))
3774 goto L_ORPV;
3775 if (DCMP(DTCL, PPDTP))
3776 goto L_ORPP;
3777 else
3778 BRANCH(INTR1)
3779 /*_*/
3780 L_ORVV:
3781 X_LOCSP(XSP,XPTR);
3782 D_A(TMVAL) = S_L(XSP);
3783 D_F(TMVAL) = D_V(TMVAL) = 0;
3784 SAVSTK();
3785 PUSH(LNODSZ);
3786 BLOCK(TPTR);
3787 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR);
3788 L_ORPV:
3789 X_LOCSP(YSP,YPTR);
3790 D_A(TMVAL) = S_L(YSP);
3791 D_F(TMVAL) = D_V(TMVAL) = 0;
3792 SAVSTK();
3793 PUSH(LNODSZ);
3794 BLOCK(TPTR);
3795 MAKNOD(YPTR,TPTR,TMVAL,ZEROCL,CHRCL,YPTR);
3796 L_ORPP:
3797 D_A(XSIZ) = D_V(D_A(XPTR));
3798 D_F(XSIZ) = D_V(XSIZ) = 0;
3799 D_A(YSIZ) = D_V(D_A(YPTR));
3800 D_F(YSIZ) = D_V(YSIZ) = 0;
3801 D(TSIZ) = D(XSIZ);
3802 D_A(TSIZ) += D_A(YSIZ);
3803 D_V(TSIZ) = P;
3804 SAVSTK();
3805 PUSH(TSIZ);
3806 BLOCK(TPTR);
3807 D(ZPTR) = D(TPTR);
3808 CPYPAT(TPTR,XPTR,ZEROCL,ZEROCL,ZEROCL,XSIZ);
3809 CPYPAT(TPTR,YPTR,ZEROCL,XSIZ,ZEROCL,YSIZ);
3810 LINKOR(ZPTR,XSIZ);
3811 BRANCH(RTZPTR)
3812 /*_*/
3813 L_ORVP:
3814 X_LOCSP(XSP,XPTR);
3815 D_A(TMVAL) = S_L(XSP);
3816 D_F(TMVAL) = D_V(TMVAL) = 0;
3817 SAVSTK();
3818 PUSH(LNODSZ);
3819 BLOCK(TPTR);
3820 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR);
3821 goto L_ORPP;
3822 /*_*/
3823 }
3824 int
SCAN(ret_t retval)3825 SCAN(ret_t retval) {
3826 ENTRY(SCAN)
3827 SAVSTK();
3828 if (ARGVAL(XPTR) == 1)
3829 BRANCH(FAIL)
3830 PUSH(XPTR);
3831 SAVSTK();
3832 if (PATVAL(YPTR) == 1)
3833 BRANCH(FAIL)
3834 POP(XPTR);
3835 D_A(DTCL) = D_V(XPTR);
3836 D_F(DTCL) = D_V(DTCL) = 0;
3837 D_V(DTCL) = D_V(YPTR);
3838 D_A(SCNCL)++;
3839 if (DCMP(DTCL, VVDTP))
3840 goto L_SCANVV;
3841 if (DCMP(DTCL, VPDTP))
3842 goto L_SCANVP;
3843 if (DCMP(DTCL, IVDTP))
3844 goto L_SCANIV;
3845 if (DCMP(DTCL, RVDTP))
3846 goto L_SCANRV;
3847 if (DCMP(DTCL, RPDTP))
3848 goto L_SCANRP;
3849 if (DCMP(DTCL, IPDTP))
3850 goto L_SCANIP;
3851 else
3852 BRANCH(INTR1)
3853 /*_*/
3854 L_SCANVV:
3855 X_LOCSP(XSP,XPTR);
3856 X_LOCSP(YSP,YPTR);
3857 L_SCANVB:
3858 if (S_L(XSP) < S_L(YSP))
3859 BRANCH(FAIL)
3860 _SPEC(TSP) = _SPEC(XSP);
3861 S_L(TSP) = S_L(YSP);
3862 if (LEXEQ(TSP,YSP))
3863 BRANCH(RTYPTR)
3864 if (D_A(ANCCL) != 0)
3865 BRANCH(FAIL)
3866 S_L(XSP)--;
3867 S_O(XSP)++;
3868 goto L_SCANVB;
3869 /*_*/
3870 L_SCANIV:
3871 SAVSTK();
3872 PUSH(XPTR);
3873 GNVARI(XPTR);
3874 goto L_SCANVV;
3875 /*_*/
3876 L_SCANVP:
3877 X_LOCSP(XSP,XPTR);
3878 SAVSTK();
3879 switch (SCNR(NORET)) {
3880 case 1:
3881 case 3:
3882 BRANCH(FAIL)
3883 }
3884 SAVSTK();
3885 switch (NMD(NORET)) {
3886 case 1:
3887 BRANCH(FAIL)
3888 }
3889 if (S_L(TXSP) >= S_L(HEADSP))
3890 goto L_SCANV1;
3891 X_REMSP(XSP,HEADSP,TXSP);
3892 goto L_SCANV2;
3893 /*_*/
3894 L_SCANV1:
3895 X_REMSP(XSP,TXSP,HEADSP);
3896 L_SCANV2:
3897 SAVSTK();
3898 PUSH(XSPPTR);
3899 if (GENVAR(YPTR) == 1)
3900 BRANCH(RTYPTR)
3901 /*_*/
3902 L_SCANIP:
3903 SAVSTK();
3904 PUSH(XPTR);
3905 GNVARI(XPTR);
3906 goto L_SCANVP;
3907 /*_*/
3908 L_SCANRV:
3909 REALST(XSP,XPTR);
3910 SAVSTK();
3911 PUSH(XSPPTR);
3912 if (GENVAR(XPTR) == 1)
3913 goto L_SCANVV;
3914 /*_*/
3915 L_SCANRP:
3916 REALST(XSP,XPTR);
3917 SAVSTK();
3918 PUSH(XSPPTR);
3919 if (GENVAR(XPTR) == 1)
3920 goto L_SCANVP;
3921 /*_*/
3922 }
3923 int
SJSR(ret_t retval)3924 SJSR(ret_t retval) {
3925 ENTRY(SJSR)
3926 D_A(OCICL) += DESCR;
3927 D(WPTR) = D(D_A(OCBSCL) + D_A(OCICL));
3928 if ((D_F(WPTR) & FNC))
3929 goto L_SJSRC1;
3930 L_SJSR1:
3931 if (D_A(INSW) == 0)
3932 goto L_SJSR1A;
3933 if (!LOCAPV(ZPTR,INATL,WPTR))
3934 goto L_SJSR1A;
3935 D(ZPTR) = D(D_A(ZPTR) + DESCR);
3936 SAVSTK();
3937 PUSH(WPTR);
3938 PUSH(ZPTR);
3939 switch (PUTIN(XPTR)) {
3940 case 1:
3941 BRANCH(FAIL)
3942 case 2:
3943 goto L_SJSR1B;
3944 }
3945 /*_*/
3946 L_SJSR1A:
3947 D(XPTR) = D(D_A(WPTR) + DESCR);
3948 L_SJSR1B:
3949 PUSH(WPTR);
3950 PUSH(XPTR);
3951 SAVSTK();
3952 if (PATVAL(YPTR) == 1)
3953 BRANCH(FAIL)
3954 POP(XPTR);
3955 D_A(DTCL) = D_V(XPTR);
3956 D_F(DTCL) = D_V(DTCL) = 0;
3957 D_V(DTCL) = D_V(YPTR);
3958 D_A(SCNCL)++;
3959 if (DCMP(DTCL, VVDTP))
3960 goto L_SJSSVV;
3961 if (DCMP(DTCL, VPDTP))
3962 goto L_SJSSVP;
3963 if (DCMP(DTCL, IVDTP))
3964 goto L_SJSSIV;
3965 if (DCMP(DTCL, RVDTP))
3966 goto L_SJSSRV;
3967 if (DCMP(DTCL, RPDTP))
3968 goto L_SJSSRP;
3969 if (DCMP(DTCL, IPDTP))
3970 goto L_SJSSIP;
3971 else
3972 BRANCH(INTR1)
3973 /*_*/
3974 L_SJSRC1:
3975 SAVSTK();
3976 PUSH(WPTR);
3977 switch (INVOKE(WPTR)) {
3978 case 1:
3979 BRANCH(FAIL)
3980 case 2:
3981 goto L_SJSR1;
3982 case 3:
3983 BRANCH(NEMO)
3984 }
3985 /*_*/
3986 L_SJSSVP:
3987 X_LOCSP(XSP,XPTR);
3988 SAVSTK();
3989 switch (SCNR(NORET)) {
3990 case 1:
3991 case 3:
3992 BRANCH(FAIL)
3993 }
3994 D_A(NAMGCL) = 1;
3995 X_REMSP(TAILSP,XSP,TXSP);
3996 goto L_SJSS1;
3997 /*_*/
3998 L_SJSSIP:
3999 SAVSTK();
4000 PUSH(XPTR);
4001 GNVARI(XPTR);
4002 goto L_SJSSVP;
4003 /*_*/
4004 L_SJSSIV:
4005 SAVSTK();
4006 PUSH(XPTR);
4007 GNVARI(XPTR);
4008 goto L_SJSSVV;
4009 /*_*/
4010 L_SJSSRV:
4011 REALST(XSP,XPTR);
4012 SAVSTK();
4013 PUSH(XSPPTR);
4014 if (GENVAR(XPTR) == 1)
4015 goto L_SJSSVV;
4016 /*_*/
4017 L_SJSSRP:
4018 REALST(XSP,XPTR);
4019 SAVSTK();
4020 PUSH(XSPPTR);
4021 if (GENVAR(XPTR) == 1)
4022 goto L_SJSSVP;
4023 /*_*/
4024 L_SJVVON:
4025 if (D_A(ANCCL) != 0)
4026 BRANCH(FAIL)
4027 S_L(HEADSP) += D_A(ONECL);
4028 S_L(XSP)--;
4029 S_O(XSP)++;
4030 goto L_SJSSV2;
4031 /*_*/
4032 L_SJSSVV:
4033 X_LOCSP(XSP,XPTR);
4034 X_LOCSP(YSP,YPTR);
4035 _SPEC(HEADSP) = _SPEC(XSP);
4036 S_L(HEADSP) = 0;
4037 L_SJSSV2:
4038 if (S_L(XSP) < S_L(YSP))
4039 BRANCH(FAIL)
4040 _SPEC(TSP) = _SPEC(XSP);
4041 S_L(TSP) = S_L(YSP);
4042 if (!LEXEQ(TSP,YSP))
4043 goto L_SJVVON;
4044 D_A(NAMGCL) = 0;
4045 X_REMSP(TAILSP,XSP,TSP);
4046 L_SJSS1:
4047 SPUSH(TAILSP);
4048 SPUSH(HEADSP);
4049 if (D_A(NAMGCL) == 0)
4050 goto L_SJSS1A;
4051 SAVSTK();
4052 if (NMD(NORET) == 1)
4053 BRANCH(FAIL)
4054 L_SJSS1A:
4055 SAVSTK();
4056 if (ARGVAL(ZPTR) == 1)
4057 BRANCH(FAIL)
4058 SPOP(HEADSP);
4059 SPOP(TAILSP);
4060 POP(WPTR);
4061 if (S_L(HEADSP) != 0)
4062 goto L_SJSSDT;
4063 if (S_L(TAILSP) == 0)
4064 goto L_SJSRV1;
4065 L_SJSSDT:
4066 if (D_V(ZPTR) == S)
4067 goto L_SJSRV;
4068 if (D_V(ZPTR) == P)
4069 goto L_SJSRP;
4070 if (D_V(ZPTR) == I)
4071 goto L_SJSRI;
4072 if (D_V(ZPTR) == R)
4073 goto L_SJSRR;
4074 if (D_V(ZPTR) != E)
4075 BRANCH(INTR1)
4076 SAVSTK();
4077 PUSH(STARSZ);
4078 BLOCK(TPTR);
4079 MOVBLK(D_A(TPTR),D_A(STRPAT),D_A(STARSZ));
4080 D(D_A(TPTR) + 4*DESCR) = D(ZPTR);
4081 D(ZPTR) = D(TPTR);
4082 L_SJSRP:
4083 _SPEC(XSP) = _SPEC(HEADSP);
4084 SAVSTK();
4085 PUSH(XSPPTR);
4086 GENVAR(XPTR);
4087 D_A(TMVAL) = S_L(HEADSP);
4088 D_F(TMVAL) = D_V(TMVAL) = 0;
4089 SAVSTK();
4090 PUSH(LNODSZ);
4091 BLOCK(TPTR);
4092 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR);
4093 _SPEC(YSP) = _SPEC(TAILSP);
4094 SAVSTK();
4095 PUSH(YSPPTR);
4096 GENVAR(YPTR);
4097 D_A(TMVAL) = S_L(TAILSP);
4098 D_F(TMVAL) = D_V(TMVAL) = 0;
4099 SAVSTK();
4100 PUSH(LNODSZ);
4101 BLOCK(TPTR);
4102 MAKNOD(YPTR,TPTR,TMVAL,ZEROCL,CHRCL,YPTR);
4103 D_A(XSIZ) = D_V(D_A(XPTR));
4104 D_F(XSIZ) = D_V(XSIZ) = 0;
4105 D_A(YSIZ) = D_V(D_A(YPTR));
4106 D_F(YSIZ) = D_V(YSIZ) = 0;
4107 D_A(ZSIZ) = D_V(D_A(ZPTR));
4108 D_F(ZSIZ) = D_V(ZSIZ) = 0;
4109 D(TSIZ) = D(XSIZ);
4110 D_A(TSIZ) += D_A(ZSIZ);
4111 D_A(TSIZ) += D_A(YSIZ);
4112 D_V(TSIZ) = P;
4113 SAVSTK();
4114 PUSH(TSIZ);
4115 BLOCK(TPTR);
4116 D(VVAL) = D(TPTR);
4117 LVALUE(TVAL,ZPTR);
4118 CPYPAT(TPTR,XPTR,TVAL,ZEROCL,XSIZ,XSIZ);
4119 LVALUE(TVAL,YPTR);
4120 D(TSIZ) = D(XSIZ);
4121 D_A(TSIZ) += D_A(ZSIZ);
4122 CPYPAT(TPTR,ZPTR,TVAL,XSIZ,TSIZ,ZSIZ);
4123 CPYPAT(TPTR,YPTR,ZEROCL,TSIZ,ZEROCL,YSIZ);
4124 D(ZPTR) = D(VVAL);
4125 goto L_SJSRV1;
4126 /*_*/
4127 L_SJSRV:
4128 X_LOCSP(ZSP,ZPTR);
4129 L_SJSRS:
4130 D_A(XPTR) = S_L(TAILSP);
4131 D_F(XPTR) = D_V(XPTR) = 0;
4132 D_A(YPTR) = S_L(HEADSP);
4133 D_F(YPTR) = D_V(YPTR) = 0;
4134 D_A(ZPTR) = S_L(ZSP);
4135 D_F(ZPTR) = D_V(ZPTR) = 0;
4136 D_A(XPTR) += D_A(YPTR);
4137 D_A(XPTR) += D_A(ZPTR);
4138 if (D_A(XPTR) > D_A(MLENCL))
4139 BRANCH(INTR8)
4140 SAVSTK();
4141 PUSH(XPTR);
4142 CONVAR(ZPTR);
4143 X_LOCSP(TSP,ZPTR);
4144 S_L(TSP) = 0;
4145 APDSP(TSP,HEADSP);
4146 APDSP(TSP,ZSP);
4147 APDSP(TSP,TAILSP);
4148 SAVSTK();
4149 PUSH(XPTR);
4150 GNVARS(ZPTR);
4151 L_SJSRV1:
4152 D(D_A(WPTR) + DESCR) = D(ZPTR);
4153 if (D_A(OUTSW) == 0)
4154 goto L_SJSRV2;
4155 if (!LOCAPV(YPTR,OUTATL,WPTR))
4156 goto L_SJSRV2;
4157 D(YPTR) = D(D_A(YPTR) + DESCR);
4158 SAVSTK();
4159 PUSH(ZPTR);
4160 PUSH(YPTR);
4161 PUTOUT(NORET);
4162 L_SJSRV2:
4163 if (D_A(TRAPCL) <= 0)
4164 BRANCH(RTZPTR)
4165 if (!LOCAPT(ATPTR,TVALL,WPTR))
4166 BRANCH(RTZPTR)
4167 SAVSTK();
4168 PUSH(ATPTR);
4169 if (TRPHND(NORET) == 1)
4170 BRANCH(RTZPTR)
4171 /*_*/
4172 L_SJSRI:
4173 INTSPC(ZSP,ZPTR);
4174 goto L_SJSRS;
4175 /*_*/
4176 L_SJSRR:
4177 REALST(ZSP,ZPTR);
4178 goto L_SJSRS;
4179 /*_*/
4180 }
4181 static int
SCNR(ret_t retval)4182 SCNR(ret_t retval) {
4183 ENTRY(SCNR)
4184 D_A(MAXLEN) = S_L(XSP);
4185 D_F(MAXLEN) = D_V(MAXLEN) = 0;
4186 LVALUE(YSIZ,YPTR);
4187 if (D_A(FULLCL) != 0)
4188 goto L_SCNR1;
4189 if (D_A(YSIZ) > D_A(MAXLEN))
4190 BRANCH(FAIL)
4191 L_SCNR1:
4192 _SPEC(TXSP) = _SPEC(XSP);
4193 S_L(TXSP) = 0;
4194 D(PDLPTR) = D(PDLHED);
4195 D(NAMICL) = D(NHEDCL);
4196 if (D_A(ANCCL) != 0)
4197 goto L_SCNR3;
4198 if (D_A(FULLCL) == 0)
4199 goto L_SCNR4;
4200 D(YSIZ) = D(MAXLEN);
4201 goto L_SCNR5;
4202 /*_*/
4203 L_SCNR4:
4204 D_A(YSIZ) = D_A(MAXLEN) - D_A(YSIZ);
4205 D_F(YSIZ) = D_F(MAXLEN);
4206 D_V(YSIZ) = D_V(MAXLEN);
4207 L_SCNR5:
4208 D_A(YSIZ) += D_A(CHARCL);
4209 PUSH(YPTR);
4210 PUSH(YSIZ);
4211 _SPEC(HEADSP) = _SPEC(TXSP);
4212 D_A(PDLPTR) += 3*DESCR;
4213 if (D_A(PDLPTR) > D_A(PDLEND))
4214 BRANCH(INTR31)
4215 D_A(LENFCL) = 1;
4216 D(D_A(PDLPTR) + DESCR) = D(SCONCL);
4217 D_A(TMVAL) = S_L(TXSP);
4218 D_F(TMVAL) = D_V(TMVAL) = 0;
4219 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL);
4220 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL);
4221 BRANCH(SCIN)
4222 /*_*/
4223 L_SCNR3:
4224 D_A(PDLPTR) += 3*DESCR;
4225 if (D_A(PDLPTR) > D_A(PDLEND))
4226 BRANCH(INTR31)
4227 S_L(HEADSP) = 0;
4228 D(D_A(PDLPTR) + DESCR) = D(SCFLCL);
4229 D_A(TMVAL) = S_L(TXSP);
4230 D_F(TMVAL) = D_V(TMVAL) = 0;
4231 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL);
4232 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL);
4233 BRANCH(SCIN)
4234 /*_*/
4235 }
4236 static int
SCIN(ret_t retval)4237 SCIN(ret_t retval) {
4238 ENTRY(SCIN)
4239 D_A(UNSCCL) = 0;
4240 /* FALL */
4241 BRANCH(SCIN1)
4242 }
4243 static int
SCIN1(ret_t retval)4244 SCIN1(ret_t retval) {
4245 ENTRY(SCIN1)
4246 L_SCIN1A:
4247 D(PATBCL) = D(YPTR);
4248 if (D_A(UNSCCL) != 0)
4249 goto L_UNSC;
4250 D_A(PATICL) = 0;
4251 L_SCIN2:
4252 D_A(LENFCL) = 1;
4253 L_SCIN3:
4254 D_A(PATICL) += DESCR;
4255 D(ZCL) = D(D_A(PATBCL) + D_A(PATICL));
4256 D_A(PATICL) += DESCR;
4257 D(XCL) = D(D_A(PATBCL) + D_A(PATICL));
4258 D_A(PATICL) += DESCR;
4259 D(YCL) = D(D_A(PATBCL) + D_A(PATICL));
4260 D_A(PDLPTR) += 3*DESCR;
4261 if (D_A(PDLPTR) > D_A(PDLEND))
4262 BRANCH(INTR31)
4263 D(D_A(PDLPTR) + DESCR) = D(XCL);
4264 D_A(TMVAL) = S_L(TXSP);
4265 D_F(TMVAL) = D_V(TMVAL) = 0;
4266 D_V(TMVAL) = D_V(YCL);
4267 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL);
4268 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL);
4269 if (D_A(FULLCL) != 0)
4270 goto L_SCIN4;
4271 if (S_L(TXSP) + D_A(YCL) > D_A(MAXLEN))
4272 goto L_SALT1;
4273 L_SCIN4:
4274 D(PTBRCL) = D(D_A(ZCL));
4275 goto L_PATBRA;
4276 /*_*/
4277 L_SALF:
4278 L_TSALF:
4279 L_SALF1:
4280 D_A(LENFCL) = 0;
4281 goto L_SALT2;
4282 /*_*/
4283 L_SALT:
4284 L_TSALT:
4285 L_SALT1:
4286 D(LENFCL) = D(D_A(PDLPTR) + 3*DESCR);
4287 L_SALT2:
4288 D(XCL) = D(D_A(PDLPTR) + DESCR);
4289 D(YCL) = D(D_A(PDLPTR) + 2*DESCR);
4290 D_A(PDLPTR) -= 3*DESCR;
4291 D(PATICL) = D(XCL);
4292 if (D_A(PATICL) == 0)
4293 goto L_SALT3;
4294 S_L(TXSP) = D_A(YCL);
4295 if (!(D_F(PATICL) & FNC))
4296 goto L_SCIN3;
4297 D(PTBRCL) = D(D_A(PATICL));
4298 L_PATBRA:
4299 switch (D_A(PTBRCL)) {
4300 case 1:
4301 goto L_ANYC;
4302 case 2:
4303 goto L_ARBF;
4304 case 3:
4305 goto L_ARBN;
4306 case 4:
4307 goto L_ATP;
4308 case 5:
4309 goto L_CHR;
4310 case 6:
4311 goto L_BAL;
4312 case 7:
4313 goto L_BALF;
4314 case 8:
4315 goto L_BRKC;
4316 case 9:
4317 goto L_BRKX;
4318 case 10:
4319 goto L_BRKXF;
4320 case 11:
4321 goto L_DNME;
4322 case 12:
4323 goto L_DNME1;
4324 case 13:
4325 goto L_EARB;
4326 case 14:
4327 goto L_DSAR;
4328 case 15:
4329 goto L_ENME;
4330 case 16:
4331 goto L_ENMI;
4332 case 17:
4333 goto L_FARB;
4334 case 18:
4335 goto L_FNME;
4336 case 19:
4337 goto L_LNTH;
4338 case 20:
4339 goto L_NME;
4340 case 21:
4341 goto L_NNYC;
4342 case 22:
4343 goto L_ONAR;
4344 case 23:
4345 goto L_ONRF;
4346 case 24:
4347 goto L_POSI;
4348 case 25:
4349 goto L_RPSI;
4350 case 26:
4351 goto L_RTB;
4352 case 27:
4353 BRANCH(FAIL)
4354 case 28:
4355 goto L_SALF;
4356 case 29:
4357 goto L_SCOK;
4358 case 30:
4359 goto L_SCON;
4360 case 31:
4361 goto L_SPNC;
4362 case 32:
4363 goto L_STAR;
4364 case 33:
4365 goto L_TB;
4366 case 34:
4367 BRANCH(RTNUL3)
4368 case 35:
4369 goto L_FNCE;
4370 case 36:
4371 goto L_SUCF;
4372 }
4373 BRANCH(INTR13)
4374 /*_*/
4375 L_UNSC:
4376 D_A(UNSCCL) = 0;
4377 D(PATBCL) = D(YPTR);
4378 L_SALT3:
4379 if (D_A(LENFCL) != 0)
4380 goto L_SALT1;
4381 goto L_SALF1;
4382 /*_*/
4383 L_SCOK:
4384 L_TSCOK:
4385 D_A(PATICL) = D_V(XCL);
4386 D_F(PATICL) = D_V(PATICL) = 0;
4387 if (D_A(PATICL) == 0)
4388 BRANCH(RTN2)
4389 else
4390 goto L_SCIN2;
4391 /*_*/
4392 L_SCON:
4393 if (D_A(FULLCL) != 0)
4394 goto L_SCON1;
4395 if (D_A(LENFCL) != 0)
4396 BRANCH(FAIL)
4397 L_SCON1:
4398 POP(YSIZ);
4399 POP(YPTR);
4400 D_A(YSIZ)--;
4401 if (D_A(YSIZ) < 0)
4402 BRANCH(INTR13)
4403 if (D_A(YSIZ) == 0)
4404 BRANCH(FAIL)
4405 S_L(TXSP) += D_A(ONECL);
4406 PUSH(YPTR);
4407 PUSH(YSIZ);
4408 _SPEC(HEADSP) = _SPEC(TXSP);
4409 D_A(PDLPTR) += 3*DESCR;
4410 if (D_A(PDLPTR) > D_A(PDLEND))
4411 BRANCH(INTR31)
4412 D_A(LENFCL) = 1;
4413 D(D_A(PDLPTR) + DESCR) = D(SCONCL);
4414 D_A(TMVAL) = S_L(TXSP);
4415 D_F(TMVAL) = D_V(TMVAL) = 0;
4416 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL);
4417 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL);
4418 goto L_SCIN1A;
4419 /*_*/
4420 L_BRKC:
4421 D_A(SCL) = 2;
4422 goto L_ABNS;
4423 /*_*/
4424 L_BRKX:
4425 D_A(SCL) = 5;
4426 goto L_ABNS;
4427 /*_*/
4428 L_NNYC:
4429 D_A(SCL) = 3;
4430 goto L_ABNS;
4431 /*_*/
4432 L_SPNC:
4433 D_A(SCL) = 4;
4434 goto L_ABNS;
4435 /*_*/
4436 L_ANYC:
4437 D_A(SCL) = 1;
4438 L_ABNS:
4439 D_A(PATICL) += DESCR;
4440 D(XPTR) = D(D_A(PATBCL) + D_A(PATICL));
4441 L_ABNS1:
4442 if (D_V(XPTR) == S)
4443 goto L_ABNSV;
4444 if (D_V(XPTR) == E)
4445 goto L_ABNSE;
4446 if (D_V(XPTR) == I)
4447 goto L_ABNSI;
4448 else
4449 goto L_SCDTER;
4450 /*_*/
4451 L_ABNSE:
4452 PUSH(SCL);
4453 SAVSTK();
4454 PUSH(XPTR);
4455 switch (EXPVAL(XPTR)) {
4456 case 1:
4457 goto L_ABNSF;
4458 case 2:
4459 goto L_ABNS2;
4460 }
4461 L_ABNSF:
4462 POP(SCL);
4463 goto L_SALF;
4464 /*_*/
4465 L_ABNS2:
4466 POP(SCL);
4467 goto L_ABNS1;
4468 /*_*/
4469 L_ABNSI:
4470 SAVSTK();
4471 PUSH(XPTR);
4472 GNVARI(XPTR);
4473 L_ABNSV:
4474 if (D_A(XPTR) == 0)
4475 goto L_SCNAME;
4476 switch (D_A(SCL)) {
4477 case 1:
4478 case 3:
4479 goto L_ANYC3;
4480 case 4:
4481 goto L_SPNV;
4482 }
4483 if (DCMP(XPTR, TBLBCS))
4484 goto L_ANYC3;
4485 clertb(&BRKTB,AC_CONTIN);
4486 X_LOCSP(YSP,XPTR);
4487 PLUGTB(&BRKTB,AC_STOPSH,YSP);
4488 D(TBLBCS) = D(XPTR);
4489 L_ANYC3:
4490 _SPEC(VSP) = _SPEC(XSP);
4491 if (D_A(FULLCL) != 0)
4492 goto L_ANYC4;
4493 S_L(VSP) = D_A(MAXLEN);
4494 if (S_L(VSP) < S_L(TXSP))
4495 goto L_SALT;
4496 if (S_L(XSP) + D_A(ZEROCL) <= D_A(MAXLEN))
4497 goto L_ANYC4;
4498 S_L(VSP) += D_A(ONECL);
4499 L_ANYC4:
4500 X_REMSP(YSP,VSP,TXSP);
4501 switch (D_A(SCL)) {
4502 case 1:
4503 case 3:
4504 goto L_ANYC7;
4505 }
4506 switch (STREAM(ZSP, YSP, &BRKTB)) {
4507 case ST_ERROR:
4508 goto L_SALF;
4509 case ST_EOS:
4510 goto L_SALT;
4511 }
4512 D_A(XPTR) = S_L(ZSP);
4513 D_F(XPTR) = D_V(XPTR) = 0;
4514 S_L(TXSP) += D_A(XPTR);
4515 if (D_A(SCL) != 5)
4516 goto L_SCOK;
4517 D_A(PDLPTR) += 3*DESCR;
4518 if (D_A(PDLPTR) > D_A(PDLEND))
4519 BRANCH(INTR31)
4520 D(D_A(PDLPTR) + DESCR) = D(ZEROCL);
4521 D(D_A(PDLPTR) + 2*DESCR) = D(PATICL);
4522 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL);
4523 D_A(TVAL) = S_L(TXSP);
4524 D_F(TVAL) = D_V(TVAL) = 0;
4525 D_A(TMVAL) = D_A(TVAL);
4526 D_A(PDLPTR) += 3*DESCR;
4527 if (D_A(PDLPTR) > D_A(PDLEND))
4528 BRANCH(INTR31)
4529 D(D_A(PDLPTR) + DESCR) = D(BRXFCL);
4530 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL);
4531 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL);
4532 goto L_SCOK;
4533 /*_*/
4534 L_ANYC7:
4535 if (S_L(YSP) == 0)
4536 goto L_SALT;
4537 if (XANY(YSP,XPTR))
4538 goto L_ANYC5;
4539 if (D_A(SCL) == 1)
4540 goto L_SALF;
4541 L_ANYC6:
4542 S_L(TXSP) += D_A(ONECL);
4543 goto L_SCOK;
4544 L_ANYC5:
4545 if (D_A(SCL) == 3)
4546 goto L_SALF;
4547 else
4548 goto L_ANYC6;
4549 /*_*/
4550 L_BRKXF:
4551 D(PATICL) = D(D_A(PDLPTR) + 2*DESCR);
4552 D_A(PATICL) -= DESCR;
4553 D_A(PDLPTR) -= 3*DESCR;
4554 if (D_A(FULLCL) == 0)
4555 goto L_BRXF1;
4556 D_A(NVAL) = 0;
4557 goto L_BRXF3;
4558 /*_*/
4559 L_BRXF1:
4560 if (D_A(LENFCL) != 0)
4561 goto L_SALT;
4562 D_A(NVAL) = D_V(YCL);
4563 D_F(NVAL) = D_V(NVAL) = 0;
4564 L_BRXF3:
4565 if (S_L(TXSP) + D_A(NVAL) >= D_A(MAXLEN))
4566 goto L_SALT;
4567 D(XCL) = D(D_A(PDLPTR) + DESCR);
4568 S_L(TXSP) += D_A(ONECL);
4569 goto L_BRKX;
4570 /*_*/
4571 L_SPNV:
4572 if (DCMP(XPTR, TBLSCS))
4573 goto L_SPNC3;
4574 clertb(&SPANTB,AC_STOPSH);
4575 X_LOCSP(YSP,XPTR);
4576 PLUGTB(&SPANTB,AC_CONTIN,YSP);
4577 D(TBLSCS) = D(XPTR);
4578 L_SPNC3:
4579 if (S_L(XSP) <= S_L(TXSP))
4580 goto L_SALT;
4581 X_REMSP(YSP,XSP,TXSP);
4582 switch (STREAM(ZSP, YSP, &SPANTB)) {
4583 case ST_ERROR:
4584 goto L_SALF;
4585 }
4586 if (S_L(ZSP) == 0)
4587 goto L_SALF;
4588 D_A(XPTR) = S_L(ZSP);
4589 D_F(XPTR) = D_V(XPTR) = 0;
4590 if (D_A(FULLCL) != 0)
4591 goto L_SPNC5;
4592 if (S_L(TXSP) + D_A(XPTR) > D_A(MAXLEN))
4593 goto L_SALT;
4594 L_SPNC5:
4595 S_L(TXSP) += D_A(XPTR);
4596 goto L_SCOK;
4597 /*_*/
4598 L_LNTH:
4599 D_A(SCL) = 1;
4600 L_LPRRT:
4601 D_A(PATICL) += DESCR;
4602 D(XPTR) = D(D_A(PATBCL) + D_A(PATICL));
4603 PUSH(SCL);
4604 L_LPRRT1:
4605 if (D_V(XPTR) == I)
4606 goto L_LPRRTI;
4607 if (D_V(XPTR) == E)
4608 goto L_LPRRTE;
4609 if (D_V(XPTR) == S)
4610 goto L_LPRRTV;
4611 POP(SCL);
4612 goto L_SCDTER;
4613 L_LPRRTE:
4614 SAVSTK();
4615 PUSH(XPTR);
4616 switch (EXPVAL(XPTR)) {
4617 case 2:
4618 goto L_LPRRT1;
4619 }
4620 POP(SCL);
4621 goto L_TSALF;
4622 /*_*/
4623 L_LPRRTV:
4624 X_LOCSP(ZSP,XPTR);
4625 if (!SPCINT(XPTR,ZSP))
4626 goto L_SCDTER;
4627 L_LPRRTI:
4628 POP(SCL);
4629 switch (D_A(SCL)) {
4630 case 2:
4631 goto L_POSII;
4632 case 3:
4633 goto L_RPSII;
4634 case 4:
4635 goto L_RTBI;
4636 case 5:
4637 goto L_TBI;
4638 }
4639 if (D_A(XPTR) < 0)
4640 goto L_SCLENR;
4641 if (S_L(TXSP) + D_A(XPTR) > D_A(MAXLEN))
4642 goto L_TSALT;
4643 S_L(TXSP) += D_A(XPTR);
4644 goto L_SCOK;
4645 /*_*/
4646 L_POSII:
4647 if (D_A(XPTR) < 0)
4648 goto L_SCLENR;
4649 D_A(NVAL) = S_L(TXSP);
4650 D_F(NVAL) = D_V(NVAL) = 0;
4651 if (D_A(XPTR) > D_A(MAXLEN))
4652 goto L_TSALT;
4653 if (D_A(XPTR) == D_A(NVAL))
4654 goto L_TSCOK;
4655 if (D_A(XPTR) > D_A(NVAL))
4656 goto L_TSALF;
4657 goto L_SALT;
4658 /*_*/
4659 L_RPSII:
4660 if (D_A(XPTR) < 0)
4661 goto L_SCLENR;
4662 D_A(NVAL) = S_L(XSP);
4663 D_F(NVAL) = D_V(NVAL) = 0;
4664 D(TVAL) = D(NVAL);
4665 D_A(TVAL) -= D_A(XPTR);
4666 D_A(NVAL) = S_L(TXSP);
4667 D_F(NVAL) = D_V(NVAL) = 0;
4668 if (D_A(NVAL) < D_A(TVAL))
4669 goto L_TSALF;
4670 if (D_A(NVAL) == D_A(TVAL))
4671 goto L_TSCOK;
4672 goto L_TSALT;
4673 /*_*/
4674 L_RTBI:
4675 if (D_A(XPTR) < 0)
4676 goto L_SCLENR;
4677 D_A(NVAL) = S_L(XSP);
4678 D_F(NVAL) = D_V(NVAL) = 0;
4679 D(TVAL) = D(NVAL);
4680 D_A(TVAL) -= D_A(XPTR);
4681 D_A(NVAL) = S_L(TXSP);
4682 D_F(NVAL) = D_V(NVAL) = 0;
4683 if (D_A(NVAL) > D_A(TVAL))
4684 goto L_TSALT;
4685 if (D_A(FULLCL) != 0)
4686 goto L_RTBII;
4687 D_A(NVAL) = D_V(YCL);
4688 D_F(NVAL) = D_V(NVAL) = 0;
4689 D_A(NVAL) = D_A(MAXLEN) - D_A(NVAL);
4690 D_F(NVAL) = D_F(MAXLEN);
4691 D_V(NVAL) = D_V(MAXLEN);
4692 if (D_A(NVAL) < D_A(TVAL))
4693 goto L_TSALT;
4694 L_RTBII:
4695 S_L(TXSP) = D_A(TVAL);
4696 goto L_SCOK;
4697 /*_*/
4698 L_TBI:
4699 if (D_A(XPTR) < 0)
4700 goto L_SCLENR;
4701 D_A(NVAL) = S_L(TXSP);
4702 D_F(NVAL) = D_V(NVAL) = 0;
4703 if (D_A(NVAL) > D_A(XPTR))
4704 goto L_TSALT;
4705 if (D_A(XPTR) > D_A(MAXLEN))
4706 goto L_TSALT;
4707 S_L(TXSP) = D_A(XPTR);
4708 goto L_SCOK;
4709 /*_*/
4710 L_POSI:
4711 D_A(SCL) = 2;
4712 goto L_LPRRT;
4713 /*_*/
4714 L_RPSI:
4715 D_A(SCL) = 3;
4716 goto L_LPRRT;
4717 /*_*/
4718 L_RTB:
4719 D_A(SCL) = 4;
4720 goto L_LPRRT;
4721 /*_*/
4722 L_TB:
4723 D_A(SCL) = 5;
4724 goto L_LPRRT;
4725 /*_*/
4726 L_ARBN:
4727 D_A(TMVAL) = S_L(TXSP);
4728 D_F(TMVAL) = D_V(TMVAL) = 0;
4729 PUSH(TMVAL);
4730 goto L_SCOK;
4731 /*_*/
4732 L_ARBF:
4733 POP(TMVAL);
4734 goto L_ONAR2;
4735 /*_*/
4736 L_EARB:
4737 POP(TMVAL);
4738 D(D_A(PDLPTR) + DESCR) = D(TMVAL);
4739 D_A(TMVAL) = S_L(TXSP);
4740 D_F(TMVAL) = D_V(TMVAL) = 0;
4741 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL);
4742 D(D_A(PDLPTR) + 3*DESCR) = D(ZEROCL);
4743 goto L_SCOK;
4744 /*_*/
4745 L_ONAR:
4746 if (D_A(FULLCL) != 0)
4747 goto L_TSCOK;
4748 D(TVAL) = D(ZEROCL);
4749 D_A(TVAL) = D_A(D_A(PDLPTR) + -2*DESCR);
4750 D_A(TMVAL) = S_L(TXSP);
4751 D_F(TMVAL) = D_V(TMVAL) = 0;
4752 if (D_A(TVAL) != D_A(TMVAL))
4753 goto L_TSCOK;
4754 L_ONAR1:
4755 PUSH(TVAL);
4756 D_A(PDLPTR) -= 6*DESCR;
4757 L_ONAR2:
4758 if (D_A(LENFCL) != 0)
4759 goto L_TSALT;
4760 goto L_SALF;
4761 /*_*/
4762 L_ONRF:
4763 D(TVAL) = D(ZEROCL);
4764 D_A(TVAL) = D_A(D_A(PDLPTR) + -2*DESCR);
4765 goto L_ONAR1;
4766 /*_*/
4767 L_FARB:
4768 if (D_A(FULLCL) == 0)
4769 goto L_FARB2;
4770 D_A(NVAL) = 0;
4771 goto L_FARB3;
4772 /*_*/
4773 L_FARB2:
4774 if (D_A(LENFCL) != 0)
4775 goto L_FARB1;
4776 D_A(NVAL) = D_V(YCL);
4777 D_F(NVAL) = D_V(NVAL) = 0;
4778 L_FARB3:
4779 D_A(TVAL) = S_L(TXSP);
4780 D_F(TVAL) = D_V(TVAL) = 0;
4781 D_A(TVAL) += D_A(NVAL);
4782 if (D_A(TVAL) >= D_A(MAXLEN))
4783 goto L_FARB1;
4784 S_L(TXSP) += D_A(ONECL);
4785 D_A(TVAL) = S_L(TXSP);
4786 D_F(TVAL) = D_V(TVAL) = 0;
4787 D_A(D_A(PDLPTR) + 2*DESCR) = D_A(TVAL);
4788 goto L_SCOK;
4789 /*_*/
4790 L_FARB1:
4791 D_A(PDLPTR) -= 3*DESCR;
4792 goto L_SALT;
4793 /*_*/
4794 L_ATP:
4795 D_A(PATICL) += DESCR;
4796 D(XPTR) = D(D_A(PATBCL) + D_A(PATICL));
4797 L_ATP1:
4798 if (D_V(XPTR) == E)
4799 goto L_ATPEXN;
4800 D_A(NVAL) = S_L(TXSP);
4801 D_F(NVAL) = D_V(NVAL) = 0;
4802 D_V(NVAL) = I;
4803 D(D_A(XPTR) + DESCR) = D(NVAL);
4804 if (D_A(OUTSW) == 0)
4805 goto L_ATP2;
4806 if (!LOCAPV(ZPTR,OUTATL,XPTR))
4807 goto L_ATP2;
4808 D(ZPTR) = D(D_A(ZPTR) + DESCR);
4809 SAVSTK();
4810 PUSH(NVAL);
4811 PUSH(ZPTR);
4812 PUTOUT(NORET);
4813 L_ATP2:
4814 if (D_A(TRAPCL) == 0)
4815 goto L_TSCOK;
4816 if (!LOCAPT(ATPTR,TVALL,XPTR))
4817 goto L_TSCOK;
4818 PUSH(PATBCL);
4819 PUSH(PATICL);
4820 PUSH(WPTR);
4821 PUSH(XCL);
4822 PUSH(YCL);
4823 PUSH(MAXLEN);
4824 PUSH(LENFCL);
4825 PUSH(PDLPTR);
4826 PUSH(PDLHED);
4827 PUSH(NAMICL);
4828 PUSH(NHEDCL);
4829 SPUSH(HEADSP);
4830 SPUSH(TSP);
4831 SPUSH(TXSP);
4832 SPUSH(XSP);
4833 D(PDLHED) = D(PDLPTR);
4834 D(NHEDCL) = D(NAMICL);
4835 SAVSTK();
4836 PUSH(ATPTR);
4837 TRPHND(NORET);
4838 SPOP(XSP);
4839 SPOP(TXSP);
4840 SPOP(TSP);
4841 SPOP(HEADSP);
4842 POP(NHEDCL);
4843 POP(NAMICL);
4844 POP(PDLHED);
4845 POP(PDLPTR);
4846 POP(LENFCL);
4847 POP(MAXLEN);
4848 POP(YCL);
4849 POP(XCL);
4850 POP(WPTR);
4851 POP(PATICL);
4852 POP(PATBCL);
4853 goto L_SCOK;
4854 /*_*/
4855 L_ATPEXN:
4856 SAVSTK();
4857 PUSH(XPTR);
4858 switch (EXPEVL(XPTR)) {
4859 case 1:
4860 goto L_TSALF;
4861 case 2:
4862 goto L_ATP1;
4863 case 3:
4864 goto L_SCNEMO;
4865 }
4866 /*_*/
4867 L_BAL:
4868 L_BALF1:
4869 if (D_A(FULLCL) == 0)
4870 goto L_BALF4;
4871 D_A(NVAL) = 0;
4872 goto L_BALF2;
4873 /*_*/
4874 L_BALF4:
4875 D_A(NVAL) = D_V(YCL);
4876 D_F(NVAL) = D_V(NVAL) = 0;
4877 L_BALF2:
4878 D_A(TVAL) = S_L(TXSP);
4879 D_F(TVAL) = D_V(TVAL) = 0;
4880 D_A(TVAL) += D_A(NVAL);
4881 if (D_A(TVAL) >= D_A(MAXLEN))
4882 goto L_BAL1;
4883 D_A(TVAL) = D_A(MAXLEN) - D_A(TVAL);
4884 D_F(TVAL) = D_F(MAXLEN);
4885 D_V(TVAL) = D_V(MAXLEN);
4886 if (!GETBAL(TXSP,TVAL))
4887 goto L_BAL1;
4888 D_A(TVAL) = S_L(TXSP);
4889 D_F(TVAL) = D_V(TVAL) = 0;
4890 D_A(D_A(PDLPTR) + 2*DESCR) = D_A(TVAL);
4891 goto L_SCOK;
4892 /*_*/
4893 L_BAL1:
4894 D_A(PDLPTR) -= 3*DESCR;
4895 if (D_PTR(PDLPTR) < D_PTR(PDLHED))
4896 BRANCH(INTR13)
4897 else
4898 goto L_TSALF;
4899 /*_*/
4900 L_BALF:
4901 if (D_A(FULLCL) == 0)
4902 goto L_BALF3;
4903 D_A(NVAL) = 0;
4904 goto L_BALF2;
4905 /*_*/
4906 L_BALF3:
4907 if (D_A(LENFCL) == 0)
4908 goto L_BALF1;
4909 else
4910 goto L_BAL1;
4911 /*_*/
4912 L_CHR:
4913 D_A(PATICL) += DESCR;
4914 D(YPTR) = D(D_A(PATBCL) + D_A(PATICL));
4915 L_CHR1:
4916 X_LOCSP(TSP,YPTR);
4917 L_CHR2:
4918 X_REMSP(VSP,XSP,TXSP);
4919 if (S_L(VSP) < S_L(TSP))
4920 goto L_TSALT;
4921 S_L(VSP) = S_L(TSP);
4922 if (!LEXEQ(VSP,TSP))
4923 goto L_TSALF;
4924 D_A(YPTR) = S_L(TSP);
4925 D_F(YPTR) = D_V(YPTR) = 0;
4926 S_L(TXSP) += D_A(YPTR);
4927 goto L_SCOK;
4928 /*_*/
4929 L_STAR:
4930 D_A(PATICL) += DESCR;
4931 D(YPTR) = D(D_A(PATBCL) + D_A(PATICL));
4932 L_STAR2:
4933 SAVSTK();
4934 PUSH(YPTR);
4935 if (EXPVAL(YPTR) == 1)
4936 goto L_TSALF;
4937 if (D_V(YPTR) == E)
4938 goto L_STAR2;
4939 D(XPTR) = D(PATBCL);
4940 D_A(XPTR) += D_A(PATICL);
4941 D(D_A(XPTR) + 7*DESCR) = D(YPTR);
4942 if (D_V(YPTR) == S)
4943 goto L_CHR1;
4944 if (D_V(YPTR) == P)
4945 goto L_STARP;
4946 if (D_V(YPTR) != I)
4947 goto L_SCDTER;
4948 INTSPC(TSP,YPTR);
4949 goto L_CHR2;
4950 /*_*/
4951 L_STARP:
4952 if (D_A(FULLCL) == 0)
4953 goto L_STARP1;
4954 D_A(NVAL) = 0;
4955 goto L_STARP4;
4956 /*_*/
4957 L_STARP1:
4958 D_A(NVAL) = D_V(YCL);
4959 D_F(NVAL) = D_V(NVAL) = 0;
4960 L_STARP4:
4961 D_A(NVAL) = D_A(MAXLEN) - D_A(NVAL);
4962 D_F(NVAL) = D_F(MAXLEN);
4963 D_V(NVAL) = D_V(MAXLEN);
4964 if (D_A(NVAL) < 0)
4965 goto L_TSALT;
4966 LVALUE(TSIZ,YPTR);
4967 if (D_A(FULLCL) != 0)
4968 goto L_STARP6;
4969 if (D_A(TSIZ) > D_A(NVAL))
4970 goto L_TSALT;
4971 L_STARP6:
4972 D_A(PDLPTR) += 3*DESCR;
4973 if (D_A(PDLPTR) > D_A(PDLEND))
4974 BRANCH(INTR31)
4975 D(D_A(PDLPTR) + DESCR) = D(SCFLCL);
4976 D_A(TMVAL) = S_L(TXSP);
4977 D_F(TMVAL) = D_V(TMVAL) = 0;
4978 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL);
4979 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL);
4980 PUSH(MAXLEN);
4981 PUSH(PATBCL);
4982 PUSH(PATICL);
4983 PUSH(XCL);
4984 PUSH(YCL);
4985 D(MAXLEN) = D(NVAL);
4986 SAVSTK();
4987 switch (SCIN(NORET)) {
4988 case 1:
4989 goto L_STARP5;
4990 case 3:
4991 BRANCH(RTNUL3)
4992 }
4993 L_STARP2:
4994 POP(YCL);
4995 POP(XCL);
4996 POP(PATICL);
4997 POP(PATBCL);
4998 POP(MAXLEN);
4999 goto L_SCOK;
5000 /*_*/
5001 L_STARP5:
5002 POP(YCL);
5003 POP(XCL);
5004 POP(PATICL);
5005 POP(PATBCL);
5006 POP(MAXLEN);
5007 L_STARP3:
5008 if (D_A(LENFCL) != 0)
5009 goto L_TSALT;
5010 goto L_SALF;
5011 /*_*/
5012 L_DSAR:
5013 D_A(PATICL) += DESCR;
5014 D(YPTR) = D(D_A(PATBCL) + D_A(PATICL));
5015 if (D_V(YPTR) == S)
5016 goto L_STARP3;
5017 if (D_V(YPTR) == P)
5018 goto L_DSARP;
5019 if (D_V(YPTR) == I)
5020 goto L_STARP3;
5021 else
5022 goto L_SCDTER;
5023 /*_*/
5024 L_DSARP:
5025 if (D_A(FULLCL) == 0)
5026 goto L_DSARP1;
5027 D_A(NVAL) = 0;
5028 goto L_DSARP2;
5029 /*_*/
5030 L_DSARP1:
5031 D_A(NVAL) = D_V(YCL);
5032 D_F(NVAL) = D_V(NVAL) = 0;
5033 L_DSARP2:
5034 D_A(NVAL) = D_A(MAXLEN) - D_A(NVAL);
5035 D_F(NVAL) = D_F(MAXLEN);
5036 D_V(NVAL) = D_V(MAXLEN);
5037 PUSH(MAXLEN);
5038 PUSH(PATBCL);
5039 PUSH(PATICL);
5040 PUSH(XCL);
5041 PUSH(YCL);
5042 D(MAXLEN) = D(NVAL);
5043 D_A(UNSCCL) = 1;
5044 SAVSTK();
5045 switch (SCIN1(NORET)) {
5046 case 1:
5047 goto L_STARP5;
5048 case 2:
5049 goto L_STARP2;
5050 case 3:
5051 BRANCH(RTNUL3)
5052 }
5053 /*_*/
5054 L_FNCE:
5055 D_A(PDLPTR) += 3*DESCR;
5056 if (D_A(PDLPTR) > D_A(PDLEND))
5057 BRANCH(INTR31)
5058 D(D_A(PDLPTR) + DESCR) = D(FNCFCL);
5059 D_A(TMVAL) = S_L(TXSP);
5060 D_F(TMVAL) = D_V(TMVAL) = 0;
5061 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL);
5062 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL);
5063 D_A(LENFCL) = 1;
5064 goto L_SCOK;
5065 /*_*/
5066 L_NME:
5067 D_A(PDLPTR) += 3*DESCR;
5068 if (D_A(PDLPTR) > D_A(PDLEND))
5069 BRANCH(INTR31)
5070 D(D_A(PDLPTR) + DESCR) = D(FNMECL);
5071 D_A(TMVAL) = S_L(TXSP);
5072 D_F(TMVAL) = D_V(TMVAL) = 0;
5073 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL);
5074 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL);
5075 PUSH(TMVAL);
5076 D_A(LENFCL) = 1;
5077 goto L_SCOK;
5078 /*_*/
5079 L_FNME:
5080 POP(TVAL);
5081 L_FNME1:
5082 if (D_A(LENFCL) == 0)
5083 goto L_TSALF;
5084 else
5085 goto L_TSALT;
5086 /*_*/
5087 L_ENME:
5088 D_A(PATICL) += DESCR;
5089 D(YPTR) = D(D_A(PATBCL) + D_A(PATICL));
5090 POP(NVAL);
5091 D_V(YCL) = D_A(NVAL);
5092 _SPEC(TSP) = _SPEC(TXSP);
5093 S_L(TSP) = D_A(NVAL);
5094 X_REMSP(TSP,TXSP,TSP);
5095 D(TPTR) = D(NBSPTR);
5096 D_A(TPTR) += D_A(NAMICL);
5097 _SPEC(D_A(TPTR) + DESCR) = _SPEC(TSP);
5098 D(D_A(TPTR) + DESCR+SPEC) = D(YPTR);
5099 D_A(NAMICL) += DESCR+SPEC;
5100 if (D_A(NAMICL) == D_A(NMOVER))
5101 goto L_ENME1;
5102 if (D_A(NAMICL) > D_A(NMOVER))
5103 BRANCH(INTR13)
5104 L_ENME2:
5105 D_A(PDLPTR) += DESCR+SPEC;
5106 if (D_A(PDLPTR) > D_A(PDLEND))
5107 BRANCH(INTR31)
5108 D(D_A(PDLPTR) + DESCR) = D(DNMECL);
5109 L_ENME3:
5110 D_A(TMVAL) = S_L(TXSP);
5111 D_F(TMVAL) = D_V(TMVAL) = 0;
5112 D_V(TMVAL) = D_V(YCL);
5113 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL);
5114 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL);
5115 D_A(LENFCL) = 1;
5116 goto L_SCOK;
5117 /*_*/
5118 L_ENME1:
5119 D(WCL) = D(NMOVER);
5120 D_A(NMOVER) += NAMLSZ*SPDR;
5121 SAVSTK();
5122 PUSH(NMOVER);
5123 BLOCK(TPTR);
5124 MOVBLK(D_A(TPTR),D_A(NBSPTR),D_A(WCL));
5125 D(NBSPTR) = D(TPTR);
5126 goto L_ENME2;
5127 /*_*/
5128 L_DNME:
5129 D_A(NAMICL) -= DESCR+SPEC;
5130 D(TPTR) = D(NBSPTR);
5131 D_A(TPTR) += D_A(NAMICL);
5132 L_DNME1:
5133 D_A(VVAL) = D_V(YCL);
5134 D_F(VVAL) = D_V(VVAL) = 0;
5135 PUSH(VVAL);
5136 goto L_FNME1;
5137 /*_*/
5138 L_ENMI:
5139 D_A(PATICL) += DESCR;
5140 D(YPTR) = D(D_A(PATBCL) + D_A(PATICL));
5141 POP(NVAL);
5142 D_V(YCL) = D_A(NVAL);
5143 _SPEC(TSP) = _SPEC(TXSP);
5144 S_L(TSP) = D_A(NVAL);
5145 X_REMSP(TSP,TXSP,TSP);
5146 D_A(ZCL) = S_L(TSP);
5147 D_F(ZCL) = D_V(ZCL) = 0;
5148 if (D_A(ZCL) > D_A(MLENCL))
5149 goto L_SCLNOR;
5150 if (D_V(YPTR) == E)
5151 goto L_ENMEXN;
5152 L_ENMI5:
5153 if (D_V(YPTR) == K)
5154 goto L_ENMIC;
5155 SAVSTK();
5156 PUSH(TSPPTR);
5157 GENVAR(VVAL);
5158 L_ENMI3:
5159 D(D_A(YPTR) + DESCR) = D(VVAL);
5160 if (D_A(OUTSW) == 0)
5161 goto L_ENMI4;
5162 if (!LOCAPV(ZPTR,OUTATL,YPTR))
5163 goto L_ENMI4;
5164 D(ZPTR) = D(D_A(ZPTR) + DESCR);
5165 SAVSTK();
5166 PUSH(VVAL);
5167 PUSH(ZPTR);
5168 PUTOUT(NORET);
5169 L_ENMI4:
5170 if (D_A(TRAPCL) <= 0)
5171 goto L_ENMI2;
5172 if (!LOCAPT(ATPTR,TVALL,YPTR))
5173 goto L_ENMI2;
5174 PUSH(PATBCL);
5175 PUSH(PATICL);
5176 PUSH(WPTR);
5177 PUSH(XCL);
5178 PUSH(YCL);
5179 PUSH(MAXLEN);
5180 PUSH(LENFCL);
5181 PUSH(PDLPTR);
5182 PUSH(PDLHED);
5183 PUSH(NAMICL);
5184 PUSH(NHEDCL);
5185 SPUSH(HEADSP);
5186 SPUSH(TSP);
5187 SPUSH(TXSP);
5188 SPUSH(XSP);
5189 D(PDLHED) = D(PDLPTR);
5190 D(NHEDCL) = D(NAMICL);
5191 SAVSTK();
5192 PUSH(ATPTR);
5193 TRPHND(NORET);
5194 SPOP(XSP);
5195 SPOP(TXSP);
5196 SPOP(TSP);
5197 SPOP(HEADSP);
5198 POP(NHEDCL);
5199 POP(NAMICL);
5200 POP(PDLHED);
5201 POP(PDLPTR);
5202 POP(LENFCL);
5203 POP(MAXLEN);
5204 POP(YCL);
5205 POP(XCL);
5206 POP(WPTR);
5207 POP(PATICL);
5208 POP(PATBCL);
5209 L_ENMI2:
5210 D_A(PDLPTR) += 3*DESCR;
5211 if (D_A(PDLPTR) > D_A(PDLEND))
5212 BRANCH(INTR31)
5213 D(D_A(PDLPTR) + DESCR) = D(DNMICL);
5214 goto L_ENME3;
5215 /*_*/
5216 L_ENMIC:
5217 if (SPCINT(VVAL,TSP))
5218 goto L_ENMI3;
5219 else
5220 goto L_SCDTER;
5221 /*_*/
5222 L_ENMEXN:
5223 PUSH(ZEROCL);
5224 SAVSTK();
5225 PUSH(YPTR);
5226 switch (EXPEVL(YPTR)) {
5227 case 1:
5228 goto L_TSALF;
5229 case 3:
5230 goto L_SCNEMO;
5231 }
5232 POP(ZEROCL);
5233 goto L_ENMI5;
5234 /*_*/
5235 L_SUCE:
5236 D_A(PDLPTR) += 3*DESCR;
5237 if (D_A(PDLPTR) > D_A(PDLEND))
5238 BRANCH(INTR31)
5239 D(D_A(PDLPTR) + DESCR) = D(SUCFCL);
5240 D_A(TMVAL) = S_L(TXSP);
5241 D_F(TMVAL) = D_V(TMVAL) = 0;
5242 D(D_A(PDLPTR) + 2*DESCR) = D(TMVAL);
5243 D(D_A(PDLPTR) + 3*DESCR) = D(LENFCL);
5244 D_A(LENFCL) = 1;
5245 goto L_SCOK;
5246 /*_*/
5247 L_SUCF:
5248 D(XCL) = D(D_A(PDLPTR) + DESCR);
5249 D(YCL) = D(D_A(PDLPTR) + 2*DESCR);
5250 goto L_SUCE;
5251 /*_*/
5252 L_SCDTER:
5253 D_A(ERRTYP) = 1;
5254 goto L_SCERSX;
5255 /*_*/
5256 L_SCLENR:
5257 D_A(ERRTYP) = 14;
5258 goto L_SCERSX;
5259 /*_*/
5260 L_SCLNOR:
5261 D_A(ERRTYP) = 15;
5262 goto L_SCERSX;
5263 /*_*/
5264 L_SCNAME:
5265 D_A(ERRTYP) = 4;
5266 goto L_SCERSX;
5267 /*_*/
5268 L_SCNEMO:
5269 D_A(ERRTYP) = 8;
5270 L_SCERSX:
5271 SAVSTK();
5272 SCERST(NORET);
5273 goto L_TSALF;
5274 /*_*/
5275 }
5276 int
DEFINE(ret_t retval)5277 DEFINE(ret_t retval) {
5278 ENTRY(DEFINE)
5279 SAVSTK();
5280 if (VARVAL(XPTR) == 1)
5281 BRANCH(FAIL)
5282 PUSH(XPTR);
5283 SAVSTK();
5284 if (VARVUP(YPTR) == 1)
5285 BRANCH(FAIL)
5286 POP(XPTR);
5287 X_LOCSP(XSP,XPTR);
5288 switch (STREAM(YSP, XSP, &VARATB)) {
5289 case ST_ERROR:
5290 case ST_EOS:
5291 BRANCH(PROTER)
5292 }
5293 if (D_A(STYPE) != LPTYP)
5294 BRANCH(PROTER)
5295 SAVSTK();
5296 PUSH(YSPPTR);
5297 GENVUP(XPTR);
5298 SAVSTK();
5299 PUSH(XPTR);
5300 FINDEX(ZCL);
5301 if (!DCMP(YPTR, NULVCL))
5302 goto L_DEFIN3;
5303 D(YPTR) = D(XPTR);
5304 L_DEFIN3:
5305 PUSH(YPTR);
5306 D(YCL) = D(ZEROCL);
5307 PUSH(XPTR);
5308 L_DEFIN4:
5309 S_L(XSP)--;
5310 S_O(XSP)++;
5311 switch (STREAM(YSP, XSP, &VARATB)) {
5312 case ST_ERROR:
5313 case ST_EOS:
5314 BRANCH(PROTER)
5315 }
5316 switch (D_A(STYPE)) {
5317 case 1:
5318 BRANCH(PROTER)
5319 case 3:
5320 goto L_DEFIN6;
5321 }
5322 if (S_L(YSP) == 0)
5323 goto L_DEFIN4;
5324 SAVSTK();
5325 PUSH(YSPPTR);
5326 GENVUP(XPTR);
5327 PUSH(XPTR);
5328 D_A(YCL)++;
5329 goto L_DEFIN4;
5330 /*_*/
5331 L_DEFIN6:
5332 if (S_L(YSP) == 0)
5333 goto L_DEFIN9;
5334 D_A(YCL)++;
5335 SAVSTK();
5336 PUSH(YSPPTR);
5337 GENVUP(XPTR);
5338 PUSH(XPTR);
5339 L_DEFIN9:
5340 D_V(DEFCL) = D_A(YCL);
5341 L_DEFIN8:
5342 S_L(XSP)--;
5343 S_O(XSP)++;
5344 switch (STREAM(YSP, XSP, &VARATB)) {
5345 case ST_ERROR:
5346 BRANCH(PROTER)
5347 case ST_EOS:
5348 goto L_DEF10;
5349 }
5350 if (D_A(STYPE) != CMATYP)
5351 BRANCH(PROTER)
5352 if (S_L(YSP) == 0)
5353 goto L_DEFIN8;
5354 SAVSTK();
5355 PUSH(YSPPTR);
5356 GENVUP(XPTR);
5357 PUSH(XPTR);
5358 D_A(YCL)++;
5359 goto L_DEFIN8;
5360 /*_*/
5361 L_DEF10:
5362 if (S_L(YSP) == 0)
5363 goto L_DEF11;
5364 SAVSTK();
5365 PUSH(YSPPTR);
5366 GENVUP(XPTR);
5367 PUSH(XPTR);
5368 D_A(YCL)++;
5369 L_DEF11:
5370 D_A(YCL) += 2;
5371 D_A(XCL) = D_A(YCL);
5372 D_A(XCL) *= DESCR;
5373 D_F(XCL) = D_V(XCL) = 0;
5374 D_V(XCL) = B;
5375 SAVSTK();
5376 PUSH(XCL);
5377 BLOCK(XPTR);
5378 D(D_A(ZCL)) = D(DEFCL);
5379 D(D_A(ZCL) + DESCR) = D(XPTR);
5380 D_A(XPTR) += D_A(XCL);
5381 L_DEF12:
5382 D_A(XPTR) -= DESCR;
5383 POP(YPTR);
5384 D(D_A(XPTR) + DESCR) = D(YPTR);
5385 D_A(YCL)--;
5386 if (D_A(YCL) == 0)
5387 BRANCH(RETNUL)
5388 else
5389 goto L_DEF12;
5390 /*_*/
5391 }
5392 int
DEFFNC(ret_t retval)5393 DEFFNC(ret_t retval) {
5394 ENTRY(DEFFNC)
5395 D_A(XCL) = D_V(INCL);
5396 D_F(XCL) = D_V(XCL) = 0;
5397 D(WCL) = D(XCL);
5398 D(YCL) = D(INCL);
5399 PSTACK(YPTR);
5400 PUSH(NULVCL);
5401 L_DEFF1:
5402 D_A(OCICL) += DESCR;
5403 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
5404 if ((D_F(XPTR) & FNC))
5405 goto L_DEFFC;
5406 L_DEFF2:
5407 if (D_A(INSW) == 0)
5408 goto L_DEFF14;
5409 if (!LOCAPV(ZPTR,INATL,XPTR))
5410 goto L_DEFF14;
5411 D(ZPTR) = D(D_A(ZPTR) + DESCR);
5412 PUSH(XCL);
5413 PUSH(WCL);
5414 PUSH(YCL);
5415 PUSH(YPTR);
5416 SAVSTK();
5417 PUSH(XPTR);
5418 PUSH(ZPTR);
5419 if (PUTIN(XPTR) == 1)
5420 BRANCH(FAIL)
5421 POP(YPTR);
5422 POP(YCL);
5423 POP(WCL);
5424 POP(XCL);
5425 goto L_DEFF3;
5426 /*_*/
5427 L_DEFF14:
5428 D(XPTR) = D(D_A(XPTR) + DESCR);
5429 L_DEFF3:
5430 PUSH(XPTR);
5431 D_A(XCL)--;
5432 if (D_A(XCL) < 0)
5433 BRANCH(INTR10)
5434 if (D_A(XCL) > 0)
5435 goto L_DEFF1;
5436 D(XCL) = D(D_A(YCL));
5437 D_A(XCL) = D_V(XCL);
5438 D_F(XCL) = D_V(XCL) = 0;
5439 L_DEFF4:
5440 if (D_A(WCL) == D_A(XCL))
5441 goto L_DEFF5;
5442 if (D_A(WCL) > D_A(XCL))
5443 goto L_DEFF9;
5444 PUSH(NULVCL);
5445 D_A(WCL)++;
5446 goto L_DEFF4;
5447 /*_*/
5448 L_DEFF9:
5449 POP(ZCL);
5450 D_A(WCL)--;
5451 goto L_DEFF4;
5452 /*_*/
5453 L_DEFF5:
5454 D(ZCL) = D(D_A(YCL) + DESCR);
5455 D(XPTR) = D(ZCL);
5456 D_A(WCL) = D_V(D_A(ZCL));
5457 D_F(WCL) = D_V(WCL) = 0;
5458 D(WPTR) = D(ZCL);
5459 D_A(WPTR) += D_A(WCL);
5460 D_A(XCL)++;
5461 L_DEFF8:
5462 D_A(XPTR) += DESCR;
5463 D_A(YPTR) += DESCR;
5464 D(ZPTR) = D(D_A(XPTR) + DESCR);
5465 D(TPTR) = D(D_A(ZPTR) + DESCR);
5466 D(ATPTR) = D(D_A(YPTR) + DESCR);
5467 D(D_A(ZPTR) + DESCR) = D(ATPTR);
5468 D(D_A(YPTR) + DESCR) = D(TPTR);
5469 D_A(XCL)--;
5470 if (D_A(XCL) < 0)
5471 BRANCH(INTR10)
5472 if (D_A(XCL) > 0)
5473 goto L_DEFF8;
5474 L_DEFF10:
5475 D_A(XPTR) += DESCR;
5476 if (D_A(XPTR) == D_A(WPTR))
5477 goto L_DEFFGO;
5478 D(ZPTR) = D(D_A(XPTR) + DESCR);
5479 D(TPTR) = D(D_A(ZPTR) + DESCR);
5480 PUSH(TPTR);
5481 D(D_A(ZPTR) + DESCR) = D(NULVCL);
5482 goto L_DEFF10;
5483 /*_*/
5484 L_DEFFGO:
5485 PUSH(FILENM);
5486 PUSH(LNNOCL);
5487 PUSH(FRTNCL);
5488 PUSH(STNOCL);
5489 PUSH(OCICL);
5490 PUSH(OCBSCL);
5491 PUSH(ZCL);
5492 PUSH(ZCL);
5493 D(XCL) = D(D_A(ZCL) + DESCR);
5494 if (D_A(D_A(XCL) + ATTRIB) == (int_t)0)
5495 BRANCH(UNDFFE)
5496 D(OCBSCL) = D(D_A(XCL) + ATTRIB);
5497 if (D_A(TRACL) <= 0)
5498 goto L_DEFF18;
5499 D_A(TRACL)--;
5500 D(ATPTR) = D(D_A(ZCL) + 2*DESCR);
5501 PUSH(ZCL);
5502 SAVSTK();
5503 PUSH(ATPTR);
5504 switch (FENTR2(NORET)) {
5505 case 1:
5506 case 2:
5507 BRANCH(INTR10)
5508 }
5509 POP(ZCL);
5510 L_DEFF18:
5511 if (D_A(TRAPCL) <= 0)
5512 goto L_DEFF19;
5513 D(ATPTR) = D(D_A(ZCL) + 2*DESCR);
5514 if (!LOCAPT(ATPTR,TFENTL,ATPTR))
5515 goto L_DEFF19;
5516 PUSH(OCBSCL);
5517 PUSH(ZCL);
5518 SAVSTK();
5519 PUSH(ATPTR);
5520 TRPHND(NORET);
5521 POP(ZCL);
5522 POP(OCBSCL);
5523 L_DEFF19:
5524 D_A(LVLCL)++;
5525 if (D_A(TRAPCL) <= 0)
5526 goto L_DEFF15;
5527 if (!LOCAPT(ATPTR,TKEYL,FNCLKY))
5528 goto L_DEFF15;
5529 SAVSTK();
5530 PUSH(ATPTR);
5531 TRPHND(NORET);
5532 L_DEFF15:
5533 D_A(OCICL) = 0;
5534 SAVSTK();
5535 switch (INTERP(NORET)) {
5536 case 1:
5537 goto L_DEFFF;
5538 case 2:
5539 goto L_DEFFNR;
5540 }
5541 D(RETPCL) = D(RETCL);
5542 L_DEFFS1:
5543 POP(ZCL);
5544 if (D_A(TRACL) <= 0)
5545 goto L_DEFF20;
5546 D_A(TRACL)--;
5547 D(ATPTR) = D(D_A(ZCL) + 2*DESCR);
5548 PUSH(ZCL);
5549 SAVSTK();
5550 PUSH(ATPTR);
5551 switch (FNEXT2(NORET)) {
5552 case 1:
5553 case 2:
5554 BRANCH(INTR10)
5555 }
5556 POP(ZCL);
5557 L_DEFF20:
5558 if (D_A(TRAPCL) <= 0)
5559 goto L_DEFFS2;
5560 D(ATPTR) = D(D_A(ZCL) + 2*DESCR);
5561 if (!LOCAPT(ATPTR,TFEXTL,ATPTR))
5562 goto L_DEFFS2;
5563 PUSH(RETPCL);
5564 PUSH(ZCL);
5565 SAVSTK();
5566 PUSH(ATPTR);
5567 TRPHND(NORET);
5568 POP(ZCL);
5569 POP(RETPCL);
5570 L_DEFFS2:
5571 D_A(LVLCL)--;
5572 if (D_A(TRAPCL) <= 0)
5573 goto L_DEFF17;
5574 if (!LOCAPT(ATPTR,TKEYL,FNCLKY))
5575 goto L_DEFF17;
5576 PUSH(RETPCL);
5577 PUSH(ZCL);
5578 SAVSTK();
5579 PUSH(ATPTR);
5580 TRPHND(NORET);
5581 POP(ZCL);
5582 POP(RETPCL);
5583 L_DEFF17:
5584 POP(ZCL);
5585 POP(OCBSCL);
5586 POP(OCICL);
5587 POP(STNOCL);
5588 POP(FRTNCL);
5589 POP(LNNOCL);
5590 POP(FILENM);
5591 D_A(WCL) = D_V(D_A(ZCL));
5592 D_F(WCL) = D_V(WCL) = 0;
5593 D_A(WCL) -= DESCR;
5594 if (D_A(WCL) <= 0)
5595 BRANCH(INTR10)
5596 D(WPTR) = D(ZCL);
5597 D_A(WPTR) += D_A(WCL);
5598 D(YPTR) = D(ZCL);
5599 D_A(YPTR) += DESCR;
5600 D(ZPTR) = D(D_A(YPTR) + DESCR);
5601 D(ZPTR) = D(D_A(ZPTR) + DESCR);
5602 L_DEFF6:
5603 POP(XPTR);
5604 D(YPTR) = D(D_A(WPTR) + DESCR);
5605 D(D_A(YPTR) + DESCR) = D(XPTR);
5606 D_A(WPTR) -= DESCR;
5607 if (D_A(WPTR) != D_A(ZCL))
5608 goto L_DEFF6;
5609 if (DCMP(RETPCL, FRETCL))
5610 BRANCH(FAIL)
5611 if (!DCMP(RETPCL, NRETCL))
5612 BRANCH(RTZPTR)
5613 D(XPTR) = D(ZPTR);
5614 if (D_V(XPTR) == S)
5615 goto L_DEFFVX;
5616 if (D_V(XPTR) == I)
5617 BRANCH(GENVIX)
5618 if (D_V(XPTR) == N)
5619 BRANCH(RTXNAM)
5620 if (D_V(XPTR) == K)
5621 BRANCH(RTXNAM)
5622 else
5623 BRANCH(NONAME)
5624 L_DEFFVX:
5625 if (D_A(XPTR) == 0)
5626 BRANCH(NONAME)
5627 else
5628 BRANCH(RTXNAM)
5629 /*_*/
5630 L_DEFFF:
5631 D(RETPCL) = D(FRETCL);
5632 goto L_DEFFS1;
5633 /*_*/
5634 L_DEFFC:
5635 PUSH(XCL);
5636 PUSH(WCL);
5637 PUSH(YCL);
5638 PUSH(YPTR);
5639 SAVSTK();
5640 PUSH(XPTR);
5641 switch (INVOKE(XPTR)) {
5642 case 1:
5643 BRANCH(FAIL)
5644 case 2:
5645 goto L_DEFFN;
5646 }
5647 POP(YPTR);
5648 POP(YCL);
5649 POP(WCL);
5650 POP(XCL);
5651 goto L_DEFF3;
5652 /*_*/
5653 L_DEFFN:
5654 POP(YPTR);
5655 POP(YCL);
5656 POP(WCL);
5657 POP(XCL);
5658 goto L_DEFF2;
5659 /*_*/
5660 L_DEFFNR:
5661 D(RETPCL) = D(NRETCL);
5662 goto L_DEFFS1;
5663 /*_*/
5664 }
5665 int
LOAD(ret_t retval)5666 LOAD(ret_t retval) {
5667 ENTRY(LOAD)
5668 SAVSTK();
5669 if (VARVAL(XPTR) == 1)
5670 BRANCH(FAIL)
5671 PUSH(XPTR);
5672 SAVSTK();
5673 if (VARVAL(WPTR) == 1)
5674 BRANCH(FAIL)
5675 POP(XPTR);
5676 /* FALL */
5677 BRANCH(LOAD2)
5678 }
5679 static int
LOAD2(ret_t retval)5680 LOAD2(ret_t retval) {
5681 ENTRY(LOAD2)
5682 X_LOCSP(VSP,WPTR);
5683 X_LOCSP(XSP,XPTR);
5684 switch (STREAM(YSP, XSP, &VARATB)) {
5685 case ST_ERROR:
5686 case ST_EOS:
5687 BRANCH(PROTER)
5688 }
5689 if (D_A(STYPE) != LPTYP)
5690 BRANCH(PROTER)
5691 SAVSTK();
5692 PUSH(YSPPTR);
5693 GENVUP(XPTR);
5694 SAVSTK();
5695 PUSH(XPTR);
5696 FINDEX(ZCL);
5697 D(YCL) = D(ZEROCL);
5698 L_LOAD4:
5699 S_L(XSP)--;
5700 S_O(XSP)++;
5701 switch (STREAM(ZSP, XSP, &VARATB)) {
5702 case ST_ERROR:
5703 goto L_LOAD1;
5704 case ST_EOS:
5705 BRANCH(PROTER)
5706 }
5707 switch (D_A(STYPE)) {
5708 case 1:
5709 BRANCH(PROTER)
5710 case 3:
5711 goto L_LOAD6;
5712 }
5713 SAVSTK();
5714 PUSH(ZSPPTR);
5715 GENVUP(XPTR);
5716 if (!LOCAPV(XPTR,DTATL,XPTR))
5717 goto L_LOAD9;
5718 D(XPTR) = D(D_A(XPTR) + DESCR);
5719 PUSH(XPTR);
5720 L_LOAD10:
5721 D_A(YCL)++;
5722 goto L_LOAD4;
5723 /*_*/
5724 L_LOAD6:
5725 D_A(YCL)++;
5726 SAVSTK();
5727 PUSH(ZSPPTR);
5728 GENVAR(XPTR);
5729 if (!LOCAPV(XPTR,DTATL,XPTR))
5730 goto L_LOAD11;
5731 D(XPTR) = D(D_A(XPTR) + DESCR);
5732 PUSH(XPTR);
5733 L_LOAD13:
5734 S_L(XSP)--;
5735 S_O(XSP)++;
5736 SAVSTK();
5737 PUSH(XSPPTR);
5738 GENVAR(XPTR);
5739 if (!LOCAPV(XPTR,DTATL,XPTR))
5740 goto L_LOAD7;
5741 D(XPTR) = D(D_A(XPTR) + DESCR);
5742 PUSH(XPTR);
5743 L_LOAD8:
5744 D_V(LODCL) = D_A(YCL);
5745 D_A(YCL)++;
5746 D_A(XCL) = D_A(YCL);
5747 D_A(XCL) *= DESCR;
5748 D_F(XCL) = D_V(XCL) = 0;
5749 D_A(XCL) += DESCR;
5750 D_V(XCL) = B;
5751 SAVSTK();
5752 PUSH(XCL);
5753 BLOCK(ZPTR);
5754 D(XPTR) = D(ZPTR);
5755 D_A(XPTR) += D_A(XCL);
5756 L_LOAD12:
5757 D_A(XPTR) -= DESCR;
5758 POP(YPTR);
5759 D(D_A(XPTR) + DESCR) = D(YPTR);
5760 D_A(YCL)--;
5761 if (D_A(YCL) > 0)
5762 goto L_LOAD12;
5763 if (!_LOAD(YPTR,YSP,VSP))
5764 BRANCH(FAIL)
5765 D(D_A(XPTR)) = D(YPTR);
5766 D(D_A(ZCL)) = D(LODCL);
5767 D(D_A(ZCL) + DESCR) = D(ZPTR);
5768 BRANCH(RETNUL)
5769 /*_*/
5770 L_LOAD7:
5771 PUSH(ZEROCL);
5772 goto L_LOAD8;
5773 /*_*/
5774 L_LOAD9:
5775 PUSH(ZEROCL);
5776 goto L_LOAD10;
5777 /*_*/
5778 L_LOAD1:
5779 PUSH(ZEROCL);
5780 _SPEC(TSP) = _SPEC(XSP);
5781 S_L(TSP) = 1;
5782 D_A(YCL)++;
5783 if (LEXEQ(TSP,RPRNSP))
5784 goto L_LOAD13;
5785 else
5786 goto L_LOAD4;
5787 /*_*/
5788 L_LOAD11:
5789 PUSH(ZEROCL);
5790 goto L_LOAD13;
5791 /*_*/
5792 }
5793 int
UNLOAD(ret_t retval)5794 UNLOAD(ret_t retval) {
5795 ENTRY(UNLOAD)
5796 SAVSTK();
5797 if (VARVUP(XPTR) == 1)
5798 BRANCH(FAIL)
5799 SAVSTK();
5800 PUSH(XPTR);
5801 FINDEX(ZCL);
5802 D(D_A(ZCL)) = D(UNDFCL);
5803 X_LOCSP(XSP,XPTR);
5804 _UNLOAD(XSP);
5805 BRANCH(RETNUL)
5806 /*_*/
5807 }
5808 int
LNKFNC(ret_t retval)5809 LNKFNC(ret_t retval) {
5810 ENTRY(LNKFNC)
5811 D_A(XCL) = D_V(INCL);
5812 D_F(XCL) = D_V(XCL) = 0;
5813 D(YCL) = D(INCL);
5814 D(WCL) = D(D_A(YCL));
5815 D_A(WCL) = D_V(WCL);
5816 D_F(WCL) = D_V(WCL) = 0;
5817 D(WPTR) = D(ZEROCL);
5818 D(ZCL) = D(D_A(YCL) + DESCR);
5819 PSTACK(YPTR);
5820 D_A(TCL) = (int_t) (2*DESCR);
5821 L_LNKF1:
5822 PUSH(XCL);
5823 PUSH(ZCL);
5824 PUSH(TCL);
5825 PUSH(YPTR);
5826 PUSH(WCL);
5827 PUSH(YCL);
5828 PUSH(WPTR);
5829 SAVSTK();
5830 if (ARGVAL(XPTR) == 1)
5831 BRANCH(FAIL)
5832 POP(WPTR);
5833 POP(YCL);
5834 POP(WCL);
5835 POP(YPTR);
5836 POP(TCL);
5837 POP(ZCL);
5838 POP(XCL);
5839 D_A(WCL)--;
5840 if (D_A(WCL) < 0)
5841 goto L_LNKF6;
5842 D(ZPTR) = D(D_A(ZCL) + D_A(TCL));
5843 if (D_V(ZPTR) == 0)
5844 goto L_LNKF6;
5845 if (D_V(ZPTR) == D_V(XPTR))
5846 goto L_LNKF6;
5847 D_A(DTCL) = D_V(XPTR);
5848 D_F(DTCL) = D_V(DTCL) = 0;
5849 D_V(DTCL) = D_V(ZPTR);
5850 if (DCMP(DTCL, VIDTP))
5851 goto L_LNKVI;
5852 if (DCMP(DTCL, IVDTP))
5853 goto L_LNKIV;
5854 if (DCMP(DTCL, RIDTP))
5855 goto L_LNKRI;
5856 if (DCMP(DTCL, IRDTP))
5857 goto L_LNKIR;
5858 if (DCMP(DTCL, RVDTP))
5859 goto L_LNKRV;
5860 if (DCMP(DTCL, VRDTP))
5861 goto L_LNKVR;
5862 else
5863 BRANCH(INTR1)
5864 L_LNKIV:
5865 SAVSTK();
5866 PUSH(XPTR);
5867 if (GNVARI(XPTR) == 1)
5868 goto L_LNKF6;
5869 /*_*/
5870 L_LNKRI:
5871 CLR_MATH_ERROR();
5872 D_A(XPTR) = (int_t) D_RV(XPTR);
5873 D_F(XPTR) = 0;
5874 D_V(XPTR) = I;
5875 if (MATH_ERROR())
5876 BRANCH(INTR1)
5877 goto L_LNKF6;
5878 /*_*/
5879 L_LNKIR:
5880 D_RV(XPTR) = (real_t)D_A(XPTR);
5881 D_F(XPTR) = 0;
5882 D_V(XPTR) = R;
5883 goto L_LNKF6;
5884 /*_*/
5885 L_LNKVR:
5886 X_LOCSP(XSP,XPTR);
5887 if (SPCINT(XPTR,XSP))
5888 goto L_LNKIR;
5889 if (SPREAL(XPTR,XSP))
5890 goto L_LNKF6;
5891 else
5892 BRANCH(INTR1)
5893 /*_*/
5894 L_LNKRV:
5895 REALST(XSP,XPTR);
5896 SAVSTK();
5897 PUSH(XSPPTR);
5898 if (GENVAR(XPTR) == 1)
5899 goto L_LNKF6;
5900 /*_*/
5901 L_LNKVI:
5902 X_LOCSP(XSP,XPTR);
5903 if (SPCINT(XPTR,XSP))
5904 goto L_LNKF6;
5905 if (SPREAL(XPTR,XSP))
5906 goto L_LNKRI;
5907 else
5908 BRANCH(INTR1)
5909 L_LNKF6:
5910 D_A(TCL) += DESCR;
5911 PUSH(XPTR);
5912 D_A(WPTR)++;
5913 D_A(XCL)--;
5914 if (D_A(XCL) > 0)
5915 goto L_LNKF1;
5916 L_LNKF4:
5917 if (D_A(WCL) <= 0)
5918 goto L_LNKF5;
5919 PUSH(NULVCL);
5920 D_A(WPTR)++;
5921 D_A(WCL)--;
5922 goto L_LNKF4;
5923 /*_*/
5924 L_LNKF5:
5925 D_A(WCL) = D_V(D_A(ZCL));
5926 D_F(WCL) = D_V(WCL) = 0;
5927 D(XPTR) = D(ZCL);
5928 D_A(XPTR) += D_A(WCL);
5929 D(ZPTR) = D(D_A(XPTR));
5930 D(ZCL) = D(D_A(ZCL) + DESCR);
5931 D_A(YPTR) += 2*DESCR;
5932 if (!CALLX(ZPTR,YPTR,WPTR,ZCL))
5933 BRANCH(FAIL)
5934 if (D_V(ZPTR) == M)
5935 goto L_LNKF7;
5936 if (D_V(ZPTR) != L)
5937 BRANCH(RTZPTR)
5938 _SPEC(ZSP) = _SPEC(D_A(ZPTR));
5939 BRANCH(GENVRZ)
5940 /*_*/
5941 L_LNKF7:
5942 PUSH(ZPTR);
5943 _SPEC(ZSP) = _SPEC(D_A(ZPTR));
5944 SAVSTK();
5945 PUSH(ZSPPTR);
5946 GENVAR(ZPTR);
5947 POP(XPTR);
5948 RELSTRING(XPTR);
5949 BRANCH(RTZPTR)
5950 /*_*/
5951 }
5952 int
ARRAY(ret_t retval)5953 ARRAY(ret_t retval) {
5954 ENTRY(ARRAY)
5955 SAVSTK();
5956 if (VARVAL(XPTR) == 1)
5957 BRANCH(FAIL)
5958 PUSH(XPTR);
5959 SAVSTK();
5960 if (ARGVAL(TPTR) == 1)
5961 BRANCH(FAIL)
5962 POP(XPTR);
5963 D_A(ARRMRK) = 0;
5964 D(WCL) = D(ZEROCL);
5965 D(XCL) = D(ONECL);
5966 X_LOCSP(XSP,XPTR);
5967 PUSH(XPTR);
5968 L_ARRAY1:
5969 switch (STREAM(YSP, XSP, &NUMBTB)) {
5970 case ST_ERROR:
5971 BRANCH(PROTER)
5972 case ST_EOS:
5973 goto L_ARROT1;
5974 }
5975 if (!SPCINT(YCL,YSP))
5976 BRANCH(PROTER)
5977 switch (D_A(STYPE)) {
5978 case 2:
5979 goto L_ARRAY3;
5980 }
5981 S_L(XSP)--;
5982 S_O(XSP)++;
5983 switch (STREAM(ZSP, XSP, &NUMBTB)) {
5984 case ST_ERROR:
5985 BRANCH(PROTER)
5986 case ST_EOS:
5987 goto L_ARROT2;
5988 }
5989 if (!SPCINT(ZCL,ZSP))
5990 BRANCH(PROTER)
5991 switch (D_A(STYPE)) {
5992 case 1:
5993 BRANCH(PROTER)
5994 case 2:
5995 goto L_ARRAY5;
5996 }
5997 /*_*/
5998 L_ARRAY3:
5999 if (D_A(YCL) <= 0)
6000 BRANCH(PROTER)
6001 D(ZCL) = D(YCL);
6002 D_A(YCL) = 1;
6003 goto L_ARRAY6;
6004 /*_*/
6005 L_ARRAY5:
6006 D_A(ZCL) -= D_A(YCL);
6007 D_A(ZCL) += D_A(ONECL);
6008 if (D_A(ZCL) < 0)
6009 BRANCH(PROTER)
6010 L_ARRAY6:
6011 D_V(YCL) = D_A(ZCL);
6012 PUSH(YCL);
6013 CLR_MATH_ERROR();
6014 D_A(XCL) *= D_A(ZCL);
6015 if (MATH_ERROR())
6016 BRANCH(PROTER)
6017 D_A(WCL)++;
6018 if (D_A(ARRMRK) != 0)
6019 goto L_ARRAY7;
6020 S_L(XSP)--;
6021 S_O(XSP)++;
6022 goto L_ARRAY1;
6023 /*_*/
6024 L_ARROT1:
6025 D_A(ARRMRK) = 1;
6026 if (SPCINT(YCL,YSP))
6027 goto L_ARRAY3;
6028 else
6029 BRANCH(PROTER)
6030 /*_*/
6031 L_ARROT2:
6032 D_A(ARRMRK) = 1;
6033 if (SPCINT(ZCL,ZSP))
6034 goto L_ARRAY5;
6035 else
6036 BRANCH(PROTER)
6037 /*_*/
6038 L_ARRAY7:
6039 D(ZCL) = D(XCL);
6040 D_A(ZCL) += D_A(WCL);
6041 D_A(ZCL) += 2;
6042 D_A(ZCL) *= DESCR;
6043 D_F(ZCL) = D_V(ZCL) = 0;
6044 D_V(ZCL) = A;
6045 SAVSTK();
6046 PUSH(ZCL);
6047 BLOCK(ZPTR);
6048 D(XPTR) = D(ZPTR);
6049 D(WPTR) = D(XPTR);
6050 D_A(WPTR) += D_A(ZCL);
6051 D(D_A(ZPTR) + 2*DESCR) = D(WCL);
6052 D_A(XPTR) += DESCR;
6053 L_ARRAY8:
6054 D_A(XPTR) += DESCR;
6055 POP(YPTR);
6056 D(D_A(XPTR) + DESCR) = D(YPTR);
6057 D_A(WCL)--;
6058 if (D_A(WCL) == 0)
6059 goto L_ARRFIL;
6060 if (D_A(WCL) > 0)
6061 goto L_ARRAY8;
6062 L_ARRAY9:
6063 D(D_A(XPTR) + DESCR) = D(TPTR);
6064 L_ARRFIL:
6065 D_A(XPTR) += DESCR;
6066 if (D_PTR(XPTR) < D_PTR(WPTR))
6067 goto L_ARRAY9;
6068 if (D_PTR(XPTR) > D_PTR(WPTR))
6069 BRANCH(INTR10)
6070 POP(WPTR);
6071 D(D_A(ZPTR) + DESCR) = D(WPTR);
6072 BRANCH(RTZPTR)
6073 /*_*/
6074 }
6075 int
ASSOC(ret_t retval)6076 ASSOC(ret_t retval) {
6077 ENTRY(ASSOC)
6078 SAVSTK();
6079 if (INTVAL(XPTR) == 1)
6080 BRANCH(FAIL)
6081 PUSH(XPTR);
6082 SAVSTK();
6083 if (INTVAL(WPTR) == 1)
6084 BRANCH(FAIL)
6085 CLR_MATH_ERROR();
6086 D(ZPTR) = D(WPTR);
6087 D_A(ZPTR) *= D_A(DSCRTW);
6088 if (MATH_ERROR())
6089 BRANCH(SIZERR)
6090 D_A(ZPTR) += 2*DESCR;
6091 if (D_A(ZPTR) >= D_A(SIZLMT))
6092 BRANCH(SIZERR)
6093 POP(XPTR);
6094 if (D_A(XPTR) < 0)
6095 BRANCH(LENERR)
6096 if (D_A(XPTR) > 0)
6097 goto L_ASSOC1;
6098 D_A(XPTR) = (int_t) EXTSIZ;
6099 L_ASSOC1:
6100 D_A(XPTR)++;
6101 D_A(XPTR) *= 2*DESCR;
6102 D_F(XPTR) = D_V(XPTR) = 0;
6103 if (D_A(WPTR) < 0)
6104 BRANCH(LENERR)
6105 if (D_A(WPTR) > 0)
6106 goto L_ASSOC4;
6107 D_A(WPTR) = (int_t) EXTSIZ;
6108 L_ASSOC4:
6109 D_A(WPTR)++;
6110 D_A(WPTR) *= 2*DESCR;
6111 D_F(WPTR) = D_V(WPTR) = 0;
6112 D_V(XPTR) = T;
6113 /* FALL */
6114 BRANCH(ASSOCE)
6115 }
6116 static int
ASSOCE(ret_t retval)6117 ASSOCE(ret_t retval) {
6118 ENTRY(ASSOCE)
6119 SAVSTK();
6120 PUSH(XPTR);
6121 BLOCK(ZPTR);
6122 D(D_A(ZPTR) + D_A(XPTR)) = D(ONECL);
6123 D_A(XPTR) -= DESCR;
6124 D(D_A(ZPTR) + D_A(XPTR)) = D(WPTR);
6125 L_ASSOC2:
6126 D_A(XPTR) -= 2*DESCR;
6127 D(D_A(ZPTR) + D_A(XPTR)) = D(NULVCL);
6128 if (D_A(XPTR) == DESCR)
6129 BRANCH(RTZPTR)
6130 else
6131 goto L_ASSOC2;
6132 /*_*/
6133 }
6134 int
DATDEF(ret_t retval)6135 DATDEF(ret_t retval) {
6136 ENTRY(DATDEF)
6137 SAVSTK();
6138 if (VARVAL(XPTR) == 1)
6139 BRANCH(FAIL)
6140 D_A(DATACL) = 0;
6141 X_LOCSP(XSP,XPTR);
6142 switch (STREAM(YSP, XSP, &VARATB)) {
6143 case ST_ERROR:
6144 case ST_EOS:
6145 BRANCH(PROTER)
6146 }
6147 if (D_A(STYPE) != LPTYP)
6148 BRANCH(PROTER)
6149 SAVSTK();
6150 PUSH(YSPPTR);
6151 GENVUP(XPTR);
6152 SAVSTK();
6153 PUSH(XPTR);
6154 FINDEX(ZCL);
6155 D_V(DATSEG)++;
6156 if (D_V(DATSEG) == DATSIZ)
6157 BRANCH(INTR27)
6158 D(YCL) = D(ZEROCL);
6159 SAVSTK();
6160 PUSH(XPTR);
6161 PUSH(DATSEG);
6162 PUSH(DTATL);
6163 AUGATL(DTATL);
6164 PSTACK(WPTR);
6165 PUSH(DATSEG);
6166 PUSH(XPTR);
6167 L_DATA3:
6168 S_L(XSP)--;
6169 S_O(XSP)++;
6170 if (D_A(DATACL) != 0)
6171 goto L_DAT5;
6172 switch (STREAM(YSP, XSP, &VARATB)) {
6173 case ST_ERROR:
6174 case ST_EOS:
6175 BRANCH(PROTER)
6176 }
6177 switch (D_A(STYPE)) {
6178 case 1:
6179 BRANCH(PROTER)
6180 case 3:
6181 goto L_DATA6;
6182 }
6183 L_DATA4:
6184 if (S_L(YSP) == 0)
6185 goto L_DATA3;
6186 SAVSTK();
6187 PUSH(YSPPTR);
6188 GENVUP(XPTR);
6189 PUSH(XPTR);
6190 SAVSTK();
6191 PUSH(XPTR);
6192 FINDEX(XCL);
6193 D(WCL) = D(D_A(XCL));
6194 if (!DCMP(WCL, FLDCL))
6195 goto L_DAT6;
6196 D(ZPTR) = D(D_A(XCL) + DESCR);
6197 D_A(TCL) = D_A(YCL);
6198 D_A(TCL) *= DESCR;
6199 D_F(TCL) = D_V(TCL) = 0;
6200 SAVSTK();
6201 PUSH(TCL);
6202 PUSH(DATSEG);
6203 PUSH(ZPTR);
6204 AUGATL(ZPTR);
6205 L_DAT7:
6206 D(D_A(XCL) + DESCR) = D(ZPTR);
6207 D_A(YCL)++;
6208 goto L_DATA3;
6209 /*_*/
6210 L_DATA6:
6211 D_A(DATACL) = 1;
6212 goto L_DATA4;
6213 /*_*/
6214 L_DAT5:
6215 if (S_L(XSP) != 0)
6216 BRANCH(PROTER)
6217 if (D_A(YCL) == 0)
6218 BRANCH(PROTER)
6219 D_V(DATCL) = D_A(YCL);
6220 D(D_A(ZCL)) = D(DATCL);
6221 D_A(YCL) *= DESCR;
6222 D_F(YCL) = D_V(YCL) = 0;
6223 D_A(YCL) += 2*DESCR;
6224 D_V(YCL) = D_V(DATSEG);
6225 SAVSTK();
6226 PUSH(YCL);
6227 BLOCK(ZPTR);
6228 D_A(WPTR) += DESCR;
6229 MOVBLK(D_A(ZPTR),D_A(WPTR),D_A(YCL));
6230 D(D_A(ZCL) + DESCR) = D(ZPTR);
6231 BRANCH(RETNUL)
6232 /*_*/
6233 L_DAT6:
6234 D(D_A(XCL)) = D(FLDCL);
6235 SAVSTK();
6236 PUSH(TWOCL);
6237 BLOCK(ZPTR);
6238 D(D_A(ZPTR) + DESCR) = D(DATSEG);
6239 D_A(TCL) = D_A(YCL);
6240 D_A(TCL) *= DESCR;
6241 D_F(TCL) = D_V(TCL) = 0;
6242 D(D_A(ZPTR) + 2*DESCR) = D(TCL);
6243 goto L_DAT7;
6244 /*_*/
6245 }
6246 int
PROTO(ret_t retval)6247 PROTO(ret_t retval) {
6248 ENTRY(PROTO)
6249 SAVSTK();
6250 if (ARGVAL(XPTR) == 1)
6251 BRANCH(FAIL)
6252 if (D_V(XPTR) != A)
6253 BRANCH(NONARY)
6254 D(ZPTR) = D(D_A(XPTR) + DESCR);
6255 BRANCH(RTZPTR)
6256 /*_*/
6257 }
6258 int
FREEZE(ret_t retval)6259 FREEZE(ret_t retval) {
6260 ENTRY(FREEZE)
6261 SAVSTK();
6262 if (ARGVAL(XPTR) == 1)
6263 BRANCH(FAIL)
6264 if (D_V(XPTR) != T)
6265 BRANCH(NONARY)
6266 D_F(D_A(XPTR)) |= FRZN;
6267 BRANCH(RETNUL)
6268 /*_*/
6269 }
6270 int
THAW(ret_t retval)6271 THAW(ret_t retval) {
6272 ENTRY(THAW)
6273 SAVSTK();
6274 if (ARGVAL(XPTR) == 1)
6275 BRANCH(FAIL)
6276 if (D_V(XPTR) != T)
6277 BRANCH(NONARY)
6278 D_F(D_A(XPTR)) &= ~(FRZN);
6279 BRANCH(RETNUL)
6280 /*_*/
6281 }
6282 int
ITEM(ret_t retval)6283 ITEM(ret_t retval) {
6284 ENTRY(ITEM)
6285 D_A(XCL) = D_V(INCL);
6286 D_F(XCL) = D_V(XCL) = 0;
6287 D_A(XCL)--;
6288 PUSH(XCL);
6289 SAVSTK();
6290 if (ARGVAL(YCL) == 1)
6291 BRANCH(FAIL)
6292 POP(XCL);
6293 if (D_V(YCL) == A)
6294 goto L_ARYAD3;
6295 if (D_V(YCL) == T)
6296 goto L_ASSCR;
6297 else
6298 BRANCH(NONARY)
6299 L_ARYAD3:
6300 D(WCL) = D(XCL);
6301 L_ARYAD1:
6302 if (D_A(XCL) <= 0)
6303 goto L_ARYAD2;
6304 PUSH(XCL);
6305 PUSH(WCL);
6306 PUSH(YCL);
6307 SAVSTK();
6308 if (INTVAL(XPTR) == 1)
6309 BRANCH(FAIL)
6310 POP(YCL);
6311 POP(WCL);
6312 POP(XCL);
6313 PUSH(XPTR);
6314 D_A(XCL)--;
6315 goto L_ARYAD1;
6316 /*_*/
6317 L_ARYAD2:
6318 D(ZPTR) = D(ZEROCL);
6319 D(ZCL) = D(D_A(YCL) + 2*DESCR);
6320 D_A(YPTR) = D_A(ZCL);
6321 D_A(YPTR) *= DESCR;
6322 D_F(YPTR) = D_V(YPTR) = 0;
6323 D_A(YPTR) = D_A(YCL) + D_A(YPTR);
6324 D_F(YPTR) = D_F(YCL);
6325 D_V(YPTR) = D_V(YCL);
6326 D_A(YPTR) += 2*DESCR;
6327 L_ARYAD7:
6328 if (D_A(WCL) == D_A(ZCL))
6329 goto L_ARYAD9;
6330 if (D_A(WCL) > D_A(ZCL))
6331 BRANCH(ARGNER)
6332 PUSH(ZEROCL);
6333 D_A(WCL)++;
6334 goto L_ARYAD7;
6335 /*_*/
6336 L_ARYAD9:
6337 D_A(YCL) += 2*DESCR;
6338 D(WPTR) = D(D_A(YCL) + DESCR);
6339 D_A(TPTR) = D_V(WPTR);
6340 D_F(TPTR) = D_V(TPTR) = 0;
6341 L_ARYA11:
6342 POP(XPTR);
6343 D_A(XPTR) -= D_A(WPTR);
6344 if (D_A(XPTR) < 0)
6345 BRANCH(FAIL)
6346 if (D_A(XPTR) >= D_A(TPTR))
6347 BRANCH(FAIL)
6348 D_A(XPTR) = D_A(ZPTR) + D_A(XPTR);
6349 D_F(XPTR) = D_F(ZPTR);
6350 D_V(XPTR) = D_V(ZPTR);
6351 D_A(ZCL)--;
6352 if (D_A(ZCL) == 0)
6353 goto L_ARYA12;
6354 D_A(YCL) += DESCR;
6355 D(WPTR) = D(D_A(YCL) + DESCR);
6356 D_A(TPTR) = D_V(WPTR);
6357 D_F(TPTR) = D_V(TPTR) = 0;
6358 D(ZPTR) = D(XPTR);
6359 D_A(ZPTR) *= D_A(TPTR);
6360 goto L_ARYA11;
6361 /*_*/
6362 L_ARYA12:
6363 D_A(XPTR) *= DESCR;
6364 D_F(XPTR) = D_V(XPTR) = 0;
6365 D_A(XPTR) = D_A(YPTR) + D_A(XPTR);
6366 D_F(XPTR) = D_F(YPTR);
6367 D_V(XPTR) = D_V(YPTR);
6368 L_ARYA10:
6369 D_V(XPTR) = N;
6370 BRANCH(RTXNAM)
6371 /*_*/
6372 L_ASSCR:
6373 if (D_A(XCL) != 1)
6374 BRANCH(ARGNER)
6375 PUSH(YCL);
6376 SAVSTK();
6377 if (ARGVAL(YPTR) == 1)
6378 BRANCH(FAIL)
6379 POP(XPTR);
6380 D(YCL) = D(XPTR);
6381 L_ASSCR5:
6382 if (LOCAPV(XPTR,XPTR,YPTR))
6383 goto L_ARYA10;
6384 D_A(TCL) = D_V(D_A(XPTR));
6385 D_F(TCL) = D_V(TCL) = 0;
6386 D(ZPTR) = D(D_A(XPTR) + D_A(TCL));
6387 if (D_A(ZPTR) == 1)
6388 goto L_ASSCR6;
6389 D(XPTR) = D(ZPTR);
6390 goto L_ASSCR5;
6391 /*_*/
6392 L_ASSCR6:
6393 if ((D_F(D_A(YCL)) & FRZN))
6394 BRANCH(RETNUL)
6395 if (!LOCAPV(XPTR,XPTR,ZEROCL))
6396 goto L_ASSCR3;
6397 L_ASSCR8:
6398 D(D_A(XPTR) + 2*DESCR) = D(YPTR);
6399 goto L_ARYA10;
6400 /*_*/
6401 L_ASSCR3:
6402 D_A(TCL) -= DESCR;
6403 D(WPTR) = D(D_A(XPTR) + D_A(TCL));
6404 D(ZCL) = D(XPTR);
6405 SAVSTK();
6406 PUSH(WPTR);
6407 BLOCK(ZPTR);
6408 D(XPTR) = D(WPTR);
6409 SAVSTK();
6410 switch (ASSOCE(XPTR)) {
6411 case 1:
6412 case 2:
6413 BRANCH(INTR10)
6414 }
6415 D_A(TCL) += DESCR;
6416 D(D_A(ZCL) + D_A(TCL)) = D(XPTR);
6417 goto L_ASSCR8;
6418 /*_*/
6419 }
6420 int
DEFDAT(ret_t retval)6421 DEFDAT(ret_t retval) {
6422 ENTRY(DEFDAT)
6423 D_A(XCL) = D_V(INCL);
6424 D_F(XCL) = D_V(XCL) = 0;
6425 D(WCL) = D(XCL);
6426 D(YCL) = D(INCL);
6427 PSTACK(YPTR);
6428 L_DEFD1:
6429 D_A(OCICL) += DESCR;
6430 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
6431 if ((D_F(XPTR) & FNC))
6432 goto L_DEFDC;
6433 L_DEFD2:
6434 if (D_A(INSW) == 0)
6435 goto L_DEFD8;
6436 if (!LOCAPV(ZPTR,INATL,XPTR))
6437 goto L_DEFD8;
6438 D(ZPTR) = D(D_A(ZPTR) + DESCR);
6439 PUSH(XCL);
6440 PUSH(WCL);
6441 PUSH(YCL);
6442 PUSH(YPTR);
6443 SAVSTK();
6444 PUSH(XPTR);
6445 PUSH(ZPTR);
6446 if (PUTIN(XPTR) == 1)
6447 BRANCH(FAIL)
6448 POP(YPTR);
6449 POP(YCL);
6450 POP(WCL);
6451 POP(XCL);
6452 goto L_DEFD3;
6453 /*_*/
6454 L_DEFD8:
6455 D(XPTR) = D(D_A(XPTR) + DESCR);
6456 L_DEFD3:
6457 PUSH(XPTR);
6458 D_A(XCL)--;
6459 if (D_A(XCL) < 0)
6460 BRANCH(INTR10)
6461 if (D_A(XCL) > 0)
6462 goto L_DEFD1;
6463 D(XCL) = D(D_A(YCL));
6464 D_A(XCL) = D_V(XCL);
6465 D_F(XCL) = D_V(XCL) = 0;
6466 L_DEFD4:
6467 if (D_A(WCL) >= D_A(XCL))
6468 goto L_DEFD5;
6469 PUSH(NULVCL);
6470 D_A(WCL)++;
6471 goto L_DEFD4;
6472 /*_*/
6473 L_DEFD5:
6474 D(WCL) = D(D_A(YCL) + DESCR);
6475 D_A(XCL) *= DESCR;
6476 D_F(XCL) = D_V(XCL) = 0;
6477 D_V(XCL) = D_V(WCL);
6478 SAVSTK();
6479 PUSH(XCL);
6480 BLOCK(ZPTR);
6481 D_A(YPTR) += DESCR;
6482 MOVBLK(D_A(ZPTR),D_A(YPTR),D_A(XCL));
6483 BRANCH(RTZPTR)
6484 /*_*/
6485 L_DEFDC:
6486 PUSH(XCL);
6487 PUSH(WCL);
6488 PUSH(YCL);
6489 PUSH(YPTR);
6490 SAVSTK();
6491 PUSH(XPTR);
6492 switch (INVOKE(XPTR)) {
6493 case 1:
6494 BRANCH(FAIL)
6495 case 2:
6496 goto L_DEFDN;
6497 }
6498 POP(YPTR);
6499 POP(YCL);
6500 POP(WCL);
6501 POP(XCL);
6502 goto L_DEFD3;
6503 /*_*/
6504 L_DEFDN:
6505 POP(YPTR);
6506 POP(YCL);
6507 POP(WCL);
6508 POP(XCL);
6509 goto L_DEFD2;
6510 /*_*/
6511 }
6512 int
FIELD(ret_t retval)6513 FIELD(ret_t retval) {
6514 ENTRY(FIELD)
6515 PUSH(INCL);
6516 SAVSTK();
6517 if (ARGVAL(XPTR) == 1)
6518 BRANCH(FAIL)
6519 if (DCMP(XPTR, NULVCL))
6520 BRANCH(NONAME)
6521 POP(YCL);
6522 if (D_V(XPTR) == I)
6523 goto L_FIELD2;
6524 if (D_V(XPTR) != S)
6525 goto L_FIELD1;
6526 if (D_A(CASECL) == 0)
6527 goto L_FIELD1;
6528 SAVSTK();
6529 if (VPXPTR(NORET) == 1)
6530 BRANCH(FAIL)
6531 L_FIELD1:
6532 D_V(DT1CL) = D_V(XPTR);
6533 D(YPTR) = D(D_A(YCL) + DESCR);
6534 if (!LOCAPT(ZCL,YPTR,DT1CL))
6535 BRANCH(INTR1)
6536 D(ZCL) = D(D_A(ZCL) + 2*DESCR);
6537 D_A(XPTR) += D_A(ZCL);
6538 D_V(XPTR) = N;
6539 BRANCH(RTXNAM)
6540 /*_*/
6541 L_FIELD2:
6542 SAVSTK();
6543 PUSH(XPTR);
6544 if (GNVARI(XPTR) == 1)
6545 goto L_FIELD1;
6546 /*_*/
6547 }
6548 int
RSORT(ret_t retval)6549 RSORT(ret_t retval) {
6550 ENTRY(RSORT)
6551 D_A(SCL) = 1;
6552 BRANCH(SORT1)
6553 /*_*/
6554 }
6555 int
SORT(ret_t retval)6556 SORT(ret_t retval) {
6557 ENTRY(SORT)
6558 D_A(SCL) = 0;
6559 /* FALL */
6560 BRANCH(SORT1)
6561 }
6562 static int
SORT1(ret_t retval)6563 SORT1(ret_t retval) {
6564 ENTRY(SORT1)
6565 D_A(WCL) = D_V(INCL);
6566 D_F(WCL) = D_V(WCL) = 0;
6567 PUSH(WCL);
6568 PUSH(SCL);
6569 SAVSTK();
6570 if (ARGVAL(XPTR) == 1)
6571 BRANCH(FAIL)
6572 D(WPTR) = D(XPTR);
6573 if (D_V(XPTR) == A)
6574 goto L_SORT2;
6575 if (D_V(XPTR) != T)
6576 BRANCH(NONARY)
6577 SAVSTK();
6578 PUSH(XPTR);
6579 switch (ICNVTA(XPTR)) {
6580 case 1:
6581 BRANCH(FAIL)
6582 }
6583 L_SORT2:
6584 POP(SCL);
6585 POP(WCL);
6586 D(XCL) = D(D_A(XPTR) + 2*DESCR);
6587 D_A(YPTR) = D_A(XCL);
6588 D_A(YPTR) *= DESCR;
6589 D_F(YPTR) = D_V(YPTR) = 0;
6590 D_A(YPTR) = D_A(XPTR) + D_A(YPTR);
6591 D_F(YPTR) = D_F(XPTR);
6592 D_V(YPTR) = D_V(XPTR);
6593 D_A(YPTR) += 2*DESCR;
6594 D(YCL) = D(ONECL);
6595 if (D_A(XCL) < 2)
6596 goto L_SORT3;
6597 if (D_A(XCL) > 2)
6598 BRANCH(INTR30)
6599 D(YCL) = D(D_A(XPTR) + 3*DESCR);
6600 D_A(YCL) = D_V(YCL);
6601 D_F(YCL) = D_V(YCL) = 0;
6602 L_SORT3:
6603 D(ZCL) = D(D_A(YPTR));
6604 D_A(ZCL) = D_V(ZCL);
6605 D_F(ZCL) = D_V(ZCL) = 0;
6606 D_A(ZCL) *= DESCR;
6607 D_F(ZCL) = D_V(ZCL) = 0;
6608 D(ZPTR) = D(YPTR);
6609 if (D_A(WCL) < 2)
6610 goto L_SORT5;
6611 if (D_A(WCL) > 2)
6612 BRANCH(ARGNER)
6613 PUSH(WPTR);
6614 PUSH(XPTR);
6615 PUSH(YPTR);
6616 PUSH(ZPTR);
6617 PUSH(XCL);
6618 PUSH(YCL);
6619 PUSH(ZCL);
6620 PUSH(SCL);
6621 SAVSTK();
6622 if (ARGVAL(WCL) == 1)
6623 BRANCH(FAIL)
6624 POP(SCL);
6625 POP(ZCL);
6626 POP(YCL);
6627 POP(XCL);
6628 POP(ZPTR);
6629 POP(YPTR);
6630 POP(XPTR);
6631 POP(WPTR);
6632 D(A3PTR) = D(ZEROCL);
6633 if (D_V(WCL) == I)
6634 goto L_SORT3C;
6635 if (D_V(WCL) == S)
6636 goto L_SORT3B;
6637 if (D_V(WCL) == R)
6638 goto L_SORT3A;
6639 else
6640 BRANCH(INTR30)
6641 /*_*/
6642 L_SORT3A:
6643 CLR_MATH_ERROR();
6644 D_A(WCL) = (int_t) D_RV(WCL);
6645 D_F(WCL) = 0;
6646 D_V(WCL) = I;
6647 if (MATH_ERROR())
6648 BRANCH(INTR30)
6649 goto L_SORT3C;
6650 L_SORT3B:
6651 X_LOCSP(XSP,WCL);
6652 if (SPCINT(WCL,XSP))
6653 goto L_SORT3C;
6654 if (SPREAL(WCL,XSP))
6655 goto L_SORT3A;
6656 if (D_A(XCL) != 1)
6657 BRANCH(INTR30)
6658 if (!LOCAPV(WCL,FNCPL,WCL))
6659 BRANCH(INTR30)
6660 D(WCL) = D(D_A(WCL) + DESCR);
6661 D(TCL) = D(D_A(WCL));
6662 if (D_A(TCL) != D_A(FLDCL))
6663 BRANCH(INTR30)
6664 D(A3PTR) = D(D_A(WCL) + DESCR);
6665 D(WCL) = D(ONECL);
6666 L_SORT3C:
6667 if (D_A(XCL) != 1)
6668 goto L_SORT4;
6669 if (D_A(WCL) == 1)
6670 goto L_SORT5;
6671 else
6672 BRANCH(INTR30)
6673 /*_*/
6674 L_SORT4:
6675 D(TCL) = D(D_A(XPTR) + 3*DESCR);
6676 CLR_MATH_ERROR();
6677 D_A(WCL) -= D_A(TCL);
6678 if (MATH_ERROR())
6679 BRANCH(INTR30)
6680 goto L_SORT4A;
6681 L_SORT4A:
6682 if (D_A(WCL) < 0)
6683 BRANCH(INTR30)
6684 if (D_A(WCL) >= D_A(YCL))
6685 BRANCH(INTR30)
6686 CLR_MATH_ERROR();
6687 D_A(WCL) *= D_A(ZCL);
6688 if (MATH_ERROR())
6689 BRANCH(INTR30)
6690 D(ZPTR) = D(YPTR);
6691 D_A(ZPTR) += D_A(WCL);
6692 L_SORT5:
6693 D_A(XCL) = 0;
6694 if (D_V(WPTR) == A)
6695 goto L_SORTA;
6696 D_A(TCL) = D_V(D_A(XPTR));
6697 D_F(TCL) = D_V(TCL) = 0;
6698 D(TPTR) = D(XPTR);
6699 D_A(TPTR) += D_A(TCL);
6700 D_A(TPTR) -= D_A(ZCL);
6701 D_A(A4PTR) = (int_t) (-DESCR);
6702 D_A(A5PTR) = 0;
6703 if (D_A(ZPTR) == D_A(YPTR))
6704 goto L_SORTT1;
6705 D_A(A5PTR) = (int_t) (-DESCR);
6706 L_SORTT1:
6707 D_A(WCL) = D_V(D_A(WPTR));
6708 D_F(WCL) = D_V(WCL) = 0;
6709 D_A(WCL) -= 2*DESCR;
6710 D_A(WCL) = D_A(WPTR) + D_A(WCL);
6711 D_F(WCL) = D_F(WPTR);
6712 D_V(WCL) = D_V(WPTR);
6713 L_SORTT2:
6714 D(TCL) = D(D_A(WPTR) + DESCR);
6715 if (DCMP(TCL, NULVCL))
6716 goto L_SORTT3;
6717 D_A(XCL) += DESCR;
6718 D(A6PTR) = D(WPTR);
6719 D_A(A6PTR) += D_A(A5PTR);
6720 D_A(A6PTR) += 2*DESCR;
6721 D(D_A(TPTR) + D_A(XCL)) = D(A6PTR);
6722 if (D_A(XCL) == D_A(ZCL))
6723 goto L_SORTGO;
6724 L_SORTT3:
6725 D_A(WPTR) += 2*DESCR;
6726 if (D_A(WCL) != D_A(WPTR))
6727 goto L_SORTT2;
6728 D(WPTR) = D(D_A(WCL) + 2*DESCR);
6729 goto L_SORTT1;
6730 /*_*/
6731 L_SORTA:
6732 D_A(WCL) = D_V(D_A(WPTR));
6733 D_F(WCL) = D_V(WCL) = 0;
6734 D_V(WCL) = A;
6735 SAVSTK();
6736 PUSH(WCL);
6737 BLOCK(XPTR);
6738 D_A(A4PTR) = (int_t) (4*DESCR);
6739 MOVBLK(D_A(XPTR),D_A(WPTR),D_A(A4PTR));
6740 D(TPTR) = D(XPTR);
6741 D_A(TPTR) += D_A(WCL);
6742 D_A(TPTR) -= D_A(ZCL);
6743 D(A5PTR) = D(ZPTR);
6744 D_A(A5PTR) -= D_A(YPTR);
6745 D_F(A5PTR) &= ~(PTR);
6746 D_A(A4PTR) = D_A(ZCL);
6747 L_SORTA1:
6748 D_A(XCL) += DESCR;
6749 D_A(ZPTR) += DESCR;
6750 D(D_A(TPTR) + D_A(XCL)) = D(ZPTR);
6751 if (D_A(XCL) != D_A(ZCL))
6752 goto L_SORTA1;
6753 L_SORTGO:
6754 D_A(A6PTR) = D_A(ZCL);
6755 L_SORT6:
6756 if (D_A(A6PTR) <= DESCR)
6757 goto L_SORT12;
6758 D_A(A6PTR) /= D_A(TWOCL);
6759 D_A(A6PTR) *= DESCR;
6760 D_F(A6PTR) = D_V(A6PTR) = 0;
6761 D(XCL) = D(ZCL);
6762 D_A(XCL) -= D_A(A6PTR);
6763 L_SORT7:
6764 D(TCL) = D(ZEROCL);
6765 D_A(A7PTR) = (int_t) DESCR;
6766 L_SORT8:
6767 D(LPTR) = D(A7PTR);
6768 D_A(LPTR) += D_A(A6PTR);
6769 D(F1PTR) = D(D_A(TPTR) + D_A(A7PTR));
6770 D(F2PTR) = D(D_A(TPTR) + D_A(LPTR));
6771 D(A1PTR) = D(D_A(F1PTR));
6772 D(A2PTR) = D(D_A(F2PTR));
6773 L_SORT9:
6774 D_A(DTCL) = D_V(A1PTR);
6775 D_F(DTCL) = D_V(DTCL) = 0;
6776 D_V(DTCL) = D_V(A2PTR);
6777 if (DCMP(DTCL, VVDTP))
6778 goto L_CVV;
6779 if (DCMP(DTCL, IIDTP))
6780 goto L_CII;
6781 if (DCMP(DTCL, RIDTP))
6782 goto L_CRI;
6783 if (DCMP(DTCL, IRDTP))
6784 goto L_CIRX;
6785 if (DCMP(DTCL, RRDTP))
6786 goto L_CRR;
6787 goto L_COTH;
6788 /*_*/
6789 L_CVV:
6790 X_LOCSP(XSP,A1PTR);
6791 X_LOCSP(YSP,A2PTR);
6792 {
6793 int x = LEXCMP(XSP,YSP);
6794 if (x < 0)
6795 goto L_CMPLT;
6796 if (x == 0)
6797 goto L_CMPEQ;
6798 goto L_CMPGT;
6799 }
6800 L_CIRX:
6801 D_RV(A1PTR) = (real_t)D_A(A1PTR);
6802 D_F(A1PTR) = 0;
6803 D_V(A1PTR) = R;
6804 goto L_CRR;
6805 /*_*/
6806 L_CRI:
6807 D_RV(A2PTR) = (real_t)D_A(A2PTR);
6808 D_F(A2PTR) = 0;
6809 D_V(A2PTR) = R;
6810 goto L_CRR;
6811 /*_*/
6812 L_CII:
6813 if (D_A(A1PTR) < D_A(A2PTR))
6814 goto L_CMPLT;
6815 if (D_A(A1PTR) == D_A(A2PTR))
6816 goto L_CMPEQ;
6817 goto L_CMPGT;
6818 /*_*/
6819 L_CRR:
6820 if (isnan(D_RV(A1PTR)))
6821 goto L_CRR1;
6822 if (isnan(D_RV(A2PTR)))
6823 goto L_CMPLT;
6824 if (D_RV(A1PTR) < D_RV(A2PTR))
6825 goto L_CMPLT;
6826 if (D_RV(A1PTR) == D_RV(A2PTR))
6827 goto L_CMPEQ;
6828 goto L_CMPGT;
6829 /*_*/
6830 L_CRR1:
6831 if (isnan(D_RV(A2PTR)))
6832 goto L_CMPEQ;
6833 else
6834 goto L_CMPGT;
6835 /*_*/
6836 L_CMPEQ:
6837 if (D_PTR(F1PTR) <= D_PTR(F2PTR))
6838 goto L_CMPNXT;
6839 else
6840 goto L_SWAP;
6841 L_CMPGT:
6842 if (D_A(SCL) == 0)
6843 goto L_SWAP;
6844 else
6845 goto L_CMPNXT;
6846 L_CMPLT:
6847 if (D_A(SCL) == 0)
6848 goto L_CMPNXT;
6849 L_SWAP:
6850 D(D_A(TPTR) + D_A(A7PTR)) = D(F2PTR);
6851 D(D_A(TPTR) + D_A(LPTR)) = D(F1PTR);
6852 D_A(TCL)++;
6853 L_CMPNXT:
6854 if (D_A(A7PTR) >= D_A(XCL))
6855 goto L_SORT11;
6856 D_A(A7PTR) += DESCR;
6857 goto L_SORT8;
6858 /*_*/
6859 L_SORT11:
6860 if (D_A(TCL) == 0)
6861 goto L_SORT6;
6862 else
6863 goto L_SORT7;
6864 /*_*/
6865 L_COTH:
6866 if (D_A(A3PTR) == 0)
6867 goto L_COTH2;
6868 if (D_V(A1PTR) < DATSTA)
6869 goto L_COTH0;
6870 D_V(DT1CL) = D_V(A1PTR);
6871 if (!LOCAPT(ZPTR,A3PTR,DT1CL))
6872 BRANCH(INTR1)
6873 D(ZPTR) = D(D_A(ZPTR) + 2*DESCR);
6874 D_A(A1PTR) += D_A(ZPTR);
6875 D(A1PTR) = D(D_A(A1PTR) + DESCR);
6876 goto L_SORT9;
6877 /*_*/
6878 L_COTH0:
6879 if (D_V(A2PTR) < DATSTA)
6880 goto L_COTH2;
6881 D_V(DT1CL) = D_V(A2PTR);
6882 if (!LOCAPT(ZPTR,A3PTR,DT1CL))
6883 BRANCH(INTR1)
6884 D(ZPTR) = D(D_A(ZPTR) + 2*DESCR);
6885 D_A(A2PTR) += D_A(ZPTR);
6886 D(A2PTR) = D(D_A(A2PTR) + DESCR);
6887 goto L_SORT9;
6888 L_COTH2:
6889 if (D_V(A1PTR) == D_V(A2PTR))
6890 goto L_COTH1;
6891 D_A(A1PTR) = D_V(A1PTR);
6892 D_F(A1PTR) = D_V(A1PTR) = 0;
6893 D_A(A2PTR) = D_V(A2PTR);
6894 D_F(A2PTR) = D_V(A2PTR) = 0;
6895 L_COTH1:
6896 if (D_PTR(A1PTR) < D_PTR(A2PTR))
6897 goto L_CMPLT;
6898 if (D_PTR(A1PTR) == D_PTR(A2PTR))
6899 goto L_CMPEQ;
6900 goto L_CMPGT;
6901 /*_*/
6902 L_SORT12:
6903 D(XCL) = D(D_A(XPTR) + 2*DESCR);
6904 D_A(WPTR) = D_A(XCL);
6905 D_A(WPTR) *= DESCR;
6906 D_F(WPTR) = D_V(WPTR) = 0;
6907 D_A(WPTR) = D_A(XPTR) + D_A(WPTR);
6908 D_F(WPTR) = D_F(XPTR);
6909 D_V(WPTR) = D_V(XPTR);
6910 D_A(WPTR) += 3*DESCR;
6911 D(LPTR) = D(ONECL);
6912 D_A(LPTR) *= DESCR;
6913 D_F(LPTR) = D_V(LPTR) = 0;
6914 L_SORT13:
6915 D(ZPTR) = D(D_A(TPTR) + D_A(LPTR));
6916 D_A(ZPTR) -= D_A(A5PTR);
6917 D(YPTR) = D(WPTR);
6918 D_A(A6PTR) = D_A(YCL);
6919 D_A(A6PTR) *= DESCR;
6920 D_F(A6PTR) = D_V(A6PTR) = 0;
6921 L_SORT14:
6922 D(D_A(YPTR)) = D(D_A(ZPTR));
6923 D_A(ZPTR) += D_A(A4PTR);
6924 D_A(YPTR) += D_A(ZCL);
6925 D_A(A6PTR) -= DESCR;
6926 if (D_A(A6PTR) != 0)
6927 goto L_SORT14;
6928 D_A(WPTR) += DESCR;
6929 D_A(LPTR) += DESCR;
6930 if (D_PTR(LPTR) <= D_PTR(ZCL))
6931 goto L_SORT13;
6932 PUSH(ZEROCL);
6933 PUSH(ZEROCL);
6934 PUSH(ZEROCL);
6935 PUSH(ZEROCL);
6936 POP(YPTR);
6937 POP(ZPTR);
6938 POP(F1PTR);
6939 POP(F2PTR);
6940 BRANCH(RTXPTR)
6941 /*_*/
6942 }
6943 int
READ(ret_t retval)6944 READ(ret_t retval) {
6945 ENTRY(READ)
6946 SAVSTK();
6947 if (IND(XPTR) == 1)
6948 BRANCH(FAIL)
6949 PUSH(XPTR);
6950 SAVSTK();
6951 if (INTVAL(YPTR) == 1)
6952 BRANCH(FAIL)
6953 PUSH(YPTR);
6954 SAVSTK();
6955 if (VARVAL(ZPTR) == 1)
6956 BRANCH(FAIL)
6957 POP(YPTR);
6958 if (D_A(YPTR) < 0)
6959 BRANCH(UNTERR)
6960 if (D_A(YPTR) == 0)
6961 goto L_READ5;
6962 L_READ6:
6963 PUSH(YPTR);
6964 PUSH(ZPTR);
6965 SAVSTK();
6966 if (VARVAL(TPTR) == 1)
6967 BRANCH(FAIL)
6968 X_LOCSP(XSP,TPTR);
6969 POP(ZPTR);
6970 POP(YPTR);
6971 POP(XPTR);
6972 X_LOCSP(ZSP,ZPTR);
6973 D(ZPTR) = D(ZEROCL);
6974 if (!IO_OPENI(YPTR,XSP,ZSP,ZPTR))
6975 BRANCH(FAIL)
6976 if (D_A(ZPTR) < 0)
6977 BRANCH(LENERR)
6978 if (D_A(ZPTR) > 0)
6979 goto L_READ2;
6980 if (!LOCAPT(TPTR,INSATL,YPTR))
6981 goto L_READ4;
6982 L_READ3:
6983 if (!LOCAPV(ZPTR,INATL,XPTR))
6984 goto L_READ1;
6985 D(D_A(ZPTR) + DESCR) = D(TPTR);
6986 BRANCH(RETNUL)
6987 /*_*/
6988 L_READ1:
6989 SAVSTK();
6990 PUSH(XPTR);
6991 PUSH(TPTR);
6992 PUSH(INATL);
6993 if (AUGATL(INATL) == 1)
6994 BRANCH(RETNUL)
6995 /*_*/
6996 L_READ4:
6997 D(ZPTR) = D(DFLSIZ);
6998 L_READ2:
6999 SAVSTK();
7000 PUSH(IOBLSZ);
7001 BLOCK(TPTR);
7002 D(D_A(TPTR) + DESCR) = D(YPTR);
7003 D(D_A(TPTR) + 2*DESCR) = D(ZPTR);
7004 goto L_READ3;
7005 /*_*/
7006 L_READ5:
7007 D_A(YPTR) = (int_t) UNITI;
7008 goto L_READ6;
7009 /*_*/
7010 }
7011 int
PRINT(ret_t retval)7012 PRINT(ret_t retval) {
7013 ENTRY(PRINT)
7014 SAVSTK();
7015 if (IND(XPTR) == 1)
7016 BRANCH(FAIL)
7017 PUSH(XPTR);
7018 SAVSTK();
7019 if (INTVAL(YPTR) == 1)
7020 BRANCH(FAIL)
7021 PUSH(YPTR);
7022 SAVSTK();
7023 if (VARVAL(ZPTR) == 1)
7024 BRANCH(FAIL)
7025 PUSH(ZPTR);
7026 SAVSTK();
7027 if (VARVAL(TPTR) == 1)
7028 BRANCH(FAIL)
7029 POP(ZPTR);
7030 POP(YPTR);
7031 POP(XPTR);
7032 X_LOCSP(XSP,TPTR);
7033 X_LOCSP(ZSP,ZPTR);
7034 if (!IO_OPENO(YPTR,XSP,ZSP))
7035 BRANCH(FAIL)
7036 if (D_A(YPTR) < 0)
7037 BRANCH(UNTERR)
7038 if (D_A(YPTR) == 0)
7039 goto L_PRINT5;
7040 L_PRINT6:
7041 if (D_A(ZPTR) != 0)
7042 goto L_PRINT2;
7043 if (!LOCAPT(TPTR,OTSATL,YPTR))
7044 goto L_PRINT4;
7045 L_PRINT3:
7046 if (!LOCAPV(ZPTR,OUTATL,XPTR))
7047 goto L_PRINT1;
7048 D(D_A(ZPTR) + DESCR) = D(TPTR);
7049 BRANCH(RETNUL)
7050 /*_*/
7051 L_PRINT1:
7052 SAVSTK();
7053 PUSH(XPTR);
7054 PUSH(TPTR);
7055 PUSH(OUTATL);
7056 if (AUGATL(OUTATL) == 1)
7057 BRANCH(RETNUL)
7058 /*_*/
7059 L_PRINT4:
7060 D(ZPTR) = D(DFLFST);
7061 L_PRINT2:
7062 SAVSTK();
7063 PUSH(IOBLSZ);
7064 BLOCK(TPTR);
7065 D(D_A(TPTR) + DESCR) = D(YPTR);
7066 D(D_A(TPTR) + 2*DESCR) = D(ZPTR);
7067 goto L_PRINT3;
7068 /*_*/
7069 L_PRINT5:
7070 D_A(YPTR) = (int_t) UNITO;
7071 goto L_PRINT6;
7072 /*_*/
7073 }
7074 int
BKSPCE(ret_t retval)7075 BKSPCE(ret_t retval) {
7076 ENTRY(BKSPCE)
7077 D_A(SCL) = 1;
7078 BRANCH(IOOP)
7079 /*_*/
7080 }
7081 int
ENDFIL(ret_t retval)7082 ENDFIL(ret_t retval) {
7083 ENTRY(ENDFIL)
7084 D_A(SCL) = 2;
7085 BRANCH(IOOP)
7086 /*_*/
7087 }
7088 int
REWIND(ret_t retval)7089 REWIND(ret_t retval) {
7090 ENTRY(REWIND)
7091 D_A(SCL) = 3;
7092 BRANCH(IOOP)
7093 /*_*/
7094 }
7095 int
SET(ret_t retval)7096 SET(ret_t retval) {
7097 ENTRY(SET)
7098 D_A(SCL) = 4;
7099 /* FALL */
7100 BRANCH(IOOP)
7101 }
7102 static int
IOOP(ret_t retval)7103 IOOP(ret_t retval) {
7104 ENTRY(IOOP)
7105 PUSH(SCL);
7106 SAVSTK();
7107 if (INTVAL(XCL) == 1)
7108 BRANCH(FAIL)
7109 if (D_A(XCL) <= 0)
7110 BRANCH(UNTERR)
7111 POP(SCL);
7112 switch (D_A(SCL)) {
7113 case 2:
7114 goto L_EOP;
7115 case 3:
7116 goto L_ROP;
7117 case 4:
7118 goto L_SOP;
7119 }
7120 io_backspace(D_A(XCL));
7121 BRANCH(RETNUL)
7122 /*_*/
7123 L_EOP:
7124 if (!io_endfile(D_A(XCL)))
7125 BRANCH(COMP6)
7126 BRANCH(RETNUL)
7127 /*_*/
7128 L_ROP:
7129 io_rewind(D_A(XCL));
7130 BRANCH(RETNUL)
7131 /*_*/
7132 L_SOP:
7133 PUSH(XCL);
7134 SAVSTK();
7135 if (INTVAL(XPTR) == 1)
7136 BRANCH(FAIL)
7137 PUSH(XPTR);
7138 SAVSTK();
7139 if (INTVAL(YPTR) == 1)
7140 BRANCH(FAIL)
7141 POP(XPTR);
7142 POP(XCL);
7143 if (IO_SEEK(XCL,XPTR,YPTR))
7144 BRANCH(RTXPTR)
7145 else
7146 BRANCH(FAIL)
7147 /*_*/
7148 }
7149 int
DETACH(ret_t retval)7150 DETACH(ret_t retval) {
7151 ENTRY(DETACH)
7152 SAVSTK();
7153 if (IND(XPTR) == 1)
7154 BRANCH(FAIL)
7155 if (!LOCAPV(ZPTR,INATL,XPTR))
7156 goto L_DTCH1;
7157 D(D_A(ZPTR) + DESCR) = D(ZEROCL);
7158 D(D_A(ZPTR) + 2*DESCR) = D(ZEROCL);
7159 L_DTCH1:
7160 if (!LOCAPV(ZPTR,OUTATL,XPTR))
7161 BRANCH(RETNUL)
7162 D(D_A(ZPTR) + DESCR) = D(ZEROCL);
7163 D(D_A(ZPTR) + 2*DESCR) = D(ZEROCL);
7164 BRANCH(RETNUL)
7165 /*_*/
7166 }
7167 static int
PUTIN(ret_t retval)7168 PUTIN(ret_t retval) {
7169 ENTRY(PUTIN)
7170 POP(IO1PTR);
7171 POP(IO2PTR);
7172 D(IO3PTR) = D(D_A(IO1PTR) + DESCR);
7173 D(IO1PTR) = D(D_A(IO1PTR) + 2*DESCR);
7174 if (D_A(IO1PTR) == VLRECL)
7175 goto L_PUTIN0;
7176 SAVSTK();
7177 PUSH(IO1PTR);
7178 CONVAR(IO4PTR);
7179 X_LOCSP(IOSP,IO4PTR);
7180 L_PUTIN0:
7181 D(XCL) = D(IO1PTR);
7182 D_A(RSTAT)++;
7183 switch (IO_READ(IO3PTR, IOSP)) {
7184 case IO_EOF:
7185 BRANCH(FAIL)
7186 case IO_ERR:
7187 BRANCH(COMP5)
7188 }
7189 if (D_A(TRIMCL) == 0)
7190 goto L_PUTIN1;
7191 TRIMSP(IOSP,IOSP);
7192 L_PUTIN1:
7193 D_A(IO1PTR) = S_L(IOSP);
7194 D_F(IO1PTR) = D_V(IO1PTR) = 0;
7195 if (D_A(IO1PTR) > D_A(MLENCL))
7196 BRANCH(INTR8)
7197 if (D_V(IO2PTR) == K)
7198 goto L_PUTIN3;
7199 if (D_A(XCL) != VLRECL)
7200 goto L_PUTIN4;
7201 SAVSTK();
7202 PUSH(ISPPTR);
7203 GENVAR(IO1PTR);
7204 goto L_PUTIN2;
7205 L_PUTIN4:
7206 SAVSTK();
7207 PUSH(IO1PTR);
7208 GNVARS(IO1PTR);
7209 L_PUTIN2:
7210 D(D_A(IO2PTR) + DESCR) = D(IO1PTR);
7211 D(retval) = D(IO1PTR);
7212 RETURN(2)
7213 L_PUTIN3:
7214 X_LOCSP(XSP,IO1PTR);
7215 if (SPCINT(IO1PTR,XSP))
7216 goto L_PUTIN2;
7217 else
7218 BRANCH(INTR1)
7219 /*_*/
7220 }
7221 static int
PUTOUT(ret_t retval)7222 PUTOUT(ret_t retval) {
7223 ENTRY(PUTOUT)
7224 POP(IO1PTR);
7225 POP(IO2PTR);
7226 if (D_V(IO2PTR) == S)
7227 goto L_PUTV;
7228 if (D_V(IO2PTR) == I)
7229 goto L_PUTI;
7230 SAVSTK();
7231 PUSH(IO2PTR);
7232 DTREP(IO2PTR);
7233 _SPEC(IOSP) = _SPEC(D_A(IO2PTR));
7234 goto L_PUTVU;
7235 /*_*/
7236 L_PUTV:
7237 X_LOCSP(IOSP,IO2PTR);
7238 L_PUTVU:
7239 IO_PRINT(IOKEY, IO1PTR, IOSP);
7240 if (D_A(IOKEY) == 0)
7241 BRANCH(COMP6)
7242 D_A(WSTAT)++;
7243 BRANCH(RTN1)
7244 /*_*/
7245 L_PUTI:
7246 INTSPC(IOSP,IO2PTR);
7247 goto L_PUTVU;
7248 /*_*/
7249 }
7250 int
TRACE(ret_t retval)7251 TRACE(ret_t retval) {
7252 ENTRY(TRACE)
7253 SAVSTK();
7254 if (IND(XPTR) == 1)
7255 BRANCH(FAIL)
7256 PUSH(XPTR);
7257 SAVSTK();
7258 if (VARVUP(YPTR) == 1)
7259 BRANCH(FAIL)
7260 PUSH(YPTR);
7261 SAVSTK();
7262 if (ARGVAL(WPTR) == 1)
7263 BRANCH(FAIL)
7264 PUSH(WPTR);
7265 SAVSTK();
7266 if (VARVUP(ZPTR) == 1)
7267 BRANCH(FAIL)
7268 POP(WPTR);
7269 POP(YPTR);
7270 POP(XPTR);
7271 if (!DCMP(YPTR, NULVCL))
7272 goto L_TRAC5;
7273 D(YPTR) = D(VALTRS);
7274 L_TRAC5:
7275 if (!LOCAPV(YPTR,TRATL,YPTR))
7276 goto L_TRAC1;
7277 D(YPTR) = D(D_A(YPTR) + DESCR);
7278 BRANCH(TRACEP)
7279 /*_*/
7280 L_TRAC1:
7281 if (DCMP(YPTR, FUNTCL))
7282 goto L_TRACF;
7283 if (!DCMP(YPTR, EFFCL))
7284 BRANCH(INTR30)
7285 L_TRACF:
7286 D(YPTR) = D(TFNCLP);
7287 SAVSTK();
7288 switch (TRACEP(NORET)) {
7289 case 1:
7290 case 2:
7291 BRANCH(INTR10)
7292 }
7293 D(YPTR) = D(TFNRLP);
7294 BRANCH(TRACEP)
7295 /*_*/
7296 }
7297 static int
TRACEP(ret_t retval)7298 TRACEP(ret_t retval) {
7299 ENTRY(TRACEP)
7300 D(TPTR) = D(D_A(YPTR) + DESCR);
7301 if (DCMP(ZPTR, NULVCL))
7302 goto L_TRAC2;
7303 SAVSTK();
7304 PUSH(ZPTR);
7305 FINDEX(TPTR);
7306 L_TRAC2:
7307 D_A(XSIZ) = (int_t) (5*DESCR);
7308 D_V(XSIZ) = C;
7309 SAVSTK();
7310 PUSH(XSIZ);
7311 BLOCK(XCL);
7312 MOVBLK(D_A(XCL),D_A(TRCBLK),D_A(XSIZ));
7313 D_V(TPTR) = 2;
7314 D(D_A(XCL) + 1*DESCR) = D(TPTR);
7315 D(D_A(XCL) + 3*DESCR) = D(XPTR);
7316 D(D_A(XCL) + 5*DESCR) = D(WPTR);
7317 D(TPTR) = D(D_A(YPTR));
7318 if (D_A(TPTR) == 0)
7319 goto L_TRAC4;
7320 if (!LOCAPT(TPTR,TPTR,XPTR))
7321 goto L_TRAC3;
7322 D(D_A(TPTR) + 2*DESCR) = D(XCL);
7323 BRANCH(RETNUL)
7324 /*_*/
7325 L_TRAC3:
7326 SAVSTK();
7327 PUSH(XCL);
7328 PUSH(XPTR);
7329 PUSH(TPTR);
7330 AUGATL(TPTR);
7331 L_TRAC6:
7332 D(D_A(YPTR)) = D(TPTR);
7333 BRANCH(RETNUL)
7334 /*_*/
7335 L_TRAC4:
7336 SAVSTK();
7337 PUSH(TWOCL);
7338 BLOCK(TPTR);
7339 D(D_A(TPTR) + DESCR) = D(XPTR);
7340 D(D_A(TPTR) + 2*DESCR) = D(XCL);
7341 goto L_TRAC6;
7342 /*_*/
7343 }
7344 int
STOPTR(ret_t retval)7345 STOPTR(ret_t retval) {
7346 ENTRY(STOPTR)
7347 SAVSTK();
7348 if (IND(XPTR) == 1)
7349 BRANCH(FAIL)
7350 PUSH(XPTR);
7351 SAVSTK();
7352 if (VARVUP(YPTR) == 1)
7353 BRANCH(FAIL)
7354 POP(XPTR);
7355 if (!DCMP(YPTR, NULVCL))
7356 goto L_STOPT2;
7357 D(YPTR) = D(VALTRS);
7358 L_STOPT2:
7359 if (!LOCAPV(YPTR,TRATL,YPTR))
7360 goto L_STOPT1;
7361 D(YPTR) = D(D_A(YPTR) + DESCR);
7362 BRANCH(STOPTP)
7363 /*_*/
7364 L_STOPT1:
7365 if (DCMP(YPTR, FUNTCL))
7366 goto L_STOPTF;
7367 if (!DCMP(YPTR, EFFCL))
7368 BRANCH(INTR30)
7369 L_STOPTF:
7370 D(YPTR) = D(TFNCLP);
7371 SAVSTK();
7372 switch (STOPTP(NORET)) {
7373 case 1:
7374 BRANCH(FAIL)
7375 case 2:
7376 BRANCH(INTR10)
7377 }
7378 D(YPTR) = D(TFNRLP);
7379 BRANCH(STOPTP)
7380 /*_*/
7381 }
7382 static int
STOPTP(ret_t retval)7383 STOPTP(ret_t retval) {
7384 ENTRY(STOPTP)
7385 D(YPTR) = D(D_A(YPTR));
7386 if (!LOCAPT(YPTR,YPTR,XPTR))
7387 BRANCH(FAIL)
7388 D(D_A(YPTR) + DESCR) = D(ZEROCL);
7389 D(D_A(YPTR) + 2*DESCR) = D(ZEROCL);
7390 BRANCH(RETNUL)
7391 /*_*/
7392 }
7393 int
FENTR(ret_t retval)7394 FENTR(ret_t retval) {
7395 ENTRY(FENTR)
7396 SAVSTK();
7397 if (VARVAL(WPTR) == 1)
7398 BRANCH(FAIL)
7399 /* FALL */
7400 BRANCH(FENTR3)
7401 }
7402 static int
FENTR3(ret_t retval)7403 FENTR3(ret_t retval) {
7404 ENTRY(FENTR3)
7405 S_L(PROTSP) = 0;
7406 X_LOCSP(XSP,FILENM);
7407 APDSP(PROTSP,XSP);
7408 APDSP(PROTSP,COLSP);
7409 INTSPC(XSP,LNNOCL);
7410 APDSP(PROTSP,XSP);
7411 APDSP(PROTSP,TRSTSP);
7412 INTSPC(XSP,STNOCL);
7413 APDSP(PROTSP,XSP);
7414 APDSP(PROTSP,COLSP);
7415 APDSP(PROTSP,SPCSP);
7416 APDSP(PROTSP,TRLVSP);
7417 INTSPC(XSP,LVLCL);
7418 APDSP(PROTSP,XSP);
7419 APDSP(PROTSP,TRCLSP);
7420 X_LOCSP(XSP,WPTR);
7421 D_A(TCL) = S_L(XSP);
7422 D_F(TCL) = D_V(TCL) = 0;
7423 if (D_A(TCL) >= BUFLEN)
7424 BRANCH(FXOVR)
7425 APDSP(PROTSP,XSP);
7426 APDSP(PROTSP,LPRNSP);
7427 D_A(WCL) = 0;
7428 L_FNTRLP:
7429 D_A(WCL)++;
7430 SAVSTK();
7431 PUSH(WCL);
7432 PUSH(WPTR);
7433 switch (ARGINT(ZPTR)) {
7434 case 1:
7435 goto L_FENTR4;
7436 case 2:
7437 BRANCH(INTR10)
7438 }
7439 D(ZPTR) = D(D_A(ZPTR) + DESCR);
7440 if (D_V(ZPTR) == S)
7441 goto L_DEFTV;
7442 if (D_V(ZPTR) == I)
7443 goto L_DEFTI;
7444 SAVSTK();
7445 PUSH(ZPTR);
7446 DTREP(A2PTR);
7447 _SPEC(XSP) = _SPEC(D_A(A2PTR));
7448 D_A(SCL) = S_L(XSP);
7449 D_F(SCL) = D_V(SCL) = 0;
7450 D_A(TCL) += D_A(SCL);
7451 if (D_A(TCL) >= BUFLEN)
7452 BRANCH(FXOVR)
7453 L_DEFTIA:
7454 APDSP(PROTSP,XSP);
7455 goto L_DEFDTT;
7456 /*_*/
7457 L_DEFTI:
7458 INTSPC(XSP,ZPTR);
7459 goto L_DEFTIA;
7460 /*_*/
7461 L_DEFTV:
7462 X_LOCSP(XSP,ZPTR);
7463 D_A(SCL) = S_L(XSP);
7464 D_F(SCL) = D_V(SCL) = 0;
7465 D_A(TCL) += D_A(SCL);
7466 if (D_A(TCL) >= BUFLEN)
7467 BRANCH(FXOVR)
7468 APDSP(PROTSP,QTSP);
7469 APDSP(PROTSP,XSP);
7470 APDSP(PROTSP,QTSP);
7471 L_DEFDTT:
7472 APDSP(PROTSP,CMASP);
7473 goto L_FNTRLP;
7474 /*_*/
7475 L_FENTR4:
7476 if (D_A(WCL) == 1)
7477 goto L_FENTR5;
7478 S_L(PROTSP)--;
7479 L_FENTR5:
7480 APDSP(PROTSP,RPRNSP);
7481 D_RV(ZPTR) = mstime();
7482 D_F(ZPTR) = D_V(ZPTR) = 0;
7483 D_RV(ZPTR) -= D_RV(ETMCL);
7484 REALST(XSP,ZPTR);
7485 APDSP(PROTSP,ETIMSP);
7486 APDSP(PROTSP,XSP);
7487 IO_PRINT(IOKEY, OUTBLK, PROTSP);
7488 BRANCH(RTNUL3)
7489 /*_*/
7490 }
7491 static int
FENTR2(ret_t retval)7492 FENTR2(ret_t retval) {
7493 ENTRY(FENTR2)
7494 POP(WPTR);
7495 BRANCH(FENTR3)
7496 /*_*/
7497 }
7498 static int
FXOVR(ret_t retval)7499 FXOVR(ret_t retval) {
7500 ENTRY(FXOVR)
7501 io_printf(D_A(OUTPUT),PRTOVF);
7502 BRANCH(RTNUL3)
7503 /*_*/
7504 }
7505 int
KEYTR(ret_t retval)7506 KEYTR(ret_t retval) {
7507 ENTRY(KEYTR)
7508 D_A(FNVLCL) = 1;
7509 SAVSTK();
7510 if (VARVAL(WPTR) == 1)
7511 BRANCH(FAIL)
7512 X_LOCSP(XSP,WPTR);
7513 SAVSTK();
7514 PUSH(WPTR);
7515 switch (KEYT(YCL)) {
7516 case 1:
7517 BRANCH(INTR10)
7518 }
7519 /* FALL */
7520 BRANCH(KEYTR3)
7521 }
7522 static int
KEYTR3(ret_t retval)7523 KEYTR3(ret_t retval) {
7524 ENTRY(KEYTR3)
7525 S_L(PROTSP) = 0;
7526 X_LOCSP(TSP,FILENM);
7527 APDSP(PROTSP,TSP);
7528 APDSP(PROTSP,COLSP);
7529 INTSPC(TSP,LNNOCL);
7530 APDSP(PROTSP,TSP);
7531 APDSP(PROTSP,TRSTSP);
7532 INTSPC(TSP,STNOCL);
7533 APDSP(PROTSP,TSP);
7534 APDSP(PROTSP,COLSP);
7535 APDSP(PROTSP,SPCSP);
7536 if (D_A(FNVLCL) == 0)
7537 goto L_KEYTR4;
7538 APDSP(PROTSP,AMPSP);
7539 L_KEYTR4:
7540 APDSP(PROTSP,XSP);
7541 APDSP(PROTSP,BLSP);
7542 if (D_A(FNVLCL) == 0)
7543 goto L_KEYTR5;
7544 INTSPC(YSP,YCL);
7545 APDSP(PROTSP,EQLSP);
7546 L_KEYTR5:
7547 APDSP(PROTSP,YSP);
7548 D_RV(YPTR) = mstime();
7549 D_F(YPTR) = D_V(YPTR) = 0;
7550 D_RV(YPTR) -= D_RV(ETMCL);
7551 REALST(XSP,YPTR);
7552 APDSP(PROTSP,ETIMSP);
7553 APDSP(PROTSP,XSP);
7554 IO_PRINT(IOKEY, OUTBLK, PROTSP);
7555 BRANCH(RTN2)
7556 /*_*/
7557 }
7558 int
LABTR(ret_t retval)7559 LABTR(ret_t retval) {
7560 ENTRY(LABTR)
7561 D_A(FNVLCL) = 0;
7562 SAVSTK();
7563 if (VARVAL(YPTR) == 1)
7564 BRANCH(FAIL)
7565 X_LOCSP(YSP,YPTR);
7566 _SPEC(XSP) = _SPEC(XFERSP);
7567 BRANCH(KEYTR3)
7568 /*_*/
7569 }
7570 static int
TRPHND(ret_t retval)7571 TRPHND(ret_t retval) {
7572 ENTRY(TRPHND)
7573 POP(ATPTR);
7574 D_A(TRAPCL)--;
7575 PUSH(FILENM);
7576 PUSH(LNNOCL);
7577 PUSH(LSTNCL);
7578 PUSH(STNOCL);
7579 PUSH(FRTNCL);
7580 PUSH(OCBSCL);
7581 PUSH(OCICL);
7582 PUSH(TRAPCL);
7583 PUSH(TRACL);
7584 PUSH(LSFLNM);
7585 PUSH(LSLNCL);
7586 D(OCBSCL) = D(D_A(ATPTR) + 2*DESCR);
7587 D_A(OCICL) = (int_t) DESCR;
7588 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
7589 D_A(TRAPCL) = 0;
7590 D_A(TRACL) = 0;
7591 SAVSTK();
7592 PUSH(XPTR);
7593 INVOKE(NORET);
7594 POP(LSLNCL);
7595 POP(LSFLNM);
7596 POP(TRACL);
7597 POP(TRAPCL);
7598 POP(OCICL);
7599 POP(OCBSCL);
7600 POP(FRTNCL);
7601 POP(STNOCL);
7602 POP(LSTNCL);
7603 POP(LNNOCL);
7604 POP(FILENM);
7605 BRANCH(RTN1)
7606 /*_*/
7607 }
7608 int
VALTR(ret_t retval)7609 VALTR(ret_t retval) {
7610 ENTRY(VALTR)
7611 D_A(FNVLCL) = 1;
7612 /* FALL */
7613 BRANCH(VALTR2)
7614 }
7615 static int
VALTR2(ret_t retval)7616 VALTR2(ret_t retval) {
7617 ENTRY(VALTR2)
7618 SAVSTK();
7619 if (IND(XPTR) == 1)
7620 BRANCH(FAIL)
7621 PUSH(XPTR);
7622 SAVSTK();
7623 if (VARVAL(ZPTR) == 1)
7624 BRANCH(FAIL)
7625 POP(XPTR);
7626 /* FALL */
7627 BRANCH(VALTR4)
7628 }
7629 static int
VALTR4(ret_t retval)7630 VALTR4(ret_t retval) {
7631 ENTRY(VALTR4)
7632 S_L(TRACSP) = 0;
7633 X_LOCSP(XSP,FILENM);
7634 APDSP(TRACSP,XSP);
7635 APDSP(TRACSP,COLSP);
7636 INTSPC(XSP,LNNOCL);
7637 APDSP(TRACSP,XSP);
7638 APDSP(TRACSP,TRSTSP);
7639 INTSPC(XSP,STNOCL);
7640 APDSP(TRACSP,XSP);
7641 APDSP(TRACSP,COLSP);
7642 APDSP(TRACSP,SPCSP);
7643 if (D_A(FNVLCL) == 0)
7644 BRANCH(FNEXT1)
7645 if (D_V(XPTR) != S)
7646 BRANCH(DEFDT)
7647 /* FALL */
7648 BRANCH(VALTR3)
7649 }
7650 static int
VALTR3(ret_t retval)7651 VALTR3(ret_t retval) {
7652 ENTRY(VALTR3)
7653 X_LOCSP(XSP,XPTR);
7654 D_A(TCL) = S_L(XSP);
7655 D_F(TCL) = D_V(TCL) = 0;
7656 if (D_A(TCL) >= BUFLEN)
7657 BRANCH(VXOVR)
7658 /* FALL */
7659 BRANCH(VALTR1)
7660 }
7661 static int
VALTR1(ret_t retval)7662 VALTR1(ret_t retval) {
7663 ENTRY(VALTR1)
7664 APDSP(TRACSP,XSP);
7665 APDSP(TRACSP,BLEQSP);
7666 D(YPTR) = D(D_A(XPTR) + DESCR);
7667 if (D_V(YPTR) == S)
7668 BRANCH(TRV)
7669 if (D_V(YPTR) == I)
7670 BRANCH(TRI)
7671 SAVSTK();
7672 PUSH(YPTR);
7673 DTREP(XPTR);
7674 _SPEC(XSP) = _SPEC(D_A(XPTR));
7675 /* FALL */
7676 BRANCH(TRI2)
7677 }
7678 static int
TRI2(ret_t retval)7679 TRI2(ret_t retval) {
7680 ENTRY(TRI2)
7681 APDSP(TRACSP,XSP);
7682 BRANCH(TRPRT)
7683 /*_*/
7684 }
7685 static int
TRV(ret_t retval)7686 TRV(ret_t retval) {
7687 ENTRY(TRV)
7688 X_LOCSP(XSP,YPTR);
7689 D_A(SCL) = S_L(XSP);
7690 D_F(SCL) = D_V(SCL) = 0;
7691 D_A(TCL) += D_A(SCL);
7692 if (D_A(TCL) >= BUFLEN)
7693 BRANCH(VXOVR)
7694 APDSP(TRACSP,QTSP);
7695 APDSP(TRACSP,XSP);
7696 APDSP(TRACSP,QTSP);
7697 /* FALL */
7698 BRANCH(TRPRT)
7699 }
7700 static int
TRPRT(ret_t retval)7701 TRPRT(ret_t retval) {
7702 ENTRY(TRPRT)
7703 D_RV(YPTR) = mstime();
7704 D_F(YPTR) = D_V(YPTR) = 0;
7705 D_RV(YPTR) -= D_RV(ETMCL);
7706 REALST(XSP,YPTR);
7707 APDSP(TRACSP,ETIMSP);
7708 APDSP(TRACSP,XSP);
7709 IO_PRINT(IOKEY, OUTBLK, TRACSP);
7710 BRANCH(RTNUL3)
7711 /*_*/
7712 }
7713 static int
TRI(ret_t retval)7714 TRI(ret_t retval) {
7715 ENTRY(TRI)
7716 INTSPC(XSP,YPTR);
7717 BRANCH(TRI2)
7718 /*_*/
7719 }
7720 static int
DEFDT(ret_t retval)7721 DEFDT(ret_t retval) {
7722 ENTRY(DEFDT)
7723 X_LOCSP(XSP,ZPTR);
7724 BRANCH(VALTR1)
7725 /*_*/
7726 }
7727 int
FNEXTR(ret_t retval)7728 FNEXTR(ret_t retval) {
7729 ENTRY(FNEXTR)
7730 D_A(FNVLCL) = 0;
7731 BRANCH(VALTR2)
7732 /*_*/
7733 }
7734 static int
FNEXT1(ret_t retval)7735 FNEXT1(ret_t retval) {
7736 ENTRY(FNEXT1)
7737 APDSP(TRACSP,TRLVSP);
7738 D(XCL) = D(LVLCL);
7739 D_A(XCL)--;
7740 INTSPC(XSP,XCL);
7741 APDSP(TRACSP,XSP);
7742 APDSP(TRACSP,BLSP);
7743 X_LOCSP(XSP,RETPCL);
7744 APDSP(TRACSP,XSP);
7745 APDSP(TRACSP,OFSP);
7746 if (!DCMP(RETPCL, FRETCL))
7747 BRANCH(VALTR3)
7748 X_LOCSP(XSP,XPTR);
7749 D_A(TCL) = S_L(XSP);
7750 D_F(TCL) = D_V(TCL) = 0;
7751 if (D_A(TCL) >= BUFLEN)
7752 BRANCH(VXOVR)
7753 APDSP(TRACSP,XSP);
7754 BRANCH(TRPRT)
7755 /*_*/
7756 }
7757 static int
FNEXT2(ret_t retval)7758 FNEXT2(ret_t retval) {
7759 ENTRY(FNEXT2)
7760 D_A(FNVLCL) = 0;
7761 POP(XPTR);
7762 BRANCH(VALTR4)
7763 /*_*/
7764 }
7765 static int
VXOVR(ret_t retval)7766 VXOVR(ret_t retval) {
7767 ENTRY(VXOVR)
7768 io_printf(D_A(OUTPUT),PRTOVF);
7769 BRANCH(RTNUL3)
7770 /*_*/
7771 }
7772 int
SETXIT(ret_t retval)7773 SETXIT(ret_t retval) {
7774 ENTRY(SETXIT)
7775 SAVSTK();
7776 if (VARVUP(XPTR) == 1)
7777 BRANCH(INTR30)
7778 if (D_A(XPTR) == 0)
7779 goto L_SETXI2;
7780 D(YPTR) = D(D_A(XPTR) + ATTRIB);
7781 if (D_A(YPTR) == 0)
7782 BRANCH(INTR30)
7783 L_SETXI2:
7784 D(YPTR) = D(XITPTR);
7785 D(XITPTR) = D(XPTR);
7786 BRANCH(RTYPTR)
7787 /*_*/
7788 }
7789 static int
XITHND(ret_t retval)7790 XITHND(ret_t retval) {
7791 ENTRY(XITHND)
7792 if (D_A(XITPTR) == 0)
7793 BRANCH(FAIL)
7794 D(XFILEN) = D(FILENM);
7795 D(XLNNOC) = D(LNNOCL);
7796 D(XSTNOC) = D(STNOCL);
7797 D(XLSFLN) = D(LSFLNM);
7798 D(XLSLNC) = D(LSLNCL);
7799 D(XLNNOC) = D(LNNOCL);
7800 D(XERRTY) = D(ERRTYP);
7801 D(XOCBSC) = D(OCBSCL);
7802 D(XFRTNC) = D(FRTNCL);
7803 D(XOCICL) = D(OCICL);
7804 D(OCBSCL) = D(D_A(XITPTR) + ATTRIB);
7805 if (D_A(OCBSCL) == 0)
7806 BRANCH(INTR4)
7807 D_A(FRTNCL) = 0;
7808 D_A(XITPTR) = 0;
7809 D(LSTNCL) = D(STNOCL);
7810 D_A(LSLNCL) = D_A(LNNOCL);
7811 D_A(LSFLNM) = D_A(FILENM);
7812 BRANCH(RETNUL)
7813 /*_*/
7814 }
7815 int
ASGN(ret_t retval)7816 ASGN(ret_t retval) {
7817 ENTRY(ASGN)
7818 D_A(OCICL) += DESCR;
7819 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
7820 if ((D_F(XPTR) & FNC))
7821 goto L_ASGNC;
7822 L_ASGNV:
7823 if (D_V(XPTR) == K)
7824 goto L_ASGNIC;
7825 D_A(OCICL) += DESCR;
7826 D(YPTR) = D(D_A(OCBSCL) + D_A(OCICL));
7827 if ((D_F(YPTR) & FNC))
7828 goto L_ASGNCV;
7829 L_ASGNVN:
7830 if (D_A(INSW) == 0)
7831 goto L_ASGNV1;
7832 if (!LOCAPV(ZPTR,INATL,YPTR))
7833 goto L_ASGNV1;
7834 D(ZPTR) = D(D_A(ZPTR) + DESCR);
7835 SAVSTK();
7836 PUSH(YPTR);
7837 PUSH(ZPTR);
7838 switch (PUTIN(YPTR)) {
7839 case 1:
7840 BRANCH(FAIL)
7841 case 2:
7842 goto L_ASGNVV;
7843 }
7844 /*_*/
7845 L_ASGNV1:
7846 D(YPTR) = D(D_A(YPTR) + DESCR);
7847 L_ASGNVV:
7848 D(D_A(XPTR) + DESCR) = D(YPTR);
7849 if (D_A(OUTSW) == 0)
7850 goto L_ASGN1;
7851 if (!LOCAPV(ZPTR,OUTATL,XPTR))
7852 goto L_ASGN1;
7853 D(ZPTR) = D(D_A(ZPTR) + DESCR);
7854 SAVSTK();
7855 PUSH(YPTR);
7856 PUSH(ZPTR);
7857 PUTOUT(NORET);
7858 L_ASGN1:
7859 if (D_A(TRAPCL) <= 0)
7860 BRANCH(RTYPTR)
7861 if (!LOCAPT(ATPTR,TVALL,XPTR))
7862 BRANCH(RTYPTR)
7863 PUSH(YPTR);
7864 SAVSTK();
7865 PUSH(ATPTR);
7866 TRPHND(NORET);
7867 POP(YPTR);
7868 BRANCH(RTYPTR)
7869 /*_*/
7870 L_ASGNC:
7871 SAVSTK();
7872 PUSH(XPTR);
7873 switch (INVOKE(XPTR)) {
7874 case 1:
7875 BRANCH(FAIL)
7876 case 2:
7877 goto L_ASGNV;
7878 case 3:
7879 BRANCH(NEMO)
7880 }
7881 /*_*/
7882 L_ASGNCV:
7883 PUSH(XPTR);
7884 SAVSTK();
7885 PUSH(YPTR);
7886 switch (INVOKE(YPTR)) {
7887 case 1:
7888 BRANCH(FAIL)
7889 case 2:
7890 goto L_ASGNVP;
7891 }
7892 L_ASGNCJ:
7893 POP(XPTR);
7894 goto L_ASGNVV;
7895 /*_*/
7896 L_ASGNVP:
7897 POP(XPTR);
7898 goto L_ASGNVN;
7899 /*_*/
7900 L_ASGNIC:
7901 PUSH(XPTR);
7902 SAVSTK();
7903 switch (INTVAL(YPTR)) {
7904 case 1:
7905 BRANCH(FAIL)
7906 case 2:
7907 goto L_ASGNCJ;
7908 }
7909 /*_*/
7910 }
7911 int
CONCAT(ret_t retval)7912 CONCAT(ret_t retval) {
7913 ENTRY(CONCAT)
7914 SAVSTK();
7915 if (XYARGS(NORET) == 1)
7916 BRANCH(FAIL)
7917 if (DCMP(XPTR, NULVCL))
7918 BRANCH(RTYPTR)
7919 if (DCMP(YPTR, NULVCL))
7920 BRANCH(RTXPTR)
7921 if (D_V(XPTR) == S)
7922 goto L_CON5;
7923 if (D_V(XPTR) == P)
7924 goto L_CON5;
7925 if (D_V(XPTR) == I)
7926 goto L_CON4I;
7927 if (D_V(XPTR) == R)
7928 goto L_CON4R;
7929 if (D_V(XPTR) == BL)
7930 goto L_CON5;
7931 if (D_V(XPTR) != E)
7932 BRANCH(INTR1)
7933 SAVSTK();
7934 PUSH(STARSZ);
7935 BLOCK(TPTR);
7936 MOVBLK(D_A(TPTR),D_A(STRPAT),D_A(STARSZ));
7937 D(D_A(TPTR) + 4*DESCR) = D(XPTR);
7938 D(XPTR) = D(TPTR);
7939 goto L_CON5;
7940 /*_*/
7941 L_CON4R:
7942 REALST(REALSP,XPTR);
7943 _SPEC(XSP) = _SPEC(REALSP);
7944 SAVSTK();
7945 PUSH(XSPPTR);
7946 if (GENVAR(XPTR) == 1)
7947 goto L_CON5;
7948 /*_*/
7949 L_CON4I:
7950 INTSPC(ZSP,XPTR);
7951 SAVSTK();
7952 PUSH(ZSPPTR);
7953 GENVAR(XPTR);
7954 L_CON5:
7955 if (D_V(YPTR) == S)
7956 goto L_CON7;
7957 if (D_V(YPTR) == P)
7958 goto L_CON7;
7959 if (D_V(YPTR) == I)
7960 goto L_CON5I;
7961 if (D_V(YPTR) == R)
7962 goto L_CON5R;
7963 if (D_V(YPTR) == BL)
7964 goto L_CON7;
7965 if (D_V(YPTR) != E)
7966 BRANCH(INTR1)
7967 SAVSTK();
7968 PUSH(STARSZ);
7969 BLOCK(TPTR);
7970 MOVBLK(D_A(TPTR),D_A(STRPAT),D_A(STARSZ));
7971 D(D_A(TPTR) + 4*DESCR) = D(YPTR);
7972 D(YPTR) = D(TPTR);
7973 goto L_CON7;
7974 /*_*/
7975 L_CON5R:
7976 REALST(REALSP,YPTR);
7977 _SPEC(YSP) = _SPEC(REALSP);
7978 SAVSTK();
7979 PUSH(YSPPTR);
7980 if (GENVAR(YPTR) == 1)
7981 goto L_CON7;
7982 /*_*/
7983 L_CON5I:
7984 INTSPC(ZSP,YPTR);
7985 SAVSTK();
7986 PUSH(ZSPPTR);
7987 GENVAR(YPTR);
7988 L_CON7:
7989 D_A(DTCL) = D_V(XPTR);
7990 D_F(DTCL) = D_V(DTCL) = 0;
7991 D_V(DTCL) = D_V(YPTR);
7992 if (DCMP(DTCL, VVDTP))
7993 BRANCH(CONVV)
7994 if (DCMP(DTCL, VPDTP))
7995 goto L_CONVP;
7996 if (DCMP(DTCL, PVDTP))
7997 goto L_CONPV;
7998 if (DCMP(DTCL, PPDTP))
7999 goto L_CONPP;
8000 else
8001 BRANCH(CCATB)
8002 /*_*/
8003 L_CONVP:
8004 X_LOCSP(TSP,XPTR);
8005 D_A(TMVAL) = S_L(TSP);
8006 D_F(TMVAL) = D_V(TMVAL) = 0;
8007 SAVSTK();
8008 PUSH(LNODSZ);
8009 BLOCK(TPTR);
8010 MAKNOD(XPTR,TPTR,TMVAL,ZEROCL,CHRCL,XPTR);
8011 L_CONPP:
8012 D_A(XSIZ) = D_V(D_A(XPTR));
8013 D_F(XSIZ) = D_V(XSIZ) = 0;
8014 D_A(YSIZ) = D_V(D_A(YPTR));
8015 D_F(YSIZ) = D_V(YSIZ) = 0;
8016 D(TSIZ) = D(XSIZ);
8017 D_A(TSIZ) += D_A(YSIZ);
8018 D_V(TSIZ) = P;
8019 SAVSTK();
8020 PUSH(TSIZ);
8021 BLOCK(TPTR);
8022 D(ZPTR) = D(TPTR);
8023 LVALUE(TVAL,YPTR);
8024 CPYPAT(TPTR,XPTR,TVAL,ZEROCL,XSIZ,XSIZ);
8025 CPYPAT(TPTR,YPTR,ZEROCL,XSIZ,ZEROCL,YSIZ);
8026 BRANCH(RTZPTR)
8027 /*_*/
8028 L_CONPV:
8029 X_LOCSP(TSP,YPTR);
8030 D_A(TMVAL) = S_L(TSP);
8031 D_F(TMVAL) = D_V(TMVAL) = 0;
8032 SAVSTK();
8033 PUSH(LNODSZ);
8034 BLOCK(TPTR);
8035 MAKNOD(YPTR,TPTR,TMVAL,ZEROCL,CHRCL,YPTR);
8036 goto L_CONPP;
8037 /*_*/
8038 }
8039 static int
CONVV(ret_t retval)8040 CONVV(ret_t retval) {
8041 ENTRY(CONVV)
8042 X_LOCSP(XSP,XPTR);
8043 X_LOCSP(YSP,YPTR);
8044 D_A(XCL) = S_L(XSP);
8045 D_F(XCL) = D_V(XCL) = 0;
8046 D_A(YCL) = S_L(YSP);
8047 D_F(YCL) = D_V(YCL) = 0;
8048 D_A(XCL) += D_A(YCL);
8049 if (D_A(XCL) > D_A(MLENCL))
8050 BRANCH(INTR8)
8051 SAVSTK();
8052 PUSH(XCL);
8053 CONVAR(ZPTR);
8054 X_LOCSP(TSP,ZPTR);
8055 S_L(TSP) = 0;
8056 APDSP(TSP,XSP);
8057 APDSP(TSP,YSP);
8058 BRANCH(GENVSZ)
8059 /*_*/
8060 }
8061 int
IND(ret_t retval)8062 IND(ret_t retval) {
8063 ENTRY(IND)
8064 SAVSTK();
8065 if (ARGVAL(XPTR) == 1)
8066 BRANCH(FAIL)
8067 if (D_V(XPTR) == S)
8068 goto L_INDV;
8069 if (D_V(XPTR) == N)
8070 BRANCH(RTXNAM)
8071 if (D_V(XPTR) == I)
8072 BRANCH(GENVIX)
8073 if (D_V(XPTR) == K)
8074 BRANCH(RTXNAM)
8075 else
8076 BRANCH(INTR1)
8077 /*_*/
8078 L_INDV:
8079 if (D_A(XPTR) == 0)
8080 BRANCH(NONAME)
8081 if (D_A(CASECL) == 0)
8082 BRANCH(RTXNAM)
8083 else
8084 BRANCH(VPXPTR)
8085 /*_*/
8086 }
8087 int
KEYWRD(ret_t retval)8088 KEYWRD(ret_t retval) {
8089 ENTRY(KEYWRD)
8090 D_A(OCICL) += DESCR;
8091 D(XPTR) = D(D_A(OCBSCL) + D_A(OCICL));
8092 if ((D_F(XPTR) & FNC))
8093 BRANCH(KEYC)
8094 /* FALL */
8095 BRANCH(KEYN)
8096 }
8097 static int
KEYN(ret_t retval)8098 KEYN(ret_t retval) {
8099 ENTRY(KEYN)
8100 if (!LOCAPV(XPTR,KNATL,XPTR))
8101 goto L_KEYV;
8102 D(YPTR) = D(D_A(XPTR) + DESCR);
8103 if (D_V(YPTR) == I)
8104 goto L_KEYN1;
8105 D_V(XPTR) = N;
8106 BRANCH(RTXNAM)
8107 L_KEYN1:
8108 D_V(XPTR) = K;
8109 BRANCH(RTXNAM)
8110 /*_*/
8111 L_KEYV:
8112 if (!LOCAPV(ATPTR,KVATL,XPTR))
8113 BRANCH(UNKNKW)
8114 D(ZPTR) = D(D_A(ATPTR) + DESCR);
8115 BRANCH(RTZPTR)
8116 /*_*/
8117 }
8118 static int
KEYC(ret_t retval)8119 KEYC(ret_t retval) {
8120 ENTRY(KEYC)
8121 SAVSTK();
8122 PUSH(XPTR);
8123 switch (INVOKE(XPTR)) {
8124 case 1:
8125 BRANCH(FAIL)
8126 case 2:
8127 BRANCH(KEYN)
8128 case 3:
8129 BRANCH(NEMO)
8130 }
8131 /*_*/
8132 }
8133 static int
KEYT(ret_t retval)8134 KEYT(ret_t retval) {
8135 ENTRY(KEYT)
8136 POP(XPTR);
8137 BRANCH(KEYN)
8138 /*_*/
8139 }
8140 int
LIT(ret_t retval)8141 LIT(ret_t retval) {
8142 ENTRY(LIT)
8143 D_A(OCICL) += DESCR;
8144 D(ZPTR) = D(D_A(OCBSCL) + D_A(OCICL));
8145 BRANCH(RTZPTR)
8146 /*_*/
8147 }
8148 int
NAME(ret_t retval)8149 NAME(ret_t retval) {
8150 ENTRY(NAME)
8151 D_A(OCICL) += DESCR;
8152 D(ZPTR) = D(D_A(OCBSCL) + D_A(OCICL));
8153 if (!(D_F(ZPTR) & FNC))
8154 BRANCH(RTZPTR)
8155 SAVSTK();
8156 PUSH(ZPTR);
8157 switch (INVOKE(ZPTR)) {
8158 case 1:
8159 BRANCH(FAIL)
8160 case 2:
8161 BRANCH(RTZPTR)
8162 case 3:
8163 BRANCH(NEMO)
8164 }
8165 /*_*/
8166 }
8167 static int
NMD(ret_t retval)8168 NMD(ret_t retval) {
8169 ENTRY(NMD)
8170 D(TCL) = D(NHEDCL);
8171 L_NMD1:
8172 if (D_A(TCL) == D_A(NAMICL))
8173 BRANCH(RTN2)
8174 if (D_A(TCL) > D_A(NAMICL))
8175 BRANCH(INTR13)
8176 D(TPTR) = D(NBSPTR);
8177 D_A(TPTR) += D_A(TCL);
8178 _SPEC(TSP) = _SPEC(D_A(TPTR) + DESCR);
8179 D(TVAL) = D(D_A(TPTR) + DESCR+SPEC);
8180 D_A(XCL) = S_L(TSP);
8181 D_F(XCL) = D_V(XCL) = 0;
8182 if (D_A(XCL) > D_A(MLENCL))
8183 BRANCH(INTR8)
8184 if (D_V(TVAL) == E)
8185 goto L_NAMEXN;
8186 L_NMD5:
8187 if (D_V(TVAL) == K)
8188 goto L_NMDIC;
8189 SAVSTK();
8190 PUSH(TSPPTR);
8191 GENVAR(VVAL);
8192 L_NMD4:
8193 D(D_A(TVAL) + DESCR) = D(VVAL);
8194 if (D_A(OUTSW) == 0)
8195 goto L_NMD3;
8196 if (!LOCAPV(ZPTR,OUTATL,TVAL))
8197 goto L_NMD3;
8198 D(ZPTR) = D(D_A(ZPTR) + DESCR);
8199 SAVSTK();
8200 PUSH(VVAL);
8201 PUSH(ZPTR);
8202 PUTOUT(NORET);
8203 L_NMD3:
8204 if (D_A(TRAPCL) <= 0)
8205 goto L_NMD2;
8206 if (!LOCAPT(ATPTR,TVALL,TVAL))
8207 goto L_NMD2;
8208 PUSH(TCL);
8209 PUSH(NAMICL);
8210 PUSH(NHEDCL);
8211 D(NHEDCL) = D(NAMICL);
8212 SAVSTK();
8213 PUSH(ATPTR);
8214 TRPHND(NORET);
8215 POP(NHEDCL);
8216 POP(NAMICL);
8217 POP(TCL);
8218 L_NMD2:
8219 D_A(TCL) += DESCR+SPEC;
8220 goto L_NMD1;
8221 /*_*/
8222 L_NMDIC:
8223 if (SPCINT(VVAL,TSP))
8224 goto L_NMD4;
8225 else
8226 BRANCH(INTR1)
8227 /*_*/
8228 L_NAMEXN:
8229 SAVSTK();
8230 PUSH(TVAL);
8231 switch (EXPEVL(TVAL)) {
8232 case 1:
8233 BRANCH(FAIL)
8234 case 2:
8235 goto L_NMD5;
8236 case 3:
8237 BRANCH(NEMO)
8238 }
8239 /*_*/
8240 }
8241 int
STR(ret_t retval)8242 STR(ret_t retval) {
8243 ENTRY(STR)
8244 D(ZPTR) = D(OCBSCL);
8245 D_A(ZPTR) += D_A(OCICL);
8246 SAVSTK();
8247 PUSH(ONECL);
8248 CODSKP(NORET);
8249 D_V(ZPTR) = E;
8250 BRANCH(RTZPTR)
8251 /*_*/
8252 }
8253 int
DIFFER(ret_t retval)8254 DIFFER(ret_t retval) {
8255 ENTRY(DIFFER)
8256 SAVSTK();
8257 if (XYARGS(NORET) == 1)
8258 BRANCH(FAIL)
8259 if (DCMP(XPTR, YPTR))
8260 BRANCH(FAIL)
8261 else
8262 BRANCH(RETNUL)
8263 /*_*/
8264 }
8265 int
FUNCTN(ret_t retval)8266 FUNCTN(ret_t retval) {
8267 ENTRY(FUNCTN)
8268 SAVSTK();
8269 if (VARVUP(XPTR) == 1)
8270 BRANCH(FAIL)
8271 if (!LOCAPV(XPTR,FNCPL,XPTR))
8272 BRANCH(FAIL)
8273 D(XPTR) = D(D_A(XPTR) + DESCR);
8274 D(XPTR) = D(D_A(XPTR));
8275 if (D_A(XPTR) == D_A(UNDFCL))
8276 BRANCH(FAIL)
8277 else
8278 BRANCH(RETNUL)
8279 /*_*/
8280 }
8281 int
IDENT(ret_t retval)8282 IDENT(ret_t retval) {
8283 ENTRY(IDENT)
8284 SAVSTK();
8285 if (XYARGS(NORET) == 1)
8286 BRANCH(FAIL)
8287 if (DCMP(XPTR, YPTR))
8288 BRANCH(RETNUL)
8289 else
8290 BRANCH(FAIL)
8291 /*_*/
8292 }
8293 int
LABEL(ret_t retval)8294 LABEL(ret_t retval) {
8295 ENTRY(LABEL)
8296 SAVSTK();
8297 if (VARVUP(NORET) == 1)
8298 BRANCH(FAIL)
8299 if (D_A(XPTR) == 0)
8300 BRANCH(FAIL)
8301 D(XPTR) = D(D_A(XPTR) + ATTRIB);
8302 if (D_A(XPTR) == 0)
8303 BRANCH(FAIL)
8304 else
8305 BRANCH(RETNUL)
8306 /*_*/
8307 }
8308 int
LABELC(ret_t retval)8309 LABELC(ret_t retval) {
8310 ENTRY(LABELC)
8311 SAVSTK();
8312 if (VARVUP(NORET) == 1)
8313 BRANCH(FAIL)
8314 if (D_A(XPTR) == 0)
8315 BRANCH(FAIL)
8316 D(XPTR) = D(D_A(XPTR) + ATTRIB);
8317 if (D_A(XPTR) == 0)
8318 BRANCH(FAIL)
8319 else
8320 BRANCH(RTXPTR)
8321 /*_*/
8322 }
8323 int
LEQ(ret_t retval)8324 LEQ(ret_t retval) {
8325 ENTRY(LEQ)
8326 SAVSTK();
8327 if (VARVAL(XPTR) == 1)
8328 BRANCH(FAIL)
8329 PUSH(XPTR);
8330 SAVSTK();
8331 if (VARVAL(YPTR) == 1)
8332 BRANCH(FAIL)
8333 POP(XPTR);
8334 if (DCMP(XPTR, YPTR))
8335 BRANCH(RETNUL)
8336 else
8337 BRANCH(FAIL)
8338 /*_*/
8339 }
8340 int
LGE(ret_t retval)8341 LGE(ret_t retval) {
8342 ENTRY(LGE)
8343 SAVSTK();
8344 if (VARVAL(XPTR) == 1)
8345 BRANCH(FAIL)
8346 PUSH(XPTR);
8347 SAVSTK();
8348 if (VARVAL(YPTR) == 1)
8349 BRANCH(FAIL)
8350 POP(XPTR);
8351 if (DCMP(XPTR, YPTR))
8352 BRANCH(RETNUL)
8353 if (D_A(XPTR) == 0)
8354 BRANCH(FAIL)
8355 if (D_A(YPTR) == 0)
8356 BRANCH(RETNUL)
8357 X_LOCSP(XSP,XPTR);
8358 X_LOCSP(YSP,YPTR);
8359 if (LEXCMP(XSP,YSP) < 0)
8360 BRANCH(FAIL)
8361 else
8362 BRANCH(RETNUL)
8363 /*_*/
8364 }
8365 int
LGT(ret_t retval)8366 LGT(ret_t retval) {
8367 ENTRY(LGT)
8368 SAVSTK();
8369 if (VARVAL(XPTR) == 1)
8370 BRANCH(FAIL)
8371 PUSH(XPTR);
8372 SAVSTK();
8373 if (VARVAL(YPTR) == 1)
8374 BRANCH(FAIL)
8375 POP(XPTR);
8376 if (DCMP(XPTR, YPTR))
8377 BRANCH(FAIL)
8378 if (D_A(XPTR) == 0)
8379 BRANCH(FAIL)
8380 if (D_A(YPTR) == 0)
8381 BRANCH(RETNUL)
8382 X_LOCSP(XSP,XPTR);
8383 X_LOCSP(YSP,YPTR);
8384 if (LEXCMP(XSP,YSP) <= 0)
8385 BRANCH(FAIL)
8386 else
8387 BRANCH(RETNUL)
8388 /*_*/
8389 }
8390 int
LLE(ret_t retval)8391 LLE(ret_t retval) {
8392 ENTRY(LLE)
8393 SAVSTK();
8394 if (VARVAL(XPTR) == 1)
8395 BRANCH(FAIL)
8396 PUSH(XPTR);
8397 SAVSTK();
8398 if (VARVAL(YPTR) == 1)
8399 BRANCH(FAIL)
8400 POP(XPTR);
8401 if (DCMP(XPTR, YPTR))
8402 BRANCH(RETNUL)
8403 if (D_A(XPTR) == 0)
8404 BRANCH(RETNUL)
8405 if (D_A(YPTR) == 0)
8406 BRANCH(FAIL)
8407 X_LOCSP(XSP,XPTR);
8408 X_LOCSP(YSP,YPTR);
8409 if (LEXCMP(XSP,YSP) <= 0)
8410 BRANCH(RETNUL)
8411 else
8412 BRANCH(FAIL)
8413 /*_*/
8414 }
8415 int
LLT(ret_t retval)8416 LLT(ret_t retval) {
8417 ENTRY(LLT)
8418 SAVSTK();
8419 if (VARVAL(XPTR) == 1)
8420 BRANCH(FAIL)
8421 PUSH(XPTR);
8422 SAVSTK();
8423 if (VARVAL(YPTR) == 1)
8424 BRANCH(FAIL)
8425 POP(XPTR);
8426 if (DCMP(XPTR, YPTR))
8427 BRANCH(FAIL)
8428 if (D_A(XPTR) == 0)
8429 BRANCH(RETNUL)
8430 if (D_A(YPTR) == 0)
8431 BRANCH(FAIL)
8432 X_LOCSP(XSP,XPTR);
8433 X_LOCSP(YSP,YPTR);
8434 if (LEXCMP(XSP,YSP) < 0)
8435 BRANCH(RETNUL)
8436 else
8437 BRANCH(FAIL)
8438 /*_*/
8439 }
8440 int
LNE(ret_t retval)8441 LNE(ret_t retval) {
8442 ENTRY(LNE)
8443 SAVSTK();
8444 if (VARVAL(XPTR) == 1)
8445 BRANCH(FAIL)
8446 PUSH(XPTR);
8447 SAVSTK();
8448 if (VARVAL(YPTR) == 1)
8449 BRANCH(FAIL)
8450 POP(XPTR);
8451 if (DCMP(XPTR, YPTR))
8452 BRANCH(FAIL)
8453 else
8454 BRANCH(RETNUL)
8455 /*_*/
8456 }
8457 int
NEG(ret_t retval)8458 NEG(ret_t retval) {
8459 ENTRY(NEG)
8460 PUSH(OCBSCL);
8461 PUSH(OCICL);
8462 SAVSTK();
8463 switch (ARGVAL(NORET)) {
8464 case 2:
8465 BRANCH(FAIL)
8466 }
8467 POP(OCICL);
8468 POP(OCBSCL);
8469 SAVSTK();
8470 PUSH(ONECL);
8471 if (CODSKP(NORET) == 1)
8472 BRANCH(RETNUL)
8473 /*_*/
8474 }
8475 int
QUES(ret_t retval)8476 QUES(ret_t retval) {
8477 ENTRY(QUES)
8478 SAVSTK();
8479 switch (ARGVAL(NORET)) {
8480 case 1:
8481 BRANCH(FAIL)
8482 case 2:
8483 BRANCH(RETNUL)
8484 }
8485 /*_*/
8486 }
8487 int
CHAR(ret_t retval)8488 CHAR(ret_t retval) {
8489 ENTRY(CHAR)
8490 SAVSTK();
8491 if (INTVAL(XCL) == 1)
8492 BRANCH(FAIL)
8493 if (D_A(XCL) < 0)
8494 BRANCH(LENERR)
8495 if (D_A(XCL) >= 256)
8496 BRANCH(INTR30)
8497 SAVSTK();
8498 PUSH(ONECL);
8499 CONVAR(XPTR);
8500 X_LOCSP(XSP,XPTR);
8501 {
8502 *S_SP(XSP) = D_A(XCL); /* Store argument as char */
8503 }
8504 SAVSTK();
8505 PUSH(ONECL);
8506 GNVARS(XPTR);
8507 BRANCH(RTXPTR)
8508 /*_*/
8509 }
8510 int
LPAD(ret_t retval)8511 LPAD(ret_t retval) {
8512 ENTRY(LPAD)
8513 D_A(SCL) = 0;
8514 BRANCH(RPAD0)
8515 /*_*/
8516 }
8517 int
RPAD(ret_t retval)8518 RPAD(ret_t retval) {
8519 ENTRY(RPAD)
8520 D_A(SCL) = 1;
8521 /* FALL */
8522 BRANCH(RPAD0)
8523 }
8524 static int
RPAD0(ret_t retval)8525 RPAD0(ret_t retval) {
8526 ENTRY(RPAD0)
8527 PUSH(SCL);
8528 SAVSTK();
8529 if (VARVAL(XPTR) == 1)
8530 BRANCH(FAIL)
8531 PUSH(XPTR);
8532 SAVSTK();
8533 if (INTVAL(ZPTR) == 1)
8534 BRANCH(FAIL)
8535 PUSH(ZPTR);
8536 SAVSTK();
8537 if (VARVAL(WPTR) == 1)
8538 BRANCH(FAIL)
8539 POP(ZPTR);
8540 POP(XPTR);
8541 POP(SCL);
8542 X_LOCSP(VSP,WPTR);
8543 X_LOCSP(XSP,XPTR);
8544 if (D_A(ZPTR) > D_A(MLENCL))
8545 BRANCH(INTR8)
8546 if (D_A(ZEROCL) > D_A(ZPTR))
8547 BRANCH(LENERR)
8548 D_A(YPTR) = S_L(XSP);
8549 D_F(YPTR) = D_V(YPTR) = 0;
8550 if (D_A(YPTR) >= D_A(ZPTR))
8551 BRANCH(RTXPTR)
8552 D_A(XCL) = D_A(ZPTR);
8553 SAVSTK();
8554 PUSH(XCL);
8555 CONVAR(ZPTR);
8556 X_LOCSP(TSP,ZPTR);
8557 PAD(SCL,TSP,XSP,VSP);
8558 BRANCH(GENVSZ)
8559 /*_*/
8560 }
8561 int
APPLY(ret_t retval)8562 APPLY(ret_t retval) {
8563 ENTRY(APPLY)
8564 D_A(XCL) = D_V(INCL);
8565 D_F(XCL) = D_V(XCL) = 0;
8566 D_A(XCL)--;
8567 if (D_A(XCL) < 1)
8568 BRANCH(ARGNER)
8569 PUSH(XCL);
8570 SAVSTK();
8571 if (VARVUP(XPTR) == 1)
8572 BRANCH(FAIL)
8573 POP(XCL);
8574 if (!LOCAPV(XPTR,FNCPL,XPTR))
8575 BRANCH(UNDF)
8576 D(INCL) = D(D_A(XPTR) + DESCR);
8577 D_V(INCL) = D_A(XCL);
8578 SAVSTK();
8579 PUSH(INCL);
8580 switch (INVOKE(ZPTR)) {
8581 case 1:
8582 BRANCH(FAIL)
8583 case 3:
8584 BRANCH(RTZPTR)
8585 }
8586 D(XPTR) = D(ZPTR);
8587 BRANCH(RTXNAM)
8588 /*_*/
8589 }
8590 int
ARG(ret_t retval)8591 ARG(ret_t retval) {
8592 ENTRY(ARG)
8593 PUSH(ONECL);
8594 PUSH(DEFCL);
8595 BRANCH(ARG1)
8596 /*_*/
8597 }
8598 static int
ARGINT(ret_t retval)8599 ARGINT(ret_t retval) {
8600 ENTRY(ARGINT)
8601 POP(XPTR);
8602 POP(XCL);
8603 PUSH(ONECL);
8604 PUSH(DEFCL);
8605 BRANCH(ARG2)
8606 /*_*/
8607 }
8608 int
LOCAL(ret_t retval)8609 LOCAL(ret_t retval) {
8610 ENTRY(LOCAL)
8611 PUSH(ONECL);
8612 PUSH(ZEROCL);
8613 PUSH(DEFCL);
8614 BRANCH(ARG1)
8615 /*_*/
8616 }
8617 int
FIELDS(ret_t retval)8618 FIELDS(ret_t retval) {
8619 ENTRY(FIELDS)
8620 PUSH(ZEROCL);
8621 PUSH(ZEROCL);
8622 PUSH(DATCL);
8623 /* FALL */
8624 BRANCH(ARG1)
8625 }
8626 static int
ARG1(ret_t retval)8627 ARG1(ret_t retval) {
8628 ENTRY(ARG1)
8629 SAVSTK();
8630 if (VARVUP(XPTR) == 1)
8631 BRANCH(FAIL)
8632 PUSH(XPTR);
8633 SAVSTK();
8634 if (INTVAL(XCL) == 1)
8635 BRANCH(FAIL)
8636 if (D_A(ZEROCL) >= D_A(XCL))
8637 BRANCH(FAIL)
8638 POP(XPTR);
8639 /* FALL */
8640 BRANCH(ARG2)
8641 }
8642 static int
ARG2(ret_t retval)8643 ARG2(ret_t retval) {
8644 ENTRY(ARG2)
8645 if (!LOCAPV(XPTR,FNCPL,XPTR))
8646 BRANCH(INTR30)
8647 D(XPTR) = D(D_A(XPTR) + DESCR);
8648 D(YCL) = D(D_A(XPTR));
8649 D(XPTR) = D(D_A(XPTR) + DESCR);
8650 POP(ZCL);
8651 POP(ALCL);
8652 if (D_A(YCL) != D_A(ZCL))
8653 BRANCH(INTR30)
8654 D_A(XCL) *= DESCR;
8655 D_F(XCL) = D_V(XCL) = 0;
8656 D_A(XCL) += 2*DESCR;
8657 D_A(YCL) = D_V(YCL);
8658 D_F(YCL) = D_V(YCL) = 0;
8659 D_A(YCL) *= DESCR;
8660 D_F(YCL) = D_V(YCL) = 0;
8661 if (D_A(ALCL) == 0)
8662 goto L_ARG4;
8663 D_A(YCL) += 2*DESCR;
8664 D(ZCL) = D(YCL);
8665 goto L_ARG5;
8666 /*_*/
8667 L_ARG4:
8668 D_A(ZCL) = D_V(D_A(XPTR));
8669 D_F(ZCL) = D_V(ZCL) = 0;
8670 POP(ALCL);
8671 if (D_A(ALCL) == 0)
8672 goto L_ARG5;
8673 D_A(XCL) += D_A(YCL);
8674 L_ARG5:
8675 if (D_A(XCL) > D_A(ZCL))
8676 BRANCH(FAIL)
8677 D(ZPTR) = D(D_A(XPTR) + D_A(XCL));
8678 BRANCH(RTZPTR)
8679 /*_*/
8680 }
8681 int
CLEAR(ret_t retval)8682 CLEAR(ret_t retval) {
8683 ENTRY(CLEAR)
8684 SAVSTK();
8685 if (ARGVAL(NORET) == 1)
8686 BRANCH(FAIL)
8687 D_A(DMPPTR) = (int_t) (OBLIST-DESCR);
8688 L_CLEAR1:
8689 if (D_PTR(DMPPTR) > D_PTR(OBEND))
8690 BRANCH(RETNUL)
8691 D_A(DMPPTR) += DESCR;
8692 D(YPTR) = D(DMPPTR);
8693 L_CLEAR2:
8694 D_A(YPTR) = D_A(D_A(YPTR) + LNKFLD);
8695 if (D_A(YPTR) == 0)
8696 goto L_CLEAR1;
8697 D(D_A(YPTR) + DESCR) = D(NULVCL);
8698 goto L_CLEAR2;
8699 /*_*/
8700 }
8701 int
CMA(ret_t retval)8702 CMA(ret_t retval) {
8703 ENTRY(CMA)
8704 D_A(ZCL) = D_V(INCL);
8705 D_F(ZCL) = D_V(ZCL) = 0;
8706 L_CMA1:
8707 if (D_A(ZCL) == 0)
8708 BRANCH(FAIL)
8709 PUSH(ZCL);
8710 PUSH(OCBSCL);
8711 PUSH(OCICL);
8712 SAVSTK();
8713 if (ARGVAL(XPTR) == 1)
8714 goto L_CMA2;
8715 POP(OCICL);
8716 POP(OCBSCL);
8717 POP(ZCL);
8718 SAVSTK();
8719 PUSH(ZCL);
8720 if (CODSKP(NORET) == 1)
8721 BRANCH(RTXPTR)
8722 L_CMA2:
8723 POP(OCICL);
8724 POP(OCBSCL);
8725 POP(ZCL);
8726 D_A(ZCL)--;
8727 SAVSTK();
8728 PUSH(ONECL);
8729 if (CODSKP(NORET) == 1)
8730 goto L_CMA1;
8731 /*_*/
8732 }
8733 int
COLECT(ret_t retval)8734 COLECT(ret_t retval) {
8735 ENTRY(COLECT)
8736 SAVSTK();
8737 if (INTVAL(XPTR) == 1)
8738 BRANCH(FAIL)
8739 if (D_A(XPTR) < 0)
8740 BRANCH(LENERR)
8741 SAVSTK();
8742 PUSH(XPTR);
8743 if (GC(ZPTR) == 1)
8744 BRANCH(FAIL)
8745 D_V(ZPTR) = I;
8746 BRANCH(RTZPTR)
8747 /*_*/
8748 }
8749 int
COPY(ret_t retval)8750 COPY(ret_t retval) {
8751 ENTRY(COPY)
8752 SAVSTK();
8753 if (ARGVAL(XPTR) == 1)
8754 BRANCH(FAIL)
8755 if (D_V(XPTR) == S)
8756 BRANCH(INTR1)
8757 if (D_V(XPTR) == I)
8758 BRANCH(INTR1)
8759 if (D_V(XPTR) == R)
8760 BRANCH(INTR1)
8761 if (D_V(XPTR) == N)
8762 BRANCH(INTR1)
8763 if (D_V(XPTR) == K)
8764 BRANCH(INTR1)
8765 if (D_V(XPTR) == E)
8766 BRANCH(INTR1)
8767 if (D_V(XPTR) == T)
8768 BRANCH(INTR1)
8769 D_A(XCL) = D_V(D_A(XPTR));
8770 D_F(XCL) = D_V(XCL) = 0;
8771 D_V(XCL) = D_V(XPTR);
8772 SAVSTK();
8773 PUSH(XCL);
8774 BLOCK(ZPTR);
8775 MOVBLK(D_A(ZPTR),D_A(XPTR),D_A(XCL));
8776 BRANCH(RTZPTR)
8777 /*_*/
8778 }
8779 int
CNVRT(ret_t retval)8780 CNVRT(ret_t retval) {
8781 ENTRY(CNVRT)
8782 SAVSTK();
8783 if (ARGVAL(ZPTR) == 1)
8784 BRANCH(FAIL)
8785 PUSH(ZPTR);
8786 SAVSTK();
8787 if (VARVUP(YPTR) == 1)
8788 BRANCH(FAIL)
8789 POP(ZPTR);
8790 if (!LOCAPV(XPTR,DTATL,YPTR))
8791 goto L_CNV1;
8792 D(XPTR) = D(D_A(XPTR) + DESCR);
8793 D_A(DTCL) = D_V(ZPTR);
8794 D_F(DTCL) = D_V(DTCL) = 0;
8795 D_V(DTCL) = D_V(XPTR);
8796 if (DCMP(DTCL, IVDTP))
8797 BRANCH(CNVIV)
8798 if (DCMP(DTCL, VCDTP))
8799 BRANCH(RECOMP)
8800 if (DCMP(DTCL, VEDTP))
8801 BRANCH(CONVE)
8802 if (DCMP(DTCL, VRDTP))
8803 BRANCH(CONVR)
8804 if (DCMP(DTCL, RIDTP))
8805 BRANCH(CONRI)
8806 if (DCMP(DTCL, IRDTP))
8807 BRANCH(CONIR)
8808 if (DCMP(DTCL, VIDTP))
8809 BRANCH(CNVVI)
8810 if (DCMP(DTCL, ATDTP))
8811 BRANCH(CNVAT)
8812 if (DCMP(DTCL, TADTP))
8813 BRANCH(CNVTA)
8814 if (D_V(ZPTR) == D_V(XPTR))
8815 BRANCH(RTZPTR)
8816 if (D_V(XPTR) == S)
8817 BRANCH(CNVRTS)
8818 else
8819 BRANCH(FAIL)
8820 /*_*/
8821 L_CNV1:
8822 X_LOCSP(YSP,YPTR);
8823 if (!LEXEQ(YSP,NUMSP))
8824 BRANCH(INTR1)
8825 if (D_V(ZPTR) == I)
8826 BRANCH(RTZPTR)
8827 if (D_V(ZPTR) == R)
8828 BRANCH(RTZPTR)
8829 if (D_V(ZPTR) != S)
8830 BRANCH(FAIL)
8831 X_LOCSP(ZSP,ZPTR);
8832 if (SPCINT(ZPTR,ZSP))
8833 BRANCH(RTZPTR)
8834 if (SPREAL(ZPTR,ZSP))
8835 BRANCH(RTZPTR)
8836 else
8837 BRANCH(FAIL)
8838 /*_*/
8839 }
8840 static int
RECOMP(ret_t retval)8841 RECOMP(ret_t retval) {
8842 ENTRY(RECOMP)
8843 D_A(SCL) = 1;
8844 /* FALL */
8845 BRANCH(RECOMJ)
8846 }
8847 static int
RECOMJ(ret_t retval)8848 RECOMJ(ret_t retval) {
8849 ENTRY(RECOMJ)
8850 X_LOCSP(TEXTSP,ZPTR);
8851 L_RECOMT:
8852 D_A(OCALIM) = S_L(TEXTSP);
8853 D_F(OCALIM) = D_V(OCALIM) = 0;
8854 if (D_A(OCALIM) == 0)
8855 goto L_RECOMN;
8856 D_A(OCALIM) *= DESCR;
8857 D_F(OCALIM) = D_V(OCALIM) = 0;
8858 D_A(OCALIM) += 6*DESCR;
8859 D_V(OCALIM) = C;
8860 SAVSTK();
8861 PUSH(OCALIM);
8862 BLOCK(CMBSCL);
8863 D(OCLIM) = D(CMBSCL);
8864 D_A(OCLIM) += D_A(OCALIM);
8865 D_A(OCLIM) -= 6*DESCR;
8866 D_A(CMOFCL) = 0;
8867 D_A(ESAICL) = 0;
8868 PUSH(CMBSCL);
8869 switch (D_A(SCL)) {
8870 case 2:
8871 BRANCH(CONVEX)
8872 }
8873 L_RECOM1:
8874 if (S_L(TEXTSP) == 0)
8875 goto L_RECOM2;
8876 SAVSTK();
8877 switch (CMPILE(NORET)) {
8878 case 1:
8879 goto L_RECOMF;
8880 case 3:
8881 goto L_RECOM1;
8882 }
8883 L_RECOM2:
8884 D_A(SCL) = 3;
8885 L_RECOMQ:
8886 D_A(CMOFCL) += DESCR;
8887 D(D_A(CMBSCL) + D_A(CMOFCL)) = D(ENDCL);
8888 POP(ZPTR);
8889 BRANCH(RECOMZ)
8890 /*_*/
8891 L_RECOMF:
8892 D_A(SCL) = 1;
8893 goto L_RECOMQ;
8894 /*_*/
8895 L_RECOMN:
8896 _SPEC(TEXTSP) = _SPEC(BLSP);
8897 goto L_RECOMT;
8898 /*_*/
8899 }
8900 static int
RECOMZ(ret_t retval)8901 RECOMZ(ret_t retval) {
8902 ENTRY(RECOMZ)
8903 D_A(CMBSCL) += D_A(CMOFCL);
8904 SAVSTK();
8905 PUSH(CMBSCL);
8906 SPLIT(NORET);
8907 D_A(OCLIM) = 0;
8908 D_A(LPTR) = 0;
8909 ZERBLK(D_A(COMREG),D_A(COMDCT));
8910 switch (D_A(SCL)) {
8911 case 1:
8912 BRANCH(FAIL)
8913 case 2:
8914 BRANCH(INTR10)
8915 case 3:
8916 BRANCH(RTZPTR)
8917 }
8918 /*_*/
8919 }
8920 int
CODER(ret_t retval)8921 CODER(ret_t retval) {
8922 ENTRY(CODER)
8923 SAVSTK();
8924 switch (VARVAL(ZPTR)) {
8925 case 1:
8926 BRANCH(FAIL)
8927 case 2:
8928 BRANCH(RECOMP)
8929 }
8930 /*_*/
8931 }
8932 static int
CONVE(ret_t retval)8933 CONVE(ret_t retval) {
8934 ENTRY(CONVE)
8935 D_A(SCL) = 2;
8936 BRANCH(RECOMJ)
8937 /*_*/
8938 }
8939 static int
CONVEX(ret_t retval)8940 CONVEX(ret_t retval) {
8941 ENTRY(CONVEX)
8942 SAVSTK();
8943 if (EXPR(FORMND) == 1)
8944 BRANCH(FAIL)
8945 if (S_L(TEXTSP) != 0)
8946 BRANCH(FAIL)
8947 SAVSTK();
8948 PUSH(FORMND);
8949 TREPUB(NORET);
8950 D(ZPTR) = D(CMBSCL);
8951 D_V(ZPTR) = E;
8952 D_A(SCL) = 3;
8953 BRANCH(RECOMZ)
8954 /*_*/
8955 }
8956 static int
CONVR(ret_t retval)8957 CONVR(ret_t retval) {
8958 ENTRY(CONVR)
8959 X_LOCSP(ZSP,ZPTR);
8960 if (SPCINT(ZPTR,ZSP))
8961 BRANCH(CONIR)
8962 if (SPREAL(ZPTR,ZSP))
8963 BRANCH(RTZPTR)
8964 else
8965 BRANCH(FAIL)
8966 /*_*/
8967 }
8968 static int
CONIR(ret_t retval)8969 CONIR(ret_t retval) {
8970 ENTRY(CONIR)
8971 D_RV(ZPTR) = (real_t)D_A(ZPTR);
8972 D_F(ZPTR) = 0;
8973 D_V(ZPTR) = R;
8974 BRANCH(RTZPTR)
8975 /*_*/
8976 }
8977 static int
CONRI(ret_t retval)8978 CONRI(ret_t retval) {
8979 ENTRY(CONRI)
8980 CLR_MATH_ERROR();
8981 D_A(ZPTR) = (int_t) D_RV(ZPTR);
8982 D_F(ZPTR) = 0;
8983 D_V(ZPTR) = I;
8984 if (MATH_ERROR())
8985 BRANCH(FAIL)
8986 BRANCH(RTZPTR)
8987 /*_*/
8988 }
8989 static int
CNVIV(ret_t retval)8990 CNVIV(ret_t retval) {
8991 ENTRY(CNVIV)
8992 SAVSTK();
8993 PUSH(ZPTR);
8994 if (GNVARI(ZPTR) == 1)
8995 BRANCH(RTZPTR)
8996 /*_*/
8997 }
8998 static int
CNVVI(ret_t retval)8999 CNVVI(ret_t retval) {
9000 ENTRY(CNVVI)
9001 X_LOCSP(ZSP,ZPTR);
9002 if (SPCINT(ZPTR,ZSP))
9003 BRANCH(RTZPTR)
9004 if (SPREAL(ZPTR,ZSP))
9005 BRANCH(CONRI)
9006 else
9007 BRANCH(FAIL)
9008 /*_*/
9009 }
9010 static int
CNVRTS(ret_t retval)9011 CNVRTS(ret_t retval) {
9012 ENTRY(CNVRTS)
9013 SAVSTK();
9014 PUSH(ZPTR);
9015 DTREP(XPTR);
9016 _SPEC(ZSP) = _SPEC(D_A(XPTR));
9017 BRANCH(GENVRZ)
9018 /*_*/
9019 }
9020 static int
CNVTA(ret_t retval)9021 CNVTA(ret_t retval) {
9022 ENTRY(CNVTA)
9023 D(WPTR) = D(ZPTR);
9024 SAVSTK();
9025 PUSH(ZPTR);
9026 switch (ICNVTA(ZPTR)) {
9027 case 1:
9028 BRANCH(FAIL)
9029 }
9030 D(YPTR) = D(ZPTR);
9031 D_A(YCL) *= DESCR;
9032 D_F(YCL) = D_V(YCL) = 0;
9033 D_A(YPTR) += 5*DESCR;
9034 D(TPTR) = D(YPTR);
9035 D_A(TPTR) += D_A(YCL);
9036 L_CNVTA8:
9037 D_A(WCL) = D_V(D_A(WPTR));
9038 D_F(WCL) = D_V(WCL) = 0;
9039 D_A(WCL) -= 2*DESCR;
9040 D_A(WCL) = D_A(WPTR) + D_A(WCL);
9041 D_F(WCL) = D_F(WPTR);
9042 D_V(WCL) = D_V(WPTR);
9043 L_CNVTA3:
9044 D(TCL) = D(D_A(WPTR) + DESCR);
9045 if (DCMP(TCL, NULVCL))
9046 goto L_CNVTA5;
9047 D(D_A(TPTR)) = D(TCL);
9048 D(D_A(YPTR)) = D(D_A(WPTR) + 2*DESCR);
9049 D_A(YPTR) += DESCR;
9050 D_A(TPTR) += DESCR;
9051 L_CNVTA5:
9052 D_A(WPTR) += 2*DESCR;
9053 if (D_A(WCL) != D_A(WPTR))
9054 goto L_CNVTA3;
9055 D(WPTR) = D(D_A(WCL) + 2*DESCR);
9056 if (D_A(WPTR) != 1)
9057 goto L_CNVTA8;
9058 D_A(TPTR) = 0;
9059 BRANCH(RTZPTR)
9060 /*_*/
9061 }
9062 static int
ICNVTA(ret_t retval)9063 ICNVTA(ret_t retval) {
9064 ENTRY(ICNVTA)
9065 POP(YPTR);
9066 D(YCL) = D(ZEROCL);
9067 L_CNVTA7:
9068 D_A(XCL) = D_V(D_A(YPTR));
9069 D_F(XCL) = D_V(XCL) = 0;
9070 D(ZCL) = D(XCL);
9071 D_A(XCL) -= 3*DESCR;
9072 L_CNVTA1:
9073 D(WCL) = D(D_A(YPTR) + D_A(XCL));
9074 if (DCMP(WCL, NULVCL))
9075 goto L_CNVTA2;
9076 D_A(YCL)++;
9077 L_CNVTA2:
9078 if (D_A(XCL) == DESCR)
9079 goto L_CNVTA6;
9080 D_A(XCL) -= 2*DESCR;
9081 goto L_CNVTA1;
9082 /*_*/
9083 L_CNVTA6:
9084 D(YPTR) = D(D_A(YPTR) + D_A(ZCL));
9085 if (D_A(YPTR) != 1)
9086 goto L_CNVTA7;
9087 if (D_A(YCL) == 0)
9088 BRANCH(FAIL)
9089 D_A(XCL) = D_A(YCL);
9090 D_A(XCL) *= 2*DESCR;
9091 D_F(XCL) = D_V(XCL) = 0;
9092 INTSPC(YSP,YCL);
9093 S_L(PROTSP) = 0;
9094 APDSP(PROTSP,YSP);
9095 APDSP(PROTSP,CMASP);
9096 D(WCL) = D(ZEROCL);
9097 D_A(WCL) = 2;
9098 INTSPC(XSP,WCL);
9099 APDSP(PROTSP,XSP);
9100 _SPEC(XSP) = _SPEC(PROTSP);
9101 SAVSTK();
9102 PUSH(XSPPTR);
9103 GENVAR(TPTR);
9104 D(ZCL) = D(XCL);
9105 D_A(XCL) += 4*DESCR;
9106 SAVSTK();
9107 PUSH(XCL);
9108 BLOCK(ZPTR);
9109 D_V(ZPTR) = A;
9110 D(ATPRCL) = D(TPTR);
9111 D_V(ATEXCL) = D_A(YCL);
9112 MOVBLK(D_A(ZPTR),D_A(ATRHD),D_A(FRDSCL));
9113 D(retval) = D(ZPTR);
9114 RETURN(2)
9115 /*_*/
9116 }
9117 static int
CNVAT(ret_t retval)9118 CNVAT(ret_t retval) {
9119 ENTRY(CNVAT)
9120 D(XCL) = D(D_A(ZPTR) + 2*DESCR);
9121 D(YPTR) = D(ZPTR);
9122 if (D_A(XCL) != 2)
9123 BRANCH(FAIL)
9124 D(XCL) = D(D_A(ZPTR) + 3*DESCR);
9125 if (D_V(XCL) != 2)
9126 BRANCH(FAIL)
9127 D_A(XCL) = D_V(D_A(ZPTR));
9128 D_F(XCL) = D_V(XCL) = 0;
9129 D_A(XCL) -= 2*DESCR;
9130 SAVSTK();
9131 PUSH(XCL);
9132 BLOCK(XPTR);
9133 D_V(XPTR) = T;
9134 D(YCL) = D(D_A(ZPTR) + 4*DESCR);
9135 D(ZPTR) = D(XPTR);
9136 D(D_A(XPTR) + D_A(XCL)) = D(ONECL);
9137 D_A(XCL) -= DESCR;
9138 D(TCL) = D(EXTVAL);
9139 D_A(TCL) += 2*DESCR;
9140 D(D_A(XPTR) + D_A(XCL)) = D(TCL);
9141 D_A(YCL) = D_V(YCL);
9142 D_F(YCL) = D_V(YCL) = 0;
9143 D_A(YCL) *= DESCR;
9144 D_F(YCL) = D_V(YCL) = 0;
9145 D_A(YPTR) += 5*DESCR;
9146 D(WPTR) = D(YPTR);
9147 D_A(WPTR) += D_A(YCL);
9148 L_CNVAT2:
9149 D(D_A(XPTR) + DESCR) = D(D_A(WPTR));
9150 D(D_A(XPTR) + 2*DESCR) = D(D_A(YPTR));
9151 D_A(YCL) -= DESCR;
9152 if (D_A(YCL) == 0)
9153 BRANCH(RTZPTR)
9154 D_A(XPTR) += 2*DESCR;
9155 D_A(WPTR) += DESCR;
9156 D_A(YPTR) += DESCR;
9157 goto L_CNVAT2;
9158 /*_*/
9159 }
9160 int
DATE(ret_t retval)9161 DATE(ret_t retval) {
9162 ENTRY(DATE)
9163 SAVSTK();
9164 if (ARGVAL(XPTR) == 1)
9165 BRANCH(FAIL)
9166 _DATE(ZSP,XPTR);
9167 BRANCH(GENVRZ)
9168 /*_*/
9169 }
9170 int
DT(ret_t retval)9171 DT(ret_t retval) {
9172 ENTRY(DT)
9173 SAVSTK();
9174 if (ARGVAL(A2PTR) == 1)
9175 BRANCH(FAIL)
9176 D_V(DT1CL) = D_V(A2PTR);
9177 if (!LOCAPT(A3PTR,DTATL,DT1CL))
9178 goto L_DTEXTN;
9179 D(A3PTR) = D(D_A(A3PTR) + 2*DESCR);
9180 L_DTRTN:
9181 D(retval) = D(A3PTR);
9182 RETURN(3)
9183 /*_*/
9184 L_DTEXTN:
9185 D(A3PTR) = D(EXTPTR);
9186 goto L_DTRTN;
9187 /*_*/
9188 }
9189 int
DMP(ret_t retval)9190 DMP(ret_t retval) {
9191 ENTRY(DMP)
9192 SAVSTK();
9193 if (INTVAL(XPTR) == 1)
9194 BRANCH(FAIL)
9195 if (D_A(XPTR) == 0)
9196 BRANCH(RETNUL)
9197 /* FALL */
9198 BRANCH(DUMP)
9199 }
9200 static int
DUMP(ret_t retval)9201 DUMP(ret_t retval) {
9202 ENTRY(DUMP)
9203 D_A(WPTR) = (int_t) (OBLIST-DESCR);
9204 L_DMPB:
9205 if (D_PTR(WPTR) > D_PTR(OBEND))
9206 BRANCH(RETNUL)
9207 D_A(WPTR) += DESCR;
9208 D(YPTR) = D(WPTR);
9209 L_DMPA:
9210 D_A(YPTR) = D_A(D_A(YPTR) + LNKFLD);
9211 if (D_A(YPTR) == 0)
9212 goto L_DMPB;
9213 D(XPTR) = D(D_A(YPTR) + DESCR);
9214 if (DCMP(XPTR, NULVCL))
9215 goto L_DMPA;
9216 S_L(DMPSP) = 0;
9217 X_LOCSP(YSP,YPTR);
9218 D_A(YCL) = S_L(YSP);
9219 D_F(YCL) = D_V(YCL) = 0;
9220 if (D_A(YCL) >= BUFLEN)
9221 goto L_DMPOVR;
9222 APDSP(DMPSP,YSP);
9223 APDSP(DMPSP,BLEQSP);
9224 if (D_V(XPTR) == S)
9225 goto L_DMPV;
9226 if (D_V(XPTR) == I)
9227 goto L_DMPI;
9228 SAVSTK();
9229 PUSH(XPTR);
9230 DTREP(A1PTR);
9231 _SPEC(YSP) = _SPEC(D_A(A1PTR));
9232 L_DMPX:
9233 D_A(XCL) = S_L(YSP);
9234 D_F(XCL) = D_V(XCL) = 0;
9235 D_A(YCL) += D_A(XCL);
9236 if (D_A(YCL) > BUFLEN)
9237 goto L_DMPOVR;
9238 APDSP(DMPSP,YSP);
9239 if (D_V(XPTR) != T)
9240 goto L_DMPRT;
9241 if (!(D_F(D_A(XPTR)) & FRZN))
9242 goto L_DMPRT;
9243 APDSP(DMPSP,FRZNSP);
9244 goto L_DMPRT;
9245 /*_*/
9246 L_DMPV:
9247 X_LOCSP(YSP,XPTR);
9248 D_A(XCL) = S_L(YSP);
9249 D_F(XCL) = D_V(XCL) = 0;
9250 D_A(YCL) += D_A(XCL);
9251 if (D_A(YCL) > BUFLEN)
9252 goto L_DMPOVR;
9253 APDSP(DMPSP,QTSP);
9254 APDSP(DMPSP,YSP);
9255 APDSP(DMPSP,QTSP);
9256 L_DMPRT:
9257 IO_PRINT(IOKEY, OUTBLK, DMPSP);
9258 goto L_DMPA;
9259 /*_*/
9260 L_DMPI:
9261 INTSPC(YSP,XPTR);
9262 goto L_DMPX;
9263 /*_*/
9264 L_DMPOVR:
9265 io_printf(D_A(OUTPUT),PRTOVF);
9266 goto L_DMPA;
9267 /*_*/
9268 }
9269 static int
DMK(ret_t retval)9270 DMK(ret_t retval) {
9271 ENTRY(DMK)
9272 io_printf(D_A(OUTPUT),PKEYF);
9273 D_A(XCL) = D_V(D_A(KNLIST));
9274 D_F(XCL) = D_V(XCL) = 0;
9275 L_DMPK1:
9276 D(XPTR) = D(D_A(KNLIST) + D_A(XCL));
9277 D_A(XCL) -= DESCR;
9278 D(YPTR) = D(D_A(KNLIST) + D_A(XCL));
9279 INTSPC(YSP,YPTR);
9280 X_LOCSP(XSP,XPTR);
9281 S_L(DMPSP) = 0;
9282 APDSP(DMPSP,AMPSP);
9283 APDSP(DMPSP,XSP);
9284 APDSP(DMPSP,BLEQSP);
9285 if (D_V(YPTR) == S)
9286 goto L_DMPKV;
9287 APDSP(DMPSP,YSP);
9288 L_DMPK2:
9289 IO_PRINT(IOKEY, OUTBLK, DMPSP);
9290 D_A(XCL) -= DESCR;
9291 if (D_A(XCL) == 0)
9292 BRANCH(RTN1)
9293 else
9294 goto L_DMPK1;
9295 /*_*/
9296 L_DMPKV:
9297 X_LOCSP(YSP,YPTR);
9298 APDSP(DMPSP,QTSP);
9299 D_A(YCL) = S_L(YSP);
9300 D_F(YCL) = D_V(YCL) = 0;
9301 if (D_A(YCL) > BUFLEN-20)
9302 goto L_DMPK3;
9303 APDSP(DMPSP,YSP);
9304 L_DMPK3:
9305 APDSP(DMPSP,QTSP);
9306 goto L_DMPK2;
9307 /*_*/
9308 }
9309 int
DUPL(ret_t retval)9310 DUPL(ret_t retval) {
9311 ENTRY(DUPL)
9312 SAVSTK();
9313 if (VARVAL(XPTR) == 1)
9314 BRANCH(FAIL)
9315 PUSH(XPTR);
9316 SAVSTK();
9317 if (INTVAL(YPTR) == 1)
9318 BRANCH(FAIL)
9319 POP(XPTR);
9320 if (D_A(YPTR) < 0)
9321 BRANCH(FAIL)
9322 if (D_A(YPTR) == 0)
9323 BRANCH(RETNUL)
9324 X_LOCSP(XSP,XPTR);
9325 D_A(XCL) = S_L(XSP);
9326 D_F(XCL) = D_V(XCL) = 0;
9327 CLR_MATH_ERROR();
9328 D_A(XCL) *= D_A(YPTR);
9329 if (MATH_ERROR())
9330 BRANCH(AERROR)
9331 if (D_A(XCL) > D_A(MLENCL))
9332 BRANCH(INTR8)
9333 SAVSTK();
9334 PUSH(XCL);
9335 CONVAR(ZPTR);
9336 X_LOCSP(TSP,ZPTR);
9337 S_L(TSP) = 0;
9338 L_DUPL1:
9339 APDSP(TSP,XSP);
9340 D_A(YPTR)--;
9341 if (D_A(YPTR) == 0)
9342 BRANCH(GENVSZ)
9343 else
9344 goto L_DUPL1;
9345 /*_*/
9346 }
9347 int
OPSYN(ret_t retval)9348 OPSYN(ret_t retval) {
9349 ENTRY(OPSYN)
9350 SAVSTK();
9351 if (VARVUP(XPTR) == 1)
9352 BRANCH(FAIL)
9353 PUSH(XPTR);
9354 SAVSTK();
9355 if (VARVUP(YPTR) == 1)
9356 BRANCH(FAIL)
9357 PUSH(YPTR);
9358 SAVSTK();
9359 if (INTVAL(ZPTR) == 1)
9360 BRANCH(FAIL)
9361 POP(YPTR);
9362 POP(XPTR);
9363 if (D_A(XPTR) == 0)
9364 BRANCH(NONAME)
9365 if (D_A(ZPTR) == 1)
9366 goto L_UNYOP;
9367 if (D_A(ZPTR) == 2)
9368 goto L_BNYOP;
9369 if (D_A(ZPTR) != 0)
9370 BRANCH(INTR30)
9371 SAVSTK();
9372 PUSH(XPTR);
9373 FINDEX(XPTR);
9374 L_UNBF:
9375 SAVSTK();
9376 PUSH(YPTR);
9377 FINDEX(YPTR);
9378 L_OPPD:
9379 D(D_A(XPTR)) = D(D_A(YPTR));
9380 D(D_A(XPTR) + DESCR) = D(D_A(YPTR) + DESCR);
9381 BRANCH(RETNUL)
9382 /*_*/
9383 L_UNYOP:
9384 X_LOCSP(XSP,XPTR);
9385 if (S_L(XSP) != 1)
9386 goto L_UNAF;
9387 _SPEC(ZSP) = _SPEC(PROTSP);
9388 S_L(ZSP) = 0;
9389 APDSP(ZSP,XSP);
9390 APDSP(ZSP,LPRNSP);
9391 switch (STREAM(TSP, ZSP, &UNOPTB)) {
9392 case ST_ERROR:
9393 case ST_EOS:
9394 goto L_UNAF;
9395 }
9396 D(XPTR) = D(STYPE);
9397 L_UNCF:
9398 X_LOCSP(YSP,YPTR);
9399 if (S_L(YSP) != 1)
9400 goto L_UNBF;
9401 _SPEC(ZSP) = _SPEC(PROTSP);
9402 S_L(ZSP) = 0;
9403 APDSP(ZSP,YSP);
9404 APDSP(ZSP,LPRNSP);
9405 switch (STREAM(TSP, ZSP, &UNOPTB)) {
9406 case ST_ERROR:
9407 case ST_EOS:
9408 goto L_UNBF;
9409 }
9410 D(YPTR) = D(STYPE);
9411 goto L_OPPD;
9412 /*_*/
9413 L_UNAF:
9414 SAVSTK();
9415 PUSH(XPTR);
9416 FINDEX(XPTR);
9417 goto L_UNCF;
9418 /*_*/
9419 L_BNYOP:
9420 X_LOCSP(XSP,XPTR);
9421 if (S_L(XSP) > S_L(EQLSP))
9422 goto L_BNAF;
9423 _SPEC(ZSP) = _SPEC(PROTSP);
9424 S_L(ZSP) = 0;
9425 APDSP(ZSP,XSP);
9426 APDSP(ZSP,BLSP);
9427 if (D_A(SPITCL) != 0)
9428 goto L_BNYOP2;
9429 if (D_A(BLOKCL) != 0)
9430 goto L_BNYOP4;
9431 switch (STREAM(TSP, ZSP, &BIOPTB)) {
9432 case ST_ERROR:
9433 case ST_EOS:
9434 goto L_BNAF;
9435 }
9436 goto L_BNYOP3;
9437 /*_*/
9438 L_BNYOP4:
9439 switch (STREAM(TSP, ZSP, &BBIOPTB)) {
9440 case ST_ERROR:
9441 case ST_EOS:
9442 goto L_BNAF;
9443 }
9444 goto L_BNYOP3;
9445 /*_*/
9446 L_BNYOP2:
9447 if (D_A(BLOKCL) != 0)
9448 goto L_BNYOP5;
9449 switch (STREAM(TSP, ZSP, &SBIPTB)) {
9450 case ST_ERROR:
9451 case ST_EOS:
9452 goto L_BNAF;
9453 }
9454 goto L_BNYOP3;
9455 /*_*/
9456 L_BNYOP5:
9457 switch (STREAM(TSP, ZSP, &BSBIPTB)) {
9458 case ST_ERROR:
9459 case ST_EOS:
9460 goto L_BNAF;
9461 }
9462 L_BNYOP3:
9463 if (S_L(ZSP) != 0)
9464 goto L_BNAF;
9465 D(XPTR) = D(STYPE);
9466 L_BNCF:
9467 X_LOCSP(YSP,YPTR);
9468 if (S_L(YSP) > S_L(EQLSP))
9469 goto L_BNBF;
9470 _SPEC(ZSP) = _SPEC(PROTSP);
9471 S_L(ZSP) = 0;
9472 APDSP(ZSP,YSP);
9473 APDSP(ZSP,BLSP);
9474 if (D_A(SPITCL) != 0)
9475 goto L_BNCF2;
9476 if (D_A(BLOKSP) != 0)
9477 goto L_BNCF4;
9478 switch (STREAM(TSP, ZSP, &BIOPTB)) {
9479 case ST_ERROR:
9480 case ST_EOS:
9481 goto L_BNBF;
9482 }
9483 goto L_BNCF3;
9484 /*_*/
9485 L_BNCF4:
9486 switch (STREAM(TSP, ZSP, &BBIOPTB)) {
9487 case ST_ERROR:
9488 case ST_EOS:
9489 goto L_BNBF;
9490 }
9491 goto L_BNCF3;
9492 /*_*/
9493 L_BNCF2:
9494 if (D_A(BLOKSP) != 0)
9495 goto L_BNCF5;
9496 switch (STREAM(TSP, ZSP, &SBIPTB)) {
9497 case ST_ERROR:
9498 case ST_EOS:
9499 goto L_BNBF;
9500 }
9501 goto L_BNCF3;
9502 /*_*/
9503 L_BNCF5:
9504 switch (STREAM(TSP, ZSP, &BSBIPTB)) {
9505 case ST_ERROR:
9506 case ST_EOS:
9507 goto L_BNBF;
9508 }
9509 L_BNCF3:
9510 if (S_L(ZSP) != 0)
9511 goto L_BNBF;
9512 D(YPTR) = D(STYPE);
9513 goto L_OPPD;
9514 /*_*/
9515 L_BNAF:
9516 if (LEXEQ(XSP,BLSP))
9517 goto L_BNCN;
9518 SAVSTK();
9519 PUSH(XPTR);
9520 FINDEX(XPTR);
9521 goto L_BNCF;
9522 /*_*/
9523 L_BNCN:
9524 D(XPTR) = D(CONCL);
9525 goto L_BNCF;
9526 /*_*/
9527 L_BNBF:
9528 if (!LEXEQ(YSP,BLSP))
9529 goto L_UNBF;
9530 D(YPTR) = D(CONCL);
9531 goto L_OPPD;
9532 /*_*/
9533 }
9534 int
RPLACE(ret_t retval)9535 RPLACE(ret_t retval) {
9536 ENTRY(RPLACE)
9537 SAVSTK();
9538 if (VARVAL(XPTR) == 1)
9539 BRANCH(FAIL)
9540 PUSH(XPTR);
9541 SAVSTK();
9542 if (VARVAL(YPTR) == 1)
9543 BRANCH(FAIL)
9544 PUSH(YPTR);
9545 SAVSTK();
9546 if (VARVAL(ZPTR) == 1)
9547 BRANCH(FAIL)
9548 POP(YPTR);
9549 POP(XPTR);
9550 if (D_A(XPTR) == 0)
9551 BRANCH(RTXPTR)
9552 X_LOCSP(YSP,YPTR);
9553 X_LOCSP(ZSP,ZPTR);
9554 if (S_L(ZSP) != S_L(YSP))
9555 BRANCH(FAIL)
9556 if (D_A(YPTR) == 0)
9557 BRANCH(FAIL)
9558 X_LOCSP(XSP,XPTR);
9559 D_A(XCL) = S_L(XSP);
9560 D_F(XCL) = D_V(XCL) = 0;
9561 SAVSTK();
9562 PUSH(XCL);
9563 CONVAR(ZPTR);
9564 X_LOCSP(TSP,ZPTR);
9565 S_L(TSP) = 0;
9566 APDSP(TSP,XSP);
9567 _RPLACE(TSP,YSP,ZSP);
9568 BRANCH(GENVSZ)
9569 /*_*/
9570 }
9571 int
REVERS(ret_t retval)9572 REVERS(ret_t retval) {
9573 ENTRY(REVERS)
9574 SAVSTK();
9575 if (VARVAL(XPTR) == 1)
9576 BRANCH(FAIL)
9577 X_LOCSP(XSP,XPTR);
9578 D_A(ZPTR) = S_L(XSP);
9579 D_F(ZPTR) = D_V(ZPTR) = 0;
9580 if (D_A(ZPTR) == 0)
9581 BRANCH(RETNUL)
9582 D_A(XCL) = D_A(ZPTR);
9583 SAVSTK();
9584 PUSH(XCL);
9585 CONVAR(ZPTR);
9586 X_LOCSP(TSP,ZPTR);
9587 REVERSE(TSP,XSP);
9588 BRANCH(GENVSZ)
9589 /*_*/
9590 }
9591 int
SIZE(ret_t retval)9592 SIZE(ret_t retval) {
9593 ENTRY(SIZE)
9594 SAVSTK();
9595 if (VARVAL(XPTR) == 1)
9596 BRANCH(FAIL)
9597 X_LOCSP(XSP,XPTR);
9598 D_A(ZPTR) = S_L(XSP);
9599 D_F(ZPTR) = D_V(ZPTR) = 0;
9600 D_V(ZPTR) = I;
9601 BRANCH(RTZPTR)
9602 /*_*/
9603 }
9604 int
SUBSTR(ret_t retval)9605 SUBSTR(ret_t retval) {
9606 ENTRY(SUBSTR)
9607 SAVSTK();
9608 if (VARVAL(XPTR) == 1)
9609 BRANCH(FAIL)
9610 PUSH(XPTR);
9611 SAVSTK();
9612 if (INTVAL(YPTR) == 1)
9613 BRANCH(FAIL)
9614 PUSH(YPTR);
9615 SAVSTK();
9616 if (INTVAL(ZPTR) == 1)
9617 BRANCH(FAIL)
9618 POP(YPTR);
9619 POP(XPTR);
9620 if (D_A(YPTR) < 1)
9621 BRANCH(FAIL)
9622 D_A(YPTR)--;
9623 X_LOCSP(XSP,XPTR);
9624 D_A(WPTR) = S_L(XSP);
9625 D_F(WPTR) = D_V(WPTR) = 0;
9626 D_A(WPTR) -= D_A(YPTR);
9627 if (D_A(ZPTR) > D_A(WPTR))
9628 BRANCH(FAIL)
9629 if (D_A(ZPTR) < 0)
9630 BRANCH(FAIL)
9631 if (D_A(ZPTR) > 0)
9632 goto L_SSNOFX;
9633 D_A(ZPTR) = D_A(WPTR);
9634 L_SSNOFX:
9635 if (D_A(ZPTR) < 0)
9636 BRANCH(FAIL)
9637 if (D_A(ZPTR) == 0)
9638 BRANCH(RETNUL)
9639 D_A(XCL) = D_A(ZPTR);
9640 SAVSTK();
9641 PUSH(XCL);
9642 CONVAR(ZPTR);
9643 X_LOCSP(TSP,ZPTR);
9644 XSUBSTR(TSP,XSP,YPTR);
9645 BRANCH(GENVSZ)
9646 /*_*/
9647 }
9648 int
TIME(ret_t retval)9649 TIME(ret_t retval) {
9650 ENTRY(TIME)
9651 SAVSTK();
9652 if (ARGVAL(NORET) == 1)
9653 BRANCH(FAIL)
9654 D_RV(ZPTR) = mstime();
9655 D_F(ZPTR) = D_V(ZPTR) = 0;
9656 D_RV(ZPTR) -= D_RV(ETMCL);
9657 D_V(ZPTR) = R;
9658 BRANCH(RTZPTR)
9659 /*_*/
9660 }
9661 int
TRIM(ret_t retval)9662 TRIM(ret_t retval) {
9663 ENTRY(TRIM)
9664 SAVSTK();
9665 if (VARVAL(XPTR) == 1)
9666 BRANCH(FAIL)
9667 X_LOCSP(ZSP,XPTR);
9668 TRIMSP(ZSP,ZSP);
9669 BRANCH(GENVRZ)
9670 /*_*/
9671 }
9672 int
VDIFFR(ret_t retval)9673 VDIFFR(ret_t retval) {
9674 ENTRY(VDIFFR)
9675 SAVSTK();
9676 if (XYARGS(NORET) == 1)
9677 BRANCH(FAIL)
9678 if (DCMP(XPTR, YPTR))
9679 BRANCH(FAIL)
9680 else
9681 BRANCH(RTXPTR)
9682 /*_*/
9683 }
9684 static int
ADD_NP(ret_t retval)9685 ADD_NP(ret_t retval) {
9686 ENTRY(ADD_NP)
9687 POP(AN_EDGE);
9688 POP(AN_NODE);
9689 POP(AN_DIST);
9690 D_V(AN_NODE) = D_A(AN_DIST);
9691 if (D_V(AN_EDGE) == EDGDT)
9692 goto L_AN1;
9693 SAVSTK();
9694 PUSH(AN_RD);
9695 BLOCK(TEMP31);
9696 SAVSTK();
9697 PUSH(AN_ED);
9698 BLOCK(TEMP32);
9699 D(D_A(TEMP32) + RELS1_) = D(TEMP31);
9700 D(D_A(TEMP32) + NN1_) = D(AN_1);
9701 D(D_A(TEMP32) + TR1_) = D(AN_EDGE);
9702 D(D_A(TEMP31) + DESCR) = D(AN_NODE);
9703 goto L_AN99;
9704 L_AN1:
9705 D(TEMP32) = D(D_A(AN_EDGE) + RELS1_);
9706 SAVSTK();
9707 PUSH(AN_EDGE);
9708 BCOPY(AN_EDGE);
9709 PUSH(AN_EDGE);
9710 SAVSTK();
9711 PUSH(TEMP32);
9712 BCOPY(TEMP32);
9713 POP(AN_EDGE);
9714 D_A(TEMP31) = D_V(D_A(TEMP32));
9715 D_F(TEMP31) = D_V(TEMP31) = 0;
9716 D(TEMP33) = D(D_A(AN_EDGE) + NN1_);
9717 D_A(TEMP33)++;
9718 D(D_A(AN_EDGE) + NN1_) = D(TEMP33);
9719 D_A(TEMP33) *= DESCR;
9720 D_F(TEMP33) = D_V(TEMP33) = 0;
9721 if (D_A(TEMP31) < D_A(TEMP33))
9722 goto L_AN2;
9723 L_AN3:
9724 D(D_A(TEMP32) + D_A(TEMP33)) = D(AN_NODE);
9725 D(TEMP32) = D(AN_EDGE);
9726 goto L_AN99;
9727 L_AN2:
9728 PUSH(AN_EDGE);
9729 PUSH(XPTR);
9730 SAVSTK();
9731 PUSH(TEMP32);
9732 MORE(TEMP32);
9733 POP(XPTR);
9734 POP(AN_EDGE);
9735 D(D_A(AN_EDGE) + RELS1_) = D(TEMP32);
9736 goto L_AN3;
9737 L_AN99:
9738 D(retval) = D(TEMP32);
9739 RETURN(1)
9740 }
9741 static int
AF_MERGE(ret_t retval)9742 AF_MERGE(ret_t retval) {
9743 ENTRY(AF_MERGE)
9744 POP(TEMP41);
9745 POP(TEMP42);
9746 D(AM_DIR) = D(ZEROCL);
9747 L_AM4:
9748 D_A(AM_DIR) += DESCR;
9749 if (D_A(AM_DIR) > FRSIZE_)
9750 BRANCH(RTN1)
9751 D(TEMP43) = D(D_A(TEMP41) + D_A(AM_DIR));
9752 if (D_V(TEMP43) == AEDGDT)
9753 goto L_AM1;
9754 SAVSTK();
9755 PUSH(AM_DE);
9756 BLOCK(AM_AE);
9757 D(D_A(AM_AE) + VAL_) = D(TEMP43);
9758 D(D_A(TEMP41) + D_A(AM_DIR)) = D(AM_AE);
9759 D(TEMP43) = D(AM_AE);
9760 L_AM1:
9761 D(TEMP44) = D(D_A(TEMP42) + D_A(AM_DIR));
9762 if (D_V(TEMP44) == AEDGDT)
9763 goto L_AM2;
9764 SAVSTK();
9765 PUSH(TEMP44);
9766 PUSH(TEMP43);
9767 COAG(NORET);
9768 goto L_AM4;
9769 L_AM2:
9770 L_AM3:
9771 D(AM_E) = D(D_A(TEMP44) + VAL_);
9772 SAVSTK();
9773 PUSH(AM_E);
9774 PUSH(TEMP43);
9775 COAG(NORET);
9776 D(TEMP44) = D(D_A(TEMP44) + NEXT_);
9777 if (D_A(TEMP44) != 0)
9778 goto L_AM3;
9779 goto L_AM4;
9780 }
9781 static int
AFRAME(ret_t retval)9782 AFRAME(ret_t retval) {
9783 ENTRY(AFRAME)
9784 POP(TEMP1);
9785 D(TEMP2) = D(D_A(TEMP1) + VALUE_);
9786 if (D_V(TEMP2) == S)
9787 goto L_AFR4;
9788 D(TEMP39) = D(D_A(TEMP2) + ORG_);
9789 D_A(TEMP39) = D_V(TEMP39);
9790 D_F(TEMP39) = D_V(TEMP39) = 0;
9791 if (D_A(TEMP39) > OVY_)
9792 goto L_AFR4;
9793 SAVSTK();
9794 PUSH(AF_SIZE);
9795 BLOCK(TEMP3);
9796 D(TEMP4) = D(D_A(TEMP2) + ORG_);
9797 D_A(TEMP4) = D_V(TEMP4);
9798 D_F(TEMP4) = D_V(TEMP4) = 0;
9799 D_A(TEMP4) *= DESCR;
9800 D_F(TEMP4) = D_V(TEMP4) = 0;
9801 D(TEMP5) = D(D_A(TEMP1) + TNREG_);
9802 SAVSTK();
9803 PUSH(AF_SIZE);
9804 BLOCK(TEMP6);
9805 D(D_A(TEMP6) + D_A(TEMP4)) = D(AF_Z);
9806 SAVSTK();
9807 PUSH(TEMP1);
9808 LSOHN(TEMP7);
9809 PUSH(TEMP2);
9810 PUSH(TEMP3);
9811 PUSH(TEMP5);
9812 PUSH(TEMP1);
9813 PUSH(TEMP4);
9814 PUSH(TEMP6);
9815 D(AF_NF) = D(ZEROCL);
9816 L_AFR3A:
9817 D(TEMP31) = D(D_A(TEMP7) + VALUE_);
9818 if (D_V(TEMP31) == S)
9819 goto L_T1;
9820 D(TEMP39) = D(D_A(TEMP31) + ORG_);
9821 if (D_V(TEMP39) == REP_)
9822 goto L_AFR1A;
9823 L_T1:
9824 PUSH(TEMP7);
9825 PUSH(AF_NF);
9826 SAVSTK();
9827 PUSH(NULVCL);
9828 PUSH(TEMP7);
9829 B_PB(TEMP31);
9830 POP(AF_NF);
9831 POP(TEMP7);
9832 D(TEMP31) = D(D_A(TEMP31) + FRAME_);
9833 D(TEMP31) = D(D_A(TEMP31) + HT_);
9834 if (D_V(TEMP31) != EDGDT)
9835 goto L_AFR1A;
9836 D_A(AF_NF) = 1;
9837 L_AFR1A:
9838 D(TEMP7) = D(D_A(TEMP7) + RSIB_);
9839 if (D_A(TEMP7) != 0)
9840 goto L_AFR3A;
9841 POP(TEMP6);
9842 POP(TEMP4);
9843 POP(TEMP1);
9844 PUSH(AF_NF);
9845 if (D_A(TEMP4)>= 3*DESCR) {
9846 D_A(TEMP4) = 0;
9847 D_F(TEMP4) = D_V(TEMP4) = 0;
9848 }
9849 D_A(TEMP4) += DESCR;
9850 PUSH(TEMP1);
9851 PUSH(TEMP4);
9852 PUSH(TEMP6);
9853 SAVSTK();
9854 PUSH(TEMP4);
9855 PUSH(TEMP1);
9856 FORCING(TEMP31);
9857 POP(TEMP6);
9858 POP(TEMP4);
9859 POP(TEMP1);
9860 D(D_A(TEMP6) + D_A(TEMP4)) = D(TEMP31);
9861 if (D_A(TEMP4)>= 3*DESCR) {
9862 D_A(TEMP4) = 0;
9863 D_F(TEMP4) = D_V(TEMP4) = 0;
9864 }
9865 D_A(TEMP4) += DESCR;
9866 PUSH(TEMP1);
9867 PUSH(TEMP4);
9868 PUSH(TEMP6);
9869 SAVSTK();
9870 PUSH(TEMP4);
9871 PUSH(TEMP1);
9872 FORCING(TEMP31);
9873 POP(TEMP6);
9874 POP(TEMP4);
9875 POP(TEMP1);
9876 D(D_A(TEMP6) + D_A(TEMP4)) = D(TEMP31);
9877 if (D_A(TEMP4)>= 3*DESCR) {
9878 D_A(TEMP4) = 0;
9879 D_F(TEMP4) = D_V(TEMP4) = 0;
9880 }
9881 D_A(TEMP4) += DESCR;
9882 POP(AF_NF);
9883 POP(TEMP5);
9884 POP(TEMP3);
9885 POP(TEMP2);
9886 D(TEMP7) = D(D_A(TEMP1) + LSO_);
9887 L_AFR3:
9888 D(TEMP31) = D(D_A(TEMP7) + VALUE_);
9889 if (D_V(TEMP31) == S)
9890 goto L_T2;
9891 D(TEMP39) = D(D_A(TEMP31) + ORG_);
9892 if (D_V(TEMP39) == REP_)
9893 goto L_AFR1;
9894 L_T2:
9895 D(TEMP8) = D(D_A(TEMP31) + FRAME_);
9896 if (D_A(AF_NF) != 0)
9897 goto L_AFR6;
9898 D(TEMP8) = D(D_A(TEMP8) + D_A(TEMP4));
9899 D(TEMP31) = D(D_A(TEMP6) + D_A(TEMP4));
9900 D_A(TEMP31) += D_A(TEMP8);
9901 D(D_A(TEMP6) + D_A(TEMP4)) = D(TEMP31);
9902 goto L_AFR2;
9903 L_AFR6:
9904 SAVSTK();
9905 PUSH(TEMP5);
9906 PUSH(TEMP8);
9907 PUSH(TEMP6);
9908 PUSH(TEMP4);
9909 F_JOIN(TEMP6);
9910 L_AFR2:
9911 D(TEMP7) = D(D_A(TEMP7) + RSIB_);
9912 if (D_A(TEMP7) != 0)
9913 goto L_AFR3;
9914 D(TEMP31) = D(D_A(TEMP3) + D_A(TEMP4));
9915 D(TEMP32) = D(D_A(TEMP6) + D_A(TEMP4));
9916 if (DCMP(TEMP31, ZEROCL))
9917 goto L_AFNOTA;
9918 SAVSTK();
9919 PUSH(TEMP32);
9920 PUSH(TEMP31);
9921 E_ATTACH(TEMP32);
9922 D(D_A(TEMP3) + D_A(TEMP4)) = D(TEMP32);
9923 if (D_A(TEMP4)>= 3*DESCR) {
9924 D_A(TEMP4) = 0;
9925 D_F(TEMP4) = D_V(TEMP4) = 0;
9926 }
9927 D_A(TEMP4) += DESCR;
9928 D(TEMP31) = D(D_A(TEMP6) + D_A(TEMP4));
9929 D(D_A(TEMP3) + D_A(TEMP4)) = D(TEMP31);
9930 if (D_A(TEMP4)>= 3*DESCR) {
9931 D_A(TEMP4) = 0;
9932 D_F(TEMP4) = D_V(TEMP4) = 0;
9933 }
9934 D_A(TEMP4) += DESCR;
9935 D(TEMP31) = D(D_A(TEMP6) + D_A(TEMP4));
9936 D(D_A(TEMP3) + D_A(TEMP4)) = D(TEMP31);
9937 L_AFR21:
9938 SAVSTK();
9939 PUSH(NULVCL);
9940 PUSH(TEMP3);
9941 PUSH(TEMP2);
9942 NP_BLOCK(TEMP31);
9943 D(D_A(TEMP1) + VALUE_) = D(TEMP31);
9944 goto L_AFR99;
9945 L_AFNOTA:
9946 D(TEMP3) = D(TEMP6);
9947 goto L_AFR21;
9948 L_AFR1:
9949 D(TEMP31) = D(D_A(TEMP3) + D_A(TEMP4));
9950 D(TEMP32) = D(D_A(TEMP6) + D_A(TEMP4));
9951 if (DCMP(TEMP31, ZEROCL))
9952 goto L_AFR11;
9953 SAVSTK();
9954 PUSH(TEMP32);
9955 PUSH(TEMP31);
9956 E_ATTACH(TEMP32);
9957 L_AFR11:
9958 D(D_A(TEMP3) + D_A(TEMP4)) = D(TEMP32);
9959 D(D_A(TEMP6) + D_A(TEMP4)) = D(AF_Z);
9960 goto L_AFR2;
9961 L_AFR4:
9962 D(TEMP31) = D(D_A(TEMP2) + ORG_);
9963 if (D_V(TEMP31) != NODE_)
9964 goto L_AFR5;
9965 PUSH(TEMP1);
9966 SAVSTK();
9967 PUSH(TEMP1);
9968 B_PB(TEMP2);
9969 POP(TEMP1);
9970 L_AFR5:
9971 if (D_V(TEMP2) == S)
9972 goto L_T3;
9973 D(TEMP39) = D(D_A(TEMP2) + ORG_);
9974 if (D_V(TEMP39) == PHY_)
9975 goto L_AFR51;
9976 L_T3:
9977 D_A(ERRTYP) = (int_t) (ERRNO+3);
9978 BRANCH(FTLEND)
9979 L_AFR51:
9980 D(TEMP3) = D(D_A(TEMP2) + FRAME_);
9981 goto L_AFR99;
9982 L_AFR99:
9983 D(retval) = D(TEMP3);
9984 RETURN(1)
9985 }
9986 static int
B_PB(ret_t retval)9987 B_PB(ret_t retval) {
9988 ENTRY(B_PB)
9989 POP(XPTR);
9990 D(TEMP1) = D(D_A(XPTR) + VALUE_);
9991 if (D_V(TEMP1) != S)
9992 goto L_BPNOST;
9993 if (D_A(TEMP1) != 0)
9994 goto L_BPNONL;
9995 SAVSTK();
9996 PUSH(NULVCL);
9997 PUSH(BP_0);
9998 PUSH(BP_0);
9999 PUSH(BP_0);
10000 PUSH(NULVCL);
10001 P_BLOCK(TEMP12);
10002 goto L_BPST1;
10003 L_BPNONL:
10004 SAVSTK();
10005 PUSH(BP_ARY);
10006 BLOCK(BP_T);
10007 D(D_A(BP_T) + DESCR) = D(TEMP1);
10008 D_A(BP_L) = D_V(D_A(TEMP1));
10009 D_F(BP_L) = D_V(BP_L) = 0;
10010 D_V(BP_L) = I;
10011 SAVSTK();
10012 PUSH(BP_T);
10013 PUSH(BP_1);
10014 PUSH(BP_L);
10015 PUSH(BP_1);
10016 PUSH(TEMP1);
10017 P_BLOCK(TEMP12);
10018 L_BPST1:
10019 D(D_A(XPTR) + VALUE_) = D(TEMP12);
10020 goto L_BP99;
10021 L_BPNOST:
10022 D(BP_ORG) = D(D_A(TEMP1) + ORG_);
10023 D_A(BP_ORG) = D_V(BP_ORG);
10024 D_F(BP_ORG) = D_V(BP_ORG) = 0;
10025 switch (D_A(BP_ORG)) {
10026 case 1:
10027 goto L_BPORG1;
10028 case 2:
10029 goto L_BPORG2;
10030 case 3:
10031 goto L_BPORG3;
10032 case 4:
10033 goto L_BPORG4;
10034 case 5:
10035 goto L_BPORG5;
10036 case 6:
10037 goto L_BPORG6;
10038 case 7:
10039 goto L_BPORG7;
10040 case 8:
10041 goto L_BPORG8;
10042 case 9:
10043 goto L_BPORG9;
10044 }
10045 L_BPORG1:
10046 L_BPORG2:
10047 L_BPORG3:
10048 PUSH(XPTR);
10049 PUSH(TEMP1);
10050 SAVSTK();
10051 PUSH(XPTR);
10052 AFRAME(TEMP3);
10053 POP(TEMP1);
10054 POP(XPTR);
10055 D(BP_ORG) = D(D_A(TEMP1) + ORG_);
10056 D_A(BP_ORG) = D_V(BP_ORG);
10057 D_F(BP_ORG) = D_V(BP_ORG) = 0;
10058 D_A(BP_DIR) = D_A(BP_ORG);
10059 D_A(BP_DIR) *= DESCR;
10060 D_F(BP_DIR) = D_V(BP_DIR) = 0;
10061 D(TEMP2) = D(D_A(XPTR) + TNREG_);
10062 D(TEMP4) = D(D_A(TEMP3) + D_A(BP_DIR));
10063 if (D_V(TEMP4) != AEDGEDT)
10064 goto L_BPCONT1;
10065 D(BP_N) = D(ZEROCL);
10066 D(BP_L) = D(ZEROCL);
10067 L_BPCONT2:
10068 D_A(BP_N) += DESCR;
10069 D(BP_EDGE) = D(D_A(TEMP4) + VAL_);
10070 if (D_V(BP_EDGE) == EDGDT)
10071 D(XCL) = D(D_A(BP_EDGE) + TR1_);
10072 else
10073 D(XCL) = D(BP_EDGE);
10074 D_A(BP_L) += D_A(XCL);
10075 D(YPTR) = D(D_A(TEMP4) + NEXT_);
10076 if (D_A(YPTR) == 0)
10077 goto L_BPCONT3;
10078 D(TEMP4) = D(YPTR);
10079 goto L_BPCONT2;
10080 L_BPCONT1:
10081 D_A(BP_N) = (int_t) DESCR;
10082 D(TEMP5) = D(TEMP3);
10083 D(BP_L) = D(D_A(TEMP3) + D_A(BP_DIR));
10084 if (D_V(BP_L) == EDGDT)
10085 D(BP_L) = D(D_A(BP_L) + TR1_);
10086 goto L_BPCONT4;
10087 L_BPCONT3:
10088 PUSH(XPTR);
10089 PUSH(TEMP1);
10090 PUSH(TEMP2);
10091 PUSH(TEMP3);
10092 PUSH(BP_DIR);
10093 PUSH(BP_L);
10094 PUSH(BP_N);
10095 D(BP_A) = D(BP_L);
10096 SAVSTK();
10097 PUSH(XPTR);
10098 if (PAR_CONG(YPTR) == 1)
10099 goto L_BPCONT31;
10100 SAVSTK();
10101 PUSH(BP_DIR);
10102 PUSH(YPTR);
10103 FORCING(BP_A);
10104 L_BPCONT31:
10105 POP(BP_N);
10106 POP(BP_L);
10107 POP(BP_DIR);
10108 POP(TEMP3);
10109 POP(TEMP2);
10110 POP(TEMP1);
10111 POP(XPTR);
10112 D_A(BP_A) -= D_A(BP_L);
10113 D_A(BP_N) -= DESCR;
10114 SAVSTK();
10115 PUSH(BP_N);
10116 PUSH(BP_A);
10117 DISTR(TEMP6);
10118 D_A(BP_N) = (int_t) DESCR;
10119 D(TEMP4) = D(D_A(TEMP3) + D_A(BP_DIR));
10120 D(TEMP7) = D(D_A(TEMP4) + VAL_);
10121 if (D_V(TEMP7) != EDGDT)
10122 goto L_BPCONT33;
10123 SAVSTK();
10124 PUSH(TEMP7);
10125 BCOPY(TEMP7);
10126 L_BPCONT33:
10127 D(TEMP4) = D(D_A(TEMP4) + NEXT_);
10128 if (D_A(TEMP4) == 0)
10129 goto L_BPCONT34;
10130 D(BP_L) = D(D_A(TEMP6) + D_A(BP_N));
10131 D_A(BP_N) += DESCR;
10132 SAVSTK();
10133 PUSH(BP_L);
10134 PUSH(TEMP7);
10135 JE_LONGI(TEMP7);
10136 D(BP_L) = D(D_A(TEMP4) + VAL_);
10137 SAVSTK();
10138 PUSH(BP_L);
10139 PUSH(TEMP7);
10140 JE_LONGI(TEMP7);
10141 goto L_BPCONT33;
10142 L_BPCONT34:
10143 D(BP_N) = D(ZEROCL);
10144 SAVSTK();
10145 PUSH(TEMP3);
10146 BCOPY(TEMP5);
10147 D(D_A(TEMP5) + D_A(BP_DIR)) = D(TEMP7);
10148 L_BPCONT4:
10149 SAVSTK();
10150 PUSH(XPTR);
10151 LSOHN(TEMP8);
10152 SAVSTK();
10153 PUSH(TEMP5);
10154 STRIP_F(TEMP9);
10155 D(BP_H) = D(D_A(TEMP9) + HT_);
10156 D(BP_D) = D(D_A(TEMP9) + DTH_);
10157 D(BP_W) = D(D_A(TEMP9) + WTH_);
10158 PUSH(XPTR);
10159 SAVSTK();
10160 PUSH(BP_D);
10161 PUSH(BP_W);
10162 PUSH(BP_H);
10163 if (BLAND(TEMP10) == 1)
10164 goto L_BPCONTNL;
10165 POP(XPTR);
10166 SAVSTK();
10167 PUSH(TEMP9);
10168 IDENT_SB(TEMP11);
10169 SAVSTK();
10170 PUSH(TEMP10);
10171 PUSH(TEMP5);
10172 PUSH(TEMP1);
10173 NP_BLOCK(TEMP12);
10174 L_BPCONT5:
10175 D(BP_T) = D(D_A(TEMP8) + VALUE_);
10176 if (D_V(BP_T) == S)
10177 goto L_T4;
10178 D(TEMP39) = D(D_A(BP_T) + ORG_);
10179 if (D_V(TEMP39) == REP_)
10180 goto L_BPCONT6;
10181 L_T4:
10182 PUSH(TEMP9);
10183 PUSH(XPTR);
10184 PUSH(BP_DIR);
10185 PUSH(BP_N);
10186 PUSH(TEMP2);
10187 PUSH(TEMP5);
10188 PUSH(TEMP6);
10189 PUSH(TEMP8);
10190 PUSH(TEMP10);
10191 PUSH(TEMP11);
10192 PUSH(TEMP12);
10193 SAVSTK();
10194 PUSH(NULVCL);
10195 PUSH(TEMP8);
10196 B_PB(TEMP13);
10197 POP(TEMP12);
10198 POP(TEMP11);
10199 POP(TEMP10);
10200 POP(TEMP8);
10201 POP(TEMP6);
10202 POP(TEMP5);
10203 POP(TEMP2);
10204 POP(BP_N);
10205 POP(BP_DIR);
10206 POP(XPTR);
10207 POP(TEMP9);
10208 D(BP_T) = D(D_A(TEMP13) + FRAME_);
10209 SAVSTK();
10210 PUSH(BP_T);
10211 STRIP_F(TEMP14);
10212 L_BPCONT51:
10213 SAVSTK();
10214 PUSH(TEMP2);
10215 PUSH(BP_DIR);
10216 PUSH(TEMP14);
10217 PUSH(TEMP11);
10218 INIT_SUB(TEMP15);
10219 L_BPCONT52:
10220 D(BP_T) = D(D_A(TEMP13) + ARRAY_);
10221 SAVSTK();
10222 PUSH(TEMP15);
10223 PUSH(BP_T);
10224 PUSH(TEMP9);
10225 PUSH(TEMP10);
10226 INSERT(NORET);
10227 D(TEMP8) = D(D_A(TEMP8) + RSIB_);
10228 if (D_A(TEMP8) != 0)
10229 goto L_BPCONT5;
10230 D(D_A(XPTR) + LSO_) = D(NULVCL);
10231 D(D_A(XPTR) + VALUE_) = D(TEMP12);
10232 goto L_BP99;
10233 L_BPCONT6:
10234 D_A(BP_N) += DESCR;
10235 D(BP_L) = D(D_A(TEMP6) + D_A(BP_N));
10236 PUSH(TEMP2);
10237 PUSH(TEMP5);
10238 PUSH(TEMP6);
10239 PUSH(TEMP8);
10240 PUSH(TEMP9);
10241 PUSH(TEMP10);
10242 PUSH(TEMP11);
10243 PUSH(TEMP12);
10244 PUSH(XPTR);
10245 PUSH(BP_L);
10246 PUSH(BP_DIR);
10247 PUSH(BP_N);
10248 SAVSTK();
10249 PUSH(BP_L);
10250 PUSH(TEMP8);
10251 B_PB(TEMP13);
10252 POP(BP_N);
10253 POP(BP_DIR);
10254 POP(BP_L);
10255 POP(XPTR);
10256 POP(TEMP12);
10257 POP(TEMP11);
10258 POP(TEMP10);
10259 POP(TEMP9);
10260 POP(TEMP8);
10261 POP(TEMP6);
10262 POP(TEMP5);
10263 POP(TEMP2);
10264 D(TEMP14) = D(D_A(TEMP13) + FRAME_);
10265 D(BP_T) = D(D_A(TEMP14) + D_A(BP_DIR));
10266 if (D_A(BP_T) == D_A(BP_L))
10267 goto L_BPCONT8;
10268 SAVSTK();
10269 PUSH(TEMP5);
10270 BCOPY(TEMP16);
10271 SAVSTK();
10272 PUSH(TEMP5);
10273 BCOPY(TEMP17);
10274 D(BP_DIF) = D(BP_L);
10275 D_A(BP_DIF) -= D_A(BP_T);
10276 if (D_A(BP_TWO) == 0)
10277 BRANCH(FAIL)
10278 CLR_MATH_ERROR();
10279 D(BP_PREF) = D(BP_DIF);
10280 D_A(BP_PREF) /= D_A(BP_TWO);
10281 if (MATH_ERROR())
10282 BRANCH(FAIL)
10283 D(D_A(TEMP16) + D_A(BP_DIR)) = D(BP_PREF);
10284 D(BP_T) = D(BP_DIF);
10285 D_A(BP_T) -= D_A(BP_PREF);
10286 D(D_A(TEMP17) + D_A(BP_DIR)) = D(BP_T);
10287 SAVSTK();
10288 PUSH(TEMP2);
10289 PUSH(BP_DIR);
10290 PUSH(TEMP16);
10291 PUSH(TEMP11);
10292 INIT_SUB(NORET);
10293 SAVSTK();
10294 PUSH(TEMP2);
10295 PUSH(BP_DIR);
10296 PUSH(TEMP14);
10297 PUSH(TEMP11);
10298 INIT_SUB(TEMP15);
10299 SAVSTK();
10300 PUSH(TEMP2);
10301 PUSH(BP_DIR);
10302 PUSH(TEMP17);
10303 PUSH(TEMP11);
10304 INIT_SUB(NORET);
10305 goto L_BPCONT52;
10306 L_BPCONT8:
10307 goto L_BPCONT51;
10308 L_BPCONTNL:
10309 SAVSTK();
10310 PUSH(NULVCL);
10311 PUSH(TEMP5);
10312 PUSH(TEMP1);
10313 NP_BLOCK(TEMP12);
10314 D(D_A(XPTR) + LSO_) = D(NULVCL);
10315 D(D_A(XPTR) + VALUE_) = D(TEMP12);
10316 goto L_BP99;
10317 L_BPORG4:
10318 BRANCH(BMORG4)
10319 L_BPORG5:
10320 BRANCH(BMORG5)
10321 L_BPORG6:
10322 BRANCH(BMORG6)
10323 L_BPORG7:
10324 BRANCH(BMORG7)
10325 L_BP99:
10326 D(retval) = D(TEMP12);
10327 RETURN(1)
10328 L_BPORG8:
10329 D_A(ERRTYP) = (int_t) (ERRNO+1);
10330 BRANCH(FTLEND)
10331 L_BPORG9:
10332 D(TEMP12) = D(TEMP1);
10333 goto L_BP99;
10334 }
10335 static int
BMORG4(ret_t retval)10336 BMORG4(ret_t retval) {
10337 ENTRY(BMORG4)
10338 SAVSTK();
10339 PUSH(XPTR);
10340 LSOHN(TEMP8);
10341 PUSH(XPTR);
10342 PUSH(TEMP8);
10343 SAVSTK();
10344 PUSH(TEMP8);
10345 AFRAME(TEMP5);
10346 POP(TEMP8);
10347 POP(XPTR);
10348 SAVSTK();
10349 PUSH(TEMP5);
10350 BCOPY(TEMP5);
10351 D(TEMP32) = D(ZEROCL);
10352 L_BPMRG51:
10353 D_A(TEMP32) += DESCR;
10354 if (D_A(TEMP32) > FRSIZE_)
10355 goto L_BPMRG52;
10356 D(TEMP31) = D(D_A(TEMP5) + D_A(TEMP32));
10357 SAVSTK();
10358 PUSH(TEMP31);
10359 CAE(TEMP31);
10360 D(D_A(TEMP5) + D_A(TEMP32)) = D(TEMP31);
10361 goto L_BPMRG51;
10362 L_BPMRG52:
10363 D(TEMP31) = D(NULVCL);
10364 L_BPMRG1:
10365 D(TEMP8) = D(D_A(TEMP8) + RSIB_);
10366 if (D_A(TEMP8) == 0)
10367 goto L_BPMRG2;
10368 PUSH(XPTR);
10369 PUSH(TEMP5);
10370 PUSH(TEMP8);
10371 SAVSTK();
10372 PUSH(TEMP8);
10373 AFRAME(TEMP31);
10374 POP(TEMP8);
10375 POP(TEMP5);
10376 POP(XPTR);
10377 SAVSTK();
10378 PUSH(TEMP31);
10379 PUSH(TEMP5);
10380 AF_MERGE(NORET);
10381 goto L_BPMRG1;
10382 L_BPMRG2:
10383 SAVSTK();
10384 PUSH(TEMP5);
10385 COMPFR(NORET);
10386 SAVSTK();
10387 PUSH(TEMP5);
10388 STRIP_F(TEMP9);
10389 D(BM_H) = D(D_A(TEMP9) + HT_);
10390 D(BM_W) = D(D_A(TEMP9) + WTH_);
10391 D(BM_D) = D(D_A(TEMP9) + DTH_);
10392 PUSH(XPTR);
10393 SAVSTK();
10394 PUSH(BM_D);
10395 PUSH(BM_W);
10396 PUSH(BM_H);
10397 if (BLAND(TEMP10) == 1)
10398 BRANCH(BMNULL)
10399 POP(XPTR);
10400 D(TEMP1) = D(D_A(XPTR) + VALUE_);
10401 SAVSTK();
10402 PUSH(TEMP10);
10403 PUSH(TEMP5);
10404 PUSH(TEMP1);
10405 NP_BLOCK(TEMP12);
10406 D(D_A(XPTR) + VALUE_) = D(TEMP12);
10407 D(TEMP8) = D(D_A(XPTR) + LSO_);
10408 L_BPMRG3:
10409 PUSH(XPTR);
10410 PUSH(TEMP8);
10411 PUSH(TEMP12);
10412 SAVSTK();
10413 PUSH(TEMP8);
10414 EMB_PHY(NORET);
10415 POP(TEMP12);
10416 POP(TEMP8);
10417 POP(XPTR);
10418 D(TEMP8) = D(D_A(TEMP8) + RSIB_);
10419 if (D_A(TEMP8) != 0)
10420 goto L_BPMRG3;
10421 D(D_A(XPTR) + LSO_) = D(NULVCL);
10422 BRANCH(BM99)
10423 }
10424 static int
BMORG5(ret_t retval)10425 BMORG5(ret_t retval) {
10426 ENTRY(BMORG5)
10427 D(TEMP31) = D(D_A(XPTR) + LSO_);
10428 PUSH(XPTR);
10429 SAVSTK();
10430 PUSH(TEMP31);
10431 B_PB(TEMP13);
10432 POP(XPTR);
10433 D(TEMP10) = D(D_A(TEMP13) + ARRAY_);
10434 D(TEMP31) = D(D_A(TEMP13) + FRAME_);
10435 SAVSTK();
10436 PUSH(TEMP31);
10437 STRIP_F(TEMP5);
10438 SAVSTK();
10439 PUSH(XPTR);
10440 if (PAR_CONG(BM_PC) == 1)
10441 BRANCH(BMNULL)
10442 D(BM_PCD) = D(D_A(BM_PC) + VALUE_);
10443 if (D_V(BM_PCD) == S)
10444 goto L_BPIT3;
10445 D(TEMP39) = D(D_A(BM_PCD) + ORG_);
10446 if (D_V(TEMP39) != PHY_)
10447 goto L_BPIT3;
10448 D(BM_PCD) = D(D_A(BM_PCD) + BL_);
10449 L_BPIT3:
10450 D(BM_PCD) = D(D_A(BM_PCD) + ORG_);
10451 D_A(BM_PCD) = D_V(BM_PCD);
10452 D_F(BM_PCD) = D_V(BM_PCD) = 0;
10453 D_A(BM_PCD) *= DESCR;
10454 D_F(BM_PCD) = D_V(BM_PCD) = 0;
10455 D(BM_DIR) = D(BM_PCD);
10456 if (D_A(BM_DIR)>= 3*DESCR) {
10457 D_A(BM_DIR) = 0;
10458 D_F(BM_DIR) = D_V(BM_DIR) = 0;
10459 }
10460 D_A(BM_DIR) += DESCR;
10461 L_BPIT1:
10462 PUSH(XPTR);
10463 PUSH(TEMP10);
10464 PUSH(TEMP5);
10465 PUSH(BM_DIR);
10466 PUSH(BM_PC);
10467 PUSH(BM_PCD);
10468 SAVSTK();
10469 PUSH(BM_DIR);
10470 PUSH(BM_PC);
10471 FORCING(TEMP6);
10472 POP(BM_PCD);
10473 POP(BM_PC);
10474 POP(BM_DIR);
10475 POP(TEMP5);
10476 POP(TEMP10);
10477 POP(XPTR);
10478 D(TEMP31) = D(D_A(TEMP5) + D_A(BM_DIR));
10479 if (D_A(TEMP31) == 0)
10480 goto L_BPIT2;
10481 if (D_A(TEMP31) == 0)
10482 BRANCH(FAIL)
10483 CLR_MATH_ERROR();
10484 D_A(TEMP6) /= D_A(TEMP31);
10485 if (MATH_ERROR())
10486 BRANCH(FAIL)
10487 L_BPIT2:
10488 PUSH(BM_PC);
10489 SAVSTK();
10490 PUSH(TEMP6);
10491 PUSH(BM_DIR);
10492 PUSH(TEMP5);
10493 PUSH(TEMP10);
10494 REPL(TEMP10);
10495 POP(BM_PC);
10496 if (D_A(BM_DIR)>= 3*DESCR) {
10497 D_A(BM_DIR) = 0;
10498 D_F(BM_DIR) = D_V(BM_DIR) = 0;
10499 }
10500 D_A(BM_DIR) += DESCR;
10501 if (D_A(BM_DIR) != D_A(BM_PCD))
10502 goto L_BPIT1;
10503 D(TEMP31) = D(D_A(XPTR) + VALUE_);
10504 SAVSTK();
10505 PUSH(TEMP10);
10506 PUSH(TEMP5);
10507 PUSH(TEMP31);
10508 NP_BLOCK(TEMP12);
10509 D(D_A(XPTR) + VALUE_) = D(TEMP12);
10510 D(D_A(XPTR) + LSO_) = D(NULVCL);
10511 BRANCH(BM99)
10512 }
10513 static int
BMORG6(ret_t retval)10514 BMORG6(ret_t retval) {
10515 ENTRY(BMORG6)
10516 D(TEMP31) = D(D_A(XPTR) + FATHER_);
10517 D(BM_PC) = D(D_A(TEMP31) + VALUE_);
10518 D(TEMP32) = D(D_A(BM_PC) + BL_);
10519 D(BM_ORG) = D(D_A(TEMP32) + ORG_);
10520 D_A(BM_DIR) = D_V(BM_ORG);
10521 D_F(BM_DIR) = D_V(BM_DIR) = 0;
10522 D_A(BM_DIR) *= DESCR;
10523 D_F(BM_DIR) = D_V(BM_DIR) = 0;
10524 D(TEMP31) = D(D_A(XPTR) + LSO_);
10525 PUSH(BM_DIR);
10526 PUSH(XPTR);
10527 SAVSTK();
10528 PUSH(NULVCL);
10529 PUSH(TEMP31);
10530 B_PB(TEMP13);
10531 POP(XPTR);
10532 POP(BM_DIR);
10533 D(TEMP10) = D(D_A(TEMP13) + ARRAY_);
10534 D(TEMP31) = D(D_A(TEMP13) + FRAME_);
10535 SAVSTK();
10536 PUSH(TEMP31);
10537 STRIP_F(TEMP5);
10538 POP(BM_A);
10539 D(BM_L) = D(D_A(TEMP5) + D_A(BM_DIR));
10540 if (D_A(BM_L) == 0)
10541 goto L_BPREP1;
10542 CLR_MATH_ERROR();
10543 D_A(BM_A) /= D_A(BM_L);
10544 if (MATH_ERROR())
10545 goto L_BPREP1;
10546 L_BPREP1:
10547 SAVSTK();
10548 PUSH(BM_A);
10549 PUSH(BM_DIR);
10550 PUSH(TEMP5);
10551 PUSH(TEMP10);
10552 REPL(TEMP10);
10553 SAVSTK();
10554 PUSH(TEMP10);
10555 PUSH(TEMP5);
10556 PUSH(NULVCL);
10557 NP_BLOCK(TEMP12);
10558 D(D_A(XPTR) + VALUE_) = D(TEMP12);
10559 D(D_A(XPTR) + LSO_) = D(NULVCL);
10560 BRANCH(BM99)
10561 }
10562 static int
BMORG7(ret_t retval)10563 BMORG7(ret_t retval) {
10564 ENTRY(BMORG7)
10565 D(BM_T) = D(D_A(TEMP1) + ID_);
10566 if (!LOCAPT(TEMP31,TEMP50,BM_T))
10567 goto L_BPND0;
10568 D(TEMP12) = D(D_A(TEMP31) + 2*DESCR);
10569 D(D_A(XPTR) + VALUE_) = D(TEMP12);
10570 BRANCH(BM99)
10571 L_BPND0:
10572 D(TEMP31) = D(D_A(XPTR) + LSO_);
10573 PUSH(XPTR);
10574 PUSH(BM_T);
10575 PUSH(TEMP1);
10576 SAVSTK();
10577 PUSH(NULVCL);
10578 PUSH(TEMP31);
10579 B_PB(TEMP13);
10580 POP(TEMP1);
10581 POP(BM_T);
10582 POP(XPTR);
10583 D(TEMP5) = D(D_A(TEMP13) + FRAME_);
10584 SAVSTK();
10585 PUSH(TEMP5);
10586 BCOPY(TEMP5);
10587 D_A(BM_DIR) = 0;
10588 L_BPND1:
10589 D_A(BM_DIR) += DESCR;
10590 if (D_A(BM_DIR) > DTH_)
10591 goto L_BPND2;
10592 D(TEMP31) = D(D_A(TEMP5) + D_A(BM_DIR));
10593 SAVSTK();
10594 PUSH(BM_0);
10595 PUSH(BM_T);
10596 PUSH(TEMP31);
10597 ADD_NP(TEMP31);
10598 D(D_A(TEMP5) + D_A(BM_DIR)) = D(TEMP31);
10599 goto L_BPND1;
10600 L_BPND2:
10601 D(TEMP31) = D(D_A(TEMP13) + ARRAY_);
10602 SAVSTK();
10603 PUSH(TEMP31);
10604 PUSH(TEMP5);
10605 PUSH(TEMP1);
10606 NP_BLOCK(TEMP12);
10607 D(WCL) = D(TEMP50);
10608 SAVSTK();
10609 BTAIL(TEMP31);
10610 D(D_A(WCL) + D_A(TEMP31)) = D(BM_T);
10611 SAVSTK();
10612 BTAIL(TEMP31);
10613 D(D_A(WCL) + D_A(TEMP31)) = D(TEMP12);
10614 D(TEMP50) = D(WCL);
10615 D(D_A(XPTR) + VALUE_) = D(TEMP12);
10616 BRANCH(BM99)
10617 }
10618 static int
BMNULL(ret_t retval)10619 BMNULL(ret_t retval) {
10620 ENTRY(BMNULL)
10621 D(D_A(XPTR) + LSO_) = D(NULVCL);
10622 SAVSTK();
10623 PUSH(NULVCL);
10624 PUSH(BM_0);
10625 PUSH(BM_0);
10626 PUSH(BM_0);
10627 PUSH(NULVCL);
10628 P_BLOCK(TEMP12);
10629 D(D_A(XPTR) + VALUE_) = D(TEMP12);
10630 BRANCH(BM99)
10631 }
10632 static int
BM99(ret_t retval)10633 BM99(ret_t retval) {
10634 ENTRY(BM99)
10635 D(retval) = D(TEMP12);
10636 RETURN(1)
10637 }
10638 int
BCOPY(ret_t retval)10639 BCOPY(ret_t retval) {
10640 ENTRY(BCOPY)
10641 POP(BC_B1);
10642 D_A(BC_N) = D_V(D_A(BC_B1));
10643 D_F(BC_N) = D_V(BC_N) = 0;
10644 PUSH(BC_B1);
10645 D_V(BC_N) = D_V(BC_B1);
10646 SAVSTK();
10647 PUSH(BC_N);
10648 BLOCK(BC_B2);
10649 POP(BC_B1);
10650 MOVBLK(D_A(BC_B2),D_A(BC_B1),D_A(BC_N));
10651 D(retval) = D(BC_B2);
10652 RETURN(1)
10653 }
10654 static int
BHEAD(ret_t retval)10655 BHEAD(ret_t retval) {
10656 ENTRY(BHEAD)
10657 L_BHEAD0:
10658 D_A(BH_SIZE) = D_V(D_A(WCL));
10659 D_F(BH_SIZE) = D_V(BH_SIZE) = 0;
10660 D(BH_TOP) = D(D_A(WCL) + TOP_);
10661 if (D_A(BH_TOP) >= D_A(BH_SIZE))
10662 goto L_BH_MORE;
10663 D(BH_PTR) = D(WCL);
10664 D_A(BH_PTR) += D_A(BH_TOP);
10665 D_A(BH_TOP) += DESCR;
10666 D(D_A(WCL) + TOP_) = D(BH_TOP);
10667 D(BH_1ST) = D(WCL);
10668 D_A(BH_1ST) += FIRST_;
10669 L_BH1:
10670 D(BH_TEMP) = D(D_A(BH_PTR));
10671 D(D_A(BH_PTR) + DESCR) = D(BH_TEMP);
10672 D_A(BH_PTR) -= DESCR;
10673 if (D_A(BH_PTR) >= D_A(BH_1ST))
10674 goto L_BH1;
10675 RETURN(1)
10676 L_BH_MORE:
10677 SAVSTK();
10678 PUSH(WCL);
10679 MORE(WCL);
10680 goto L_BHEAD0;
10681 }
10682 static int
BLAND(ret_t retval)10683 BLAND(ret_t retval) {
10684 ENTRY(BLAND)
10685 POP(BL_H);
10686 POP(BL_W);
10687 POP(BL_D);
10688 D(BL_L) = D(BL_H);
10689 D_A(BL_L) *= D_A(BL_D);
10690 D_A(BL_L) *= DESCR;
10691 D_F(BL_L) = D_V(BL_L) = 0;
10692 if (D_A(BL_L) == 0)
10693 BRANCH(FAIL)
10694 if (D_A(BL_W) == 0)
10695 BRANCH(FAIL)
10696 D_V(BL_L) = A;
10697 SAVSTK();
10698 PUSH(BL_L);
10699 BLOCK(TEMP31);
10700 SAVSTK();
10701 PUSH(BL_W);
10702 BLANK(TEMP32);
10703 D(D_A(TEMP31) + DESCR) = D(TEMP32);
10704 D(TEMP33) = D(TEMP31);
10705 D_A(TEMP33) += DESCR;
10706 D_A(BL_L) -= DESCR;
10707 if (D_A(BL_L) == 0)
10708 goto L_BL1;
10709 MOVBLK2(D_A(TEMP33),D_A(TEMP31),D_A(BL_L));
10710 L_BL1:
10711 D(retval) = D(TEMP31);
10712 RETURN(2)
10713 }
10714 static int
BLANK(ret_t retval)10715 BLANK(ret_t retval) {
10716 ENTRY(BLANK)
10717 POP(BK_N);
10718 L_BKB:
10719 S_L(YSP) = D_A(BK_N);
10720 if (D_A(TEMP49) == 0)
10721 goto L_BK3;
10722 if (DCMP(BKGNCL, TEMP26))
10723 goto L_BK2;
10724 if (D_V(BKGNCL) != S)
10725 goto L_BK2;
10726 if (D_A(BKGNCL) == 0)
10727 goto L_BK2;
10728 D(TEMP26) = D(BKGNCL);
10729 D(TEMP49) = D(BKGNCL);
10730 L_BK2:
10731 X_LOCSP(ZSP,TEMP49);
10732 if (S_L(ZSP) < S_L(YSP))
10733 goto L_BK1;
10734 S_L(ZSP) = S_L(YSP);
10735 SAVSTK();
10736 PUSH(ZSPPTR);
10737 GENVAR(YPTR);
10738 D(retval) = D(YPTR);
10739 RETURN(1)
10740 L_BK1:
10741 D(XPTR) = D(TEMP49);
10742 D(YPTR) = D(TEMP49);
10743 SAVSTK();
10744 switch (CONVV(TEMP49)) {
10745 case 1:
10746 case 2:
10747 BRANCH(FAIL)
10748 case 3:
10749 goto L_BKB;
10750 }
10751 L_BK3:
10752 SAVSTK();
10753 PUSH(BK_PTR);
10754 GENVAR(TEMP49);
10755 D(TEMP26) = D(TEMP49);
10756 goto L_BKB;
10757 }
10758 int
HEIGHT(ret_t retval)10759 HEIGHT(ret_t retval) {
10760 ENTRY(HEIGHT)
10761 D_A(BS_DIR) = (int_t) HT_;
10762 BRANCH(BLS2)
10763 }
10764 int
WIDTH(ret_t retval)10765 WIDTH(ret_t retval) {
10766 ENTRY(WIDTH)
10767 D_A(BS_DIR) = (int_t) WTH_;
10768 BRANCH(BLS2)
10769 }
10770 int
DEPTH(ret_t retval)10771 DEPTH(ret_t retval) {
10772 ENTRY(DEPTH)
10773 D_A(BS_DIR) = (int_t) DTH_;
10774 BRANCH(BLS2)
10775 }
10776 static int
BLS2(ret_t retval)10777 BLS2(ret_t retval) {
10778 ENTRY(BLS2)
10779 if (D_V(INCL) != 1)
10780 goto L_BLS3;
10781 SAVSTK();
10782 if (BLOKVAL(BS_B) == 1)
10783 BRANCH(FAIL)
10784 BRANCH(BLS1)
10785 L_BLS3:
10786 if (D_V(INCL) != 0)
10787 BRANCH(ARGNER)
10788 D(BS_B) = D(NULVCL);
10789 BRANCH(BLS1)
10790 }
10791 int
BLOCKSIZ(ret_t retval)10792 BLOCKSIZ(ret_t retval) {
10793 ENTRY(BLOCKSIZ)
10794 if (D_V(INCL) != 2)
10795 BRANCH(ARGNER)
10796 SAVSTK();
10797 if (BLOKVAL(BS_B) == 1)
10798 BRANCH(FAIL)
10799 PUSH(BS_B);
10800 SAVSTK();
10801 if (INTVAL(BS_DIR) == 1)
10802 BRANCH(FAIL)
10803 POP(BS_B);
10804 D_A(BS_DIR)++;
10805 D_A(BS_DIR) *= DESCR;
10806 D_F(BS_DIR) = D_V(BS_DIR) = 0;
10807 BRANCH(BLS1)
10808 }
10809 static int
BLS1(ret_t retval)10810 BLS1(ret_t retval) {
10811 ENTRY(BLS1)
10812 SAVSTK();
10813 PUSH(BS_B);
10814 PUSH(BS_B);
10815 FIXINL(BS_B);
10816 D(BS_B) = D(D_A(BS_B) + FRAME_);
10817 D(BS_B) = D(D_A(BS_B) + D_A(BS_DIR));
10818 D_V(BS_B) = I;
10819 D(retval) = D(BS_B);
10820 RETURN(3)
10821 }
10822 static int
BLOKVAL(ret_t retval)10823 BLOKVAL(ret_t retval) {
10824 ENTRY(BLOKVAL)
10825 SAVSTK();
10826 if (ARGVAL(XPTR) == 1)
10827 BRANCH(FAIL)
10828 if (D_V(XPTR) == BL)
10829 BRANCH(RTXNAM)
10830 if (D_V(XPTR) == S)
10831 BRANCH(RTXNAM)
10832 if (D_V(XPTR) != R)
10833 goto L_BLOKV1;
10834 REALST(REALSP,XPTR);
10835 _SPEC(XSP) = _SPEC(REALSP);
10836 SAVSTK();
10837 PUSH(XSPPTR);
10838 if (GENVAR(XPTR) == 1)
10839 BRANCH(RTXNAM)
10840 L_BLOKV1:
10841 if (D_V(XPTR) == I)
10842 goto L_BLOKVI;
10843 else
10844 BRANCH(INTR1)
10845 L_BLOKVI:
10846 SAVSTK();
10847 PUSH(XPTR);
10848 if (GNVARI(XPTR) == 1)
10849 BRANCH(RTXNAM)
10850 /* FALL */
10851 BRANCH(FRONT)
10852 }
10853 int
FRONT(ret_t retval)10854 FRONT(ret_t retval) {
10855 ENTRY(FRONT)
10856 BRANCH(BOX)
10857 }
10858 int
VER(ret_t retval)10859 VER(ret_t retval) {
10860 ENTRY(VER)
10861 BRANCH(BOX)
10862 }
10863 int
HOR(ret_t retval)10864 HOR(ret_t retval) {
10865 ENTRY(HOR)
10866 SAVSTK();
10867 if (INTVAL(BX_W) == 1)
10868 BRANCH(FAIL)
10869 if (D_A(BX_W) < 0)
10870 BRANCH(FAIL)
10871 D(BX_H) = D(BX_ZERO);
10872 D(BX_D) = D(BX_ZERO);
10873 BRANCH(BOXIN)
10874 }
10875 int
BOX(ret_t retval)10876 BOX(ret_t retval) {
10877 ENTRY(BOX)
10878 D_A(TEMP1) = D_V(INCL);
10879 D_F(TEMP1) = D_V(TEMP1) = 0;
10880 PUSH(TEMP1);
10881 SAVSTK();
10882 if (INTVAL(BX_H) == 1)
10883 BRANCH(FAIL)
10884 POP(TEMP1);
10885 if (D_A(BX_H) < 0)
10886 BRANCH(LENERR)
10887 D(BX_W) = D(BX_ZERO);
10888 if (D_A(TEMP1) <= 1)
10889 goto L_BOX2;
10890 PUSH(TEMP1);
10891 PUSH(BX_H);
10892 SAVSTK();
10893 if (INTVAL(BX_W) == 1)
10894 BRANCH(FAIL)
10895 POP(BX_H);
10896 POP(TEMP1);
10897 if (D_A(BX_W) < 0)
10898 BRANCH(LENERR)
10899 L_BOX2:
10900 D(BX_D) = D(BX_ZERO);
10901 if (D_A(TEMP1) <= 2)
10902 goto L_BOX3;
10903 PUSH(BX_H);
10904 PUSH(BX_W);
10905 SAVSTK();
10906 if (INTVAL(BX_D) == 1)
10907 BRANCH(FAIL)
10908 POP(BX_W);
10909 POP(BX_H);
10910 if (D_A(BX_D) < 0)
10911 BRANCH(LENERR)
10912 L_BOX3:
10913 BRANCH(BOXIN)
10914 }
10915 static int
BOXIN(ret_t retval)10916 BOXIN(ret_t retval) {
10917 ENTRY(BOXIN)
10918 SAVSTK();
10919 PUSH(BX_D);
10920 PUSH(BX_W);
10921 PUSH(BX_H);
10922 if (BLAND(XPTR) == 1)
10923 goto L_BOXNL;
10924 L_BOX4:
10925 SAVSTK();
10926 PUSH(XPTR);
10927 PUSH(BX_D);
10928 PUSH(BX_W);
10929 PUSH(BX_H);
10930 PUSH(NULVCL);
10931 P_BLOCK(XPTR);
10932 BRANCH(RTXPTR)
10933 L_BOXNL:
10934 D(XPTR) = D(NULVCL);
10935 goto L_BOX4;
10936 }
10937 static int
BTAIL(ret_t retval)10938 BTAIL(ret_t retval) {
10939 ENTRY(BTAIL)
10940 L_BTAIL0:
10941 D_A(BT_SIZE) = D_V(D_A(WCL));
10942 D_F(BT_SIZE) = D_V(BT_SIZE) = 0;
10943 D(BT_TOP) = D(D_A(WCL) + TOP_);
10944 if (D_A(BT_TOP) >= D_A(BT_SIZE))
10945 goto L_BT_MORE;
10946 D_A(BT_TOP) += DESCR;
10947 D(D_A(WCL) + TOP_) = D(BT_TOP);
10948 D(retval) = D(BT_TOP);
10949 RETURN(1)
10950 L_BT_MORE:
10951 SAVSTK();
10952 PUSH(WCL);
10953 MORE(WCL);
10954 goto L_BTAIL0;
10955 }
10956 static int
CAE(ret_t retval)10957 CAE(ret_t retval) {
10958 ENTRY(CAE)
10959 POP(TEMP35);
10960 if (D_V(TEMP35) != AEDGDT)
10961 goto L_CA99;
10962 SAVSTK();
10963 PUSH(TEMP35);
10964 BCOPY(TEMP35);
10965 D(TEMP36) = D(D_A(TEMP35) + NEXT_);
10966 PUSH(TEMP35);
10967 SAVSTK();
10968 PUSH(TEMP36);
10969 CAE(TEMP36);
10970 POP(TEMP35);
10971 D(D_A(TEMP35) + NEXT_) = D(TEMP36);
10972 L_CA99:
10973 D(retval) = D(TEMP35);
10974 RETURN(1)
10975 }
10976 int
BCHAR(ret_t retval)10977 BCHAR(ret_t retval) {
10978 ENTRY(BCHAR)
10979 if (D_V(INCL) != 1)
10980 goto L_CH1;
10981 SAVSTK();
10982 if (BLOKVAL(ZPTR) == 1)
10983 BRANCH(FAIL)
10984 SAVSTK();
10985 PUSH(ZPTR);
10986 PUSH(ZPTR);
10987 FIXINL(ZPTR);
10988 D(CH_F) = D(D_A(ZPTR) + FRAME_);
10989 D(TEMP1) = D(D_A(ZPTR) + ARRAY_);
10990 D(CH_H) = D(D_A(CH_F) + HT_);
10991 D(CH_D) = D(D_A(CH_F) + DTH_);
10992 D_V(CH_H1) = D_A(CH_H);
10993 D_V(CH_D1) = D_A(CH_D);
10994 D(TEMP3) = D(CH_H);
10995 D_A(TEMP3) *= D_A(CH_D);
10996 D_A(TEMP2) = D_A(TEMP3);
10997 D_A(TEMP2) *= DESCR;
10998 D_F(TEMP2) = D_V(TEMP2) = 0;
10999 D_A(CH_LG) = D_A(TEMP2);
11000 D_A(TEMP2) += D_A(CH_DL);
11001 D_V(TEMP2) = A;
11002 SAVSTK();
11003 PUSH(TEMP2);
11004 BLOCK(YPTR);
11005 _SPEC(TSP) = _SPEC(CH_SPEC);
11006 S_L(TSP) = D_A(ZEROCL);
11007 INTSPC(XSP,CH_D);
11008 APDSP(TSP,XSP);
11009 APDSP(TSP,CMASP);
11010 INTSPC(XSP,CH_H);
11011 APDSP(TSP,XSP);
11012 SAVSTK();
11013 PUSH(TSPPTR);
11014 GENVAR(CH_PR);
11015 MOVBLK(D_A(YPTR),D_A(CH_DOPE),D_A(CH_DL));
11016 D(TPTR) = D(YPTR);
11017 D_A(TPTR) += D_A(CH_DL);
11018 if (D_A(TEMP1) == 0)
11019 goto L_CH2;
11020 MOVBLK(D_A(TPTR),D_A(TEMP1),D_A(CH_LG));
11021 L_CH3:
11022 BRANCH(RTYPTR)
11023 L_CH1:
11024 if (D_V(INCL) == 0)
11025 BRANCH(RETNUL)
11026 else
11027 BRANCH(ARGNER)
11028 L_CH2:
11029 if (D_A(CH_LG) == 0)
11030 goto L_CH3;
11031 D(TEMP4) = D(CH_LG);
11032 D_A(TEMP4) -= DESCR;
11033 D(D_A(TPTR) + DESCR) = D(NULVCL);
11034 D(TEMP5) = D(TPTR);
11035 D_A(TEMP5) += DESCR;
11036 if (D_A(TEMP4) == 0)
11037 goto L_CH3;
11038 MOVBLK(D_A(TEMP5),D_A(TPTR),D_A(TEMP4));
11039 goto L_CH3;
11040 }
11041 static int
CIR(ret_t retval)11042 CIR(ret_t retval) {
11043 ENTRY(CIR)
11044 POP(CI_A1);
11045 POP(CI_N1);
11046 POP(CI_A2);
11047 POP(CI_N2);
11048 POP(CI_D);
11049 if (D_A(CI_N2) != 0)
11050 goto L_CIR11;
11051 D(CI_CI) = D(CI_A1);
11052 goto L_CI99;
11053 L_CIR11:
11054 if (D_A(CI_N1) != 0)
11055 goto L_CIR12;
11056 if (D_A(CI_D) != 0)
11057 goto L_CIR12;
11058 D(CI_CI) = D(CI_A2);
11059 goto L_CI99;
11060 L_CIR12:
11061 D_A(CI_N1) *= DESCR;
11062 D_F(CI_N1) = D_V(CI_N1) = 0;
11063 D_A(CI_N2) *= DESCR;
11064 D_F(CI_N2) = D_V(CI_N2) = 0;
11065 D(TEMP31) = D(CI_N1);
11066 D_A(TEMP31) += D_A(CI_N2);
11067 PUSH(CI_A1);
11068 PUSH(CI_A2);
11069 D_V(TEMP31) = A;
11070 SAVSTK();
11071 PUSH(TEMP31);
11072 BLOCK(CI_CI);
11073 POP(CI_A2);
11074 POP(CI_A1);
11075 MOVBLK(D_A(CI_CI),D_A(CI_A1),D_A(CI_N1));
11076 D_A(CI_J) = 0;
11077 D(TEMP31) = D(CI_CI);
11078 D_A(TEMP31) += D_A(CI_N1);
11079 L_CIR1:
11080 if (D_A(CI_J) >= D_A(CI_N2))
11081 goto L_CI99;
11082 D_A(CI_J) += DESCR;
11083 D(TEMP32) = D(D_A(CI_A2) + D_A(CI_J));
11084 D_A(TEMP33) = D_V(TEMP32);
11085 D_F(TEMP33) = D_V(TEMP33) = 0;
11086 D_A(TEMP33) += D_A(CI_D);
11087 D_V(TEMP32) = D_A(TEMP33);
11088 D(D_A(TEMP31) + D_A(CI_J)) = D(TEMP32);
11089 goto L_CIR1;
11090 L_CI99:
11091 D(retval) = D(CI_CI);
11092 RETURN(1)
11093 }
11094 static int
CLASS(ret_t retval)11095 CLASS(ret_t retval) {
11096 ENTRY(CLASS)
11097 POP(CL_B);
11098 if (D_V(CL_B) != S)
11099 goto L_CLASS1;
11100 D_A(CL_CLASS) = 0;
11101 L_CLASS2:
11102 D(retval) = D(CL_CLASS);
11103 RETURN(1)
11104 L_CLASS1:
11105 D_A(CL_CLASS) = 1;
11106 D(CL_REG) = D(D_A(CL_B) + SET_);
11107 if (D_V(CL_REG) != 0)
11108 goto L_CLASS3;
11109 D(CL_B) = D(D_A(CL_B) + ORG_);
11110 if (D_V(CL_B) == D_V(TEMP1))
11111 goto L_CLASS2;
11112 L_CLASS3:
11113 D_A(CL_CLASS)++;
11114 goto L_CLASS2;
11115 }
11116 int
COAG(ret_t retval)11117 COAG(ret_t retval) {
11118 ENTRY(COAG)
11119 POP(TEMP45);
11120 POP(TEMP46);
11121 D(TEMP47) = D(TEMP45);
11122 D_A(CO_HIT) = 0;
11123 L_COAG2:
11124 D(TEMP31) = D(D_A(TEMP45) + VAL_);
11125 SAVSTK();
11126 PUSH(TEMP46);
11127 PUSH(TEMP31);
11128 if (MINGLE(TEMP46) == 1)
11129 goto L_COAG1;
11130 D_A(CO_HIT) = 1;
11131 D(D_A(TEMP45) + VAL_) = D(ZEROCL);
11132 L_COAG1:
11133 if (D_A(D_A(TEMP45) + NEXT_) == (int_t)0)
11134 goto L_COAG11;
11135 D(TEMP45) = D(D_A(TEMP45) + NEXT_);
11136 goto L_COAG2;
11137 L_COAG11:
11138 if (D_A(CO_HIT) != 0)
11139 goto L_COAG12;
11140 SAVSTK();
11141 PUSH(CO_DE);
11142 BLOCK(TEMP31);
11143 D(D_A(TEMP31) + VAL_) = D(TEMP46);
11144 D(D_A(TEMP45) + NEXT_) = D(TEMP31);
11145 goto L_COAG99;
11146 L_COAG12:
11147 D(TEMP45) = D(TEMP47);
11148 L_COAG3:
11149 if (D_A(D_A(TEMP45) + VAL_) == (int_t)0)
11150 goto L_COAG31;
11151 D(TEMP45) = D(D_A(TEMP45) + NEXT_);
11152 goto L_COAG3;
11153 L_COAG31:
11154 D(D_A(TEMP45) + VAL_) = D(TEMP46);
11155 L_COAG4:
11156 if (D_A(D_A(TEMP45) + NEXT_) == (int_t)0)
11157 goto L_COAG99;
11158 D(TEMP31) = D(D_A(TEMP45) + NEXT_);
11159 if (D_A(D_A(TEMP31) + VAL_) != (int_t)0)
11160 goto L_COAG41;
11161 D(TEMP31) = D(D_A(TEMP31) + NEXT_);
11162 D(D_A(TEMP45) + NEXT_) = D(TEMP31);
11163 goto L_COAG4;
11164 L_COAG41:
11165 D(TEMP45) = D(D_A(TEMP45) + NEXT_);
11166 goto L_COAG4;
11167 L_COAG99:
11168 BRANCH(RTN1)
11169 }
11170 static int
COMPFR(ret_t retval)11171 COMPFR(ret_t retval) {
11172 ENTRY(COMPFR)
11173 POP(CF_AF);
11174 D_A(CF_DIR) = (int_t) HT_;
11175 L_CF2:
11176 D(CF_E) = D(D_A(CF_AF) + D_A(CF_DIR));
11177 if (D_V(CF_E) != AEDGDT)
11178 goto L_CF1;
11179 if (D_A(D_A(CF_E) + NEXT_) != (int_t)0)
11180 goto L_CF3;
11181 D(CF_E) = D(D_A(CF_E) + VAL_);
11182 D(D_A(CF_AF) + D_A(CF_DIR)) = D(CF_E);
11183 goto L_CF1;
11184 L_CF3:
11185 io_printf(D_A(CF_UNIT),CF_FMT);
11186 SAVSTK();
11187 WARNING(NORET);
11188 D(TEMP31) = D(D_A(CF_E) + VAL_);
11189 L_CF5:
11190 D(CF_E) = D(D_A(CF_E) + NEXT_);
11191 if (D_A(CF_E) == 0)
11192 goto L_CF4;
11193 D(TEMP32) = D(D_A(CF_E) + VAL_);
11194 PUSH(CF_AF);
11195 PUSH(CF_E);
11196 SAVSTK();
11197 PUSH(TEMP32);
11198 PUSH(TEMP31);
11199 JE_LONGI(TEMP31);
11200 POP(CF_E);
11201 POP(CF_AF);
11202 goto L_CF5;
11203 L_CF4:
11204 D(D_A(CF_AF) + D_A(CF_DIR)) = D(TEMP31);
11205 L_CF1:
11206 D_A(CF_DIR) += DESCR;
11207 if (D_A(CF_DIR) <= DTH_)
11208 goto L_CF2;
11209 else
11210 BRANCH(RTN1)
11211 }
11212 static int
DISTR(ret_t retval)11213 DISTR(ret_t retval) {
11214 ENTRY(DISTR)
11215 POP(DI_A);
11216 POP(DI_N);
11217 D_V(DI_N) = A;
11218 SAVSTK();
11219 PUSH(DI_N);
11220 BLOCK(DI_DI);
11221 L_DI1:
11222 if (D_A(DI_N) <= 0)
11223 goto L_DI99;
11224 if (D_A(DI_DSC) == 0)
11225 BRANCH(FAIL)
11226 CLR_MATH_ERROR();
11227 D(DI_M) = D(DI_N);
11228 D_A(DI_M) /= D_A(DI_DSC);
11229 if (MATH_ERROR())
11230 BRANCH(FAIL)
11231 if (D_A(DI_M) == 0)
11232 BRANCH(FAIL)
11233 CLR_MATH_ERROR();
11234 D(DI_V) = D(DI_A);
11235 D_A(DI_V) /= D_A(DI_M);
11236 if (MATH_ERROR())
11237 BRANCH(FAIL)
11238 D(D_A(DI_DI) + D_A(DI_N)) = D(DI_V);
11239 D_A(DI_A) -= D_A(DI_V);
11240 D_A(DI_N) -= DESCR;
11241 goto L_DI1;
11242 L_DI99:
11243 D(retval) = D(DI_DI);
11244 RETURN(1)
11245 }
11246 static int
DUMP_B(ret_t retval)11247 DUMP_B(ret_t retval) {
11248 ENTRY(DUMP_B)
11249 io_printf(D_A(DP_UNIT),DP_FT1);
11250 POP(DP_BLOCK);
11251 D_A(DP_TEMP) = D_A(D_A(DP_BLOCK));
11252 if (D_A(DP_TEMP) != D_A(DP_BLOCK))
11253 goto L_DP_NOBLK;
11254 D_A(DP_I) = 0;
11255 D_A(DP_SIZE) = D_V(D_A(DP_BLOCK));
11256 D_F(DP_SIZE) = D_V(DP_SIZE) = 0;
11257 L_DP_LOOP:
11258 D(DP_TEMP) = D(D_A(DP_BLOCK) + D_A(DP_I));
11259 io_printf(D_A(DP_UNIT),DP_FT2,DP_TEMP,DP_TEMP,DP_TEMP);
11260 if (D_A(DP_I) >= D_A(DP_SIZE))
11261 goto L_DP_END;
11262 D_A(DP_I) += DESCR;
11263 goto L_DP_LOOP;
11264 L_DP_NOBLK:
11265 L_DP_END:
11266 RETURN(1)
11267 }
11268 static int
DUMP_A(ret_t retval)11269 DUMP_A(ret_t retval) {
11270 ENTRY(DUMP_A)
11271 POP(DP_BLOCK);
11272 if (D_A(DP_BLOCK) != 0)
11273 goto L_DP1;
11274 io_printf(D_A(DP_UNIT),DP_FT3,ZEROCL);
11275 BRANCH(RTN1)
11276 L_DP1:
11277 D_A(DP_SIZE) = D_V(D_A(DP_BLOCK));
11278 D_F(DP_SIZE) = D_V(DP_SIZE) = 0;
11279 if (D_A(DP_8) == 0)
11280 BRANCH(FAIL)
11281 CLR_MATH_ERROR();
11282 D(DP_TEMP) = D(DP_SIZE);
11283 D_A(DP_TEMP) /= D_A(DP_8);
11284 if (MATH_ERROR())
11285 BRANCH(FAIL)
11286 io_printf(D_A(DP_UNIT),DP_FT3,DP_TEMP);
11287 D_A(DP_I) = (int_t) DESCR;
11288 L_DP_LP:
11289 D(DP_TEMP) = D(D_A(DP_BLOCK) + D_A(DP_I));
11290 X_LOCSP(YSP,DP_TEMP);
11291 FASTPR(IOKEY,DP_UNIT,DP_UNIT,YSP,BLSP);
11292 D_A(DP_I) += DESCR;
11293 if (D_A(DP_I) <= D_A(DP_SIZE))
11294 goto L_DP_LP;
11295 else
11296 BRANCH(RTN1)
11297 }
11298 int
DUP(ret_t retval)11299 DUP(ret_t retval) {
11300 ENTRY(DUP)
11301 D_A(DUP_NA) = D_V(INCL);
11302 D_F(DUP_NA) = D_V(DUP_NA) = 0;
11303 if (D_A(DUP_NA) != 3)
11304 BRANCH(ARGNER)
11305 SAVSTK();
11306 if (BLOKVAL(XPTR) == 1)
11307 BRANCH(FAIL)
11308 if (D_V(XPTR) == S)
11309 goto L_DUP2;
11310 D(TEMP39) = D(D_A(XPTR) + ORG_);
11311 if (D_V(TEMP39) != PHY_)
11312 goto L_DUP2;
11313 SAVSTK();
11314 PUSH(XPTR);
11315 BCOPY(XPTR);
11316 L_DUP2:
11317 PUSH(XPTR);
11318 SAVSTK();
11319 if (INTVAL(DUP_DIR) == 1)
11320 BRANCH(FAIL)
11321 PUSH(DUP_DIR);
11322 SAVSTK();
11323 if (INTVAL(DUP_N) == 1)
11324 BRANCH(FAIL)
11325 POP(DUP_DIR);
11326 POP(XPTR);
11327 if (D_A(DUP_N) < 0)
11328 BRANCH(FAIL)
11329 if (D_V(XPTR) != S)
11330 goto L_DUP1;
11331 if (D_A(DUP_DIR) != 1)
11332 goto L_DUP1;
11333 SAVSTK();
11334 PUSH(DUP_N);
11335 PUSH(XPTR);
11336 if (DUPE(XPTR) == 1)
11337 BRANCH(RTXPTR)
11338 L_DUP1:
11339 SAVSTK();
11340 PUSH(XPTR);
11341 PUSH(XPTR);
11342 FIXINL(XPTR);
11343 D_A(DUP_DIR)++;
11344 D_A(DUP_DIR) *= DESCR;
11345 D_F(DUP_DIR) = D_V(DUP_DIR) = 0;
11346 D(TEMP1) = D(D_A(XPTR) + ARRAY_);
11347 D(TEMP2) = D(D_A(XPTR) + FRAME_);
11348 PUSH(XPTR);
11349 SAVSTK();
11350 PUSH(DUP_N);
11351 PUSH(DUP_DIR);
11352 PUSH(TEMP2);
11353 PUSH(TEMP1);
11354 REPL(TEMP1);
11355 POP(XPTR);
11356 D(D_A(XPTR) + ARRAY_) = D(TEMP1);
11357 BRANCH(RTXPTR)
11358 }
11359 static int
DUPE(ret_t retval)11360 DUPE(ret_t retval) {
11361 ENTRY(DUPE)
11362 POP(YPTR);
11363 POP(DU_N);
11364 if (D_A(DU_N) == 0)
11365 BRANCH(RT1NUL)
11366 X_LOCSP(YSP,YPTR);
11367 D_A(YCL) = S_L(YSP);
11368 D_F(YCL) = D_V(YCL) = 0;
11369 D_A(YCL) *= D_A(DU_N);
11370 if (D_A(YCL) > D_A(MLENCL))
11371 BRANCH(INTR8)
11372 SAVSTK();
11373 PUSH(YCL);
11374 CONVAR(ZPTR);
11375 X_LOCSP(TSP,ZPTR);
11376 S_L(TSP) = 0;
11377 L_DUPE2:
11378 if (D_A(DU_N) <= 0)
11379 goto L_DUPE1;
11380 D_A(DU_N)--;
11381 APDSP(TSP,YSP);
11382 goto L_DUPE2;
11383 L_DUPE1:
11384 SAVSTK();
11385 PUSH(YCL);
11386 GNVARS(ZPTR);
11387 D(retval) = D(ZPTR);
11388 RETURN(1)
11389 }
11390 static int
E_ATTACH(ret_t retval)11391 E_ATTACH(ret_t retval) {
11392 ENTRY(E_ATTACH)
11393 POP(EA_AE);
11394 POP(EA_E);
11395 if (D_V(EA_AE) == AEDGDT)
11396 goto L_EA1;
11397 PUSH(EA_AE);
11398 PUSH(EA_E);
11399 SAVSTK();
11400 PUSH(EA_DE);
11401 BLOCK(EA_T);
11402 POP(EA_E);
11403 POP(EA_AE);
11404 D(D_A(EA_T) + VAL_) = D(EA_AE);
11405 D(EA_AE) = D(EA_T);
11406 L_EA1:
11407 D(EA_T) = D(EA_AE);
11408 L_EA2:
11409 if (D_A(D_A(EA_T) + NEXT_) == (int_t)0)
11410 goto L_EA3;
11411 D(EA_T) = D(D_A(EA_T) + NEXT_);
11412 goto L_EA2;
11413 L_EA3:
11414 PUSH(EA_AE);
11415 PUSH(EA_T);
11416 PUSH(EA_E);
11417 SAVSTK();
11418 PUSH(EA_DE);
11419 BLOCK(TEMP31);
11420 POP(EA_E);
11421 POP(EA_T);
11422 POP(EA_AE);
11423 D(D_A(EA_T) + NEXT_) = D(TEMP31);
11424 D(D_A(TEMP31) + VAL_) = D(EA_E);
11425 D(retval) = D(EA_AE);
11426 RETURN(1)
11427 }
11428 static int
EMB_PHY(ret_t retval)11429 EMB_PHY(ret_t retval) {
11430 ENTRY(EMB_PHY)
11431 POP(XPTR);
11432 D(TEMP31) = D(D_A(XPTR) + VALUE_);
11433 if (D_V(TEMP31) == S)
11434 goto L_EMERR;
11435 D(TEMP39) = D(D_A(TEMP31) + ORG_);
11436 if (D_V(TEMP39) != PHY_)
11437 goto L_EMERR;
11438 D(TEMP1) = D(D_A(TEMP31) + BL_);
11439 D(TEMP3) = D(D_A(TEMP31) + FRAME_);
11440 SAVSTK();
11441 PUSH(TEMP3);
11442 BCOPY(TEMP5);
11443 D(TEMP32) = D(D_A(XPTR) + FATHER_);
11444 D(TEMP33) = D(D_A(TEMP32) + VALUE_);
11445 D(TEMP18) = D(D_A(TEMP33) + FRAME_);
11446 D(TEMP10) = D(D_A(TEMP33) + ARRAY_);
11447 if (D_A(TEMP1) == 0)
11448 goto L_EM4;
11449 D(EM_DIR) = D(D_A(TEMP1) + ORG_);
11450 D_A(EM_DIR) = D_V(EM_DIR);
11451 D_F(EM_DIR) = D_V(EM_DIR) = 0;
11452 D_A(EM_DIR) *= DESCR;
11453 D_F(EM_DIR) = D_V(EM_DIR) = 0;
11454 D(TEMP4) = D(D_A(TEMP3) + D_A(EM_DIR));
11455 if (D_V(TEMP4) != AEDGDT)
11456 goto L_EM11;
11457 D(TEMP31) = D(D_A(TEMP4) + VAL_);
11458 D(D_A(TEMP5) + D_A(EM_DIR)) = D(TEMP31);
11459 L_EM11:
11460 SAVSTK();
11461 PUSH(TEMP18);
11462 STRIP_F(TEMP9);
11463 SAVSTK();
11464 PUSH(TEMP5);
11465 PUSH(TEMP18);
11466 if (SUBBLOCK(TEMP11) == 1)
11467 goto L_EMERR1;
11468 if (D_V(TEMP1) == S)
11469 goto L_EM3;
11470 D(TEMP39) = D(D_A(TEMP1) + ORG_);
11471 D_A(TEMP39) = D_V(TEMP39);
11472 D_F(TEMP39) = D_V(TEMP39) = 0;
11473 if (D_A(TEMP39) > OVY_)
11474 goto L_EM3;
11475 SAVSTK();
11476 PUSH(TEMP11);
11477 BCOPY(TEMP20);
11478 D(TEMP2) = D(D_A(XPTR) + TNREG_);
11479 D(TEMP8) = D(D_A(XPTR) + LSO_);
11480 L_EM1:
11481 D(TEMP31) = D(D_A(TEMP8) + VALUE_);
11482 D(TEMP32) = D(D_A(TEMP31) + FRAME_);
11483 SAVSTK();
11484 PUSH(TEMP32);
11485 STRIP_F(TEMP21);
11486 D(TEMP22) = D(D_A(TEMP31) + ARRAY_);
11487 SAVSTK();
11488 PUSH(TEMP2);
11489 PUSH(EM_DIR);
11490 PUSH(TEMP21);
11491 PUSH(TEMP11);
11492 INIT_SUB(TEMP15);
11493 SAVSTK();
11494 PUSH(TEMP15);
11495 PUSH(TEMP22);
11496 PUSH(TEMP9);
11497 PUSH(TEMP10);
11498 INSERT(NORET);
11499 D(TEMP8) = D(D_A(TEMP8) + RSIB_);
11500 if (D_A(TEMP8) == 0)
11501 goto L_EM99;
11502 D(TEMP31) = D(D_A(TEMP8) + VALUE_);
11503 if (D_V(TEMP31) == S)
11504 goto L_EM1;
11505 D(TEMP39) = D(D_A(TEMP31) + ORG_);
11506 if (D_V(TEMP39) != REP_)
11507 goto L_EM1;
11508 D(TEMP4) = D(D_A(TEMP4) + NEXT_);
11509 D(TEMP32) = D(D_A(TEMP4) + VAL_);
11510 D(D_A(TEMP5) + D_A(EM_DIR)) = D(TEMP32);
11511 SAVSTK();
11512 PUSH(TEMP5);
11513 PUSH(TEMP18);
11514 if (SUBBLOCK(TEMP23) == 1)
11515 goto L_EMERR1;
11516 SAVSTK();
11517 PUSH(EM_DIR);
11518 PUSH(TEMP23);
11519 PUSH(TEMP20);
11520 switch (MIDREG(TEMP11)) {
11521 case 2:
11522 goto L_EM2;
11523 }
11524 SAVSTK();
11525 PUSH(EM_DIR);
11526 PUSH(TEMP20);
11527 PUSH(TEMP23);
11528 switch (MIDREG(TEMP11)) {
11529 case 2:
11530 goto L_EM2;
11531 }
11532 D(TEMP11) = D(TEMP23);
11533 SAVSTK();
11534 PUSH(TEMP11);
11535 BCOPY(TEMP20);
11536 D(TEMP8) = D(D_A(TEMP8) + RSIB_);
11537 goto L_EM1;
11538 L_EM2:
11539 D(TEMP31) = D(D_A(TEMP11) + D_A(EM_DIR));
11540 D_A(EM_A) = D_V(TEMP31);
11541 D_F(EM_A) = D_V(EM_A) = 0;
11542 PUSH(EM_DIR);
11543 PUSH(TEMP2);
11544 PUSH(TEMP4);
11545 PUSH(TEMP5);
11546 PUSH(TEMP8);
11547 PUSH(TEMP9);
11548 PUSH(TEMP10);
11549 PUSH(TEMP11);
11550 PUSH(TEMP18);
11551 PUSH(TEMP21);
11552 PUSH(TEMP23);
11553 SAVSTK();
11554 PUSH(EM_A);
11555 PUSH(TEMP8);
11556 B_PB(TEMP24);
11557 POP(TEMP23);
11558 POP(TEMP21);
11559 POP(TEMP18);
11560 POP(TEMP11);
11561 POP(TEMP10);
11562 POP(TEMP9);
11563 POP(TEMP8);
11564 POP(TEMP5);
11565 POP(TEMP4);
11566 POP(TEMP2);
11567 POP(EM_DIR);
11568 D(TEMP14) = D(D_A(TEMP24) + FRAME_);
11569 SAVSTK();
11570 PUSH(TEMP2);
11571 PUSH(EM_DIR);
11572 PUSH(TEMP14);
11573 PUSH(TEMP11);
11574 INIT_SUB(TEMP15);
11575 D(TEMP31) = D(D_A(TEMP24) + ARRAY_);
11576 SAVSTK();
11577 PUSH(TEMP15);
11578 PUSH(TEMP31);
11579 PUSH(TEMP9);
11580 PUSH(TEMP10);
11581 INSERT(NORET);
11582 D(TEMP11) = D(TEMP23);
11583 SAVSTK();
11584 PUSH(TEMP11);
11585 BCOPY(TEMP20);
11586 D(TEMP8) = D(D_A(TEMP8) + RSIB_);
11587 goto L_EM1;
11588 L_EM4:
11589 SAVSTK();
11590 PUSH(TEMP18);
11591 STRIP_F(TEMP9);
11592 SAVSTK();
11593 PUSH(TEMP5);
11594 PUSH(TEMP18);
11595 if (SUBBLOCK(TEMP11) == 1)
11596 goto L_EMERR1;
11597 L_EM3:
11598 D(TEMP1) = D(D_A(XPTR) + VALUE_);
11599 D(TEMP31) = D(D_A(TEMP1) + ARRAY_);
11600 SAVSTK();
11601 PUSH(TEMP11);
11602 PUSH(TEMP31);
11603 PUSH(TEMP9);
11604 PUSH(TEMP10);
11605 INSERT(NORET);
11606 goto L_EM99;
11607 L_EMERR1:
11608 io_printf(D_A(EM_DIAG),EM_FMT2);
11609 SAVSTK();
11610 WARNING(NORET);
11611 goto L_EM99;
11612 L_EMERR:
11613 io_printf(D_A(EM_DIAG),EM_FMT3);
11614 SAVSTK();
11615 WARNING(NORET);
11616 goto L_EM99;
11617 L_EM99:
11618 RETURN(1)
11619 }
11620 static int
FICOM(ret_t retval)11621 FICOM(ret_t retval) {
11622 ENTRY(FICOM)
11623 POP(FC_A1);
11624 POP(FC_N1);
11625 POP(FC_A2);
11626 POP(FC_N2);
11627 D(TEMP31) = D(ZEROCL);
11628 D(TEMP32) = D(ZEROCL);
11629 D_A(FC_N1) *= DESCR;
11630 D_F(FC_N1) = D_V(FC_N1) = 0;
11631 D_A(FC_N2) *= DESCR;
11632 D_F(FC_N2) = D_V(FC_N2) = 0;
11633 L_FICOM2:
11634 D_A(TEMP31) += DESCR;
11635 if (D_A(TEMP31) > D_A(FC_N1))
11636 BRANCH(FAIL)
11637 D_A(TEMP32) = 0;
11638 D(FC_ND1) = D(D_A(FC_A1) + D_A(TEMP31));
11639 L_FICOM1:
11640 D_A(TEMP32) += DESCR;
11641 if (D_A(TEMP32) > D_A(FC_N2))
11642 goto L_FICOM2;
11643 D(FC_ND2) = D(D_A(FC_A2) + D_A(TEMP32));
11644 if (D_A(FC_ND1) == D_A(FC_ND2))
11645 BRANCH(RTN2)
11646 else
11647 goto L_FICOM1;
11648 }
11649 int
FIX(ret_t retval)11650 FIX(ret_t retval) {
11651 ENTRY(FIX)
11652 PUSH(INCL);
11653 SAVSTK();
11654 if (BLOKVAL(TEMP1) == 1)
11655 BRANCH(FAIL)
11656 POP(INCL);
11657 D(TEMP2) = D(NULVCL);
11658 if (D_V(INCL) == 1)
11659 goto L_FIXCL;
11660 PUSH(INCL);
11661 PUSH(TEMP1);
11662 SAVSTK();
11663 if (ARGVAL(TEMP2) == 1)
11664 BRANCH(FAIL)
11665 POP(TEMP1);
11666 POP(INCL);
11667 if (D_A(TEMP2) != 1)
11668 goto L_FIXNDS;
11669 L_FIXCL:
11670 SAVSTK();
11671 PUSH(TEMP2);
11672 PUSH(TEMP1);
11673 if (FIXINL(ZPTR) == 1)
11674 BRANCH(RTZPTR)
11675 L_FIXNDS:
11676 PUSH(TEMP2);
11677 PUSH(INCL);
11678 SAVSTK();
11679 PUSH(NULVCL);
11680 PUSH(TEMP1);
11681 FIXINL(ZPTR);
11682 POP(INCL);
11683 POP(TEMP2);
11684 D_A(FX_ARGS) = D_V(INCL);
11685 D_F(FX_ARGS) = D_V(FX_ARGS) = 0;
11686 D_A(FX_ARGS) -= 2;
11687 D(TEMP10) = D(D_A(ZPTR) + FRAME_);
11688 SAVSTK();
11689 PUSH(TEMP10);
11690 STRIP_F(TEMP20);
11691 BRANCH(FIX1)
11692 }
11693 static int
FIX2(ret_t retval)11694 FIX2(ret_t retval) {
11695 ENTRY(FIX2)
11696 if (D_A(FX_ARGS) <= 0)
11697 BRANCH(FIX99)
11698 D_A(FX_ARGS)--;
11699 PUSH(FX_ARGS);
11700 PUSH(TEMP10);
11701 PUSH(TEMP20);
11702 PUSH(ZPTR);
11703 SAVSTK();
11704 if (BLOKVAL(TEMP2) == 1)
11705 BRANCH(FAIL)
11706 POP(ZPTR);
11707 POP(TEMP20);
11708 POP(TEMP10);
11709 POP(FX_ARGS);
11710 /* FALL */
11711 BRANCH(FIX1)
11712 }
11713 static int
FIX1(ret_t retval)11714 FIX1(ret_t retval) {
11715 ENTRY(FIX1)
11716 D(FX_ND) = D(D_A(TEMP2) + ID_);
11717 D_A(FX_DIR) = (int_t) HT_;
11718 L_FIX11:
11719 D(TEMP11) = D(D_A(TEMP10) + D_A(FX_DIR));
11720 if (D_V(TEMP11) == EDGDT)
11721 D(TEMP12) = D(D_A(TEMP11) + RELS1_);
11722 else
11723 D(TEMP12) = D(NULVCL);
11724 if (D_V(TEMP11) == EDGDT)
11725 D(TEMP13) = D(D_A(TEMP11) + NN1_);
11726 else
11727 D(TEMP13) = D(ZEROCL);
11728 SAVSTK();
11729 PUSH(TEMP13);
11730 PUSH(TEMP12);
11731 PUSH(FX_N1);
11732 PUSH(FX_A1);
11733 if (FICOM(NORET) == 1)
11734 BRANCH(FIX2)
11735 D(TEMP14) = D(D_A(TEMP12) + D_A(TEMP32));
11736 D_A(TEMP13) = D_V(TEMP14);
11737 D_F(TEMP13) = D_V(TEMP13) = 0;
11738 D(TEMP21) = D(D_A(TEMP20) + D_A(FX_DIR));
11739 SAVSTK();
11740 PUSH(TEMP13);
11741 PUSH(TEMP14);
11742 PUSH(TEMP21);
11743 ADD_NP(TEMP21);
11744 D(D_A(TEMP20) + D_A(FX_DIR)) = D(TEMP21);
11745 D_A(FX_DIR) += DESCR;
11746 if (D_A(FX_DIR) <= DTH_)
11747 goto L_FIX11;
11748 else
11749 BRANCH(FIX2)
11750 }
11751 static int
FIX99(ret_t retval)11752 FIX99(ret_t retval) {
11753 ENTRY(FIX99)
11754 D(D_A(ZPTR) + FRAME_) = D(TEMP20);
11755 BRANCH(RTZPTR)
11756 }
11757 static int
FIXINL(ret_t retval)11758 FIXINL(ret_t retval) {
11759 ENTRY(FIXINL)
11760 POP(FIX_B);
11761 POP(FIX_FLAG);
11762 if (D_V(FIX_B) == S)
11763 goto L_T5;
11764 D(TEMP39) = D(D_A(FIX_B) + ORG_);
11765 if (D_V(TEMP39) == PHY_)
11766 goto L_FIXI1;
11767 L_T5:
11768 D(TEMP50) = D(FX_NN);
11769 SAVSTK();
11770 PUSH(FIX_B);
11771 PUSH(NULVCL);
11772 PUSH(NULVCL);
11773 T_LEAF(FIX_B);
11774 SAVSTK();
11775 PUSH(FIX_B);
11776 B_PB(FIX_B);
11777 D(D_A(FIX_B) + BL_) = D(NULVCL);
11778 D(TEMP50) = D(FX_NN);
11779 L_FIXI1:
11780 SAVSTK();
11781 PUSH(FIX_B);
11782 BCOPY(FIX_B);
11783 if (D_A(FIX_FLAG) == 0)
11784 goto L_FIXI99;
11785 D(TEMP31) = D(D_A(FIX_B) + FRAME_);
11786 PUSH(FIX_B);
11787 SAVSTK();
11788 PUSH(TEMP31);
11789 STRIP_F(TEMP31);
11790 POP(FIX_B);
11791 D(D_A(FIX_B) + FRAME_) = D(TEMP31);
11792 L_FIXI99:
11793 D(retval) = D(FIX_B);
11794 RETURN(1)
11795 }
11796 static int
FORCING(ret_t retval)11797 FORCING(ret_t retval) {
11798 ENTRY(FORCING)
11799 POP(FO_TN);
11800 POP(FO_DIR);
11801 D(FO_FO) = D(FO_ZERO);
11802 D(FO_B) = D(D_A(FO_TN) + VALUE_);
11803 if (D_V(FO_B) != S)
11804 goto L_FO1;
11805 if (D_A(FO_B) == 0)
11806 goto L_FO99;
11807 if (D_A(FO_DIR) == WTH_)
11808 goto L_FO2;
11809 D_A(FO_FO) = 1;
11810 goto L_FO99;
11811 L_FO2:
11812 D_A(FO_FO) = D_V(D_A(FO_B));
11813 D_F(FO_FO) = D_V(FO_FO) = 0;
11814 D_V(FO_FO) = I;
11815 goto L_FO99;
11816 L_FO1:
11817 D(TEMP1) = D(D_A(FO_B) + ORG_);
11818 D_A(TEMP1) = D_V(TEMP1);
11819 D_F(TEMP1) = D_V(TEMP1) = 0;
11820 switch (D_A(TEMP1)) {
11821 case 1:
11822 goto L_FORCE1;
11823 case 2:
11824 goto L_FORCE2;
11825 case 3:
11826 goto L_FORCE3;
11827 case 4:
11828 goto L_FORCE4;
11829 case 5:
11830 goto L_FORCE5;
11831 case 6:
11832 goto L_FORCE6;
11833 case 7:
11834 goto L_FORCE7;
11835 case 8:
11836 goto L_FORCE8;
11837 case 9:
11838 goto L_FORCE9;
11839 }
11840 L_FORCE1:
11841 L_FORCE2:
11842 L_FORCE3:
11843 PUSH(FO_TN);
11844 SAVSTK();
11845 PUSH(FO_TN);
11846 LSOHN(FO_P);
11847 POP(FO_TN);
11848 D_A(FO_SW) = 1;
11849 D_A(TEMP1) *= DESCR;
11850 D_F(TEMP1) = D_V(TEMP1) = 0;
11851 if (D_A(TEMP1) != D_A(FO_DIR))
11852 goto L_FO3;
11853 D_A(FO_SW) = 2;
11854 L_FO3:
11855 goto L_FO4;
11856 L_FO31:
11857 D(FO_P) = D(D_A(FO_P) + RSIB_);
11858 L_FO4:
11859 if (D_A(FO_P) == 0)
11860 goto L_FO99;
11861 PUSH(FO_P);
11862 PUSH(FO_DIR);
11863 PUSH(FO_SW);
11864 PUSH(FO_FO);
11865 SAVSTK();
11866 PUSH(FO_DIR);
11867 PUSH(FO_P);
11868 FORCING(TEMP1);
11869 POP(FO_FO);
11870 POP(FO_SW);
11871 POP(FO_DIR);
11872 POP(FO_P);
11873 switch (D_A(FO_SW)) {
11874 case 1:
11875 goto L_FO_ORTH;
11876 case 2:
11877 goto L_FO_LONGI;
11878 }
11879 L_FO_ORTH:
11880 if (D_A(FO_FO) >= D_A(TEMP1))
11881 goto L_FO31;
11882 D_A(FO_FO) = D_A(TEMP1);
11883 goto L_FO31;
11884 L_FO_LONGI:
11885 D_A(FO_FO) += D_A(TEMP1);
11886 goto L_FO31;
11887 L_FORCE4:
11888 PUSH(FO_DIR);
11889 SAVSTK();
11890 PUSH(NULVCL);
11891 PUSH(FO_TN);
11892 B_PB(FO_B);
11893 POP(FO_DIR);
11894 D(FO_B) = D(D_A(FO_B) + FRAME_);
11895 D(FO_E) = D(D_A(FO_B) + D_A(FO_DIR));
11896 if (D_V(FO_E) == EDGDT)
11897 D(FO_FO) = D(D_A(FO_E) + TR1_);
11898 else
11899 D(FO_FO) = D(FO_E);
11900 goto L_FO99;
11901 L_FORCE5:
11902 L_FORCE6:
11903 SAVSTK();
11904 PUSH(FO_TN);
11905 if (PAR_CONG(FO_P) == 1)
11906 goto L_FO99;
11907 D(FO_P) = D(D_A(FO_P) + VALUE_);
11908 D(FO_P) = D(D_A(FO_P) + ORG_);
11909 D_A(FO_P) = D_V(FO_P);
11910 D_F(FO_P) = D_V(FO_P) = 0;
11911 D_A(FO_P) *= DESCR;
11912 D_F(FO_P) = D_V(FO_P) = 0;
11913 if (D_A(FO_P) != D_A(FO_DIR))
11914 goto L_FORCE52;
11915 if (D_A(TEMP1) == REP_)
11916 goto L_FO99;
11917 else
11918 goto L_FORCE51;
11919 L_FORCE52:
11920 if (D_A(TEMP1) == IT_)
11921 goto L_FO99;
11922 else
11923 goto L_FORCE51;
11924 L_FORCE51:
11925 SAVSTK();
11926 PUSH(FO_TN);
11927 LSOHN(FO_TN);
11928 SAVSTK();
11929 PUSH(FO_DIR);
11930 PUSH(FO_TN);
11931 if (FORCING(FO_FO) == 1)
11932 goto L_FO99;
11933 L_FORCE7:
11934 goto L_FORCE51;
11935 L_FORCE8:
11936 D_A(ERRTYP) = (int_t) (ERRNO+1);
11937 BRANCH(FTLEND)
11938 L_FORCE9:
11939 D(FO_P) = D(D_A(FO_B) + FRAME_);
11940 D(FO_P) = D(D_A(FO_P) + D_A(FO_DIR));
11941 if (D_V(FO_P) == AEDGEDT)
11942 goto L_FORCE91;
11943 if (D_V(FO_P) == EDGDT)
11944 D(FO_FO) = D(D_A(FO_P) + TR1_);
11945 else
11946 D(FO_FO) = D(FO_P);
11947 goto L_FO99;
11948 L_FORCE91:
11949 D(FO_E) = D(D_A(FO_P) + VAL_);
11950 if (D_V(FO_E) == EDGDT)
11951 D(TEMP1) = D(D_A(FO_E) + TR1_);
11952 else
11953 D(TEMP1) = D(FO_E);
11954 D_A(FO_FO) += D_A(TEMP1);
11955 D(FO_P) = D(D_A(FO_P) + NEXT_);
11956 if (D_A(FO_P) == 0)
11957 goto L_FO99;
11958 else
11959 goto L_FORCE91;
11960 L_FO99:
11961 D(retval) = D(FO_FO);
11962 RETURN(1)
11963 }
11964 static int
F_JOIN(ret_t retval)11965 F_JOIN(ret_t retval) {
11966 ENTRY(F_JOIN)
11967 POP(FJ_DIR);
11968 POP(FJ_F1);
11969 POP(FJ_F2);
11970 POP(FJ_REG);
11971 if (DCMP(FJ_F2, NULVCL))
11972 goto L_FJ99;
11973 D_A(FJ_I) = (int_t) HT_;
11974 L_FJ6:
11975 D(FJ_T1) = D(D_A(FJ_F1) + D_A(FJ_I));
11976 D(FJ_T2) = D(D_A(FJ_F2) + D_A(FJ_I));
11977 D(FJ_RI) = D(D_A(FJ_REG) + D_A(FJ_I));
11978 PUSH(FJ_F1);
11979 PUSH(FJ_F2);
11980 PUSH(FJ_REG);
11981 if (D_A(FJ_I) != D_A(FJ_DIR))
11982 goto L_FJ3;
11983 SAVSTK();
11984 PUSH(FJ_T2);
11985 PUSH(FJ_T1);
11986 if (JE_LONGI(FJ_T) == 1)
11987 goto L_FJ4;
11988 L_FJ3:
11989 SAVSTK();
11990 PUSH(FJ_RI);
11991 PUSH(FJ_T2);
11992 PUSH(FJ_T1);
11993 JE_ORTHO(FJ_T);
11994 L_FJ4:
11995 POP(FJ_REG);
11996 POP(FJ_F2);
11997 POP(FJ_F1);
11998 D(D_A(FJ_F1) + D_A(FJ_I)) = D(FJ_T);
11999 if (D_A(FJ_I) == DTH_)
12000 goto L_FJ99;
12001 D_A(FJ_I) += DESCR;
12002 goto L_FJ6;
12003 L_FJ99:
12004 D(retval) = D(FJ_F1);
12005 RETURN(1)
12006 }
12007 int
HOR_REG(ret_t retval)12008 HOR_REG(ret_t retval) {
12009 ENTRY(HOR_REG)
12010 D_A(GR_DIR) = (int_t) (WTH_-DESCR);
12011 BRANCH(GR1)
12012 }
12013 int
VER_REG(ret_t retval)12014 VER_REG(ret_t retval) {
12015 ENTRY(VER_REG)
12016 D_A(GR_DIR) = (int_t) (HT_-DESCR);
12017 BRANCH(GR1)
12018 }
12019 int
NORM_REG(ret_t retval)12020 NORM_REG(ret_t retval) {
12021 ENTRY(NORM_REG)
12022 D_A(GR_DIR) = (int_t) (DTH_-DESCR);
12023 BRANCH(GR1)
12024 }
12025 static int
GR1(ret_t retval)12026 GR1(ret_t retval) {
12027 ENTRY(GR1)
12028 if (D_V(INCL) != 1)
12029 goto L_GRERR;
12030 SAVSTK();
12031 if (BLOKVAL(TEMP1) == 1)
12032 BRANCH(FAIL)
12033 if (D_V(TEMP1) == S)
12034 BRANCH(FAIL)
12035 D(TEMP39) = D(D_A(TEMP1) + ORG_);
12036 D_A(TEMP39) = D_V(TEMP39);
12037 D_F(TEMP39) = D_V(TEMP39) = 0;
12038 if (D_A(TEMP39) > OVY_)
12039 BRANCH(FAIL)
12040 if (D_A(D_A(TEMP1) + REG_) != (int_t)0)
12041 goto L_GR2;
12042 SAVSTK();
12043 PUSH(GR_REG);
12044 BLOCK(TEMP2);
12045 D(D_A(TEMP1) + REG_) = D(TEMP2);
12046 L_GR2:
12047 D(XPTR) = D(D_A(TEMP1) + REG_);
12048 D_A(XPTR) += D_A(GR_DIR);
12049 BRANCH(RTXNAM)
12050 L_GRERR:
12051 BRANCH(ARGNER)
12052 }
12053 static int
IDENT_SB(ret_t retval)12054 IDENT_SB(ret_t retval) {
12055 ENTRY(IDENT_SB)
12056 SAVSTK();
12057 PUSH(ID_D);
12058 BLOCK(ID_ID);
12059 POP(ID_SF);
12060 D(ID_T) = D(D_A(ID_SF) + HT_);
12061 D_V(ID_T) = D_A(ID_T);
12062 D_V(D_A(ID_ID) + HT_) = D_V(ID_T);
12063 D(ID_T) = D(D_A(ID_SF) + WTH_);
12064 D_V(ID_T) = D_A(ID_T);
12065 D_V(D_A(ID_ID) + WTH_) = D_V(ID_T);
12066 D(ID_T) = D(D_A(ID_SF) + DTH_);
12067 D_V(ID_T) = D_A(ID_T);
12068 D_V(D_A(ID_ID) + DTH_) = D_V(ID_T);
12069 D(retval) = D(ID_ID);
12070 RETURN(1)
12071 }
12072 static int
INIT_SUB(ret_t retval)12073 INIT_SUB(ret_t retval) {
12074 ENTRY(INIT_SUB)
12075 SAVSTK();
12076 PUSH(IS_SBD);
12077 BLOCK(IS_IS);
12078 POP(IS_SB);
12079 POP(IS_SF);
12080 POP(IS_DIR);
12081 POP(IS_REG);
12082 D(IS_DS) = D(IS_DIR);
12083 D(TEMP31) = D(D_A(IS_SF) + D_A(IS_DIR));
12084 D(TEMP32) = D(D_A(IS_SB) + D_A(IS_DIR));
12085 D(TEMP33) = D(TEMP32);
12086 D_V(TEMP32) = D_A(TEMP31);
12087 D(D_A(IS_IS) + D_A(IS_DIR)) = D(TEMP32);
12088 D_A(TEMP34) = D_V(TEMP33);
12089 D_F(TEMP34) = D_V(TEMP34) = 0;
12090 D_A(TEMP34) -= D_A(TEMP31);
12091 D_A(TEMP33) += D_A(TEMP31);
12092 D_V(TEMP33) = D_A(TEMP34);
12093 D(D_A(IS_SB) + D_A(IS_DIR)) = D(TEMP33);
12094 L_IS1:
12095 if (D_A(IS_DIR)>= 3*DESCR) {
12096 D_A(IS_DIR) = 0;
12097 D_F(IS_DIR) = D_V(IS_DIR) = 0;
12098 }
12099 D_A(IS_DIR) += DESCR;
12100 if (D_A(IS_DIR) == D_A(IS_DS))
12101 goto L_IS2;
12102 D(IS_ST) = D(D_A(IS_SB) + D_A(IS_DIR));
12103 D_A(TEMP31) = D_V(IS_ST);
12104 D_F(TEMP31) = D_V(TEMP31) = 0;
12105 D(IS_SFD) = D(D_A(IS_SF) + D_A(IS_DIR));
12106 D(TEMP33) = D(D_A(IS_REG) + D_A(IS_DIR));
12107 SAVSTK();
12108 PUSH(TEMP33);
12109 PUSH(IS_SFD);
12110 PUSH(TEMP31);
12111 PRE_SUF(NORET);
12112 D_A(IS_ST) += D_A(TEMP31);
12113 D_V(IS_ST) = D_A(IS_SFD);
12114 D(D_A(IS_IS) + D_A(IS_DIR)) = D(IS_ST);
12115 goto L_IS1;
12116 L_IS2:
12117 D(retval) = D(IS_IS);
12118 RETURN(1)
12119 }
12120 static int
INSERT(ret_t retval)12121 INSERT(ret_t retval) {
12122 ENTRY(INSERT)
12123 POP(TEMP35);
12124 POP(IN_GF);
12125 POP(TEMP36);
12126 POP(IN_SB);
12127 D(IN_HO) = D(D_A(IN_SB) + HT_);
12128 D_A(IN_H) = D_V(IN_HO);
12129 D_F(IN_H) = D_V(IN_H) = 0;
12130 D(IN_WO) = D(D_A(IN_SB) + WTH_);
12131 D_A(IN_W) = D_V(IN_WO);
12132 D_F(IN_W) = D_V(IN_W) = 0;
12133 D(IN_DO) = D(D_A(IN_SB) + DTH_);
12134 D_A(IN_D) = D_V(IN_DO);
12135 D_F(IN_D) = D_V(IN_D) = 0;
12136 D(IN_DG) = D(D_A(IN_GF) + DTH_);
12137 D(IN_WG) = D(D_A(IN_GF) + WTH_);
12138 S_L(IN_REM) = D_A(IN_WO);
12139 if (D_A(IN_W) == 0)
12140 goto L_IN99;
12141 D(IN_N) = D(IN_HO);
12142 D_A(IN_N) *= D_A(IN_DG);
12143 D(IN_INC) = D(IN_DG);
12144 D_A(IN_INC) -= D_A(IN_D);
12145 D_A(IN_N) -= D_A(IN_INC);
12146 D_A(IN_N) += D_A(IN_DO);
12147 D_A(IN_N) *= DESCR;
12148 D_F(IN_N) = D_V(IN_N) = 0;
12149 D_A(IN_INC) *= DESCR;
12150 D_F(IN_INC) = D_V(IN_INC) = 0;
12151 D_A(IN_I) = 0;
12152 D_A(IN_M) = 0;
12153 X_LOCSP(TXSP,BKGNCL);
12154 L_IN1:
12155 D_A(IN_J) = 0;
12156 D_A(IN_I)++;
12157 if (D_A(IN_I) > D_A(IN_H))
12158 goto L_IN99;
12159 D_A(IN_N) += D_A(IN_INC);
12160 L_IN2:
12161 D_A(IN_J)++;
12162 if (D_A(IN_J) > D_A(IN_D))
12163 goto L_IN1;
12164 D_A(IN_M) += DESCR;
12165 D_A(IN_N) += DESCR;
12166 D(TEMP31) = D(D_A(TEMP35) + D_A(IN_N));
12167 X_LOCSP(VSP,TEMP31);
12168 D(TEMP32) = D(D_A(TEMP36) + D_A(IN_M));
12169 X_LOCSP(YSP,TEMP32);
12170 SAVSTK();
12171 PUSH(IN_WG);
12172 CONVAR(ZPTR);
12173 X_LOCSP(XSP,ZPTR);
12174 S_L(XSP) = 0;
12175 APDSP(XSP,VSP);
12176 X_REMSP(ZSP,XSP,IN_REM);
12177 MERGSP(ZSP,YSP,TXSP);
12178 SAVSTK();
12179 PUSH(IN_WG);
12180 GNVARS(ZPTR);
12181 D(D_A(TEMP35) + D_A(IN_N)) = D(ZPTR);
12182 goto L_IN2;
12183 L_IN99:
12184 if (D_A(DMPCL) != 50)
12185 BRANCH(RTN1)
12186 io_printf(D_A(IN_UNIT),IN_FT1);
12187 SAVSTK();
12188 PUSH(TEMP35);
12189 DUMP_A(NORET);
12190 SAVSTK();
12191 PUSH(IN_GF);
12192 DUMP_B(NORET);
12193 SAVSTK();
12194 PUSH(TEMP36);
12195 DUMP_A(NORET);
12196 SAVSTK();
12197 PUSH(IN_SB);
12198 DUMP_B(NORET);
12199 BRANCH(RTN1)
12200 }
12201 static int
JE_LONGI(ret_t retval)12202 JE_LONGI(ret_t retval) {
12203 ENTRY(JE_LONGI)
12204 POP(JEL_E1);
12205 POP(JEL_E2);
12206 if (D_V(JEL_E1) == EDGDT)
12207 goto L_JEL1;
12208 if (D_V(JEL_E2) == EDGDT)
12209 goto L_JEL1;
12210 D_A(JEL_E1) += D_A(JEL_E2);
12211 BRANCH(JEL99)
12212 L_JEL1:
12213 if (D_V(JEL_E1) == EDGDT)
12214 D(JEL_T1) = D(D_A(JEL_E1) + TR1_);
12215 else
12216 D(JEL_T1) = D(JEL_E1);
12217 if (D_V(JEL_E2) == EDGDT)
12218 D(JEL_T2) = D(D_A(JEL_E2) + TR1_);
12219 else
12220 D(JEL_T2) = D(JEL_E2);
12221 D(JEL_T) = D(JEL_T1);
12222 D_A(JEL_T) += D_A(JEL_T2);
12223 if (D_V(JEL_E1) == EDGDT)
12224 D(JEL_N1) = D(D_A(JEL_E1) + NN1_);
12225 else
12226 D(JEL_N1) = D(ZEROCL);
12227 if (D_V(JEL_E2) == EDGDT)
12228 D(JEL_N2) = D(D_A(JEL_E2) + NN1_);
12229 else
12230 D(JEL_N2) = D(ZEROCL);
12231 D(JEL_N) = D(JEL_N1);
12232 D_A(JEL_N) += D_A(JEL_N2);
12233 if (D_V(JEL_E1) == EDGDT)
12234 D(JEL_R1) = D(D_A(JEL_E1) + RELS1_);
12235 else
12236 D(JEL_R1) = D(NULVCL);
12237 if (D_V(JEL_E2) == EDGDT)
12238 D(JEL_R2) = D(D_A(JEL_E2) + RELS1_);
12239 else
12240 D(JEL_R2) = D(NULVCL);
12241 BRANCH(JELCO)
12242 }
12243 static int
JE_ORTHO(ret_t retval)12244 JE_ORTHO(ret_t retval) {
12245 ENTRY(JE_ORTHO)
12246 POP(JEL_E1);
12247 POP(JEL_E2);
12248 POP(JEL_REG);
12249 if (D_V(JEL_E1) == EDGDT)
12250 goto L_JEL3;
12251 if (D_V(JEL_E2) == EDGDT)
12252 goto L_JEL3;
12253 if (D_A(JEL_E1) > D_A(JEL_E2))
12254 D(JEL_E1) = D(JEL_E1);
12255 else
12256 D(JEL_E1) = D(JEL_E2);
12257 BRANCH(JEL99)
12258 L_JEL3:
12259 if (D_V(JEL_E1) == EDGDT)
12260 D(JEL_T1) = D(D_A(JEL_E1) + TR1_);
12261 else
12262 D(JEL_T1) = D(JEL_E1);
12263 if (D_V(JEL_E2) == EDGDT)
12264 D(JEL_T2) = D(D_A(JEL_E2) + TR1_);
12265 else
12266 D(JEL_T2) = D(JEL_E2);
12267 if (D_V(JEL_E1) == EDGDT)
12268 D(JEL_N1) = D(D_A(JEL_E1) + NN1_);
12269 else
12270 D(JEL_N1) = D(ZEROCL);
12271 if (D_V(JEL_E2) == EDGDT)
12272 D(JEL_N2) = D(D_A(JEL_E2) + NN1_);
12273 else
12274 D(JEL_N2) = D(ZEROCL);
12275 if (D_V(JEL_E1) == EDGDT)
12276 D(JEL_R1) = D(D_A(JEL_E1) + RELS1_);
12277 else
12278 D(JEL_R1) = D(NULVCL);
12279 if (D_V(JEL_E2) == EDGDT)
12280 D(JEL_R2) = D(D_A(JEL_E2) + RELS1_);
12281 else
12282 D(JEL_R2) = D(NULVCL);
12283 if (D_A(JEL_T1) >= D_A(JEL_T2))
12284 goto L_JEL4;
12285 D(TEMP39) = D(JEL_T1);
12286 D(JEL_T1) = D(JEL_T2);
12287 D(JEL_T2) = D(TEMP39);
12288 D(TEMP39) = D(JEL_N1);
12289 D(JEL_N1) = D(JEL_N2);
12290 D(JEL_N2) = D(TEMP39);
12291 D(TEMP39) = D(JEL_R1);
12292 D(JEL_R1) = D(JEL_R2);
12293 D(JEL_R2) = D(TEMP39);
12294 L_JEL4:
12295 D(JEL_N) = D(JEL_N1);
12296 D_A(JEL_N) += D_A(JEL_N2);
12297 D(JEL_T) = D(JEL_T1);
12298 SAVSTK();
12299 PUSH(JEL_REG);
12300 PUSH(JEL_T2);
12301 PUSH(JEL_T1);
12302 PRE_SUF(NORET);
12303 D(JEL_T1) = D(TEMP31);
12304 /* FALL */
12305 BRANCH(JELCO)
12306 }
12307 static int
JELCO(ret_t retval)12308 JELCO(ret_t retval) {
12309 ENTRY(JELCO)
12310 PUSH(JEL_E1);
12311 SAVSTK();
12312 PUSH(JEL_T1);
12313 PUSH(JEL_N2);
12314 PUSH(JEL_R2);
12315 PUSH(JEL_N1);
12316 PUSH(JEL_R1);
12317 CIR(JEL_R);
12318 POP(JEL_E1);
12319 if (D_V(JEL_E1) == EDGDT)
12320 goto L_JEL2;
12321 PUSH(JEL_R);
12322 SAVSTK();
12323 PUSH(JEL_SIZE);
12324 BLOCK(JEL_E1);
12325 POP(JEL_R);
12326 L_JEL2:
12327 D(D_A(JEL_E1) + TR1_) = D(JEL_T);
12328 D(D_A(JEL_E1) + NN1_) = D(JEL_N);
12329 D(D_A(JEL_E1) + RELS1_) = D(JEL_R);
12330 /* FALL */
12331 BRANCH(JEL99)
12332 }
12333 static int
JEL99(ret_t retval)12334 JEL99(ret_t retval) {
12335 ENTRY(JEL99)
12336 D(retval) = D(JEL_E1);
12337 RETURN(1)
12338 }
12339 static int
JOIN(ret_t retval)12340 JOIN(ret_t retval) {
12341 ENTRY(JOIN)
12342 POP(JN_B1);
12343 POP(JN_B2);
12344 if (!DCMP(JN_B1, NULVCL))
12345 goto L_JOIN1;
12346 D(WCL) = D(JN_B2);
12347 goto L_JOIN99;
12348 L_JOIN1:
12349 if (!DCMP(JN_B2, NULVCL))
12350 goto L_JOIN2;
12351 D(WCL) = D(JN_B1);
12352 goto L_JOIN99;
12353 L_JOIN2:
12354 SAVSTK();
12355 PUSH(JN_B1);
12356 CLASS(JN_CL1);
12357 D_A(JN_CL1) *= 3;
12358 D_F(JN_CL1) = D_V(JN_CL1) = 0;
12359 SAVSTK();
12360 PUSH(JN_B2);
12361 CLASS(JN_CL2);
12362 D_A(JN_CL1) += D_A(JN_CL2);
12363 D_A(JN_CL1)++;
12364 PUSH(JN_B1);
12365 PUSH(JN_B2);
12366 switch (D_A(JN_CL1)) {
12367 case 1:
12368 goto L_ST_ST;
12369 case 2:
12370 goto L_ST_BW;
12371 case 3:
12372 goto L_ST_BA;
12373 case 4:
12374 goto L_BW_ST;
12375 case 5:
12376 goto L_BW_BW;
12377 case 6:
12378 goto L_BW_BA;
12379 case 7:
12380 goto L_BA_ST;
12381 case 8:
12382 goto L_BA_BW;
12383 case 9:
12384 goto L_BA_BA;
12385 }
12386 L_ST_BA:
12387 L_BA_ST:
12388 L_BA_BA:
12389 SAVSTK();
12390 PUSH(JN_SIZE);
12391 BLOCK(WCL);
12392 POP(JN_B2);
12393 POP(JN_B1);
12394 D_V(D_A(WCL) + ORG_) = D_V(TEMP1);
12395 D_A(TEMP1) = (int_t) (FIRST_+DESCR);
12396 D_A(D_A(WCL) + TOP_) = D_A(TEMP1);
12397 D(D_A(WCL) + FIRST_) = D(JN_B1);
12398 D(D_A(WCL) + FIRST_+DESCR) = D(JN_B2);
12399 goto L_JOIN99;
12400 L_ST_BW:
12401 L_BA_BW:
12402 SAVSTK();
12403 PUSH(JN_B2);
12404 BCOPY(WCL);
12405 SAVSTK();
12406 BHEAD(NORET);
12407 POP(JN_B2);
12408 POP(JN_B1);
12409 D(D_A(WCL) + FIRST_) = D(JN_B1);
12410 goto L_JOIN99;
12411 L_BW_ST:
12412 L_BW_BA:
12413 SAVSTK();
12414 PUSH(JN_B1);
12415 BCOPY(WCL);
12416 SAVSTK();
12417 BTAIL(JN_TOP);
12418 POP(JN_B2);
12419 POP(JN_B1);
12420 D(D_A(WCL) + D_A(JN_TOP)) = D(JN_B2);
12421 goto L_JOIN99;
12422 L_BW_BW:
12423 SAVSTK();
12424 PUSH(JN_B1);
12425 BCOPY(WCL);
12426 POP(TEMP2);
12427 D(JN_TOP) = D(D_A(TEMP2) + TOP_);
12428 D_A(JN_I) = (int_t) FIRST_;
12429 L_BW_BW_1:
12430 if (D_A(JN_I) > D_A(JN_TOP))
12431 goto L_JOIN99;
12432 SAVSTK();
12433 BTAIL(JN_K);
12434 D(TEMP22) = D(D_A(TEMP2) + D_A(JN_I));
12435 D(D_A(WCL) + D_A(JN_K)) = D(TEMP22);
12436 D_A(JN_I) += DESCR;
12437 goto L_BW_BW_1;
12438 L_ST_ST:
12439 if (D_V(TEMP1) != PAR_)
12440 goto L_BA_BA;
12441 D(XPTR) = D(JN_B1);
12442 D(YPTR) = D(JN_B2);
12443 SAVSTK();
12444 switch (CONVV(WCL)) {
12445 case 1:
12446 BRANCH(FAIL)
12447 case 3:
12448 goto L_JOIN99;
12449 }
12450 L_JOIN99:
12451 D(retval) = D(WCL);
12452 RETURN(1)
12453 }
12454 int
LOC(ret_t retval)12455 LOC(ret_t retval) {
12456 ENTRY(LOC)
12457 D_A(LO_AC) = D_V(INCL);
12458 D_F(LO_AC) = D_V(LO_AC) = 0;
12459 if (D_A(LO_AC) < 2)
12460 BRANCH(FAIL)
12461 PUSH(LO_AC);
12462 SAVSTK();
12463 if (BLOKVAL(TEMP1) == 1)
12464 BRANCH(FAIL)
12465 PUSH(TEMP1);
12466 SAVSTK();
12467 if (BLOKVAL(TEMP2) == 1)
12468 BRANCH(FAIL)
12469 SAVSTK();
12470 PUSH(NULVCL);
12471 PUSH(TEMP2);
12472 FIXINL(TEMP2);
12473 POP(TEMP1);
12474 POP(LO_AC);
12475 D(TEMP3) = D(ZEROCL);
12476 if (D_A(LO_AC) != 3)
12477 goto L_LOC1;
12478 PUSH(TEMP1);
12479 PUSH(TEMP2);
12480 SAVSTK();
12481 if (INTVAL(TEMP3) == 1)
12482 BRANCH(FAIL)
12483 L_LOC1:
12484 D(LO_ND) = D(D_A(TEMP1) + ID_);
12485 D_A(TEMP3)++;
12486 D_A(TEMP3) *= DESCR;
12487 D_F(TEMP3) = D_V(TEMP3) = 0;
12488 D(TEMP4) = D(D_A(TEMP2) + FRAME_);
12489 D(TEMP5) = D(D_A(TEMP4) + D_A(TEMP3));
12490 if (D_V(TEMP5) == EDGDT)
12491 D(TEMP6) = D(D_A(TEMP5) + RELS1_);
12492 else
12493 D(TEMP6) = D(NULVCL);
12494 if (D_V(TEMP5) == EDGDT)
12495 D(TEMP7) = D(D_A(TEMP5) + NN1_);
12496 else
12497 D(TEMP7) = D(ZEROCL);
12498 SAVSTK();
12499 PUSH(TEMP7);
12500 PUSH(TEMP6);
12501 PUSH(LO_N1);
12502 PUSH(LO_A1);
12503 if (FICOM(NORET) == 1)
12504 BRANCH(FAIL)
12505 D(ZPTR) = D(D_A(TEMP6) + D_A(TEMP32));
12506 D_A(ZPTR) = D_V(ZPTR);
12507 D_F(ZPTR) = D_V(ZPTR) = 0;
12508 D_V(ZPTR) = I;
12509 BRANCH(RTZPTR)
12510 }
12511 int
LRECL(ret_t retval)12512 LRECL(ret_t retval) {
12513 ENTRY(LRECL)
12514 /* FALL */
12515 BRANCH(CC)
12516 }
12517 int
CC(ret_t retval)12518 CC(ret_t retval) {
12519 ENTRY(CC)
12520 if (D_V(INCL) != 1)
12521 BRANCH(ARGNER)
12522 SAVSTK();
12523 if (INTVAL(XPTR) == 1)
12524 BRANCH(FAIL)
12525 D(YPTR) = D(ONECL);
12526 D_V(YPTR) = I;
12527 if (D_A(XPTR) == 0)
12528 goto L_LRECL5;
12529 D_A(YPTR) = 0;
12530 L_LRECL5:
12531 if (D_A(TEMP48) == 0)
12532 goto L_LRECL4;
12533 L_LRECL3:
12534 if (!LOCAPT(XPTR,TEMP48,XPTR))
12535 goto L_LRECL2;
12536 D_A(XPTR) += DESCR;
12537 D_V(XPTR) = N;
12538 BRANCH(RTXNAM)
12539 L_LRECL2:
12540 SAVSTK();
12541 PUSH(YPTR);
12542 PUSH(XPTR);
12543 PUSH(TEMP48);
12544 AUGATL(TEMP48);
12545 goto L_LRECL3;
12546 L_LRECL4:
12547 D(TEMP48) = D(LR_1);
12548 goto L_LRECL2;
12549 }
12550 static int
LSOHN(ret_t retval)12551 LSOHN(ret_t retval) {
12552 ENTRY(LSOHN)
12553 POP(LS_TN);
12554 D(LS_LS) = D(D_A(LS_TN) + LSO_);
12555 if (D_A(LS_LS) != 0)
12556 goto L_LS99;
12557 D(LS_B) = D(D_A(LS_TN) + VALUE_);
12558 D(LS_I) = D(D_A(LS_B) + TOP_);
12559 D(LS_ORG) = D(D_A(LS_B) + ORG_);
12560 L_LS1:
12561 if (D_A(LS_I) < FIRST_)
12562 goto L_LS2;
12563 D(LS_BI) = D(D_A(LS_B) + D_A(LS_I));
12564 D_A(LS_I) -= DESCR;
12565 L_LS4:
12566 if (D_V(LS_BI) == S)
12567 goto L_T6;
12568 D(TEMP39) = D(D_A(LS_BI) + ORG_);
12569 if (D_V(TEMP39) == DEF_)
12570 goto L_LS3;
12571 L_T6:
12572 PUSH(LS_TN);
12573 PUSH(LS_B);
12574 SAVSTK();
12575 PUSH(LS_BI);
12576 PUSH(LS_LS);
12577 PUSH(LS_TN);
12578 T_LEAF(LS_LS);
12579 POP(LS_B);
12580 POP(LS_TN);
12581 goto L_LS1;
12582 L_LS2:
12583 D(D_A(LS_TN) + LSO_) = D(LS_LS);
12584 goto L_LS99;
12585 L_LS3:
12586 D(LS_BI) = D(D_A(LS_BI) + NAME_);
12587 D(LS_BI) = D(D_A(LS_BI) + DESCR);
12588 if (D_V(LS_BI) == BL)
12589 goto L_LS7;
12590 if (D_V(LS_BI) == S)
12591 goto L_LS4;
12592 if (D_V(LS_BI) != I)
12593 goto L_LS8;
12594 SAVSTK();
12595 PUSH(LS_BI);
12596 if (GNVARI(LS_BI) == 1)
12597 goto L_LS4;
12598 L_LS8:
12599 if (D_V(LS_BI) != R)
12600 BRANCH(INTR1)
12601 REALST(REALSP,LS_BI);
12602 _SPEC(YSP) = _SPEC(REALSP);
12603 SAVSTK();
12604 PUSH(YSPPTR);
12605 if (GENVAR(YPTR) == 1)
12606 goto L_LS4;
12607 L_LS7:
12608 if (D_V(D_A(LS_BI) + ORG_) != D_V(LS_ORG))
12609 goto L_LS4;
12610 if (D_V(D_A(LS_BI) + SET_) != D_V(LS_NULL))
12611 goto L_LS4;
12612 D(LS_OLDP) = D(LS_LS);
12613 D(D_A(LS_TN) + VALUE_) = D(LS_BI);
12614 PUSH(LS_OLDP);
12615 PUSH(LS_TN);
12616 PUSH(LS_B);
12617 PUSH(LS_I);
12618 PUSH(LS_ORG);
12619 SAVSTK();
12620 PUSH(LS_TN);
12621 LSOHN(LS_LS);
12622 POP(LS_ORG);
12623 POP(LS_I);
12624 POP(LS_B);
12625 POP(LS_TN);
12626 POP(LS_OLDP);
12627 D(D_A(LS_TN) + VALUE_) = D(LS_B);
12628 D(LS_P) = D(LS_LS);
12629 L_LS5:
12630 if (D_A(D_A(LS_P) + RSIB_) == (int_t)0)
12631 goto L_LS6;
12632 D(LS_P) = D(D_A(LS_P) + RSIB_);
12633 goto L_LS5;
12634 L_LS6:
12635 D(D_A(LS_P) + RSIB_) = D(LS_OLDP);
12636 goto L_LS1;
12637 L_LS99:
12638 D(retval) = D(LS_LS);
12639 RETURN(1)
12640 }
12641 static int
MIDREG(ret_t retval)12642 MIDREG(ret_t retval) {
12643 ENTRY(MIDREG)
12644 POP(MR_SB1);
12645 POP(MR_SB2);
12646 POP(MR_DIR);
12647 D(TEMP31) = D(D_A(MR_SB1) + D_A(MR_DIR));
12648 D_A(TEMP32) = D_V(TEMP31);
12649 D_F(TEMP32) = D_V(TEMP32) = 0;
12650 D(MR_NO) = D(TEMP32);
12651 D_A(MR_NO) += D_A(TEMP31);
12652 D(TEMP31) = D(D_A(MR_SB2) + D_A(MR_DIR));
12653 D(MR_NE) = D(TEMP31);
12654 D_A(MR_NE) -= D_A(MR_NO);
12655 if (D_A(MR_NE) < 0)
12656 BRANCH(FAIL)
12657 D_V(MR_NO) = D_A(MR_NE);
12658 SAVSTK();
12659 PUSH(MR_SB1);
12660 BCOPY(MR_MR);
12661 D(D_A(MR_MR) + D_A(MR_DIR)) = D(MR_NO);
12662 D(retval) = D(MR_MR);
12663 RETURN(2)
12664 }
12665 static int
MINGLE(ret_t retval)12666 MINGLE(ret_t retval) {
12667 ENTRY(MINGLE)
12668 POP(TEMP28);
12669 POP(TEMP29);
12670 if (D_V(TEMP28) == EDGDT)
12671 D(MI_R1) = D(D_A(TEMP28) + RELS1_);
12672 else
12673 D(MI_R1) = D(NULVCL);
12674 if (D_V(TEMP28) == EDGDT)
12675 D(MI_N1) = D(D_A(TEMP28) + NN1_);
12676 else
12677 D(MI_N1) = D(ZEROCL);
12678 if (D_V(TEMP29) == EDGDT)
12679 D(MI_R2) = D(D_A(TEMP29) + RELS1_);
12680 else
12681 D(MI_R2) = D(NULVCL);
12682 if (D_V(TEMP29) == EDGDT)
12683 D(MI_N2) = D(D_A(TEMP29) + NN1_);
12684 else
12685 D(MI_N2) = D(ZEROCL);
12686 SAVSTK();
12687 PUSH(MI_N2);
12688 PUSH(MI_R2);
12689 PUSH(MI_N1);
12690 PUSH(MI_R1);
12691 if (FICOM(NORET) == 1)
12692 BRANCH(FAIL)
12693 D(MI_D1) = D(D_A(MI_R1) + D_A(TEMP31));
12694 D_A(MI_D1) = D_V(MI_D1);
12695 D_F(MI_D1) = D_V(MI_D1) = 0;
12696 D(MI_D2) = D(D_A(MI_R2) + D_A(TEMP32));
12697 D_A(MI_D2) = D_V(MI_D2);
12698 D_F(MI_D2) = D_V(MI_D2) = 0;
12699 D_A(MI_D1) -= D_A(MI_D2);
12700 if (D_A(MI_D1) >= 0)
12701 goto L_MI1;
12702 CLR_MATH_ERROR();
12703 D_A(MI_D1) = -D_A(MI_D1);
12704 if (MATH_ERROR())
12705 goto L_MI62;
12706 goto L_MI62;
12707 L_MI62:
12708 D(TEMP39) = D(TEMP28);
12709 D(TEMP28) = D(TEMP29);
12710 D(TEMP29) = D(TEMP39);
12711 D(TEMP39) = D(MI_R1);
12712 D(MI_R1) = D(MI_R2);
12713 D(MI_R2) = D(TEMP39);
12714 D(TEMP39) = D(MI_N1);
12715 D(MI_N1) = D(MI_N2);
12716 D(MI_N2) = D(TEMP39);
12717 L_MI1:
12718 SAVSTK();
12719 PUSH(MI_D1);
12720 PUSH(MI_N2);
12721 PUSH(MI_R2);
12722 PUSH(MI_N1);
12723 PUSH(MI_R1);
12724 CIR(TEMP33);
12725 if (D_V(TEMP28) == EDGDT)
12726 D(MI_T1) = D(D_A(TEMP28) + TR1_);
12727 else
12728 D(MI_T1) = D(TEMP28);
12729 if (D_V(TEMP29) == EDGDT)
12730 D(MI_T2) = D(D_A(TEMP29) + TR1_);
12731 else
12732 D(MI_T2) = D(TEMP29);
12733 D_A(MI_T2) += D_A(MI_D1);
12734 D_A(MI_N1) += D_A(MI_N2);
12735 if (D_A(MI_T1) > D_A(MI_T2))
12736 D(MI_T1) = D(MI_T1);
12737 else
12738 D(MI_T1) = D(MI_T2);
12739 SAVSTK();
12740 PUSH(MI_ED);
12741 BLOCK(MI_MI);
12742 D(D_A(MI_MI) + TR1_) = D(MI_T1);
12743 D(D_A(MI_MI) + NN1_) = D(MI_N1);
12744 D(D_A(MI_MI) + RELS1_) = D(TEMP33);
12745 D(retval) = D(MI_MI);
12746 RETURN(2)
12747 }
12748 int
MORE(ret_t retval)12749 MORE(ret_t retval) {
12750 ENTRY(MORE)
12751 POP(MR_BLOCK);
12752 D_A(MR_SIZE1) = D_V(D_A(MR_BLOCK));
12753 D_F(MR_SIZE1) = D_V(MR_SIZE1) = 0;
12754 D_A(MR_SIZE2) = D_A(MR_SIZE1);
12755 D_A(MR_SIZE2) *= 2;
12756 D_F(MR_SIZE2) = D_V(MR_SIZE2) = 0;
12757 D_V(MR_SIZE2) = D_V(MR_BLOCK);
12758 SAVSTK();
12759 PUSH(MR_SIZE2);
12760 BLOCK(MR_X);
12761 MOVBLK(D_A(MR_X),D_A(MR_BLOCK),D_A(MR_SIZE1));
12762 D(retval) = D(MR_X);
12763 RETURN(1)
12764 }
12765 static int
NRMZ_REG(ret_t retval)12766 NRMZ_REG(ret_t retval) {
12767 ENTRY(NRMZ_REG)
12768 POP(ZCL);
12769 D_A(NR_DIR) = (int_t) HT_;
12770 SAVSTK();
12771 PUSH(NR_VA);
12772 PUSH(NR_VF);
12773 N_REG(NORET);
12774 D_A(NR_DIR) = (int_t) WTH_;
12775 SAVSTK();
12776 PUSH(NR_HA);
12777 PUSH(NR_HF);
12778 N_REG(NORET);
12779 D_A(NR_DIR) = (int_t) DTH_;
12780 SAVSTK();
12781 PUSH(NR_NA);
12782 PUSH(NR_NF);
12783 N_REG(NORET);
12784 BRANCH(NR99)
12785 }
12786 static int
N_REG(ret_t retval)12787 N_REG(ret_t retval) {
12788 ENTRY(N_REG)
12789 POP(NR_F);
12790 POP(NR_A);
12791 D(NR_VAL) = D(D_A(ZCL) + D_A(NR_DIR));
12792 if (D_V(NR_VAL) != S)
12793 BRANCH(NR99)
12794 if (D_A(NR_VAL) != 0)
12795 goto L_NR1;
12796 L_NR0:
12797 D(D_A(ZCL) + D_A(NR_DIR)) = D(NR_SC);
12798 BRANCH(NR99)
12799 L_NR1:
12800 X_LOCSP(TXSP,NR_VAL);
12801 S_L(TXSP) = 1;
12802 _SPEC(NR_SP) = _SPEC(D_A(NR_F));
12803 if (!LEXEQ(TXSP,NR_SP))
12804 goto L_NR2;
12805 D(D_A(ZCL) + D_A(NR_DIR)) = D(NR_SF);
12806 BRANCH(NR99)
12807 L_NR2:
12808 _SPEC(NR_SP) = _SPEC(D_A(NR_A));
12809 if (!LEXEQ(TXSP,NR_SP))
12810 goto L_NR3;
12811 D(D_A(ZCL) + D_A(NR_DIR)) = D(NR_SA);
12812 BRANCH(NR99)
12813 L_NR3:
12814 X_LOCSP(TXSP,NR_VAL);
12815 if (D_A(NR_DES) == 0)
12816 goto L_NR9;
12817 CLR_MATH_ERROR();
12818 D_A(NR_DIR) /= D_A(NR_DES);
12819 if (MATH_ERROR())
12820 goto L_NR9;
12821 L_NR9:
12822 D_A(NR_DIR)--;
12823 io_printf(D_A(NR_UNIT),NR_FMT1);
12824 io_printf(D_A(NR_UNIT),NR_FMT2,NR_DIR);
12825 D_A(NR_DIR)++;
12826 D_A(NR_DIR) *= DESCR;
12827 D_F(NR_DIR) = D_V(NR_DIR) = 0;
12828 FASTPR(IOKEY,NR_UNIT,NR_UNIT,TXSP,BLSP);
12829 SAVSTK();
12830 WARNING(NORET);
12831 goto L_NR0;
12832 }
12833 static int
NR99(ret_t retval)12834 NR99(ret_t retval) {
12835 ENTRY(NR99)
12836 RETURN(1)
12837 }
12838 int
PAR(ret_t retval)12839 PAR(ret_t retval) {
12840 ENTRY(PAR)
12841 D(TEMP1) = D(ZEROCL);
12842 D_V(TEMP1) = PAR_;
12843 BRANCH(OPS1)
12844 }
12845 int
SER(ret_t retval)12846 SER(ret_t retval) {
12847 ENTRY(SER)
12848 D(TEMP1) = D(ZEROCL);
12849 D_V(TEMP1) = SER_;
12850 BRANCH(OPS1)
12851 }
12852 int
OVY(ret_t retval)12853 OVY(ret_t retval) {
12854 ENTRY(OVY)
12855 D(TEMP1) = D(ZEROCL);
12856 D_V(TEMP1) = OVY_;
12857 BRANCH(OPS1)
12858 }
12859 int
MERGE(ret_t retval)12860 MERGE(ret_t retval) {
12861 ENTRY(MERGE)
12862 D(TEMP1) = D(ZEROCL);
12863 D_V(TEMP1) = MERGE_;
12864 BRANCH(OPS1)
12865 }
12866 static int
OPS1(ret_t retval)12867 OPS1(ret_t retval) {
12868 ENTRY(OPS1)
12869 D(ZPTR) = D(NULVCL);
12870 D_A(OP_N) = D_V(INCL);
12871 D_F(OP_N) = D_V(OP_N) = 0;
12872 L_OPS4:
12873 if (D_A(OP_N) != 0)
12874 goto L_OPS2;
12875 BRANCH(RTZPTR)
12876 L_OPS2:
12877 D_A(OP_N)--;
12878 PUSH(ZPTR);
12879 PUSH(TEMP1);
12880 PUSH(OP_N);
12881 SAVSTK();
12882 if (BLOKVAL(YPTR) == 1)
12883 BRANCH(FAIL)
12884 POP(OP_N);
12885 POP(TEMP1);
12886 POP(ZPTR);
12887 SAVSTK();
12888 PUSH(YPTR);
12889 PUSH(ZPTR);
12890 JOIN(ZPTR);
12891 goto L_OPS4;
12892 }
12893 static int
CCATB(ret_t retval)12894 CCATB(ret_t retval) {
12895 ENTRY(CCATB)
12896 D(TEMP1) = D(ZEROCL);
12897 D_V(TEMP1) = PAR_;
12898 SAVSTK();
12899 PUSH(YPTR);
12900 PUSH(XPTR);
12901 JOIN(XPTR);
12902 BRANCH(RTXPTR)
12903 }
12904 static int
PAR_CONG(ret_t retval)12905 PAR_CONG(ret_t retval) {
12906 ENTRY(PAR_CONG)
12907 POP(PC_TN);
12908 L_PC1:
12909 D(PC_PC) = D(D_A(PC_TN) + FATHER_);
12910 if (D_A(PC_PC) == 0)
12911 BRANCH(FAIL)
12912 D(PC_VAL) = D(D_A(PC_PC) + VALUE_);
12913 if (D_V(D_A(PC_VAL) + ORG_) <= D_V(PC_MG))
12914 goto L_PC3;
12915 if (D_V(PC_VAL) == S)
12916 goto L_PC2;
12917 D(TEMP39) = D(D_A(PC_VAL) + ORG_);
12918 if (D_V(TEMP39) != PHY_)
12919 goto L_PC2;
12920 L_PC3:
12921 D(retval) = D(PC_PC);
12922 RETURN(2)
12923 L_PC2:
12924 D(PC_TN) = D(PC_PC);
12925 goto L_PC1;
12926 }
12927 static int
PRE_SUF(ret_t retval)12928 PRE_SUF(ret_t retval) {
12929 ENTRY(PRE_SUF)
12930 POP(PS_OTR);
12931 POP(PS_INR);
12932 POP(PS_REG);
12933 D(TEMP33) = D(PS_OTR);
12934 D_A(TEMP33) -= D_A(PS_INR);
12935 if (D_A(PS_REG) != 0)
12936 goto L_PS1;
12937 if (D_A(PS_TWO) == 0)
12938 BRANCH(FAIL)
12939 CLR_MATH_ERROR();
12940 D(TEMP31) = D(TEMP33);
12941 D_A(TEMP31) /= D_A(PS_TWO);
12942 if (MATH_ERROR())
12943 BRANCH(FAIL)
12944 D(TEMP32) = D(TEMP33);
12945 D_A(TEMP32) -= D_A(TEMP31);
12946 L_PS99:
12947 RETURN(1)
12948 L_PS1:
12949 if (D_A(PS_REG) != 1)
12950 goto L_PS2;
12951 D(TEMP32) = D(TEMP33);
12952 D(TEMP31) = D(PS_ZR);
12953 goto L_PS99;
12954 L_PS2:
12955 D(TEMP32) = D(PS_ZR);
12956 D(TEMP31) = D(TEMP33);
12957 goto L_PS99;
12958 }
12959 int
PRINTB(ret_t retval)12960 PRINTB(ret_t retval) {
12961 ENTRY(PRINTB)
12962 D_A(PR_NA) = D_V(INCL);
12963 D_F(PR_NA) = D_V(PR_NA) = 0;
12964 if (D_A(PR_NA) == 0)
12965 BRANCH(ARGNER)
12966 D_A(PR_NA)--;
12967 SAVSTK();
12968 if (BLOKVAL(XCL) == 1)
12969 BRANCH(FAIL)
12970 if (D_A(XCL) == 0)
12971 BRANCH(RETNUL)
12972 if (D_V(XCL) == S)
12973 goto L_PR6;
12974 SAVSTK();
12975 PUSH(ZEROCL);
12976 PUSH(XCL);
12977 FIXINL(XCL);
12978 L_PR6:
12979 PUSH(XCL);
12980 SAVSTK();
12981 PUSH(PR_NA);
12982 if (UNITS(PR_UF1) == 1)
12983 BRANCH(FAIL)
12984 POP(XCL);
12985 if (D_A(PR_UF1) == 0)
12986 BRANCH(RETNUL)
12987 D_A(PR_NA) = D_V(D_A(PR_UF1));
12988 D_F(PR_NA) = D_V(PR_NA) = 0;
12989 goto L_PR3;
12990 L_PR4:
12991 D_A(PR_UF1) += 2*DESCR;
12992 L_PR3:
12993 if (D_A(PR_NA) == 0)
12994 BRANCH(RETNUL)
12995 D_A(PR_NA) -= 2*DESCR;
12996 D(PR_UNIT) = D(D_A(PR_UF1) + DESCR);
12997 if (D_A(PR_UNIT) == 0)
12998 goto L_PR4;
12999 D(PR_FLAG) = D(D_A(PR_UF1) + 2*DESCR);
13000 if (D_V(XCL) == S)
13001 goto L_PRSTR;
13002 D(TEMP2) = D(D_A(XCL) + FRAME_);
13003 D(PR_HT) = D(D_A(TEMP2) + HT_);
13004 if (D_V(PR_HT) == EDGDT)
13005 D(PR_HT) = D(D_A(PR_HT) + TR1_);
13006 D(PR_DTH) = D(D_A(TEMP2) + DTH_);
13007 if (D_V(PR_DTH) == EDGDT)
13008 D(PR_DTH) = D(D_A(PR_DTH) + TR1_);
13009 D_A(PR_N) = 0;
13010 D_A(PR_I) = 0;
13011 D(TEMP1) = D(D_A(XCL) + ARRAY_);
13012 if (D_A(TEMP1) == 0)
13013 goto L_PRNOTH;
13014 D(PR_UF2) = D(ZEROCL);
13015 L_PR1:
13016 D_A(PR_I)++;
13017 if (D_A(PR_I) > D_A(PR_HT))
13018 goto L_PR99;
13019 D_A(PR_J) = 1;
13020 D_A(PR_N) += DESCR;
13021 D(YCL) = D(D_A(TEMP1) + D_A(PR_N));
13022 X_LOCSP(YSP,YCL);
13023 FASTPR(IOKEY,PR_UNIT,PR_FLAG,YSP,BLSP);
13024 if (D_A(IOKEY) != 0)
13025 BRANCH(PRERR)
13026 L_PR2:
13027 D_A(PR_J)++;
13028 if (D_A(PR_J) > D_A(PR_DTH))
13029 goto L_PR1;
13030 D_A(PR_N) += DESCR;
13031 D(YCL) = D(D_A(TEMP1) + D_A(PR_N));
13032 if (D_A(PR_UF2) != 0)
13033 goto L_PR21;
13034 X_LOCSP(YSP,YCL);
13035 switch (STREAM(XSP, YSP, &FRWDTB)) {
13036 case ST_ERROR:
13037 case ST_EOS:
13038 goto L_PR23;
13039 }
13040 L_PR22:
13041 X_LOCSP(YSP,YCL);
13042 FASTPR(IOKEY,PR_UNIT,PR_FLAG,YSP,PR_PLUS);
13043 if (D_A(IOKEY) != 0)
13044 BRANCH(PRERR)
13045 goto L_PR2;
13046 L_PR21:
13047 if (D_A(PR_UF2) == D_A(YCL))
13048 goto L_PR2;
13049 goto L_PR22;
13050 L_PR23:
13051 D(PR_UF2) = D(YCL);
13052 goto L_PR2;
13053 L_PR99:
13054 if (D_A(PR_FLAG) >= 0)
13055 goto L_PR4;
13056 FASTPR(IOKEY,PR_UNIT,PR_FLAG,PR_NULL,BLSP);
13057 if (D_A(IOKEY) != 0)
13058 BRANCH(PRERR)
13059 goto L_PR4;
13060 L_PRSTR:
13061 X_LOCSP(YSP,XCL);
13062 FASTPR(IOKEY,PR_UNIT,PR_FLAG,YSP,BLSP);
13063 if (D_A(IOKEY) != 0)
13064 BRANCH(PRERR)
13065 goto L_PR99;
13066 L_PRNOTH:
13067 L_PRN1:
13068 D_A(PR_I)++;
13069 if (D_A(PR_I) > D_A(PR_HT))
13070 goto L_PR99;
13071 FASTPR(IOKEY,PR_UNIT,PR_FLAG,PR_NULL,BLSP);
13072 if (D_A(IOKEY) != 0)
13073 BRANCH(PRERR)
13074 goto L_PRN1;
13075 }
13076 int
NEW_PAGE(ret_t retval)13077 NEW_PAGE(ret_t retval) {
13078 ENTRY(NEW_PAGE)
13079 D_A(PR_NA) = D_V(INCL);
13080 D_F(PR_NA) = D_V(PR_NA) = 0;
13081 SAVSTK();
13082 PUSH(PR_NA);
13083 if (UNITS(PR_UF1) == 1)
13084 BRANCH(FAIL)
13085 if (D_A(PR_UF1) == 0)
13086 BRANCH(RETNUL)
13087 D_A(PR_NA) = D_V(D_A(PR_UF1));
13088 D_F(PR_NA) = D_V(PR_NA) = 0;
13089 L_NP1:
13090 if (D_A(PR_NA) == 0)
13091 BRANCH(RETNUL)
13092 D(PR_I) = D(D_A(PR_UF1) + DESCR);
13093 if (D_A(PR_I) == 0)
13094 goto L_NP2;
13095 D(PR_FLAG) = D(D_A(PR_UF1) + 2*DESCR);
13096 FASTPR(IOKEY,PR_I,PR_FLAG,PR_NULL,PR_1);
13097 if (D_A(IOKEY) != 0)
13098 BRANCH(PRERR)
13099 L_NP2:
13100 D_A(PR_NA) -= 2*DESCR;
13101 D_A(PR_UF1) += 2*DESCR;
13102 goto L_NP1;
13103 }
13104 static int
PRERR(ret_t retval)13105 PRERR(ret_t retval) {
13106 ENTRY(PRERR)
13107 BRANCH(COMP6)
13108 }
13109 static int
P_BLOCK(ret_t retval)13110 P_BLOCK(ret_t retval) {
13111 ENTRY(P_BLOCK)
13112 D_V(PB_FS) = A;
13113 SAVSTK();
13114 PUSH(PB_FS);
13115 BLOCK(NP_FR);
13116 POP(NP_BL);
13117 POP(PB_H);
13118 POP(PB_W);
13119 POP(PB_D);
13120 POP(NP_AR);
13121 MOVBLK(D_A(NP_FR),D_A(PB_FR),D_A(PB_FS));
13122 PUSH(NP_AR);
13123 PUSH(NP_FR);
13124 PUSH(NP_BL);
13125 BRANCH(NP_BLOCK)
13126 }
13127 static int
NP_BLOCK(ret_t retval)13128 NP_BLOCK(ret_t retval) {
13129 ENTRY(NP_BLOCK)
13130 SAVSTK();
13131 PUSH(NP_DE);
13132 BLOCK(NP_NP);
13133 POP(NP_BL);
13134 POP(NP_FR);
13135 POP(NP_AR);
13136 MOVBLK(D_A(NP_NP),D_A(NP_BK),D_A(NP_DE));
13137 D(retval) = D(NP_NP);
13138 RETURN(1)
13139 }
13140 static int
REPL(ret_t retval)13141 REPL(ret_t retval) {
13142 ENTRY(REPL)
13143 POP(RE_A);
13144 POP(RE_F);
13145 POP(RE_DIR);
13146 POP(RE_N);
13147 D(RE_RE) = D(NULVCL);
13148 if (D_A(RE_A) == 0)
13149 goto L_RE99;
13150 if (D_A(RE_N) < 1)
13151 goto L_RESZ;
13152 if (D_A(RE_N) == 1)
13153 goto L_RES1;
13154 if (D_A(RE_DIR) == WTH_)
13155 goto L_REH;
13156 D(RE_H) = D(D_A(RE_F) + HT_);
13157 D(RE_D) = D(D_A(RE_F) + DTH_);
13158 D(RE_L) = D(RE_D);
13159 D_A(RE_L) *= D_A(RE_H);
13160 D_A(RE_L) *= DESCR;
13161 D_F(RE_L) = D_V(RE_L) = 0;
13162 D(RE_SIZE) = D(RE_L);
13163 D_A(RE_SIZE) *= D_A(RE_N);
13164 PUSH(RE_A);
13165 PUSH(RE_F);
13166 D_V(RE_SIZE) = A;
13167 SAVSTK();
13168 PUSH(RE_SIZE);
13169 BLOCK(RE_RE);
13170 POP(RE_F);
13171 POP(RE_A);
13172 D(RE_P) = D(RE_RE);
13173 if (D_A(RE_DIR) != HT_)
13174 goto L_REN;
13175 D_A(RE_H) *= D_A(RE_N);
13176 D(D_A(RE_F) + HT_) = D(RE_H);
13177 L_REV1:
13178 if (D_A(RE_N) == 0)
13179 goto L_REV2;
13180 D_A(RE_N)--;
13181 MOVBLK(D_A(RE_P),D_A(RE_A),D_A(RE_L));
13182 D_A(RE_P) += D_A(RE_L);
13183 goto L_REV1;
13184 L_REV2:
13185 goto L_RE99;
13186 L_REN:
13187 D(RE_L) = D(RE_D);
13188 D_A(RE_L) *= D_A(RE_N);
13189 D(D_A(RE_F) + DTH_) = D(RE_L);
13190 D_A(RE_D) *= DESCR;
13191 D_F(RE_D) = D_V(RE_D) = 0;
13192 D(RE_Q) = D(RE_A);
13193 D(RE_I) = D(RE_N);
13194 L_REN1:
13195 if (D_A(RE_H) == 0)
13196 goto L_RE99;
13197 D_A(RE_H)--;
13198 L_REN2:
13199 if (D_A(RE_I) == 0)
13200 goto L_REN3;
13201 D_A(RE_I)--;
13202 MOVBLK(D_A(RE_P),D_A(RE_Q),D_A(RE_D));
13203 D_A(RE_P) += D_A(RE_D);
13204 goto L_REN2;
13205 L_REN3:
13206 D_A(RE_Q) += D_A(RE_D);
13207 D(RE_I) = D(RE_N);
13208 goto L_REN1;
13209 L_REH:
13210 SAVSTK();
13211 PUSH(RE_A);
13212 BCOPY(TEMP31);
13213 D_A(RE_SIZE) = D_V(D_A(TEMP31));
13214 D_F(RE_SIZE) = D_V(RE_SIZE) = 0;
13215 D(TEMP32) = D(TEMP31);
13216 D(TEMP33) = D(TEMP32);
13217 D_A(TEMP33) += D_A(RE_SIZE);
13218 D(RE_W) = D(D_A(RE_F) + WTH_);
13219 D_A(RE_W) *= D_A(RE_N);
13220 D(D_A(RE_F) + WTH_) = D(RE_W);
13221 L_REH1:
13222 D_A(TEMP32) += DESCR;
13223 if (D_A(TEMP32) > D_A(TEMP33))
13224 goto L_REH99;
13225 D(RE_P) = D(D_A(TEMP32));
13226 SAVSTK();
13227 PUSH(RE_N);
13228 PUSH(RE_P);
13229 DUPE(RE_P);
13230 D(D_A(TEMP32)) = D(RE_P);
13231 goto L_REH1;
13232 L_REH99:
13233 D(RE_RE) = D(TEMP31);
13234 goto L_RE99;
13235 L_RES1:
13236 SAVSTK();
13237 PUSH(RE_A);
13238 BCOPY(RE_RE);
13239 goto L_RE99;
13240 L_RESZ:
13241 D(RE_RE) = D(NULVCL);
13242 D(D_A(RE_F) + D_A(RE_DIR)) = D(RE_0);
13243 goto L_RE99;
13244 L_RE99:
13245 D(retval) = D(RE_RE);
13246 RETURN(1)
13247 }
13248 int
SLAB(ret_t retval)13249 SLAB(ret_t retval) {
13250 ENTRY(SLAB)
13251 D_A(SL_NA) = D_V(INCL);
13252 D_F(SL_NA) = D_V(SL_NA) = 0;
13253 if (D_A(SL_NA) != 4)
13254 BRANCH(ARGNER)
13255 SAVSTK();
13256 if (BLOKVAL(ZPTR) == 1)
13257 BRANCH(FAIL)
13258 SAVSTK();
13259 PUSH(NULVCL);
13260 PUSH(ZPTR);
13261 FIXINL(ZPTR);
13262 SAVSTK();
13263 PUSH(ZPTR);
13264 BCOPY(ZPTR);
13265 D(TEMP2) = D(D_A(ZPTR) + FRAME_);
13266 SAVSTK();
13267 PUSH(TEMP2);
13268 STRIP_F(TEMP2);
13269 D(D_A(ZPTR) + FRAME_) = D(TEMP2);
13270 PUSH(ZPTR);
13271 SAVSTK();
13272 if (INTVAL(SL_DIR) == 1)
13273 BRANCH(FAIL)
13274 if (D_A(SL_DIR) < 0)
13275 BRANCH(LENERR)
13276 PUSH(SL_DIR);
13277 SAVSTK();
13278 if (INTVAL(SL_I) == 1)
13279 BRANCH(FAIL)
13280 PUSH(SL_I);
13281 SAVSTK();
13282 if (INTVAL(SL_L) == 1)
13283 BRANCH(FAIL)
13284 if (D_A(SL_L) < 0)
13285 BRANCH(LENERR)
13286 POP(SL_I);
13287 POP(SL_DIR);
13288 POP(ZPTR);
13289 D_A(SL_DIR)++;
13290 D(TEMP1) = D(D_A(ZPTR) + ARRAY_);
13291 D(D_A(ZPTR) + ARRAY_) = D(NULVCL);
13292 D(TEMP2) = D(D_A(ZPTR) + FRAME_);
13293 D(SL_H) = D(D_A(TEMP2) + HT_);
13294 D(SL_W) = D(D_A(TEMP2) + WTH_);
13295 D(SL_D) = D(D_A(TEMP2) + DTH_);
13296 D(WPTR) = D(ZEROCL);
13297 D_A(WPTR) = D_A(SL_DIR);
13298 D_A(WPTR) *= DESCR;
13299 D_F(WPTR) = D_V(WPTR) = 0;
13300 D(SL_T) = D(D_A(TEMP2) + D_A(WPTR));
13301 if (D_A(SL_I) >= 1)
13302 goto L_SL1;
13303 D_A(SL_L)--;
13304 D_A(SL_L) += D_A(SL_I);
13305 D_A(SL_I) = 1;
13306 if (D_A(SL_L) > 0)
13307 goto L_SL1;
13308 D_A(SL_L) = 0;
13309 goto L_SL2;
13310 L_SL1:
13311 if (D_A(SL_I) <= D_A(SL_T))
13312 goto L_SL11;
13313 D_A(SL_L) = 0;
13314 goto L_SL2;
13315 L_SL11:
13316 D_A(SL_I)--;
13317 D_A(SL_T) -= D_A(SL_I);
13318 if (D_A(SL_L) <= D_A(SL_T))
13319 goto L_SL2;
13320 D_A(SL_L) = D_A(SL_T);
13321 L_SL2:
13322 D(D_A(TEMP2) + D_A(WPTR)) = D(SL_L);
13323 if (D_A(SL_L) == 0)
13324 BRANCH(RTZPTR)
13325 if (D_A(TEMP1) == 0)
13326 BRANCH(RTZPTR)
13327 switch (D_A(SL_DIR)) {
13328 case 1:
13329 goto L_SLAB1;
13330 case 2:
13331 goto L_SLAB2;
13332 case 3:
13333 goto L_SLAB3;
13334 }
13335 L_SLAB1:
13336 D_A(SL_D) *= DESCR;
13337 D_F(SL_D) = D_V(SL_D) = 0;
13338 D_A(SL_L) *= D_A(SL_D);
13339 D_V(SL_L) = A;
13340 SAVSTK();
13341 PUSH(SL_L);
13342 BLOCK(TEMP3);
13343 D_A(SL_I) *= D_A(SL_D);
13344 D_A(TEMP1) += D_A(SL_I);
13345 MOVBLK(D_A(TEMP3),D_A(TEMP1),D_A(SL_L));
13346 D(D_A(ZPTR) + ARRAY_) = D(TEMP3);
13347 BRANCH(RTZPTR)
13348 L_SLAB2:
13349 SAVSTK();
13350 PUSH(TEMP1);
13351 BCOPY(TEMP1);
13352 D_A(SL_T) = D_V(D_A(TEMP1));
13353 D_F(SL_T) = D_V(SL_T) = 0;
13354 D_A(SL_H) = 0;
13355 L_SLAB21:
13356 D_A(SL_H) += DESCR;
13357 if (D_A(SL_H) > D_A(SL_T))
13358 goto L_SLAB22;
13359 D(YPTR) = D(D_A(TEMP1) + D_A(SL_H));
13360 SAVSTK();
13361 PUSH(SL_L);
13362 CONVAR(XPTR);
13363 X_LOCSP(YSP,YPTR);
13364 X_LOCSP(VSP,XPTR);
13365 S_L(VSP) = 0;
13366 S_L(XSP) = D_A(SL_I);
13367 X_REMSP(YSP,YSP,XSP);
13368 S_L(YSP) = D_A(SL_L);
13369 APDSP(VSP,YSP);
13370 SAVSTK();
13371 PUSH(SL_L);
13372 GNVARS(XPTR);
13373 D(D_A(TEMP1) + D_A(SL_H)) = D(XPTR);
13374 goto L_SLAB21;
13375 L_SLAB22:
13376 D(D_A(ZPTR) + ARRAY_) = D(TEMP1);
13377 BRANCH(RTZPTR)
13378 L_SLAB3:
13379 D_A(SL_D) *= DESCR;
13380 D_F(SL_D) = D_V(SL_D) = 0;
13381 D_A(SL_L) *= DESCR;
13382 D_F(SL_L) = D_V(SL_L) = 0;
13383 D(SL_T) = D(SL_H);
13384 D_A(SL_T) *= D_A(SL_L);
13385 D_V(SL_T) = A;
13386 SAVSTK();
13387 PUSH(SL_T);
13388 BLOCK(TEMP3);
13389 D(TEMP11) = D(TEMP1);
13390 D(TEMP31) = D(TEMP3);
13391 D_A(SL_I) *= DESCR;
13392 D_F(SL_I) = D_V(SL_I) = 0;
13393 D_A(TEMP11) += D_A(SL_I);
13394 D_A(SL_T) = 0;
13395 L_SLAB32:
13396 D_A(SL_T)++;
13397 if (D_A(SL_T) > D_A(SL_H))
13398 goto L_SLAB31;
13399 MOVBLK(D_A(TEMP31),D_A(TEMP11),D_A(SL_L));
13400 D_A(TEMP31) += D_A(SL_L);
13401 D_A(TEMP11) += D_A(SL_D);
13402 goto L_SLAB32;
13403 L_SLAB31:
13404 D(D_A(ZPTR) + ARRAY_) = D(TEMP3);
13405 BRANCH(RTZPTR)
13406 }
13407 static int
SUBBLOCK(ret_t retval)13408 SUBBLOCK(ret_t retval) {
13409 ENTRY(SUBBLOCK)
13410 SAVSTK();
13411 PUSH(SB_DSB);
13412 BLOCK(SB_SB);
13413 POP(SB_GF);
13414 POP(SB_LF);
13415 D_A(SB_DIR) = 0;
13416 L_SB1:
13417 D_A(SB_DIR) += DESCR;
13418 if (D_A(SB_DIR) > FRSIZE_)
13419 goto L_SB99;
13420 D(SB_GE) = D(D_A(SB_GF) + D_A(SB_DIR));
13421 D(SB_LE) = D(D_A(SB_LF) + D_A(SB_DIR));
13422 if (D_V(SB_GE) == EDGDT)
13423 D(SB_GR) = D(D_A(SB_GE) + RELS1_);
13424 else
13425 D(SB_GR) = D(NULVCL);
13426 if (D_V(SB_LE) == EDGDT)
13427 D(SB_LR) = D(D_A(SB_LE) + RELS1_);
13428 else
13429 D(SB_LR) = D(NULVCL);
13430 if (D_V(SB_GE) == EDGDT)
13431 D(SB_GN) = D(D_A(SB_GE) + NN1_);
13432 else
13433 D(SB_GN) = D(ZEROCL);
13434 if (D_V(SB_LE) == EDGDT)
13435 D(SB_LN) = D(D_A(SB_LE) + NN1_);
13436 else
13437 D(SB_LN) = D(ZEROCL);
13438 SAVSTK();
13439 PUSH(SB_LN);
13440 PUSH(SB_LR);
13441 PUSH(SB_GN);
13442 PUSH(SB_GR);
13443 if (FICOM(NORET) == 1)
13444 BRANCH(FAIL)
13445 D(TEMP33) = D(D_A(SB_GR) + D_A(TEMP31));
13446 D(TEMP34) = D(D_A(SB_LR) + D_A(TEMP32));
13447 D_A(TEMP33) = D_V(TEMP33);
13448 D_F(TEMP33) = D_V(TEMP33) = 0;
13449 D_A(TEMP34) = D_V(TEMP34);
13450 D_F(TEMP34) = D_V(TEMP34) = 0;
13451 D(TEMP35) = D(TEMP33);
13452 D_A(TEMP35) -= D_A(TEMP34);
13453 if (D_V(SB_LE) == EDGDT)
13454 D(TEMP36) = D(D_A(SB_LE) + TR1_);
13455 else
13456 D(TEMP36) = D(SB_LE);
13457 D_V(TEMP35) = D_A(TEMP36);
13458 D(D_A(SB_SB) + D_A(SB_DIR)) = D(TEMP35);
13459 goto L_SB1;
13460 L_SB99:
13461 D(retval) = D(SB_SB);
13462 RETURN(2)
13463 }
13464 static int
STRIP_F(ret_t retval)13465 STRIP_F(ret_t retval) {
13466 ENTRY(STRIP_F)
13467 POP(SF_F);
13468 SAVSTK();
13469 PUSH(SF_F);
13470 BCOPY(SF_F);
13471 D_A(SF_DIR) = (int_t) HT_;
13472 L_SF1:
13473 D(SF_E) = D(D_A(SF_F) + D_A(SF_DIR));
13474 if (D_V(SF_E) == EDGDT)
13475 D(SF_E) = D(D_A(SF_E) + TR1_);
13476 D(D_A(SF_F) + D_A(SF_DIR)) = D(SF_E);
13477 D_A(SF_DIR) += DESCR;
13478 if (D_A(SF_DIR) <= DTH_)
13479 goto L_SF1;
13480 D(retval) = D(SF_F);
13481 RETURN(1)
13482 }
13483 static int
T_LEAF(ret_t retval)13484 T_LEAF(ret_t retval) {
13485 ENTRY(T_LEAF)
13486 SAVSTK();
13487 PUSH(TL_SIZE);
13488 BLOCK(TL_TL);
13489 POP(TL_F);
13490 POP(TL_RS);
13491 POP(TL_V);
13492 D(D_A(TL_TL) + FATHER_) = D(TL_F);
13493 D(D_A(TL_TL) + RSIB_) = D(TL_RS);
13494 L_TLF0:
13495 D(D_A(TL_TL) + VALUE_) = D(TL_V);
13496 if (D_V(TL_V) == S)
13497 goto L_TLF99;
13498 D(TL_N) = D(D_A(TL_V) + ORG_);
13499 D_A(TL_N) = D_V(TL_N);
13500 D_F(TL_N) = D_V(TL_N) = 0;
13501 switch (D_A(TL_N)) {
13502 case 1:
13503 goto L_TLF1;
13504 case 2:
13505 goto L_TLF2;
13506 case 3:
13507 goto L_TLF3;
13508 case 4:
13509 goto L_TLF4;
13510 case 5:
13511 goto L_TLF5;
13512 case 6:
13513 goto L_TLF6;
13514 case 7:
13515 goto L_TLF7;
13516 case 8:
13517 goto L_TLF8;
13518 case 9:
13519 goto L_TLF9;
13520 }
13521 L_TLF1:
13522 L_TLF2:
13523 L_TLF3:
13524 D(TL_REG) = D(D_A(TL_V) + REG_);
13525 if (D_A(TL_REG) != 0)
13526 goto L_TLF11;
13527 D(D_A(TL_TL) + TNREG_) = D(CTR_REG);
13528 goto L_TLF99;
13529 L_TLF11:
13530 PUSH(TL_TL);
13531 SAVSTK();
13532 PUSH(TL_REG);
13533 BCOPY(TL_REG);
13534 POP(TL_TL);
13535 SAVSTK();
13536 PUSH(TL_REG);
13537 NRMZ_REG(NORET);
13538 D(D_A(TL_TL) + TNREG_) = D(TL_REG);
13539 goto L_TLF99;
13540 L_TLF4:
13541 goto L_TLF99;
13542 L_TLF5:
13543 D(TL_V) = D(D_A(TL_V) + ELEMENT_);
13544 PUSH(TL_TL);
13545 SAVSTK();
13546 PUSH(TL_V);
13547 PUSH(NULVCL);
13548 PUSH(TL_TL);
13549 T_LEAF(TL_TN2);
13550 POP(TL_TL);
13551 D(D_A(TL_TL) + LSO_) = D(TL_TN2);
13552 D(TL_V) = D(D_A(TL_TN2) + VALUE_);
13553 if (D_V(TL_V) == S)
13554 goto L_TLF99;
13555 D(TEMP39) = D(D_A(TL_V) + ORG_);
13556 if (D_V(TEMP39) != REP_)
13557 goto L_TLF99;
13558 D(TL_TEMP) = D(D_A(TL_TL) + VALUE_);
13559 D(D_A(TL_TN2) + VALUE_) = D(TL_TEMP);
13560 D(D_A(TL_TL) + VALUE_) = D(TL_V);
13561 goto L_TLF99;
13562 L_TLF6:
13563 L_TLF7:
13564 D(TL_V) = D(D_A(TL_V) + ELEMENT_);
13565 PUSH(TL_TL);
13566 SAVSTK();
13567 PUSH(TL_V);
13568 PUSH(NULVCL);
13569 PUSH(TL_TL);
13570 T_LEAF(TL_TN2);
13571 POP(TL_TL);
13572 D(D_A(TL_TL) + LSO_) = D(TL_TN2);
13573 goto L_TLF99;
13574 L_TLF8:
13575 D(TL_V) = D(D_A(TL_V) + NAME_);
13576 D(TL_V) = D(D_A(TL_V) + DESCR);
13577 goto L_TLF0;
13578 L_TLF9:
13579 goto L_TLF99;
13580 L_TLF99:
13581 D(retval) = D(TL_TL);
13582 RETURN(1)
13583 }
13584 int
IT(ret_t retval)13585 IT(ret_t retval) {
13586 ENTRY(IT)
13587 D(UD_TP) = D(UD_IT);
13588 BRANCH(UDCOM)
13589 }
13590 int
REP(ret_t retval)13591 REP(ret_t retval) {
13592 ENTRY(REP)
13593 D(UD_TP) = D(UD_REP);
13594 BRANCH(UDCOM)
13595 }
13596 int
NODE(ret_t retval)13597 NODE(ret_t retval) {
13598 ENTRY(NODE)
13599 D_A(UD_ID)++;
13600 D(UD_TP) = D(UD_ID);
13601 BRANCH(UDCOM)
13602 }
13603 static int
UDCOM(ret_t retval)13604 UDCOM(ret_t retval) {
13605 ENTRY(UDCOM)
13606 PUSH(UD_TP);
13607 SAVSTK();
13608 if (BLOKVAL(TEMP1) == 1)
13609 BRANCH(FAIL)
13610 if (D_V(TEMP1) != S)
13611 goto L_UDCOM1;
13612 SAVSTK();
13613 PUSH(NULVCL);
13614 PUSH(TEMP1);
13615 FIXINL(TEMP1);
13616 L_UDCOM1:
13617 POP(UD_TP);
13618 SAVSTK();
13619 PUSH(UD_SIZE);
13620 BLOCK(XPTR);
13621 D(D_A(XPTR) + ELEMENT_) = D(TEMP1);
13622 D(D_A(XPTR) + ORG_) = D(UD_TP);
13623 BRANCH(RTXPTR)
13624 }
13625 int
DEF(ret_t retval)13626 DEF(ret_t retval) {
13627 ENTRY(DEF)
13628 SAVSTK();
13629 if (IND(TEMP1) == 1)
13630 BRANCH(FAIL)
13631 SAVSTK();
13632 PUSH(UD_SIZE);
13633 BLOCK(XPTR);
13634 D(D_A(XPTR) + ORG_) = D(UD_DFT);
13635 D(D_A(XPTR) + NAME_) = D(TEMP1);
13636 BRANCH(RTXPTR)
13637 }
13638 static int
UNITS(ret_t retval)13639 UNITS(ret_t retval) {
13640 ENTRY(UNITS)
13641 D(UN_I) = D(UN_0);
13642 D(UN_UN) = D(UN_UN1);
13643 ZERBLK(D_A(UN_UN3),D_A(UN_UN4));
13644 POP(UN_N);
13645 if (D_A(UN_N) == 0)
13646 goto L_UNITS2;
13647 L_UNITS1:
13648 if (D_A(UN_N) == 0)
13649 goto L_UN99;
13650 D_A(UN_N)--;
13651 PUSH(UN_UN);
13652 PUSH(UN_N);
13653 SAVSTK();
13654 if (INTVAL(UN_I) == 1)
13655 BRANCH(FAIL)
13656 POP(UN_N);
13657 POP(UN_UN);
13658 if (D_A(UN_I) < 0)
13659 goto L_UNITS1;
13660 L_UNITS2:
13661 if (D_A(TEMP48) == 0)
13662 goto L_UNNATL;
13663 if (!LOCAPT(XCL,TEMP48,UN_I))
13664 goto L_UNNATL;
13665 D(YCL) = D(D_A(XCL) + 2*DESCR);
13666 if (D_A(UN_I) != 0)
13667 goto L_UNITS5;
13668 D_A(UN_I) = (int_t) PRUNO;
13669 L_UNITS5:
13670 SAVSTK();
13671 PUSH(YCL);
13672 PUSH(UN_I);
13673 PUSH(UN_UN);
13674 AUGATL(UN_UN);
13675 goto L_UNITS1;
13676 L_UNNATL:
13677 D(YPTR) = D(ZEROCL);
13678 if (D_A(UN_I) != 0)
13679 goto L_UNITS4;
13680 D_A(YPTR) = 1;
13681 D_A(UN_I) = (int_t) PRUNO;
13682 L_UNITS4:
13683 SAVSTK();
13684 PUSH(YPTR);
13685 PUSH(UN_I);
13686 PUSH(UN_UN);
13687 AUGATL(UN_UN);
13688 goto L_UNITS1;
13689 L_UN99:
13690 D(retval) = D(UN_UN);
13691 RETURN(2)
13692 }
13693 static int
WARNING(ret_t retval)13694 WARNING(ret_t retval) {
13695 ENTRY(WARNING)
13696 D_A(WA_N)++;
13697 io_printf(D_A(WA_DIAG),WA_FMT,FILENM,LNNOCL,WA_N,STNOCL);
13698 if (D_A(WA_N) > MAXW)
13699 goto L_WA1;
13700 BRANCH(RTN1)
13701 L_WA1:
13702 D_A(ERRTYP) = (int_t) (ERRNO+2);
13703 BRANCH(FTLEND)
13704 }
13705 static int
RT1NUL(ret_t retval)13706 RT1NUL(ret_t retval) {
13707 ENTRY(RT1NUL)
13708 D(retval) = D(NULVCL);
13709 RETURN(1)
13710 /*_*/
13711 }
13712 static int
RTN1(ret_t retval)13713 RTN1(ret_t retval) {
13714 ENTRY(RTN1)
13715 /* FALL */
13716 BRANCH(FAIL)
13717 }
13718 static int
FAIL(ret_t retval)13719 FAIL(ret_t retval) {
13720 ENTRY(FAIL)
13721 RETURN(1)
13722 /*_*/
13723 }
13724 static int
RETNUL(ret_t retval)13725 RETNUL(ret_t retval) {
13726 ENTRY(RETNUL)
13727 D(retval) = D(NULVCL);
13728 RETURN(3)
13729 /*_*/
13730 }
13731 static int
RTN2(ret_t retval)13732 RTN2(ret_t retval) {
13733 ENTRY(RTN2)
13734 RETURN(2)
13735 /*_*/
13736 }
13737 static int
RTN3(ret_t retval)13738 RTN3(ret_t retval) {
13739 ENTRY(RTN3)
13740 /* FALL */
13741 BRANCH(RTNUL3)
13742 }
13743 static int
RTNUL3(ret_t retval)13744 RTNUL3(ret_t retval) {
13745 ENTRY(RTNUL3)
13746 RETURN(3)
13747 /*_*/
13748 }
13749 static int
RTXNAM(ret_t retval)13750 RTXNAM(ret_t retval) {
13751 ENTRY(RTXNAM)
13752 D(retval) = D(XPTR);
13753 RETURN(2)
13754 /*_*/
13755 }
13756 static int
RTXPTR(ret_t retval)13757 RTXPTR(ret_t retval) {
13758 ENTRY(RTXPTR)
13759 D(retval) = D(XPTR);
13760 RETURN(3)
13761 /*_*/
13762 }
13763 static int
RTYPTR(ret_t retval)13764 RTYPTR(ret_t retval) {
13765 ENTRY(RTYPTR)
13766 D(retval) = D(YPTR);
13767 RETURN(3)
13768 /*_*/
13769 }
13770 static int
ARTN(ret_t retval)13771 ARTN(ret_t retval) {
13772 ENTRY(ARTN)
13773 D_A(ARTHCL)++;
13774 /* FALL */
13775 BRANCH(RTZPTR)
13776 }
13777 static int
RTZPTR(ret_t retval)13778 RTZPTR(ret_t retval) {
13779 ENTRY(RTZPTR)
13780 D(retval) = D(ZPTR);
13781 RETURN(3)
13782 /*_*/
13783 }
13784 static int
A5RTN(ret_t retval)13785 A5RTN(ret_t retval) {
13786 ENTRY(A5RTN)
13787 D(retval) = D(A5PTR);
13788 RETURN(1)
13789 /*_*/
13790 }
13791 static int
GENVSZ(ret_t retval)13792 GENVSZ(ret_t retval) {
13793 ENTRY(GENVSZ)
13794 SAVSTK();
13795 PUSH(XCL);
13796 if (GNVARS(ZPTR) == 1)
13797 BRANCH(RTZPTR)
13798 /*_*/
13799 }
13800 static int
GENVRZ(ret_t retval)13801 GENVRZ(ret_t retval) {
13802 ENTRY(GENVRZ)
13803 SAVSTK();
13804 PUSH(ZSPPTR);
13805 if (GENVAR(ZPTR) == 1)
13806 BRANCH(RTZPTR)
13807 /*_*/
13808 }
13809 static int
GENVIX(ret_t retval)13810 GENVIX(ret_t retval) {
13811 ENTRY(GENVIX)
13812 SAVSTK();
13813 PUSH(XPTR);
13814 if (GNVARI(XPTR) == 1)
13815 BRANCH(RTXNAM)
13816 /*_*/
13817 }
13818 int
END(ret_t retval)13819 END(ret_t retval) {
13820 ENTRY(END)
13821 if (D_A(ERRLCL) <= 0)
13822 BRANCH(END0)
13823 D_A(ERRLCL)--;
13824 D_A(ERRTYP) = 0;
13825 D_A(ERRTXT) = 0;
13826 D(FRTNCL) = D(OCICL);
13827 D_A(FRTNCL) -= DESCR;
13828 D(LSTNCL) = D(STNOCL);
13829 D_A(LSLNCL) = D_A(LNNOCL);
13830 D_A(LSFLNM) = D_A(FILENM);
13831 SAVSTK();
13832 switch (XITHND(NORET)) {
13833 case 3:
13834 BRANCH(RTNUL3)
13835 }
13836 /* FALL */
13837 BRANCH(END0)
13838 }
13839 static int
END0(ret_t retval)13840 END0(ret_t retval) {
13841 ENTRY(END0)
13842 io_flushall(0);
13843 if (D_A(BANRCL) == 0)
13844 BRANCH(FTLEN2)
13845 io_printf(D_A(PUNCH),NRMEND,LVLCL);
13846 io_printf(D_A(PUNCH),LASTSF,FILENM,LNNOCL,STNOCL);
13847 BRANCH(FTLEN2)
13848 /*_*/
13849 }
13850 static int
FTLEND(ret_t retval)13851 FTLEND(ret_t retval) {
13852 ENTRY(FTLEND)
13853 io_flushall(0);
13854 io_printf(D_A(PUNCH),FTLCF,FILENM,LNNOCL,ERRTYP,STNOCL,LVLCL);
13855 D_A(RETCOD) = 1;
13856 if (D_A(INICOM) != 0)
13857 goto L_FTLEN3;
13858 io_printf(D_A(PUNCH),ALOCFL);
13859 BRANCH(ENDALL)
13860 /*_*/
13861 L_FTLEN3:
13862 D_A(YCL) = D_A(ERRTYP);
13863 D_A(YCL) *= DESCR;
13864 D_F(YCL) = D_V(YCL) = 0;
13865 D(YCL) = D(D_A(MSGNO) + D_A(YCL));
13866 _SPEC(TSP) = _SPEC(D_A(YCL));
13867 IO_PRINT(IOKEY, ERRBLK, TSP);
13868 /* FALL */
13869 BRANCH(FTLEN2)
13870 }
13871 static int
FTLEN2(ret_t retval)13872 FTLEN2(ret_t retval) {
13873 ENTRY(FTLEN2)
13874 ISTACK();
13875 if (D_A(COMPCL) == 0)
13876 goto L_FTLEN4;
13877 D_RV(ETMCL) = mstime();
13878 D_F(ETMCL) = D_V(ETMCL) = 0;
13879 D_RV(TIMECL) = D_RV(ETMCL) - D_RV(TIMECL);
13880 D_F(TIMECL) = D_F(ETMCL);
13881 D_V(TIMECL) = D_V(ETMCL);
13882 D_A(ETMCL) = 0;
13883 goto L_FTLEN1;
13884 /*_*/
13885 L_FTLEN4:
13886 D_RV(XCL) = mstime();
13887 D_F(XCL) = D_V(XCL) = 0;
13888 D_RV(ETMCL) = D_RV(XCL) - D_RV(ETMCL);
13889 D_F(ETMCL) = D_F(XCL);
13890 D_V(ETMCL) = D_V(XCL);
13891 L_FTLEN1:
13892 if (D_A(DMPCL) == 0)
13893 goto L_END1;
13894 if (D_A(NODPCL) != 0)
13895 goto L_DMPNO;
13896 ordvst();
13897 io_printf(D_A(OUTPUT),STDMP);
13898 io_printf(D_A(OUTPUT),NVARF);
13899 SAVSTK();
13900 switch (DUMP(NORET)) {
13901 case 1:
13902 case 2:
13903 BRANCH(INTR10)
13904 case 3:
13905 goto L_DMPK;
13906 }
13907 /*_*/
13908 L_DMPNO:
13909 io_printf(D_A(OUTPUT),INCGCF);
13910 io_printf(D_A(OUTPUT),NODMPF);
13911 goto L_END1;
13912 /*_*/
13913 L_DMPK:
13914 SAVSTK();
13915 DMK(NORET);
13916 L_END1:
13917 if (D_A(STATCL) == 0)
13918 BRANCH(ENDALL)
13919 io_printf(D_A(PUNCH),STATHD);
13920 io_printf(D_A(PUNCH),CMTIME,TIMECL);
13921 io_printf(D_A(PUNCH),INTIME,ETMCL);
13922 io_printf(D_A(PUNCH),EXNO,EXN2CL,FALCL);
13923 io_printf(D_A(PUNCH),ARTHNO,ARTHCL);
13924 io_printf(D_A(PUNCH),SCANNO,SCNCL);
13925 io_printf(D_A(PUNCH),STGENO,GCNO);
13926 io_printf(D_A(PUNCH),STGETM,GCTTTL);
13927 io_printf(D_A(PUNCH),READNO,RSTAT);
13928 io_printf(D_A(PUNCH),WRITNO,WSTAT);
13929 if (D_A(EXN2CL) != 0)
13930 goto L_END2;
13931 D_RV(FCL) = (real_t)D_A(ZEROCL);
13932 D_F(FCL) = 0;
13933 D_V(FCL) = R;
13934 goto L_AVTIME;
13935 /*_*/
13936 L_END2:
13937 D_RV(EXN2CL) = (real_t)D_A(EXN2CL);
13938 D_F(EXN2CL) = 0;
13939 D_V(EXN2CL) = R;
13940 D(FCL) = D(ETMCL);
13941 D_RV(FCL) /= D_RV(EXN2CL);
13942 D_RV(FCL) *= D_RV(R1MCL);
13943 L_AVTIME:
13944 io_printf(D_A(PUNCH),TIMEPS,FCL);
13945 if (D_RV(ETMCL) == D_RV(RZERCL))
13946 BRANCH(ENDALL)
13947 CLR_MATH_ERROR();
13948 D(FCL) = D(EXN2CL);
13949 D_RV(FCL) /= D_RV(ETMCL);
13950 if (RMATH_ERROR(D_RV(FCL)))
13951 BRANCH(ENDALL)
13952 io_printf(D_A(PUNCH),KSTSF,FCL);
13953 /* FALL */
13954 BRANCH(ENDALL)
13955 }
13956 static int
ENDALL(ret_t retval)13957 ENDALL(ret_t retval) {
13958 ENTRY(ENDALL)
13959 endex(D_A(ABNDCL));
13960 return 0;
13961 /*_*/
13962 }
13963 int
SYSCUT(ret_t retval)13964 SYSCUT(ret_t retval) {
13965 ENTRY(SYSCUT)
13966 io_flushall(0);
13967 io_printf(D_A(PUNCH),SYSCMT,FILENM,LNNOCL,SIGNCL,STNOCL,LVLCL);
13968 if (D_A(CUTNO) != 0)
13969 BRANCH(ENDALL)
13970 D_A(CUTNO) = 1;
13971 D_A(RETCOD) = 1;
13972 BRANCH(FTLEN2)
13973 /*_*/
13974 }
13975 static int
AERROR(ret_t retval)13976 AERROR(ret_t retval) {
13977 ENTRY(AERROR)
13978 D_A(ERRTYP) = 2;
13979 BRANCH(FTLTST)
13980 /*_*/
13981 }
13982 static int
ALOC2(ret_t retval)13983 ALOC2(ret_t retval) {
13984 ENTRY(ALOC2)
13985 D_A(ERRTYP) = 20;
13986 BRANCH(FTLEND)
13987 /*_*/
13988 }
13989 int
ARGNER(ret_t retval)13990 ARGNER(ret_t retval) {
13991 ENTRY(ARGNER)
13992 D_A(ERRTYP) = 25;
13993 BRANCH(FTLERR)
13994 /*_*/
13995 }
13996 static int
COMP1(ret_t retval)13997 COMP1(ret_t retval) {
13998 ENTRY(COMP1)
13999 D_A(ERRTYP) = 32;
14000 BRANCH(FTLTST)
14001 /*_*/
14002 }
14003 int
INTR10(ret_t retval)14004 INTR10(ret_t retval) {
14005 ENTRY(INTR10)
14006 /* FALL */
14007 BRANCH(INTR13)
14008 }
14009 static int
INTR13(ret_t retval)14010 INTR13(ret_t retval) {
14011 ENTRY(INTR13)
14012 /* FALL */
14013 BRANCH(COMP3)
14014 }
14015 static int
COMP3(ret_t retval)14016 COMP3(ret_t retval) {
14017 ENTRY(COMP3)
14018 D_A(ERRTYP) = 17;
14019 BRANCH(FTLEND)
14020 /*_*/
14021 }
14022 static int
COMP5(ret_t retval)14023 COMP5(ret_t retval) {
14024 ENTRY(COMP5)
14025 D_A(ERRTYP) = 11;
14026 BRANCH(FTLTST)
14027 /*_*/
14028 }
14029 static int
COMP6(ret_t retval)14030 COMP6(ret_t retval) {
14031 ENTRY(COMP6)
14032 D_A(ERRTYP) = 33;
14033 BRANCH(FTLTST)
14034 /*_*/
14035 }
14036 static int
COMP7(ret_t retval)14037 COMP7(ret_t retval) {
14038 ENTRY(COMP7)
14039 D_A(ERRTYP) = 27;
14040 BRANCH(FTLEND)
14041 /*_*/
14042 }
14043 static int
COMP9(ret_t retval)14044 COMP9(ret_t retval) {
14045 ENTRY(COMP9)
14046 D_A(ERRTYP) = 26;
14047 D_A(ESAICL) -= DESCR;
14048 BRANCH(FTLEND)
14049 /*_*/
14050 }
14051 int
EROR(ret_t retval)14052 EROR(ret_t retval) {
14053 ENTRY(EROR)
14054 D_A(ERRTYP) = 28;
14055 D_A(OCICL) += DESCR;
14056 D(STNOCL) = D(D_A(OCBSCL) + D_A(OCICL));
14057 D_A(OCICL) += DESCR;
14058 D(LNNOCL) = D(D_A(OCBSCL) + D_A(OCICL));
14059 D_A(OCICL) += DESCR;
14060 D(FILENM) = D(D_A(OCBSCL) + D_A(OCICL));
14061 BRANCH(FTLEND)
14062 /*_*/
14063 }
14064 static int
EXEX(ret_t retval)14065 EXEX(ret_t retval) {
14066 ENTRY(EXEX)
14067 D_A(ERRTYP) = 22;
14068 BRANCH(FTLEND)
14069 /*_*/
14070 }
14071 static int
INTR1(ret_t retval)14072 INTR1(ret_t retval) {
14073 ENTRY(INTR1)
14074 D_A(ERRTYP) = 1;
14075 BRANCH(FTLTST)
14076 /*_*/
14077 }
14078 static int
INTR4(ret_t retval)14079 INTR4(ret_t retval) {
14080 ENTRY(INTR4)
14081 D_A(ERRTYP) = 24;
14082 BRANCH(FTLERR)
14083 /*_*/
14084 }
14085 static int
INTR5(ret_t retval)14086 INTR5(ret_t retval) {
14087 ENTRY(INTR5)
14088 D_A(ERRTYP) = 19;
14089 BRANCH(FTLERR)
14090 /*_*/
14091 }
14092 static int
INTR8(ret_t retval)14093 INTR8(ret_t retval) {
14094 ENTRY(INTR8)
14095 D_A(ERRTYP) = 15;
14096 BRANCH(FTLTST)
14097 /*_*/
14098 }
14099 static int
INTR27(ret_t retval)14100 INTR27(ret_t retval) {
14101 ENTRY(INTR27)
14102 D_A(ERRTYP) = 13;
14103 BRANCH(FTLTST)
14104 /*_*/
14105 }
14106 static int
INTR30(ret_t retval)14107 INTR30(ret_t retval) {
14108 ENTRY(INTR30)
14109 D_A(ERRTYP) = 10;
14110 BRANCH(FTLTST)
14111 /*_*/
14112 }
14113 static int
INTR31(ret_t retval)14114 INTR31(ret_t retval) {
14115 ENTRY(INTR31)
14116 D_A(ERRTYP) = 16;
14117 D_A(SCERCL) = 3;
14118 BRANCH(FTERST)
14119 /*_*/
14120 }
14121 static int
LENERR(ret_t retval)14122 LENERR(ret_t retval) {
14123 ENTRY(LENERR)
14124 D_A(ERRTYP) = 14;
14125 BRANCH(FTLTST)
14126 /*_*/
14127 }
14128 static int
MAIN1(ret_t retval)14129 MAIN1(ret_t retval) {
14130 ENTRY(MAIN1)
14131 D_A(ERRTYP) = 18;
14132 BRANCH(FTLEND)
14133 /*_*/
14134 }
14135 static int
NEMO(ret_t retval)14136 NEMO(ret_t retval) {
14137 ENTRY(NEMO)
14138 D_A(ERRTYP) = 8;
14139 BRANCH(FTLTST)
14140 /*_*/
14141 }
14142 static int
NONAME(ret_t retval)14143 NONAME(ret_t retval) {
14144 ENTRY(NONAME)
14145 D_A(ERRTYP) = 4;
14146 BRANCH(FTLTST)
14147 /*_*/
14148 }
14149 static int
NONARY(ret_t retval)14150 NONARY(ret_t retval) {
14151 ENTRY(NONARY)
14152 D_A(ERRTYP) = 3;
14153 BRANCH(FTLTST)
14154 /*_*/
14155 }
14156 int
OVER(ret_t retval)14157 OVER(ret_t retval) {
14158 ENTRY(OVER)
14159 D_A(ERRTYP) = 21;
14160 BRANCH(FTLEND)
14161 /*_*/
14162 }
14163 static int
PROTER(ret_t retval)14164 PROTER(ret_t retval) {
14165 ENTRY(PROTER)
14166 D_A(ERRTYP) = 6;
14167 BRANCH(FTLTST)
14168 /*_*/
14169 }
14170 static int
SIZERR(ret_t retval)14171 SIZERR(ret_t retval) {
14172 ENTRY(SIZERR)
14173 D_A(ERRTYP) = 23;
14174 BRANCH(FTLEND)
14175 /*_*/
14176 }
14177 int
UNDF(ret_t retval)14178 UNDF(ret_t retval) {
14179 ENTRY(UNDF)
14180 D_A(ERRTYP) = 5;
14181 BRANCH(FTLTST)
14182 /*_*/
14183 }
14184 static int
UNDFFE(ret_t retval)14185 UNDFFE(ret_t retval) {
14186 ENTRY(UNDFFE)
14187 D_A(ERRTYP) = 9;
14188 BRANCH(FTLTST)
14189 /*_*/
14190 }
14191 static int
UNKNKW(ret_t retval)14192 UNKNKW(ret_t retval) {
14193 ENTRY(UNKNKW)
14194 D_A(ERRTYP) = 7;
14195 BRANCH(FTLTST)
14196 /*_*/
14197 }
14198 static int
UNTERR(ret_t retval)14199 UNTERR(ret_t retval) {
14200 ENTRY(UNTERR)
14201 D_A(ERRTYP) = 12;
14202 BRANCH(FTLTST)
14203 /*_*/
14204 }
14205 static int
USRINT(ret_t retval)14206 USRINT(ret_t retval) {
14207 ENTRY(USRINT)
14208 D_A(ERRTYP) = 34;
14209 D_A(UINTCL) = 0;
14210 BRANCH(FTLTST)
14211 /*_*/
14212 }
14213 static int
CNTERR(ret_t retval)14214 CNTERR(ret_t retval) {
14215 ENTRY(CNTERR)
14216 D_A(ERRTYP) = 35;
14217 BRANCH(FTLERR)
14218 /*_*/
14219 }
14220 static int
CFTERR(ret_t retval)14221 CFTERR(ret_t retval) {
14222 ENTRY(CFTERR)
14223 D_A(ERRTYP) = 39;
14224 BRANCH(FTLEND)
14225 /*_*/
14226 }
14227 static int
SCERST(ret_t retval)14228 SCERST(ret_t retval) {
14229 ENTRY(SCERST)
14230 D_A(SCERCL) = 1;
14231 BRANCH(FTERST)
14232 /*_*/
14233 }
14234 static int
FTLERR(ret_t retval)14235 FTLERR(ret_t retval) {
14236 ENTRY(FTLERR)
14237 if (D_A(FTLLCL) <= 0)
14238 BRANCH(FTLEND)
14239 D_A(FTLLCL)--;
14240 D_A(FATLCL) = 1;
14241 BRANCH(FTLTS2)
14242 /*_*/
14243 }
14244 static int
FTLTST(ret_t retval)14245 FTLTST(ret_t retval) {
14246 ENTRY(FTLTST)
14247 D_A(FATLCL) = 0;
14248 /* FALL */
14249 BRANCH(FTLTS2)
14250 }
14251 static int
FTLTS2(ret_t retval)14252 FTLTS2(ret_t retval) {
14253 ENTRY(FTLTS2)
14254 D_A(SCERCL) = 2;
14255 /* FALL */
14256 BRANCH(FTERST)
14257 }
14258 static int
FTERST(ret_t retval)14259 FTERST(ret_t retval) {
14260 ENTRY(FTERST)
14261 if (D_A(ERRLCL) <= 0)
14262 BRANCH(FTLEND)
14263 D_A(ERRLCL)--;
14264 D_A(YCL) = D_A(ERRTYP);
14265 D_A(YCL) *= DESCR;
14266 D_F(YCL) = D_V(YCL) = 0;
14267 D(YCL) = D(D_A(MSGNO) + D_A(YCL));
14268 _SPEC(TSP) = _SPEC(D_A(YCL));
14269 SAVSTK();
14270 PUSH(TSPPTR);
14271 GENVAR(ERRTXT);
14272 if (D_A(TRAPCL) <= 0)
14273 goto L_FTERBR;
14274 if (!LOCAPT(ATPTR,TKEYL,ERRTKY))
14275 goto L_FTERBR;
14276 PUSH(SCERCL);
14277 SAVSTK();
14278 PUSH(ATPTR);
14279 TRPHND(NORET);
14280 POP(SCERCL);
14281 L_FTERBR:
14282 SAVSTK();
14283 XITHND(NORET);
14284 switch (D_A(SCERCL)) {
14285 case 1:
14286 case 2:
14287 BRANCH(FAIL)
14288 case 3:
14289 BRANCH(RTNUL3)
14290 }
14291 /* PANIC? */
14292 ;
14293 }
14294