Context Navigation

source: git/Singular/grammar.cc @ 9f2069

fieker-DuValspielwiese

Last change on this file since 9f2069 was 9f2069, checked in by Hans Schoenemann <hannes@…>, 8 years ago
revert ff3119a9dd3c4ff5f8f594edaffaffd569a49cd8 for grammar.y (see rInit)
Property mode set to `100644`
File size: 150.8 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 242 "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 415 "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, 363, 363, 365, 399, 400, 402, 404, 408, 413,
795	415, 466, 467, 468, 469, 470, 471, 472, 473, 477,
796	480, 481, 482, 483, 484, 485, 486, 487, 488, 491,
797	498, 503, 507, 511, 515, 519, 532, 560, 584, 590,
798	596, 600, 604, 608, 612, 616, 620, 624, 628, 632,
799	636, 640, 644, 648, 652, 656, 660, 664, 668, 672,
800	676, 682, 686, 690, 694, 698, 705, 716, 722, 727,
801	728, 729, 733, 737, 741, 745, 749, 753, 757, 761,
802	765, 782, 789, 788, 806, 814, 822, 831, 835, 839,
803	843, 847, 851, 855, 859, 863, 867, 871, 875, 879,
804	891, 898, 899, 918, 919, 931, 936, 941, 945, 949,
805	985, 1011, 1032, 1040, 1044, 1045, 1059, 1067, 1076, 1121,
806	1122, 1131, 1132, 1138, 1145, 1147, 1149, 1159, 1158, 1166,
807	1171, 1178, 1186, 1198, 1214, 1233, 1237, 1241, 1246, 1250,
808	1254, 1258, 1262, 1267, 1273, 1279, 1285, 1291, 1297, 1303,
809	1315, 1322, 1326, 1363, 1370, 1378, 1384, 1384, 1387, 1459,
810	1463, 1492, 1505, 1522, 1531, 1536, 1544, 1556, 1575, 1585,
811	1604, 1627, 1633, 1645, 1651
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 366 "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 401 "grammar.y"
2464	{currentVoice->ifsw=0;;}
2465	break;
2466
2467	case 6:
2468
2469	/* Line 1464 of yacc.c */
2470	#line 403 "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 405 "grammar.y"
2478	{
2479	YYACCEPT;
2480	;}
2481	break;
2482
2483	case 8:
2484
2485	/* Line 1464 of yacc.c */
2486	#line 409 "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 414 "grammar.y"
2497	{currentVoice->ifsw=0;;}
2498	break;
2499
2500	case 10:
2501
2502	/* Line 1464 of yacc.c */
2503	#line 416 "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 474 "grammar.y"
2558	{if (currentVoice!=NULL) currentVoice->ifsw=0;;}
2559	break;
2560
2561	case 19:
2562
2563	/* Line 1464 of yacc.c */
2564	#line 477 "grammar.y"
2565	{ omFree((ADDRESS)(yyvsp[(2) - (2)].name)); ;}
2566	break;
2567
2568	case 29:
2569
2570	/* Line 1464 of yacc.c */
2571	#line 492 "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 499 "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 504 "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 508 "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 512 "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 516 "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 520 "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 533 "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 561 "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 585 "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 591 "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 597 "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 601 "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 605 "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 609 "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 613 "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 617 "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 621 "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 625 "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 629 "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 633 "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 637 "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 641 "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 645 "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 649 "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 653 "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 657 "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 661 "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 665 "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 669 "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 673 "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 677 "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 683 "grammar.y"
2920	{
2921	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2922	;}
2923	break;
2924
2925	case 62:
2926
2927	/* Line 1464 of yacc.c */
2928	#line 687 "grammar.y"
2929	{
2930	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2931	;}
2932	break;
2933
2934	case 63:
2935
2936	/* Line 1464 of yacc.c */
2937	#line 691 "grammar.y"
2938	{
2939	if(iiExprArith3(&(yyval.lv),RING_CMD,&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2940	;}
2941	break;
2942
2943	case 64:
2944
2945	/* Line 1464 of yacc.c */
2946	#line 695 "grammar.y"
2947	{
2948	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),RING_CMD)) YYERROR;
2949	;}
2950	break;
2951
2952	case 65:
2953
2954	/* Line 1464 of yacc.c */
2955	#line 699 "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 706 "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 717 "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 723 "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 727 "grammar.y"
3000	{ (yyval.lv) = (yyvsp[(1) - (1)].lv); ;}
3001	break;
3002
3003	case 70:
3004
3005	/* Line 1464 of yacc.c */
3006	#line 728 "grammar.y"
3007	{ (yyval.lv) = (yyvsp[(2) - (3)].lv); ;}
3008	break;
3009
3010	case 71:
3011
3012	/* Line 1464 of yacc.c */
3013	#line 730 "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 734 "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 738 "grammar.y"
3032	{
3033	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3034	;}
3035	break;
3036
3037	case 74:
3038
3039	/* Line 1464 of yacc.c */
3040	#line 742 "grammar.y"
3041	{
3042	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3043	;}
3044	break;
3045
3046	case 75:
3047
3048	/* Line 1464 of yacc.c */
3049	#line 746 "grammar.y"
3050	{
3051	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3052	;}
3053	break;
3054
3055	case 76:
3056
3057	/* Line 1464 of yacc.c */
3058	#line 750 "grammar.y"
3059	{
3060	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3061	;}
3062	break;
3063
3064	case 77:
3065
3066	/* Line 1464 of yacc.c */
3067	#line 754 "grammar.y"
3068	{
3069	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3070	;}
3071	break;
3072
3073	case 78:
3074
3075	/* Line 1464 of yacc.c */
3076	#line 758 "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 762 "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 766 "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 783 "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 789 "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 795 "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 807 "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 815 "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 823 "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 832 "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 836 "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 840 "grammar.y"
3205	{
3206	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'+',&(yyvsp[(3) - (3)].lv))) YYERROR;
3207	;}
3208	break;
3209
3210	case 90:
3211
3212	/* Line 1464 of yacc.c */
3213	#line 844 "grammar.y"
3214	{
3215	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'-',&(yyvsp[(3) - (3)].lv))) YYERROR;
3216	;}
3217	break;
3218
3219	case 91:
3220
3221	/* Line 1464 of yacc.c */
3222	#line 848 "grammar.y"
3223	{
3224	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3225	;}
3226	break;
3227
3228	case 92:
3229
3230	/* Line 1464 of yacc.c */
3231	#line 852 "grammar.y"
3232	{
3233	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'^',&(yyvsp[(3) - (3)].lv))) YYERROR;
3234	;}
3235	break;
3236
3237	case 93:
3238
3239	/* Line 1464 of yacc.c */
3240	#line 856 "grammar.y"
3241	{
3242	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3243	;}
3244	break;
3245
3246	case 94:
3247
3248	/* Line 1464 of yacc.c */
3249	#line 860 "grammar.y"
3250	{
3251	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(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 864 "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 868 "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 872 "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 876 "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 880 "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 892 "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 898 "grammar.y"
3321	{ (yyval.lv) = (yyvsp[(1) - (2)].lv); ;}
3322	break;
3323
3324	case 102:
3325
3326	/* Line 1464 of yacc.c */
3327	#line 900 "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 920 "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 932 "grammar.y"
3362	{
3363	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3364	YYERROR;
3365	;}
3366	break;
3367
3368	case 106:
3369
3370	/* Line 1464 of yacc.c */
3371	#line 937 "grammar.y"
3372	{
3373	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((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 942 "grammar.y"
3382	{
3383	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3384	;}
3385	break;
3386
3387	case 108:
3388
3389	/* Line 1464 of yacc.c */
3390	#line 946 "grammar.y"
3391	{
3392	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 950 "grammar.y"
3400	{
3401	int r; TESTSETINT((yyvsp[(4) - (8)].lv),r);
3402	int c; TESTSETINT((yyvsp[(7) - (8)].lv),c);
3403	leftv v;
3404	idhdl h;
3405	if ((yyvsp[(1) - (8)].i) == MATRIX_CMD)
3406	{
3407	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&(currRing->idroot), TRUE)) YYERROR;
3408	v=&(yyval.lv);
3409	h=(idhdl)v->data;
3410	idDelete(&IDIDEAL(h));
3411	IDMATRIX(h) = mpNew(r,c);
3412	if (IDMATRIX(h)==NULL) YYERROR;
3413	}
3414	else if ((yyvsp[(1) - (8)].i) == INTMAT_CMD)
3415	{
3416	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3417	YYERROR;
3418	v=&(yyval.lv);
3419	h=(idhdl)v->data;
3420	delete IDINTVEC(h);
3421	IDINTVEC(h) = new intvec(r,c,0);
3422	if (IDINTVEC(h)==NULL) YYERROR;
3423	}
3424	else /* BIGINTMAT_CMD */
3425	{
3426	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3427	YYERROR;
3428	v=&(yyval.lv);
3429	h=(idhdl)v->data;
3430	delete IDBIMAT(h);
3431	IDBIMAT(h) = new bigintmat(r, c, coeffs_BIGINT);
3432	if (IDBIMAT(h)==NULL) YYERROR;
3433	}
3434	;}
3435	break;
3436
3437	case 110:
3438
3439	/* Line 1464 of yacc.c */
3440	#line 986 "grammar.y"
3441	{
3442	if ((yyvsp[(1) - (2)].i) == MATRIX_CMD)
3443	{
3444	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3445	}
3446	else if ((yyvsp[(1) - (2)].i) == INTMAT_CMD)
3447	{
3448	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3449	YYERROR;
3450	leftv v=&(yyval.lv);
3451	idhdl h;
3452	do
3453	{
3454	h=(idhdl)v->data;
3455	delete IDINTVEC(h);
3456	IDINTVEC(h) = new intvec(1,1,0);
3457	v=v->next;
3458	} while (v!=NULL);
3459	}
3460	else /* BIGINTMAT_CMD */
3461	{
3462	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3463	YYERROR;
3464	}
3465	;}
3466	break;
3467
3468	case 111:
3469
3470	/* Line 1464 of yacc.c */
3471	#line 1012 "grammar.y"
3472	{
3473	int t=(yyvsp[(1) - (3)].lv).Typ();
3474	sleftv r;
3475	memset(&r,0,sizeof(sleftv));
3476	if ((BEGIN_RING<t) && (t<END_RING))
3477	{
3478	if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&(currRing->idroot), TRUE))
3479	YYERROR;
3480	}
3481	else
3482	{
3483	if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&((yyvsp[(3) - (3)].lv).req_packhdl->idroot)))
3484	YYERROR;
3485	}
3486	leftv v=&(yyvsp[(1) - (3)].lv);
3487	while (v->next!=NULL) v=v->next;
3488	v->next=(leftv)omAllocBin(sleftv_bin);
3489	memcpy(v->next,&r,sizeof(sleftv));
3490	(yyval.lv)=(yyvsp[(1) - (3)].lv);
3491	;}
3492	break;
3493
3494	case 112:
3495
3496	/* Line 1464 of yacc.c */
3497	#line 1033 "grammar.y"
3498	{
3499	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3500	YYERROR;
3501	;}
3502	break;
3503
3504	case 115:
3505
3506	/* Line 1464 of yacc.c */
3507	#line 1046 "grammar.y"
3508	{
3509	leftv v = &(yyvsp[(2) - (5)].lv);
3510	while (v->next!=NULL)
3511	{
3512	v=v->next;
3513	}
3514	v->next = (leftv)omAllocBin(sleftv_bin);
3515	memcpy(v->next,&((yyvsp[(4) - (5)].lv)),sizeof(sleftv));
3516	(yyval.lv) = (yyvsp[(2) - (5)].lv);
3517	;}
3518	break;
3519
3520	case 116:
3521
3522	/* Line 1464 of yacc.c */
3523	#line 1060 "grammar.y"
3524	{
3525	// let rInit take care of any errors
3526	(yyval.i)=rOrderName((yyvsp[(1) - (1)].name));
3527	;}
3528	break;
3529
3530	case 117:
3531
3532	/* Line 1464 of yacc.c */
3533	#line 1068 "grammar.y"
3534	{
3535	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3536	intvec *iv = new intvec(2);
3537	(*iv)[0] = 1;
3538	(*iv)[1] = (yyvsp[(1) - (1)].i);
3539	(yyval.lv).rtyp = INTVEC_CMD;
3540	(yyval.lv).data = (void *)iv;
3541	;}
3542	break;
3543
3544	case 118:
3545
3546	/* Line 1464 of yacc.c */
3547	#line 1077 "grammar.y"
3548	{
3549	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3550	leftv sl = &(yyvsp[(3) - (4)].lv);
3551	int slLength;
3552	{
3553	slLength = exprlist_length(sl);
3554	int l = 2 + slLength;
3555	intvec *iv = new intvec(l);
3556	(*iv)[0] = slLength;
3557	(*iv)[1] = (yyvsp[(1) - (4)].i);
3558
3559	int i = 2;
3560	while ((i<l) && (sl!=NULL))
3561	{
3562	if (sl->Typ() == INT_CMD)
3563	{
3564	(*iv)[i++] = (int)((long)(sl->Data()));
3565	}
3566	else if ((sl->Typ() == INTVEC_CMD)
3567	\|\|(sl->Typ() == INTMAT_CMD))
3568	{
3569	intvec ivv = (intvec )(sl->Data());
3570	int ll = 0,l = ivv->length();
3571	for (; l>0; l--)
3572	{
3573	(iv)[i++] = (ivv)[ll++];
3574	}
3575	}
3576	else
3577	{
3578	delete iv;
3579	(yyvsp[(3) - (4)].lv).CleanUp();
3580	MYYERROR("wrong type in ordering");
3581	}
3582	sl = sl->next;
3583	}
3584	(yyval.lv).rtyp = INTVEC_CMD;
3585	(yyval.lv).data = (void *)iv;
3586	}
3587	(yyvsp[(3) - (4)].lv).CleanUp();
3588	;}
3589	break;
3590
3591	case 120:
3592
3593	/* Line 1464 of yacc.c */
3594	#line 1123 "grammar.y"
3595	{
3596	(yyval.lv) = (yyvsp[(1) - (3)].lv);
3597	(yyval.lv).next = (sleftv *)omAllocBin(sleftv_bin);
3598	memcpy((yyval.lv).next,&(yyvsp[(3) - (3)].lv),sizeof(sleftv));
3599	;}
3600	break;
3601
3602	case 122:
3603
3604	/* Line 1464 of yacc.c */
3605	#line 1133 "grammar.y"
3606	{
3607	(yyval.lv) = (yyvsp[(2) - (3)].lv);
3608	;}
3609	break;
3610
3611	case 123:
3612
3613	/* Line 1464 of yacc.c */
3614	#line 1139 "grammar.y"
3615	{
3616	expected_parms = TRUE;
3617	;}
3618	break;
3619
3620	case 124:
3621
3622	/* Line 1464 of yacc.c */
3623	#line 1146 "grammar.y"
3624	{ (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3625	break;
3626
3627	case 125:
3628
3629	/* Line 1464 of yacc.c */
3630	#line 1148 "grammar.y"
3631	{ (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3632	break;
3633
3634	case 126:
3635
3636	/* Line 1464 of yacc.c */
3637	#line 1150 "grammar.y"
3638	{ (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3639	break;
3640
3641	case 127:
3642
3643	/* Line 1464 of yacc.c */
3644	#line 1159 "grammar.y"
3645	{ if ((yyvsp[(1) - (2)].i) != '<') YYERROR;
3646	if((feFilePending=feFopen((yyvsp[(2) - (2)].name),"r",NULL,TRUE))==NULL) YYERROR; ;}
3647	break;
3648
3649	case 128:
3650
3651	/* Line 1464 of yacc.c */
3652	#line 1162 "grammar.y"
3653	{ newFile((yyvsp[(2) - (4)].name),feFilePending); ;}
3654	break;
3655
3656	case 129:
3657
3658	/* Line 1464 of yacc.c */
3659	#line 1167 "grammar.y"
3660	{
3661	feHelp((yyvsp[(2) - (3)].name));
3662	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3663	;}
3664	break;
3665
3666	case 130:
3667
3668	/* Line 1464 of yacc.c */
3669	#line 1172 "grammar.y"
3670	{
3671	feHelp(NULL);
3672	;}
3673	break;
3674
3675	case 131:
3676
3677	/* Line 1464 of yacc.c */
3678	#line 1179 "grammar.y"
3679	{
3680	singular_example((yyvsp[(2) - (3)].name));
3681	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3682	;}
3683	break;
3684
3685	case 132:
3686
3687	/* Line 1464 of yacc.c */
3688	#line 1187 "grammar.y"
3689	{
3690	if (basePack!=(yyvsp[(2) - (2)].lv).req_packhdl)
3691	{
3692	if(iiExport(&(yyvsp[(2) - (2)].lv),0,currPack)) YYERROR;
3693	}
3694	else
3695	if (iiExport(&(yyvsp[(2) - (2)].lv),0)) YYERROR;
3696	;}
3697	break;
3698
3699	case 133:
3700
3701	/* Line 1464 of yacc.c */
3702	#line 1199 "grammar.y"
3703	{
3704	leftv v=&(yyvsp[(2) - (2)].lv);
3705	if (v->rtyp!=IDHDL)
3706	{
3707	if (v->name!=NULL)
3708	{
3709	Werror("`%s` is undefined in kill",v->name);
3710	}
3711	else WerrorS("kill what ?");
3712	}
3713	else
3714	{
3715	killhdl((idhdl)v->data,v->req_packhdl);
3716	}
3717	;}
3718	break;
3719
3720	case 134:
3721
3722	/* Line 1464 of yacc.c */
3723	#line 1215 "grammar.y"
3724	{
3725	leftv v=&(yyvsp[(3) - (3)].lv);
3726	if (v->rtyp!=IDHDL)
3727	{
3728	if (v->name!=NULL)
3729	{
3730	Werror("`%s` is undefined in kill",v->name);
3731	}
3732	else WerrorS("kill what ?");
3733	}
3734	else
3735	{
3736	killhdl((idhdl)v->data,v->req_packhdl);
3737	}
3738	;}
3739	break;
3740
3741	case 135:
3742
3743	/* Line 1464 of yacc.c */
3744	#line 1234 "grammar.y"
3745	{
3746	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3747	;}
3748	break;
3749
3750	case 136:
3751
3752	/* Line 1464 of yacc.c */
3753	#line 1238 "grammar.y"
3754	{
3755	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3756	;}
3757	break;
3758
3759	case 137:
3760
3761	/* Line 1464 of yacc.c */
3762	#line 1242 "grammar.y"
3763	{
3764	if ((yyvsp[(3) - (4)].i)==QRING_CMD) (yyvsp[(3) - (4)].i)=RING_CMD;
3765	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3766	;}
3767	break;
3768
3769	case 138:
3770
3771	/* Line 1464 of yacc.c */
3772	#line 1247 "grammar.y"
3773	{
3774	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3775	;}
3776	break;
3777
3778	case 139:
3779
3780	/* Line 1464 of yacc.c */
3781	#line 1251 "grammar.y"
3782	{
3783	list_cmd(RING_CMD,NULL,"// ",TRUE);
3784	;}
3785	break;
3786
3787	case 140:
3788
3789	/* Line 1464 of yacc.c */
3790	#line 1255 "grammar.y"
3791	{
3792	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3793	;}
3794	break;
3795
3796	case 141:
3797
3798	/* Line 1464 of yacc.c */
3799	#line 1259 "grammar.y"
3800	{
3801	list_cmd(PROC_CMD,NULL,"// ",TRUE);
3802	;}
3803	break;
3804
3805	case 142:
3806
3807	/* Line 1464 of yacc.c */
3808	#line 1263 "grammar.y"
3809	{
3810	list_cmd(0,(yyvsp[(3) - (4)].lv).Fullname(),"// ",TRUE);
3811	(yyvsp[(3) - (4)].lv).CleanUp();
3812	;}
3813	break;
3814
3815	case 143:
3816
3817	/* Line 1464 of yacc.c */
3818	#line 1268 "grammar.y"
3819	{
3820	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3821	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3822	(yyvsp[(3) - (6)].lv).CleanUp();
3823	;}
3824	break;
3825
3826	case 144:
3827
3828	/* Line 1464 of yacc.c */
3829	#line 1274 "grammar.y"
3830	{
3831	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3832	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3833	(yyvsp[(3) - (6)].lv).CleanUp();
3834	;}
3835	break;
3836
3837	case 145:
3838
3839	/* Line 1464 of yacc.c */
3840	#line 1280 "grammar.y"
3841	{
3842	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3843	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3844	(yyvsp[(3) - (6)].lv).CleanUp();
3845	;}
3846	break;
3847
3848	case 146:
3849
3850	/* Line 1464 of yacc.c */
3851	#line 1286 "grammar.y"
3852	{
3853	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3854	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3855	(yyvsp[(3) - (6)].lv).CleanUp();
3856	;}
3857	break;
3858
3859	case 147:
3860
3861	/* Line 1464 of yacc.c */
3862	#line 1292 "grammar.y"
3863	{
3864	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3865	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3866	(yyvsp[(3) - (6)].lv).CleanUp();
3867	;}
3868	break;
3869
3870	case 148:
3871
3872	/* Line 1464 of yacc.c */
3873	#line 1298 "grammar.y"
3874	{
3875	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3876	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3877	(yyvsp[(3) - (6)].lv).CleanUp();
3878	;}
3879	break;
3880
3881	case 149:
3882
3883	/* Line 1464 of yacc.c */
3884	#line 1304 "grammar.y"
3885	{
3886	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3887	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3888	(yyvsp[(3) - (6)].lv).CleanUp();
3889	;}
3890	break;
3891
3892	case 150:
3893
3894	/* Line 1464 of yacc.c */
3895	#line 1316 "grammar.y"
3896	{
3897	list_cmd(-1,NULL,"// ",TRUE);
3898	;}
3899	break;
3900
3901	case 151:
3902
3903	/* Line 1464 of yacc.c */
3904	#line 1322 "grammar.y"
3905	{ yyInRingConstruction = TRUE; ;}
3906	break;
3907
3908	case 152:
3909
3910	/* Line 1464 of yacc.c */
3911	#line 1331 "grammar.y"
3912	{
3913	const char *ring_name = (yyvsp[(2) - (8)].lv).name;
3914	ring b=
3915	rInit(&(yyvsp[(4) - (8)].lv), /* characteristik and list of parameters*/
3916	&(yyvsp[(6) - (8)].lv), /* names of ringvariables */
3917	&(yyvsp[(8) - (8)].lv)); /* ordering */
3918	idhdl newRingHdl=NULL;
3919
3920	if (b!=NULL)
3921	{
3922	newRingHdl=enterid(ring_name, myynest, RING_CMD,
3923	&((yyvsp[(2) - (8)].lv).req_packhdl->idroot),FALSE);
3924	(yyvsp[(2) - (8)].lv).CleanUp();
3925	if (newRingHdl!=NULL)
3926	{
3927	IDRING(newRingHdl)=b;
3928	}
3929	else
3930	{
3931	rKill(b);
3932	}
3933	}
3934	yyInRingConstruction = FALSE;
3935	if (newRingHdl==NULL)
3936	{
3937	MYYERROR("cannot make ring");
3938	}
3939	else
3940	{
3941	rSetHdl(newRingHdl);
3942	}
3943	;}
3944	break;
3945
3946	case 153:
3947
3948	/* Line 1464 of yacc.c */
3949	#line 1364 "grammar.y"
3950	{
3951	const char *ring_name = (yyvsp[(2) - (2)].lv).name;
3952	if (!inerror) rDefault(ring_name);
3953	yyInRingConstruction = FALSE;
3954	(yyvsp[(2) - (2)].lv).CleanUp();
3955	;}
3956	break;
3957
3958	case 154:
3959
3960	/* Line 1464 of yacc.c */
3961	#line 1371 "grammar.y"
3962	{
3963	yyInRingConstruction = FALSE;
3964	if (iiAssignCR(&(yyvsp[(2) - (4)].lv),&(yyvsp[(4) - (4)].lv))) YYERROR;
3965	;}
3966	break;
3967
3968	case 155:
3969
3970	/* Line 1464 of yacc.c */
3971	#line 1379 "grammar.y"
3972	{
3973	if (((yyvsp[(1) - (2)].i)!=LIB_CMD)\|\|(jjLOAD((yyvsp[(2) - (2)].name),TRUE))) YYERROR;
3974	;}
3975	break;
3976
3977	case 158:
3978
3979	/* Line 1464 of yacc.c */
3980	#line 1388 "grammar.y"
3981	{
3982	if (((yyvsp[(1) - (2)].i)==KEEPRING_CMD) && (myynest==0))
3983	MYYERROR("only inside a proc allowed");
3984	const char * n=(yyvsp[(2) - (2)].lv).Name();
3985	if ((((yyvsp[(2) - (2)].lv).Typ()==RING_CMD)\|\|((yyvsp[(2) - (2)].lv).Typ()==QRING_CMD))
3986	&& ((yyvsp[(2) - (2)].lv).rtyp==IDHDL))
3987	{
3988	idhdl h=(idhdl)(yyvsp[(2) - (2)].lv).data;
3989	if ((yyvsp[(2) - (2)].lv).e!=NULL) h=rFindHdl((ring)(yyvsp[(2) - (2)].lv).Data(),NULL);
3990	//Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
3991	if ((yyvsp[(1) - (2)].i)==KEEPRING_CMD)
3992	{
3993	if (h!=NULL)
3994	{
3995	if (IDLEV(h)!=0)
3996	{
3997	if (iiExport(&(yyvsp[(2) - (2)].lv),myynest-1)) YYERROR;
3998	#if 1
3999	idhdl p=IDRING(h)->idroot;
4000	idhdl root=p;
4001	int prevlev=myynest-1;
4002	while (p!=NULL)
4003	{
4004	if (IDLEV(p)==myynest)
4005	{
4006	idhdl old=root->get(IDID(p),prevlev);
4007	if (old!=NULL)
4008	{
4009	if (BVERBOSE(V_REDEFINE))
4010	Warn("redefining %s",IDID(p));
4011	killhdl2(old,&root,IDRING(h));
4012	IDRING(h)->idroot=root;
4013	}
4014	IDLEV(p)=prevlev;
4015	}
4016	p=IDNEXT(p);
4017	}
4018	#endif
4019	}
4020	#ifdef USE_IILOCALRING
4021	iiLocalRing[myynest-1]=IDRING(h);
4022	#endif
4023	procstack->cRing=IDRING(h);
4024	procstack->cRingHdl=h;
4025	}
4026	else
4027	{
4028	Werror("%s is no identifier",n);
4029	(yyvsp[(2) - (2)].lv).CleanUp();
4030	YYERROR;
4031	}
4032	}
4033	if (h!=NULL) rSetHdl(h);
4034	else
4035	{
4036	Werror("cannot find the name of the basering %s",n);
4037	(yyvsp[(2) - (2)].lv).CleanUp();
4038	YYERROR;
4039	}
4040	(yyvsp[(2) - (2)].lv).CleanUp();
4041	}
4042	else
4043	{
4044	Werror("%s is no name of a ring/qring",n);
4045	(yyvsp[(2) - (2)].lv).CleanUp();
4046	YYERROR;
4047	}
4048	;}
4049	break;
4050
4051	case 159:
4052
4053	/* Line 1464 of yacc.c */
4054	#line 1460 "grammar.y"
4055	{
4056	type_cmd(&((yyvsp[(2) - (2)].lv)));
4057	;}
4058	break;
4059
4060	case 160:
4061
4062	/* Line 1464 of yacc.c */
4063	#line 1464 "grammar.y"
4064	{
4065	//Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
4066	#ifdef SIQ
4067	if ((yyvsp[(1) - (1)].lv).rtyp!=COMMAND)
4068	{
4069	#endif
4070	if ((yyvsp[(1) - (1)].lv).Typ()==UNKNOWN)
4071	{
4072	if ((yyvsp[(1) - (1)].lv).name!=NULL)
4073	{
4074	Werror("`%s` is undefined",(yyvsp[(1) - (1)].lv).name);
4075	omFree((ADDRESS)(yyvsp[(1) - (1)].lv).name);
4076	}
4077	YYERROR;
4078	}
4079	#ifdef SIQ
4080	}
4081	#endif
4082	(yyvsp[(1) - (1)].lv).Print(&sLastPrinted);
4083	(yyvsp[(1) - (1)].lv).CleanUp(currRing);
4084	if (errorreported) YYERROR;
4085	;}
4086	break;
4087
4088	case 161:
4089
4090	/* Line 1464 of yacc.c */
4091	#line 1493 "grammar.y"
4092	{
4093	int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4094	if (i!=0)
4095	{
4096	newBuffer( (yyvsp[(5) - (5)].name), BT_if);
4097	}
4098	else
4099	{
4100	omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4101	currentVoice->ifsw=1;
4102	}
4103	;}
4104	break;
4105
4106	case 162:
4107
4108	/* Line 1464 of yacc.c */
4109	#line 1506 "grammar.y"
4110	{
4111	if (currentVoice->ifsw==1)
4112	{
4113	currentVoice->ifsw=0;
4114	newBuffer( (yyvsp[(2) - (2)].name), BT_else);
4115	}
4116	else
4117	{
4118	if (currentVoice->ifsw!=2)
4119	{
4120	Warn("`else` without `if` in level %d",myynest);
4121	}
4122	omFree((ADDRESS)(yyvsp[(2) - (2)].name));
4123	}
4124	currentVoice->ifsw=0;
4125	;}
4126	break;
4127
4128	case 163:
4129
4130	/* Line 1464 of yacc.c */
4131	#line 1523 "grammar.y"
4132	{
4133	int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4134	if (i)
4135	{
4136	if (exitBuffer(BT_break)) YYERROR;
4137	}
4138	currentVoice->ifsw=0;
4139	;}
4140	break;
4141
4142	case 164:
4143
4144	/* Line 1464 of yacc.c */
4145	#line 1532 "grammar.y"
4146	{
4147	if (exitBuffer(BT_break)) YYERROR;
4148	currentVoice->ifsw=0;
4149	;}
4150	break;
4151
4152	case 165:
4153
4154	/* Line 1464 of yacc.c */
4155	#line 1537 "grammar.y"
4156	{
4157	if (contBuffer(BT_break)) YYERROR;
4158	currentVoice->ifsw=0;
4159	;}
4160	break;
4161
4162	case 166:
4163
4164	/* Line 1464 of yacc.c */
4165	#line 1545 "grammar.y"
4166	{
4167	/* -> if(!$2) break; $3; continue;*/
4168	char * s = (char *)omAlloc( strlen((yyvsp[(2) - (3)].name)) + strlen((yyvsp[(3) - (3)].name)) + 36);
4169	sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,(yyvsp[(2) - (3)].name),(yyvsp[(3) - (3)].name));
4170	newBuffer(s,BT_break);
4171	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4172	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4173	;}
4174	break;
4175
4176	case 167:
4177
4178	/* Line 1464 of yacc.c */
4179	#line 1557 "grammar.y"
4180	{
4181	/* $2 */
4182	/* if (!$3) break; $5; $4; continue; */
4183	char * s = (char *)omAlloc( strlen((yyvsp[(3) - (5)].name))+strlen((yyvsp[(4) - (5)].name))+strlen((yyvsp[(5) - (5)].name))+36);
4184	sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
4185	,(yyvsp[(3) - (5)].name),(yyvsp[(5) - (5)].name),(yyvsp[(4) - (5)].name));
4186	omFree((ADDRESS)(yyvsp[(3) - (5)].name));
4187	omFree((ADDRESS)(yyvsp[(4) - (5)].name));
4188	omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4189	newBuffer(s,BT_break);
4190	s = (char *)omAlloc( strlen((yyvsp[(2) - (5)].name)) + 3);
4191	sprintf(s,"%s;\n",(yyvsp[(2) - (5)].name));
4192	omFree((ADDRESS)(yyvsp[(2) - (5)].name));
4193	newBuffer(s,BT_if);
4194	;}
4195	break;
4196
4197	case 168:
4198
4199	/* Line 1464 of yacc.c */
4200	#line 1576 "grammar.y"
4201	{
4202	idhdl h = enterid((yyvsp[(2) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4203	if (h==NULL) {omFree((ADDRESS)(yyvsp[(2) - (3)].name));omFree((ADDRESS)(yyvsp[(3) - (3)].name)); YYERROR;}
4204	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(2) - (3)].name), 0, 0);
4205	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+31);;
4206	sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",(yyvsp[(3) - (3)].name));
4207	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4208	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4209	;}
4210	break;
4211
4212	case 169:
4213
4214	/* Line 1464 of yacc.c */
4215	#line 1586 "grammar.y"
4216	{
4217	idhdl h = enterid((yyvsp[(1) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4218	if (h==NULL)
4219	{
4220	omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4221	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4222	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4223	YYERROR;
4224	}
4225	char *args=iiProcArgs((yyvsp[(2) - (3)].name),FALSE);
4226	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4227	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (3)].name), 0, 0);
4228	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+strlen(args)+14);;
4229	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(3) - (3)].name));
4230	omFree((ADDRESS)args);
4231	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4232	omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4233	;}
4234	break;
4235
4236	case 170:
4237
4238	/* Line 1464 of yacc.c */
4239	#line 1605 "grammar.y"
4240	{
4241	omFree((ADDRESS)(yyvsp[(3) - (4)].name));
4242	idhdl h = enterid((yyvsp[(1) - (4)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4243	if (h==NULL)
4244	{
4245	omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4246	omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4247	omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4248	YYERROR;
4249	}
4250	char *args=iiProcArgs((yyvsp[(2) - (4)].name),FALSE);
4251	omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4252	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (4)].name), 0, 0);
4253	omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4254	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(4) - (4)].name))+strlen(args)+14);;
4255	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(4) - (4)].name));
4256	omFree((ADDRESS)args);
4257	omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4258	;}
4259	break;
4260
4261	case 171:
4262
4263	/* Line 1464 of yacc.c */
4264	#line 1628 "grammar.y"
4265	{
4266	// decl. of type proc p(int i)
4267	if ((yyvsp[(1) - (2)].i)==PARAMETER) { if (iiParameter(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4268	else { if (iiAlias(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4269	;}
4270	break;
4271
4272	case 172:
4273
4274	/* Line 1464 of yacc.c */
4275	#line 1634 "grammar.y"
4276	{
4277	// decl. of type proc p(i)
4278	sleftv tmp_expr;
4279	if ((yyvsp[(1) - (2)].i)==ALIAS_CMD) MYYERROR("alias requires a type");
4280	if ((iiDeclCommand(&tmp_expr,&(yyvsp[(2) - (2)].lv),myynest,DEF_CMD,&IDROOT))
4281	\|\| (iiParameter(&tmp_expr)))
4282	YYERROR;
4283	;}
4284	break;
4285
4286	case 173:
4287
4288	/* Line 1464 of yacc.c */
4289	#line 1646 "grammar.y"
4290	{
4291	iiRETURNEXPR.Copy(&(yyvsp[(3) - (4)].lv));
4292	(yyvsp[(3) - (4)].lv).CleanUp();
4293	if (exitBuffer(BT_proc)) YYERROR;
4294	;}
4295	break;
4296
4297	case 174:
4298
4299	/* Line 1464 of yacc.c */
4300	#line 1652 "grammar.y"
4301	{
4302	if ((yyvsp[(1) - (3)].i)==RETURN)
4303	{
4304	iiRETURNEXPR.Init();
4305	iiRETURNEXPR.rtyp=NONE;
4306	if (exitBuffer(BT_proc)) YYERROR;
4307	}
4308	;}
4309	break;
4310
4311
4312
4313	/* Line 1464 of yacc.c */
4314	#line 4315 "grammar.cc"
4315	default: break;
4316	}
4317	YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4318
4319	YYPOPSTACK (yylen);
4320	yylen = 0;
4321	YY_STACK_PRINT (yyss, yyssp);
4322
4323	*++yyvsp = yyval;
4324
4325	/* Now `shift' the result of the reduction. Determine what state
4326	that goes to, based on the state we popped back to and the rule
4327	number reduced by. */
4328
4329	yyn = yyr1[yyn];
4330
4331	yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4332	if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4333	yystate = yytable[yystate];
4334	else
4335	yystate = yydefgoto[yyn - YYNTOKENS];
4336
4337	goto yynewstate;
4338
4339
4340	/*------------------------------------.
4341	\| yyerrlab -- here on detecting error \|
4342	`------------------------------------*/
4343	yyerrlab:
4344	/* If not already recovering from an error, report this error. */
4345	if (!yyerrstatus)
4346	{
4347	++yynerrs;
4348	#if ! YYERROR_VERBOSE
4349	yyerror (YY_("syntax error"));
4350	#else
4351	{
4352	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
4353	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
4354	{
4355	YYSIZE_T yyalloc = 2 * yysize;
4356	if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
4357	yyalloc = YYSTACK_ALLOC_MAXIMUM;
4358	if (yymsg != yymsgbuf)
4359	YYSTACK_FREE (yymsg);
4360	yymsg = (char *) YYSTACK_ALLOC (yyalloc);
4361	if (yymsg)
4362	yymsg_alloc = yyalloc;
4363	else
4364	{
4365	yymsg = yymsgbuf;
4366	yymsg_alloc = sizeof yymsgbuf;
4367	}
4368	}
4369
4370	if (0 < yysize && yysize <= yymsg_alloc)
4371	{
4372	(void) yysyntax_error (yymsg, yystate, yychar);
4373	yyerror (yymsg);
4374	}
4375	else
4376	{
4377	yyerror (YY_("syntax error"));
4378	if (yysize != 0)
4379	goto yyexhaustedlab;
4380	}
4381	}
4382	#endif
4383	}
4384
4385
4386
4387	if (yyerrstatus == 3)
4388	{
4389	/* If just tried and failed to reuse lookahead token after an
4390	error, discard it. */
4391
4392	if (yychar <= YYEOF)
4393	{
4394	/* Return failure if at end of input. */
4395	if (yychar == YYEOF)
4396	YYABORT;
4397	}
4398	else
4399	{
4400	yydestruct ("Error: discarding",
4401	yytoken, &yylval);
4402	yychar = YYEMPTY;
4403	}
4404	}
4405
4406	/* Else will try to reuse lookahead token after shifting the error
4407	token. */
4408	goto yyerrlab1;
4409
4410
4411	/*---------------------------------------------------.
4412	\| yyerrorlab -- error raised explicitly by YYERROR. \|
4413	`---------------------------------------------------*/
4414	yyerrorlab:
4415
4416	/* Pacify compilers like GCC when the user code never invokes
4417	YYERROR and the label yyerrorlab therefore never appears in user
4418	code. */
4419	if (/CONSTCOND/ 0)
4420	goto yyerrorlab;
4421
4422	/* Do not reclaim the symbols of the rule which action triggered
4423	this YYERROR. */
4424	YYPOPSTACK (yylen);
4425	yylen = 0;
4426	YY_STACK_PRINT (yyss, yyssp);
4427	yystate = *yyssp;
4428	goto yyerrlab1;
4429
4430
4431	/*-------------------------------------------------------------.
4432	\| yyerrlab1 -- common code for both syntax error and YYERROR. \|
4433	`-------------------------------------------------------------*/
4434	yyerrlab1:
4435	yyerrstatus = 3; /* Each real token shifted decrements this. */
4436
4437	for (;;)
4438	{
4439	yyn = yypact[yystate];
4440	if (yyn != YYPACT_NINF)
4441	{
4442	yyn += YYTERROR;
4443	if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4444	{
4445	yyn = yytable[yyn];
4446	if (0 < yyn)
4447	break;
4448	}
4449	}
4450
4451	/* Pop the current state because it cannot handle the error token. */
4452	if (yyssp == yyss)
4453	YYABORT;
4454
4455
4456	yydestruct ("Error: popping",
4457	yystos[yystate], yyvsp);
4458	YYPOPSTACK (1);
4459	yystate = *yyssp;
4460	YY_STACK_PRINT (yyss, yyssp);
4461	}
4462
4463	*++yyvsp = yylval;
4464
4465
4466	/* Shift the error token. */
4467	YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4468
4469	yystate = yyn;
4470	goto yynewstate;
4471
4472
4473	/*-------------------------------------.
4474	\| yyacceptlab -- YYACCEPT comes here. \|
4475	`-------------------------------------*/
4476	yyacceptlab:
4477	yyresult = 0;
4478	goto yyreturn;
4479
4480	/*-----------------------------------.
4481	\| yyabortlab -- YYABORT comes here. \|
4482	`-----------------------------------*/
4483	yyabortlab:
4484	yyresult = 1;
4485	goto yyreturn;
4486
4487	#if !defined(yyoverflow) \|\| YYERROR_VERBOSE
4488	/*-------------------------------------------------.
4489	\| yyexhaustedlab -- memory exhaustion comes here. \|
4490	`-------------------------------------------------*/
4491	yyexhaustedlab:
4492	yyerror (YY_("memory exhausted"));
4493	yyresult = 2;
4494	/* Fall through. */
4495	#endif
4496
4497	yyreturn:
4498	if (yychar != YYEMPTY)
4499	yydestruct ("Cleanup: discarding lookahead",
4500	yytoken, &yylval);
4501	/* Do not reclaim the symbols of the rule which action triggered
4502	this YYABORT or YYACCEPT. */
4503	YYPOPSTACK (yylen);
4504	YY_STACK_PRINT (yyss, yyssp);
4505	while (yyssp != yyss)
4506	{
4507	yydestruct ("Cleanup: popping",
4508	yystos[*yyssp], yyvsp);
4509	YYPOPSTACK (1);
4510	}
4511	#ifndef yyoverflow
4512	if (yyss != yyssa)
4513	YYSTACK_FREE (yyss);
4514	#endif
4515	#if YYERROR_VERBOSE
4516	if (yymsg != yymsgbuf)
4517	YYSTACK_FREE (yymsg);
4518	#endif
4519	/* Make sure YYID is used. */
4520	return YYID (yyresult);
4521	}
4522
4523
4524

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

Download in other formats: