Context Navigation

source: git/Singular/grammar.cc @ f13d949

fieker-DuValspielwiese

Last change on this file since f13d949 was db5523, checked in by Hans Schönemann <hannes@…>, 16 years ago
*hannes: bigint git-svn-id: file:///usr/local/Singular/svn/trunk@10875 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 109.3 KB

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

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

Download in other formats: