Context Navigation

source: git/Singular/grammar.cc @ cbe2a4c

fieker-DuValspielwiese

Last change on this file since cbe2a4c was cbe2a4c, checked in by Hans Schoenemann <hannes@…>, 10 years ago
chg: simplify rFindHdl
Property mode set to `100644`
File size: 150.4 KB

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

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

Download in other formats: