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