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