Context Navigation

source: git/Singular/grammar.cc @ fa167e

fieker-DuValspielwiese

Last change on this file since fa167e was 75f460, checked in by Hans Schoenemann <hannes@…>, 9 years ago
format
Property mode set to `100644`
File size: 151.0 KB

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

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

Download in other formats: