Context Navigation

source: git/Singular/grammar.cc @ 0f36a0

fieker-DuValspielwiese

Last change on this file since 0f36a0 was 0f36a0, checked in by Hans Schoenemann <hannes@…>, 8 years ago
chg: remove LIB as SYSVAR
Property mode set to `100644`
File size: 149.1 KB

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

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

Download in other formats: