Context Navigation

source: git/Singular/grammar.cc @ 762407

spielwiese

Last change on this file since 762407 was 762407, checked in by Oleksandr Motsak <motsak@…>, 12 years ago
config.h is for sources files only FIX: config.h should only be used by source (not from inside kernel/mod2.h!) NOTE: each source file should better include mod2.h right after config.h, while headers should better not include mod2.h.
Property mode set to `100644`
File size: 125.8 KB

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

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

Download in other formats: