source: git/Singular/grammar.y @ 6d281ac

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