Context Navigation

source: git/Singular/grammar.cc @ f24b9c

spielwiese

Last change on this file since f24b9c was 4996b12, checked in by Hans Schoenemann <hannes@…>, 10 years ago
chg: grammar for ASSUME
Property mode set to `100644`
File size: 150.3 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: