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