source: git/Singular/grammar.y @ c04b94

spielwiese
Last change on this file since c04b94 was c04b94, checked in by Olaf Bachmann <obachman@…>, 24 years ago
* example on kernel commands implemented git-svn-id: file:///usr/local/Singular/svn/trunk@3959 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 44.9 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: grammar.y,v 1.76 1999-12-06 16:06:44 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          | examplecmd
414            {currentVoice->ifsw=0;}
415        ;
416
417example_dummy : EXAMPLE_CMD BLOCKTOK { FreeL((ADDRESS)$2); }
418
419command: assign
420         | executecmd
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,'*',&$3)) YYERROR;
750          }
751        | expr '/' expr
752          {
753            if(iiExprArith2(&$$,&$1,'/',&$3)) YYERROR;
754          }
755        | expr INTDIV expr
756          {
757            if(iiExprArith2(&$$,&$1,INTDIV,&$3)) YYERROR;
758          }
759        | expr '^' expr
760          {
761            if(iiExprArith2(&$$,&$1,'^',&$3)) YYERROR;
762          }
763        | expr '%' expr
764          {
765            if(iiExprArith2(&$$,&$1,'%',&$3)) YYERROR;
766          }
767        | expr '>' expr
768          {
769            if(iiExprArith2(&$$,&$1,'>',&$3)) YYERROR;
770          }
771        | expr '<' expr
772          {
773            if(iiExprArith2(&$$,&$1,'<',&$3)) YYERROR;
774          }
775        | expr '&' expr
776          {
777            if(iiExprArith2(&$$,&$1,'&',&$3)) YYERROR;
778          }
779        | expr '|' expr
780          {
781            if(iiExprArith2(&$$,&$1,'|',&$3)) YYERROR;
782          }
783        | expr NOTEQUAL expr
784          {
785            if(iiExprArith2(&$$,&$1,NOTEQUAL,&$3)) YYERROR;
786          }
787        | expr EQUAL_EQUAL expr
788          {
789            if(iiExprArith2(&$$,&$1,EQUAL_EQUAL,&$3)) YYERROR;
790          }
791        | expr GE  expr
792          {
793            if(iiExprArith2(&$$,&$1,GE,&$3)) YYERROR;
794          }
795        | expr LE expr
796          {
797            if(iiExprArith2(&$$,&$1,LE,&$3)) YYERROR;
798          }
799        | expr DOTDOT expr
800          {
801            if(iiExprArith2(&$$,&$1,DOTDOT,&$3)) YYERROR;
802          }
803        | NOT expr
804          {
805            memset(&$$,0,sizeof($$));
806            int i; TESTSETINT($2,i);
807            $$.rtyp  = INT_CMD;
808            $$.data = (void *)(i == 0 ? 1 : 0);
809          }
810        | '-' expr %prec UMINUS
811          {
812            if(iiExprArith1(&$$,&$2,'-')) YYERROR;
813          }
814        ;
815
816left_value:
817        declare_ip_variable cmdeq  { $$ = $1; }
818        | exprlist '='
819          {
820            if ($1.rtyp==0)
821            {
822              Werror("`%s` is undefined",$1.Fullname());
823              YYERROR;
824            }
825            $$ = $1;
826          }
827        ;
828
829
830extendedid:
831        UNKNOWN_IDENT
832        | '`' expr '`'
833          {
834            if ($2.Typ()!=STRING_CMD)
835            {
836              MYYERROR("string expression expected");
837            }
838            $$ = (char *)$2.CopyD(STRING_CMD);
839            $2.CleanUp();
840          }
841        ;
842
843currring_lists:
844        IDEAL_CMD | MODUL_CMD
845        /* put variables into the current ring */
846        ;
847
848declare_ip_variable:
849        ROOT_DECL elemexpr
850          {
851            if (iiDeclCommand(&$$,&$2,myynest,$1,&IDROOT)) YYERROR;
852          }
853        | ROOT_DECL_LIST elemexpr
854          {
855            if (iiDeclCommand(&$$,&$2,myynest,$1,&IDROOT)) YYERROR;
856          }
857        | RING_DECL elemexpr
858          {
859            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot), TRUE)) YYERROR;
860          }
861        | currring_lists elemexpr
862          {
863            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot), TRUE)) YYERROR;
864          }
865        | MATRIX_CMD elemexpr '[' expr ']' '[' expr ']'
866          {
867            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot), TRUE)) YYERROR;
868            int r; TESTSETINT($4,r);
869            int c; TESTSETINT($7,c);
870            if (r < 1)
871              MYYERROR("rows must be greater than 0");
872            if (c < 0)
873              MYYERROR("cols must be greater than -1");
874            leftv v=&$$;
875            //while (v->next!=NULL) { v=v->next; }
876            idhdl h=(idhdl)v->data;
877            idDelete(&IDIDEAL(h));
878            IDMATRIX(h) = mpNew(r,c);
879            if (IDMATRIX(h)==NULL) YYERROR;
880          }
881        | MATRIX_CMD elemexpr
882          {
883            if (iiDeclCommand(&$$,&$2,myynest,$1,&(currRing->idroot), TRUE)) YYERROR;
884          }
885        | INTMAT_CMD elemexpr '[' expr ']' '[' expr ']'
886          {
887            if (iiDeclCommand(&$$,&$2,myynest,$1,&IDROOT)) YYERROR;
888            int r; TESTSETINT($4,r);
889            int c; TESTSETINT($7,c);
890            if (r < 1)
891              MYYERROR("rows must be greater than 0");
892            if (c < 0)
893              MYYERROR("cols must be greater than -1");
894            leftv v=&$$;
895            //while (v->next!=NULL) { v=v->next; }
896            idhdl h=(idhdl)v->data;
897            delete IDINTVEC(h);
898            IDINTVEC(h) = NewIntvec3(r,c,0);
899            if (IDINTVEC(h)==NULL) YYERROR;
900          }
901        | INTMAT_CMD elemexpr
902          {
903            if (iiDeclCommand(&$$,&$2,myynest,$1,&IDROOT)) YYERROR;
904            leftv v=&$$;
905            idhdl h;
906            do
907            {
908               h=(idhdl)v->data;
909               delete IDINTVEC(h);
910               IDINTVEC(h) = NewIntvec3(1,1,0);
911               v=v->next;
912            } while (v!=NULL);
913          }
914        | declare_ip_variable ',' elemexpr
915          {
916            int t=$1.Typ();
917            sleftv r;
918            memset(&r,0,sizeof(sleftv));
919            if ((BEGIN_RING<t) && (t<END_RING))
920            {
921              if (iiDeclCommand(&r,&$3,myynest,t,&(currRing->idroot), TRUE)) YYERROR;
922            }
923            else
924            {
925              if (iiDeclCommand(&r,&$3,myynest,t,&IDROOT)) YYERROR;
926            }
927            leftv v=&$1;
928            while (v->next!=NULL) v=v->next;
929            v->next=(leftv)AllocSizeOf(sleftv);
930            memcpy(v->next,&r,sizeof(sleftv));
931            $$=$1;
932          }
933        | PROC_CMD elemexpr
934          {
935            if (iiDeclCommand(&$$,&$2,myynest,PROC_CMD,&IDROOT, FALSE, TRUE)) YYERROR;
936          }
937        ;
938
939stringexpr:
940        STRINGTOK
941        ;
942
943rlist:
944        expr
945        | '(' expr ',' exprlist ')'
946          {
947            leftv v = &$2;
948            while (v->next!=NULL)
949            {
950              v=v->next;
951            }
952            v->next = (leftv)AllocSizeOf(sleftv);
953            memcpy(v->next,&($4),sizeof(sleftv));
954            $$ = $2;
955          }
956        ;
957
958ordername:
959        UNKNOWN_IDENT
960        {
961          // let rInit take care of any errors
962          $$=rOrderName($1);
963        }
964        ;
965
966orderelem:
967        ordername
968          {
969            memset(&$$,0,sizeof($$));
970            intvec *iv = NewIntvec1(2);
971            (*iv)[0] = 1;
972            (*iv)[1] = $1;
973            $$.rtyp = INTVEC_CMD;
974            $$.data = (void *)iv;
975          }
976        | ordername '(' exprlist ')'
977          {
978            memset(&$$,0,sizeof($$));
979            leftv sl = &$3;
980            int slLength;
981            {
982              slLength =  exprlist_length(sl);
983              int l = 2 +  slLength;
984              intvec *iv = NewIntvec1(l);
985              (*iv)[0] = slLength;
986              (*iv)[1] = $1;
987
988              int i = 2;
989              while ((i<l) && (sl!=NULL))
990              {
991                if (sl->Typ() == INT_CMD)
992                {
993                  (*iv)[i++] = (int)(sl->Data());
994                }
995                else if ((sl->Typ() == INTVEC_CMD)
996                ||(sl->Typ() == INTMAT_CMD))
997                {
998                  intvec *ivv = (intvec *)(sl->Data());
999                  int ll = 0,l = ivv->length();
1000                  for (; l>0; l--)
1001                  {
1002                    (*iv)[i++] = (*ivv)[ll++];
1003                  }
1004                }
1005                else
1006                {
1007                  delete iv;
1008                  $3.CleanUp();
1009                  MYYERROR("wrong type in ordering");
1010                }
1011                sl = sl->next;
1012              }
1013              $$.rtyp = INTVEC_CMD;
1014              $$.data = (void *)iv;
1015            }
1016            $3.CleanUp();
1017          }
1018        ;
1019
1020OrderingList:
1021        orderelem
1022        |  orderelem ',' OrderingList
1023          {
1024            $$ = $1;
1025            $$.next = (sleftv *)AllocSizeOf(sleftv);
1026            memcpy($$.next,&$3,sizeof(sleftv));
1027          }
1028        ;
1029
1030ordering:
1031        orderelem
1032        | '(' OrderingList ')'
1033          {
1034            $$ = $2;
1035          }
1036        ;
1037
1038cmdeq:  '='
1039          {
1040            expected_parms = TRUE;
1041          }
1042        ;
1043
1044
1045/* --------------------------------------------------------------------*/
1046/* section of pure commands                                            */
1047/* --------------------------------------------------------------------*/
1048
1049executecmd:
1050        EXECUTE_CMD expr
1051          {
1052            if ($2.Typ() == STRING_CMD)
1053            {
1054              char * s = (char *)AllocL(strlen((char *)$2.Data()) + 4);
1055              strcpy( s, (char *)$2.Data());
1056              strcat( s, "\n;\n");
1057              $2.CleanUp();
1058              newBuffer(s,BT_execute);
1059            }
1060            else
1061            {
1062              MYYERROR("string expected");
1063            }
1064          }
1065        ;
1066
1067filecmd:
1068        '<' stringexpr
1069          { if((feFilePending=feFopen($2,"r",NULL,TRUE))==NULL) YYERROR; }
1070        ';'
1071          { newFile($2,feFilePending); }
1072        ;
1073
1074helpcmd:
1075        HELP_CMD STRINGTOK ';'
1076          {
1077            feHelp($2);
1078            FreeL((ADDRESS)$2);
1079          }
1080        | HELP_CMD ';'
1081          {
1082            feHelp(NULL);
1083          }
1084        ;
1085
1086examplecmd:
1087        EXAMPLE_CMD STRINGTOK ';'
1088          {
1089            singular_example($2);
1090            FreeL((ADDRESS)$2);
1091          }
1092       ;
1093
1094exportcmd:
1095        EXPORT_CMD exprlist
1096        {
1097#ifdef HAVE_NAMESPACES
1098          if (iiExport(&$2,0,namespaceroot->get("Top",0,TRUE))) YYERROR;
1099#else /* HAVE_NAMESPACES */
1100          if (iiExport(&$2,0)) YYERROR;
1101#endif /* HAVE_NAMESPACES */
1102            }
1103        | EXPORT_CMD exprlist extendedid expr
1104        {
1105          if ((strcmp($3,"to")!=0) ||
1106          (($4.Typ()!=PACKAGE_CMD) && ($4.Typ()!=INT_CMD) &&
1107           ($4.Typ()!=STRING_CMD)))
1108            MYYERROR("export <id> to <package|int>");
1109          FreeL((ADDRESS)$3);
1110          if ($4.Typ()==INT_CMD)
1111          {
1112            if (iiExport(&$2,((int)$4.Data())-1)) YYERROR;
1113          }
1114          else
1115          {
1116#ifdef HAVE_NAMESPACES
1117            if ($4.Typ()==PACKAGE_CMD) {
1118              if (iiExport(&$2,0,(idhdl)$4.data))
1119                YYERROR;
1120            }
1121            else
1122#endif /* HAVE_NAMESPACES */
1123            {
1124             printf("String: %s;\n", (char *)$4.data);
1125            }
1126          }
1127        }
1128        ;
1129
1130killcmd:
1131        KILL_CMD exprlist
1132        {
1133          leftv v=&$2;
1134          do
1135          {
1136            if (v->rtyp!=IDHDL)
1137            {
1138              if (v->name!=NULL) Werror("`%s` is undefined in kill",v->name);
1139              else               WerrorS("kill what ?");
1140            }
1141            else
1142            {
1143            #ifdef HAVE_NAMESPACES
1144              if (v->packhdl != NULL)
1145              {
1146                namespaceroot->push( IDPACKAGE(v->packhdl) , IDID(v->packhdl));
1147                killhdl((idhdl)v->data);
1148                namespaceroot->pop();
1149              }
1150              else
1151              #endif /* HAVE_NAMESPACES */
1152                killhdl((idhdl)v->data);
1153            }
1154            v=v->next;
1155          } while (v!=NULL);
1156          $2.CleanUp();
1157        }
1158        ;
1159
1160listcmd:
1161        LISTVAR_CMD '(' ROOT_DECL ')'
1162          {
1163            list_cmd($3,NULL,"// ",TRUE);
1164          }
1165        | LISTVAR_CMD '(' ROOT_DECL_LIST ')'
1166          {
1167            list_cmd($3,NULL,"// ",TRUE);
1168          }
1169        | LISTVAR_CMD '(' RING_DECL ')'
1170          {
1171            if ($3==QRING_CMD) $3=RING_CMD;
1172            list_cmd($3,NULL,"// ",TRUE);
1173          }
1174        | LISTVAR_CMD '(' currring_lists ')'
1175          {
1176            list_cmd($3,NULL,"// ",TRUE);
1177          }
1178        | LISTVAR_CMD '(' RING_CMD ')'
1179          {
1180            list_cmd(RING_CMD,NULL,"// ",TRUE);
1181          }
1182        | LISTVAR_CMD '(' MATRIX_CMD ')'
1183          {
1184            list_cmd(MATRIX_CMD,NULL,"// ",TRUE);
1185           }
1186        | LISTVAR_CMD '(' INTMAT_CMD ')'
1187          {
1188            list_cmd(INTMAT_CMD,NULL,"// ",TRUE);
1189          }
1190        | LISTVAR_CMD '(' PROC_CMD ')'
1191          {
1192            list_cmd(PROC_CMD,NULL,"// ",TRUE);
1193          }
1194        | LISTVAR_CMD '(' elemexpr ')'
1195          {
1196#ifdef HAVE_NAMESPACES
1197            if($3.Typ() == PACKAGE_CMD) {
1198              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
1199                                   ((sleftv)$3).name);
1200              list_cmd(-2,NULL,"// ",TRUE);
1201              namespaceroot->pop();
1202            }
1203            else
1204#endif /* HAVE_NAMESPACES */
1205              list_cmd(0,$3.Fullname(),"// ",TRUE);
1206            $3.CleanUp();
1207          }
1208        | LISTVAR_CMD '(' elemexpr ',' ROOT_DECL ')'
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 ',' ROOT_DECL_LIST ')'
1221          {
1222#ifdef HAVE_NAMESPACES
1223            if($3.Typ() == PACKAGE_CMD) {
1224              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
1225                                   ((sleftv)$3).name);
1226              list_cmd($5,NULL,"// ",TRUE);
1227              namespaceroot->pop();
1228            }
1229#endif /* HAVE_NAMESPACES */
1230            $3.CleanUp();
1231          }
1232        | LISTVAR_CMD '(' elemexpr ',' RING_DECL ')'
1233          {
1234#ifdef HAVE_NAMESPACES
1235            if($3.Typ() == PACKAGE_CMD) {
1236              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
1237                                   ((sleftv)$3).name);
1238              if ($5==QRING_CMD) $5=RING_CMD;
1239              list_cmd($5,NULL,"// ",TRUE);
1240              namespaceroot->pop();
1241            }
1242#endif /* HAVE_NAMESPACES */
1243            $3.CleanUp();
1244          }
1245        | LISTVAR_CMD '(' elemexpr ',' currring_lists ')'
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($5,NULL,"// ",TRUE);
1252              namespaceroot->pop();
1253            }
1254#endif /* HAVE_NAMESPACES */
1255            $3.CleanUp();
1256          }
1257        | LISTVAR_CMD '(' elemexpr ',' RING_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(RING_CMD,NULL,"// ",TRUE);
1264              namespaceroot->pop();
1265            }
1266#endif /* HAVE_NAMESPACES */
1267            $3.CleanUp();
1268          }
1269        | LISTVAR_CMD '(' elemexpr ',' MATRIX_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(MATRIX_CMD,NULL,"// ",TRUE);
1276              namespaceroot->pop();
1277            }
1278#endif /* HAVE_NAMESPACES */
1279            $3.CleanUp();
1280          }
1281        | LISTVAR_CMD '(' elemexpr ',' INTMAT_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(INTMAT_CMD,NULL,"// ",TRUE);
1288              namespaceroot->pop();
1289            }
1290#endif /* HAVE_NAMESPACES */
1291            $3.CleanUp();
1292          }
1293        | LISTVAR_CMD '(' elemexpr ',' PROC_CMD ')'
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(PROC_CMD,$3.Fullname(),"// ",TRUE);
1300              namespaceroot->pop();
1301            }
1302#endif /* HAVE_NAMESPACES */
1303            $3.CleanUp();
1304          }
1305        | LISTVAR_CMD '(' elemexpr ',' elemexpr ')'
1306          {
1307#ifdef HAVE_NAMESPACES
1308            if($3.Typ() == PACKAGE_CMD) {
1309              namespaceroot->push( IDPACKAGE((idhdl)$3.data),
1310                                   ((sleftv)$3).name);
1311              list_cmd(0,$5.Fullname(),"// ",TRUE);
1312              namespaceroot->pop();
1313            }
1314#endif /* HAVE_NAMESPACES */
1315            $3.CleanUp();
1316          }
1317        | LISTVAR_CMD '(' ')'
1318          {
1319            list_cmd(-1,NULL,"// ",TRUE);
1320          }
1321        ;
1322
1323ringcmd1:
1324       RING_CMD { yyInRingConstruction = TRUE; }
1325       ;
1326
1327ringcmd:
1328        ringcmd1
1329          elemexpr cmdeq
1330          rlist     ','      /* description of coeffs */
1331          rlist     ','      /* var names */
1332          ordering           /* list of (multiplier ordering (weight(s))) */
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            ring b=
1347            rInit(&$4,            /* characteristik and list of parameters*/
1348                  &$6,            /* names of ringvariables */
1349                  &$8);            /* ordering */
1350            idhdl newRingHdl=NULL;
1351            if (b!=NULL)
1352            {
1353              newRingHdl=enterid(ring_name, myynest, RING_CMD, &IDROOT);
1354              if (newRingHdl!=NULL)
1355              {
1356                Free(IDRING(newRingHdl),sizeof(ip_sring));
1357                IDRING(newRingHdl)=b;
1358              }
1359              else
1360              {
1361                rKill(b);
1362              }
1363            }
1364            #ifdef HAVE_NAMESPACES
1365              if(do_pop) namespaceroot->pop();
1366            #endif /* HAVE_NAMESPACES */
1367            yyInRingConstruction = FALSE;
1368            if (newRingHdl==NULL)
1369            {
1370              MYYERROR("cannot make ring");
1371            }
1372            else
1373            {
1374              rSetHdl(newRingHdl);
1375            }
1376          }
1377        | ringcmd1 elemexpr
1378          {
1379            BOOLEAN do_pop = FALSE;
1380            char *ring_name = $2.name;
1381            #ifdef HAVE_NAMESPACES
1382              if (((sleftv)$2).req_packhdl != NULL)
1383              {
1384                namespaceroot->push( IDPACKAGE(((sleftv)$2).req_packhdl) , "");
1385                do_pop = TRUE;
1386                if( (((sleftv)$2).req_packhdl != NULL) &&
1387                  (((sleftv)$2).packhdl != ((sleftv)$2).req_packhdl))
1388                  ring_name = mstrdup($2.name);
1389              }
1390            #endif /* HAVE_NAMESPACES */
1391            if (!inerror) rDefault(ring_name);
1392            #ifdef HAVE_NAMESPACES
1393              if(do_pop) namespaceroot->pop();
1394            #endif /* HAVE_NAMESPACES */
1395            yyInRingConstruction = FALSE;
1396          }
1397        ;
1398
1399scriptcmd:
1400         SYSVAR stringexpr
1401          {
1402            if (($1!=LIB_CMD)||(iiLibCmd($2))) YYERROR;
1403          }
1404        ;
1405
1406setrings:  SETRING_CMD | KEEPRING_CMD ;
1407
1408setringcmd:
1409        setrings expr
1410          {
1411            if (($1==KEEPRING_CMD) && (myynest==0))
1412               MYYERROR("only inside a proc allowed");
1413            const char * n=$2.Name();
1414            if ((($2.Typ()==RING_CMD)||($2.Typ()==QRING_CMD))
1415            && ($2.rtyp==IDHDL))
1416            {
1417              idhdl h=(idhdl)$2.data;
1418              if ($2.e!=NULL) h=rFindHdl((ring)$2.Data(),NULL, NULL);
1419              if ($1==KEEPRING_CMD)
1420              {
1421                if (h!=NULL)
1422                {
1423                  if (IDLEV(h)!=0)
1424                  {
1425#ifdef HAVE_NAMESPACES
1426                    if(namespaceroot->isroot) {
1427                      if (iiExport(&$2,myynest-1)) YYERROR;
1428                    } else {
1429                      if (iiExport(&$2,myynest-1,
1430                        namespaceroot->get(namespaceroot->next->name,0,TRUE)))
1431                        YYERROR;
1432                    }
1433#else /* HAVE_NAMESPACES */
1434                    if (iiExport(&$2,myynest-1)) YYERROR;
1435#endif /* HAVE_NAMESPACES */
1436                    //if (TEST_OPT_KEEPVARS)
1437                    //{
1438                      idhdl p=IDRING(h)->idroot;
1439                      idhdl root=p;
1440                      int prevlev=myynest-1;
1441                      while (p!=NULL)
1442                      {
1443                        if (IDLEV(p)==myynest)
1444                        {
1445                          idhdl old=root->get(IDID(p),prevlev);
1446                          if (old!=NULL)
1447                          {
1448                            if (BVERBOSE(V_REDEFINE))
1449                              Warn("redefining %s",IDID(p));
1450                            killhdl(old,&root);
1451                          }
1452                          IDLEV(p)=prevlev;
1453                        }
1454                        p=IDNEXT(p);
1455                      }
1456                    //}
1457                  }
1458#ifdef USE_IILOCALRING
1459                  iiLocalRing[myynest-1]=IDRING(h);
1460#else
1461                  namespaceroot->next->currRing=IDRING(h);
1462#endif
1463                }
1464                else
1465                {
1466                  Werror("%s is no identifier",n);
1467                  $2.CleanUp();
1468                  YYERROR;
1469                }
1470              }
1471              if (h!=NULL) rSetHdl(h,TRUE);
1472              else
1473              {
1474                Werror("cannot find the name of the basering %s",n);
1475                $2.CleanUp();
1476                YYERROR;
1477              }
1478              $2.CleanUp();
1479            }
1480            else
1481            {
1482              Werror("%s is no name of a ring/qring",n);
1483              $2.CleanUp();
1484              YYERROR;
1485            }
1486          }
1487        ;
1488
1489typecmd:
1490        TYPE_CMD expr
1491          {
1492            if ($2.rtyp!=IDHDL) MYYERROR("identifier expected");
1493            idhdl h = (idhdl)$2.data;
1494            type_cmd(h);
1495          }
1496        | exprlist
1497          {
1498            //Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
1499            #ifdef SIQ
1500            if ($1.rtyp!=COMMAND)
1501            {
1502            #endif
1503              if ($1.Typ()==UNKNOWN)
1504              {
1505                if ($1.name!=NULL)
1506                {
1507                  Werror("`%s` is undefined",$1.name);
1508                  FreeL((ADDRESS)$1.name);
1509                }
1510                YYERROR;
1511              }
1512            #ifdef SIQ
1513            }
1514            #endif
1515            $1.Print(&sLastPrinted);
1516            $1.CleanUp();
1517            if (errorreported) YYERROR;
1518          }
1519        ;
1520
1521/* --------------------------------------------------------------------*/
1522/* section of flow control                                             */
1523/* --------------------------------------------------------------------*/
1524
1525ifcmd: IF_CMD '(' expr ')' BLOCKTOK
1526          {
1527            int i; TESTSETINT($3,i);
1528            if (i!=0)
1529            {
1530              newBuffer( $5, BT_if);
1531            }
1532            else
1533            {
1534              FreeL((ADDRESS)$5);
1535              currentVoice->ifsw=1;
1536            }
1537          }
1538        | ELSE_CMD BLOCKTOK
1539          {
1540            if (currentVoice->ifsw==1)
1541            {
1542              currentVoice->ifsw=0;
1543              newBuffer( $2, BT_else);
1544            }
1545            else
1546            {
1547              if (currentVoice->ifsw!=2)
1548              {
1549                Warn("`else` without `if` in level %d",myynest);
1550              }
1551              FreeL((ADDRESS)$2);
1552            }
1553            currentVoice->ifsw=0;
1554          }
1555        | IF_CMD '(' expr ')' BREAK_CMD
1556          {
1557            int i; TESTSETINT($3,i);
1558            if (i)
1559            {
1560              if (exitBuffer(BT_break)) YYERROR;
1561            }
1562            currentVoice->ifsw=0;
1563          }
1564        | BREAK_CMD
1565          {
1566            if (exitBuffer(BT_break)) YYERROR;
1567            currentVoice->ifsw=0;
1568          }
1569        | CONTINUE_CMD
1570          {
1571            if (contBuffer(BT_break)) YYERROR;
1572            currentVoice->ifsw=0;
1573          }
1574      ;
1575
1576whilecmd:
1577        WHILE_CMD STRINGTOK BLOCKTOK
1578          {
1579            /* -> if(!$2) break; $3; continue;*/
1580            char * s = (char *)AllocL( strlen($2) + strlen($3) + 36);
1581            sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,$2,$3);
1582            newBuffer(s,BT_break);
1583            FreeL((ADDRESS)$2);
1584            FreeL((ADDRESS)$3);
1585          }
1586        ;
1587
1588forcmd:
1589        FOR_CMD STRINGTOK STRINGTOK STRINGTOK BLOCKTOK
1590          {
1591            /* $2 */
1592            /* if (!$3) break; $5; $4; continue; */
1593            char * s = (char *)AllocL( strlen($3)+strlen($4)+strlen($5)+36);
1594            sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
1595                   ,$3,$5,$4);
1596            FreeL((ADDRESS)$3);
1597            FreeL((ADDRESS)$4);
1598            FreeL((ADDRESS)$5);
1599            newBuffer(s,BT_break);
1600            s = (char *)AllocL( strlen($2) + 3);
1601            sprintf(s,"%s;\n",$2);
1602            FreeL((ADDRESS)$2);
1603            newBuffer(s,BT_if);
1604          }
1605        ;
1606
1607proccmd:
1608        PROC_CMD extendedid BLOCKTOK
1609          {
1610            procinfov pi;
1611            idhdl h = enterid($2,myynest,PROC_CMD,&IDROOT,TRUE);
1612            if (h==NULL) {FreeL((ADDRESS)$3); YYERROR;}
1613            iiInitSingularProcinfo(IDPROC(h),"", $2, 0, 0);
1614            IDPROC(h)->data.s.body = (char *)AllocL(strlen($3)+31);;
1615            sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",$3);
1616            FreeL((ADDRESS)$3);
1617          }
1618        | PROC_DEF STRINGTOK BLOCKTOK
1619          {
1620            idhdl h = enterid($1,myynest,PROC_CMD,&IDROOT,TRUE);
1621            if (h==NULL)
1622            {
1623              FreeL((ADDRESS)$2);
1624              FreeL((ADDRESS)$3);
1625              YYERROR;
1626            }
1627            char *args=iiProcArgs($2,FALSE);
1628            FreeL((ADDRESS)$2);
1629            procinfov pi;
1630            iiInitSingularProcinfo(IDPROC(h),"", $1, 0, 0);
1631            IDPROC(h)->data.s.body = (char *)AllocL(strlen($3)+strlen(args)+14);;
1632            sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,$3);
1633            FreeL((ADDRESS)args);
1634            FreeL((ADDRESS)$3);
1635          }
1636        | PROC_DEF STRINGTOK STRINGTOK BLOCKTOK
1637          {
1638            FreeL((ADDRESS)$3);
1639            idhdl h = enterid($1,myynest,PROC_CMD,&IDROOT,TRUE);
1640            if (h==NULL)
1641            {
1642              FreeL((ADDRESS)$2);
1643              FreeL((ADDRESS)$4);
1644              YYERROR;
1645            }
1646            char *args=iiProcArgs($2,FALSE);
1647            FreeL((ADDRESS)$2);
1648            procinfov pi;
1649            iiInitSingularProcinfo(IDPROC(h),"", $1, 0, 0);
1650            IDPROC(h)->data.s.body = (char *)AllocL(strlen($4)+strlen(args)+14);;
1651            sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,$4);
1652            FreeL((ADDRESS)args);
1653            FreeL((ADDRESS)$4);
1654          }
1655        ;
1656
1657parametercmd:
1658        PARAMETER declare_ip_variable
1659          {
1660            //Print("par:%s, %d\n",$2.Name(),$2.Typ());
1661            //yylineno--;
1662            if (iiParameter(&$2)) YYERROR;
1663          }
1664        | PARAMETER expr
1665          {
1666            //Print("par:%s, %d\n",$2.Name(),$2.Typ());
1667            sleftv tmp_expr;
1668            //yylineno--;
1669            if ((iiDeclCommand(&tmp_expr,&$2,myynest,DEF_CMD,&IDROOT))
1670            || (iiParameter(&tmp_expr)))
1671              YYERROR;
1672          }
1673        ;
1674
1675returncmd:
1676        RETURN '(' exprlist ')'
1677          {
1678            if(iiRETURNEXPR==NULL) YYERROR;
1679            iiRETURNEXPR[myynest].Copy(&$3);
1680            $3.CleanUp();
1681            if (exitBuffer(BT_proc)) YYERROR;
1682          }
1683        | RETURN '(' ')'
1684          {
1685            if ($1==RETURN)
1686            {
1687              if(iiRETURNEXPR==NULL) YYERROR;
1688              iiRETURNEXPR[myynest].Init();
1689              iiRETURNEXPR[myynest].rtyp=NONE;
1690              if (exitBuffer(BT_proc)) YYERROR;
1691            }
1692          }
1693        ;
Note: See TracBrowser for help on using the repository browser.