Context Navigation

source: git/Singular/grammar.cc @ 69262fa

fieker-DuValspielwiese

Last change on this file since 69262fa was 254a326, checked in by Hans Schönemann <hannes@…>, 16 years ago
*hannes: matrix m[i] git-svn-id: file:///usr/local/Singular/svn/trunk@11191 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 109.5 KB

Line
1
2	/* A Bison parser, made from grammar.y
3	by GNU Bison version 1.28 */
4
5	#define YYBISON 1 /* Identify Bison output. */
6
7	#define DOTDOT 257
8	#define EQUAL_EQUAL 258
9	#define GE 259
10	#define LE 260
11	#define MINUSMINUS 261
12	#define NOT 262
13	#define NOTEQUAL 263
14	#define PLUSPLUS 264
15	#define COLONCOLON 265
16	#define GRING_CMD 266
17	#define INTMAT_CMD 267
18	#define PROC_CMD 268
19	#define RING_CMD 269
20	#define BEGIN_RING 270
21	#define IDEAL_CMD 271
22	#define MAP_CMD 272
23	#define MATRIX_CMD 273
24	#define MODUL_CMD 274
25	#define NUMBER_CMD 275
26	#define POLY_CMD 276
27	#define RESOLUTION_CMD 277
28	#define VECTOR_CMD 278
29	#define BETTI_CMD 279
30	#define COEFFS_CMD 280
31	#define COEF_CMD 281
32	#define CONTRACT_CMD 282
33	#define DEGREE_CMD 283
34	#define DEG_CMD 284
35	#define DIFF_CMD 285
36	#define DIM_CMD 286
37	#define DIVISION_CMD 287
38	#define ELIMINATION_CMD 288
39	#define E_CMD 289
40	#define FETCH_CMD 290
41	#define FREEMODULE_CMD 291
42	#define KEEPRING_CMD 292
43	#define HILBERT_CMD 293
44	#define HOMOG_CMD 294
45	#define IMAP_CMD 295
46	#define INDEPSET_CMD 296
47	#define INTERRED_CMD 297
48	#define INTERSECT_CMD 298
49	#define JACOB_CMD 299
50	#define JET_CMD 300
51	#define KBASE_CMD 301
52	#define KOSZUL_CMD 302
53	#define LEADCOEF_CMD 303
54	#define LEADEXP_CMD 304
55	#define LEAD_CMD 305
56	#define LEADMONOM_CMD 306
57	#define LIFTSTD_CMD 307
58	#define LIFT_CMD 308
59	#define MAXID_CMD 309
60	#define MINBASE_CMD 310
61	#define MINOR_CMD 311
62	#define MINRES_CMD 312
63	#define MODULO_CMD 313
64	#define MRES_CMD 314
65	#define MULTIPLICITY_CMD 315
66	#define ORD_CMD 316
67	#define PAR_CMD 317
68	#define PARDEG_CMD 318
69	#define PREIMAGE_CMD 319
70	#define QUOTIENT_CMD 320
71	#define QHWEIGHT_CMD 321
72	#define REDUCE_CMD 322
73	#define REGULARITY_CMD 323
74	#define RES_CMD 324
75	#define SIMPLIFY_CMD 325
76	#define SORTVEC_CMD 326
77	#define SRES_CMD 327
78	#define STD_CMD 328
79	#define SUBST_CMD 329
80	#define SYZYGY_CMD 330
81	#define VAR_CMD 331
82	#define VDIM_CMD 332
83	#define WEDGE_CMD 333
84	#define WEIGHT_CMD 334
85	#define VALTVARS 335
86	#define VMAXDEG 336
87	#define VMAXMULT 337
88	#define VNOETHER 338
89	#define VMINPOLY 339
90	#define END_RING 340
91	#define CMD_1 341
92	#define CMD_2 342
93	#define CMD_3 343
94	#define CMD_12 344
95	#define CMD_13 345
96	#define CMD_23 346
97	#define CMD_123 347
98	#define CMD_M 348
99	#define ROOT_DECL 349
100	#define ROOT_DECL_LIST 350
101	#define RING_DECL 351
102	#define EXAMPLE_CMD 352
103	#define EXPORT_CMD 353
104	#define HELP_CMD 354
105	#define KILL_CMD 355
106	#define LIB_CMD 356
107	#define LISTVAR_CMD 357
108	#define SETRING_CMD 358
109	#define TYPE_CMD 359
110	#define STRINGTOK 360
111	#define BLOCKTOK 361
112	#define INT_CONST 362
113	#define UNKNOWN_IDENT 363
114	#define RINGVAR 364
115	#define PROC_DEF 365
116	#define BREAK_CMD 366
117	#define CONTINUE_CMD 367
118	#define ELSE_CMD 368
119	#define EVAL 369
120	#define QUOTE 370
121	#define FOR_CMD 371
122	#define IF_CMD 372
123	#define SYS_BREAK 373
124	#define WHILE_CMD 374
125	#define RETURN 375
126	#define PARAMETER 376
127	#define SYSVAR 377
128	#define UMINUS 378
129
130	#line 8 "grammar.y"
131
132
133	#include <stdio.h>
134	#include <stddef.h>
135	#include <stdlib.h>
136	#include <stdarg.h>
137	#include <string.h>
138
139	#include "mod2.h"
140	#include <mylimits.h>
141	#include "omalloc.h"
142	#include "tok.h"
143	#include "stype.h"
144	#include "ipid.h"
145	#include "intvec.h"
146	#include "febase.h"
147	#include "matpol.h"
148	#include "ring.h"
149	#include "kstd1.h"
150	#include "subexpr.h"
151	#include "ipshell.h"
152	#include "ipconv.h"
153	#include "sdb.h"
154	#include "ideals.h"
155	#include "numbers.h"
156	#include "polys.h"
157	#include "stairc.h"
158	#include "timer.h"
159	#include "cntrlc.h"
160	#include "maps.h"
161	#include "syz.h"
162	#include "lists.h"
163	#include "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, 875, 877, 888, 889, 893, 903, 912, 916,
476	920, 936, 940, 960, 978, 1003, 1014, 1018, 1020, 1033,
477	1041, 1051, 1095, 1097, 1105, 1107, 1113, 1124, 1129, 1132,
478	1138, 1144, 1152, 1166, 1187, 1209, 1214, 1218, 1223, 1227,
479	1231, 1235, 1239, 1243, 1248, 1257, 1266, 1275, 1284, 1293,
480	1302, 1311, 1329, 1335, 1339, 1382, 1391, 1405, 1405, 1407,
481	1483, 1490, 1519, 1532, 1549, 1558, 1563, 1570, 1582, 1601,
482	1613, 1633, 1656, 1663, 1674, 1682
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	else if ((yyvsp[-1].lv.rtyp==MODUL_CMD)
2182	// matrix m; m[2]=...
2183	&& (yyvsp[-1].lv.e!=NULL) && (yyvsp[-1].lv.e->next==NULL))
2184	{
2185	MYYERROR("matrix must have 2 indices");
2186	}
2187	yyval.lv = yyvsp[-1].lv;
2188	;
2189	break;}
2190	case 94:
2191	#line 878 "grammar.y"
2192	{
2193	if (yyvsp[-1].lv.Typ()!=STRING_CMD)
2194	{
2195	MYYERROR("string expression expected");
2196	}
2197	yyval.name = (char *)yyvsp[-1].lv.CopyD(STRING_CMD);
2198	yyvsp[-1].lv.CleanUp();
2199	;
2200	break;}
2201	case 97:
2202	#line 895 "grammar.y"
2203	{
2204	#ifdef HAVE_NS
2205	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2206	YYERROR;
2207	#else
2208	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&IDROOT)) YYERROR;
2209	#endif
2210	;
2211	break;}
2212	case 98:
2213	#line 904 "grammar.y"
2214	{
2215	#ifdef HAVE_NS
2216	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2217	YYERROR;
2218	#else
2219	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&IDROOT)) YYERROR;
2220	#endif
2221	;
2222	break;}
2223	case 99:
2224	#line 913 "grammar.y"
2225	{
2226	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR;
2227	;
2228	break;}
2229	case 100:
2230	#line 917 "grammar.y"
2231	{
2232	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR;
2233	;
2234	break;}
2235	case 101:
2236	#line 921 "grammar.y"
2237	{
2238	if (iiDeclCommand(&yyval.lv,&yyvsp[-6].lv,myynest,yyvsp[-7].i,&(currRing->idroot), TRUE)) YYERROR;
2239	int r; TESTSETINT(yyvsp[-4].lv,r);
2240	int c; TESTSETINT(yyvsp[-1].lv,c);
2241	if (r < 1)
2242	MYYERROR("rows must be greater than 0");
2243	if (c < 0)
2244	MYYERROR("cols must be greater than -1");
2245	leftv v=&yyval.lv;
2246	//while (v->next!=NULL) { v=v->next; }
2247	idhdl h=(idhdl)v->data;
2248	idDelete(&IDIDEAL(h));
2249	IDMATRIX(h) = mpNew(r,c);
2250	if (IDMATRIX(h)==NULL) YYERROR;
2251	;
2252	break;}
2253	case 102:
2254	#line 937 "grammar.y"
2255	{
2256	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(currRing->idroot), TRUE)) YYERROR;
2257	;
2258	break;}
2259	case 103:
2260	#line 941 "grammar.y"
2261	{
2262	int r; TESTSETINT(yyvsp[-4].lv,r);
2263	int c; TESTSETINT(yyvsp[-1].lv,c);
2264	if (r < 1)
2265	MYYERROR("rows must be greater than 0");
2266	if (c < 0)
2267	MYYERROR("cols must be greater than -1");
2268	#ifdef HAVE_NS
2269	if (iiDeclCommand(&yyval.lv,&yyvsp[-6].lv,myynest,yyvsp[-7].i,&(yyvsp[-6].lv.req_packhdl->idroot)))
2270	YYERROR;
2271	#else
2272	if (iiDeclCommand(&yyval.lv,&yyvsp[-6].lv,myynest,yyvsp[-7].i,&IDROOT)) YYERROR;
2273	#endif
2274	leftv v=&yyval.lv;
2275	idhdl h=(idhdl)v->data;
2276	delete IDINTVEC(h);
2277	IDINTVEC(h) = new intvec(r,c,0);
2278	if (IDINTVEC(h)==NULL) YYERROR;
2279	;
2280	break;}
2281	case 104:
2282	#line 961 "grammar.y"
2283	{
2284	#ifdef HAVE_NS
2285	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2286	YYERROR;
2287	#else
2288	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&IDROOT)) YYERROR;
2289	#endif
2290	leftv v=&yyval.lv;
2291	idhdl h;
2292	do
2293	{
2294	h=(idhdl)v->data;
2295	delete IDINTVEC(h);
2296	IDINTVEC(h) = new intvec(1,1,0);
2297	v=v->next;
2298	} while (v!=NULL);
2299	;
2300	break;}
2301	case 105:
2302	#line 979 "grammar.y"
2303	{
2304	int t=yyvsp[-2].lv.Typ();
2305	sleftv r;
2306	memset(&r,0,sizeof(sleftv));
2307	if ((BEGIN_RING<t) && (t<END_RING))
2308	{
2309	if (iiDeclCommand(&r,&yyvsp[0].lv,myynest,t,&(currRing->idroot), TRUE))
2310	YYERROR;
2311	}
2312	else
2313	{
2314	#ifdef HAVE_NS
2315	if (iiDeclCommand(&r,&yyvsp[0].lv,myynest,t,&(yyvsp[0].lv.req_packhdl->idroot)))
2316	YYERROR;
2317	#else
2318	if (iiDeclCommand(&r,&yyvsp[0].lv,myynest,t,&IDROOT)) YYERROR;
2319	#endif
2320	}
2321	leftv v=&yyvsp[-2].lv;
2322	while (v->next!=NULL) v=v->next;
2323	v->next=(leftv)omAllocBin(sleftv_bin);
2324	memcpy(v->next,&r,sizeof(sleftv));
2325	yyval.lv=yyvsp[-2].lv;
2326	;
2327	break;}
2328	case 106:
2329	#line 1004 "grammar.y"
2330	{
2331	#ifdef HAVE_NS
2332	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&(yyvsp[0].lv.req_packhdl->idroot)))
2333	YYERROR;
2334	#else
2335	if (iiDeclCommand(&yyval.lv,&yyvsp[0].lv,myynest,yyvsp[-1].i,&IDROOT)) YYERROR;
2336	#endif
2337	;
2338	break;}
2339	case 109:
2340	#line 1021 "grammar.y"
2341	{
2342	leftv v = &yyvsp[-3].lv;
2343	while (v->next!=NULL)
2344	{
2345	v=v->next;
2346	}
2347	v->next = (leftv)omAllocBin(sleftv_bin);
2348	memcpy(v->next,&(yyvsp[-1].lv),sizeof(sleftv));
2349	yyval.lv = yyvsp[-3].lv;
2350	;
2351	break;}
2352	case 110:
2353	#line 1035 "grammar.y"
2354	{
2355	// let rInit take care of any errors
2356	yyval.i=rOrderName(yyvsp[0].name);
2357	;
2358	break;}
2359	case 111:
2360	#line 1043 "grammar.y"
2361	{
2362	memset(&yyval.lv,0,sizeof(yyval.lv));
2363	intvec *iv = new intvec(2);
2364	(*iv)[0] = 1;
2365	(*iv)[1] = yyvsp[0].i;
2366	yyval.lv.rtyp = INTVEC_CMD;
2367	yyval.lv.data = (void *)iv;
2368	;
2369	break;}
2370	case 112:
2371	#line 1052 "grammar.y"
2372	{
2373	memset(&yyval.lv,0,sizeof(yyval.lv));
2374	leftv sl = &yyvsp[-1].lv;
2375	int slLength;
2376	{
2377	slLength = exprlist_length(sl);
2378	int l = 2 + slLength;
2379	intvec *iv = new intvec(l);
2380	(*iv)[0] = slLength;
2381	(*iv)[1] = yyvsp[-3].i;
2382
2383	int i = 2;
2384	while ((i<l) && (sl!=NULL))
2385	{
2386	if (sl->Typ() == INT_CMD)
2387	{
2388	(*iv)[i++] = (int)((long)(sl->Data()));
2389	}
2390	else if ((sl->Typ() == INTVEC_CMD)
2391	\|\|(sl->Typ() == INTMAT_CMD))
2392	{
2393	intvec ivv = (intvec )(sl->Data());
2394	int ll = 0,l = ivv->length();
2395	for (; l>0; l--)
2396	{
2397	(iv)[i++] = (ivv)[ll++];
2398	}
2399	}
2400	else
2401	{
2402	delete iv;
2403	yyvsp[-1].lv.CleanUp();
2404	MYYERROR("wrong type in ordering");
2405	}
2406	sl = sl->next;
2407	}
2408	yyval.lv.rtyp = INTVEC_CMD;
2409	yyval.lv.data = (void *)iv;
2410	}
2411	yyvsp[-1].lv.CleanUp();
2412	;
2413	break;}
2414	case 114:
2415	#line 1098 "grammar.y"
2416	{
2417	yyval.lv = yyvsp[-2].lv;
2418	yyval.lv.next = (sleftv *)omAllocBin(sleftv_bin);
2419	memcpy(yyval.lv.next,&yyvsp[0].lv,sizeof(sleftv));
2420	;
2421	break;}
2422	case 116:
2423	#line 1108 "grammar.y"
2424	{
2425	yyval.lv = yyvsp[-1].lv;
2426	;
2427	break;}
2428	case 117:
2429	#line 1114 "grammar.y"
2430	{
2431	expected_parms = TRUE;
2432	;
2433	break;}
2434	case 118:
2435	#line 1126 "grammar.y"
2436	{ if (yyvsp[-1].i != '<') YYERROR;
2437	if((feFilePending=feFopen(yyvsp[0].name,"r",NULL,TRUE))==NULL) YYERROR; ;
2438	break;}
2439	case 119:
2440	#line 1129 "grammar.y"
2441	{ newFile(yyvsp[-2].name,feFilePending); ;
2442	break;}
2443	case 120:
2444	#line 1134 "grammar.y"
2445	{
2446	feHelp(yyvsp[-1].name);
2447	omFree((ADDRESS)yyvsp[-1].name);
2448	;
2449	break;}
2450	case 121:
2451	#line 1139 "grammar.y"
2452	{
2453	feHelp(NULL);
2454	;
2455	break;}
2456	case 122:
2457	#line 1146 "grammar.y"
2458	{
2459	singular_example(yyvsp[-1].name);
2460	omFree((ADDRESS)yyvsp[-1].name);
2461	;
2462	break;}
2463	case 123:
2464	#line 1154 "grammar.y"
2465	{
2466	#ifdef HAVE_NS
2467	if (basePack!=yyvsp[0].lv.req_packhdl)
2468	{
2469	if(iiExport(&yyvsp[0].lv,0,currPackHdl)) YYERROR;
2470	}
2471	else
2472	#endif /* HAVE_NS */
2473	if (iiExport(&yyvsp[0].lv,0)) YYERROR;
2474	;
2475	break;}
2476	case 124:
2477	#line 1168 "grammar.y"
2478	{
2479	leftv v=&yyvsp[0].lv;
2480	if (v->rtyp!=IDHDL)
2481	{
2482	if (v->name!=NULL)
2483	{
2484	Werror("`%s` is undefined in kill",v->name);
2485	}
2486	else WerrorS("kill what ?");
2487	}
2488	else
2489	{
2490	#ifdef HAVE_NS
2491	killhdl((idhdl)v->data,v->req_packhdl);
2492	#else
2493	killhdl((idhdl)v->data);
2494	#endif
2495	}
2496	;
2497	break;}
2498	case 125:
2499	#line 1188 "grammar.y"
2500	{
2501	leftv v=&yyvsp[0].lv;
2502	if (v->rtyp!=IDHDL)
2503	{
2504	if (v->name!=NULL)
2505	{
2506	Werror("`%s` is undefined in kill",v->name);
2507	}
2508	else WerrorS("kill what ?");
2509	}
2510	else
2511	{
2512	#ifdef HAVE_NS
2513	killhdl((idhdl)v->data,v->req_packhdl);
2514	#else
2515	killhdl((idhdl)v->data);
2516	#endif
2517	}
2518	;
2519	break;}
2520	case 126:
2521	#line 1211 "grammar.y"
2522	{
2523	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2524	;
2525	break;}
2526	case 127:
2527	#line 1215 "grammar.y"
2528	{
2529	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2530	;
2531	break;}
2532	case 128:
2533	#line 1219 "grammar.y"
2534	{
2535	if (yyvsp[-1].i==QRING_CMD) yyvsp[-1].i=RING_CMD;
2536	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2537	;
2538	break;}
2539	case 129:
2540	#line 1224 "grammar.y"
2541	{
2542	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2543	;
2544	break;}
2545	case 130:
2546	#line 1228 "grammar.y"
2547	{
2548	list_cmd(RING_CMD,NULL,"// ",TRUE);
2549	;
2550	break;}
2551	case 131:
2552	#line 1232 "grammar.y"
2553	{
2554	list_cmd(MATRIX_CMD,NULL,"// ",TRUE);
2555	;
2556	break;}
2557	case 132:
2558	#line 1236 "grammar.y"
2559	{
2560	list_cmd(INTMAT_CMD,NULL,"// ",TRUE);
2561	;
2562	break;}
2563	case 133:
2564	#line 1240 "grammar.y"
2565	{
2566	list_cmd(PROC_CMD,NULL,"// ",TRUE);
2567	;
2568	break;}
2569	case 134:
2570	#line 1244 "grammar.y"
2571	{
2572	list_cmd(0,yyvsp[-1].lv.Fullname(),"// ",TRUE);
2573	yyvsp[-1].lv.CleanUp();
2574	;
2575	break;}
2576	case 135:
2577	#line 1249 "grammar.y"
2578	{
2579	#ifdef HAVE_NS
2580	//PrintS("?????\n");
2581	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2582	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2583	#endif /* HAVE_NS */
2584	yyvsp[-3].lv.CleanUp();
2585	;
2586	break;}
2587	case 136:
2588	#line 1258 "grammar.y"
2589	{
2590	#ifdef HAVE_NS
2591	//PrintS("?????\n");
2592	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2593	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2594	#endif /* HAVE_NS */
2595	yyvsp[-3].lv.CleanUp();
2596	;
2597	break;}
2598	case 137:
2599	#line 1267 "grammar.y"
2600	{
2601	#ifdef HAVE_NS
2602	//PrintS("?????\n");
2603	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2604	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2605	#endif /* HAVE_NS */
2606	yyvsp[-3].lv.CleanUp();
2607	;
2608	break;}
2609	case 138:
2610	#line 1276 "grammar.y"
2611	{
2612	#ifdef HAVE_NS
2613	//PrintS("?????\n");
2614	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2615	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2616	#endif /* HAVE_NS */
2617	yyvsp[-3].lv.CleanUp();
2618	;
2619	break;}
2620	case 139:
2621	#line 1285 "grammar.y"
2622	{
2623	#ifdef HAVE_NS
2624	//PrintS("?????\n");
2625	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2626	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2627	#endif /* HAVE_NS */
2628	yyvsp[-3].lv.CleanUp();
2629	;
2630	break;}
2631	case 140:
2632	#line 1294 "grammar.y"
2633	{
2634	#ifdef HAVE_NS
2635	//PrintS("?????\n");
2636	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2637	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2638	#endif /* HAVE_NS */
2639	yyvsp[-3].lv.CleanUp();
2640	;
2641	break;}
2642	case 141:
2643	#line 1303 "grammar.y"
2644	{
2645	#ifdef HAVE_NS
2646	//PrintS("?????\n");
2647	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2648	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2649	#endif /* HAVE_NS */
2650	yyvsp[-3].lv.CleanUp();
2651	;
2652	break;}
2653	case 142:
2654	#line 1312 "grammar.y"
2655	{
2656	#ifdef HAVE_NS
2657	//PrintS("?????\n");
2658	if(yyvsp[-3].lv.Typ() == PACKAGE_CMD)
2659	list_cmd(yyvsp[-1].i,NULL,"// ",TRUE);
2660	#endif /* HAVE_NS */
2661	yyvsp[-3].lv.CleanUp();
2662	;
2663	break;}
2664	case 143:
2665	#line 1330 "grammar.y"
2666	{
2667	list_cmd(-1,NULL,"// ",TRUE);
2668	;
2669	break;}
2670	case 144:
2671	#line 1336 "grammar.y"
2672	{ yyInRingConstruction = TRUE; ;
2673	break;}
2674	case 145:
2675	#line 1345 "grammar.y"
2676	{
2677	const char *ring_name = yyvsp[-6].lv.name;
2678	ring b=
2679	rInit(&yyvsp[-4].lv, /* characteristik and list of parameters*/
2680	&yyvsp[-2].lv, /* names of ringvariables */
2681	&yyvsp[0].lv); /* ordering */
2682	idhdl newRingHdl=NULL;
2683
2684	if (b!=NULL)
2685	{
2686	#ifdef HAVE_NS
2687	newRingHdl=enterid(ring_name, myynest, RING_CMD,
2688	&(yyvsp[-6].lv.req_packhdl->idroot));
2689	#else
2690	newRingHdl=enterid(ring_name, myynest, RING_CMD, &IDROOT);
2691	#endif
2692	yyvsp[-6].lv.CleanUp();
2693	if (newRingHdl!=NULL)
2694	{
2695	omFreeSize(IDRING(newRingHdl),sizeof(ip_sring));
2696	IDRING(newRingHdl)=b;
2697	}
2698	else
2699	{
2700	rKill(b);
2701	}
2702	}
2703	yyInRingConstruction = FALSE;
2704	if (newRingHdl==NULL)
2705	{
2706	MYYERROR("cannot make ring");
2707	}
2708	else
2709	{
2710	rSetHdl(newRingHdl);
2711	}
2712	;
2713	break;}
2714	case 146:
2715	#line 1383 "grammar.y"
2716	{
2717	const char *ring_name = yyvsp[0].lv.name;
2718	if (!inerror) rDefault(ring_name);
2719	yyInRingConstruction = FALSE;
2720	yyvsp[0].lv.CleanUp();
2721	;
2722	break;}
2723	case 147:
2724	#line 1393 "grammar.y"
2725	{
2726	if ((yyvsp[-1].i!=LIB_CMD)\|\|(iiLibCmd(yyvsp[0].name,TRUE,TRUE,TRUE)))
2727	//if ($1==LIB_CMD)
2728	//{
2729	// sleftv tmp;
2730	// if(iiExprArith1(&tmp,&$2,LIB_CMD)) YYERROR;
2731	//}
2732	//else
2733	YYERROR;
2734	;
2735	break;}
2736	case 150:
2737	#line 1409 "grammar.y"
2738	{
2739	if ((yyvsp[-1].i==KEEPRING_CMD) && (myynest==0))
2740	MYYERROR("only inside a proc allowed");
2741	const char * n=yyvsp[0].lv.Name();
2742	if (((yyvsp[0].lv.Typ()==RING_CMD)\|\|(yyvsp[0].lv.Typ()==QRING_CMD))
2743	&& (yyvsp[0].lv.rtyp==IDHDL))
2744	{
2745	idhdl h=(idhdl)yyvsp[0].lv.data;
2746	if (yyvsp[0].lv.e!=NULL) h=rFindHdl((ring)yyvsp[0].lv.Data(),NULL, NULL);
2747	//Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
2748	if (yyvsp[-1].i==KEEPRING_CMD)
2749	{
2750	if (h!=NULL)
2751	{
2752	if (IDLEV(h)!=0)
2753	{
2754	if (iiExport(&yyvsp[0].lv,myynest-1)) YYERROR;
2755	#if 1
2756	//if (TEST_OPT_KEEPVARS)
2757	//{
2758	idhdl p=IDRING(h)->idroot;
2759	idhdl root=p;
2760	int prevlev=myynest-1;
2761	while (p!=NULL)
2762	{
2763	if (IDLEV(p)==myynest)
2764	{
2765	idhdl old=root->get(IDID(p),prevlev);
2766	if (old!=NULL)
2767	{
2768	if (BVERBOSE(V_REDEFINE))
2769	Warn("redefining %s",IDID(p));
2770	killhdl2(old,&root,IDRING(h));
2771	IDRING(h)->idroot=root;
2772	}
2773	IDLEV(p)=prevlev;
2774	}
2775	p=IDNEXT(p);
2776	}
2777	//IDRING(h)->idroot=root;
2778	#endif
2779	//}
2780	}
2781	#ifdef USE_IILOCALRING
2782	iiLocalRing[myynest-1]=IDRING(h);
2783	#endif
2784	procstack->cRing=IDRING(h);
2785	procstack->cRingHdl=h;
2786	}
2787	else
2788	{
2789	Werror("%s is no identifier",n);
2790	yyvsp[0].lv.CleanUp();
2791	YYERROR;
2792	}
2793	}
2794	if (h!=NULL) rSetHdl(h);
2795	else
2796	{
2797	Werror("cannot find the name of the basering %s",n);
2798	yyvsp[0].lv.CleanUp();
2799	YYERROR;
2800	}
2801	yyvsp[0].lv.CleanUp();
2802	}
2803	else
2804	{
2805	Werror("%s is no name of a ring/qring",n);
2806	yyvsp[0].lv.CleanUp();
2807	YYERROR;
2808	}
2809	;
2810	break;}
2811	case 151:
2812	#line 1485 "grammar.y"
2813	{
2814	if (yyvsp[0].lv.rtyp!=IDHDL) MYYERROR("identifier expected");
2815	idhdl h = (idhdl)yyvsp[0].lv.data;
2816	type_cmd(h);
2817	;
2818	break;}
2819	case 152:
2820	#line 1491 "grammar.y"
2821	{
2822	//Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
2823	#ifdef SIQ
2824	if (yyvsp[0].lv.rtyp!=COMMAND)
2825	{
2826	#endif
2827	if (yyvsp[0].lv.Typ()==UNKNOWN)
2828	{
2829	if (yyvsp[0].lv.name!=NULL)
2830	{
2831	Werror("`%s` is undefined",yyvsp[0].lv.name);
2832	omFree((ADDRESS)yyvsp[0].lv.name);
2833	}
2834	YYERROR;
2835	}
2836	#ifdef SIQ
2837	}
2838	#endif
2839	yyvsp[0].lv.Print(&sLastPrinted);
2840	yyvsp[0].lv.CleanUp(currRing);
2841	if (errorreported) YYERROR;
2842	;
2843	break;}
2844	case 153:
2845	#line 1520 "grammar.y"
2846	{
2847	int i; TESTSETINT(yyvsp[-2].lv,i);
2848	if (i!=0)
2849	{
2850	newBuffer( yyvsp[0].name, BT_if);
2851	}
2852	else
2853	{
2854	omFree((ADDRESS)yyvsp[0].name);
2855	currentVoice->ifsw=1;
2856	}
2857	;
2858	break;}
2859	case 154:
2860	#line 1533 "grammar.y"
2861	{
2862	if (currentVoice->ifsw==1)
2863	{
2864	currentVoice->ifsw=0;
2865	newBuffer( yyvsp[0].name, BT_else);
2866	}
2867	else
2868	{
2869	if (currentVoice->ifsw!=2)
2870	{
2871	Warn("`else` without `if` in level %d",myynest);
2872	}
2873	omFree((ADDRESS)yyvsp[0].name);
2874	}
2875	currentVoice->ifsw=0;
2876	;
2877	break;}
2878	case 155:
2879	#line 1550 "grammar.y"
2880	{
2881	int i; TESTSETINT(yyvsp[-2].lv,i);
2882	if (i)
2883	{
2884	if (exitBuffer(BT_break)) YYERROR;
2885	}
2886	currentVoice->ifsw=0;
2887	;
2888	break;}
2889	case 156:
2890	#line 1559 "grammar.y"
2891	{
2892	if (exitBuffer(BT_break)) YYERROR;
2893	currentVoice->ifsw=0;
2894	;
2895	break;}
2896	case 157:
2897	#line 1564 "grammar.y"
2898	{
2899	if (contBuffer(BT_break)) YYERROR;
2900	currentVoice->ifsw=0;
2901	;
2902	break;}
2903	case 158:
2904	#line 1572 "grammar.y"
2905	{
2906	/* -> if(!$2) break; $3; continue;*/
2907	char * s = (char *)omAlloc( strlen(yyvsp[-1].name) + strlen(yyvsp[0].name) + 36);
2908	sprintf(s,"whileif (!(%s)) break;\n%scontinue;\n " ,yyvsp[-1].name,yyvsp[0].name);
2909	newBuffer(s,BT_break);
2910	omFree((ADDRESS)yyvsp[-1].name);
2911	omFree((ADDRESS)yyvsp[0].name);
2912	;
2913	break;}
2914	case 159:
2915	#line 1584 "grammar.y"
2916	{
2917	/* $2 */
2918	/* if (!$3) break; $5; $4; continue; */
2919	char * s = (char *)omAlloc( strlen(yyvsp[-2].name)+strlen(yyvsp[-1].name)+strlen(yyvsp[0].name)+36);
2920	sprintf(s,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
2921	,yyvsp[-2].name,yyvsp[0].name,yyvsp[-1].name);
2922	omFree((ADDRESS)yyvsp[-2].name);
2923	omFree((ADDRESS)yyvsp[-1].name);
2924	omFree((ADDRESS)yyvsp[0].name);
2925	newBuffer(s,BT_break);
2926	s = (char *)omAlloc( strlen(yyvsp[-3].name) + 3);
2927	sprintf(s,"%s;\n",yyvsp[-3].name);
2928	omFree((ADDRESS)yyvsp[-3].name);
2929	newBuffer(s,BT_if);
2930	;
2931	break;}
2932	case 160:
2933	#line 1603 "grammar.y"
2934	{
2935	procinfov pi;
2936	idhdl h = enterid(yyvsp[-1].name,myynest,PROC_CMD,&IDROOT,TRUE);
2937	if (h==NULL) {omFree((ADDRESS)yyvsp[-1].name);omFree((ADDRESS)yyvsp[0].name); YYERROR;}
2938	iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-1].name, 0, 0);
2939	IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+31);;
2940	sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",yyvsp[0].name);
2941	omFree((ADDRESS)yyvsp[0].name);
2942	omFree((ADDRESS)yyvsp[-1].name);
2943	;
2944	break;}
2945	case 161:
2946	#line 1614 "grammar.y"
2947	{
2948	idhdl h = enterid(yyvsp[-2].name,myynest,PROC_CMD,&IDROOT,TRUE);
2949	if (h==NULL)
2950	{
2951	omFree((ADDRESS)yyvsp[-2].name);
2952	omFree((ADDRESS)yyvsp[-1].name);
2953	omFree((ADDRESS)yyvsp[0].name);
2954	YYERROR;
2955	}
2956	char *args=iiProcArgs(yyvsp[-1].name,FALSE);
2957	omFree((ADDRESS)yyvsp[-1].name);
2958	procinfov pi;
2959	iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-2].name, 0, 0);
2960	IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+strlen(args)+14);;
2961	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,yyvsp[0].name);
2962	omFree((ADDRESS)args);
2963	omFree((ADDRESS)yyvsp[0].name);
2964	omFree((ADDRESS)yyvsp[-2].name);
2965	;
2966	break;}
2967	case 162:
2968	#line 1634 "grammar.y"
2969	{
2970	omFree((ADDRESS)yyvsp[-1].name);
2971	idhdl h = enterid(yyvsp[-3].name,myynest,PROC_CMD,&IDROOT,TRUE);
2972	if (h==NULL)
2973	{
2974	omFree((ADDRESS)yyvsp[-3].name);
2975	omFree((ADDRESS)yyvsp[-2].name);
2976	omFree((ADDRESS)yyvsp[0].name);
2977	YYERROR;
2978	}
2979	char *args=iiProcArgs(yyvsp[-2].name,FALSE);
2980	omFree((ADDRESS)yyvsp[-2].name);
2981	procinfov pi;
2982	iiInitSingularProcinfo(IDPROC(h),"", yyvsp[-3].name, 0, 0);
2983	omFree((ADDRESS)yyvsp[-3].name);
2984	IDPROC(h)->data.s.body = (char *)omAlloc(strlen(yyvsp[0].name)+strlen(args)+14);;
2985	sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,yyvsp[0].name);
2986	omFree((ADDRESS)args);
2987	omFree((ADDRESS)yyvsp[0].name);
2988	;
2989	break;}
2990	case 163:
2991	#line 1658 "grammar.y"
2992	{
2993	//Print("par:%s, %d\n",$2.Name(),$2.Typ());
2994	//yylineno--;
2995	if (iiParameter(&yyvsp[0].lv)) YYERROR;
2996	;
2997	break;}
2998	case 164:
2999	#line 1664 "grammar.y"
3000	{
3001	//Print("par:%s, %d\n",$2.Name(),$2.Typ());
3002	sleftv tmp_expr;
3003	//yylineno--;
3004	if ((iiDeclCommand(&tmp_expr,&yyvsp[0].lv,myynest,DEF_CMD,&IDROOT))
3005	\|\| (iiParameter(&tmp_expr)))
3006	YYERROR;
3007	;
3008	break;}
3009	case 165:
3010	#line 1676 "grammar.y"
3011	{
3012	if(iiRETURNEXPR==NULL) YYERROR;
3013	iiRETURNEXPR[myynest].Copy(&yyvsp[-1].lv);
3014	yyvsp[-1].lv.CleanUp();
3015	if (exitBuffer(BT_proc)) YYERROR;
3016	;
3017	break;}
3018	case 166:
3019	#line 1683 "grammar.y"
3020	{
3021	if (yyvsp[-2].i==RETURN)
3022	{
3023	if(iiRETURNEXPR==NULL) YYERROR;
3024	iiRETURNEXPR[myynest].Init();
3025	iiRETURNEXPR[myynest].rtyp=NONE;
3026	if (exitBuffer(BT_proc)) YYERROR;
3027	}
3028	;
3029	break;}
3030	}
3031	/* the action file gets copied in in place of this dollarsign */
3032	#line 543 "/usr/lib/bison.simple"
3033
3034	yyvsp -= yylen;
3035	yyssp -= yylen;
3036	#ifdef YYLSP_NEEDED
3037	yylsp -= yylen;
3038	#endif
3039
3040	#if YYDEBUG != 0
3041	if (yydebug)
3042	{
3043	short *ssp1 = yyss - 1;
3044	fprintf (stderr, "state stack now");
3045	while (ssp1 != yyssp)
3046	fprintf (stderr, " %d", *++ssp1);
3047	fprintf (stderr, "\n");
3048	}
3049	#endif
3050
3051	*++yyvsp = yyval;
3052
3053	#ifdef YYLSP_NEEDED
3054	yylsp++;
3055	if (yylen == 0)
3056	{
3057	yylsp->first_line = yylloc.first_line;
3058	yylsp->first_column = yylloc.first_column;
3059	yylsp->last_line = (yylsp-1)->last_line;
3060	yylsp->last_column = (yylsp-1)->last_column;
3061	yylsp->text = 0;
3062	}
3063	else
3064	{
3065	yylsp->last_line = (yylsp+yylen-1)->last_line;
3066	yylsp->last_column = (yylsp+yylen-1)->last_column;
3067	}
3068	#endif
3069
3070	/* Now "shift" the result of the reduction.
3071	Determine what state that goes to,
3072	based on the state we popped back to
3073	and the rule number reduced by. */
3074
3075	yyn = yyr1[yyn];
3076
3077	yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
3078	if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3079	yystate = yytable[yystate];
3080	else
3081	yystate = yydefgoto[yyn - YYNTBASE];
3082
3083	goto yynewstate;
3084
3085	yyerrlab: /* here on detecting error */
3086
3087	if (! yyerrstatus)
3088	/* If not already recovering from an error, report this error. */
3089	{
3090	++yynerrs;
3091
3092	#ifdef YYERROR_VERBOSE
3093	yyn = yypact[yystate];
3094
3095	if (yyn > YYFLAG && yyn < YYLAST)
3096	{
3097	int size = 0;
3098	char *msg;
3099	int x, count;
3100
3101	count = 0;
3102	/* Start X at -yyn if nec to avoid negative indexes in yycheck. */
3103	for (x = (yyn < 0 ? -yyn : 0);
3104	x < (sizeof(yytname) / sizeof(char *)); x++)
3105	if (yycheck[x + yyn] == x)
3106	size += strlen(yytname[x]) + 15, count++;
3107	msg = (char *) malloc(size + 15);
3108	if (msg != 0)
3109	{
3110	strcpy(msg, "parse error");
3111
3112	if (count < 5)
3113	{
3114	count = 0;
3115	for (x = (yyn < 0 ? -yyn : 0);
3116	x < (sizeof(yytname) / sizeof(char *)); x++)
3117	if (yycheck[x + yyn] == x)
3118	{
3119	strcat(msg, count == 0 ? ", expecting `" : " or `");
3120	strcat(msg, yytname[x]);
3121	strcat(msg, "'");
3122	count++;
3123	}
3124	}
3125	yyerror(msg);
3126	free(msg);
3127	}
3128	else
3129	yyerror ("parse error; also virtual memory exceeded");
3130	}
3131	else
3132	#endif /* YYERROR_VERBOSE */
3133	yyerror("parse error");
3134	}
3135
3136	goto yyerrlab1;
3137	yyerrlab1: /* here on error raised explicitly by an action */
3138
3139	if (yyerrstatus == 3)
3140	{
3141	/* if just tried and failed to reuse lookahead token after an error, discard it. */
3142
3143	/* return failure if at end of input */
3144	if (yychar == YYEOF)
3145	YYABORT;
3146
3147	#if YYDEBUG != 0
3148	if (yydebug)
3149	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
3150	#endif
3151
3152	yychar = YYEMPTY;
3153	}
3154
3155	/* Else will try to reuse lookahead token
3156	after shifting the error token. */
3157
3158	yyerrstatus = 3; /* Each real token shifted decrements this */
3159
3160	goto yyerrhandle;
3161
3162	yyerrdefault: /* current state does not do anything special for the error token. */
3163
3164	#if 0
3165	/* This is wrong; only states that explicitly want error tokens
3166	should shift them. */
3167	yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
3168	if (yyn) goto yydefault;
3169	#endif
3170
3171	yyerrpop: /* pop the current state because it cannot handle the error token */
3172
3173	if (yyssp == yyss) YYABORT;
3174	yyvsp--;
3175	yystate = *--yyssp;
3176	#ifdef YYLSP_NEEDED
3177	yylsp--;
3178	#endif
3179
3180	#if YYDEBUG != 0
3181	if (yydebug)
3182	{
3183	short *ssp1 = yyss - 1;
3184	fprintf (stderr, "Error: state stack now");
3185	while (ssp1 != yyssp)
3186	fprintf (stderr, " %d", *++ssp1);
3187	fprintf (stderr, "\n");
3188	}
3189	#endif
3190
3191	yyerrhandle:
3192
3193	yyn = yypact[yystate];
3194	if (yyn == YYFLAG)
3195	goto yyerrdefault;
3196
3197	yyn += YYTERROR;
3198	if (yyn < 0 \|\| yyn > YYLAST \|\| yycheck[yyn] != YYTERROR)
3199	goto yyerrdefault;
3200
3201	yyn = yytable[yyn];
3202	if (yyn < 0)
3203	{
3204	if (yyn == YYFLAG)
3205	goto yyerrpop;
3206	yyn = -yyn;
3207	goto yyreduce;
3208	}
3209	else if (yyn == 0)
3210	goto yyerrpop;
3211
3212	if (yyn == YYFINAL)
3213	YYACCEPT;
3214
3215	#if YYDEBUG != 0
3216	if (yydebug)
3217	fprintf(stderr, "Shifting error token, ");
3218	#endif
3219
3220	*++yyvsp = yylval;
3221	#ifdef YYLSP_NEEDED
3222	*++yylsp = yylloc;
3223	#endif
3224
3225	yystate = yyn;
3226	goto yynewstate;
3227
3228	yyacceptlab:
3229	/* YYACCEPT comes here. */
3230	if (yyfree_stacks)
3231	{
3232	free (yyss);
3233	free (yyvs);
3234	#ifdef YYLSP_NEEDED
3235	free (yyls);
3236	#endif
3237	}
3238	return 0;
3239
3240	yyabortlab:
3241	/* YYABORT comes here. */
3242	if (yyfree_stacks)
3243	{
3244	free (yyss);
3245	free (yyvs);
3246	#ifdef YYLSP_NEEDED
3247	free (yyls);
3248	#endif
3249	}
3250	return 1;
3251	}
3252	#line 1693 "grammar.y"

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

Download in other formats: