Context Navigation

source: git/Singular/grammar.cc @ 995a6a

fieker-DuValspielwiese

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

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

Download in other formats: