Context Navigation

source: git/Singular/grammar.cc @ a3f0fea

spielwiese

Last change on this file since a3f0fea was a3f0fea, checked in by Reimer Behrends <behrends@…>, 5 years ago
Modify variable declarions for pSingular.
Property mode set to `100644`
File size: 148.7 KB

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

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

Download in other formats: