Context Navigation

source: git/Singular/grammar.cc @ 2ef33b

spielwiese

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

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

Download in other formats: