source: git/Singular/grammar.y @ 138f0c

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