Fix typo: occured ==> occurred
[scilab.git] / scilab / modules / core / src / c / run.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) INRIA - Serge STEER
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12 /*--------------------------------------------------------------------------
13  * Execution of a compiled macro (byte code)
14  * byte code is a sequence of tags each of them containing the data relative
15  * to a particular basic operation
16  *
17  * Code automatically translated from Fortran to C
18  *------------------------------------------------------------------ */
19
20 #include <string.h>
21 #include <stdio.h>
22 #ifdef _MSC_VER
23 #include <stdlib.h>
24 #endif
25
26 #include <time.h>
27 #include "sciquit.h"
28 #include "stack-c.h"
29 #include "run.h"
30 #include "basout.h"
31 #include "parse.h"
32 #include "localization.h"
33 #include "core_math.h"
34 #include "scilabmode.h"
35 #include "stack-def.h" /* C2F(basbrk) */
36 #include "storeCommand.h"
37 #include "do_error_number.h"
38 #include "Scierror.h"
39 #include "msgs.h"
40 #include "parserConstant.h"
41 #undef Lstk
42 #undef Infstk
43
44
45 /* Table of constant values */
46
47 static int c__1 = 1;
48 static int c__0 = 0;
49
50 #define Pt (C2F(recu).pt)
51 extern int C2F(stackp)(int *, int *);
52 extern int C2F(eqid)(int *, int *);
53 extern int C2F(bexec)(char *, int *, int *);
54 extern int C2F(print)(int *, int *, int *);
55 extern int C2F(createref1)(int *);
56 extern int C2F(command)(int *, int *);
57 extern int C2F(mkindx)(int *, int *);
58 extern int C2F(whatln)(int *, int *, int *, int *, int *, int *);
59 extern int C2F(prompt)(int *, int *);
60 extern int C2F(seteol)(void);
61 extern int C2F(name2var)(int *);
62 extern int C2F(getendian)(void);
63 extern int C2F(nextj)(int *, int *);
64 extern int C2F(isafunptr)(int *, int *, int *, int *);
65 extern int C2F(varfunptr)(int *, int *, int *);
66 extern int C2F(defmat)(void);
67 extern int C2F(clunit)(int *, char *, int *);
68 extern int C2F(istrue)(int *);
69
70 int Istrue(int n)
71 {
72
73     return C2F(istrue)(&n);
74 }
75
76
77
78 int C2F(run)(void)
79 {
80     /* Initialized data */
81     /* Fortran common data equivalence */
82     static int    *Ids  = C2F(recu).ids - nsiz - 1;
83     static int    *Rstk = C2F(recu).rstk - 1;
84     static int    *Pstk = C2F(recu).pstk - 1;
85     static int    *Lstk = C2F(vstk).lstk - 1;
86     static int    *Lin  = C2F(iop).lin - 1;
87     static int    *Lpt  = C2F(iop).lpt - 1;
88     static int  *Infstk = C2F(vstk).infstk - 1;
89     static int    *Lct = C2F(iop).lct - 1;
90
91     static double equiv_4[1];
92 #define x (equiv_4)
93 #define ix ((int *)equiv_4)
94
95     /* Local variables */
96     static int ifin, iesc, ibpt, tref, ifun;
97     static int ierr, ndel;
98     static int j, k, m, n, p, r, t;
99     static int lname, imode;
100     static int l0;
101     static int id[6], lc, kc, nc, lb, li, il, io, ip;
102     static int ok;
103     static int ir, lr, op;
104     static int mm1;
105     static int nn1;
106     static int nentry, lastindpos;
107     static int lcc, kid, nlr;
108     int i2;
109     static char tmp[80]; /*string for sending debug messages*/
110     tref = 0;
111
112     /* set debug trace mode on  */
113     if (C2F(iop).ddt == 4)
114     {
115         sprintf(tmp, " run pt:%d rstk(pt):%d", Pt, Rstk[Pt]);
116         C2F(basout)(&io, &C2F(iop).wte, tmp, (long)strlen(tmp));
117     }
118
119     l0 = 0;
120     nc = 0;
121
122     if (Ptover(0))
123     {
124         return 0;
125     }
126
127     r = Rstk[Pt];
128     ir = r / 100;
129     if (ir != 6)
130     {
131         goto L1;
132     }
133     switch ((int)(r - 600))
134     {
135         case 1:
136             goto L33;
137         case 2:
138             goto L66;
139         case 3:
140             goto L82;
141         case 4:
142             goto L92;
143         case 5:
144             goto L58;
145         case 6:
146             goto L116;
147         case 7:
148             goto L250;
149         case 8:  /*Rstk[Pt]=1101;*/
150             goto L254;
151         case 9:  /*Rstk[Pt]=1101;*/
152             goto L240;
153
154     }
155
156
157 L1: /*  Start execution of a "compiled" function  */
158     tref = clock();
159     C2F(errgst).toperr = Top;
160     k = Lpt[1] - (13 + nsiz);
161     lc = Lin[k + 7];
162
163 L10: /* Current opcode finished handle error, interruptions,...*/
164     if (Err > 0)  return 0;
165
166     if (C2F(basbrk).iflag)
167     {
168         C2F(basbrk).iflag = FALSE;
169         goto L91;
170     }
171     if (C2F(errgst).err1 != 0 )
172     {
173         if ((C2F(errgst).errpt > 0) && (Pt >= C2F(errgst).errpt) && (Rstk[C2F(errgst).errpt] == 618))
174         {
175             /* error under try catch */
176             for (p = Pt; p >= C2F(errgst).errpt; p--)
177             {
178                 if (Rstk[p] <= 502 && Rstk[p] >= 501)
179                 {
180                     k = Lpt[1] - (13 + nsiz);
181                     Lpt[1] = Lin[k + 1];
182                     Lpt[2] = Lin[k + 2];
183                     Lpt[3] = Lin[k + 3];
184                     Lpt[4] = Lin[k + 4];
185                     Lpt[6] = k;
186                     C2F(recu).macr--;
187                     if (Rstk[p - 1] == 909) Top--; /* execed function*/
188                 }
189                 /* may it will be necessary to take care of for loop variables */
190             }
191             Pt = C2F(errgst).errpt;
192             goto L271;
193         }
194         /* errcatch in exec(function,'errcatch')
195           * or catched error in an external
196           * or errcatch in execstr('foo()','errcatch') */
197         if (C2F(errgst).errcatch == 0) goto L999;
198         /* error under errcatch(....,'continue') */
199
200         /* @TODO : replace 903 909 1001 1002 by a #define ... */
201         if (Rstk[Pt - 1] == 903 || Rstk[Pt - 1] == 909 || Rstk[Pt] == 1001 || Rstk[Pt] == 1002)  return 0;
202     }
203     if (lc - l0 == nc)   /* is current opcodes block (if, for, .. structure) finished ?*/
204     {
205         /* yes */
206         r = Rstk[Pt] - 610;
207         switch (r)
208         {
209             case 1:
210                 goto L46;
211             case 2:
212                 goto L47;
213             case 3:
214                 goto L52;
215             case 4:
216                 goto L56;
217             case 5:
218                 goto L57;
219             case 6:
220                 goto L61;
221             case 8:
222                 goto L271;
223             case 9:
224                 goto L272;
225         }
226     }
227
228
229 L11:   /*  next opcode */
230     op = *istk(lc);
231     /*  label 49 retains to be able issue a compatibility error message */
232     switch ((int)op)   /* step to corresponding part*/
233     {
234         case 1:
235             goto L20;
236         case 2:
237             goto L25;
238         case 3:
239             goto L40;
240         case 4:
241             goto L42;
242         case 5:
243             goto L30;
244         case 6:
245             goto L41;
246         case 7:
247             goto L45;
248         case 8:
249             goto L49;
250         case 9:
251             goto L49;
252         case 10:
253             goto L55;
254         case 11:
255             goto L270;/* try */
256         case 12:
257             goto L90;
258         case 13:
259             goto L95;
260         case 14:
261             goto L100;
262         case 15:
263             goto L105;
264         case 16:
265             goto L110;
266         case 17:
267             goto L120;
268         case 18:
269             goto L130;
270         case 19:
271             goto L140;
272         case 20:
273             goto L150;
274         case 21:
275             goto L160;
276         case 22:
277             goto L170;
278         case 23:
279             goto L180;
280         case 24:
281             goto L190;
282         case 25:
283             goto L200;
284         case 26:
285             goto L210;
286         case 27:
287             goto L220;
288         case 28:
289             goto L97;
290         case 29:
291             goto L230;
292         case 30:
293             goto L260;
294         case 31:
295             goto L261;
296
297     }
298     if (op >= 100)
299     {
300         /* ------------- primitive call (matfn's) -------------- */
301         goto L80;
302     }
303
304     if (op == 99)
305     {
306         /* ------------- return -------------------------------- */
307         /* check if "return" occurred in a for loop */
308         p = Pt + 1;
309 L12:
310         --p;
311         if (Rstk[p] == 612)
312         {
313             /* yes, remove the for loop variable */
314             --Top;
315             goto L12;
316         }
317         else if (Rstk[p] != 501)
318         {
319             goto L12;
320         }
321         Fin = 2;
322         goto L998;
323     }
324
325     if (op <= 0)
326     {
327         /* ------------- nop ---------------------------------- */
328         lc += *istk(1 + lc);
329         goto L11;
330     }
331
332     SciError(60);
333     return 0;
334
335 L20: /* stackp, retplaced by assign */
336     /*     retained for 2.7 and earlier versions compatibility */
337     C2F(stackp)(istk(1 + lc), &c__0);
338     /*     store info if printing is required see code 22 */
339     C2F(putid)(id, istk(1 + lc));
340     kid = Fin;
341     lc += 7;
342     goto L10;
343
344 L25: /* stackg */
345     Fin = *istk(7 + lc);
346     ifin = Fin;
347     Rhs = *istk(8 + lc);
348     lname = lc + 1;
349 L26:
350     C2F(stackg)(istk(lname));
351     if (Err > 0 || C2F(errgst).err1 > 0)
352     {
353         lc += 9;
354         goto L10;
355     }
356     if (Fin != 0)  /* variable exists */
357     {
358         goto L28;
359     }
360     C2F(funs)(istk(1 + lc)); /* check if it is a function */
361     if (Err > 0 || C2F(errgst).err1 > 0)
362     {
363         lc += 9;
364         goto L10;
365     }
366     if (C2F(com).fun != -2)
367     {
368         C2F(putid)(&Ids[1 + (Pt + 1) * nsiz ], istk(1 + lc));
369         if (C2F(com).fun == 0)
370         {
371             /* the search variable is neither a regular variable nor a function in a librar */
372             /* it may be a simple variable in a lib */
373
374             C2F(stackg)(istk(lname));
375             if (Err > 0 || C2F(errgst).err1 > 0)
376             {
377                 lc += 9;
378                 goto L10;
379             }
380             if (Fin == 0)
381             {
382                 SciError(4);
383                 if (Err > 0 || C2F(errgst).err1 > 0)
384                 {
385                     lc += 9;
386                     goto L10;
387                 }
388             }
389
390         }
391         else
392         {
393             /* referenced name was function at compile time it is now a
394              * primitive. Modify the code for further use */
395             if (ifin != -4 && ifin != 0)
396             {
397                 /* function call */
398                 /* change current  opcode to nop */
399                 *istk(lc) = 0;
400                 *istk(1 + lc) = 9;
401                 lc += 9;
402                 /* change the following opcode to matfn opcode */
403                 op = C2F(com).fun * 100;
404                 *istk(lc) = op;
405                 *istk(1 + lc) = *istk(2 + lc) - 1;
406                 *istk(2 + lc) = *istk(3 + lc);
407                 *istk(3 + lc) = Fin;
408                 goto L80;
409             }
410             else
411             {
412                 /* only reference to a function */
413                 /* stackg opcode replaced by varfun opcode */
414                 *istk(lc) = 27;
415                 *istk(1 + lc) = C2F(com).fun;
416                 *istk(2 + lc) = Fin;
417                 C2F(putid)(istk(3 + lc), &Ids[1 + (Pt + 1) * nsiz]);
418                 goto L10;
419             }
420         }
421         lc += 9;
422         goto L10;
423     }
424     Fin = *istk(7 + lc);
425     goto L26;
426 L28:
427     if (Rhs == 0 && ((*istk(7 + lc) == -2) || (*istk(7 + lc) == -1)) && Fin == -1)
428     {
429         lc += 9;
430
431         if (*istk(7 + lc - 9) == -2)
432         {
433
434             /* instruction reduced to <name> with name not a function, replace */
435             /* next two op code by a single store */
436             /* skip extract op-code <5 3 1 1> */
437             if (*istk(lc) != 5 || *istk(1 + lc) != 3)
438             {
439                 strcpy(C2F(cha1).buf, _("Unexpected opcode, please report into the Scilab bug tracker."));
440                 SciError(9999);
441                 return 0;
442             }
443             lc += 4;
444         }
445         /* skip assignment op_code <29 43 ans 0> */
446         if (*istk(lc) != 29)
447         {
448             strcpy(C2F(cha1).buf, _("Unexpected opcode, please report into the Scilab bug tracker."));
449             SciError(9999);
450             return 0;
451         }
452         lc += 10;
453         /* store */
454         Rhs = 1;
455         C2F(ref2val)();
456         C2F(stackp)(istk(lname), &c__0);
457         if (Err > 0 || C2F(errgst).err1 > 0)
458         {
459             goto L10;
460         }
461         goto L10;
462     }
463     lc += 9;
464     if (Fin > 0)
465     {
466         goto L65;
467     }
468     goto L10;
469
470     /*     allops */
471 L30:
472     Fin = *istk(1 + lc);
473     Rhs = *istk(2 + lc);
474     Lhs = *istk(3 + lc);
475     lc += 4;
476     if (Fin == extrac)
477     {
478         C2F(isafunptr)(&Top, id, &ifun, &ifin);
479         if (ifun != 0)
480         {
481             --Top;
482             --Rhs;
483             C2F(com).fun = ifun;
484             Fin = ifin;
485             C2F(adjustrhs)();
486             goto L81;
487         }
488     }
489     if (Fin == extrac || Fin == insert)
490     {
491         C2F(adjustrhs)();
492     }
493     ++Pt;
494     Rstk[Pt] = 601;
495     Ids[1 + Pt * nsiz] = tref;
496     Ids[3 + Pt * nsiz] = l0;
497     Ids[4 + Pt * nsiz] = nc;
498     C2F(recu).icall = 4;
499     /*     pstk(pt) is used by allops to get the name of output variable (insertion) */
500     Pstk[Pt] = lc;
501     /*     *call* allops */
502     return 0;
503 L33:
504     tref = Ids[1 + Pt * nsiz];
505     l0 = Ids[3 + Pt *  nsiz];
506     nc = Ids[4 + Pt *  nsiz];
507     lc = Pstk[Pt];
508     --Pt;
509     goto L70;
510
511     /*     string */
512 L40:
513     n = *istk(1 + lc);
514     if (C2F(errgst).err1 <= 0)
515     {
516         ++Top;
517         if (C2F(cresmat)("run", &Top, &c__1, &c__1, &n, 3L))
518         {
519             C2F(getsimat)("run", &Top, &Top, &mm1, &nn1, &c__1, &
520                           c__1, &lr, &nlr, 3L);
521             C2F(icopy)(&n, istk(2 + lc), &c__1, istk(lr), &c__1);
522         }
523     }
524     lc = lc + n + 2;
525     goto L10;
526
527     /*     num */
528 L41:
529     if (C2F(errgst).err1 <= 0)
530     {
531         if (C2F(getendian)() == 1)
532         {
533             ix[0] = *istk(1 + lc);
534             ix[1] = *istk(2 + lc);
535         }
536         else
537         {
538             ix[1] = *istk(1 + lc);
539             ix[0] = *istk(2 + lc);
540         }
541         ++Top;
542         if (C2F(cremat)("run", &Top, &c__0, &c__1, &c__1, &lr, &lcc, 3L))
543         {
544             *stk(lr) = *x;
545         }
546     }
547     lc += 3;
548     goto L10;
549
550 L42:
551     C2F(defmat)();
552     ++lc;
553     goto L10;
554
555     /*     for */
556 L45:
557     nc = *istk(1 + lc);
558     lc += 2;
559     l0 = lc;
560     if (Ptover(1))
561     {
562         lc += nc;
563         lc = lc + nsiz + *istk(lc);
564         goto L10;
565     }
566     Rstk[Pt] = 611;
567     Ids[1 + Pt * nsiz] = l0;
568     Ids[2 + Pt * nsiz] = nc;
569     goto L10;
570
571 L46:
572     nc = *istk(lc);
573     l0 = lc + 7;
574     if  (C2F(errgst).errcatch >= 1 && C2F(errgst).err1 > 0)
575     {
576         /*an error occurred in the loop variable expression evaluation, in 'continue' mode
577           skip all the for codes*/
578         lc = l0;
579         goto L48;
580     }
581     Rstk[Pt] = 612;
582     Pstk[Pt] = 0;
583     Ids[1 + Pt * nsiz] = l0;
584     Ids[2 + Pt * nsiz] = Lct[8];
585     Ids[3 + Pt * nsiz] = Top;
586     Ids[4 + Pt * nsiz] = C2F(errgst).toperr;
587     C2F(errgst).toperr = Top;
588 L47:
589     lc = l0;
590     if (Top != Ids[3 + Pt * nsiz])
591     {
592         SciError(115);
593         goto L48;
594     }
595     C2F(nextj)(istk(1 + l0 - 7), &Pstk[Pt]);
596     if (Pstk[Pt] != 0)
597     {
598         Lct[8] = Ids[2 + Pt * nsiz];
599         if (ismenu() == 1 && C2F(basbrk).interruptible) goto L115;
600         goto L10;
601     }
602     /*     fin for */
603 L48:
604     lc += nc;
605     C2F(errgst).toperr = Ids[4 + Pt * nsiz];
606     --Pt;
607     goto L70;
608
609     /*     Very old if - while (removed) */
610 L49:
611     if (*istk(1 + lc) < 0)
612     {
613         goto L55;
614     }
615 L52:
616     strcpy(C2F(cha1).buf, _("Functions compiled with very old versions are no more handled."));
617     SciError(997);
618     return 0;
619
620     /*     "select- case"  or  "if elseif else end" */
621 L55:
622     if (Ptover(1))
623     {
624         lc += (i2 = *istk(1 + lc), abs(i2));
625         goto L10;
626     }
627     Pstk[Pt] = lc;
628     Ids[3 + Pt * nsiz] = C2F(errgst).toperr;
629
630 L551:
631     if (*istk(1 + lc) > 0)
632     {
633         /*    first expression */
634         nc = *istk(3 + lc);
635         Rstk[Pt] = 614;
636         lc += 4;
637         l0 = lc;
638         Ids[1 + Pt * nsiz] = l0;
639         Ids[2 + Pt * nsiz] = nc;
640         goto L10;
641     }
642     else
643     {
644         lc += 4;
645     }
646
647     /*     expri */
648 L56:
649     if  (C2F(errgst).errcatch >= 1 && C2F(errgst).err1 > 0 )
650     {
651         /*an error occurred in the first expression evaluation, in 'continue' mode
652           skip all the control structure codes*/
653         goto L62;
654     }
655
656     if (*istk(Pstk[Pt]) == 10)
657     {
658         /*     copy first expression */
659         i2 = Top + 1;
660         if (! C2F(vcopyobj)("run", &Top, &i2, 3L))
661         {
662             return 0;
663         }
664         ++Top;
665     }
666
667     nc = *istk(lc);
668     Rstk[Pt] = 615;
669     ++lc;
670     l0 = lc;
671     Ids[1 + Pt * nsiz] = l0;
672     Ids[2 + Pt * nsiz] = nc;
673     goto L10;
674
675     /*     instructions i */
676 L57:
677     if  (C2F(errgst).errcatch >= 1 && C2F(errgst).err1 > 0 )
678     {
679         /*an error occurred in the first expression evaluation, in 'continue' mode
680           skip all the control structure codes*/
681         goto L62;
682     }
683     if (nc == 0)
684     {
685         /* if nc=0 the instruction correspond to the else */
686         ok = TRUE;
687         if (*istk(Pstk[Pt]) == 10)
688         {
689             --Top;
690         }
691         goto L59;
692     }
693     else if (*istk(Pstk[Pt]) != 10)
694     {
695         ok = Istrue(1);
696         if (Err > 0 || C2F(errgst).err1 > 0)
697         {
698             goto L10;
699         }
700         goto L59;
701     }
702     ++Pt;
703     Fin = equal;
704     Rhs = 2;
705     Lhs = 1;
706     Rstk[Pt] = 605;
707     C2F(recu).icall = 4;
708     Pstk[Pt] = lc;
709     Ids[1 + Pt * nsiz] = tref;
710     /*     *call* allops(equal) */
711     return 0;
712
713 L58:
714     if  (C2F(errgst).errcatch >= 1 && C2F(errgst).err1 > 0 )
715     {
716         /*an error occurred in the first expression evaluation, in 'continue' mode
717           skip all the control structure codes*/
718         goto L62;
719     }
720
721     lc = Pstk[Pt];
722     tref = Ids[1 + Pt * nsiz];
723     --Pt;
724     ok = Istrue(1);
725     if (Err > 0 || C2F(errgst).err1 > 0)
726     {
727         goto L10;
728     }
729 L59:
730     nc = *istk(lc);
731     C2F(errgst).toperr = Top;
732     if (ok)
733     {
734         ++lc;
735         if (*istk(Pstk[Pt]) == 10)
736         {
737             --Top;
738         }
739         l0 = lc;
740         Ids[1 + Pt * nsiz] = l0;
741         Ids[2 + Pt * nsiz] = nc;
742         Rstk[Pt] = 616;
743         if (ismenu() == 1 && C2F(basbrk).interruptible) goto L115;
744         goto L10;
745     }
746     else
747     {
748         if (*istk(Pstk[Pt]) == 9)
749         {
750             goto L62;
751         }
752         lc = lc + nc + 1;
753         goto L56;
754     }
755
756 L61:
757     /*     fin if while select/case */
758     l0 = Pstk[Pt];
759     if (*istk(Pstk[Pt]) == 9)
760     {
761         lc = l0 + 4;
762         goto L56;
763     }
764 L62:
765     l0 = Pstk[Pt];
766     lc = l0 + (i2 = *istk(1 + l0), abs(i2));
767     C2F(errgst).toperr = Ids[3 + Pt * nsiz];
768     --Pt;
769     goto L70;
770
771     /*     macro */
772 L65:
773     i2 = *istk(2 + lc) - 1;
774     Rhs = Max(i2, 0);
775     C2F(adjustrhs)();
776     Lhs = *istk(3 + lc);
777
778     lc += 4;
779
780     if (Ptover(1))
781     {
782         goto L10;
783     }
784     Rstk[Pt] = 602;
785     Pstk[Pt] = lc;
786     /*  Ids[1 + Pt * nsiz] = C2F(dbg).wmac; *//*moved into macro.f*/
787     Ids[2 + Pt * nsiz] = tref;
788     Ids[3 + Pt * nsiz] = l0;
789     Ids[4 + Pt * nsiz] = nc;
790     C2F(recu).icall = 5;
791     C2F(com).fun = 0;
792     /*     *call* macro */
793     return 0;
794 L66:
795     lc = Pstk[Pt];
796     /*C2F(dbg).wmac = Ids[1 + Pt * nsiz];*//*moved into macro.f*/
797     tref = Ids[2 + Pt * nsiz];
798     l0 = Ids[3 + Pt * nsiz];
799     nc = Ids[4 + Pt * nsiz];
800     --Pt;
801     goto L70;
802
803 L70:
804     /* re entering run to continue macro evaluation */
805     if (ismenu() == 1 && C2F(basbrk).interruptible) goto L115;
806
807 L71:
808     /* reset proper values for l0 and nc if a control structure had been escaped*/
809     r = Rstk[Pt] - 610;
810     switch ((int)r)
811     {
812         case 1:
813             l0 = Ids[1 + Pt * nsiz];
814             nc = Ids[2 + Pt * nsiz];
815             goto L10;
816         case 2: /* back to a for */
817             j = Pstk[Pt];
818             l0 = Ids[1 + Pt * nsiz];
819             nc = *istk(l0 - 7);
820             goto L10;
821         case 3: /* back to an if or a while */
822             li = Ids[1 + Pt * nsiz];
823             kc = Ids[2 + Pt * nsiz];
824             nc = *istk(2 + li);
825             l0 = li + 5;
826             if (kc == 0)
827             {
828                 goto L10;
829             }
830             l0 += nc;
831             nc = *istk(3 + li);
832             if (kc == 1)
833             {
834                 goto L10;
835             }
836             l0 += nc;
837             nc = *istk(4 + li);
838             goto L10;
839         case 4:
840         case 5:
841         case 6:
842             /*    back to a select case   */
843             l0 = Ids[1 + Pt * nsiz];
844             nc = Ids[2 + Pt * nsiz];
845             goto L10;
846         case 8: /*back to a try*/
847             l0 = Ids[1 + Pt * nsiz];
848             nc = *istk(l0 - 2);
849             goto L10;
850         case 9:  /*back to a catch*/
851             l0 = Ids[1 + Pt * nsiz];
852             nc = *istk(l0 - 1);
853             l0 = l0 + *istk(l0 - 2);
854             goto L10;
855         default :
856             goto L10;
857     }
858
859 L80:
860     C2F(com).fun = op / 100;
861     Rhs = *istk(1 + lc);
862     C2F(adjustrhs)();
863     Lhs = *istk(2 + lc);
864     Fin = *istk(3 + lc);
865     lc += 4;
866
867 L81:
868     ++Pt;
869     Rstk[Pt] = 603;
870     Pstk[Pt] = lc;
871     C2F(recu).icall = 9;
872     Ids[2 + Pt * nsiz] = 0;
873     Ids[3 + Pt * nsiz] = tref;
874     Ids[4 + Pt * nsiz] = l0;
875     Ids[5 + Pt * nsiz] = nc;
876     /*     *call* matfns */
877     return 0;
878 L82:
879     /*     warning if builtin is "resume" control is passed to macro and not here */
880     lc = Pstk[Pt];
881     tref = Ids[3 + Pt * nsiz];
882     l0 =   Ids[4 + Pt * nsiz];
883     nc =   Ids[5 + Pt * nsiz];
884     --Pt;
885     goto L70;
886
887     /*     pause */
888 L90:
889     ++lc;
890 L91:
891     if (Ptover(1))
892     {
893         goto L10;
894     }
895     Pstk[Pt] = C2F(iop).rio;
896     C2F(iop).rio = C2F(iop).rte;
897     Fin = 2;
898     if (Lct[4] <= -10)
899     {
900         Fin = -1;
901         Lct[4] = -Lct[4] - 11;
902     }
903     Ids[1 + Pt * nsiz] = lc;
904     Ids[2 + Pt * nsiz] = Top;
905     Ids[3 + Pt * nsiz] = tref;
906     Ids[4 + Pt * nsiz] = l0;
907     Ids[5 + Pt * nsiz] = nc;
908     Rstk[Pt] = 604;
909     C2F(recu).icall = 5;
910     /*     *call* macro */
911     return 0;
912 L92:
913     lc =   Ids[1 + Pt * nsiz];
914     Top =  Ids[2 + Pt * nsiz];
915     tref = Ids[3 + Pt * nsiz];
916     l0 =   Ids[4 + Pt * nsiz];
917     nc =   Ids[5 + Pt * nsiz];
918     C2F(iop).rio = Pstk[Pt];
919     --Pt;
920     goto L70;
921
922     /*     break */
923 L95:
924     p = Pt + 1;
925 L96:
926     --p;
927     if (p == 0)
928     {
929         ++lc;
930         goto L10;
931     }
932     if (Rstk[p] == 612)
933     {
934         /*     break in a for */
935         l0 = Ids[1 + p * nsiz];
936         lc = l0 + *istk(1 + l0 - 8);
937         Pt = p - 1;
938         --Top;
939         goto L70;
940     }
941     else if (Rstk[p] == 616 && *istk(1 + Pstk[p] - 1) == 9)
942     {
943         /*     break in a while */
944         l0 = Pstk[p];
945         lc = l0 + (i2 = *istk(1 + l0), abs(i2));
946         Pt = p - 1;
947         goto L70;
948     }
949     else if (Rstk[p] == 501 || Rstk[p] == 502 ||
950              Rstk[p] == 503)
951     {
952         /*     going outside a function an exec (break ignored) */
953         ++lc;
954         goto L10;
955     }
956     else
957     {
958         goto L96;
959     }
960     /*     continue */
961 L97:
962     p = Pt + 1;
963 L98:
964     --p;
965     if (p == 0)
966     {
967         ++lc;
968         goto L10;
969     }
970     if (Rstk[p] == 612)
971     {
972         /*     continue in a  for */
973         l0 = Ids[1 + p * nsiz];
974         /* nc is required for the end of loop */
975         lc = l0 - 7;
976         nc = *istk(lc);
977         Pt = p;
978         goto L47;
979     }
980     else if (Rstk[p] == 616 && *istk(1 + Pstk[p] - 1) == 9)
981     {
982         /*     continue in a while */
983         l0 = Pstk[p];
984         lc = l0;
985         nc = *istk(lc);
986         Pt = p;
987         goto L551;
988     }
989     else
990     {
991         goto L98;
992     }
993     /*     abort */
994 L100:
995     ++Pt;
996 L101:
997     --Pt;
998     if (Pt == 0)
999     {
1000         goto L102;
1001     }
1002     if (Rstk[Pt] / 100 == 5)
1003     {
1004         k = Lpt[1] - (13 + nsiz);
1005         Lpt[1] = Lin[1 + k];
1006         Lpt[2] = Lin[2 + k];
1007         Lpt[3] = Lin[3 + k];
1008         Lpt[4] = Lin[4 + k];
1009         Lct[4] = Lin[6 + k ];
1010         Lpt[6] = k;
1011         if (Rstk[Pt] <= 502)
1012         {
1013             if (Pt > 1)
1014             {
1015                 if (Rstk[Pt - 1] != 903 && Rstk[Pt - 1] != 909 && Rstk[Pt - 1] != 706)
1016                     Bot = Lin[5 + k];
1017             }
1018             else
1019                 Bot = Lin[5 + k];
1020         }
1021         else if (Rstk[Pt] == 503)
1022         {
1023             if (C2F(iop).rio == C2F(iop).rte)
1024             {
1025                 /* abort in a pause mode */
1026                 C2F(iop).rio = Pstk[Pt - 1];
1027                 C2F(recu).paus--;
1028                 Bot = Lin[5 + k];
1029             }
1030             else
1031             {
1032                 int mode[3];
1033                 int lunit = -C2F(iop).rio;
1034                 /*  abort in an exec*/
1035                 mode[0] = 0;
1036                 C2F(clunit)(&lunit, C2F(cha1).buf, mode);
1037                 C2F(iop).rio = Pstk[Pt - 1];
1038             }
1039         }
1040     }
1041     goto L101;
1042 L102:
1043     C2F(recu).icall = 10;
1044     Top = 0;
1045     C2F(com).comp[0] = 0;
1046     if (C2F(recu).niv > 1)
1047     {
1048         Err = 9999999;
1049     }
1050     return 0;
1051
1052 L105:
1053     /*     eol */
1054     /*     la gestion de la recuperation des erreurs devrait plutot se trouver */
1055     /*     a la fin de l'instruction (mais il n'y a pas actuellement d'indicateur */
1056     /*     de fin d'instruction dans les macros */
1057     if (C2F(errgst).err1 != 0)
1058     {
1059         if (C2F(errgst).err2 == 0)
1060         {
1061             C2F(errgst).err2 = C2F(errgst).err1;
1062         }
1063         if (C2F(errgst).errcatch > 0)
1064         {
1065             /* running under errcatch(num,....) */
1066             if (Rstk[Pt] != 614 && Rstk[Pt] != 615 && Rstk[Pt] != 605) C2F(errgst).err1 = 0;
1067             if (Pt < C2F(errgst).errpt)
1068             {
1069                 C2F(errgst).errcatch = 0;
1070             }
1071         }
1072         imode = (i2 = C2F(errgst).errct / 100000, abs(i2));
1073         if (imode - (imode / 8 << 3) == 2)
1074         {
1075             C2F(basbrk).iflag = TRUE;
1076         }
1077     }
1078
1079     /*     gestion des points d'arrets dynamiques */
1080     if (C2F(dbg).nmacs != 0)   /* there are breakpoints set */
1081     {
1082         int kfin = C2F(dbg).wmac - 1; /*the stack index of the current function*/
1083         /*  first test if the function has breakpoints   */
1084         int kmac;
1085         for (kmac = 0; kmac < C2F(dbg).nmacs; kmac++) /* loop on table of functions containing breakpoints */
1086         {
1087             /* does the name of the current funtion fit the registered name*/
1088             if (C2F(eqid)(&(C2F(vstk).idstk[kfin * nsiz]), &(C2F(dbg).macnms[kmac * nsiz])))  /* yes */
1089             {
1090                 /* test if there is a registered breakpoint at the current line*/
1091                 i2 = C2F(dbg).lgptrs[kmac + 1] - 1;
1092                 for (ibpt = C2F(dbg).lgptrs[kmac]; ibpt <= i2; ++ibpt)
1093                 {
1094                     if (Lct[8] == C2F(dbg).bptlg[ibpt - 1])   /* yes */
1095                     {
1096                         /* display a message */
1097                         C2F(cvname)(&C2F(dbg).macnms[kmac * nsiz], tmp, &c__1, 24L);
1098                         sprintf(C2F(cha1).buf, "%s %5d", tmp, Lct[8]);
1099                         Msgs(32, 0);
1100                         /* raise the interruption flag */
1101                         C2F(basbrk).iflag = TRUE;
1102                         goto L107;
1103                     }
1104                 }
1105                 break;
1106             }
1107         }
1108     }
1109 L107:
1110
1111     if (Lct[4] / 2 % 2 == 1)
1112     {
1113         i2 = Lct[4] / 4;
1114         C2F(prompt)(&i2, &iesc);
1115     }
1116     ++Lct[8];
1117     ++lc;
1118     if (ismenu() == 1 && C2F(basbrk).interruptible) goto L115;
1119
1120     goto L10;
1121
1122     /* set line number.
1123      *
1124      *   Au debut de chaque expression liee a un then et a la fin de
1125      *   chaque clause, le compilateur (compcl) inscrit la valeur de la
1126      *   ligne. ceci permet de mettre rapidement a jour le compteur de
1127      *   ligne sans avoir a analyser la suite des codes operatoires */
1128
1129 L110:
1130     Lct[8] = *istk(1 + lc);
1131     lc += 2;
1132     goto L10;
1133
1134     /* gestion des evements asynchrones "interpretes" */
1135 L115:
1136     C2F(basbrk).interruptible = C2F(getmen)(C2F(cha1).buf, &lb, &nentry) == 0;
1137     C2F(bexec)(C2F(cha1).buf, &lb, &ierr);
1138     if (ierr != 0)
1139     {
1140         goto L10;
1141     }
1142     ++Pt;
1143     Ids[1 + Pt * nsiz] = lc;
1144     Ids[2 + Pt * nsiz] = l0;
1145     Ids[3 + Pt * nsiz] = nc;
1146     Ids[4 + Pt * nsiz] = tref;
1147     Rstk[Pt] = 606;
1148     C2F(recu).icall = 5;
1149     /*     *call* macro */
1150     return 0;
1151 L116:
1152     C2F(basbrk).interruptible = TRUE;
1153     lc = Ids[1 + Pt * nsiz];
1154     l0 = Ids[2 + Pt * nsiz];
1155     nc = Ids[3 + Pt * nsiz];
1156     tref = Ids[4 + Pt * nsiz];
1157     --Top;
1158     --Pt;
1159     goto L71;
1160     /*  r = Rstk[Pt] - 610;
1161     switch ((int)r) {
1162     case 1:  goto L74;
1163     case 2:  goto L71;
1164     case 3:  goto L72;
1165     case 4:  goto L73;
1166     case 5:  goto L73;
1167     case 6:  goto L73;
1168     }
1169     goto L10;*/
1170
1171     /*     quit */
1172
1173 L120:
1174     if (C2F(recu).paus != 0)
1175     {
1176         /*   quit in a pause: decrease recursion level up to the pause one (Rstk[Pt] == 503) */
1177         Pt = Pt + 1;
1178 L121:
1179         Pt = Pt - 1;
1180         /*  suppress loop variables if any */
1181         if (Rstk[Pt] == 802 || Rstk[Pt] == 612 ||
1182                 (Rstk[Pt] == 805 && Ids[1 + Pt * nsiz] == iselect) ||
1183                 (Rstk[Pt] == 616 && Pstk[Pt] == 10)) Top--;
1184         if (Rstk[Pt] != 503) goto L121;
1185         /* recall macro to terminate the pause level */
1186         C2F(com).fun = 0;
1187         return 0;
1188     }
1189     else
1190         C2F(com).fun = 99;
1191     return 0;
1192
1193     /*     named variable */
1194
1195 L130:
1196     Infstk[Top] = 1;
1197     C2F(putid)(&C2F(vstk).idstk[Top * nsiz - nsiz], istk(1 + lc));
1198     lc += 7;
1199     goto L10;
1200
1201     /*     form recursive extraction list */
1202
1203 L140:
1204     m = *istk(2 + lc);
1205     if (Rstk[Pt] == 617)
1206     {
1207         /* runtime arg count (list extraction) */
1208         m += Pstk[Pt];
1209         Pstk[Pt] = 0;
1210     }
1211     C2F(mkindx)(istk(1 + lc), &m);
1212     lc += 3;
1213     goto L10;
1214
1215     /*     exit */
1216
1217 L150:
1218     ++lc;
1219     if (C2F(recu).niv > 0)
1220     {
1221         sciquit();
1222         exit(0); /* stop */
1223     }
1224     C2F(com).fun = 99;
1225     goto L10;
1226
1227     /*     begrhs - for run time rhs value computation */
1228     /*              syntax like: l=list(...); a(l(:)) */
1229
1230 L160:
1231     ++lc;
1232     ++Pt;
1233     Rstk[Pt] = 617;
1234     Pstk[Pt] = 0;
1235     goto L10;
1236
1237     /*     printmode */
1238
1239 L170:
1240     /*     print stored variable */
1241     if (Lct[4] >= 0 && *istk(1 + lc) != semi && kid != 0)
1242     {
1243         C2F(print)(id, &kid, &C2F(iop).wte);
1244     }
1245     lc += 2;
1246     goto L10;
1247 L180:
1248     /*     name2var */
1249     C2F(name2var)(istk(1 + lc));
1250     lc += 7;
1251     goto L10;
1252
1253 L190:
1254     /*     deffnull */
1255     ++lc;
1256     ++Top;
1257     C2F(objvide)(" ", &Top, 1L);
1258     goto L10;
1259
1260 L200:
1261     /*     profile */
1262     ++*istk(1 + lc);
1263     t = clock();
1264     *istk(2 + lc) = *istk(2 + lc) + t - tref;
1265     tref = t;
1266     lc += 3;
1267     goto L10;
1268
1269 L210:
1270     /*     character string vector */
1271     if (C2F(errgst).err1 <= 0)
1272     {
1273         n = *istk(1 + lc) * *istk(2 + lc);
1274         nc = *istk(lc + 4 + n) - 1;
1275         ++Top;
1276         il = Lstk[Top] + Lstk[Top] - 1;
1277         i2 = il + 5 + n + nc;
1278         Err = i2 / 2 + 1 - Lstk[Bot];
1279         if (Err > 0 || C2F(errgst).err1 > 0)
1280         {
1281             SciError(17);
1282             lc = lc + 5 + n + nc;
1283             goto L10;
1284         }
1285         i2 = n + 5 + nc;
1286         C2F(icopy)(&i2, istk(lc), &c__1, istk(il), &c__1);
1287         *istk(il) = 10;
1288         i2 = il + 5 + n + nc;
1289         Lstk[1 + Top] = i2 / 2 + 1;
1290     }
1291     lc = lc + 5 + n + nc;
1292     goto L10;
1293 L220:
1294     /*     varfun */
1295     C2F(varfunptr)(istk(3 + lc), istk(1 + lc), istk(2 + lc));
1296     lc += 9;
1297     goto L10;
1298 L230:
1299     /*     affectation */
1300     Lhs = *istk(1 + lc);
1301     ip = *istk(2 + lc);
1302     li = lc + 3;
1303     lc = li + Lhs * 7;
1304     /*     following code is an adaptation of corresponding code in parse.f */
1305     ndel = 0;
1306 L231:
1307     Rhs = *istk(6 + li);
1308     lastindpos = Top - Lhs - ndel;
1309     if (C2F(errgst).err1 != 0)
1310     {
1311         goto L253;
1312     }
1313     if (Rhs == 0)
1314     {
1315         /* goto simple affectation */
1316         C2F(stackp)(istk(li), &c__0);
1317         if (Err > 0 || C2F(errgst).err1 > 0)
1318         {
1319             goto L10;
1320         }
1321         if (C2F(errgst).err1 > 0)
1322         {
1323             goto L253;
1324         }
1325         /* fin points on the newly saved variable */
1326         if (!(Lct[4] >= 0 && ip != semi && Fin != 0)) goto L253;
1327         ifin = Fin;
1328 L232:
1329         C2F(print)(istk(li), &ifin, &C2F(iop).wte);
1330         if (Rstk[Pt] != 1101) goto L253;
1331         ++Pt;
1332         Pstk[Pt] = li;
1333         Ids[1 + Pt * nsiz] = ndel;
1334         Ids[2 + Pt * nsiz] = lastindpos;
1335         Ids[3 + Pt * nsiz] = tref;
1336         Ids[4 + Pt * nsiz] = l0;
1337         Ids[5 + Pt * nsiz] = Lhs;
1338         Ids[6 + Pt * nsiz] = nc;
1339         Rstk[Pt] = 609;
1340         return 0;
1341 L240:
1342         li = Pstk[Pt];
1343         ip = *istk(li - 1);
1344         ndel =       Ids[1 + Pt * nsiz];
1345         lastindpos = Ids[2 + Pt * nsiz];
1346         tref =       Ids[3 + Pt * nsiz];
1347         l0 =         Ids[4 + Pt * nsiz];
1348         Lhs =        Ids[5 + Pt * nsiz];
1349         nc =         Ids[6 + Pt * nsiz];
1350         --Pt;
1351         /*goto L253;*/
1352         goto L232;
1353
1354     }
1355
1356     /*     take rhs (number of indices) computed at runtime into account */
1357     C2F(adjustrhs)();
1358     /*     partial variable affectation (insertion) */
1359     if (lastindpos + 1 != Top)
1360     {
1361         /* create reference variables to get index1,...,indexn, value at */
1362         /* the top of the stack in this order */
1363         /* create reference variables pointing to the  indices */
1364         for (ir = 1; ir <= Rhs; ++ir)
1365         {
1366             i2 = lastindpos - Rhs + ir;
1367             C2F(createref1)(&i2);
1368         }
1369         /* create reference variable pointing to the value */
1370         i2 = Top - Rhs;
1371         C2F(createref1)(&i2);
1372         /* remind to remove the original indices */
1373         ndel += Rhs;
1374     }
1375     lastindpos -= Rhs;
1376     /*     put a reference to the lhs variable */
1377     Fin = -3;
1378     C2F(stackg)(istk(li));
1379     if (Err > 0 || C2F(errgst).err1 > 0)
1380     {
1381         goto L10;
1382     }
1383     /*     perform insertion operation */
1384     /*     index1,...,indexn, value ==> updated lhs value (or pointer to) */
1385     if (Eptover(1))
1386     {
1387         return 0;
1388     }
1389     /*     pstk(pt) is used by allops to get the name of output variable */
1390     Pstk[Pt] = li;
1391     Ids[1 + Pt * nsiz] = ndel;
1392     Ids[2 + Pt * nsiz] = lastindpos;
1393     Ids[3 + Pt * nsiz] = tref;
1394     Ids[4 + Pt * nsiz] = l0;
1395     Ids[5 + Pt * nsiz] = Lhs;
1396     Ids[6 + Pt * nsiz] = nc;
1397     Rstk[Pt] = 607;
1398     Rhs += 2;
1399     Lhs = 1;
1400     C2F(recu).icall = 4;
1401     Fin = insert;
1402     /*     *call* allops(insert) */
1403     return 0;
1404 L250:
1405     li = Pstk[Pt];
1406     ip = *istk(li - 1);
1407     ndel =       Ids[1 + Pt * nsiz];
1408     lastindpos = Ids[2 + Pt * nsiz];
1409     tref =       Ids[3 + Pt * nsiz];
1410     l0 =         Ids[4 + Pt * nsiz];
1411     Lhs =        Ids[5 + Pt * nsiz];
1412     nc =         Ids[6 + Pt * nsiz];
1413     --Pt;
1414     /*     store the updated value */
1415     C2F(stackp)(istk(li), &c__0);
1416
1417     if (Err > 0 || C2F(errgst).err1 > 0)
1418     {
1419         goto L10;
1420     }
1421     if (C2F(errgst).err1 > 0)
1422     {
1423         goto L253;
1424     }
1425     /*     fin points on the newly saved variable */
1426     if (!(Lct[4] >= 0 && ip != semi && Fin != 0))  goto L252;
1427     ifin = Fin;
1428 L251:
1429     C2F(print)(istk(li), &ifin, &C2F(iop).wte);
1430     if (Rstk[Pt] != 1101) goto L252;
1431     ++Pt;
1432     Pstk[Pt] = li;
1433     Ids[1 + Pt * nsiz] = ndel;
1434     Ids[2 + Pt * nsiz] = lastindpos;
1435     Ids[3 + Pt * nsiz] = tref;
1436     Ids[4 + Pt * nsiz] = l0;
1437     Ids[5 + Pt * nsiz] = Lhs;
1438     Ids[6 + Pt * nsiz] = nc;
1439     Rstk[Pt] = 608;
1440     return 0;
1441 L254:
1442     li = Pstk[Pt];
1443     ip = *istk(li - 1);
1444     ndel =       Ids[1 + Pt * nsiz];
1445     lastindpos = Ids[2 + Pt * nsiz];
1446     tref =       Ids[3 + Pt * nsiz];
1447     l0 =         Ids[4 + Pt * nsiz];
1448     Lhs =        Ids[5 + Pt * nsiz];
1449     nc =         Ids[6 + Pt * nsiz];
1450     --Pt;
1451     goto L251;
1452
1453 L252:
1454     /*     remove variable containing the value if required */
1455     if (lastindpos != Top)   --Top;
1456
1457 L253:
1458     li += 7;
1459     --Lhs;
1460     if (Lhs > 0)
1461     {
1462         goto L231;
1463     }
1464     Top -= ndel;
1465     lc = li;
1466     goto L10;
1467
1468     /*     logical expression shortcircuit */
1469 L260:
1470     if (*istk(1 + lc) == 1)
1471     {
1472         /* | case */
1473         if (C2F(gettype)(&Top) != sci_ints && Istrue(0))
1474         {
1475             lc += *istk(2 + lc);
1476         }
1477     }
1478     else
1479     {
1480         /* & case */
1481         if (C2F(gettype)(&Top) != sci_ints && ! Istrue(0))
1482         {
1483             lc += *istk(2 + lc);
1484         }
1485     }
1486     lc += 3;
1487     goto L10;
1488     /*     comment */
1489 L261:
1490
1491     lc += 2 + *istk(1 + lc);
1492     goto L10;
1493
1494     /*     try catch */
1495 L270:
1496     nc = *istk(1 + lc);
1497     lc += 3;
1498     l0 = lc;
1499     if (Ptover(1))
1500     {
1501         lc += nc;
1502         lc += nsiz + *istk(lc);
1503         goto L10;
1504     }
1505     Rstk[Pt] = 618;
1506     Ids[1 + Pt * nsiz] = l0;
1507     /* preserve current error modes */
1508     Ids[2 + Pt * nsiz] = C2F(errgst).errct;
1509     Ids[3 + Pt * nsiz] = C2F(errgst).err2;
1510     Ids[4 + Pt * nsiz] = C2F(errgst).err1;
1511     Ids[5 + Pt * nsiz] = C2F(errgst).errpt;
1512     Ids[6 + Pt * nsiz] = (Lct[4] + 100) + 10000 * C2F(com).sym;
1513     /* set error recovery mode without message*/
1514     C2F(errgst).errct = -(900000 + 1);
1515     C2F(errgst).errpt = Pt;
1516     Pstk[Pt] = Top;
1517     goto L10;
1518 L271:
1519     /* try op-codes finished*/
1520     l0 = Ids[1 + Pt * nsiz];
1521     /*check if an error occurred*/
1522     ok = Max(C2F(errgst).err2, C2F(errgst).err1) <= 0;
1523     /* restore preserved error modes */
1524     C2F(errgst).errct = Ids[2 + Pt * nsiz];
1525     C2F(errgst).err2  = Ids[3 + Pt * nsiz];
1526     C2F(errgst).err1  = Ids[4 + Pt * nsiz];
1527     C2F(errgst).errpt = Ids[5 + Pt * nsiz];
1528     C2F(com).sym      = Ids[6 + Pt * nsiz] / 10000;
1529     Lct[4]            = Ids[6 + Pt * nsiz] - 10000 * C2F(com).sym - 100;
1530     if (ok)
1531     {
1532         /* no error occurred in the try part*/
1533         nc = *istk(l0 - 1);
1534         lc += nc; /*skip catch  instructions*/
1535         /* finish try catch context and continue*/
1536         --Pt;
1537         goto L70;
1538     }
1539     /*an error occurred in the try part*/
1540     lc = l0 + *istk(l0 - 2); /*skip remaining try instruction*/
1541     nc = *istk(l0 - 1);
1542     /*execute catch instructions (next op-codes)*/
1543     l0 = lc;
1544     Rstk[Pt] = 619;
1545     goto L10;
1546 L272:
1547     /* catch op-codes finished*/
1548     /* close "try catch" context and continue*/
1549     --Pt;
1550     goto L70;
1551
1552
1553 L998:
1554     Lhs = 0;
1555 L999:
1556     /*remove context down to current running macro */
1557     if (Rstk[Pt] != 501)
1558     {
1559         --Pt;
1560         goto L999;
1561     }
1562     C2F(com).fun = 0;
1563     return 0;
1564 #undef ix
1565 #undef x
1566 }
1567
1568
1569
1570 int C2F(adjustrhs)(void)
1571 {
1572     /* to adjust rhs in the case it is only fixed at run time example
1573     *  l=list(....); foo(a,l(2:3)).  the parser supposes that the rhs
1574     *  for foo is 2. at run time it is really 3. See begrhs.
1575     * Copyright INRIA
1576     * Author S. Steer
1577     */
1578     static int    *Ids  = C2F(recu).ids - nsiz - 1;
1579     static int    *Rstk = C2F(recu).rstk - 1;
1580     static int    *Pstk = C2F(recu).pstk - 1;
1581
1582     if (Rstk[Pt] == 617)
1583     {
1584         Rhs += Pstk[Pt];
1585         --Pt;
1586     }
1587     else if (Rstk[Pt] == 501)
1588     {
1589         /* retained for 2.4.1 compatiblity */
1590         Rhs += Ids[5 + Pt * nsiz];
1591         Ids[5 + Pt * nsiz] = 0;
1592     }
1593     return 0;
1594 }