source: git/Singular/grammar.y @ 34ab5de

spielwiese
Last change on this file since 34ab5de was 34ab5de, checked in by Olaf Bachmann <obachman@…>, 27 years ago
Thu Mar 27 21:20:20 1997 Olaf Bachmann <obachman@ratchwum.mathematik.uni-kl.de (Olaf Bachmann)> * added real time timer (rtimer) analog to timer * added command-line option "-d ticks_per_second" and "-m min_displayed_time_in_sec" and chahnged timer accordingly * added some #ifdef HAVE_FGLM in fglm*.cc git-svn-id: file:///usr/local/Singular/svn/trunk@121 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 40.7 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: grammar.y,v 1.5 1997-03-27 20:23:39 obachman Exp $ */
5/*
6* ABSTRACT: SINGULAR shell grammatik
7*/
8%{
9
10#include <stdio.h>
11#include <stddef.h>
12#include <stdlib.h>
13#include <stdarg.h>
14#include <string.h>
15#include <limits.h>
16
17#include "mod2.h"
18#include "tok.h"
19#include "stype.h"
20#include "ipid.h"
21#include "intvec.h"
22#include "febase.h"
23#include "matpol.h"
24#include "ring.h"
25#include "kstd1.h"
26#include "mmemory.h"
27#include "subexpr.h"
28#include "ipshell.h"
29#include "ipconv.h"
30#include "ideals.h"
31#include "numbers.h"
32#include "polys.h"
33#include "weight.h"
34#include "stairc.h"
35#include "timer.h"
36#include "cntrlc.h"
37#include "maps.h"
38#include "syz.h"
39#include "lists.h"
40
41
42extern int   yylineno;
43extern FILE* yyin;
44
45char       my_yylinebuf[YY_READ_BUF_SIZE];
46char *     currid;
47BOOLEAN    noringvars=FALSE;
48BOOLEAN    expected_parms;
49int        cmdtok;
50int        inerror = 0;
51
52#define TESTSETINT(a,i)                                \
53   if ((a).Typ() != INT_CMD)                           \
54   {                                                   \
55     WerrorS("no int expression");                     \
56     YYERROR;                                          \
57   }                                                   \
58   (i) = (int)(a).Data();
59
60#define MYYERROR(a) { WerrorS(a); YYERROR; }
61
62void yyerror(char * fmt)
63{
64  int oldInError=inerror;
65
66  inerror = 1;
67  BOOLEAN old_errorreported=errorreported;
68  errorreported = TRUE;
69  if (currid!=NULL)
70  {
71    killid(currid,&idroot);
72    currid = NULL;
73  }
74  if(!oldInError)
75  {
76    Werror( "error occurred in %s line %d: `%s`"
77           ,VoiceName(), yylineno-1, my_yylinebuf);
78    if (cmdtok!=0)
79    {
80      char *s=Tok2Cmdname(cmdtok);
81      if (expected_parms)
82      {
83        Werror("expected %s-expression. type \'help %s;\'",s,s);
84      }
85      else
86      {
87        Werror("wrong type declaration. type \'help %s;\'",s);
88      }
89    }
90    if (!old_errorreported && (lastreserved!=NULL))
91    {
92      Werror("last reserved name was `%s`",lastreserved);
93    }
94  }
95  else
96    inerror=oldInError;
97  if ((voice>0)&&(myynest>0))
98  {
99    Werror("leaving %s",VoiceName());
100    exitBuffer(BT_proc);
101  }
102}
103
104#ifndef alloca
105#define alloca malloc
106#endif
107
108%}
109
110/* %expect 22 */
111%pure_parser
112
113/* special symbols */
114%token DOTDOT
115%token EQUAL_EQUAL
116%token GE
117%token LE
118/*%token MINUSEQUAL*/
119%token MINUSMINUS
120%token NOT
121%token NOTEQUAL
122/*%token PLUSEQUAL*/
123%token PLUSPLUS
124
125/* types, part 1 (ring indep.)*/
126%token <i> DRING_CMD
127%token <i> INTMAT_CMD
128%token <i> PROC_CMD
129%token <i> RING_CMD
130
131/* valid when ring defined ! */
132%token <i> BEGIN_RING
133/* types, part 2 */
134%token <i> IDEAL_CMD
135%token <i> MAP_CMD
136%token <i> MATRIX_CMD
137%token <i> MODUL_CMD
138%token <i> NUMBER_CMD
139%token <i> POLY_CMD
140%token <i> VECTOR_CMD
141/* end types */
142
143/* ring dependent cmd:*/
144%token <i> BAREISS_CMD
145%token <i> BETTI_CMD
146%token <i> COEFFS_CMD
147%token <i> COEF_CMD
148%token <i> CONTRACT_CMD
149%token <i> DEGREE_CMD
150%token <i> DEG_CMD
151%token <i> DET_CMD
152%token <i> DIFF_CMD
153%token <i> DIM_CMD
154%token <i> ELIMINATION_CMD
155%token <i> E_CMD
156%token <i> FETCH_CMD
157%token <i> FREEMODULE_CMD
158%token <i> KEEPRING_CMD
159%token <i> HILBERT_CMD
160%token <i> HOMOG_CMD
161%token <i> IMAP_CMD
162%token <i> INDEPSET_CMD
163%token <i> INTERRED_CMD
164%token <i> INTERSECT_CMD
165%token <i> JACOB_CMD
166%token <i> JET_CMD
167%token <i> KBASE_CMD
168%token <i> KOSZUL_CMD
169%token <i> LEADCOEF_CMD
170%token <i> LEADEXP_CMD
171%token <i> LEAD_CMD
172%token <i> LIFTSTD_CMD
173%token <i> LIFT_CMD
174%token <i> MAXID_CMD
175%token <i> MINBASE_CMD
176%token <i> MINOR_CMD
177%token <i> MINRES_CMD
178%token <i> MODULO_CMD
179%token <i> MRES_CMD
180%token <i> MULTIPLICITY_CMD
181%token <i> ORD_CMD
182%token <i> PAR_CMD
183%token <i> PARDEG_CMD
184%token <i> PREIMAGE_CMD
185%token <i> QUOTIENT_CMD
186%token <i> QHWEIGHT_CMD
187%token <i> REDUCE_CMD
188%token <i> REGULARITY_CMD
189%token <i> RES_CMD
190%token <i> SIMPLIFY_CMD
191%token <i> SORTVEC_CMD
192%token <i> SRES_CMD
193%token <i> STD_CMD
194%token <i> SUBST_CMD
195%token <i> SYZYGY_CMD
196%token <i> VAR_CMD
197%token <i> VDIM_CMD
198%token <i> WEDGE_CMD
199%token <i> WEIGHT_CMD
200
201/*system variables in ring block*/
202%token <i> VALTVARS
203%token <i> VMAXDEG
204%token <i> VMAXMULT
205%token <i> VNOETHER
206%token <i> VMINPOLY
207
208%token <i> END_RING
209/* end of ring definitions */
210
211%token <i> CMD_1
212%token <i> CMD_2
213%token <i> CMD_3
214%token <i> CMD_12
215%token <i> CMD_23
216%token <i> CMD_123
217%token <i> CMD_M
218%token <i> ROOT_DECL
219        /* put variables of this type into the idroot list */
220%token <i> ROOT_DECL_LIST
221        /* put variables of this type into the idroot list */
222%token <i> RING_DECL
223        /* put variables of this type into the currRing list */
224%token <i> EXAMPLE_CMD
225%token <i> EXECUTE_CMD
226%token <i> EXPORT_CMD
227%token <i> HELP_CMD
228%token <i> KILL_CMD
229%token <i> LIB_CMD
230%token <i> LISTVAR_CMD
231%token <i> SETRING_CMD
232%token <i> TYPE_CMD
233
234%token <name> STRINGTOK BLOCKTOK INT_CONST
235%token <name> UNKNOWN_IDENT RINGVAR PROC_DEF
236
237/* control */
238%token <i> BREAK_CMD
239%token <i> CONTINUE_CMD
240%token <i> ELSE_CMD
241%token <i> EVAL
242%token <i> QUOTE
243%token <i> EXIT_CMD
244%token <i> FOR_CMD
245%token <i> IF_CMD
246%token <i> SYS_BREAK
247%token <i> WHILE_CMD
248%token <i> RETURN
249%token <i> END_PROC
250%token <i> PARAMETER
251
252/* system variables */
253%token <i> SYSVAR
254
255%type <name> extendedid
256%type <lv>   rlist ordering OrderingList orderelem
257%type <name> stringexpr
258%type <lv>   expr elemexpr exprlist expr_arithmetic
259%type <lv>   declare_ip_variable left_value
260%type <i>    ordername
261%type <i>    cmdeq
262%type <i>    currring_lists
263%type <i>    setrings
264%type <i>    ringcmd1
265
266%type <i>    '=' '<' '>' '+' '-'
267%type <i>    '*' '/' '[' ']' '.' '^' ',' ';'
268
269
270/*%nonassoc '=' PLUSEQUAL DOTDOT*/
271%nonassoc '=' DOTDOT
272%left '|' '&'
273%left EQUAL_EQUAL NOTEQUAL
274%left '<' '>' GE LE
275%left '+' '-'
276%left '*' '/' '%'
277%left UMINUS
278%left  '^'
279%left '[' ']'
280%left '(' ')'
281%left PLUSPLUS
282%left MINUSMINUS
283
284%%
285lines:
286        /**/
287        | lines pprompt
288          {
289            if (timerv
290            #ifdef SIC
291            && (!sic)
292            #endif
293            )
294            {
295              writeTime("used time:");
296              startTimer();
297            }
298            #ifdef HAVE_RTIMER
299            if (rtimerv
300            #ifdef SIC
301            && (!sic)
302            #endif
303            )
304            {
305              writeRTime("used real time:");
306              startRTimer();
307            }
308            #endif
309            prompt_char = '>';
310            currid = NULL;
311            if (errorreported)
312            {
313              yyerror("");
314            }
315            if (inerror==2) PrintLn();
316            errorreported = inerror = cmdtok = 0;
317            lastreserved=NULL;
318            expected_parms=FALSE;
319            noringvars = FALSE;
320            test_int();
321          }
322        ;
323
324pprompt:
325        flowctrl                       /* if, while, for etc */
326        | command ';'                  /* commands returning no value */
327          {ifswitch[voice]=0;}
328        | assign  ';'                  /* general assignment */
329          {ifswitch[voice]=0;}
330        | parametercmd ';'             /* proc parameter assignments */
331          {yylineno--;ifswitch[voice]=0;}
332        | declare_ip_variable ';'      /* default initialization */
333          { $1.CleanUp(); ifswitch[voice]=0;}
334        | filecmd
335          {ifswitch[voice]=0;}
336        | returncmd
337          {
338            #ifdef SIC
339            if (!sic)
340            #endif
341            YYACCEPT;
342          }
343        | EXIT_CMD
344          {
345            ifswitch[voice]=0;
346            /* Print("exit found\n"); */
347            YYACCEPT;
348          }
349        | SYS_BREAK
350          {
351            #ifdef SIC
352            if (sic)
353              emStoreOp(SYS_BREAK,0);
354            else
355            #endif
356            {
357              ifswitch[voice]=0;
358              iiDebug();
359            }
360          }
361        | ';'                    /* ignore empty statements */
362          {ifswitch[voice]=0;}
363        | error ';'
364          {
365            #ifdef SIQ
366            siq=0;
367            #endif
368            ifswitch[voice]=0;
369            if (inerror&&($1.i<UMINUS) && ($1.i>' '))
370            {
371              // 1: yyerror called
372              // 2: scanner put actual string
373              // 3: error rule put token+\n
374              inerror=3;
375              Print(" error at token `%s`\n",iiTwoOps($1.i));
376            }
377            if (!errorreported) WerrorS("...parse error");
378            yyerror("");
379            yyerrok;
380            #ifdef SIC
381            if (sic) YYABORT;
382            #endif
383            if (myynest>0)
384            {
385              //WerrorS("leaving yyparse");
386              YYABORT;
387            }
388            else if (voice>0)
389            {
390              //WerrorS("leaving voice");
391              exitBuffer(BT_break);
392            }
393            errorreported = FALSE;
394            lastreserved=NULL;
395          }
396        ;
397
398flowctrl: ifcmd
399          | whilecmd
400          | forcmd
401          | proccmd
402            {ifswitch[voice]=0;}
403        ;
404
405command: executecmd | helpcmd | killcmd | exportcmd | listcmd
406         | ringcmd | scriptcmd | setringcmd | typecmd
407         ;
408
409assign: left_value exprlist
410          {
411            if(iiAssign(&$1,&$2)) YYERROR;
412          }
413        ;
414
415elemexpr:
416        RINGVAR
417          {
418            #ifdef SIC
419            if (!sic)
420            #endif
421              if (currRing==NULL) MYYERROR("no ring active");
422            syMake(&$$,$1);
423          }
424        | extendedid
425          {
426            syMake(&$$,$1);
427          }
428        | elemexpr '('  ')'
429          {
430            if(iiExprArith1(&$$,&$1,'(')) YYERROR;
431          }
432        | elemexpr '(' exprlist ')'
433          {
434            $1.next=(leftv)Alloc(sizeof(sleftv));
435            memcpy($1.next,&$3,sizeof(sleftv));
436            if(iiExprArithM(&$$,&$1,'(')) YYERROR;
437          }
438        | elemexpr '.' extendedid
439          {
440            idhdl r=idroot;
441            if ($1.Typ()!=PACKAGE_CMD) MYYERROR("<package>.<id> expected");
442            idroot=IDPACKAGE((idhdl)$1.data)->idroot;
443            syMake(&$$,$3);
444            idroot=r;
445          }
446        | '[' exprlist ']'
447          {
448            if (currRingHdl==NULL) MYYERROR("no ring active");
449            int j = 0;
450            memset(&$$,0,sizeof(sleftv));
451            $$.rtyp=VECTOR_CMD;
452            leftv v = &$2;
453            while (v!=NULL)
454            {
455              poly p = pOne();
456              pSetCompP(p,++j);
457              int k = (int)(v->Data());
458              if (k!=0)
459              {
460                if (v->Typ() == INT_CMD)
461                {
462                  $$.data = (void *)pAdd((poly)$$.data,pMult(p,pISet(k)));
463                }
464                else if (v->Typ() == POLY_CMD)
465                {
466                  $$.data = (void *)pAdd((poly)$$.data,pMult(p, (poly)(v->CopyD())) );
467                }
468                else
469                  MYYERROR("expected '[poly,...'");
470              }
471              else
472                pDelete1(&p);
473              v=v->next;
474            }
475            $2.CleanUp();
476          }
477        | INT_CONST
478          {
479            memset(&$$,0,sizeof($$));
480            int i = atoi($1);
481
482            /* check: out of range input */
483            int l = strlen($1)+2;
484            if (l >= MAX_INT_LEN)
485            {
486              char tmp[100];
487              sprintf(tmp,"%d",i);
488              if (strcmp(tmp,$1)!=0)
489              {
490                Werror("`%s` greater than %d(max. integer representation)"
491                       ,$1,INT_MAX);
492                YYERROR;
493              }
494            }
495            /*remember not to FreeL($1)
496            *because it is a part of the scanner buffer*/
497            $$.rtyp  = INT_CMD;
498            $$.data = (void *)i;
499          }
500        | SYSVAR
501          {
502            memset(&$$,0,sizeof($$));
503            $$.rtyp = $1;
504            $$.data = $$.Data();
505          }
506        | stringexpr
507          {
508            memset(&$$,0,sizeof($$));
509            $$.rtyp  = STRING_CMD;
510            $$.data = $1;
511          }
512        ;
513
514exprlist:
515        expr ',' exprlist
516          {
517            leftv v = &$1;
518            while (v->next!=NULL)
519            {
520              v=v->next;
521            }
522            v->next = (leftv)Alloc(sizeof(sleftv));
523            memcpy(v->next,&($3),sizeof(sleftv));
524            $$ = $1;
525          }
526        | expr
527          {
528            $$ = $1;
529          }
530        | '(' expr ',' exprlist ')'
531          {
532            leftv v = &$2;
533            while (v->next!=NULL)
534            {
535              v=v->next;
536            }
537            v->next = (leftv)Alloc(sizeof(sleftv));
538            memcpy(v->next,&($4),sizeof(sleftv));
539            $$ = $2;
540          }
541        ;
542
543expr:   expr_arithmetic
544          {
545            /*if ($1.typ == eunknown) YYERROR;*/
546            $$ = $1;
547          }
548        | elemexpr        { $$ = $1; }
549        | '(' expr ')'    { $$ = $2; }
550        | expr '[' expr ',' expr ']'
551          {
552            if(iiExprArith3(&$$,'[',&$1,&$3,&$5)) YYERROR;
553          }
554        | expr '[' expr ']'
555          {
556            if(iiExprArith2(&$$,&$1,'[',&$3)) YYERROR;
557          }
558        | ROOT_DECL '(' expr ')'
559          {
560            if(iiExprArith1(&$$,&$3,$1)) YYERROR;
561          }
562        | ROOT_DECL_LIST '(' exprlist ')'
563          {
564            if(iiExprArithM(&$$,&$3,$1)) YYERROR;
565          }
566        | ROOT_DECL_LIST '(' ')'
567          {
568            if(iiExprArithM(&$$,NULL,$1)) YYERROR;
569          }
570        | RING_DECL '(' expr ')'
571          {
572            if(iiExprArith1(&$$,&$3,$1)) YYERROR;
573          }
574        | currring_lists '(' exprlist ')'
575          {
576            if(iiExprArithM(&$$,&$3,$1)) YYERROR;
577          }
578        | currring_lists '(' ')'
579          {
580            if(iiExprArithM(&$$,NULL,$1)) YYERROR;
581          }
582        | CMD_1 '(' expr ')'
583          {
584            if(iiExprArith1(&$$,&$3,$1)) YYERROR;
585          }
586        | CMD_2 '(' expr ',' expr ')'
587          {
588            if(iiExprArith2(&$$,&$3,$1,&$5,TRUE)) YYERROR;
589          }
590        | CMD_3 '(' expr ',' expr ',' expr ')'
591          {
592            if(iiExprArith3(&$$,$1,&$3,&$5,&$7)) YYERROR;
593          }
594        | CMD_M '(' ')'
595          {
596            if(iiExprArithM(&$$,NULL,$1)) YYERROR;
597          }
598        | CMD_23 '(' expr ',' expr ')'
599          {
600            if(iiExprArith2(&$$,&$3,$1,&$5,TRUE)) YYERROR;
601          }
602        | CMD_23 '(' expr ',' expr ',' expr ')'
603          {
604            if(iiExprArith3(&$$,$1,&$3,&$5,&$7)) YYERROR;
605          }
606        | CMD_12 '(' expr ')'
607          {
608            if(iiExprArith1(&$$,&$3,$1)) YYERROR;
609          }
610        | CMD_12 '(' expr ',' expr ')'
611          {
612            if(iiExprArith2(&$$,&$3,$1,&$5,TRUE)) YYERROR;
613          }
614        | CMD_123 '(' expr ')'
615          {
616            if(iiExprArith1(&$$,&$3,$1)) YYERROR;
617          }
618        | CMD_123 '(' expr ',' expr ')'
619          {
620            if(iiExprArith2(&$$,&$3,$1,&$5,TRUE)) YYERROR;
621          }
622        | CMD_123 '(' expr ',' expr ',' expr ')'
623          {
624            if(iiExprArith3(&$$,$1,&$3,&$5,&$7)) YYERROR;
625          }
626        | MATRIX_CMD '(' expr ',' expr ',' expr ')'
627          {
628            if(iiExprArith3(&$$,MATRIX_CMD,&$3,&$5,&$7)) YYERROR;
629          }
630        | MATRIX_CMD '(' expr ')'
631          {
632            if(iiExprArith1(&$$,&$3,MATRIX_CMD)) YYERROR;
633          }
634        | INTMAT_CMD '(' expr ')'
635          {
636            if(iiExprArith1(&$$,&$3,INTMAT_CMD)) YYERROR;
637          }
638        | CMD_M '(' exprlist ')'
639          {
640            if(iiExprArithM(&$$,&$3,$1)) YYERROR;
641          }
642        | quote_start expr quote_end
643          {
644            $$=$2;
645          }
646        | quote_start expr '=' expr quote_end
647          {
648            #ifdef SIQ
649            siq++;
650            if (siq>0)
651            { if (iiExprArith2(&$$,&$2,'=',&$4)) YYERROR; }
652            else
653            #endif
654            {
655              memset(&$$,0,sizeof($$));
656              $$.rtyp=NONE;
657              if (iiAssign(&$2,&$4)) YYERROR;
658            }
659            #ifdef SIQ
660            siq--;
661            #endif
662          }
663        | EVAL  '('
664          {
665            #ifdef SIQ
666            siq--;
667            #endif
668          }
669          expr ')'
670          {
671            #ifdef SIQ
672            if (siq<=0) $4.Eval();
673            #endif
674            $$=$4;
675            #ifdef SIQ
676            siq++;
677            #endif
678          }
679          ;
680
681quote_start:    QUOTE  '('
682          {
683            #ifdef SIQ
684            siq++;
685            #endif
686          }
687          ;
688
689quote_end: ')'
690          {
691            #ifdef SIQ
692            siq--;
693            #endif
694          }
695          ;
696
697expr_arithmetic:
698          expr  PLUSPLUS     %prec PLUSPLUS
699          {
700            if(iiExprArith1(&$$,&$1,PLUSPLUS)) YYERROR;
701          }
702        | expr  MINUSMINUS   %prec MINUSMINUS
703          {
704            if(iiExprArith1(&$$,&$1,MINUSMINUS)) YYERROR;
705          }
706        | expr  '+' expr
707          {
708            if(iiExprArith2(&$$,&$1,'+',&$3)) YYERROR;
709          }
710        | expr  '-' expr
711          {
712            if(iiExprArith2(&$$,&$1,'-',&$3)) YYERROR;
713          }
714        | expr  '*' expr
715          {
716            if(iiExprArith2(&$$,&$1,'*',&$3)) YYERROR;
717          }
718        | expr  '/' expr
719          {
720            if(iiExprArith2(&$$,&$1,'/',&$3)) YYERROR;
721          }
722        | expr  '^' expr
723          {
724            if(iiExprArith2(&$$,&$1,'^',&$3)) YYERROR;
725          }
726        | expr  '%' expr
727          {
728            if(iiExprArith2(&$$,&$1,'%',&$3)) YYERROR;
729          }
730        | expr  '>' expr
731          {
732            if(iiExprArith2(&$$,&$1,'>',&$3)) YYERROR;
733          }
734        | expr  '<' expr
735          {
736            if(iiExprArith2(&$$,&$1,'<',&$3)) YYERROR;
737          }
738        | expr  '&' expr
739          {
740            if(iiExprArith2(&$$,&$1,'&',&$3)) YYERROR;
741          }
742        | expr  '|' expr
743          {
744            if(iiExprArith2(&$$,&$1,'|',&$3)) YYERROR;
745          }
746        | expr  NOTEQUAL expr
747          {
748            if(iiExprArith2(&$$,&$1,NOTEQUAL,&$3)) YYERROR;
749          }
750        | expr  EQUAL_EQUAL expr
751          {
752            if(iiExprArith2(&$$,&$1,EQUAL_EQUAL,&$3)) YYERROR;
753          }
754        | expr  GE  expr
755          {
756            if(iiExprArith2(&$$,&$1,GE,&$3)) YYERROR;
757          }
758        | expr  LE expr
759          {
760            if(iiExprArith2(&$$,&$1,LE,&$3)) YYERROR;
761          }
762        | expr DOTDOT expr
763          {
764            if(iiExprArith2(&$$,&$1,DOTDOT,&$3)) YYERROR;
765          }
766        | NOT '(' expr ')'
767          {
768            memset(&$$,0,sizeof($$));
769            int i; TESTSETINT($3,i);
770            $$.rtyp  = INT_CMD;
771            $$.data = (void *)(i == 0 ? 1 : 0);
772          }
773        | '-' expr %prec UMINUS
774          {
775            if(iiExprArith1(&$$,&$2,'-')) YYERROR;
776          }
777        ;
778
779left_value:
780        declare_ip_variable cmdeq  { $$ = $1; }
781        | exprlist '=' { $$ = $1; }
782        ;
783
784
785extendedid:
786        UNKNOWN_IDENT
787        | '`' expr '`'
788          {
789            if ($2.Typ()!=STRING_CMD)
790            {
791              MYYERROR("string expression expected");
792            }
793            $$ = (char *)$2.CopyD();
794            $2.CleanUp();
795          }
796        ;
797
798currring_lists:
799        IDEAL_CMD | MODUL_CMD
800        /* put variables into the current ring */
801        ;
802
803declare_ip_variable:
804        ROOT_DECL elemexpr
805          {
806            if (iiDeclCommand(&$$,&$2,myynest,$1,&idroot)) YYERROR;
807          }
808        | ROOT_DECL_LIST elemexpr
809          {
810            if (iiDeclCommand(&$$,&$2,myynest,$1,&idroot)) YYERROR;
811          }
812        | RING_DECL elemexpr
813          {
814            #ifdef SIC
815            if ((sic) && (currRing==NULL))
816            {
817              if (iiDeclCommand(&$$,&$2,myynest,$1,NULL)) YYERROR;
818            }
819            else
820            #endif
821            {
822              if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
823            }
824          }
825        | currring_lists elemexpr
826          {
827            #ifdef SIC
828            if ((sic) && (currRing==NULL))
829            {
830              if (iiDeclCommand(&$$,&$2,myynest,$1,NULL)) YYERROR;
831            }
832            else
833            #endif
834            {
835              if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
836            }
837          }
838        | MATRIX_CMD elemexpr '[' expr ']' '[' expr ']'
839          {
840            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
841            #ifdef SIC
842            if (sic)
843            {
844            }
845            else
846            #endif
847            {
848              int r; TESTSETINT($4,r);
849              int c; TESTSETINT($7,c);
850              if (r < 1)
851                MYYERROR("rows must be greater than 0");
852              if (c < 0)
853                MYYERROR("cols must be greater than -1");
854              leftv v=&$$;
855              //while (v->next!=NULL) { v=v->next; }
856              idhdl h=(idhdl)v->data;
857              idDelete(&IDIDEAL(h));
858              IDMATRIX(h) = mpNew(r,c);
859              if (IDMATRIX(h)==NULL) YYERROR;
860            }
861          }
862        | MATRIX_CMD elemexpr
863          {
864            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
865          }
866        | INTMAT_CMD elemexpr '[' expr ']' '[' expr ']'
867          {
868            if (iiDeclCommand(&$$,&$2,myynest,$1,&idroot)) YYERROR;
869            #ifdef SIC
870            if (sic)
871            {
872            }
873            else
874            #endif
875            {
876              int r; TESTSETINT($4,r);
877              int c; TESTSETINT($7,c);
878              if (r < 1)
879                MYYERROR("rows must be greater than 0");
880              if (c < 0)
881                MYYERROR("cols must be greater than -1");
882              leftv v=&$$;
883              //while (v->next!=NULL) { v=v->next; }
884              idhdl h=(idhdl)v->data;
885              delete IDINTVEC(h);
886              IDINTVEC(h) = new intvec(r,c,0);
887              if (IDINTVEC(h)==NULL) YYERROR;
888            }
889          }
890        | INTMAT_CMD elemexpr
891          {
892            if (iiDeclCommand(&$$,&$2,myynest,$1,&idroot)) YYERROR;
893            leftv v=&$$;
894            idhdl h;
895            do
896            {
897               h=(idhdl)v->data;
898               delete IDINTVEC(h);
899               IDINTVEC(h) = new intvec(1,1,0);
900               v=v->next;
901            } while (v!=NULL);
902          }
903        | declare_ip_variable ',' elemexpr
904          {
905            int t=$1.Typ();
906            sleftv r;
907            memset(&r,0,sizeof(sleftv));
908            if ((BEGIN_RING<t) && (t<END_RING))
909            {
910              if (iiDeclCommand(&r,&$3,myynest,t,&(currRing->idroot))) YYERROR;
911            }
912            else
913            {
914              if (iiDeclCommand(&r,&$3,myynest,t,&idroot)) YYERROR;
915            }
916            leftv v=&$1;
917            while (v->next!=NULL) v=v->next;
918            v->next=(leftv)Alloc(sizeof(sleftv));
919            memcpy(v->next,&r,sizeof(sleftv));
920            $$=$1;
921          }
922        ;
923
924stringexpr:
925        STRINGTOK
926        | LIB_CMD
927          {
928            idhdl h = ggetid( "LIB" );
929            if (h==NULL) YYERROR;
930            $$ = mstrdup(IDSTRING(h));
931          }
932        ;
933
934rlist:
935        expr
936        | '(' expr ',' exprlist ')'
937          {
938            leftv v = &$2;
939            while (v->next!=NULL)
940            {
941              v=v->next;
942            }
943            v->next = (leftv)Alloc(sizeof(sleftv));
944            memcpy(v->next,&($4),sizeof(sleftv));
945            $$ = $2;
946          }
947        ;
948
949ordername:
950        UNKNOWN_IDENT
951        {
952          if (!($$=rOrderName($1)))
953            YYERROR;
954        }
955        ;
956
957orderelem:
958        ordername
959          {
960            memset(&$$,0,sizeof($$));
961            intvec *iv = new intvec(2);
962            (*iv)[0] = 1;
963            (*iv)[1] = $1;
964            $$.rtyp = INTVEC_CMD;
965            $$.data = (void *)iv;
966          }
967        | ordername '(' exprlist ')'
968          {
969            memset(&$$,0,sizeof($$));
970            leftv sl = &$3;
971            int slLength;
972            {
973              slLength =  exprlist_length(sl);
974              int l = 2 +  slLength;
975              intvec *iv = new intvec(l);
976              (*iv)[0] = slLength;
977              (*iv)[1] = $1;
978
979              int i = 2;
980              while ((i<l) && (sl!=NULL))
981              {
982                if (sl->Typ() == INT_CMD)
983                {
984                  (*iv)[i++] = (int)(sl->Data());
985                }
986                else if ((sl->Typ() == INTVEC_CMD)
987                ||(sl->Typ() == INTMAT_CMD))
988                {
989                  intvec *ivv = (intvec *)(sl->Data());
990                  int ll = 0,l = ivv->length();
991                  for (; l>0; l--)
992                  {
993                    (*iv)[i++] = (*ivv)[ll++];
994                  }
995                }
996                else
997                {
998                  delete iv;
999                  $3.CleanUp();
1000                  MYYERROR("wrong type in ordering");
1001                }
1002                sl = sl->next;
1003              }
1004              $$.rtyp = INTVEC_CMD;
1005              $$.data = (void *)iv;
1006            }
1007            $3.CleanUp();
1008          }
1009        ;
1010
1011OrderingList:
1012        orderelem
1013        |  orderelem ',' OrderingList
1014          {
1015            $$ = $1;
1016            $$.next = (sleftv *)Alloc(sizeof(sleftv));
1017            memcpy($$.next,&$3,sizeof(sleftv));
1018          }
1019        ;
1020
1021ordering:
1022        orderelem
1023        | '(' OrderingList ')'
1024          {
1025            $$ = $2;
1026          }
1027        ;
1028
1029cmdeq:  '='
1030          {
1031            expected_parms = TRUE;
1032          }
1033        ;
1034
1035
1036/* --------------------------------------------------------------------*/
1037/* section of pure commands                                            */
1038/* --------------------------------------------------------------------*/
1039
1040executecmd:
1041        EXECUTE_CMD expr
1042          {
1043            #ifdef SIC
1044            if (sic) MYYERROR("execute not supported");
1045            #endif
1046            if ($2.Typ() == STRING_CMD)
1047            {
1048              char * s = (char *)AllocL(strlen((char *)$2.Data()) + 4);
1049              strcpy( s, (char *)$2.Data());
1050              strcat( s, "\n;\n");
1051              $2.CleanUp();
1052              newBuffer(s,BT_execute);
1053            }
1054            else
1055            {
1056              MYYERROR("string expected");
1057            }
1058          }
1059        ;
1060
1061filecmd:
1062        '<' stringexpr ';'
1063          { if (iiPStart(NULL,$2,NULL)) YYERROR; }
1064        ;
1065
1066helpcmd:
1067        HELP_CMD STRINGTOK
1068          {
1069            singular_help($2,FALSE);
1070            FreeL((ADDRESS)$2);
1071          }
1072        | HELP_CMD
1073          {
1074#ifdef buildin_help
1075            char *s=(char *)Alloc(10);
1076            strcpy(s,"index");
1077            singular_help(s,FALSE);
1078            Free((ADDRESS)s,10);
1079#else
1080            system("info singular");
1081#endif
1082          }
1083        | EXAMPLE_CMD STRINGTOK
1084          {
1085            singular_help($2,TRUE);
1086            FreeL((ADDRESS)$2);
1087            if (inerror) YYERROR;
1088          }
1089        ;
1090
1091exportcmd:
1092        EXPORT_CMD exprlist
1093        {
1094          if (iiExport(&$2,0)) YYERROR;
1095        }
1096        | EXPORT_CMD exprlist extendedid expr
1097        {
1098          if ((strcmp($3,"to")!=0) ||
1099          (($4.Typ()!=PACKAGE_CMD) && ($4.Typ()!=INT_CMD)))
1100            MYYERROR("export <id> to <package|int>");
1101          FreeL((ADDRESS)$3);
1102          if ($4.Typ()==INT_CMD)
1103          {
1104            if (iiExport(&$2,((int)$4.Data())-1)) YYERROR;
1105          }
1106          else
1107          {
1108            if (iiExport(&$2,0,IDPACKAGE((idhdl)$4.data)->idroot))
1109              YYERROR;
1110          }
1111        }
1112        ;
1113
1114killcmd:
1115        KILL_CMD kill_any_identifier {;}
1116        ;
1117
1118kill_any_identifier:
1119        elemexpr
1120          {
1121            leftv v=&$1;
1122            do
1123            {
1124              if (v->rtyp!=IDHDL)
1125              {
1126                if (v->name!=NULL) Werror("`%s` is undefined in kill",v->name);
1127                else               WerrorS("kill what ?");
1128              }
1129              else
1130              {
1131                killhdl((idhdl)v->data);
1132              }
1133              v=v->next;
1134            } while (v!=NULL);
1135            $1.CleanUp();
1136          }
1137        | kill_any_identifier ',' elemexpr
1138          {
1139            if ($3.rtyp!=IDHDL)
1140            {
1141              if ($3.name!=NULL) Werror("`%s` is undefined",$3.name);
1142              else               WerrorS("kill what ?");
1143            }
1144            else
1145            {
1146              killhdl((idhdl)$3.data);
1147            }
1148            $3.CleanUp();
1149          }
1150        ;
1151
1152listcmd:
1153        LISTVAR_CMD '(' ROOT_DECL ')'
1154          {
1155            list_cmd($3,NULL,"// ",TRUE);
1156          }
1157        | LISTVAR_CMD '(' ROOT_DECL_LIST ')'
1158          {
1159            list_cmd($3,NULL,"// ",TRUE);
1160          }
1161        | LISTVAR_CMD '(' RING_DECL ')'
1162          {
1163            if ($3==QRING_CMD) $3=RING_CMD;
1164            list_cmd($3,NULL,"// ",TRUE);
1165          }
1166        | LISTVAR_CMD '(' currring_lists ')'
1167          {
1168            list_cmd($3,NULL,"// ",TRUE);
1169          }
1170        | LISTVAR_CMD '(' RING_CMD ')'
1171          {
1172            #ifdef SIC
1173            if (sic) MYYERROR("not implemented yet");
1174            #endif
1175            list_cmd(RING_CMD,NULL,"// ",TRUE);
1176          }
1177        | LISTVAR_CMD '(' MATRIX_CMD ')'
1178          {
1179            #ifdef SIC
1180            if (sic) MYYERROR("not implemented yet");
1181            #endif
1182            list_cmd(MATRIX_CMD,NULL,"// ",TRUE);
1183           }
1184        | LISTVAR_CMD '(' INTMAT_CMD ')'
1185          {
1186            #ifdef SIC
1187            if (sic) MYYERROR("not implemented yet");
1188            #endif
1189            list_cmd(INTMAT_CMD,NULL,"// ",TRUE);
1190          }
1191        | LISTVAR_CMD '(' PROC_CMD ')'
1192          {
1193            #ifdef SIC
1194            if (sic) MYYERROR("not implemented yet");
1195            #endif
1196            list_cmd(PROC_CMD,NULL,"// ",TRUE);
1197          }
1198        | LISTVAR_CMD '(' elemexpr ')'
1199          {
1200            #ifdef SIC
1201            if (sic) MYYERROR("not implemented yet");
1202            #endif
1203            list_cmd(0,$3.Name(),"// ",TRUE);
1204            $3.CleanUp();
1205          }
1206        | LISTVAR_CMD '(' ')'
1207          {
1208            #ifdef SIC
1209            if (sic) MYYERROR("not implemented yet");
1210            #endif
1211            list_cmd(-1,NULL,"// ",TRUE);
1212          }
1213        ;
1214
1215ringcmd1:
1216       RING_CMD { noringvars = TRUE; }
1217       ;
1218
1219ringcmd:
1220        ringcmd1
1221          elemexpr cmdeq
1222          rlist     ','      /* description of coeffs */
1223          rlist     ','      /* var names */
1224          ordering           /* list of (multiplier ordering (weight(s))) */
1225          {
1226            #ifdef SIC
1227            if (sic)
1228            {
1229            }
1230            #endif
1231            //noringvars = FALSE;
1232            if(!rInit($2.name,        /* ringname */
1233                     &$4,            /* characteristik and list of parameters*/
1234                     &$6,            /* names of ringvariables */
1235                     &$8,            /* ordering */
1236                     FALSE))         /* is not a dring */
1237            {
1238              MYYERROR("cannot make ring");
1239            }
1240            $4.CleanUp();
1241            $6.CleanUp();
1242            $8.CleanUp();
1243          }
1244        | ringcmd1 elemexpr
1245          {
1246            //noringvars = FALSE;
1247            if (!inerror) rDefault($2.name);
1248          }
1249        | DRING_CMD { noringvars = TRUE; }
1250          elemexpr cmdeq
1251          rlist     ','       /* description of coeffs */
1252          rlist     ','       /* var names */
1253          ordering           /* list of (multiplier ordering (weight(s))) */
1254          {
1255            #ifdef DRING
1256            idhdl h;
1257            //noringvars = FALSE;
1258            if(!(h=rInit($3.name,    /* ringname */
1259                     &$5,            /* characteristik and list of parameters*/
1260                     &$7,            /* names of ringvariables */
1261                     &$9,            /* ordering */
1262                     TRUE)))         /* is a dring */
1263            {
1264              YYERROR;
1265            }
1266            setFlag(h,FLAG_DRING);
1267            rDSet();
1268            $5.CleanUp();
1269            $7.CleanUp();
1270            $9.CleanUp();
1271            #endif
1272          }
1273        ;
1274
1275scriptcmd:
1276         LIB_CMD stringexpr
1277          {
1278            if (iiLibCmd($2)) YYERROR;
1279          }
1280        ;
1281
1282setrings:  SETRING_CMD | KEEPRING_CMD ;
1283
1284setringcmd:
1285        setrings expr
1286          {
1287            if (($1==KEEPRING_CMD) && (myynest==0))
1288               MYYERROR("only inside a proc allowed");
1289            const char * n=$2.Name();
1290            if ((($2.Typ()==RING_CMD)||($2.Typ()==QRING_CMD))
1291            && ($2.rtyp==IDHDL))
1292            {
1293              idhdl h=(idhdl)$2.data;
1294              if ($2.e!=NULL) h=rFindHdl((ring)$2.Data(),NULL);
1295              if ($1==KEEPRING_CMD)
1296              {
1297                if (h!=NULL)
1298                {
1299                  if (IDLEV(h)!=0)
1300                  {
1301                    if (iiExport(&$2,myynest-1)) YYERROR;
1302                    //if (TEST_OPT_KEEPVARS)
1303                    //{
1304                      idhdl p=IDRING(h)->idroot;
1305                      int prevlev=myynest-1;
1306                      while (p!=NULL)
1307                      {
1308                        if (IDLEV(p)==myynest) IDLEV(p)=prevlev;
1309                        p=IDNEXT(p);
1310                      }
1311                    //}
1312                  }
1313                  iiLocalRing[myynest-1]=IDRING(h);
1314                }
1315                else
1316                {
1317                  Werror("%s is no identifier",n);
1318                  $2.CleanUp();
1319                  YYERROR;
1320                }
1321              }
1322              if (h!=NULL) rSetHdl(h,TRUE);
1323              else
1324              {
1325                Werror("cannot find the name of the basering %s",n);
1326                $2.CleanUp();
1327                YYERROR;
1328              }
1329              $2.CleanUp();
1330            }
1331            else
1332            {
1333              Werror("%s is no name of a ring/qring",n);
1334              $2.CleanUp();
1335              YYERROR;
1336            }
1337          }
1338        ;
1339
1340typecmd:
1341        TYPE_CMD expr
1342          {
1343            if ($2.rtyp!=IDHDL) MYYERROR("identifier expected");
1344            #ifdef SIC
1345            if (sic)
1346            {
1347            }
1348            else
1349            #endif
1350            {
1351              idhdl h = (idhdl)$2.data;
1352              type_cmd(h);
1353            }
1354          }
1355        | exprlist
1356          {
1357            //Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
1358            #ifdef SIQ
1359            if ($1.rtyp!=COMMAND)
1360            {
1361            #endif
1362              if ($1.Typ()==UNKNOWN)
1363              {
1364                if ($1.name!=NULL)
1365                {
1366                  Werror("`%s` is undefined",$1.name);
1367                  FreeL((ADDRESS)$1.name);
1368                }
1369                YYERROR;
1370              }
1371            #ifdef SIQ
1372            }
1373            #endif
1374            $1.Print(&sLastPrinted);
1375            $1.CleanUp();
1376          }
1377        ;
1378
1379/* --------------------------------------------------------------------*/
1380/* section of flow control                                             */
1381/* --------------------------------------------------------------------*/
1382
1383ifcmd: IF_CMD '(' expr ')' BLOCKTOK
1384          {
1385            #ifdef SIC
1386            if (sic)
1387            {
1388              //egPrint(IF_CMD,1,"if, 1\n");
1389              //egPrint(&$3);
1390              newBuffer( $5, BT_if);
1391            }
1392            else
1393            #endif
1394            {
1395              int i; TESTSETINT($3,i);
1396              if (i!=0)
1397              {
1398                newBuffer( $5, BT_if);
1399                //printf("if:new level %d\n",voice);
1400              }
1401              else
1402              {
1403                FreeL((ADDRESS)$5);
1404                ifswitch[voice]=1;
1405                //printf("if:(0):set ifsw=1 in voice %d\n",voice);
1406              }
1407            }
1408          }
1409        | ELSE_CMD BLOCKTOK
1410          {
1411            #ifdef SIC
1412            if (sic)
1413            {
1414            //egPrint(ELSE_CMD,0,"op: else, 0\n");
1415            newBuffer( $2, BT_else);
1416            }
1417            else
1418            #endif
1419            {
1420              if (ifswitch[voice]==1)
1421              {
1422                ifswitch[voice]=0;
1423                newBuffer( $2, BT_else);
1424              }
1425              else
1426              {
1427                if (ifswitch[voice]!=2)
1428                {
1429                  char *s=$2+strlen($2)-1;
1430                  while ((*s=='\0')||(*s=='\n')) s--;
1431                  s[1]='\0';
1432                  Warn("`else` without `if` in level %d",myynest);
1433                }
1434                FreeL((ADDRESS)$2);
1435              }
1436              ifswitch[voice]=0;
1437            }
1438          }
1439        | IF_CMD '(' expr ')' BREAK_CMD
1440          {
1441            #ifdef SIC
1442            if (sic)
1443            {
1444              //egPrint(IFBREAK,1,"ifbreak, 1\n");
1445              //egPrint(&$3);
1446            }
1447            else
1448            #endif
1449            {
1450              int i; TESTSETINT($3,i);
1451              if (i)
1452              {
1453                if (exitBuffer(BT_break)) YYERROR;
1454              }
1455              ifswitch[voice]=0;
1456            }
1457          }
1458        | BREAK_CMD
1459          {
1460            #ifdef SIC
1461            if (sic)
1462            {
1463            }
1464            else
1465            #endif
1466            {
1467              if (exitBuffer(BT_break)) YYERROR;
1468              ifswitch[voice]=0;
1469            }
1470          }
1471        | CONTINUE_CMD
1472          {
1473            #ifdef SIC
1474            if (sic)
1475            {
1476            }
1477            else
1478            #endif
1479            {
1480              contBuffer(BT_break);
1481              ifswitch[voice]=0;
1482            }
1483          }
1484      ;
1485
1486whilecmd:
1487        WHILE_CMD STRINGTOK BLOCKTOK
1488          {
1489            /* -> if(!$2) break; $3; continue;*/
1490            char * s = (char *)AllocL( strlen($2) + strlen($3) + 36);
1491            sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,$2,$3);
1492            newBuffer(s,BT_break);
1493            FreeL((ADDRESS)$2);
1494            FreeL((ADDRESS)$3);
1495          }
1496        ;
1497
1498forcmd:
1499        FOR_CMD STRINGTOK STRINGTOK STRINGTOK BLOCKTOK
1500          {
1501            /* $2 */
1502            /* if (!$3) break; $5; $4; continue; */
1503            char * s = (char *)AllocL( strlen($3)+strlen($4)+strlen($5)+36);
1504            sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
1505                   ,$3,$5,$4);
1506            FreeL((ADDRESS)$3);
1507            FreeL((ADDRESS)$4);
1508            FreeL((ADDRESS)$5);
1509            newBuffer(s,BT_break);
1510            s = (char *)AllocL( strlen($2) + 3);
1511            sprintf(s,"%s;\n",$2);
1512            FreeL((ADDRESS)$2);
1513            newBuffer(s,BT_if);
1514          }
1515        ;
1516
1517proccmd:
1518        PROC_CMD extendedid BLOCKTOK
1519          {
1520            #ifdef SIC
1521            if (sic)
1522            {
1523              FreeL((ADDRESS)$2);
1524              FreeL((ADDRESS)$3);
1525              MYYERROR("not implemented");
1526            }
1527            #endif
1528            idhdl h = enterid($2,myynest,PROC_CMD,&idroot,FALSE);
1529            if (h==NULL) {FreeL((ADDRESS)$3); YYERROR;}
1530            IDSTRING(h) = (char *)AllocL(strlen($3)+31);
1531            sprintf(IDSTRING(h),"parameter list #;\n%s;return();\n\n",$3);
1532            FreeL((ADDRESS)$3);
1533          }
1534        | PROC_CMD extendedid '=' expr ';'
1535          {
1536            #ifdef SIC
1537            if (sic)
1538            {
1539              $4.CleanUp();
1540              FreeL((ADDRESS)$2);
1541              MYYERROR("not implemented");
1542            }
1543            #endif
1544            if ($4.Typ()!=STRING_CMD)
1545              MYYERROR("string expression expected");
1546            idhdl h = enterid($2,myynest,PROC_CMD,&idroot,FALSE);
1547            if (h==NULL) YYERROR;
1548            IDSTRING(h) = (char *)$4.CopyD();
1549            $4.CleanUp();
1550          }
1551        | PROC_DEF STRINGTOK BLOCKTOK
1552          {
1553            idhdl h = enterid($1,myynest,PROC_CMD,&idroot,FALSE);
1554            if (h==NULL)
1555            {
1556              FreeL((ADDRESS)$2);
1557              FreeL((ADDRESS)$3);
1558              YYERROR;
1559            }
1560            char *args=iiProcArgs($2,FALSE);
1561            FreeL((ADDRESS)$2);
1562            IDSTRING(h) = (char *)AllocL(strlen($3)+strlen(args)+14);
1563            sprintf(IDSTRING(h),"%s\n%s;RETURN();\n\n",args,$3);
1564            FreeL((ADDRESS)args);
1565            FreeL((ADDRESS)$3);
1566            //Print(">>%s<<\n",IDSTRING(h));
1567          }
1568        ;
1569
1570parametercmd:
1571        PARAMETER declare_ip_variable
1572          {
1573            //Print("par:%s, %d\n",$2.Name(),$2.Typ());
1574            yylineno--;
1575            #ifdef SIC
1576            if (sic)
1577            {
1578              //egParameter(&$2);
1579            }
1580            else
1581            #endif
1582            {
1583              if (iiParameter(&$2)) YYERROR;
1584            }
1585          }
1586        | PARAMETER expr
1587          {
1588            //Print("par:%s, %d\n",$2.Name(),$2.Typ());
1589            sleftv tmp_expr;
1590            #ifdef SIC
1591            if (sic)
1592            {
1593              if (iiDeclCommand(&tmp_expr,&$2,myynest,DEF_CMD,&idroot))
1594                YYERROR;
1595              //egParameter(&$2);
1596            }
1597            else
1598            #endif
1599            {
1600              if ((iiDeclCommand(&tmp_expr,&$2,myynest,DEF_CMD,&idroot))
1601              || (iiParameter(&tmp_expr)))
1602                YYERROR;
1603            }
1604          }
1605        ;
1606
1607returncmd:
1608        RETURN '(' exprlist ')'
1609          {
1610            iiRETURNEXPR[myynest].Copy(&$3);
1611            $3.CleanUp();
1612            if (exitBuffer(BT_proc)) YYERROR;
1613          }
1614        | RETURN '(' ')'
1615          {
1616            iiRETURNEXPR[myynest].Init();
1617            iiRETURNEXPR[myynest].rtyp=NONE;
1618            if (exitBuffer(BT_proc)&&($1!=END_PROC)) YYERROR;
1619            if ($1==END_PROC) YYACCEPT;
1620          }
1621        ;
Note: See TracBrowser for help on using the repository browser.