Context Navigation

source: git/Singular/grammar.cc @ 84fc1f

spielwiese

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

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

Download in other formats: