Context Navigation

source: git/Singular/grammar.cc @ 71e2bd

fieker-DuValspielwiese

Last change on this file since 71e2bd was 71e2bd, checked in by Hans Schoenemann <hannes@…>, 7 years ago
fix: memory leak in ->
Property mode set to `100644`
File size: 149.1 KB

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

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

Download in other formats: