source: git/Singular/grammar.y @ 2830f8

spielwiese
Last change on this file since 2830f8 was 2830f8, checked in by Hans Schönemann <hannes@…>, 27 years ago
* hannes: removed test_int from grammar.y git-svn-id: file:///usr/local/Singular/svn/trunk@386 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 40.5 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: grammar.y,v 1.11 1997-06-11 13:26:10 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> FOR_CMD
243%token <i> IF_CMD
244%token <i> SYS_BREAK
245%token <i> WHILE_CMD
246%token <i> RETURN
247%token <i> END_PROC
248%token <i> PARAMETER
249
250/* system variables */
251%token <i> SYSVAR
252
253%type <name> extendedid
254%type <lv>   rlist ordering OrderingList orderelem
255%type <name> stringexpr
256%type <lv>   expr elemexpr exprlist expr_arithmetic
257%type <lv>   declare_ip_variable left_value
258%type <i>    ordername
259%type <i>    cmdeq
260%type <i>    currring_lists
261%type <i>    setrings
262%type <i>    ringcmd1
263
264%type <i>    '=' '<' '>' '+' '-'
265%type <i>    '*' '/' '[' ']' '.' '^' ',' ';'
266
267
268/*%nonassoc '=' PLUSEQUAL DOTDOT*/
269%nonassoc '=' DOTDOT
270%left '|' '&'
271%left EQUAL_EQUAL NOTEQUAL
272%left '<' '>' GE LE
273%left '+' '-'
274%left '*' '/' '%'
275%left UMINUS
276%left  '^'
277%left '[' ']'
278%left '(' ')'
279%left PLUSPLUS
280%left MINUSMINUS
281
282%%
283lines:
284        /**/
285        | lines pprompt
286          {
287            if (timerv
288            #ifdef SIC
289            && (!sic)
290            #endif
291            )
292            {
293              writeTime("used time:");
294              startTimer();
295            }
296            #ifdef HAVE_RTIMER
297            if (rtimerv
298            #ifdef SIC
299            && (!sic)
300            #endif
301            )
302            {
303              writeRTime("used real time:");
304              startRTimer();
305            }
306            #endif
307            prompt_char = '>';
308            currid = NULL;
309            if (errorreported)
310            {
311              yyerror("");
312            }
313            if (inerror==2) PrintLn();
314            errorreported = inerror = cmdtok = 0;
315            lastreserved=NULL;
316            expected_parms=FALSE;
317            noringvars = FALSE;
318          }
319        ;
320
321pprompt:
322        flowctrl                       /* if, while, for etc */
323        | command ';'                  /* commands returning no value */
324          {ifswitch[voice]=0;}
325        | assign  ';'                  /* general assignment */
326          {ifswitch[voice]=0;}
327        | parametercmd ';'             /* proc parameter assignments */
328          {yylineno--;ifswitch[voice]=0;}
329        | declare_ip_variable ';'      /* default initialization */
330          { $1.CleanUp(); ifswitch[voice]=0;}
331        | filecmd
332          {ifswitch[voice]=0;}
333        | returncmd
334          {
335            #ifdef SIC
336            if (!sic)
337            #endif
338            YYACCEPT;
339          }
340        | SYS_BREAK
341          {
342            #ifdef SIC
343            if (sic)
344              emStoreOp(SYS_BREAK,0);
345            else
346            #endif
347            {
348              ifswitch[voice]=0;
349              iiDebug();
350            }
351          }
352        | ';'                    /* ignore empty statements */
353          {ifswitch[voice]=0;}
354        | error ';'
355          {
356            #ifdef SIQ
357            siq=0;
358            #endif
359            ifswitch[voice]=0;
360            if (inerror&&($1.i<UMINUS) && ($1.i>' '))
361            {
362              // 1: yyerror called
363              // 2: scanner put actual string
364              // 3: error rule put token+\n
365              inerror=3;
366              Print(" error at token `%s`\n",iiTwoOps($1.i));
367            }
368            if (!errorreported) WerrorS("...parse error");
369            yyerror("");
370            yyerrok;
371            #ifdef SIC
372            if (sic) YYABORT;
373            #endif
374            if (myynest>0)
375            {
376              //WerrorS("leaving yyparse");
377              YYABORT;
378            }
379            else if (voice>0)
380            {
381              //WerrorS("leaving voice");
382              exitBuffer(BT_break);
383            }
384            errorreported = FALSE;
385            lastreserved=NULL;
386          }
387        ;
388
389flowctrl: ifcmd
390          | whilecmd
391          | forcmd
392          | proccmd
393            {ifswitch[voice]=0;}
394        ;
395
396command: executecmd | helpcmd | killcmd | exportcmd | listcmd
397         | ringcmd | scriptcmd | setringcmd | typecmd
398         ;
399
400assign: left_value exprlist
401          {
402            if(iiAssign(&$1,&$2)) YYERROR;
403          }
404        ;
405
406elemexpr:
407        RINGVAR
408          {
409            #ifdef SIC
410            if (!sic)
411            #endif
412              if (currRing==NULL) MYYERROR("no ring active");
413            syMake(&$$,$1);
414          }
415        | extendedid
416          {
417            syMake(&$$,$1);
418          }
419        | elemexpr '('  ')'
420          {
421            if(iiExprArith1(&$$,&$1,'(')) YYERROR;
422          }
423        | elemexpr '(' exprlist ')'
424          {
425            $1.next=(leftv)Alloc(sizeof(sleftv));
426            memcpy($1.next,&$3,sizeof(sleftv));
427            if(iiExprArithM(&$$,&$1,'(')) YYERROR;
428          }
429        | elemexpr '.' extendedid
430          {
431            idhdl r=idroot;
432            if ($1.Typ()!=PACKAGE_CMD) MYYERROR("<package>.<id> expected");
433            idroot=IDPACKAGE((idhdl)$1.data)->idroot;
434            syMake(&$$,$3);
435            idroot=r;
436          }
437        | '[' exprlist ']'
438          {
439            if (currRingHdl==NULL) MYYERROR("no ring active");
440            int j = 0;
441            memset(&$$,0,sizeof(sleftv));
442            $$.rtyp=VECTOR_CMD;
443            leftv v = &$2;
444            while (v!=NULL)
445            {
446              poly p = pOne();
447              pSetCompP(p,++j);
448              int k = (int)(v->Data());
449              if (k!=0)
450              {
451                if (v->Typ() == INT_CMD)
452                {
453                  $$.data = (void *)pAdd((poly)$$.data,pMult(p,pISet(k)));
454                }
455                else if (v->Typ() == POLY_CMD)
456                {
457                  $$.data = (void *)pAdd((poly)$$.data,pMult(p, (poly)(v->CopyD())) );
458                }
459                else
460                  MYYERROR("expected '[poly,...'");
461              }
462              else
463                pDelete1(&p);
464              v=v->next;
465            }
466            $2.CleanUp();
467          }
468        | INT_CONST
469          {
470            memset(&$$,0,sizeof($$));
471            int i = atoi($1);
472
473            /* check: out of range input */
474            int l = strlen($1)+2;
475            if (l >= MAX_INT_LEN)
476            {
477              char tmp[100];
478              sprintf(tmp,"%d",i);
479              if (strcmp(tmp,$1)!=0)
480              {
481                Werror("`%s` greater than %d(max. integer representation)"
482                       ,$1,INT_MAX);
483                YYERROR;
484              }
485            }
486            /*remember not to FreeL($1)
487            *because it is a part of the scanner buffer*/
488            $$.rtyp  = INT_CMD;
489            $$.data = (void *)i;
490          }
491        | SYSVAR
492          {
493            memset(&$$,0,sizeof($$));
494            $$.rtyp = $1;
495            $$.data = $$.Data();
496          }
497        | stringexpr
498          {
499            memset(&$$,0,sizeof($$));
500            $$.rtyp  = STRING_CMD;
501            $$.data = $1;
502          }
503        ;
504
505exprlist:
506        expr ',' exprlist
507          {
508            leftv v = &$1;
509            while (v->next!=NULL)
510            {
511              v=v->next;
512            }
513            v->next = (leftv)Alloc(sizeof(sleftv));
514            memcpy(v->next,&($3),sizeof(sleftv));
515            $$ = $1;
516          }
517        | expr
518          {
519            $$ = $1;
520          }
521        | '(' expr ',' exprlist ')'
522          {
523            leftv v = &$2;
524            while (v->next!=NULL)
525            {
526              v=v->next;
527            }
528            v->next = (leftv)Alloc(sizeof(sleftv));
529            memcpy(v->next,&($4),sizeof(sleftv));
530            $$ = $2;
531          }
532        ;
533
534expr:   expr_arithmetic
535          {
536            /*if ($1.typ == eunknown) YYERROR;*/
537            $$ = $1;
538          }
539        | elemexpr        { $$ = $1; }
540        | '(' expr ')'    { $$ = $2; }
541        | expr '[' expr ',' expr ']'
542          {
543            if(iiExprArith3(&$$,'[',&$1,&$3,&$5)) YYERROR;
544          }
545        | expr '[' expr ']'
546          {
547            if(iiExprArith2(&$$,&$1,'[',&$3)) YYERROR;
548          }
549        | ROOT_DECL '(' expr ')'
550          {
551            if(iiExprArith1(&$$,&$3,$1)) YYERROR;
552          }
553        | ROOT_DECL_LIST '(' exprlist ')'
554          {
555            if(iiExprArithM(&$$,&$3,$1)) YYERROR;
556          }
557        | ROOT_DECL_LIST '(' ')'
558          {
559            if(iiExprArithM(&$$,NULL,$1)) YYERROR;
560          }
561        | RING_DECL '(' expr ')'
562          {
563            if(iiExprArith1(&$$,&$3,$1)) YYERROR;
564          }
565        | currring_lists '(' exprlist ')'
566          {
567            if(iiExprArithM(&$$,&$3,$1)) YYERROR;
568          }
569        | currring_lists '(' ')'
570          {
571            if(iiExprArithM(&$$,NULL,$1)) YYERROR;
572          }
573        | CMD_1 '(' expr ')'
574          {
575            if(iiExprArith1(&$$,&$3,$1)) YYERROR;
576          }
577        | CMD_2 '(' expr ',' expr ')'
578          {
579            if(iiExprArith2(&$$,&$3,$1,&$5,TRUE)) YYERROR;
580          }
581        | CMD_3 '(' expr ',' expr ',' expr ')'
582          {
583            if(iiExprArith3(&$$,$1,&$3,&$5,&$7)) YYERROR;
584          }
585        | CMD_M '(' ')'
586          {
587            if(iiExprArithM(&$$,NULL,$1)) YYERROR;
588          }
589        | CMD_23 '(' expr ',' expr ')'
590          {
591            if(iiExprArith2(&$$,&$3,$1,&$5,TRUE)) YYERROR;
592          }
593        | CMD_23 '(' expr ',' expr ',' expr ')'
594          {
595            if(iiExprArith3(&$$,$1,&$3,&$5,&$7)) YYERROR;
596          }
597        | CMD_12 '(' expr ')'
598          {
599            if(iiExprArith1(&$$,&$3,$1)) YYERROR;
600          }
601        | CMD_12 '(' expr ',' expr ')'
602          {
603            if(iiExprArith2(&$$,&$3,$1,&$5,TRUE)) YYERROR;
604          }
605        | CMD_123 '(' expr ')'
606          {
607            if(iiExprArith1(&$$,&$3,$1)) YYERROR;
608          }
609        | CMD_123 '(' expr ',' expr ')'
610          {
611            if(iiExprArith2(&$$,&$3,$1,&$5,TRUE)) YYERROR;
612          }
613        | CMD_123 '(' expr ',' expr ',' expr ')'
614          {
615            if(iiExprArith3(&$$,$1,&$3,&$5,&$7)) YYERROR;
616          }
617        | MATRIX_CMD '(' expr ',' expr ',' expr ')'
618          {
619            if(iiExprArith3(&$$,MATRIX_CMD,&$3,&$5,&$7)) YYERROR;
620          }
621        | MATRIX_CMD '(' expr ')'
622          {
623            if(iiExprArith1(&$$,&$3,MATRIX_CMD)) YYERROR;
624          }
625        | INTMAT_CMD '(' expr ')'
626          {
627            if(iiExprArith1(&$$,&$3,INTMAT_CMD)) YYERROR;
628          }
629        | CMD_M '(' exprlist ')'
630          {
631            if(iiExprArithM(&$$,&$3,$1)) YYERROR;
632          }
633        | quote_start expr quote_end
634          {
635            $$=$2;
636          }
637        | quote_start expr '=' expr quote_end
638          {
639            #ifdef SIQ
640            siq++;
641            if (siq>0)
642            { if (iiExprArith2(&$$,&$2,'=',&$4)) YYERROR; }
643            else
644            #endif
645            {
646              memset(&$$,0,sizeof($$));
647              $$.rtyp=NONE;
648              if (iiAssign(&$2,&$4)) YYERROR;
649            }
650            #ifdef SIQ
651            siq--;
652            #endif
653          }
654        | EVAL  '('
655          {
656            #ifdef SIQ
657            siq--;
658            #endif
659          }
660          expr ')'
661          {
662            #ifdef SIQ
663            if (siq<=0) $4.Eval();
664            #endif
665            $$=$4;
666            #ifdef SIQ
667            siq++;
668            #endif
669          }
670          ;
671
672quote_start:    QUOTE  '('
673          {
674            #ifdef SIQ
675            siq++;
676            #endif
677          }
678          ;
679
680quote_end: ')'
681          {
682            #ifdef SIQ
683            siq--;
684            #endif
685          }
686          ;
687
688expr_arithmetic:
689          expr  PLUSPLUS     %prec PLUSPLUS
690          {
691            if(iiExprArith1(&$$,&$1,PLUSPLUS)) YYERROR;
692          }
693        | expr  MINUSMINUS   %prec MINUSMINUS
694          {
695            if(iiExprArith1(&$$,&$1,MINUSMINUS)) YYERROR;
696          }
697        | expr  '+' expr
698          {
699            if(iiExprArith2(&$$,&$1,'+',&$3)) YYERROR;
700          }
701        | expr  '-' expr
702          {
703            if(iiExprArith2(&$$,&$1,'-',&$3)) 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  NOTEQUAL expr
738          {
739            if(iiExprArith2(&$$,&$1,NOTEQUAL,&$3)) YYERROR;
740          }
741        | expr  EQUAL_EQUAL expr
742          {
743            if(iiExprArith2(&$$,&$1,EQUAL_EQUAL,&$3)) YYERROR;
744          }
745        | expr  GE  expr
746          {
747            if(iiExprArith2(&$$,&$1,GE,&$3)) YYERROR;
748          }
749        | expr  LE expr
750          {
751            if(iiExprArith2(&$$,&$1,LE,&$3)) YYERROR;
752          }
753        | expr DOTDOT expr
754          {
755            if(iiExprArith2(&$$,&$1,DOTDOT,&$3)) YYERROR;
756          }
757        | NOT '(' expr ')'
758          {
759            memset(&$$,0,sizeof($$));
760            int i; TESTSETINT($3,i);
761            $$.rtyp  = INT_CMD;
762            $$.data = (void *)(i == 0 ? 1 : 0);
763          }
764        | '-' expr %prec UMINUS
765          {
766            if(iiExprArith1(&$$,&$2,'-')) YYERROR;
767          }
768        ;
769
770left_value:
771        declare_ip_variable cmdeq  { $$ = $1; }
772        | exprlist '='
773          {
774            if ($1.rtyp==0)
775            {
776              Werror("`%s` is undefined",$1.Name());
777              YYERROR;
778            }
779            $$ = $1;
780          }
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            char *s=(char *)Alloc(10);
1074            strcpy(s,"index");
1075            singular_help(s,FALSE);
1076            Free((ADDRESS)s,10);
1077          }
1078        | EXAMPLE_CMD STRINGTOK
1079          {
1080            singular_help($2,TRUE);
1081            FreeL((ADDRESS)$2);
1082            if (inerror) YYERROR;
1083          }
1084        ;
1085
1086exportcmd:
1087        EXPORT_CMD exprlist
1088        {
1089          if (iiExport(&$2,0)) YYERROR;
1090        }
1091        | EXPORT_CMD exprlist extendedid expr
1092        {
1093          if ((strcmp($3,"to")!=0) ||
1094          (($4.Typ()!=PACKAGE_CMD) && ($4.Typ()!=INT_CMD)))
1095            MYYERROR("export <id> to <package|int>");
1096          FreeL((ADDRESS)$3);
1097          if ($4.Typ()==INT_CMD)
1098          {
1099            if (iiExport(&$2,((int)$4.Data())-1)) YYERROR;
1100          }
1101          else
1102          {
1103            if (iiExport(&$2,0,IDPACKAGE((idhdl)$4.data)->idroot))
1104              YYERROR;
1105          }
1106        }
1107        ;
1108
1109killcmd:
1110        KILL_CMD kill_any_identifier {;}
1111        ;
1112
1113kill_any_identifier:
1114        elemexpr
1115          {
1116            leftv v=&$1;
1117            do
1118            {
1119              if (v->rtyp!=IDHDL)
1120              {
1121                if (v->name!=NULL) Werror("`%s` is undefined in kill",v->name);
1122                else               WerrorS("kill what ?");
1123              }
1124              else
1125              {
1126                killhdl((idhdl)v->data);
1127              }
1128              v=v->next;
1129            } while (v!=NULL);
1130            $1.CleanUp();
1131          }
1132        | kill_any_identifier ',' elemexpr
1133          {
1134            if ($3.rtyp!=IDHDL)
1135            {
1136              if ($3.name!=NULL) Werror("`%s` is undefined",$3.name);
1137              else               WerrorS("kill what ?");
1138            }
1139            else
1140            {
1141              killhdl((idhdl)$3.data);
1142            }
1143            $3.CleanUp();
1144          }
1145        ;
1146
1147listcmd:
1148        LISTVAR_CMD '(' ROOT_DECL ')'
1149          {
1150            list_cmd($3,NULL,"// ",TRUE);
1151          }
1152        | LISTVAR_CMD '(' ROOT_DECL_LIST ')'
1153          {
1154            list_cmd($3,NULL,"// ",TRUE);
1155          }
1156        | LISTVAR_CMD '(' RING_DECL ')'
1157          {
1158            if ($3==QRING_CMD) $3=RING_CMD;
1159            list_cmd($3,NULL,"// ",TRUE);
1160          }
1161        | LISTVAR_CMD '(' currring_lists ')'
1162          {
1163            list_cmd($3,NULL,"// ",TRUE);
1164          }
1165        | LISTVAR_CMD '(' RING_CMD ')'
1166          {
1167            #ifdef SIC
1168            if (sic) MYYERROR("not implemented yet");
1169            #endif
1170            list_cmd(RING_CMD,NULL,"// ",TRUE);
1171          }
1172        | LISTVAR_CMD '(' MATRIX_CMD ')'
1173          {
1174            #ifdef SIC
1175            if (sic) MYYERROR("not implemented yet");
1176            #endif
1177            list_cmd(MATRIX_CMD,NULL,"// ",TRUE);
1178           }
1179        | LISTVAR_CMD '(' INTMAT_CMD ')'
1180          {
1181            #ifdef SIC
1182            if (sic) MYYERROR("not implemented yet");
1183            #endif
1184            list_cmd(INTMAT_CMD,NULL,"// ",TRUE);
1185          }
1186        | LISTVAR_CMD '(' PROC_CMD ')'
1187          {
1188            #ifdef SIC
1189            if (sic) MYYERROR("not implemented yet");
1190            #endif
1191            list_cmd(PROC_CMD,NULL,"// ",TRUE);
1192          }
1193        | LISTVAR_CMD '(' elemexpr ')'
1194          {
1195            #ifdef SIC
1196            if (sic) MYYERROR("not implemented yet");
1197            #endif
1198            list_cmd(0,$3.Name(),"// ",TRUE);
1199            $3.CleanUp();
1200          }
1201        | LISTVAR_CMD '(' ')'
1202          {
1203            #ifdef SIC
1204            if (sic) MYYERROR("not implemented yet");
1205            #endif
1206            list_cmd(-1,NULL,"// ",TRUE);
1207          }
1208        ;
1209
1210ringcmd1:
1211       RING_CMD { noringvars = TRUE; }
1212       ;
1213
1214ringcmd:
1215        ringcmd1
1216          elemexpr cmdeq
1217          rlist     ','      /* description of coeffs */
1218          rlist     ','      /* var names */
1219          ordering           /* list of (multiplier ordering (weight(s))) */
1220          {
1221            #ifdef SIC
1222            if (sic)
1223            {
1224            }
1225            #endif
1226            //noringvars = FALSE;
1227            if(!rInit($2.name,        /* ringname */
1228                     &$4,            /* characteristik and list of parameters*/
1229                     &$6,            /* names of ringvariables */
1230                     &$8,            /* ordering */
1231                     FALSE))         /* is not a dring */
1232            {
1233              MYYERROR("cannot make ring");
1234            }
1235            $4.CleanUp();
1236            $6.CleanUp();
1237            $8.CleanUp();
1238          }
1239        | ringcmd1 elemexpr
1240          {
1241            //noringvars = FALSE;
1242            if (!inerror) rDefault($2.name);
1243          }
1244        | DRING_CMD { noringvars = TRUE; }
1245          elemexpr cmdeq
1246          rlist     ','       /* description of coeffs */
1247          rlist     ','       /* var names */
1248          ordering           /* list of (multiplier ordering (weight(s))) */
1249          {
1250            #ifdef DRING
1251            idhdl h;
1252            //noringvars = FALSE;
1253            if(!(h=rInit($3.name,    /* ringname */
1254                     &$5,            /* characteristik and list of parameters*/
1255                     &$7,            /* names of ringvariables */
1256                     &$9,            /* ordering */
1257                     TRUE)))         /* is a dring */
1258            {
1259              YYERROR;
1260            }
1261            setFlag(h,FLAG_DRING);
1262            rDSet();
1263            $5.CleanUp();
1264            $7.CleanUp();
1265            $9.CleanUp();
1266            #endif
1267          }
1268        ;
1269
1270scriptcmd:
1271         LIB_CMD stringexpr
1272          {
1273            if (iiLibCmd($2)) YYERROR;
1274          }
1275        ;
1276
1277setrings:  SETRING_CMD | KEEPRING_CMD ;
1278
1279setringcmd:
1280        setrings expr
1281          {
1282            if (($1==KEEPRING_CMD) && (myynest==0))
1283               MYYERROR("only inside a proc allowed");
1284            const char * n=$2.Name();
1285            if ((($2.Typ()==RING_CMD)||($2.Typ()==QRING_CMD))
1286            && ($2.rtyp==IDHDL))
1287            {
1288              idhdl h=(idhdl)$2.data;
1289              if ($2.e!=NULL) h=rFindHdl((ring)$2.Data(),NULL);
1290              if ($1==KEEPRING_CMD)
1291              {
1292                if (h!=NULL)
1293                {
1294                  if (IDLEV(h)!=0)
1295                  {
1296                    if (iiExport(&$2,myynest-1)) YYERROR;
1297                    //if (TEST_OPT_KEEPVARS)
1298                    //{
1299                      idhdl p=IDRING(h)->idroot;
1300                      int prevlev=myynest-1;
1301                      while (p!=NULL)
1302                      {
1303                        if (IDLEV(p)==myynest) IDLEV(p)=prevlev;
1304                        p=IDNEXT(p);
1305                      }
1306                    //}
1307                  }
1308                  iiLocalRing[myynest-1]=IDRING(h);
1309                }
1310                else
1311                {
1312                  Werror("%s is no identifier",n);
1313                  $2.CleanUp();
1314                  YYERROR;
1315                }
1316              }
1317              if (h!=NULL) rSetHdl(h,TRUE);
1318              else
1319              {
1320                Werror("cannot find the name of the basering %s",n);
1321                $2.CleanUp();
1322                YYERROR;
1323              }
1324              $2.CleanUp();
1325            }
1326            else
1327            {
1328              Werror("%s is no name of a ring/qring",n);
1329              $2.CleanUp();
1330              YYERROR;
1331            }
1332          }
1333        ;
1334
1335typecmd:
1336        TYPE_CMD expr
1337          {
1338            if ($2.rtyp!=IDHDL) MYYERROR("identifier expected");
1339            #ifdef SIC
1340            if (sic)
1341            {
1342            }
1343            else
1344            #endif
1345            {
1346              idhdl h = (idhdl)$2.data;
1347              type_cmd(h);
1348            }
1349          }
1350        | exprlist
1351          {
1352            //Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
1353            #ifdef SIQ
1354            if ($1.rtyp!=COMMAND)
1355            {
1356            #endif
1357              if ($1.Typ()==UNKNOWN)
1358              {
1359                if ($1.name!=NULL)
1360                {
1361                  Werror("`%s` is undefined",$1.name);
1362                  FreeL((ADDRESS)$1.name);
1363                }
1364                YYERROR;
1365              }
1366            #ifdef SIQ
1367            }
1368            #endif
1369            $1.Print(&sLastPrinted);
1370            $1.CleanUp();
1371          }
1372        ;
1373
1374/* --------------------------------------------------------------------*/
1375/* section of flow control                                             */
1376/* --------------------------------------------------------------------*/
1377
1378ifcmd: IF_CMD '(' expr ')' BLOCKTOK
1379          {
1380            #ifdef SIC
1381            if (sic)
1382            {
1383              //egPrint(IF_CMD,1,"if, 1\n");
1384              //egPrint(&$3);
1385              newBuffer( $5, BT_if);
1386            }
1387            else
1388            #endif
1389            {
1390              int i; TESTSETINT($3,i);
1391              if (i!=0)
1392              {
1393                newBuffer( $5, BT_if);
1394                //printf("if:new level %d\n",voice);
1395              }
1396              else
1397              {
1398                FreeL((ADDRESS)$5);
1399                ifswitch[voice]=1;
1400                //printf("if:(0):set ifsw=1 in voice %d\n",voice);
1401              }
1402            }
1403          }
1404        | ELSE_CMD BLOCKTOK
1405          {
1406            #ifdef SIC
1407            if (sic)
1408            {
1409            //egPrint(ELSE_CMD,0,"op: else, 0\n");
1410            newBuffer( $2, BT_else);
1411            }
1412            else
1413            #endif
1414            {
1415              if (ifswitch[voice]==1)
1416              {
1417                ifswitch[voice]=0;
1418                newBuffer( $2, BT_else);
1419              }
1420              else
1421              {
1422                if (ifswitch[voice]!=2)
1423                {
1424                  char *s=$2+strlen($2)-1;
1425                  while ((*s=='\0')||(*s=='\n')) s--;
1426                  s[1]='\0';
1427                  Warn("`else` without `if` in level %d",myynest);
1428                }
1429                FreeL((ADDRESS)$2);
1430              }
1431              ifswitch[voice]=0;
1432            }
1433          }
1434        | IF_CMD '(' expr ')' BREAK_CMD
1435          {
1436            #ifdef SIC
1437            if (sic)
1438            {
1439              //egPrint(IFBREAK,1,"ifbreak, 1\n");
1440              //egPrint(&$3);
1441            }
1442            else
1443            #endif
1444            {
1445              int i; TESTSETINT($3,i);
1446              if (i)
1447              {
1448                if (exitBuffer(BT_break)) YYERROR;
1449              }
1450              ifswitch[voice]=0;
1451            }
1452          }
1453        | BREAK_CMD
1454          {
1455            #ifdef SIC
1456            if (sic)
1457            {
1458            }
1459            else
1460            #endif
1461            {
1462              if (exitBuffer(BT_break)) YYERROR;
1463              ifswitch[voice]=0;
1464            }
1465          }
1466        | CONTINUE_CMD
1467          {
1468            #ifdef SIC
1469            if (sic)
1470            {
1471            }
1472            else
1473            #endif
1474            {
1475              contBuffer(BT_break);
1476              ifswitch[voice]=0;
1477            }
1478          }
1479      ;
1480
1481whilecmd:
1482        WHILE_CMD STRINGTOK BLOCKTOK
1483          {
1484            /* -> if(!$2) break; $3; continue;*/
1485            char * s = (char *)AllocL( strlen($2) + strlen($3) + 36);
1486            sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,$2,$3);
1487            newBuffer(s,BT_break);
1488            FreeL((ADDRESS)$2);
1489            FreeL((ADDRESS)$3);
1490          }
1491        ;
1492
1493forcmd:
1494        FOR_CMD STRINGTOK STRINGTOK STRINGTOK BLOCKTOK
1495          {
1496            /* $2 */
1497            /* if (!$3) break; $5; $4; continue; */
1498            char * s = (char *)AllocL( strlen($3)+strlen($4)+strlen($5)+36);
1499            sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
1500                   ,$3,$5,$4);
1501            FreeL((ADDRESS)$3);
1502            FreeL((ADDRESS)$4);
1503            FreeL((ADDRESS)$5);
1504            newBuffer(s,BT_break);
1505            s = (char *)AllocL( strlen($2) + 3);
1506            sprintf(s,"%s;\n",$2);
1507            FreeL((ADDRESS)$2);
1508            newBuffer(s,BT_if);
1509          }
1510        ;
1511
1512proccmd:
1513        PROC_CMD extendedid BLOCKTOK
1514          {
1515            #ifdef SIC
1516            if (sic)
1517            {
1518              FreeL((ADDRESS)$2);
1519              FreeL((ADDRESS)$3);
1520              MYYERROR("not implemented");
1521            }
1522            #endif
1523            idhdl h = enterid($2,myynest,PROC_CMD,&idroot,FALSE);
1524            if (h==NULL) {FreeL((ADDRESS)$3); YYERROR;}
1525            IDSTRING(h) = (char *)AllocL(strlen($3)+31);
1526            sprintf(IDSTRING(h),"parameter list #;\n%s;return();\n\n",$3);
1527            FreeL((ADDRESS)$3);
1528          }
1529        | PROC_CMD elemexpr '=' expr ';'
1530          {
1531            #ifdef SIC
1532            if (sic)
1533            {
1534              $4.CleanUp();
1535              FreeL((ADDRESS)$2);
1536              MYYERROR("not implemented");
1537            }
1538            #endif
1539            sleftv v;
1540            if ((iiDeclCommand(&v,&$2,myynest,PROC_CMD,&idroot,FALSE))
1541            || (iiAssign(&v,&($4)))) YYERROR;
1542          }
1543        | PROC_DEF STRINGTOK BLOCKTOK
1544          {
1545            idhdl h = enterid($1,myynest,PROC_CMD,&idroot,FALSE);
1546            if (h==NULL)
1547            {
1548              FreeL((ADDRESS)$2);
1549              FreeL((ADDRESS)$3);
1550              YYERROR;
1551            }
1552            char *args=iiProcArgs($2,FALSE);
1553            FreeL((ADDRESS)$2);
1554            IDSTRING(h) = (char *)AllocL(strlen($3)+strlen(args)+14);
1555            sprintf(IDSTRING(h),"%s\n%s;RETURN();\n\n",args,$3);
1556            FreeL((ADDRESS)args);
1557            FreeL((ADDRESS)$3);
1558            //Print(">>%s<<\n",IDSTRING(h));
1559          }
1560        ;
1561
1562parametercmd:
1563        PARAMETER declare_ip_variable
1564          {
1565            //Print("par:%s, %d\n",$2.Name(),$2.Typ());
1566            yylineno--;
1567            #ifdef SIC
1568            if (sic)
1569            {
1570              //egParameter(&$2);
1571            }
1572            else
1573            #endif
1574            {
1575              if (iiParameter(&$2)) YYERROR;
1576            }
1577          }
1578        | PARAMETER expr
1579          {
1580            //Print("par:%s, %d\n",$2.Name(),$2.Typ());
1581            sleftv tmp_expr;
1582            #ifdef SIC
1583            if (sic)
1584            {
1585              if (iiDeclCommand(&tmp_expr,&$2,myynest,DEF_CMD,&idroot))
1586                YYERROR;
1587              //egParameter(&$2);
1588            }
1589            else
1590            #endif
1591            {
1592              if ((iiDeclCommand(&tmp_expr,&$2,myynest,DEF_CMD,&idroot))
1593              || (iiParameter(&tmp_expr)))
1594                YYERROR;
1595            }
1596          }
1597        ;
1598
1599returncmd:
1600        RETURN '(' exprlist ')'
1601          {
1602            iiRETURNEXPR[myynest].Copy(&$3);
1603            $3.CleanUp();
1604            if (exitBuffer(BT_proc)) YYERROR;
1605          }
1606        | RETURN '(' ')'
1607          {
1608            iiRETURNEXPR[myynest].Init();
1609            iiRETURNEXPR[myynest].rtyp=NONE;
1610            if (exitBuffer(BT_proc)&&($1!=END_PROC)) YYERROR;
1611            if ($1==END_PROC) YYACCEPT;
1612          }
1613        ;
Note: See TracBrowser for help on using the repository browser.