Context Navigation

source: git/Singular/grammar.cc @ b5f276e

spielwiese

Last change on this file since b5f276e was b1dfaf, checked in by Frank Seelisch <seelisch@…>, 14 years ago
patch from Kai (checked for problems under Windows OS: no problems) git-svn-id: file:///usr/local/Singular/svn/trunk@13210 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 135.5 KB

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

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

Download in other formats: