source: git/Singular/grammar.cc @ ae7cad0

spielwiese
Last change on this file since ae7cad0 was a5a8a1, checked in by Hans Schoenemann <hannes@…>, 13 years ago
trac 343 git-svn-id: file:///usr/local/Singular/svn/trunk@14256 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 125.4 KB
Line 
1/* A Bison parser, made by GNU Bison 1.875d.  */
2
3/* Skeleton parser for Yacc-like parsing with Bison,
4   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   This program is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program; if not, write to the Free Software
18   Foundation, Inc., 59 Temple Place - Suite 330,
19   Boston, MA 02111-1307, USA.  */
20
21/* As a special exception, when this file is copied by Bison into a
22   Bison output file, you may use that output file without restriction.
23   This special exception was added by the Free Software Foundation
24   in version 1.24 of Bison.  */
25
26/* Written by Richard Stallman by simplifying the original so called
27   ``semantic'' parser.  */
28
29/* All symbols defined below should begin with yy or YY, to avoid
30   infringing on user name space.  This should be done even for local
31   variables, as they might otherwise be expanded by user macros.
32   There are some unavoidable exceptions within include files to
33   define necessary library symbols; they are noted "INFRINGES ON
34   USER NAME SPACE" below.  */
35
36/* Identify Bison output.  */
37#define YYBISON 1
38
39/* Skeleton name.  */
40#define YYSKELETON_NAME "yacc.c"
41
42/* Pure parsers.  */
43#define YYPURE 1
44
45/* Using locations.  */
46#define YYLSP_NEEDED 0
47
48
49
50/* Tokens.  */
51#ifndef YYTOKENTYPE
52# define YYTOKENTYPE
53   /* Put the tokens into the symbol table, so that GDB and other debuggers
54      know about them.  */
55   enum yytokentype {
56     DOTDOT = 258,
57     EQUAL_EQUAL = 259,
58     GE = 260,
59     LE = 261,
60     MINUSMINUS = 262,
61     NOT = 263,
62     NOTEQUAL = 264,
63     PLUSPLUS = 265,
64     COLONCOLON = 266,
65     GRING_CMD = 267,
66     INTMAT_CMD = 268,
67     PROC_CMD = 269,
68     RING_CMD = 270,
69     BEGIN_RING = 271,
70     IDEAL_CMD = 272,
71     MAP_CMD = 273,
72     MATRIX_CMD = 274,
73     MODUL_CMD = 275,
74     NUMBER_CMD = 276,
75     POLY_CMD = 277,
76     RESOLUTION_CMD = 278,
77     VECTOR_CMD = 279,
78     BETTI_CMD = 280,
79     COEFFS_CMD = 281,
80     COEF_CMD = 282,
81     CONTRACT_CMD = 283,
82     DEGREE_CMD = 284,
83     DEG_CMD = 285,
84     DIFF_CMD = 286,
85     DIM_CMD = 287,
86     DIVISION_CMD = 288,
87     ELIMINATION_CMD = 289,
88     E_CMD = 290,
89     FAREY_CMD = 291,
90     FETCH_CMD = 292,
91     FREEMODULE_CMD = 293,
92     KEEPRING_CMD = 294,
93     HILBERT_CMD = 295,
94     HOMOG_CMD = 296,
95     IMAP_CMD = 297,
96     INDEPSET_CMD = 298,
97     INTERRED_CMD = 299,
98     INTERSECT_CMD = 300,
99     JACOB_CMD = 301,
100     JET_CMD = 302,
101     KBASE_CMD = 303,
102     KOSZUL_CMD = 304,
103     LEADCOEF_CMD = 305,
104     LEADEXP_CMD = 306,
105     LEAD_CMD = 307,
106     LEADMONOM_CMD = 308,
107     LIFTSTD_CMD = 309,
108     LIFT_CMD = 310,
109     MAXID_CMD = 311,
110     MINBASE_CMD = 312,
111     MINOR_CMD = 313,
112     MINRES_CMD = 314,
113     MODULO_CMD = 315,
114     MONOM_CMD = 316,
115     MRES_CMD = 317,
116     MULTIPLICITY_CMD = 318,
117     ORD_CMD = 319,
118     PAR_CMD = 320,
119     PARDEG_CMD = 321,
120     PREIMAGE_CMD = 322,
121     QUOTIENT_CMD = 323,
122     QHWEIGHT_CMD = 324,
123     REDUCE_CMD = 325,
124     REGULARITY_CMD = 326,
125     RES_CMD = 327,
126     SIMPLIFY_CMD = 328,
127     SORTVEC_CMD = 329,
128     SRES_CMD = 330,
129     STD_CMD = 331,
130     SUBST_CMD = 332,
131     SYZYGY_CMD = 333,
132     VAR_CMD = 334,
133     VDIM_CMD = 335,
134     WEDGE_CMD = 336,
135     WEIGHT_CMD = 337,
136     VALTVARS = 338,
137     VMAXDEG = 339,
138     VMAXMULT = 340,
139     VNOETHER = 341,
140     VMINPOLY = 342,
141     END_RING = 343,
142     CMD_1 = 344,
143     CMD_2 = 345,
144     CMD_3 = 346,
145     CMD_12 = 347,
146     CMD_13 = 348,
147     CMD_23 = 349,
148     CMD_123 = 350,
149     CMD_M = 351,
150     ROOT_DECL = 352,
151     ROOT_DECL_LIST = 353,
152     RING_DECL = 354,
153     EXAMPLE_CMD = 355,
154     EXPORT_CMD = 356,
155     HELP_CMD = 357,
156     KILL_CMD = 358,
157     LIB_CMD = 359,
158     LISTVAR_CMD = 360,
159     SETRING_CMD = 361,
160     TYPE_CMD = 362,
161     STRINGTOK = 363,
162     BLOCKTOK = 364,
163     INT_CONST = 365,
164     UNKNOWN_IDENT = 366,
165     RINGVAR = 367,
166     PROC_DEF = 368,
167     BREAK_CMD = 369,
168     CONTINUE_CMD = 370,
169     ELSE_CMD = 371,
170     EVAL = 372,
171     QUOTE = 373,
172     FOR_CMD = 374,
173     IF_CMD = 375,
174     SYS_BREAK = 376,
175     WHILE_CMD = 377,
176     RETURN = 378,
177     PARAMETER = 379,
178     SYSVAR = 380,
179     UMINUS = 381
180   };
181#endif
182#define DOTDOT 258
183#define EQUAL_EQUAL 259
184#define GE 260
185#define LE 261
186#define MINUSMINUS 262
187#define NOT 263
188#define NOTEQUAL 264
189#define PLUSPLUS 265
190#define COLONCOLON 266
191#define GRING_CMD 267
192#define INTMAT_CMD 268
193#define PROC_CMD 269
194#define RING_CMD 270
195#define BEGIN_RING 271
196#define IDEAL_CMD 272
197#define MAP_CMD 273
198#define MATRIX_CMD 274
199#define MODUL_CMD 275
200#define NUMBER_CMD 276
201#define POLY_CMD 277
202#define RESOLUTION_CMD 278
203#define VECTOR_CMD 279
204#define BETTI_CMD 280
205#define COEFFS_CMD 281
206#define COEF_CMD 282
207#define CONTRACT_CMD 283
208#define DEGREE_CMD 284
209#define DEG_CMD 285
210#define DIFF_CMD 286
211#define DIM_CMD 287
212#define DIVISION_CMD 288
213#define ELIMINATION_CMD 289
214#define E_CMD 290
215#define FAREY_CMD 291
216#define FETCH_CMD 292
217#define FREEMODULE_CMD 293
218#define KEEPRING_CMD 294
219#define HILBERT_CMD 295
220#define HOMOG_CMD 296
221#define IMAP_CMD 297
222#define INDEPSET_CMD 298
223#define INTERRED_CMD 299
224#define INTERSECT_CMD 300
225#define JACOB_CMD 301
226#define JET_CMD 302
227#define KBASE_CMD 303
228#define KOSZUL_CMD 304
229#define LEADCOEF_CMD 305
230#define LEADEXP_CMD 306
231#define LEAD_CMD 307
232#define LEADMONOM_CMD 308
233#define LIFTSTD_CMD 309
234#define LIFT_CMD 310
235#define MAXID_CMD 311
236#define MINBASE_CMD 312
237#define MINOR_CMD 313
238#define MINRES_CMD 314
239#define MODULO_CMD 315
240#define MONOM_CMD 316
241#define MRES_CMD 317
242#define MULTIPLICITY_CMD 318
243#define ORD_CMD 319
244#define PAR_CMD 320
245#define PARDEG_CMD 321
246#define PREIMAGE_CMD 322
247#define QUOTIENT_CMD 323
248#define QHWEIGHT_CMD 324
249#define REDUCE_CMD 325
250#define REGULARITY_CMD 326
251#define RES_CMD 327
252#define SIMPLIFY_CMD 328
253#define SORTVEC_CMD 329
254#define SRES_CMD 330
255#define STD_CMD 331
256#define SUBST_CMD 332
257#define SYZYGY_CMD 333
258#define VAR_CMD 334
259#define VDIM_CMD 335
260#define WEDGE_CMD 336
261#define WEIGHT_CMD 337
262#define VALTVARS 338
263#define VMAXDEG 339
264#define VMAXMULT 340
265#define VNOETHER 341
266#define VMINPOLY 342
267#define END_RING 343
268#define CMD_1 344
269#define CMD_2 345
270#define CMD_3 346
271#define CMD_12 347
272#define CMD_13 348
273#define CMD_23 349
274#define CMD_123 350
275#define CMD_M 351
276#define ROOT_DECL 352
277#define ROOT_DECL_LIST 353
278#define RING_DECL 354
279#define EXAMPLE_CMD 355
280#define EXPORT_CMD 356
281#define HELP_CMD 357
282#define KILL_CMD 358
283#define LIB_CMD 359
284#define LISTVAR_CMD 360
285#define SETRING_CMD 361
286#define TYPE_CMD 362
287#define STRINGTOK 363
288#define BLOCKTOK 364
289#define INT_CONST 365
290#define UNKNOWN_IDENT 366
291#define RINGVAR 367
292#define PROC_DEF 368
293#define BREAK_CMD 369
294#define CONTINUE_CMD 370
295#define ELSE_CMD 371
296#define EVAL 372
297#define QUOTE 373
298#define FOR_CMD 374
299#define IF_CMD 375
300#define SYS_BREAK 376
301#define WHILE_CMD 377
302#define RETURN 378
303#define PARAMETER 379
304#define SYSVAR 380
305#define UMINUS 381
306
307
308
309
310/* Copy the first part of user declarations.  */
311#line 8 "grammar.y"
312
313
314#include <stdio.h>
315#include <stddef.h>
316#include <stdlib.h>
317#include <stdarg.h>
318#include <string.h>
319
320#include <kernel/mod2.h>
321#include <omalloc/mylimits.h>
322#include <omalloc/omalloc.h>
323#include <Singular/tok.h>
324#include <kernel/options.h>
325#include <Singular/stype.h>
326#include <Singular/ipid.h>
327#include <kernel/intvec.h>
328#include <kernel/febase.h>
329#include <kernel/matpol.h>
330#include <kernel/ring.h>
331#include <kernel/kstd1.h>
332#include <Singular/subexpr.h>
333#include <Singular/ipshell.h>
334#include <Singular/ipconv.h>
335#include <Singular/sdb.h>
336#include <kernel/ideals.h>
337#include <kernel/numbers.h>
338#include <kernel/polys.h>
339#include <kernel/stairc.h>
340#include <kernel/timer.h>
341#include <Singular/cntrlc.h>
342#include <kernel/maps.h>
343#include <kernel/syz.h>
344#include <Singular/lists.h>
345#include <kernel/longrat.h>
346#include <Singular/libparse.h>
347
348#if 0
349void debug_list(leftv v)
350{
351  idhdl r=basePackHdl;
352  idhdl h;
353  BOOLEAN found=FALSE;
354  const char *nn=v->name;
355  h=IDROOT->get(nn,myynest);
356  if (h!=NULL)
357  {
358     Print("Curr::%s, (%s)\n",nn,Tok2Cmdname((int)IDTYP(h)));
359     found=TRUE;
360  }
361  else         Print("`%s` not found in IDROOT\n",nn);
362  while (r!=NULL)
363  {
364    if ((IDTYP(r)==PACKAGE_CMD)
365    || (IDTYP(r)==RING_CMD)
366    || (IDTYP(r)==QRING_CMD))
367    {
368      h=IDPACKAGE(r)->idroot->get(nn,myynest);
369      if (h!=NULL)
370      {
371        Print("%s::%s, (%s)\n",r->id,nn,Tok2Cmdname((int)IDTYP(h)));
372        found=TRUE;
373      }
374      else         Print("%s::%s not found\n",r->id,nn);
375    }
376    if (r==basePackHdl) r=IDPACKAGE(r)->idroot;
377    r=r->next;
378   if (r==basePackHdl) break;
379  }
380  if (!found)
381  {
382    listall(TRUE);
383  }
384}
385#endif
386
387/* From the bison docu:
388
389     By defining the macro `YYMAXDEPTH', you can control how deep the
390parser stack can become before a stack overflow occurs.  Define the
391macro with a value that is an integer.  This value is the maximum number
392of tokens that can be shifted (and not reduced) before overflow.  It
393must be a constant expression whose value is known at compile time.
394
395   The stack space allowed is not necessarily allocated.  If you
396specify a large value for `YYMAXDEPTH', the parser actually allocates a
397small stack at first, and then makes it bigger by stages as needed.
398This increasing allocation happens automatically and silently.
399Therefore, you do not need to make `YYMAXDEPTH' painfully small merely
400to save space for ordinary inputs that do not need much stack.
401
402   The default value of `YYMAXDEPTH', if you do not define it, is 10000.
403*/
404#define YYMAXDEPTH INT_MAX
405
406extern int   yylineno;
407extern FILE* yyin;
408
409char       my_yylinebuf[80];
410const  char *  currid;
411BOOLEAN    yyInRingConstruction=FALSE;
412BOOLEAN    expected_parms;
413int        cmdtok;
414int        inerror = 0;
415
416#define TESTSETINT(a,i)                                \
417   if ((a).Typ() != INT_CMD)                           \
418   {                                                   \
419     WerrorS("no int expression");                     \
420     YYERROR;                                          \
421   }                                                   \
422   (i) = (int)((long)(a).Data());
423
424#define MYYERROR(a) { WerrorS(a); YYERROR; }
425
426void yyerror(const char * fmt)
427{
428
429  BOOLEAN old_errorreported=errorreported;
430  errorreported = TRUE;
431  if (currid!=NULL)
432  {
433    killid(currid,&IDROOT);
434    currid = NULL;
435  }
436  if(inerror==0)
437  {
438    {
439      if ((strlen(fmt)>1)
440      && (strncmp(fmt,"parse",5)!=0)
441      && (strncmp(fmt,"syntax",6)!=0))
442        WerrorS(fmt);
443      Werror( "error occurred in or before %s line %d: `%s`"
444             ,VoiceName(), yylineno, my_yylinebuf);
445    }
446    if (cmdtok!=0)
447    {
448      const char *s=Tok2Cmdname(cmdtok);
449      if (expected_parms)
450      {
451        Werror("expected %s-expression. type \'help %s;\'",s,s);
452      }
453      else
454      {
455        Werror("wrong type declaration. type \'help %s;\'",s);
456      }
457    }
458    if (!old_errorreported && (lastreserved!=NULL))
459    {
460      Werror("last reserved name was `%s`",lastreserved);
461    }
462    inerror=1;
463  }
464  if ((currentVoice!=NULL)
465  && (currentVoice->prev!=NULL)
466  && (myynest>0)
467#ifdef HAVE_SDB
468  && ((sdb_flags &1)==0)
469#endif
470  )
471  {
472    Werror("leaving %s",VoiceName());
473  }
474  #ifdef HAVE_FACTORY
475  // libfac:
476  extern int libfac_interruptflag;
477  libfac_interruptflag=0;
478  #endif
479}
480
481
482
483/* Enabling traces.  */
484#ifndef YYDEBUG
485# define YYDEBUG 1
486#endif
487
488/* Enabling verbose error messages.  */
489#ifdef YYERROR_VERBOSE
490# undef YYERROR_VERBOSE
491# define YYERROR_VERBOSE 1
492#else
493# define YYERROR_VERBOSE 0
494#endif
495
496#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
497typedef int YYSTYPE;
498# define yystype YYSTYPE /* obsolescent; will be withdrawn */
499# define YYSTYPE_IS_DECLARED 1
500# define YYSTYPE_IS_TRIVIAL 1
501#endif
502
503
504
505/* Copy the second part of user declarations.  */
506
507
508/* Line 214 of yacc.c.  */
509#line 510 "grammar.cc"
510
511#if ! defined (yyoverflow) || YYERROR_VERBOSE
512
513# ifndef YYFREE
514#  define YYFREE free
515# endif
516# ifndef YYMALLOC
517#  define YYMALLOC malloc
518# endif
519
520/* The parser invokes alloca or malloc; define the necessary symbols.  */
521
522# ifdef YYSTACK_USE_ALLOCA
523#  if YYSTACK_USE_ALLOCA
524#   define YYSTACK_ALLOC alloca
525#  endif
526# else
527#  if defined (alloca) || defined (_ALLOCA_H)
528#   define YYSTACK_ALLOC alloca
529#  else
530#   ifdef __GNUC__
531#    define YYSTACK_ALLOC __builtin_alloca
532#   endif
533#  endif
534# endif
535
536# ifdef YYSTACK_ALLOC
537   /* Pacify GCC's `empty if-body' warning. */
538#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
539# else
540#  if defined (__STDC__) || defined (__cplusplus)
541#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
542#   define YYSIZE_T size_t
543#  endif
544#  define YYSTACK_ALLOC YYMALLOC
545#  define YYSTACK_FREE YYFREE
546# endif
547#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
548
549
550#if (! defined (yyoverflow) \
551     && (! defined (__cplusplus) \
552         || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
553
554/* A type that is properly aligned for any stack member.  */
555union yyalloc
556{
557  short int yyss;
558  YYSTYPE yyvs;
559  };
560
561/* The size of the maximum gap between one aligned stack and the next.  */
562# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
563
564/* The size of an array large to enough to hold all stacks, each with
565   N elements.  */
566# define YYSTACK_BYTES(N) \
567     ((N) * (sizeof (short int) + sizeof (YYSTYPE))                     \
568      + YYSTACK_GAP_MAXIMUM)
569
570/* Copy COUNT objects from FROM to TO.  The source and destination do
571   not overlap.  */
572# ifndef YYCOPY
573#  if defined (__GNUC__) && 1 < __GNUC__
574#   define YYCOPY(To, From, Count) \
575      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
576#  else
577#   define YYCOPY(To, From, Count)              \
578      do                                        \
579        {                                       \
580          register YYSIZE_T yyi;                \
581          for (yyi = 0; yyi < (Count); yyi++)   \
582            (To)[yyi] = (From)[yyi];            \
583        }                                       \
584      while (0)
585#  endif
586# endif
587
588/* Relocate STACK from its old location to the new one.  The
589   local variables YYSIZE and YYSTACKSIZE give the old and new number of
590   elements in the stack, and YYPTR gives the new location of the
591   stack.  Advance YYPTR to a properly aligned location for the next
592   stack.  */
593# define YYSTACK_RELOCATE(Stack)                                        \
594    do                                                                  \
595      {                                                                 \
596        YYSIZE_T yynewbytes;                                            \
597        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
598        Stack = &yyptr->Stack;                                          \
599        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
600        yyptr += yynewbytes / sizeof (*yyptr);                          \
601      }                                                                 \
602    while (0)
603
604#endif
605
606#if defined (__STDC__) || defined (__cplusplus)
607   typedef signed char yysigned_char;
608#else
609   typedef short int yysigned_char;
610#endif
611
612/* YYFINAL -- State number of the termination state. */
613#define YYFINAL  2
614/* YYLAST -- Last index in YYTABLE.  */
615#define YYLAST   1957
616
617/* YYNTOKENS -- Number of terminals. */
618#define YYNTOKENS  145
619/* YYNNTS -- Number of nonterminals. */
620#define YYNNTS  44
621/* YYNRULES -- Number of rules. */
622#define YYNRULES  169
623/* YYNRULES -- Number of states. */
624#define YYNSTATES  375
625
626/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
627#define YYUNDEFTOK  2
628#define YYMAXUTOK   381
629
630#define YYTRANSLATE(YYX)                                                \
631  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
632
633/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
634static const unsigned char yytranslate[] =
635{
636       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
637       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
638       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
639       2,     2,     2,     2,     2,     2,     2,     2,   137,     2,
640     141,   142,   139,   129,   135,   130,   143,   131,     2,     2,
641       2,     2,     2,     2,     2,     2,     2,     2,   138,   136,
642     127,   126,   128,     2,     2,     2,     2,     2,     2,     2,
643       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
644       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
645       2,   132,     2,   133,   134,     2,   144,     2,     2,     2,
646       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
647       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
648       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
649       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
650       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
651       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
652       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
653       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
654       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
655       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
656       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
657       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
658       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
659       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
660       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
661       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
662       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
663      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
664      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
665      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
666      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
667      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
668      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
669      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
670      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
671      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
672     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
673     115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
674     125,   140
675};
676
677#if YYDEBUG
678/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
679   YYRHS.  */
680static const unsigned short int yyprhs[] =
681{
682       0,     0,     3,     4,     7,     9,    12,    15,    17,    19,
683      21,    24,    26,    28,    30,    32,    34,    36,    38,    40,
684      43,    45,    47,    49,    51,    53,    55,    57,    59,    61,
685      64,    66,    68,    72,    76,    80,    85,    89,    91,    93,
686      95,   100,   104,   106,   108,   110,   114,   121,   126,   131,
687     136,   140,   145,   150,   154,   159,   166,   175,   182,   191,
688     196,   201,   208,   213,   220,   229,   238,   242,   247,   256,
689     261,   270,   275,   284,   289,   293,   299,   300,   306,   309,
690     311,   314,   317,   321,   325,   329,   333,   337,   341,   345,
691     349,   353,   357,   360,   363,   366,   369,   371,   375,   377,
692     379,   382,   385,   388,   391,   400,   403,   412,   415,   419,
693     422,   424,   426,   432,   434,   436,   441,   443,   447,   449,
694     453,   455,   456,   461,   465,   468,   472,   475,   478,   482,
695     487,   492,   497,   502,   507,   512,   517,   522,   527,   534,
696     541,   548,   555,   562,   569,   576,   583,   587,   589,   598,
697     601,   604,   606,   608,   611,   614,   616,   622,   625,   631,
698     633,   635,   639,   645,   649,   653,   658,   661,   664,   669
699};
700
701/* YYRHS -- A `-1'-separated list of the rules' RHS. */
702static const short int yyrhs[] =
703{
704     146,     0,    -1,    -1,   146,   147,    -1,   148,    -1,   150,
705     136,    -1,   162,   136,    -1,   188,    -1,   121,    -1,   136,
706      -1,     1,   136,    -1,   183,    -1,   184,    -1,   149,    -1,
707     185,    -1,   186,    -1,   170,    -1,   172,    -1,   173,    -1,
708     100,   109,    -1,   151,    -1,   174,    -1,   175,    -1,   176,
709      -1,   187,    -1,   178,    -1,   179,    -1,   181,    -1,   182,
710      -1,   159,   153,    -1,   112,    -1,   160,    -1,   152,    11,
711     152,    -1,   152,   143,   152,    -1,   152,   141,   142,    -1,
712     152,   141,   153,   142,    -1,   132,   153,   133,    -1,   110,
713      -1,   125,    -1,   163,    -1,    14,   141,   154,   142,    -1,
714     153,   135,   154,    -1,   154,    -1,   158,    -1,   152,    -1,
715     141,   153,   142,    -1,   154,   132,   154,   135,   154,   133,
716      -1,   154,   132,   154,   133,    -1,    97,   141,   154,   142,
717      -1,    98,   141,   153,   142,    -1,    98,   141,   142,    -1,
718      99,   141,   154,   142,    -1,   161,   141,   153,   142,    -1,
719     161,   141,   142,    -1,    89,   141,   154,   142,    -1,    90,
720     141,   154,   135,   154,   142,    -1,    91,   141,   154,   135,
721     154,   135,   154,   142,    -1,    94,   141,   154,   135,   154,
722     142,    -1,    94,   141,   154,   135,   154,   135,   154,   142,
723      -1,    92,   141,   154,   142,    -1,    93,   141,   154,   142,
724      -1,    92,   141,   154,   135,   154,   142,    -1,    95,   141,
725     154,   142,    -1,    95,   141,   154,   135,   154,   142,    -1,
726      93,   141,   154,   135,   154,   135,   154,   142,    -1,    95,
727     141,   154,   135,   154,   135,   154,   142,    -1,    96,   141,
728     142,    -1,    96,   141,   153,   142,    -1,    19,   141,   154,
729     135,   154,   135,   154,   142,    -1,    19,   141,   154,   142,
730      -1,    13,   141,   154,   135,   154,   135,   154,   142,    -1,
731      13,   141,   154,   142,    -1,    15,   141,   164,   135,   164,
732     135,   168,   142,    -1,    15,   141,   154,   142,    -1,   156,
733     154,   157,    -1,   156,   154,   126,   154,   157,    -1,    -1,
734     117,   141,   155,   154,   142,    -1,   118,   141,    -1,   142,
735      -1,   154,    10,    -1,   154,     7,    -1,   154,   129,   154,
736      -1,   154,   130,   154,    -1,   154,   131,   154,    -1,   154,
737     134,   154,    -1,   154,   127,   154,    -1,   154,   137,   154,
738      -1,   154,     9,   154,    -1,   154,     4,   154,    -1,   154,
739       3,   154,    -1,   154,   138,   154,    -1,     8,   154,    -1,
740     130,   154,    -1,   162,   169,    -1,   153,   126,    -1,   111,
741      -1,   144,   154,   144,    -1,    17,    -1,    20,    -1,    97,
742     152,    -1,    98,   152,    -1,    99,   152,    -1,   161,   152,
743      -1,    19,   152,   132,   154,   133,   132,   154,   133,    -1,
744      19,   152,    -1,    13,   152,   132,   154,   133,   132,   154,
745     133,    -1,    13,   152,    -1,   162,   135,   152,    -1,    14,
746     152,    -1,   108,    -1,   154,    -1,   141,   154,   135,   153,
747     142,    -1,   111,    -1,   165,    -1,   165,   141,   153,   142,
748      -1,   166,    -1,   166,   135,   167,    -1,   166,    -1,   141,
749     167,   142,    -1,   126,    -1,    -1,   127,   163,   171,   136,
750      -1,   102,   108,   136,    -1,   102,   136,    -1,   100,   108,
751     136,    -1,   101,   153,    -1,   103,   152,    -1,   175,   135,
752     152,    -1,   105,   141,    97,   142,    -1,   105,   141,    98,
753     142,    -1,   105,   141,    99,   142,    -1,   105,   141,   161,
754     142,    -1,   105,   141,    15,   142,    -1,   105,   141,    19,
755     142,    -1,   105,   141,    13,   142,    -1,   105,   141,    14,
756     142,    -1,   105,   141,   152,   142,    -1,   105,   141,   152,
757     135,    97,   142,    -1,   105,   141,   152,   135,    98,   142,
758      -1,   105,   141,   152,   135,    99,   142,    -1,   105,   141,
759     152,   135,   161,   142,    -1,   105,   141,   152,   135,    15,
760     142,    -1,   105,   141,   152,   135,    19,   142,    -1,   105,
761     141,   152,   135,    13,   142,    -1,   105,   141,   152,   135,
762      14,   142,    -1,   105,   141,   142,    -1,    15,    -1,   177,
763     152,   169,   164,   135,   164,   135,   168,    -1,   177,   152,
764      -1,   125,   163,    -1,   106,    -1,    39,    -1,   180,   154,
765      -1,   107,   154,    -1,   153,    -1,   120,   141,   154,   142,
766     109,    -1,   116,   109,    -1,   120,   141,   154,   142,   114,
767      -1,   114,    -1,   115,    -1,   122,   108,   109,    -1,   119,
768     108,   108,   108,   109,    -1,    14,   160,   109,    -1,   113,
769     108,   109,    -1,   113,   108,   108,   109,    -1,   124,   162,
770      -1,   124,   154,    -1,   123,   141,   153,   142,    -1,   123,
771     141,   142,    -1
772};
773
774/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
775static const unsigned short int yyrline[] =
776{
777       0,   357,   357,   359,   393,   394,   396,   398,   402,   407,
778     409,   460,   461,   462,   463,   464,   465,   466,   467,   471,
779     474,   475,   476,   477,   478,   479,   480,   481,   482,   485,
780     492,   497,   501,   505,   509,   513,   526,   554,   578,   584,
781     590,   597,   608,   614,   619,   620,   621,   625,   629,   633,
782     637,   641,   645,   649,   653,   657,   661,   665,   669,   673,
783     677,   681,   685,   689,   693,   697,   701,   705,   709,   713,
784     717,   721,   725,   729,   733,   737,   755,   754,   772,   780,
785     789,   793,   797,   801,   805,   809,   813,   817,   821,   825,
786     829,   833,   837,   844,   851,   852,   871,   872,   884,   884,
787     889,   894,   899,   903,   907,   923,   927,   943,   957,   978,
788     986,   990,   991,  1005,  1013,  1022,  1067,  1068,  1077,  1078,
789    1084,  1097,  1096,  1104,  1109,  1116,  1124,  1136,  1152,  1171,
790    1175,  1179,  1184,  1188,  1192,  1196,  1200,  1204,  1209,  1215,
791    1221,  1227,  1233,  1239,  1245,  1251,  1263,  1270,  1274,  1312,
792    1322,  1335,  1335,  1338,  1410,  1419,  1448,  1461,  1478,  1487,
793    1492,  1500,  1512,  1531,  1542,  1562,  1586,  1592,  1604,  1611
794};
795#endif
796
797#if YYDEBUG || YYERROR_VERBOSE
798/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
799   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
800static const char *const yytname[] =
801{
802  "$end", "error", "$undefined", "DOTDOT", "EQUAL_EQUAL", "GE", "LE",
803  "MINUSMINUS", "NOT", "NOTEQUAL", "PLUSPLUS", "COLONCOLON", "GRING_CMD",
804  "INTMAT_CMD", "PROC_CMD", "RING_CMD", "BEGIN_RING", "IDEAL_CMD",
805  "MAP_CMD", "MATRIX_CMD", "MODUL_CMD", "NUMBER_CMD", "POLY_CMD",
806  "RESOLUTION_CMD", "VECTOR_CMD", "BETTI_CMD", "COEFFS_CMD", "COEF_CMD",
807  "CONTRACT_CMD", "DEGREE_CMD", "DEG_CMD", "DIFF_CMD", "DIM_CMD",
808  "DIVISION_CMD", "ELIMINATION_CMD", "E_CMD", "FAREY_CMD", "FETCH_CMD",
809  "FREEMODULE_CMD", "KEEPRING_CMD", "HILBERT_CMD", "HOMOG_CMD", "IMAP_CMD",
810  "INDEPSET_CMD", "INTERRED_CMD", "INTERSECT_CMD", "JACOB_CMD", "JET_CMD",
811  "KBASE_CMD", "KOSZUL_CMD", "LEADCOEF_CMD", "LEADEXP_CMD", "LEAD_CMD",
812  "LEADMONOM_CMD", "LIFTSTD_CMD", "LIFT_CMD", "MAXID_CMD", "MINBASE_CMD",
813  "MINOR_CMD", "MINRES_CMD", "MODULO_CMD", "MONOM_CMD", "MRES_CMD",
814  "MULTIPLICITY_CMD", "ORD_CMD", "PAR_CMD", "PARDEG_CMD", "PREIMAGE_CMD",
815  "QUOTIENT_CMD", "QHWEIGHT_CMD", "REDUCE_CMD", "REGULARITY_CMD",
816  "RES_CMD", "SIMPLIFY_CMD", "SORTVEC_CMD", "SRES_CMD", "STD_CMD",
817  "SUBST_CMD", "SYZYGY_CMD", "VAR_CMD", "VDIM_CMD", "WEDGE_CMD",
818  "WEIGHT_CMD", "VALTVARS", "VMAXDEG", "VMAXMULT", "VNOETHER", "VMINPOLY",
819  "END_RING", "CMD_1", "CMD_2", "CMD_3", "CMD_12", "CMD_13", "CMD_23",
820  "CMD_123", "CMD_M", "ROOT_DECL", "ROOT_DECL_LIST", "RING_DECL",
821  "EXAMPLE_CMD", "EXPORT_CMD", "HELP_CMD", "KILL_CMD", "LIB_CMD",
822  "LISTVAR_CMD", "SETRING_CMD", "TYPE_CMD", "STRINGTOK", "BLOCKTOK",
823  "INT_CONST", "UNKNOWN_IDENT", "RINGVAR", "PROC_DEF", "BREAK_CMD",
824  "CONTINUE_CMD", "ELSE_CMD", "EVAL", "QUOTE", "FOR_CMD", "IF_CMD",
825  "SYS_BREAK", "WHILE_CMD", "RETURN", "PARAMETER", "SYSVAR", "'='", "'<'",
826  "'>'", "'+'", "'-'", "'/'", "'['", "']'", "'^'", "','", "';'", "'&'",
827  "':'", "'*'", "UMINUS", "'('", "')'", "'.'", "'`'", "$accept", "lines",
828  "pprompt", "flowctrl", "example_dummy", "command", "assign", "elemexpr",
829  "exprlist", "expr", "@1", "quote_start", "quote_end", "expr_arithmetic",
830  "left_value", "extendedid", "currring_lists", "declare_ip_variable",
831  "stringexpr", "rlist", "ordername", "orderelem", "OrderingList",
832  "ordering", "cmdeq", "filecmd", "@2", "helpcmd", "examplecmd",
833  "exportcmd", "killcmd", "listcmd", "ringcmd1", "ringcmd", "scriptcmd",
834  "setrings", "setringcmd", "typecmd", "ifcmd", "whilecmd", "forcmd",
835  "proccmd", "parametercmd", "returncmd", 0
836};
837#endif
838
839# ifdef YYPRINT
840/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
841   token YYLEX-NUM.  */
842static const unsigned short int yytoknum[] =
843{
844       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
845     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
846     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
847     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
848     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
849     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
850     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
851     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
852     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
853     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
854     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
855     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
856     375,   376,   377,   378,   379,   380,    61,    60,    62,    43,
857      45,    47,    91,    93,    94,    44,    59,    38,    58,    42,
858     381,    40,    41,    46,    96
859};
860# endif
861
862/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
863static const unsigned char yyr1[] =
864{
865       0,   145,   146,   146,   147,   147,   147,   147,   147,   147,
866     147,   148,   148,   148,   148,   148,   148,   148,   148,   149,
867     150,   150,   150,   150,   150,   150,   150,   150,   150,   151,
868     152,   152,   152,   152,   152,   152,   152,   152,   152,   152,
869     152,   153,   153,   154,   154,   154,   154,   154,   154,   154,
870     154,   154,   154,   154,   154,   154,   154,   154,   154,   154,
871     154,   154,   154,   154,   154,   154,   154,   154,   154,   154,
872     154,   154,   154,   154,   154,   154,   155,   154,   156,   157,
873     158,   158,   158,   158,   158,   158,   158,   158,   158,   158,
874     158,   158,   158,   158,   159,   159,   160,   160,   161,   161,
875     162,   162,   162,   162,   162,   162,   162,   162,   162,   162,
876     163,   164,   164,   165,   166,   166,   167,   167,   168,   168,
877     169,   171,   170,   172,   172,   173,   174,   175,   175,   176,
878     176,   176,   176,   176,   176,   176,   176,   176,   176,   176,
879     176,   176,   176,   176,   176,   176,   176,   177,   178,   178,
880     179,   180,   180,   181,   182,   182,   183,   183,   183,   183,
881     183,   184,   185,   186,   186,   186,   187,   187,   188,   188
882};
883
884/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
885static const unsigned char yyr2[] =
886{
887       0,     2,     0,     2,     1,     2,     2,     1,     1,     1,
888       2,     1,     1,     1,     1,     1,     1,     1,     1,     2,
889       1,     1,     1,     1,     1,     1,     1,     1,     1,     2,
890       1,     1,     3,     3,     3,     4,     3,     1,     1,     1,
891       4,     3,     1,     1,     1,     3,     6,     4,     4,     4,
892       3,     4,     4,     3,     4,     6,     8,     6,     8,     4,
893       4,     6,     4,     6,     8,     8,     3,     4,     8,     4,
894       8,     4,     8,     4,     3,     5,     0,     5,     2,     1,
895       2,     2,     3,     3,     3,     3,     3,     3,     3,     3,
896       3,     3,     2,     2,     2,     2,     1,     3,     1,     1,
897       2,     2,     2,     2,     8,     2,     8,     2,     3,     2,
898       1,     1,     5,     1,     1,     4,     1,     3,     1,     3,
899       1,     0,     4,     3,     2,     3,     2,     2,     3,     4,
900       4,     4,     4,     4,     4,     4,     4,     4,     6,     6,
901       6,     6,     6,     6,     6,     6,     3,     1,     8,     2,
902       2,     1,     1,     2,     2,     1,     5,     2,     5,     1,
903       1,     3,     5,     3,     3,     4,     2,     2,     4,     3
904};
905
906/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
907   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
908   means the default is an error.  */
909static const unsigned char yydefact[] =
910{
911       2,     0,     1,     0,     0,     0,     0,   147,    98,     0,
912      99,   152,     0,     0,     0,     0,     0,     0,     0,     0,
913       0,     0,     0,     0,     0,     0,     0,     0,   151,     0,
914     110,    37,    96,    30,     0,   159,   160,     0,     0,     0,
915       0,     0,     8,     0,     0,     0,    38,     0,     0,     0,
916       9,     0,     0,     3,     4,    13,     0,    20,    44,   155,
917      42,     0,    43,     0,    31,     0,     0,    39,    16,    17,
918      18,    21,    22,    23,     0,    25,    26,     0,    27,    28,
919      11,    12,    14,    15,    24,     7,    10,     0,     0,     0,
920       0,     0,     0,     0,    38,    92,     0,     0,   107,     0,
921     109,    31,     0,     0,   105,     0,     0,     0,     0,     0,
922       0,     0,     0,     0,   100,     0,   101,     0,   102,     0,
923      19,   126,     0,   124,   127,     0,   154,     0,   157,    76,
924      78,     0,     0,     0,     0,     0,   167,   166,   150,   121,
925      93,     0,     0,     0,     5,     0,     0,     0,    95,     0,
926       0,     0,    81,     0,    80,     0,     0,     0,     0,     0,
927       0,     0,     0,     0,    29,     0,   103,   120,     0,     6,
928      94,     0,   149,   153,     0,     0,     0,   163,     0,   111,
929       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
930      66,     0,     0,    50,     0,     0,   125,   123,     0,     0,
931       0,     0,     0,     0,     0,   146,     0,     0,     0,   164,
932       0,     0,     0,   161,   169,     0,     0,    36,    45,    97,
933      32,    34,     0,    33,    41,    90,    89,    88,    86,    82,
934      83,    84,     0,    85,    87,    91,     0,    79,    74,    53,
935       0,   108,   128,     0,     0,    71,     0,    40,    42,    73,
936       0,     0,    69,     0,    54,     0,     0,     0,    59,     0,
937      60,     0,     0,    62,    67,    48,    49,    51,   135,   136,
938     133,   134,   129,   130,   131,     0,   137,   132,   165,     0,
939       0,     0,   168,   122,    35,    47,     0,     0,    52,   111,
940       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
941       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
942       0,    77,   162,   156,   158,     0,    75,     0,     0,     0,
943       0,     0,     0,     0,    55,     0,    61,     0,     0,    57,
944       0,    63,   144,   145,   142,   143,   138,   139,   140,   141,
945      46,     0,     0,     0,   112,   113,     0,   114,   118,     0,
946       0,     0,     0,     0,     0,     0,     0,    70,   106,   116,
947       0,     0,    72,    68,   104,    56,    64,    58,    65,   148,
948       0,   119,     0,   117,   115
949};
950
951/* YYDEFGOTO[NTERM-NUM]. */
952static const short int yydefgoto[] =
953{
954      -1,     1,    53,    54,    55,    56,    57,    58,   142,    60,
955     210,    61,   238,    62,    63,    64,    96,    66,    67,   180,
956     347,   348,   360,   349,   170,    68,   216,    69,    70,    71,
957      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
958      82,    83,    84,    85
959};
960
961/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
962   STATE-NUM.  */
963#define YYPACT_NINF -327
964static const short int yypact[] =
965{
966    -327,   283,  -327,   -79,  1263,   957,  1010,  -126,  -327,  1747,
967    -327,  -327,   -76,   -72,   -55,   -51,   -45,   -44,   -42,   -40,
968    1765,  1770,  1775,  -107,  1263,   -97,   222,   -39,  -327,  1263,
969    -327,  -327,  -327,  -327,    -8,  -327,  -327,    -4,   -35,   -29,
970       0,   -28,  -327,     8,   -23,  1319,    11,    11,  1263,  1263,
971    -327,  1263,  1263,  -327,  -327,  -327,   -14,  -327,     1,   -98,
972    1704,  1263,  -327,  1263,  -327,  1813,   -81,  -327,  -327,  -327,
973    -327,  -327,    -5,  -327,   222,  -327,  -327,  1263,  -327,  -327,
974    -327,  -327,  -327,  -327,  -327,  -327,  -327,    -7,    17,  -126,
975      43,    53,    57,    58,  -327,    23,    61,  1263,    29,  1263,
976       1,    39,  1377,  1263,    60,  1263,  1263,  1263,  1263,  1263,
977    1263,  1263,   903,  1263,     1,  1035,     1,  1263,     1,    68,
978    -327,    70,    73,  -327,     1,  1638,  1704,   -33,  -327,  -327,
979    -327,    98,  1263,    99,  1091,  1010,  1704,    76,  -327,  -327,
980      23,   -61,  -121,    22,  -327,   222,  1149,   222,  -327,  1263,
981    1263,  1263,  -327,  1263,  -327,  1263,  1263,  1263,  1263,  1263,
982    1263,  1263,  1263,   100,    70,  1205,     1,  -327,   222,  -327,
983    -327,   222,    69,  1704,   178,  1263,   496,  -327,  1263,   510,
984      78,   314,  1263,   524,  1396,  1416,   346,   360,  1431,   413,
985    -327,  -108,   563,  -327,  -100,   586,  -327,  -327,    74,   -59,
986      79,    80,    81,    82,    83,  -327,    48,    91,   105,  -327,
987    1263,   107,   600,  -327,  -327,   -92,    84,  -327,  -327,  -327,
988      75,  -327,   -89,  -327,  1704,  1716,   486,   486,   332,    31,
989      31,    23,   946,    54,     9,    31,  1263,  -327,  -327,  -327,
990     -86,     1,     1,  1377,  1263,  -327,  1443,  -327,  1455,  -327,
991    1377,  1263,  -327,  1474,  -327,  1263,  1263,  1263,  -327,  1263,
992    -327,  1263,  1263,  -327,  -327,  -327,  -327,  -327,  -327,  -327,
993    -327,  -327,  -327,  -327,  -327,   -10,  -327,  -327,  -327,   660,
994     126,   -41,  -327,  -327,  -327,  -327,  1263,   674,  -327,  1704,
995     104,  1489,   109,  1263,   110,  1501,   112,   699,  1532,   736,
996    1637,   427,   450,   106,   108,   111,   113,   114,   115,   116,
997     117,  -327,  -327,  -327,  -327,  1668,  -327,  1377,  1263,  1263,
998     -84,  -105,  1263,  1263,  -327,  1263,  -327,  1263,  1263,  -327,
999    1263,  -327,  -327,  -327,  -327,  -327,  -327,  -327,  -327,  -327,
1000    -327,   125,   750,  1680,  -327,  -327,   135,   122,  -327,   123,
1001     764,  1692,   810,   835,   849,   900,  -105,  -327,  -327,   129,
1002     124,  1263,  -327,  -327,  -327,  -327,  -327,  -327,  -327,  -327,
1003     135,  -327,   -75,  -327,  -327
1004};
1005
1006/* YYPGOTO[NTERM-NUM].  */
1007static const short int yypgoto[] =
1008{
1009    -327,  -327,  -327,  -327,  -327,  -327,  -327,    72,    -1,    18,
1010    -327,  -327,   -38,  -327,  -327,   241,     7,   206,    38,  -226,
1011    -327,  -326,  -118,   -85,    95,  -327,  -327,  -327,  -327,  -327,
1012    -327,  -327,  -327,  -327,  -327,  -327,  -327,  -327,  -327,  -327,
1013    -327,  -327,  -327,  -327
1014};
1015
1016/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
1017   positive, shift that token.  If negative, reduce the rule which
1018   number is the opposite.  If zero, do what YYDEFACT says.
1019   If YYTABLE_NINF, syntax error.  */
1020#define YYTABLE_NINF -1
1021static const short int yytable[] =
1022{
1023      59,   119,   120,   303,   304,   305,   345,     8,    65,   306,
1024      10,   122,   145,   151,   149,   102,   152,   290,   153,   154,
1025     359,   218,    95,   121,   294,   150,   151,   149,   148,   152,
1026     152,   153,   154,   154,   264,   149,   346,   149,   152,   123,
1027     145,   154,   266,   149,   359,   167,   149,   126,   141,   149,
1028     282,   149,    65,   284,   168,   169,   288,    86,   344,   145,
1029     149,   152,   164,   136,   154,   105,   140,   374,   313,   106,
1030     143,   145,   217,   314,   149,   208,   209,    98,   100,   163,
1031     145,   104,    99,   269,   138,   139,   107,   307,   308,   309,
1032     108,   341,   114,   116,   118,   173,   109,   110,   124,   111,
1033     127,   112,   125,   150,   151,   128,   129,   152,   131,   153,
1034     154,   191,   130,   132,   194,   174,   133,   176,   134,    30,
1035     179,   181,   144,   183,   184,   185,   186,   187,   188,   189,
1036     171,   192,   207,   215,    97,   195,   155,   166,   156,   157,
1037     158,   159,   146,   160,   147,   222,   172,   162,   177,   155,
1038     212,   156,   157,   158,   159,   159,   160,   160,    99,   161,
1039     162,   175,   158,   159,   240,   160,   219,   224,   225,   226,
1040     146,   227,   147,   228,   229,   230,   231,   232,   233,   234,
1041     235,   150,   151,   275,   103,   152,   159,   153,   154,   146,
1042     276,   147,   182,   246,   113,   167,   248,   206,   115,   117,
1043     253,   146,   165,   147,   196,   149,   211,   100,   213,   197,
1044     146,   168,   147,   250,   278,   280,   268,   220,   147,   223,
1045     283,   270,   271,   272,   273,   274,   236,   155,   279,   156,
1046     157,   158,   159,   277,   160,   312,    88,   161,   162,   317,
1047     241,   319,   237,   242,   323,   321,   345,   101,   332,   316,
1048     333,   137,   373,   334,   287,   335,   336,   337,   338,   339,
1049     356,   289,   291,   361,   370,   362,   371,   243,   289,   295,
1050       0,   369,     0,   297,   298,   299,     0,   300,     0,   301,
1051     302,     0,   310,     2,     3,     0,     0,     0,     0,     0,
1052       0,     4,   320,     0,     0,     0,     5,     6,     7,     0,
1053       8,     0,     9,    10,   315,   155,     0,   156,   157,   158,
1054     159,     0,   160,   244,     0,   161,   162,   150,   151,     0,
1055     245,   152,    11,   153,   154,     0,     0,     0,     0,     0,
1056      30,     0,    31,    32,    33,   289,   342,   343,     0,   152,
1057     350,   351,   154,   352,     0,   353,   354,    94,   355,   150,
1058     151,     0,     0,   152,    49,   153,   154,     0,     0,     0,
1059     372,     0,     0,   150,   151,     0,    52,   152,     0,   153,
1060     154,     0,    12,    13,    14,    15,    16,    17,    18,    19,
1061      20,    21,    22,    23,    24,    25,    26,     0,    27,    28,
1062      29,    30,     0,    31,    32,    33,    34,    35,    36,    37,
1063      38,    39,    40,    41,    42,    43,    44,    45,    46,     0,
1064      47,     0,     0,    48,     0,    49,   150,   151,     0,    50,
1065     152,     0,   153,   154,    51,     0,     0,    52,     0,     0,
1066     150,   151,     0,     0,   152,     0,   153,   154,     0,     0,
1067       0,   155,     0,   156,   157,   158,   159,     0,   160,   251,
1068       0,   161,   162,   150,   151,     0,   252,   152,     0,   153,
1069     154,   156,   157,   158,   159,     0,   160,     0,     0,     0,
1070     162,     0,     0,   155,     0,   156,   157,   158,   159,     0,
1071     160,   257,     0,   161,   162,     0,     0,   155,   258,   156,
1072     157,   158,   159,   152,   160,   259,   154,   161,   162,   150,
1073     151,     0,   260,   152,     0,   153,   154,     0,     0,     0,
1074       0,     0,     0,   150,   151,     0,     0,   152,     0,   153,
1075     154,     0,     0,     0,     0,     0,     0,   150,   151,     0,
1076       0,   152,     0,   153,   154,     0,     0,     0,     0,     0,
1077     155,     0,   156,   157,   158,   159,     0,   160,   262,     0,
1078     161,   162,     0,     0,   155,   263,   156,   157,   158,   159,
1079       0,   160,   328,     0,   161,   162,   150,   151,     0,   329,
1080     152,     0,   153,   154,     0,     0,     0,   155,     0,   156,
1081     157,   158,   159,     0,   160,   330,     0,   161,   162,   150,
1082     151,     0,   331,   152,     0,   153,   154,     0,     0,     0,
1083       0,     0,     0,   150,   151,     0,     0,   152,     0,   153,
1084     154,     0,     0,   155,     0,   156,   157,   158,   159,     0,
1085     160,     0,     0,   155,   162,   156,   157,   158,   159,     0,
1086     160,     0,     0,   161,   162,     0,     0,   155,   247,   156,
1087     157,   158,   159,     0,   160,     0,     0,   161,   162,     0,
1088       0,   155,   249,   156,   157,   158,   159,     0,   160,     0,
1089       0,   161,   162,   150,   151,     0,   254,   152,     0,   153,
1090     154,     0,     0,     0,     0,     0,     0,   150,   151,     0,
1091       0,   152,     0,   153,   154,     0,     0,     0,     0,     0,
1092     155,     0,   156,   157,   158,   159,     0,   160,     0,     0,
1093     161,   162,   150,   151,     0,   265,   152,     0,   153,   154,
1094       0,     0,     0,   155,     0,   156,   157,   158,   159,     0,
1095     160,     0,     0,   161,   162,     0,     0,   155,   267,   156,
1096     157,   158,   159,     0,   160,     0,     0,   161,   162,   150,
1097     151,     0,   281,   152,     0,   153,   154,     0,     0,     0,
1098       0,     0,     0,   150,   151,     0,     0,   152,     0,   153,
1099     154,     0,     0,     0,     0,     0,     0,   150,   151,     0,
1100       0,   152,     0,   153,   154,     0,     0,     0,     0,     0,
1101       0,     0,     0,     0,     0,     0,     0,   155,     0,   156,
1102     157,   158,   159,     0,   160,     0,     0,   161,   162,     0,
1103       0,   155,   311,   156,   157,   158,   159,     0,   160,     0,
1104       0,   161,   162,   150,   151,     0,   237,   152,     0,   153,
1105     154,     0,     0,     0,     0,     0,   155,     0,   156,   157,
1106     158,   159,     0,   160,     0,     0,   161,   162,   150,   151,
1107       0,   324,   152,     0,   153,   154,     0,     0,     0,     0,
1108       0,     0,   150,   151,     0,     0,   152,     0,   153,   154,
1109       0,     0,     0,   155,     0,   156,   157,   158,   159,     0,
1110     160,     0,     0,   161,   162,     0,     0,   155,   326,   156,
1111     157,   158,   159,     0,   160,     0,     0,   161,   162,     0,
1112       0,   155,   357,   156,   157,   158,   159,     0,   160,     0,
1113       0,   161,   162,   150,   151,     0,   363,   152,     0,   153,
1114     154,     4,     0,     0,     0,     0,    87,    88,    89,     0,
1115       8,     0,    90,    10,     0,     0,     0,     0,     0,     0,
1116       0,     0,     0,     0,     0,     0,     0,   155,     0,   156,
1117     157,   158,   159,     0,   160,     0,     0,   161,   162,   150,
1118     151,     0,   365,   152,     0,   153,   154,     0,     0,     0,
1119       0,     0,   155,     0,   156,   157,   158,   159,     0,   160,
1120       0,    88,   161,   162,     0,     0,   155,   366,   156,   157,
1121     158,   159,     0,   160,     0,     0,   161,   162,     0,     0,
1122       0,   367,    12,    13,    14,    15,    16,    17,    18,    19,
1123      91,    92,    93,     0,     0,     0,     0,     0,     0,     0,
1124       0,    30,     0,    31,    32,    33,     0,     0,     0,     0,
1125      38,    39,     0,     0,    88,     0,     0,   155,    94,   156,
1126     157,   158,   159,    48,   160,    49,     0,   161,   162,     0,
1127       0,     0,   368,     4,    51,   190,     0,    52,    87,    88,
1128      89,     0,     8,     0,    90,    10,     0,     0,     0,     0,
1129       0,     0,     0,     0,     0,    30,     0,    31,    32,    33,
1130       0,     0,     0,   155,     0,   156,   157,   158,   159,   285,
1131     160,   286,    94,   161,   162,     0,     0,     0,     0,    49,
1132       0,     0,     0,     0,     0,     0,     0,     0,    97,     4,
1133       0,    52,     0,     0,    87,    88,    89,     0,     8,     0,
1134      90,    10,     0,     0,     0,     0,     0,     0,    30,     0,
1135      31,    32,    33,     0,    12,    13,    14,    15,    16,    17,
1136      18,    19,    91,    92,    93,    94,     0,     0,     0,     0,
1137       0,     0,    49,    30,     0,    31,    32,    33,     0,     0,
1138       0,    99,    38,    39,    52,     0,     0,     4,     0,     0,
1139      94,     0,    87,    88,    89,    48,     8,    49,    90,    10,
1140       0,     0,     0,     0,     0,     0,    51,   193,     0,    52,
1141      12,    13,    14,    15,    16,    17,    18,    19,    91,    92,
1142      93,     0,     0,     0,     0,     0,     0,     0,     0,    30,
1143       0,    31,    32,    33,     0,     0,     0,     0,    38,    39,
1144       0,     0,     0,     4,     0,     0,    94,     0,    87,    88,
1145      89,    48,     8,    49,    90,    10,     0,     0,     0,     0,
1146       0,     0,    51,   214,     0,    52,     0,     0,    12,    13,
1147      14,    15,    16,    17,    18,    19,    91,    92,    93,     0,
1148       0,     0,     0,     0,     0,     0,     0,    30,     0,    31,
1149      32,    33,     0,     0,     0,     0,    38,    39,     0,     0,
1150       0,     4,     0,     0,    94,     0,    87,    88,    89,    48,
1151       8,    49,    90,    10,     0,     0,     0,     0,     0,     0,
1152      51,   221,     0,    52,    12,    13,    14,    15,    16,    17,
1153      18,    19,    91,    92,    93,     0,     0,     0,     0,     0,
1154       0,     0,     0,    30,     0,    31,    32,    33,     0,     0,
1155       0,     0,    38,    39,     0,     0,     0,     4,     0,     0,
1156      94,     0,     5,   135,    89,    48,     8,    49,     9,    10,
1157       0,     0,     0,     0,     0,     0,    51,   239,     0,    52,
1158       0,     0,    12,    13,    14,    15,    16,    17,    18,    19,
1159      91,    92,    93,     0,     0,     0,     0,     0,     0,     0,
1160       0,    30,     0,    31,    32,    33,     0,     0,     0,     0,
1161      38,    39,     0,     0,     0,     4,     0,     0,    94,     0,
1162      87,    88,    89,    48,     8,    49,    90,    10,     0,   150,
1163     151,     0,     0,   152,    51,   153,   154,    52,    12,    13,
1164      14,    15,    16,    17,    18,    19,    20,    21,    22,   150,
1165     151,     0,     0,   152,     0,   153,   154,    30,     0,    31,
1166      32,    33,     0,     0,   150,   151,    38,    39,   152,     0,
1167     153,   154,     0,     0,    94,     0,   150,   151,     0,    48,
1168     152,    49,   153,   154,     0,     0,     0,     0,   150,   151,
1169      51,     0,   152,    52,   153,   154,    12,    13,    14,    15,
1170      16,    17,    18,    19,    91,    92,    93,   150,   151,     0,
1171       0,   152,     0,   153,   154,    30,     0,    31,    32,    33,
1172       0,     0,   150,   151,    38,    39,   152,     0,   153,   154,
1173       0,     0,    94,     0,   150,   151,     0,    48,   152,    49,
1174     153,   154,     0,     0,     0,     0,     0,     0,   178,     0,
1175       0,    52,     0,   155,     0,   156,   157,   158,   159,     0,
1176     160,   255,     0,   161,   162,   150,   151,     0,     0,   152,
1177       0,   153,   154,   155,     0,   156,   157,   158,   159,     0,
1178     160,   256,     0,   161,   162,     0,     0,     0,   155,     0,
1179     156,   157,   158,   159,     0,   160,   261,     0,   161,   162,
1180     155,     0,   156,   157,   158,   159,   292,   160,     0,     0,
1181     161,   162,   155,     0,   156,   157,   158,   159,     0,   160,
1182     293,     0,   161,   162,     0,     0,     0,     0,     0,     0,
1183       0,   155,     0,   156,   157,   158,   159,   296,   160,     0,
1184       0,   161,   162,     0,     0,     0,   155,     0,   156,   157,
1185     158,   159,     0,   160,   318,     0,   161,   162,   155,     0,
1186     156,   157,   158,   159,     0,   160,   322,     0,   161,   162,
1187     150,   151,     0,     0,   152,     0,   153,   154,     0,     0,
1188       0,   198,   199,   200,     0,     8,     0,   201,    10,   155,
1189       0,   156,   157,   158,   159,     0,   160,   325,     0,   161,
1190     162,   150,   151,     0,     0,   152,     0,   153,   154,     0,
1191       0,     0,     0,   150,   151,     0,     0,   152,     0,   153,
1192     154,     0,     0,     0,     0,   150,   151,     0,     0,   152,
1193       0,   153,   154,     0,     0,     0,     0,   150,   151,     0,
1194       0,   152,     0,   153,   154,     0,     0,     0,     0,    -1,
1195     151,     0,     0,   152,     0,   153,   154,     0,     0,     0,
1196       0,     0,     0,     0,     0,   202,   203,   204,     0,     0,
1197       0,     0,     0,     0,     0,     0,    30,     0,    31,    32,
1198      33,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1199       0,    88,     0,    94,   155,     0,   156,   157,   158,   159,
1200      49,   160,   327,     0,   161,   162,     0,     0,     0,    88,
1201     205,     0,    52,     0,    88,     0,     0,     0,     0,    88,
1202       0,     0,     0,     0,     0,   155,     0,   156,   157,   158,
1203     159,   340,   160,     0,     0,   161,   162,   155,     0,   156,
1204     157,   158,   159,   358,   160,     0,     0,   161,   162,   155,
1205       0,   156,   157,   158,   159,   364,   160,    88,     0,   161,
1206     162,   155,     0,   156,   157,   158,   159,     0,   160,     0,
1207       0,   161,   162,   155,     0,   156,   157,   158,   159,     0,
1208     160,     0,     0,   161,   162,    30,     0,    31,    32,    33,
1209       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1210       0,     0,    94,    30,     0,    31,    32,    33,    30,    49,
1211      31,    32,    33,    30,     0,    31,    32,    33,   103,     0,
1212      94,    52,     0,     0,     0,    94,     0,    49,     0,     0,
1213      94,     0,    49,     0,     0,     0,   113,    49,     0,    52,
1214       0,   115,     0,     0,    52,     0,   117,     0,     0,    52,
1215       0,    30,     0,    31,    32,    33,     0,     0,     0,     0,
1216       0,     0,     0,     0,     0,     0,     0,     0,    94,     0,
1217       0,     0,     0,     0,     0,    49,     0,     0,     0,     0,
1218       0,     0,     0,     0,   165,     0,     0,    52
1219};
1220
1221static const short int yycheck[] =
1222{
1223       1,   108,   109,    13,    14,    15,   111,    17,     1,    19,
1224      20,   108,    11,     4,   135,   141,     7,   243,     9,    10,
1225     346,   142,     4,    24,   250,     3,     4,   135,   126,     7,
1226       7,     9,    10,    10,   142,   135,   141,   135,     7,   136,
1227      11,    10,   142,   135,   370,   126,   135,    29,    49,   135,
1228     142,   135,    45,   142,   135,   136,   142,   136,   142,    11,
1229     135,     7,    63,    45,    10,   141,    48,   142,   109,   141,
1230      52,    11,   133,   114,   135,   108,   109,     5,     6,    61,
1231      11,     9,   141,   142,    46,    47,   141,    97,    98,    99,
1232     141,   317,    20,    21,    22,    77,   141,   141,    26,   141,
1233     108,   141,   141,     3,     4,   109,   141,     7,   108,     9,
1234      10,   112,   141,   141,   115,    97,   108,    99,   141,   108,
1235     102,   103,   136,   105,   106,   107,   108,   109,   110,   111,
1236     135,   113,   125,   134,   141,   117,   127,    65,   129,   130,
1237     131,   132,   141,   134,   143,   146,    74,   138,   109,   127,
1238     132,   129,   130,   131,   132,   132,   134,   134,   141,   137,
1239     138,   132,   131,   132,   165,   134,   144,   149,   150,   151,
1240     141,   153,   143,   155,   156,   157,   158,   159,   160,   161,
1241     162,     3,     4,   135,   141,     7,   132,     9,    10,   141,
1242     142,   143,   132,   175,   141,   126,   178,   125,   141,   141,
1243     182,   141,   141,   143,   136,   135,   108,   135,   109,   136,
1244     141,   135,   143,   135,   109,   108,   142,   145,   143,   147,
1245     136,   142,   142,   142,   142,   142,   126,   127,   210,   129,
1246     130,   131,   132,   142,   134,   109,    14,   137,   138,   135,
1247     168,   132,   142,   171,   132,   135,   111,     6,   142,   287,
1248     142,    45,   370,   142,   236,   142,   142,   142,   142,   142,
1249     135,   243,   244,   141,   135,   142,   142,   172,   250,   251,
1250      -1,   356,    -1,   255,   256,   257,    -1,   259,    -1,   261,
1251     262,    -1,   275,     0,     1,    -1,    -1,    -1,    -1,    -1,
1252      -1,     8,   293,    -1,    -1,    -1,    13,    14,    15,    -1,
1253      17,    -1,    19,    20,   286,   127,    -1,   129,   130,   131,
1254     132,    -1,   134,   135,    -1,   137,   138,     3,     4,    -1,
1255     142,     7,    39,     9,    10,    -1,    -1,    -1,    -1,    -1,
1256     108,    -1,   110,   111,   112,   317,   318,   319,    -1,     7,
1257     322,   323,    10,   325,    -1,   327,   328,   125,   330,     3,
1258       4,    -1,    -1,     7,   132,     9,    10,    -1,    -1,    -1,
1259     361,    -1,    -1,     3,     4,    -1,   144,     7,    -1,     9,
1260      10,    -1,    89,    90,    91,    92,    93,    94,    95,    96,
1261      97,    98,    99,   100,   101,   102,   103,    -1,   105,   106,
1262     107,   108,    -1,   110,   111,   112,   113,   114,   115,   116,
1263     117,   118,   119,   120,   121,   122,   123,   124,   125,    -1,
1264     127,    -1,    -1,   130,    -1,   132,     3,     4,    -1,   136,
1265       7,    -1,     9,    10,   141,    -1,    -1,   144,    -1,    -1,
1266       3,     4,    -1,    -1,     7,    -1,     9,    10,    -1,    -1,
1267      -1,   127,    -1,   129,   130,   131,   132,    -1,   134,   135,
1268      -1,   137,   138,     3,     4,    -1,   142,     7,    -1,     9,
1269      10,   129,   130,   131,   132,    -1,   134,    -1,    -1,    -1,
1270     138,    -1,    -1,   127,    -1,   129,   130,   131,   132,    -1,
1271     134,   135,    -1,   137,   138,    -1,    -1,   127,   142,   129,
1272     130,   131,   132,     7,   134,   135,    10,   137,   138,     3,
1273       4,    -1,   142,     7,    -1,     9,    10,    -1,    -1,    -1,
1274      -1,    -1,    -1,     3,     4,    -1,    -1,     7,    -1,     9,
1275      10,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,    -1,
1276      -1,     7,    -1,     9,    10,    -1,    -1,    -1,    -1,    -1,
1277     127,    -1,   129,   130,   131,   132,    -1,   134,   135,    -1,
1278     137,   138,    -1,    -1,   127,   142,   129,   130,   131,   132,
1279      -1,   134,   135,    -1,   137,   138,     3,     4,    -1,   142,
1280       7,    -1,     9,    10,    -1,    -1,    -1,   127,    -1,   129,
1281     130,   131,   132,    -1,   134,   135,    -1,   137,   138,     3,
1282       4,    -1,   142,     7,    -1,     9,    10,    -1,    -1,    -1,
1283      -1,    -1,    -1,     3,     4,    -1,    -1,     7,    -1,     9,
1284      10,    -1,    -1,   127,    -1,   129,   130,   131,   132,    -1,
1285     134,    -1,    -1,   127,   138,   129,   130,   131,   132,    -1,
1286     134,    -1,    -1,   137,   138,    -1,    -1,   127,   142,   129,
1287     130,   131,   132,    -1,   134,    -1,    -1,   137,   138,    -1,
1288      -1,   127,   142,   129,   130,   131,   132,    -1,   134,    -1,
1289      -1,   137,   138,     3,     4,    -1,   142,     7,    -1,     9,
1290      10,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,    -1,
1291      -1,     7,    -1,     9,    10,    -1,    -1,    -1,    -1,    -1,
1292     127,    -1,   129,   130,   131,   132,    -1,   134,    -1,    -1,
1293     137,   138,     3,     4,    -1,   142,     7,    -1,     9,    10,
1294      -1,    -1,    -1,   127,    -1,   129,   130,   131,   132,    -1,
1295     134,    -1,    -1,   137,   138,    -1,    -1,   127,   142,   129,
1296     130,   131,   132,    -1,   134,    -1,    -1,   137,   138,     3,
1297       4,    -1,   142,     7,    -1,     9,    10,    -1,    -1,    -1,
1298      -1,    -1,    -1,     3,     4,    -1,    -1,     7,    -1,     9,
1299      10,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,    -1,
1300      -1,     7,    -1,     9,    10,    -1,    -1,    -1,    -1,    -1,
1301      -1,    -1,    -1,    -1,    -1,    -1,    -1,   127,    -1,   129,
1302     130,   131,   132,    -1,   134,    -1,    -1,   137,   138,    -1,
1303      -1,   127,   142,   129,   130,   131,   132,    -1,   134,    -1,
1304      -1,   137,   138,     3,     4,    -1,   142,     7,    -1,     9,
1305      10,    -1,    -1,    -1,    -1,    -1,   127,    -1,   129,   130,
1306     131,   132,    -1,   134,    -1,    -1,   137,   138,     3,     4,
1307      -1,   142,     7,    -1,     9,    10,    -1,    -1,    -1,    -1,
1308      -1,    -1,     3,     4,    -1,    -1,     7,    -1,     9,    10,
1309      -1,    -1,    -1,   127,    -1,   129,   130,   131,   132,    -1,
1310     134,    -1,    -1,   137,   138,    -1,    -1,   127,   142,   129,
1311     130,   131,   132,    -1,   134,    -1,    -1,   137,   138,    -1,
1312      -1,   127,   142,   129,   130,   131,   132,    -1,   134,    -1,
1313      -1,   137,   138,     3,     4,    -1,   142,     7,    -1,     9,
1314      10,     8,    -1,    -1,    -1,    -1,    13,    14,    15,    -1,
1315      17,    -1,    19,    20,    -1,    -1,    -1,    -1,    -1,    -1,
1316      -1,    -1,    -1,    -1,    -1,    -1,    -1,   127,    -1,   129,
1317     130,   131,   132,    -1,   134,    -1,    -1,   137,   138,     3,
1318       4,    -1,   142,     7,    -1,     9,    10,    -1,    -1,    -1,
1319      -1,    -1,   127,    -1,   129,   130,   131,   132,    -1,   134,
1320      -1,    14,   137,   138,    -1,    -1,   127,   142,   129,   130,
1321     131,   132,    -1,   134,    -1,    -1,   137,   138,    -1,    -1,
1322      -1,   142,    89,    90,    91,    92,    93,    94,    95,    96,
1323      97,    98,    99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1324      -1,   108,    -1,   110,   111,   112,    -1,    -1,    -1,    -1,
1325     117,   118,    -1,    -1,    14,    -1,    -1,   127,   125,   129,
1326     130,   131,   132,   130,   134,   132,    -1,   137,   138,    -1,
1327      -1,    -1,   142,     8,   141,   142,    -1,   144,    13,    14,
1328      15,    -1,    17,    -1,    19,    20,    -1,    -1,    -1,    -1,
1329      -1,    -1,    -1,    -1,    -1,   108,    -1,   110,   111,   112,
1330      -1,    -1,    -1,   127,    -1,   129,   130,   131,   132,   133,
1331     134,   135,   125,   137,   138,    -1,    -1,    -1,    -1,   132,
1332      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   141,     8,
1333      -1,   144,    -1,    -1,    13,    14,    15,    -1,    17,    -1,
1334      19,    20,    -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,
1335     110,   111,   112,    -1,    89,    90,    91,    92,    93,    94,
1336      95,    96,    97,    98,    99,   125,    -1,    -1,    -1,    -1,
1337      -1,    -1,   132,   108,    -1,   110,   111,   112,    -1,    -1,
1338      -1,   141,   117,   118,   144,    -1,    -1,     8,    -1,    -1,
1339     125,    -1,    13,    14,    15,   130,    17,   132,    19,    20,
1340      -1,    -1,    -1,    -1,    -1,    -1,   141,   142,    -1,   144,
1341      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
1342      99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,
1343      -1,   110,   111,   112,    -1,    -1,    -1,    -1,   117,   118,
1344      -1,    -1,    -1,     8,    -1,    -1,   125,    -1,    13,    14,
1345      15,   130,    17,   132,    19,    20,    -1,    -1,    -1,    -1,
1346      -1,    -1,   141,   142,    -1,   144,    -1,    -1,    89,    90,
1347      91,    92,    93,    94,    95,    96,    97,    98,    99,    -1,
1348      -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,   110,
1349     111,   112,    -1,    -1,    -1,    -1,   117,   118,    -1,    -1,
1350      -1,     8,    -1,    -1,   125,    -1,    13,    14,    15,   130,
1351      17,   132,    19,    20,    -1,    -1,    -1,    -1,    -1,    -1,
1352     141,   142,    -1,   144,    89,    90,    91,    92,    93,    94,
1353      95,    96,    97,    98,    99,    -1,    -1,    -1,    -1,    -1,
1354      -1,    -1,    -1,   108,    -1,   110,   111,   112,    -1,    -1,
1355      -1,    -1,   117,   118,    -1,    -1,    -1,     8,    -1,    -1,
1356     125,    -1,    13,    14,    15,   130,    17,   132,    19,    20,
1357      -1,    -1,    -1,    -1,    -1,    -1,   141,   142,    -1,   144,
1358      -1,    -1,    89,    90,    91,    92,    93,    94,    95,    96,
1359      97,    98,    99,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1360      -1,   108,    -1,   110,   111,   112,    -1,    -1,    -1,    -1,
1361     117,   118,    -1,    -1,    -1,     8,    -1,    -1,   125,    -1,
1362      13,    14,    15,   130,    17,   132,    19,    20,    -1,     3,
1363       4,    -1,    -1,     7,   141,     9,    10,   144,    89,    90,
1364      91,    92,    93,    94,    95,    96,    97,    98,    99,     3,
1365       4,    -1,    -1,     7,    -1,     9,    10,   108,    -1,   110,
1366     111,   112,    -1,    -1,     3,     4,   117,   118,     7,    -1,
1367       9,    10,    -1,    -1,   125,    -1,     3,     4,    -1,   130,
1368       7,   132,     9,    10,    -1,    -1,    -1,    -1,     3,     4,
1369     141,    -1,     7,   144,     9,    10,    89,    90,    91,    92,
1370      93,    94,    95,    96,    97,    98,    99,     3,     4,    -1,
1371      -1,     7,    -1,     9,    10,   108,    -1,   110,   111,   112,
1372      -1,    -1,     3,     4,   117,   118,     7,    -1,     9,    10,
1373      -1,    -1,   125,    -1,     3,     4,    -1,   130,     7,   132,
1374       9,    10,    -1,    -1,    -1,    -1,    -1,    -1,   141,    -1,
1375      -1,   144,    -1,   127,    -1,   129,   130,   131,   132,    -1,
1376     134,   135,    -1,   137,   138,     3,     4,    -1,    -1,     7,
1377      -1,     9,    10,   127,    -1,   129,   130,   131,   132,    -1,
1378     134,   135,    -1,   137,   138,    -1,    -1,    -1,   127,    -1,
1379     129,   130,   131,   132,    -1,   134,   135,    -1,   137,   138,
1380     127,    -1,   129,   130,   131,   132,   133,   134,    -1,    -1,
1381     137,   138,   127,    -1,   129,   130,   131,   132,    -1,   134,
1382     135,    -1,   137,   138,    -1,    -1,    -1,    -1,    -1,    -1,
1383      -1,   127,    -1,   129,   130,   131,   132,   133,   134,    -1,
1384      -1,   137,   138,    -1,    -1,    -1,   127,    -1,   129,   130,
1385     131,   132,    -1,   134,   135,    -1,   137,   138,   127,    -1,
1386     129,   130,   131,   132,    -1,   134,   135,    -1,   137,   138,
1387       3,     4,    -1,    -1,     7,    -1,     9,    10,    -1,    -1,
1388      -1,    13,    14,    15,    -1,    17,    -1,    19,    20,   127,
1389      -1,   129,   130,   131,   132,    -1,   134,   135,    -1,   137,
1390     138,     3,     4,    -1,    -1,     7,    -1,     9,    10,    -1,
1391      -1,    -1,    -1,     3,     4,    -1,    -1,     7,    -1,     9,
1392      10,    -1,    -1,    -1,    -1,     3,     4,    -1,    -1,     7,
1393      -1,     9,    10,    -1,    -1,    -1,    -1,     3,     4,    -1,
1394      -1,     7,    -1,     9,    10,    -1,    -1,    -1,    -1,     3,
1395       4,    -1,    -1,     7,    -1,     9,    10,    -1,    -1,    -1,
1396      -1,    -1,    -1,    -1,    -1,    97,    98,    99,    -1,    -1,
1397      -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,   110,   111,
1398     112,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1399      -1,    14,    -1,   125,   127,    -1,   129,   130,   131,   132,
1400     132,   134,   135,    -1,   137,   138,    -1,    -1,    -1,    14,
1401     142,    -1,   144,    -1,    14,    -1,    -1,    -1,    -1,    14,
1402      -1,    -1,    -1,    -1,    -1,   127,    -1,   129,   130,   131,
1403     132,   133,   134,    -1,    -1,   137,   138,   127,    -1,   129,
1404     130,   131,   132,   133,   134,    -1,    -1,   137,   138,   127,
1405      -1,   129,   130,   131,   132,   133,   134,    14,    -1,   137,
1406     138,   127,    -1,   129,   130,   131,   132,    -1,   134,    -1,
1407      -1,   137,   138,   127,    -1,   129,   130,   131,   132,    -1,
1408     134,    -1,    -1,   137,   138,   108,    -1,   110,   111,   112,
1409      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1410      -1,    -1,   125,   108,    -1,   110,   111,   112,   108,   132,
1411     110,   111,   112,   108,    -1,   110,   111,   112,   141,    -1,
1412     125,   144,    -1,    -1,    -1,   125,    -1,   132,    -1,    -1,
1413     125,    -1,   132,    -1,    -1,    -1,   141,   132,    -1,   144,
1414      -1,   141,    -1,    -1,   144,    -1,   141,    -1,    -1,   144,
1415      -1,   108,    -1,   110,   111,   112,    -1,    -1,    -1,    -1,
1416      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   125,    -1,
1417      -1,    -1,    -1,    -1,    -1,   132,    -1,    -1,    -1,    -1,
1418      -1,    -1,    -1,    -1,   141,    -1,    -1,   144
1419};
1420
1421/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1422   symbol of state STATE-NUM.  */
1423static const unsigned char yystos[] =
1424{
1425       0,   146,     0,     1,     8,    13,    14,    15,    17,    19,
1426      20,    39,    89,    90,    91,    92,    93,    94,    95,    96,
1427      97,    98,    99,   100,   101,   102,   103,   105,   106,   107,
1428     108,   110,   111,   112,   113,   114,   115,   116,   117,   118,
1429     119,   120,   121,   122,   123,   124,   125,   127,   130,   132,
1430     136,   141,   144,   147,   148,   149,   150,   151,   152,   153,
1431     154,   156,   158,   159,   160,   161,   162,   163,   170,   172,
1432     173,   174,   175,   176,   177,   178,   179,   180,   181,   182,
1433     183,   184,   185,   186,   187,   188,   136,    13,    14,    15,
1434      19,    97,    98,    99,   125,   154,   161,   141,   152,   141,
1435     152,   160,   141,   141,   152,   141,   141,   141,   141,   141,
1436     141,   141,   141,   141,   152,   141,   152,   141,   152,   108,
1437     109,   153,   108,   136,   152,   141,   154,   108,   109,   141,
1438     141,   108,   141,   108,   141,    14,   154,   162,   163,   163,
1439     154,   153,   153,   154,   136,    11,   141,   143,   126,   135,
1440       3,     4,     7,     9,    10,   127,   129,   130,   131,   132,
1441     134,   137,   138,   154,   153,   141,   152,   126,   135,   136,
1442     169,   135,   152,   154,   154,   132,   154,   109,   141,   154,
1443     164,   154,   132,   154,   154,   154,   154,   154,   154,   154,
1444     142,   153,   154,   142,   153,   154,   136,   136,    13,    14,
1445      15,    19,    97,    98,    99,   142,   152,   161,   108,   109,
1446     155,   108,   154,   109,   142,   153,   171,   133,   142,   144,
1447     152,   142,   153,   152,   154,   154,   154,   154,   154,   154,
1448     154,   154,   154,   154,   154,   154,   126,   142,   157,   142,
1449     153,   152,   152,   169,   135,   142,   154,   142,   154,   142,
1450     135,   135,   142,   154,   142,   135,   135,   135,   142,   135,
1451     142,   135,   135,   142,   142,   142,   142,   142,   142,   142,
1452     142,   142,   142,   142,   142,   135,   142,   142,   109,   154,
1453     108,   142,   142,   136,   142,   133,   135,   154,   142,   154,
1454     164,   154,   133,   135,   164,   154,   133,   154,   154,   154,
1455     154,   154,   154,    13,    14,    15,    19,    97,    98,    99,
1456     161,   142,   109,   109,   114,   154,   157,   135,   135,   132,
1457     153,   135,   135,   132,   142,   135,   142,   135,   135,   142,
1458     135,   142,   142,   142,   142,   142,   142,   142,   142,   142,
1459     133,   164,   154,   154,   142,   111,   141,   165,   166,   168,
1460     154,   154,   154,   154,   154,   154,   135,   142,   133,   166,
1461     167,   141,   142,   142,   133,   142,   142,   142,   142,   168,
1462     135,   142,   153,   167,   142
1463};
1464
1465#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
1466# define YYSIZE_T __SIZE_TYPE__
1467#endif
1468#if ! defined (YYSIZE_T) && defined (size_t)
1469# define YYSIZE_T size_t
1470#endif
1471#if ! defined (YYSIZE_T)
1472# if defined (__STDC__) || defined (__cplusplus)
1473#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1474#  define YYSIZE_T size_t
1475# endif
1476#endif
1477#if ! defined (YYSIZE_T)
1478# define YYSIZE_T unsigned int
1479#endif
1480
1481#define yyerrok         (yyerrstatus = 0)
1482#define yyclearin       (yychar = YYEMPTY)
1483#define YYEMPTY         (-2)
1484#define YYEOF           0
1485
1486#define YYACCEPT        goto yyacceptlab
1487#define YYABORT         goto yyabortlab
1488#define YYERROR         goto yyerrorlab
1489
1490
1491/* Like YYERROR except do call yyerror.  This remains here temporarily
1492   to ease the transition to the new meaning of YYERROR, for GCC.
1493   Once GCC version 2 has supplanted version 1, this can go.  */
1494
1495#define YYFAIL          goto yyerrlab
1496
1497#define YYRECOVERING()  (!!yyerrstatus)
1498
1499#define YYBACKUP(Token, Value)                                  \
1500do                                                              \
1501  if (yychar == YYEMPTY && yylen == 1)                          \
1502    {                                                           \
1503      yychar = (Token);                                         \
1504      yylval = (Value);                                         \
1505      yytoken = YYTRANSLATE (yychar);                           \
1506      YYPOPSTACK;                                               \
1507      goto yybackup;                                            \
1508    }                                                           \
1509  else                                                          \
1510    {                                                           \
1511      yyerror ("syntax error: cannot back up");\
1512      YYERROR;                                                  \
1513    }                                                           \
1514while (0)
1515
1516#define YYTERROR        1
1517#define YYERRCODE       256
1518
1519/* YYLLOC_DEFAULT -- Compute the default location (before the actions
1520   are run).  */
1521
1522#ifndef YYLLOC_DEFAULT
1523# define YYLLOC_DEFAULT(Current, Rhs, N)                \
1524   ((Current).first_line   = (Rhs)[1].first_line,       \
1525    (Current).first_column = (Rhs)[1].first_column,     \
1526    (Current).last_line    = (Rhs)[N].last_line,        \
1527    (Current).last_column  = (Rhs)[N].last_column)
1528#endif
1529
1530/* YYLEX -- calling `yylex' with the right arguments.  */
1531
1532#ifdef YYLEX_PARAM
1533# define YYLEX yylex (&yylval, YYLEX_PARAM)
1534#else
1535# define YYLEX yylex (&yylval)
1536#endif
1537
1538/* Enable debugging if requested.  */
1539#if YYDEBUG
1540
1541# ifndef YYFPRINTF
1542#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1543#  define YYFPRINTF fprintf
1544# endif
1545
1546# define YYDPRINTF(Args)                        \
1547do {                                            \
1548  if (yydebug)                                  \
1549    YYFPRINTF Args;                             \
1550} while (0)
1551
1552# define YYDSYMPRINT(Args)                      \
1553do {                                            \
1554  if (yydebug)                                  \
1555    yysymprint Args;                            \
1556} while (0)
1557
1558# define YYDSYMPRINTF(Title, Token, Value, Location)            \
1559do {                                                            \
1560  if (yydebug)                                                  \
1561    {                                                           \
1562      YYFPRINTF (stderr, "%s ", Title);                         \
1563      yysymprint (stderr,                                       \
1564                  Token, Value);        \
1565      YYFPRINTF (stderr, "\n");                                 \
1566    }                                                           \
1567} while (0)
1568
1569/*------------------------------------------------------------------.
1570| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1571| TOP (included).                                                   |
1572`------------------------------------------------------------------*/
1573
1574#if defined (__STDC__) || defined (__cplusplus)
1575static void
1576yy_stack_print (short int *bottom, short int *top)
1577#else
1578static void
1579yy_stack_print (bottom, top)
1580    short int *bottom;
1581    short int *top;
1582#endif
1583{
1584  YYFPRINTF (stderr, "Stack now");
1585  for (/* Nothing. */; bottom <= top; ++bottom)
1586    YYFPRINTF (stderr, " %d", *bottom);
1587  YYFPRINTF (stderr, "\n");
1588}
1589
1590# define YY_STACK_PRINT(Bottom, Top)                            \
1591do {                                                            \
1592  if (yydebug)                                                  \
1593    yy_stack_print ((Bottom), (Top));                           \
1594} while (0)
1595
1596
1597/*------------------------------------------------.
1598| Report that the YYRULE is going to be reduced.  |
1599`------------------------------------------------*/
1600
1601#if defined (__STDC__) || defined (__cplusplus)
1602static void
1603yy_reduce_print (int yyrule)
1604#else
1605static void
1606yy_reduce_print (yyrule)
1607    int yyrule;
1608#endif
1609{
1610  int yyi;
1611  unsigned int yylno = yyrline[yyrule];
1612  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
1613             yyrule - 1, yylno);
1614  /* Print the symbols being reduced, and their result.  */
1615  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
1616    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
1617  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
1618}
1619
1620# define YY_REDUCE_PRINT(Rule)          \
1621do {                                    \
1622  if (yydebug)                          \
1623    yy_reduce_print (Rule);             \
1624} while (0)
1625
1626/* Nonzero means print parse trace.  It is left uninitialized so that
1627   multiple parsers can coexist.  */
1628int yydebug;
1629#else /* !YYDEBUG */
1630# define YYDPRINTF(Args)
1631# define YYDSYMPRINT(Args)
1632# define YYDSYMPRINTF(Title, Token, Value, Location)
1633# define YY_STACK_PRINT(Bottom, Top)
1634# define YY_REDUCE_PRINT(Rule)
1635#endif /* !YYDEBUG */
1636
1637
1638/* YYINITDEPTH -- initial size of the parser's stacks.  */
1639#ifndef YYINITDEPTH
1640# define YYINITDEPTH 200
1641#endif
1642
1643/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1644   if the built-in stack extension method is used).
1645
1646   Do not make this value too large; the results are undefined if
1647   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
1648   evaluated with infinite-precision integer arithmetic.  */
1649
1650#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
1651# undef YYMAXDEPTH
1652#endif
1653
1654#ifndef YYMAXDEPTH
1655# define YYMAXDEPTH 10000
1656#endif
1657
1658
1659
1660#if YYERROR_VERBOSE
1661
1662# ifndef yystrlen
1663#  if defined (__GLIBC__) && defined (_STRING_H)
1664#   define yystrlen strlen
1665#  else
1666/* Return the length of YYSTR.  */
1667static YYSIZE_T
1668#   if defined (__STDC__) || defined (__cplusplus)
1669yystrlen (const char *yystr)
1670#   else
1671yystrlen (yystr)
1672     const char *yystr;
1673#   endif
1674{
1675  register const char *yys = yystr;
1676
1677  while (*yys++ != '\0')
1678    continue;
1679
1680  return yys - yystr - 1;
1681}
1682#  endif
1683# endif
1684
1685# ifndef yystpcpy
1686#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1687#   define yystpcpy stpcpy
1688#  else
1689/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1690   YYDEST.  */
1691static char *
1692#   if defined (__STDC__) || defined (__cplusplus)
1693yystpcpy (char *yydest, const char *yysrc)
1694#   else
1695yystpcpy (yydest, yysrc)
1696     char *yydest;
1697     const char *yysrc;
1698#   endif
1699{
1700  register char *yyd = yydest;
1701  register const char *yys = yysrc;
1702
1703  while ((*yyd++ = *yys++) != '\0')
1704    continue;
1705
1706  return yyd - 1;
1707}
1708#  endif
1709# endif
1710
1711#endif /* !YYERROR_VERBOSE */
1712
1713
1714
1715#if YYDEBUG
1716/*--------------------------------.
1717| Print this symbol on YYOUTPUT.  |
1718`--------------------------------*/
1719
1720#if defined (__STDC__) || defined (__cplusplus)
1721static void
1722yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
1723#else
1724static void
1725yysymprint (yyoutput, yytype, yyvaluep)
1726    FILE *yyoutput;
1727    int yytype;
1728    YYSTYPE *yyvaluep;
1729#endif
1730{
1731  /* Pacify ``unused variable'' warnings.  */
1732  (void) yyvaluep;
1733
1734  if (yytype < YYNTOKENS)
1735    {
1736      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1737# ifdef YYPRINT
1738      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1739# endif
1740    }
1741  else
1742    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1743
1744  switch (yytype)
1745    {
1746      default:
1747        break;
1748    }
1749  YYFPRINTF (yyoutput, ")");
1750}
1751
1752#endif /* ! YYDEBUG */
1753/*-----------------------------------------------.
1754| Release the memory associated to this symbol.  |
1755`-----------------------------------------------*/
1756
1757#if defined (__STDC__) || defined (__cplusplus)
1758static void
1759yydestruct (int yytype, YYSTYPE *yyvaluep)
1760#else
1761static void
1762yydestruct (yytype, yyvaluep)
1763    int yytype;
1764    YYSTYPE *yyvaluep;
1765#endif
1766{
1767  /* Pacify ``unused variable'' warnings.  */
1768  (void) yyvaluep;
1769
1770  switch (yytype)
1771    {
1772
1773      default:
1774        break;
1775    }
1776}
1777
1778
1779/* Prevent warnings from -Wmissing-prototypes.  */
1780
1781#ifdef YYPARSE_PARAM
1782# if defined (__STDC__) || defined (__cplusplus)
1783int yyparse (void *YYPARSE_PARAM);
1784# else
1785int yyparse ();
1786# endif
1787#else /* ! YYPARSE_PARAM */
1788#if defined (__STDC__) || defined (__cplusplus)
1789int yyparse (void);
1790#else
1791int yyparse ();
1792#endif
1793#endif /* ! YYPARSE_PARAM */
1794
1795
1796
1797
1798
1799
1800/*----------.
1801| yyparse.  |
1802`----------*/
1803
1804#ifdef YYPARSE_PARAM
1805# if defined (__STDC__) || defined (__cplusplus)
1806int yyparse (void *YYPARSE_PARAM)
1807# else
1808int yyparse (YYPARSE_PARAM)
1809  void *YYPARSE_PARAM;
1810# endif
1811#else /* ! YYPARSE_PARAM */
1812#if defined (__STDC__) || defined (__cplusplus)
1813int
1814yyparse (void)
1815#else
1816int
1817yyparse ()
1818
1819#endif
1820#endif
1821{
1822  /* The lookahead symbol.  */
1823int yychar;
1824
1825/* The semantic value of the lookahead symbol.  */
1826YYSTYPE yylval;
1827
1828/* Number of syntax errors so far.  */
1829int yynerrs;
1830
1831  register int yystate;
1832  register int yyn;
1833  int yyresult;
1834  /* Number of tokens to shift before error messages enabled.  */
1835  int yyerrstatus;
1836  /* Lookahead token as an internal (translated) token number.  */
1837  int yytoken = 0;
1838
1839  /* Three stacks and their tools:
1840     `yyss': related to states,
1841     `yyvs': related to semantic values,
1842     `yyls': related to locations.
1843
1844     Refer to the stacks thru separate pointers, to allow yyoverflow
1845     to reallocate them elsewhere.  */
1846
1847  /* The state stack.  */
1848  short int yyssa[YYINITDEPTH];
1849  short int *yyss = yyssa;
1850  register short int *yyssp;
1851
1852  /* The semantic value stack.  */
1853  YYSTYPE yyvsa[YYINITDEPTH];
1854  YYSTYPE *yyvs = yyvsa;
1855  register YYSTYPE *yyvsp;
1856
1857
1858
1859#define YYPOPSTACK   (yyvsp--, yyssp--)
1860
1861  YYSIZE_T yystacksize = YYINITDEPTH;
1862
1863  /* The variables used to return semantic value and location from the
1864     action routines.  */
1865  YYSTYPE yyval;
1866
1867
1868  /* When reducing, the number of symbols on the RHS of the reduced
1869     rule.  */
1870  int yylen;
1871
1872  YYDPRINTF ((stderr, "Starting parse\n"));
1873
1874  yystate = 0;
1875  yyerrstatus = 0;
1876  yynerrs = 0;
1877  yychar = YYEMPTY;             /* Cause a token to be read.  */
1878
1879  /* Initialize stack pointers.
1880     Waste one element of value and location stack
1881     so that they stay on the same level as the state stack.
1882     The wasted elements are never initialized.  */
1883
1884  yyssp = yyss;
1885  yyvsp = yyvs;
1886
1887
1888  goto yysetstate;
1889
1890/*------------------------------------------------------------.
1891| yynewstate -- Push a new state, which is found in yystate.  |
1892`------------------------------------------------------------*/
1893 yynewstate:
1894  /* In all cases, when you get here, the value and location stacks
1895     have just been pushed. so pushing a state here evens the stacks.
1896     */
1897  yyssp++;
1898
1899 yysetstate:
1900  *yyssp = yystate;
1901
1902  if (yyss + yystacksize - 1 <= yyssp)
1903    {
1904      /* Get the current used size of the three stacks, in elements.  */
1905      YYSIZE_T yysize = yyssp - yyss + 1;
1906
1907#ifdef yyoverflow
1908      {
1909        /* Give user a chance to reallocate the stack. Use copies of
1910           these so that the &'s don't force the real ones into
1911           memory.  */
1912        YYSTYPE *yyvs1 = yyvs;
1913        short int *yyss1 = yyss;
1914
1915
1916        /* Each stack pointer address is followed by the size of the
1917           data in use in that stack, in bytes.  This used to be a
1918           conditional around just the two extra args, but that might
1919           be undefined if yyoverflow is a macro.  */
1920        yyoverflow ("parser stack overflow",
1921                    &yyss1, yysize * sizeof (*yyssp),
1922                    &yyvs1, yysize * sizeof (*yyvsp),
1923
1924                    &yystacksize);
1925
1926        yyss = yyss1;
1927        yyvs = yyvs1;
1928      }
1929#else /* no yyoverflow */
1930# ifndef YYSTACK_RELOCATE
1931      goto yyoverflowlab;
1932# else
1933      /* Extend the stack our own way.  */
1934      if (YYMAXDEPTH <= yystacksize)
1935        goto yyoverflowlab;
1936      yystacksize *= 2;
1937      if (YYMAXDEPTH < yystacksize)
1938        yystacksize = YYMAXDEPTH;
1939
1940      {
1941        short int *yyss1 = yyss;
1942        union yyalloc *yyptr =
1943          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1944        if (! yyptr)
1945          goto yyoverflowlab;
1946        YYSTACK_RELOCATE (yyss);
1947        YYSTACK_RELOCATE (yyvs);
1948
1949#  undef YYSTACK_RELOCATE
1950        if (yyss1 != yyssa)
1951          YYSTACK_FREE (yyss1);
1952      }
1953# endif
1954#endif /* no yyoverflow */
1955
1956      yyssp = yyss + yysize - 1;
1957      yyvsp = yyvs + yysize - 1;
1958
1959
1960      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1961                  (unsigned long int) yystacksize));
1962
1963      if (yyss + yystacksize - 1 <= yyssp)
1964        YYABORT;
1965    }
1966
1967  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1968
1969  goto yybackup;
1970
1971/*-----------.
1972| yybackup.  |
1973`-----------*/
1974yybackup:
1975
1976/* Do appropriate processing given the current state.  */
1977/* Read a lookahead token if we need one and don't already have one.  */
1978/* yyresume: */
1979
1980  /* First try to decide what to do without reference to lookahead token.  */
1981
1982  yyn = yypact[yystate];
1983  if (yyn == YYPACT_NINF)
1984    goto yydefault;
1985
1986  /* Not known => get a lookahead token if don't already have one.  */
1987
1988  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1989  if (yychar == YYEMPTY)
1990    {
1991      YYDPRINTF ((stderr, "Reading a token: "));
1992      yychar = YYLEX;
1993    }
1994
1995  if (yychar <= YYEOF)
1996    {
1997      yychar = yytoken = YYEOF;
1998      YYDPRINTF ((stderr, "Now at end of input.\n"));
1999    }
2000  else
2001    {
2002      yytoken = YYTRANSLATE (yychar);
2003      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
2004    }
2005
2006  /* If the proper action on seeing token YYTOKEN is to reduce or to
2007     detect an error, take that action.  */
2008  yyn += yytoken;
2009  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2010    goto yydefault;
2011  yyn = yytable[yyn];
2012  if (yyn <= 0)
2013    {
2014      if (yyn == 0 || yyn == YYTABLE_NINF)
2015        goto yyerrlab;
2016      yyn = -yyn;
2017      goto yyreduce;
2018    }
2019
2020  if (yyn == YYFINAL)
2021    YYACCEPT;
2022
2023  /* Shift the lookahead token.  */
2024  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
2025
2026  /* Discard the token being shifted unless it is eof.  */
2027  if (yychar != YYEOF)
2028    yychar = YYEMPTY;
2029
2030  *++yyvsp = yylval;
2031
2032
2033  /* Count tokens shifted since error; after three, turn off error
2034     status.  */
2035  if (yyerrstatus)
2036    yyerrstatus--;
2037
2038  yystate = yyn;
2039  goto yynewstate;
2040
2041
2042/*-----------------------------------------------------------.
2043| yydefault -- do the default action for the current state.  |
2044`-----------------------------------------------------------*/
2045yydefault:
2046  yyn = yydefact[yystate];
2047  if (yyn == 0)
2048    goto yyerrlab;
2049  goto yyreduce;
2050
2051
2052/*-----------------------------.
2053| yyreduce -- Do a reduction.  |
2054`-----------------------------*/
2055yyreduce:
2056  /* yyn is the number of a rule to reduce with.  */
2057  yylen = yyr2[yyn];
2058
2059  /* If YYLEN is nonzero, implement the default value of the action:
2060     `$$ = $1'.
2061
2062     Otherwise, the following line sets YYVAL to garbage.
2063     This behavior is undocumented and Bison
2064     users should not rely upon it.  Assigning to YYVAL
2065     unconditionally makes the parser a bit smaller, and it avoids a
2066     GCC warning that YYVAL may be used uninitialized.  */
2067  yyval = yyvsp[1-yylen];
2068
2069
2070  YY_REDUCE_PRINT (yyn);
2071  switch (yyn)
2072    {
2073        case 3:
2074#line 360 "grammar.y"
2075    {
2076            if (timerv)
2077            {
2078              writeTime("used time:");
2079              startTimer();
2080            }
2081            if (rtimerv)
2082            {
2083              writeRTime("used real time:");
2084              startRTimer();
2085            }
2086            prompt_char = '>';
2087#ifdef HAVE_SDB
2088            if (sdb_flags & 2) { sdb_flags=1; YYERROR; }
2089#endif
2090            if(siCntrlc)
2091            {
2092              WerrorS("abort...");
2093              while((currentVoice!=NULL) && (currentVoice->prev!=NULL)) exitVoice();
2094              if (currentVoice!=NULL) currentVoice->ifsw=0;
2095            }
2096            if (errorreported) /* also catches abort... */
2097            {
2098              yyerror("");
2099            }
2100            if (inerror==2) PrintLn();
2101            errorreported = inerror = cmdtok = 0;
2102            lastreserved = currid = NULL;
2103            expected_parms = siCntrlc = FALSE;
2104          ;}
2105    break;
2106
2107  case 5:
2108#line 395 "grammar.y"
2109    {currentVoice->ifsw=0;;}
2110    break;
2111
2112  case 6:
2113#line 397 "grammar.y"
2114    { yyvsp[-1].lv.CleanUp(); currentVoice->ifsw=0;;}
2115    break;
2116
2117  case 7:
2118#line 399 "grammar.y"
2119    {
2120            YYACCEPT;
2121          ;}
2122    break;
2123
2124  case 8:
2125#line 403 "grammar.y"
2126    {
2127            currentVoice->ifsw=0;
2128            iiDebug();
2129          ;}
2130    break;
2131
2132  case 9:
2133#line 408 "grammar.y"
2134    {currentVoice->ifsw=0;;}
2135    break;
2136
2137  case 10:
2138#line 410 "grammar.y"
2139    {
2140            #ifdef SIQ
2141            siq=0;
2142            #endif
2143            yyInRingConstruction = FALSE;
2144            currentVoice->ifsw=0;
2145            if (inerror)
2146            {
2147/*  bison failed here*/
2148              if ((inerror!=3) && (yyvsp[-1].i<UMINUS) && (yyvsp[-1].i>' '))
2149              {
2150                // 1: yyerror called
2151                // 2: scanner put actual string
2152                // 3: error rule put token+\n
2153                inerror=3;
2154                Print(" error at token `%s`\n",iiTwoOps(yyvsp[-1].i));
2155              }
2156/**/
2157
2158            }
2159            if (!errorreported) WerrorS("...parse error");
2160            yyerror("");
2161            yyerrok;
2162#ifdef HAVE_SDB
2163            if ((sdb_flags & 1) && currentVoice->pi!=NULL)
2164            {
2165              currentVoice->pi->trace_flag |=1;
2166            }
2167            else
2168#endif
2169            if (myynest>0)
2170            {
2171              feBufferTypes t=currentVoice->Typ();
2172              //PrintS("leaving yyparse\n");
2173              exitBuffer(BT_proc);
2174              if (t==BT_example)
2175                YYACCEPT;
2176              else
2177                YYABORT;
2178            }
2179            else if (currentVoice->prev!=NULL)
2180            {
2181              exitVoice();
2182            }
2183#ifdef HAVE_SDB
2184            if (sdb_flags &2) sdb_flags=1;
2185#endif
2186          ;}
2187    break;
2188
2189  case 18:
2190#line 468 "grammar.y"
2191    {if (currentVoice!=NULL) currentVoice->ifsw=0;;}
2192    break;
2193
2194  case 19:
2195#line 471 "grammar.y"
2196    { omFree((ADDRESS)yyvsp[0].name); ;}
2197    break;
2198
2199  case 29:
2200#line 486 "grammar.y"
2201    {
2202            if(iiAssign(&yyvsp[-1].lv,&yyvsp[0].lv)) YYERROR;
2203          ;}
2204    break;
2205
2206  case 30:
2207#line 493 "grammar.y"
2208    {
2209            if (currRing==NULL) MYYERROR("no ring active");
2210            syMake(&yyval.lv,omStrDup(yyvsp[0].name));
2211          ;}
2212    break;
2213
2214  case 31:
2215#line 498 "grammar.y"
2216    {
2217            syMake(&yyval.lv,yyvsp[0].name);
2218          ;}
2219    break;
2220
2221  case 32:
2222#line 502 "grammar.y"
2223    {
2224            if(iiExprArith2(&yyval.lv, &yyvsp[-2].lv, COLONCOLON, &yyvsp[0].lv)) YYERROR;
2225          ;}
2226    break;
2227
2228  case 33:
2229#line 506 "grammar.y"
2230    {
2231            if(iiExprArith2(&yyval.lv, &yyvsp[-2].lv, '.', &yyvsp[0].lv)) YYERROR;
2232          ;}
2233    break;
2234
2235  case 34:
2236#line 510 "grammar.y"
2237    {
2238            if(iiExprArith1(&yyval.lv,&yyvsp[-2].lv,'(')) YYERROR;
2239          ;}
2240    break;
2241
2242  case 35:
2243#line 514 "grammar.y"
2244    {
2245            if (yyvsp[-3].lv.rtyp==UNKNOWN)
2246            { // for x(i)(j)
2247              if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,'(',&yyvsp[-1].lv)) YYERROR;
2248            }
2249            else
2250            {
2251              yyvsp[-3].lv.next=(leftv)omAllocBin(sleftv_bin);
2252              memcpy(yyvsp[-3].lv.next,&yyvsp[-1].lv,sizeof(sleftv));
2253              if(iiExprArithM(&yyval.lv,&yyvsp[-3].lv,'(')) YYERROR;
2254            }
2255          ;}
2256    break;
2257
2258  case 36:
2259#line 527 "grammar.y"
2260    {
2261            if (currRingHdl==NULL) MYYERROR("no ring active");
2262            int j = 0;
2263            memset(&yyval.lv,0,sizeof(sleftv));
2264            yyval.lv.rtyp=VECTOR_CMD;
2265            leftv v = &yyvsp[-1].lv;
2266            while (v!=NULL)
2267            {
2268              int i,t;
2269              sleftv tmp;
2270              memset(&tmp,0,sizeof(tmp));
2271              i=iiTestConvert((t=v->Typ()),POLY_CMD);
2272              if((i==0) || (iiConvert(t /*v->Typ()*/,POLY_CMD,i,v,&tmp)))
2273              {
2274                pDelete((poly *)&yyval.lv.data);
2275                yyvsp[-1].lv.CleanUp();
2276                MYYERROR("expected '[poly,...'");
2277              }
2278              poly p = (poly)tmp.CopyD(POLY_CMD);
2279              pSetCompP(p,++j);
2280              yyval.lv.data = (void *)pAdd((poly)yyval.lv.data,p);
2281              v->next=tmp.next;tmp.next=NULL;
2282              tmp.CleanUp();
2283              v=v->next;
2284            }
2285            yyvsp[-1].lv.CleanUp();
2286          ;}
2287    break;
2288
2289  case 37:
2290#line 555 "grammar.y"
2291    {
2292            memset(&yyval.lv,0,sizeof(yyval.lv));
2293            int i = atoi(yyvsp[0].name);
2294            /*remember not to omFree($1)
2295            *because it is a part of the scanner buffer*/
2296            yyval.lv.rtyp  = INT_CMD;
2297            yyval.lv.data = (void *)(long)i;
2298
2299            /* check: out of range input */
2300            int l = strlen(yyvsp[0].name)+2;
2301            number n;
2302            if (l >= MAX_INT_LEN)
2303            {
2304              char tmp[MAX_INT_LEN+5];
2305              sprintf(tmp,"%d",i);
2306              if (strcmp(tmp,yyvsp[0].name)!=0)
2307              {
2308                nlRead(yyvsp[0].name,&n);
2309                yyval.lv.rtyp=BIGINT_CMD;
2310                yyval.lv.data = n;
2311              }
2312            }
2313          ;}
2314    break;
2315
2316  case 38:
2317#line 579 "grammar.y"
2318    {
2319            memset(&yyval.lv,0,sizeof(yyval.lv));
2320            yyval.lv.rtyp = yyvsp[0].i;
2321            yyval.lv.data = yyval.lv.Data();
2322          ;}
2323    break;
2324
2325  case 39:
2326#line 585 "grammar.y"
2327    {
2328            memset(&yyval.lv,0,sizeof(yyval.lv));
2329            yyval.lv.rtyp  = STRING_CMD;
2330            yyval.lv.data = yyvsp[0].name;
2331          ;}
2332    break;
2333
2334  case 40:
2335#line 591 "grammar.y"
2336    {
2337            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
2338          ;}
2339    break;
2340
2341  case 41:
2342#line 598 "grammar.y"
2343    {
2344            leftv v = &yyvsp[-2].lv;
2345            while (v->next!=NULL)
2346            {
2347              v=v->next;
2348            }
2349            v->next = (leftv)omAllocBin(sleftv_bin);
2350            memcpy(v->next,&(yyvsp[0].lv),sizeof(sleftv));
2351            yyval.lv = yyvsp[-2].lv;
2352          ;}
2353    break;
2354
2355  case 42:
2356#line 609 "grammar.y"
2357    {
2358            yyval.lv = yyvsp[0].lv;
2359          ;}
2360    break;
2361
2362  case 43:
2363#line 615 "grammar.y"
2364    {
2365            /*if ($1.typ == eunknown) YYERROR;*/
2366            yyval.lv = yyvsp[0].lv;
2367          ;}
2368    break;
2369
2370  case 44:
2371#line 619 "grammar.y"
2372    { yyval.lv = yyvsp[0].lv; ;}
2373    break;
2374
2375  case 45:
2376#line 620 "grammar.y"
2377    { yyval.lv = yyvsp[-1].lv; ;}
2378    break;
2379
2380  case 46:
2381#line 622 "grammar.y"
2382    {
2383            if(iiExprArith3(&yyval.lv,'[',&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2384          ;}
2385    break;
2386
2387  case 47:
2388#line 626 "grammar.y"
2389    {
2390            if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,'[',&yyvsp[-1].lv)) YYERROR;
2391          ;}
2392    break;
2393
2394  case 48:
2395#line 630 "grammar.y"
2396    {
2397            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
2398          ;}
2399    break;
2400
2401  case 49:
2402#line 634 "grammar.y"
2403    {
2404            if(iiExprArithM(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
2405          ;}
2406    break;
2407
2408  case 50:
2409#line 638 "grammar.y"
2410    {
2411            if(iiExprArithM(&yyval.lv,NULL,yyvsp[-2].i)) YYERROR;
2412          ;}
2413    break;
2414
2415  case 51:
2416#line 642 "grammar.y"
2417    {
2418            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
2419          ;}
2420    break;
2421
2422  case 52:
2423#line 646 "grammar.y"
2424    {
2425            if(iiExprArithM(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
2426          ;}
2427    break;
2428
2429  case 53:
2430#line 650 "grammar.y"
2431    {
2432            if(iiExprArithM(&yyval.lv,NULL,yyvsp[-2].i)) YYERROR;
2433          ;}
2434    break;
2435
2436  case 54:
2437#line 654 "grammar.y"
2438    {
2439            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
2440          ;}
2441    break;
2442
2443  case 55:
2444#line 658 "grammar.y"
2445    {
2446            if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR;
2447          ;}
2448    break;
2449
2450  case 56:
2451#line 662 "grammar.y"
2452    {
2453            if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2454          ;}
2455    break;
2456
2457  case 57:
2458#line 666 "grammar.y"
2459    {
2460            if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR;
2461          ;}
2462    break;
2463
2464  case 58:
2465#line 670 "grammar.y"
2466    {
2467            if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2468          ;}
2469    break;
2470
2471  case 59:
2472#line 674 "grammar.y"
2473    {
2474            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
2475          ;}
2476    break;
2477
2478  case 60:
2479#line 678 "grammar.y"
2480    {
2481            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
2482          ;}
2483    break;
2484
2485  case 61:
2486#line 682 "grammar.y"
2487    {
2488            if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR;
2489          ;}
2490    break;
2491
2492  case 62:
2493#line 686 "grammar.y"
2494    {
2495            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
2496          ;}
2497    break;
2498
2499  case 63:
2500#line 690 "grammar.y"
2501    {
2502            if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR;
2503          ;}
2504    break;
2505
2506  case 64:
2507#line 694 "grammar.y"
2508    {
2509            if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2510          ;}
2511    break;
2512
2513  case 65:
2514#line 698 "grammar.y"
2515    {
2516            if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2517          ;}
2518    break;
2519
2520  case 66:
2521#line 702 "grammar.y"
2522    {
2523            if(iiExprArithM(&yyval.lv,NULL,yyvsp[-2].i)) YYERROR;
2524          ;}
2525    break;
2526
2527  case 67:
2528#line 706 "grammar.y"
2529    {
2530            if(iiExprArithM(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
2531          ;}
2532    break;
2533
2534  case 68:
2535#line 710 "grammar.y"
2536    {
2537            if(iiExprArith3(&yyval.lv,MATRIX_CMD,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2538          ;}
2539    break;
2540
2541  case 69:
2542#line 714 "grammar.y"
2543    {
2544            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,MATRIX_CMD)) YYERROR;
2545          ;}
2546    break;
2547
2548  case 70:
2549#line 718 "grammar.y"
2550    {
2551            if(iiExprArith3(&yyval.lv,INTMAT_CMD,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2552          ;}
2553    break;
2554
2555  case 71:
2556#line 722 "grammar.y"
2557    {
2558            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,INTMAT_CMD)) YYERROR;
2559          ;}
2560    break;
2561
2562  case 72:
2563#line 726 "grammar.y"
2564    {
2565            if(iiExprArith3(&yyval.lv,RING_CMD,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2566          ;}
2567    break;
2568
2569  case 73:
2570#line 730 "grammar.y"
2571    {
2572            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,RING_CMD)) YYERROR;
2573          ;}
2574    break;
2575
2576  case 74:
2577#line 734 "grammar.y"
2578    {
2579            yyval.lv=yyvsp[-1].lv;
2580          ;}
2581    break;
2582
2583  case 75:
2584#line 738 "grammar.y"
2585    {
2586            #ifdef SIQ
2587            siq++;
2588            if (siq>0)
2589            { if (iiExprArith2(&yyval.lv,&yyvsp[-3].lv,'=',&yyvsp[-1].lv)) YYERROR; }
2590            else
2591            #endif
2592            {
2593              memset(&yyval.lv,0,sizeof(yyval.lv));
2594              yyval.lv.rtyp=NONE;
2595              if (iiAssign(&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2596            }
2597            #ifdef SIQ
2598            siq--;
2599            #endif
2600          ;}
2601    break;
2602
2603  case 76:
2604#line 755 "grammar.y"
2605    {
2606            #ifdef SIQ
2607            siq--;
2608            #endif
2609          ;}
2610    break;
2611
2612  case 77:
2613#line 761 "grammar.y"
2614    {
2615            #ifdef SIQ
2616            if (siq<=0) yyvsp[-1].lv.Eval();
2617            #endif
2618            yyval.lv=yyvsp[-1].lv;
2619            #ifdef SIQ
2620            siq++;
2621            #endif
2622          ;}
2623    break;
2624
2625  case 78:
2626#line 773 "grammar.y"
2627    {
2628            #ifdef SIQ
2629            siq++;
2630            #endif
2631          ;}
2632    break;
2633
2634  case 79:
2635#line 781 "grammar.y"
2636    {
2637            #ifdef SIQ
2638            siq--;
2639            #endif
2640          ;}
2641    break;
2642
2643  case 80:
2644#line 790 "grammar.y"
2645    {
2646            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,PLUSPLUS)) YYERROR;
2647          ;}
2648    break;
2649
2650  case 81:
2651#line 794 "grammar.y"
2652    {
2653            if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,MINUSMINUS)) YYERROR;
2654          ;}
2655    break;
2656
2657  case 82:
2658#line 798 "grammar.y"
2659    {
2660            if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,'+',&yyvsp[0].lv)) YYERROR;
2661          ;}
2662    break;
2663
2664  case 83:
2665#line 802 "grammar.y"
2666    {
2667            if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,'-',&yyvsp[0].lv)) YYERROR;
2668          ;}
2669    break;
2670
2671  case 84:
2672#line 806 "grammar.y"
2673    {
2674            if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,yyvsp[-1].i,&yyvsp[0].lv)) YYERROR;
2675          ;}
2676    break;
2677
2678  case 85:
2679#line 810 "grammar.y"
2680    {
2681            if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,'^',&yyvsp[0].lv)) YYERROR;
2682          ;}
2683    break;
2684
2685  case 86:
2686#line 814 "grammar.y"
2687    {
2688            if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,yyvsp[-1].i,&yyvsp[0].lv)) YYERROR;
2689          ;}
2690    break;
2691
2692  case 87:
2693#line 818 "grammar.y"
2694    {
2695            if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,yyvsp[-1].i,&yyvsp[0].lv)) YYERROR;
2696          ;}
2697    break;
2698
2699  case 88:
2700#line 822 "grammar.y"
2701    {
2702            if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,NOTEQUAL,&yyvsp[0].lv)) YYERROR;
2703          ;}
2704    break;
2705
2706  case 89:
2707#line 826 "grammar.y"
2708    {
2709            if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,EQUAL_EQUAL,&yyvsp[0].lv)) YYERROR;
2710          ;}
2711    break;
2712
2713  case 90:
2714#line 830 "grammar.y"
2715    {
2716            if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,DOTDOT,&yyvsp[0].lv)) YYERROR;
2717          ;}
2718    break;
2719
2720  case 91:
2721#line 834 "grammar.y"
2722    {
2723            if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,':',&yyvsp[0].lv)) YYERROR;
2724          ;}
2725    break;
2726
2727  case 92:
2728#line 838 "grammar.y"
2729    {
2730            memset(&yyval.lv,0,sizeof(yyval.lv));
2731            int i; TESTSETINT(yyvsp[0].lv,i);
2732            yyval.lv.rtyp  = INT_CMD;
2733            yyval.lv.data = (void *)(long)(i == 0 ? 1 : 0);
2734          ;}
2735    break;
2736
2737  case 93:
2738#line 845 "grammar.y"
2739    {
2740            if(iiExprArith1(&yyval.lv,&yyvsp[0].lv,'-')) YYERROR;
2741          ;}
2742    break;
2743
2744  case 94:
2745#line 851 "grammar.y"
2746    { yyval.lv = yyvsp[-1].lv; ;}
2747    break;
2748
2749  case 95:
2750#line 853 "grammar.y"
2751    {
2752            if (yyvsp[-1].lv.rtyp==0)
2753            {
2754              Werror("`%s` is undefined",yyvsp[-1].lv.Fullname());
2755              YYERROR;
2756            }
2757            else if ((yyvsp[-1].lv.rtyp==MODUL_CMD)
2758            // matrix m; m[2]=...
2759            && (yyvsp[-1].lv.e!=NULL) && (yyvsp[-1].lv.e->next==NULL))
2760            {
2761              MYYERROR("matrix must have 2 indices");
2762            }
2763            yyval.lv = yyvsp[-1].lv;
2764          ;}
2765    break;
2766
2767  case 97:
2768#line 873 "grammar.y"
2769    {
2770            if (yyvsp[-1].lv.Typ()!=STRING_CMD)
2771            {
2772              MYYERROR("string expression expected");
2773            }
2774            yyval.name = (char *)yyvsp[-1].lv.CopyD(STRING_CMD);
2775            yyvsp[-1].lv.CleanUp();
2776          ;}
2777    break;
2778
2779  case 100:
2780#line 890 "grammar.y"
2781    {
2782            if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2783              YYERROR;
2784          ;}
2785    break;
2786
2787  case 101:
2788#line 895 "grammar.y"
2789    {
2790            if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2791              YYERROR;
2792          ;}
2793    break;
2794
2795  case 102:
2796#line 900 "grammar.y"
2797    {
2798            if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR;
2799          ;}
2800    break;
2801
2802  case 103:
2803#line 904 "grammar.y"
2804    {
2805            if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR;
2806          ;}
2807    break;
2808
2809  case 104:
2810#line 908 "grammar.y"
2811    {
2812            if (iiDeclCommand(&yyval.lv,&yyvsp[-6].lv,myynest,yyvsp[-7].i,&(currRing->idroot), TRUE)) YYERROR;
2813            int r; TESTSETINT(yyvsp[-4].lv,r);
2814            int c; TESTSETINT(yyvsp[-1].lv,c);
2815            if (r < 1)
2816              MYYERROR("rows must be greater than 0");
2817            if (c < 0)
2818              MYYERROR("cols must be greater than -1");
2819            leftv v=&yyval.lv;
2820            //while (v->next!=NULL) { v=v->next; }
2821            idhdl h=(idhdl)v->data;
2822            idDelete(&IDIDEAL(h));
2823            IDMATRIX(h) = mpNew(r,c);
2824            if (IDMATRIX(h)==NULL) YYERROR;
2825          ;}
2826    break;
2827
2828  case 105:
2829#line 924 "grammar.y"
2830    {
2831            if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR;
2832          ;}
2833    break;
2834
2835  case 106:
2836#line 928 "grammar.y"
2837    {
2838            int r; TESTSETINT(yyvsp[-4].lv,r);
2839            int c; TESTSETINT(yyvsp[-1].lv,c);
2840            if (r < 1)
2841              MYYERROR("rows must be greater than 0");
2842            if (c < 0)
2843              MYYERROR("cols must be greater than -1");
2844            if (iiDeclCommand(&yyval.lv,&yyvsp[-6].lv,myynest,yyvsp[-7].i,&(yyvsp[-6].lv.req_packhdl->idroot)))
2845              YYERROR;
2846            leftv v=&yyval.lv;
2847            idhdl h=(idhdl)v->data;
2848            delete IDINTVEC(h);
2849            IDINTVEC(h) = new intvec(r,c,0);
2850            if (IDINTVEC(h)==NULL) YYERROR;
2851          ;}
2852    break;
2853
2854  case 107:
2855#line 944 "grammar.y"
2856    {
2857            if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2858              YYERROR;
2859            leftv v=&yyval.lv;
2860            idhdl h;
2861            do
2862            {
2863               h=(idhdl)v->data;
2864               delete IDINTVEC(h);
2865               IDINTVEC(h) = new intvec(1,1,0);
2866               v=v->next;
2867            } while (v!=NULL);
2868          ;}
2869    break;
2870
2871  case 108:
2872#line 958 "grammar.y"
2873    {
2874            int t=yyvsp[-2].lv.Typ();
2875            sleftv r;
2876            memset(&r,0,sizeof(sleftv));
2877            if ((BEGIN_RING<t) && (t<END_RING))
2878            {
2879              if (iiDeclCommand(&r,&yyvsp[0].lv,myynest,t,&(currRing->idroot), TRUE))
2880                YYERROR;
2881            }
2882            else
2883            {
2884              if (iiDeclCommand(&r,&yyvsp[0].lv,myynest,t,&(yyvsp[0].lv.req_packhdl->idroot)))
2885                YYERROR;
2886            }
2887            leftv v=&yyvsp[-2].lv;
2888            while (v->next!=NULL) v=v->next;
2889            v->next=(leftv)omAllocBin(sleftv_bin);
2890            memcpy(v->next,&r,sizeof(sleftv));
2891            yyval.lv=yyvsp[-2].lv;
2892          ;}
2893    break;
2894
2895  case 109:
2896#line 979 "grammar.y"
2897    {
2898            if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2899              YYERROR;
2900          ;}
2901    break;
2902
2903  case 112:
2904#line 992 "grammar.y"
2905    {
2906            leftv v = &yyvsp[-3].lv;
2907            while (v->next!=NULL)
2908            {
2909              v=v->next;
2910            }
2911            v->next = (leftv)omAllocBin(sleftv_bin);
2912            memcpy(v->next,&(yyvsp[-1].lv),sizeof(sleftv));
2913            yyval.lv = yyvsp[-3].lv;
2914          ;}
2915    break;
2916
2917  case 113:
2918#line 1006 "grammar.y"
2919    {
2920          // let rInit take care of any errors
2921          yyval.i=rOrderName(yyvsp[0].name);
2922        ;}
2923    break;
2924
2925  case 114:
2926#line 1014 "grammar.y"
2927    {
2928            memset(&yyval.lv,0,sizeof(yyval.lv));
2929            intvec *iv = new intvec(2);
2930            (*iv)[0] = 1;
2931            (*iv)[1] = yyvsp[0].i;
2932            yyval.lv.rtyp = INTVEC_CMD;
2933            yyval.lv.data = (void *)iv;
2934          ;}
2935    break;
2936
2937  case 115:
2938#line 1023 "grammar.y"
2939    {
2940            memset(&yyval.lv,0,sizeof(yyval.lv));
2941            leftv sl = &yyvsp[-1].lv;
2942            int slLength;
2943            {
2944              slLength =  exprlist_length(sl);
2945              int l = 2 +  slLength;
2946              intvec *iv = new intvec(l);
2947              (*iv)[0] = slLength;
2948              (*iv)[1] = yyvsp[-3].i;
2949
2950              int i = 2;
2951              while ((i<l) && (sl!=NULL))
2952              {
2953                if (sl->Typ() == INT_CMD)
2954                {
2955                  (*iv)[i++] = (int)((long)(sl->Data()));
2956                }
2957                else if ((sl->Typ() == INTVEC_CMD)
2958                ||(sl->Typ() == INTMAT_CMD))
2959                {
2960                  intvec *ivv = (intvec *)(sl->Data());
2961                  int ll = 0,l = ivv->length();
2962                  for (; l>0; l--)
2963                  {
2964                    (*iv)[i++] = (*ivv)[ll++];
2965                  }
2966                }
2967                else
2968                {
2969                  delete iv;
2970                  yyvsp[-1].lv.CleanUp();
2971                  MYYERROR("wrong type in ordering");
2972                }
2973                sl = sl->next;
2974              }
2975              yyval.lv.rtyp = INTVEC_CMD;
2976              yyval.lv.data = (void *)iv;
2977            }
2978            yyvsp[-1].lv.CleanUp();
2979          ;}
2980    break;
2981
2982  case 117:
2983#line 1069 "grammar.y"
2984    {
2985            yyval.lv = yyvsp[-2].lv;
2986            yyval.lv.next = (sleftv *)omAllocBin(sleftv_bin);
2987            memcpy(yyval.lv.next,&yyvsp[0].lv,sizeof(sleftv));
2988          ;}
2989    break;
2990
2991  case 119:
2992#line 1079 "grammar.y"
2993    {
2994            yyval.lv = yyvsp[-1].lv;
2995          ;}
2996    break;
2997
2998  case 120:
2999#line 1085 "grammar.y"
3000    {
3001            expected_parms = TRUE;
3002          ;}
3003    break;
3004
3005  case 121:
3006#line 1097 "grammar.y"
3007    { if (yyvsp[-1].i != '<') YYERROR;
3008            if((feFilePending=feFopen(yyvsp[0].name,"r",NULL,TRUE))==NULL) YYERROR; ;}
3009    break;
3010
3011  case 122:
3012#line 1100 "grammar.y"
3013    { newFile(yyvsp[-2].name,feFilePending); ;}
3014    break;
3015
3016  case 123:
3017#line 1105 "grammar.y"
3018    {
3019            feHelp(yyvsp[-1].name);
3020            omFree((ADDRESS)yyvsp[-1].name);
3021          ;}
3022    break;
3023
3024  case 124:
3025#line 1110 "grammar.y"
3026    {
3027            feHelp(NULL);
3028          ;}
3029    break;
3030
3031  case 125:
3032#line 1117 "grammar.y"
3033    {
3034            singular_example(yyvsp[-1].name);
3035            omFree((ADDRESS)yyvsp[-1].name);
3036          ;}
3037    break;
3038
3039  case 126:
3040#line 1125 "grammar.y"
3041    {
3042          if (basePack!=yyvsp[0].lv.req_packhdl)
3043          {
3044            if(iiExport(&yyvsp[0].lv,0,currPackHdl)) YYERROR;
3045          }
3046          else
3047            if (iiExport(&yyvsp[0].lv,0)) YYERROR;
3048        ;}
3049    break;
3050
3051  case 127:
3052#line 1137 "grammar.y"
3053    {
3054          leftv v=&yyvsp[0].lv;
3055          if (v->rtyp!=IDHDL)
3056          {
3057            if (v->name!=NULL)
3058            {
3059               Werror("`%s` is undefined in kill",v->name);
3060            }
3061            else               WerrorS("kill what ?");
3062          }
3063          else
3064          {
3065            killhdl((idhdl)v->data,v->req_packhdl);
3066          }
3067        ;}
3068    break;
3069
3070  case 128:
3071#line 1153 "grammar.y"
3072    {
3073          leftv v=&yyvsp[0].lv;
3074          if (v->rtyp!=IDHDL)
3075          {
3076            if (v->name!=NULL)
3077            {
3078               Werror("`%s` is undefined in kill",v->name);
3079            }
3080            else               WerrorS("kill what ?");
3081          }
3082          else
3083          {
3084            killhdl((idhdl)v->data,v->req_packhdl);
3085          }
3086        ;}
3087    break;
3088
3089  case 129:
3090#line 1172 "grammar.y"
3091    {
3092            list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3093          ;}
3094    break;
3095
3096  case 130:
3097#line 1176 "grammar.y"
3098    {
3099            list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3100          ;}
3101    break;
3102
3103  case 131:
3104#line 1180 "grammar.y"
3105    {
3106            if (yyvsp[-1].i==QRING_CMD) yyvsp[-1].i=RING_CMD;
3107            list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3108          ;}
3109    break;
3110
3111  case 132:
3112#line 1185 "grammar.y"
3113    {
3114            list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3115          ;}
3116    break;
3117
3118  case 133:
3119#line 1189 "grammar.y"
3120    {
3121            list_cmd(RING_CMD,NULL,"// ",TRUE);
3122          ;}
3123    break;
3124
3125  case 134:
3126#line 1193 "grammar.y"
3127    {
3128            list_cmd(MATRIX_CMD,NULL,"// ",TRUE);
3129           ;}
3130    break;
3131
3132  case 135:
3133#line 1197 "grammar.y"
3134    {
3135            list_cmd(INTMAT_CMD,NULL,"// ",TRUE);
3136          ;}
3137    break;
3138
3139  case 136:
3140#line 1201 "grammar.y"
3141    {
3142            list_cmd(PROC_CMD,NULL,"// ",TRUE);
3143          ;}
3144    break;
3145
3146  case 137:
3147#line 1205 "grammar.y"
3148    {
3149            list_cmd(0,yyvsp[-1].lv.Fullname(),"// ",TRUE);
3150            yyvsp[-1].lv.CleanUp();
3151          ;}
3152    break;
3153
3154  case 138:
3155#line 1210 "grammar.y"
3156    {
3157            if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
3158              list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3159            yyvsp[-3].lv.CleanUp();
3160          ;}
3161    break;
3162
3163  case 139:
3164#line 1216 "grammar.y"
3165    {
3166            if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
3167              list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3168            yyvsp[-3].lv.CleanUp();
3169          ;}
3170    break;
3171
3172  case 140:
3173#line 1222 "grammar.y"
3174    {
3175            if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
3176              list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3177            yyvsp[-3].lv.CleanUp();
3178          ;}
3179    break;
3180
3181  case 141:
3182#line 1228 "grammar.y"
3183    {
3184            if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
3185              list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3186            yyvsp[-3].lv.CleanUp();
3187          ;}
3188    break;
3189
3190  case 142:
3191#line 1234 "grammar.y"
3192    {
3193            if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
3194              list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3195            yyvsp[-3].lv.CleanUp();
3196          ;}
3197    break;
3198
3199  case 143:
3200#line 1240 "grammar.y"
3201    {
3202            if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
3203              list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3204            yyvsp[-3].lv.CleanUp();
3205          ;}
3206    break;
3207
3208  case 144:
3209#line 1246 "grammar.y"
3210    {
3211            if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
3212              list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3213            yyvsp[-3].lv.CleanUp();
3214          ;}
3215    break;
3216
3217  case 145:
3218#line 1252 "grammar.y"
3219    {
3220            if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
3221              list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
3222            yyvsp[-3].lv.CleanUp();
3223          ;}
3224    break;
3225
3226  case 146:
3227#line 1264 "grammar.y"
3228    {
3229            list_cmd(-1,NULL,"// ",TRUE);
3230          ;}
3231    break;
3232
3233  case 147:
3234#line 1270 "grammar.y"
3235    { yyInRingConstruction = TRUE; ;}
3236    break;
3237
3238  case 148:
3239#line 1279 "grammar.y"
3240    {
3241            const char *ring_name = yyvsp[-6].lv.name;
3242            ring b=
3243            rInit(&yyvsp[-4].lv,            /* characteristik and list of parameters*/
3244                  &yyvsp[-2].lv,            /* names of ringvariables */
3245                  &yyvsp[0].lv);            /* ordering */
3246            idhdl newRingHdl=NULL;
3247
3248            if (b!=NULL)
3249            {
3250                newRingHdl=enterid(ring_name, myynest, RING_CMD,
3251                                   &(yyvsp[-6].lv.req_packhdl->idroot));
3252              yyvsp[-6].lv.CleanUp();
3253              if (newRingHdl!=NULL)
3254              {
3255                omFreeSize(IDRING(newRingHdl),sizeof(ip_sring));
3256                IDRING(newRingHdl)=b;
3257              }
3258              else
3259              {
3260                rKill(b);
3261              }
3262            }
3263            yyInRingConstruction = FALSE;
3264            if (newRingHdl==NULL)
3265            {
3266              MYYERROR("cannot make ring");
3267            }
3268            else
3269            {
3270              rSetHdl(newRingHdl);
3271            }
3272          ;}
3273    break;
3274
3275  case 149:
3276#line 1313 "grammar.y"
3277    {
3278            const char *ring_name = yyvsp[0].lv.name;
3279            if (!inerror) rDefault(ring_name);
3280            yyInRingConstruction = FALSE;
3281            yyvsp[0].lv.CleanUp();
3282          ;}
3283    break;
3284
3285  case 150:
3286#line 1323 "grammar.y"
3287    {
3288            if ((yyvsp[-1].i!=LIB_CMD)||(iiLibCmd(yyvsp[0].name,TRUE,TRUE,TRUE)))
3289            //if ($1==LIB_CMD)
3290            //{
3291            //  sleftv tmp;
3292            //  if(iiExprArith1(&tmp,&$2,LIB_CMD)) YYERROR;
3293            //}
3294            //else
3295                YYERROR;
3296          ;}
3297    break;
3298
3299  case 153:
3300#line 1339 "grammar.y"
3301    {
3302            if ((yyvsp[-1].i==KEEPRING_CMD) && (myynest==0))
3303               MYYERROR("only inside a proc allowed");
3304            const char * n=yyvsp[0].lv.Name();
3305            if (((yyvsp[0].lv.Typ()==RING_CMD)||(yyvsp[0].lv.Typ()==QRING_CMD))
3306            && (yyvsp[0].lv.rtyp==IDHDL))
3307            {
3308              idhdl h=(idhdl)yyvsp[0].lv.data;
3309              if (yyvsp[0].lv.e!=NULL) h=rFindHdl((ring)yyvsp[0].lv.Data(),NULL, NULL);
3310              //Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
3311              if (yyvsp[-1].i==KEEPRING_CMD)
3312              {
3313                if (h!=NULL)
3314                {
3315                  if (IDLEV(h)!=0)
3316                  {
3317                    if (iiExport(&yyvsp[0].lv,myynest-1)) YYERROR;
3318#if 1
3319                    idhdl p=IDRING(h)->idroot;
3320                    idhdl root=p;
3321                    int prevlev=myynest-1;
3322                    while (p!=NULL)
3323                    {
3324                      if (IDLEV(p)==myynest)
3325                      {
3326                        idhdl old=root->get(IDID(p),prevlev);
3327                        if (old!=NULL)
3328                        {
3329                          if (BVERBOSE(V_REDEFINE))
3330                            Warn("redefining %s",IDID(p));
3331                          killhdl2(old,&root,IDRING(h));
3332                          IDRING(h)->idroot=root;
3333                        }
3334                        IDLEV(p)=prevlev;
3335                      }
3336                      p=IDNEXT(p);
3337                    }
3338#endif
3339                  }
3340#ifdef USE_IILOCALRING
3341                  iiLocalRing[myynest-1]=IDRING(h);
3342#endif
3343                  procstack->cRing=IDRING(h);
3344                  procstack->cRingHdl=h;
3345                }
3346                else
3347                {
3348                  Werror("%s is no identifier",n);
3349                  yyvsp[0].lv.CleanUp();
3350                  YYERROR;
3351                }
3352              }
3353              if (h!=NULL) rSetHdl(h);
3354              else
3355              {
3356                Werror("cannot find the name of the basering %s",n);
3357                yyvsp[0].lv.CleanUp();
3358                YYERROR;
3359              }
3360              yyvsp[0].lv.CleanUp();
3361            }
3362            else
3363            {
3364              Werror("%s is no name of a ring/qring",n);
3365              yyvsp[0].lv.CleanUp();
3366              YYERROR;
3367            }
3368          ;}
3369    break;
3370
3371  case 154:
3372#line 1411 "grammar.y"
3373    {
3374            if ((yyvsp[0].lv.e!=NULL)||(yyvsp[0].lv.rtyp!=IDHDL)) yyvsp[0].lv.Print();
3375            else
3376            {
3377              idhdl h = (idhdl)yyvsp[0].lv.data;
3378              type_cmd(h);
3379            }
3380          ;}
3381    break;
3382
3383  case 155:
3384#line 1420 "grammar.y"
3385    {
3386            //Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
3387            #ifdef SIQ
3388            if (yyvsp[0].lv.rtyp!=COMMAND)
3389            {
3390            #endif
3391              if (yyvsp[0].lv.Typ()==UNKNOWN)
3392              {
3393                if (yyvsp[0].lv.name!=NULL)
3394                {
3395                  Werror("`%s` is undefined",yyvsp[0].lv.name);
3396                  omFree((ADDRESS)yyvsp[0].lv.name);
3397                }
3398                YYERROR;
3399              }
3400            #ifdef SIQ
3401            }
3402            #endif
3403            yyvsp[0].lv.Print(&sLastPrinted);
3404            yyvsp[0].lv.CleanUp(currRing);
3405            if (errorreported) YYERROR;
3406          ;}
3407    break;
3408
3409  case 156:
3410#line 1449 "grammar.y"
3411    {
3412            int i; TESTSETINT(yyvsp[-2].lv,i);
3413            if (i!=0)
3414            {
3415              newBuffer( yyvsp[0].name, BT_if);
3416            }
3417            else
3418            {
3419              omFree((ADDRESS)yyvsp[0].name);
3420              currentVoice->ifsw=1;
3421            }
3422          ;}
3423    break;
3424
3425  case 157:
3426#line 1462 "grammar.y"
3427    {
3428            if (currentVoice->ifsw==1)
3429            {
3430              currentVoice->ifsw=0;
3431              newBuffer( yyvsp[0].name, BT_else);
3432            }
3433            else
3434            {
3435              if (currentVoice->ifsw!=2)
3436              {
3437                Warn("`else` without `if` in level %d",myynest);
3438              }
3439              omFree((ADDRESS)yyvsp[0].name);
3440            }
3441            currentVoice->ifsw=0;
3442          ;}
3443    break;
3444
3445  case 158:
3446#line 1479 "grammar.y"
3447    {
3448            int i; TESTSETINT(yyvsp[-2].lv,i);
3449            if (i)
3450            {
3451              if (exitBuffer(BT_break)) YYERROR;
3452            }
3453            currentVoice->ifsw=0;
3454          ;}
3455    break;
3456
3457  case 159:
3458#line 1488 "grammar.y"
3459    {
3460            if (exitBuffer(BT_break)) YYERROR;
3461            currentVoice->ifsw=0;
3462          ;}
3463    break;
3464
3465  case 160:
3466#line 1493 "grammar.y"
3467    {
3468            if (contBuffer(BT_break)) YYERROR;
3469            currentVoice->ifsw=0;
3470          ;}
3471    break;
3472
3473  case 161:
3474#line 1501 "grammar.y"
3475    {
3476            /* -> if(!$2) break; $3; continue;*/
3477            char * s = (char *)omAlloc( strlen(yyvsp[-1].name) + strlen(yyvsp[0].name) + 36);
3478            sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,yyvsp[-1].name,yyvsp[0].name);
3479            newBuffer(s,BT_break);
3480            omFree((ADDRESS)yyvsp[-1].name);
3481            omFree((ADDRESS)yyvsp[0].name);
3482          ;}
3483    break;
3484
3485  case 162:
3486#line 1513 "grammar.y"
3487    {
3488            /* $2 */
3489            /* if (!$3) break; $5; $4; continue; */
3490            char * s = (char *)omAlloc( strlen(yyvsp[-2].name)+strlen(yyvsp[-1].name)+strlen(yyvsp[0].name)+36);
3491            sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
3492                   ,yyvsp[-2].name,yyvsp[0].name,yyvsp[-1].name);
3493            omFree((ADDRESS)yyvsp[-2].name);
3494            omFree((ADDRESS)yyvsp[-1].name);
3495            omFree((ADDRESS)yyvsp[0].name);
3496            newBuffer(s,BT_break);
3497            s = (char *)omAlloc( strlen(yyvsp[-3].name) + 3);
3498            sprintf(s,"%s;\n",yyvsp[-3].name);
3499            omFree((ADDRESS)yyvsp[-3].name);
3500            newBuffer(s,BT_if);
3501          ;}
3502    break;
3503
3504  case 163:
3505#line 1532 "grammar.y"
3506    {
3507            procinfov pi;
3508            idhdl h = enterid(yyvsp[-1].name,myynest,PROC_CMD,&IDROOT,TRUE);
3509            if (h==NULL) {omFree((ADDRESS)yyvsp[-1].name);omFree((ADDRESS)yyvsp[0].name); YYERROR;}
3510            iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-1].name, 0, 0);
3511            IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+31);;
3512            sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",yyvsp[0].name);
3513            omFree((ADDRESS)yyvsp[0].name);
3514            omFree((ADDRESS)yyvsp[-1].name);
3515          ;}
3516    break;
3517
3518  case 164:
3519#line 1543 "grammar.y"
3520    {
3521            idhdl h = enterid(yyvsp[-2].name,myynest,PROC_CMD,&IDROOT,TRUE);
3522            if (h==NULL)
3523            {
3524              omFree((ADDRESS)yyvsp[-2].name);
3525              omFree((ADDRESS)yyvsp[-1].name);
3526              omFree((ADDRESS)yyvsp[0].name);
3527              YYERROR;
3528            }
3529            char *args=iiProcArgs(yyvsp[-1].name,FALSE);
3530            omFree((ADDRESS)yyvsp[-1].name);
3531            procinfov pi;
3532            iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-2].name, 0, 0);
3533            IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+strlen(args)+14);;
3534            sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,yyvsp[0].name);
3535            omFree((ADDRESS)args);
3536            omFree((ADDRESS)yyvsp[0].name);
3537            omFree((ADDRESS)yyvsp[-2].name);
3538          ;}
3539    break;
3540
3541  case 165:
3542#line 1563 "grammar.y"
3543    {
3544            omFree((ADDRESS)yyvsp[-1].name);
3545            idhdl h = enterid(yyvsp[-3].name,myynest,PROC_CMD,&IDROOT,TRUE);
3546            if (h==NULL)
3547            {
3548              omFree((ADDRESS)yyvsp[-3].name);
3549              omFree((ADDRESS)yyvsp[-2].name);
3550              omFree((ADDRESS)yyvsp[0].name);
3551              YYERROR;
3552            }
3553            char *args=iiProcArgs(yyvsp[-2].name,FALSE);
3554            omFree((ADDRESS)yyvsp[-2].name);
3555            procinfov pi;
3556            iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-3].name, 0, 0);
3557            omFree((ADDRESS)yyvsp[-3].name);
3558            IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+strlen(args)+14);;
3559            sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,yyvsp[0].name);
3560            omFree((ADDRESS)args);
3561            omFree((ADDRESS)yyvsp[0].name);
3562          ;}
3563    break;
3564
3565  case 166:
3566#line 1587 "grammar.y"
3567    {
3568            // decl. of type proc p(int i)
3569            if (yyvsp[-1].i==PARAMETER)  { if (iiParameter(&yyvsp[0].lv)) YYERROR; }
3570            else                { if (iiAlias(&yyvsp[0].lv)) YYERROR; } 
3571          ;}
3572    break;
3573
3574  case 167:
3575#line 1593 "grammar.y"
3576    {
3577            // decl. of type proc p(i)
3578            sleftv tmp_expr;
3579            if (yyvsp[-1].i==ALIAS_CMD) MYYERROR("alias requires a type");
3580            if ((iiDeclCommand(&tmp_expr,&yyvsp[0].lv,myynest,DEF_CMD,&IDROOT))
3581            || (iiParameter(&tmp_expr)))
3582              YYERROR;
3583          ;}
3584    break;
3585
3586  case 168:
3587#line 1605 "grammar.y"
3588    {
3589            if(iiRETURNEXPR==NULL) YYERROR;
3590            iiRETURNEXPR[myynest].Copy(&yyvsp[-1].lv);
3591            yyvsp[-1].lv.CleanUp();
3592            if (exitBuffer(BT_proc)) YYERROR;
3593          ;}
3594    break;
3595
3596  case 169:
3597#line 1612 "grammar.y"
3598    {
3599            if (yyvsp[-2].i==RETURN)
3600            {
3601              if(iiRETURNEXPR==NULL) YYERROR;
3602              iiRETURNEXPR[myynest].Init();
3603              iiRETURNEXPR[myynest].rtyp=NONE;
3604              if (exitBuffer(BT_proc)) YYERROR;
3605            }
3606          ;}
3607    break;
3608
3609
3610    }
3611
3612/* Line 1010 of yacc.c.  */
3613#line 3614 "grammar.cc"
3614
3615  yyvsp -= yylen;
3616  yyssp -= yylen;
3617
3618
3619  YY_STACK_PRINT (yyss, yyssp);
3620
3621  *++yyvsp = yyval;
3622
3623
3624  /* Now `shift' the result of the reduction.  Determine what state
3625     that goes to, based on the state we popped back to and the rule
3626     number reduced by.  */
3627
3628  yyn = yyr1[yyn];
3629
3630  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3631  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3632    yystate = yytable[yystate];
3633  else
3634    yystate = yydefgoto[yyn - YYNTOKENS];
3635
3636  goto yynewstate;
3637
3638
3639/*------------------------------------.
3640| yyerrlab -- here on detecting error |
3641`------------------------------------*/
3642yyerrlab:
3643  /* If not already recovering from an error, report this error.  */
3644  if (!yyerrstatus)
3645    {
3646      ++yynerrs;
3647#if YYERROR_VERBOSE
3648      yyn = yypact[yystate];
3649
3650      if (YYPACT_NINF < yyn && yyn < YYLAST)
3651        {
3652          YYSIZE_T yysize = 0;
3653          int yytype = YYTRANSLATE (yychar);
3654          const char* yyprefix;
3655          char *yymsg;
3656          int yyx;
3657
3658          /* Start YYX at -YYN if negative to avoid negative indexes in
3659             YYCHECK.  */
3660          int yyxbegin = yyn < 0 ? -yyn : 0;
3661
3662          /* Stay within bounds of both yycheck and yytname.  */
3663          int yychecklim = YYLAST - yyn;
3664          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3665          int yycount = 0;
3666
3667          yyprefix = ", expecting ";
3668          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3669            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3670              {
3671                yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
3672                yycount += 1;
3673                if (yycount == 5)
3674                  {
3675                    yysize = 0;
3676                    break;
3677                  }
3678              }
3679          yysize += (sizeof ("syntax error, unexpected ")
3680                     + yystrlen (yytname[yytype]));
3681          yymsg = (char *) YYSTACK_ALLOC (yysize);
3682          if (yymsg != 0)
3683            {
3684              char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
3685              yyp = yystpcpy (yyp, yytname[yytype]);
3686
3687              if (yycount < 5)
3688                {
3689                  yyprefix = ", expecting ";
3690                  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3691                    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3692                      {
3693                        yyp = yystpcpy (yyp, yyprefix);
3694                        yyp = yystpcpy (yyp, yytname[yyx]);
3695                        yyprefix = " or ";
3696                      }
3697                }
3698              yyerror (yymsg);
3699              YYSTACK_FREE (yymsg);
3700            }
3701          else
3702            yyerror ("syntax error; also virtual memory exhausted");
3703        }
3704      else
3705#endif /* YYERROR_VERBOSE */
3706        yyerror ("syntax error");
3707    }
3708
3709
3710
3711  if (yyerrstatus == 3)
3712    {
3713      /* If just tried and failed to reuse lookahead token after an
3714         error, discard it.  */
3715
3716      if (yychar <= YYEOF)
3717        {
3718          /* If at end of input, pop the error token,
3719             then the rest of the stack, then return failure.  */
3720          if (yychar == YYEOF)
3721             for (;;)
3722               {
3723                 YYPOPSTACK;
3724                 if (yyssp == yyss)
3725                   YYABORT;
3726                 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
3727                 yydestruct (yystos[*yyssp], yyvsp);
3728               }
3729        }
3730      else
3731        {
3732          YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
3733          yydestruct (yytoken, &yylval);
3734          yychar = YYEMPTY;
3735
3736        }
3737    }
3738
3739  /* Else will try to reuse lookahead token after shifting the error
3740     token.  */
3741  goto yyerrlab1;
3742
3743
3744/*---------------------------------------------------.
3745| yyerrorlab -- error raised explicitly by YYERROR.  |
3746`---------------------------------------------------*/
3747yyerrorlab:
3748
3749#ifdef __GNUC__
3750  /* Pacify GCC when the user code never invokes YYERROR and the label
3751     yyerrorlab therefore never appears in user code.  */
3752  if (0)
3753     goto yyerrorlab;
3754#endif
3755
3756  yyvsp -= yylen;
3757  yyssp -= yylen;
3758  yystate = *yyssp;
3759  goto yyerrlab1;
3760
3761
3762/*-------------------------------------------------------------.
3763| yyerrlab1 -- common code for both syntax error and YYERROR.  |
3764`-------------------------------------------------------------*/
3765yyerrlab1:
3766  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
3767
3768  for (;;)
3769    {
3770      yyn = yypact[yystate];
3771      if (yyn != YYPACT_NINF)
3772        {
3773          yyn += YYTERROR;
3774          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3775            {
3776              yyn = yytable[yyn];
3777              if (0 < yyn)
3778                break;
3779            }
3780        }
3781
3782      /* Pop the current state because it cannot handle the error token.  */
3783      if (yyssp == yyss)
3784        YYABORT;
3785
3786      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
3787      yydestruct (yystos[yystate], yyvsp);
3788      YYPOPSTACK;
3789      yystate = *yyssp;
3790      YY_STACK_PRINT (yyss, yyssp);
3791    }
3792
3793  if (yyn == YYFINAL)
3794    YYACCEPT;
3795
3796  YYDPRINTF ((stderr, "Shifting error token, "));
3797
3798  *++yyvsp = yylval;
3799
3800
3801  yystate = yyn;
3802  goto yynewstate;
3803
3804
3805/*-------------------------------------.
3806| yyacceptlab -- YYACCEPT comes here.  |
3807`-------------------------------------*/
3808yyacceptlab:
3809  yyresult = 0;
3810  goto yyreturn;
3811
3812/*-----------------------------------.
3813| yyabortlab -- YYABORT comes here.  |
3814`-----------------------------------*/
3815yyabortlab:
3816  yyresult = 1;
3817  goto yyreturn;
3818
3819#ifndef yyoverflow
3820/*----------------------------------------------.
3821| yyoverflowlab -- parser overflow comes here.  |
3822`----------------------------------------------*/
3823yyoverflowlab:
3824  yyerror ("parser stack overflow");
3825  yyresult = 2;
3826  /* Fall through.  */
3827#endif
3828
3829yyreturn:
3830#ifndef yyoverflow
3831  if (yyss != yyssa)
3832    YYSTACK_FREE (yyss);
3833#endif
3834  return yyresult;
3835}
3836
3837
3838
Note: See TracBrowser for help on using the repository browser.