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