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>
90 #include <kernel/oswrapper/feread.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>
102 #include <kernel/combinatorics/stairc.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 {
114  idhdl r=basePackHdl;
115  idhdl h;
116  BOOLEAN found=FALSE;
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;
173 BOOLEAN yyInRingConstruction=FALSE;
174 BOOLEAN expected_parms;
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;
192  errorreported = TRUE;
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`"
206  ,VoiceName(), yylineno, my_yylinebuf);
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 243 "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,
279  BIGINTMAT_CMD = 269,
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,
290  RESOLUTION_CMD = 280,
291  VECTOR_CMD = 281,
292  BETTI_CMD = 282,
293  COEFFS_CMD = 283,
294  COEF_CMD = 284,
295  CONTRACT_CMD = 285,
296  DEGREE_CMD = 286,
297  DEG_CMD = 287,
298  DIFF_CMD = 288,
299  DIM_CMD = 289,
300  DIVISION_CMD = 290,
301  ELIMINATION_CMD = 291,
302  E_CMD = 292,
303  FAREY_CMD = 293,
304  FETCH_CMD = 294,
305  FREEMODULE_CMD = 295,
306  KEEPRING_CMD = 296,
307  HILBERT_CMD = 297,
308  HOMOG_CMD = 298,
309  IMAP_CMD = 299,
310  INDEPSET_CMD = 300,
311  INTERRED_CMD = 301,
312  INTERSECT_CMD = 302,
313  JACOB_CMD = 303,
314  JET_CMD = 304,
315  KBASE_CMD = 305,
316  KOSZUL_CMD = 306,
317  LEADCOEF_CMD = 307,
318  LEADEXP_CMD = 308,
319  LEAD_CMD = 309,
320  LEADMONOM_CMD = 310,
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,
330  MULTIPLICITY_CMD = 320,
331  ORD_CMD = 321,
332  PAR_CMD = 322,
333  PARDEG_CMD = 323,
334  PREIMAGE_CMD = 324,
335  QUOTIENT_CMD = 325,
336  QHWEIGHT_CMD = 326,
337  REDUCE_CMD = 327,
338  REGULARITY_CMD = 328,
339  RES_CMD = 329,
340  SBA_CMD = 330,
341  SIMPLIFY_CMD = 331,
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,
366  ROOT_DECL_LIST = 356,
367  RING_DECL = 357,
368  RING_DECL_LIST = 358,
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,
380  UNKNOWN_IDENT = 370,
381  RINGVAR = 371,
382  PROC_DEF = 372,
383  APPLY = 373,
384  ASSUME_CMD = 374,
385  BREAK_CMD = 375,
386  CONTINUE_CMD = 376,
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 416 "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, 364, 364, 366, 400, 401, 403, 405, 409, 414,
795  416, 467, 468, 469, 470, 471, 472, 473, 474, 478,
796  481, 482, 483, 484, 485, 486, 487, 488, 489, 492,
797  499, 504, 508, 512, 516, 520, 533, 561, 585, 591,
798  597, 601, 605, 609, 613, 617, 621, 625, 629, 633,
799  637, 641, 645, 649, 653, 657, 661, 665, 669, 673,
800  677, 683, 687, 691, 695, 699, 706, 717, 723, 728,
801  729, 730, 734, 738, 742, 746, 750, 754, 758, 762,
802  766, 783, 790, 789, 807, 815, 823, 832, 836, 840,
803  844, 848, 852, 856, 860, 864, 868, 872, 876, 880,
804  892, 899, 900, 919, 920, 932, 937, 942, 946, 950,
805  990, 1016, 1037, 1045, 1049, 1050, 1064, 1072, 1081, 1126,
806  1127, 1136, 1137, 1143, 1150, 1152, 1154, 1164, 1163, 1171,
807  1176, 1183, 1191, 1203, 1219, 1238, 1242, 1246, 1251, 1255,
808  1259, 1263, 1267, 1272, 1278, 1284, 1290, 1296, 1302, 1308,
809  1320, 1327, 1331, 1368, 1375, 1383, 1389, 1389, 1392, 1464,
810  1468, 1497, 1510, 1527, 1536, 1541, 1549, 1561, 1580, 1590,
811  1609, 1632, 1638, 1650, 1656
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
1799 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
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. */
1862 int yydebug;
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 367 "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();
2447  if (currentVoice!=NULL) currentVoice->ifsw=0;
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;
2456  expected_parms = siCntrlc = FALSE;
2457  ;}
2458  break;
2459 
2460  case 5:
2461 
2462 /* Line 1464 of yacc.c */
2463 #line 402 "grammar.y"
2464  {currentVoice->ifsw=0;;}
2465  break;
2466 
2467  case 6:
2468 
2469 /* Line 1464 of yacc.c */
2470 #line 404 "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 406 "grammar.y"
2478  {
2479  YYACCEPT;
2480  ;}
2481  break;
2482 
2483  case 8:
2484 
2485 /* Line 1464 of yacc.c */
2486 #line 410 "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 415 "grammar.y"
2497  {currentVoice->ifsw=0;;}
2498  break;
2499 
2500  case 10:
2501 
2502 /* Line 1464 of yacc.c */
2503 #line 417 "grammar.y"
2504  {
2505  #ifdef SIQ
2506  siq=0;
2507  #endif
2508  yyInRingConstruction = FALSE;
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  {
2536  feBufferTypes t=currentVoice->Typ();
2537  //PrintS("leaving yyparse\n");
2538  exitBuffer(BT_proc);
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 475 "grammar.y"
2558  {if (currentVoice!=NULL) currentVoice->ifsw=0;;}
2559  break;
2560 
2561  case 19:
2562 
2563 /* Line 1464 of yacc.c */
2564 #line 478 "grammar.y"
2565  { omFree((ADDRESS)(yyvsp[(2) - (2)].name)); ;}
2566  break;
2567 
2568  case 29:
2569 
2570 /* Line 1464 of yacc.c */
2571 #line 493 "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 500 "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 505 "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 509 "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 513 "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 517 "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 521 "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 534 "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 562 "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 586 "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 592 "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 598 "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 602 "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 606 "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 610 "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 614 "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 618 "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 622 "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 626 "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 630 "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 634 "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 638 "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 642 "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 646 "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 650 "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 654 "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 658 "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 662 "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 666 "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 670 "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 674 "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 678 "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 684 "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 688 "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 692 "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 696 "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 700 "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 707 "grammar.y"
2965  {
2966  leftv v = &(yyvsp[(1) - (3)].lv);
2967  while (v->next!=NULL)
2968  {
2969  v=v->next;
2970  }
2971  v->next = (leftv)omAllocBin(sleftv_bin);
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 718 "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 724 "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 728 "grammar.y"
3000  { (yyval.lv) = (yyvsp[(1) - (1)].lv); ;}
3001  break;
3002 
3003  case 70:
3004 
3005 /* Line 1464 of yacc.c */
3006 #line 729 "grammar.y"
3007  { (yyval.lv) = (yyvsp[(2) - (3)].lv); ;}
3008  break;
3009 
3010  case 71:
3011 
3012 /* Line 1464 of yacc.c */
3013 #line 731 "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 735 "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 739 "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 743 "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 747 "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 751 "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 755 "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 759 "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 763 "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 767 "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 784 "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 790 "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 796 "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 808 "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 816 "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 824 "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 833 "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 837 "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 841 "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 845 "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 849 "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 853 "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 857 "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 861 "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 865 "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 869 "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 873 "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 877 "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 881 "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 893 "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 899 "grammar.y"
3321  { (yyval.lv) = (yyvsp[(1) - (2)].lv); ;}
3322  break;
3323 
3324  case 102:
3325 
3326 /* Line 1464 of yacc.c */
3327 #line 901 "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 921 "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 933 "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 938 "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 943 "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 947 "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 951 "grammar.y"
3400  {
3401  int r; TESTSETINT((yyvsp[(4) - (8)].lv),r);
3402  int c; TESTSETINT((yyvsp[(7) - (8)].lv),c);
3403  if (r < 1)
3404  MYYERROR("rows must be greater than 0");
3405  if (c < 0)
3406  MYYERROR("cols must be greater than -1");
3407  leftv v;
3408  idhdl h;
3409  if ((yyvsp[(1) - (8)].i) == MATRIX_CMD)
3410  {
3411  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&(currRing->idroot), TRUE)) YYERROR;
3412  v=&(yyval.lv);
3413  h=(idhdl)v->data;
3414  idDelete(&IDIDEAL(h));
3415  IDMATRIX(h) = mpNew(r,c);
3416  if (IDMATRIX(h)==NULL) YYERROR;
3417  }
3418  else if ((yyvsp[(1) - (8)].i) == INTMAT_CMD)
3419  {
3420  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3421  YYERROR;
3422  v=&(yyval.lv);
3423  h=(idhdl)v->data;
3424  delete IDINTVEC(h);
3425  IDINTVEC(h) = new intvec(r,c,0);
3426  if (IDINTVEC(h)==NULL) YYERROR;
3427  }
3428  else /* BIGINTMAT_CMD */
3429  {
3430  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3431  YYERROR;
3432  v=&(yyval.lv);
3433  h=(idhdl)v->data;
3434  delete IDBIMAT(h);
3435  IDBIMAT(h) = new bigintmat(r, c, coeffs_BIGINT);
3436  if (IDBIMAT(h)==NULL) YYERROR;
3437  }
3438  ;}
3439  break;
3440 
3441  case 110:
3442 
3443 /* Line 1464 of yacc.c */
3444 #line 991 "grammar.y"
3445  {
3446  if ((yyvsp[(1) - (2)].i) == MATRIX_CMD)
3447  {
3448  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3449  }
3450  else if ((yyvsp[(1) - (2)].i) == INTMAT_CMD)
3451  {
3452  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3453  YYERROR;
3454  leftv v=&(yyval.lv);
3455  idhdl h;
3456  do
3457  {
3458  h=(idhdl)v->data;
3459  delete IDINTVEC(h);
3460  IDINTVEC(h) = new intvec(1,1,0);
3461  v=v->next;
3462  } while (v!=NULL);
3463  }
3464  else /* BIGINTMAT_CMD */
3465  {
3466  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3467  YYERROR;
3468  }
3469  ;}
3470  break;
3471 
3472  case 111:
3473 
3474 /* Line 1464 of yacc.c */
3475 #line 1017 "grammar.y"
3476  {
3477  int t=(yyvsp[(1) - (3)].lv).Typ();
3478  sleftv r;
3479  memset(&r,0,sizeof(sleftv));
3480  if ((BEGIN_RING<t) && (t<END_RING))
3481  {
3482  if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&(currRing->idroot), TRUE))
3483  YYERROR;
3484  }
3485  else
3486  {
3487  if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&((yyvsp[(3) - (3)].lv).req_packhdl->idroot)))
3488  YYERROR;
3489  }
3490  leftv v=&(yyvsp[(1) - (3)].lv);
3491  while (v->next!=NULL) v=v->next;
3492  v->next=(leftv)omAllocBin(sleftv_bin);
3493  memcpy(v->next,&r,sizeof(sleftv));
3494  (yyval.lv)=(yyvsp[(1) - (3)].lv);
3495  ;}
3496  break;
3497 
3498  case 112:
3499 
3500 /* Line 1464 of yacc.c */
3501 #line 1038 "grammar.y"
3502  {
3503  if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3504  YYERROR;
3505  ;}
3506  break;
3507 
3508  case 115:
3509 
3510 /* Line 1464 of yacc.c */
3511 #line 1051 "grammar.y"
3512  {
3513  leftv v = &(yyvsp[(2) - (5)].lv);
3514  while (v->next!=NULL)
3515  {
3516  v=v->next;
3517  }
3518  v->next = (leftv)omAllocBin(sleftv_bin);
3519  memcpy(v->next,&((yyvsp[(4) - (5)].lv)),sizeof(sleftv));
3520  (yyval.lv) = (yyvsp[(2) - (5)].lv);
3521  ;}
3522  break;
3523 
3524  case 116:
3525 
3526 /* Line 1464 of yacc.c */
3527 #line 1065 "grammar.y"
3528  {
3529  // let rInit take care of any errors
3530  (yyval.i)=rOrderName((yyvsp[(1) - (1)].name));
3531  ;}
3532  break;
3533 
3534  case 117:
3535 
3536 /* Line 1464 of yacc.c */
3537 #line 1073 "grammar.y"
3538  {
3539  memset(&(yyval.lv),0,sizeof((yyval.lv)));
3540  intvec *iv = new intvec(2);
3541  (*iv)[0] = 1;
3542  (*iv)[1] = (yyvsp[(1) - (1)].i);
3543  (yyval.lv).rtyp = INTVEC_CMD;
3544  (yyval.lv).data = (void *)iv;
3545  ;}
3546  break;
3547 
3548  case 118:
3549 
3550 /* Line 1464 of yacc.c */
3551 #line 1082 "grammar.y"
3552  {
3553  memset(&(yyval.lv),0,sizeof((yyval.lv)));
3554  leftv sl = &(yyvsp[(3) - (4)].lv);
3555  int slLength;
3556  {
3557  slLength = exprlist_length(sl);
3558  int l = 2 + slLength;
3559  intvec *iv = new intvec(l);
3560  (*iv)[0] = slLength;
3561  (*iv)[1] = (yyvsp[(1) - (4)].i);
3562 
3563  int i = 2;
3564  while ((i<l) && (sl!=NULL))
3565  {
3566  if (sl->Typ() == INT_CMD)
3567  {
3568  (*iv)[i++] = (int)((long)(sl->Data()));
3569  }
3570  else if ((sl->Typ() == INTVEC_CMD)
3571  ||(sl->Typ() == INTMAT_CMD))
3572  {
3573  intvec *ivv = (intvec *)(sl->Data());
3574  int ll = 0,l = ivv->length();
3575  for (; l>0; l--)
3576  {
3577  (*iv)[i++] = (*ivv)[ll++];
3578  }
3579  }
3580  else
3581  {
3582  delete iv;
3583  (yyvsp[(3) - (4)].lv).CleanUp();
3584  MYYERROR("wrong type in ordering");
3585  }
3586  sl = sl->next;
3587  }
3588  (yyval.lv).rtyp = INTVEC_CMD;
3589  (yyval.lv).data = (void *)iv;
3590  }
3591  (yyvsp[(3) - (4)].lv).CleanUp();
3592  ;}
3593  break;
3594 
3595  case 120:
3596 
3597 /* Line 1464 of yacc.c */
3598 #line 1128 "grammar.y"
3599  {
3600  (yyval.lv) = (yyvsp[(1) - (3)].lv);
3601  (yyval.lv).next = (sleftv *)omAllocBin(sleftv_bin);
3602  memcpy((yyval.lv).next,&(yyvsp[(3) - (3)].lv),sizeof(sleftv));
3603  ;}
3604  break;
3605 
3606  case 122:
3607 
3608 /* Line 1464 of yacc.c */
3609 #line 1138 "grammar.y"
3610  {
3611  (yyval.lv) = (yyvsp[(2) - (3)].lv);
3612  ;}
3613  break;
3614 
3615  case 123:
3616 
3617 /* Line 1464 of yacc.c */
3618 #line 1144 "grammar.y"
3619  {
3620  expected_parms = TRUE;
3621  ;}
3622  break;
3623 
3624  case 124:
3625 
3626 /* Line 1464 of yacc.c */
3627 #line 1151 "grammar.y"
3628  { (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3629  break;
3630 
3631  case 125:
3632 
3633 /* Line 1464 of yacc.c */
3634 #line 1153 "grammar.y"
3635  { (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3636  break;
3637 
3638  case 126:
3639 
3640 /* Line 1464 of yacc.c */
3641 #line 1155 "grammar.y"
3642  { (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3643  break;
3644 
3645  case 127:
3646 
3647 /* Line 1464 of yacc.c */
3648 #line 1164 "grammar.y"
3649  { if ((yyvsp[(1) - (2)].i) != '<') YYERROR;
3650  if((feFilePending=feFopen((yyvsp[(2) - (2)].name),"r",NULL,TRUE))==NULL) YYERROR; ;}
3651  break;
3652 
3653  case 128:
3654 
3655 /* Line 1464 of yacc.c */
3656 #line 1167 "grammar.y"
3657  { newFile((yyvsp[(2) - (4)].name),feFilePending); ;}
3658  break;
3659 
3660  case 129:
3661 
3662 /* Line 1464 of yacc.c */
3663 #line 1172 "grammar.y"
3664  {
3665  feHelp((yyvsp[(2) - (3)].name));
3666  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3667  ;}
3668  break;
3669 
3670  case 130:
3671 
3672 /* Line 1464 of yacc.c */
3673 #line 1177 "grammar.y"
3674  {
3675  feHelp(NULL);
3676  ;}
3677  break;
3678 
3679  case 131:
3680 
3681 /* Line 1464 of yacc.c */
3682 #line 1184 "grammar.y"
3683  {
3684  singular_example((yyvsp[(2) - (3)].name));
3685  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3686  ;}
3687  break;
3688 
3689  case 132:
3690 
3691 /* Line 1464 of yacc.c */
3692 #line 1192 "grammar.y"
3693  {
3694  if (basePack!=(yyvsp[(2) - (2)].lv).req_packhdl)
3695  {
3696  if(iiExport(&(yyvsp[(2) - (2)].lv),0,currPack)) YYERROR;
3697  }
3698  else
3699  if (iiExport(&(yyvsp[(2) - (2)].lv),0)) YYERROR;
3700  ;}
3701  break;
3702 
3703  case 133:
3704 
3705 /* Line 1464 of yacc.c */
3706 #line 1204 "grammar.y"
3707  {
3708  leftv v=&(yyvsp[(2) - (2)].lv);
3709  if (v->rtyp!=IDHDL)
3710  {
3711  if (v->name!=NULL)
3712  {
3713  Werror("`%s` is undefined in kill",v->name);
3714  }
3715  else WerrorS("kill what ?");
3716  }
3717  else
3718  {
3719  killhdl((idhdl)v->data,v->req_packhdl);
3720  }
3721  ;}
3722  break;
3723 
3724  case 134:
3725 
3726 /* Line 1464 of yacc.c */
3727 #line 1220 "grammar.y"
3728  {
3729  leftv v=&(yyvsp[(3) - (3)].lv);
3730  if (v->rtyp!=IDHDL)
3731  {
3732  if (v->name!=NULL)
3733  {
3734  Werror("`%s` is undefined in kill",v->name);
3735  }
3736  else WerrorS("kill what ?");
3737  }
3738  else
3739  {
3740  killhdl((idhdl)v->data,v->req_packhdl);
3741  }
3742  ;}
3743  break;
3744 
3745  case 135:
3746 
3747 /* Line 1464 of yacc.c */
3748 #line 1239 "grammar.y"
3749  {
3750  list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3751  ;}
3752  break;
3753 
3754  case 136:
3755 
3756 /* Line 1464 of yacc.c */
3757 #line 1243 "grammar.y"
3758  {
3759  list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3760  ;}
3761  break;
3762 
3763  case 137:
3764 
3765 /* Line 1464 of yacc.c */
3766 #line 1247 "grammar.y"
3767  {
3768  if ((yyvsp[(3) - (4)].i)==QRING_CMD) (yyvsp[(3) - (4)].i)=RING_CMD;
3769  list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3770  ;}
3771  break;
3772 
3773  case 138:
3774 
3775 /* Line 1464 of yacc.c */
3776 #line 1252 "grammar.y"
3777  {
3778  list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3779  ;}
3780  break;
3781 
3782  case 139:
3783 
3784 /* Line 1464 of yacc.c */
3785 #line 1256 "grammar.y"
3786  {
3787  list_cmd(RING_CMD,NULL,"// ",TRUE);
3788  ;}
3789  break;
3790 
3791  case 140:
3792 
3793 /* Line 1464 of yacc.c */
3794 #line 1260 "grammar.y"
3795  {
3796  list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3797  ;}
3798  break;
3799 
3800  case 141:
3801 
3802 /* Line 1464 of yacc.c */
3803 #line 1264 "grammar.y"
3804  {
3805  list_cmd(PROC_CMD,NULL,"// ",TRUE);
3806  ;}
3807  break;
3808 
3809  case 142:
3810 
3811 /* Line 1464 of yacc.c */
3812 #line 1268 "grammar.y"
3813  {
3814  list_cmd(0,(yyvsp[(3) - (4)].lv).Fullname(),"// ",TRUE);
3815  (yyvsp[(3) - (4)].lv).CleanUp();
3816  ;}
3817  break;
3818 
3819  case 143:
3820 
3821 /* Line 1464 of yacc.c */
3822 #line 1273 "grammar.y"
3823  {
3824  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3825  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3826  (yyvsp[(3) - (6)].lv).CleanUp();
3827  ;}
3828  break;
3829 
3830  case 144:
3831 
3832 /* Line 1464 of yacc.c */
3833 #line 1279 "grammar.y"
3834  {
3835  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3836  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3837  (yyvsp[(3) - (6)].lv).CleanUp();
3838  ;}
3839  break;
3840 
3841  case 145:
3842 
3843 /* Line 1464 of yacc.c */
3844 #line 1285 "grammar.y"
3845  {
3846  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3847  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3848  (yyvsp[(3) - (6)].lv).CleanUp();
3849  ;}
3850  break;
3851 
3852  case 146:
3853 
3854 /* Line 1464 of yacc.c */
3855 #line 1291 "grammar.y"
3856  {
3857  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3858  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3859  (yyvsp[(3) - (6)].lv).CleanUp();
3860  ;}
3861  break;
3862 
3863  case 147:
3864 
3865 /* Line 1464 of yacc.c */
3866 #line 1297 "grammar.y"
3867  {
3868  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3869  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3870  (yyvsp[(3) - (6)].lv).CleanUp();
3871  ;}
3872  break;
3873 
3874  case 148:
3875 
3876 /* Line 1464 of yacc.c */
3877 #line 1303 "grammar.y"
3878  {
3879  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3880  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3881  (yyvsp[(3) - (6)].lv).CleanUp();
3882  ;}
3883  break;
3884 
3885  case 149:
3886 
3887 /* Line 1464 of yacc.c */
3888 #line 1309 "grammar.y"
3889  {
3890  if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3891  list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3892  (yyvsp[(3) - (6)].lv).CleanUp();
3893  ;}
3894  break;
3895 
3896  case 150:
3897 
3898 /* Line 1464 of yacc.c */
3899 #line 1321 "grammar.y"
3900  {
3901  list_cmd(-1,NULL,"// ",TRUE);
3902  ;}
3903  break;
3904 
3905  case 151:
3906 
3907 /* Line 1464 of yacc.c */
3908 #line 1327 "grammar.y"
3909  { yyInRingConstruction = TRUE; ;}
3910  break;
3911 
3912  case 152:
3913 
3914 /* Line 1464 of yacc.c */
3915 #line 1336 "grammar.y"
3916  {
3917  const char *ring_name = (yyvsp[(2) - (8)].lv).name;
3918  ring b=
3919  rInit(&(yyvsp[(4) - (8)].lv), /* characteristik and list of parameters*/
3920  &(yyvsp[(6) - (8)].lv), /* names of ringvariables */
3921  &(yyvsp[(8) - (8)].lv)); /* ordering */
3922  idhdl newRingHdl=NULL;
3923 
3924  if (b!=NULL)
3925  {
3926  newRingHdl=enterid(ring_name, myynest, RING_CMD,
3927  &((yyvsp[(2) - (8)].lv).req_packhdl->idroot),FALSE);
3928  (yyvsp[(2) - (8)].lv).CleanUp();
3929  if (newRingHdl!=NULL)
3930  {
3931  IDRING(newRingHdl)=b;
3932  }
3933  else
3934  {
3935  rKill(b);
3936  }
3937  }
3938  yyInRingConstruction = FALSE;
3939  if (newRingHdl==NULL)
3940  {
3941  MYYERROR("cannot make ring");
3942  }
3943  else
3944  {
3945  rSetHdl(newRingHdl);
3946  }
3947  ;}
3948  break;
3949 
3950  case 153:
3951 
3952 /* Line 1464 of yacc.c */
3953 #line 1369 "grammar.y"
3954  {
3955  const char *ring_name = (yyvsp[(2) - (2)].lv).name;
3956  if (!inerror) rDefault(ring_name);
3957  yyInRingConstruction = FALSE;
3958  (yyvsp[(2) - (2)].lv).CleanUp();
3959  ;}
3960  break;
3961 
3962  case 154:
3963 
3964 /* Line 1464 of yacc.c */
3965 #line 1376 "grammar.y"
3966  {
3967  yyInRingConstruction = FALSE;
3968  if (iiAssignCR(&(yyvsp[(2) - (4)].lv),&(yyvsp[(4) - (4)].lv))) YYERROR;
3969  ;}
3970  break;
3971 
3972  case 155:
3973 
3974 /* Line 1464 of yacc.c */
3975 #line 1384 "grammar.y"
3976  {
3977  if (((yyvsp[(1) - (2)].i)!=LIB_CMD)||(jjLOAD((yyvsp[(2) - (2)].name),TRUE))) YYERROR;
3978  ;}
3979  break;
3980 
3981  case 158:
3982 
3983 /* Line 1464 of yacc.c */
3984 #line 1393 "grammar.y"
3985  {
3986  if (((yyvsp[(1) - (2)].i)==KEEPRING_CMD) && (myynest==0))
3987  MYYERROR("only inside a proc allowed");
3988  const char * n=(yyvsp[(2) - (2)].lv).Name();
3989  if ((((yyvsp[(2) - (2)].lv).Typ()==RING_CMD)||((yyvsp[(2) - (2)].lv).Typ()==QRING_CMD))
3990  && ((yyvsp[(2) - (2)].lv).rtyp==IDHDL))
3991  {
3992  idhdl h=(idhdl)(yyvsp[(2) - (2)].lv).data;
3993  if ((yyvsp[(2) - (2)].lv).e!=NULL) h=rFindHdl((ring)(yyvsp[(2) - (2)].lv).Data(),NULL);
3994  //Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
3995  if ((yyvsp[(1) - (2)].i)==KEEPRING_CMD)
3996  {
3997  if (h!=NULL)
3998  {
3999  if (IDLEV(h)!=0)
4000  {
4001  if (iiExport(&(yyvsp[(2) - (2)].lv),myynest-1)) YYERROR;
4002 #if 1
4003  idhdl p=IDRING(h)->idroot;
4004  idhdl root=p;
4005  int prevlev=myynest-1;
4006  while (p!=NULL)
4007  {
4008  if (IDLEV(p)==myynest)
4009  {
4010  idhdl old=root->get(IDID(p),prevlev);
4011  if (old!=NULL)
4012  {
4013  if (BVERBOSE(V_REDEFINE))
4014  Warn("redefining %s",IDID(p));
4015  killhdl2(old,&root,IDRING(h));
4016  IDRING(h)->idroot=root;
4017  }
4018  IDLEV(p)=prevlev;
4019  }
4020  p=IDNEXT(p);
4021  }
4022 #endif
4023  }
4024 #ifdef USE_IILOCALRING
4025  iiLocalRing[myynest-1]=IDRING(h);
4026 #endif
4027  procstack->cRing=IDRING(h);
4028  procstack->cRingHdl=h;
4029  }
4030  else
4031  {
4032  Werror("%s is no identifier",n);
4033  (yyvsp[(2) - (2)].lv).CleanUp();
4034  YYERROR;
4035  }
4036  }
4037  if (h!=NULL) rSetHdl(h);
4038  else
4039  {
4040  Werror("cannot find the name of the basering %s",n);
4041  (yyvsp[(2) - (2)].lv).CleanUp();
4042  YYERROR;
4043  }
4044  (yyvsp[(2) - (2)].lv).CleanUp();
4045  }
4046  else
4047  {
4048  Werror("%s is no name of a ring/qring",n);
4049  (yyvsp[(2) - (2)].lv).CleanUp();
4050  YYERROR;
4051  }
4052  ;}
4053  break;
4054 
4055  case 159:
4056 
4057 /* Line 1464 of yacc.c */
4058 #line 1465 "grammar.y"
4059  {
4060  type_cmd(&((yyvsp[(2) - (2)].lv)));
4061  ;}
4062  break;
4063 
4064  case 160:
4065 
4066 /* Line 1464 of yacc.c */
4067 #line 1469 "grammar.y"
4068  {
4069  //Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
4070  #ifdef SIQ
4071  if ((yyvsp[(1) - (1)].lv).rtyp!=COMMAND)
4072  {
4073  #endif
4074  if ((yyvsp[(1) - (1)].lv).Typ()==UNKNOWN)
4075  {
4076  if ((yyvsp[(1) - (1)].lv).name!=NULL)
4077  {
4078  Werror("`%s` is undefined",(yyvsp[(1) - (1)].lv).name);
4079  omFree((ADDRESS)(yyvsp[(1) - (1)].lv).name);
4080  }
4081  YYERROR;
4082  }
4083  #ifdef SIQ
4084  }
4085  #endif
4086  (yyvsp[(1) - (1)].lv).Print(&sLastPrinted);
4087  (yyvsp[(1) - (1)].lv).CleanUp(currRing);
4088  if (errorreported) YYERROR;
4089  ;}
4090  break;
4091 
4092  case 161:
4093 
4094 /* Line 1464 of yacc.c */
4095 #line 1498 "grammar.y"
4096  {
4097  int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4098  if (i!=0)
4099  {
4100  newBuffer( (yyvsp[(5) - (5)].name), BT_if);
4101  }
4102  else
4103  {
4104  omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4105  currentVoice->ifsw=1;
4106  }
4107  ;}
4108  break;
4109 
4110  case 162:
4111 
4112 /* Line 1464 of yacc.c */
4113 #line 1511 "grammar.y"
4114  {
4115  if (currentVoice->ifsw==1)
4116  {
4117  currentVoice->ifsw=0;
4118  newBuffer( (yyvsp[(2) - (2)].name), BT_else);
4119  }
4120  else
4121  {
4122  if (currentVoice->ifsw!=2)
4123  {
4124  Warn("`else` without `if` in level %d",myynest);
4125  }
4126  omFree((ADDRESS)(yyvsp[(2) - (2)].name));
4127  }
4128  currentVoice->ifsw=0;
4129  ;}
4130  break;
4131 
4132  case 163:
4133 
4134 /* Line 1464 of yacc.c */
4135 #line 1528 "grammar.y"
4136  {
4137  int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4138  if (i)
4139  {
4140  if (exitBuffer(BT_break)) YYERROR;
4141  }
4142  currentVoice->ifsw=0;
4143  ;}
4144  break;
4145 
4146  case 164:
4147 
4148 /* Line 1464 of yacc.c */
4149 #line 1537 "grammar.y"
4150  {
4151  if (exitBuffer(BT_break)) YYERROR;
4152  currentVoice->ifsw=0;
4153  ;}
4154  break;
4155 
4156  case 165:
4157 
4158 /* Line 1464 of yacc.c */
4159 #line 1542 "grammar.y"
4160  {
4161  if (contBuffer(BT_break)) YYERROR;
4162  currentVoice->ifsw=0;
4163  ;}
4164  break;
4165 
4166  case 166:
4167 
4168 /* Line 1464 of yacc.c */
4169 #line 1550 "grammar.y"
4170  {
4171  /* -> if(!$2) break; $3; continue;*/
4172  char * s = (char *)omAlloc( strlen((yyvsp[(2) - (3)].name)) + strlen((yyvsp[(3) - (3)].name)) + 36);
4173  sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,(yyvsp[(2) - (3)].name),(yyvsp[(3) - (3)].name));
4174  newBuffer(s,BT_break);
4175  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4176  omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4177  ;}
4178  break;
4179 
4180  case 167:
4181 
4182 /* Line 1464 of yacc.c */
4183 #line 1562 "grammar.y"
4184  {
4185  /* $2 */
4186  /* if (!$3) break; $5; $4; continue; */
4187  char * s = (char *)omAlloc( strlen((yyvsp[(3) - (5)].name))+strlen((yyvsp[(4) - (5)].name))+strlen((yyvsp[(5) - (5)].name))+36);
4188  sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
4189  ,(yyvsp[(3) - (5)].name),(yyvsp[(5) - (5)].name),(yyvsp[(4) - (5)].name));
4190  omFree((ADDRESS)(yyvsp[(3) - (5)].name));
4191  omFree((ADDRESS)(yyvsp[(4) - (5)].name));
4192  omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4193  newBuffer(s,BT_break);
4194  s = (char *)omAlloc( strlen((yyvsp[(2) - (5)].name)) + 3);
4195  sprintf(s,"%s;\n",(yyvsp[(2) - (5)].name));
4196  omFree((ADDRESS)(yyvsp[(2) - (5)].name));
4197  newBuffer(s,BT_if);
4198  ;}
4199  break;
4200 
4201  case 168:
4202 
4203 /* Line 1464 of yacc.c */
4204 #line 1581 "grammar.y"
4205  {
4206  idhdl h = enterid((yyvsp[(2) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4207  if (h==NULL) {omFree((ADDRESS)(yyvsp[(2) - (3)].name));omFree((ADDRESS)(yyvsp[(3) - (3)].name)); YYERROR;}
4208  iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(2) - (3)].name), 0, 0);
4209  IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+31);;
4210  sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",(yyvsp[(3) - (3)].name));
4211  omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4212  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4213  ;}
4214  break;
4215 
4216  case 169:
4217 
4218 /* Line 1464 of yacc.c */
4219 #line 1591 "grammar.y"
4220  {
4221  idhdl h = enterid((yyvsp[(1) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4222  if (h==NULL)
4223  {
4224  omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4225  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4226  omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4227  YYERROR;
4228  }
4229  char *args=iiProcArgs((yyvsp[(2) - (3)].name),FALSE);
4230  omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4231  iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (3)].name), 0, 0);
4232  IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+strlen(args)+14);;
4233  sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(3) - (3)].name));
4234  omFree((ADDRESS)args);
4235  omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4236  omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4237  ;}
4238  break;
4239 
4240  case 170:
4241 
4242 /* Line 1464 of yacc.c */
4243 #line 1610 "grammar.y"
4244  {
4245  omFree((ADDRESS)(yyvsp[(3) - (4)].name));
4246  idhdl h = enterid((yyvsp[(1) - (4)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4247  if (h==NULL)
4248  {
4249  omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4250  omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4251  omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4252  YYERROR;
4253  }
4254  char *args=iiProcArgs((yyvsp[(2) - (4)].name),FALSE);
4255  omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4256  iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (4)].name), 0, 0);
4257  omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4258  IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(4) - (4)].name))+strlen(args)+14);;
4259  sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(4) - (4)].name));
4260  omFree((ADDRESS)args);
4261  omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4262  ;}
4263  break;
4264 
4265  case 171:
4266 
4267 /* Line 1464 of yacc.c */
4268 #line 1633 "grammar.y"
4269  {
4270  // decl. of type proc p(int i)
4271  if ((yyvsp[(1) - (2)].i)==PARAMETER) { if (iiParameter(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4272  else { if (iiAlias(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4273  ;}
4274  break;
4275 
4276  case 172:
4277 
4278 /* Line 1464 of yacc.c */
4279 #line 1639 "grammar.y"
4280  {
4281  // decl. of type proc p(i)
4282  sleftv tmp_expr;
4283  if ((yyvsp[(1) - (2)].i)==ALIAS_CMD) MYYERROR("alias requires a type");
4284  if ((iiDeclCommand(&tmp_expr,&(yyvsp[(2) - (2)].lv),myynest,DEF_CMD,&IDROOT))
4285  || (iiParameter(&tmp_expr)))
4286  YYERROR;
4287  ;}
4288  break;
4289 
4290  case 173:
4291 
4292 /* Line 1464 of yacc.c */
4293 #line 1651 "grammar.y"
4294  {
4295  iiRETURNEXPR.Copy(&(yyvsp[(3) - (4)].lv));
4296  (yyvsp[(3) - (4)].lv).CleanUp();
4297  if (exitBuffer(BT_proc)) YYERROR;
4298  ;}
4299  break;
4300 
4301  case 174:
4302 
4303 /* Line 1464 of yacc.c */
4304 #line 1657 "grammar.y"
4305  {
4306  if ((yyvsp[(1) - (3)].i)==RETURN)
4307  {
4308  iiRETURNEXPR.Init();
4309  iiRETURNEXPR.rtyp=NONE;
4310  if (exitBuffer(BT_proc)) YYERROR;
4311  }
4312  ;}
4313  break;
4314 
4315 
4316 
4317 /* Line 1464 of yacc.c */
4318 #line 4320 "grammar.cc"
4319  default: break;
4320  }
4321  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4322 
4323  YYPOPSTACK (yylen);
4324  yylen = 0;
4325  YY_STACK_PRINT (yyss, yyssp);
4326 
4327  *++yyvsp = yyval;
4328 
4329  /* Now `shift' the result of the reduction. Determine what state
4330  that goes to, based on the state we popped back to and the rule
4331  number reduced by. */
4332 
4333  yyn = yyr1[yyn];
4334 
4335  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4336  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4337  yystate = yytable[yystate];
4338  else
4339  yystate = yydefgoto[yyn - YYNTOKENS];
4340 
4341  goto yynewstate;
4342 
4343 
4344 /*------------------------------------.
4345 | yyerrlab -- here on detecting error |
4346 `------------------------------------*/
4347 yyerrlab:
4348  /* If not already recovering from an error, report this error. */
4349  if (!yyerrstatus)
4350  {
4351  ++yynerrs;
4352 #if ! YYERROR_VERBOSE
4353  yyerror (YY_("syntax error"));
4354 #else
4355  {
4356  YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
4357  if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
4358  {
4359  YYSIZE_T yyalloc = 2 * yysize;
4360  if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
4361  yyalloc = YYSTACK_ALLOC_MAXIMUM;
4362  if (yymsg != yymsgbuf)
4363  YYSTACK_FREE (yymsg);
4364  yymsg = (char *) YYSTACK_ALLOC (yyalloc);
4365  if (yymsg)
4366  yymsg_alloc = yyalloc;
4367  else
4368  {
4369  yymsg = yymsgbuf;
4370  yymsg_alloc = sizeof yymsgbuf;
4371  }
4372  }
4373 
4374  if (0 < yysize && yysize <= yymsg_alloc)
4375  {
4376  (void) yysyntax_error (yymsg, yystate, yychar);
4377  yyerror (yymsg);
4378  }
4379  else
4380  {
4381  yyerror (YY_("syntax error"));
4382  if (yysize != 0)
4383  goto yyexhaustedlab;
4384  }
4385  }
4386 #endif
4387  }
4388 
4389 
4390 
4391  if (yyerrstatus == 3)
4392  {
4393  /* If just tried and failed to reuse lookahead token after an
4394  error, discard it. */
4395 
4396  if (yychar <= YYEOF)
4397  {
4398  /* Return failure if at end of input. */
4399  if (yychar == YYEOF)
4400  YYABORT;
4401  }
4402  else
4403  {
4404  yydestruct ("Error: discarding",
4405  yytoken, &yylval);
4406  yychar = YYEMPTY;
4407  }
4408  }
4409 
4410  /* Else will try to reuse lookahead token after shifting the error
4411  token. */
4412  goto yyerrlab1;
4413 
4414 
4415 /*---------------------------------------------------.
4416 | yyerrorlab -- error raised explicitly by YYERROR. |
4417 `---------------------------------------------------*/
4418 yyerrorlab:
4419 
4420  /* Pacify compilers like GCC when the user code never invokes
4421  YYERROR and the label yyerrorlab therefore never appears in user
4422  code. */
4423  if (/*CONSTCOND*/ 0)
4424  goto yyerrorlab;
4425 
4426  /* Do not reclaim the symbols of the rule which action triggered
4427  this YYERROR. */
4428  YYPOPSTACK (yylen);
4429  yylen = 0;
4430  YY_STACK_PRINT (yyss, yyssp);
4431  yystate = *yyssp;
4432  goto yyerrlab1;
4433 
4434 
4435 /*-------------------------------------------------------------.
4436 | yyerrlab1 -- common code for both syntax error and YYERROR. |
4437 `-------------------------------------------------------------*/
4438 yyerrlab1:
4439  yyerrstatus = 3; /* Each real token shifted decrements this. */
4440 
4441  for (;;)
4442  {
4443  yyn = yypact[yystate];
4444  if (yyn != YYPACT_NINF)
4445  {
4446  yyn += YYTERROR;
4447  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4448  {
4449  yyn = yytable[yyn];
4450  if (0 < yyn)
4451  break;
4452  }
4453  }
4454 
4455  /* Pop the current state because it cannot handle the error token. */
4456  if (yyssp == yyss)
4457  YYABORT;
4458 
4459 
4460  yydestruct ("Error: popping",
4461  yystos[yystate], yyvsp);
4462  YYPOPSTACK (1);
4463  yystate = *yyssp;
4464  YY_STACK_PRINT (yyss, yyssp);
4465  }
4466 
4467  *++yyvsp = yylval;
4468 
4469 
4470  /* Shift the error token. */
4471  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4472 
4473  yystate = yyn;
4474  goto yynewstate;
4475 
4476 
4477 /*-------------------------------------.
4478 | yyacceptlab -- YYACCEPT comes here. |
4479 `-------------------------------------*/
4480 yyacceptlab:
4481  yyresult = 0;
4482  goto yyreturn;
4483 
4484 /*-----------------------------------.
4485 | yyabortlab -- YYABORT comes here. |
4486 `-----------------------------------*/
4487 yyabortlab:
4488  yyresult = 1;
4489  goto yyreturn;
4490 
4491 #if !defined(yyoverflow) || YYERROR_VERBOSE
4492 /*-------------------------------------------------.
4493 | yyexhaustedlab -- memory exhaustion comes here. |
4494 `-------------------------------------------------*/
4495 yyexhaustedlab:
4496  yyerror (YY_("memory exhausted"));
4497  yyresult = 2;
4498  /* Fall through. */
4499 #endif
4500 
4501 yyreturn:
4502  if (yychar != YYEMPTY)
4503  yydestruct ("Cleanup: discarding lookahead",
4504  yytoken, &yylval);
4505  /* Do not reclaim the symbols of the rule which action triggered
4506  this YYABORT or YYACCEPT. */
4507  YYPOPSTACK (yylen);
4508  YY_STACK_PRINT (yyss, yyssp);
4509  while (yyssp != yyss)
4510  {
4511  yydestruct ("Cleanup: popping",
4512  yystos[*yyssp], yyvsp);
4513  YYPOPSTACK (1);
4514  }
4515 #ifndef yyoverflow
4516  if (yyss != yyssa)
4517  YYSTACK_FREE (yyss);
4518 #endif
4519 #if YYERROR_VERBOSE
4520  if (yymsg != yymsgbuf)
4521  YYSTACK_FREE (yymsg);
4522 #endif
4523  /* Make sure YYID is used. */
4524  return YYID (yyresult);
4525 }
4526 
4527 
4528 
iiProcArgs
char * iiProcArgs(char *e, BOOLEAN withParenth)
Definition: iplib.cc:127
NOT
Definition: grammar.cc:273
omAllocBin
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
int
const const intvec const intvec const ring _currRing const const intvec const intvec const ring _currRing int
Definition: gb_hack.h:53
yyInRingConstruction
BOOLEAN yyInRingConstruction
Definition: grammar.cc:173
yytokentype
yytokentype
Definition: grammar.cc:267
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
iiTestConvert
int iiTestConvert(int inputType, int outputType)
Definition: gentable.cc:290
yytype_uint16
unsigned short int yytype_uint16
Definition: grammar.cc:438
sleftv
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
singular_example
void singular_example(char *str)
Definition: misc_ip.cc:435
YYFINAL
#define YYFINAL
Definition: grammar.cc:627
yyerrok
#define yyerrok
Definition: grammar.cc:1608
n_Read
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:597
syMake
void syMake(leftv v, const char *id, idhdl packhdl)
Definition: subexpr.cc:1454
sdb_flags
int sdb_flags
Definition: sdb.cc:32
PrintLn
void PrintLn()
Definition: reporter.cc:322
Print
#define Print
Definition: emacs.cc:83
EVAL
Definition: grammar.cc:388
INT_CMD
Definition: tok.h:85
pAdd
#define pAdd(p, q)
Definition: polys.h:174
iiInitSingularProcinfo
procinfo * iiInitSingularProcinfo(procinfov pi, const char *libname, const char *procname, int line, long pos, BOOLEAN pstatic)
Definition: iplib.cc:966
YYFPRINTF
#define YYFPRINTF
Definition: grammar.cc:1712
IDINTVEC
#define IDINTVEC(a)
Definition: ipid.h:127
yy_symbol_print
static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep)
Definition: grammar.cc:1773
IDID
#define IDID(a)
Definition: ipid.h:121
iiExprArith1
BOOLEAN iiExprArith1(leftv res, leftv a, int op)
Definition: iparith.cc:8289
FALSE
#define FALSE
Definition: auxiliary.h:140
polys.h
Compatiblity layer for legacy polynomial operations (over currRing)
yyrline
static const yytype_uint16 yyrline[]
Definition: grammar.cc:792
MAX_INT_LEN
const int MAX_INT_LEN
Definition: mylimits.h:13
BIGINT_CMD
Definition: tok.h:42
p
return P p
Definition: myNF.cc:203
exprlist_length
int exprlist_length(leftv v)
Definition: ipshell.cc:549
bigintmat
Matrices of numbers.
Definition: bigintmat.h:32
Voice::Typ
feBufferTypes Typ()
Definition: fevoices.cc:109
iiExprArith3
BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
Definition: iparith.cc:8491
killid
void killid(const char *id, idhdl *ih)
Definition: ipid.cc:342
YYACCEPT
#define YYACCEPT
Definition: grammar.cc:1613
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: grammar.cc:539
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: grammar.cc:644
prompt_char
char prompt_char
Definition: febase.cc:44
iiRETURNEXPR
sleftv iiRETURNEXPR
Definition: iplib.cc:517
writeTime
void writeTime(const char *v)
Definition: timer.cc:121
IDNEXT
#define IDNEXT(a)
Definition: ipid.h:117
LE
Definition: grammar.cc:271
procstack
proclevel * procstack
Definition: ipid.cc:57
n
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
IDROOT
#define IDROOT
Definition: ipid.h:20
siq
BOOLEAN siq
Definition: subexpr.cc:58
YYUSE
#define YYUSE(e)
Definition: grammar.cc:477
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: grammar.cc:1721
yytype_int8
signed char yytype_int8
Definition: grammar.cc:430
TRUE
#define TRUE
Definition: auxiliary.h:144
intvec::length
int length() const
Definition: intvec.h:85
type_cmd
void type_cmd(leftv v)
Definition: ipshell.cc:248
iiAssignCR
BOOLEAN iiAssignCR(leftv r, leftv arg)
Definition: ipshell.cc:6192
IDIDEAL
#define IDIDEAL(a)
Definition: ipid.h:132
sleftv::Init
void Init()
Definition: subexpr.h:108
yy_symbol_value_print
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep)
Definition: grammar.cc:1741
UNKNOWN
#define UNKNOWN
Definition: tok.h:171
ADDRESS
void * ADDRESS
Definition: auxiliary.h:161
leftv
sleftv * leftv
Definition: structs.h:60
iiExprArithM
BOOLEAN iiExprArithM(leftv res, leftv a, int op)
Definition: iparith.cc:8579
yyprhs
static const yytype_uint16 yyprhs[]
Definition: grammar.cc:694
IDBIMAT
#define IDBIMAT(a)
Definition: ipid.h:128
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:23
inerror
int inerror
Definition: grammar.cc:176
yy_reduce_print
static void yy_reduce_print(YYSTYPE *yyvsp, int yyrule)
Definition: grammar.cc:1830
YYNTOKENS
#define YYNTOKENS
Definition: grammar.cc:632
basePackHdl
idhdl basePackHdl
Definition: ipid.cc:61
timerv
int timerv
Definition: timer.cc:19
jjLOAD
BOOLEAN jjLOAD(const char *s, BOOLEAN autoexport)
load lib/module given in v
Definition: iparith.cc:5266
coeffs_BIGINT
coeffs coeffs_BIGINT
Definition: ipid.cc:53
sleftv::Typ
int Typ()
Definition: subexpr.cc:949
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
proclevel::cRingHdl
idhdl cRingHdl
Definition: ipid.h:60
exitBuffer
BOOLEAN exitBuffer(feBufferTypes typ)
Definition: fevoices.cc:231
YYSIZE_MAXIMUM
#define YYSIZE_MAXIMUM
Definition: grammar.cc:461
iiExport
BOOLEAN iiExport(leftv v, int toLev)
Definition: ipshell.cc:1505
idrec
Definition: idrec.h:34
IDHDL
#define IDHDL
Definition: tok.h:35
idrec::get
idhdl get(const char *s, int lev)
Definition: ipid.cc:90
iiParameter
BOOLEAN iiParameter(leftv p)
Definition: ipshell.cc:1285
iiAlias
BOOLEAN iiAlias(leftv p)
Definition: ipshell.cc:1320
found
bool found
Definition: facFactorize.cc:56
currid
const char * currid
Definition: grammar.cc:172
sleftv::data
void * data
Definition: subexpr.h:89
Voice::ifsw
char ifsw
Definition: fevoices.h:76
YYSTYPE
#define YYSTYPE
Definition: stype.h:19
BT_if
Definition: fevoices.h:24
iiTestAssume
BOOLEAN iiTestAssume(leftv a, leftv b)
Definition: ipshell.cc:6131
IDPACKAGE
#define IDPACKAGE(a)
Definition: ipid.h:138
myynest
int myynest
Definition: febase.cc:46
yytype_uint8
unsigned char yytype_uint8
Definition: grammar.cc:423
YYPOPSTACK
#define YYPOPSTACK(N)
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
IDTYP
#define IDTYP(a)
Definition: ipid.h:118
killhdl2
void killhdl2(idhdl h, idhdl *ih, ring r)
Definition: ipid.cc:400
enterid
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
Definition: ipid.cc:256
YYTERROR
#define YYTERROR
Definition: grammar.cc:1653
my_yylinebuf
char my_yylinebuf[80]
Definition: febase.cc:48
YYEMPTY
#define YYEMPTY
Definition: grammar.cc:1610
r
const ring r
Definition: syzextra.cc:208
YYSTACK_FREE
#define YYSTACK_FREE
Definition: grammar.cc:540
yyr2
static const yytype_uint8 yyr2[]
Definition: grammar.cc:905
cmdtok
int cmdtok
Definition: grammar.cc:175
intvec
Definition: intvec.h:16
iiTwoOps
const char * iiTwoOps(int t)
Definition: gentable.cc:250
rKill
void rKill(ring r)
Definition: ipshell.cc:5815
list_cmd
void list_cmd(int typ, const char *what, const char *prefix, BOOLEAN iterate, BOOLEAN fullname)
Definition: ipshell.cc:422
j
int j
Definition: myNF.cc:70
yy_stack_print
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
Definition: grammar.cc:1799
DEF_CMD
Definition: tok.h:58
Voice::pi
procinfo * pi
Definition: fevoices.h:63
sleftv::name
const char * name
Definition: subexpr.h:88
pSetCompP
#define pSetCompP(a, i)
Definition: polys.h:274
omFree
#define omFree(addr)
Definition: omAllocDecl.h:261
poly
polyrec * poly
Definition: hilb.h:10
siCntrlc
BOOLEAN siCntrlc
Definition: cntrlc.cc:111
yypact
static const yytype_int16 yypact[]
Definition: grammar.cc:987
yytype_int16
short int yytype_int16
Definition: grammar.cc:444
YYSTACK_ALLOC_MAXIMUM
#define YYSTACK_ALLOC_MAXIMUM
Definition: grammar.cc:542
malloc
void * malloc(size_t size)
Definition: omalloc.c:98
GE
Definition: grammar.cc:270
yyin
FILE * yyin
YYABORT
#define YYABORT
Definition: grammar.cc:1614
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: grammar.cc:1854
exitVoice
BOOLEAN exitVoice()
Definition: fevoices.cc:336
currRingHdl
idhdl currRingHdl
Definition: ipid.cc:64
sleftv::Copy
void Copy(leftv e)
Definition: subexpr.cc:637
auxiliary.h
All the auxiliary stuff.
rOrderName
int rOrderName(char *ordername)
Definition: ring.cc:508
idDelete
void idDelete(ideal *h, ring r=currRing)
delete an ideal
Definition: ideals.h:31
HAVE_SDB
#define HAVE_SDB
Definition: sdb.h:10
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: grammar.cc:1816
rDefault
ring rDefault(const coeffs cf, int N, char **n, int ord_size, int *ord, int *block0, int *block1, int **wvhdl)
Definition: ring.cc:113
free
#define free
Definition: omAllocFunc.c:12
idhdl
idrec * idhdl
Definition: ring.h:18
feFopen
FILE * feFopen(const char *path, const char *mode, char *where, short useWerror, short path_only)
Definition: feFopen.cc:46
sleftv_bin
omBin sleftv_bin
Definition: subexpr.cc:50
i
int i
Definition: cfEzgcd.cc:123
idrec::next
idhdl next
Definition: idrec.h:38
startRTimer
void startRTimer()
Definition: timer.cc:153
rFindHdl
idhdl rFindHdl(ring r, idhdl n)
Definition: ipshell.cc:1690
yydestruct
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep)
Definition: grammar.cc:2108
yyparse
int yyparse(void)
Definition: grammar.cc:2168
iiDebug
void iiDebug()
Definition: ipshell.cc:1025
INTVEC_CMD
Definition: tok.h:88
yypgoto
static const yytype_int16 yypgoto[]
Definition: grammar.cc:1032
MYYERROR
#define MYYERROR(a)
Definition: grammar.cc:186
IDLEV
#define IDLEV(a)
Definition: ipid.h:120
VoiceName
const char * VoiceName()
Definition: fevoices.cc:64
yydefact
static const yytype_uint8 yydefact[]
Definition: grammar.cc:930
errorreported
short errorreported
Definition: feFopen.cc:22
sleftv::next
leftv next
Definition: subexpr.h:87
Voice::prev
Voice * prev
Definition: fevoices.h:61
feFilePending
FILE * feFilePending
Definition: ipid.cc:55
BVERBOSE
#define BVERBOSE(a)
Definition: options.h:33
mpNew
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:48
ALIAS_CMD
Definition: tok.h:38
iiDeclCommand
int iiDeclCommand(leftv sy, leftv name, int lev, int t, idhdl *root, BOOLEAN isring, BOOLEAN init_b)
Definition: ipshell.cc:1160
TESTSETINT
#define TESTSETINT(a, i)
Definition: grammar.cc:178
IDPROC
#define IDPROC(a)
Definition: ipid.h:139
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
feBufferTypes
feBufferTypes
Definition: fevoices.h:16
YYLEX
#define YYLEX
Definition: grammar.cc:1704
iiLocalRing
ring * iiLocalRing
Definition: iplib.cc:515
name
char name(const Variable &v)
Definition: variable.h:95
yytranslate
static const yytype_uint8 yytranslate[]
Definition: grammar.cc:648
YYLAST
#define YYLAST
Definition: grammar.cc:629
NULL
#define NULL
Definition: omList.c:10
sleftv::req_packhdl
package req_packhdl
Definition: subexpr.h:107
YYDPRINTF
#define YYDPRINTF(Args)
Definition: grammar.cc:1715
yydebug
int yydebug
Definition: grammar.cc:1862
YYTABLE_NINF
#define YYTABLE_NINF
Definition: grammar.cc:1045
Tok2Cmdname
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:128
yylineno
int yylineno
Definition: febase.cc:45
currentVoice
Voice * currentVoice
Definition: fevoices.cc:55
killhdl
void killhdl(idhdl h, package proot)
Definition: ipid.cc:369
basePack
package basePack
Definition: ipid.cc:63
iiConvert
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, struct sConvertTypes *dConvertTypes)
Definition: ipconv.cc:295
yyerror
void yyerror(const char *fmt)
Definition: grammar.cc:188
IDRING
#define IDRING(a)
Definition: ipid.h:126
pDelete
#define pDelete(p_ptr)
Definition: polys.h:157
currPack
package currPack
Definition: ipid.cc:62
YYINITDEPTH
#define YYINITDEPTH
Definition: grammar.cc:1873
proclevel::cRing
ring cRing
Definition: ipid.h:61
sleftv::rtyp
int rtyp
Definition: subexpr.h:92
sLastPrinted
sleftv sLastPrinted
Definition: subexpr.cc:55
sleftv::CleanUp
void CleanUp(ring r=currRing)
Definition: subexpr.cc:301
sleftv::Data
void * Data()
Definition: subexpr.cc:1091
YYSIZE_T
#define YYSIZE_T
Definition: grammar.cc:455
yyrhs
static const yytype_int16 yyrhs[]
Definition: grammar.cc:717
newBuffer
void newBuffer(char *s, feBufferTypes t, procinfo *pi, int lineno)
Definition: fevoices.cc:169
YYMAXDEPTH
#define YYMAXDEPTH
Definition: grammar.cc:167
const
#define const
Definition: fegetopt.c:41
idrec::id
const char * id
Definition: idrec.h:39
newFile
BOOLEAN newFile(char *fname, FILE *f)
Definition: fevoices.cc:127
iiARROW
BOOLEAN iiARROW(leftv r, char *a, char *s)
Definition: ipshell.cc:6158
YY_
#define YY_(msgid)
Definition: grammar.cc:471
yytable
static const yytype_int16 yytable[]
Definition: grammar.cc:1046
yydefgoto
static const yytype_int16 yydefgoto[]
Definition: grammar.cc:975
yycheck
static const yytype_int16 yycheck[]
Definition: grammar.cc:1304
QRING_CMD
Definition: tok.h:126
rInit
ring rInit(sleftv *pn, sleftv *rv, sleftv *ord)
Definition: ipshell.cc:5304
rtimerv
int rtimerv
Definition: timer.cc:148
yyr1
static const yytype_uint8 yyr1[]
Definition: grammar.cc:882
rSetHdl
void rSetHdl(idhdl h)
Definition: ipshell.cc:4821
startTimer
void startTimer()
Definition: timer.cc:82
yytname
static const char *const yytname[]
Definition: grammar.cc:818
h
static Poly * h
Definition: janet.cc:978
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:131
b
const poly b
Definition: syzextra.cc:213
iiExprArith2
BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
Definition: iparith.cc:8101
YYPACT_NINF
#define YYPACT_NINF
Definition: grammar.cc:986
NONE
#define NONE
Definition: tok.h:170
yylval
YYSTYPE yylval
iiApply
BOOLEAN iiApply(leftv res, leftv a, int op, leftv proc)
Definition: ipshell.cc:6109
procinfo::trace_flag
char trace_flag
Definition: subexpr.h:61
V_REDEFINE
#define V_REDEFINE
Definition: options.h:43
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:199
YYID
#define YYID(n)
Definition: grammar.cc:484
sleftv::CopyD
void * CopyD(int t)
Definition: subexpr.cc:656
expected_parms
BOOLEAN expected_parms
Definition: grammar.cc:174
lastreserved
const char * lastreserved
Definition: ipshell.cc:84
YYEOF
#define YYEOF
Definition: grammar.cc:1611
l
int l
Definition: cfEzgcd.cc:94
writeRTime
void writeRTime(const char *v)
Definition: timer.cc:195
YYERROR
#define YYERROR
Definition: grammar.cc:1615
feHelp
void feHelp(char *str)
Definition: fehelp.cc:103
IDMATRIX
#define IDMATRIX(a)
Definition: ipid.h:133
COMMAND
#define COMMAND
Definition: tok.h:33
next
ListNode * next
Definition: janet.h:31
iiAssign
BOOLEAN iiAssign(leftv l, leftv r, BOOLEAN toplevel)
Definition: ipassign.cc:1659
Warn
#define Warn
Definition: emacs.cc:80
yystos
static const yytype_uint8 yystos[]
Definition: grammar.cc:1564
contBuffer
BOOLEAN contBuffer(feBufferTypes typ)
Definition: fevoices.cc:299
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:263
Generated on Mon Aug 3 2015 12:41:03 by   doxygen 1.8.9.1 for Singular a9b8ed0|M