Context Navigation

source: git/Singular/grammar.cc @ 14814e3

fieker-DuValspielwiese

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

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

Download in other formats: