source: git/Singular/grammar.y @ eb84e2

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