Context Navigation

source: git/Singular/grammar.cc @ 4b3ef4b

spielwiese

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

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

Download in other formats: