* Bug #12774 fixed - Fix various typos.
[scilab.git] / scilab / modules / core / src / c / parse.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 1984-2010 - 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  * Scilab parsing function
14  *
15  * Code automatically translated from Fortran to C
16  *------------------------------------------------------------------ */
17 #include <string.h>
18 #include <stdio.h>
19 #include "stack-c.h"
20 /*--------------------------------------------------------------------------*/
21 #include "parse.h"
22 #include "basout.h"
23 #include "core_math.h"
24 #include "cvstr.h"
25 #include "msgs.h"
26 #include "scilabmode.h"
27 #include "stack-def.h" /* C2F(basbrk) */
28 #include "Scierror.h"
29 #include "do_error_number.h"
30 #include "prompt.h"
31 #include "storeCommand.h"
32 #include "msgs.h"
33 #include "eqid.h"
34 #include "parserConstant.h"
35 #include "ExternalObjectsFunction.h"
36 /*--------------------------------------------------------------------------*/
37 #undef Lstk
38 #undef Infstk
39 /*--------------------------------------------------------------------------*/
40
41 /* Table of constant values */
42
43 static int c__1 = 1;
44 static int c__0 = 0;
45
46 #define Pt (C2F(recu).pt)
47 /*--------------------------------------------------------------------------*/
48 extern int C2F(clause)(void);
49 extern int C2F(fact)(void);
50 extern int C2F(expr)(void);
51 extern int C2F(terme)(void);
52 extern int C2F(stackp)(int *, int *);
53 extern int C2F(macro)(void);
54 extern int C2F(getsym)(void);
55
56 extern int C2F(bexec)(char *, int *, int *);
57
58 extern int C2F(findequal)(int *);
59 extern int C2F(print)(int *, int *, int *);
60 extern int C2F(createref1)(int *);
61 extern int C2F(command)(int *, int *);
62 extern int C2F(getlin)(int *, int *);
63 extern int C2F(mrknmd)(void);
64 extern int C2F(mkindx)(int *, int *);
65 extern int C2F(whatln)(int *, int *, int *, int *, int *, int *);
66 extern int C2F(prompt)(int *, int *);
67 extern int C2F(seteol)(void);
68 extern int C2F(run)(void);
69 extern int C2F(name2var)(int *);
70 extern int C2F(compil)(int *, int *, int *, int *, int *);
71 extern int C2F(ptover)(int *, int *); /* see src/fortran/ptover.f */
72 extern int C2F(eptover)(int *, int *); /* see src/fortran/eptover.f */
73 /*--------------------------------------------------------------------------*/
74 void handle_onprompt(int *n);
75 /*--------------------------------------------------------------------------*/
76 static int Compil(int code, int * val1, int val2, int val3, int val4)
77 {
78     return C2F(compil)(&code, val1, &val2, &val3, &val4);
79 }
80 /*--------------------------------------------------------------------------*/
81 int Eptover(int n)
82 {
83     int c;
84     return C2F(eptover)(&n, (c = psiz, &c));
85 }
86 /*--------------------------------------------------------------------------*/
87 int Ptover(int n)
88 {
89     int c;
90     return C2F(ptover)(&n, (c = psiz, &c));
91 }
92 /*--------------------------------------------------------------------------*/
93 int C2F(parse)(void)
94 {
95     /* Initialized data */
96     static int ans[6] = { 672929546, 673720360, 673720360, 673720360,
97                           673720360, 673720360
98                         };
99     static int varargout[6] = { 169544223, 504893467, 673720349, 673720360,
100                                 673720360, 673720360
101                               };
102     /* static int catch[6] = {203229708,673720337,673720360,673720360, 673720360,673720360 };*/
103
104     static int *Ids     = C2F(recu).ids - nsiz - 1;
105     static int *Rstk    = C2F(recu).rstk - 1;
106     static int *Pstk    = C2F(recu).pstk - 1;
107     static int *Lstk    = C2F(vstk).lstk - 1;
108     static int *Lin     = C2F(iop).lin - 1;
109     static int *Lct     = C2F(iop).lct - 1;
110     static int *Lpt     = C2F(iop).lpt - 1;
111
112     /* System generated locals */
113     int i__2, i__3;
114
115     /* Local variables */
116     static int iesc, ndel, ifin, ibpt;
117     static int iret;
118     static int topk;
119     static int lpts, next;
120     static int ierr;
121     static int k, p, r;
122     static int imode, schar;
123     static int itime, where_;
124     static int found;
125     static int excnt;
126     static int l1;
127     static int id[6], lb, io, ir;
128     static int dotsep;
129     static int icount;
130     static int nentry, lastindpos;
131     static int job, nlc, pts;
132     static char tmp[80];
133
134     /* Used to manage space between prompts */
135     static int returnFromCallbackExec = FALSE;
136
137     /* Retrieve the current Scilab Mode */
138     /*  scilabMode sciMode=getScilabMode();*/
139
140     itime = 10000;
141 L1:
142     r = 0;
143     if (Pt > 0)
144     {
145         r = Rstk[Pt];
146     }
147     if (C2F(iop).ddt == 4)
148     {
149         sprintf(tmp, " TOP    pt:%d rstk(pt):%d icall: %d niv: %d err:%d",
150                 Pt, Rstk[Pt], C2F(recu).icall, C2F(recu).niv, Err);
151         C2F(basout)(&io, &C2F(iop).wte, tmp, (long)strlen(tmp));
152     }
153
154     if (C2F(recu).icall == 5)
155     {
156         goto L88;
157     }
158     if (Pt > 0)
159     {
160         goto L86;
161     }
162     if (Err > 0)
163     {
164         goto L98;
165     }
166     /*     initialization */
167     /* ------------------- */
168 L5:
169     C2F(com).sym = eol;
170     job = 0;
171     if (C2F(iop).rio == -1)
172     {
173         job = -1;
174     }
175     Top = 0;
176     Fin = 0;
177     C2F(recu).macr = 0;
178     C2F(recu).paus = 0;
179     C2F(recu).icall = 0;
180     C2F(iop).rio = C2F(iop).rte;
181     Lct[3] = 0;
182     Lct[4] = 2;
183     Lpt[1] = 1;
184     if (job == -1)
185     {
186         goto L13;
187     }
188
189 L10:
190     if (C2F(com).sym != eol)
191     {
192         goto L15;
193     }
194     if (C2F(com).comp[0] == 0)
195     {
196         goto L12;
197     }
198     if (Lin[Lpt[4] + 1] == eol)
199     {
200         goto L88;
201     }
202
203     /*     get a new line */
204     /* ------------------- */
205 L12:
206     if (Lct[4] <= -10)
207     {
208         Lct[4] = -Lct[4] - 11;
209     }
210     else
211     {
212         if (Lct[4] / 2 % 2 == 1)
213         {
214             i__2 = Lct[4] / 4;
215             /* Manage space between two prompts */
216             if (!returnFromCallbackExec)
217             {
218                 /* Space added only if Scilab does not return from a callback execution */
219                 C2F(prompt)(&i__2, &iesc);
220             }
221             else
222             {
223                 /* Reset the flag indicating a callback has just been executed */
224                 returnFromCallbackExec = FALSE;
225             }
226             if (iesc == 1)
227             {
228                 /* interrupted line acquisition (mode=7) */
229                 iret = 3;
230                 goto L96;
231             }
232             Lct[1] = 0;
233             if (C2F(recu).paus == 0 &&
234                     C2F(iop).rio == C2F(iop).rte &&
235                     C2F(recu).macr ==  0)
236             {
237                 if (Pt != 0)
238                 {
239                     Msgs(30, 0);
240                     Pt = 0;
241                 }
242                 if (Top != 0)
243                 {
244                     Msgs(31, 0);
245                     Top = 0;
246                 }
247             }
248         }
249     }
250 L13:
251     //C2F(tksynchro)(&C2F(recu).paus);
252
253     C2F(getlin)(&job, &c__1);
254
255     ClearTemporaryPrompt();
256     //C2F(tksynchro)(&c_n1);
257
258
259     if (Fin == -3)
260     {
261         /*     interrupted line acquisition */
262         iret = 2;
263         goto L96;
264     }
265     else if (Fin == -1)
266     {
267         /*     Continuation line handling when scilab is called as a routine */
268         C2F(com).fun = 99;
269         return 0;
270     }
271     job = 0;
272     Err = 0;
273
274     if (Pt != 0)
275     {
276         goto L15;
277     }
278 L14:
279     handle_onprompt(&where_);
280     if (Err > 0)
281     {
282         goto L98;
283     }
284     switch ((int)where_)
285     {
286         case 1:
287             goto L85;
288         case 2:
289             goto L88;
290     }
291     /*     Beginning of a new statement, clause expression or command */
292     /* ------------------------------------------------------------ */
293 L15:
294     if (ismenu() == 1 && C2F(basbrk).interruptible)
295     {
296         iret = 1;
297         goto L96;
298     }
299
300     r = 0;
301     if (Pt > 0)
302     {
303         r = Rstk[Pt];
304     }
305     if (C2F(iop).ddt == 4)
306     {
307         sprintf(tmp, " parse  pt:%d rstk(pt):%d top: %d niv: %d err:%d",
308                 Pt, r, Top, C2F(recu).niv, Err);
309         C2F(basout)(&io, &C2F(iop).wte, tmp, (long)strlen(tmp));
310     }
311
312     excnt = 0;
313     if (! C2F(basbrk).iflag || C2F(com).comp[0] != 0 )
314     {
315         goto L18;
316     }
317     /*     Handling of pauses */
318 L16:
319     if (Eptover(1))
320     {
321         goto L98;
322     }
323     Pstk[Pt] = C2F(iop).rio;
324     Ids[2 + Pt * nsiz] = Top;
325     C2F(iop).rio = C2F(iop).rte;
326     Rstk[Pt] = 701;
327     C2F(basbrk).iflag = FALSE;
328     Fin = 2;
329     if (Lct[4] <= -10)
330     {
331         Fin = -1;
332         Lct[4] = -Lct[4] - 11;
333     }
334     /*     *call* macro */
335     goto L88;
336     /*     pauses termination */
337 L17:
338     C2F(iop).rio = Pstk[Pt];
339     Top = Ids[2 + Pt * nsiz];
340     --Pt;
341     goto L15;
342 L18:
343     Lhs = 1;
344     excnt = 0;
345     C2F(putid)(id, ans);
346     /*     preserve current character position */
347     lpts = Lpt[4] - 1;
348     pts = Pt;
349
350     C2F(getsym)();
351     if (C2F(com).sym == right || C2F(com).sym == rparen || C2F(com).sym == less ||
352             C2F(com).sym == great)
353     {
354         /* Incorrect assignment. */
355         SciError(1);
356         goto L98;
357     }
358     else if (C2F(com).sym == semi || C2F(com).sym == comma || C2F(com).sym == eol)
359     {
360         goto L77;
361     }
362     else if (C2F(com).sym == cmt)
363     {
364         C2F(parsecomment)();
365         goto L77;
366     }
367     else if (C2F(com).sym == name)
368     {
369         lpts = Lpt[3] - 1;
370         /* try to avoid the command call whenever it is possible */
371         if (C2F(com).char1 == equal)
372         {
373             goto L25;
374         }
375         /*         if (char1 .eq. lparen) then */
376         /*           one can get this case with "if ( ) then" */
377         /*         endif */
378         if (Lpt[4] >= 2)
379         {
380             if (Lin[Lpt[4] - 2] == blank)
381             {
382                 goto L20;
383             }
384         }
385         if (C2F(com).char1 == dot)
386         {
387             /* name.x */
388             schar = C2F(com).char1;
389             goto L30;
390         }
391         goto L20;
392     }
393     else if (C2F(com).sym == left)
394     {
395         /* is there an explicit affectation */
396         lpts = Lpt[3] - 1;
397         Lpt[4] = lpts;
398         Lpt[3] = lpts;
399         C2F(com).char1 = blank;
400         C2F(findequal)(&found);
401         if (Err > 0)
402         {
403             goto L98;
404         }
405         if (found)
406         {
407             /* multiple lhs */
408             goto L40;
409         }
410         else
411         {
412             /* no ==> implicit lhs */
413             goto L50;
414         }
415     }
416     else
417     {
418         /* not lhs defined */
419         /* set ans for lhs */
420         if (Eptover(1))
421         {
422             goto L98;
423         }
424         C2F(putid)(&Ids[1 + Pt * nsiz], ans);
425         Lhs = 1;
426         Pstk[Pt] = 0;
427         /* go to rhs analysis */
428         goto L60;
429     }
430
431     /*     lhs begins with name */
432     /* ------------------------- */
433     /*     check if it is a simple command like clear,... */
434 L20:
435     C2F(command)(C2F(com).syn, &c__0);
436     if (Err > 0)
437     {
438         goto L98;
439     }
440     if (Fin == 0)
441     {
442         goto L21;
443     }
444     if (C2F(com).fun == 99)
445     {
446         return 0;
447     }
448     if (C2F(com).fun != 0)
449     {
450         goto L93;
451     }
452     if (Fin < 0)
453     {
454         goto L80;
455     }
456     if (Fin == 2)
457     {
458         goto L88;
459     }
460     if (Fin == 3)
461     {
462         goto L16;
463     }
464     if (Fin == 4)
465     {
466         goto L5;
467     }
468     if (Fin > 0)
469     {
470         goto L77;
471     }
472     /*     name is not a command */
473 L21:
474     Rhs = 0;
475     Fin = -5;
476     /* IL y a p avec fin=-5 (on ne trouve pas les macros parce que l'on ne */
477     /* veut pas que les macros sans arg soient vues comme des commandes */
478     /* mais pourquoi pas il suffirait de dire que pour visualiser une macro */
479     /* il faut faire disp() */
480     C2F(com).fun = 0;
481     C2F(funs)(C2F(com).syn);
482     if (Fin > 0)
483     {
484         /*        name is a builtin name */
485         if (C2F(com).char1 == equal)
486         {
487             /*           fun=expr is not allowed */
488             C2F(putid)(&Ids[1 + (Pt + 1) * nsiz], C2F(com).syn);
489             /* Bad call to primitive */
490             SciError(25);
491             goto L98;
492         }
493         /*        skip lhs analysis */
494         if (Eptover(1))
495         {
496             goto L98;
497         }
498         C2F(putid)(&Ids[1 + Pt * nsiz], id);
499         Lhs = 1;
500         Pstk[Pt] = 0;
501         /* go to rhs analysis */
502         goto L60;
503     }
504
505     /*     peek one character ahead */
506     if (C2F(com).char1 == semi || C2F(com).char1 == comma || C2F(com).char1 == eol)
507     {
508         C2F(putid)(id, C2F(com).syn);
509     }
510     if (C2F(com).char1 == lparen)
511     {
512         schar = C2F(com).char1;
513         goto L30;
514     }
515     /*     instruction is just "name", skip lhs analysis */
516     /*     record name as lhs */
517     if (Eptover(1))
518     {
519         goto L98;
520     }
521     C2F(putid)(&Ids[1 + Pt * nsiz], id);
522     Lhs = 1;
523     Pstk[Pt] = 0;
524     /*     go to rhs analysis */
525     goto L60;
526
527     /*     name = expr  or name == expr syntax */
528     /* ---------------------------------------- */
529 L25:
530     C2F(putid)(id, C2F(com).syn);
531     lpts = Lpt[2];
532     C2F(getsym)();
533     if (C2F(com).char1 == equal)
534     {
535         /* name == expr syntax ==> implicit lhs */
536         goto L50;
537     }
538     else
539     {
540         /* lhs found */
541         /* record it */
542         if (Eptover(1))
543         {
544             goto L98;
545         }
546         C2F(putid)(&Ids[1 + Pt * nsiz], id);
547         Lhs = 1;
548         Pstk[Pt] = 0;
549         C2F(getsym)();
550         /* go to rhs analysis */
551         goto L60;
552     }
553
554     /*     lhs is name(...) or name.x... */
555     /* ----------------------------------- */
556 L30:
557     Lpt[5] = Lpt[4];
558     C2F(putid)(id, C2F(com).syn);
559
560     /*     looking for equal to check if it is really an lhs */
561     C2F(findequal)(&found);
562     if (Err > 0)
563     {
564         goto L98;
565     }
566     if (! found)
567     {
568         goto L50;
569     }
570     /*     It is really a lhs (insertion syntax) */
571 L32:
572     Lpt[4] = Lpt[5];
573     C2F(com).char1 = schar;
574
575     /* 35     call parseindexlist(excnt) */
576     /*     if(err.gt.0) goto 98 */
577     if (Compil(21, &c__0, 0, 0, 0))
578     {
579         if (Err > 0)
580         {
581             return 0;
582         }
583     }
584     /*     begin the index lists */
585     icount = 0;
586     C2F(getsym)();
587
588 L33:
589     /*     begin a new index list (.,..) or .name */
590     ++icount;
591
592     dotsep = C2F(com).sym == dot;
593     C2F(getsym)();
594     if (dotsep)
595     {
596         /* --> new index list is .name */
597         if (C2F(com).sym != name)
598         {
599             /* Invalid index.*/
600             SciError(21);
601             if (Err > 0)
602             {
603                 return 0;
604             }
605         }
606
607         if (C2F(com).comp[0] != 0)
608         {
609             if (Compil(23, C2F(com).syn, 0, 0, 0))
610             {
611                 if (Err > 0)
612                 {
613                     return 0;
614                 }
615             }
616         }
617         else
618         {
619             C2F(name2var)(C2F(com).syn);
620         }
621         C2F(getsym)();
622         /*         icount=icount+1 */
623         if (C2F(com).sym == dot)
624         {
625             goto L33;
626         }
627         dotsep = FALSE;
628         excnt = 1;
629         goto L36;
630     }
631     /*     --> new index list is (.,..) */
632 L34:
633     /*     add a new index in index list (i,...) */
634     ++excnt;
635     if (Eptover(1))
636     {
637         goto L98;
638     }
639     C2F(putid)(&Ids[1 + Pt * nsiz], id);
640     Pstk[Pt] = excnt + icount * 1000;
641     Rstk[Pt] = 702;
642     /*     *call* expr */
643     goto L81;
644 L35:
645     C2F(putid)(id, &Ids[1 + Pt * nsiz]);
646     icount = Pstk[Pt] / 1000;
647     excnt = Pstk[Pt] - icount * 1000;
648     --Pt;
649
650     if (C2F(com).sym == comma)
651     {
652         /* current syntax is (i,j,..) */
653         C2F(getsym)();
654         goto L34;
655     }
656
657     if (C2F(com).sym == rparen)
658     {
659         /* end of the current index list */
660         C2F(getsym)();
661     }
662     else
663     {
664         /* Waiting for right parenthesis */
665         SciError(3);
666         if (Err > 0)
667         {
668             goto L98;
669         }
670     }
671
672 L36:
673     if (C2F(com).sym == lparen || C2F(com).sym == dot)
674     {
675         /* begining of a new index list */
676         /* first memorize the previous one */
677         if (excnt > 1)
678         {
679             /* previously analysed syntax is (i,j,..)( */
680             if (C2F(com).comp[0] == 0)
681             {
682                 /* form  list with individual indexes i,j,.. */
683                 C2F(mkindx)(&c__0, &excnt);
684                 if (Err > 0)
685                 {
686                     return 0;
687                 }
688             }
689             else
690             {
691                 if (Compil(19, &c__0, excnt, 0, 0))
692                 {
693                     if (Err > 0)
694                     {
695                         return 0;
696                     }
697                 }
698             }
699             excnt = 1;
700         }
701         /* open a new index list */
702         excnt = 0;
703         /*         icount=icount+1 */
704         goto L33;
705     }
706     /*     end of all the index lists */
707     if (icount > 1)
708     {
709         /* form  list with individual indexes */
710         if (C2F(com).comp[0] == 0)
711         {
712             C2F(mkindx)(&icount, &excnt);
713             if (Err > 0)
714             {
715                 return 0;
716             }
717         }
718         else
719         {
720             if (Compil(19, &icount, excnt, 0, 0))
721             {
722                 if (Err > 0)
723                 {
724                     return 0;
725                 }
726             }
727         }
728         excnt = 1;
729     }
730     /*     end of code for recursive index */
731     if (Rstk[Pt] == 711)
732     {
733         goto L42;
734     }
735
736     if (C2F(com).sym == equal)
737     {
738         /* name(...) = expr syntax */
739         /* record name as lhs */
740         if (Eptover(1))
741         {
742             goto L98;
743         }
744         C2F(putid)(&Ids[1 + Pt * nsiz], id);
745         Pstk[Pt] = excnt;
746         Lhs = 1;
747         C2F(getsym)();
748         /* go to rhs analysis */
749         goto L60;
750     }
751     else
752     {
753         /* this should never happen. this case has been detected above */
754         /* when lookin for equal sign */
755         /* name(...) syntax ==> really an rhs */
756         if (Eptover(1))
757         {
758             goto L98;
759         }
760         C2F(putid)(&Ids[1 + Pt * nsiz], ans);
761         Lhs = 1;
762         Pstk[Pt] = 0;
763         goto L60;
764     }
765
766     /*     multiple lhs [a,...]= or [a(..),..] */
767     /* ---------------------------------------- */
768 L40:
769     Lpt[4] = lpts;
770     Lpt[3] = lpts;
771     C2F(com).char1 = blank;
772     Lhs = 0;
773     C2F(getsym)();
774     /*     start lhs arguments list */
775     C2F(getsym)();
776 L41:
777     /*     begin analysis of a new lhs argument */
778     if (C2F(com).sym != name)
779     {
780         /* Instruction left hand side: waiting for a name */
781         SciError(274);
782         goto L98;
783     }
784     if (C2F(eqid)(C2F(com).syn, varargout))
785     {
786         /* varargout keyword cannot be used here */
787         SciError(275);
788         goto L98;
789     }
790     C2F(putid)(id, C2F(com).syn);
791     excnt = 0;
792     next = Lin[Lpt[4] - 2];
793     if (next == blank || C2F(com).char1 == comma || C2F(com).char1 == right)
794     {
795         /* argument followed by a blank, a comma or a ] ==> it is a simple name */
796         C2F(getsym)();
797         goto L44;
798     }
799     else if (C2F(com).char1 != lparen && C2F(com).char1 != dot)
800     {
801         /* invalid lhs */
802         SciError(273);
803         goto L98;
804     }
805     /*     lhs argument is name(..) or name.xx */
806     if (Eptover(1))
807     {
808         goto L98;
809     }
810     Rstk[Pt] = 711;
811     Lpt[5] = Lpt[4];
812     schar = C2F(com).char1;
813     goto L32;
814     /*     *parse* index */
815 L42:
816     --Pt;
817     goto L44;
818 L44:
819     /*     record current lhs arg */
820     if (Eptover(1))
821     {
822         goto L98;
823     }
824     C2F(putid)(&Ids[1 + Pt * nsiz], id);
825     ++Lhs;
826     Pstk[Pt] = excnt;
827     Rstk[Pt] = 0;
828     /*     end analysis of a current lhs arg */
829     if (C2F(com).sym == right)
830     {
831         goto L46;
832     }
833     if (C2F(com).sym == comma)
834     {
835         C2F(getsym)();
836     }
837     /*     loop on lhs args */
838     goto L41;
839
840 L46:
841     C2F(getsym)();
842     if (C2F(com).sym == equal && C2F(com).char1 != equal)
843     {
844         /*        really found a lhs go to  the rhs analysis part */
845         C2F(getsym)();
846         goto L60;
847     }
848     /*     lhs revealed to be an rhs */
849     /* ------------------------------------- */
850 L50:
851     /*     no equal symbol */
852     goto L51;
853 L51:
854     /*     lhs is in fact an  rhs */
855     /*     1 - reinititialise the parser at the instruction beginning */
856     Pt = pts;
857     Lpt[4] = lpts;
858     Lpt[3] = lpts;
859     C2F(com).char1 = blank;
860     /* L52: */
861     C2F(getsym)();
862     /*      if(sym.eq.comma.or.sym.eq.semi) goto 52 */
863     /*     2 - make "ans" the lhs */
864     if (Eptover(1))
865     {
866         goto L98;
867     }
868     C2F(putid)(&Ids[1 + Pt * nsiz], ans);
869     Pstk[Pt] = 0;
870     Lhs = 1;
871     /*     3 - go to the rhs analysis part */
872     goto L60;
873
874     /*     lhs finished, start rhs */
875     /* ---------------------------- */
876 L60:
877     Rstk[Pt] = 703;
878     /*     *call* expr */
879     goto L81;
880 L65:
881     if (Rstk[Pt - Lhs] == 313)
882     {
883         /*     store  new variable as "named" at the top of the stack */
884         if (C2F(com).sym == rparen || C2F(com).sym == comma)
885         {
886             C2F(mrknmd)();
887             if (Err > 0)
888             {
889                 goto L98;
890             }
891             goto L83;
892         }
893         else
894         {
895             /* Waiting for end of command. */
896             SciError(40);
897             goto L98;
898         }
899     }
900     if (C2F(com).sym == semi || C2F(com).sym == comma || C2F(com).sym == eol || C2F(com).sym == cmt)
901     {
902         goto L70;
903     }
904     if (Rstk[Pt - Lhs] == 808)  /* syntax error while in try */
905     {
906         /* set back the standard error handling ++++*/
907         Pt = Pt - Lhs;
908         C2F(errgst).errct = Ids[2 + Pt * nsiz];
909         C2F(errgst).errpt = Ids[5 + Pt * nsiz];
910         /* forgot the catch error */
911         C2F(errgst).err1 = Ids[3 + Pt * nsiz];
912         C2F(errgst).err2 = Ids[4 + Pt * nsiz];
913         C2F(com).comp[0] = 0;
914         Lpt[2] = Lpt[3] + 1;
915         /* Missing operator, comma, or semicolon. */
916         SciError(276);
917         Pt = Pt - 1;
918         goto L98;
919     }
920     else
921     {
922         Lpt[2] = Lpt[3] + 1;
923         /* Missing operator, comma, or semicolon. */
924         SciError(276);
925         goto L98;
926     }
927
928     /*     store results */
929     /* ------------------- */
930 L70:
931     Lhs = Max(Lhs, 1);
932     if (Compil(29, &(Lhs), C2F(com).sym, 0, 0))
933     {
934         if (Err > 0)
935         {
936             return 0;
937         }
938         Pt -= Lhs;
939         Lhs = 0;
940         goto L77;
941     }
942     ndel = 0;
943 L71:
944     Rhs = Pstk[Pt];
945     lastindpos = Top - Lhs - ndel;
946     if (C2F(errgst).err1 != 0)
947     {
948         goto L76;
949     }
950     if (Rhs == 0)
951     {
952         /* goto simple affectation */
953         C2F(stackp)(&Ids[1 + Pt * nsiz], &c__0);
954         if (Err > 0)
955         {
956             goto L98;
957         }
958         if (C2F(errgst).err1 > 0)
959         {
960             if (C2F(errgst).err1 != 13 || Rstk[Pt] != 502)
961             {
962                 --Pt;
963             }
964             --Lhs;
965             goto L98;
966         }
967         /* topk points on the newly saved variable */
968         topk = Fin;
969         /* go to print */
970         goto L73;
971     }
972     /*     partial variable affectation (insertion) */
973     if (lastindpos + 1 != Top)
974     {
975         /* create reference variables to get index1,...,indexn, value at */
976         /* the top of the stack in this order */
977         /* create reference variables pointing to the  indices */
978         i__2 = Rhs;
979         for (ir = 1; ir <= i__2; ++ir)
980         {
981             i__3 = lastindpos - Rhs + ir;
982             C2F(createref1)(&i__3);
983         }
984         /* create reference variable pointing to the value */
985         i__2 = Top - Rhs;
986         C2F(createref1)(&i__2);
987         /* remind to remove the original indices */
988         ndel += Rhs;
989     }
990     lastindpos -= Rhs;
991     /*     put a reference to the lhs variable */
992     Fin = -3;
993     C2F(stackg)(&Ids[1 + Pt * nsiz]);
994     if (Err > 0)
995     {
996         goto L98;
997     }
998     /*     perform insertion operation */
999     /*     index1,...,indexn, value ==> updated lhs value (or pointer to) */
1000     if (Eptover(1))
1001     {
1002         goto L98;
1003     }
1004     Pstk[Pt] = Lhs;
1005     C2F(putid)(&Ids[1 + Pt * nsiz], &Ids[1 + (Pt - 1) * nsiz]);
1006     Ids[1 + (Pt - 1) * nsiz] = ndel;
1007     Ids[2 + (Pt - 1) * nsiz] = lastindpos;
1008     Rstk[Pt] = 704;
1009     Rhs += 2;
1010     Lhs = 1;
1011     Fin = insert;
1012     /*     *call* allops(insert) */
1013     goto L91;
1014 L72:
1015     Lhs = Pstk[Pt];
1016     ndel = Ids[1 + (Pt - 1) * nsiz];
1017     lastindpos = Ids[2 + (Pt - 1) * nsiz];
1018     C2F(putid)(&Ids[1 + (Pt - 1) * nsiz], &Ids[1 + Pt * nsiz]);
1019     --Pt;
1020     /*     store the updated value */
1021     C2F(stackp)(&Ids[1 + Pt * nsiz], &c__0);
1022     if (Err > 0)
1023     {
1024         goto L98;
1025     }
1026     if (C2F(errgst).err1 > 0)
1027     {
1028         --Pt;
1029         --Lhs;
1030         goto L98;
1031     }
1032     /*     topk points on the newly saved variable */
1033     topk = Fin;
1034     /*     remove variable containing the value if required */
1035     if (lastindpos != Top)
1036     {
1037         --Top;
1038     }
1039 L73:
1040     /*     print if required */
1041     /* ---------------------- */
1042     if (Lct[4] < 0 || Fin == 0)
1043     {
1044         goto L76;
1045     }
1046     if (! ((C2F(com).sym != semi && Lct[3] == 0) || (C2F(com).sym == semi &&
1047             Lct[3] == 1)))
1048     {
1049         goto L76;
1050     }
1051 L74:
1052     C2F(print)(&Ids[1 + Pt * nsiz], &topk, &C2F(iop).wte);
1053     if (Err > 0)
1054     {
1055         goto L98;
1056     }
1057     if (topk == 0)
1058     {
1059         goto L76;
1060     }
1061     /*     overloaded display, call a macro */
1062     if (Eptover(1))
1063     {
1064         goto L98;
1065     }
1066     Rstk[Pt] = 708;
1067     Pstk[Pt] = C2F(com).sym;
1068     Ids[1 + Pt * nsiz] = C2F(com).sym;
1069     Ids[2 + Pt * nsiz] = ndel;
1070     Ids[3 + Pt * nsiz] = Lhs;
1071     if (C2F(com).fun == 0)
1072     {
1073         goto L88;
1074     }
1075     goto L85;
1076 L75:
1077     C2F(com).sym = Pstk[Pt];
1078     ndel = Ids[2 + Pt * nsiz];
1079     Lhs =  Ids[3 + Pt * nsiz];
1080     --Pt;
1081     goto L74;
1082
1083 L76:
1084     --Pt;
1085     --Lhs;
1086     if (Lhs > 0)
1087     {
1088         goto L71;
1089     }
1090     Top -= ndel;
1091
1092     /*     finish statement */
1093     /* --------------------- */
1094 L77:
1095     Fin = 0;
1096     p = 0;
1097     r = 0;
1098     if (Pt > 0)
1099     {
1100         p = Pstk[Pt];
1101     }
1102     if (Pt > 0)
1103     {
1104         r = Rstk[Pt];
1105     }
1106     if (C2F(iop).ddt == 4)
1107     {
1108         sprintf(tmp, " finish  pt:%d rstk(pt):%d  pstk(pt):%d lpt(1): %d niv: %d macr:%d, paus:%d",
1109                 Pt, r, p, Lpt[1], C2F(recu).niv, C2F(recu).macr, C2F(recu).paus);
1110         C2F(basout)(&io, &C2F(iop).wte, tmp, (long)strlen(tmp));
1111     }
1112
1113     ExternalObjects_goDown();
1114
1115     if (C2F(errgst).err1 != 0)
1116     {
1117         /* a catched error has occurred */
1118         if (r == 808)
1119         {
1120             /* in try instructions */
1121             goto L80;
1122         }
1123         else if (Ids[1 + (Pt - 1) * nsiz] != 0)
1124         {
1125             /* execution is explicitly required to be stopped */
1126             if (r == 502 && Rstk[Pt - 1] == 903)
1127             {
1128                 /* in an execstr(...,'errcatch') instruction */
1129                 goto L88;
1130             }
1131             else if (r == 502 && Rstk[Pt - 1] == 909)
1132             {
1133                 /* in an exec(function,'errcatch') instruction */
1134                 goto L88;
1135             }
1136             else if (r == 503 && Rstk[Pt - 1] == 902)
1137             {
1138                 /* in an exec(file,'errcatch') instruction */
1139                 goto L88;
1140             }
1141         }
1142         if (C2F(errgst).err2 == 0)
1143         {
1144             C2F(errgst).err2 = C2F(errgst).err1;
1145         }
1146         if (C2F(errgst).errcatch > 0)
1147         {
1148             /* running under errcatch(num,....) */
1149             C2F(errgst).err1 = 0;
1150             if (Pt < C2F(errgst).errpt)
1151             {
1152                 C2F(errgst).errcatch = 0;
1153             }
1154         }
1155
1156         imode = (i__2 = C2F(errgst).errct / 100000, abs(i__2));
1157         if (imode - (imode / 8 << 3) == 2)
1158         {
1159             C2F(basbrk).iflag = TRUE;
1160             goto L16;
1161         }
1162     }
1163     C2F(errgst).toperr = Top;
1164     /*     fin instruction */
1165     if (C2F(com).sym != eol)
1166     {
1167         if (C2F(com).sym == cmt)
1168         {
1169             C2F(parsecomment)();
1170         }
1171         else
1172         {
1173             goto L15;
1174         }
1175     }
1176
1177     /*     gestion des points d'arrets dynamiques */
1178     if (C2F(dbg).nmacs != 0)   /* there are breakpoints set */
1179     {
1180         int kfin = C2F(dbg).wmac - 1; /*the stack index of the current function*/
1181         /*  first test if the function has breakpoints   */
1182         int kmac;
1183         int curline;
1184         for (kmac = 0; kmac < C2F(dbg).nmacs; kmac++) /* loop on table of functions containing breakpoints */
1185         {
1186             /* does the name of the current function fit the registered name*/
1187             if (C2F(eqid)(&(C2F(vstk).idstk[kfin * nsiz]), &(C2F(dbg).macnms[kmac * nsiz])))  /* yes */
1188             {
1189                 /* test if there is a registered breakpoint at the current line*/
1190                 i__2 = Lpt[2] - 1;
1191                 C2F(whatln)(&Lpt[1], &i__2, &Lpt[6], &nlc, &l1, &ifin);
1192                 i__2 = C2F(dbg).lgptrs[kmac + 1] - 1;
1193                 curline = Lct[8] - nlc - 1;
1194                 for (ibpt = C2F(dbg).lgptrs[kmac]; ibpt <= i__2; ++ibpt)
1195                 {
1196                     //sciprint("la Lct[8]-nlc =%d, bptlg=%d\n",Lct[8] - nlc,C2F(dbg).bptlg[ibpt - 1]);
1197                     if (curline == C2F(dbg).bptlg[ibpt - 1])   /* yes */
1198                     {
1199                         /* display a message */
1200                         C2F(cvname)(&C2F(dbg).macnms[kmac * nsiz], tmp, &c__1, nlgh);
1201                         sprintf(C2F(cha1).buf, "%s %5d", tmp, curline);
1202                         Msgs(32, 0);
1203                         /* raise the interruption flag */
1204                         C2F(basbrk).iflag = TRUE;
1205                         goto L79;
1206                     }
1207                 }
1208                 break;
1209             }
1210         }
1211     }
1212 L79:
1213
1214     if (C2F(com).comp[0] != 0)
1215     {
1216         C2F(seteol)();
1217     }
1218     /*     EOL */
1219     if (r / 100 != 8)
1220     {
1221         goto L10;
1222     }
1223     /*     end of an instruction or a clause */
1224     if (C2F(com).comp[0] != 0)
1225     {
1226         k = Lpt[6];
1227         if (Lin[k - 1] == eol && Lin[k] == eol)
1228         {
1229             /* end or else is missing... */
1230             SciError(47);
1231             goto L98;
1232         }
1233     }
1234     if (Lpt[4] == Lpt[6])
1235     {
1236         /*         call getlin(1,0) */
1237         goto L13;
1238     }
1239     else
1240     {
1241         ++Lpt[4];
1242         C2F(getsym)();
1243     }
1244     goto L15;
1245
1246     /*     simulate recursion */
1247     /* ----------------------- */
1248 L80:
1249     C2F(recu).icall = 0;
1250     C2F(clause)();
1251     if (Err > 0)
1252     {
1253         goto L98;
1254     }
1255     switch ((int)C2F(recu).icall)
1256     {
1257         case 1:
1258             goto L81;
1259         case 2:
1260             goto L82;
1261         case 3:
1262             goto L83;
1263         case 4:
1264             goto L91;
1265         case 5:
1266             goto L88;
1267         case 6:
1268             goto L90;
1269         case 7:
1270             goto L15;
1271         case 8:
1272             goto L80;
1273         case 9:
1274             goto L85;
1275     }
1276     if (Pt <= 0)
1277     {
1278         goto L15;
1279     }
1280     r = Rstk[Pt] / 100;
1281     switch ((int)r)
1282     {
1283         case 1:
1284             goto L81;
1285         case 2:
1286             goto L82;
1287         case 3:
1288             goto L83;
1289         case 4:
1290             goto L91;
1291         case 5:
1292             goto L88;
1293         case 6:
1294             goto L90;
1295         case 7:
1296             goto L92;
1297         case 8:
1298             goto L80;
1299         case 9:
1300             goto L85;
1301     }
1302     goto L99;
1303
1304 L81:
1305     C2F(recu).icall = 0;
1306     C2F(expr)();
1307     if (Err > 0)
1308     {
1309         goto L98;
1310     }
1311     switch ((int)C2F(recu).icall)
1312     {
1313         case 1:
1314             goto L81;
1315         case 2:
1316             goto L82;
1317         case 3:
1318             goto L83;
1319         case 4:
1320             goto L91;
1321         case 5:
1322             goto L88;
1323         case 6:
1324             goto L90;
1325         case 7:
1326             goto L15;
1327         case 8:
1328             goto L80;
1329         case 9:
1330             goto L85;
1331     }
1332     r = Rstk[Pt] / 100;
1333     switch ((int)r)
1334     {
1335         case 1:
1336             goto L81;
1337         case 2:
1338             goto L82;
1339         case 3:
1340             goto L83;
1341         case 4:
1342             goto L91;
1343         case 5:
1344             goto L88;
1345         case 6:
1346             goto L90;
1347         case 7:
1348             goto L92;
1349         case 8:
1350             goto L80;
1351         case 9:
1352             goto L85;
1353     }
1354     goto L99;
1355
1356 L82:
1357     C2F(recu).icall = 0;
1358     C2F(terme)();
1359     if (Err > 0)
1360     {
1361         goto L98;
1362     }
1363     switch ((int)C2F(recu).icall)
1364     {
1365         case 1:
1366             goto L81;
1367         case 2:
1368             goto L82;
1369         case 3:
1370             goto L83;
1371         case 4:
1372             goto L91;
1373         case 5:
1374             goto L88;
1375         case 6:
1376             goto L90;
1377         case 7:
1378             goto L15;
1379         case 8:
1380             goto L80;
1381         case 9:
1382             goto L85;
1383     }
1384     r = Rstk[Pt] / 100;
1385     switch ((int)r)
1386     {
1387         case 1:
1388             goto L81;
1389         case 2:
1390             goto L82;
1391         case 3:
1392             goto L83;
1393         case 4:
1394             goto L91;
1395         case 5:
1396             goto L88;
1397         case 6:
1398             goto L90;
1399         case 7:
1400             goto L92;
1401         case 8:
1402             goto L80;
1403         case 9:
1404             goto L85;
1405     }
1406     goto L99;
1407
1408 L83:
1409     C2F(recu).icall = 0;
1410     C2F(fact)();
1411     if (Err > 0)
1412     {
1413         goto L98;
1414     }
1415     switch ((int)C2F(recu).icall)
1416     {
1417         case 1:
1418             goto L81;
1419         case 2:
1420             goto L82;
1421         case 3:
1422             goto L83;
1423         case 4:
1424             goto L91;
1425         case 5:
1426             goto L88;
1427         case 6:
1428             goto L90;
1429         case 7:
1430             goto L15;
1431         case 8:
1432             goto L80;
1433         case 9:
1434             goto L85;
1435     }
1436     r = Rstk[Pt] / 100;
1437     switch ((int)r)
1438     {
1439         case 1:
1440             goto L81;
1441         case 2:
1442             goto L82;
1443         case 3:
1444             goto L83;
1445         case 4:
1446             goto L91;
1447         case 5:
1448             goto L88;
1449         case 6:
1450             goto L90;
1451         case 7:
1452             goto L92;
1453         case 8:
1454             goto L80;
1455         case 9:
1456             goto L85;
1457     }
1458     goto L99;
1459
1460 L85:
1461     C2F(recu).icall = 0;
1462     if (C2F(com).fun == C2F(recu).krec)
1463     {
1464         if (C2F(com).fun > 0)
1465         {
1466             /* Recursion problems. Sorry */
1467             SciError(22);
1468             goto L98;
1469         }
1470     }
1471     if (C2F(errgst).err1 != 0)
1472     {
1473         if (Rstk[Pt] / 100 == 9)
1474         {
1475             if (Rstk[Pt] >= 901 && Rstk[Pt] <= 909)
1476             {
1477                 /*              *call* matfns */
1478                 return 0;
1479             }
1480             else
1481             {
1482                 --Pt;
1483                 goto L86;
1484             }
1485         }
1486         else
1487         {
1488             goto L86;
1489         }
1490     }
1491     /*     compilation matfns: <100*fun rhs lhs fin> */
1492     if (Compil( C2F(com).fun * 100, &(Rhs), Lhs, Fin, 0))
1493     {
1494         if (Err > 0)
1495         {
1496             goto L98;
1497         }
1498         goto L86;
1499     }
1500     else
1501     {
1502         /*     *call* matfns */
1503         return 0;
1504     }
1505 L86:
1506     if (Err > 0)
1507     {
1508         goto L98;
1509     }
1510     switch ((int)C2F(recu).icall)
1511     {
1512         case 1:
1513             goto L81;
1514         case 2:
1515             goto L82;
1516         case 3:
1517             goto L83;
1518         case 4:
1519             goto L91;
1520         case 5:
1521             goto L88;
1522         case 6:
1523             goto L90;
1524         case 7:
1525             goto L15;
1526         case 8:
1527             goto L80;
1528         case 9:
1529             goto L85;
1530     }
1531     r = Rstk[Pt] / 100;
1532     switch ((int)r)
1533     {
1534         case 1:
1535             goto L81;
1536         case 2:
1537             goto L82;
1538         case 3:
1539             goto L83;
1540         case 4:
1541             goto L91;
1542         case 5:
1543             goto L88;
1544         case 6:
1545             goto L90;
1546         case 7:
1547             goto L92;
1548         case 8:
1549             goto L80;
1550         case 9:
1551             goto L85;
1552     }
1553     goto L98;
1554
1555 L88:
1556     C2F(recu).icall = 0;
1557     C2F(macro)();
1558     if (Err > 0)
1559     {
1560         goto L98;
1561     }
1562     switch ((int)C2F(recu).icall)
1563     {
1564         case 1:
1565             goto L81;
1566         case 2:
1567             goto L82;
1568         case 3:
1569             goto L83;
1570         case 4:
1571             goto L91;
1572         case 5:
1573             goto L88;
1574         case 6:
1575             goto L90;
1576         case 7:
1577             goto L10;
1578         case 8:
1579             goto L80;
1580         case 9:
1581             goto L85;
1582     }
1583
1584     r = Rstk[Pt] / 100;
1585     switch ((int)r)
1586     {
1587         case 1:
1588             goto L81;
1589         case 2:
1590             goto L82;
1591         case 3:
1592             goto L83;
1593         case 4:
1594             goto L91;
1595         case 5:
1596             goto L88;
1597         case 6:
1598             goto L90;
1599         case 7:
1600             goto L92;
1601         case 8:
1602             goto L80;
1603         case 9:
1604             goto L85;
1605         case 10:
1606             goto L89;
1607     }
1608     goto L99;
1609 L89:
1610     C2F(com).fun = 99;
1611     return 0;
1612
1613 L90:
1614     C2F(recu).icall = 0;
1615     C2F(run)();
1616     if (Err > 0)
1617     {
1618         goto L98;
1619     }
1620     if (C2F(com).fun == 99)
1621     {
1622         return 0;
1623     }
1624     /*     last label is used to handle return from abort */
1625     switch ((int)C2F(recu).icall)
1626     {
1627         case 1:
1628             goto L81;
1629         case 2:
1630             goto L82;
1631         case 3:
1632             goto L83;
1633         case 4:
1634             goto L91;
1635         case 5:
1636             goto L88;
1637         case 6:
1638             goto L90;
1639         case 7:
1640             goto L15;
1641         case 8:
1642             goto L80;
1643         case 9:
1644             goto L85;
1645         case 10:
1646             goto L5;
1647     }
1648     r = Rstk[Pt] / 100;
1649     switch ((int)r)
1650     {
1651         case 1:
1652             goto L81;
1653         case 2:
1654             goto L82;
1655         case 3:
1656             goto L83;
1657         case 4:
1658             goto L91;
1659         case 5:
1660             goto L88;
1661         case 6:
1662             goto L90;
1663         case 7:
1664             goto L92;
1665         case 8:
1666             goto L80;
1667         case 9:
1668             goto L85;
1669         case 10:
1670             goto L89;
1671     }
1672     goto L99;
1673
1674 L91:
1675     C2F(recu).icall = 0;
1676     C2F(allops)();
1677     if (Err > 0)
1678     {
1679         goto L98;
1680     }
1681     switch ((int)C2F(recu).icall)
1682     {
1683         case 1:
1684             goto L81;
1685         case 2:
1686             goto L82;
1687         case 3:
1688             goto L83;
1689         case 4:
1690             goto L91;
1691         case 5:
1692             goto L88;
1693         case 6:
1694             goto L90;
1695         case 7:
1696             goto L15;
1697         case 8:
1698             goto L80;
1699         case 9:
1700             goto L85;
1701     }
1702     r = Rstk[Pt] / 100;
1703     switch ((int)r)
1704     {
1705         case 1:
1706             goto L81;
1707         case 2:
1708             goto L82;
1709         case 3:
1710             goto L83;
1711         case 4:
1712             goto L91;
1713         case 5:
1714             goto L88;
1715         case 6:
1716             goto L90;
1717         case 7:
1718             goto L92;
1719         case 8:
1720             goto L80;
1721         case 9:
1722             goto L85;
1723     }
1724     goto L98;
1725
1726 L92:
1727     switch ((int)(Rstk[Pt] - 700))
1728     {
1729         case 1:
1730             goto L17;
1731         case 2:
1732             goto L35;
1733         case 3:
1734             goto L65;
1735         case 4:
1736             goto L72;
1737         case 5:
1738             goto L65;
1739         case 6:
1740             goto L97;
1741         case 7:
1742             goto L94;
1743         case 8:
1744             goto L75;
1745         case 9:
1746             goto L99;
1747         case 10:
1748             goto L14;
1749     }
1750     goto L99;
1751
1752 L93:
1753     /*     command like function and macro call */
1754     /*     store ans as lhs */
1755     if (Eptover(1))
1756     {
1757         goto L98;
1758     }
1759     C2F(putid)(&Ids[1 + Pt * nsiz], ans);
1760     Pstk[Pt] = 0;
1761
1762     Rstk[Pt] = 707;
1763     if (C2F(com).fun > 0)
1764     {
1765         /*        *call* matfns */
1766         goto L85;
1767     }
1768     else
1769     {
1770         if (C2F(com).comp[0] != 0)
1771         {
1772             ++Rhs;
1773             Fin = extrac;
1774             /*           *call* allops(extrac) */
1775             goto L91;
1776         }
1777         else
1778         {
1779             Fin = Lstk[C2F(com).fin];
1780             /*           *call* macro */
1781             goto L88;
1782         }
1783     }
1784 L94:
1785     /*     go to store code */
1786     goto L70;
1787
1788 L96:
1789     /*     asynchronous events handling */
1790     C2F(basbrk).interruptible = C2F(getmen)(C2F(cha1).buf, &lb, &nentry) == 0;
1791     C2F(bexec)(C2F(cha1).buf, &lb, &ierr);
1792     if (ierr != 0)
1793     {
1794         goto L15;
1795     }
1796     if (Eptover(1))
1797     {
1798         goto L98;
1799     }
1800     Pstk[Pt] = Top;
1801     Rstk[Pt] = 706;
1802     Ids[1 + Pt * nsiz] = iret;
1803     /*     *call* macro */
1804     goto L88;
1805 L97:
1806     /* Rstk[Pt] == 706 indicates we return from a callback execution */
1807     if (Rstk[Pt] == 706)
1808     {
1809         returnFromCallbackExec = TRUE;
1810     }
1811
1812     Top = Pstk[Pt] - 1;
1813     C2F(basbrk).interruptible = TRUE;
1814     iret = Ids[1 + Pt * nsiz];
1815     --Pt;
1816     if (iret == 1)
1817     {
1818         goto L15;
1819     }
1820     else if (iret == 2)
1821     {
1822         if (Lpt[6] == Lpt[1])
1823         {
1824             job = 0;
1825         }
1826         else
1827         {
1828             /* go ahead with interrupted continuation line */
1829             job = 3;
1830         }
1831         C2F(com).sym = eol;
1832         goto L13;
1833     }
1834     else if (iret == 3)
1835     {
1836         job = 0;
1837         goto L12;
1838     }
1839     else if (iret == 4)
1840     {
1841         return 0;
1842     }
1843 L98:
1844     C2F(basbrk).interruptible = TRUE;
1845     /*     error recovery */
1846     /* ------------------- */
1847     imode = abs(C2F(errgst).errct) / 100000;
1848     imode -= imode / 8 << 3;
1849     if (imode == 3)
1850     {
1851         C2F(com).fun = 99;
1852         return 0;
1853     }
1854
1855     /*     error in an external (niv), during compilation (comp) or in a pause */
1856     if (Pt != 0)
1857     {
1858         if (Rstk[Pt] == 503 && C2F(iop).rio == C2F(iop).rte)
1859         {
1860             C2F(com).comp[0] = 0;
1861             goto L12;
1862         }
1863         if (C2F(errgst).err1 != 0 && Rstk[Pt] == 502)   /* catched error while compiling */
1864         {
1865             goto L88;
1866         }
1867         if (C2F(errgst).err1 != 0 && Rstk[Pt] == 808)   /* catched error in a try */
1868         {
1869             goto L80;
1870         }
1871     }
1872
1873     if (C2F(recu).niv > 0)   /*     error in an external */
1874     {
1875         C2F(com).fun = 99;
1876         return 0;
1877     }
1878     else if (C2F(recu).paus > 0) /*     error in a  pause */
1879     {
1880         C2F(com).comp[0] = 0;
1881         goto L5;
1882     }
1883     else if (Err > 0)
1884     {
1885         Pt = 0;
1886         C2F(errgst).errct = -1;
1887         C2F(errgst).errpt = 0;
1888         C2F(com).comp[0] = 0;
1889         goto L5;
1890     }
1891     else
1892     {
1893         C2F(com).comp[0] = 0;
1894         goto L5;
1895     }
1896
1897 L99:
1898     /* Recursion problems. Sorry */
1899     SciError(22);
1900     goto L1;
1901
1902 }
1903 /*--------------------------------------------------------------------------*/
1904 /**
1905  * checks if an implicit execution is required on the prompt
1906  * @param where_ returned indicator
1907  * where_ = 0 : no implicit execution is required
1908  * where_ = 1 : implicit execution is a primitive
1909  * where_ = 2 : implicit execution is a Scilab function
1910  */
1911 void handle_onprompt(int *where_)
1912 {
1913     /* Initialized data */
1914     /* onprompt[6] internal scilab code for %onprompt variable see C2F(cvname) */
1915     static int onprompt[6] = {420943928, 420878363, 673720349, 673720360, 673720360, 673720360 };
1916
1917     static int *Rstk = C2F(recu).rstk - 1;
1918     static int *Pstk = C2F(recu).pstk - 1;
1919     static int *Lstk = C2F(vstk).lstk - 1;
1920
1921     *where_ = 0;
1922     if (Pt > 0)
1923     {
1924         /* back from %onprompt */
1925         C2F(errgst).errct = Pstk[Pt];
1926         --Pt;
1927         C2F(errgst).err2 = 0;
1928         Top = 0;
1929         Fin = 0;
1930         C2F(com).fun = 0;
1931     }
1932     else
1933     {
1934         /* on prompt implicit execution */
1935         C2F(com).fun = 0;
1936         C2F(funs)(onprompt);
1937         if (Err > 0)
1938         {
1939             return;
1940         }
1941         if (C2F(com).fun <= 0 && Fin == 0)
1942         {
1943             return;
1944         }
1945         /* %onprompt function exists */
1946         Rhs = 0;
1947         Lhs = 1;
1948         ++Pt;
1949         Pstk[Pt] = C2F(errgst).errct;
1950         Rstk[Pt] = 710;
1951         /* set error catch with mode continue */
1952         C2F(errgst).errct = -100001;
1953         C2F(errgst).errpt = 1;
1954         if (C2F(com).fun > 0)
1955         {
1956             /* %onprompt is a primitive *call* matfns */
1957             *where_ = 1;
1958         }
1959         else
1960         {
1961             /* %onprompt is a Scilab function *call*  macro */
1962             C2F(com).fin = Lstk[Fin];
1963             *where_ = 2;
1964         }
1965     }
1966 }
1967 /*--------------------------------------------------------------------------*/
1968 void C2F(parsecomment)(void)
1969 {
1970
1971     static int *Lstk    = C2F(vstk).lstk - 1;
1972     static int *Lin     = C2F(iop).lin - 1;
1973     static int *Lpt     = C2F(iop).lpt - 1;
1974     static int *Comp    = C2F(com).comp - 1;
1975
1976
1977     static int l, ll, lkp, l0, c1 = 1;
1978     /* look for eol */
1979     l0 = Lpt[4] - 1;
1980     if ( (Lin[l0] == slash) && (Lin[l0 - 1] == slash) & (Lin[l0 + 1] == eol))
1981     {
1982         l0 = l0 + 1;
1983     }
1984
1985     l = l0;
1986     while (Lin[l] != eol)
1987     {
1988         l++;
1989     }
1990     ll = l - l0;
1991     if (Comp[1] == 0)
1992     {
1993         /* ignore all characters up to the end */
1994     }
1995     else
1996     {
1997         /* compilation [30 number-of-char chars-vector] */
1998         lkp = C2F(com).comp[0];
1999         Err = (lkp + 2 + ll) / 2 + 1 - Lstk[Bot];
2000         if (Err > 0)
2001         {
2002             /* Display the stack information */
2003             SciError(17);
2004             return ;
2005         }
2006         *istk(lkp) = 31;
2007         *istk(lkp + 1) = ll;
2008         C2F(icopy)(&ll, &(Lin[l0]), &c1, istk(lkp + 2), &c1);
2009         Comp[1] = lkp + 2 + ll;
2010     }
2011     Lpt[4] = l;
2012     C2F(com).char1 = eol;
2013     C2F(com).sym = eol;
2014     return ;
2015 }
2016 /*--------------------------------------------------------------------------*/
2017