source: git/Singular/grammar.y @ 6f2edc

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