source: git/Singular/grammar.y @ 4b2155

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