Context Navigation

source: git/Singular/grammar.cc @ f59519

fieker-DuValspielwiese

Last change on this file since f59519 was 7647014, checked in by Hans Schoenemann <hannes@…>, 7 years ago
fix: memory leak in "kill unknown"
Property mode set to `100644`
File size: 149.0 KB

Line
1	/* A Bison parser, made by GNU Bison 2.4.3. */
2
3	/* Skeleton implementation for Bison's Yacc-like parsers in C
4
5	Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6	2009, 2010 Free Software Foundation, Inc.
7
8	This program is free software: you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation, either version 3 of the License, or
11	(at your option) any later version.
12
13	This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.
17
18	You should have received a copy of the GNU General Public License
19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21	/* As a special exception, you may create a larger work that contains
22	part or all of the Bison parser skeleton and distribute that work
23	under terms of your choice, so long as that work isn't itself a
24	parser generator using the skeleton or a modified version thereof
25	as a parser skeleton. Alternatively, if you modify or redistribute
26	the parser skeleton itself, you may (at your option) remove this
27	special exception, which will cause the skeleton and the resulting
28	Bison output files to be licensed under the GNU General Public
29	License without this special exception.
30
31	This special exception was added by the Free Software Foundation in
32	version 2.2 of Bison. */
33
34	/* C LALR(1) parser skeleton written by Richard Stallman, by
35	simplifying the original so-called "semantic" parser. */
36
37	/* All symbols defined below should begin with yy or YY, to avoid
38	infringing on user name space. This should be done even for local
39	variables, as they might otherwise be expanded by user macros.
40	There are some unavoidable exceptions within include files to
41	define necessary library symbols; they are noted "INFRINGES ON
42	USER NAME SPACE" below. */
43
44	/* Identify Bison output. */
45	#define YYBISON 1
46
47	/* Bison version. */
48	#define YYBISON_VERSION "2.4.3"
49
50	/* Skeleton name. */
51	#define YYSKELETON_NAME "yacc.c"
52
53	/* Pure parsers. */
54	#define YYPURE 1
55
56	/* Push parsers. */
57	#define YYPUSH 0
58
59	/* Pull parsers. */
60	#define YYPULL 1
61
62	/* Using locations. */
63	#define YYLSP_NEEDED 0
64
65
66
67	/* Copy the first part of user declarations. */
68
69	/* Line 189 of yacc.c */
70	#line 7 "grammar.y"
71
72
73	#include <stdio.h>
74	#include <stddef.h>
75	#include <stdlib.h>
76	#include <stdarg.h>
77	#include <string.h>
78
79	#include <kernel/mod2.h>
80	#include <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, 261, 263,
651	265, 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, 99, 111, 100, -1, 111, 94, 112,
693	-1, 112, -1, 117, -1, 110, -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, 486, 514, 538, 544,
747	550, 554, 558, 562, 566, 570, 574, 578, 582, 586,
748	590, 594, 598, 602, 606, 610, 614, 618, 622, 626,
749	630, 636, 640, 644, 648, 652, 656, 660, 671, 677,
750	682, 683, 687, 691, 695, 699, 703, 707, 711, 715,
751	719, 736, 743, 742, 760, 768, 776, 785, 789, 793,
752	797, 801, 805, 809, 813, 817, 821, 825, 829, 833,
753	845, 852, 853, 872, 873, 885, 890, 895, 899, 903,
754	939, 965, 986, 994, 998, 999, 1013, 1021, 1030, 1075,
755	1076, 1085, 1086, 1092, 1099, 1101, 1103, 1113, 1112, 1120,
756	1125, 1132, 1140, 1152, 1169, 1189, 1193, 1197, 1202, 1206,
757	1210, 1214, 1218, 1223, 1229, 1235, 1241, 1247, 1253, 1259,
758	1271, 1278, 1282, 1319, 1326, 1331, 1344, 1350, 1350, 1353,
759	1421, 1425, 1454, 1467, 1484, 1493, 1498, 1506, 1518, 1537,
760	1547, 1566, 1589, 1595, 1607, 1613
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, 110, 111, 111, 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, 3, 1, 1,
849	1, 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	70, 161, 68, 0, 0, 69, 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	70, 0, 31, 0, 0, 0, 0, 0, 0, 0,
878	0, 0, 0, 70, 0, 70, 0, 70, 0, 70,
879	0, 19, 132, 0, 130, 70, 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, 70, 0, 70, 159, 0,
885	0, 0, 0, 0, 0, 68, 169, 0, 114, 0,
886	0, 0, 0, 0, 0, 0, 0, 59, 0, 68,
887	43, 0, 68, 46, 0, 131, 129, 0, 0, 0,
888	0, 0, 0, 150, 70, 0, 0, 170, 0, 0,
889	0, 0, 167, 175, 0, 0, 36, 66, 104, 32,
890	34, 0, 67, 97, 96, 95, 93, 89, 90, 91,
891	0, 92, 94, 98, 33, 0, 86, 79, 0, 65,
892	70, 0, 0, 70, 0, 0, 0, 0, 0, 0,
893	0, 40, 68, 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, 70, 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).next==NULL)
2562	{
2563	(yyvsp[(1) - (4)].lv).next=(leftv)omAllocBin(sleftv_bin);
2564	memcpy((yyvsp[(1) - (4)].lv).next,&(yyvsp[(3) - (4)].lv),sizeof(sleftv));
2565	if(iiExprArithM(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'(')) YYERROR;
2566	}
2567	else if ((yyvsp[(1) - (4)].lv).rtyp==UNKNOWN)
2568	{ // for x(i)(j)
2569	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'(',&(yyvsp[(3) - (4)].lv))) YYERROR;
2570	}
2571	else YYERROR;
2572	;}
2573	break;
2574
2575	case 36:
2576
2577	/* Line 1464 of yacc.c */
2578	#line 487 "grammar.y"
2579	{
2580	if (currRingHdl==NULL) MYYERROR("no ring active");
2581	int j = 0;
2582	memset(&(yyval.lv),0,sizeof(sleftv));
2583	(yyval.lv).rtyp=VECTOR_CMD;
2584	leftv v = &(yyvsp[(2) - (3)].lv);
2585	while (v!=NULL)
2586	{
2587	int i,t;
2588	sleftv tmp;
2589	memset(&tmp,0,sizeof(tmp));
2590	i=iiTestConvert((t=v->Typ()),POLY_CMD);
2591	if((i==0) \|\| (iiConvert(t /v->Typ()/,POLY_CMD,i,v,&tmp)))
2592	{
2593	pDelete((poly *)&(yyval.lv).data);
2594	(yyvsp[(2) - (3)].lv).CleanUp();
2595	MYYERROR("expected '[poly,...'");
2596	}
2597	poly p = (poly)tmp.CopyD(POLY_CMD);
2598	pSetCompP(p,++j);
2599	(yyval.lv).data = (void *)pAdd((poly)(yyval.lv).data,p);
2600	v->next=tmp.next;tmp.next=NULL;
2601	tmp.CleanUp();
2602	v=v->next;
2603	}
2604	(yyvsp[(2) - (3)].lv).CleanUp();
2605	;}
2606	break;
2607
2608	case 37:
2609
2610	/* Line 1464 of yacc.c */
2611	#line 515 "grammar.y"
2612	{
2613	memset(&(yyval.lv),0,sizeof((yyval.lv)));
2614	int i = atoi((yyvsp[(1) - (1)].name));
2615	/*remember not to omFree($1)
2616	because it is a part of the scanner buffer/
2617	(yyval.lv).rtyp = INT_CMD;
2618	(yyval.lv).data = (void *)(long)i;
2619
2620	/* check: out of range input */
2621	int l = strlen((yyvsp[(1) - (1)].name))+2;
2622	number n;
2623	if (l >= MAX_INT_LEN)
2624	{
2625	char tmp[MAX_INT_LEN+5];
2626	sprintf(tmp,"%d",i);
2627	if (strcmp(tmp,(yyvsp[(1) - (1)].name))!=0)
2628	{
2629	n_Read((yyvsp[(1) - (1)].name),&n,coeffs_BIGINT);
2630	(yyval.lv).rtyp=BIGINT_CMD;
2631	(yyval.lv).data = n;
2632	}
2633	}
2634	;}
2635	break;
2636
2637	case 38:
2638
2639	/* Line 1464 of yacc.c */
2640	#line 539 "grammar.y"
2641	{
2642	memset(&(yyval.lv),0,sizeof((yyval.lv)));
2643	(yyval.lv).rtyp = (yyvsp[(1) - (1)].i);
2644	(yyval.lv).data = (yyval.lv).Data();
2645	;}
2646	break;
2647
2648	case 39:
2649
2650	/* Line 1464 of yacc.c */
2651	#line 545 "grammar.y"
2652	{
2653	memset(&(yyval.lv),0,sizeof((yyval.lv)));
2654	(yyval.lv).rtyp = STRING_CMD;
2655	(yyval.lv).data = (yyvsp[(1) - (1)].name);
2656	;}
2657	break;
2658
2659	case 40:
2660
2661	/* Line 1464 of yacc.c */
2662	#line 551 "grammar.y"
2663	{
2664	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2665	;}
2666	break;
2667
2668	case 41:
2669
2670	/* Line 1464 of yacc.c */
2671	#line 555 "grammar.y"
2672	{
2673	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2674	;}
2675	break;
2676
2677	case 42:
2678
2679	/* Line 1464 of yacc.c */
2680	#line 559 "grammar.y"
2681	{
2682	if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2683	;}
2684	break;
2685
2686	case 43:
2687
2688	/* Line 1464 of yacc.c */
2689	#line 563 "grammar.y"
2690	{
2691	if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2692	;}
2693	break;
2694
2695	case 44:
2696
2697	/* Line 1464 of yacc.c */
2698	#line 567 "grammar.y"
2699	{
2700	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2701	;}
2702	break;
2703
2704	case 45:
2705
2706	/* Line 1464 of yacc.c */
2707	#line 571 "grammar.y"
2708	{
2709	if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2710	;}
2711	break;
2712
2713	case 46:
2714
2715	/* Line 1464 of yacc.c */
2716	#line 575 "grammar.y"
2717	{
2718	if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2719	;}
2720	break;
2721
2722	case 47:
2723
2724	/* Line 1464 of yacc.c */
2725	#line 579 "grammar.y"
2726	{
2727	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2728	;}
2729	break;
2730
2731	case 48:
2732
2733	/* Line 1464 of yacc.c */
2734	#line 583 "grammar.y"
2735	{
2736	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2737	;}
2738	break;
2739
2740	case 49:
2741
2742	/* Line 1464 of yacc.c */
2743	#line 587 "grammar.y"
2744	{
2745	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2746	;}
2747	break;
2748
2749	case 50:
2750
2751	/* Line 1464 of yacc.c */
2752	#line 591 "grammar.y"
2753	{
2754	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2755	;}
2756	break;
2757
2758	case 51:
2759
2760	/* Line 1464 of yacc.c */
2761	#line 595 "grammar.y"
2762	{
2763	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2764	;}
2765	break;
2766
2767	case 52:
2768
2769	/* Line 1464 of yacc.c */
2770	#line 599 "grammar.y"
2771	{
2772	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2773	;}
2774	break;
2775
2776	case 53:
2777
2778	/* Line 1464 of yacc.c */
2779	#line 603 "grammar.y"
2780	{
2781	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2782	;}
2783	break;
2784
2785	case 54:
2786
2787	/* Line 1464 of yacc.c */
2788	#line 607 "grammar.y"
2789	{
2790	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2791	;}
2792	break;
2793
2794	case 55:
2795
2796	/* Line 1464 of yacc.c */
2797	#line 611 "grammar.y"
2798	{
2799	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2800	;}
2801	break;
2802
2803	case 56:
2804
2805	/* Line 1464 of yacc.c */
2806	#line 615 "grammar.y"
2807	{
2808	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2809	;}
2810	break;
2811
2812	case 57:
2813
2814	/* Line 1464 of yacc.c */
2815	#line 619 "grammar.y"
2816	{
2817	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2818	;}
2819	break;
2820
2821	case 58:
2822
2823	/* Line 1464 of yacc.c */
2824	#line 623 "grammar.y"
2825	{
2826	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2827	;}
2828	break;
2829
2830	case 59:
2831
2832	/* Line 1464 of yacc.c */
2833	#line 627 "grammar.y"
2834	{
2835	if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2836	;}
2837	break;
2838
2839	case 60:
2840
2841	/* Line 1464 of yacc.c */
2842	#line 631 "grammar.y"
2843	{
2844	int b=iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i)); // handle branchTo
2845	if (b==TRUE) YYERROR;
2846	if (b==2) YYACCEPT;
2847	;}
2848	break;
2849
2850	case 61:
2851
2852	/* Line 1464 of yacc.c */
2853	#line 637 "grammar.y"
2854	{
2855	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2856	;}
2857	break;
2858
2859	case 62:
2860
2861	/* Line 1464 of yacc.c */
2862	#line 641 "grammar.y"
2863	{
2864	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2865	;}
2866	break;
2867
2868	case 63:
2869
2870	/* Line 1464 of yacc.c */
2871	#line 645 "grammar.y"
2872	{
2873	if(iiExprArith3(&(yyval.lv),RING_CMD,&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2874	;}
2875	break;
2876
2877	case 64:
2878
2879	/* Line 1464 of yacc.c */
2880	#line 649 "grammar.y"
2881	{
2882	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),RING_CMD)) YYERROR;
2883	;}
2884	break;
2885
2886	case 65:
2887
2888	/* Line 1464 of yacc.c */
2889	#line 653 "grammar.y"
2890	{
2891	if (iiARROW(&(yyval.lv),(yyvsp[(1) - (3)].name),(yyvsp[(3) - (3)].name))) YYERROR;
2892	;}
2893	break;
2894
2895	case 66:
2896
2897	/* Line 1464 of yacc.c */
2898	#line 656 "grammar.y"
2899	{ (yyval.lv) = (yyvsp[(2) - (3)].lv); ;}
2900	break;
2901
2902	case 67:
2903
2904	/* Line 1464 of yacc.c */
2905	#line 661 "grammar.y"
2906	{
2907	leftv v = &(yyvsp[(1) - (3)].lv);
2908	while (v->next!=NULL)
2909	{
2910	v=v->next;
2911	}
2912	v->next = (leftv)omAllocBin(sleftv_bin);
2913	memcpy(v->next,&((yyvsp[(3) - (3)].lv)),sizeof(sleftv));
2914	(yyval.lv) = (yyvsp[(1) - (3)].lv);
2915	;}
2916	break;
2917
2918	case 68:
2919
2920	/* Line 1464 of yacc.c */
2921	#line 672 "grammar.y"
2922	{
2923	(yyval.lv) = (yyvsp[(1) - (1)].lv);
2924	;}
2925	break;
2926
2927	case 69:
2928
2929	/* Line 1464 of yacc.c */
2930	#line 678 "grammar.y"
2931	{
2932	/if ($1.typ == eunknown) YYERROR;/
2933	(yyval.lv) = (yyvsp[(1) - (1)].lv);
2934	;}
2935	break;
2936
2937	case 70:
2938
2939	/* Line 1464 of yacc.c */
2940	#line 682 "grammar.y"
2941	{ (yyval.lv) = (yyvsp[(1) - (1)].lv); ;}
2942	break;
2943
2944	case 71:
2945
2946	/* Line 1464 of yacc.c */
2947	#line 684 "grammar.y"
2948	{
2949	if(iiExprArith3(&(yyval.lv),'[',&(yyvsp[(1) - (6)].lv),&(yyvsp[(3) - (6)].lv),&(yyvsp[(5) - (6)].lv))) YYERROR;
2950	;}
2951	break;
2952
2953	case 72:
2954
2955	/* Line 1464 of yacc.c */
2956	#line 688 "grammar.y"
2957	{
2958	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'[',&(yyvsp[(3) - (4)].lv))) YYERROR;
2959	;}
2960	break;
2961
2962	case 73:
2963
2964	/* Line 1464 of yacc.c */
2965	#line 692 "grammar.y"
2966	{
2967	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
2968	;}
2969	break;
2970
2971	case 74:
2972
2973	/* Line 1464 of yacc.c */
2974	#line 696 "grammar.y"
2975	{
2976	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
2977	;}
2978	break;
2979
2980	case 75:
2981
2982	/* Line 1464 of yacc.c */
2983	#line 700 "grammar.y"
2984	{
2985	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
2986	;}
2987	break;
2988
2989	case 76:
2990
2991	/* Line 1464 of yacc.c */
2992	#line 704 "grammar.y"
2993	{
2994	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
2995	;}
2996	break;
2997
2998	case 77:
2999
3000	/* Line 1464 of yacc.c */
3001	#line 708 "grammar.y"
3002	{
3003	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3004	;}
3005	break;
3006
3007	case 78:
3008
3009	/* Line 1464 of yacc.c */
3010	#line 712 "grammar.y"
3011	{
3012	if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), 0, &(yyvsp[(5) - (6)].lv))) YYERROR;
3013	;}
3014	break;
3015
3016	case 79:
3017
3018	/* Line 1464 of yacc.c */
3019	#line 716 "grammar.y"
3020	{
3021	(yyval.lv)=(yyvsp[(2) - (3)].lv);
3022	;}
3023	break;
3024
3025	case 80:
3026
3027	/* Line 1464 of yacc.c */
3028	#line 720 "grammar.y"
3029	{
3030	#ifdef SIQ
3031	siq++;
3032	if (siq>0)
3033	{ if (iiExprArith2(&(yyval.lv),&(yyvsp[(2) - (5)].lv),'=',&(yyvsp[(4) - (5)].lv))) YYERROR; }
3034	else
3035	#endif
3036	{
3037	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3038	(yyval.lv).rtyp=NONE;
3039	if (iiAssign(&(yyvsp[(2) - (5)].lv),&(yyvsp[(4) - (5)].lv))) YYERROR;
3040	}
3041	#ifdef SIQ
3042	siq--;
3043	#endif
3044	;}
3045	break;
3046
3047	case 81:
3048
3049	/* Line 1464 of yacc.c */
3050	#line 737 "grammar.y"
3051	{
3052	iiTestAssume(&(yyvsp[(2) - (5)].lv),&(yyvsp[(4) - (5)].lv));
3053	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3054	(yyval.lv).rtyp=NONE;
3055	;}
3056	break;
3057
3058	case 82:
3059
3060	/* Line 1464 of yacc.c */
3061	#line 743 "grammar.y"
3062	{
3063	#ifdef SIQ
3064	siq--;
3065	#endif
3066	;}
3067	break;
3068
3069	case 83:
3070
3071	/* Line 1464 of yacc.c */
3072	#line 749 "grammar.y"
3073	{
3074	#ifdef SIQ
3075	if (siq<=0) (yyvsp[(4) - (5)].lv).Eval();
3076	#endif
3077	(yyval.lv)=(yyvsp[(4) - (5)].lv);
3078	#ifdef SIQ
3079	siq++;
3080	#endif
3081	;}
3082	break;
3083
3084	case 84:
3085
3086	/* Line 1464 of yacc.c */
3087	#line 761 "grammar.y"
3088	{
3089	#ifdef SIQ
3090	siq++;
3091	#endif
3092	;}
3093	break;
3094
3095	case 85:
3096
3097	/* Line 1464 of yacc.c */
3098	#line 769 "grammar.y"
3099	{
3100	#ifdef SIQ
3101	siq++;
3102	#endif
3103	;}
3104	break;
3105
3106	case 86:
3107
3108	/* Line 1464 of yacc.c */
3109	#line 777 "grammar.y"
3110	{
3111	#ifdef SIQ
3112	siq--;
3113	#endif
3114	;}
3115	break;
3116
3117	case 87:
3118
3119	/* Line 1464 of yacc.c */
3120	#line 786 "grammar.y"
3121	{
3122	if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),PLUSPLUS)) YYERROR;
3123	;}
3124	break;
3125
3126	case 88:
3127
3128	/* Line 1464 of yacc.c */
3129	#line 790 "grammar.y"
3130	{
3131	if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),MINUSMINUS)) YYERROR;
3132	;}
3133	break;
3134
3135	case 89:
3136
3137	/* Line 1464 of yacc.c */
3138	#line 794 "grammar.y"
3139	{
3140	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'+',&(yyvsp[(3) - (3)].lv))) YYERROR;
3141	;}
3142	break;
3143
3144	case 90:
3145
3146	/* Line 1464 of yacc.c */
3147	#line 798 "grammar.y"
3148	{
3149	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'-',&(yyvsp[(3) - (3)].lv))) YYERROR;
3150	;}
3151	break;
3152
3153	case 91:
3154
3155	/* Line 1464 of yacc.c */
3156	#line 802 "grammar.y"
3157	{
3158	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3159	;}
3160	break;
3161
3162	case 92:
3163
3164	/* Line 1464 of yacc.c */
3165	#line 806 "grammar.y"
3166	{
3167	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'^',&(yyvsp[(3) - (3)].lv))) YYERROR;
3168	;}
3169	break;
3170
3171	case 93:
3172
3173	/* Line 1464 of yacc.c */
3174	#line 810 "grammar.y"
3175	{
3176	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3177	;}
3178	break;
3179
3180	case 94:
3181
3182	/* Line 1464 of yacc.c */
3183	#line 814 "grammar.y"
3184	{
3185	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3186	;}
3187	break;
3188
3189	case 95:
3190
3191	/* Line 1464 of yacc.c */
3192	#line 818 "grammar.y"
3193	{
3194	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),NOTEQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR;
3195	;}
3196	break;
3197
3198	case 96:
3199
3200	/* Line 1464 of yacc.c */
3201	#line 822 "grammar.y"
3202	{
3203	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),EQUAL_EQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR;
3204	;}
3205	break;
3206
3207	case 97:
3208
3209	/* Line 1464 of yacc.c */
3210	#line 826 "grammar.y"
3211	{
3212	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),DOTDOT,&(yyvsp[(3) - (3)].lv))) YYERROR;
3213	;}
3214	break;
3215
3216	case 98:
3217
3218	/* Line 1464 of yacc.c */
3219	#line 830 "grammar.y"
3220	{
3221	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),':',&(yyvsp[(3) - (3)].lv))) YYERROR;
3222	;}
3223	break;
3224
3225	case 99:
3226
3227	/* Line 1464 of yacc.c */
3228	#line 834 "grammar.y"
3229	{
3230	if (siq>0)
3231	{ if (iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),NOT)) YYERROR; }
3232	else
3233	{
3234	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3235	int i; TESTSETINT((yyvsp[(2) - (2)].lv),i);
3236	(yyval.lv).rtyp = INT_CMD;
3237	(yyval.lv).data = (void *)(long)(i == 0 ? 1 : 0);
3238	}
3239	;}
3240	break;
3241
3242	case 100:
3243
3244	/* Line 1464 of yacc.c */
3245	#line 846 "grammar.y"
3246	{
3247	if(iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),'-')) YYERROR;
3248	;}
3249	break;
3250
3251	case 101:
3252
3253	/* Line 1464 of yacc.c */
3254	#line 852 "grammar.y"
3255	{ (yyval.lv) = (yyvsp[(1) - (2)].lv); ;}
3256	break;
3257
3258	case 102:
3259
3260	/* Line 1464 of yacc.c */
3261	#line 854 "grammar.y"
3262	{
3263	if ((yyvsp[(1) - (2)].lv).rtyp==0)
3264	{
3265	Werror("`%s` is undefined",(yyvsp[(1) - (2)].lv).Fullname());
3266	YYERROR;
3267	}
3268	else if (((yyvsp[(1) - (2)].lv).rtyp==MODUL_CMD)
3269	// matrix m; m[2]=...
3270	&& ((yyvsp[(1) - (2)].lv).e!=NULL) && ((yyvsp[(1) - (2)].lv).e->next==NULL))
3271	{
3272	MYYERROR("matrix must have 2 indices");
3273	}
3274	(yyval.lv) = (yyvsp[(1) - (2)].lv);
3275	;}
3276	break;
3277
3278	case 104:
3279
3280	/* Line 1464 of yacc.c */
3281	#line 874 "grammar.y"
3282	{
3283	if ((yyvsp[(2) - (3)].lv).Typ()!=STRING_CMD)
3284	{
3285	MYYERROR("string expression expected");
3286	}
3287	(yyval.name) = (char *)(yyvsp[(2) - (3)].lv).CopyD(STRING_CMD);
3288	(yyvsp[(2) - (3)].lv).CleanUp();
3289	;}
3290	break;
3291
3292	case 105:
3293
3294	/* Line 1464 of yacc.c */
3295	#line 886 "grammar.y"
3296	{
3297	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3298	YYERROR;
3299	;}
3300	break;
3301
3302	case 106:
3303
3304	/* Line 1464 of yacc.c */
3305	#line 891 "grammar.y"
3306	{
3307	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3308	YYERROR;
3309	;}
3310	break;
3311
3312	case 107:
3313
3314	/* Line 1464 of yacc.c */
3315	#line 896 "grammar.y"
3316	{
3317	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3318	;}
3319	break;
3320
3321	case 108:
3322
3323	/* Line 1464 of yacc.c */
3324	#line 900 "grammar.y"
3325	{
3326	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3327	;}
3328	break;
3329
3330	case 109:
3331
3332	/* Line 1464 of yacc.c */
3333	#line 904 "grammar.y"
3334	{
3335	int r; TESTSETINT((yyvsp[(4) - (8)].lv),r);
3336	int c; TESTSETINT((yyvsp[(7) - (8)].lv),c);
3337	leftv v;
3338	idhdl h;
3339	if ((yyvsp[(1) - (8)].i) == MATRIX_CMD)
3340	{
3341	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&(currRing->idroot), TRUE)) YYERROR;
3342	v=&(yyval.lv);
3343	h=(idhdl)v->data;
3344	idDelete(&IDIDEAL(h));
3345	IDMATRIX(h) = mpNew(r,c);
3346	if (IDMATRIX(h)==NULL) YYERROR;
3347	}
3348	else if ((yyvsp[(1) - (8)].i) == INTMAT_CMD)
3349	{
3350	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3351	YYERROR;
3352	v=&(yyval.lv);
3353	h=(idhdl)v->data;
3354	delete IDINTVEC(h);
3355	IDINTVEC(h) = new intvec(r,c,0);
3356	if (IDINTVEC(h)==NULL) YYERROR;
3357	}
3358	else /* BIGINTMAT_CMD */
3359	{
3360	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3361	YYERROR;
3362	v=&(yyval.lv);
3363	h=(idhdl)v->data;
3364	delete IDBIMAT(h);
3365	IDBIMAT(h) = new bigintmat(r, c, coeffs_BIGINT);
3366	if (IDBIMAT(h)==NULL) YYERROR;
3367	}
3368	;}
3369	break;
3370
3371	case 110:
3372
3373	/* Line 1464 of yacc.c */
3374	#line 940 "grammar.y"
3375	{
3376	if ((yyvsp[(1) - (2)].i) == MATRIX_CMD)
3377	{
3378	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3379	}
3380	else if ((yyvsp[(1) - (2)].i) == INTMAT_CMD)
3381	{
3382	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3383	YYERROR;
3384	leftv v=&(yyval.lv);
3385	idhdl h;
3386	do
3387	{
3388	h=(idhdl)v->data;
3389	delete IDINTVEC(h);
3390	IDINTVEC(h) = new intvec(1,1,0);
3391	v=v->next;
3392	} while (v!=NULL);
3393	}
3394	else /* BIGINTMAT_CMD */
3395	{
3396	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3397	YYERROR;
3398	}
3399	;}
3400	break;
3401
3402	case 111:
3403
3404	/* Line 1464 of yacc.c */
3405	#line 966 "grammar.y"
3406	{
3407	int t=(yyvsp[(1) - (3)].lv).Typ();
3408	sleftv r;
3409	memset(&r,0,sizeof(sleftv));
3410	if ((BEGIN_RING<t) && (t<END_RING))
3411	{
3412	if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&(currRing->idroot), TRUE))
3413	YYERROR;
3414	}
3415	else
3416	{
3417	if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&((yyvsp[(3) - (3)].lv).req_packhdl->idroot)))
3418	YYERROR;
3419	}
3420	leftv v=&(yyvsp[(1) - (3)].lv);
3421	while (v->next!=NULL) v=v->next;
3422	v->next=(leftv)omAllocBin(sleftv_bin);
3423	memcpy(v->next,&r,sizeof(sleftv));
3424	(yyval.lv)=(yyvsp[(1) - (3)].lv);
3425	;}
3426	break;
3427
3428	case 112:
3429
3430	/* Line 1464 of yacc.c */
3431	#line 987 "grammar.y"
3432	{
3433	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3434	YYERROR;
3435	;}
3436	break;
3437
3438	case 115:
3439
3440	/* Line 1464 of yacc.c */
3441	#line 1000 "grammar.y"
3442	{
3443	leftv v = &(yyvsp[(2) - (5)].lv);
3444	while (v->next!=NULL)
3445	{
3446	v=v->next;
3447	}
3448	v->next = (leftv)omAllocBin(sleftv_bin);
3449	memcpy(v->next,&((yyvsp[(4) - (5)].lv)),sizeof(sleftv));
3450	(yyval.lv) = (yyvsp[(2) - (5)].lv);
3451	;}
3452	break;
3453
3454	case 116:
3455
3456	/* Line 1464 of yacc.c */
3457	#line 1014 "grammar.y"
3458	{
3459	// let rInit take care of any errors
3460	(yyval.i)=rOrderName((yyvsp[(1) - (1)].name));
3461	;}
3462	break;
3463
3464	case 117:
3465
3466	/* Line 1464 of yacc.c */
3467	#line 1022 "grammar.y"
3468	{
3469	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3470	intvec *iv = new intvec(2);
3471	(*iv)[0] = 1;
3472	(*iv)[1] = (yyvsp[(1) - (1)].i);
3473	(yyval.lv).rtyp = INTVEC_CMD;
3474	(yyval.lv).data = (void *)iv;
3475	;}
3476	break;
3477
3478	case 118:
3479
3480	/* Line 1464 of yacc.c */
3481	#line 1031 "grammar.y"
3482	{
3483	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3484	leftv sl = &(yyvsp[(3) - (4)].lv);
3485	int slLength;
3486	{
3487	slLength = exprlist_length(sl);
3488	int l = 2 + slLength;
3489	intvec *iv = new intvec(l);
3490	(*iv)[0] = slLength;
3491	(*iv)[1] = (yyvsp[(1) - (4)].i);
3492
3493	int i = 2;
3494	while ((i<l) && (sl!=NULL))
3495	{
3496	if (sl->Typ() == INT_CMD)
3497	{
3498	(*iv)[i++] = (int)((long)(sl->Data()));
3499	}
3500	else if ((sl->Typ() == INTVEC_CMD)
3501	\|\|(sl->Typ() == INTMAT_CMD))
3502	{
3503	intvec ivv = (intvec )(sl->Data());
3504	int ll = 0,l = ivv->length();
3505	for (; l>0; l--)
3506	{
3507	(iv)[i++] = (ivv)[ll++];
3508	}
3509	}
3510	else
3511	{
3512	delete iv;
3513	(yyvsp[(3) - (4)].lv).CleanUp();
3514	MYYERROR("wrong type in ordering");
3515	}
3516	sl = sl->next;
3517	}
3518	(yyval.lv).rtyp = INTVEC_CMD;
3519	(yyval.lv).data = (void *)iv;
3520	}
3521	(yyvsp[(3) - (4)].lv).CleanUp();
3522	;}
3523	break;
3524
3525	case 120:
3526
3527	/* Line 1464 of yacc.c */
3528	#line 1077 "grammar.y"
3529	{
3530	(yyval.lv) = (yyvsp[(1) - (3)].lv);
3531	(yyval.lv).next = (sleftv *)omAllocBin(sleftv_bin);
3532	memcpy((yyval.lv).next,&(yyvsp[(3) - (3)].lv),sizeof(sleftv));
3533	;}
3534	break;
3535
3536	case 122:
3537
3538	/* Line 1464 of yacc.c */
3539	#line 1087 "grammar.y"
3540	{
3541	(yyval.lv) = (yyvsp[(2) - (3)].lv);
3542	;}
3543	break;
3544
3545	case 123:
3546
3547	/* Line 1464 of yacc.c */
3548	#line 1093 "grammar.y"
3549	{
3550	expected_parms = TRUE;
3551	;}
3552	break;
3553
3554	case 124:
3555
3556	/* Line 1464 of yacc.c */
3557	#line 1100 "grammar.y"
3558	{ (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3559	break;
3560
3561	case 125:
3562
3563	/* Line 1464 of yacc.c */
3564	#line 1102 "grammar.y"
3565	{ (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3566	break;
3567
3568	case 126:
3569
3570	/* Line 1464 of yacc.c */
3571	#line 1104 "grammar.y"
3572	{ (yyval.i) = (yyvsp[(1) - (1)].i); ;}
3573	break;
3574
3575	case 127:
3576
3577	/* Line 1464 of yacc.c */
3578	#line 1113 "grammar.y"
3579	{ if ((yyvsp[(1) - (2)].i) != '<') YYERROR;
3580	if((feFilePending=feFopen((yyvsp[(2) - (2)].name),"r",NULL,TRUE))==NULL) YYERROR; ;}
3581	break;
3582
3583	case 128:
3584
3585	/* Line 1464 of yacc.c */
3586	#line 1116 "grammar.y"
3587	{ newFile((yyvsp[(2) - (4)].name),feFilePending); ;}
3588	break;
3589
3590	case 129:
3591
3592	/* Line 1464 of yacc.c */
3593	#line 1121 "grammar.y"
3594	{
3595	feHelp((yyvsp[(2) - (3)].name));
3596	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3597	;}
3598	break;
3599
3600	case 130:
3601
3602	/* Line 1464 of yacc.c */
3603	#line 1126 "grammar.y"
3604	{
3605	feHelp(NULL);
3606	;}
3607	break;
3608
3609	case 131:
3610
3611	/* Line 1464 of yacc.c */
3612	#line 1133 "grammar.y"
3613	{
3614	singular_example((yyvsp[(2) - (3)].name));
3615	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3616	;}
3617	break;
3618
3619	case 132:
3620
3621	/* Line 1464 of yacc.c */
3622	#line 1141 "grammar.y"
3623	{
3624	if (basePack!=(yyvsp[(2) - (2)].lv).req_packhdl)
3625	{
3626	if(iiExport(&(yyvsp[(2) - (2)].lv),0,currPack)) YYERROR;
3627	}
3628	else
3629	if (iiExport(&(yyvsp[(2) - (2)].lv),0)) YYERROR;
3630	;}
3631	break;
3632
3633	case 133:
3634
3635	/* Line 1464 of yacc.c */
3636	#line 1153 "grammar.y"
3637	{
3638	leftv v=&(yyvsp[(2) - (2)].lv);
3639	if (v->rtyp!=IDHDL)
3640	{
3641	if (v->name!=NULL)
3642	{
3643	Werror("`%s` is undefined in kill",v->name);
3644	omFree((ADDRESS)v->name); v->name=NULL;
3645	}
3646	else WerrorS("kill what ?");
3647	}
3648	else
3649	{
3650	killhdl((idhdl)v->data,v->req_packhdl);
3651	}
3652	;}
3653	break;
3654
3655	case 134:
3656
3657	/* Line 1464 of yacc.c */
3658	#line 1170 "grammar.y"
3659	{
3660	leftv v=&(yyvsp[(3) - (3)].lv);
3661	if (v->rtyp!=IDHDL)
3662	{
3663	if (v->name!=NULL)
3664	{
3665	Werror("`%s` is undefined in kill",v->name);
3666	omFree((ADDRESS)v->name); v->name=NULL;
3667	}
3668	else WerrorS("kill what ?");
3669	}
3670	else
3671	{
3672	killhdl((idhdl)v->data,v->req_packhdl);
3673	}
3674	;}
3675	break;
3676
3677	case 135:
3678
3679	/* Line 1464 of yacc.c */
3680	#line 1190 "grammar.y"
3681	{
3682	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3683	;}
3684	break;
3685
3686	case 136:
3687
3688	/* Line 1464 of yacc.c */
3689	#line 1194 "grammar.y"
3690	{
3691	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3692	;}
3693	break;
3694
3695	case 137:
3696
3697	/* Line 1464 of yacc.c */
3698	#line 1198 "grammar.y"
3699	{
3700	if ((yyvsp[(3) - (4)].i)==QRING_CMD) (yyvsp[(3) - (4)].i)=RING_CMD;
3701	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3702	;}
3703	break;
3704
3705	case 138:
3706
3707	/* Line 1464 of yacc.c */
3708	#line 1203 "grammar.y"
3709	{
3710	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3711	;}
3712	break;
3713
3714	case 139:
3715
3716	/* Line 1464 of yacc.c */
3717	#line 1207 "grammar.y"
3718	{
3719	list_cmd(RING_CMD,NULL,"// ",TRUE);
3720	;}
3721	break;
3722
3723	case 140:
3724
3725	/* Line 1464 of yacc.c */
3726	#line 1211 "grammar.y"
3727	{
3728	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3729	;}
3730	break;
3731
3732	case 141:
3733
3734	/* Line 1464 of yacc.c */
3735	#line 1215 "grammar.y"
3736	{
3737	list_cmd(PROC_CMD,NULL,"// ",TRUE);
3738	;}
3739	break;
3740
3741	case 142:
3742
3743	/* Line 1464 of yacc.c */
3744	#line 1219 "grammar.y"
3745	{
3746	list_cmd(0,(yyvsp[(3) - (4)].lv).Fullname(),"// ",TRUE);
3747	(yyvsp[(3) - (4)].lv).CleanUp();
3748	;}
3749	break;
3750
3751	case 143:
3752
3753	/* Line 1464 of yacc.c */
3754	#line 1224 "grammar.y"
3755	{
3756	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3757	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3758	(yyvsp[(3) - (6)].lv).CleanUp();
3759	;}
3760	break;
3761
3762	case 144:
3763
3764	/* Line 1464 of yacc.c */
3765	#line 1230 "grammar.y"
3766	{
3767	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3768	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3769	(yyvsp[(3) - (6)].lv).CleanUp();
3770	;}
3771	break;
3772
3773	case 145:
3774
3775	/* Line 1464 of yacc.c */
3776	#line 1236 "grammar.y"
3777	{
3778	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3779	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3780	(yyvsp[(3) - (6)].lv).CleanUp();
3781	;}
3782	break;
3783
3784	case 146:
3785
3786	/* Line 1464 of yacc.c */
3787	#line 1242 "grammar.y"
3788	{
3789	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3790	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3791	(yyvsp[(3) - (6)].lv).CleanUp();
3792	;}
3793	break;
3794
3795	case 147:
3796
3797	/* Line 1464 of yacc.c */
3798	#line 1248 "grammar.y"
3799	{
3800	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3801	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3802	(yyvsp[(3) - (6)].lv).CleanUp();
3803	;}
3804	break;
3805
3806	case 148:
3807
3808	/* Line 1464 of yacc.c */
3809	#line 1254 "grammar.y"
3810	{
3811	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3812	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3813	(yyvsp[(3) - (6)].lv).CleanUp();
3814	;}
3815	break;
3816
3817	case 149:
3818
3819	/* Line 1464 of yacc.c */
3820	#line 1260 "grammar.y"
3821	{
3822	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3823	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3824	(yyvsp[(3) - (6)].lv).CleanUp();
3825	;}
3826	break;
3827
3828	case 150:
3829
3830	/* Line 1464 of yacc.c */
3831	#line 1272 "grammar.y"
3832	{
3833	list_cmd(-1,NULL,"// ",TRUE);
3834	;}
3835	break;
3836
3837	case 151:
3838
3839	/* Line 1464 of yacc.c */
3840	#line 1278 "grammar.y"
3841	{ yyInRingConstruction = TRUE; ;}
3842	break;
3843
3844	case 152:
3845
3846	/* Line 1464 of yacc.c */
3847	#line 1287 "grammar.y"
3848	{
3849	const char *ring_name = (yyvsp[(2) - (8)].lv).name;
3850	ring b=
3851	rInit(&(yyvsp[(4) - (8)].lv), /* characteristik and list of parameters*/
3852	&(yyvsp[(6) - (8)].lv), /* names of ringvariables */
3853	&(yyvsp[(8) - (8)].lv)); /* ordering */
3854	idhdl newRingHdl=NULL;
3855
3856	if (b!=NULL)
3857	{
3858	newRingHdl=enterid(ring_name, myynest, RING_CMD,
3859	&((yyvsp[(2) - (8)].lv).req_packhdl->idroot),FALSE);
3860	(yyvsp[(2) - (8)].lv).CleanUp();
3861	if (newRingHdl!=NULL)
3862	{
3863	IDRING(newRingHdl)=b;
3864	}
3865	else
3866	{
3867	rKill(b);
3868	}
3869	}
3870	yyInRingConstruction = FALSE;
3871	if (newRingHdl==NULL)
3872	{
3873	MYYERROR("cannot make ring");
3874	}
3875	else
3876	{
3877	rSetHdl(newRingHdl);
3878	}
3879	;}
3880	break;
3881
3882	case 153:
3883
3884	/* Line 1464 of yacc.c */
3885	#line 1320 "grammar.y"
3886	{
3887	const char *ring_name = (yyvsp[(2) - (2)].lv).name;
3888	if (!inerror) rDefault(ring_name);
3889	yyInRingConstruction = FALSE;
3890	(yyvsp[(2) - (2)].lv).CleanUp();
3891	;}
3892	break;
3893
3894	case 154:
3895
3896	/* Line 1464 of yacc.c */
3897	#line 1327 "grammar.y"
3898	{
3899	yyInRingConstruction = FALSE;
3900	if (iiAssignCR(&(yyvsp[(2) - (4)].lv),&(yyvsp[(4) - (4)].lv))) YYERROR;
3901	;}
3902	break;
3903
3904	case 155:
3905
3906	/* Line 1464 of yacc.c */
3907	#line 1332 "grammar.y"
3908	{
3909	yyInRingConstruction = FALSE;
3910	sleftv tmp;
3911	(yyvsp[(4) - (7)].lv).next=(leftv)omAlloc(sizeof(sleftv));
3912	memcpy((yyvsp[(4) - (7)].lv).next,&(yyvsp[(6) - (7)].lv),sizeof(sleftv));
3913	memset(&(yyvsp[(6) - (7)].lv),0,sizeof(sleftv));
3914	if (iiExprArithM(&tmp,&(yyvsp[(4) - (7)].lv),'[')) YYERROR;
3915	if (iiAssignCR(&(yyvsp[(2) - (7)].lv),&tmp)) YYERROR;
3916	;}
3917	break;
3918
3919	case 156:
3920
3921	/* Line 1464 of yacc.c */
3922	#line 1345 "grammar.y"
3923	{
3924	if (((yyvsp[(1) - (2)].i)!=LIB_CMD)\|\|(jjLOAD((yyvsp[(2) - (2)].name),TRUE))) YYERROR;
3925	;}
3926	break;
3927
3928	case 159:
3929
3930	/* Line 1464 of yacc.c */
3931	#line 1354 "grammar.y"
3932	{
3933	if (((yyvsp[(1) - (2)].i)==KEEPRING_CMD) && (myynest==0))
3934	MYYERROR("only inside a proc allowed");
3935	const char * n=(yyvsp[(2) - (2)].lv).Name();
3936	if (((yyvsp[(2) - (2)].lv).Typ()==RING_CMD)
3937	&& ((yyvsp[(2) - (2)].lv).rtyp==IDHDL))
3938	{
3939	idhdl h=(idhdl)(yyvsp[(2) - (2)].lv).data;
3940	if ((yyvsp[(2) - (2)].lv).e!=NULL) h=rFindHdl((ring)(yyvsp[(2) - (2)].lv).Data(),NULL);
3941	//Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
3942	if ((yyvsp[(1) - (2)].i)==KEEPRING_CMD)
3943	{
3944	if (h!=NULL)
3945	{
3946	if (IDLEV(h)!=0)
3947	{
3948	if (iiExport(&(yyvsp[(2) - (2)].lv),myynest-1)) YYERROR;
3949	#if 1
3950	idhdl p=IDRING(h)->idroot;
3951	idhdl root=p;
3952	int prevlev=myynest-1;
3953	while (p!=NULL)
3954	{
3955	if (IDLEV(p)==myynest)
3956	{
3957	idhdl old=root->get(IDID(p),prevlev);
3958	if (old!=NULL)
3959	{
3960	if (BVERBOSE(V_REDEFINE))
3961	Warn("redefining %s",IDID(p));
3962	killhdl2(old,&root,IDRING(h));
3963	IDRING(h)->idroot=root;
3964	}
3965	IDLEV(p)=prevlev;
3966	}
3967	p=IDNEXT(p);
3968	}
3969	#endif
3970	}
3971	iiLocalRing[myynest-1]=IDRING(h);
3972	}
3973	else
3974	{
3975	Werror("%s is no identifier",n);
3976	(yyvsp[(2) - (2)].lv).CleanUp();
3977	YYERROR;
3978	}
3979	}
3980	if (h!=NULL) rSetHdl(h);
3981	else
3982	{
3983	Werror("cannot find the name of the basering %s",n);
3984	(yyvsp[(2) - (2)].lv).CleanUp();
3985	YYERROR;
3986	}
3987	(yyvsp[(2) - (2)].lv).CleanUp();
3988	}
3989	else
3990	{
3991	Werror("%s is no name of a ring/qring",n);
3992	(yyvsp[(2) - (2)].lv).CleanUp();
3993	YYERROR;
3994	}
3995	;}
3996	break;
3997
3998	case 160:
3999
4000	/* Line 1464 of yacc.c */
4001	#line 1422 "grammar.y"
4002	{
4003	type_cmd(&((yyvsp[(2) - (2)].lv)));
4004	;}
4005	break;
4006
4007	case 161:
4008
4009	/* Line 1464 of yacc.c */
4010	#line 1426 "grammar.y"
4011	{
4012	//Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
4013	#ifdef SIQ
4014	if ((yyvsp[(1) - (1)].lv).rtyp!=COMMAND)
4015	{
4016	#endif
4017	if ((yyvsp[(1) - (1)].lv).Typ()==UNKNOWN)
4018	{
4019	if ((yyvsp[(1) - (1)].lv).name!=NULL)
4020	{
4021	Werror("`%s` is undefined",(yyvsp[(1) - (1)].lv).name);
4022	omFree((ADDRESS)(yyvsp[(1) - (1)].lv).name);
4023	}
4024	YYERROR;
4025	}
4026	#ifdef SIQ
4027	}
4028	#endif
4029	(yyvsp[(1) - (1)].lv).Print(&sLastPrinted);
4030	(yyvsp[(1) - (1)].lv).CleanUp(currRing);
4031	if (errorreported) YYERROR;
4032	;}
4033	break;
4034
4035	case 162:
4036
4037	/* Line 1464 of yacc.c */
4038	#line 1455 "grammar.y"
4039	{
4040	int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4041	if (i!=0)
4042	{
4043	newBuffer( (yyvsp[(5) - (5)].name), BT_if);
4044	}
4045	else
4046	{
4047	omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4048	currentVoice->ifsw=1;
4049	}
4050	;}
4051	break;
4052
4053	case 163:
4054
4055	/* Line 1464 of yacc.c */
4056	#line 1468 "grammar.y"
4057	{
4058	if (currentVoice->ifsw==1)
4059	{
4060	currentVoice->ifsw=0;
4061	newBuffer( (yyvsp[(2) - (2)].name), BT_else);
4062	}
4063	else
4064	{
4065	if (currentVoice->ifsw!=2)
4066	{
4067	Warn("`else` without `if` in level %d",myynest);
4068	}
4069	omFree((ADDRESS)(yyvsp[(2) - (2)].name));
4070	}
4071	currentVoice->ifsw=0;
4072	;}
4073	break;
4074
4075	case 164:
4076
4077	/* Line 1464 of yacc.c */
4078	#line 1485 "grammar.y"
4079	{
4080	int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4081	if (i)
4082	{
4083	if (exitBuffer(BT_break)) YYERROR;
4084	}
4085	currentVoice->ifsw=0;
4086	;}
4087	break;
4088
4089	case 165:
4090
4091	/* Line 1464 of yacc.c */
4092	#line 1494 "grammar.y"
4093	{
4094	if (exitBuffer(BT_break)) YYERROR;
4095	currentVoice->ifsw=0;
4096	;}
4097	break;
4098
4099	case 166:
4100
4101	/* Line 1464 of yacc.c */
4102	#line 1499 "grammar.y"
4103	{
4104	if (contBuffer(BT_break)) YYERROR;
4105	currentVoice->ifsw=0;
4106	;}
4107	break;
4108
4109	case 167:
4110
4111	/* Line 1464 of yacc.c */
4112	#line 1507 "grammar.y"
4113	{
4114	/* -> if(!$2) break; $3; continue;*/
4115	char * s = (char *)omAlloc( strlen((yyvsp[(2) - (3)].name)) + strlen((yyvsp[(3) - (3)].name)) + 36);
4116	sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,(yyvsp[(2) - (3)].name),(yyvsp[(3) - (3)].name));
4117	newBuffer(s,BT_break);
4118	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4119	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4120	;}
4121	break;
4122
4123	case 168:
4124
4125	/* Line 1464 of yacc.c */
4126	#line 1519 "grammar.y"
4127	{
4128	/* $2 */
4129	/* if (!$3) break; $5; $4; continue; */
4130	char * s = (char *)omAlloc( strlen((yyvsp[(3) - (5)].name))+strlen((yyvsp[(4) - (5)].name))+strlen((yyvsp[(5) - (5)].name))+36);
4131	sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
4132	,(yyvsp[(3) - (5)].name),(yyvsp[(5) - (5)].name),(yyvsp[(4) - (5)].name));
4133	omFree((ADDRESS)(yyvsp[(3) - (5)].name));
4134	omFree((ADDRESS)(yyvsp[(4) - (5)].name));
4135	omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4136	newBuffer(s,BT_break);
4137	s = (char *)omAlloc( strlen((yyvsp[(2) - (5)].name)) + 3);
4138	sprintf(s,"%s;\n",(yyvsp[(2) - (5)].name));
4139	omFree((ADDRESS)(yyvsp[(2) - (5)].name));
4140	newBuffer(s,BT_if);
4141	;}
4142	break;
4143
4144	case 169:
4145
4146	/* Line 1464 of yacc.c */
4147	#line 1538 "grammar.y"
4148	{
4149	idhdl h = enterid((yyvsp[(2) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4150	if (h==NULL) {omFree((ADDRESS)(yyvsp[(2) - (3)].name));omFree((ADDRESS)(yyvsp[(3) - (3)].name)); YYERROR;}
4151	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(2) - (3)].name), 0, 0);
4152	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+31);;
4153	sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",(yyvsp[(3) - (3)].name));
4154	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4155	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4156	;}
4157	break;
4158
4159	case 170:
4160
4161	/* Line 1464 of yacc.c */
4162	#line 1548 "grammar.y"
4163	{
4164	idhdl h = enterid((yyvsp[(1) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4165	if (h==NULL)
4166	{
4167	omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4168	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4169	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4170	YYERROR;
4171	}
4172	char *args=iiProcArgs((yyvsp[(2) - (3)].name),FALSE);
4173	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4174	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (3)].name), 0, 0);
4175	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+strlen(args)+14);;
4176	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(3) - (3)].name));
4177	omFree((ADDRESS)args);
4178	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4179	omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4180	;}
4181	break;
4182
4183	case 171:
4184
4185	/* Line 1464 of yacc.c */
4186	#line 1567 "grammar.y"
4187	{
4188	omFree((ADDRESS)(yyvsp[(3) - (4)].name));
4189	idhdl h = enterid((yyvsp[(1) - (4)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4190	if (h==NULL)
4191	{
4192	omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4193	omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4194	omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4195	YYERROR;
4196	}
4197	char *args=iiProcArgs((yyvsp[(2) - (4)].name),FALSE);
4198	omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4199	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (4)].name), 0, 0);
4200	omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4201	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(4) - (4)].name))+strlen(args)+14);;
4202	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(4) - (4)].name));
4203	omFree((ADDRESS)args);
4204	omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4205	;}
4206	break;
4207
4208	case 172:
4209
4210	/* Line 1464 of yacc.c */
4211	#line 1590 "grammar.y"
4212	{
4213	// decl. of type proc p(int i)
4214	if ((yyvsp[(1) - (2)].i)==PARAMETER) { if (iiParameter(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4215	else { if (iiAlias(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4216	;}
4217	break;
4218
4219	case 173:
4220
4221	/* Line 1464 of yacc.c */
4222	#line 1596 "grammar.y"
4223	{
4224	// decl. of type proc p(i)
4225	sleftv tmp_expr;
4226	if ((yyvsp[(1) - (2)].i)==ALIAS_CMD) MYYERROR("alias requires a type");
4227	if ((iiDeclCommand(&tmp_expr,&(yyvsp[(2) - (2)].lv),myynest,DEF_CMD,&IDROOT))
4228	\|\| (iiParameter(&tmp_expr)))
4229	YYERROR;
4230	;}
4231	break;
4232
4233	case 174:
4234
4235	/* Line 1464 of yacc.c */
4236	#line 1608 "grammar.y"
4237	{
4238	iiRETURNEXPR.Copy(&(yyvsp[(3) - (4)].lv));
4239	(yyvsp[(3) - (4)].lv).CleanUp();
4240	if (exitBuffer(BT_proc)) YYERROR;
4241	;}
4242	break;
4243
4244	case 175:
4245
4246	/* Line 1464 of yacc.c */
4247	#line 1614 "grammar.y"
4248	{
4249	if ((yyvsp[(1) - (3)].i)==RETURN)
4250	{
4251	iiRETURNEXPR.Init();
4252	iiRETURNEXPR.rtyp=NONE;
4253	if (exitBuffer(BT_proc)) YYERROR;
4254	}
4255	;}
4256	break;
4257
4258
4259
4260	/* Line 1464 of yacc.c */
4261	#line 4262 "grammar.cc"
4262	default: break;
4263	}
4264	YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4265
4266	YYPOPSTACK (yylen);
4267	yylen = 0;
4268	YY_STACK_PRINT (yyss, yyssp);
4269
4270	*++yyvsp = yyval;
4271
4272	/* Now `shift' the result of the reduction. Determine what state
4273	that goes to, based on the state we popped back to and the rule
4274	number reduced by. */
4275
4276	yyn = yyr1[yyn];
4277
4278	yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4279	if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4280	yystate = yytable[yystate];
4281	else
4282	yystate = yydefgoto[yyn - YYNTOKENS];
4283
4284	goto yynewstate;
4285
4286
4287	/*------------------------------------.
4288	\| yyerrlab -- here on detecting error \|
4289	`------------------------------------*/
4290	yyerrlab:
4291	/* If not already recovering from an error, report this error. */
4292	if (!yyerrstatus)
4293	{
4294	++yynerrs;
4295	#if ! YYERROR_VERBOSE
4296	yyerror (YY_("syntax error"));
4297	#else
4298	{
4299	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
4300	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
4301	{
4302	YYSIZE_T yyalloc = 2 * yysize;
4303	if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
4304	yyalloc = YYSTACK_ALLOC_MAXIMUM;
4305	if (yymsg != yymsgbuf)
4306	YYSTACK_FREE (yymsg);
4307	yymsg = (char *) YYSTACK_ALLOC (yyalloc);
4308	if (yymsg)
4309	yymsg_alloc = yyalloc;
4310	else
4311	{
4312	yymsg = yymsgbuf;
4313	yymsg_alloc = sizeof yymsgbuf;
4314	}
4315	}
4316
4317	if (0 < yysize && yysize <= yymsg_alloc)
4318	{
4319	(void) yysyntax_error (yymsg, yystate, yychar);
4320	yyerror (yymsg);
4321	}
4322	else
4323	{
4324	yyerror (YY_("syntax error"));
4325	if (yysize != 0)
4326	goto yyexhaustedlab;
4327	}
4328	}
4329	#endif
4330	}
4331
4332
4333
4334	if (yyerrstatus == 3)
4335	{
4336	/* If just tried and failed to reuse lookahead token after an
4337	error, discard it. */
4338
4339	if (yychar <= YYEOF)
4340	{
4341	/* Return failure if at end of input. */
4342	if (yychar == YYEOF)
4343	YYABORT;
4344	}
4345	else
4346	{
4347	yydestruct ("Error: discarding",
4348	yytoken, &yylval);
4349	yychar = YYEMPTY;
4350	}
4351	}
4352
4353	/* Else will try to reuse lookahead token after shifting the error
4354	token. */
4355	goto yyerrlab1;
4356
4357
4358	/*---------------------------------------------------.
4359	\| yyerrorlab -- error raised explicitly by YYERROR. \|
4360	`---------------------------------------------------*/
4361	yyerrorlab:
4362
4363	/* Pacify compilers like GCC when the user code never invokes
4364	YYERROR and the label yyerrorlab therefore never appears in user
4365	code. */
4366	if (/CONSTCOND/ 0)
4367	goto yyerrorlab;
4368
4369	/* Do not reclaim the symbols of the rule which action triggered
4370	this YYERROR. */
4371	YYPOPSTACK (yylen);
4372	yylen = 0;
4373	YY_STACK_PRINT (yyss, yyssp);
4374	yystate = *yyssp;
4375	goto yyerrlab1;
4376
4377
4378	/*-------------------------------------------------------------.
4379	\| yyerrlab1 -- common code for both syntax error and YYERROR. \|
4380	`-------------------------------------------------------------*/
4381	yyerrlab1:
4382	yyerrstatus = 3; /* Each real token shifted decrements this. */
4383
4384	for (;;)
4385	{
4386	yyn = yypact[yystate];
4387	if (yyn != YYPACT_NINF)
4388	{
4389	yyn += YYTERROR;
4390	if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4391	{
4392	yyn = yytable[yyn];
4393	if (0 < yyn)
4394	break;
4395	}
4396	}
4397
4398	/* Pop the current state because it cannot handle the error token. */
4399	if (yyssp == yyss)
4400	YYABORT;
4401
4402
4403	yydestruct ("Error: popping",
4404	yystos[yystate], yyvsp);
4405	YYPOPSTACK (1);
4406	yystate = *yyssp;
4407	YY_STACK_PRINT (yyss, yyssp);
4408	}
4409
4410	*++yyvsp = yylval;
4411
4412
4413	/* Shift the error token. */
4414	YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4415
4416	yystate = yyn;
4417	goto yynewstate;
4418
4419
4420	/*-------------------------------------.
4421	\| yyacceptlab -- YYACCEPT comes here. \|
4422	`-------------------------------------*/
4423	yyacceptlab:
4424	yyresult = 0;
4425	goto yyreturn;
4426
4427	/*-----------------------------------.
4428	\| yyabortlab -- YYABORT comes here. \|
4429	`-----------------------------------*/
4430	yyabortlab:
4431	yyresult = 1;
4432	goto yyreturn;
4433
4434	#if !defined(yyoverflow) \|\| YYERROR_VERBOSE
4435	/*-------------------------------------------------.
4436	\| yyexhaustedlab -- memory exhaustion comes here. \|
4437	`-------------------------------------------------*/
4438	yyexhaustedlab:
4439	yyerror (YY_("memory exhausted"));
4440	yyresult = 2;
4441	/* Fall through. */
4442	#endif
4443
4444	yyreturn:
4445	if (yychar != YYEMPTY)
4446	yydestruct ("Cleanup: discarding lookahead",
4447	yytoken, &yylval);
4448	/* Do not reclaim the symbols of the rule which action triggered
4449	this YYABORT or YYACCEPT. */
4450	YYPOPSTACK (yylen);
4451	YY_STACK_PRINT (yyss, yyssp);
4452	while (yyssp != yyss)
4453	{
4454	yydestruct ("Cleanup: popping",
4455	yystos[*yyssp], yyvsp);
4456	YYPOPSTACK (1);
4457	}
4458	#ifndef yyoverflow
4459	if (yyss != yyssa)
4460	YYSTACK_FREE (yyss);
4461	#endif
4462	#if YYERROR_VERBOSE
4463	if (yymsg != yymsgbuf)
4464	YYSTACK_FREE (yymsg);
4465	#endif
4466	/* Make sure YYID is used. */
4467	return YYID (yyresult);
4468	}
4469
4470
4471

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

Download in other formats: