My Project
Loading...
Searching...
No Matches
grammar.cc
Go to the documentation of this file.
1/* A Bison parser, made by GNU Bison 2.4.3. */
2
3/* Skeleton implementation for Bison's Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 2009, 2010 Free Software Foundation, Inc.
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21/* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34/* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
36
37/* All symbols defined below should begin with yy or YY, to avoid
38 infringing on user name space. This should be done even for local
39 variables, as they might otherwise be expanded by user macros.
40 There are some unavoidable exceptions within include files to
41 define necessary library symbols; they are noted "INFRINGES ON
42 USER NAME SPACE" below. */
43
44/* Identify Bison output. */
45#define YYBISON 1
46
47/* Bison version. */
48#define YYBISON_VERSION "2.4.3"
49
50/* Skeleton name. */
51#define YYSKELETON_NAME "yacc.c"
52
53/* Pure parsers. */
54#define YYPURE 1
55
56/* Push parsers. */
57#define YYPUSH 0
58
59/* Pull parsers. */
60#define YYPULL 1
61
62/* Using locations. */
63#define YYLSP_NEEDED 0
64
65
66
67/* Copy the first part of user declarations. */
68
69/* Line 189 of yacc.c */
70#line 7 "grammar.y"
71
72
73#include <stdio.h>
74#include <stddef.h>
75#include <stdlib.h>
76#include <stdarg.h>
77#include <string.h>
78
79#include "kernel/mod2.h"
80#include "Singular/grammar.h"
81
82#include "misc/mylimits.h"
83#include "omalloc/omalloc.h"
84#include "Singular/tok.h"
85#include "misc/options.h"
86#include "Singular/stype.h"
87#include "Singular/fehelp.h"
88#include "Singular/ipid.h"
89#include "misc/intvec.h"
90#include "kernel/oswrapper/feread.h"
91#include "Singular/fevoices.h"
92#include "polys/matpol.h"
93#include "polys/monomials/ring.h"
94#include "kernel/GBEngine/kstd1.h"
95#include "Singular/subexpr.h"
96#include "Singular/ipshell.h"
97#include "Singular/ipconv.h"
98#include "Singular/sdb.h"
99#include "kernel/ideals.h"
100#include "coeffs/numbers.h"
101#include "kernel/polys.h"
102#include "kernel/combinatorics/stairc.h"
103#include "kernel/oswrapper/timer.h"
104#include "Singular/cntrlc.h"
105#include "polys/monomials/maps.h"
106#include "kernel/GBEngine/syz.h"
107#include "Singular/lists.h"
108#include "Singular/libparse.h"
109#include "coeffs/bigintmat.h"
110
111#if 0
112void debug_list(leftv v)
113{
114 idhdl r=basePackHdl;
115 idhdl h;
116 BOOLEAN found=FALSE;
117 const char *nn=v->name;
118 h=IDROOT->get(nn,myynest);
119 if (h!=NULL)
120 {
121 Print("Curr::%s, (%s)\n",nn,Tok2Cmdname((int)IDTYP(h)));
122 found=TRUE;
123 }
124 else Print("`%s` not found in IDROOT\n",nn);
125 while (r!=NULL)
126 {
127 if ((IDTYP(r)==PACKAGE_CMD)
128 || (IDTYP(r)==RING_CMD))
129 {
130 h=IDPACKAGE(r)->idroot->get(nn,myynest);
131 if (h!=NULL)
132 {
133 Print("%s::%s, (%s)\n",r->id,nn,Tok2Cmdname((int)IDTYP(h)));
134 found=TRUE;
135 }
136 else Print("%s::%s not found\n",r->id,nn);
137 }
138 if (r==basePackHdl) r=IDPACKAGE(r)->idroot;
139 r=r->next;
140 if (r==basePackHdl) break;
141 }
142 if (!found)
143 {
144 listall(TRUE);
145 }
146}
147#endif
148
149/* From the bison docu:
150
151 By defining the macro `YYMAXDEPTH', you can control how deep the
152parser stack can become before a stack overflow occurs. Define the
153macro with a value that is an integer. This value is the maximum number
154of tokens that can be shifted (and not reduced) before overflow. It
155must be a constant expression whose value is known at compile time.
156
157 The stack space allowed is not necessarily allocated. If you
158specify a large value for `YYMAXDEPTH', the parser actually allocates a
159small stack at first, and then makes it bigger by stages as needed.
160This increasing allocation happens automatically and silently.
161Therefore, you do not need to make `YYMAXDEPTH' painfully small merely
162to save space for ordinary inputs that do not need much stack.
163
164 The default value of `YYMAXDEPTH', if you do not define it, is 10000.
165*/
166#define YYMAXDEPTH MAX_INT_VAL
167
168extern int yylineno;
169extern FILE* yyin;
170
171const char * currid;
172BOOLEAN yyInRingConstruction=FALSE;
173BOOLEAN expected_parms;
174int cmdtok;
175int inerror = 0;
176
177#define TESTSETINT(a,i) \
178 if ((a).Typ() != INT_CMD) \
179 { \
180 WerrorS("no int expression"); \
181 YYERROR; \
182 } \
183 (i) = (int)((long)(a).Data());(a).CleanUp()
184
185#define MYYERROR(a) { WerrorS(a); YYERROR; }
186
187void yyerror(const char * fmt)
188{
189
190 BOOLEAN old_errorreported=errorreported;
191 errorreported = TRUE;
192 if (currid!=NULL)
193 {
194 killid(currid,&IDROOT);
195 currid = NULL;
196 }
197 if(inerror==0)
198 {
199 {
200 if ((strlen(fmt)>1)
201 && (strncmp(fmt,"parse",5)!=0)
202 && (strncmp(fmt,"syntax",6)!=0))
203 WerrorS(fmt);
204 Werror( "error occurred in or before %s line %d: `%s`"
205 ,VoiceName(), yylineno, my_yylinebuf);
206 }
207 if (cmdtok!=0)
208 {
209 const char *s=Tok2Cmdname(cmdtok);
210 if (expected_parms)
211 {
212 Werror("expected %s-expression. type \'help %s;\'",s,s);
213 }
214 else
215 {
216 Werror("wrong type declaration. type \'help %s;\'",s);
217 }
218 }
219 if (!old_errorreported && (lastreserved!=NULL))
220 {
221 Werror("last reserved name was `%s`",lastreserved);
222 }
223 inerror=1;
224 }
225 if ((currentVoice!=NULL)
226 && (currentVoice->prev!=NULL)
227 && (myynest>0)
228#ifdef HAVE_SDB
229 && ((sdb_flags &1)==0)
230#endif
231 )
232 {
233 Werror("leaving %s (%d)",VoiceName(), VoiceLine());
234 }
235}
236
237
238
239/* Line 189 of yacc.c */
240#line 241 "grammar.cc"
241
242/* Enabling traces. */
243#ifndef YYDEBUG
244# define YYDEBUG 1
245#endif
246
247/* Enabling verbose error messages. */
248#ifdef YYERROR_VERBOSE
249# undef YYERROR_VERBOSE
250# define YYERROR_VERBOSE 1
251#else
252# define YYERROR_VERBOSE 0
253#endif
254
255/* Enabling the token table. */
256#ifndef YYTOKEN_TABLE
257# define YYTOKEN_TABLE 0
258#endif
259
260
261/* Tokens. */
262#ifndef YYTOKENTYPE
263# define YYTOKENTYPE
264 /* Put the tokens into the symbol table, so that GDB and other debuggers
265 know about them. */
266 enum yytokentype {
267 DOTDOT = 258,
268 EQUAL_EQUAL = 259,
269 GE = 260,
270 LE = 261,
271 MINUSMINUS = 262,
272 NOT = 263,
273 NOTEQUAL = 264,
274 PLUSPLUS = 265,
275 COLONCOLON = 266,
276 ARROW = 267,
277 GRING_CMD = 268,
278 BIGINTMAT_CMD = 269,
279 BIGINTVEC_CMD = 270,
280 INTMAT_CMD = 271,
281 PROC_CMD = 272,
282 RING_CMD = 273,
283 BEGIN_RING = 274,
284 BUCKET_CMD = 275,
285 IDEAL_CMD = 276,
286 MAP_CMD = 277,
287 MATRIX_CMD = 278,
288 MODUL_CMD = 279,
289 NUMBER_CMD = 280,
290 POLY_CMD = 281,
291 RESOLUTION_CMD = 282,
292 SMATRIX_CMD = 283,
293 VECTOR_CMD = 284,
294 BETTI_CMD = 285,
295 E_CMD = 286,
296 FETCH_CMD = 287,
297 FREEMODULE_CMD = 288,
298 KEEPRING_CMD = 289,
299 IMAP_CMD = 290,
300 KOSZUL_CMD = 291,
301 MAXID_CMD = 292,
302 MONOM_CMD = 293,
303 PAR_CMD = 294,
304 PREIMAGE_CMD = 295,
305 VAR_CMD = 296,
306 VALTVARS = 297,
307 VMAXDEG = 298,
308 VMAXMULT = 299,
309 VNOETHER = 300,
310 VMINPOLY = 301,
311 END_RING = 302,
312 CMD_1 = 303,
313 CMD_2 = 304,
314 CMD_3 = 305,
315 CMD_12 = 306,
316 CMD_13 = 307,
317 CMD_23 = 308,
318 CMD_123 = 309,
319 CMD_M = 310,
320 ROOT_DECL = 311,
321 ROOT_DECL_LIST = 312,
322 RING_DECL = 313,
323 RING_DECL_LIST = 314,
324 EXAMPLE_CMD = 315,
325 EXPORT_CMD = 316,
326 HELP_CMD = 317,
327 KILL_CMD = 318,
328 LIB_CMD = 319,
329 LISTVAR_CMD = 320,
330 SETRING_CMD = 321,
331 TYPE_CMD = 322,
332 STRINGTOK = 323,
333 BLOCKTOK = 324,
334 INT_CONST = 325,
335 UNKNOWN_IDENT = 326,
336 MONOM = 327,
337 PROC_DEF = 328,
338 APPLY = 329,
339 ASSUME_CMD = 330,
340 BREAK_CMD = 331,
341 CONTINUE_CMD = 332,
342 ELSE_CMD = 333,
343 EVAL = 334,
344 QUOTE = 335,
345 FOR_CMD = 336,
346 IF_CMD = 337,
347 SYS_BREAK = 338,
348 WHILE_CMD = 339,
349 RETURN = 340,
350 PARAMETER = 341,
351 SYSVAR = 342,
352 UMINUS = 343
353 };
354#endif
355
356
357
358#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
359
360# define yystype YYSTYPE /* obsolescent; will be withdrawn */
361# define YYSTYPE_IS_DECLARED 1
362#endif
363
364
365/* Copy the second part of user declarations. */
366
367
368/* Line 264 of yacc.c */
369#line 370 "grammar.cc"
370
371#ifdef short
372# undef short
373#endif
374
375#ifdef YYTYPE_UINT8
376typedef YYTYPE_UINT8 yytype_uint8;
377#else
378typedef unsigned char yytype_uint8;
379#endif
380
381#ifdef YYTYPE_INT8
382typedef YYTYPE_INT8 yytype_int8;
383#elif (defined __STDC__ || defined __C99__FUNC__ \
384 || defined __cplusplus || defined _MSC_VER)
385typedef signed char yytype_int8;
386#else
387typedef short int yytype_int8;
388#endif
389
390#ifdef YYTYPE_UINT16
391typedef YYTYPE_UINT16 yytype_uint16;
392#else
393typedef unsigned short int yytype_uint16;
394#endif
395
396#ifdef YYTYPE_INT16
397typedef YYTYPE_INT16 yytype_int16;
398#else
399typedef short int yytype_int16;
400#endif
401
402#ifndef YYSIZE_T
403# ifdef __SIZE_TYPE__
404# define YYSIZE_T __SIZE_TYPE__
405# elif defined size_t
406# define YYSIZE_T size_t
407# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
408 || defined __cplusplus || defined _MSC_VER)
409# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
410# define YYSIZE_T size_t
411# else
412# define YYSIZE_T unsigned int
413# endif
414#endif
415
416#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
417
418#ifndef YY_
419# if defined YYENABLE_NLS && YYENABLE_NLS
420# if ENABLE_NLS
421# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
422# define YY_(msgid) dgettext ("bison-runtime", msgid)
423# endif
424# endif
425# ifndef YY_
426# define YY_(msgid) msgid
427# endif
428#endif
429
430/* Suppress unused-variable warnings by "using" E. */
431#if ! defined lint || defined __GNUC__
432# define YYUSE(e) ((void) (e))
433#else
434# define YYUSE(e) /* empty */
435#endif
436
437/* Identity function, used to suppress warnings about constant conditions. */
438#ifndef lint
439# define YYID(n) (n)
440#else
441#if (defined __STDC__ || defined __C99__FUNC__ \
442 || defined __cplusplus || defined _MSC_VER)
443static int
444YYID (int yyi)
445#else
446static int
447YYID (yyi)
448 int yyi;
449#endif
450{
451 return yyi;
452}
453#endif
454
455#if ! defined yyoverflow || YYERROR_VERBOSE
456
457/* The parser invokes alloca or malloc; define the necessary symbols. */
458
459# ifdef YYSTACK_USE_ALLOCA
460# if YYSTACK_USE_ALLOCA
461# ifdef __GNUC__
462# define YYSTACK_ALLOC __builtin_alloca
463# elif defined __BUILTIN_VA_ARG_INCR
464# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
465# elif defined _AIX
466# define YYSTACK_ALLOC __alloca
467# elif defined _MSC_VER
468# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
469# define alloca _alloca
470# else
471# define YYSTACK_ALLOC alloca
472# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
473 || defined __cplusplus || defined _MSC_VER)
474# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
475# ifndef _STDLIB_H
476# define _STDLIB_H 1
477# endif
478# endif
479# endif
480# endif
481# endif
482
483# ifdef YYSTACK_ALLOC
484 /* Pacify GCC's `empty if-body' warning. */
485# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
486# ifndef YYSTACK_ALLOC_MAXIMUM
487 /* The OS might guarantee only one guard page at the bottom of the stack,
488 and a page size can be as small as 4096 bytes. So we cannot safely
489 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
490 to allow for a few compiler-allocated temporary stack slots. */
491# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
492# endif
493# else
494# define YYSTACK_ALLOC YYMALLOC
495# define YYSTACK_FREE YYFREE
496# ifndef YYSTACK_ALLOC_MAXIMUM
497# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
498# endif
499# if (defined __cplusplus && ! defined _STDLIB_H \
500 && ! ((defined YYMALLOC || defined malloc) \
501 && (defined YYFREE || defined free)))
502# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
503# ifndef _STDLIB_H
504# define _STDLIB_H 1
505# endif
506# endif
507# ifndef YYMALLOC
508# define YYMALLOC malloc
509# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
510 || defined __cplusplus || defined _MSC_VER)
511void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
512# endif
513# endif
514# ifndef YYFREE
515# define YYFREE free
516# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
517 || defined __cplusplus || defined _MSC_VER)
518void free (void *); /* INFRINGES ON USER NAME SPACE */
519# endif
520# endif
521# endif
522#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
523
524
525#if (! defined yyoverflow \
526 && (! defined __cplusplus \
527 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
528
529/* A type that is properly aligned for any stack member. */
530union yyalloc
531{
532 yytype_int16 yyss_alloc;
533 YYSTYPE yyvs_alloc;
534};
535
536/* The size of the maximum gap between one aligned stack and the next. */
537# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
538
539/* The size of an array large to enough to hold all stacks, each with
540 N elements. */
541# define YYSTACK_BYTES(N) \
542 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
543 + YYSTACK_GAP_MAXIMUM)
544
545/* Copy COUNT objects from FROM to TO. The source and destination do
546 not overlap. */
547# ifndef YYCOPY
548# if defined __GNUC__ && 1 < __GNUC__
549# define YYCOPY(To, From, Count) \
550 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
551# else
552# define YYCOPY(To, From, Count) \
553 do \
554 { \
555 YYSIZE_T yyi; \
556 for (yyi = 0; yyi < (Count); yyi++) \
557 (To)[yyi] = (From)[yyi]; \
558 } \
559 while (YYID (0))
560# endif
561# endif
562
563/* Relocate STACK from its old location to the new one. The
564 local variables YYSIZE and YYSTACKSIZE give the old and new number of
565 elements in the stack, and YYPTR gives the new location of the
566 stack. Advance YYPTR to a properly aligned location for the next
567 stack. */
568# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
569 do \
570 { \
571 YYSIZE_T yynewbytes; \
572 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
573 Stack = &yyptr->Stack_alloc; \
574 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
575 yyptr += yynewbytes / sizeof (*yyptr); \
576 } \
577 while (YYID (0))
578
579#endif
580
581/* YYFINAL -- State number of the termination state. */
582#define YYFINAL 2
583/* YYLAST -- Last index in YYTABLE. */
584#define YYLAST 2747
585
586/* YYNTOKENS -- Number of terminals. */
587#define YYNTOKENS 105
588/* YYNNTS -- Number of nonterminals. */
589#define YYNNTS 44
590/* YYNRULES -- Number of rules. */
591#define YYNRULES 175
592/* YYNRULES -- Number of states. */
593#define YYNSTATES 398
594
595/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
596#define YYUNDEFTOK 2
597#define YYMAXUTOK 343
598
599#define YYTRANSLATE(YYX) \
600 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
601
602/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
603static const yytype_uint8 yytranslate[] =
604{
605 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
606 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
607 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
608 2, 2, 2, 2, 2, 2, 2, 2, 98, 2,
609 101, 102, 2, 90, 96, 91, 103, 92, 2, 2,
610 2, 2, 2, 2, 2, 2, 2, 2, 99, 97,
611 89, 88, 2, 2, 2, 2, 2, 2, 2, 2,
612 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
613 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
614 2, 93, 2, 94, 95, 2, 104, 2, 2, 2,
615 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
616 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
617 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
618 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
619 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
620 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
621 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
622 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
623 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
624 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
625 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
626 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
627 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
628 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
629 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
630 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
631 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
632 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
633 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
634 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
635 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
636 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
637 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
638 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
639 85, 86, 87, 100
640};
641
642#if YYDEBUG
643/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
644 YYRHS. */
645static const yytype_uint16 yyprhs[] =
646{
647 0, 0, 3, 4, 7, 9, 12, 15, 17, 19,
648 21, 24, 26, 28, 30, 32, 34, 36, 38, 40,
649 43, 45, 47, 49, 51, 53, 55, 57, 59, 61,
650 64, 66, 68, 72, 76, 80, 85, 89, 91, 93,
651 95, 100, 105, 110, 114, 119, 124, 128, 133, 138,
652 143, 148, 155, 162, 169, 176, 185, 194, 203, 212,
653 216, 221, 230, 235, 244, 249, 253, 257, 261, 263,
654 265, 267, 274, 279, 286, 293, 300, 307, 314, 321,
655 325, 331, 337, 338, 344, 347, 350, 352, 355, 358,
656 362, 366, 370, 374, 378, 382, 386, 390, 394, 398,
657 401, 404, 407, 410, 412, 416, 419, 422, 425, 428,
658 437, 440, 444, 447, 449, 451, 457, 459, 461, 466,
659 468, 472, 474, 478, 480, 482, 484, 486, 488, 491,
660 495, 498, 502, 505, 508, 512, 517, 522, 527, 532,
661 537, 542, 547, 552, 559, 566, 573, 580, 587, 594,
662 601, 605, 607, 616, 619, 624, 632, 635, 637, 639,
663 642, 645, 647, 653, 656, 662, 664, 666, 670, 676,
664 680, 684, 689, 692, 695, 700
665};
666
667/* YYRHS -- A `-1'-separated list of the rules' RHS. */
668static const yytype_int16 yyrhs[] =
669{
670 106, 0, -1, -1, 106, 107, -1, 108, -1, 110,
671 97, -1, 122, 97, -1, 148, -1, 83, -1, 97,
672 -1, 1, 97, -1, 143, -1, 144, -1, 109, -1,
673 145, -1, 146, -1, 131, -1, 132, -1, 133, -1,
674 60, 69, -1, 111, -1, 134, -1, 135, -1, 136,
675 -1, 147, -1, 138, -1, 139, -1, 141, -1, 142,
676 -1, 120, 113, -1, 72, -1, 121, -1, 112, 11,
677 112, -1, 114, 103, 112, -1, 112, 101, 102, -1,
678 112, 101, 113, 102, -1, 93, 113, 94, -1, 70,
679 -1, 87, -1, 123, -1, 17, 101, 114, 102, -1,
680 56, 101, 114, 102, -1, 57, 101, 113, 102, -1,
681 57, 101, 102, -1, 58, 101, 114, 102, -1, 59,
682 101, 113, 102, -1, 59, 101, 102, -1, 48, 101,
683 114, 102, -1, 51, 101, 114, 102, -1, 52, 101,
684 114, 102, -1, 54, 101, 114, 102, -1, 49, 101,
685 114, 96, 114, 102, -1, 51, 101, 114, 96, 114,
686 102, -1, 53, 101, 114, 96, 114, 102, -1, 54,
687 101, 114, 96, 114, 102, -1, 50, 101, 114, 96,
688 114, 96, 114, 102, -1, 52, 101, 114, 96, 114,
689 96, 114, 102, -1, 53, 101, 114, 96, 114, 96,
690 114, 102, -1, 54, 101, 114, 96, 114, 96, 114,
691 102, -1, 55, 101, 102, -1, 55, 101, 113, 102,
692 -1, 130, 101, 114, 96, 114, 96, 114, 102, -1,
693 130, 101, 114, 102, -1, 18, 101, 124, 96, 124,
694 96, 128, 102, -1, 18, 101, 114, 102, -1, 121,
695 12, 69, -1, 101, 113, 102, -1, 113, 96, 114,
696 -1, 114, -1, 119, -1, 112, -1, 114, 93, 114,
697 96, 114, 94, -1, 114, 93, 114, 94, -1, 74,
698 101, 114, 96, 48, 102, -1, 74, 101, 114, 96,
699 51, 102, -1, 74, 101, 114, 96, 52, 102, -1,
700 74, 101, 114, 96, 54, 102, -1, 74, 101, 114,
701 96, 55, 102, -1, 74, 101, 114, 96, 114, 102,
702 -1, 116, 114, 118, -1, 116, 114, 88, 114, 118,
703 -1, 117, 114, 96, 114, 118, -1, -1, 79, 101,
704 115, 114, 102, -1, 80, 101, -1, 75, 101, -1,
705 102, -1, 114, 10, -1, 114, 7, -1, 114, 90,
706 114, -1, 114, 91, 114, -1, 114, 92, 114, -1,
707 114, 95, 114, -1, 114, 89, 114, -1, 114, 98,
708 114, -1, 114, 9, 114, -1, 114, 4, 114, -1,
709 114, 3, 114, -1, 114, 99, 114, -1, 8, 114,
710 -1, 91, 114, -1, 122, 129, -1, 113, 129, -1,
711 71, -1, 104, 114, 104, -1, 56, 112, -1, 57,
712 112, -1, 58, 112, -1, 59, 112, -1, 130, 112,
713 93, 114, 94, 93, 114, 94, -1, 130, 112, -1,
714 122, 96, 112, -1, 17, 112, -1, 68, -1, 114,
715 -1, 101, 114, 96, 113, 102, -1, 71, -1, 125,
716 -1, 125, 101, 113, 102, -1, 126, -1, 126, 96,
717 127, -1, 126, -1, 101, 127, 102, -1, 88, -1,
718 23, -1, 28, -1, 16, -1, 14, -1, 89, 123,
719 -1, 62, 68, 97, -1, 62, 97, -1, 60, 68,
720 97, -1, 61, 113, -1, 63, 112, -1, 135, 96,
721 112, -1, 65, 101, 56, 102, -1, 65, 101, 57,
722 102, -1, 65, 101, 58, 102, -1, 65, 101, 59,
723 102, -1, 65, 101, 18, 102, -1, 65, 101, 130,
724 102, -1, 65, 101, 17, 102, -1, 65, 101, 112,
725 102, -1, 65, 101, 112, 96, 56, 102, -1, 65,
726 101, 112, 96, 57, 102, -1, 65, 101, 112, 96,
727 58, 102, -1, 65, 101, 112, 96, 59, 102, -1,
728 65, 101, 112, 96, 18, 102, -1, 65, 101, 112,
729 96, 130, 102, -1, 65, 101, 112, 96, 17, 102,
730 -1, 65, 101, 102, -1, 18, -1, 137, 112, 129,
731 124, 96, 124, 96, 128, -1, 137, 112, -1, 137,
732 112, 129, 112, -1, 137, 112, 129, 112, 93, 113,
733 94, -1, 87, 123, -1, 66, -1, 34, -1, 140,
734 114, -1, 67, 114, -1, 113, -1, 82, 101, 114,
735 102, 69, -1, 78, 69, -1, 82, 101, 114, 102,
736 76, -1, 76, -1, 77, -1, 84, 68, 69, -1,
737 81, 68, 68, 68, 69, -1, 17, 121, 69, -1,
738 73, 68, 69, -1, 73, 68, 68, 69, -1, 86,
739 122, -1, 86, 114, -1, 85, 101, 113, 102, -1,
740 85, 101, 102, -1
741};
742
743/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
744static const yytype_uint16 yyrline[] =
745{
746 0, 319, 319, 321, 355, 356, 358, 360, 364, 369,
747 371, 422, 423, 424, 425, 426, 427, 428, 429, 433,
748 436, 437, 438, 439, 440, 441, 442, 443, 444, 447,
749 454, 459, 463, 467, 471, 475, 489, 517, 541, 547,
750 553, 557, 561, 565, 569, 573, 577, 581, 585, 589,
751 593, 597, 601, 605, 609, 613, 617, 621, 625, 629,
752 633, 639, 643, 647, 651, 655, 660, 664, 675, 678,
753 679, 680, 684, 688, 692, 696, 700, 704, 708, 712,
754 716, 733, 740, 739, 757, 765, 773, 782, 786, 790,
755 794, 798, 802, 806, 810, 814, 818, 822, 826, 830,
756 842, 849, 850, 869, 870, 882, 887, 892, 896, 900,
757 937, 961, 982, 990, 994, 995, 1009, 1017, 1026, 1071,
758 1072, 1081, 1082, 1088, 1095, 1096, 1097, 1098, 1106, 1111,
759 1116, 1123, 1131, 1143, 1160, 1180, 1184, 1188, 1193, 1197,
760 1201, 1205, 1209, 1214, 1220, 1226, 1232, 1238, 1244, 1250,
761 1262, 1269, 1273, 1310, 1317, 1322, 1335, 1342, 1342, 1345,
762 1413, 1417, 1446, 1459, 1476, 1485, 1490, 1498, 1511, 1532,
763 1542, 1561, 1584, 1590, 1602, 1608
764};
765#endif
766
767#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
768/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
769 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
770static const char *const yytname[] =
771{
772 "$end", "error", "$undefined", "DOTDOT", "EQUAL_EQUAL", "GE", "LE",
773 "MINUSMINUS", "NOT", "NOTEQUAL", "PLUSPLUS", "COLONCOLON", "ARROW",
774 "GRING_CMD", "BIGINTMAT_CMD", "BIGINTVEC_CMD", "INTMAT_CMD", "PROC_CMD",
775 "RING_CMD", "BEGIN_RING", "BUCKET_CMD", "IDEAL_CMD", "MAP_CMD",
776 "MATRIX_CMD", "MODUL_CMD", "NUMBER_CMD", "POLY_CMD", "RESOLUTION_CMD",
777 "SMATRIX_CMD", "VECTOR_CMD", "BETTI_CMD", "E_CMD", "FETCH_CMD",
778 "FREEMODULE_CMD", "KEEPRING_CMD", "IMAP_CMD", "KOSZUL_CMD", "MAXID_CMD",
779 "MONOM_CMD", "PAR_CMD", "PREIMAGE_CMD", "VAR_CMD", "VALTVARS", "VMAXDEG",
780 "VMAXMULT", "VNOETHER", "VMINPOLY", "END_RING", "CMD_1", "CMD_2",
781 "CMD_3", "CMD_12", "CMD_13", "CMD_23", "CMD_123", "CMD_M", "ROOT_DECL",
782 "ROOT_DECL_LIST", "RING_DECL", "RING_DECL_LIST", "EXAMPLE_CMD",
783 "EXPORT_CMD", "HELP_CMD", "KILL_CMD", "LIB_CMD", "LISTVAR_CMD",
784 "SETRING_CMD", "TYPE_CMD", "STRINGTOK", "BLOCKTOK", "INT_CONST",
785 "UNKNOWN_IDENT", "MONOM", "PROC_DEF", "APPLY", "ASSUME_CMD", "BREAK_CMD",
786 "CONTINUE_CMD", "ELSE_CMD", "EVAL", "QUOTE", "FOR_CMD", "IF_CMD",
787 "SYS_BREAK", "WHILE_CMD", "RETURN", "PARAMETER", "SYSVAR", "'='", "'<'",
788 "'+'", "'-'", "'/'", "'['", "']'", "'^'", "','", "';'", "'&'", "':'",
789 "UMINUS", "'('", "')'", "'.'", "'`'", "$accept", "lines", "pprompt",
790 "flowctrl", "example_dummy", "command", "assign", "elemexpr", "exprlist",
791 "expr", "$@1", "quote_start", "assume_start", "quote_end",
792 "expr_arithmetic", "left_value", "extendedid", "declare_ip_variable",
793 "stringexpr", "rlist", "ordername", "orderelem", "OrderingList",
794 "ordering", "cmdeq", "mat_cmd", "filecmd", "helpcmd", "examplecmd",
795 "exportcmd", "killcmd", "listcmd", "ringcmd1", "ringcmd", "scriptcmd",
796 "setrings", "setringcmd", "typecmd", "ifcmd", "whilecmd", "forcmd",
797 "proccmd", "parametercmd", "returncmd", 0
798};
799#endif
800
801# ifdef YYPRINT
802/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
803 token YYLEX-NUM. */
804static const yytype_uint16 yytoknum[] =
805{
806 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
807 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
808 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
809 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
810 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
811 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
812 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
813 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
814 335, 336, 337, 338, 339, 340, 341, 342, 61, 60,
815 43, 45, 47, 91, 93, 94, 44, 59, 38, 58,
816 343, 40, 41, 46, 96
817};
818# endif
819
820/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
821static const yytype_uint8 yyr1[] =
822{
823 0, 105, 106, 106, 107, 107, 107, 107, 107, 107,
824 107, 108, 108, 108, 108, 108, 108, 108, 108, 109,
825 110, 110, 110, 110, 110, 110, 110, 110, 110, 111,
826 112, 112, 112, 112, 112, 112, 112, 112, 112, 112,
827 112, 112, 112, 112, 112, 112, 112, 112, 112, 112,
828 112, 112, 112, 112, 112, 112, 112, 112, 112, 112,
829 112, 112, 112, 112, 112, 112, 112, 113, 113, 114,
830 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
831 114, 114, 115, 114, 116, 117, 118, 119, 119, 119,
832 119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
833 119, 120, 120, 121, 121, 122, 122, 122, 122, 122,
834 122, 122, 122, 123, 124, 124, 125, 126, 126, 127,
835 127, 128, 128, 129, 130, 130, 130, 130, 131, 132,
836 132, 133, 134, 135, 135, 136, 136, 136, 136, 136,
837 136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
838 136, 137, 138, 138, 138, 138, 139, 140, 140, 141,
839 142, 142, 143, 143, 143, 143, 143, 144, 145, 146,
840 146, 146, 147, 147, 148, 148
841};
842
843/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
844static const yytype_uint8 yyr2[] =
845{
846 0, 2, 0, 2, 1, 2, 2, 1, 1, 1,
847 2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
848 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
849 1, 1, 3, 3, 3, 4, 3, 1, 1, 1,
850 4, 4, 4, 3, 4, 4, 3, 4, 4, 4,
851 4, 6, 6, 6, 6, 8, 8, 8, 8, 3,
852 4, 8, 4, 8, 4, 3, 3, 3, 1, 1,
853 1, 6, 4, 6, 6, 6, 6, 6, 6, 3,
854 5, 5, 0, 5, 2, 2, 1, 2, 2, 3,
855 3, 3, 3, 3, 3, 3, 3, 3, 3, 2,
856 2, 2, 2, 1, 3, 2, 2, 2, 2, 8,
857 2, 3, 2, 1, 1, 5, 1, 1, 4, 1,
858 3, 1, 3, 1, 1, 1, 1, 1, 2, 3,
859 2, 3, 2, 2, 3, 4, 4, 4, 4, 4,
860 4, 4, 4, 6, 6, 6, 6, 6, 6, 6,
861 3, 1, 8, 2, 4, 7, 2, 1, 1, 2,
862 2, 1, 5, 2, 5, 1, 1, 3, 5, 3,
863 3, 4, 2, 2, 4, 3
864};
865
866/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
867 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
868 means the default is an error. */
869static const yytype_uint8 yydefact[] =
870{
871 2, 0, 1, 0, 0, 127, 126, 0, 151, 124,
872 125, 158, 0, 0, 0, 0, 0, 0, 0, 0,
873 0, 0, 0, 0, 0, 0, 0, 0, 0, 157,
874 0, 113, 37, 103, 30, 0, 0, 0, 165, 166,
875 0, 0, 0, 0, 0, 8, 0, 0, 0, 38,
876 0, 0, 0, 9, 0, 0, 3, 4, 13, 0,
877 20, 70, 161, 68, 0, 0, 69, 0, 31, 0,
878 39, 0, 16, 17, 18, 21, 22, 23, 0, 25,
879 26, 0, 27, 28, 11, 12, 14, 15, 24, 7,
880 10, 0, 0, 0, 0, 0, 0, 38, 99, 0,
881 0, 70, 0, 31, 0, 0, 0, 0, 0, 0,
882 0, 0, 0, 0, 70, 0, 70, 0, 70, 0,
883 70, 0, 19, 132, 0, 130, 70, 0, 160, 0,
884 0, 85, 163, 82, 84, 0, 0, 0, 0, 0,
885 173, 172, 156, 128, 100, 0, 0, 0, 5, 0,
886 0, 123, 0, 102, 0, 0, 88, 0, 87, 0,
887 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
888 29, 0, 0, 6, 101, 0, 70, 0, 70, 159,
889 0, 0, 0, 0, 0, 0, 68, 169, 0, 114,
890 0, 0, 0, 0, 0, 0, 0, 0, 59, 0,
891 68, 43, 0, 68, 46, 0, 131, 129, 0, 0,
892 0, 0, 0, 0, 150, 70, 0, 0, 170, 0,
893 0, 0, 0, 167, 175, 0, 36, 66, 104, 32,
894 34, 0, 67, 97, 96, 95, 93, 89, 90, 91,
895 0, 92, 94, 98, 33, 0, 86, 79, 0, 65,
896 70, 0, 0, 70, 0, 0, 0, 0, 0, 0,
897 0, 40, 68, 64, 0, 47, 0, 0, 0, 48,
898 0, 49, 0, 0, 50, 60, 41, 42, 44, 45,
899 141, 139, 135, 136, 137, 138, 0, 142, 140, 171,
900 0, 0, 0, 0, 174, 35, 72, 0, 0, 0,
901 0, 62, 0, 70, 114, 0, 42, 45, 0, 0,
902 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
903 0, 0, 0, 0, 0, 0, 0, 0, 0, 83,
904 168, 162, 164, 0, 80, 81, 0, 0, 0, 0,
905 0, 0, 51, 0, 52, 0, 0, 53, 0, 54,
906 149, 147, 143, 144, 145, 146, 148, 73, 74, 75,
907 76, 77, 78, 71, 0, 0, 0, 0, 115, 116,
908 0, 117, 121, 0, 0, 0, 0, 0, 0, 0,
909 155, 0, 119, 0, 0, 63, 55, 56, 57, 58,
910 61, 109, 152, 0, 122, 0, 120, 118
911};
912
913/* YYDEFGOTO[NTERM-NUM]. */
914static const yytype_int16 yydefgoto[] =
915{
916 -1, 1, 56, 57, 58, 59, 60, 61, 146, 63,
917 220, 64, 65, 247, 66, 67, 68, 69, 70, 190,
918 371, 372, 383, 373, 153, 99, 72, 73, 74, 75,
919 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
920 86, 87, 88, 89
921};
922
923/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
924 STATE-NUM. */
925#define YYPACT_NINF -361
926static const yytype_int16 yypact[] =
927{
928 -361, 344, -361, -90, 1923, -361, -361, 2003, -81, -361,
929 -361, -361, -29, -23, -14, 18, 23, 38, 44, 47,
930 2083, 2163, 2243, 2323, 13, 1923, -59, 1923, 50, -361,
931 1923, -361, -361, -361, -361, -57, 52, 55, -361, -361,
932 -30, 57, 59, 7, 69, -361, 58, 77, 2403, 100,
933 100, 1923, 1923, -361, 1923, 1923, -361, -361, -361, 76,
934 -361, 6, -74, 1336, 1923, 1923, -361, 1923, 62, -70,
935 -361, 2483, -361, -361, -361, -361, 97, -361, 1923, -361,
936 -361, 1923, -361, -361, -361, -361, -361, -361, -361, -361,
937 -361, 106, -81, 108, 111, 130, 147, -361, 9, 155,
938 1923, 146, 1336, -8, 2563, 1923, 1923, 1923, 1923, 1923,
939 1923, 1923, 1443, 1923, 222, 1523, 358, 1923, 597, 1603,
940 755, 161, -361, 180, 165, -361, 26, 1683, 1336, 15,
941 1923, -361, -361, -361, -361, 201, 1923, 209, 1763, 2003,
942 1336, 189, -361, -361, 9, -27, -71, 137, -361, 1923,
943 1843, -361, 1923, -361, 1923, 1923, -361, 1923, -361, 1923,
944 1923, 1923, 1923, 1923, 1923, 1923, 1923, 1923, 162, 213,
945 180, 219, 1923, -361, -361, 1923, 66, 1923, 425, 1336,
946 1923, 1923, 1523, 1923, 1603, 1923, 611, -361, 1923, 634,
947 200, 649, 664, 679, 372, 440, 708, 469, -361, -62,
948 776, -361, -61, 805, -361, -52, -361, -361, -16, 74,
949 94, 102, 113, 117, -361, 19, 123, 232, -361, 820,
950 1923, 245, 835, -361, -361, -43, -361, -361, -361, -361,
951 -361, -42, 1336, 256, 191, 191, 1377, 5, 5, 9,
952 484, -2, 1351, 5, -361, 1923, -361, -361, 1923, -361,
953 890, 499, 1923, 235, 2563, 611, 776, -40, 805, -39,
954 499, -361, 850, -361, 2563, -361, 1923, 1923, 1923, -361,
955 1923, -361, 1923, 1923, -361, -361, -361, -361, -361, -361,
956 -361, -361, -361, -361, -361, -361, 1169, -361, -361, -361,
957 2643, 873, 248, -48, -361, -361, -361, 1923, 947, 947,
958 1923, -361, 970, 12, 1336, 218, -361, -361, 1923, 224,
959 985, 1000, 1015, 1044, 514, 537, 225, 226, 227, 228,
960 231, 233, 236, 136, 166, 170, 173, 198, 1112, -361,
961 -361, -361, -361, 1141, -361, -361, 1156, 241, 1923, 2563,
962 -38, -65, -361, 1923, -361, 1923, 1923, -361, 1923, -361,
963 -361, -361, -361, -361, -361, -361, -361, -361, -361, -361,
964 -361, -361, -361, -361, 1923, 1923, -26, 243, -361, -361,
965 250, 223, -361, 238, 1171, 1186, 1209, 1283, 1306, 1321,
966 -361, -65, 246, 239, 1923, -361, -361, -361, -361, -361,
967 -361, -361, -361, 250, -361, -31, -361, -361
968};
969
970/* YYPGOTO[NTERM-NUM]. */
971static const yytype_int16 yypgoto[] =
972{
973 -361, -361, -361, -361, -361, -361, -361, 72, -1, 25,
974 -361, -361, -361, -256, -361, -361, 336, 302, 67, -251,
975 -361, -360, -37, -28, -68, 1, -361, -361, -361, -361,
976 -361, -361, -361, -361, -361, -361, -361, -361, -361, -361,
977 -361, -361, -361, -361
978};
979
980/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
981 positive, shift that token. If negative, reduce the rule which
982 number is the opposite. If zero, do what YYDEFACT says.
983 If YYTABLE_NINF, syntax error. */
984#define YYTABLE_NINF -155
985static const yytype_int16 yytable[] =
986{
987 62, 174, 71, 305, 171, 156, 369, 90, 158, 124,
988 382, 129, 156, 309, 151, 158, 156, 149, 151, 158,
989 104, 331, 152, 149, 123, 152, 172, 173, 332, 98,
990 149, 227, 102, 382, 152, 152, 370, 149, 125, 132,
991 275, 277, 334, 335, 152, 102, 102, 102, 102, 71,
992 279, 145, 102, 152, 152, 128, 152, 152, 152, 294,
993 295, 187, 306, 307, 368, 152, 170, 226, 380, 152,
994 152, 397, 105, 140, 171, 135, 144, 149, 106, 101,
995 147, 121, 122, 217, 218, 180, 280, 107, 367, 168,
996 169, 163, 114, 116, 118, 120, 102, 162, 163, 126,
997 164, 167, 163, 102, 164, 338, 179, 150, 167, -154,
998 254, 199, 167, 150, 202, 286, 142, 143, 205, 108,
999 150, 287, -133, -133, 109, 186, 137, 150, 216, 189,
1000 191, 192, 193, 194, 195, 196, 197, 225, 200, 110,
1001 154, 155, 203, 176, 156, 111, 157, 158, 112, 231,
1002 178, 127, 102, 130, -110, 219, 131, 149, 133, 252,
1003 134, 222, -110, -110, 102, 154, 155, 150, 31, 156,
1004 136, 157, 158, 148, 102, 104, 281, 232, 138, 233,
1005 234, 257, 235, 259, 236, 237, 238, 239, 240, 241,
1006 242, 243, 102, 177, 154, 181, 282, 102, 156, 215,
1007 251, 158, 102, 182, 283, 255, 256, 180, 258, 181,
1008 260, 101, 182, 262, 183, 284, 154, 155, 184, 285,
1009 156, 229, 157, 158, 185, 288, 159, 160, 161, 162,
1010 163, 183, 164, 149, -112, 165, 166, 105, 357, 244,
1011 167, 228, -112, -112, 250, 291, 149, 150, 184, 253,
1012 245, 159, 160, 161, 162, 163, 185, 164, 206, -155,
1013 165, 166, 207, 156, 246, 167, 158, 108, 358, 221,
1014 298, 109, 359, 299, 111, 360, 152, 302, 223, 304,
1015 159, 160, 161, 162, 163, 172, 164, 322, 249, 304,
1016 166, 310, 311, 312, 167, 313, 264, 314, 315, 112,
1017 361, 289, 159, 160, 161, 162, 163, 340, 164, 248,
1018 -105, 165, 166, 292, 339, 328, 167, 330, -105, -105,
1019 341, 369, 333, 150, 384, 336, 303, 350, 351, 352,
1020 353, -134, -134, 354, 365, 355, 150, 366, 356, 381,
1021 385, 394, 393, 103, 2, 3, 160, 161, 162, 163,
1022 141, 164, 4, 392, 0, 166, 396, 0, 5, 167,
1023 6, 7, 8, 0, 304, 0, 0, 9, 374, 149,
1024 375, 376, 10, 377, 0, 154, 155, 0, 11, 156,
1025 0, 157, 158, 395, 0, 0, 0, 0, 0, 378,
1026 379, 0, 12, 13, 14, 15, 16, 17, 18, 19,
1027 20, 21, 22, 23, 24, 25, 26, 27, 0, 28,
1028 29, 30, 31, 0, 32, 33, 34, 35, 36, 37,
1029 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1030 48, 49, 0, 50, 0, 51, 149, 52, 0, 0,
1031 0, 53, 0, 154, 155, 54, -106, 156, 55, 157,
1032 158, 0, 0, 0, -106, -106, 0, 0, 0, 150,
1033 0, 159, 160, 161, 162, 163, 0, 164, 268, 0,
1034 165, 166, 154, 155, 269, 167, 156, 0, 157, 158,
1035 0, 0, 0, 0, 0, 0, 0, 154, 155, 0,
1036 0, 156, 0, 157, 158, 0, 0, 0, 0, 0,
1037 0, 0, 154, 155, 0, 0, 156, 0, 157, 158,
1038 0, 0, 0, 151, 0, 0, 0, 154, 155, 0,
1039 0, 156, -153, 157, 158, 0, 150, 0, 0, 159,
1040 160, 161, 162, 163, 0, 164, 270, 0, 165, 166,
1041 154, 155, 271, 167, 156, 0, 157, 158, 0, 0,
1042 0, 0, 0, 0, 0, 0, 0, 0, 159, 160,
1043 161, 162, 163, 0, 164, 273, 0, 165, 166, 0,
1044 0, 274, 167, 159, 160, 161, 162, 163, 296, 164,
1045 297, 0, 165, 166, 0, 0, 0, 167, 159, 160,
1046 161, 162, 163, 0, 164, 300, 0, 165, 166, 0,
1047 0, 301, 167, 159, 160, 161, 162, 163, 149, 164,
1048 346, 0, 165, 166, 154, 155, 347, 167, 156, 0,
1049 157, 158, 0, 0, 0, 0, 159, 160, 161, 162,
1050 163, 0, 164, 348, 0, 165, 166, 154, 155, 349,
1051 167, 156, 0, 157, 158, 0, 0, 0, 0, 0,
1052 0, 0, 154, 155, 0, 0, 156, 0, 157, 158,
1053 0, 0, 0, 0, 0, 0, 0, 154, 155, 0,
1054 0, 156, 0, 157, 158, 0, 0, 0, 0, 0,
1055 0, 0, 154, 155, 0, -107, 156, 0, 157, 158,
1056 0, 0, 0, -107, -107, 0, 0, 0, 150, 0,
1057 159, 160, 161, 162, 163, 0, 164, 0, 0, 165,
1058 166, 154, 155, 261, 167, 156, 0, 157, 158, 0,
1059 0, 0, 0, 159, 160, 161, 162, 163, 0, 164,
1060 0, 0, 165, 166, 0, 0, 263, 167, 159, 160,
1061 161, 162, 163, 0, 164, 0, 0, 165, 166, 0,
1062 0, 265, 167, 159, 160, 161, 162, 163, 0, 164,
1063 266, 0, 165, 166, 0, 0, 149, 167, 159, 160,
1064 161, 162, 163, 0, 164, 267, 0, 165, 166, 154,
1065 155, 0, 167, 156, 0, 157, 158, 0, 0, 0,
1066 0, 0, 0, 0, 0, 0, 0, 159, 160, 161,
1067 162, 163, 0, 164, 272, 0, 165, 166, 154, 155,
1068 0, 167, 156, 0, 157, 158, 0, 0, 0, 0,
1069 0, 0, 0, 154, 155, 0, 0, 156, 0, 157,
1070 158, 0, 0, 0, 0, 0, 0, 0, 154, 155,
1071 0, 0, 156, -108, 157, 158, 0, 0, 0, 0,
1072 0, -108, -108, 154, 155, 0, 150, 156, 0, 157,
1073 158, 0, 0, 0, 0, 159, 160, 161, 162, 163,
1074 0, 164, 0, 0, 165, 166, 154, 155, 276, 167,
1075 156, 0, 157, 158, 0, 0, 0, 0, 0, 0,
1076 0, 0, 0, 0, 159, 160, 161, 162, 163, 0,
1077 164, 149, 0, 165, 166, 0, 0, 278, 167, 159,
1078 160, 161, 162, 163, 0, 164, 290, 0, 165, 166,
1079 0, 0, 0, 167, 159, 160, 161, 162, 163, 0,
1080 164, 0, 0, 165, 166, 0, 0, 293, 167, 159,
1081 160, 161, 162, 163, 0, 164, 308, 0, 165, 166,
1082 154, 155, 0, 167, 156, 0, 157, 158, 0, 0,
1083 0, 0, 159, 160, 161, 162, 163, 0, 164, 0,
1084 0, 165, 166, 154, 155, 329, 167, 156, -111, 157,
1085 158, 0, 0, 0, 0, 0, -111, -111, 154, 155,
1086 0, 150, 156, 0, 157, 158, 0, 0, 0, 0,
1087 0, 0, 0, 154, 155, 0, 0, 156, 0, 157,
1088 158, 0, 0, 0, 0, 0, 0, 0, 154, 155,
1089 0, 0, 156, 0, 157, 158, 0, 0, 0, 0,
1090 0, 0, 0, 0, 0, 0, 159, 160, 161, 162,
1091 163, 0, 164, 0, 0, 165, 166, 154, 155, 246,
1092 167, 156, 0, 157, 158, 0, 0, 0, 0, 159,
1093 160, 161, 162, 163, 337, 164, 0, 0, 165, 166,
1094 0, 0, 0, 167, 159, 160, 161, 162, 163, 0,
1095 164, 0, 0, 165, 166, 0, 0, 342, 167, 159,
1096 160, 161, 162, 163, 0, 164, 343, 0, 165, 166,
1097 0, 0, 0, 167, 159, 160, 161, 162, 163, 0,
1098 164, 0, 0, 165, 166, 154, 155, 344, 167, 156,
1099 0, 157, 158, 0, 0, 0, 0, 0, 0, 0,
1100 0, 0, 0, 159, 160, 161, 162, 163, 0, 164,
1101 345, 0, 165, 166, 154, 155, 0, 167, 156, 0,
1102 157, 158, 0, 0, 0, 0, 0, 0, 0, 154,
1103 155, 0, 0, 156, 0, 157, 158, 0, 0, 0,
1104 0, 0, 0, 0, 154, 155, 0, 0, 156, 0,
1105 157, 158, 0, 5, 0, 6, 316, 317, 0, 154,
1106 155, 0, 9, 156, 0, 157, 158, 10, 0, 0,
1107 0, 159, 160, 161, 162, 163, 0, 164, 0, 0,
1108 165, 166, 154, 155, 362, 167, 156, 0, 157, 158,
1109 0, 0, 0, 0, 0, 318, 319, 320, 321, 0,
1110 159, 160, 161, 162, 163, 363, 164, 0, 0, 165,
1111 166, 0, 0, 0, 167, 159, 160, 161, 162, 163,
1112 0, 164, 364, 0, 165, 166, 0, 0, 0, 167,
1113 159, 160, 161, 162, 163, 0, 164, 0, 0, 165,
1114 166, 0, 0, 386, 167, 159, 160, 161, 162, 163,
1115 0, 164, 0, 0, 165, 166, 154, 155, 387, 167,
1116 156, 0, 157, 158, 0, 0, 0, 0, 159, 160,
1117 161, 162, 163, 0, 164, 0, 0, 165, 166, 154,
1118 155, 388, 167, 156, 0, 157, 158, 0, 0, 0,
1119 0, 0, 0, 0, 154, 155, 0, 0, 156, 0,
1120 157, 158, 0, 0, 0, 0, 0, 0, 0, 154,
1121 155, 0, 0, 156, 0, 157, 158, 0, 0, 0,
1122 0, 0, 0, 0, 154, 155, 0, 0, 156, 0,
1123 157, 158, 0, 0, 0, 0, 0, 0, 0, 0,
1124 0, 0, 159, 160, 161, 162, 163, 0, 164, 0,
1125 154, 165, 166, 0, 156, 389, 167, 158, 0, 0,
1126 0, 0, 0, 0, 0, 159, 160, 161, 162, 163,
1127 0, 164, 0, 0, 165, 166, 0, 0, 390, 167,
1128 159, 160, 161, 162, 163, 391, 164, 0, 0, 165,
1129 166, 0, 0, 0, 167, 159, 160, 161, 162, 163,
1130 0, 164, 0, 0, 165, 166, 0, 0, 0, 167,
1131 159, 160, 161, 162, 163, 0, 164, 0, 0, 0,
1132 166, 4, 0, 0, 167, 0, 0, 5, 0, 6,
1133 91, 92, 0, 0, 0, 0, 9, 160, 161, 162,
1134 163, 10, 164, 0, 0, 0, 166, 0, 0, 0,
1135 167, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1136 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1137 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1138 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1139 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1140 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1141 91, 92, 0, 0, 54, 198, 9, 55, 0, 0,
1142 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1144 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1145 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1146 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1147 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1148 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1149 91, 92, 0, 0, 54, 201, 9, 55, 0, 0,
1150 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1152 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1153 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1154 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1155 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1156 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1157 208, 209, 0, 0, 54, 204, 9, 55, 0, 0,
1158 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1159 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1160 0, 12, 13, 14, 15, 16, 17, 18, 19, 210,
1161 211, 212, 213, 0, 0, 0, 0, 0, 0, 0,
1162 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1163 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1164 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1165 91, 92, 0, 0, 54, 214, 9, 55, 0, 0,
1166 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1167 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1168 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1169 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1170 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1171 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1172 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1173 91, 92, 0, 0, 54, 224, 9, 55, 0, 0,
1174 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1175 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1176 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1177 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1178 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1179 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1180 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1181 91, 92, 0, 0, 54, 230, 9, 55, 0, 0,
1182 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1183 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1184 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1185 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1186 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1187 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1188 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1189 91, 92, 0, 0, 54, 0, 9, 55, 0, 0,
1190 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1191 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1192 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1193 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1194 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1195 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1196 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1197 91, 92, 0, 0, 100, 0, 9, 55, 0, 0,
1198 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1199 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1200 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1201 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1202 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1203 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1204 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1205 91, 92, 0, 0, 113, 0, 9, 55, 0, 0,
1206 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1207 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1208 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1209 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1210 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1211 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1212 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1213 91, 92, 0, 0, 115, 0, 9, 55, 0, 0,
1214 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1215 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1216 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1217 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1218 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1219 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1220 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1221 91, 92, 0, 0, 117, 0, 9, 55, 0, 0,
1222 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1223 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1224 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1225 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1226 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1227 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1228 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1229 139, 92, 0, 0, 119, 0, 9, 55, 0, 0,
1230 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1231 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1232 0, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1233 21, 22, 23, 0, 0, 0, 0, 0, 0, 0,
1234 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1235 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1236 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1237 91, 92, 0, 0, 54, 0, 9, 55, 0, 0,
1238 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1240 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1241 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1242 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1243 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1244 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1245 91, 92, 0, 0, 175, 0, 9, 55, 0, 0,
1246 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1247 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1248 0, 12, 13, 14, 15, 16, 17, 18, 19, 93,
1249 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1250 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1251 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1252 97, 4, 0, 0, 51, 0, 52, 5, 0, 6,
1253 91, 92, 0, 0, 188, 0, 9, 55, 0, 0,
1254 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
1255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1256 0, 323, 13, 14, 324, 325, 17, 326, 327, 93,
1257 94, 95, 96, 0, 0, 0, 0, 0, 0, 0,
1258 0, 31, 0, 32, 33, 34, 0, 36, 37, 0,
1259 0, 0, 41, 42, 0, 0, 0, 0, 0, 0,
1260 97, 0, 0, 0, 51, 0, 52, 0, 0, 0,
1261 0, 0, 0, 0, 54, 0, 0, 55
1262};
1263
1264static const yytype_int16 yycheck[] =
1265{
1266 1, 69, 1, 254, 12, 7, 71, 97, 10, 68,
1267 370, 68, 7, 264, 88, 10, 7, 11, 88, 10,
1268 101, 69, 96, 11, 25, 96, 96, 97, 76, 4,
1269 11, 102, 7, 393, 96, 96, 101, 11, 97, 69,
1270 102, 102, 298, 299, 96, 20, 21, 22, 23, 48,
1271 102, 52, 27, 96, 96, 30, 96, 96, 96, 102,
1272 102, 69, 102, 102, 102, 96, 67, 94, 94, 96,
1273 96, 102, 101, 48, 12, 68, 51, 11, 101, 7,
1274 55, 68, 69, 68, 69, 101, 102, 101, 339, 64,
1275 65, 93, 20, 21, 22, 23, 71, 92, 93, 27,
1276 95, 103, 93, 78, 95, 93, 81, 101, 103, 97,
1277 178, 112, 103, 101, 115, 96, 49, 50, 119, 101,
1278 101, 102, 96, 97, 101, 100, 68, 101, 127, 104,
1279 105, 106, 107, 108, 109, 110, 111, 138, 113, 101,
1280 3, 4, 117, 71, 7, 101, 9, 10, 101, 150,
1281 78, 101, 127, 101, 88, 130, 101, 11, 101, 93,
1282 101, 136, 96, 97, 139, 3, 4, 101, 68, 7,
1283 101, 9, 10, 97, 149, 101, 102, 152, 101, 154,
1284 155, 182, 157, 184, 159, 160, 161, 162, 163, 164,
1285 165, 166, 167, 96, 3, 101, 102, 172, 7, 127,
1286 175, 10, 177, 101, 102, 180, 181, 101, 183, 101,
1287 185, 139, 101, 188, 101, 102, 3, 4, 101, 102,
1288 7, 149, 9, 10, 101, 102, 89, 90, 91, 92,
1289 93, 101, 95, 11, 88, 98, 99, 101, 102, 167,
1290 103, 104, 96, 97, 172, 220, 11, 101, 101, 177,
1291 88, 89, 90, 91, 92, 93, 101, 95, 97, 3,
1292 98, 99, 97, 7, 102, 103, 10, 101, 102, 68,
1293 245, 101, 102, 248, 101, 102, 96, 252, 69, 254,
1294 89, 90, 91, 92, 93, 96, 95, 286, 69, 264,
1295 99, 266, 267, 268, 103, 270, 96, 272, 273, 101,
1296 102, 69, 89, 90, 91, 92, 93, 308, 95, 96,
1297 88, 98, 99, 68, 96, 290, 103, 69, 96, 97,
1298 96, 71, 297, 101, 101, 300, 254, 102, 102, 102,
1299 102, 96, 97, 102, 93, 102, 101, 338, 102, 96,
1300 102, 102, 96, 7, 0, 1, 90, 91, 92, 93,
1301 48, 95, 8, 381, -1, 99, 393, -1, 14, 103,
1302 16, 17, 18, -1, 339, -1, -1, 23, 343, 11,
1303 345, 346, 28, 348, -1, 3, 4, -1, 34, 7,
1304 -1, 9, 10, 384, -1, -1, -1, -1, -1, 364,
1305 365, -1, 48, 49, 50, 51, 52, 53, 54, 55,
1306 56, 57, 58, 59, 60, 61, 62, 63, -1, 65,
1307 66, 67, 68, -1, 70, 71, 72, 73, 74, 75,
1308 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
1309 86, 87, -1, 89, -1, 91, 11, 93, -1, -1,
1310 -1, 97, -1, 3, 4, 101, 88, 7, 104, 9,
1311 10, -1, -1, -1, 96, 97, -1, -1, -1, 101,
1312 -1, 89, 90, 91, 92, 93, -1, 95, 96, -1,
1313 98, 99, 3, 4, 102, 103, 7, -1, 9, 10,
1314 -1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1315 -1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1316 -1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1317 -1, -1, -1, 88, -1, -1, -1, 3, 4, -1,
1318 -1, 7, 97, 9, 10, -1, 101, -1, -1, 89,
1319 90, 91, 92, 93, -1, 95, 96, -1, 98, 99,
1320 3, 4, 102, 103, 7, -1, 9, 10, -1, -1,
1321 -1, -1, -1, -1, -1, -1, -1, -1, 89, 90,
1322 91, 92, 93, -1, 95, 96, -1, 98, 99, -1,
1323 -1, 102, 103, 89, 90, 91, 92, 93, 94, 95,
1324 96, -1, 98, 99, -1, -1, -1, 103, 89, 90,
1325 91, 92, 93, -1, 95, 96, -1, 98, 99, -1,
1326 -1, 102, 103, 89, 90, 91, 92, 93, 11, 95,
1327 96, -1, 98, 99, 3, 4, 102, 103, 7, -1,
1328 9, 10, -1, -1, -1, -1, 89, 90, 91, 92,
1329 93, -1, 95, 96, -1, 98, 99, 3, 4, 102,
1330 103, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1331 -1, -1, 3, 4, -1, -1, 7, -1, 9, 10,
1332 -1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
1333 -1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
1334 -1, -1, 3, 4, -1, 88, 7, -1, 9, 10,
1335 -1, -1, -1, 96, 97, -1, -1, -1, 101, -1,
1336 89, 90, 91, 92, 93, -1, 95, -1, -1, 98,
1337 99, 3, 4, 102, 103, 7, -1, 9, 10, -1,
1338 -1, -1, -1, 89, 90, 91, 92, 93, -1, 95,
1339 -1, -1, 98, 99, -1, -1, 102, 103, 89, 90,
1340 91, 92, 93, -1, 95, -1, -1, 98, 99, -1,
1341 -1, 102, 103, 89, 90, 91, 92, 93, -1, 95,
1342 96, -1, 98, 99, -1, -1, 11, 103, 89, 90,
1343 91, 92, 93, -1, 95, 96, -1, 98, 99, 3,
1344 4, -1, 103, 7, -1, 9, 10, -1, -1, -1,
1345 -1, -1, -1, -1, -1, -1, -1, 89, 90, 91,
1346 92, 93, -1, 95, 96, -1, 98, 99, 3, 4,
1347 -1, 103, 7, -1, 9, 10, -1, -1, -1, -1,
1348 -1, -1, -1, 3, 4, -1, -1, 7, -1, 9,
1349 10, -1, -1, -1, -1, -1, -1, -1, 3, 4,
1350 -1, -1, 7, 88, 9, 10, -1, -1, -1, -1,
1351 -1, 96, 97, 3, 4, -1, 101, 7, -1, 9,
1352 10, -1, -1, -1, -1, 89, 90, 91, 92, 93,
1353 -1, 95, -1, -1, 98, 99, 3, 4, 102, 103,
1354 7, -1, 9, 10, -1, -1, -1, -1, -1, -1,
1355 -1, -1, -1, -1, 89, 90, 91, 92, 93, -1,
1356 95, 11, -1, 98, 99, -1, -1, 102, 103, 89,
1357 90, 91, 92, 93, -1, 95, 96, -1, 98, 99,
1358 -1, -1, -1, 103, 89, 90, 91, 92, 93, -1,
1359 95, -1, -1, 98, 99, -1, -1, 102, 103, 89,
1360 90, 91, 92, 93, -1, 95, 96, -1, 98, 99,
1361 3, 4, -1, 103, 7, -1, 9, 10, -1, -1,
1362 -1, -1, 89, 90, 91, 92, 93, -1, 95, -1,
1363 -1, 98, 99, 3, 4, 102, 103, 7, 88, 9,
1364 10, -1, -1, -1, -1, -1, 96, 97, 3, 4,
1365 -1, 101, 7, -1, 9, 10, -1, -1, -1, -1,
1366 -1, -1, -1, 3, 4, -1, -1, 7, -1, 9,
1367 10, -1, -1, -1, -1, -1, -1, -1, 3, 4,
1368 -1, -1, 7, -1, 9, 10, -1, -1, -1, -1,
1369 -1, -1, -1, -1, -1, -1, 89, 90, 91, 92,
1370 93, -1, 95, -1, -1, 98, 99, 3, 4, 102,
1371 103, 7, -1, 9, 10, -1, -1, -1, -1, 89,
1372 90, 91, 92, 93, 94, 95, -1, -1, 98, 99,
1373 -1, -1, -1, 103, 89, 90, 91, 92, 93, -1,
1374 95, -1, -1, 98, 99, -1, -1, 102, 103, 89,
1375 90, 91, 92, 93, -1, 95, 96, -1, 98, 99,
1376 -1, -1, -1, 103, 89, 90, 91, 92, 93, -1,
1377 95, -1, -1, 98, 99, 3, 4, 102, 103, 7,
1378 -1, 9, 10, -1, -1, -1, -1, -1, -1, -1,
1379 -1, -1, -1, 89, 90, 91, 92, 93, -1, 95,
1380 96, -1, 98, 99, 3, 4, -1, 103, 7, -1,
1381 9, 10, -1, -1, -1, -1, -1, -1, -1, 3,
1382 4, -1, -1, 7, -1, 9, 10, -1, -1, -1,
1383 -1, -1, -1, -1, 3, 4, -1, -1, 7, -1,
1384 9, 10, -1, 14, -1, 16, 17, 18, -1, 3,
1385 4, -1, 23, 7, -1, 9, 10, 28, -1, -1,
1386 -1, 89, 90, 91, 92, 93, -1, 95, -1, -1,
1387 98, 99, 3, 4, 102, 103, 7, -1, 9, 10,
1388 -1, -1, -1, -1, -1, 56, 57, 58, 59, -1,
1389 89, 90, 91, 92, 93, 94, 95, -1, -1, 98,
1390 99, -1, -1, -1, 103, 89, 90, 91, 92, 93,
1391 -1, 95, 96, -1, 98, 99, -1, -1, -1, 103,
1392 89, 90, 91, 92, 93, -1, 95, -1, -1, 98,
1393 99, -1, -1, 102, 103, 89, 90, 91, 92, 93,
1394 -1, 95, -1, -1, 98, 99, 3, 4, 102, 103,
1395 7, -1, 9, 10, -1, -1, -1, -1, 89, 90,
1396 91, 92, 93, -1, 95, -1, -1, 98, 99, 3,
1397 4, 102, 103, 7, -1, 9, 10, -1, -1, -1,
1398 -1, -1, -1, -1, 3, 4, -1, -1, 7, -1,
1399 9, 10, -1, -1, -1, -1, -1, -1, -1, 3,
1400 4, -1, -1, 7, -1, 9, 10, -1, -1, -1,
1401 -1, -1, -1, -1, 3, 4, -1, -1, 7, -1,
1402 9, 10, -1, -1, -1, -1, -1, -1, -1, -1,
1403 -1, -1, 89, 90, 91, 92, 93, -1, 95, -1,
1404 3, 98, 99, -1, 7, 102, 103, 10, -1, -1,
1405 -1, -1, -1, -1, -1, 89, 90, 91, 92, 93,
1406 -1, 95, -1, -1, 98, 99, -1, -1, 102, 103,
1407 89, 90, 91, 92, 93, 94, 95, -1, -1, 98,
1408 99, -1, -1, -1, 103, 89, 90, 91, 92, 93,
1409 -1, 95, -1, -1, 98, 99, -1, -1, -1, 103,
1410 89, 90, 91, 92, 93, -1, 95, -1, -1, -1,
1411 99, 8, -1, -1, 103, -1, -1, 14, -1, 16,
1412 17, 18, -1, -1, -1, -1, 23, 90, 91, 92,
1413 93, 28, 95, -1, -1, -1, 99, -1, -1, -1,
1414 103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1415 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1416 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1417 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1418 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1419 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1420 17, 18, -1, -1, 101, 102, 23, 104, -1, -1,
1421 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1422 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1423 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1424 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1425 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1426 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1427 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1428 17, 18, -1, -1, 101, 102, 23, 104, -1, -1,
1429 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1430 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1431 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1432 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1433 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1434 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1435 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1436 17, 18, -1, -1, 101, 102, 23, 104, -1, -1,
1437 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1438 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1439 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1440 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1441 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1442 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1443 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1444 17, 18, -1, -1, 101, 102, 23, 104, -1, -1,
1445 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1446 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1447 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1448 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1449 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1450 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1451 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1452 17, 18, -1, -1, 101, 102, 23, 104, -1, -1,
1453 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1454 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1455 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1456 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1457 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1458 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1459 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1460 17, 18, -1, -1, 101, 102, 23, 104, -1, -1,
1461 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1462 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1463 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1464 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1465 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1466 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1467 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1468 17, 18, -1, -1, 101, -1, 23, 104, -1, -1,
1469 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1470 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1471 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1472 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1473 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1474 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1475 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1476 17, 18, -1, -1, 101, -1, 23, 104, -1, -1,
1477 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1478 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1479 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1480 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1481 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1482 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1483 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1484 17, 18, -1, -1, 101, -1, 23, 104, -1, -1,
1485 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1486 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1487 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1488 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1489 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1490 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1491 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1492 17, 18, -1, -1, 101, -1, 23, 104, -1, -1,
1493 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1494 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1495 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1496 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1497 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1498 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1499 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1500 17, 18, -1, -1, 101, -1, 23, 104, -1, -1,
1501 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1502 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1503 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1504 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1505 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1506 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1507 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1508 17, 18, -1, -1, 101, -1, 23, 104, -1, -1,
1509 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1510 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1511 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1512 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1513 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1514 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1515 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1516 17, 18, -1, -1, 101, -1, 23, 104, -1, -1,
1517 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1518 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1519 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1520 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1521 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1522 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1523 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1524 17, 18, -1, -1, 101, -1, 23, 104, -1, -1,
1525 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1526 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1527 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1528 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1529 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1530 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1531 87, 8, -1, -1, 91, -1, 93, 14, -1, 16,
1532 17, 18, -1, -1, 101, -1, 23, 104, -1, -1,
1533 -1, 28, -1, -1, -1, -1, -1, -1, -1, -1,
1534 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1535 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
1536 57, 58, 59, -1, -1, -1, -1, -1, -1, -1,
1537 -1, 68, -1, 70, 71, 72, -1, 74, 75, -1,
1538 -1, -1, 79, 80, -1, -1, -1, -1, -1, -1,
1539 87, -1, -1, -1, 91, -1, 93, -1, -1, -1,
1540 -1, -1, -1, -1, 101, -1, -1, 104
1541};
1542
1543/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1544 symbol of state STATE-NUM. */
1545static const yytype_uint8 yystos[] =
1546{
1547 0, 106, 0, 1, 8, 14, 16, 17, 18, 23,
1548 28, 34, 48, 49, 50, 51, 52, 53, 54, 55,
1549 56, 57, 58, 59, 60, 61, 62, 63, 65, 66,
1550 67, 68, 70, 71, 72, 73, 74, 75, 76, 77,
1551 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
1552 89, 91, 93, 97, 101, 104, 107, 108, 109, 110,
1553 111, 112, 113, 114, 116, 117, 119, 120, 121, 122,
1554 123, 130, 131, 132, 133, 134, 135, 136, 137, 138,
1555 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
1556 97, 17, 18, 56, 57, 58, 59, 87, 114, 130,
1557 101, 112, 114, 121, 101, 101, 101, 101, 101, 101,
1558 101, 101, 101, 101, 112, 101, 112, 101, 112, 101,
1559 112, 68, 69, 113, 68, 97, 112, 101, 114, 68,
1560 101, 101, 69, 101, 101, 68, 101, 68, 101, 17,
1561 114, 122, 123, 123, 114, 113, 113, 114, 97, 11,
1562 101, 88, 96, 129, 3, 4, 7, 9, 10, 89,
1563 90, 91, 92, 93, 95, 98, 99, 103, 114, 114,
1564 113, 12, 96, 97, 129, 101, 112, 96, 112, 114,
1565 101, 101, 101, 101, 101, 101, 114, 69, 101, 114,
1566 124, 114, 114, 114, 114, 114, 114, 114, 102, 113,
1567 114, 102, 113, 114, 102, 113, 97, 97, 17, 18,
1568 56, 57, 58, 59, 102, 112, 130, 68, 69, 114,
1569 115, 68, 114, 69, 102, 113, 94, 102, 104, 112,
1570 102, 113, 114, 114, 114, 114, 114, 114, 114, 114,
1571 114, 114, 114, 114, 112, 88, 102, 118, 96, 69,
1572 112, 114, 93, 112, 129, 114, 114, 113, 114, 113,
1573 114, 102, 114, 102, 96, 102, 96, 96, 96, 102,
1574 96, 102, 96, 96, 102, 102, 102, 102, 102, 102,
1575 102, 102, 102, 102, 102, 102, 96, 102, 102, 69,
1576 96, 114, 68, 102, 102, 102, 94, 96, 114, 114,
1577 96, 102, 114, 112, 114, 124, 102, 102, 96, 124,
1578 114, 114, 114, 114, 114, 114, 17, 18, 56, 57,
1579 58, 59, 130, 48, 51, 52, 54, 55, 114, 102,
1580 69, 69, 76, 114, 118, 118, 114, 94, 93, 96,
1581 113, 96, 102, 96, 102, 96, 96, 102, 96, 102,
1582 102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
1583 102, 102, 102, 94, 96, 93, 113, 124, 102, 71,
1584 101, 125, 126, 128, 114, 114, 114, 114, 114, 114,
1585 94, 96, 126, 127, 101, 102, 102, 102, 102, 102,
1586 102, 94, 128, 96, 102, 113, 127, 102
1587};
1588
1589#define yyerrok (yyerrstatus = 0)
1590#define yyclearin (yychar = YYEMPTY)
1591#define YYEMPTY (-2)
1592#define YYEOF 0
1593
1594#define YYACCEPT goto yyacceptlab
1595#define YYABORT goto yyabortlab
1596#define YYERROR goto yyerrorlab
1597
1598
1599/* Like YYERROR except do call yyerror. This remains here temporarily
1600 to ease the transition to the new meaning of YYERROR, for GCC.
1601 Once GCC version 2 has supplanted version 1, this can go. However,
1602 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
1603 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1604 discussed. */
1605
1606#define YYFAIL goto yyerrlab
1607#if defined YYFAIL
1608 /* This is here to suppress warnings from the GCC cpp's
1609 -Wunused-macros. Normally we don't worry about that warning, but
1610 some users do, and we want to make it easy for users to remove
1611 YYFAIL uses, which will produce warnings from Bison 2.5. */
1612#endif
1613
1614#define YYRECOVERING() (!!yyerrstatus)
1615
1616#define YYBACKUP(Token, Value) \
1617do \
1618 if (yychar == YYEMPTY && yylen == 1) \
1619 { \
1620 yychar = (Token); \
1621 yylval = (Value); \
1622 yytoken = YYTRANSLATE (yychar); \
1623 YYPOPSTACK (1); \
1624 goto yybackup; \
1625 } \
1626 else \
1627 { \
1628 yyerror (YY_("syntax error: cannot back up")); \
1629 YYERROR; \
1630 } \
1631while (YYID (0))
1632
1633
1634#define YYTERROR 1
1635#define YYERRCODE 256
1636
1637
1638/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1639 If N is 0, then set CURRENT to the empty location which ends
1640 the previous symbol: RHS[0] (always defined). */
1641
1642#define YYRHSLOC(Rhs, K) ((Rhs)[K])
1643#ifndef YYLLOC_DEFAULT
1644# define YYLLOC_DEFAULT(Current, Rhs, N) \
1645 do \
1646 if (YYID (N)) \
1647 { \
1648 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1649 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1650 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1651 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1652 } \
1653 else \
1654 { \
1655 (Current).first_line = (Current).last_line = \
1656 YYRHSLOC (Rhs, 0).last_line; \
1657 (Current).first_column = (Current).last_column = \
1658 YYRHSLOC (Rhs, 0).last_column; \
1659 } \
1660 while (YYID (0))
1661#endif
1662
1663
1664/* YY_LOCATION_PRINT -- Print the location on the stream.
1665 This macro was not mandated originally: define only if we know
1666 we won't break user code: when these are the locations we know. */
1667
1668#ifndef YY_LOCATION_PRINT
1669# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1670# define YY_LOCATION_PRINT(File, Loc) \
1671 fprintf (File, "%d.%d-%d.%d", \
1672 (Loc).first_line, (Loc).first_column, \
1673 (Loc).last_line, (Loc).last_column)
1674# else
1675# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1676# endif
1677#endif
1678
1679
1680/* YYLEX -- calling `yylex' with the right arguments. */
1681
1682#ifdef YYLEX_PARAM
1683# define YYLEX yylex (&yylval, YYLEX_PARAM)
1684#else
1685# define YYLEX yylex (&yylval)
1686#endif
1687
1688/* Enable debugging if requested. */
1689#if YYDEBUG
1690
1691# ifndef YYFPRINTF
1692# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1693# define YYFPRINTF fprintf
1694# endif
1695
1696# define YYDPRINTF(Args) \
1697do { \
1698 if (yydebug) \
1699 YYFPRINTF Args; \
1700} while (YYID (0))
1701
1702# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1703do { \
1704 if (yydebug) \
1705 { \
1706 YYFPRINTF (stderr, "%s ", Title); \
1707 yy_symbol_print (stderr, \
1708 Type, Value); \
1709 YYFPRINTF (stderr, "\n"); \
1710 } \
1711} while (YYID (0))
1712
1713
1714/*--------------------------------.
1715| Print this symbol on YYOUTPUT. |
1716`--------------------------------*/
1717
1718/*ARGSUSED*/
1719#if (defined __STDC__ || defined __C99__FUNC__ \
1720 || defined __cplusplus || defined _MSC_VER)
1721static void
1722yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1723#else
1724static void
1725yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1726 FILE *yyoutput;
1727 int yytype;
1728 YYSTYPE const * const yyvaluep;
1729#endif
1730{
1731 if (!yyvaluep)
1732 return;
1733# ifdef YYPRINT
1734 if (yytype < YYNTOKENS)
1735 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1736# else
1737 YYUSE (yyoutput);
1738# endif
1739 switch (yytype)
1740 {
1741 default:
1742 break;
1743 }
1744}
1745
1746
1747/*--------------------------------.
1748| Print this symbol on YYOUTPUT. |
1749`--------------------------------*/
1750
1751#if (defined __STDC__ || defined __C99__FUNC__ \
1752 || defined __cplusplus || defined _MSC_VER)
1753static void
1754yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1755#else
1756static void
1757yy_symbol_print (yyoutput, yytype, yyvaluep)
1758 FILE *yyoutput;
1759 int yytype;
1760 YYSTYPE const * const yyvaluep;
1761#endif
1762{
1763 if (yytype < YYNTOKENS)
1764 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1765 else
1766 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1767
1768 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1769 YYFPRINTF (yyoutput, ")");
1770}
1771
1772/*------------------------------------------------------------------.
1773| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1774| TOP (included). |
1775`------------------------------------------------------------------*/
1776
1777#if (defined __STDC__ || defined __C99__FUNC__ \
1778 || defined __cplusplus || defined _MSC_VER)
1779static void
1780yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1781#else
1782static void
1783yy_stack_print (yybottom, yytop)
1784 yytype_int16 *yybottom;
1785 yytype_int16 *yytop;
1786#endif
1787{
1788 YYFPRINTF (stderr, "Stack now");
1789 for (; yybottom <= yytop; yybottom++)
1790 {
1791 int yybot = *yybottom;
1792 YYFPRINTF (stderr, " %d", yybot);
1793 }
1794 YYFPRINTF (stderr, "\n");
1795}
1796
1797# define YY_STACK_PRINT(Bottom, Top) \
1798do { \
1799 if (yydebug) \
1800 yy_stack_print ((Bottom), (Top)); \
1801} while (YYID (0))
1802
1803
1804/*------------------------------------------------.
1805| Report that the YYRULE is going to be reduced. |
1806`------------------------------------------------*/
1807
1808#if (defined __STDC__ || defined __C99__FUNC__ \
1809 || defined __cplusplus || defined _MSC_VER)
1810static void
1811yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1812#else
1813static void
1814yy_reduce_print (yyvsp, yyrule)
1815 YYSTYPE *yyvsp;
1816 int yyrule;
1817#endif
1818{
1819 int yynrhs = yyr2[yyrule];
1820 int yyi;
1821 unsigned long int yylno = yyrline[yyrule];
1822 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1823 yyrule - 1, yylno);
1824 /* The symbols being reduced. */
1825 for (yyi = 0; yyi < yynrhs; yyi++)
1826 {
1827 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1828 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1829 &(yyvsp[(yyi + 1) - (yynrhs)])
1830 );
1831 YYFPRINTF (stderr, "\n");
1832 }
1833}
1834
1835# define YY_REDUCE_PRINT(Rule) \
1836do { \
1837 if (yydebug) \
1838 yy_reduce_print (yyvsp, Rule); \
1839} while (YYID (0))
1840
1841/* Nonzero means print parse trace. It is left uninitialized so that
1842 multiple parsers can coexist. */
1843int yydebug;
1844#else /* !YYDEBUG */
1845# define YYDPRINTF(Args)
1846# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1847# define YY_STACK_PRINT(Bottom, Top)
1848# define YY_REDUCE_PRINT(Rule)
1849#endif /* !YYDEBUG */
1850
1851
1852/* YYINITDEPTH -- initial size of the parser's stacks. */
1853#ifndef YYINITDEPTH
1854# define YYINITDEPTH 200
1855#endif
1856
1857/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1858 if the built-in stack extension method is used).
1859
1860 Do not make this value too large; the results are undefined if
1861 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1862 evaluated with infinite-precision integer arithmetic. */
1863
1864#ifndef YYMAXDEPTH
1865# define YYMAXDEPTH 10000
1866#endif
1867
1868␌
1869
1870#if YYERROR_VERBOSE
1871
1872# ifndef yystrlen
1873# if defined __GLIBC__ && defined _STRING_H
1874# define yystrlen strlen
1875# else
1876/* Return the length of YYSTR. */
1877#if (defined __STDC__ || defined __C99__FUNC__ \
1878 || defined __cplusplus || defined _MSC_VER)
1879static YYSIZE_T
1880yystrlen (const char *yystr)
1881#else
1882static YYSIZE_T
1883yystrlen (yystr)
1884 const char *yystr;
1885#endif
1886{
1887 YYSIZE_T yylen;
1888 for (yylen = 0; yystr[yylen]; yylen++)
1889 continue;
1890 return yylen;
1891}
1892# endif
1893# endif
1894
1895# ifndef yystpcpy
1896# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1897# define yystpcpy stpcpy
1898# else
1899/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1900 YYDEST. */
1901#if (defined __STDC__ || defined __C99__FUNC__ \
1902 || defined __cplusplus || defined _MSC_VER)
1903static char *
1904yystpcpy (char *yydest, const char *yysrc)
1905#else
1906static char *
1907yystpcpy (yydest, yysrc)
1908 char *yydest;
1909 const char *yysrc;
1910#endif
1911{
1912 char *yyd = yydest;
1913 const char *yys = yysrc;
1914
1915 while ((*yyd++ = *yys++) != '\0')
1916 continue;
1917
1918 return yyd - 1;
1919}
1920# endif
1921# endif
1922
1923# ifndef yytnamerr
1924/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1925 quotes and backslashes, so that it's suitable for yyerror. The
1926 heuristic is that double-quoting is unnecessary unless the string
1927 contains an apostrophe, a comma, or backslash (other than
1928 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1929 null, do not copy; instead, return the length of what the result
1930 would have been. */
1931static YYSIZE_T
1932yytnamerr (char *yyres, const char *yystr)
1933{
1934 if (*yystr == '"')
1935 {
1936 YYSIZE_T yyn = 0;
1937 char const *yyp = yystr;
1938
1939 for (;;)
1940 switch (*++yyp)
1941 {
1942 case '\'':
1943 case ',':
1944 goto do_not_strip_quotes;
1945
1946 case '\\':
1947 if (*++yyp != '\\')
1948 goto do_not_strip_quotes;
1949 /* Fall through. */
1950 default:
1951 if (yyres)
1952 yyres[yyn] = *yyp;
1953 yyn++;
1954 break;
1955
1956 case '"':
1957 if (yyres)
1958 yyres[yyn] = '\0';
1959 return yyn;
1960 }
1961 do_not_strip_quotes: ;
1962 }
1963
1964 if (! yyres)
1965 return yystrlen (yystr);
1966
1967 return yystpcpy (yyres, yystr) - yyres;
1968}
1969# endif
1970
1971/* Copy into YYRESULT an error message about the unexpected token
1972 YYCHAR while in state YYSTATE. Return the number of bytes copied,
1973 including the terminating null byte. If YYRESULT is null, do not
1974 copy anything; just return the number of bytes that would be
1975 copied. As a special case, return 0 if an ordinary "syntax error"
1976 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1977 size calculation. */
1978static YYSIZE_T
1979yysyntax_error (char *yyresult, int yystate, int yychar)
1980{
1981 int yyn = yypact[yystate];
1982
1983 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1984 return 0;
1985 else
1986 {
1987 int yytype = YYTRANSLATE (yychar);
1988 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1989 YYSIZE_T yysize = yysize0;
1990 YYSIZE_T yysize1;
1991 int yysize_overflow = 0;
1992 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1993 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1994 int yyx;
1995
1996# if 0
1997 /* This is so xgettext sees the translatable formats that are
1998 constructed on the fly. */
1999 YY_("syntax error, unexpected %s");
2000 YY_("syntax error, unexpected %s, expecting %s");
2001 YY_("syntax error, unexpected %s, expecting %s or %s");
2002 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
2003 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
2004# endif
2005 char *yyfmt;
2006 char const *yyf;
2007 static char const yyunexpected[] = "syntax error, unexpected %s";
2008 static char const yyexpecting[] = ", expecting %s";
2009 static char const yyor[] = " or %s";
2010 char yyformat[sizeof yyunexpected
2011 + sizeof yyexpecting - 1
2012 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
2013 * (sizeof yyor - 1))];
2014 char const *yyprefix = yyexpecting;
2015
2016 /* Start YYX at -YYN if negative to avoid negative indexes in
2017 YYCHECK. */
2018 int yyxbegin = yyn < 0 ? -yyn : 0;
2019
2020 /* Stay within bounds of both yycheck and yytname. */
2021 int yychecklim = YYLAST - yyn + 1;
2022 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2023 int yycount = 1;
2024
2025 yyarg[0] = yytname[yytype];
2026 yyfmt = yystpcpy (yyformat, yyunexpected);
2027
2028 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2029 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2030 {
2031 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2032 {
2033 yycount = 1;
2034 yysize = yysize0;
2035 yyformat[sizeof yyunexpected - 1] = '\0';
2036 break;
2037 }
2038 yyarg[yycount++] = yytname[yyx];
2039 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
2040 yysize_overflow |= (yysize1 < yysize);
2041 yysize = yysize1;
2042 yyfmt = yystpcpy (yyfmt, yyprefix);
2043 yyprefix = yyor;
2044 }
2045
2046 yyf = YY_(yyformat);
2047 yysize1 = yysize + yystrlen (yyf);
2048 yysize_overflow |= (yysize1 < yysize);
2049 yysize = yysize1;
2050
2051 if (yysize_overflow)
2052 return YYSIZE_MAXIMUM;
2053
2054 if (yyresult)
2055 {
2056 /* Avoid sprintf, as that infringes on the user's name space.
2057 Don't have undefined behavior even if the translation
2058 produced a string with the wrong number of "%s"s. */
2059 char *yyp = yyresult;
2060 int yyi = 0;
2061 while ((*yyp = *yyf) != '\0')
2062 {
2063 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2064 {
2065 yyp += yytnamerr (yyp, yyarg[yyi++]);
2066 yyf += 2;
2067 }
2068 else
2069 {
2070 yyp++;
2071 yyf++;
2072 }
2073 }
2074 }
2075 return yysize;
2076 }
2077}
2078#endif /* YYERROR_VERBOSE */
2079␌
2080
2081/*-----------------------------------------------.
2082| Release the memory associated to this symbol. |
2083`-----------------------------------------------*/
2084
2085/*ARGSUSED*/
2086#if (defined __STDC__ || defined __C99__FUNC__ \
2087 || defined __cplusplus || defined _MSC_VER)
2088static void
2089yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2090#else
2091static void
2092yydestruct (yymsg, yytype, yyvaluep)
2093 const char *yymsg;
2094 int yytype;
2095 YYSTYPE *yyvaluep;
2096#endif
2097{
2098 YYUSE (yyvaluep);
2099
2100 if (!yymsg)
2101 yymsg = "Deleting";
2102 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2103
2104 switch (yytype)
2105 {
2106
2107 default:
2108 break;
2109 }
2110}
2111
2112/* Prevent warnings from -Wmissing-prototypes. */
2113#ifdef YYPARSE_PARAM
2114#if defined __STDC__ || defined __cplusplus
2115int yyparse (void *YYPARSE_PARAM);
2116#else
2117int yyparse ();
2118#endif
2119#else /* ! YYPARSE_PARAM */
2120#if defined __STDC__ || defined __cplusplus
2121int yyparse (void);
2122#else
2123int yyparse ();
2124#endif
2125#endif /* ! YYPARSE_PARAM */
2126
2127
2128
2129
2130
2131/*-------------------------.
2132| yyparse or yypush_parse. |
2133`-------------------------*/
2134
2135#ifdef YYPARSE_PARAM
2136#if (defined __STDC__ || defined __C99__FUNC__ \
2137 || defined __cplusplus || defined _MSC_VER)
2138int
2139yyparse (void *YYPARSE_PARAM)
2140#else
2141int
2142yyparse (YYPARSE_PARAM)
2143 void *YYPARSE_PARAM;
2144#endif
2145#else /* ! YYPARSE_PARAM */
2146#if (defined __STDC__ || defined __C99__FUNC__ \
2147 || defined __cplusplus || defined _MSC_VER)
2148int
2149yyparse (void)
2150#else
2151int
2152yyparse ()
2153
2154#endif
2155#endif
2156{
2157/* The lookahead symbol. */
2158int yychar;
2159
2160/* The semantic value of the lookahead symbol. */
2161YYSTYPE yylval;
2162
2163 /* Number of syntax errors so far. */
2164 int yynerrs;
2165
2166 int yystate;
2167 /* Number of tokens to shift before error messages enabled. */
2168 int yyerrstatus;
2169
2170 /* The stacks and their tools:
2171 `yyss': related to states.
2172 `yyvs': related to semantic values.
2173
2174 Refer to the stacks thru separate pointers, to allow yyoverflow
2175 to reallocate them elsewhere. */
2176
2177 /* The state stack. */
2178 yytype_int16 yyssa[YYINITDEPTH];
2179 yytype_int16 *yyss;
2180 yytype_int16 *yyssp;
2181
2182 /* The semantic value stack. */
2183 YYSTYPE yyvsa[YYINITDEPTH];
2184 YYSTYPE *yyvs;
2185 YYSTYPE *yyvsp;
2186
2187 YYSIZE_T yystacksize;
2188
2189 int yyn;
2190 int yyresult;
2191 /* Lookahead token as an internal (translated) token number. */
2192 int yytoken;
2193 /* The variables used to return semantic value and location from the
2194 action routines. */
2195 YYSTYPE yyval;
2196
2197#if YYERROR_VERBOSE
2198 /* Buffer for error messages, and its allocated size. */
2199 char yymsgbuf[128];
2200 char *yymsg = yymsgbuf;
2201 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2202#endif
2203
2204#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2205
2206 /* The number of symbols on the RHS of the reduced rule.
2207 Keep to zero when no symbol should be popped. */
2208 int yylen = 0;
2209
2210 yytoken = 0;
2211 yyss = yyssa;
2212 yyvs = yyvsa;
2213 yystacksize = YYINITDEPTH;
2214
2215 YYDPRINTF ((stderr, "Starting parse\n"));
2216
2217 yystate = 0;
2218 yyerrstatus = 0;
2219 yynerrs = 0;
2220 yychar = YYEMPTY; /* Cause a token to be read. */
2221
2222 /* Initialize stack pointers.
2223 Waste one element of value and location stack
2224 so that they stay on the same level as the state stack.
2225 The wasted elements are never initialized. */
2226 yyssp = yyss;
2227 yyvsp = yyvs;
2228
2229 goto yysetstate;
2230
2231/*------------------------------------------------------------.
2232| yynewstate -- Push a new state, which is found in yystate. |
2233`------------------------------------------------------------*/
2234 yynewstate:
2235 /* In all cases, when you get here, the value and location stacks
2236 have just been pushed. So pushing a state here evens the stacks. */
2237 yyssp++;
2238
2239 yysetstate:
2240 *yyssp = yystate;
2241
2242 if (yyss + yystacksize - 1 <= yyssp)
2243 {
2244 /* Get the current used size of the three stacks, in elements. */
2245 YYSIZE_T yysize = yyssp - yyss + 1;
2246
2247#ifdef yyoverflow
2248 {
2249 /* Give user a chance to reallocate the stack. Use copies of
2250 these so that the &'s don't force the real ones into
2251 memory. */
2252 YYSTYPE *yyvs1 = yyvs;
2253 yytype_int16 *yyss1 = yyss;
2254
2255 /* Each stack pointer address is followed by the size of the
2256 data in use in that stack, in bytes. This used to be a
2257 conditional around just the two extra args, but that might
2258 be undefined if yyoverflow is a macro. */
2259 yyoverflow (YY_("memory exhausted"),
2260 &yyss1, yysize * sizeof (*yyssp),
2261 &yyvs1, yysize * sizeof (*yyvsp),
2262 &yystacksize);
2263
2264 yyss = yyss1;
2265 yyvs = yyvs1;
2266 }
2267#else /* no yyoverflow */
2268# ifndef YYSTACK_RELOCATE
2269 goto yyexhaustedlab;
2270# else
2271 /* Extend the stack our own way. */
2272 if (YYMAXDEPTH <= yystacksize)
2273 goto yyexhaustedlab;
2274 yystacksize *= 2;
2275 if (YYMAXDEPTH < yystacksize)
2276 yystacksize = YYMAXDEPTH;
2277
2278 {
2279 yytype_int16 *yyss1 = yyss;
2280 union yyalloc *yyptr =
2281 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2282 if (! yyptr)
2283 goto yyexhaustedlab;
2284 YYSTACK_RELOCATE (yyss_alloc, yyss);
2285 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2286# undef YYSTACK_RELOCATE
2287 if (yyss1 != yyssa)
2288 YYSTACK_FREE (yyss1);
2289 }
2290# endif
2291#endif /* no yyoverflow */
2292
2293 yyssp = yyss + yysize - 1;
2294 yyvsp = yyvs + yysize - 1;
2295
2296 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2297 (unsigned long int) yystacksize));
2298
2299 if (yyss + yystacksize - 1 <= yyssp)
2300 YYABORT;
2301 }
2302
2303 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2304
2305 if (yystate == YYFINAL)
2306 YYACCEPT;
2307
2308 goto yybackup;
2309
2310/*-----------.
2311| yybackup. |
2312`-----------*/
2313yybackup:
2314
2315 /* Do appropriate processing given the current state. Read a
2316 lookahead token if we need one and don't already have one. */
2317
2318 /* First try to decide what to do without reference to lookahead token. */
2319 yyn = yypact[yystate];
2320 if (yyn == YYPACT_NINF)
2321 goto yydefault;
2322
2323 /* Not known => get a lookahead token if don't already have one. */
2324
2325 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2326 if (yychar == YYEMPTY)
2327 {
2328 YYDPRINTF ((stderr, "Reading a token: "));
2329 yychar = YYLEX;
2330 }
2331
2332 if (yychar <= YYEOF)
2333 {
2334 yychar = yytoken = YYEOF;
2335 YYDPRINTF ((stderr, "Now at end of input.\n"));
2336 }
2337 else
2338 {
2339 yytoken = YYTRANSLATE (yychar);
2340 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2341 }
2342
2343 /* If the proper action on seeing token YYTOKEN is to reduce or to
2344 detect an error, take that action. */
2345 yyn += yytoken;
2346 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2347 goto yydefault;
2348 yyn = yytable[yyn];
2349 if (yyn <= 0)
2350 {
2351 if (yyn == 0 || yyn == YYTABLE_NINF)
2352 goto yyerrlab;
2353 yyn = -yyn;
2354 goto yyreduce;
2355 }
2356
2357 /* Count tokens shifted since error; after three, turn off error
2358 status. */
2359 if (yyerrstatus)
2360 yyerrstatus--;
2361
2362 /* Shift the lookahead token. */
2363 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2364
2365 /* Discard the shifted token. */
2366 yychar = YYEMPTY;
2367
2368 yystate = yyn;
2369 *++yyvsp = yylval;
2370
2371 goto yynewstate;
2372
2373
2374/*-----------------------------------------------------------.
2375| yydefault -- do the default action for the current state. |
2376`-----------------------------------------------------------*/
2377yydefault:
2378 yyn = yydefact[yystate];
2379 if (yyn == 0)
2380 goto yyerrlab;
2381 goto yyreduce;
2382
2383
2384/*-----------------------------.
2385| yyreduce -- Do a reduction. |
2386`-----------------------------*/
2387yyreduce:
2388 /* yyn is the number of a rule to reduce with. */
2389 yylen = yyr2[yyn];
2390
2391 /* If YYLEN is nonzero, implement the default value of the action:
2392 `$$ = $1'.
2393
2394 Otherwise, the following line sets YYVAL to garbage.
2395 This behavior is undocumented and Bison
2396 users should not rely upon it. Assigning to YYVAL
2397 unconditionally makes the parser a bit smaller, and it avoids a
2398 GCC warning that YYVAL may be used uninitialized. */
2399 yyval = yyvsp[1-yylen];
2400
2401
2402 YY_REDUCE_PRINT (yyn);
2403 switch (yyn)
2404 {
2405 case 3:
2406
2407/* Line 1464 of yacc.c */
2408#line 322 "grammar.y"
2409 {
2410 if (timerv)
2411 {
2412 writeTime("used time:");
2413 startTimer();
2414 }
2415 if (rtimerv)
2416 {
2417 writeRTime("used real time:");
2418 startRTimer();
2419 }
2420 prompt_char = '>';
2421#ifdef HAVE_SDB
2422 if (sdb_flags & 2) { sdb_flags=1; YYERROR; }
2423#endif
2424 if(siCntrlc)
2425 {
2426 WerrorS("abort...");
2427 while((currentVoice!=NULL) && (currentVoice->prev!=NULL)) exitVoice();
2428 if (currentVoice!=NULL) currentVoice->ifsw=0;
2429 }
2430 if (errorreported) /* also catches abort... */
2431 {
2432 yyerror("");
2433 }
2434 if (inerror==2) PrintLn();
2435 errorreported = inerror = cmdtok = 0;
2436 lastreserved = currid = NULL;
2437 expected_parms = siCntrlc = FALSE;
2438 ;}
2439 break;
2440
2441 case 5:
2442
2443/* Line 1464 of yacc.c */
2444#line 357 "grammar.y"
2445 {currentVoice->ifsw=0;;}
2446 break;
2447
2448 case 6:
2449
2450/* Line 1464 of yacc.c */
2451#line 359 "grammar.y"
2452 { (yyvsp[(1) - (2)].lv).CleanUp(); currentVoice->ifsw=0;;}
2453 break;
2454
2455 case 7:
2456
2457/* Line 1464 of yacc.c */
2458#line 361 "grammar.y"
2459 {
2460 YYACCEPT;
2461 ;}
2462 break;
2463
2464 case 8:
2465
2466/* Line 1464 of yacc.c */
2467#line 365 "grammar.y"
2468 {
2469 currentVoice->ifsw=0;
2470 iiDebug();
2471 ;}
2472 break;
2473
2474 case 9:
2475
2476/* Line 1464 of yacc.c */
2477#line 370 "grammar.y"
2478 {currentVoice->ifsw=0;;}
2479 break;
2480
2481 case 10:
2482
2483/* Line 1464 of yacc.c */
2484#line 372 "grammar.y"
2485 {
2486 #ifdef SIQ
2487 siq=0;
2488 #endif
2489 yyInRingConstruction = FALSE;
2490 currentVoice->ifsw=0;
2491 if (inerror)
2492 {
2493/* bison failed here*/
2494 if ((inerror!=3) && ((yyvsp[(1) - (2)].i)<UMINUS) && ((yyvsp[(1) - (2)].i)>' '))
2495 {
2496 // 1: yyerror called
2497 // 2: scanner put actual string
2498 // 3: error rule put token+\n
2499 inerror=3;
2500 Print(" error at token `%s`\n",iiTwoOps((yyvsp[(1) - (2)].i)));
2501 }
2502/**/
2503
2504 }
2505 if (!errorreported) WerrorS("...parse error");
2506 yyerror("");
2507 yyerrok;
2508#ifdef HAVE_SDB
2509 if ((sdb_flags & 1) && currentVoice->pi!=NULL)
2510 {
2511 currentVoice->pi->trace_flag |=1;
2512 }
2513 else
2514#endif
2515 if (myynest>0)
2516 {
2517 feBufferTypes t=currentVoice->Typ();
2518 //PrintS("leaving yyparse\n");
2519 exitBuffer(BT_proc);
2520 if (t==BT_example)
2521 YYACCEPT;
2522 else
2523 YYABORT;
2524 }
2525 else if (currentVoice->prev!=NULL)
2526 {
2527 exitVoice();
2528 }
2529#ifdef HAVE_SDB
2530 if (sdb_flags &2) sdb_flags=1;
2531#endif
2532 ;}
2533 break;
2534
2535 case 18:
2536
2537/* Line 1464 of yacc.c */
2538#line 430 "grammar.y"
2539 {if (currentVoice!=NULL) currentVoice->ifsw=0;;}
2540 break;
2541
2542 case 19:
2543
2544/* Line 1464 of yacc.c */
2545#line 433 "grammar.y"
2546 { omFree((ADDRESS)(yyvsp[(2) - (2)].name)); ;}
2547 break;
2548
2549 case 29:
2550
2551/* Line 1464 of yacc.c */
2552#line 448 "grammar.y"
2553 {
2554 if(iiAssign(&(yyvsp[(1) - (2)].lv),&(yyvsp[(2) - (2)].lv))) YYERROR;
2555 ;}
2556 break;
2557
2558 case 30:
2559
2560/* Line 1464 of yacc.c */
2561#line 455 "grammar.y"
2562 {
2563 if (currRing==NULL) MYYERROR("no ring active (7)");
2564 syMakeMonom(&(yyval.lv),(yyvsp[(1) - (1)].name));
2565 ;}
2566 break;
2567
2568 case 31:
2569
2570/* Line 1464 of yacc.c */
2571#line 460 "grammar.y"
2572 {
2573 syMake(&(yyval.lv),(yyvsp[(1) - (1)].name));
2574 ;}
2575 break;
2576
2577 case 32:
2578
2579/* Line 1464 of yacc.c */
2580#line 464 "grammar.y"
2581 {
2582 if(iiExprArith2(&(yyval.lv), &(yyvsp[(1) - (3)].lv), COLONCOLON, &(yyvsp[(3) - (3)].lv))) YYERROR;
2583 ;}
2584 break;
2585
2586 case 33:
2587
2588/* Line 1464 of yacc.c */
2589#line 468 "grammar.y"
2590 {
2591 if(iiExprArith2(&(yyval.lv), &(yyvsp[(1) - (3)].lv), '.', &(yyvsp[(3) - (3)].lv))) YYERROR;
2592 ;}
2593 break;
2594
2595 case 34:
2596
2597/* Line 1464 of yacc.c */
2598#line 472 "grammar.y"
2599 {
2600 if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'(')) YYERROR;
2601 ;}
2602 break;
2603
2604 case 35:
2605
2606/* Line 1464 of yacc.c */
2607#line 476 "grammar.y"
2608 {
2609 if ((yyvsp[(1) - (4)].lv).next==NULL)
2610 {
2611 (yyvsp[(1) - (4)].lv).next=(leftv)omAllocBin(sleftv_bin);
2612 memcpy((yyvsp[(1) - (4)].lv).next,&(yyvsp[(3) - (4)].lv),sizeof(sleftv));
2613 if(iiExprArithM(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'(')) YYERROR;
2614 }
2615 else if ((yyvsp[(1) - (4)].lv).rtyp==UNKNOWN)
2616 { // for x(i)(j)
2617 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'(',&(yyvsp[(3) - (4)].lv))) YYERROR;
2618 }
2619 else YYERROR;
2620 ;}
2621 break;
2622
2623 case 36:
2624
2625/* Line 1464 of yacc.c */
2626#line 490 "grammar.y"
2627 {
2628 if (currRing==NULL) MYYERROR("no ring active (8)");
2629 int j = 0;
2630 memset(&(yyval.lv),0,sizeof(sleftv));
2631 (yyval.lv).rtyp=VECTOR_CMD;
2632 leftv v = &(yyvsp[(2) - (3)].lv);
2633 while (v!=NULL)
2634 {
2635 int i,t;
2636 sleftv tmp;
2637 memset(&tmp,0,sizeof(tmp));
2638 i=iiTestConvert((t=v->Typ()),POLY_CMD);
2639 if((i==0) || (iiConvert(t /*v->Typ()*/,POLY_CMD,i,v,&tmp)))
2640 {
2641 pDelete((poly *)&(yyval.lv).data);
2642 (yyvsp[(2) - (3)].lv).CleanUp();
2643 MYYERROR("expected '[poly,...'");
2644 }
2645 poly p = (poly)tmp.CopyD(POLY_CMD);
2646 pSetCompP(p,++j);
2647 (yyval.lv).data = (void *)pAdd((poly)(yyval.lv).data,p);
2648 v->next=tmp.next;tmp.next=NULL;
2649 tmp.CleanUp();
2650 v=v->next;
2651 }
2652 (yyvsp[(2) - (3)].lv).CleanUp();
2653 ;}
2654 break;
2655
2656 case 37:
2657
2658/* Line 1464 of yacc.c */
2659#line 518 "grammar.y"
2660 {
2661 memset(&(yyval.lv),0,sizeof((yyval.lv)));
2662 int i = atoi((yyvsp[(1) - (1)].name));
2663 /*remember not to omFree($1)
2664 *because it is a part of the scanner buffer*/
2665 (yyval.lv).rtyp = INT_CMD;
2666 (yyval.lv).data = (void *)(long)i;
2667
2668 /* check: out of range input */
2669 int l = strlen((yyvsp[(1) - (1)].name))+2;
2670 number n;
2671 if (l >= MAX_INT_LEN)
2672 {
2673 char tmp[MAX_INT_LEN+5];
2674 snprintf(tmp,MAX_INT_LEN+5,"%d",i);
2675 if (strcmp(tmp,(yyvsp[(1) - (1)].name))!=0)
2676 {
2677 n_Read((yyvsp[(1) - (1)].name),&n,coeffs_BIGINT);
2678 (yyval.lv).rtyp=BIGINT_CMD;
2679 (yyval.lv).data = n;
2680 }
2681 }
2682 ;}
2683 break;
2684
2685 case 38:
2686
2687/* Line 1464 of yacc.c */
2688#line 542 "grammar.y"
2689 {
2690 memset(&(yyval.lv),0,sizeof((yyval.lv)));
2691 (yyval.lv).rtyp = (yyvsp[(1) - (1)].i);
2692 (yyval.lv).data = (yyval.lv).Data();
2693 ;}
2694 break;
2695
2696 case 39:
2697
2698/* Line 1464 of yacc.c */
2699#line 548 "grammar.y"
2700 {
2701 memset(&(yyval.lv),0,sizeof((yyval.lv)));
2702 (yyval.lv).rtyp = STRING_CMD;
2703 (yyval.lv).data = (yyvsp[(1) - (1)].name);
2704 ;}
2705 break;
2706
2707 case 40:
2708
2709/* Line 1464 of yacc.c */
2710#line 554 "grammar.y"
2711 {
2712 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2713 ;}
2714 break;
2715
2716 case 41:
2717
2718/* Line 1464 of yacc.c */
2719#line 558 "grammar.y"
2720 {
2721 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2722 ;}
2723 break;
2724
2725 case 42:
2726
2727/* Line 1464 of yacc.c */
2728#line 562 "grammar.y"
2729 {
2730 if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2731 ;}
2732 break;
2733
2734 case 43:
2735
2736/* Line 1464 of yacc.c */
2737#line 566 "grammar.y"
2738 {
2739 if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2740 ;}
2741 break;
2742
2743 case 44:
2744
2745/* Line 1464 of yacc.c */
2746#line 570 "grammar.y"
2747 {
2748 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2749 ;}
2750 break;
2751
2752 case 45:
2753
2754/* Line 1464 of yacc.c */
2755#line 574 "grammar.y"
2756 {
2757 if(iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2758 ;}
2759 break;
2760
2761 case 46:
2762
2763/* Line 1464 of yacc.c */
2764#line 578 "grammar.y"
2765 {
2766 if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2767 ;}
2768 break;
2769
2770 case 47:
2771
2772/* Line 1464 of yacc.c */
2773#line 582 "grammar.y"
2774 {
2775 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2776 ;}
2777 break;
2778
2779 case 48:
2780
2781/* Line 1464 of yacc.c */
2782#line 586 "grammar.y"
2783 {
2784 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2785 ;}
2786 break;
2787
2788 case 49:
2789
2790/* Line 1464 of yacc.c */
2791#line 590 "grammar.y"
2792 {
2793 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2794 ;}
2795 break;
2796
2797 case 50:
2798
2799/* Line 1464 of yacc.c */
2800#line 594 "grammar.y"
2801 {
2802 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2803 ;}
2804 break;
2805
2806 case 51:
2807
2808/* Line 1464 of yacc.c */
2809#line 598 "grammar.y"
2810 {
2811 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2812 ;}
2813 break;
2814
2815 case 52:
2816
2817/* Line 1464 of yacc.c */
2818#line 602 "grammar.y"
2819 {
2820 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2821 ;}
2822 break;
2823
2824 case 53:
2825
2826/* Line 1464 of yacc.c */
2827#line 606 "grammar.y"
2828 {
2829 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2830 ;}
2831 break;
2832
2833 case 54:
2834
2835/* Line 1464 of yacc.c */
2836#line 610 "grammar.y"
2837 {
2838 if(iiExprArith2(&(yyval.lv),&(yyvsp[(3) - (6)].lv),(yyvsp[(1) - (6)].i),&(yyvsp[(5) - (6)].lv),TRUE)) YYERROR;
2839 ;}
2840 break;
2841
2842 case 55:
2843
2844/* Line 1464 of yacc.c */
2845#line 614 "grammar.y"
2846 {
2847 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2848 ;}
2849 break;
2850
2851 case 56:
2852
2853/* Line 1464 of yacc.c */
2854#line 618 "grammar.y"
2855 {
2856 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2857 ;}
2858 break;
2859
2860 case 57:
2861
2862/* Line 1464 of yacc.c */
2863#line 622 "grammar.y"
2864 {
2865 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2866 ;}
2867 break;
2868
2869 case 58:
2870
2871/* Line 1464 of yacc.c */
2872#line 626 "grammar.y"
2873 {
2874 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2875 ;}
2876 break;
2877
2878 case 59:
2879
2880/* Line 1464 of yacc.c */
2881#line 630 "grammar.y"
2882 {
2883 if(iiExprArithM(&(yyval.lv),NULL,(yyvsp[(1) - (3)].i))) YYERROR;
2884 ;}
2885 break;
2886
2887 case 60:
2888
2889/* Line 1464 of yacc.c */
2890#line 634 "grammar.y"
2891 {
2892 int b=iiExprArithM(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i)); // handle branchTo
2893 if (b==TRUE) YYERROR;
2894 if (b==2) YYACCEPT;
2895 ;}
2896 break;
2897
2898 case 61:
2899
2900/* Line 1464 of yacc.c */
2901#line 640 "grammar.y"
2902 {
2903 if(iiExprArith3(&(yyval.lv),(yyvsp[(1) - (8)].i),&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2904 ;}
2905 break;
2906
2907 case 62:
2908
2909/* Line 1464 of yacc.c */
2910#line 644 "grammar.y"
2911 {
2912 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),(yyvsp[(1) - (4)].i))) YYERROR;
2913 ;}
2914 break;
2915
2916 case 63:
2917
2918/* Line 1464 of yacc.c */
2919#line 648 "grammar.y"
2920 {
2921 if(iiExprArith3(&(yyval.lv),RING_CMD,&(yyvsp[(3) - (8)].lv),&(yyvsp[(5) - (8)].lv),&(yyvsp[(7) - (8)].lv))) YYERROR;
2922 ;}
2923 break;
2924
2925 case 64:
2926
2927/* Line 1464 of yacc.c */
2928#line 652 "grammar.y"
2929 {
2930 if(iiExprArith1(&(yyval.lv),&(yyvsp[(3) - (4)].lv),RING_CMD)) YYERROR;
2931 ;}
2932 break;
2933
2934 case 65:
2935
2936/* Line 1464 of yacc.c */
2937#line 656 "grammar.y"
2938 {
2939 if (iiARROW(&(yyval.lv),(yyvsp[(1) - (3)].name),(yyvsp[(3) - (3)].name))) YYERROR;
2940 omFree((ADDRESS)(yyvsp[(3) - (3)].name));
2941 ;}
2942 break;
2943
2944 case 66:
2945
2946/* Line 1464 of yacc.c */
2947#line 660 "grammar.y"
2948 { (yyval.lv) = (yyvsp[(2) - (3)].lv); ;}
2949 break;
2950
2951 case 67:
2952
2953/* Line 1464 of yacc.c */
2954#line 665 "grammar.y"
2955 {
2956 leftv v = &(yyvsp[(1) - (3)].lv);
2957 while (v->next!=NULL)
2958 {
2959 v=v->next;
2960 }
2961 v->next = (leftv)omAllocBin(sleftv_bin);
2962 memcpy(v->next,&((yyvsp[(3) - (3)].lv)),sizeof(sleftv));
2963 (yyval.lv) = (yyvsp[(1) - (3)].lv);
2964 ;}
2965 break;
2966
2967 case 71:
2968
2969/* Line 1464 of yacc.c */
2970#line 681 "grammar.y"
2971 {
2972 if(iiExprArith3(&(yyval.lv),'[',&(yyvsp[(1) - (6)].lv),&(yyvsp[(3) - (6)].lv),&(yyvsp[(5) - (6)].lv))) YYERROR;
2973 ;}
2974 break;
2975
2976 case 72:
2977
2978/* Line 1464 of yacc.c */
2979#line 685 "grammar.y"
2980 {
2981 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (4)].lv),'[',&(yyvsp[(3) - (4)].lv))) YYERROR;
2982 ;}
2983 break;
2984
2985 case 73:
2986
2987/* Line 1464 of yacc.c */
2988#line 689 "grammar.y"
2989 {
2990 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
2991 ;}
2992 break;
2993
2994 case 74:
2995
2996/* Line 1464 of yacc.c */
2997#line 693 "grammar.y"
2998 {
2999 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3000 ;}
3001 break;
3002
3003 case 75:
3004
3005/* Line 1464 of yacc.c */
3006#line 697 "grammar.y"
3007 {
3008 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3009 ;}
3010 break;
3011
3012 case 76:
3013
3014/* Line 1464 of yacc.c */
3015#line 701 "grammar.y"
3016 {
3017 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3018 ;}
3019 break;
3020
3021 case 77:
3022
3023/* Line 1464 of yacc.c */
3024#line 705 "grammar.y"
3025 {
3026 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), (yyvsp[(5) - (6)].i), NULL)) YYERROR;
3027 ;}
3028 break;
3029
3030 case 78:
3031
3032/* Line 1464 of yacc.c */
3033#line 709 "grammar.y"
3034 {
3035 if (iiApply(&(yyval.lv), &(yyvsp[(3) - (6)].lv), 0, &(yyvsp[(5) - (6)].lv))) YYERROR;
3036 ;}
3037 break;
3038
3039 case 79:
3040
3041/* Line 1464 of yacc.c */
3042#line 713 "grammar.y"
3043 {
3044 (yyval.lv)=(yyvsp[(2) - (3)].lv);
3045 ;}
3046 break;
3047
3048 case 80:
3049
3050/* Line 1464 of yacc.c */
3051#line 717 "grammar.y"
3052 {
3053 #ifdef SIQ
3054 siq++;
3055 if (siq>0)
3056 { if (iiExprArith2(&(yyval.lv),&(yyvsp[(2) - (5)].lv),'=',&(yyvsp[(4) - (5)].lv))) YYERROR; }
3057 else
3058 #endif
3059 {
3060 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3061 (yyval.lv).rtyp=NONE;
3062 if (iiAssign(&(yyvsp[(2) - (5)].lv),&(yyvsp[(4) - (5)].lv))) YYERROR;
3063 }
3064 #ifdef SIQ
3065 siq--;
3066 #endif
3067 ;}
3068 break;
3069
3070 case 81:
3071
3072/* Line 1464 of yacc.c */
3073#line 734 "grammar.y"
3074 {
3075 iiTestAssume(&(yyvsp[(2) - (5)].lv),&(yyvsp[(4) - (5)].lv));
3076 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3077 (yyval.lv).rtyp=NONE;
3078 ;}
3079 break;
3080
3081 case 82:
3082
3083/* Line 1464 of yacc.c */
3084#line 740 "grammar.y"
3085 {
3086 #ifdef SIQ
3087 siq--;
3088 #endif
3089 ;}
3090 break;
3091
3092 case 83:
3093
3094/* Line 1464 of yacc.c */
3095#line 746 "grammar.y"
3096 {
3097 #ifdef SIQ
3098 if (siq<=0) (yyvsp[(4) - (5)].lv).Eval();
3099 #endif
3100 (yyval.lv)=(yyvsp[(4) - (5)].lv);
3101 #ifdef SIQ
3102 siq++;
3103 #endif
3104 ;}
3105 break;
3106
3107 case 84:
3108
3109/* Line 1464 of yacc.c */
3110#line 758 "grammar.y"
3111 {
3112 #ifdef SIQ
3113 siq++;
3114 #endif
3115 ;}
3116 break;
3117
3118 case 85:
3119
3120/* Line 1464 of yacc.c */
3121#line 766 "grammar.y"
3122 {
3123 #ifdef SIQ
3124 siq++;
3125 #endif
3126 ;}
3127 break;
3128
3129 case 86:
3130
3131/* Line 1464 of yacc.c */
3132#line 774 "grammar.y"
3133 {
3134 #ifdef SIQ
3135 siq--;
3136 #endif
3137 ;}
3138 break;
3139
3140 case 87:
3141
3142/* Line 1464 of yacc.c */
3143#line 783 "grammar.y"
3144 {
3145 if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),PLUSPLUS)) YYERROR;
3146 ;}
3147 break;
3148
3149 case 88:
3150
3151/* Line 1464 of yacc.c */
3152#line 787 "grammar.y"
3153 {
3154 if(iiExprArith1(&(yyval.lv),&(yyvsp[(1) - (2)].lv),MINUSMINUS)) YYERROR;
3155 ;}
3156 break;
3157
3158 case 89:
3159
3160/* Line 1464 of yacc.c */
3161#line 791 "grammar.y"
3162 {
3163 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'+',&(yyvsp[(3) - (3)].lv))) YYERROR;
3164 ;}
3165 break;
3166
3167 case 90:
3168
3169/* Line 1464 of yacc.c */
3170#line 795 "grammar.y"
3171 {
3172 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'-',&(yyvsp[(3) - (3)].lv))) YYERROR;
3173 ;}
3174 break;
3175
3176 case 91:
3177
3178/* Line 1464 of yacc.c */
3179#line 799 "grammar.y"
3180 { /* also for *,% */
3181 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3182 ;}
3183 break;
3184
3185 case 92:
3186
3187/* Line 1464 of yacc.c */
3188#line 803 "grammar.y"
3189 {
3190 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),'^',&(yyvsp[(3) - (3)].lv))) YYERROR;
3191 ;}
3192 break;
3193
3194 case 93:
3195
3196/* Line 1464 of yacc.c */
3197#line 807 "grammar.y"
3198 { /* also for > */
3199 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3200 ;}
3201 break;
3202
3203 case 94:
3204
3205/* Line 1464 of yacc.c */
3206#line 811 "grammar.y"
3207 { /* also for |*/
3208 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),(yyvsp[(2) - (3)].i),&(yyvsp[(3) - (3)].lv))) YYERROR;
3209 ;}
3210 break;
3211
3212 case 95:
3213
3214/* Line 1464 of yacc.c */
3215#line 815 "grammar.y"
3216 {
3217 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),NOTEQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR;
3218 ;}
3219 break;
3220
3221 case 96:
3222
3223/* Line 1464 of yacc.c */
3224#line 819 "grammar.y"
3225 {
3226 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),EQUAL_EQUAL,&(yyvsp[(3) - (3)].lv))) YYERROR;
3227 ;}
3228 break;
3229
3230 case 97:
3231
3232/* Line 1464 of yacc.c */
3233#line 823 "grammar.y"
3234 {
3235 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),DOTDOT,&(yyvsp[(3) - (3)].lv))) YYERROR;
3236 ;}
3237 break;
3238
3239 case 98:
3240
3241/* Line 1464 of yacc.c */
3242#line 827 "grammar.y"
3243 {
3244 if(iiExprArith2(&(yyval.lv),&(yyvsp[(1) - (3)].lv),':',&(yyvsp[(3) - (3)].lv))) YYERROR;
3245 ;}
3246 break;
3247
3248 case 99:
3249
3250/* Line 1464 of yacc.c */
3251#line 831 "grammar.y"
3252 {
3253 if (siq>0)
3254 { if (iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),NOT)) YYERROR; }
3255 else
3256 {
3257 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3258 int i; TESTSETINT((yyvsp[(2) - (2)].lv),i);
3259 (yyval.lv).rtyp = INT_CMD;
3260 (yyval.lv).data = (void *)(long)(i == 0 ? 1 : 0);
3261 }
3262 ;}
3263 break;
3264
3265 case 100:
3266
3267/* Line 1464 of yacc.c */
3268#line 843 "grammar.y"
3269 {
3270 if(iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),'-')) YYERROR;
3271 ;}
3272 break;
3273
3274 case 102:
3275
3276/* Line 1464 of yacc.c */
3277#line 851 "grammar.y"
3278 {
3279 if ((yyvsp[(1) - (2)].lv).rtyp==0)
3280 {
3281 Werror("`%s` is undefined",(yyvsp[(1) - (2)].lv).Fullname());
3282 YYERROR;
3283 }
3284 else if (((yyvsp[(1) - (2)].lv).rtyp==MODUL_CMD)
3285 // matrix m; m[2]=...
3286 && ((yyvsp[(1) - (2)].lv).e!=NULL) && ((yyvsp[(1) - (2)].lv).e->next==NULL))
3287 {
3288 MYYERROR("matrix must have 2 indices");
3289 }
3290 (yyval.lv) = (yyvsp[(1) - (2)].lv);
3291 ;}
3292 break;
3293
3294 case 104:
3295
3296/* Line 1464 of yacc.c */
3297#line 871 "grammar.y"
3298 {
3299 if ((yyvsp[(2) - (3)].lv).Typ()!=STRING_CMD)
3300 {
3301 MYYERROR("string expression expected");
3302 }
3303 (yyval.name) = (char *)(yyvsp[(2) - (3)].lv).CopyD(STRING_CMD);
3304 (yyvsp[(2) - (3)].lv).CleanUp();
3305 ;}
3306 break;
3307
3308 case 105:
3309
3310/* Line 1464 of yacc.c */
3311#line 883 "grammar.y"
3312 {
3313 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3314 YYERROR;
3315 ;}
3316 break;
3317
3318 case 106:
3319
3320/* Line 1464 of yacc.c */
3321#line 888 "grammar.y"
3322 {
3323 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3324 YYERROR;
3325 ;}
3326 break;
3327
3328 case 107:
3329
3330/* Line 1464 of yacc.c */
3331#line 893 "grammar.y"
3332 {
3333 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3334 ;}
3335 break;
3336
3337 case 108:
3338
3339/* Line 1464 of yacc.c */
3340#line 897 "grammar.y"
3341 {
3342 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3343 ;}
3344 break;
3345
3346 case 109:
3347
3348/* Line 1464 of yacc.c */
3349#line 901 "grammar.y"
3350 {
3351 int r; TESTSETINT((yyvsp[(4) - (8)].lv),r);
3352 int c; TESTSETINT((yyvsp[(7) - (8)].lv),c);
3353 leftv v;
3354 idhdl h;
3355 if (((yyvsp[(1) - (8)].i) == MATRIX_CMD) || ((yyvsp[(1) - (8)].i) == SMATRIX_CMD ))
3356 {
3357 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&(currRing->idroot), TRUE)) YYERROR;
3358 v=&(yyval.lv);
3359 h=(idhdl)v->data;
3360 idDelete(&IDIDEAL(h));
3361 if ((yyvsp[(1) - (8)].i) == MATRIX_CMD)
3362 IDMATRIX(h) = mpNew(r,c);
3363 else
3364 IDIDEAL(h) = idInit(c,r);
3365 if (IDMATRIX(h)==NULL) YYERROR;
3366 }
3367 else if (((yyvsp[(1) - (8)].i) == INTMAT_CMD)||((yyvsp[(1) - (8)].i) == BIGINTMAT_CMD))
3368 {
3369 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (8)].lv),myynest,(yyvsp[(1) - (8)].i),&((yyvsp[(2) - (8)].lv).req_packhdl->idroot)))
3370 YYERROR;
3371 v=&(yyval.lv);
3372 h=(idhdl)v->data;
3373 if ((yyvsp[(1) - (8)].i)==INTMAT_CMD)
3374 {
3375 delete IDINTVEC(h);
3376 IDINTVEC(h) = new intvec(r,c,0);
3377 }
3378 else
3379 {
3380 delete IDBIMAT(h);
3381 IDBIMAT(h) = new bigintmat(r, c, coeffs_BIGINT);
3382 }
3383 if (IDINTVEC(h)==NULL) YYERROR;
3384 }
3385 ;}
3386 break;
3387
3388 case 110:
3389
3390/* Line 1464 of yacc.c */
3391#line 938 "grammar.y"
3392 {
3393 if (((yyvsp[(1) - (2)].i) == MATRIX_CMD)||((yyvsp[(1) - (2)].i) == SMATRIX_CMD))
3394 {
3395 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
3396 }
3397 else if (((yyvsp[(1) - (2)].i) == INTMAT_CMD)||((yyvsp[(1) - (2)].i) == BIGINTMAT_CMD))
3398 {
3399 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3400 YYERROR;
3401 if ((yyvsp[(1) - (2)].i) == INTMAT_CMD)
3402 {
3403 leftv v=&(yyval.lv);
3404 idhdl h;
3405 do
3406 {
3407 h=(idhdl)v->data;
3408 delete IDINTVEC(h);
3409 IDINTVEC(h) = new intvec(1,1,0);
3410 v=v->next;
3411 } while (v!=NULL);
3412 }
3413 }
3414 ;}
3415 break;
3416
3417 case 111:
3418
3419/* Line 1464 of yacc.c */
3420#line 962 "grammar.y"
3421 {
3422 int t=(yyvsp[(1) - (3)].lv).Typ();
3423 sleftv r;
3424 memset(&r,0,sizeof(sleftv));
3425 if ((BEGIN_RING<t) && (t<END_RING))
3426 {
3427 if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&(currRing->idroot), TRUE))
3428 YYERROR;
3429 }
3430 else
3431 {
3432 if (iiDeclCommand(&r,&(yyvsp[(3) - (3)].lv),myynest,t,&((yyvsp[(3) - (3)].lv).req_packhdl->idroot)))
3433 YYERROR;
3434 }
3435 leftv v=&(yyvsp[(1) - (3)].lv);
3436 while (v->next!=NULL) v=v->next;
3437 v->next=(leftv)omAllocBin(sleftv_bin);
3438 memcpy(v->next,&r,sizeof(sleftv));
3439 (yyval.lv)=(yyvsp[(1) - (3)].lv);
3440 ;}
3441 break;
3442
3443 case 112:
3444
3445/* Line 1464 of yacc.c */
3446#line 983 "grammar.y"
3447 {
3448 if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
3449 YYERROR;
3450 ;}
3451 break;
3452
3453 case 115:
3454
3455/* Line 1464 of yacc.c */
3456#line 996 "grammar.y"
3457 {
3458 leftv v = &(yyvsp[(2) - (5)].lv);
3459 while (v->next!=NULL)
3460 {
3461 v=v->next;
3462 }
3463 v->next = (leftv)omAllocBin(sleftv_bin);
3464 memcpy(v->next,&((yyvsp[(4) - (5)].lv)),sizeof(sleftv));
3465 (yyval.lv) = (yyvsp[(2) - (5)].lv);
3466 ;}
3467 break;
3468
3469 case 116:
3470
3471/* Line 1464 of yacc.c */
3472#line 1010 "grammar.y"
3473 {
3474 // let rInit take care of any errors
3475 (yyval.i)=rOrderName((yyvsp[(1) - (1)].name));
3476 ;}
3477 break;
3478
3479 case 117:
3480
3481/* Line 1464 of yacc.c */
3482#line 1018 "grammar.y"
3483 {
3484 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3485 intvec *iv = new intvec(2);
3486 (*iv)[0] = 1;
3487 (*iv)[1] = (yyvsp[(1) - (1)].i);
3488 (yyval.lv).rtyp = INTVEC_CMD;
3489 (yyval.lv).data = (void *)iv;
3490 ;}
3491 break;
3492
3493 case 118:
3494
3495/* Line 1464 of yacc.c */
3496#line 1027 "grammar.y"
3497 {
3498 memset(&(yyval.lv),0,sizeof((yyval.lv)));
3499 leftv sl = &(yyvsp[(3) - (4)].lv);
3500 int slLength;
3501 {
3502 slLength = exprlist_length(sl);
3503 int l = 2 + slLength;
3504 intvec *iv = new intvec(l);
3505 (*iv)[0] = slLength;
3506 (*iv)[1] = (yyvsp[(1) - (4)].i);
3507
3508 int i = 2;
3509 while ((i<l) && (sl!=NULL))
3510 {
3511 if (sl->Typ() == INT_CMD)
3512 {
3513 (*iv)[i++] = (int)((long)(sl->Data()));
3514 }
3515 else if ((sl->Typ() == INTVEC_CMD)
3516 ||(sl->Typ() == INTMAT_CMD))
3517 {
3518 intvec *ivv = (intvec *)(sl->Data());
3519 int ll = 0,l = ivv->length();
3520 for (; l>0; l--)
3521 {
3522 (*iv)[i++] = (*ivv)[ll++];
3523 }
3524 }
3525 else
3526 {
3527 delete iv;
3528 (yyvsp[(3) - (4)].lv).CleanUp();
3529 MYYERROR("wrong type in ordering");
3530 }
3531 sl = sl->next;
3532 }
3533 (yyval.lv).rtyp = INTVEC_CMD;
3534 (yyval.lv).data = (void *)iv;
3535 }
3536 (yyvsp[(3) - (4)].lv).CleanUp();
3537 ;}
3538 break;
3539
3540 case 120:
3541
3542/* Line 1464 of yacc.c */
3543#line 1073 "grammar.y"
3544 {
3545 (yyval.lv) = (yyvsp[(1) - (3)].lv);
3546 (yyval.lv).next = (sleftv *)omAllocBin(sleftv_bin);
3547 memcpy((yyval.lv).next,&(yyvsp[(3) - (3)].lv),sizeof(sleftv));
3548 ;}
3549 break;
3550
3551 case 122:
3552
3553/* Line 1464 of yacc.c */
3554#line 1083 "grammar.y"
3555 {
3556 (yyval.lv) = (yyvsp[(2) - (3)].lv);
3557 ;}
3558 break;
3559
3560 case 123:
3561
3562/* Line 1464 of yacc.c */
3563#line 1089 "grammar.y"
3564 {
3565 expected_parms = TRUE;
3566 ;}
3567 break;
3568
3569 case 128:
3570
3571/* Line 1464 of yacc.c */
3572#line 1107 "grammar.y"
3573 { newFile((yyvsp[(2) - (2)].name)); omFree((yyvsp[(2) - (2)].name)); ;}
3574 break;
3575
3576 case 129:
3577
3578/* Line 1464 of yacc.c */
3579#line 1112 "grammar.y"
3580 {
3581 feHelp((yyvsp[(2) - (3)].name));
3582 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3583 ;}
3584 break;
3585
3586 case 130:
3587
3588/* Line 1464 of yacc.c */
3589#line 1117 "grammar.y"
3590 {
3591 feHelp(NULL);
3592 ;}
3593 break;
3594
3595 case 131:
3596
3597/* Line 1464 of yacc.c */
3598#line 1124 "grammar.y"
3599 {
3600 singular_example((yyvsp[(2) - (3)].name));
3601 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
3602 ;}
3603 break;
3604
3605 case 132:
3606
3607/* Line 1464 of yacc.c */
3608#line 1132 "grammar.y"
3609 {
3610 if (basePack!=(yyvsp[(2) - (2)].lv).req_packhdl)
3611 {
3612 if(iiExport(&(yyvsp[(2) - (2)].lv),0,currPack)) YYERROR;
3613 }
3614 else
3615 if (iiExport(&(yyvsp[(2) - (2)].lv),0)) YYERROR;
3616 ;}
3617 break;
3618
3619 case 133:
3620
3621/* Line 1464 of yacc.c */
3622#line 1144 "grammar.y"
3623 {
3624 leftv v=&(yyvsp[(2) - (2)].lv);
3625 if (v->rtyp!=IDHDL)
3626 {
3627 if (v->name!=NULL)
3628 {
3629 Werror("`%s` is undefined in kill",v->name);
3630 omFree((ADDRESS)v->name); v->name=NULL;
3631 }
3632 else WerrorS("kill what ?");
3633 }
3634 else
3635 {
3636 killhdl((idhdl)v->data,v->req_packhdl);
3637 }
3638 ;}
3639 break;
3640
3641 case 134:
3642
3643/* Line 1464 of yacc.c */
3644#line 1161 "grammar.y"
3645 {
3646 leftv v=&(yyvsp[(3) - (3)].lv);
3647 if (v->rtyp!=IDHDL)
3648 {
3649 if (v->name!=NULL)
3650 {
3651 Werror("`%s` is undefined in kill",v->name);
3652 omFree((ADDRESS)v->name); v->name=NULL;
3653 }
3654 else WerrorS("kill what ?");
3655 }
3656 else
3657 {
3658 killhdl((idhdl)v->data,v->req_packhdl);
3659 }
3660 ;}
3661 break;
3662
3663 case 135:
3664
3665/* Line 1464 of yacc.c */
3666#line 1181 "grammar.y"
3667 {
3668 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3669 ;}
3670 break;
3671
3672 case 136:
3673
3674/* Line 1464 of yacc.c */
3675#line 1185 "grammar.y"
3676 {
3677 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3678 ;}
3679 break;
3680
3681 case 137:
3682
3683/* Line 1464 of yacc.c */
3684#line 1189 "grammar.y"
3685 {
3686 if ((yyvsp[(3) - (4)].i)==QRING_CMD) (yyvsp[(3) - (4)].i)=RING_CMD;
3687 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3688 ;}
3689 break;
3690
3691 case 138:
3692
3693/* Line 1464 of yacc.c */
3694#line 1194 "grammar.y"
3695 {
3696 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3697 ;}
3698 break;
3699
3700 case 139:
3701
3702/* Line 1464 of yacc.c */
3703#line 1198 "grammar.y"
3704 {
3705 list_cmd(RING_CMD,NULL,"// ",TRUE);
3706 ;}
3707 break;
3708
3709 case 140:
3710
3711/* Line 1464 of yacc.c */
3712#line 1202 "grammar.y"
3713 {
3714 list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
3715 ;}
3716 break;
3717
3718 case 141:
3719
3720/* Line 1464 of yacc.c */
3721#line 1206 "grammar.y"
3722 {
3723 list_cmd(PROC_CMD,NULL,"// ",TRUE);
3724 ;}
3725 break;
3726
3727 case 142:
3728
3729/* Line 1464 of yacc.c */
3730#line 1210 "grammar.y"
3731 {
3732 list_cmd(0,(yyvsp[(3) - (4)].lv).Fullname(),"// ",TRUE);
3733 (yyvsp[(3) - (4)].lv).CleanUp();
3734 ;}
3735 break;
3736
3737 case 143:
3738
3739/* Line 1464 of yacc.c */
3740#line 1215 "grammar.y"
3741 {
3742 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3743 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3744 (yyvsp[(3) - (6)].lv).CleanUp();
3745 ;}
3746 break;
3747
3748 case 144:
3749
3750/* Line 1464 of yacc.c */
3751#line 1221 "grammar.y"
3752 {
3753 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3754 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3755 (yyvsp[(3) - (6)].lv).CleanUp();
3756 ;}
3757 break;
3758
3759 case 145:
3760
3761/* Line 1464 of yacc.c */
3762#line 1227 "grammar.y"
3763 {
3764 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3765 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3766 (yyvsp[(3) - (6)].lv).CleanUp();
3767 ;}
3768 break;
3769
3770 case 146:
3771
3772/* Line 1464 of yacc.c */
3773#line 1233 "grammar.y"
3774 {
3775 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3776 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3777 (yyvsp[(3) - (6)].lv).CleanUp();
3778 ;}
3779 break;
3780
3781 case 147:
3782
3783/* Line 1464 of yacc.c */
3784#line 1239 "grammar.y"
3785 {
3786 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3787 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3788 (yyvsp[(3) - (6)].lv).CleanUp();
3789 ;}
3790 break;
3791
3792 case 148:
3793
3794/* Line 1464 of yacc.c */
3795#line 1245 "grammar.y"
3796 {
3797 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3798 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3799 (yyvsp[(3) - (6)].lv).CleanUp();
3800 ;}
3801 break;
3802
3803 case 149:
3804
3805/* Line 1464 of yacc.c */
3806#line 1251 "grammar.y"
3807 {
3808 if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
3809 list_cmd((yyvsp[(5) - (6)].i),NULL,"// ",TRUE);
3810 (yyvsp[(3) - (6)].lv).CleanUp();
3811 ;}
3812 break;
3813
3814 case 150:
3815
3816/* Line 1464 of yacc.c */
3817#line 1263 "grammar.y"
3818 {
3819 list_cmd(-1,NULL,"// ",TRUE);
3820 ;}
3821 break;
3822
3823 case 151:
3824
3825/* Line 1464 of yacc.c */
3826#line 1269 "grammar.y"
3827 { yyInRingConstruction = TRUE; ;}
3828 break;
3829
3830 case 152:
3831
3832/* Line 1464 of yacc.c */
3833#line 1278 "grammar.y"
3834 {
3835 const char *ring_name = (yyvsp[(2) - (8)].lv).name;
3836 ring b=
3837 rInit(&(yyvsp[(4) - (8)].lv), /* characteristik and list of parameters*/
3838 &(yyvsp[(6) - (8)].lv), /* names of ringvariables */
3839 &(yyvsp[(8) - (8)].lv)); /* ordering */
3840 idhdl newRingHdl=NULL;
3841
3842 if (b!=NULL)
3843 {
3844 newRingHdl=enterid(ring_name, myynest, RING_CMD,
3845 &((yyvsp[(2) - (8)].lv).req_packhdl->idroot),FALSE);
3846 (yyvsp[(2) - (8)].lv).CleanUp();
3847 if (newRingHdl!=NULL)
3848 {
3849 IDRING(newRingHdl)=b;
3850 }
3851 else
3852 {
3853 rKill(b);
3854 }
3855 }
3856 yyInRingConstruction = FALSE;
3857 if (newRingHdl==NULL)
3858 {
3859 MYYERROR("cannot make ring");
3860 }
3861 else
3862 {
3863 rSetHdl(newRingHdl);
3864 }
3865 ;}
3866 break;
3867
3868 case 153:
3869
3870/* Line 1464 of yacc.c */
3871#line 1311 "grammar.y"
3872 {
3873 const char *ring_name = (yyvsp[(2) - (2)].lv).name;
3874 if (!inerror) rDefault(ring_name);
3875 yyInRingConstruction = FALSE;
3876 (yyvsp[(2) - (2)].lv).CleanUp();
3877 ;}
3878 break;
3879
3880 case 154:
3881
3882/* Line 1464 of yacc.c */
3883#line 1318 "grammar.y"
3884 {
3885 yyInRingConstruction = FALSE;
3886 if (iiAssignCR(&(yyvsp[(2) - (4)].lv),&(yyvsp[(4) - (4)].lv))) YYERROR;
3887 ;}
3888 break;
3889
3890 case 155:
3891
3892/* Line 1464 of yacc.c */
3893#line 1323 "grammar.y"
3894 {
3895 yyInRingConstruction = FALSE;
3896 sleftv tmp;
3897 (yyvsp[(4) - (7)].lv).next=(leftv)omAlloc(sizeof(sleftv));
3898 memcpy((yyvsp[(4) - (7)].lv).next,&(yyvsp[(6) - (7)].lv),sizeof(sleftv));
3899 memset(&(yyvsp[(6) - (7)].lv),0,sizeof(sleftv));
3900 if (iiExprArithM(&tmp,&(yyvsp[(4) - (7)].lv),'[')) YYERROR;
3901 if (iiAssignCR(&(yyvsp[(2) - (7)].lv),&tmp)) YYERROR;
3902 ;}
3903 break;
3904
3905 case 156:
3906
3907/* Line 1464 of yacc.c */
3908#line 1336 "grammar.y"
3909 {
3910 if (((yyvsp[(1) - (2)].i)!=LIB_CMD)||(jjLOAD((yyvsp[(2) - (2)].name),TRUE))) YYERROR;
3911 omFree((yyvsp[(2) - (2)].name));
3912 ;}
3913 break;
3914
3915 case 159:
3916
3917/* Line 1464 of yacc.c */
3918#line 1346 "grammar.y"
3919 {
3920 if (((yyvsp[(1) - (2)].i)==KEEPRING_CMD) && (myynest==0))
3921 MYYERROR("only inside a proc allowed");
3922 const char * n=(yyvsp[(2) - (2)].lv).Name();
3923 if (((yyvsp[(2) - (2)].lv).Typ()==RING_CMD)
3924 && ((yyvsp[(2) - (2)].lv).rtyp==IDHDL))
3925 {
3926 idhdl h=(idhdl)(yyvsp[(2) - (2)].lv).data;
3927 if ((yyvsp[(2) - (2)].lv).e!=NULL) h=rFindHdl((ring)(yyvsp[(2) - (2)].lv).Data(),NULL);
3928 //Print("setring %s lev %d (ptr:%x)\n",IDID(h),IDLEV(h),IDRING(h));
3929 if ((yyvsp[(1) - (2)].i)==KEEPRING_CMD)
3930 {
3931 if (h!=NULL)
3932 {
3933 if (IDLEV(h)!=0)
3934 {
3935 if (iiExport(&(yyvsp[(2) - (2)].lv),myynest-1)) YYERROR;
3936#if 1
3937 idhdl p=IDRING(h)->idroot;
3938 idhdl root=p;
3939 int prevlev=myynest-1;
3940 while (p!=NULL)
3941 {
3942 if (IDLEV(p)==myynest)
3943 {
3944 idhdl old=root->get(IDID(p),prevlev);
3945 if (old!=NULL)
3946 {
3947 if (BVERBOSE(V_REDEFINE))
3948 Warn("redefining %s",IDID(p));
3949 killhdl2(old,&root,IDRING(h));
3950 IDRING(h)->idroot=root;
3951 }
3952 IDLEV(p)=prevlev;
3953 }
3954 p=IDNEXT(p);
3955 }
3956#endif
3957 }
3958 iiLocalRing[myynest-1]=IDRING(h);
3959 }
3960 else
3961 {
3962 Werror("%s is no identifier",n);
3963 (yyvsp[(2) - (2)].lv).CleanUp();
3964 YYERROR;
3965 }
3966 }
3967 if (h!=NULL) rSetHdl(h);
3968 else
3969 {
3970 Werror("cannot find the name of the basering %s",n);
3971 (yyvsp[(2) - (2)].lv).CleanUp();
3972 YYERROR;
3973 }
3974 (yyvsp[(2) - (2)].lv).CleanUp();
3975 }
3976 else
3977 {
3978 Werror("%s is no name of a ring/qring",n);
3979 (yyvsp[(2) - (2)].lv).CleanUp();
3980 YYERROR;
3981 }
3982 ;}
3983 break;
3984
3985 case 160:
3986
3987/* Line 1464 of yacc.c */
3988#line 1414 "grammar.y"
3989 {
3990 type_cmd(&((yyvsp[(2) - (2)].lv)));
3991 ;}
3992 break;
3993
3994 case 161:
3995
3996/* Line 1464 of yacc.c */
3997#line 1418 "grammar.y"
3998 {
3999 //Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
4000 #ifdef SIQ
4001 if ((yyvsp[(1) - (1)].lv).rtyp!=COMMAND)
4002 {
4003 #endif
4004 if ((yyvsp[(1) - (1)].lv).Typ()==UNKNOWN)
4005 {
4006 if ((yyvsp[(1) - (1)].lv).name!=NULL)
4007 {
4008 Werror("`%s` is undefined",(yyvsp[(1) - (1)].lv).name);
4009 omFree((ADDRESS)(yyvsp[(1) - (1)].lv).name);
4010 }
4011 YYERROR;
4012 }
4013 #ifdef SIQ
4014 }
4015 #endif
4016 (yyvsp[(1) - (1)].lv).Print(&sLastPrinted);
4017 (yyvsp[(1) - (1)].lv).CleanUp(currRing);
4018 if (errorreported) YYERROR;
4019 ;}
4020 break;
4021
4022 case 162:
4023
4024/* Line 1464 of yacc.c */
4025#line 1447 "grammar.y"
4026 {
4027 int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4028 if (i!=0)
4029 {
4030 newBuffer( (yyvsp[(5) - (5)].name), BT_if);
4031 }
4032 else
4033 {
4034 omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4035 currentVoice->ifsw=1;
4036 }
4037 ;}
4038 break;
4039
4040 case 163:
4041
4042/* Line 1464 of yacc.c */
4043#line 1460 "grammar.y"
4044 {
4045 if (currentVoice->ifsw==1)
4046 {
4047 currentVoice->ifsw=0;
4048 newBuffer( (yyvsp[(2) - (2)].name), BT_else);
4049 }
4050 else
4051 {
4052 if (currentVoice->ifsw!=2)
4053 {
4054 Warn("`else` without `if` in level %d",myynest);
4055 }
4056 omFree((ADDRESS)(yyvsp[(2) - (2)].name));
4057 }
4058 currentVoice->ifsw=0;
4059 ;}
4060 break;
4061
4062 case 164:
4063
4064/* Line 1464 of yacc.c */
4065#line 1477 "grammar.y"
4066 {
4067 int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
4068 if (i)
4069 {
4070 if (exitBuffer(BT_break)) YYERROR;
4071 }
4072 currentVoice->ifsw=0;
4073 ;}
4074 break;
4075
4076 case 165:
4077
4078/* Line 1464 of yacc.c */
4079#line 1486 "grammar.y"
4080 {
4081 if (exitBuffer(BT_break)) YYERROR;
4082 currentVoice->ifsw=0;
4083 ;}
4084 break;
4085
4086 case 166:
4087
4088/* Line 1464 of yacc.c */
4089#line 1491 "grammar.y"
4090 {
4091 if (contBuffer(BT_break)) YYERROR;
4092 currentVoice->ifsw=0;
4093 ;}
4094 break;
4095
4096 case 167:
4097
4098/* Line 1464 of yacc.c */
4099#line 1499 "grammar.y"
4100 {
4101 /* -> if(!$2) break; $3; continue;*/
4102 size_t len= strlen((yyvsp[(2) - (3)].name)) + strlen((yyvsp[(3) - (3)].name)) + 36;
4103 char * s = (char *)omAlloc( len);
4104 snprintf(s,len,"whileif (!(%s)) break;\n%scontinue;\n " ,(yyvsp[(2) - (3)].name),(yyvsp[(3) - (3)].name));
4105 newBuffer(s,BT_break);
4106 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4107 omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4108 ;}
4109 break;
4110
4111 case 168:
4112
4113/* Line 1464 of yacc.c */
4114#line 1512 "grammar.y"
4115 {
4116 /* $2 */
4117 /* if (!$3) break; $5; $4; continue; */
4118 size_t len= strlen((yyvsp[(3) - (5)].name))+strlen((yyvsp[(4) - (5)].name))+strlen((yyvsp[(5) - (5)].name))+36;
4119 char *s=(char*)omAlloc(len);
4120 snprintf(s,len,"forif (!(%s)) break;\n%s%s;\ncontinue;\n "
4121 ,(yyvsp[(3) - (5)].name),(yyvsp[(5) - (5)].name),(yyvsp[(4) - (5)].name));
4122 omFree((ADDRESS)(yyvsp[(3) - (5)].name));
4123 omFree((ADDRESS)(yyvsp[(4) - (5)].name));
4124 omFree((ADDRESS)(yyvsp[(5) - (5)].name));
4125 newBuffer(s,BT_break);
4126 len=strlen((yyvsp[(2) - (5)].name)) + 3;
4127 s = (char *)omAlloc( len);
4128 snprintf(s,len,"%s;\n",(yyvsp[(2) - (5)].name));
4129 omFree((ADDRESS)(yyvsp[(2) - (5)].name));
4130 newBuffer(s,BT_if);
4131 ;}
4132 break;
4133
4134 case 169:
4135
4136/* Line 1464 of yacc.c */
4137#line 1533 "grammar.y"
4138 {
4139 idhdl h = enterid((yyvsp[(2) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4140 if (h==NULL) {omFree((ADDRESS)(yyvsp[(2) - (3)].name));omFree((ADDRESS)(yyvsp[(3) - (3)].name)); YYERROR;}
4141 iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(2) - (3)].name), 0, 0);
4142 IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+31);;
4143 sprintf(IDPROC(h)->data.s.body,"parameter list #;\n%s;return();\n\n",(yyvsp[(3) - (3)].name));
4144 omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4145 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4146 ;}
4147 break;
4148
4149 case 170:
4150
4151/* Line 1464 of yacc.c */
4152#line 1543 "grammar.y"
4153 {
4154 idhdl h = enterid((yyvsp[(1) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4155 if (h==NULL)
4156 {
4157 omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4158 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4159 omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4160 YYERROR;
4161 }
4162 char *args=iiProcArgs((yyvsp[(2) - (3)].name),FALSE);
4163 omFree((ADDRESS)(yyvsp[(2) - (3)].name));
4164 iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (3)].name), 0, 0);
4165 IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(3) - (3)].name))+strlen(args)+14);;
4166 sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(3) - (3)].name));
4167 omFree((ADDRESS)args);
4168 omFree((ADDRESS)(yyvsp[(3) - (3)].name));
4169 omFree((ADDRESS)(yyvsp[(1) - (3)].name));
4170 ;}
4171 break;
4172
4173 case 171:
4174
4175/* Line 1464 of yacc.c */
4176#line 1562 "grammar.y"
4177 {
4178 omFree((ADDRESS)(yyvsp[(3) - (4)].name));
4179 idhdl h = enterid((yyvsp[(1) - (4)].name),myynest,PROC_CMD,&IDROOT,TRUE);
4180 if (h==NULL)
4181 {
4182 omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4183 omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4184 omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4185 YYERROR;
4186 }
4187 char *args=iiProcArgs((yyvsp[(2) - (4)].name),FALSE);
4188 omFree((ADDRESS)(yyvsp[(2) - (4)].name));
4189 iiInitSingularProcinfo(IDPROC(h),"", (yyvsp[(1) - (4)].name), 0, 0);
4190 omFree((ADDRESS)(yyvsp[(1) - (4)].name));
4191 IDPROC(h)->data.s.body = (char *)omAlloc(strlen((yyvsp[(4) - (4)].name))+strlen(args)+14);;
4192 sprintf(IDPROC(h)->data.s.body,"%s\n%s;return();\n\n",args,(yyvsp[(4) - (4)].name));
4193 omFree((ADDRESS)args);
4194 omFree((ADDRESS)(yyvsp[(4) - (4)].name));
4195 ;}
4196 break;
4197
4198 case 172:
4199
4200/* Line 1464 of yacc.c */
4201#line 1585 "grammar.y"
4202 {
4203 // decl. of type proc p(int i)
4204 if ((yyvsp[(1) - (2)].i)==PARAMETER) { if (iiParameter(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4205 else { if (iiAlias(&(yyvsp[(2) - (2)].lv))) YYERROR; }
4206 ;}
4207 break;
4208
4209 case 173:
4210
4211/* Line 1464 of yacc.c */
4212#line 1591 "grammar.y"
4213 {
4214 // decl. of type proc p(i)
4215 sleftv tmp_expr;
4216 if ((yyvsp[(1) - (2)].i)==ALIAS_CMD) MYYERROR("alias requires a type");
4217 if ((iiDeclCommand(&tmp_expr,&(yyvsp[(2) - (2)].lv),myynest,DEF_CMD,&IDROOT))
4218 || (iiParameter(&tmp_expr)))
4219 YYERROR;
4220 ;}
4221 break;
4222
4223 case 174:
4224
4225/* Line 1464 of yacc.c */
4226#line 1603 "grammar.y"
4227 {
4228 iiSetReturn(&(yyvsp[(3) - (4)].lv));
4229 (yyvsp[(3) - (4)].lv).CleanUp();
4230 if (exitBuffer(BT_proc)) YYERROR;
4231 ;}
4232 break;
4233
4234 case 175:
4235
4236/* Line 1464 of yacc.c */
4237#line 1609 "grammar.y"
4238 {
4239 if ((yyvsp[(1) - (3)].i)==RETURN)
4240 {
4241 iiRETURNEXPR.Init();
4242 iiRETURNEXPR.rtyp=NONE;
4243 if (exitBuffer(BT_proc)) YYERROR;
4244 }
4245 ;}
4246 break;
4247
4248
4249
4250/* Line 1464 of yacc.c */
4251#line 4252 "grammar.cc"
4252 default: break;
4253 }
4254 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4255
4256 YYPOPSTACK (yylen);
4257 yylen = 0;
4258 YY_STACK_PRINT (yyss, yyssp);
4259
4260 *++yyvsp = yyval;
4261
4262 /* Now `shift' the result of the reduction. Determine what state
4263 that goes to, based on the state we popped back to and the rule
4264 number reduced by. */
4265
4266 yyn = yyr1[yyn];
4267
4268 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4269 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4270 yystate = yytable[yystate];
4271 else
4272 yystate = yydefgoto[yyn - YYNTOKENS];
4273
4274 goto yynewstate;
4275
4276
4277/*------------------------------------.
4278| yyerrlab -- here on detecting error |
4279`------------------------------------*/
4280yyerrlab:
4281 /* If not already recovering from an error, report this error. */
4282 if (!yyerrstatus)
4283 {
4284 ++yynerrs;
4285#if ! YYERROR_VERBOSE
4286 yyerror (YY_("syntax error"));
4287#else
4288 {
4289 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
4290 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
4291 {
4292 YYSIZE_T yyalloc = 2 * yysize;
4293 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
4294 yyalloc = YYSTACK_ALLOC_MAXIMUM;
4295 if (yymsg != yymsgbuf)
4296 YYSTACK_FREE (yymsg);
4297 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
4298 if (yymsg)
4299 yymsg_alloc = yyalloc;
4300 else
4301 {
4302 yymsg = yymsgbuf;
4303 yymsg_alloc = sizeof yymsgbuf;
4304 }
4305 }
4306
4307 if (0 < yysize && yysize <= yymsg_alloc)
4308 {
4309 (void) yysyntax_error (yymsg, yystate, yychar);
4310 yyerror (yymsg);
4311 }
4312 else
4313 {
4314 yyerror (YY_("syntax error"));
4315 if (yysize != 0)
4316 goto yyexhaustedlab;
4317 }
4318 }
4319#endif
4320 }
4321
4322
4323
4324 if (yyerrstatus == 3)
4325 {
4326 /* If just tried and failed to reuse lookahead token after an
4327 error, discard it. */
4328
4329 if (yychar <= YYEOF)
4330 {
4331 /* Return failure if at end of input. */
4332 if (yychar == YYEOF)
4333 YYABORT;
4334 }
4335 else
4336 {
4337 yydestruct ("Error: discarding",
4338 yytoken, &yylval);
4339 yychar = YYEMPTY;
4340 }
4341 }
4342
4343 /* Else will try to reuse lookahead token after shifting the error
4344 token. */
4345 goto yyerrlab1;
4346
4347
4348/*---------------------------------------------------.
4349| yyerrorlab -- error raised explicitly by YYERROR. |
4350`---------------------------------------------------*/
4351yyerrorlab:
4352
4353 /* Pacify compilers like GCC when the user code never invokes
4354 YYERROR and the label yyerrorlab therefore never appears in user
4355 code. */
4356 if (/*CONSTCOND*/ 0)
4357 goto yyerrorlab;
4358
4359 /* Do not reclaim the symbols of the rule which action triggered
4360 this YYERROR. */
4361 YYPOPSTACK (yylen);
4362 yylen = 0;
4363 YY_STACK_PRINT (yyss, yyssp);
4364 yystate = *yyssp;
4365 goto yyerrlab1;
4366
4367
4368/*-------------------------------------------------------------.
4369| yyerrlab1 -- common code for both syntax error and YYERROR. |
4370`-------------------------------------------------------------*/
4371yyerrlab1:
4372 yyerrstatus = 3; /* Each real token shifted decrements this. */
4373
4374 for (;;)
4375 {
4376 yyn = yypact[yystate];
4377 if (yyn != YYPACT_NINF)
4378 {
4379 yyn += YYTERROR;
4380 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4381 {
4382 yyn = yytable[yyn];
4383 if (0 < yyn)
4384 break;
4385 }
4386 }
4387
4388 /* Pop the current state because it cannot handle the error token. */
4389 if (yyssp == yyss)
4390 YYABORT;
4391
4392
4393 yydestruct ("Error: popping",
4394 yystos[yystate], yyvsp);
4395 YYPOPSTACK (1);
4396 yystate = *yyssp;
4397 YY_STACK_PRINT (yyss, yyssp);
4398 }
4399
4400 *++yyvsp = yylval;
4401
4402
4403 /* Shift the error token. */
4404 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4405
4406 yystate = yyn;
4407 goto yynewstate;
4408
4409
4410/*-------------------------------------.
4411| yyacceptlab -- YYACCEPT comes here. |
4412`-------------------------------------*/
4413yyacceptlab:
4414 yyresult = 0;
4415 goto yyreturn;
4416
4417/*-----------------------------------.
4418| yyabortlab -- YYABORT comes here. |
4419`-----------------------------------*/
4420yyabortlab:
4421 yyresult = 1;
4422 goto yyreturn;
4423
4424#if !defined(yyoverflow) || YYERROR_VERBOSE
4425/*-------------------------------------------------.
4426| yyexhaustedlab -- memory exhaustion comes here. |
4427`-------------------------------------------------*/
4428yyexhaustedlab:
4429 yyerror (YY_("memory exhausted"));
4430 yyresult = 2;
4431 /* Fall through. */
4432#endif
4433
4434yyreturn:
4435 if (yychar != YYEMPTY)
4436 yydestruct ("Cleanup: discarding lookahead",
4437 yytoken, &yylval);
4438 /* Do not reclaim the symbols of the rule which action triggered
4439 this YYABORT or YYACCEPT. */
4440 YYPOPSTACK (yylen);
4441 YY_STACK_PRINT (yyss, yyssp);
4442 while (yyssp != yyss)
4443 {
4444 yydestruct ("Cleanup: popping",
4445 yystos[*yyssp], yyvsp);
4446 YYPOPSTACK (1);
4447 }
4448#ifndef yyoverflow
4449 if (yyss != yyssa)
4450 YYSTACK_FREE (yyss);
4451#endif
4452#if YYERROR_VERBOSE
4453 if (yymsg != yymsgbuf)
4454 YYSTACK_FREE (yymsg);
4455#endif
4456 /* Make sure YYID is used. */
4457 return YYID (yyresult);
4458}
4459
4460
4461
BOOLEAN
int BOOLEAN
Definition auxiliary.h:88
TRUE
#define TRUE
Definition auxiliary.h:101
FALSE
#define FALSE
Definition auxiliary.h:97
ADDRESS
void * ADDRESS
Definition auxiliary.h:120
l
int l
Definition cfEzgcd.cc:100
i
int i
Definition cfEzgcd.cc:132
p
int p
Definition cfModGcd.cc:4086
b
CanonicalForm b
Definition cfModGcd.cc:4111
Variable::name
char name() const
Definition variable.cc:122
Variable::next
Variable next() const
Definition factory.h:146
Voice::Typ
feBufferTypes Typ()
Definition fevoices.cc:111
Voice::ifsw
char ifsw
Definition fevoices.h:80
Voice::pi
procinfo * pi
Definition fevoices.h:64
Voice::prev
Voice * prev
Definition fevoices.h:62
bigintmat
Matrices of numbers.
Definition bigintmat.h:51
idrec
Definition idrec.h:35
idrec::get
idhdl get(const char *s, int lev)
Definition ipid.cc:63
idrec::next
idhdl next
Definition idrec.h:38
idrec::id
const char * id
Definition idrec.h:39
intvec::length
int length() const
Definition intvec.h:95
sleftv
Class used for (list of) interpreter objects.
Definition subexpr.h:83
sleftv::CopyD
void * CopyD(int t)
Definition subexpr.cc:714
sleftv::Typ
int Typ()
Definition subexpr.cc:1048
sleftv::rtyp
int rtyp
Definition subexpr.h:91
sleftv::Data
void * Data()
Definition subexpr.cc:1192
sleftv::Init
void Init()
Definition subexpr.h:107
sleftv::next
leftv next
Definition subexpr.h:86
sleftv::CleanUp
void CleanUp(ring r=currRing)
Definition subexpr.cc:351
n_Read
static FORCE_INLINE const char * n_Read(const char *s, number *a, const coeffs r)
!!! Recommendation: This method is too cryptic to be part of the user- !!! interface....
Definition coeffs.h:599
Print
#define Print
Definition emacs.cc:80
Warn
#define Warn
Definition emacs.cc:77
s
const CanonicalForm int s
Definition facAbsFact.cc:51
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
found
bool found
Definition facFactorize.cc:55
j
int j
Definition facHensel.cc:110
errorreported
VAR short errorreported
Definition feFopen.cc:23
WerrorS
void WerrorS(const char *s)
Definition feFopen.cc:24
my_yylinebuf
VAR char my_yylinebuf[80]
Definition febase.cc:44
myynest
VAR int myynest
Definition febase.cc:41
feHelp
void feHelp(char *str)
Definition fehelp.cc:90
prompt_char
EXTERN_VAR char prompt_char
Definition feread.h:10
exitBuffer
BOOLEAN exitBuffer(feBufferTypes typ)
Definition fevoices.cc:236
newBuffer
void newBuffer(char *s, feBufferTypes t, procinfo *pi, int lineno)
Definition fevoices.cc:166
contBuffer
BOOLEAN contBuffer(feBufferTypes typ)
Definition fevoices.cc:304
currentVoice
VAR Voice * currentVoice
Definition fevoices.cc:49
VoiceName
const char * VoiceName()
Definition fevoices.cc:58
newFile
BOOLEAN newFile(char *fname)
Definition fevoices.cc:129
VoiceLine
int VoiceLine()
Definition fevoices.cc:66
exitVoice
BOOLEAN exitVoice()
Definition fevoices.cc:341
feBufferTypes
feBufferTypes
Definition fevoices.h:17
BT_else
@ BT_else
Definition fevoices.h:25
BT_if
@ BT_if
Definition fevoices.h:24
BT_break
@ BT_break
Definition fevoices.h:19
BT_example
@ BT_example
Definition fevoices.h:21
BT_proc
@ BT_proc
Definition fevoices.h:20
iiTestConvert
int iiTestConvert(int inputType, int outputType)
Definition gentable.cc:298
iiTwoOps
const char * iiTwoOps(int t)
Definition gentable.cc:258
Tok2Cmdname
const char * Tok2Cmdname(int tok)
Definition gentable.cc:137
yytype_uint16
unsigned short int yytype_uint16
Definition grammar.cc:393
YYID
#define YYID(n)
Definition grammar.cc:439
yyr1
static const yytype_uint8 yyr1[]
Definition grammar.cc:821
YYLEX
#define YYLEX
Definition grammar.cc:1685
YYMAXDEPTH
#define YYMAXDEPTH
Definition grammar.cc:166
yytokentype
yytokentype
Definition grammar.cc:266
CMD_1
@ CMD_1
Definition grammar.cc:312
PLUSPLUS
@ PLUSPLUS
Definition grammar.cc:274
NOT
@ NOT
Definition grammar.cc:272
KILL_CMD
@ KILL_CMD
Definition grammar.cc:327
END_RING
@ END_RING
Definition grammar.cc:311
MINUSMINUS
@ MINUSMINUS
Definition grammar.cc:271
IDEAL_CMD
@ IDEAL_CMD
Definition grammar.cc:285
UMINUS
@ UMINUS
Definition grammar.cc:352
PARAMETER
@ PARAMETER
Definition grammar.cc:350
PAR_CMD
@ PAR_CMD
Definition grammar.cc:303
PREIMAGE_CMD
@ PREIMAGE_CMD
Definition grammar.cc:304
CMD_23
@ CMD_23
Definition grammar.cc:317
EXAMPLE_CMD
@ EXAMPLE_CMD
Definition grammar.cc:324
VALTVARS
@ VALTVARS
Definition grammar.cc:306
CMD_2
@ CMD_2
Definition grammar.cc:313
MATRIX_CMD
@ MATRIX_CMD
Definition grammar.cc:287
KEEPRING_CMD
@ KEEPRING_CMD
Definition grammar.cc:298
RING_DECL
@ RING_DECL
Definition grammar.cc:322
TYPE_CMD
@ TYPE_CMD
Definition grammar.cc:331
BUCKET_CMD
@ BUCKET_CMD
Definition grammar.cc:284
RING_DECL_LIST
@ RING_DECL_LIST
Definition grammar.cc:323
BIGINTMAT_CMD
@ BIGINTMAT_CMD
Definition grammar.cc:278
KOSZUL_CMD
@ KOSZUL_CMD
Definition grammar.cc:300
SYS_BREAK
@ SYS_BREAK
Definition grammar.cc:347
SETRING_CMD
@ SETRING_CMD
Definition grammar.cc:330
RETURN
@ RETURN
Definition grammar.cc:349
IMAP_CMD
@ IMAP_CMD
Definition grammar.cc:299
ARROW
@ ARROW
Definition grammar.cc:276
GE
@ GE
Definition grammar.cc:269
EQUAL_EQUAL
@ EQUAL_EQUAL
Definition grammar.cc:268
CMD_3
@ CMD_3
Definition grammar.cc:314
SYSVAR
@ SYSVAR
Definition grammar.cc:351
ROOT_DECL
@ ROOT_DECL
Definition grammar.cc:320
APPLY
@ APPLY
Definition grammar.cc:338
MAP_CMD
@ MAP_CMD
Definition grammar.cc:286
EVAL
@ EVAL
Definition grammar.cc:343
INT_CONST
@ INT_CONST
Definition grammar.cc:334
PROC_CMD
@ PROC_CMD
Definition grammar.cc:281
BLOCKTOK
@ BLOCKTOK
Definition grammar.cc:333
LE
@ LE
Definition grammar.cc:270
BEGIN_RING
@ BEGIN_RING
Definition grammar.cc:283
INTMAT_CMD
@ INTMAT_CMD
Definition grammar.cc:280
MONOM
@ MONOM
Definition grammar.cc:336
LISTVAR_CMD
@ LISTVAR_CMD
Definition grammar.cc:329
UNKNOWN_IDENT
@ UNKNOWN_IDENT
Definition grammar.cc:335
LIB_CMD
@ LIB_CMD
Definition grammar.cc:328
ROOT_DECL_LIST
@ ROOT_DECL_LIST
Definition grammar.cc:321
BREAK_CMD
@ BREAK_CMD
Definition grammar.cc:340
ELSE_CMD
@ ELSE_CMD
Definition grammar.cc:342
VMAXMULT
@ VMAXMULT
Definition grammar.cc:308
MODUL_CMD
@ MODUL_CMD
Definition grammar.cc:288
CMD_123
@ CMD_123
Definition grammar.cc:318
ASSUME_CMD
@ ASSUME_CMD
Definition grammar.cc:339
IF_CMD
@ IF_CMD
Definition grammar.cc:346
MONOM_CMD
@ MONOM_CMD
Definition grammar.cc:302
VMAXDEG
@ VMAXDEG
Definition grammar.cc:307
SMATRIX_CMD
@ SMATRIX_CMD
Definition grammar.cc:292
FOR_CMD
@ FOR_CMD
Definition grammar.cc:345
VECTOR_CMD
@ VECTOR_CMD
Definition grammar.cc:293
RESOLUTION_CMD
@ RESOLUTION_CMD
Definition grammar.cc:291
NOTEQUAL
@ NOTEQUAL
Definition grammar.cc:273
CMD_12
@ CMD_12
Definition grammar.cc:315
CONTINUE_CMD
@ CONTINUE_CMD
Definition grammar.cc:341
VAR_CMD
@ VAR_CMD
Definition grammar.cc:305
STRINGTOK
@ STRINGTOK
Definition grammar.cc:332
BIGINTVEC_CMD
@ BIGINTVEC_CMD
Definition grammar.cc:279
DOTDOT
@ DOTDOT
Definition grammar.cc:267
PROC_DEF
@ PROC_DEF
Definition grammar.cc:337
COLONCOLON
@ COLONCOLON
Definition grammar.cc:275
CMD_13
@ CMD_13
Definition grammar.cc:316
WHILE_CMD
@ WHILE_CMD
Definition grammar.cc:348
HELP_CMD
@ HELP_CMD
Definition grammar.cc:326
NUMBER_CMD
@ NUMBER_CMD
Definition grammar.cc:289
MAXID_CMD
@ MAXID_CMD
Definition grammar.cc:301
POLY_CMD
@ POLY_CMD
Definition grammar.cc:290
VMINPOLY
@ VMINPOLY
Definition grammar.cc:310
CMD_M
@ CMD_M
Definition grammar.cc:319
RING_CMD
@ RING_CMD
Definition grammar.cc:282
QUOTE
@ QUOTE
Definition grammar.cc:344
VNOETHER
@ VNOETHER
Definition grammar.cc:309
E_CMD
@ E_CMD
Definition grammar.cc:295
FETCH_CMD
@ FETCH_CMD
Definition grammar.cc:296
GRING_CMD
@ GRING_CMD
Definition grammar.cc:277
FREEMODULE_CMD
@ FREEMODULE_CMD
Definition grammar.cc:297
EXPORT_CMD
@ EXPORT_CMD
Definition grammar.cc:325
BETTI_CMD
@ BETTI_CMD
Definition grammar.cc:294
YYSTACK_FREE
#define YYSTACK_FREE
Definition grammar.cc:495
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition grammar.cc:1702
cmdtok
int cmdtok
Definition grammar.cc:174
expected_parms
BOOLEAN expected_parms
Definition grammar.cc:173
yyerrok
#define yyerrok
Definition grammar.cc:1589
yy_stack_print
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
Definition grammar.cc:1780
currid
const char * currid
Definition grammar.cc:171
yytranslate
static const yytype_uint8 yytranslate[]
Definition grammar.cc:603
TESTSETINT
#define TESTSETINT(a, i)
Definition grammar.cc:177
YYEOF
#define YYEOF
Definition grammar.cc:1592
YYABORT
#define YYABORT
Definition grammar.cc:1595
yyin
FILE * yyin
Definition libparse.cc:122
yydefgoto
static const yytype_int16 yydefgoto[]
Definition grammar.cc:914
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition grammar.cc:1835
YYTABLE_NINF
#define YYTABLE_NINF
Definition grammar.cc:984
yypact
static const yytype_int16 yypact[]
Definition grammar.cc:926
MYYERROR
#define MYYERROR(a)
Definition grammar.cc:185
yylineno
int yylineno
Definition febase.cc:40
YYPACT_NINF
#define YYPACT_NINF
Definition grammar.cc:925
YYFINAL
#define YYFINAL
Definition grammar.cc:582
yy_reduce_print
static void yy_reduce_print(YYSTYPE *yyvsp, int yyrule)
Definition grammar.cc:1811
yyrline
static const yytype_uint16 yyrline[]
Definition grammar.cc:744
yypgoto
static const yytype_int16 yypgoto[]
Definition grammar.cc:971
yydestruct
static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep)
Definition grammar.cc:2089
YYNTOKENS
#define YYNTOKENS
Definition grammar.cc:587
yy_symbol_value_print
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep)
Definition grammar.cc:1722
yytype_uint8
unsigned char yytype_uint8
Definition grammar.cc:378
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition grammar.cc:1797
YYSIZE_T
#define YYSIZE_T
Definition grammar.cc:410
YYSTACK_ALLOC_MAXIMUM
#define YYSTACK_ALLOC_MAXIMUM
Definition grammar.cc:497
yyparse
int yyparse(void)
Definition grammar.cc:2149
YY_
#define YY_(msgid)
Definition grammar.cc:426
yyerror
void yyerror(const char *fmt)
Definition grammar.cc:187
inerror
int inerror
Definition grammar.cc:175
yyInRingConstruction
BOOLEAN yyInRingConstruction
Definition grammar.cc:172
yy_symbol_print
static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep)
Definition grammar.cc:1754
yytable
static const yytype_int16 yytable[]
Definition grammar.cc:985
yyr2
static const yytype_uint8 yyr2[]
Definition grammar.cc:844
YYACCEPT
#define YYACCEPT
Definition grammar.cc:1594
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition grammar.cc:599
yydebug
int yydebug
Definition grammar.cc:1843
YYSIZE_MAXIMUM
#define YYSIZE_MAXIMUM
Definition grammar.cc:416
yytname
static const char *const yytname[]
Definition grammar.cc:770
yystos
static const yytype_uint8 yystos[]
Definition grammar.cc:1545
YYTERROR
#define YYTERROR
Definition grammar.cc:1634
YYPOPSTACK
#define YYPOPSTACK(N)
YYUSE
#define YYUSE(e)
Definition grammar.cc:432
yytype_int16
short int yytype_int16
Definition grammar.cc:399
yyprhs
static const yytype_uint16 yyprhs[]
Definition grammar.cc:645
YYEMPTY
#define YYEMPTY
Definition grammar.cc:1591
YYLAST
#define YYLAST
Definition grammar.cc:584
YYINITDEPTH
#define YYINITDEPTH
Definition grammar.cc:1854
yytype_int8
signed char yytype_int8
Definition grammar.cc:385
yyrhs
static const yytype_int16 yyrhs[]
Definition grammar.cc:668
YYERROR
#define YYERROR
Definition grammar.cc:1596
YYFPRINTF
#define YYFPRINTF
Definition grammar.cc:1693
yycheck
static const yytype_int16 yycheck[]
Definition grammar.cc:1264
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition grammar.cc:494
YYDPRINTF
#define YYDPRINTF(Args)
Definition grammar.cc:1696
yydefact
static const yytype_uint8 yydefact[]
Definition grammar.cc:869
idDelete
#define idDelete(H)
delete an ideal
Definition ideals.h:29
jjLOAD
BOOLEAN jjLOAD(const char *s, BOOLEAN autoexport)
load lib/module given in v
Definition iparith.cc:5567
iiExprArith2
BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
Definition iparith.cc:9141
iiExprArith1
BOOLEAN iiExprArith1(leftv res, leftv a, int op)
Definition iparith.cc:9330
iiExprArithM
BOOLEAN iiExprArithM(leftv res, leftv a, int op)
Definition iparith.cc:9631
iiExprArith3
BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
Definition iparith.cc:9540
iiAssign
BOOLEAN iiAssign(leftv l, leftv r, BOOLEAN toplevel)
Definition ipassign.cc:2097
iiConvert
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, const struct sConvertTypes *dConvertTypes)
Definition ipconv.cc:450
killid
void killid(const char *id, idhdl *ih)
Definition ipid.cc:364
killhdl2
void killhdl2(idhdl h, idhdl *ih, ring r)
Definition ipid.cc:422
enterid
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
Definition ipid.cc:256
basePack
VAR package basePack
Definition ipid.cc:56
currPack
VAR package currPack
Definition ipid.cc:55
iiAlias
BOOLEAN iiAlias(leftv p)
Definition ipid.cc:821
killhdl
void killhdl(idhdl h, package proot)
Definition ipid.cc:391
basePackHdl
VAR idhdl basePackHdl
Definition ipid.cc:54
IDMATRIX
#define IDMATRIX(a)
Definition ipid.h:134
IDNEXT
#define IDNEXT(a)
Definition ipid.h:118
sleftv_bin
EXTERN_VAR omBin sleftv_bin
Definition ipid.h:145
IDPROC
#define IDPROC(a)
Definition ipid.h:140
IDINTVEC
#define IDINTVEC(a)
Definition ipid.h:128
IDBIMAT
#define IDBIMAT(a)
Definition ipid.h:129
IDIDEAL
#define IDIDEAL(a)
Definition ipid.h:133
IDID
#define IDID(a)
Definition ipid.h:122
IDROOT
#define IDROOT
Definition ipid.h:19
IDPACKAGE
#define IDPACKAGE(a)
Definition ipid.h:139
IDLEV
#define IDLEV(a)
Definition ipid.h:121
IDRING
#define IDRING(a)
Definition ipid.h:127
IDTYP
#define IDTYP(a)
Definition ipid.h:119
iiProcArgs
char * iiProcArgs(char *e, BOOLEAN withParenth)
Definition iplib.cc:114
iiRETURNEXPR
INST_VAR sleftv iiRETURNEXPR
Definition iplib.cc:483
iiLocalRing
VAR ring * iiLocalRing
Definition iplib.cc:482
iiInitSingularProcinfo
procinfo * iiInitSingularProcinfo(procinfov pi, const char *libname, const char *procname, int, long pos, BOOLEAN pstatic)
Definition iplib.cc:1059
iiParameter
BOOLEAN iiParameter(leftv p)
Definition ipshell.cc:1380
iiDeclCommand
int iiDeclCommand(leftv sy, leftv name, int lev, int t, idhdl *root, BOOLEAN isring, BOOLEAN init_b)
Definition ipshell.cc:1202
rKill
void rKill(ring r)
Definition ipshell.cc:6174
iiApply
BOOLEAN iiApply(leftv res, leftv a, int op, leftv proc)
Definition ipshell.cc:6424
list_cmd
void list_cmd(int typ, const char *what, const char *prefix, BOOLEAN iterate, BOOLEAN fullname)
Definition ipshell.cc:426
rInit
ring rInit(leftv pn, leftv rv, leftv ord)
Definition ipshell.cc:5621
iiARROW
BOOLEAN iiARROW(leftv r, char *a, char *s)
Definition ipshell.cc:6473
exprlist_length
int exprlist_length(leftv v)
Definition ipshell.cc:551
iiTestAssume
BOOLEAN iiTestAssume(leftv a, leftv b)
Definition ipshell.cc:6446
iiSetReturn
void iiSetReturn(const leftv source)
Definition ipshell.cc:6627
iiAssignCR
BOOLEAN iiAssignCR(leftv r, leftv arg)
Definition ipshell.cc:6508
rFindHdl
idhdl rFindHdl(ring r, idhdl n)
Definition ipshell.cc:1695
iiDebug
void iiDebug()
Definition ipshell.cc:1069
lastreserved
const char * lastreserved
Definition ipshell.cc:83
type_cmd
void type_cmd(leftv v)
Definition ipshell.cc:255
rSetHdl
void rSetHdl(idhdl h)
Definition ipshell.cc:5122
iiExport
BOOLEAN iiExport(leftv v, int toLev)
Definition ipshell.cc:1506
singular_example
void singular_example(char *str)
Definition misc_ip.cc:431
h
STATIC_VAR Poly * h
Definition janet.cc:971
next
ListNode * next
Definition janet.h:31
mpNew
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition matpol.cc:37
MAX_INT_LEN
const int MAX_INT_LEN
Definition mylimits.h:13
omAlloc
#define omAlloc(size)
Definition omAllocDecl.h:210
omAllocBin
#define omAllocBin(bin)
Definition omAllocDecl.h:205
omFree
#define omFree(addr)
Definition omAllocDecl.h:261
free
#define free
Definition omAllocFunc.c:14
malloc
#define malloc
Definition omAllocFunc.c:12
NULL
#define NULL
Definition omList.c:12
siCntrlc
VAR BOOLEAN siCntrlc
Definition options.c:14
BVERBOSE
#define BVERBOSE(a)
Definition options.h:35
V_REDEFINE
#define V_REDEFINE
Definition options.h:45
coeffs_BIGINT
VAR coeffs coeffs_BIGINT
Definition polys.cc:14
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
polys.h
Compatibility layer for legacy polynomial operations (over currRing)
pAdd
#define pAdd(p, q)
Definition polys.h:204
pDelete
#define pDelete(p_ptr)
Definition polys.h:187
pSetCompP
#define pSetCompP(a, i)
Definition polys.h:304
yynerrs
int yynerrs
Definition readcf.cc:927
yychar
int yychar
Definition readcf.cc:922
PrintLn
void PrintLn()
Definition reporter.cc:310
Werror
void Werror(const char *fmt,...)
Definition reporter.cc:189
rOrderName
rRingOrder_t rOrderName(char *ordername)
Definition ring.cc:512
rDefault
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
Definition ring.cc:103
idhdl
idrec * idhdl
Definition ring.h:22
sdb_flags
VAR int sdb_flags
Definition sdb.cc:31
HAVE_SDB
#define HAVE_SDB
Definition sdb.h:10
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition simpleideals.cc:35
leftv
sleftv * leftv
Definition structs.h:53
YYSTYPE
#define YYSTYPE
Definition stype.h:19
yylval
EXTERN_VAR YYSTYPE yylval
Definition stype.h:20
syMake
void syMake(leftv v, const char *id, package pa)
Definition subexpr.cc:1613
sLastPrinted
INST_VAR sleftv sLastPrinted
Definition subexpr.cc:46
siq
VAR BOOLEAN siq
Definition subexpr.cc:48
syMakeMonom
void syMakeMonom(leftv v, const char *id)
Definition subexpr.cc:1917
procinfo::trace_flag
char trace_flag
Definition subexpr.h:62
name
int name
New type name for int.
Definition templateForC.h:21
writeRTime
void writeRTime(const char *v)
Definition timer.cc:173
startTimer
int startTimer()
Definition timer.cc:66
rtimerv
VAR int rtimerv
Definition timer.cc:126
writeTime
void writeTime(const char *v)
Definition timer.cc:101
timerv
VAR int timerv
Definition timer.cc:17
startRTimer
void startRTimer()
Definition timer.cc:131
IDHDL
#define IDHDL
Definition tok.h:31
ALIAS_CMD
@ ALIAS_CMD
Definition tok.h:34
BIGINT_CMD
@ BIGINT_CMD
Definition tok.h:38
INTVEC_CMD
@ INTVEC_CMD
Definition tok.h:101
PACKAGE_CMD
@ PACKAGE_CMD
Definition tok.h:150
DEF_CMD
@ DEF_CMD
Definition tok.h:58
QRING_CMD
@ QRING_CMD
Definition tok.h:160
STRING_CMD
@ STRING_CMD
Definition tok.h:187
INT_CMD
@ INT_CMD
Definition tok.h:96
NONE
#define NONE
Definition tok.h:223
COMMAND
#define COMMAND
Definition tok.h:29
UNKNOWN
#define UNKNOWN
Definition tok.h:224
Generated on Tue Feb 24 2026 00:00:00 for My Project by   doxygen 1.9.7 for Singular