source: git/Singular/grammar.y @ ba8e94

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