Context Navigation

source: git/Singular/grammar.cc @ f263b5

fieker-DuValspielwiese

Last change on this file since f263b5 was f263b5, checked in by Hans Schoenemann <hannes@…>, 7 years ago
add: multi-indices p(1,1,2,3,4)
Property mode set to `100644`
File size: 148.7 KB

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

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

Download in other formats: