Context Navigation

source: git/Singular/grammar.cc @ 37dc41

spielwiese

Last change on this file since 37dc41 was 37dc41, checked in by Hans Schoenemann <hannes@…>, 13 years ago
x(i)(j) fixed git-svn-id: file:///usr/local/Singular/svn/trunk@13757 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 135.2 KB

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

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

Download in other formats: