Context Navigation

source: git/Singular/grammar.cc @ 05a2f6

fieker-DuValspielwiese

Last change on this file since 05a2f6 was d3e630, checked in by Hans Schönemann <hannes@…>, 15 years ago
*hannes: code cleanup (see ChangeLog) git-svn-id: file:///usr/local/Singular/svn/trunk@12029 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 107.8 KB

Line
1
2	/* A Bison parser, made from grammar.y
3	by GNU Bison version 1.28 */
4
5	#define YYBISON 1 /* Identify Bison output. */
6
7	#define DOTDOT 257
8	#define EQUAL_EQUAL 258
9	#define GE 259
10	#define LE 260
11	#define MINUSMINUS 261
12	#define NOT 262
13	#define NOTEQUAL 263
14	#define PLUSPLUS 264
15	#define COLONCOLON 265
16	#define GRING_CMD 266
17	#define INTMAT_CMD 267
18	#define PROC_CMD 268
19	#define RING_CMD 269
20	#define BEGIN_RING 270
21	#define IDEAL_CMD 271
22	#define MAP_CMD 272
23	#define MATRIX_CMD 273
24	#define MODUL_CMD 274
25	#define NUMBER_CMD 275
26	#define POLY_CMD 276
27	#define RESOLUTION_CMD 277
28	#define VECTOR_CMD 278
29	#define BETTI_CMD 279
30	#define COEFFS_CMD 280
31	#define COEF_CMD 281
32	#define CONTRACT_CMD 282
33	#define DEGREE_CMD 283
34	#define DEG_CMD 284
35	#define DIFF_CMD 285
36	#define DIM_CMD 286
37	#define DIVISION_CMD 287
38	#define ELIMINATION_CMD 288
39	#define E_CMD 289
40	#define FETCH_CMD 290
41	#define FREEMODULE_CMD 291
42	#define KEEPRING_CMD 292
43	#define HILBERT_CMD 293
44	#define HOMOG_CMD 294
45	#define IMAP_CMD 295
46	#define INDEPSET_CMD 296
47	#define INTERRED_CMD 297
48	#define INTERSECT_CMD 298
49	#define JACOB_CMD 299
50	#define JET_CMD 300
51	#define KBASE_CMD 301
52	#define KOSZUL_CMD 302
53	#define LEADCOEF_CMD 303
54	#define LEADEXP_CMD 304
55	#define LEAD_CMD 305
56	#define LEADMONOM_CMD 306
57	#define LIFTSTD_CMD 307
58	#define LIFT_CMD 308
59	#define MAXID_CMD 309
60	#define MINBASE_CMD 310
61	#define MINOR_CMD 311
62	#define MINRES_CMD 312
63	#define MODULO_CMD 313
64	#define MRES_CMD 314
65	#define MULTIPLICITY_CMD 315
66	#define ORD_CMD 316
67	#define PAR_CMD 317
68	#define PARDEG_CMD 318
69	#define PREIMAGE_CMD 319
70	#define QUOTIENT_CMD 320
71	#define QHWEIGHT_CMD 321
72	#define REDUCE_CMD 322
73	#define REGULARITY_CMD 323
74	#define RES_CMD 324
75	#define SIMPLIFY_CMD 325
76	#define SORTVEC_CMD 326
77	#define SRES_CMD 327
78	#define STD_CMD 328
79	#define SUBST_CMD 329
80	#define SYZYGY_CMD 330
81	#define VAR_CMD 331
82	#define VDIM_CMD 332
83	#define WEDGE_CMD 333
84	#define WEIGHT_CMD 334
85	#define VALTVARS 335
86	#define VMAXDEG 336
87	#define VMAXMULT 337
88	#define VNOETHER 338
89	#define VMINPOLY 339
90	#define END_RING 340
91	#define CMD_1 341
92	#define CMD_2 342
93	#define CMD_3 343
94	#define CMD_12 344
95	#define CMD_13 345
96	#define CMD_23 346
97	#define CMD_123 347
98	#define CMD_M 348
99	#define ROOT_DECL 349
100	#define ROOT_DECL_LIST 350
101	#define RING_DECL 351
102	#define EXAMPLE_CMD 352
103	#define EXPORT_CMD 353
104	#define HELP_CMD 354
105	#define KILL_CMD 355
106	#define LIB_CMD 356
107	#define LISTVAR_CMD 357
108	#define SETRING_CMD 358
109	#define TYPE_CMD 359
110	#define STRINGTOK 360
111	#define BLOCKTOK 361
112	#define INT_CONST 362
113	#define UNKNOWN_IDENT 363
114	#define RINGVAR 364
115	#define PROC_DEF 365
116	#define BREAK_CMD 366
117	#define CONTINUE_CMD 367
118	#define ELSE_CMD 368
119	#define EVAL 369
120	#define QUOTE 370
121	#define FOR_CMD 371
122	#define IF_CMD 372
123	#define SYS_BREAK 373
124	#define WHILE_CMD 374
125	#define RETURN 375
126	#define PARAMETER 376
127	#define SYSVAR 377
128	#define UMINUS 378
129
130	#line 8 "grammar.y"
131
132
133	#include <stdio.h>
134	#include <stddef.h>
135	#include <stdlib.h>
136	#include <stdarg.h>
137	#include <string.h>
138
139	#include "mod2.h"
140	#include <mylimits.h>
141	#include "omalloc.h"
142	#include "tok.h"
143	#include "stype.h"
144	#include "ipid.h"
145	#include "intvec.h"
146	#include "febase.h"
147	#include "matpol.h"
148	#include "ring.h"
149	#include "kstd1.h"
150	#include "subexpr.h"
151	#include "ipshell.h"
152	#include "ipconv.h"
153	#include "sdb.h"
154	#include "ideals.h"
155	#include "numbers.h"
156	#include "polys.h"
157	#include "stairc.h"
158	#include "timer.h"
159	#include "cntrlc.h"
160	#include "maps.h"
161	#include "syz.h"
162	#include "lists.h"
163	#include "longrat.h"
164	#include "libparse.h"
165
166	#if 0
167	void debug_list(leftv v)
168	{
169	idhdl r=basePackHdl;
170	idhdl h;
171	BOOLEAN found=FALSE;
172	const char *nn=v->name;
173	h=IDROOT->get(nn,myynest);
174	if (h!=NULL)
175	{
176	Print("Curr::%s, (%s)\n",nn,Tok2Cmdname((int)IDTYP(h)));
177	found=TRUE;
178	}
179	else Print("`%s` not found in IDROOT\n",nn);
180	while (r!=NULL)
181	{
182	if ((IDTYP(r)==PACKAGE_CMD)
183	\|\| (IDTYP(r)==RING_CMD)
184	\|\| (IDTYP(r)==QRING_CMD))
185	{
186	h=IDPACKAGE(r)->idroot->get(nn,myynest);
187	if (h!=NULL)
188	{
189	Print("%s::%s, (%s)\n",r->id,nn,Tok2Cmdname((int)IDTYP(h)));
190	found=TRUE;
191	}
192	else Print("%s::%s not found\n",r->id,nn);
193	}
194	if (r==basePackHdl) r=IDPACKAGE(r)->idroot;
195	r=r->next;
196	if (r==basePackHdl) break;
197	}
198	if (!found)
199	{
200	listall(TRUE);
201	}
202	}
203	#endif
204
205	/* From the bison docu:
206
207	By defining the macro `YYMAXDEPTH', you can control how deep the
208	parser stack can become before a stack overflow occurs. Define the
209	macro with a value that is an integer. This value is the maximum number
210	of tokens that can be shifted (and not reduced) before overflow. It
211	must be a constant expression whose value is known at compile time.
212
213	The stack space allowed is not necessarily allocated. If you
214	specify a large value for `YYMAXDEPTH', the parser actually allocates a
215	small stack at first, and then makes it bigger by stages as needed.
216	This increasing allocation happens automatically and silently.
217	Therefore, you do not need to make `YYMAXDEPTH' painfully small merely
218	to save space for ordinary inputs that do not need much stack.
219
220	The default value of `YYMAXDEPTH', if you do not define it, is 10000.
221	*/
222	#define YYMAXDEPTH INT_MAX
223
224	extern int yylineno;
225	extern FILE* yyin;
226
227	char my_yylinebuf[80];
228	const char * currid;
229	BOOLEAN yyInRingConstruction=FALSE;
230	BOOLEAN expected_parms;
231	int cmdtok;
232	int inerror = 0;
233
234	#define TESTSETINT(a,i) \
235	if ((a).Typ() != INT_CMD) \
236	{ \
237	WerrorS("no int expression"); \
238	YYERROR; \
239	} \
240	(i) = (int)((long)(a).Data());
241
242	#define MYYERROR(a) { WerrorS(a); YYERROR; }
243
244	void yyerror(const char * fmt)
245	{
246
247	BOOLEAN old_errorreported=errorreported;
248	errorreported = TRUE;
249	if (currid!=NULL)
250	{
251	killid(currid,&IDROOT);
252	currid = NULL;
253	}
254	if(inerror==0)
255	{
256	#ifdef HAVE_TCL
257	if (tclmode)
258	{ /* omit output of line number if tclmode and stdin */
259	const char *n=VoiceName();
260	if (strcmp(n,"STDIN")==0)
261	Werror( "error occurred in or before %s: `%s`"
262	,n, my_yylinebuf);
263	else
264	Werror( "error occurred in or before %s line %d: `%s`"
265	,n, yylineno, my_yylinebuf);
266	}
267	else
268	#endif
269	{
270	if ((strlen(fmt)>1)
271	&& (strncmp(fmt,"parse",5)!=0)
272	&& (strncmp(fmt,"syntax",6)!=0))
273	WerrorS(fmt);
274	Werror( "error occurred in or before %s line %d: `%s`"
275	,VoiceName(), yylineno, my_yylinebuf);
276	}
277	if (cmdtok!=0)
278	{
279	const char *s=Tok2Cmdname(cmdtok);
280	if (expected_parms)
281	{
282	Werror("expected %s-expression. type \'help %s;\'",s,s);
283	}
284	else
285	{
286	Werror("wrong type declaration. type \'help %s;\'",s);
287	}
288	}
289	if (!old_errorreported && (lastreserved!=NULL))
290	{
291	Werror("last reserved name was `%s`",lastreserved);
292	}
293	inerror=1;
294	}
295	if ((currentVoice!=NULL)
296	&& (currentVoice->prev!=NULL)
297	&& (myynest>0)
298	#ifdef HAVE_SDB
299	&& ((sdb_flags &1)==0)
300	#endif
301	)
302	{
303	Werror("leaving %s",VoiceName());
304	}
305	#ifdef HAVE_FACTORY
306	// libfac:
307	extern int libfac_interruptflag;
308	libfac_interruptflag=0;
309	#endif
310	}
311
312	#ifndef YYDEBUG
313	#define YYDEBUG 1
314	#endif
315
316	#include <stdio.h>
317
318	#ifndef __cplusplus
319	#ifndef __STDC__
320	#define const
321	#endif
322	#endif
323
324
325
326	#define YYFINAL 369
327	#define YYFLAG -32768
328	#define YYNTBASE 142
329
330	#define YYTRANSLATE(x) ((unsigned)(x) <= 378 ? yytranslate[x] : 185)
331
332	static const short yytranslate[] = { 0,
333	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
334	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
335	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
336	2, 2, 2, 2, 2, 2, 2, 135, 2, 139,
337	140, 137, 127, 133, 128, 2, 129, 2, 2, 2,
338	2, 2, 2, 2, 2, 2, 2, 136, 134, 125,
339	124, 126, 2, 2, 2, 2, 2, 2, 2, 2,
340	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
341	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
342	130, 2, 131, 132, 2, 141, 2, 2, 2, 2,
343	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
344	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
345	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
346	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
347	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
348	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
349	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
350	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
351	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
352	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
353	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
354	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
355	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
356	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
357	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
358	2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
359	7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
360	17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
361	27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
362	37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
363	47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
364	57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
365	67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
366	77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
367	87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
368	97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
369	107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
370	117, 118, 119, 120, 121, 122, 123, 138
371	};
372
373	#if YYDEBUG != 0
374	static const short yyprhs[] = { 0,
375	0, 1, 4, 6, 9, 12, 14, 16, 18, 21,
376	23, 25, 27, 29, 31, 33, 35, 37, 40, 42,
377	44, 46, 48, 50, 52, 54, 56, 58, 61, 63,
378	65, 69, 73, 78, 82, 84, 86, 88, 92, 94,
379	96, 98, 102, 109, 114, 119, 124, 128, 133, 138,
380	142, 147, 154, 163, 170, 179, 184, 189, 196, 201,
381	208, 217, 226, 230, 235, 244, 249, 258, 263, 272,
382	277, 281, 287, 288, 294, 297, 299, 302, 305, 309,
383	313, 317, 321, 325, 329, 333, 337, 341, 345, 348,
384	351, 354, 357, 359, 363, 365, 367, 370, 373, 376,
385	379, 388, 391, 400, 403, 407, 410, 412, 414, 420,
386	422, 424, 429, 431, 435, 437, 441, 443, 444, 449,
387	453, 456, 460, 463, 466, 470, 475, 480, 485, 490,
388	495, 500, 505, 510, 515, 522, 529, 536, 543, 550,
389	557, 564, 571, 575, 577, 586, 589, 592, 594, 596,
390	599, 602, 604, 610, 613, 619, 621, 623, 627, 633,
391	637, 641, 646, 649, 652, 657
392	};
393
394	static const short yyrhs[] = { -1,
395	142, 143, 0, 144, 0, 146, 134, 0, 158, 134,
396	0, 184, 0, 119, 0, 134, 0, 1, 134, 0,
397	179, 0, 180, 0, 145, 0, 181, 0, 182, 0,
398	166, 0, 168, 0, 169, 0, 98, 107, 0, 147,
399	0, 170, 0, 171, 0, 172, 0, 183, 0, 174,
400	0, 175, 0, 177, 0, 178, 0, 155, 149, 0,
401	110, 0, 156, 0, 148, 11, 148, 0, 148, 139,
402	140, 0, 148, 139, 149, 140, 0, 130, 149, 131,
403	0, 108, 0, 123, 0, 159, 0, 149, 133, 150,
404	0, 150, 0, 154, 0, 148, 0, 139, 149, 140,
405	0, 150, 130, 150, 133, 150, 131, 0, 150, 130,
406	150, 131, 0, 95, 139, 150, 140, 0, 96, 139,
407	149, 140, 0, 96, 139, 140, 0, 97, 139, 150,
408	140, 0, 157, 139, 149, 140, 0, 157, 139, 140,
409	0, 87, 139, 150, 140, 0, 88, 139, 150, 133,
410	150, 140, 0, 89, 139, 150, 133, 150, 133, 150,
411	140, 0, 92, 139, 150, 133, 150, 140, 0, 92,
412	139, 150, 133, 150, 133, 150, 140, 0, 90, 139,
413	150, 140, 0, 91, 139, 150, 140, 0, 90, 139,
414	150, 133, 150, 140, 0, 93, 139, 150, 140, 0,
415	93, 139, 150, 133, 150, 140, 0, 91, 139, 150,
416	133, 150, 133, 150, 140, 0, 93, 139, 150, 133,
417	150, 133, 150, 140, 0, 94, 139, 140, 0, 94,
418	139, 149, 140, 0, 19, 139, 150, 133, 150, 133,
419	150, 140, 0, 19, 139, 150, 140, 0, 13, 139,
420	150, 133, 150, 133, 150, 140, 0, 13, 139, 150,
421	140, 0, 15, 139, 160, 133, 160, 133, 164, 140,
422	0, 15, 139, 150, 140, 0, 152, 150, 153, 0,
423	152, 150, 124, 150, 153, 0, 0, 115, 139, 151,
424	150, 140, 0, 116, 139, 0, 140, 0, 150, 10,
425	0, 150, 7, 0, 150, 127, 150, 0, 150, 128,
426	150, 0, 150, 129, 150, 0, 150, 132, 150, 0,
427	150, 125, 150, 0, 150, 135, 150, 0, 150, 9,
428	150, 0, 150, 4, 150, 0, 150, 3, 150, 0,
429	150, 136, 150, 0, 8, 150, 0, 128, 150, 0,
430	158, 165, 0, 149, 124, 0, 109, 0, 141, 150,
431	141, 0, 17, 0, 20, 0, 95, 148, 0, 96,
432	148, 0, 97, 148, 0, 157, 148, 0, 19, 148,
433	130, 150, 131, 130, 150, 131, 0, 19, 148, 0,
434	13, 148, 130, 150, 131, 130, 150, 131, 0, 13,
435	148, 0, 158, 133, 148, 0, 14, 148, 0, 106,
436	0, 150, 0, 139, 150, 133, 149, 140, 0, 109,
437	0, 161, 0, 161, 139, 149, 140, 0, 162, 0,
438	162, 133, 163, 0, 162, 0, 139, 163, 140, 0,
439	124, 0, 0, 125, 159, 167, 134, 0, 100, 106,
440	134, 0, 100, 134, 0, 98, 106, 134, 0, 99,
441	149, 0, 101, 148, 0, 171, 133, 148, 0, 103,
442	139, 95, 140, 0, 103, 139, 96, 140, 0, 103,
443	139, 97, 140, 0, 103, 139, 157, 140, 0, 103,
444	139, 15, 140, 0, 103, 139, 19, 140, 0, 103,
445	139, 13, 140, 0, 103, 139, 14, 140, 0, 103,
446	139, 148, 140, 0, 103, 139, 148, 133, 95, 140,
447	0, 103, 139, 148, 133, 96, 140, 0, 103, 139,
448	148, 133, 97, 140, 0, 103, 139, 148, 133, 157,
449	140, 0, 103, 139, 148, 133, 15, 140, 0, 103,
450	139, 148, 133, 19, 140, 0, 103, 139, 148, 133,
451	13, 140, 0, 103, 139, 148, 133, 14, 140, 0,
452	103, 139, 140, 0, 15, 0, 173, 148, 165, 160,
453	133, 160, 133, 164, 0, 173, 148, 0, 123, 159,
454	0, 104, 0, 38, 0, 176, 150, 0, 105, 150,
455	0, 149, 0, 118, 139, 150, 140, 107, 0, 114,
456	107, 0, 118, 139, 150, 140, 112, 0, 112, 0,
457	113, 0, 120, 106, 107, 0, 117, 106, 106, 106,
458	107, 0, 14, 156, 107, 0, 111, 106, 107, 0,
459	111, 106, 106, 107, 0, 122, 158, 0, 122, 150,
460	0, 121, 139, 149, 140, 0, 121, 139, 140, 0
461	};
462
463	#endif
464
465	#if YYDEBUG != 0
466	static const short yyrline[] = { 0,
467	366, 368, 402, 404, 406, 408, 412, 417, 419, 467,
468	468, 469, 470, 471, 472, 473, 474, 478, 481, 482,
469	483, 484, 485, 486, 487, 488, 489, 492, 498, 504,
470	508, 512, 516, 536, 564, 588, 594, 602, 614, 620,
471	625, 626, 627, 631, 635, 639, 643, 647, 651, 655,
472	659, 663, 667, 671, 675, 679, 683, 687, 691, 695,
473	699, 703, 707, 711, 715, 719, 723, 727, 731, 735,
474	739, 743, 760, 766, 778, 786, 794, 799, 803, 807,
475	811, 815, 819, 823, 827, 831, 835, 839, 843, 850,
476	856, 858, 876, 878, 889, 890, 894, 900, 905, 909,
477	913, 929, 933, 949, 963, 984, 991, 995, 997, 1010,
478	1018, 1028, 1072, 1074, 1082, 1084, 1090, 1101, 1106, 1109,
479	1115, 1121, 1129, 1141, 1158, 1176, 1181, 1185, 1190, 1194,
480	1198, 1202, 1206, 1210, 1215, 1221, 1227, 1233, 1239, 1245,
481	1251, 1257, 1269, 1275, 1279, 1318, 1327, 1341, 1341, 1343,
482	1419, 1426, 1455, 1468, 1485, 1494, 1499, 1506, 1518, 1537,
483	1549, 1569, 1592, 1599, 1610, 1618
484	};
485	#endif
486
487
488	#if YYDEBUG != 0 \|\| defined (YYERROR_VERBOSE)
489
490	static const char * const yytname[] = { "$","error","$undefined.","DOTDOT",
491	"EQUAL_EQUAL","GE","LE","MINUSMINUS","NOT","NOTEQUAL","PLUSPLUS","COLONCOLON",
492	"GRING_CMD","INTMAT_CMD","PROC_CMD","RING_CMD","BEGIN_RING","IDEAL_CMD","MAP_CMD",
493	"MATRIX_CMD","MODUL_CMD","NUMBER_CMD","POLY_CMD","RESOLUTION_CMD","VECTOR_CMD",
494	"BETTI_CMD","COEFFS_CMD","COEF_CMD","CONTRACT_CMD","DEGREE_CMD","DEG_CMD","DIFF_CMD",
495	"DIM_CMD","DIVISION_CMD","ELIMINATION_CMD","E_CMD","FETCH_CMD","FREEMODULE_CMD",
496	"KEEPRING_CMD","HILBERT_CMD","HOMOG_CMD","IMAP_CMD","INDEPSET_CMD","INTERRED_CMD",
497	"INTERSECT_CMD","JACOB_CMD","JET_CMD","KBASE_CMD","KOSZUL_CMD","LEADCOEF_CMD",
498	"LEADEXP_CMD","LEAD_CMD","LEADMONOM_CMD","LIFTSTD_CMD","LIFT_CMD","MAXID_CMD",
499	"MINBASE_CMD","MINOR_CMD","MINRES_CMD","MODULO_CMD","MRES_CMD","MULTIPLICITY_CMD",
500	"ORD_CMD","PAR_CMD","PARDEG_CMD","PREIMAGE_CMD","QUOTIENT_CMD","QHWEIGHT_CMD",
501	"REDUCE_CMD","REGULARITY_CMD","RES_CMD","SIMPLIFY_CMD","SORTVEC_CMD","SRES_CMD",
502	"STD_CMD","SUBST_CMD","SYZYGY_CMD","VAR_CMD","VDIM_CMD","WEDGE_CMD","WEIGHT_CMD",
503	"VALTVARS","VMAXDEG","VMAXMULT","VNOETHER","VMINPOLY","END_RING","CMD_1","CMD_2",
504	"CMD_3","CMD_12","CMD_13","CMD_23","CMD_123","CMD_M","ROOT_DECL","ROOT_DECL_LIST",
505	"RING_DECL","EXAMPLE_CMD","EXPORT_CMD","HELP_CMD","KILL_CMD","LIB_CMD","LISTVAR_CMD",
506	"SETRING_CMD","TYPE_CMD","STRINGTOK","BLOCKTOK","INT_CONST","UNKNOWN_IDENT",
507	"RINGVAR","PROC_DEF","BREAK_CMD","CONTINUE_CMD","ELSE_CMD","EVAL","QUOTE","FOR_CMD",
508	"IF_CMD","SYS_BREAK","WHILE_CMD","RETURN","PARAMETER","SYSVAR","'='","'<'","'>'",
509	"'+'","'-'","'/'","'['","']'","'^'","','","';'","'&'","':'","'*'","UMINUS","'('",
510	"')'","'`'","lines","pprompt","flowctrl","example_dummy","command","assign",
511	"elemexpr","exprlist","expr","@1","quote_start","quote_end","expr_arithmetic",
512	"left_value","extendedid","currring_lists","declare_ip_variable","stringexpr",
513	"rlist","ordername","orderelem","OrderingList","ordering","cmdeq","filecmd",
514	"@2","helpcmd","examplecmd","exportcmd","killcmd","listcmd","ringcmd1","ringcmd",
515	"scriptcmd","setrings","setringcmd","typecmd","ifcmd","whilecmd","forcmd","proccmd",
516	"parametercmd","returncmd", NULL
517	};
518	#endif
519
520	static const short yyr1[] = { 0,
521	142, 142, 143, 143, 143, 143, 143, 143, 143, 144,
522	144, 144, 144, 144, 144, 144, 144, 145, 146, 146,
523	146, 146, 146, 146, 146, 146, 146, 147, 148, 148,
524	148, 148, 148, 148, 148, 148, 148, 149, 149, 150,
525	150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
526	150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
527	150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
528	150, 150, 151, 150, 152, 153, 154, 154, 154, 154,
529	154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
530	155, 155, 156, 156, 157, 157, 158, 158, 158, 158,
531	158, 158, 158, 158, 158, 158, 159, 160, 160, 161,
532	162, 162, 163, 163, 164, 164, 165, 167, 166, 168,
533	168, 169, 170, 171, 171, 172, 172, 172, 172, 172,
534	172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
535	172, 172, 172, 173, 174, 174, 175, 176, 176, 177,
536	178, 178, 179, 179, 179, 179, 179, 180, 181, 182,
537	182, 182, 183, 183, 184, 184
538	};
539
540	static const short yyr2[] = { 0,
541	0, 2, 1, 2, 2, 1, 1, 1, 2, 1,
542	1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
543	1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
544	3, 3, 4, 3, 1, 1, 1, 3, 1, 1,
545	1, 3, 6, 4, 4, 4, 3, 4, 4, 3,
546	4, 6, 8, 6, 8, 4, 4, 6, 4, 6,
547	8, 8, 3, 4, 8, 4, 8, 4, 8, 4,
548	3, 5, 0, 5, 2, 1, 2, 2, 3, 3,
549	3, 3, 3, 3, 3, 3, 3, 3, 2, 2,
550	2, 2, 1, 3, 1, 1, 2, 2, 2, 2,
551	8, 2, 8, 2, 3, 2, 1, 1, 5, 1,
552	1, 4, 1, 3, 1, 3, 1, 0, 4, 3,
553	2, 3, 2, 2, 3, 4, 4, 4, 4, 4,
554	4, 4, 4, 4, 6, 6, 6, 6, 6, 6,
555	6, 6, 3, 1, 8, 2, 2, 1, 1, 2,
556	2, 1, 5, 2, 5, 1, 1, 3, 5, 3,
557	3, 4, 2, 2, 4, 3
558	};
559
560	static const short yydefact[] = { 1,
561	0, 0, 0, 0, 0, 144, 95, 0, 96, 149,
562	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
563	0, 0, 0, 0, 0, 0, 148, 0, 107, 35,
564	93, 29, 0, 156, 157, 0, 0, 0, 0, 0,
565	7, 0, 0, 0, 36, 0, 0, 0, 8, 0,
566	0, 2, 3, 12, 0, 19, 41, 152, 39, 0,
567	40, 0, 30, 0, 0, 37, 15, 16, 17, 20,
568	21, 22, 0, 24, 25, 0, 26, 27, 10, 11,
569	13, 14, 23, 6, 9, 0, 0, 0, 0, 0,
570	0, 36, 89, 0, 0, 104, 106, 30, 0, 0,
571	102, 0, 0, 0, 0, 0, 0, 0, 0, 0,
572	97, 0, 98, 0, 99, 0, 18, 123, 0, 121,
573	124, 0, 151, 0, 154, 73, 75, 0, 0, 0,
574	0, 0, 164, 163, 147, 118, 90, 0, 0, 0,
575	4, 0, 0, 92, 0, 0, 0, 78, 0, 77,
576	0, 0, 0, 0, 0, 0, 0, 0, 0, 28,
577	0, 100, 117, 0, 5, 91, 0, 146, 150, 0,
578	0, 160, 0, 108, 0, 0, 0, 0, 0, 0,
579	0, 0, 0, 0, 63, 0, 0, 47, 0, 0,
580	122, 120, 0, 0, 0, 0, 0, 0, 0, 143,
581	0, 0, 0, 161, 0, 0, 0, 158, 166, 0,
582	0, 34, 42, 94, 31, 32, 0, 38, 87, 86,
583	85, 83, 79, 80, 81, 0, 82, 84, 88, 0,
584	76, 71, 50, 0, 105, 125, 0, 0, 68, 0,
585	39, 70, 0, 0, 66, 0, 51, 0, 0, 0,
586	56, 0, 57, 0, 0, 59, 64, 45, 46, 48,
587	132, 133, 130, 131, 126, 127, 128, 0, 134, 129,
588	162, 0, 0, 0, 165, 119, 33, 44, 0, 0,
589	49, 108, 0, 0, 0, 0, 0, 0, 0, 0,
590	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
591	0, 0, 0, 74, 159, 153, 155, 0, 72, 0,
592	0, 0, 0, 0, 0, 0, 52, 0, 58, 0,
593	0, 54, 0, 60, 141, 142, 139, 140, 135, 136,
594	137, 138, 43, 0, 0, 0, 109, 110, 0, 111,
595	115, 0, 0, 0, 0, 0, 0, 0, 0, 67,
596	103, 113, 0, 0, 69, 65, 101, 53, 61, 55,
597	62, 145, 0, 116, 0, 114, 112, 0, 0
598	};
599
600	static const short yydefgoto[] = { 1,
601	52, 53, 54, 55, 56, 57, 139, 59, 205, 60,
602	232, 61, 62, 63, 94, 65, 66, 175, 340, 341,
603	353, 342, 166, 67, 211, 68, 69, 70, 71, 72,
604	73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
605	83, 84
606	};
607
608	static const short yypact[] = {-32768,
609	276, -125, 1218, 631, 214, -111,-32768, 800,-32768,-32768,
610	-62, -59, -55, -54, -51, -48, -42, -41, 805, 876,
611	931, -52, 1218, -105, 214, -40,-32768, 1218,-32768,-32768,
612	-32768,-32768, -19,-32768,-32768, -7, -38, -37, 0, -34,
613	-32768, 6, -25, 882, 13, 13, 1218, 1218,-32768, 1218,
614	1218,-32768,-32768,-32768, 11,-32768, -5, -119, 1632, 1218,
615	-32768, 1218,-32768, 988, -108,-32768,-32768,-32768,-32768,-32768,
616	-18,-32768, 214,-32768,-32768, 1218,-32768,-32768,-32768,-32768,
617	-32768,-32768,-32768,-32768,-32768, 27, -111, 29, 38, 41,
618	54,-32768, 60, 55, 1218, 9, -5, 39, 1273, 1218,
619	20, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 937, 1218,
620	-5, 994, -5, 1218, -5, 23,-32768, 65, 69,-32768,
621	-5, 1706, 1632, -35,-32768,-32768,-32768, 46, 1218, 98,
622	1049, 214, 1632, 73,-32768,-32768, 60, -65, -103, 8,
623	-32768, 214, 1106,-32768, 1218, 1218, 1218,-32768, 1218,-32768,
624	1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 72, 65,
625	1161, -5,-32768, 214,-32768,-32768, 214, -8, 1632, 86,
626	1218,-32768, 1218, 443, 76, 100, 1218, 473, 1328, 1340,
627	175, 309, 1368, 339,-32768, -98, 487,-32768, -92, 501,
628	-32768,-32768, 70, 77, 80, 84, 91, 99, 101,-32768,
629	48, 102, 131,-32768, 1218, 140, 515,-32768,-32768, -90,
630	117,-32768,-32768,-32768,-32768,-32768, -88, 1632, 1644, 463,
631	463, 26, 227, 227, 60, 1313, -3, 1656, 227, 1218,
632	-32768,-32768,-32768, -84, -5, -5, 1273, 1218,-32768, 1383,
633	1395,-32768, 1273, 1218,-32768, 1412,-32768, 1218, 1218, 1218,
634	-32768, 1218,-32768, 1218, 1218,-32768,-32768,-32768,-32768,-32768,
635	-32768,-32768,-32768,-32768,-32768,-32768,-32768, 230,-32768,-32768,
636	-32768, 552, 145, -49,-32768,-32768,-32768,-32768, 1218, 577,
637	-32768, 1632, 120, 1424, 124, 1218, 125, 1474, 127, 649,
638	1558, 663, 1570, 404, 418, 119, 123, 129, 134, 138,
639	139, 141, 142,-32768,-32768,-32768,-32768, 1582,-32768, 1273,
640	1218, 1218, -80, -107, 1218, 1218,-32768, 1218,-32768, 1218,
641	1218,-32768, 1218,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
642	-32768,-32768,-32768, 132, 686, 1608,-32768,-32768, 151, 144,
643	-32768, 146, 711, 1620, 725, 739, 753, 797, -107,-32768,
644	-32768, 147, 148, 1218,-32768,-32768,-32768,-32768,-32768,-32768,
645	-32768,-32768, 151,-32768, -76,-32768,-32768, 264,-32768
646	};
647
648	static const short yypgoto[] = {-32768,
649	-32768,-32768,-32768,-32768,-32768, 19, -1, 18,-32768,-32768,
650	-9,-32768,-32768, 282, 7, 248, 28, -224,-32768, -329,
651	-69, -50, 130,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
652	-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
653	-32768,-32768
654	};
655
656
657	#define YYLAST 1847
658
659
660	static const short yytable[] = { 58,
661	119, 338, 142, 148, 144, 142, 150, 64, 85, 352,
662	146, 147, 283, 145, 148, 163, 149, 150, 287, 142,
663	93, 118, 96, 97, 164, 165, 101, 99, 120, 145,
664	142, 339, 148, 352, 145, 150, 213, 111, 113, 115,
665	145, 257, 145, 121, 145, 123, 138, 259, 145, 275,
666	64, 277, 145, 116, 117, 281, 145, 306, 142, 337,
667	160, 133, 307, 367, 137, 212, 148, 145, 140, 150,
668	203, 204, 135, 136, 146, 147, 102, 159, 148, 103,
669	149, 150, 162, 104, 105, 334, 124, 106, 146, 147,
670	107, 168, 148, 169, 149, 150, 108, 109, 122, 125,
671	126, 127, 146, 147, 129, 128, 148, 186, 149, 150,
672	189, 130, 170, 131, 167, 163, 174, 176, 29, 178,
673	179, 180, 181, 182, 183, 184, 155, 187, 202, 210,
674	143, 190, 151, 143, 152, 153, 154, 155, 171, 156,
675	201, 217, 157, 158, 141, 172, 207, 143, 214, 177,
676	97, 206, 152, 153, 154, 155, 191, 156, 143, 234,
677	215, 158, 218, 219, 220, 95, 221, 100, 222, 223,
678	224, 225, 226, 227, 228, 229, 110, 146, 147, 112,
679	268, 148, 235, 149, 150, 236, 143, 269, 240, 155,
680	241, 156, 114, 161, 246, 230, 151, 145, 152, 153,
681	154, 155, 192, 156, 208, 164, 157, 158, 243, 261,
682	151, 231, 152, 153, 154, 155, 262, 156, 238, 263,
683	157, 158, 272, 264, 151, 239, 152, 153, 154, 155,
684	265, 156, 244, 148, 157, 158, 150, 271, 266, 245,
685	267, 270, 296, 297, 298, 273, 7, 280, 299, 9,
686	276, 305, 310, 312, 282, 284, 316, 314, 325, 338,
687	282, 288, 326, 369, 349, 290, 291, 292, 327, 293,
688	309, 294, 295, 328, 303, 368, 2, 329, 330, 363,
689	331, 332, 354, 3, 313, 355, 98, 364, 4, 5,
690	6, 134, 7, 366, 8, 9, 308, 237, 362, 151,
691	0, 152, 153, 154, 155, 0, 156, 250, 0, 157,
692	158, 146, 147, 10, 251, 148, 0, 149, 150, 29,
693	0, 30, 31, 32, 300, 301, 302, 282, 335, 336,
694	0, 0, 343, 344, 0, 345, 92, 346, 347, 0,
695	348, 146, 147, 48, 0, 148, 0, 149, 150, 0,
696	0, 0, 365, 0, 51, 154, 155, 0, 156, 0,
697	0, 0, 11, 12, 13, 14, 15, 16, 17, 18,
698	19, 20, 21, 22, 23, 24, 25, 0, 26, 27,
699	28, 29, 0, 30, 31, 32, 33, 34, 35, 36,
700	37, 38, 39, 40, 41, 42, 43, 44, 45, 0,
701	46, 0, 0, 47, 0, 48, 146, 147, 0, 49,
702	148, 0, 149, 150, 50, 0, 51, 0, 0, 0,
703	146, 147, 0, 0, 148, 0, 149, 150, 0, 0,
704	0, 0, 0, 151, 0, 152, 153, 154, 155, 0,
705	156, 252, 0, 157, 158, 146, 147, 0, 253, 148,
706	0, 149, 150, 0, 0, 0, 0, 0, 0, 0,
707	0, 0, 0, 151, 0, 152, 153, 154, 155, 148,
708	156, 255, 150, 157, 158, 146, 147, 0, 256, 148,
709	0, 149, 150, 0, 0, 0, 0, 0, 0, 146,
710	147, 0, 0, 148, 0, 149, 150, 0, 0, 0,
711	0, 0, 0, 146, 147, 0, 0, 148, 0, 149,
712	150, 0, 0, 0, 0, 0, 0, 146, 147, 0,
713	0, 148, 0, 149, 150, 0, 0, 0, 151, 0,
714	152, 153, 154, 155, 0, 156, 321, 0, 157, 158,
715	0, 0, 151, 322, 152, 153, 154, 155, 0, 156,
716	323, 0, 157, 158, 146, 147, 0, 324, 148, 0,
717	149, 150, 0, 0, 0, 0, 0, 151, 0, 152,
718	153, 154, 155, 0, 156, 0, 0, 157, 158, 146,
719	147, 0, 242, 148, 0, 149, 150, 151, 0, 152,
720	153, 154, 155, 0, 156, 0, 0, 151, 158, 152,
721	153, 154, 155, 0, 156, 0, 0, 157, 158, 0,
722	0, 151, 247, 152, 153, 154, 155, 0, 156, 0,
723	0, 157, 158, 0, 0, 151, 258, 152, 153, 154,
724	155, 0, 156, 0, 0, 157, 158, 0, 0, 151,
725	260, 152, 153, 154, 155, 0, 156, 0, 0, 157,
726	158, 146, 147, 0, 274, 148, 0, 149, 150, 0,
727	0, 0, 0, 0, 0, 146, 147, 0, 0, 148,
728	0, 149, 150, 0, 0, 0, 151, 0, 152, 153,
729	154, 155, 0, 156, 0, 0, 157, 158, 146, 147,
730	0, 304, 148, 0, 149, 150, 0, 0, 0, 0,
731	0, 151, 0, 152, 153, 154, 155, 0, 156, 0,
732	0, 157, 158, 146, 147, 0, 231, 148, 0, 149,
733	150, 0, 0, 0, 0, 0, 0, 146, 147, 0,
734	0, 148, 0, 149, 150, 0, 29, 0, 30, 31,
735	32, 146, 147, 0, 0, 148, 0, 149, 150, 0,
736	0, 0, 0, 92, 0, 146, 147, 0, 0, 148,
737	48, 149, 150, 0, 0, 0, 0, 0, 0, 95,
738	0, 51, 0, 151, 0, 152, 153, 154, 155, 0,
739	156, 0, 0, 157, 158, 0, 0, 151, 317, 152,
740	153, 154, 155, 0, 156, 0, 0, 157, 158, 146,
741	147, 0, 319, 148, 0, 149, 150, 0, 0, 0,
742	151, 0, 152, 153, 154, 155, 0, 156, 0, 0,
743	157, 158, 0, 0, 0, 350, 0, 0, 0, 0,
744	0, 0, 0, 0, 0, 151, 0, 152, 153, 154,
745	155, 0, 156, 0, 0, 157, 158, 0, 0, 151,
746	356, 152, 153, 154, 155, 0, 156, 0, 0, 157,
747	158, 0, 0, 151, 358, 152, 153, 154, 155, 0,
748	156, 0, 0, 157, 158, 0, 0, 151, 359, 152,
749	153, 154, 155, 0, 156, 0, 0, 157, 158, 3,
750	0, 0, 360, 0, 4, 132, 87, 0, 7, 0,
751	8, 9, 0, 0, 0, 29, 0, 30, 31, 32,
752	29, 0, 30, 31, 32, 0, 0, 0, 0, 0,
753	0, 151, 92, 152, 153, 154, 155, 92, 156, 48,
754	0, 157, 158, 0, 48, 0, 361, 0, 100, 0,
755	51, 0, 0, 110, 3, 51, 0, 0, 0, 86,
756	0, 87, 0, 7, 0, 88, 9, 0, 0, 0,
757	0, 0, 0, 0, 0, 0, 0, 0, 11, 12,
758	13, 14, 15, 16, 17, 18, 19, 20, 21, 0,
759	0, 29, 0, 30, 31, 32, 0, 29, 0, 30,
760	31, 32, 0, 0, 0, 0, 37, 38, 92, 0,
761	0, 3, 0, 0, 92, 48, 86, 0, 87, 47,
762	7, 48, 88, 9, 112, 0, 51, 0, 0, 0,
763	50, 0, 51, 11, 12, 13, 14, 15, 16, 17,
764	18, 89, 90, 91, 0, 0, 29, 0, 30, 31,
765	32, 0, 29, 0, 30, 31, 32, 0, 0, 0,
766	0, 37, 38, 92, 0, 0, 3, 0, 0, 92,
767	48, 86, 0, 87, 47, 7, 48, 88, 9, 114,
768	0, 51, 0, 0, 0, 50, 185, 51, 0, 0,
769	11, 12, 13, 14, 15, 16, 17, 18, 89, 90,
770	91, 0, 0, 29, 0, 30, 31, 32, 0, 29,
771	0, 30, 31, 32, 0, 0, 0, 0, 37, 38,
772	92, 0, 0, 3, 0, 0, 92, 48, 86, 0,
773	87, 47, 7, 48, 88, 9, 161, 0, 51, 0,
774	0, 0, 50, 188, 51, 11, 12, 13, 14, 15,
775	16, 17, 18, 89, 90, 91, 0, 0, 0, 0,
776	0, 0, 0, 0, 29, 0, 30, 31, 32, 0,
777	0, 0, 0, 37, 38, 0, 0, 0, 3, 0,
778	0, 92, 0, 86, 0, 87, 47, 7, 48, 88,
779	9, 0, 0, 0, 0, 0, 0, 50, 209, 51,
780	0, 0, 11, 12, 13, 14, 15, 16, 17, 18,
781	89, 90, 91, 0, 0, 0, 0, 0, 0, 0,
782	0, 29, 0, 30, 31, 32, 0, 0, 0, 0,
783	37, 38, 0, 0, 0, 3, 0, 0, 92, 0,
784	86, 0, 87, 47, 7, 48, 88, 9, 0, 0,
785	0, 0, 0, 0, 50, 216, 51, 11, 12, 13,
786	14, 15, 16, 17, 18, 89, 90, 91, 0, 0,
787	0, 0, 0, 0, 0, 0, 29, 0, 30, 31,
788	32, 0, 0, 0, 0, 37, 38, 0, 0, 0,
789	3, 0, 0, 92, 0, 86, 0, 87, 47, 7,
790	48, 88, 9, 0, 0, 0, 0, 0, 0, 50,
791	233, 51, 0, 0, 11, 12, 13, 14, 15, 16,
792	17, 18, 89, 90, 91, 146, 147, 0, 0, 148,
793	0, 149, 150, 29, 0, 30, 31, 32, 0, 0,
794	146, 147, 37, 38, 148, 0, 149, 150, 0, 0,
795	92, 0, 146, 147, 0, 47, 148, 48, 149, 150,
796	0, 0, 0, 0, 0, 0, 50, 0, 51, 11,
797	12, 13, 14, 15, 16, 17, 18, 89, 90, 91,
798	146, 147, 0, 0, 148, 0, 149, 150, 29, 0,
799	30, 31, 32, 0, 0, 146, 147, 37, 38, 148,
800	0, 149, 150, 0, 0, 92, 0, 146, 147, 0,
801	47, 148, 48, 149, 150, 0, 0, 0, 0, 0,
802	0, 173, 0, 51, 146, 147, 0, 0, 148, 0,
803	149, 150, 0, 0, 0, 0, 146, 147, 0, 0,
804	148, 0, 149, 150, 0, 0, 0, 151, 0, 152,
805	153, 154, 155, 278, 156, 279, 0, 157, 158, 0,
806	0, 0, 151, 0, 152, 153, 154, 155, 0, 156,
807	248, 0, 157, 158, 151, 0, 152, 153, 154, 155,
808	0, 156, 249, 0, 157, 158, 146, 147, 0, 0,
809	148, 0, 149, 150, 0, 0, 0, 0, 0, 0,
810	0, 0, 151, 0, 152, 153, 154, 155, 0, 156,
811	254, 0, 157, 158, 0, 0, 0, 151, 0, 152,
812	153, 154, 155, 285, 156, 0, 0, 157, 158, 151,
813	0, 152, 153, 154, 155, 0, 156, 286, 0, 157,
814	158, 0, 0, 0, 0, 0, 151, 0, 152, 153,
815	154, 155, 289, 156, 0, 0, 157, 158, 151, 0,
816	152, 153, 154, 155, 0, 156, 311, 0, 157, 158,
817	146, 147, 0, 0, 148, 0, 149, 150, 0, 0,
818	0, 0, 146, 147, 0, 0, 148, 0, 149, 150,
819	0, 0, 0, 0, 146, 147, 0, 0, 148, 0,
820	149, 150, 0, 0, 0, 0, 0, 0, 151, 0,
821	152, 153, 154, 155, 0, 156, 315, 0, 157, 158,
822	146, 147, 0, 0, 148, 0, 149, 150, 0, 0,
823	0, 0, 146, 147, 0, 0, 148, 0, 149, 150,
824	0, 0, 0, 0, 146, 147, 0, 0, 148, 0,
825	149, 150, 0, 0, 0, 0,-32768, 147, 0, 0,
826	148, 0, 149, 150, 0, 0, 0, 0, 0, 147,
827	0, 0, 148, 0, 149, 150, 0, 0, 0, 0,
828	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
829	0, 0, 151, 0, 152, 153, 154, 155, 0, 156,
830	318, 0, 157, 158, 151, 0, 152, 153, 154, 155,
831	0, 156, 320, 0, 157, 158, 151, 0, 152, 153,
832	154, 155, 333, 156, 0, 0, 157, 158, 193, 194,
833	195, 0, 7, 0, 196, 9, 0, 0, 0, 0,
834	0, 0, 151, 0, 152, 153, 154, 155, 351, 156,
835	0, 0, 157, 158, 151, 0, 152, 153, 154, 155,
836	357, 156, 0, 0, 157, 158, 151, 0, 152, 153,
837	154, 155, 0, 156, 0, 0, 157, 158, 151, 0,
838	152, 153, 154, 155, 0, 156, 0, 0, 157, 158,
839	151, 0, 152, 153, 154, 155, 0, 156, 0, 0,
840	0, 158, 0, 0, 0, 0, 0, 0, 0, 0,
841	197, 198, 199, 0, 0, 0, 0, 0, 0, 0,
842	0, 29, 0, 30, 31, 32, 0, 0, 0, 0,
843	0, 0, 0, 0, 0, 0, 0, 0, 92, 0,
844	0, 0, 0, 0, 0, 48, 0, 0, 0, 0,
845	0, 0, 0, 0, 0, 200, 51
846	};
847
848	static const short yycheck[] = { 1,
849	106, 109, 11, 7, 124, 11, 10, 1, 134, 339,
850	3, 4, 237, 133, 7, 124, 9, 10, 243, 11,
851	3, 23, 4, 5, 133, 134, 8, 139, 134, 133,
852	11, 139, 7, 363, 133, 10, 140, 19, 20, 21,
853	133, 140, 133, 25, 133, 28, 48, 140, 133, 140,
854	44, 140, 133, 106, 107, 140, 133, 107, 11, 140,
855	62, 44, 112, 140, 47, 131, 7, 133, 51, 10,
856	106, 107, 45, 46, 3, 4, 139, 60, 7, 139,
857	9, 10, 64, 139, 139, 310, 106, 139, 3, 4,
858	139, 73, 7, 76, 9, 10, 139, 139, 139, 107,
859	139, 139, 3, 4, 139, 106, 7, 109, 9, 10,
860	112, 106, 95, 139, 133, 124, 99, 100, 106, 102,
861	103, 104, 105, 106, 107, 108, 130, 110, 122, 131,
862	139, 114, 125, 139, 127, 128, 129, 130, 130, 132,
863	122, 143, 135, 136, 134, 107, 129, 139, 141, 130,
864	132, 106, 127, 128, 129, 130, 134, 132, 139, 161,
865	142, 136, 145, 146, 147, 139, 149, 139, 151, 152,
866	153, 154, 155, 156, 157, 158, 139, 3, 4, 139,
867	133, 7, 164, 9, 10, 167, 139, 140, 171, 130,
868	173, 132, 139, 139, 177, 124, 125, 133, 127, 128,
869	129, 130, 134, 132, 107, 133, 135, 136, 133, 140,
870	125, 140, 127, 128, 129, 130, 140, 132, 133, 140,
871	135, 136, 205, 140, 125, 140, 127, 128, 129, 130,
872	140, 132, 133, 7, 135, 136, 10, 107, 140, 140,
873	140, 140, 13, 14, 15, 106, 17, 230, 19, 20,
874	134, 107, 133, 130, 237, 238, 130, 133, 140, 109,
875	243, 244, 140, 0, 133, 248, 249, 250, 140, 252,
876	280, 254, 255, 140, 268, 0, 1, 140, 140, 133,
877	140, 140, 139, 8, 286, 140, 5, 140, 13, 14,
878	15, 44, 17, 363, 19, 20, 279, 168, 349, 125,
879	-1, 127, 128, 129, 130, -1, 132, 133, -1, 135,
880	136, 3, 4, 38, 140, 7, -1, 9, 10, 106,
881	-1, 108, 109, 110, 95, 96, 97, 310, 311, 312,
882	-1, -1, 315, 316, -1, 318, 123, 320, 321, -1,
883	323, 3, 4, 130, -1, 7, -1, 9, 10, -1,
884	-1, -1, 354, -1, 141, 129, 130, -1, 132, -1,
885	-1, -1, 87, 88, 89, 90, 91, 92, 93, 94,
886	95, 96, 97, 98, 99, 100, 101, -1, 103, 104,
887	105, 106, -1, 108, 109, 110, 111, 112, 113, 114,
888	115, 116, 117, 118, 119, 120, 121, 122, 123, -1,
889	125, -1, -1, 128, -1, 130, 3, 4, -1, 134,
890	7, -1, 9, 10, 139, -1, 141, -1, -1, -1,
891	3, 4, -1, -1, 7, -1, 9, 10, -1, -1,
892	-1, -1, -1, 125, -1, 127, 128, 129, 130, -1,
893	132, 133, -1, 135, 136, 3, 4, -1, 140, 7,
894	-1, 9, 10, -1, -1, -1, -1, -1, -1, -1,
895	-1, -1, -1, 125, -1, 127, 128, 129, 130, 7,
896	132, 133, 10, 135, 136, 3, 4, -1, 140, 7,
897	-1, 9, 10, -1, -1, -1, -1, -1, -1, 3,
898	4, -1, -1, 7, -1, 9, 10, -1, -1, -1,
899	-1, -1, -1, 3, 4, -1, -1, 7, -1, 9,
900	10, -1, -1, -1, -1, -1, -1, 3, 4, -1,
901	-1, 7, -1, 9, 10, -1, -1, -1, 125, -1,
902	127, 128, 129, 130, -1, 132, 133, -1, 135, 136,
903	-1, -1, 125, 140, 127, 128, 129, 130, -1, 132,
904	133, -1, 135, 136, 3, 4, -1, 140, 7, -1,
905	9, 10, -1, -1, -1, -1, -1, 125, -1, 127,
906	128, 129, 130, -1, 132, -1, -1, 135, 136, 3,
907	4, -1, 140, 7, -1, 9, 10, 125, -1, 127,
908	128, 129, 130, -1, 132, -1, -1, 125, 136, 127,
909	128, 129, 130, -1, 132, -1, -1, 135, 136, -1,
910	-1, 125, 140, 127, 128, 129, 130, -1, 132, -1,
911	-1, 135, 136, -1, -1, 125, 140, 127, 128, 129,
912	130, -1, 132, -1, -1, 135, 136, -1, -1, 125,
913	140, 127, 128, 129, 130, -1, 132, -1, -1, 135,
914	136, 3, 4, -1, 140, 7, -1, 9, 10, -1,
915	-1, -1, -1, -1, -1, 3, 4, -1, -1, 7,
916	-1, 9, 10, -1, -1, -1, 125, -1, 127, 128,
917	129, 130, -1, 132, -1, -1, 135, 136, 3, 4,
918	-1, 140, 7, -1, 9, 10, -1, -1, -1, -1,
919	-1, 125, -1, 127, 128, 129, 130, -1, 132, -1,
920	-1, 135, 136, 3, 4, -1, 140, 7, -1, 9,
921	10, -1, -1, -1, -1, -1, -1, 3, 4, -1,
922	-1, 7, -1, 9, 10, -1, 106, -1, 108, 109,
923	110, 3, 4, -1, -1, 7, -1, 9, 10, -1,
924	-1, -1, -1, 123, -1, 3, 4, -1, -1, 7,
925	130, 9, 10, -1, -1, -1, -1, -1, -1, 139,
926	-1, 141, -1, 125, -1, 127, 128, 129, 130, -1,
927	132, -1, -1, 135, 136, -1, -1, 125, 140, 127,
928	128, 129, 130, -1, 132, -1, -1, 135, 136, 3,
929	4, -1, 140, 7, -1, 9, 10, -1, -1, -1,
930	125, -1, 127, 128, 129, 130, -1, 132, -1, -1,
931	135, 136, -1, -1, -1, 140, -1, -1, -1, -1,
932	-1, -1, -1, -1, -1, 125, -1, 127, 128, 129,
933	130, -1, 132, -1, -1, 135, 136, -1, -1, 125,
934	140, 127, 128, 129, 130, -1, 132, -1, -1, 135,
935	136, -1, -1, 125, 140, 127, 128, 129, 130, -1,
936	132, -1, -1, 135, 136, -1, -1, 125, 140, 127,
937	128, 129, 130, -1, 132, -1, -1, 135, 136, 8,
938	-1, -1, 140, -1, 13, 14, 15, -1, 17, -1,
939	19, 20, -1, -1, -1, 106, -1, 108, 109, 110,
940	106, -1, 108, 109, 110, -1, -1, -1, -1, -1,
941	-1, 125, 123, 127, 128, 129, 130, 123, 132, 130,
942	-1, 135, 136, -1, 130, -1, 140, -1, 139, -1,
943	141, -1, -1, 139, 8, 141, -1, -1, -1, 13,
944	-1, 15, -1, 17, -1, 19, 20, -1, -1, -1,
945	-1, -1, -1, -1, -1, -1, -1, -1, 87, 88,
946	89, 90, 91, 92, 93, 94, 95, 96, 97, -1,
947	-1, 106, -1, 108, 109, 110, -1, 106, -1, 108,
948	109, 110, -1, -1, -1, -1, 115, 116, 123, -1,
949	-1, 8, -1, -1, 123, 130, 13, -1, 15, 128,
950	17, 130, 19, 20, 139, -1, 141, -1, -1, -1,
951	139, -1, 141, 87, 88, 89, 90, 91, 92, 93,
952	94, 95, 96, 97, -1, -1, 106, -1, 108, 109,
953	110, -1, 106, -1, 108, 109, 110, -1, -1, -1,
954	-1, 115, 116, 123, -1, -1, 8, -1, -1, 123,
955	130, 13, -1, 15, 128, 17, 130, 19, 20, 139,
956	-1, 141, -1, -1, -1, 139, 140, 141, -1, -1,
957	87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
958	97, -1, -1, 106, -1, 108, 109, 110, -1, 106,
959	-1, 108, 109, 110, -1, -1, -1, -1, 115, 116,
960	123, -1, -1, 8, -1, -1, 123, 130, 13, -1,
961	15, 128, 17, 130, 19, 20, 139, -1, 141, -1,
962	-1, -1, 139, 140, 141, 87, 88, 89, 90, 91,
963	92, 93, 94, 95, 96, 97, -1, -1, -1, -1,
964	-1, -1, -1, -1, 106, -1, 108, 109, 110, -1,
965	-1, -1, -1, 115, 116, -1, -1, -1, 8, -1,
966	-1, 123, -1, 13, -1, 15, 128, 17, 130, 19,
967	20, -1, -1, -1, -1, -1, -1, 139, 140, 141,
968	-1, -1, 87, 88, 89, 90, 91, 92, 93, 94,
969	95, 96, 97, -1, -1, -1, -1, -1, -1, -1,
970	-1, 106, -1, 108, 109, 110, -1, -1, -1, -1,
971	115, 116, -1, -1, -1, 8, -1, -1, 123, -1,
972	13, -1, 15, 128, 17, 130, 19, 20, -1, -1,
973	-1, -1, -1, -1, 139, 140, 141, 87, 88, 89,
974	90, 91, 92, 93, 94, 95, 96, 97, -1, -1,
975	-1, -1, -1, -1, -1, -1, 106, -1, 108, 109,
976	110, -1, -1, -1, -1, 115, 116, -1, -1, -1,
977	8, -1, -1, 123, -1, 13, -1, 15, 128, 17,
978	130, 19, 20, -1, -1, -1, -1, -1, -1, 139,
979	140, 141, -1, -1, 87, 88, 89, 90, 91, 92,
980	93, 94, 95, 96, 97, 3, 4, -1, -1, 7,
981	-1, 9, 10, 106, -1, 108, 109, 110, -1, -1,
982	3, 4, 115, 116, 7, -1, 9, 10, -1, -1,
983	123, -1, 3, 4, -1, 128, 7, 130, 9, 10,
984	-1, -1, -1, -1, -1, -1, 139, -1, 141, 87,
985	88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
986	3, 4, -1, -1, 7, -1, 9, 10, 106, -1,
987	108, 109, 110, -1, -1, 3, 4, 115, 116, 7,
988	-1, 9, 10, -1, -1, 123, -1, 3, 4, -1,
989	128, 7, 130, 9, 10, -1, -1, -1, -1, -1,
990	-1, 139, -1, 141, 3, 4, -1, -1, 7, -1,
991	9, 10, -1, -1, -1, -1, 3, 4, -1, -1,
992	7, -1, 9, 10, -1, -1, -1, 125, -1, 127,
993	128, 129, 130, 131, 132, 133, -1, 135, 136, -1,
994	-1, -1, 125, -1, 127, 128, 129, 130, -1, 132,
995	133, -1, 135, 136, 125, -1, 127, 128, 129, 130,
996	-1, 132, 133, -1, 135, 136, 3, 4, -1, -1,
997	7, -1, 9, 10, -1, -1, -1, -1, -1, -1,
998	-1, -1, 125, -1, 127, 128, 129, 130, -1, 132,
999	133, -1, 135, 136, -1, -1, -1, 125, -1, 127,
1000	128, 129, 130, 131, 132, -1, -1, 135, 136, 125,
1001	-1, 127, 128, 129, 130, -1, 132, 133, -1, 135,
1002	136, -1, -1, -1, -1, -1, 125, -1, 127, 128,
1003	129, 130, 131, 132, -1, -1, 135, 136, 125, -1,
1004	127, 128, 129, 130, -1, 132, 133, -1, 135, 136,
1005	3, 4, -1, -1, 7, -1, 9, 10, -1, -1,
1006	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1007	-1, -1, -1, -1, 3, 4, -1, -1, 7, -1,
1008	9, 10, -1, -1, -1, -1, -1, -1, 125, -1,
1009	127, 128, 129, 130, -1, 132, 133, -1, 135, 136,
1010	3, 4, -1, -1, 7, -1, 9, 10, -1, -1,
1011	-1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1012	-1, -1, -1, -1, 3, 4, -1, -1, 7, -1,
1013	9, 10, -1, -1, -1, -1, 3, 4, -1, -1,
1014	7, -1, 9, 10, -1, -1, -1, -1, -1, 4,
1015	-1, -1, 7, -1, 9, 10, -1, -1, -1, -1,
1016	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1017	-1, -1, 125, -1, 127, 128, 129, 130, -1, 132,
1018	133, -1, 135, 136, 125, -1, 127, 128, 129, 130,
1019	-1, 132, 133, -1, 135, 136, 125, -1, 127, 128,
1020	129, 130, 131, 132, -1, -1, 135, 136, 13, 14,
1021	15, -1, 17, -1, 19, 20, -1, -1, -1, -1,
1022	-1, -1, 125, -1, 127, 128, 129, 130, 131, 132,
1023	-1, -1, 135, 136, 125, -1, 127, 128, 129, 130,
1024	131, 132, -1, -1, 135, 136, 125, -1, 127, 128,
1025	129, 130, -1, 132, -1, -1, 135, 136, 125, -1,
1026	127, 128, 129, 130, -1, 132, -1, -1, 135, 136,
1027	125, -1, 127, 128, 129, 130, -1, 132, -1, -1,
1028	-1, 136, -1, -1, -1, -1, -1, -1, -1, -1,
1029	95, 96, 97, -1, -1, -1, -1, -1, -1, -1,
1030	-1, 106, -1, 108, 109, 110, -1, -1, -1, -1,
1031	-1, -1, -1, -1, -1, -1, -1, -1, 123, -1,
1032	-1, -1, -1, -1, -1, 130, -1, -1, -1, -1,
1033	-1, -1, -1, -1, -1, 140, 141
1034	};
1035	#define YYPURE 1
1036
1037	/* --C-- Note some compilers choke on comments on `#line' lines. */
1038	#line 3 "/usr/lib/bison.simple"
1039	/* This file comes from bison-1.28. */
1040
1041	/* Skeleton output parser for bison,
1042	Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
1043
1044	This program is free software; you can redistribute it and/or modify
1045	it under the terms of the GNU General Public License as published by
1046	the Free Software Foundation; either version 2, or (at your option)
1047	any later version.
1048
1049	This program is distributed in the hope that it will be useful,
1050	but WITHOUT ANY WARRANTY; without even the implied warranty of
1051	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1052	GNU General Public License for more details.
1053
1054	You should have received a copy of the GNU General Public License
1055	along with this program; if not, write to the Free Software
1056	Foundation, Inc., 59 Temple Place - Suite 330,
1057	Boston, MA 02111-1307, USA. */
1058
1059	/* As a special exception, when this file is copied by Bison into a
1060	Bison output file, you may use that output file without restriction.
1061	This special exception was added by the Free Software Foundation
1062	in version 1.24 of Bison. */
1063
1064	/* This is the parser code that is written into each bison parser
1065	when the %semantic_parser declaration is not specified in the grammar.
1066	It was written by Richard Stallman by simplifying the hairy parser
1067	used when %semantic_parser is specified. */
1068
1069	#ifndef YYSTACK_USE_ALLOCA
1070	#ifdef alloca
1071	#define YYSTACK_USE_ALLOCA
1072	#else /* alloca not defined */
1073	#ifdef __GNUC__
1074	#define YYSTACK_USE_ALLOCA
1075	#define alloca __builtin_alloca
1076	#else /* not GNU C. */
1077	#if (!defined (__STDC__) && defined (sparc)) \|\| defined (__sparc__) \|\| defined (__sparc) \|\| defined (__sgi) \|\| (defined (__sun) && defined (__i386))
1078	#define YYSTACK_USE_ALLOCA
1079	#include <alloca.h>
1080	#else /* not sparc */
1081	/* We think this test detects Watcom and Microsoft C. */
1082	/* This used to test MSDOS, but that is a bad idea
1083	since that symbol is in the user namespace. */
1084	#if (defined (_MSDOS) \|\| defined (_MSDOS_)) && !defined (__TURBOC__)
1085	#if 0 /* No need for malloc.h, which pollutes the namespace;
1086	instead, just don't use alloca. */
1087	#include <malloc.h>
1088	#endif
1089	#else /* not MSDOS, or __TURBOC__ */
1090	#if defined(_AIX)
1091	/* I don't know what this was needed for, but it pollutes the namespace.
1092	So I turned it off. rms, 2 May 1997. */
1093	/* #include <malloc.h> */
1094	#pragma alloca
1095	#define YYSTACK_USE_ALLOCA
1096	#else /* not MSDOS, or __TURBOC__, or _AIX */
1097	#if 0
1098	#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
1099	and on HPUX 10. Eventually we can turn this on. */
1100	#define YYSTACK_USE_ALLOCA
1101	#define alloca __builtin_alloca
1102	#endif /* __hpux */
1103	#endif
1104	#endif /* not _AIX */
1105	#endif /* not MSDOS, or __TURBOC__ */
1106	#endif /* not sparc */
1107	#endif /* not GNU C */
1108	#endif /* alloca not defined */
1109	#endif /* YYSTACK_USE_ALLOCA not defined */
1110
1111	#ifdef YYSTACK_USE_ALLOCA
1112	#define YYSTACK_ALLOC alloca
1113	#else
1114	#define YYSTACK_ALLOC malloc
1115	#endif
1116
1117	/* Note: there must be only one dollar sign in this file.
1118	It is replaced by the list of actions, each action
1119	as one case of the switch. */
1120
1121	#define yyerrok (yyerrstatus = 0)
1122	#define yyclearin (yychar = YYEMPTY)
1123	#define YYEMPTY -2
1124	#define YYEOF 0
1125	#define YYACCEPT goto yyacceptlab
1126	#define YYABORT goto yyabortlab
1127	#define YYERROR goto yyerrlab1
1128	/* Like YYERROR except do call yyerror.
1129	This remains here temporarily to ease the
1130	transition to the new meaning of YYERROR, for GCC.
1131	Once GCC version 2 has supplanted version 1, this can go. */
1132	#define YYFAIL goto yyerrlab
1133	#define YYRECOVERING() (!!yyerrstatus)
1134	#define YYBACKUP(token, value) \
1135	do \
1136	if (yychar == YYEMPTY && yylen == 1) \
1137	{ yychar = (token), yylval = (value); \
1138	yychar1 = YYTRANSLATE (yychar); \
1139	YYPOPSTACK; \
1140	goto yybackup; \
1141	} \
1142	else \
1143	{ yyerror ("syntax error: cannot back up"); YYERROR; } \
1144	while (0)
1145
1146	#define YYTERROR 1
1147	#define YYERRCODE 256
1148
1149	#ifndef YYPURE
1150	#define YYLEX yylex()
1151	#endif
1152
1153	#ifdef YYPURE
1154	#ifdef YYLSP_NEEDED
1155	#ifdef YYLEX_PARAM
1156	#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
1157	#else
1158	#define YYLEX yylex(&yylval, &yylloc)
1159	#endif
1160	#else /* not YYLSP_NEEDED */
1161	#ifdef YYLEX_PARAM
1162	#define YYLEX yylex(&yylval, YYLEX_PARAM)
1163	#else
1164	#define YYLEX yylex(&yylval)
1165	#endif
1166	#endif /* not YYLSP_NEEDED */
1167	#endif
1168
1169	/* If nonreentrant, generate the variables here */
1170
1171	#ifndef YYPURE
1172
1173	int yychar; /* the lookahead symbol */
1174	YYSTYPE yylval; /* the semantic value of the */
1175	/* lookahead symbol */
1176
1177	#ifdef YYLSP_NEEDED
1178	YYLTYPE yylloc; /* location data for the lookahead */
1179	/* symbol */
1180	#endif
1181
1182	int yynerrs; /* number of parse errors so far */
1183	#endif /* not YYPURE */
1184
1185	#if YYDEBUG != 0
1186	int yydebug; /* nonzero means print parse trace */
1187	/* Since this is uninitialized, it does not stop multiple parsers
1188	from coexisting. */
1189	#endif
1190
1191	/* YYINITDEPTH indicates the initial size of the parser's stacks */
1192
1193	#ifndef YYINITDEPTH
1194	#define YYINITDEPTH 200
1195	#endif
1196
1197	/* YYMAXDEPTH is the maximum size the stacks can grow to
1198	(effective only if the built-in stack extension method is used). */
1199
1200	#if YYMAXDEPTH == 0
1201	#undef YYMAXDEPTH
1202	#endif
1203
1204	#ifndef YYMAXDEPTH
1205	#define YYMAXDEPTH 10000
1206	#endif
1207
1208	/* Define __yy_memcpy. Note that the size argument
1209	should be passed with type unsigned int, because that is what the non-GCC
1210	definitions require. With GCC, __builtin_memcpy takes an arg
1211	of type size_t, but it can handle unsigned int. */
1212
1213	#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
1214	#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
1215	#else /* not GNU C or C++ */
1216	#ifndef __cplusplus
1217
1218	/* This is the most reliable way to avoid incompatibilities
1219	in available built-in functions on various systems. */
1220	static void
1221	__yy_memcpy (to, from, count)
1222	char *to;
1223	char *from;
1224	unsigned int count;
1225	{
1226	register char *f = from;
1227	register char *t = to;
1228	register int i = count;
1229
1230	while (i-- > 0)
1231	t++ = f++;
1232	}
1233
1234	#else /* __cplusplus */
1235
1236	/* This is the most reliable way to avoid incompatibilities
1237	in available built-in functions on various systems. */
1238	static void
1239	__yy_memcpy (char to, char from, unsigned int count)
1240	{
1241	register char *t = to;
1242	register char *f = from;
1243	register int i = count;
1244
1245	while (i-- > 0)
1246	t++ = f++;
1247	}
1248
1249	#endif
1250	#endif
1251
1252	#line 217 "/usr/lib/bison.simple"
1253
1254	/* The user can define YYPARSE_PARAM as the name of an argument to be passed
1255	into yyparse. The argument should have type void *.
1256	It should actually point to an object.
1257	Grammar actions can access the variable by casting it
1258	to the proper pointer type. */
1259
1260	#ifdef YYPARSE_PARAM
1261	#ifdef __cplusplus
1262	#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
1263	#define YYPARSE_PARAM_DECL
1264	#else /* not __cplusplus */
1265	#define YYPARSE_PARAM_ARG YYPARSE_PARAM
1266	#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
1267	#endif /* not __cplusplus */
1268	#else /* not YYPARSE_PARAM */
1269	#define YYPARSE_PARAM_ARG
1270	#define YYPARSE_PARAM_DECL
1271	#endif /* not YYPARSE_PARAM */
1272
1273	/* Prevent warning if -Wstrict-prototypes. */
1274	#ifdef __GNUC__
1275	#ifdef YYPARSE_PARAM
1276	int yyparse (void *);
1277	#else
1278	int yyparse (void);
1279	#endif
1280	#endif
1281
1282	int
1283	yyparse(YYPARSE_PARAM_ARG)
1284	YYPARSE_PARAM_DECL
1285	{
1286	register int yystate;
1287	register int yyn;
1288	register short *yyssp;
1289	register YYSTYPE *yyvsp;
1290	int yyerrstatus; /* number of tokens to shift before error messages enabled */
1291	int yychar1 = 0; /* lookahead token as an internal (translated) token number */
1292
1293	short yyssa[YYINITDEPTH]; /* the state stack */
1294	YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
1295
1296	short yyss = yyssa; / refer to the stacks thru separate pointers */
1297	YYSTYPE yyvs = yyvsa; / to allow yyoverflow to reallocate them elsewhere */
1298
1299	#ifdef YYLSP_NEEDED
1300	YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
1301	YYLTYPE *yyls = yylsa;
1302	YYLTYPE *yylsp;
1303
1304	#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
1305	#else
1306	#define YYPOPSTACK (yyvsp--, yyssp--)
1307	#endif
1308
1309	int yystacksize = YYINITDEPTH;
1310	int yyfree_stacks = 0;
1311
1312	#ifdef YYPURE
1313	int yychar;
1314	YYSTYPE yylval;
1315	int yynerrs;
1316	#ifdef YYLSP_NEEDED
1317	YYLTYPE yylloc;
1318	#endif
1319	#endif
1320
1321	YYSTYPE yyval; /* the variable used to return */
1322	/* semantic values from the action */
1323	/* routines */
1324
1325	int yylen;
1326
1327	#if YYDEBUG != 0
1328	if (yydebug)
1329	fprintf(stderr, "Starting parse\n");
1330	#endif
1331
1332	yystate = 0;
1333	yyerrstatus = 0;
1334	yynerrs = 0;
1335	yychar = YYEMPTY; /* Cause a token to be read. */
1336
1337	/* Initialize stack pointers.
1338	Waste one element of value and location stack
1339	so that they stay on the same level as the state stack.
1340	The wasted elements are never initialized. */
1341
1342	yyssp = yyss - 1;
1343	yyvsp = yyvs;
1344	#ifdef YYLSP_NEEDED
1345	yylsp = yyls;
1346	#endif
1347
1348	/* Push a new state, which is found in yystate . */
1349	/* In all cases, when you get here, the value and location stacks
1350	have just been pushed. so pushing a state here evens the stacks. */
1351	yynewstate:
1352
1353	*++yyssp = yystate;
1354
1355	if (yyssp >= yyss + yystacksize - 1)
1356	{
1357	/* Give user a chance to reallocate the stack */
1358	/* Use copies of these so that the &'s don't force the real ones into memory. */
1359	YYSTYPE *yyvs1 = yyvs;
1360	short *yyss1 = yyss;
1361	#ifdef YYLSP_NEEDED
1362	YYLTYPE *yyls1 = yyls;
1363	#endif
1364
1365	/* Get the current used size of the three stacks, in elements. */
1366	int size = yyssp - yyss + 1;
1367
1368	#ifdef yyoverflow
1369	/* Each stack pointer address is followed by the size of
1370	the data in use in that stack, in bytes. */
1371	#ifdef YYLSP_NEEDED
1372	/* This used to be a conditional around just the two extra args,
1373	but that might be undefined if yyoverflow is a macro. */
1374	yyoverflow("parser stack overflow",
1375	&yyss1, size * sizeof (*yyssp),
1376	&yyvs1, size * sizeof (*yyvsp),
1377	&yyls1, size * sizeof (*yylsp),
1378	&yystacksize);
1379	#else
1380	yyoverflow("parser stack overflow",
1381	&yyss1, size * sizeof (*yyssp),
1382	&yyvs1, size * sizeof (*yyvsp),
1383	&yystacksize);
1384	#endif
1385
1386	yyss = yyss1; yyvs = yyvs1;
1387	#ifdef YYLSP_NEEDED
1388	yyls = yyls1;
1389	#endif
1390	#else /* no yyoverflow */
1391	/* Extend the stack our own way. */
1392	if (yystacksize >= YYMAXDEPTH)
1393	{
1394	yyerror("parser stack overflow");
1395	if (yyfree_stacks)
1396	{
1397	free (yyss);
1398	free (yyvs);
1399	#ifdef YYLSP_NEEDED
1400	free (yyls);
1401	#endif
1402	}
1403	return 2;
1404	}
1405	yystacksize *= 2;
1406	if (yystacksize > YYMAXDEPTH)
1407	yystacksize = YYMAXDEPTH;
1408	#ifndef YYSTACK_USE_ALLOCA
1409	yyfree_stacks = 1;
1410	#endif
1411	yyss = (short ) YYSTACK_ALLOC (yystacksize sizeof (*yyssp));
1412	__yy_memcpy ((char )yyss, (char )yyss1,
1413	size * (unsigned int) sizeof (*yyssp));
1414	yyvs = (YYSTYPE ) YYSTACK_ALLOC (yystacksize sizeof (*yyvsp));
1415	__yy_memcpy ((char )yyvs, (char )yyvs1,
1416	size * (unsigned int) sizeof (*yyvsp));
1417	#ifdef YYLSP_NEEDED
1418	yyls = (YYLTYPE ) YYSTACK_ALLOC (yystacksize sizeof (*yylsp));
1419	__yy_memcpy ((char )yyls, (char )yyls1,
1420	size * (unsigned int) sizeof (*yylsp));
1421	#endif
1422	#endif /* no yyoverflow */
1423
1424	yyssp = yyss + size - 1;
1425	yyvsp = yyvs + size - 1;
1426	#ifdef YYLSP_NEEDED
1427	yylsp = yyls + size - 1;
1428	#endif
1429
1430	#if YYDEBUG != 0
1431	if (yydebug)
1432	fprintf(stderr, "Stack size increased to %d\n", yystacksize);
1433	#endif
1434
1435	if (yyssp >= yyss + yystacksize - 1)
1436	YYABORT;
1437	}
1438
1439	#if YYDEBUG != 0
1440	if (yydebug)
1441	fprintf(stderr, "Entering state %d\n", yystate);
1442	#endif
1443
1444	goto yybackup;
1445	yybackup:
1446
1447	/* Do appropriate processing given the current state. */
1448	/* Read a lookahead token if we need one and don't already have one. */
1449	/* yyresume: */
1450
1451	/* First try to decide what to do without reference to lookahead token. */
1452
1453	yyn = yypact[yystate];
1454	if (yyn == YYFLAG)
1455	goto yydefault;
1456
1457	/* Not known => get a lookahead token if don't already have one. */
1458
1459	/* yychar is either YYEMPTY or YYEOF
1460	or a valid token in external form. */
1461
1462	if (yychar == YYEMPTY)
1463	{
1464	#if YYDEBUG != 0
1465	if (yydebug)
1466	fprintf(stderr, "Reading a token: ");
1467	#endif
1468	yychar = YYLEX;
1469	}
1470
1471	/* Convert token to internal form (in yychar1) for indexing tables with */
1472
1473	if (yychar <= 0) /* This means end of input. */
1474	{
1475	yychar1 = 0;
1476	yychar = YYEOF; /* Don't call YYLEX any more */
1477
1478	#if YYDEBUG != 0
1479	if (yydebug)
1480	fprintf(stderr, "Now at end of input.\n");
1481	#endif
1482	}
1483	else
1484	{
1485	yychar1 = YYTRANSLATE(yychar);
1486
1487	#if YYDEBUG != 0
1488	if (yydebug)
1489	{
1490	fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
1491	/* Give the individual parser a way to print the precise meaning
1492	of a token, for further debugging info. */
1493	#ifdef YYPRINT
1494	YYPRINT (stderr, yychar, yylval);
1495	#endif
1496	fprintf (stderr, ")\n");
1497	}
1498	#endif
1499	}
1500
1501	yyn += yychar1;
1502	if (yyn < 0 \|\| yyn > YYLAST \|\| yycheck[yyn] != yychar1)
1503	goto yydefault;
1504
1505	yyn = yytable[yyn];
1506
1507	/* yyn is what to do for this token type in this state.
1508	Negative => reduce, -yyn is rule number.
1509	Positive => shift, yyn is new state.
1510	New state is final state => don't bother to shift,
1511	just return success.
1512	0, or most negative number => error. */
1513
1514	if (yyn < 0)
1515	{
1516	if (yyn == YYFLAG)
1517	goto yyerrlab;
1518	yyn = -yyn;
1519	goto yyreduce;
1520	}
1521	else if (yyn == 0)
1522	goto yyerrlab;
1523
1524	if (yyn == YYFINAL)
1525	YYACCEPT;
1526
1527	/* Shift the lookahead token. */
1528
1529	#if YYDEBUG != 0
1530	if (yydebug)
1531	fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
1532	#endif
1533
1534	/* Discard the token being shifted unless it is eof. */
1535	if (yychar != YYEOF)
1536	yychar = YYEMPTY;
1537
1538	*++yyvsp = yylval;
1539	#ifdef YYLSP_NEEDED
1540	*++yylsp = yylloc;
1541	#endif
1542
1543	/* count tokens shifted since error; after three, turn off error status. */
1544	if (yyerrstatus) yyerrstatus--;
1545
1546	yystate = yyn;
1547	goto yynewstate;
1548
1549	/* Do the default action for the current state. */
1550	yydefault:
1551
1552	yyn = yydefact[yystate];
1553	if (yyn == 0)
1554	goto yyerrlab;
1555
1556	/* Do a reduction. yyn is the number of a rule to reduce with. */
1557	yyreduce:
1558	yylen = yyr2[yyn];
1559	if (yylen > 0)
1560	yyval = yyvsp[1-yylen]; /* implement default value of the action */
1561
1562	#if YYDEBUG != 0
1563	if (yydebug)
1564	{
1565	int i;
1566
1567	fprintf (stderr, "Reducing via rule %d (line %d), ",
1568	yyn, yyrline[yyn]);
1569
1570	/* Print the symbols being reduced, and their result. */
1571	for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
1572	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
1573	fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1574	}
1575	#endif
1576
1577
1578	switch (yyn) {
1579
1580	case 2:
1581	#line 369 "grammar.y"
1582	{
1583	if (timerv)
1584	{
1585	writeTime("used time:");
1586	startTimer();
1587	}
1588	#ifdef HAVE_RTIMER
1589	if (rtimerv)
1590	{
1591	writeRTime("used real time:");
1592	startRTimer();
1593	}
1594	#endif
1595	prompt_char = '>';
1596	#ifdef HAVE_SDB
1597	if (sdb_flags & 2) { sdb_flags=1; YYERROR; }
1598	#endif
1599	if(siCntrlc)
1600	{
1601	siCntrlc=FALSE;
1602	MYYERROR("abort...");
1603	}
1604	if (errorreported)
1605	{
1606	yyerror("");
1607	}
1608	if (inerror==2) PrintLn();
1609	errorreported = inerror = cmdtok = 0;
1610	lastreserved = currid = NULL;
1611	expected_parms = siCntrlc = FALSE;
1612	;
1613	break;}
1614	case 4:
1615	#line 405 "grammar.y"
1616	{currentVoice->ifsw=0;;
1617	break;}
1618	case 5:
1619	#line 407 "grammar.y"
1620	{ yyvsp[-1].lv.CleanUp(); currentVoice->ifsw=0;;
1621	break;}
1622	case 6:
1623	#line 409 "grammar.y"
1624	{
1625	YYACCEPT;
1626	;
1627	break;}
1628	case 7:
1629	#line 413 "grammar.y"
1630	{
1631	currentVoice->ifsw=0;
1632	iiDebug();
1633	;
1634	break;}
1635	case 8:
1636	#line 418 "grammar.y"
1637	{currentVoice->ifsw=0;;
1638	break;}
1639	case 9:
1640	#line 420 "grammar.y"
1641	{
1642	#ifdef SIQ
1643	siq=0;
1644	#endif
1645	yyInRingConstruction = FALSE;
1646	currentVoice->ifsw=0;
1647	if (inerror)
1648	{
1649	if ((inerror!=3) && (yyvsp[-1].i<UMINUS) && (yyvsp[-1].i>' '))
1650	{
1651	// 1: yyerror called
1652	// 2: scanner put actual string
1653	// 3: error rule put token+\n
1654	inerror=3;
1655	Print(" error at token `%s`\n",iiTwoOps(yyvsp[-1].i));
1656	}
1657	}
1658	if (!errorreported) WerrorS("...parse error");
1659	yyerror("");
1660	yyerrok;
1661	#ifdef HAVE_SDB
1662	if ((sdb_flags & 1) && currentVoice->pi!=NULL)
1663	{
1664	currentVoice->pi->trace_flag \|=1;
1665	}
1666	else
1667	#endif
1668	if (myynest>0)
1669	{
1670	feBufferTypes t=currentVoice->Typ();
1671	//PrintS("leaving yyparse\n");
1672	exitBuffer(BT_proc);
1673	if (t==BT_example)
1674	YYACCEPT;
1675	else
1676	YYABORT;
1677	}
1678	else if (currentVoice->prev!=NULL)
1679	{
1680	exitVoice();
1681	}
1682	#ifdef HAVE_SDB
1683	if (sdb_flags &2) sdb_flags=1;
1684	#endif
1685	;
1686	break;}
1687	case 17:
1688	#line 475 "grammar.y"
1689	{if (currentVoice!=NULL) currentVoice->ifsw=0;;
1690	break;}
1691	case 18:
1692	#line 478 "grammar.y"
1693	{ omFree((ADDRESS)yyvsp[0].name); ;
1694	break;}
1695	case 28:
1696	#line 493 "grammar.y"
1697	{
1698	if(iiAssign(&yyvsp[-1].lv,&yyvsp[0].lv)) YYERROR;
1699	;
1700	break;}
1701	case 29:
1702	#line 500 "grammar.y"
1703	{
1704	if (currRing==NULL) MYYERROR("no ring active");
1705	syMake(&yyval.lv,omStrDup(yyvsp[0].name));
1706	;
1707	break;}
1708	case 30:
1709	#line 505 "grammar.y"
1710	{
1711	syMake(&yyval.lv,yyvsp[0].name);
1712	;
1713	break;}
1714	case 31:
1715	#line 509 "grammar.y"
1716	{
1717	if(iiExprArith2(&yyval.lv, &yyvsp[-2].lv, COLONCOLON, &yyvsp[0].lv)) YYERROR;
1718	;
1719	break;}
1720	case 32:
1721	#line 513 "grammar.y"
1722	{
1723	if(iiExprArith1(&yyval.lv,&yyvsp[-2].lv,'(')) YYERROR;
1724	;
1725	break;}
1726	case 33:
1727	#line 517 "grammar.y"
1728	{
1729	if (yyvsp[-3].lv.rtyp==LIB_CMD)
1730	{
1731	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,LIB_CMD)) YYERROR;
1732	}
1733	else
1734	{
1735	if (yyvsp[-3].lv.Typ()==UNKNOWN)
1736	{
1737	if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,'(',&yyvsp[-1].lv)) YYERROR;
1738	}
1739	else
1740	{
1741	yyvsp[-3].lv.next=(leftv)omAllocBin(sleftv_bin);
1742	memcpy(yyvsp[-3].lv.next,&yyvsp[-1].lv,sizeof(sleftv));
1743	if(iiExprArithM(&yyval.lv,&yyvsp[-3].lv,'(')) YYERROR;
1744	}
1745	}
1746	;
1747	break;}
1748	case 34:
1749	#line 537 "grammar.y"
1750	{
1751	if (currRingHdl==NULL) MYYERROR("no ring active");
1752	int j = 0;
1753	memset(&yyval.lv,0,sizeof(sleftv));
1754	yyval.lv.rtyp=VECTOR_CMD;
1755	leftv v = &yyvsp[-1].lv;
1756	while (v!=NULL)
1757	{
1758	int i,t;
1759	sleftv tmp;
1760	memset(&tmp,0,sizeof(tmp));
1761	i=iiTestConvert((t=v->Typ()),POLY_CMD);
1762	if((i==0) \|\| (iiConvert(t /v->Typ()/,POLY_CMD,i,v,&tmp)))
1763	{
1764	pDelete((poly *)&yyval.lv.data);
1765	yyvsp[-1].lv.CleanUp();
1766	MYYERROR("expected '[poly,...'");
1767	}
1768	poly p = (poly)tmp.CopyD(POLY_CMD);
1769	pSetCompP(p,++j);
1770	yyval.lv.data = (void *)pAdd((poly)yyval.lv.data,p);
1771	v->next=tmp.next;tmp.next=NULL;
1772	tmp.CleanUp();
1773	v=v->next;
1774	}
1775	yyvsp[-1].lv.CleanUp();
1776	;
1777	break;}
1778	case 35:
1779	#line 565 "grammar.y"
1780	{
1781	memset(&yyval.lv,0,sizeof(yyval.lv));
1782	int i = atoi(yyvsp[0].name);
1783	/*remember not to omFree($1)
1784	because it is a part of the scanner buffer/
1785	yyval.lv.rtyp = INT_CMD;
1786	yyval.lv.data = (void *)(long)i;
1787
1788	/* check: out of range input */
1789	int l = strlen(yyvsp[0].name)+2;
1790	number n;
1791	if (l >= MAX_INT_LEN)
1792	{
1793	char tmp[MAX_INT_LEN+5];
1794	sprintf(tmp,"%d",i);
1795	if (strcmp(tmp,yyvsp[0].name)!=0)
1796	{
1797	nlRead(yyvsp[0].name,&n);
1798	yyval.lv.rtyp=BIGINT_CMD;
1799	yyval.lv.data = n;
1800	}
1801	}
1802	;
1803	break;}
1804	case 36:
1805	#line 589 "grammar.y"
1806	{
1807	memset(&yyval.lv,0,sizeof(yyval.lv));
1808	yyval.lv.rtyp = yyvsp[0].i;
1809	yyval.lv.data = yyval.lv.Data();
1810	;
1811	break;}
1812	case 37:
1813	#line 595 "grammar.y"
1814	{
1815	memset(&yyval.lv,0,sizeof(yyval.lv));
1816	yyval.lv.rtyp = STRING_CMD;
1817	yyval.lv.data = yyvsp[0].name;
1818	;
1819	break;}
1820	case 38:
1821	#line 604 "grammar.y"
1822	{
1823	leftv v = &yyvsp[-2].lv;
1824	while (v->next!=NULL)
1825	{
1826	v=v->next;
1827	}
1828	v->next = (leftv)omAllocBin(sleftv_bin);
1829	memcpy(v->next,&(yyvsp[0].lv),sizeof(sleftv));
1830	yyval.lv = yyvsp[-2].lv;
1831	;
1832	break;}
1833	case 39:
1834	#line 615 "grammar.y"
1835	{
1836	yyval.lv = yyvsp[0].lv;
1837	;
1838	break;}
1839	case 40:
1840	#line 621 "grammar.y"
1841	{
1842	/if ($1.typ == eunknown) YYERROR;/
1843	yyval.lv = yyvsp[0].lv;
1844	;
1845	break;}
1846	case 41:
1847	#line 625 "grammar.y"
1848	{ yyval.lv = yyvsp[0].lv; ;
1849	break;}
1850	case 42:
1851	#line 626 "grammar.y"
1852	{ yyval.lv = yyvsp[-1].lv; ;
1853	break;}
1854	case 43:
1855	#line 628 "grammar.y"
1856	{
1857	if(iiExprArith3(&yyval.lv,'[',&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
1858	;
1859	break;}
1860	case 44:
1861	#line 632 "grammar.y"
1862	{
1863	if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,'[',&yyvsp[-1].lv)) YYERROR;
1864	;
1865	break;}
1866	case 45:
1867	#line 636 "grammar.y"
1868	{
1869	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
1870	;
1871	break;}
1872	case 46:
1873	#line 640 "grammar.y"
1874	{
1875	if(iiExprArithM(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
1876	;
1877	break;}
1878	case 47:
1879	#line 644 "grammar.y"
1880	{
1881	if(iiExprArithM(&yyval.lv,NULL,yyvsp[-2].i)) YYERROR;
1882	;
1883	break;}
1884	case 48:
1885	#line 648 "grammar.y"
1886	{
1887	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
1888	;
1889	break;}
1890	case 49:
1891	#line 652 "grammar.y"
1892	{
1893	if(iiExprArithM(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
1894	;
1895	break;}
1896	case 50:
1897	#line 656 "grammar.y"
1898	{
1899	if(iiExprArithM(&yyval.lv,NULL,yyvsp[-2].i)) YYERROR;
1900	;
1901	break;}
1902	case 51:
1903	#line 660 "grammar.y"
1904	{
1905	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
1906	;
1907	break;}
1908	case 52:
1909	#line 664 "grammar.y"
1910	{
1911	if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR;
1912	;
1913	break;}
1914	case 53:
1915	#line 668 "grammar.y"
1916	{
1917	if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
1918	;
1919	break;}
1920	case 54:
1921	#line 672 "grammar.y"
1922	{
1923	if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR;
1924	;
1925	break;}
1926	case 55:
1927	#line 676 "grammar.y"
1928	{
1929	if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
1930	;
1931	break;}
1932	case 56:
1933	#line 680 "grammar.y"
1934	{
1935	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
1936	;
1937	break;}
1938	case 57:
1939	#line 684 "grammar.y"
1940	{
1941	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
1942	;
1943	break;}
1944	case 58:
1945	#line 688 "grammar.y"
1946	{
1947	if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR;
1948	;
1949	break;}
1950	case 59:
1951	#line 692 "grammar.y"
1952	{
1953	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
1954	;
1955	break;}
1956	case 60:
1957	#line 696 "grammar.y"
1958	{
1959	if(iiExprArith2(&yyval.lv,&yyvsp[-3].lv,yyvsp[-5].i,&yyvsp[-1].lv,TRUE)) YYERROR;
1960	;
1961	break;}
1962	case 61:
1963	#line 700 "grammar.y"
1964	{
1965	if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
1966	;
1967	break;}
1968	case 62:
1969	#line 704 "grammar.y"
1970	{
1971	if(iiExprArith3(&yyval.lv,yyvsp[-7].i,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
1972	;
1973	break;}
1974	case 63:
1975	#line 708 "grammar.y"
1976	{
1977	if(iiExprArithM(&yyval.lv,NULL,yyvsp[-2].i)) YYERROR;
1978	;
1979	break;}
1980	case 64:
1981	#line 712 "grammar.y"
1982	{
1983	if(iiExprArithM(&yyval.lv,&yyvsp[-1].lv,yyvsp[-3].i)) YYERROR;
1984	;
1985	break;}
1986	case 65:
1987	#line 716 "grammar.y"
1988	{
1989	if(iiExprArith3(&yyval.lv,MATRIX_CMD,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
1990	;
1991	break;}
1992	case 66:
1993	#line 720 "grammar.y"
1994	{
1995	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,MATRIX_CMD)) YYERROR;
1996	;
1997	break;}
1998	case 67:
1999	#line 724 "grammar.y"
2000	{
2001	if(iiExprArith3(&yyval.lv,INTMAT_CMD,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2002	;
2003	break;}
2004	case 68:
2005	#line 728 "grammar.y"
2006	{
2007	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,INTMAT_CMD)) YYERROR;
2008	;
2009	break;}
2010	case 69:
2011	#line 732 "grammar.y"
2012	{
2013	if(iiExprArith3(&yyval.lv,RING_CMD,&yyvsp[-5].lv,&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2014	;
2015	break;}
2016	case 70:
2017	#line 736 "grammar.y"
2018	{
2019	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,RING_CMD)) YYERROR;
2020	;
2021	break;}
2022	case 71:
2023	#line 740 "grammar.y"
2024	{
2025	yyval.lv=yyvsp[-1].lv;
2026	;
2027	break;}
2028	case 72:
2029	#line 744 "grammar.y"
2030	{
2031	#ifdef SIQ
2032	siq++;
2033	if (siq>0)
2034	{ if (iiExprArith2(&yyval.lv,&yyvsp[-3].lv,'=',&yyvsp[-1].lv)) YYERROR; }
2035	else
2036	#endif
2037	{
2038	memset(&yyval.lv,0,sizeof(yyval.lv));
2039	yyval.lv.rtyp=NONE;
2040	if (iiAssign(&yyvsp[-3].lv,&yyvsp[-1].lv)) YYERROR;
2041	}
2042	#ifdef SIQ
2043	siq--;
2044	#endif
2045	;
2046	break;}
2047	case 73:
2048	#line 761 "grammar.y"
2049	{
2050	#ifdef SIQ
2051	siq--;
2052	#endif
2053	;
2054	break;}
2055	case 74:
2056	#line 767 "grammar.y"
2057	{
2058	#ifdef SIQ
2059	if (siq<=0) yyvsp[-1].lv.Eval();
2060	#endif
2061	yyval.lv=yyvsp[-1].lv;
2062	#ifdef SIQ
2063	siq++;
2064	#endif
2065	;
2066	break;}
2067	case 75:
2068	#line 779 "grammar.y"
2069	{
2070	#ifdef SIQ
2071	siq++;
2072	#endif
2073	;
2074	break;}
2075	case 76:
2076	#line 787 "grammar.y"
2077	{
2078	#ifdef SIQ
2079	siq--;
2080	#endif
2081	;
2082	break;}
2083	case 77:
2084	#line 796 "grammar.y"
2085	{
2086	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,PLUSPLUS)) YYERROR;
2087	;
2088	break;}
2089	case 78:
2090	#line 800 "grammar.y"
2091	{
2092	if(iiExprArith1(&yyval.lv,&yyvsp[-1].lv,MINUSMINUS)) YYERROR;
2093	;
2094	break;}
2095	case 79:
2096	#line 804 "grammar.y"
2097	{
2098	if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,'+',&yyvsp[0].lv)) YYERROR;
2099	;
2100	break;}
2101	case 80:
2102	#line 808 "grammar.y"
2103	{
2104	if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,'-',&yyvsp[0].lv)) YYERROR;
2105	;
2106	break;}
2107	case 81:
2108	#line 812 "grammar.y"
2109	{
2110	if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,yyvsp[-1].i,&yyvsp[0].lv)) YYERROR;
2111	;
2112	break;}
2113	case 82:
2114	#line 816 "grammar.y"
2115	{
2116	if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,'^',&yyvsp[0].lv)) YYERROR;
2117	;
2118	break;}
2119	case 83:
2120	#line 820 "grammar.y"
2121	{
2122	if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,yyvsp[-1].i,&yyvsp[0].lv)) YYERROR;
2123	;
2124	break;}
2125	case 84:
2126	#line 824 "grammar.y"
2127	{
2128	if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,yyvsp[-1].i,&yyvsp[0].lv)) YYERROR;
2129	;
2130	break;}
2131	case 85:
2132	#line 828 "grammar.y"
2133	{
2134	if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,NOTEQUAL,&yyvsp[0].lv)) YYERROR;
2135	;
2136	break;}
2137	case 86:
2138	#line 832 "grammar.y"
2139	{
2140	if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,EQUAL_EQUAL,&yyvsp[0].lv)) YYERROR;
2141	;
2142	break;}
2143	case 87:
2144	#line 836 "grammar.y"
2145	{
2146	if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,DOTDOT,&yyvsp[0].lv)) YYERROR;
2147	;
2148	break;}
2149	case 88:
2150	#line 840 "grammar.y"
2151	{
2152	if(iiExprArith2(&yyval.lv,&yyvsp[-2].lv,':',&yyvsp[0].lv)) YYERROR;
2153	;
2154	break;}
2155	case 89:
2156	#line 844 "grammar.y"
2157	{
2158	memset(&yyval.lv,0,sizeof(yyval.lv));
2159	int i; TESTSETINT(yyvsp[0].lv,i);
2160	yyval.lv.rtyp = INT_CMD;
2161	yyval.lv.data = (void *)(long)(i == 0 ? 1 : 0);
2162	;
2163	break;}
2164	case 90:
2165	#line 851 "grammar.y"
2166	{
2167	if(iiExprArith1(&yyval.lv,&yyvsp[0].lv,'-')) YYERROR;
2168	;
2169	break;}
2170	case 91:
2171	#line 857 "grammar.y"
2172	{ yyval.lv = yyvsp[-1].lv; ;
2173	break;}
2174	case 92:
2175	#line 859 "grammar.y"
2176	{
2177	if (yyvsp[-1].lv.rtyp==0)
2178	{
2179	Werror("`%s` is undefined",yyvsp[-1].lv.Fullname());
2180	YYERROR;
2181	}
2182	else if ((yyvsp[-1].lv.rtyp==MODUL_CMD)
2183	// matrix m; m[2]=...
2184	&& (yyvsp[-1].lv.e!=NULL) && (yyvsp[-1].lv.e->next==NULL))
2185	{
2186	MYYERROR("matrix must have 2 indices");
2187	}
2188	yyval.lv = yyvsp[-1].lv;
2189	;
2190	break;}
2191	case 94:
2192	#line 879 "grammar.y"
2193	{
2194	if (yyvsp[-1].lv.Typ()!=STRING_CMD)
2195	{
2196	MYYERROR("string expression expected");
2197	}
2198	yyval.name = (char *)yyvsp[-1].lv.CopyD(STRING_CMD);
2199	yyvsp[-1].lv.CleanUp();
2200	;
2201	break;}
2202	case 97:
2203	#line 896 "grammar.y"
2204	{
2205	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2206	YYERROR;
2207	;
2208	break;}
2209	case 98:
2210	#line 901 "grammar.y"
2211	{
2212	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2213	YYERROR;
2214	;
2215	break;}
2216	case 99:
2217	#line 906 "grammar.y"
2218	{
2219	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR;
2220	;
2221	break;}
2222	case 100:
2223	#line 910 "grammar.y"
2224	{
2225	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR;
2226	;
2227	break;}
2228	case 101:
2229	#line 914 "grammar.y"
2230	{
2231	if (iiDeclCommand(&yyval.lv,&yyvsp[-6].lv,myynest,yyvsp[-7].i,&(currRing->idroot), TRUE)) YYERROR;
2232	int r; TESTSETINT(yyvsp[-4].lv,r);
2233	int c; TESTSETINT(yyvsp[-1].lv,c);
2234	if (r < 1)
2235	MYYERROR("rows must be greater than 0");
2236	if (c < 0)
2237	MYYERROR("cols must be greater than -1");
2238	leftv v=&yyval.lv;
2239	//while (v->next!=NULL) { v=v->next; }
2240	idhdl h=(idhdl)v->data;
2241	idDelete(&IDIDEAL(h));
2242	IDMATRIX(h) = mpNew(r,c);
2243	if (IDMATRIX(h)==NULL) YYERROR;
2244	;
2245	break;}
2246	case 102:
2247	#line 930 "grammar.y"
2248	{
2249	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR;
2250	;
2251	break;}
2252	case 103:
2253	#line 934 "grammar.y"
2254	{
2255	int r; TESTSETINT(yyvsp[-4].lv,r);
2256	int c; TESTSETINT(yyvsp[-1].lv,c);
2257	if (r < 1)
2258	MYYERROR("rows must be greater than 0");
2259	if (c < 0)
2260	MYYERROR("cols must be greater than -1");
2261	if (iiDeclCommand(&yyval.lv,&yyvsp[-6].lv,myynest,yyvsp[-7].i,&(yyvsp[-6].lv.req_packhdl->idroot)))
2262	YYERROR;
2263	leftv v=&yyval.lv;
2264	idhdl h=(idhdl)v->data;
2265	delete IDINTVEC(h);
2266	IDINTVEC(h) = new intvec(r,c,0);
2267	if (IDINTVEC(h)==NULL) YYERROR;
2268	;
2269	break;}
2270	case 104:
2271	#line 950 "grammar.y"
2272	{
2273	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2274	YYERROR;
2275	leftv v=&yyval.lv;
2276	idhdl h;
2277	do
2278	{
2279	h=(idhdl)v->data;
2280	delete IDINTVEC(h);
2281	IDINTVEC(h) = new intvec(1,1,0);
2282	v=v->next;
2283	} while (v!=NULL);
2284	;
2285	break;}
2286	case 105:
2287	#line 964 "grammar.y"
2288	{
2289	int t=yyvsp[-2].lv.Typ();
2290	sleftv r;
2291	memset(&r,0,sizeof(sleftv));
2292	if ((BEGIN_RING<t) && (t<END_RING))
2293	{
2294	if (iiDeclCommand(&r,&yyvsp[0].lv,myynest,t,&(currRing->idroot), TRUE))
2295	YYERROR;
2296	}
2297	else
2298	{
2299	if (iiDeclCommand(&r,&yyvsp[0].lv,myynest,t,&(yyvsp[0].lv.req_packhdl->idroot)))
2300	YYERROR;
2301	}
2302	leftv v=&yyvsp[-2].lv;
2303	while (v->next!=NULL) v=v->next;
2304	v->next=(leftv)omAllocBin(sleftv_bin);
2305	memcpy(v->next,&r,sizeof(sleftv));
2306	yyval.lv=yyvsp[-2].lv;
2307	;
2308	break;}
2309	case 106:
2310	#line 985 "grammar.y"
2311	{
2312	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2313	YYERROR;
2314	;
2315	break;}
2316	case 109:
2317	#line 998 "grammar.y"
2318	{
2319	leftv v = &yyvsp[-3].lv;
2320	while (v->next!=NULL)
2321	{
2322	v=v->next;
2323	}
2324	v->next = (leftv)omAllocBin(sleftv_bin);
2325	memcpy(v->next,&(yyvsp[-1].lv),sizeof(sleftv));
2326	yyval.lv = yyvsp[-3].lv;
2327	;
2328	break;}
2329	case 110:
2330	#line 1012 "grammar.y"
2331	{
2332	// let rInit take care of any errors
2333	yyval.i=rOrderName(yyvsp[0].name);
2334	;
2335	break;}
2336	case 111:
2337	#line 1020 "grammar.y"
2338	{
2339	memset(&yyval.lv,0,sizeof(yyval.lv));
2340	intvec *iv = new intvec(2);
2341	(*iv)[0] = 1;
2342	(*iv)[1] = yyvsp[0].i;
2343	yyval.lv.rtyp = INTVEC_CMD;
2344	yyval.lv.data = (void *)iv;
2345	;
2346	break;}
2347	case 112:
2348	#line 1029 "grammar.y"
2349	{
2350	memset(&yyval.lv,0,sizeof(yyval.lv));
2351	leftv sl = &yyvsp[-1].lv;
2352	int slLength;
2353	{
2354	slLength = exprlist_length(sl);
2355	int l = 2 + slLength;
2356	intvec *iv = new intvec(l);
2357	(*iv)[0] = slLength;
2358	(*iv)[1] = yyvsp[-3].i;
2359
2360	int i = 2;
2361	while ((i<l) && (sl!=NULL))
2362	{
2363	if (sl->Typ() == INT_CMD)
2364	{
2365	(*iv)[i++] = (int)((long)(sl->Data()));
2366	}
2367	else if ((sl->Typ() == INTVEC_CMD)
2368	\|\|(sl->Typ() == INTMAT_CMD))
2369	{
2370	intvec ivv = (intvec )(sl->Data());
2371	int ll = 0,l = ivv->length();
2372	for (; l>0; l--)
2373	{
2374	(iv)[i++] = (ivv)[ll++];
2375	}
2376	}
2377	else
2378	{
2379	delete iv;
2380	yyvsp[-1].lv.CleanUp();
2381	MYYERROR("wrong type in ordering");
2382	}
2383	sl = sl->next;
2384	}
2385	yyval.lv.rtyp = INTVEC_CMD;
2386	yyval.lv.data = (void *)iv;
2387	}
2388	yyvsp[-1].lv.CleanUp();
2389	;
2390	break;}
2391	case 114:
2392	#line 1075 "grammar.y"
2393	{
2394	yyval.lv = yyvsp[-2].lv;
2395	yyval.lv.next = (sleftv *)omAllocBin(sleftv_bin);
2396	memcpy(yyval.lv.next,&yyvsp[0].lv,sizeof(sleftv));
2397	;
2398	break;}
2399	case 116:
2400	#line 1085 "grammar.y"
2401	{
2402	yyval.lv = yyvsp[-1].lv;
2403	;
2404	break;}
2405	case 117:
2406	#line 1091 "grammar.y"
2407	{
2408	expected_parms = TRUE;
2409	;
2410	break;}
2411	case 118:
2412	#line 1103 "grammar.y"
2413	{ if (yyvsp[-1].i != '<') YYERROR;
2414	if((feFilePending=feFopen(yyvsp[0].name,"r",NULL,TRUE))==NULL) YYERROR; ;
2415	break;}
2416	case 119:
2417	#line 1106 "grammar.y"
2418	{ newFile(yyvsp[-2].name,feFilePending); ;
2419	break;}
2420	case 120:
2421	#line 1111 "grammar.y"
2422	{
2423	feHelp(yyvsp[-1].name);
2424	omFree((ADDRESS)yyvsp[-1].name);
2425	;
2426	break;}
2427	case 121:
2428	#line 1116 "grammar.y"
2429	{
2430	feHelp(NULL);
2431	;
2432	break;}
2433	case 122:
2434	#line 1123 "grammar.y"
2435	{
2436	singular_example(yyvsp[-1].name);
2437	omFree((ADDRESS)yyvsp[-1].name);
2438	;
2439	break;}
2440	case 123:
2441	#line 1131 "grammar.y"
2442	{
2443	if (basePack!=yyvsp[0].lv.req_packhdl)
2444	{
2445	if(iiExport(&yyvsp[0].lv,0,currPackHdl)) YYERROR;
2446	}
2447	else
2448	if (iiExport(&yyvsp[0].lv,0)) YYERROR;
2449	;
2450	break;}
2451	case 124:
2452	#line 1143 "grammar.y"
2453	{
2454	leftv v=&yyvsp[0].lv;
2455	if (v->rtyp!=IDHDL)
2456	{
2457	if (v->name!=NULL)
2458	{
2459	Werror("`%s` is undefined in kill",v->name);
2460	}
2461	else WerrorS("kill what ?");
2462	}
2463	else
2464	{
2465	killhdl((idhdl)v->data,v->req_packhdl);
2466	}
2467	;
2468	break;}
2469	case 125:
2470	#line 1159 "grammar.y"
2471	{
2472	leftv v=&yyvsp[0].lv;
2473	if (v->rtyp!=IDHDL)
2474	{
2475	if (v->name!=NULL)
2476	{
2477	Werror("`%s` is undefined in kill",v->name);
2478	}
2479	else WerrorS("kill what ?");
2480	}
2481	else
2482	{
2483	killhdl((idhdl)v->data,v->req_packhdl);
2484	}
2485	;
2486	break;}
2487	case 126:
2488	#line 1178 "grammar.y"
2489	{
2490	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2491	;
2492	break;}
2493	case 127:
2494	#line 1182 "grammar.y"
2495	{
2496	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2497	;
2498	break;}
2499	case 128:
2500	#line 1186 "grammar.y"
2501	{
2502	if (yyvsp[-1].i==QRING_CMD) yyvsp[-1].i=RING_CMD;
2503	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2504	;
2505	break;}
2506	case 129:
2507	#line 1191 "grammar.y"
2508	{
2509	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2510	;
2511	break;}
2512	case 130:
2513	#line 1195 "grammar.y"
2514	{
2515	list_cmd(RING_CMD,NULL,"// ",TRUE);
2516	;
2517	break;}
2518	case 131:
2519	#line 1199 "grammar.y"
2520	{
2521	list_cmd(MATRIX_CMD,NULL,"// ",TRUE);
2522	;
2523	break;}
2524	case 132:
2525	#line 1203 "grammar.y"
2526	{
2527	list_cmd(INTMAT_CMD,NULL,"// ",TRUE);
2528	;
2529	break;}
2530	case 133:
2531	#line 1207 "grammar.y"
2532	{
2533	list_cmd(PROC_CMD,NULL,"// ",TRUE);
2534	;
2535	break;}
2536	case 134:
2537	#line 1211 "grammar.y"
2538	{
2539	list_cmd(0,yyvsp[-1].lv.Fullname(),"// ",TRUE);
2540	yyvsp[-1].lv.CleanUp();
2541	;
2542	break;}
2543	case 135:
2544	#line 1216 "grammar.y"
2545	{
2546	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2547	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2548	yyvsp[-3].lv.CleanUp();
2549	;
2550	break;}
2551	case 136:
2552	#line 1222 "grammar.y"
2553	{
2554	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2555	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2556	yyvsp[-3].lv.CleanUp();
2557	;
2558	break;}
2559	case 137:
2560	#line 1228 "grammar.y"
2561	{
2562	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2563	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2564	yyvsp[-3].lv.CleanUp();
2565	;
2566	break;}
2567	case 138:
2568	#line 1234 "grammar.y"
2569	{
2570	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2571	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2572	yyvsp[-3].lv.CleanUp();
2573	;
2574	break;}
2575	case 139:
2576	#line 1240 "grammar.y"
2577	{
2578	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2579	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2580	yyvsp[-3].lv.CleanUp();
2581	;
2582	break;}
2583	case 140:
2584	#line 1246 "grammar.y"
2585	{
2586	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2587	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2588	yyvsp[-3].lv.CleanUp();
2589	;
2590	break;}
2591	case 141:
2592	#line 1252 "grammar.y"
2593	{
2594	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2595	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2596	yyvsp[-3].lv.CleanUp();
2597	;
2598	break;}
2599	case 142:
2600	#line 1258 "grammar.y"
2601	{
2602	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2603	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2604	yyvsp[-3].lv.CleanUp();
2605	;
2606	break;}
2607	case 143:
2608	#line 1270 "grammar.y"
2609	{
2610	list_cmd(-1,NULL,"// ",TRUE);
2611	;
2612	break;}
2613	case 144:
2614	#line 1276 "grammar.y"
2615	{ yyInRingConstruction = TRUE; ;
2616	break;}
2617	case 145:
2618	#line 1285 "grammar.y"
2619	{
2620	const char *ring_name = yyvsp[-6].lv.name;
2621	ring b=
2622	rInit(&yyvsp[-4].lv, /* characteristik and list of parameters*/
2623	&yyvsp[-2].lv, /* names of ringvariables */
2624	&yyvsp[0].lv); /* ordering */
2625	idhdl newRingHdl=NULL;
2626
2627	if (b!=NULL)
2628	{
2629	newRingHdl=enterid(ring_name, myynest, RING_CMD,
2630	&(yyvsp[-6].lv.req_packhdl->idroot));
2631	yyvsp[-6].lv.CleanUp();
2632	if (newRingHdl!=NULL)
2633	{
2634	omFreeSize(IDRING(newRingHdl),sizeof(ip_sring));
2635	IDRING(newRingHdl)=b;
2636	}
2637	else
2638	{
2639	rKill(b);
2640	}
2641	}
2642	yyInRingConstruction = FALSE;
2643	if (newRingHdl==NULL)
2644	{
2645	MYYERROR("cannot make ring");
2646	}
2647	else
2648	{
2649	rSetHdl(newRingHdl);
2650	}
2651	;
2652	break;}
2653	case 146:
2654	#line 1319 "grammar.y"
2655	{
2656	const char *ring_name = yyvsp[0].lv.name;
2657	if (!inerror) rDefault(ring_name);
2658	yyInRingConstruction = FALSE;
2659	yyvsp[0].lv.CleanUp();
2660	;
2661	break;}
2662	case 147:
2663	#line 1329 "grammar.y"
2664	{
2665	if ((yyvsp[-1].i!=LIB_CMD)\|\|(iiLibCmd(yyvsp[0].name,TRUE,TRUE,TRUE)))
2666	//if ($1==LIB_CMD)
2667	//{
2668	// sleftv tmp;
2669	// if(iiExprArith1(&tmp,&$2,LIB_CMD)) YYERROR;
2670	//}
2671	//else
2672	YYERROR;
2673	;
2674	break;}
2675	case 150:
2676	#line 1345 "grammar.y"
2677	{
2678	if ((yyvsp[-1].i==KEEPRING_CMD) && (myynest==0))
2679	MYYERROR("only inside a proc allowed");
2680	const char * n=yyvsp[0].lv.Name();
2681	if (((yyvsp[0].lv.Typ()==RING_CMD)\|\|(yyvsp[0].lv.Typ()==QRING_CMD))
2682	&& (yyvsp[0].lv.rtyp==IDHDL))
2683	{
2684	idhdl h=(idhdl)yyvsp[0].lv.data;
2685	if (yyvsp[0].lv.e!=NULL) h=rFindHdl((ring)yyvsp[0].lv.Data(),NULL, NULL);
2686	//Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
2687	if (yyvsp[-1].i==KEEPRING_CMD)
2688	{
2689	if (h!=NULL)
2690	{
2691	if (IDLEV(h)!=0)
2692	{
2693	if (iiExport(&yyvsp[0].lv,myynest-1)) YYERROR;
2694	#if 1
2695	//if (TEST_OPT_KEEPVARS)
2696	//{
2697	idhdl p=IDRING(h)->idroot;
2698	idhdl root=p;
2699	int prevlev=myynest-1;
2700	while (p!=NULL)
2701	{
2702	if (IDLEV(p)==myynest)
2703	{
2704	idhdl old=root->get(IDID(p),prevlev);
2705	if (old!=NULL)
2706	{
2707	if (BVERBOSE(V_REDEFINE))
2708	Warn("redefining %s",IDID(p));
2709	killhdl2(old,&root,IDRING(h));
2710	IDRING(h)->idroot=root;
2711	}
2712	IDLEV(p)=prevlev;
2713	}
2714	p=IDNEXT(p);
2715	}
2716	//IDRING(h)->idroot=root;
2717	#endif
2718	//}
2719	}
2720	#ifdef USE_IILOCALRING
2721	iiLocalRing[myynest-1]=IDRING(h);
2722	#endif
2723	procstack->cRing=IDRING(h);
2724	procstack->cRingHdl=h;
2725	}
2726	else
2727	{
2728	Werror("%s is no identifier",n);
2729	yyvsp[0].lv.CleanUp();
2730	YYERROR;
2731	}
2732	}
2733	if (h!=NULL) rSetHdl(h);
2734	else
2735	{
2736	Werror("cannot find the name of the basering %s",n);
2737	yyvsp[0].lv.CleanUp();
2738	YYERROR;
2739	}
2740	yyvsp[0].lv.CleanUp();
2741	}
2742	else
2743	{
2744	Werror("%s is no name of a ring/qring",n);
2745	yyvsp[0].lv.CleanUp();
2746	YYERROR;
2747	}
2748	;
2749	break;}
2750	case 151:
2751	#line 1421 "grammar.y"
2752	{
2753	if (yyvsp[0].lv.rtyp!=IDHDL) MYYERROR("identifier expected");
2754	idhdl h = (idhdl)yyvsp[0].lv.data;
2755	type_cmd(h);
2756	;
2757	break;}
2758	case 152:
2759	#line 1427 "grammar.y"
2760	{
2761	//Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
2762	#ifdef SIQ
2763	if (yyvsp[0].lv.rtyp!=COMMAND)
2764	{
2765	#endif
2766	if (yyvsp[0].lv.Typ()==UNKNOWN)
2767	{
2768	if (yyvsp[0].lv.name!=NULL)
2769	{
2770	Werror("`%s` is undefined",yyvsp[0].lv.name);
2771	omFree((ADDRESS)yyvsp[0].lv.name);
2772	}
2773	YYERROR;
2774	}
2775	#ifdef SIQ
2776	}
2777	#endif
2778	yyvsp[0].lv.Print(&sLastPrinted);
2779	yyvsp[0].lv.CleanUp(currRing);
2780	if (errorreported) YYERROR;
2781	;
2782	break;}
2783	case 153:
2784	#line 1456 "grammar.y"
2785	{
2786	int i; TESTSETINT(yyvsp[-2].lv,i);
2787	if (i!=0)
2788	{
2789	newBuffer( yyvsp[0].name, BT_if);
2790	}
2791	else
2792	{
2793	omFree((ADDRESS)yyvsp[0].name);
2794	currentVoice->ifsw=1;
2795	}
2796	;
2797	break;}
2798	case 154:
2799	#line 1469 "grammar.y"
2800	{
2801	if (currentVoice->ifsw==1)
2802	{
2803	currentVoice->ifsw=0;
2804	newBuffer( yyvsp[0].name, BT_else);
2805	}
2806	else
2807	{
2808	if (currentVoice->ifsw!=2)
2809	{
2810	Warn("`else` without `if` in level %d",myynest);
2811	}
2812	omFree((ADDRESS)yyvsp[0].name);
2813	}
2814	currentVoice->ifsw=0;
2815	;
2816	break;}
2817	case 155:
2818	#line 1486 "grammar.y"
2819	{
2820	int i; TESTSETINT(yyvsp[-2].lv,i);
2821	if (i)
2822	{
2823	if (exitBuffer(BT_break)) YYERROR;
2824	}
2825	currentVoice->ifsw=0;
2826	;
2827	break;}
2828	case 156:
2829	#line 1495 "grammar.y"
2830	{
2831	if (exitBuffer(BT_break)) YYERROR;
2832	currentVoice->ifsw=0;
2833	;
2834	break;}
2835	case 157:
2836	#line 1500 "grammar.y"
2837	{
2838	if (contBuffer(BT_break)) YYERROR;
2839	currentVoice->ifsw=0;
2840	;
2841	break;}
2842	case 158:
2843	#line 1508 "grammar.y"
2844	{
2845	/* -> if(!$2) break; $3; continue;*/
2846	char * s = (char *)omAlloc( strlen(yyvsp[-1].name) + strlen(yyvsp[0].name) + 36);
2847	sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,yyvsp[-1].name,yyvsp[0].name);
2848	newBuffer(s,BT_break);
2849	omFree((ADDRESS)yyvsp[-1].name);
2850	omFree((ADDRESS)yyvsp[0].name);
2851	;
2852	break;}
2853	case 159:
2854	#line 1520 "grammar.y"
2855	{
2856	/* $2 */
2857	/* if (!$3) break; $5; $4; continue; */
2858	char * s = (char *)omAlloc( strlen(yyvsp[-2].name)+strlen(yyvsp[-1].name)+strlen(yyvsp[0].name)+36);
2859	sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
2860	,yyvsp[-2].name,yyvsp[0].name,yyvsp[-1].name);
2861	omFree((ADDRESS)yyvsp[-2].name);
2862	omFree((ADDRESS)yyvsp[-1].name);
2863	omFree((ADDRESS)yyvsp[0].name);
2864	newBuffer(s,BT_break);
2865	s = (char *)omAlloc( strlen(yyvsp[-3].name) + 3);
2866	sprintf(s,"%s;\n",yyvsp[-3].name);
2867	omFree((ADDRESS)yyvsp[-3].name);
2868	newBuffer(s,BT_if);
2869	;
2870	break;}
2871	case 160:
2872	#line 1539 "grammar.y"
2873	{
2874	procinfov pi;
2875	idhdl h = enterid(yyvsp[-1].name,myynest,PROC_CMD,&IDROOT,TRUE);
2876	if (h==NULL) {omFree((ADDRESS)yyvsp[-1].name);omFree((ADDRESS)yyvsp[0].name); YYERROR;}
2877	iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-1].name, 0, 0);
2878	IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+31);;
2879	sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",yyvsp[0].name);
2880	omFree((ADDRESS)yyvsp[0].name);
2881	omFree((ADDRESS)yyvsp[-1].name);
2882	;
2883	break;}
2884	case 161:
2885	#line 1550 "grammar.y"
2886	{
2887	idhdl h = enterid(yyvsp[-2].name,myynest,PROC_CMD,&IDROOT,TRUE);
2888	if (h==NULL)
2889	{
2890	omFree((ADDRESS)yyvsp[-2].name);
2891	omFree((ADDRESS)yyvsp[-1].name);
2892	omFree((ADDRESS)yyvsp[0].name);
2893	YYERROR;
2894	}
2895	char *args=iiProcArgs(yyvsp[-1].name,FALSE);
2896	omFree((ADDRESS)yyvsp[-1].name);
2897	procinfov pi;
2898	iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-2].name, 0, 0);
2899	IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+strlen(args)+14);;
2900	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,yyvsp[0].name);
2901	omFree((ADDRESS)args);
2902	omFree((ADDRESS)yyvsp[0].name);
2903	omFree((ADDRESS)yyvsp[-2].name);
2904	;
2905	break;}
2906	case 162:
2907	#line 1570 "grammar.y"
2908	{
2909	omFree((ADDRESS)yyvsp[-1].name);
2910	idhdl h = enterid(yyvsp[-3].name,myynest,PROC_CMD,&IDROOT,TRUE);
2911	if (h==NULL)
2912	{
2913	omFree((ADDRESS)yyvsp[-3].name);
2914	omFree((ADDRESS)yyvsp[-2].name);
2915	omFree((ADDRESS)yyvsp[0].name);
2916	YYERROR;
2917	}
2918	char *args=iiProcArgs(yyvsp[-2].name,FALSE);
2919	omFree((ADDRESS)yyvsp[-2].name);
2920	procinfov pi;
2921	iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-3].name, 0, 0);
2922	omFree((ADDRESS)yyvsp[-3].name);
2923	IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+strlen(args)+14);;
2924	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,yyvsp[0].name);
2925	omFree((ADDRESS)args);
2926	omFree((ADDRESS)yyvsp[0].name);
2927	;
2928	break;}
2929	case 163:
2930	#line 1594 "grammar.y"
2931	{
2932	//Print("par:%s, %d\n",$2.Name(),$2.Typ());
2933	//yylineno--;
2934	if (iiParameter(&yyvsp[0].lv)) YYERROR;
2935	;
2936	break;}
2937	case 164:
2938	#line 1600 "grammar.y"
2939	{
2940	//Print("par:%s, %d\n",$2.Name(),$2.Typ());
2941	sleftv tmp_expr;
2942	//yylineno--;
2943	if ((iiDeclCommand(&tmp_expr,&yyvsp[0].lv,myynest,DEF_CMD,&IDROOT))
2944	\|\| (iiParameter(&tmp_expr)))
2945	YYERROR;
2946	;
2947	break;}
2948	case 165:
2949	#line 1612 "grammar.y"
2950	{
2951	if(iiRETURNEXPR==NULL) YYERROR;
2952	iiRETURNEXPR[myynest].Copy(&yyvsp[-1].lv);
2953	yyvsp[-1].lv.CleanUp();
2954	if (exitBuffer(BT_proc)) YYERROR;
2955	;
2956	break;}
2957	case 166:
2958	#line 1619 "grammar.y"
2959	{
2960	if (yyvsp[-2].i==RETURN)
2961	{
2962	if(iiRETURNEXPR==NULL) YYERROR;
2963	iiRETURNEXPR[myynest].Init();
2964	iiRETURNEXPR[myynest].rtyp=NONE;
2965	if (exitBuffer(BT_proc)) YYERROR;
2966	}
2967	;
2968	break;}
2969	}
2970	/* the action file gets copied in in place of this dollarsign */
2971	#line 543 "/usr/lib/bison.simple"
2972
2973	yyvsp -= yylen;
2974	yyssp -= yylen;
2975	#ifdef YYLSP_NEEDED
2976	yylsp -= yylen;
2977	#endif
2978
2979	#if YYDEBUG != 0
2980	if (yydebug)
2981	{
2982	short *ssp1 = yyss - 1;
2983	fprintf (stderr, "state stack now");
2984	while (ssp1 != yyssp)
2985	fprintf (stderr, " %d", *++ssp1);
2986	fprintf (stderr, "\n");
2987	}
2988	#endif
2989
2990	*++yyvsp = yyval;
2991
2992	#ifdef YYLSP_NEEDED
2993	yylsp++;
2994	if (yylen == 0)
2995	{
2996	yylsp->first_line = yylloc.first_line;
2997	yylsp->first_column = yylloc.first_column;
2998	yylsp->last_line = (yylsp-1)->last_line;
2999	yylsp->last_column = (yylsp-1)->last_column;
3000	yylsp->text = 0;
3001	}
3002	else
3003	{
3004	yylsp->last_line = (yylsp+yylen-1)->last_line;
3005	yylsp->last_column = (yylsp+yylen-1)->last_column;
3006	}
3007	#endif
3008
3009	/* Now "shift" the result of the reduction.
3010	Determine what state that goes to,
3011	based on the state we popped back to
3012	and the rule number reduced by. */
3013
3014	yyn = yyr1[yyn];
3015
3016	yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
3017	if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3018	yystate = yytable[yystate];
3019	else
3020	yystate = yydefgoto[yyn - YYNTBASE];
3021
3022	goto yynewstate;
3023
3024	yyerrlab: /* here on detecting error */
3025
3026	if (! yyerrstatus)
3027	/* If not already recovering from an error, report this error. */
3028	{
3029	++yynerrs;
3030
3031	#ifdef YYERROR_VERBOSE
3032	yyn = yypact[yystate];
3033
3034	if (yyn > YYFLAG && yyn < YYLAST)
3035	{
3036	int size = 0;
3037	char *msg;
3038	int x, count;
3039
3040	count = 0;
3041	/* Start X at -yyn if nec to avoid negative indexes in yycheck. */
3042	for (x = (yyn < 0 ? -yyn : 0);
3043	x < (sizeof(yytname) / sizeof(char *)); x++)
3044	if (yycheck[x + yyn] == x)
3045	size += strlen(yytname[x]) + 15, count++;
3046	msg = (char *) malloc(size + 15);
3047	if (msg != 0)
3048	{
3049	strcpy(msg, "parse error");
3050
3051	if (count < 5)
3052	{
3053	count = 0;
3054	for (x = (yyn < 0 ? -yyn : 0);
3055	x < (sizeof(yytname) / sizeof(char *)); x++)
3056	if (yycheck[x + yyn] == x)
3057	{
3058	strcat(msg, count == 0 ? ", expecting `" : " or `");
3059	strcat(msg, yytname[x]);
3060	strcat(msg, "'");
3061	count++;
3062	}
3063	}
3064	yyerror(msg);
3065	free(msg);
3066	}
3067	else
3068	yyerror ("parse error; also virtual memory exceeded");
3069	}
3070	else
3071	#endif /* YYERROR_VERBOSE */
3072	yyerror("parse error");
3073	}
3074
3075	goto yyerrlab1;
3076	yyerrlab1: /* here on error raised explicitly by an action */
3077
3078	if (yyerrstatus == 3)
3079	{
3080	/* if just tried and failed to reuse lookahead token after an error, discard it. */
3081
3082	/* return failure if at end of input */
3083	if (yychar == YYEOF)
3084	YYABORT;
3085
3086	#if YYDEBUG != 0
3087	if (yydebug)
3088	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
3089	#endif
3090
3091	yychar = YYEMPTY;
3092	}
3093
3094	/* Else will try to reuse lookahead token
3095	after shifting the error token. */
3096
3097	yyerrstatus = 3; /* Each real token shifted decrements this */
3098
3099	goto yyerrhandle;
3100
3101	yyerrdefault: /* current state does not do anything special for the error token. */
3102
3103	#if 0
3104	/* This is wrong; only states that explicitly want error tokens
3105	should shift them. */
3106	yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
3107	if (yyn) goto yydefault;
3108	#endif
3109
3110	yyerrpop: /* pop the current state because it cannot handle the error token */
3111
3112	if (yyssp == yyss) YYABORT;
3113	yyvsp--;
3114	yystate = *--yyssp;
3115	#ifdef YYLSP_NEEDED
3116	yylsp--;
3117	#endif
3118
3119	#if YYDEBUG != 0
3120	if (yydebug)
3121	{
3122	short *ssp1 = yyss - 1;
3123	fprintf (stderr, "Error: state stack now");
3124	while (ssp1 != yyssp)
3125	fprintf (stderr, " %d", *++ssp1);
3126	fprintf (stderr, "\n");
3127	}
3128	#endif
3129
3130	yyerrhandle:
3131
3132	yyn = yypact[yystate];
3133	if (yyn == YYFLAG)
3134	goto yyerrdefault;
3135
3136	yyn += YYTERROR;
3137	if (yyn < 0 \|\| yyn > YYLAST \|\| yycheck[yyn] != YYTERROR)
3138	goto yyerrdefault;
3139
3140	yyn = yytable[yyn];
3141	if (yyn < 0)
3142	{
3143	if (yyn == YYFLAG)
3144	goto yyerrpop;
3145	yyn = -yyn;
3146	goto yyreduce;
3147	}
3148	else if (yyn == 0)
3149	goto yyerrpop;
3150
3151	if (yyn == YYFINAL)
3152	YYACCEPT;
3153
3154	#if YYDEBUG != 0
3155	if (yydebug)
3156	fprintf(stderr, "Shifting error token, ");
3157	#endif
3158
3159	*++yyvsp = yylval;
3160	#ifdef YYLSP_NEEDED
3161	*++yylsp = yylloc;
3162	#endif
3163
3164	yystate = yyn;
3165	goto yynewstate;
3166
3167	yyacceptlab:
3168	/* YYACCEPT comes here. */
3169	if (yyfree_stacks)
3170	{
3171	free (yyss);
3172	free (yyvs);
3173	#ifdef YYLSP_NEEDED
3174	free (yyls);
3175	#endif
3176	}
3177	return 0;
3178
3179	yyabortlab:
3180	/* YYABORT comes here. */
3181	if (yyfree_stacks)
3182	{
3183	free (yyss);
3184	free (yyvs);
3185	#ifdef YYLSP_NEEDED
3186	free (yyls);
3187	#endif
3188	}
3189	return 1;
3190	}
3191	#line 1629 "grammar.y"

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

Download in other formats: