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