Context Navigation

source: git/Singular/grammar.cc @ a563a0

spielwiese

Last change on this file since a563a0 was da2bd0, checked in by Hans Schoenemann <hannes@…>, 13 years ago
fix tr307 again git-svn-id: file:///usr/local/Singular/svn/trunk@13794 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 138.0 KB

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

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

Download in other formats: