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