Context Navigation

source: git/Singular/grammar.cc @ bee06d

spielwiese

Last change on this file since bee06d was 4b889d, checked in by Hans Schoenemann <hannes@…>, 14 years ago
RTIMER simplification git-svn-id: file:///usr/local/Singular/svn/trunk@13480 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 135.5 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 544 "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, 370, 370, 372, 408, 409, 411, 413, 417, 422,
907	424, 472, 473, 474, 475, 476, 477, 478, 479, 483,
908	486, 487, 488, 489, 490, 491, 492, 493, 494, 497,
909	504, 509, 513, 517, 521, 541, 569, 593, 599, 608,
910	619, 625, 630, 631, 632, 636, 640, 644, 648, 652,
911	656, 660, 664, 668, 672, 676, 680, 684, 688, 692,
912	696, 700, 704, 708, 712, 716, 720, 724, 728, 732,
913	736, 740, 744, 748, 766, 765, 783, 791, 800, 804,
914	808, 812, 816, 820, 824, 828, 832, 836, 840, 844,
915	848, 855, 862, 863, 882, 883, 895, 895, 900, 905,
916	910, 914, 918, 934, 938, 954, 968, 989, 997, 1001,
917	1002, 1016, 1024, 1033, 1078, 1079, 1088, 1089, 1095, 1108,
918	1107, 1115, 1120, 1127, 1135, 1147, 1163, 1182, 1186, 1190,
919	1195, 1199, 1203, 1207, 1211, 1215, 1220, 1226, 1232, 1238,
920	1244, 1250, 1256, 1262, 1274, 1281, 1285, 1323, 1333, 1346,
921	1346, 1349, 1421, 1427, 1456, 1469, 1486, 1495, 1500, 1508,
922	1520, 1539, 1550, 1570, 1594, 1600, 1612, 1619
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 373 "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 410 "grammar.y"
2406	{currentVoice->ifsw=0;;}
2407	break;
2408
2409	case 6:
2410	#line 412 "grammar.y"
2411	{ (yyvsp[(1) - (2)].lv).CleanUp(); currentVoice->ifsw=0;;}
2412	break;
2413
2414	case 7:
2415	#line 414 "grammar.y"
2416	{
2417	YYACCEPT;
2418	;}
2419	break;
2420
2421	case 8:
2422	#line 418 "grammar.y"
2423	{
2424	currentVoice->ifsw=0;
2425	iiDebug();
2426	;}
2427	break;
2428
2429	case 9:
2430	#line 423 "grammar.y"
2431	{currentVoice->ifsw=0;;}
2432	break;
2433
2434	case 10:
2435	#line 425 "grammar.y"
2436	{
2437	#ifdef SIQ
2438	siq=0;
2439	#endif
2440	yyInRingConstruction = FALSE;
2441	currentVoice->ifsw=0;
2442	if (inerror)
2443	{
2444	if ((inerror!=3) && ((yyvsp[(1) - (2)]).i<UMINUS) && ((yyvsp[(1) - (2)]).i>' '))
2445	{
2446	// 1: yyerror called
2447	// 2: scanner put actual string
2448	// 3: error rule put token+\n
2449	inerror=3;
2450	Print(" error at token `%s`\n",iiTwoOps((yyvsp[(1) - (2)]).i));
2451	}
2452	}
2453	if (!errorreported) WerrorS("...parse error");
2454	yyerror("");
2455	yyerrok;
2456	#ifdef HAVE_SDB
2457	if ((sdb_flags & 1) && currentVoice->pi!=NULL)
2458	{
2459	currentVoice->pi->trace_flag \|=1;
2460	}
2461	else
2462	#endif
2463	if (myynest>0)
2464	{
2465	feBufferTypes t=currentVoice->Typ();
2466	//PrintS("leaving yyparse\n");
2467	exitBuffer(BT_proc);
2468	if (t==BT_example)
2469	YYACCEPT;
2470	else
2471	YYABORT;
2472	}
2473	else if (currentVoice->prev!=NULL)
2474	{
2475	exitVoice();
2476	}
2477	#ifdef HAVE_SDB
2478	if (sdb_flags &2) sdb_flags=1;
2479	#endif
2480	;}
2481	break;
2482
2483	case 18:
2484	#line 480 "grammar.y"
2485	{if (currentVoice!=NULL) currentVoice->ifsw=0;;}
2486	break;
2487
2488	case 19:
2489	#line 483 "grammar.y"
2490	{ omFree((ADDRESS)(yyvsp[(2) - (2)].name)); ;}
2491	break;
2492
2493	case 29:
2494	#line 498 "grammar.y"
2495	{
2496	if(iiAssign(&(yyvsp[(1) - (2)].lv),&(yyvsp[(2) - (2)].lv))) YYERROR;
2497	;}
2498	break;
2499
2500	case 30:
2501	#line 505 "grammar.y"
2502	{
2503	if (currRing==NULL) MYYERROR("no ring active");
2504	syMake(&(yyval.lv),omStrDup((yyvsp[(1) - (1)].name)));
2505	;}
2506	break;
2507
2508	case 31:
2509	#line 510 "grammar.y"
2510	{
2511	syMake(&(yyval.lv),(yyvsp[(1) - (1)].name));
2512	;}
2513	break;
2514
2515	case 32:
2516	#line 514 "grammar.y"
2517	{
2518	if(iiExprArith2(&(yyval.lv), &(yyvsp[(1) - (3)].lv), COLONCOLON, &(yyvsp[(3) - (3)].lv))) YYERROR;
2519	;}
2520	break;
2521
2522	case 33:
2523	#line 518 "grammar.y"
2524	{
2525	if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'(')) YYERROR;
2526	;}
2527	break;
2528
2529	case 34:
2530	#line 522 "grammar.y"
2531	{
2532	if ((yyvsp[(1) - (4)].lv).rtyp==LIB_CMD)
2533	{
2534	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),LIB_CMD)) YYERROR;
2535	}
2536	else
2537	{
2538	if ((yyvsp[(1) - (4)].lv).Typ()==UNKNOWN)
2539	{
2540	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'(',&(yyvsp[(3) - (4)].lv))) YYERROR;
2541	}
2542	else
2543	{
2544	(yyvsp[(1) - (4)].lv).next=(leftv)omAllocBin(sleftv_bin);
2545	memcpy((yyvsp[(1) - (4)].lv).next,&(yyvsp[(3) - (4)].lv),sizeof(sleftv));
2546	if(iiExprArithM(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'(')) YYERROR;
2547	}
2548	}
2549	;}
2550	break;
2551
2552	case 35:
2553	#line 542 "grammar.y"
2554	{
2555	if (currRingHdl==NULL) MYYERROR("no ring active");
2556	int j = 0;
2557	memset(&(yyval.lv),0,sizeof(sleftv));
2558	(yyval.lv).rtyp=VECTOR_CMD;
2559	leftv v = &(yyvsp[(2) - (3)].lv);
2560	while (v!=NULL)
2561	{
2562	int i,t;
2563	sleftv tmp;
2564	memset(&tmp,0,sizeof(tmp));
2565	i=iiTestConvert((t=v->Typ()),POLY_CMD);
2566	if((i==0) \|\| (iiConvert(t /v->Typ()/,POLY_CMD,i,v,&tmp)))
2567	{
2568	pDelete((poly *)&(yyval.lv).data);
2569	(yyvsp[(2) - (3)].lv).CleanUp();
2570	MYYERROR("expected '[poly,...'");
2571	}
2572	poly p = (poly)tmp.CopyD(POLY_CMD);
2573	pSetCompP(p,++j);
2574	(yyval.lv).data = (void *)pAdd((poly)(yyval.lv).data,p);
2575	v->next=tmp.next;tmp.next=NULL;
2576	tmp.CleanUp();
2577	v=v->next;
2578	}
2579	(yyvsp[(2) - (3)].lv).CleanUp();
2580	;}
2581	break;
2582
2583	case 36:
2584	#line 570 "grammar.y"
2585	{
2586	memset(&(yyval.lv),0,sizeof((yyval.lv)));
2587	int i = atoi((yyvsp[(1) - (1)].name));
2588	/*remember not to omFree($1)
2589	because it is a part of the scanner buffer/
2590	(yyval.lv).rtyp = INT_CMD;
2591	(yyval.lv).data = (void *)(long)i;
2592
2593	/* check: out of range input */
2594	int l = strlen((yyvsp[(1) - (1)].name))+2;
2595	number n;
2596	if (l >= MAX_INT_LEN)
2597	{
2598	char tmp[MAX_INT_LEN+5];
2599	sprintf(tmp,"%d",i);
2600	if (strcmp(tmp,(yyvsp[(1) - (1)].name))!=0)
2601	{
2602	nlRead((yyvsp[(1) - (1)].name),&n);
2603	(yyval.lv).rtyp=BIGINT_CMD;
2604	(yyval.lv).data = n;
2605	}
2606	}
2607	;}
2608	break;
2609
2610	case 37:
2611	#line 594 "grammar.y"
2612	{
2613	memset(&(yyval.lv),0,sizeof((yyval.lv)));
2614	(yyval.lv).rtyp = (yyvsp[(1) - (1)].i);
2615	(yyval.lv).data = (yyval.lv).Data();
2616	;}
2617	break;
2618
2619	case 38:
2620	#line 600 "grammar.y"
2621	{
2622	memset(&(yyval.lv),0,sizeof((yyval.lv)));
2623	(yyval.lv).rtyp = STRING_CMD;
2624	(yyval.lv).data = (yyvsp[(1) - (1)].name);
2625	;}
2626	break;
2627
2628	case 39:
2629	#line 609 "grammar.y"
2630	{
2631	leftv v = &(yyvsp[(1) - (3)].lv);
2632	while (v->next!=NULL)
2633	{
2634	v=v->next;
2635	}
2636	v->next = (leftv)omAllocBin(sleftv_bin);
2637	memcpy(v->next,&((yyvsp[(3) - (3)].lv)),sizeof(sleftv));
2638	(yyval.lv) = (yyvsp[(1) - (3)].lv);
2639	;}
2640	break;
2641
2642	case 40:
2643	#line 620 "grammar.y"
2644	{
2645	(yyval.lv) = (yyvsp[(1) - (1)].lv);
2646	;}
2647	break;
2648
2649	case 41:
2650	#line 626 "grammar.y"
2651	{
2652	/if ($1.typ == eunknown) YYERROR;/
2653	(yyval.lv) = (yyvsp[(1) - (1)].lv);
2654	;}
2655	break;
2656
2657	case 42:
2658	#line 630 "grammar.y"
2659	{ (yyval.lv) = (yyvsp[(1) - (1)].lv); ;}
2660	break;
2661
2662	case 43:
2663	#line 631 "grammar.y"
2664	{ (yyval.lv) = (yyvsp[(2) - (3)].lv); ;}
2665	break;
2666
2667	case 44:
2668	#line 633 "grammar.y"
2669	{
2670	if(iiExprArith3(&(yyval.lv),'[',&(yyvsp[(1) - (6)].lv),&(yyvsp[(3) - (6)].lv),&(yyvsp[(5) - (6)].lv))) YYERROR;
2671	;}
2672	break;
2673
2674	case 45:
2675	#line 637 "grammar.y"
2676	{
2677	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'[',&(yyvsp[(3) - (4)].lv))) YYERROR;
2678	;}
2679	break;
2680
2681	case 46:
2682	#line 641 "grammar.y"
2683	{
2684	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2685	;}
2686	break;
2687
2688	case 47:
2689	#line 645 "grammar.y"
2690	{
2691	if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2692	;}
2693	break;
2694
2695	case 48:
2696	#line 649 "grammar.y"
2697	{
2698	if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2699	;}
2700	break;
2701
2702	case 49:
2703	#line 653 "grammar.y"
2704	{
2705	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2706	;}
2707	break;
2708
2709	case 50:
2710	#line 657 "grammar.y"
2711	{
2712	if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2713	;}
2714	break;
2715
2716	case 51:
2717	#line 661 "grammar.y"
2718	{
2719	if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2720	;}
2721	break;
2722
2723	case 52:
2724	#line 665 "grammar.y"
2725	{
2726	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2727	;}
2728	break;
2729
2730	case 53:
2731	#line 669 "grammar.y"
2732	{
2733	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2734	;}
2735	break;
2736
2737	case 54:
2738	#line 673 "grammar.y"
2739	{
2740	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2741	;}
2742	break;
2743
2744	case 55:
2745	#line 677 "grammar.y"
2746	{
2747	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2748	;}
2749	break;
2750
2751	case 56:
2752	#line 681 "grammar.y"
2753	{
2754	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2755	;}
2756	break;
2757
2758	case 57:
2759	#line 685 "grammar.y"
2760	{
2761	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2762	;}
2763	break;
2764
2765	case 58:
2766	#line 689 "grammar.y"
2767	{
2768	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2769	;}
2770	break;
2771
2772	case 59:
2773	#line 693 "grammar.y"
2774	{
2775	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2776	;}
2777	break;
2778
2779	case 60:
2780	#line 697 "grammar.y"
2781	{
2782	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2783	;}
2784	break;
2785
2786	case 61:
2787	#line 701 "grammar.y"
2788	{
2789	if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2790	;}
2791	break;
2792
2793	case 62:
2794	#line 705 "grammar.y"
2795	{
2796	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2797	;}
2798	break;
2799
2800	case 63:
2801	#line 709 "grammar.y"
2802	{
2803	if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2804	;}
2805	break;
2806
2807	case 64:
2808	#line 713 "grammar.y"
2809	{
2810	if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2811	;}
2812	break;
2813
2814	case 65:
2815	#line 717 "grammar.y"
2816	{
2817	if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2818	;}
2819	break;
2820
2821	case 66:
2822	#line 721 "grammar.y"
2823	{
2824	if(iiExprArith3(&(yyval.lv),MATRIX_CMD,&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2825	;}
2826	break;
2827
2828	case 67:
2829	#line 725 "grammar.y"
2830	{
2831	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),MATRIX_CMD)) YYERROR;
2832	;}
2833	break;
2834
2835	case 68:
2836	#line 729 "grammar.y"
2837	{
2838	if(iiExprArith3(&(yyval.lv),INTMAT_CMD,&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2839	;}
2840	break;
2841
2842	case 69:
2843	#line 733 "grammar.y"
2844	{
2845	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),INTMAT_CMD)) YYERROR;
2846	;}
2847	break;
2848
2849	case 70:
2850	#line 737 "grammar.y"
2851	{
2852	if(iiExprArith3(&(yyval.lv),RING_CMD,&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2853	;}
2854	break;
2855
2856	case 71:
2857	#line 741 "grammar.y"
2858	{
2859	if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),RING_CMD)) YYERROR;
2860	;}
2861	break;
2862
2863	case 72:
2864	#line 745 "grammar.y"
2865	{
2866	(yyval.lv)=(yyvsp[(2) - (3)].lv);
2867	;}
2868	break;
2869
2870	case 73:
2871	#line 749 "grammar.y"
2872	{
2873	#ifdef SIQ
2874	siq++;
2875	if (siq>0)
2876	{ if (iiExprArith2(&(yyval.lv),&(yyvsp[(2) - (5)].lv),'=',&(yyvsp[(4) - (5)].lv))) YYERROR; }
2877	else
2878	#endif
2879	{
2880	memset(&(yyval.lv),0,sizeof((yyval.lv)));
2881	(yyval.lv).rtyp=NONE;
2882	if (iiAssign(&(yyvsp[(2) - (5)].lv),&(yyvsp[(4) - (5)].lv))) YYERROR;
2883	}
2884	#ifdef SIQ
2885	siq--;
2886	#endif
2887	;}
2888	break;
2889
2890	case 74:
2891	#line 766 "grammar.y"
2892	{
2893	#ifdef SIQ
2894	siq--;
2895	#endif
2896	;}
2897	break;
2898
2899	case 75:
2900	#line 772 "grammar.y"
2901	{
2902	#ifdef SIQ
2903	if (siq<=0) (yyvsp[(4) - (5)].lv).Eval();
2904	#endif
2905	(yyval.lv)=(yyvsp[(4) - (5)].lv);
2906	#ifdef SIQ
2907	siq++;
2908	#endif
2909	;}
2910	break;
2911
2912	case 76:
2913	#line 784 "grammar.y"
2914	{
2915	#ifdef SIQ
2916	siq++;
2917	#endif
2918	;}
2919	break;
2920
2921	case 77:
2922	#line 792 "grammar.y"
2923	{
2924	#ifdef SIQ
2925	siq--;
2926	#endif
2927	;}
2928	break;
2929
2930	case 78:
2931	#line 801 "grammar.y"
2932	{
2933	if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),PLUSPLUS)) YYERROR;
2934	;}
2935	break;
2936
2937	case 79:
2938	#line 805 "grammar.y"
2939	{
2940	if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),MINUSMINUS)) YYERROR;
2941	;}
2942	break;
2943
2944	case 80:
2945	#line 809 "grammar.y"
2946	{
2947	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'+',&(yyvsp[(3) - (3)].lv))) YYERROR;
2948	;}
2949	break;
2950
2951	case 81:
2952	#line 813 "grammar.y"
2953	{
2954	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'-',&(yyvsp[(3) - (3)].lv))) YYERROR;
2955	;}
2956	break;
2957
2958	case 82:
2959	#line 817 "grammar.y"
2960	{
2961	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
2962	;}
2963	break;
2964
2965	case 83:
2966	#line 821 "grammar.y"
2967	{
2968	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'^',&(yyvsp[(3) - (3)].lv))) YYERROR;
2969	;}
2970	break;
2971
2972	case 84:
2973	#line 825 "grammar.y"
2974	{
2975	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
2976	;}
2977	break;
2978
2979	case 85:
2980	#line 829 "grammar.y"
2981	{
2982	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
2983	;}
2984	break;
2985
2986	case 86:
2987	#line 833 "grammar.y"
2988	{
2989	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),NOTEQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR;
2990	;}
2991	break;
2992
2993	case 87:
2994	#line 837 "grammar.y"
2995	{
2996	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),EQUAL_EQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR;
2997	;}
2998	break;
2999
3000	case 88:
3001	#line 841 "grammar.y"
3002	{
3003	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),DOTDOT,&(yyvsp[(3) - (3)].lv))) YYERROR;
3004	;}
3005	break;
3006
3007	case 89:
3008	#line 845 "grammar.y"
3009	{
3010	if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),':',&(yyvsp[(3) - (3)].lv))) YYERROR;
3011	;}
3012	break;
3013
3014	case 90:
3015	#line 849 "grammar.y"
3016	{
3017	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3018	int i; TESTSETINT((yyvsp[(2) - (2)].lv),i);
3019	(yyval.lv).rtyp = INT_CMD;
3020	(yyval.lv).data = (void *)(long)(i == 0 ? 1 : 0);
3021	;}
3022	break;
3023
3024	case 91:
3025	#line 856 "grammar.y"
3026	{
3027	if(iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),'-')) YYERROR;
3028	;}
3029	break;
3030
3031	case 92:
3032	#line 862 "grammar.y"
3033	{ (yyval.lv) = (yyvsp[(1) - (2)].lv); ;}
3034	break;
3035
3036	case 93:
3037	#line 864 "grammar.y"
3038	{
3039	if ((yyvsp[(1) - (2)].lv).rtyp==0)
3040	{
3041	Werror("`%s` is undefined",(yyvsp[(1) - (2)].lv).Fullname());
3042	YYERROR;
3043	}
3044	else if (((yyvsp[(1) - (2)].lv).rtyp==MODUL_CMD)
3045	// matrix m; m[2]=...
3046	&& ((yyvsp[(1) - (2)].lv).e!=NULL) && ((yyvsp[(1) - (2)].lv).e->next==NULL))
3047	{
3048	MYYERROR("matrix must have 2 indices");
3049	}
3050	(yyval.lv) = (yyvsp[(1) - (2)].lv);
3051	;}
3052	break;
3053
3054	case 95:
3055	#line 884 "grammar.y"
3056	{
3057	if ((yyvsp[(2) - (3)].lv).Typ()!=STRING_CMD)
3058	{
3059	MYYERROR("string expression expected");
3060	}
3061	(yyval.name) = (char *)(yyvsp[(2) - (3)].lv).CopyD(STRING_CMD);
3062	(yyvsp[(2) - (3)].lv).CleanUp();
3063	;}
3064	break;
3065
3066	case 98:
3067	#line 901 "grammar.y"
3068	{
3069	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3070	YYERROR;
3071	;}
3072	break;
3073
3074	case 99:
3075	#line 906 "grammar.y"
3076	{
3077	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3078	YYERROR;
3079	;}
3080	break;
3081
3082	case 100:
3083	#line 911 "grammar.y"
3084	{
3085	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3086	;}
3087	break;
3088
3089	case 101:
3090	#line 915 "grammar.y"
3091	{
3092	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3093	;}
3094	break;
3095
3096	case 102:
3097	#line 919 "grammar.y"
3098	{
3099	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&(currRing->idroot), TRUE)) YYERROR;
3100	int r; TESTSETINT((yyvsp[(4) - (8)].lv),r);
3101	int c; TESTSETINT((yyvsp[(7) - (8)].lv),c);
3102	if (r < 1)
3103	MYYERROR("rows must be greater than 0");
3104	if (c < 0)
3105	MYYERROR("cols must be greater than -1");
3106	leftv v=&(yyval.lv);
3107	//while (v->next!=NULL) { v=v->next; }
3108	idhdl h=(idhdl)v->data;
3109	idDelete(&IDIDEAL(h));
3110	IDMATRIX(h) = mpNew(r,c);
3111	if (IDMATRIX(h)==NULL) YYERROR;
3112	;}
3113	break;
3114
3115	case 103:
3116	#line 935 "grammar.y"
3117	{
3118	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3119	;}
3120	break;
3121
3122	case 104:
3123	#line 939 "grammar.y"
3124	{
3125	int r; TESTSETINT((yyvsp[(4) - (8)].lv),r);
3126	int c; TESTSETINT((yyvsp[(7) - (8)].lv),c);
3127	if (r < 1)
3128	MYYERROR("rows must be greater than 0");
3129	if (c < 0)
3130	MYYERROR("cols must be greater than -1");
3131	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3132	YYERROR;
3133	leftv v=&(yyval.lv);
3134	idhdl h=(idhdl)v->data;
3135	delete IDINTVEC(h);
3136	IDINTVEC(h) = new intvec(r,c,0);
3137	if (IDINTVEC(h)==NULL) YYERROR;
3138	;}
3139	break;
3140
3141	case 105:
3142	#line 955 "grammar.y"
3143	{
3144	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3145	YYERROR;
3146	leftv v=&(yyval.lv);
3147	idhdl h;
3148	do
3149	{
3150	h=(idhdl)v->data;
3151	delete IDINTVEC(h);
3152	IDINTVEC(h) = new intvec(1,1,0);
3153	v=v->next;
3154	} while (v!=NULL);
3155	;}
3156	break;
3157
3158	case 106:
3159	#line 969 "grammar.y"
3160	{
3161	int t=(yyvsp[(1) - (3)].lv).Typ();
3162	sleftv r;
3163	memset(&r,0,sizeof(sleftv));
3164	if ((BEGIN_RING<t) && (t<END_RING))
3165	{
3166	if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&(currRing->idroot), TRUE))
3167	YYERROR;
3168	}
3169	else
3170	{
3171	if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&((yyvsp[(3) - (3)].lv).req_packhdl->idroot)))
3172	YYERROR;
3173	}
3174	leftv v=&(yyvsp[(1) - (3)].lv);
3175	while (v->next!=NULL) v=v->next;
3176	v->next=(leftv)omAllocBin(sleftv_bin);
3177	memcpy(v->next,&r,sizeof(sleftv));
3178	(yyval.lv)=(yyvsp[(1) - (3)].lv);
3179	;}
3180	break;
3181
3182	case 107:
3183	#line 990 "grammar.y"
3184	{
3185	if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3186	YYERROR;
3187	;}
3188	break;
3189
3190	case 110:
3191	#line 1003 "grammar.y"
3192	{
3193	leftv v = &(yyvsp[(2) - (5)].lv);
3194	while (v->next!=NULL)
3195	{
3196	v=v->next;
3197	}
3198	v->next = (leftv)omAllocBin(sleftv_bin);
3199	memcpy(v->next,&((yyvsp[(4) - (5)].lv)),sizeof(sleftv));
3200	(yyval.lv) = (yyvsp[(2) - (5)].lv);
3201	;}
3202	break;
3203
3204	case 111:
3205	#line 1017 "grammar.y"
3206	{
3207	// let rInit take care of any errors
3208	(yyval.i)=rOrderName((yyvsp[(1) - (1)].name));
3209	;}
3210	break;
3211
3212	case 112:
3213	#line 1025 "grammar.y"
3214	{
3215	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3216	intvec *iv = new intvec(2);
3217	(*iv)[0] = 1;
3218	(*iv)[1] = (yyvsp[(1) - (1)].i);
3219	(yyval.lv).rtyp = INTVEC_CMD;
3220	(yyval.lv).data = (void *)iv;
3221	;}
3222	break;
3223
3224	case 113:
3225	#line 1034 "grammar.y"
3226	{
3227	memset(&(yyval.lv),0,sizeof((yyval.lv)));
3228	leftv sl = &(yyvsp[(3) - (4)].lv);
3229	int slLength;
3230	{
3231	slLength = exprlist_length(sl);
3232	int l = 2 + slLength;
3233	intvec *iv = new intvec(l);
3234	(*iv)[0] = slLength;
3235	(*iv)[1] = (yyvsp[(1) - (4)].i);
3236
3237	int i = 2;
3238	while ((i<l) && (sl!=NULL))
3239	{
3240	if (sl->Typ() == INT_CMD)
3241	{
3242	(*iv)[i++] = (int)((long)(sl->Data()));
3243	}
3244	else if ((sl->Typ() == INTVEC_CMD)
3245	\|\|(sl->Typ() == INTMAT_CMD))
3246	{
3247	intvec ivv = (intvec )(sl->Data());
3248	int ll = 0,l = ivv->length();
3249	for (; l>0; l--)
3250	{
3251	(iv)[i++] = (ivv)[ll++];
3252	}
3253	}
3254	else
3255	{
3256	delete iv;
3257	(yyvsp[(3) - (4)].lv).CleanUp();
3258	MYYERROR("wrong type in ordering");
3259	}
3260	sl = sl->next;
3261	}
3262	(yyval.lv).rtyp = INTVEC_CMD;
3263	(yyval.lv).data = (void *)iv;
3264	}
3265	(yyvsp[(3) - (4)].lv).CleanUp();
3266	;}
3267	break;
3268
3269	case 115:
3270	#line 1080 "grammar.y"
3271	{
3272	(yyval.lv) = (yyvsp[(1) - (3)].lv);
3273	(yyval.lv).next = (sleftv *)omAllocBin(sleftv_bin);
3274	memcpy((yyval.lv).next,&(yyvsp[(3) - (3)].lv),sizeof(sleftv));
3275	;}
3276	break;
3277
3278	case 117:
3279	#line 1090 "grammar.y"
3280	{
3281	(yyval.lv) = (yyvsp[(2) - (3)].lv);
3282	;}
3283	break;
3284
3285	case 118:
3286	#line 1096 "grammar.y"
3287	{
3288	expected_parms = TRUE;
3289	;}
3290	break;
3291
3292	case 119:
3293	#line 1108 "grammar.y"
3294	{ if ((yyvsp[(1) - (2)].i) != '<') YYERROR;
3295	if((feFilePending=feFopen((yyvsp[(2) - (2)].name),"r",NULL,TRUE))==NULL) YYERROR; ;}
3296	break;
3297
3298	case 120:
3299	#line 1111 "grammar.y"
3300	{ newFile((yyvsp[(2) - (4)].name),feFilePending); ;}
3301	break;
3302
3303	case 121:
3304	#line 1116 "grammar.y"
3305	{
3306	feHelp((yyvsp[(2) - (3)].name));
3307	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3308	;}
3309	break;
3310
3311	case 122:
3312	#line 1121 "grammar.y"
3313	{
3314	feHelp(NULL);
3315	;}
3316	break;
3317
3318	case 123:
3319	#line 1128 "grammar.y"
3320	{
3321	singular_example((yyvsp[(2) - (3)].name));
3322	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3323	;}
3324	break;
3325
3326	case 124:
3327	#line 1136 "grammar.y"
3328	{
3329	if (basePack!=(yyvsp[(2) - (2)].lv).req_packhdl)
3330	{
3331	if(iiExport(&(yyvsp[(2) - (2)].lv),0,currPackHdl)) YYERROR;
3332	}
3333	else
3334	if (iiExport(&(yyvsp[(2) - (2)].lv),0)) YYERROR;
3335	;}
3336	break;
3337
3338	case 125:
3339	#line 1148 "grammar.y"
3340	{
3341	leftv v=&(yyvsp[(2) - (2)].lv);
3342	if (v->rtyp!=IDHDL)
3343	{
3344	if (v->name!=NULL)
3345	{
3346	Werror("`%s` is undefined in kill",v->name);
3347	}
3348	else WerrorS("kill what ?");
3349	}
3350	else
3351	{
3352	killhdl((idhdl)v->data,v->req_packhdl);
3353	}
3354	;}
3355	break;
3356
3357	case 126:
3358	#line 1164 "grammar.y"
3359	{
3360	leftv v=&(yyvsp[(3) - (3)].lv);
3361	if (v->rtyp!=IDHDL)
3362	{
3363	if (v->name!=NULL)
3364	{
3365	Werror("`%s` is undefined in kill",v->name);
3366	}
3367	else WerrorS("kill what ?");
3368	}
3369	else
3370	{
3371	killhdl((idhdl)v->data,v->req_packhdl);
3372	}
3373	;}
3374	break;
3375
3376	case 127:
3377	#line 1183 "grammar.y"
3378	{
3379	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3380	;}
3381	break;
3382
3383	case 128:
3384	#line 1187 "grammar.y"
3385	{
3386	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3387	;}
3388	break;
3389
3390	case 129:
3391	#line 1191 "grammar.y"
3392	{
3393	if ((yyvsp[(3) - (4)].i)==QRING_CMD) (yyvsp[(3) - (4)].i)=RING_CMD;
3394	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3395	;}
3396	break;
3397
3398	case 130:
3399	#line 1196 "grammar.y"
3400	{
3401	list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3402	;}
3403	break;
3404
3405	case 131:
3406	#line 1200 "grammar.y"
3407	{
3408	list_cmd(RING_CMD,NULL,"// ",TRUE);
3409	;}
3410	break;
3411
3412	case 132:
3413	#line 1204 "grammar.y"
3414	{
3415	list_cmd(MATRIX_CMD,NULL,"// ",TRUE);
3416	;}
3417	break;
3418
3419	case 133:
3420	#line 1208 "grammar.y"
3421	{
3422	list_cmd(INTMAT_CMD,NULL,"// ",TRUE);
3423	;}
3424	break;
3425
3426	case 134:
3427	#line 1212 "grammar.y"
3428	{
3429	list_cmd(PROC_CMD,NULL,"// ",TRUE);
3430	;}
3431	break;
3432
3433	case 135:
3434	#line 1216 "grammar.y"
3435	{
3436	list_cmd(0,(yyvsp[(3) - (4)].lv).Fullname(),"// ",TRUE);
3437	(yyvsp[(3) - (4)].lv).CleanUp();
3438	;}
3439	break;
3440
3441	case 136:
3442	#line 1221 "grammar.y"
3443	{
3444	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3445	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3446	(yyvsp[(3) - (6)].lv).CleanUp();
3447	;}
3448	break;
3449
3450	case 137:
3451	#line 1227 "grammar.y"
3452	{
3453	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3454	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3455	(yyvsp[(3) - (6)].lv).CleanUp();
3456	;}
3457	break;
3458
3459	case 138:
3460	#line 1233 "grammar.y"
3461	{
3462	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3463	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3464	(yyvsp[(3) - (6)].lv).CleanUp();
3465	;}
3466	break;
3467
3468	case 139:
3469	#line 1239 "grammar.y"
3470	{
3471	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3472	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3473	(yyvsp[(3) - (6)].lv).CleanUp();
3474	;}
3475	break;
3476
3477	case 140:
3478	#line 1245 "grammar.y"
3479	{
3480	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3481	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3482	(yyvsp[(3) - (6)].lv).CleanUp();
3483	;}
3484	break;
3485
3486	case 141:
3487	#line 1251 "grammar.y"
3488	{
3489	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3490	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3491	(yyvsp[(3) - (6)].lv).CleanUp();
3492	;}
3493	break;
3494
3495	case 142:
3496	#line 1257 "grammar.y"
3497	{
3498	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3499	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3500	(yyvsp[(3) - (6)].lv).CleanUp();
3501	;}
3502	break;
3503
3504	case 143:
3505	#line 1263 "grammar.y"
3506	{
3507	if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3508	list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3509	(yyvsp[(3) - (6)].lv).CleanUp();
3510	;}
3511	break;
3512
3513	case 144:
3514	#line 1275 "grammar.y"
3515	{
3516	list_cmd(-1,NULL,"// ",TRUE);
3517	;}
3518	break;
3519
3520	case 145:
3521	#line 1281 "grammar.y"
3522	{ yyInRingConstruction = TRUE; ;}
3523	break;
3524
3525	case 146:
3526	#line 1290 "grammar.y"
3527	{
3528	const char *ring_name = (yyvsp[(2) - (8)].lv).name;
3529	ring b=
3530	rInit(&(yyvsp[(4) - (8)].lv), /* characteristik and list of parameters*/
3531	&(yyvsp[(6) - (8)].lv), /* names of ringvariables */
3532	&(yyvsp[(8) - (8)].lv)); /* ordering */
3533	idhdl newRingHdl=NULL;
3534
3535	if (b!=NULL)
3536	{
3537	newRingHdl=enterid(ring_name, myynest, RING_CMD,
3538	&((yyvsp[(2) - (8)].lv).req_packhdl->idroot));
3539	(yyvsp[(2) - (8)].lv).CleanUp();
3540	if (newRingHdl!=NULL)
3541	{
3542	omFreeSize(IDRING(newRingHdl),sizeof(ip_sring));
3543	IDRING(newRingHdl)=b;
3544	}
3545	else
3546	{
3547	rKill(b);
3548	}
3549	}
3550	yyInRingConstruction = FALSE;
3551	if (newRingHdl==NULL)
3552	{
3553	MYYERROR("cannot make ring");
3554	}
3555	else
3556	{
3557	rSetHdl(newRingHdl);
3558	}
3559	;}
3560	break;
3561
3562	case 147:
3563	#line 1324 "grammar.y"
3564	{
3565	const char *ring_name = (yyvsp[(2) - (2)].lv).name;
3566	if (!inerror) rDefault(ring_name);
3567	yyInRingConstruction = FALSE;
3568	(yyvsp[(2) - (2)].lv).CleanUp();
3569	;}
3570	break;
3571
3572	case 148:
3573	#line 1334 "grammar.y"
3574	{
3575	if (((yyvsp[(1) - (2)].i)!=LIB_CMD)\|\|(iiLibCmd((yyvsp[(2) - (2)].name),TRUE,TRUE,TRUE)))
3576	//if ($1==LIB_CMD)
3577	//{
3578	// sleftv tmp;
3579	// if(iiExprArith1(&tmp,&$2,LIB_CMD)) YYERROR;
3580	//}
3581	//else
3582	YYERROR;
3583	;}
3584	break;
3585
3586	case 151:
3587	#line 1350 "grammar.y"
3588	{
3589	if (((yyvsp[(1) - (2)].i)==KEEPRING_CMD) && (myynest==0))
3590	MYYERROR("only inside a proc allowed");
3591	const char * n=(yyvsp[(2) - (2)].lv).Name();
3592	if ((((yyvsp[(2) - (2)].lv).Typ()==RING_CMD)\|\|((yyvsp[(2) - (2)].lv).Typ()==QRING_CMD))
3593	&& ((yyvsp[(2) - (2)].lv).rtyp==IDHDL))
3594	{
3595	idhdl h=(idhdl)(yyvsp[(2) - (2)].lv).data;
3596	if ((yyvsp[(2) - (2)].lv).e!=NULL) h=rFindHdl((ring)(yyvsp[(2) - (2)].lv).Data(),NULL, NULL);
3597	//Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
3598	if ((yyvsp[(1) - (2)].i)==KEEPRING_CMD)
3599	{
3600	if (h!=NULL)
3601	{
3602	if (IDLEV(h)!=0)
3603	{
3604	if (iiExport(&(yyvsp[(2) - (2)].lv),myynest-1)) YYERROR;
3605	#if 1
3606	idhdl p=IDRING(h)->idroot;
3607	idhdl root=p;
3608	int prevlev=myynest-1;
3609	while (p!=NULL)
3610	{
3611	if (IDLEV(p)==myynest)
3612	{
3613	idhdl old=root->get(IDID(p),prevlev);
3614	if (old!=NULL)
3615	{
3616	if (BVERBOSE(V_REDEFINE))
3617	Warn("redefining %s",IDID(p));
3618	killhdl2(old,&root,IDRING(h));
3619	IDRING(h)->idroot=root;
3620	}
3621	IDLEV(p)=prevlev;
3622	}
3623	p=IDNEXT(p);
3624	}
3625	#endif
3626	}
3627	#ifdef USE_IILOCALRING
3628	iiLocalRing[myynest-1]=IDRING(h);
3629	#endif
3630	procstack->cRing=IDRING(h);
3631	procstack->cRingHdl=h;
3632	}
3633	else
3634	{
3635	Werror("%s is no identifier",n);
3636	(yyvsp[(2) - (2)].lv).CleanUp();
3637	YYERROR;
3638	}
3639	}
3640	if (h!=NULL) rSetHdl(h);
3641	else
3642	{
3643	Werror("cannot find the name of the basering %s",n);
3644	(yyvsp[(2) - (2)].lv).CleanUp();
3645	YYERROR;
3646	}
3647	(yyvsp[(2) - (2)].lv).CleanUp();
3648	}
3649	else
3650	{
3651	Werror("%s is no name of a ring/qring",n);
3652	(yyvsp[(2) - (2)].lv).CleanUp();
3653	YYERROR;
3654	}
3655	;}
3656	break;
3657
3658	case 152:
3659	#line 1422 "grammar.y"
3660	{
3661	if ((yyvsp[(2) - (2)].lv).rtyp!=IDHDL) MYYERROR("identifier expected");
3662	idhdl h = (idhdl)(yyvsp[(2) - (2)].lv).data;
3663	type_cmd(h);
3664	;}
3665	break;
3666
3667	case 153:
3668	#line 1428 "grammar.y"
3669	{
3670	//Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
3671	#ifdef SIQ
3672	if ((yyvsp[(1) - (1)].lv).rtyp!=COMMAND)
3673	{
3674	#endif
3675	if ((yyvsp[(1) - (1)].lv).Typ()==UNKNOWN)
3676	{
3677	if ((yyvsp[(1) - (1)].lv).name!=NULL)
3678	{
3679	Werror("`%s` is undefined",(yyvsp[(1) - (1)].lv).name);
3680	omFree((ADDRESS)(yyvsp[(1) - (1)].lv).name);
3681	}
3682	YYERROR;
3683	}
3684	#ifdef SIQ
3685	}
3686	#endif
3687	(yyvsp[(1) - (1)].lv).Print(&sLastPrinted);
3688	(yyvsp[(1) - (1)].lv).CleanUp(currRing);
3689	if (errorreported) YYERROR;
3690	;}
3691	break;
3692
3693	case 154:
3694	#line 1457 "grammar.y"
3695	{
3696	int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
3697	if (i!=0)
3698	{
3699	newBuffer( (yyvsp[(5) - (5)].name), BT_if);
3700	}
3701	else
3702	{
3703	omFree((ADDRESS)(yyvsp[(5) - (5)].name));
3704	currentVoice->ifsw=1;
3705	}
3706	;}
3707	break;
3708
3709	case 155:
3710	#line 1470 "grammar.y"
3711	{
3712	if (currentVoice->ifsw==1)
3713	{
3714	currentVoice->ifsw=0;
3715	newBuffer( (yyvsp[(2) - (2)].name), BT_else);
3716	}
3717	else
3718	{
3719	if (currentVoice->ifsw!=2)
3720	{
3721	Warn("`else` without `if` in level %d",myynest);
3722	}
3723	omFree((ADDRESS)(yyvsp[(2) - (2)].name));
3724	}
3725	currentVoice->ifsw=0;
3726	;}
3727	break;
3728
3729	case 156:
3730	#line 1487 "grammar.y"
3731	{
3732	int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
3733	if (i)
3734	{
3735	if (exitBuffer(BT_break)) YYERROR;
3736	}
3737	currentVoice->ifsw=0;
3738	;}
3739	break;
3740
3741	case 157:
3742	#line 1496 "grammar.y"
3743	{
3744	if (exitBuffer(BT_break)) YYERROR;
3745	currentVoice->ifsw=0;
3746	;}
3747	break;
3748
3749	case 158:
3750	#line 1501 "grammar.y"
3751	{
3752	if (contBuffer(BT_break)) YYERROR;
3753	currentVoice->ifsw=0;
3754	;}
3755	break;
3756
3757	case 159:
3758	#line 1509 "grammar.y"
3759	{
3760	/* -> if(!$2) break; $3; continue;*/
3761	char * s = (char *)omAlloc( strlen((yyvsp[(2) - (3)].name)) + strlen((yyvsp[(3) - (3)].name)) + 36);
3762	sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,(yyvsp[(2) - (3)].name),(yyvsp[(3) - (3)].name));
3763	newBuffer(s,BT_break);
3764	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3765	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
3766	;}
3767	break;
3768
3769	case 160:
3770	#line 1521 "grammar.y"
3771	{
3772	/* $2 */
3773	/* if (!$3) break; $5; $4; continue; */
3774	char * s = (char *)omAlloc( strlen((yyvsp[(3) - (5)].name))+strlen((yyvsp[(4) - (5)].name))+strlen((yyvsp[(5) - (5)].name))+36);
3775	sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
3776	,(yyvsp[(3) - (5)].name),(yyvsp[(5) - (5)].name),(yyvsp[(4) - (5)].name));
3777	omFree((ADDRESS)(yyvsp[(3) - (5)].name));
3778	omFree((ADDRESS)(yyvsp[(4) - (5)].name));
3779	omFree((ADDRESS)(yyvsp[(5) - (5)].name));
3780	newBuffer(s,BT_break);
3781	s = (char *)omAlloc( strlen((yyvsp[(2) - (5)].name)) + 3);
3782	sprintf(s,"%s;\n",(yyvsp[(2) - (5)].name));
3783	omFree((ADDRESS)(yyvsp[(2) - (5)].name));
3784	newBuffer(s,BT_if);
3785	;}
3786	break;
3787
3788	case 161:
3789	#line 1540 "grammar.y"
3790	{
3791	procinfov pi;
3792	idhdl h = enterid((yyvsp[(2) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
3793	if (h==NULL) {omFree((ADDRESS)(yyvsp[(2) - (3)].name));omFree((ADDRESS)(yyvsp[(3) - (3)].name)); YYERROR;}
3794	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(2) - (3)].name), 0, 0);
3795	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+31);;
3796	sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",(yyvsp[(3) - (3)].name));
3797	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
3798	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3799	;}
3800	break;
3801
3802	case 162:
3803	#line 1551 "grammar.y"
3804	{
3805	idhdl h = enterid((yyvsp[(1) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
3806	if (h==NULL)
3807	{
3808	omFree((ADDRESS)(yyvsp[(1) - (3)].name));
3809	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3810	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
3811	YYERROR;
3812	}
3813	char *args=iiProcArgs((yyvsp[(2) - (3)].name),FALSE);
3814	omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3815	procinfov pi;
3816	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (3)].name), 0, 0);
3817	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+strlen(args)+14);;
3818	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(3) - (3)].name));
3819	omFree((ADDRESS)args);
3820	omFree((ADDRESS)(yyvsp[(3) - (3)].name));
3821	omFree((ADDRESS)(yyvsp[(1) - (3)].name));
3822	;}
3823	break;
3824
3825	case 163:
3826	#line 1571 "grammar.y"
3827	{
3828	omFree((ADDRESS)(yyvsp[(3) - (4)].name));
3829	idhdl h = enterid((yyvsp[(1) - (4)].name),myynest,PROC_CMD,&IDROOT,TRUE);
3830	if (h==NULL)
3831	{
3832	omFree((ADDRESS)(yyvsp[(1) - (4)].name));
3833	omFree((ADDRESS)(yyvsp[(2) - (4)].name));
3834	omFree((ADDRESS)(yyvsp[(4) - (4)].name));
3835	YYERROR;
3836	}
3837	char *args=iiProcArgs((yyvsp[(2) - (4)].name),FALSE);
3838	omFree((ADDRESS)(yyvsp[(2) - (4)].name));
3839	procinfov pi;
3840	iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (4)].name), 0, 0);
3841	omFree((ADDRESS)(yyvsp[(1) - (4)].name));
3842	IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(4) - (4)].name))+strlen(args)+14);;
3843	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(4) - (4)].name));
3844	omFree((ADDRESS)args);
3845	omFree((ADDRESS)(yyvsp[(4) - (4)].name));
3846	;}
3847	break;
3848
3849	case 164:
3850	#line 1595 "grammar.y"
3851	{
3852	// decl. of type proc p(int i)
3853	if ((yyvsp[(1) - (2)].i)==PARAMETER) { if (iiParameter(&(yyvsp[(2) - (2)].lv))) YYERROR; }
3854	else { if (iiAlias(&(yyvsp[(2) - (2)].lv))) YYERROR; }
3855	;}
3856	break;
3857
3858	case 165:
3859	#line 1601 "grammar.y"
3860	{
3861	// decl. of type proc p(i)
3862	sleftv tmp_expr;
3863	if ((yyvsp[(1) - (2)].i)==ALIAS_CMD) MYYERROR("alias requires a type");
3864	if ((iiDeclCommand(&tmp_expr,&(yyvsp[(2) - (2)].lv),myynest,DEF_CMD,&IDROOT))
3865	\|\| (iiParameter(&tmp_expr)))
3866	YYERROR;
3867	;}
3868	break;
3869
3870	case 166:
3871	#line 1613 "grammar.y"
3872	{
3873	if(iiRETURNEXPR==NULL) YYERROR;
3874	iiRETURNEXPR[myynest].Copy(&(yyvsp[(3) - (4)].lv));
3875	(yyvsp[(3) - (4)].lv).CleanUp();
3876	if (exitBuffer(BT_proc)) YYERROR;
3877	;}
3878	break;
3879
3880	case 167:
3881	#line 1620 "grammar.y"
3882	{
3883	if ((yyvsp[(1) - (3)].i)==RETURN)
3884	{
3885	if(iiRETURNEXPR==NULL) YYERROR;
3886	iiRETURNEXPR[myynest].Init();
3887	iiRETURNEXPR[myynest].rtyp=NONE;
3888	if (exitBuffer(BT_proc)) YYERROR;
3889	}
3890	;}
3891	break;
3892
3893
3894	/* Line 1267 of yacc.c. */
3895	#line 3911 "grammar.cc"
3896	default: break;
3897	}
3898	YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3899
3900	YYPOPSTACK (yylen);
3901	yylen = 0;
3902	YY_STACK_PRINT (yyss, yyssp);
3903
3904	*++yyvsp = yyval;
3905
3906
3907	/* Now `shift' the result of the reduction. Determine what state
3908	that goes to, based on the state we popped back to and the rule
3909	number reduced by. */
3910
3911	yyn = yyr1[yyn];
3912
3913	yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3914	if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3915	yystate = yytable[yystate];
3916	else
3917	yystate = yydefgoto[yyn - YYNTOKENS];
3918
3919	goto yynewstate;
3920
3921
3922	/*------------------------------------.
3923	\| yyerrlab -- here on detecting error \|
3924	`------------------------------------*/
3925	yyerrlab:
3926	/* If not already recovering from an error, report this error. */
3927	if (!yyerrstatus)
3928	{
3929	++yynerrs;
3930	#if ! YYERROR_VERBOSE
3931	yyerror (YY_("syntax error"));
3932	#else
3933	{
3934	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
3935	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
3936	{
3937	YYSIZE_T yyalloc = 2 * yysize;
3938	if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
3939	yyalloc = YYSTACK_ALLOC_MAXIMUM;
3940	if (yymsg != yymsgbuf)
3941	YYSTACK_FREE (yymsg);
3942	yymsg = (char *) YYSTACK_ALLOC (yyalloc);
3943	if (yymsg)
3944	yymsg_alloc = yyalloc;
3945	else
3946	{
3947	yymsg = yymsgbuf;
3948	yymsg_alloc = sizeof yymsgbuf;
3949	}
3950	}
3951
3952	if (0 < yysize && yysize <= yymsg_alloc)
3953	{
3954	(void) yysyntax_error (yymsg, yystate, yychar);
3955	yyerror (yymsg);
3956	}
3957	else
3958	{
3959	yyerror (YY_("syntax error"));
3960	if (yysize != 0)
3961	goto yyexhaustedlab;
3962	}
3963	}
3964	#endif
3965	}
3966
3967
3968
3969	if (yyerrstatus == 3)
3970	{
3971	/* If just tried and failed to reuse look-ahead token after an
3972	error, discard it. */
3973
3974	if (yychar <= YYEOF)
3975	{
3976	/* Return failure if at end of input. */
3977	if (yychar == YYEOF)
3978	YYABORT;
3979	}
3980	else
3981	{
3982	yydestruct ("Error: discarding",
3983	yytoken, &yylval);
3984	yychar = YYEMPTY;
3985	}
3986	}
3987
3988	/* Else will try to reuse look-ahead token after shifting the error
3989	token. */
3990	goto yyerrlab1;
3991
3992
3993	/*---------------------------------------------------.
3994	\| yyerrorlab -- error raised explicitly by YYERROR. \|
3995	`---------------------------------------------------*/
3996	yyerrorlab:
3997
3998	/* Pacify compilers like GCC when the user code never invokes
3999	YYERROR and the label yyerrorlab therefore never appears in user
4000	code. */
4001	if (/CONSTCOND/ 0)
4002	goto yyerrorlab;
4003
4004	/* Do not reclaim the symbols of the rule which action triggered
4005	this YYERROR. */
4006	YYPOPSTACK (yylen);
4007	yylen = 0;
4008	YY_STACK_PRINT (yyss, yyssp);
4009	yystate = *yyssp;
4010	goto yyerrlab1;
4011
4012
4013	/*-------------------------------------------------------------.
4014	\| yyerrlab1 -- common code for both syntax error and YYERROR. \|
4015	`-------------------------------------------------------------*/
4016	yyerrlab1:
4017	yyerrstatus = 3; /* Each real token shifted decrements this. */
4018
4019	for (;;)
4020	{
4021	yyn = yypact[yystate];
4022	if (yyn != YYPACT_NINF)
4023	{
4024	yyn += YYTERROR;
4025	if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4026	{
4027	yyn = yytable[yyn];
4028	if (0 < yyn)
4029	break;
4030	}
4031	}
4032
4033	/* Pop the current state because it cannot handle the error token. */
4034	if (yyssp == yyss)
4035	YYABORT;
4036
4037
4038	yydestruct ("Error: popping",
4039	yystos[yystate], yyvsp);
4040	YYPOPSTACK (1);
4041	yystate = *yyssp;
4042	YY_STACK_PRINT (yyss, yyssp);
4043	}
4044
4045	if (yyn == YYFINAL)
4046	YYACCEPT;
4047
4048	*++yyvsp = yylval;
4049
4050
4051	/* Shift the error token. */
4052	YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4053
4054	yystate = yyn;
4055	goto yynewstate;
4056
4057
4058	/*-------------------------------------.
4059	\| yyacceptlab -- YYACCEPT comes here. \|
4060	`-------------------------------------*/
4061	yyacceptlab:
4062	yyresult = 0;
4063	goto yyreturn;
4064
4065	/*-----------------------------------.
4066	\| yyabortlab -- YYABORT comes here. \|
4067	`-----------------------------------*/
4068	yyabortlab:
4069	yyresult = 1;
4070	goto yyreturn;
4071
4072	#ifndef yyoverflow
4073	/*-------------------------------------------------.
4074	\| yyexhaustedlab -- memory exhaustion comes here. \|
4075	`-------------------------------------------------*/
4076	yyexhaustedlab:
4077	yyerror (YY_("memory exhausted"));
4078	yyresult = 2;
4079	/* Fall through. */
4080	#endif
4081
4082	yyreturn:
4083	if (yychar != YYEOF && yychar != YYEMPTY)
4084	yydestruct ("Cleanup: discarding lookahead",
4085	yytoken, &yylval);
4086	/* Do not reclaim the symbols of the rule which action triggered
4087	this YYABORT or YYACCEPT. */
4088	YYPOPSTACK (yylen);
4089	YY_STACK_PRINT (yyss, yyssp);
4090	while (yyssp != yyss)
4091	{
4092	yydestruct ("Cleanup: popping",
4093	yystos[*yyssp], yyvsp);
4094	YYPOPSTACK (1);
4095	}
4096	#ifndef yyoverflow
4097	if (yyss != yyssa)
4098	YYSTACK_FREE (yyss);
4099	#endif
4100	#if YYERROR_VERBOSE
4101	if (yymsg != yymsgbuf)
4102	YYSTACK_FREE (yymsg);
4103	#endif
4104	/* Make sure YYID is used. */
4105	return YYID (yyresult);
4106	}
4107
4108
4109

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

Download in other formats: