source: git/Singular/grammar.y @ 85e68dd

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