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

spielwiese
Last change on this file since 6ae4f5 was 6ae4f5, checked in by Hans Schönemann <hannes@…>, 26 years ago
* hannes: - corrected scanner.l: parsing of strings in blocks: if (1) { write("","}"); } - corrected ipassign.cc: assignment of "dummy" types: DEF, NONE - corrected sleftv::Print(_), initialisation of _ - added conversion int->def - added CopyD(DEF) - in insert(..): object should not be of type NONE (lists.cc:lInsert0) - added int*intvec, int*intmat to iparith.cc git-svn-id: file:///usr/local/Singular/svn/trunk@145 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 40.6 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: grammar.y,v 1.6 1997-04-09 12:19:43 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 '=' { $$ = $1; }
781        ;
782
783
784extendedid:
785        UNKNOWN_IDENT
786        | '`' expr '`'
787          {
788            if ($2.Typ()!=STRING_CMD)
789            {
790              MYYERROR("string expression expected");
791            }
792            $$ = (char *)$2.CopyD();
793            $2.CleanUp();
794          }
795        ;
796
797currring_lists:
798        IDEAL_CMD | MODUL_CMD
799        /* put variables into the current ring */
800        ;
801
802declare_ip_variable:
803        ROOT_DECL elemexpr
804          {
805            if (iiDeclCommand(&$$,&$2,myynest,$1,&idroot)) YYERROR;
806          }
807        | ROOT_DECL_LIST elemexpr
808          {
809            if (iiDeclCommand(&$$,&$2,myynest,$1,&idroot)) YYERROR;
810          }
811        | RING_DECL elemexpr
812          {
813            #ifdef SIC
814            if ((sic) && (currRing==NULL))
815            {
816              if (iiDeclCommand(&$$,&$2,myynest,$1,NULL)) YYERROR;
817            }
818            else
819            #endif
820            {
821              if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
822            }
823          }
824        | currring_lists elemexpr
825          {
826            #ifdef SIC
827            if ((sic) && (currRing==NULL))
828            {
829              if (iiDeclCommand(&$$,&$2,myynest,$1,NULL)) YYERROR;
830            }
831            else
832            #endif
833            {
834              if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
835            }
836          }
837        | MATRIX_CMD elemexpr '[' expr ']' '[' expr ']'
838          {
839            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
840            #ifdef SIC
841            if (sic)
842            {
843            }
844            else
845            #endif
846            {
847              int r; TESTSETINT($4,r);
848              int c; TESTSETINT($7,c);
849              if (r < 1)
850                MYYERROR("rows must be greater than 0");
851              if (c < 0)
852                MYYERROR("cols must be greater than -1");
853              leftv v=&$$;
854              //while (v->next!=NULL) { v=v->next; }
855              idhdl h=(idhdl)v->data;
856              idDelete(&IDIDEAL(h));
857              IDMATRIX(h) = mpNew(r,c);
858              if (IDMATRIX(h)==NULL) YYERROR;
859            }
860          }
861        | MATRIX_CMD elemexpr
862          {
863            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot))) YYERROR;
864          }
865        | INTMAT_CMD elemexpr '[' expr ']' '[' expr ']'
866          {
867            if (iiDeclCommand(&$$,&$2,myynest,$1,&idroot)) YYERROR;
868            #ifdef SIC
869            if (sic)
870            {
871            }
872            else
873            #endif
874            {
875              int r; TESTSETINT($4,r);
876              int c; TESTSETINT($7,c);
877              if (r < 1)
878                MYYERROR("rows must be greater than 0");
879              if (c < 0)
880                MYYERROR("cols must be greater than -1");
881              leftv v=&$$;
882              //while (v->next!=NULL) { v=v->next; }
883              idhdl h=(idhdl)v->data;
884              delete IDINTVEC(h);
885              IDINTVEC(h) = new intvec(r,c,0);
886              if (IDINTVEC(h)==NULL) YYERROR;
887            }
888          }
889        | INTMAT_CMD elemexpr
890          {
891            if (iiDeclCommand(&$$,&$2,myynest,$1,&idroot)) YYERROR;
892            leftv v=&$$;
893            idhdl h;
894            do
895            {
896               h=(idhdl)v->data;
897               delete IDINTVEC(h);
898               IDINTVEC(h) = new intvec(1,1,0);
899               v=v->next;
900            } while (v!=NULL);
901          }
902        | declare_ip_variable ',' elemexpr
903          {
904            int t=$1.Typ();
905            sleftv r;
906            memset(&r,0,sizeof(sleftv));
907            if ((BEGIN_RING<t) && (t<END_RING))
908            {
909              if (iiDeclCommand(&r,&$3,myynest,t,&(currRing->idroot))) YYERROR;
910            }
911            else
912            {
913              if (iiDeclCommand(&r,&$3,myynest,t,&idroot)) YYERROR;
914            }
915            leftv v=&$1;
916            while (v->next!=NULL) v=v->next;
917            v->next=(leftv)Alloc(sizeof(sleftv));
918            memcpy(v->next,&r,sizeof(sleftv));
919            $$=$1;
920          }
921        ;
922
923stringexpr:
924        STRINGTOK
925        | LIB_CMD
926          {
927            idhdl h = ggetid( "LIB" );
928            if (h==NULL) YYERROR;
929            $$ = mstrdup(IDSTRING(h));
930          }
931        ;
932
933rlist:
934        expr
935        | '(' expr ',' exprlist ')'
936          {
937            leftv v = &$2;
938            while (v->next!=NULL)
939            {
940              v=v->next;
941            }
942            v->next = (leftv)Alloc(sizeof(sleftv));
943            memcpy(v->next,&($4),sizeof(sleftv));
944            $$ = $2;
945          }
946        ;
947
948ordername:
949        UNKNOWN_IDENT
950        {
951          if (!($$=rOrderName($1)))
952            YYERROR;
953        }
954        ;
955
956orderelem:
957        ordername
958          {
959            memset(&$$,0,sizeof($$));
960            intvec *iv = new intvec(2);
961            (*iv)[0] = 1;
962            (*iv)[1] = $1;
963            $$.rtyp = INTVEC_CMD;
964            $$.data = (void *)iv;
965          }
966        | ordername '(' exprlist ')'
967          {
968            memset(&$$,0,sizeof($$));
969            leftv sl = &$3;
970            int slLength;
971            {
972              slLength =  exprlist_length(sl);
973              int l = 2 +  slLength;
974              intvec *iv = new intvec(l);
975              (*iv)[0] = slLength;
976              (*iv)[1] = $1;
977
978              int i = 2;
979              while ((i<l) && (sl!=NULL))
980              {
981                if (sl->Typ() == INT_CMD)
982                {
983                  (*iv)[i++] = (int)(sl->Data());
984                }
985                else if ((sl->Typ() == INTVEC_CMD)
986                ||(sl->Typ() == INTMAT_CMD))
987                {
988                  intvec *ivv = (intvec *)(sl->Data());
989                  int ll = 0,l = ivv->length();
990                  for (; l>0; l--)
991                  {
992                    (*iv)[i++] = (*ivv)[ll++];
993                  }
994                }
995                else
996                {
997                  delete iv;
998                  $3.CleanUp();
999                  MYYERROR("wrong type in ordering");
1000                }
1001                sl = sl->next;
1002              }
1003              $$.rtyp = INTVEC_CMD;
1004              $$.data = (void *)iv;
1005            }
1006            $3.CleanUp();
1007          }
1008        ;
1009
1010OrderingList:
1011        orderelem
1012        |  orderelem ',' OrderingList
1013          {
1014            $$ = $1;
1015            $$.next = (sleftv *)Alloc(sizeof(sleftv));
1016            memcpy($$.next,&$3,sizeof(sleftv));
1017          }
1018        ;
1019
1020ordering:
1021        orderelem
1022        | '(' OrderingList ')'
1023          {
1024            $$ = $2;
1025          }
1026        ;
1027
1028cmdeq:  '='
1029          {
1030            expected_parms = TRUE;
1031          }
1032        ;
1033
1034
1035/* --------------------------------------------------------------------*/
1036/* section of pure commands                                            */
1037/* --------------------------------------------------------------------*/
1038
1039executecmd:
1040        EXECUTE_CMD expr
1041          {
1042            #ifdef SIC
1043            if (sic) MYYERROR("execute not supported");
1044            #endif
1045            if ($2.Typ() == STRING_CMD)
1046            {
1047              char * s = (char *)AllocL(strlen((char *)$2.Data()) + 4);
1048              strcpy( s, (char *)$2.Data());
1049              strcat( s, "\n;\n");
1050              $2.CleanUp();
1051              newBuffer(s,BT_execute);
1052            }
1053            else
1054            {
1055              MYYERROR("string expected");
1056            }
1057          }
1058        ;
1059
1060filecmd:
1061        '<' stringexpr ';'
1062          { if (iiPStart(NULL,$2,NULL)) YYERROR; }
1063        ;
1064
1065helpcmd:
1066        HELP_CMD STRINGTOK
1067          {
1068            singular_help($2,FALSE);
1069            FreeL((ADDRESS)$2);
1070          }
1071        | HELP_CMD
1072          {
1073#ifdef buildin_help
1074            char *s=(char *)Alloc(10);
1075            strcpy(s,"index");
1076            singular_help(s,FALSE);
1077            Free((ADDRESS)s,10);
1078#else
1079            system("info singular");
1080#endif
1081          }
1082        | EXAMPLE_CMD STRINGTOK
1083          {
1084            singular_help($2,TRUE);
1085            FreeL((ADDRESS)$2);
1086            if (inerror) YYERROR;
1087          }
1088        ;
1089
1090exportcmd:
1091        EXPORT_CMD exprlist
1092        {
1093          if (iiExport(&$2,0)) YYERROR;
1094        }
1095        | EXPORT_CMD exprlist extendedid expr
1096        {
1097          if ((strcmp($3,"to")!=0) ||
1098          (($4.Typ()!=PACKAGE_CMD) && ($4.Typ()!=INT_CMD)))
1099            MYYERROR("export <id> to <package|int>");
1100          FreeL((ADDRESS)$3);
1101          if ($4.Typ()==INT_CMD)
1102          {
1103            if (iiExport(&$2,((int)$4.Data())-1)) YYERROR;
1104          }
1105          else
1106          {
1107            if (iiExport(&$2,0,IDPACKAGE((idhdl)$4.data)->idroot))
1108              YYERROR;
1109          }
1110        }
1111        ;
1112
1113killcmd:
1114        KILL_CMD kill_any_identifier {;}
1115        ;
1116
1117kill_any_identifier:
1118        elemexpr
1119          {
1120            leftv v=&$1;
1121            do
1122            {
1123              if (v->rtyp!=IDHDL)
1124              {
1125                if (v->name!=NULL) Werror("`%s` is undefined in kill",v->name);
1126                else               WerrorS("kill what ?");
1127              }
1128              else
1129              {
1130                killhdl((idhdl)v->data);
1131              }
1132              v=v->next;
1133            } while (v!=NULL);
1134            $1.CleanUp();
1135          }
1136        | kill_any_identifier ',' elemexpr
1137          {
1138            if ($3.rtyp!=IDHDL)
1139            {
1140              if ($3.name!=NULL) Werror("`%s` is undefined",$3.name);
1141              else               WerrorS("kill what ?");
1142            }
1143            else
1144            {
1145              killhdl((idhdl)$3.data);
1146            }
1147            $3.CleanUp();
1148          }
1149        ;
1150
1151listcmd:
1152        LISTVAR_CMD '(' ROOT_DECL ')'
1153          {
1154            list_cmd($3,NULL,"// ",TRUE);
1155          }
1156        | LISTVAR_CMD '(' ROOT_DECL_LIST ')'
1157          {
1158            list_cmd($3,NULL,"// ",TRUE);
1159          }
1160        | LISTVAR_CMD '(' RING_DECL ')'
1161          {
1162            if ($3==QRING_CMD) $3=RING_CMD;
1163            list_cmd($3,NULL,"// ",TRUE);
1164          }
1165        | LISTVAR_CMD '(' currring_lists ')'
1166          {
1167            list_cmd($3,NULL,"// ",TRUE);
1168          }
1169        | LISTVAR_CMD '(' RING_CMD ')'
1170          {
1171            #ifdef SIC
1172            if (sic) MYYERROR("not implemented yet");
1173            #endif
1174            list_cmd(RING_CMD,NULL,"// ",TRUE);
1175          }
1176        | LISTVAR_CMD '(' MATRIX_CMD ')'
1177          {
1178            #ifdef SIC
1179            if (sic) MYYERROR("not implemented yet");
1180            #endif
1181            list_cmd(MATRIX_CMD,NULL,"// ",TRUE);
1182           }
1183        | LISTVAR_CMD '(' INTMAT_CMD ')'
1184          {
1185            #ifdef SIC
1186            if (sic) MYYERROR("not implemented yet");
1187            #endif
1188            list_cmd(INTMAT_CMD,NULL,"// ",TRUE);
1189          }
1190        | LISTVAR_CMD '(' PROC_CMD ')'
1191          {
1192            #ifdef SIC
1193            if (sic) MYYERROR("not implemented yet");
1194            #endif
1195            list_cmd(PROC_CMD,NULL,"// ",TRUE);
1196          }
1197        | LISTVAR_CMD '(' elemexpr ')'
1198          {
1199            #ifdef SIC
1200            if (sic) MYYERROR("not implemented yet");
1201            #endif
1202            list_cmd(0,$3.Name(),"// ",TRUE);
1203            $3.CleanUp();
1204          }
1205        | LISTVAR_CMD '(' ')'
1206          {
1207            #ifdef SIC
1208            if (sic) MYYERROR("not implemented yet");
1209            #endif
1210            list_cmd(-1,NULL,"// ",TRUE);
1211          }
1212        ;
1213
1214ringcmd1:
1215       RING_CMD { noringvars = TRUE; }
1216       ;
1217
1218ringcmd:
1219        ringcmd1
1220          elemexpr cmdeq
1221          rlist     ','      /* description of coeffs */
1222          rlist     ','      /* var names */
1223          ordering           /* list of (multiplier ordering (weight(s))) */
1224          {
1225            #ifdef SIC
1226            if (sic)
1227            {
1228            }
1229            #endif
1230            //noringvars = FALSE;
1231            if(!rInit($2.name,        /* ringname */
1232                     &$4,            /* characteristik and list of parameters*/
1233                     &$6,            /* names of ringvariables */
1234                     &$8,            /* ordering */
1235                     FALSE))         /* is not a dring */
1236            {
1237              MYYERROR("cannot make ring");
1238            }
1239            $4.CleanUp();
1240            $6.CleanUp();
1241            $8.CleanUp();
1242          }
1243        | ringcmd1 elemexpr
1244          {
1245            //noringvars = FALSE;
1246            if (!inerror) rDefault($2.name);
1247          }
1248        | DRING_CMD { noringvars = TRUE; }
1249          elemexpr cmdeq
1250          rlist     ','       /* description of coeffs */
1251          rlist     ','       /* var names */
1252          ordering           /* list of (multiplier ordering (weight(s))) */
1253          {
1254            #ifdef DRING
1255            idhdl h;
1256            //noringvars = FALSE;
1257            if(!(h=rInit($3.name,    /* ringname */
1258                     &$5,            /* characteristik and list of parameters*/
1259                     &$7,            /* names of ringvariables */
1260                     &$9,            /* ordering */
1261                     TRUE)))         /* is a dring */
1262            {
1263              YYERROR;
1264            }
1265            setFlag(h,FLAG_DRING);
1266            rDSet();
1267            $5.CleanUp();
1268            $7.CleanUp();
1269            $9.CleanUp();
1270            #endif
1271          }
1272        ;
1273
1274scriptcmd:
1275         LIB_CMD stringexpr
1276          {
1277            if (iiLibCmd($2)) YYERROR;
1278          }
1279        ;
1280
1281setrings:  SETRING_CMD | KEEPRING_CMD ;
1282
1283setringcmd:
1284        setrings expr
1285          {
1286            if (($1==KEEPRING_CMD) && (myynest==0))
1287               MYYERROR("only inside a proc allowed");
1288            const char * n=$2.Name();
1289            if ((($2.Typ()==RING_CMD)||($2.Typ()==QRING_CMD))
1290            && ($2.rtyp==IDHDL))
1291            {
1292              idhdl h=(idhdl)$2.data;
1293              if ($2.e!=NULL) h=rFindHdl((ring)$2.Data(),NULL);
1294              if ($1==KEEPRING_CMD)
1295              {
1296                if (h!=NULL)
1297                {
1298                  if (IDLEV(h)!=0)
1299                  {
1300                    if (iiExport(&$2,myynest-1)) YYERROR;
1301                    //if (TEST_OPT_KEEPVARS)
1302                    //{
1303                      idhdl p=IDRING(h)->idroot;
1304                      int prevlev=myynest-1;
1305                      while (p!=NULL)
1306                      {
1307                        if (IDLEV(p)==myynest) IDLEV(p)=prevlev;
1308                        p=IDNEXT(p);
1309                      }
1310                    //}
1311                  }
1312                  iiLocalRing[myynest-1]=IDRING(h);
1313                }
1314                else
1315                {
1316                  Werror("%s is no identifier",n);
1317                  $2.CleanUp();
1318                  YYERROR;
1319                }
1320              }
1321              if (h!=NULL) rSetHdl(h,TRUE);
1322              else
1323              {
1324                Werror("cannot find the name of the basering %s",n);
1325                $2.CleanUp();
1326                YYERROR;
1327              }
1328              $2.CleanUp();
1329            }
1330            else
1331            {
1332              Werror("%s is no name of a ring/qring",n);
1333              $2.CleanUp();
1334              YYERROR;
1335            }
1336          }
1337        ;
1338
1339typecmd:
1340        TYPE_CMD expr
1341          {
1342            if ($2.rtyp!=IDHDL) MYYERROR("identifier expected");
1343            #ifdef SIC
1344            if (sic)
1345            {
1346            }
1347            else
1348            #endif
1349            {
1350              idhdl h = (idhdl)$2.data;
1351              type_cmd(h);
1352            }
1353          }
1354        | exprlist
1355          {
1356            //Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
1357            #ifdef SIQ
1358            if ($1.rtyp!=COMMAND)
1359            {
1360            #endif
1361              if ($1.Typ()==UNKNOWN)
1362              {
1363                if ($1.name!=NULL)
1364                {
1365                  Werror("`%s` is undefined",$1.name);
1366                  FreeL((ADDRESS)$1.name);
1367                }
1368                YYERROR;
1369              }
1370            #ifdef SIQ
1371            }
1372            #endif
1373            $1.Print(&sLastPrinted);
1374            $1.CleanUp();
1375          }
1376        ;
1377
1378/* --------------------------------------------------------------------*/
1379/* section of flow control                                             */
1380/* --------------------------------------------------------------------*/
1381
1382ifcmd: IF_CMD '(' expr ')' BLOCKTOK
1383          {
1384            #ifdef SIC
1385            if (sic)
1386            {
1387              //egPrint(IF_CMD,1,"if, 1\n");
1388              //egPrint(&$3);
1389              newBuffer( $5, BT_if);
1390            }
1391            else
1392            #endif
1393            {
1394              int i; TESTSETINT($3,i);
1395              if (i!=0)
1396              {
1397                newBuffer( $5, BT_if);
1398                //printf("if:new level %d\n",voice);
1399              }
1400              else
1401              {
1402                FreeL((ADDRESS)$5);
1403                ifswitch[voice]=1;
1404                //printf("if:(0):set ifsw=1 in voice %d\n",voice);
1405              }
1406            }
1407          }
1408        | ELSE_CMD BLOCKTOK
1409          {
1410            #ifdef SIC
1411            if (sic)
1412            {
1413            //egPrint(ELSE_CMD,0,"op: else, 0\n");
1414            newBuffer( $2, BT_else);
1415            }
1416            else
1417            #endif
1418            {
1419              if (ifswitch[voice]==1)
1420              {
1421                ifswitch[voice]=0;
1422                newBuffer( $2, BT_else);
1423              }
1424              else
1425              {
1426                if (ifswitch[voice]!=2)
1427                {
1428                  char *s=$2+strlen($2)-1;
1429                  while ((*s=='\0')||(*s=='\n')) s--;
1430                  s[1]='\0';
1431                  Warn("`else` without `if` in level %d",myynest);
1432                }
1433                FreeL((ADDRESS)$2);
1434              }
1435              ifswitch[voice]=0;
1436            }
1437          }
1438        | IF_CMD '(' expr ')' BREAK_CMD
1439          {
1440            #ifdef SIC
1441            if (sic)
1442            {
1443              //egPrint(IFBREAK,1,"ifbreak, 1\n");
1444              //egPrint(&$3);
1445            }
1446            else
1447            #endif
1448            {
1449              int i; TESTSETINT($3,i);
1450              if (i)
1451              {
1452                if (exitBuffer(BT_break)) YYERROR;
1453              }
1454              ifswitch[voice]=0;
1455            }
1456          }
1457        | BREAK_CMD
1458          {
1459            #ifdef SIC
1460            if (sic)
1461            {
1462            }
1463            else
1464            #endif
1465            {
1466              if (exitBuffer(BT_break)) YYERROR;
1467              ifswitch[voice]=0;
1468            }
1469          }
1470        | CONTINUE_CMD
1471          {
1472            #ifdef SIC
1473            if (sic)
1474            {
1475            }
1476            else
1477            #endif
1478            {
1479              contBuffer(BT_break);
1480              ifswitch[voice]=0;
1481            }
1482          }
1483      ;
1484
1485whilecmd:
1486        WHILE_CMD STRINGTOK BLOCKTOK
1487          {
1488            /* -> if(!$2) break; $3; continue;*/
1489            char * s = (char *)AllocL( strlen($2) + strlen($3) + 36);
1490            sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,$2,$3);
1491            newBuffer(s,BT_break);
1492            FreeL((ADDRESS)$2);
1493            FreeL((ADDRESS)$3);
1494          }
1495        ;
1496
1497forcmd:
1498        FOR_CMD STRINGTOK STRINGTOK STRINGTOK BLOCKTOK
1499          {
1500            /* $2 */
1501            /* if (!$3) break; $5; $4; continue; */
1502            char * s = (char *)AllocL( strlen($3)+strlen($4)+strlen($5)+36);
1503            sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
1504                   ,$3,$5,$4);
1505            FreeL((ADDRESS)$3);
1506            FreeL((ADDRESS)$4);
1507            FreeL((ADDRESS)$5);
1508            newBuffer(s,BT_break);
1509            s = (char *)AllocL( strlen($2) + 3);
1510            sprintf(s,"%s;\n",$2);
1511            FreeL((ADDRESS)$2);
1512            newBuffer(s,BT_if);
1513          }
1514        ;
1515
1516proccmd:
1517        PROC_CMD extendedid BLOCKTOK
1518          {
1519            #ifdef SIC
1520            if (sic)
1521            {
1522              FreeL((ADDRESS)$2);
1523              FreeL((ADDRESS)$3);
1524              MYYERROR("not implemented");
1525            }
1526            #endif
1527            idhdl h = enterid($2,myynest,PROC_CMD,&idroot,FALSE);
1528            if (h==NULL) {FreeL((ADDRESS)$3); YYERROR;}
1529            IDSTRING(h) = (char *)AllocL(strlen($3)+31);
1530            sprintf(IDSTRING(h),"parameter list #;\n%s;return();\n\n",$3);
1531            FreeL((ADDRESS)$3);
1532          }
1533        | PROC_CMD elemexpr '=' expr ';'
1534          {
1535            #ifdef SIC
1536            if (sic)
1537            {
1538              $4.CleanUp();
1539              FreeL((ADDRESS)$2);
1540              MYYERROR("not implemented");
1541            }
1542            #endif
1543            sleftv v;
1544            if ((iiDeclCommand(&v,&$2,myynest,PROC_CMD,&idroot,FALSE))
1545            || (iiAssign(&v,&($4)))) YYERROR;
1546          }
1547        | PROC_DEF STRINGTOK BLOCKTOK
1548          {
1549            idhdl h = enterid($1,myynest,PROC_CMD,&idroot,FALSE);
1550            if (h==NULL)
1551            {
1552              FreeL((ADDRESS)$2);
1553              FreeL((ADDRESS)$3);
1554              YYERROR;
1555            }
1556            char *args=iiProcArgs($2,FALSE);
1557            FreeL((ADDRESS)$2);
1558            IDSTRING(h) = (char *)AllocL(strlen($3)+strlen(args)+14);
1559            sprintf(IDSTRING(h),"%s\n%s;RETURN();\n\n",args,$3);
1560            FreeL((ADDRESS)args);
1561            FreeL((ADDRESS)$3);
1562            //Print(">>%s<<\n",IDSTRING(h));
1563          }
1564        ;
1565
1566parametercmd:
1567        PARAMETER declare_ip_variable
1568          {
1569            //Print("par:%s, %d\n",$2.Name(),$2.Typ());
1570            yylineno--;
1571            #ifdef SIC
1572            if (sic)
1573            {
1574              //egParameter(&$2);
1575            }
1576            else
1577            #endif
1578            {
1579              if (iiParameter(&$2)) YYERROR;
1580            }
1581          }
1582        | PARAMETER expr
1583          {
1584            //Print("par:%s, %d\n",$2.Name(),$2.Typ());
1585            sleftv tmp_expr;
1586            #ifdef SIC
1587            if (sic)
1588            {
1589              if (iiDeclCommand(&tmp_expr,&$2,myynest,DEF_CMD,&idroot))
1590                YYERROR;
1591              //egParameter(&$2);
1592            }
1593            else
1594            #endif
1595            {
1596              if ((iiDeclCommand(&tmp_expr,&$2,myynest,DEF_CMD,&idroot))
1597              || (iiParameter(&tmp_expr)))
1598                YYERROR;
1599            }
1600          }
1601        ;
1602
1603returncmd:
1604        RETURN '(' exprlist ')'
1605          {
1606            iiRETURNEXPR[myynest].Copy(&$3);
1607            $3.CleanUp();
1608            if (exitBuffer(BT_proc)) YYERROR;
1609          }
1610        | RETURN '(' ')'
1611          {
1612            iiRETURNEXPR[myynest].Init();
1613            iiRETURNEXPR[myynest].rtyp=NONE;
1614            if (exitBuffer(BT_proc)&&($1!=END_PROC)) YYERROR;
1615            if ($1==END_PROC) YYACCEPT;
1616          }
1617        ;
Note: See TracBrowser for help on using the repository browser.