Context Navigation

source: git/Singular/grammar.cc @ f4f403

spielwiese

Last change on this file since f4f403 was f4f403, checked in by Hans Schoenemann <hannes@…>, 10 years ago
fix: quote(not something)
Property mode set to `100644`
File size: 150.5 KB

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

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

Download in other formats: