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