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