source: git/Singular/grammar.cc @ c45b8f0

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