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