Context Navigation

source: git/Singular/grammar.cc @ f7d268

spielwiese

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

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

Download in other formats: