source: git/Singular/grammar.y @ fdc537

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