Context Navigation

source: git/Singular/grammar.cc @ e024cb6

fieker-DuValspielwiese

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

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

Download in other formats: