Context Navigation

source: git/Singular/grammar.cc @ aee346d

fieker-DuValspielwiese

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

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

Download in other formats: