Context Navigation

source: git/Singular/grammar.cc @ b98aea

spielwiese

Last change on this file since b98aea was b98aea, checked in by Hans Schönemann <hannes@…>, 16 years ago
hannes: generation of grammer. git-svn-id: file:///usr/local/Singular/svn/trunk@10302 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	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(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	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, 1380, 1390, 1404, 1404, 1406,
480	1482, 1489, 1518, 1531, 1548, 1557, 1562, 1569, 1581, 1600,
481	1612, 1632, 1655, 1662, 1673, 1681
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	BOOLEAN do_pop = FALSE;
2675	char *ring_name = yyvsp[-6].lv.name;
2676	ring b=
2677	rInit(&yyvsp[-4].lv, /* characteristik and list of parameters*/
2678	&yyvsp[-2].lv, /* names of ringvariables */
2679	&yyvsp[0].lv); /* ordering */
2680	idhdl newRingHdl=NULL;
2681
2682	if (b!=NULL)
2683	{
2684	#ifdef HAVE_NS
2685	newRingHdl=enterid(ring_name, myynest, RING_CMD,
2686	&(yyvsp[-6].lv.req_packhdl->idroot));
2687	#else
2688	newRingHdl=enterid(ring_name, myynest, RING_CMD, &IDROOT);
2689	#endif
2690	yyvsp[-6].lv.CleanUp();
2691	if (newRingHdl!=NULL)
2692	{
2693	omFreeSize(IDRING(newRingHdl),sizeof(ip_sring));
2694	IDRING(newRingHdl)=b;
2695	}
2696	else
2697	{
2698	rKill(b);
2699	}
2700	}
2701	yyInRingConstruction = FALSE;
2702	if (newRingHdl==NULL)
2703	{
2704	MYYERROR("cannot make ring");
2705	}
2706	else
2707	{
2708	rSetHdl(newRingHdl);
2709	}
2710	;
2711	break;}
2712	case 146:
2713	#line 1381 "grammar.y"
2714	{
2715	BOOLEAN do_pop = FALSE;
2716	char *ring_name = yyvsp[0].lv.name;
2717	if (!inerror) rDefault(ring_name);
2718	yyInRingConstruction = FALSE;
2719	yyvsp[0].lv.CleanUp();
2720	;
2721	break;}
2722	case 147:
2723	#line 1392 "grammar.y"
2724	{
2725	if ((yyvsp[-1].i!=LIB_CMD)\|\|(iiLibCmd(yyvsp[0].name,TRUE,TRUE,TRUE)))
2726	//if ($1==LIB_CMD)
2727	//{
2728	// sleftv tmp;
2729	// if(iiExprArith1(&tmp,&$2,LIB_CMD)) YYERROR;
2730	//}
2731	//else
2732	YYERROR;
2733	;
2734	break;}
2735	case 150:
2736	#line 1408 "grammar.y"
2737	{
2738	if ((yyvsp[-1].i==KEEPRING_CMD) && (myynest==0))
2739	MYYERROR("only inside a proc allowed");
2740	const char * n=yyvsp[0].lv.Name();
2741	if (((yyvsp[0].lv.Typ()==RING_CMD)\|\|(yyvsp[0].lv.Typ()==QRING_CMD))
2742	&& (yyvsp[0].lv.rtyp==IDHDL))
2743	{
2744	idhdl h=(idhdl)yyvsp[0].lv.data;
2745	if (yyvsp[0].lv.e!=NULL) h=rFindHdl((ring)yyvsp[0].lv.Data(),NULL, NULL);
2746	//Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
2747	if (yyvsp[-1].i==KEEPRING_CMD)
2748	{
2749	if (h!=NULL)
2750	{
2751	if (IDLEV(h)!=0)
2752	{
2753	if (iiExport(&yyvsp[0].lv,myynest-1)) YYERROR;
2754	#if 1
2755	//if (TEST_OPT_KEEPVARS)
2756	//{
2757	idhdl p=IDRING(h)->idroot;
2758	idhdl root=p;
2759	int prevlev=myynest-1;
2760	while (p!=NULL)
2761	{
2762	if (IDLEV(p)==myynest)
2763	{
2764	idhdl old=root->get(IDID(p),prevlev);
2765	if (old!=NULL)
2766	{
2767	if (BVERBOSE(V_REDEFINE))
2768	Warn("redefining %s",IDID(p));
2769	killhdl2(old,&root,IDRING(h));
2770	IDRING(h)->idroot=root;
2771	}
2772	IDLEV(p)=prevlev;
2773	}
2774	p=IDNEXT(p);
2775	}
2776	//IDRING(h)->idroot=root;
2777	#endif
2778	//}
2779	}
2780	#ifdef USE_IILOCALRING
2781	iiLocalRing[myynest-1]=IDRING(h);
2782	#endif
2783	procstack->cRing=IDRING(h);
2784	procstack->cRingHdl=h;
2785	}
2786	else
2787	{
2788	Werror("%s is no identifier",n);
2789	yyvsp[0].lv.CleanUp();
2790	YYERROR;
2791	}
2792	}
2793	if (h!=NULL) rSetHdl(h);
2794	else
2795	{
2796	Werror("cannot find the name of the basering %s",n);
2797	yyvsp[0].lv.CleanUp();
2798	YYERROR;
2799	}
2800	yyvsp[0].lv.CleanUp();
2801	}
2802	else
2803	{
2804	Werror("%s is no name of a ring/qring",n);
2805	yyvsp[0].lv.CleanUp();
2806	YYERROR;
2807	}
2808	;
2809	break;}
2810	case 151:
2811	#line 1484 "grammar.y"
2812	{
2813	if (yyvsp[0].lv.rtyp!=IDHDL) MYYERROR("identifier expected");
2814	idhdl h = (idhdl)yyvsp[0].lv.data;
2815	type_cmd(h);
2816	;
2817	break;}
2818	case 152:
2819	#line 1490 "grammar.y"
2820	{
2821	//Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
2822	#ifdef SIQ
2823	if (yyvsp[0].lv.rtyp!=COMMAND)
2824	{
2825	#endif
2826	if (yyvsp[0].lv.Typ()==UNKNOWN)
2827	{
2828	if (yyvsp[0].lv.name!=NULL)
2829	{
2830	Werror("`%s` is undefined",yyvsp[0].lv.name);
2831	omFree((ADDRESS)yyvsp[0].lv.name);
2832	}
2833	YYERROR;
2834	}
2835	#ifdef SIQ
2836	}
2837	#endif
2838	yyvsp[0].lv.Print(&sLastPrinted);
2839	yyvsp[0].lv.CleanUp(currRing);
2840	if (errorreported) YYERROR;
2841	;
2842	break;}
2843	case 153:
2844	#line 1519 "grammar.y"
2845	{
2846	int i; TESTSETINT(yyvsp[-2].lv,i);
2847	if (i!=0)
2848	{
2849	newBuffer( yyvsp[0].name, BT_if);
2850	}
2851	else
2852	{
2853	omFree((ADDRESS)yyvsp[0].name);
2854	currentVoice->ifsw=1;
2855	}
2856	;
2857	break;}
2858	case 154:
2859	#line 1532 "grammar.y"
2860	{
2861	if (currentVoice->ifsw==1)
2862	{
2863	currentVoice->ifsw=0;
2864	newBuffer( yyvsp[0].name, BT_else);
2865	}
2866	else
2867	{
2868	if (currentVoice->ifsw!=2)
2869	{
2870	Warn("`else` without `if` in level %d",myynest);
2871	}
2872	omFree((ADDRESS)yyvsp[0].name);
2873	}
2874	currentVoice->ifsw=0;
2875	;
2876	break;}
2877	case 155:
2878	#line 1549 "grammar.y"
2879	{
2880	int i; TESTSETINT(yyvsp[-2].lv,i);
2881	if (i)
2882	{
2883	if (exitBuffer(BT_break)) YYERROR;
2884	}
2885	currentVoice->ifsw=0;
2886	;
2887	break;}
2888	case 156:
2889	#line 1558 "grammar.y"
2890	{
2891	if (exitBuffer(BT_break)) YYERROR;
2892	currentVoice->ifsw=0;
2893	;
2894	break;}
2895	case 157:
2896	#line 1563 "grammar.y"
2897	{
2898	if (contBuffer(BT_break)) YYERROR;
2899	currentVoice->ifsw=0;
2900	;
2901	break;}
2902	case 158:
2903	#line 1571 "grammar.y"
2904	{
2905	/* -> if(!$2) break; $3; continue;*/
2906	char * s = (char *)omAlloc( strlen(yyvsp[-1].name) + strlen(yyvsp[0].name) + 36);
2907	sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,yyvsp[-1].name,yyvsp[0].name);
2908	newBuffer(s,BT_break);
2909	omFree((ADDRESS)yyvsp[-1].name);
2910	omFree((ADDRESS)yyvsp[0].name);
2911	;
2912	break;}
2913	case 159:
2914	#line 1583 "grammar.y"
2915	{
2916	/* $2 */
2917	/* if (!$3) break; $5; $4; continue; */
2918	char * s = (char *)omAlloc( strlen(yyvsp[-2].name)+strlen(yyvsp[-1].name)+strlen(yyvsp[0].name)+36);
2919	sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
2920	,yyvsp[-2].name,yyvsp[0].name,yyvsp[-1].name);
2921	omFree((ADDRESS)yyvsp[-2].name);
2922	omFree((ADDRESS)yyvsp[-1].name);
2923	omFree((ADDRESS)yyvsp[0].name);
2924	newBuffer(s,BT_break);
2925	s = (char *)omAlloc( strlen(yyvsp[-3].name) + 3);
2926	sprintf(s,"%s;\n",yyvsp[-3].name);
2927	omFree((ADDRESS)yyvsp[-3].name);
2928	newBuffer(s,BT_if);
2929	;
2930	break;}
2931	case 160:
2932	#line 1602 "grammar.y"
2933	{
2934	procinfov pi;
2935	idhdl h = enterid(yyvsp[-1].name,myynest,PROC_CMD,&IDROOT,TRUE);
2936	if (h==NULL) {omFree((ADDRESS)yyvsp[-1].name);omFree((ADDRESS)yyvsp[0].name); YYERROR;}
2937	iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-1].name, 0, 0);
2938	IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+31);;
2939	sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",yyvsp[0].name);
2940	omFree((ADDRESS)yyvsp[0].name);
2941	omFree((ADDRESS)yyvsp[-1].name);
2942	;
2943	break;}
2944	case 161:
2945	#line 1613 "grammar.y"
2946	{
2947	idhdl h = enterid(yyvsp[-2].name,myynest,PROC_CMD,&IDROOT,TRUE);
2948	if (h==NULL)
2949	{
2950	omFree((ADDRESS)yyvsp[-2].name);
2951	omFree((ADDRESS)yyvsp[-1].name);
2952	omFree((ADDRESS)yyvsp[0].name);
2953	YYERROR;
2954	}
2955	char *args=iiProcArgs(yyvsp[-1].name,FALSE);
2956	omFree((ADDRESS)yyvsp[-1].name);
2957	procinfov pi;
2958	iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-2].name, 0, 0);
2959	IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+strlen(args)+14);;
2960	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,yyvsp[0].name);
2961	omFree((ADDRESS)args);
2962	omFree((ADDRESS)yyvsp[0].name);
2963	omFree((ADDRESS)yyvsp[-2].name);
2964	;
2965	break;}
2966	case 162:
2967	#line 1633 "grammar.y"
2968	{
2969	omFree((ADDRESS)yyvsp[-1].name);
2970	idhdl h = enterid(yyvsp[-3].name,myynest,PROC_CMD,&IDROOT,TRUE);
2971	if (h==NULL)
2972	{
2973	omFree((ADDRESS)yyvsp[-3].name);
2974	omFree((ADDRESS)yyvsp[-2].name);
2975	omFree((ADDRESS)yyvsp[0].name);
2976	YYERROR;
2977	}
2978	char *args=iiProcArgs(yyvsp[-2].name,FALSE);
2979	omFree((ADDRESS)yyvsp[-2].name);
2980	procinfov pi;
2981	iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-3].name, 0, 0);
2982	omFree((ADDRESS)yyvsp[-3].name);
2983	IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+strlen(args)+14);;
2984	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,yyvsp[0].name);
2985	omFree((ADDRESS)args);
2986	omFree((ADDRESS)yyvsp[0].name);
2987	;
2988	break;}
2989	case 163:
2990	#line 1657 "grammar.y"
2991	{
2992	//Print("par:%s, %d\n",$2.Name(),$2.Typ());
2993	//yylineno--;
2994	if (iiParameter(&yyvsp[0].lv)) YYERROR;
2995	;
2996	break;}
2997	case 164:
2998	#line 1663 "grammar.y"
2999	{
3000	//Print("par:%s, %d\n",$2.Name(),$2.Typ());
3001	sleftv tmp_expr;
3002	//yylineno--;
3003	if ((iiDeclCommand(&tmp_expr,&yyvsp[0].lv,myynest,DEF_CMD,&IDROOT))
3004	\|\| (iiParameter(&tmp_expr)))
3005	YYERROR;
3006	;
3007	break;}
3008	case 165:
3009	#line 1675 "grammar.y"
3010	{
3011	if(iiRETURNEXPR==NULL) YYERROR;
3012	iiRETURNEXPR[myynest].Copy(&yyvsp[-1].lv);
3013	yyvsp[-1].lv.CleanUp();
3014	if (exitBuffer(BT_proc)) YYERROR;
3015	;
3016	break;}
3017	case 166:
3018	#line 1682 "grammar.y"
3019	{
3020	if (yyvsp[-2].i==RETURN)
3021	{
3022	if(iiRETURNEXPR==NULL) YYERROR;
3023	iiRETURNEXPR[myynest].Init();
3024	iiRETURNEXPR[myynest].rtyp=NONE;
3025	if (exitBuffer(BT_proc)) YYERROR;
3026	}
3027	;
3028	break;}
3029	}
3030	/* the action file gets copied in in place of this dollarsign */
3031	#line 543 "/usr/lib/bison.simple"
3032
3033	yyvsp -= yylen;
3034	yyssp -= yylen;
3035	#ifdef YYLSP_NEEDED
3036	yylsp -= yylen;
3037	#endif
3038
3039	#if YYDEBUG != 0
3040	if (yydebug)
3041	{
3042	short *ssp1 = yyss - 1;
3043	fprintf (stderr, "state stack now");
3044	while (ssp1 != yyssp)
3045	fprintf (stderr, " %d", *++ssp1);
3046	fprintf (stderr, "\n");
3047	}
3048	#endif
3049
3050	*++yyvsp = yyval;
3051
3052	#ifdef YYLSP_NEEDED
3053	yylsp++;
3054	if (yylen == 0)
3055	{
3056	yylsp->first_line = yylloc.first_line;
3057	yylsp->first_column = yylloc.first_column;
3058	yylsp->last_line = (yylsp-1)->last_line;
3059	yylsp->last_column = (yylsp-1)->last_column;
3060	yylsp->text = 0;
3061	}
3062	else
3063	{
3064	yylsp->last_line = (yylsp+yylen-1)->last_line;
3065	yylsp->last_column = (yylsp+yylen-1)->last_column;
3066	}
3067	#endif
3068
3069	/* Now "shift" the result of the reduction.
3070	Determine what state that goes to,
3071	based on the state we popped back to
3072	and the rule number reduced by. */
3073
3074	yyn = yyr1[yyn];
3075
3076	yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
3077	if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3078	yystate = yytable[yystate];
3079	else
3080	yystate = yydefgoto[yyn - YYNTBASE];
3081
3082	goto yynewstate;
3083
3084	yyerrlab: /* here on detecting error */
3085
3086	if (! yyerrstatus)
3087	/* If not already recovering from an error, report this error. */
3088	{
3089	++yynerrs;
3090
3091	#ifdef YYERROR_VERBOSE
3092	yyn = yypact[yystate];
3093
3094	if (yyn > YYFLAG && yyn < YYLAST)
3095	{
3096	int size = 0;
3097	char *msg;
3098	int x, count;
3099
3100	count = 0;
3101	/* Start X at -yyn if nec to avoid negative indexes in yycheck. */
3102	for (x = (yyn < 0 ? -yyn : 0);
3103	x < (sizeof(yytname) / sizeof(char *)); x++)
3104	if (yycheck[x + yyn] == x)
3105	size += strlen(yytname[x]) + 15, count++;
3106	msg = (char *) malloc(size + 15);
3107	if (msg != 0)
3108	{
3109	strcpy(msg, "parse error");
3110
3111	if (count < 5)
3112	{
3113	count = 0;
3114	for (x = (yyn < 0 ? -yyn : 0);
3115	x < (sizeof(yytname) / sizeof(char *)); x++)
3116	if (yycheck[x + yyn] == x)
3117	{
3118	strcat(msg, count == 0 ? ", expecting `" : " or `");
3119	strcat(msg, yytname[x]);
3120	strcat(msg, "'");
3121	count++;
3122	}
3123	}
3124	yyerror(msg);
3125	free(msg);
3126	}
3127	else
3128	yyerror ("parse error; also virtual memory exceeded");
3129	}
3130	else
3131	#endif /* YYERROR_VERBOSE */
3132	yyerror("parse error");
3133	}
3134
3135	goto yyerrlab1;
3136	yyerrlab1: /* here on error raised explicitly by an action */
3137
3138	if (yyerrstatus == 3)
3139	{
3140	/* if just tried and failed to reuse lookahead token after an error, discard it. */
3141
3142	/* return failure if at end of input */
3143	if (yychar == YYEOF)
3144	YYABORT;
3145
3146	#if YYDEBUG != 0
3147	if (yydebug)
3148	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
3149	#endif
3150
3151	yychar = YYEMPTY;
3152	}
3153
3154	/* Else will try to reuse lookahead token
3155	after shifting the error token. */
3156
3157	yyerrstatus = 3; /* Each real token shifted decrements this */
3158
3159	goto yyerrhandle;
3160
3161	yyerrdefault: /* current state does not do anything special for the error token. */
3162
3163	#if 0
3164	/* This is wrong; only states that explicitly want error tokens
3165	should shift them. */
3166	yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
3167	if (yyn) goto yydefault;
3168	#endif
3169
3170	yyerrpop: /* pop the current state because it cannot handle the error token */
3171
3172	if (yyssp == yyss) YYABORT;
3173	yyvsp--;
3174	yystate = *--yyssp;
3175	#ifdef YYLSP_NEEDED
3176	yylsp--;
3177	#endif
3178
3179	#if YYDEBUG != 0
3180	if (yydebug)
3181	{
3182	short *ssp1 = yyss - 1;
3183	fprintf (stderr, "Error: state stack now");
3184	while (ssp1 != yyssp)
3185	fprintf (stderr, " %d", *++ssp1);
3186	fprintf (stderr, "\n");
3187	}
3188	#endif
3189
3190	yyerrhandle:
3191
3192	yyn = yypact[yystate];
3193	if (yyn == YYFLAG)
3194	goto yyerrdefault;
3195
3196	yyn += YYTERROR;
3197	if (yyn < 0 \|\| yyn > YYLAST \|\| yycheck[yyn] != YYTERROR)
3198	goto yyerrdefault;
3199
3200	yyn = yytable[yyn];
3201	if (yyn < 0)
3202	{
3203	if (yyn == YYFLAG)
3204	goto yyerrpop;
3205	yyn = -yyn;
3206	goto yyreduce;
3207	}
3208	else if (yyn == 0)
3209	goto yyerrpop;
3210
3211	if (yyn == YYFINAL)
3212	YYACCEPT;
3213
3214	#if YYDEBUG != 0
3215	if (yydebug)
3216	fprintf(stderr, "Shifting error token, ");
3217	#endif
3218
3219	*++yyvsp = yylval;
3220	#ifdef YYLSP_NEEDED
3221	*++yylsp = yylloc;
3222	#endif
3223
3224	yystate = yyn;
3225	goto yynewstate;
3226
3227	yyacceptlab:
3228	/* YYACCEPT comes here. */
3229	if (yyfree_stacks)
3230	{
3231	free (yyss);
3232	free (yyvs);
3233	#ifdef YYLSP_NEEDED
3234	free (yyls);
3235	#endif
3236	}
3237	return 0;
3238
3239	yyabortlab:
3240	/* YYABORT comes here. */
3241	if (yyfree_stacks)
3242	{
3243	free (yyss);
3244	free (yyvs);
3245	#ifdef YYLSP_NEEDED
3246	free (yyls);
3247	#endif
3248	}
3249	return 1;
3250	}
3251	#line 1692 "grammar.y"

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

Download in other formats: