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