Context Navigation

source: git/Singular/grammar.cc

spielwiese

Last change on this file was d4a6939, checked in by Hans Schoenemann <hannes@…>, 5 months ago
prepare for Singular 4.4.0
Property mode set to `100644`
File size: 151.4 KB

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

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

Download in other formats: