Context Navigation

source: git/Singular/grammar.cc @ 33d610

spielwiese

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

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

Download in other formats: