source: XIOS/dev/dev_olga/src/extern/src_netcdf4/dcetab.c @ 1022

Last change on this file since 1022 was 1022, checked in by mhnguyen, 7 years ago
File size: 53.7 KB
Line 
1/* A Bison parser, made by GNU Bison 2.4.3.  */
2
3/* Skeleton implementation for Bison's Yacc-like parsers in C
4   
5      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6   2009, 2010 Free Software Foundation, Inc.
7   
8   This program is free software: you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation, either version 3 of the License, or
11   (at your option) any later version.
12   
13   This program is distributed in the hope that it will be useful,
14   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   GNU General Public License for more details.
17   
18   You should have received a copy of the GNU General Public License
19   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21/* As a special exception, you may create a larger work that contains
22   part or all of the Bison parser skeleton and distribute that work
23   under terms of your choice, so long as that work isn't itself a
24   parser generator using the skeleton or a modified version thereof
25   as a parser skeleton.  Alternatively, if you modify or redistribute
26   the parser skeleton itself, you may (at your option) remove this
27   special exception, which will cause the skeleton and the resulting
28   Bison output files to be licensed under the GNU General Public
29   License without this special exception.
30   
31   This special exception was added by the Free Software Foundation in
32   version 2.2 of Bison.  */
33
34/* C LALR(1) parser skeleton written by Richard Stallman, by
35   simplifying the original so-called "semantic" parser.  */
36
37/* All symbols defined below should begin with yy or YY, to avoid
38   infringing on user name space.  This should be done even for local
39   variables, as they might otherwise be expanded by user macros.
40   There are some unavoidable exceptions within include files to
41   define necessary library symbols; they are noted "INFRINGES ON
42   USER NAME SPACE" below.  */
43
44/* Identify Bison output.  */
45#define YYBISON 1
46
47/* Bison version.  */
48#define YYBISON_VERSION "2.4.3"
49
50/* Skeleton name.  */
51#define YYSKELETON_NAME "yacc.c"
52
53/* Pure parsers.  */
54#define YYPURE 1
55
56/* Push parsers.  */
57#define YYPUSH 0
58
59/* Pull parsers.  */
60#define YYPULL 1
61
62/* Using locations.  */
63#define YYLSP_NEEDED 0
64
65/* Substitute the variable and function names.  */
66#define yyparse         dceparse
67#define yylex           dcelex
68#define yyerror         dceerror
69#define yylval          dcelval
70#define yychar          dcechar
71#define yydebug         dcedebug
72#define yynerrs         dcenerrs
73
74
75/* Copy the first part of user declarations.  */
76
77/* Line 189 of yacc.c  */
78#line 11 "dce.y"
79
80#include "config.h"
81#include <stdlib.h>
82#include "netcdf.h"
83#include "ncbytes.h"
84#include "nclist.h"
85#include "dceconstraints.h"
86#include "dceparselex.h"
87
88
89/* Line 189 of yacc.c  */
90#line 93 "dce.tab.c"
91
92/* Enabling traces.  */
93#ifndef YYDEBUG
94# define YYDEBUG 1
95#endif
96
97/* Enabling verbose error messages.  */
98#ifdef YYERROR_VERBOSE
99# undef YYERROR_VERBOSE
100# define YYERROR_VERBOSE 1
101#else
102# define YYERROR_VERBOSE 0
103#endif
104
105/* Enabling the token table.  */
106#ifndef YYTOKEN_TABLE
107# define YYTOKEN_TABLE 0
108#endif
109
110
111/* Tokens.  */
112#ifndef YYTOKENTYPE
113# define YYTOKENTYPE
114   /* Put the tokens into the symbol table, so that GDB and other debuggers
115      know about them.  */
116   enum yytokentype {
117     SCAN_WORD = 258,
118     SCAN_STRINGCONST = 259,
119     SCAN_NUMBERCONST = 260
120   };
121#endif
122
123
124
125#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
126typedef int YYSTYPE;
127# define YYSTYPE_IS_TRIVIAL 1
128# define yystype YYSTYPE /* obsolescent; will be withdrawn */
129# define YYSTYPE_IS_DECLARED 1
130#endif
131
132
133/* Copy the second part of user declarations.  */
134
135
136/* Line 264 of yacc.c  */
137#line 140 "dce.tab.c"
138
139#ifdef short
140# undef short
141#endif
142
143#ifdef YYTYPE_UINT8
144typedef YYTYPE_UINT8 yytype_uint8;
145#else
146typedef unsigned char yytype_uint8;
147#endif
148
149#ifdef YYTYPE_INT8
150typedef YYTYPE_INT8 yytype_int8;
151#elif (defined __STDC__ || defined __C99__FUNC__ \
152     || defined __cplusplus || defined _MSC_VER)
153typedef signed char yytype_int8;
154#else
155typedef short int yytype_int8;
156#endif
157
158#ifdef YYTYPE_UINT16
159typedef YYTYPE_UINT16 yytype_uint16;
160#else
161typedef unsigned short int yytype_uint16;
162#endif
163
164#ifdef YYTYPE_INT16
165typedef YYTYPE_INT16 yytype_int16;
166#else
167typedef short int yytype_int16;
168#endif
169
170#ifndef YYSIZE_T
171# ifdef __SIZE_TYPE__
172#  define YYSIZE_T __SIZE_TYPE__
173# elif defined size_t
174#  define YYSIZE_T size_t
175# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
176     || defined __cplusplus || defined _MSC_VER)
177#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
178#  define YYSIZE_T size_t
179# else
180#  define YYSIZE_T unsigned int
181# endif
182#endif
183
184#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
185
186#ifndef YY_
187# if defined YYENABLE_NLS && YYENABLE_NLS
188#  if ENABLE_NLS
189#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
190#   define YY_(msgid) dgettext ("bison-runtime", msgid)
191#  endif
192# endif
193# ifndef YY_
194#  define YY_(msgid) msgid
195# endif
196#endif
197
198/* Suppress unused-variable warnings by "using" E.  */
199#if ! defined lint || defined __GNUC__
200# define YYUSE(e) ((void) (e))
201#else
202# define YYUSE(e) /* empty */
203#endif
204
205/* Identity function, used to suppress warnings about constant conditions.  */
206#ifndef lint
207# define YYID(n) (n)
208#else
209#if (defined __STDC__ || defined __C99__FUNC__ \
210     || defined __cplusplus || defined _MSC_VER)
211static int
212YYID (int yyi)
213#else
214static int
215YYID (yyi)
216    int yyi;
217#endif
218{
219  return yyi;
220}
221#endif
222
223#if ! defined yyoverflow || YYERROR_VERBOSE
224
225/* The parser invokes alloca or malloc; define the necessary symbols.  */
226
227# ifdef YYSTACK_USE_ALLOCA
228#  if YYSTACK_USE_ALLOCA
229#   ifdef __GNUC__
230#    define YYSTACK_ALLOC __builtin_alloca
231#   elif defined __BUILTIN_VA_ARG_INCR
232#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
233#   elif defined _AIX
234#    define YYSTACK_ALLOC __alloca
235#   elif defined _MSC_VER
236#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
237#    define alloca _alloca
238#   else
239#    define YYSTACK_ALLOC alloca
240#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
241     || defined __cplusplus || defined _MSC_VER)
242#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
243#     ifndef _STDLIB_H
244#      define _STDLIB_H 1
245#     endif
246#    endif
247#   endif
248#  endif
249# endif
250
251# ifdef YYSTACK_ALLOC
252   /* Pacify GCC's `empty if-body' warning.  */
253#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
254#  ifndef YYSTACK_ALLOC_MAXIMUM
255    /* The OS might guarantee only one guard page at the bottom of the stack,
256       and a page size can be as small as 4096 bytes.  So we cannot safely
257       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
258       to allow for a few compiler-allocated temporary stack slots.  */
259#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
260#  endif
261# else
262#  define YYSTACK_ALLOC YYMALLOC
263#  define YYSTACK_FREE YYFREE
264#  ifndef YYSTACK_ALLOC_MAXIMUM
265#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
266#  endif
267#  if (defined __cplusplus && ! defined _STDLIB_H \
268       && ! ((defined YYMALLOC || defined malloc) \
269             && (defined YYFREE || defined free)))
270#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
271#   ifndef _STDLIB_H
272#    define _STDLIB_H 1
273#   endif
274#  endif
275#  ifndef YYMALLOC
276#   define YYMALLOC malloc
277#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
278     || defined __cplusplus || defined _MSC_VER)
279void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
280#   endif
281#  endif
282#  ifndef YYFREE
283#   define YYFREE free
284#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
285     || defined __cplusplus || defined _MSC_VER)
286void free (void *); /* INFRINGES ON USER NAME SPACE */
287#   endif
288#  endif
289# endif
290#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
291
292
293#if (! defined yyoverflow \
294     && (! defined __cplusplus \
295         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
296
297/* A type that is properly aligned for any stack member.  */
298union yyalloc
299{
300  yytype_int16 yyss_alloc;
301  YYSTYPE yyvs_alloc;
302};
303
304/* The size of the maximum gap between one aligned stack and the next.  */
305# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
306
307/* The size of an array large to enough to hold all stacks, each with
308   N elements.  */
309# define YYSTACK_BYTES(N) \
310     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
311      + YYSTACK_GAP_MAXIMUM)
312
313/* Copy COUNT objects from FROM to TO.  The source and destination do
314   not overlap.  */
315# ifndef YYCOPY
316#  if defined __GNUC__ && 1 < __GNUC__
317#   define YYCOPY(To, From, Count) \
318      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
319#  else
320#   define YYCOPY(To, From, Count)              \
321      do                                        \
322        {                                       \
323          YYSIZE_T yyi;                         \
324          for (yyi = 0; yyi < (Count); yyi++)   \
325            (To)[yyi] = (From)[yyi];            \
326        }                                       \
327      while (YYID (0))
328#  endif
329# endif
330
331/* Relocate STACK from its old location to the new one.  The
332   local variables YYSIZE and YYSTACKSIZE give the old and new number of
333   elements in the stack, and YYPTR gives the new location of the
334   stack.  Advance YYPTR to a properly aligned location for the next
335   stack.  */
336# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
337    do                                                                  \
338      {                                                                 \
339        YYSIZE_T yynewbytes;                                            \
340        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
341        Stack = &yyptr->Stack_alloc;                                    \
342        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
343        yyptr += yynewbytes / sizeof (*yyptr);                          \
344      }                                                                 \
345    while (YYID (0))
346
347#endif
348
349/* YYFINAL -- State number of the termination state.  */
350#define YYFINAL  4
351/* YYLAST -- Last index in YYTABLE.  */
352#define YYLAST   83
353
354/* YYNTOKENS -- Number of terminals.  */
355#define YYNTOKENS  22
356/* YYNNTS -- Number of nonterminals.  */
357#define YYNNTS  29
358/* YYNRULES -- Number of rules.  */
359#define YYNRULES  59
360/* YYNRULES -- Number of states.  */
361#define YYNSTATES  87
362
363/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
364#define YYUNDEFTOK  2
365#define YYMAXUTOK   260
366
367#define YYTRANSLATE(YYX)                                                \
368  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
369
370/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
371static const yytype_uint8 yytranslate[] =
372{
373       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
374       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
375       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
376       2,     2,     2,    20,     2,     2,     2,     2,    14,     2,
377       8,     9,     2,     2,     7,     2,    10,     2,     2,     2,
378       2,     2,     2,     2,     2,     2,     2,     2,    13,     2,
379      19,    17,    18,     6,     2,     2,     2,     2,     2,     2,
380       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
381       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
382       2,    11,     2,    12,     2,     2,     2,     2,     2,     2,
383       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
384       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
385       2,     2,     2,    15,     2,    16,    21,     2,     2,     2,
386       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
387       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
388       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
389       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
390       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
391       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
392       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
393       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
394       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
395       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
396       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
397       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
398       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
399       5
400};
401
402#if YYDEBUG
403/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
404   YYRHS.  */
405static const yytype_uint8 yyprhs[] =
406{
407       0,     0,     3,     6,     9,    13,    14,    16,    17,    19,
408      21,    23,    27,    29,    31,    35,    40,    42,    46,    48,
409      51,    53,    56,    60,    66,    74,    78,    80,    83,    90,
410      95,    98,   100,   104,   106,   108,   110,   112,   114,   116,
411     118,   122,   124,   127,   129,   132,   136,   141,   143,   147,
412     149,   151,   153,   156,   159,   162,   165,   167,   169,   171
413};
414
415/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
416static const yytype_int8 yyrhs[] =
417{
418      23,     0,    -1,    24,    25,    -1,    24,    26,    -1,    24,
419      25,    26,    -1,    -1,     6,    -1,    -1,    27,    -1,    35,
420      -1,    28,    -1,    27,     7,    28,    -1,    30,    -1,    29,
421      -1,    47,     8,     9,    -1,    47,     8,    45,     9,    -1,
422      31,    -1,    30,    10,    31,    -1,    48,    -1,    48,    32,
423      -1,    33,    -1,    32,    33,    -1,    11,    49,    12,    -1,
424      11,    49,    13,    49,    12,    -1,    11,    49,    13,    49,
425      13,    49,    12,    -1,    11,    49,    12,    -1,    36,    -1,
426      35,    36,    -1,    14,    38,    46,    15,    37,    16,    -1,
427      14,    38,    46,    38,    -1,    14,    44,    -1,    38,    -1,
428      37,     7,    38,    -1,    40,    -1,    29,    -1,    39,    -1,
429      49,    -1,    50,    -1,    41,    -1,    42,    -1,    41,    10,
430      42,    -1,    48,    -1,    48,    43,    -1,    34,    -1,    43,
431      34,    -1,    47,     8,     9,    -1,    47,     8,    45,     9,
432      -1,    38,    -1,    37,     7,    38,    -1,    17,    -1,    18,
433      -1,    19,    -1,    20,    17,    -1,    18,    17,    -1,    19,
434      17,    -1,    17,    21,    -1,    48,    -1,     3,    -1,     5,
435      -1,     4,    -1
436};
437
438/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
439static const yytype_uint8 yyrline[] =
440{
441       0,    34,    34,    35,    36,    37,    40,    40,    43,    47,
442      51,    53,    58,    60,    65,    67,    72,    74,    79,    81,
443      86,    88,    93,    95,    97,   101,   107,   109,   114,   116,
444     118,   123,   125,   130,   132,   134,   139,   141,   146,   151,
445     153,   158,   160,   165,   167,   172,   174,   179,   181,   186,
446     187,   188,   189,   190,   191,   192,   195,   199,   203,   207
447};
448#endif
449
450#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
451/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
452   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
453static const char *const yytname[] =
454{
455  "$end", "error", "$undefined", "SCAN_WORD", "SCAN_STRINGCONST",
456  "SCAN_NUMBERCONST", "'?'", "','", "'('", "')'", "'.'", "'['", "']'",
457  "':'", "'&'", "'{'", "'}'", "'='", "'>'", "'<'", "'!'", "'~'", "$accept",
458  "constraints", "optquestionmark", "projections", "selections",
459  "projectionlist", "projection", "function", "segmentlist", "segment",
460  "rangelist", "range", "range1", "clauselist", "sel_clause", "value_list",
461  "value", "constant", "var", "indexpath", "index", "array_indices",
462  "boolfunction", "arg_list", "rel_op", "ident", "word", "number",
463  "string", 0
464};
465#endif
466
467# ifdef YYPRINT
468/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
469   token YYLEX-NUM.  */
470static const yytype_uint16 yytoknum[] =
471{
472       0,   256,   257,   258,   259,   260,    63,    44,    40,    41,
473      46,    91,    93,    58,    38,   123,   125,    61,    62,    60,
474      33,   126
475};
476# endif
477
478/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
479static const yytype_uint8 yyr1[] =
480{
481       0,    22,    23,    23,    23,    23,    24,    24,    25,    26,
482      27,    27,    28,    28,    29,    29,    30,    30,    31,    31,
483      32,    32,    33,    33,    33,    34,    35,    35,    36,    36,
484      36,    37,    37,    38,    38,    38,    39,    39,    40,    41,
485      41,    42,    42,    43,    43,    44,    44,    45,    45,    46,
486      46,    46,    46,    46,    46,    46,    47,    48,    49,    50
487};
488
489/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
490static const yytype_uint8 yyr2[] =
491{
492       0,     2,     2,     2,     3,     0,     1,     0,     1,     1,
493       1,     3,     1,     1,     3,     4,     1,     3,     1,     2,
494       1,     2,     3,     5,     7,     3,     1,     2,     6,     4,
495       2,     1,     3,     1,     1,     1,     1,     1,     1,     1,
496       3,     1,     2,     1,     2,     3,     4,     1,     3,     1,
497       1,     1,     2,     2,     2,     2,     1,     1,     1,     1
498};
499
500/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
501   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
502   means the default is an error.  */
503static const yytype_uint8 yydefact[] =
504{
505       7,     6,     0,     0,     1,    57,     0,     2,     3,     8,
506      10,    13,    12,    16,     9,    26,     0,    18,    59,    58,
507      34,     0,    35,    33,    38,    39,    30,     0,    41,    36,
508      37,     4,     0,     0,    27,     0,     0,    19,    20,    49,
509      50,    51,     0,     0,     0,     0,     0,    43,    42,    11,
510      17,    18,    14,     0,    31,     0,     0,    21,    55,    53,
511      54,    52,     0,    29,    40,    41,    14,     0,     0,    44,
512       0,    15,    22,     0,     0,    31,    15,    25,    32,     0,
513       0,    28,    23,     0,    32,     0,    24
514};
515
516/* YYDEFGOTO[NTERM-NUM].  */
517static const yytype_int8 yydefgoto[] =
518{
519      -1,     2,     3,     7,     8,     9,    10,    20,    12,    13,
520      37,    38,    47,    14,    15,    53,    54,    22,    23,    24,
521      25,    48,    26,    55,    43,    16,    28,    29,    30
522};
523
524/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
525   STATE-NUM.  */
526#define YYPACT_NINF -36
527static const yytype_int8 yypact[] =
528{
529      10,   -36,     8,     4,   -36,   -36,    46,    12,   -36,    23,
530     -36,   -36,    44,   -36,    12,   -36,     7,    -2,   -36,   -36,
531     -36,    27,   -36,   -36,    45,   -36,   -36,    49,    17,   -36,
532     -36,   -36,    36,    36,   -36,    18,    53,    48,   -36,    39,
533      50,    51,    52,     9,    36,    31,    53,   -36,    54,   -36,
534     -36,    48,   -36,    55,    57,    61,    29,   -36,   -36,   -36,
535     -36,   -36,    46,   -36,   -36,    54,     3,    62,    60,   -36,
536      46,   -36,   -36,    53,    13,   -36,     5,   -36,    64,    40,
537      46,   -36,   -36,    53,   -36,    63,   -36
538};
539
540/* YYPGOTO[NTERM-NUM].  */
541static const yytype_int8 yypgoto[] =
542{
543     -36,   -36,   -36,   -36,    56,   -36,    47,     1,   -36,    28,
544     -36,    41,    32,   -36,    67,    14,    -6,   -36,   -36,   -36,
545      33,   -36,   -36,    37,   -36,    77,    -1,   -35,   -36
546};
547
548/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
549   positive, shift that token.  If negative, reduce the rule which
550   number is the opposite.  If zero, do what YYDEFACT says.
551   If YYTABLE_NINF, syntax error.  */
552#define YYTABLE_NINF -57
553static const yytype_int8 yytable[] =
554{
555      21,    56,    17,   -45,    11,   -46,   -56,     5,     4,    36,
556      -5,    68,     5,    18,    19,    35,     1,   -45,     6,   -46,
557      80,     5,    18,    19,    62,   -56,     6,    52,    46,    81,
558      32,    17,    51,    11,     5,    18,    19,    63,    79,     5,
559      66,    72,    73,    65,    39,    40,    41,    42,    85,     5,
560      18,    19,    82,    83,    33,    44,    75,    45,    19,    36,
561      58,    50,    70,    31,    78,    46,   -47,    59,    60,    61,
562      71,    76,    77,   -48,    84,    86,    74,    64,    57,    49,
563      69,    34,    67,    27
564};
565
566static const yytype_uint8 yycheck[] =
567{
568       6,    36,     3,     0,     3,     0,     8,     3,     0,    11,
569       0,    46,     3,     4,     5,     8,     6,    14,    14,    14,
570       7,     3,     4,     5,    15,     8,    14,     9,    11,    16,
571       7,    32,    33,    32,     3,     4,     5,    43,    73,     3,
572       9,    12,    13,    44,    17,    18,    19,    20,    83,     3,
573       4,     5,    12,    13,    10,    10,    62,     8,     5,    11,
574      21,    33,     7,     7,    70,    11,     9,    17,    17,    17,
575       9,     9,    12,     9,    80,    12,    62,    44,    37,    32,
576      48,    14,    45,     6
577};
578
579/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
580   symbol of state STATE-NUM.  */
581static const yytype_uint8 yystos[] =
582{
583       0,     6,    23,    24,     0,     3,    14,    25,    26,    27,
584      28,    29,    30,    31,    35,    36,    47,    48,     4,     5,
585      29,    38,    39,    40,    41,    42,    44,    47,    48,    49,
586      50,    26,     7,    10,    36,     8,    11,    32,    33,    17,
587      18,    19,    20,    46,    10,     8,    11,    34,    43,    28,
588      31,    48,     9,    37,    38,    45,    49,    33,    21,    17,
589      17,    17,    15,    38,    42,    48,     9,    45,    49,    34,
590       7,     9,    12,    13,    37,    38,     9,    12,    38,    49,
591       7,    16,    12,    13,    38,    49,    12
592};
593
594#define yyerrok         (yyerrstatus = 0)
595#define yyclearin       (yychar = YYEMPTY)
596#define YYEMPTY         (-2)
597#define YYEOF           0
598
599#define YYACCEPT        goto yyacceptlab
600#define YYABORT         goto yyabortlab
601#define YYERROR         goto yyerrorlab
602
603
604/* Like YYERROR except do call yyerror.  This remains here temporarily
605   to ease the transition to the new meaning of YYERROR, for GCC.
606   Once GCC version 2 has supplanted version 1, this can go.  However,
607   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
608   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
609   discussed.  */
610
611#define YYFAIL          goto yyerrlab
612#if defined YYFAIL
613  /* This is here to suppress warnings from the GCC cpp's
614     -Wunused-macros.  Normally we don't worry about that warning, but
615     some users do, and we want to make it easy for users to remove
616     YYFAIL uses, which will produce warnings from Bison 2.5.  */
617#endif
618
619#define YYRECOVERING()  (!!yyerrstatus)
620
621#define YYBACKUP(Token, Value)                                  \
622do                                                              \
623  if (yychar == YYEMPTY && yylen == 1)                          \
624    {                                                           \
625      yychar = (Token);                                         \
626      yylval = (Value);                                         \
627      yytoken = YYTRANSLATE (yychar);                           \
628      YYPOPSTACK (1);                                           \
629      goto yybackup;                                            \
630    }                                                           \
631  else                                                          \
632    {                                                           \
633      yyerror (parsestate, YY_("syntax error: cannot back up")); \
634      YYERROR;                                                  \
635    }                                                           \
636while (YYID (0))
637
638
639#define YYTERROR        1
640#define YYERRCODE       256
641
642
643/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
644   If N is 0, then set CURRENT to the empty location which ends
645   the previous symbol: RHS[0] (always defined).  */
646
647#define YYRHSLOC(Rhs, K) ((Rhs)[K])
648#ifndef YYLLOC_DEFAULT
649# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
650    do                                                                  \
651      if (YYID (N))                                                    \
652        {                                                               \
653          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
654          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
655          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
656          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
657        }                                                               \
658      else                                                              \
659        {                                                               \
660          (Current).first_line   = (Current).last_line   =              \
661            YYRHSLOC (Rhs, 0).last_line;                                \
662          (Current).first_column = (Current).last_column =              \
663            YYRHSLOC (Rhs, 0).last_column;                              \
664        }                                                               \
665    while (YYID (0))
666#endif
667
668
669/* YY_LOCATION_PRINT -- Print the location on the stream.
670   This macro was not mandated originally: define only if we know
671   we won't break user code: when these are the locations we know.  */
672
673#ifndef YY_LOCATION_PRINT
674# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
675#  define YY_LOCATION_PRINT(File, Loc)                  \
676     fprintf (File, "%d.%d-%d.%d",                      \
677              (Loc).first_line, (Loc).first_column,     \
678              (Loc).last_line,  (Loc).last_column)
679# else
680#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
681# endif
682#endif
683
684
685/* YYLEX -- calling `yylex' with the right arguments.  */
686
687#ifdef YYLEX_PARAM
688# define YYLEX yylex (&yylval, YYLEX_PARAM)
689#else
690# define YYLEX yylex (&yylval, parsestate)
691#endif
692
693/* Enable debugging if requested.  */
694#if YYDEBUG
695
696# ifndef YYFPRINTF
697#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
698#  define YYFPRINTF fprintf
699# endif
700
701# define YYDPRINTF(Args)                        \
702do {                                            \
703  if (yydebug)                                  \
704    YYFPRINTF Args;                             \
705} while (YYID (0))
706
707# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
708do {                                                                      \
709  if (yydebug)                                                            \
710    {                                                                     \
711      YYFPRINTF (stderr, "%s ", Title);                                   \
712      yy_symbol_print (stderr,                                            \
713                  Type, Value, parsestate); \
714      YYFPRINTF (stderr, "\n");                                           \
715    }                                                                     \
716} while (YYID (0))
717
718
719/*--------------------------------.
720| Print this symbol on YYOUTPUT.  |
721`--------------------------------*/
722
723/*ARGSUSED*/
724#if (defined __STDC__ || defined __C99__FUNC__ \
725     || defined __cplusplus || defined _MSC_VER)
726static void
727yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, DCEparsestate* parsestate)
728#else
729static void
730yy_symbol_value_print (yyoutput, yytype, yyvaluep, parsestate)
731    FILE *yyoutput;
732    int yytype;
733    YYSTYPE const * const yyvaluep;
734    DCEparsestate* parsestate;
735#endif
736{
737  if (!yyvaluep)
738    return;
739  YYUSE (parsestate);
740# ifdef YYPRINT
741  if (yytype < YYNTOKENS)
742    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
743# else
744  YYUSE (yyoutput);
745# endif
746  switch (yytype)
747    {
748      default:
749        break;
750    }
751}
752
753
754/*--------------------------------.
755| Print this symbol on YYOUTPUT.  |
756`--------------------------------*/
757
758#if (defined __STDC__ || defined __C99__FUNC__ \
759     || defined __cplusplus || defined _MSC_VER)
760static void
761yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, DCEparsestate* parsestate)
762#else
763static void
764yy_symbol_print (yyoutput, yytype, yyvaluep, parsestate)
765    FILE *yyoutput;
766    int yytype;
767    YYSTYPE const * const yyvaluep;
768    DCEparsestate* parsestate;
769#endif
770{
771  if (yytype < YYNTOKENS)
772    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
773  else
774    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
775
776  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parsestate);
777  YYFPRINTF (yyoutput, ")");
778}
779
780/*------------------------------------------------------------------.
781| yy_stack_print -- Print the state stack from its BOTTOM up to its |
782| TOP (included).                                                   |
783`------------------------------------------------------------------*/
784
785#if (defined __STDC__ || defined __C99__FUNC__ \
786     || defined __cplusplus || defined _MSC_VER)
787static void
788yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
789#else
790static void
791yy_stack_print (yybottom, yytop)
792    yytype_int16 *yybottom;
793    yytype_int16 *yytop;
794#endif
795{
796  YYFPRINTF (stderr, "Stack now");
797  for (; yybottom <= yytop; yybottom++)
798    {
799      int yybot = *yybottom;
800      YYFPRINTF (stderr, " %d", yybot);
801    }
802  YYFPRINTF (stderr, "\n");
803}
804
805# define YY_STACK_PRINT(Bottom, Top)                            \
806do {                                                            \
807  if (yydebug)                                                  \
808    yy_stack_print ((Bottom), (Top));                           \
809} while (YYID (0))
810
811
812/*------------------------------------------------.
813| Report that the YYRULE is going to be reduced.  |
814`------------------------------------------------*/
815
816#if (defined __STDC__ || defined __C99__FUNC__ \
817     || defined __cplusplus || defined _MSC_VER)
818static void
819yy_reduce_print (YYSTYPE *yyvsp, int yyrule, DCEparsestate* parsestate)
820#else
821static void
822yy_reduce_print (yyvsp, yyrule, parsestate)
823    YYSTYPE *yyvsp;
824    int yyrule;
825    DCEparsestate* parsestate;
826#endif
827{
828  int yynrhs = yyr2[yyrule];
829  int yyi;
830  unsigned long int yylno = yyrline[yyrule];
831  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
832             yyrule - 1, yylno);
833  /* The symbols being reduced.  */
834  for (yyi = 0; yyi < yynrhs; yyi++)
835    {
836      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
837      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
838                       &(yyvsp[(yyi + 1) - (yynrhs)])
839                                       , parsestate);
840      YYFPRINTF (stderr, "\n");
841    }
842}
843
844# define YY_REDUCE_PRINT(Rule)          \
845do {                                    \
846  if (yydebug)                          \
847    yy_reduce_print (yyvsp, Rule, parsestate); \
848} while (YYID (0))
849
850/* Nonzero means print parse trace.  It is left uninitialized so that
851   multiple parsers can coexist.  */
852int yydebug;
853#else /* !YYDEBUG */
854# define YYDPRINTF(Args)
855# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
856# define YY_STACK_PRINT(Bottom, Top)
857# define YY_REDUCE_PRINT(Rule)
858#endif /* !YYDEBUG */
859
860
861/* YYINITDEPTH -- initial size of the parser's stacks.  */
862#ifndef YYINITDEPTH
863# define YYINITDEPTH 200
864#endif
865
866/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
867   if the built-in stack extension method is used).
868
869   Do not make this value too large; the results are undefined if
870   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
871   evaluated with infinite-precision integer arithmetic.  */
872
873#ifndef YYMAXDEPTH
874# define YYMAXDEPTH 10000
875#endif
876
877
878
879#if YYERROR_VERBOSE
880
881# ifndef yystrlen
882#  if defined __GLIBC__ && defined _STRING_H
883#   define yystrlen strlen
884#  else
885/* Return the length of YYSTR.  */
886#if (defined __STDC__ || defined __C99__FUNC__ \
887     || defined __cplusplus || defined _MSC_VER)
888static YYSIZE_T
889yystrlen (const char *yystr)
890#else
891static YYSIZE_T
892yystrlen (yystr)
893    const char *yystr;
894#endif
895{
896  YYSIZE_T yylen;
897  for (yylen = 0; yystr[yylen]; yylen++)
898    continue;
899  return yylen;
900}
901#  endif
902# endif
903
904# ifndef yystpcpy
905#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
906#   define yystpcpy stpcpy
907#  else
908/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
909   YYDEST.  */
910#if (defined __STDC__ || defined __C99__FUNC__ \
911     || defined __cplusplus || defined _MSC_VER)
912static char *
913yystpcpy (char *yydest, const char *yysrc)
914#else
915static char *
916yystpcpy (yydest, yysrc)
917    char *yydest;
918    const char *yysrc;
919#endif
920{
921  char *yyd = yydest;
922  const char *yys = yysrc;
923
924  while ((*yyd++ = *yys++) != '\0')
925    continue;
926
927  return yyd - 1;
928}
929#  endif
930# endif
931
932# ifndef yytnamerr
933/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
934   quotes and backslashes, so that it's suitable for yyerror.  The
935   heuristic is that double-quoting is unnecessary unless the string
936   contains an apostrophe, a comma, or backslash (other than
937   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
938   null, do not copy; instead, return the length of what the result
939   would have been.  */
940static YYSIZE_T
941yytnamerr (char *yyres, const char *yystr)
942{
943  if (*yystr == '"')
944    {
945      YYSIZE_T yyn = 0;
946      char const *yyp = yystr;
947
948      for (;;)
949        switch (*++yyp)
950          {
951          case '\'':
952          case ',':
953            goto do_not_strip_quotes;
954
955          case '\\':
956            if (*++yyp != '\\')
957              goto do_not_strip_quotes;
958            /* Fall through.  */
959          default:
960            if (yyres)
961              yyres[yyn] = *yyp;
962            yyn++;
963            break;
964
965          case '"':
966            if (yyres)
967              yyres[yyn] = '\0';
968            return yyn;
969          }
970    do_not_strip_quotes: ;
971    }
972
973  if (! yyres)
974    return yystrlen (yystr);
975
976  return yystpcpy (yyres, yystr) - yyres;
977}
978# endif
979
980/* Copy into YYRESULT an error message about the unexpected token
981   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
982   including the terminating null byte.  If YYRESULT is null, do not
983   copy anything; just return the number of bytes that would be
984   copied.  As a special case, return 0 if an ordinary "syntax error"
985   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
986   size calculation.  */
987static YYSIZE_T
988yysyntax_error (char *yyresult, int yystate, int yychar)
989{
990  int yyn = yypact[yystate];
991
992  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
993    return 0;
994  else
995    {
996      int yytype = YYTRANSLATE (yychar);
997      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
998      YYSIZE_T yysize = yysize0;
999      YYSIZE_T yysize1;
1000      int yysize_overflow = 0;
1001      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1002      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1003      int yyx;
1004
1005# if 0
1006      /* This is so xgettext sees the translatable formats that are
1007         constructed on the fly.  */
1008      YY_("syntax error, unexpected %s");
1009      YY_("syntax error, unexpected %s, expecting %s");
1010      YY_("syntax error, unexpected %s, expecting %s or %s");
1011      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1012      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1013# endif
1014      char *yyfmt;
1015      char const *yyf;
1016      static char const yyunexpected[] = "syntax error, unexpected %s";
1017      static char const yyexpecting[] = ", expecting %s";
1018      static char const yyor[] = " or %s";
1019      char yyformat[sizeof yyunexpected
1020                    + sizeof yyexpecting - 1
1021                    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1022                       * (sizeof yyor - 1))];
1023      char const *yyprefix = yyexpecting;
1024
1025      /* Start YYX at -YYN if negative to avoid negative indexes in
1026         YYCHECK.  */
1027      int yyxbegin = yyn < 0 ? -yyn : 0;
1028
1029      /* Stay within bounds of both yycheck and yytname.  */
1030      int yychecklim = YYLAST - yyn + 1;
1031      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1032      int yycount = 1;
1033
1034      yyarg[0] = yytname[yytype];
1035      yyfmt = yystpcpy (yyformat, yyunexpected);
1036
1037      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1038        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1039          {
1040            if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1041              {
1042                yycount = 1;
1043                yysize = yysize0;
1044                yyformat[sizeof yyunexpected - 1] = '\0';
1045                break;
1046              }
1047            yyarg[yycount++] = yytname[yyx];
1048            yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1049            yysize_overflow |= (yysize1 < yysize);
1050            yysize = yysize1;
1051            yyfmt = yystpcpy (yyfmt, yyprefix);
1052            yyprefix = yyor;
1053          }
1054
1055      yyf = YY_(yyformat);
1056      yysize1 = yysize + yystrlen (yyf);
1057      yysize_overflow |= (yysize1 < yysize);
1058      yysize = yysize1;
1059
1060      if (yysize_overflow)
1061        return YYSIZE_MAXIMUM;
1062
1063      if (yyresult)
1064        {
1065          /* Avoid sprintf, as that infringes on the user's name space.
1066             Don't have undefined behavior even if the translation
1067             produced a string with the wrong number of "%s"s.  */
1068          char *yyp = yyresult;
1069          int yyi = 0;
1070          while ((*yyp = *yyf) != '\0')
1071            {
1072              if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1073                {
1074                  yyp += yytnamerr (yyp, yyarg[yyi++]);
1075                  yyf += 2;
1076                }
1077              else
1078                {
1079                  yyp++;
1080                  yyf++;
1081                }
1082            }
1083        }
1084      return yysize;
1085    }
1086}
1087#endif /* YYERROR_VERBOSE */
1088
1089
1090/*-----------------------------------------------.
1091| Release the memory associated to this symbol.  |
1092`-----------------------------------------------*/
1093
1094/*ARGSUSED*/
1095#if (defined __STDC__ || defined __C99__FUNC__ \
1096     || defined __cplusplus || defined _MSC_VER)
1097static void
1098yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, DCEparsestate* parsestate)
1099#else
1100static void
1101yydestruct (yymsg, yytype, yyvaluep, parsestate)
1102    const char *yymsg;
1103    int yytype;
1104    YYSTYPE *yyvaluep;
1105    DCEparsestate* parsestate;
1106#endif
1107{
1108  YYUSE (yyvaluep);
1109  YYUSE (parsestate);
1110
1111  if (!yymsg)
1112    yymsg = "Deleting";
1113  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1114
1115  switch (yytype)
1116    {
1117
1118      default:
1119        break;
1120    }
1121}
1122
1123/* Prevent warnings from -Wmissing-prototypes.  */
1124#ifdef YYPARSE_PARAM
1125#if defined __STDC__ || defined __cplusplus
1126int yyparse (void *YYPARSE_PARAM);
1127#else
1128int yyparse ();
1129#endif
1130#else /* ! YYPARSE_PARAM */
1131#if defined __STDC__ || defined __cplusplus
1132int yyparse (DCEparsestate* parsestate);
1133#else
1134int yyparse ();
1135#endif
1136#endif /* ! YYPARSE_PARAM */
1137
1138
1139
1140
1141
1142/*-------------------------.
1143| yyparse or yypush_parse.  |
1144`-------------------------*/
1145
1146#ifdef YYPARSE_PARAM
1147#if (defined __STDC__ || defined __C99__FUNC__ \
1148     || defined __cplusplus || defined _MSC_VER)
1149int
1150yyparse (void *YYPARSE_PARAM)
1151#else
1152int
1153yyparse (YYPARSE_PARAM)
1154    void *YYPARSE_PARAM;
1155#endif
1156#else /* ! YYPARSE_PARAM */
1157#if (defined __STDC__ || defined __C99__FUNC__ \
1158     || defined __cplusplus || defined _MSC_VER)
1159int
1160yyparse (DCEparsestate* parsestate)
1161#else
1162int
1163yyparse (parsestate)
1164    DCEparsestate* parsestate;
1165#endif
1166#endif
1167{
1168/* The lookahead symbol.  */
1169int yychar;
1170
1171/* The semantic value of the lookahead symbol.  */
1172YYSTYPE yylval;
1173
1174    /* Number of syntax errors so far.  */
1175    int yynerrs;
1176
1177    int yystate;
1178    /* Number of tokens to shift before error messages enabled.  */
1179    int yyerrstatus;
1180
1181    /* The stacks and their tools:
1182       `yyss': related to states.
1183       `yyvs': related to semantic values.
1184
1185       Refer to the stacks thru separate pointers, to allow yyoverflow
1186       to reallocate them elsewhere.  */
1187
1188    /* The state stack.  */
1189    yytype_int16 yyssa[YYINITDEPTH];
1190    yytype_int16 *yyss;
1191    yytype_int16 *yyssp;
1192
1193    /* The semantic value stack.  */
1194    YYSTYPE yyvsa[YYINITDEPTH];
1195    YYSTYPE *yyvs;
1196    YYSTYPE *yyvsp;
1197
1198    YYSIZE_T yystacksize;
1199
1200  int yyn;
1201  int yyresult;
1202  /* Lookahead token as an internal (translated) token number.  */
1203  int yytoken;
1204  /* The variables used to return semantic value and location from the
1205     action routines.  */
1206  YYSTYPE yyval;
1207
1208#if YYERROR_VERBOSE
1209  /* Buffer for error messages, and its allocated size.  */
1210  char yymsgbuf[128];
1211  char *yymsg = yymsgbuf;
1212  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1213#endif
1214
1215#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1216
1217  /* The number of symbols on the RHS of the reduced rule.
1218     Keep to zero when no symbol should be popped.  */
1219  int yylen = 0;
1220
1221  yytoken = 0;
1222  yyss = yyssa;
1223  yyvs = yyvsa;
1224  yystacksize = YYINITDEPTH;
1225
1226  YYDPRINTF ((stderr, "Starting parse\n"));
1227
1228  yystate = 0;
1229  yyerrstatus = 0;
1230  yynerrs = 0;
1231  yychar = YYEMPTY; /* Cause a token to be read.  */
1232
1233  /* Initialize stack pointers.
1234     Waste one element of value and location stack
1235     so that they stay on the same level as the state stack.
1236     The wasted elements are never initialized.  */
1237  yyssp = yyss;
1238  yyvsp = yyvs;
1239
1240  goto yysetstate;
1241
1242/*------------------------------------------------------------.
1243| yynewstate -- Push a new state, which is found in yystate.  |
1244`------------------------------------------------------------*/
1245 yynewstate:
1246  /* In all cases, when you get here, the value and location stacks
1247     have just been pushed.  So pushing a state here evens the stacks.  */
1248  yyssp++;
1249
1250 yysetstate:
1251  *yyssp = yystate;
1252
1253  if (yyss + yystacksize - 1 <= yyssp)
1254    {
1255      /* Get the current used size of the three stacks, in elements.  */
1256      YYSIZE_T yysize = yyssp - yyss + 1;
1257
1258#ifdef yyoverflow
1259      {
1260        /* Give user a chance to reallocate the stack.  Use copies of
1261           these so that the &'s don't force the real ones into
1262           memory.  */
1263        YYSTYPE *yyvs1 = yyvs;
1264        yytype_int16 *yyss1 = yyss;
1265
1266        /* Each stack pointer address is followed by the size of the
1267           data in use in that stack, in bytes.  This used to be a
1268           conditional around just the two extra args, but that might
1269           be undefined if yyoverflow is a macro.  */
1270        yyoverflow (YY_("memory exhausted"),
1271                    &yyss1, yysize * sizeof (*yyssp),
1272                    &yyvs1, yysize * sizeof (*yyvsp),
1273                    &yystacksize);
1274
1275        yyss = yyss1;
1276        yyvs = yyvs1;
1277      }
1278#else /* no yyoverflow */
1279# ifndef YYSTACK_RELOCATE
1280      goto yyexhaustedlab;
1281# else
1282      /* Extend the stack our own way.  */
1283      if (YYMAXDEPTH <= yystacksize)
1284        goto yyexhaustedlab;
1285      yystacksize *= 2;
1286      if (YYMAXDEPTH < yystacksize)
1287        yystacksize = YYMAXDEPTH;
1288
1289      {
1290        yytype_int16 *yyss1 = yyss;
1291        union yyalloc *yyptr =
1292          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1293        if (! yyptr)
1294          goto yyexhaustedlab;
1295        YYSTACK_RELOCATE (yyss_alloc, yyss);
1296        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1297#  undef YYSTACK_RELOCATE
1298        if (yyss1 != yyssa)
1299          YYSTACK_FREE (yyss1);
1300      }
1301# endif
1302#endif /* no yyoverflow */
1303
1304      yyssp = yyss + yysize - 1;
1305      yyvsp = yyvs + yysize - 1;
1306
1307      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1308                  (unsigned long int) yystacksize));
1309
1310      if (yyss + yystacksize - 1 <= yyssp)
1311        YYABORT;
1312    }
1313
1314  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1315
1316  if (yystate == YYFINAL)
1317    YYACCEPT;
1318
1319  goto yybackup;
1320
1321/*-----------.
1322| yybackup.  |
1323`-----------*/
1324yybackup:
1325
1326  /* Do appropriate processing given the current state.  Read a
1327     lookahead token if we need one and don't already have one.  */
1328
1329  /* First try to decide what to do without reference to lookahead token.  */
1330  yyn = yypact[yystate];
1331  if (yyn == YYPACT_NINF)
1332    goto yydefault;
1333
1334  /* Not known => get a lookahead token if don't already have one.  */
1335
1336  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1337  if (yychar == YYEMPTY)
1338    {
1339      YYDPRINTF ((stderr, "Reading a token: "));
1340      yychar = YYLEX;
1341    }
1342
1343  if (yychar <= YYEOF)
1344    {
1345      yychar = yytoken = YYEOF;
1346      YYDPRINTF ((stderr, "Now at end of input.\n"));
1347    }
1348  else
1349    {
1350      yytoken = YYTRANSLATE (yychar);
1351      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1352    }
1353
1354  /* If the proper action on seeing token YYTOKEN is to reduce or to
1355     detect an error, take that action.  */
1356  yyn += yytoken;
1357  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1358    goto yydefault;
1359  yyn = yytable[yyn];
1360  if (yyn <= 0)
1361    {
1362      if (yyn == 0 || yyn == YYTABLE_NINF)
1363        goto yyerrlab;
1364      yyn = -yyn;
1365      goto yyreduce;
1366    }
1367
1368  /* Count tokens shifted since error; after three, turn off error
1369     status.  */
1370  if (yyerrstatus)
1371    yyerrstatus--;
1372
1373  /* Shift the lookahead token.  */
1374  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1375
1376  /* Discard the shifted token.  */
1377  yychar = YYEMPTY;
1378
1379  yystate = yyn;
1380  *++yyvsp = yylval;
1381
1382  goto yynewstate;
1383
1384
1385/*-----------------------------------------------------------.
1386| yydefault -- do the default action for the current state.  |
1387`-----------------------------------------------------------*/
1388yydefault:
1389  yyn = yydefact[yystate];
1390  if (yyn == 0)
1391    goto yyerrlab;
1392  goto yyreduce;
1393
1394
1395/*-----------------------------.
1396| yyreduce -- Do a reduction.  |
1397`-----------------------------*/
1398yyreduce:
1399  /* yyn is the number of a rule to reduce with.  */
1400  yylen = yyr2[yyn];
1401
1402  /* If YYLEN is nonzero, implement the default value of the action:
1403     `$$ = $1'.
1404
1405     Otherwise, the following line sets YYVAL to garbage.
1406     This behavior is undocumented and Bison
1407     users should not rely upon it.  Assigning to YYVAL
1408     unconditionally makes the parser a bit smaller, and it avoids a
1409     GCC warning that YYVAL may be used uninitialized.  */
1410  yyval = yyvsp[1-yylen];
1411
1412
1413  YY_REDUCE_PRINT (yyn);
1414  switch (yyn)
1415    {
1416        case 8:
1417
1418/* Line 1464 of yacc.c  */
1419#line 43 "dce.y"
1420    {projections(parsestate,(yyvsp[(1) - (1)]));;}
1421    break;
1422
1423  case 9:
1424
1425/* Line 1464 of yacc.c  */
1426#line 47 "dce.y"
1427    {selections(parsestate,(yyvsp[(1) - (1)]));;}
1428    break;
1429
1430  case 10:
1431
1432/* Line 1464 of yacc.c  */
1433#line 52 "dce.y"
1434    {(yyval)=projectionlist(parsestate,(Object)null,(yyvsp[(1) - (1)]));;}
1435    break;
1436
1437  case 11:
1438
1439/* Line 1464 of yacc.c  */
1440#line 54 "dce.y"
1441    {(yyval)=projectionlist(parsestate,(yyvsp[(1) - (3)]),(yyvsp[(3) - (3)]));;}
1442    break;
1443
1444  case 12:
1445
1446/* Line 1464 of yacc.c  */
1447#line 59 "dce.y"
1448    {(yyval)=projection(parsestate,(yyvsp[(1) - (1)]));;}
1449    break;
1450
1451  case 13:
1452
1453/* Line 1464 of yacc.c  */
1454#line 61 "dce.y"
1455    {(yyval)=(yyvsp[(1) - (1)]);;}
1456    break;
1457
1458  case 14:
1459
1460/* Line 1464 of yacc.c  */
1461#line 66 "dce.y"
1462    {(yyval)=function(parsestate,(yyvsp[(1) - (3)]),null);;}
1463    break;
1464
1465  case 15:
1466
1467/* Line 1464 of yacc.c  */
1468#line 68 "dce.y"
1469    {(yyval)=function(parsestate,(yyvsp[(1) - (4)]),(yyvsp[(3) - (4)]));;}
1470    break;
1471
1472  case 16:
1473
1474/* Line 1464 of yacc.c  */
1475#line 73 "dce.y"
1476    {(yyval)=segmentlist(parsestate,null,(yyvsp[(1) - (1)]));;}
1477    break;
1478
1479  case 17:
1480
1481/* Line 1464 of yacc.c  */
1482#line 75 "dce.y"
1483    {(yyval)=segmentlist(parsestate,(yyvsp[(1) - (3)]),(yyvsp[(3) - (3)]));;}
1484    break;
1485
1486  case 18:
1487
1488/* Line 1464 of yacc.c  */
1489#line 80 "dce.y"
1490    {(yyval)=segment(parsestate,(yyvsp[(1) - (1)]),null);;}
1491    break;
1492
1493  case 19:
1494
1495/* Line 1464 of yacc.c  */
1496#line 82 "dce.y"
1497    {(yyval)=segment(parsestate,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)]));;}
1498    break;
1499
1500  case 20:
1501
1502/* Line 1464 of yacc.c  */
1503#line 87 "dce.y"
1504    {(yyval)=rangelist(parsestate,null,(yyvsp[(1) - (1)]));;}
1505    break;
1506
1507  case 21:
1508
1509/* Line 1464 of yacc.c  */
1510#line 89 "dce.y"
1511    {(yyval)=rangelist(parsestate,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)]));;}
1512    break;
1513
1514  case 22:
1515
1516/* Line 1464 of yacc.c  */
1517#line 94 "dce.y"
1518    {(yyval)=range(parsestate,(yyvsp[(2) - (3)]),null,null);;}
1519    break;
1520
1521  case 23:
1522
1523/* Line 1464 of yacc.c  */
1524#line 96 "dce.y"
1525    {(yyval)=range(parsestate,(yyvsp[(2) - (5)]),null,(yyvsp[(4) - (5)]));;}
1526    break;
1527
1528  case 24:
1529
1530/* Line 1464 of yacc.c  */
1531#line 98 "dce.y"
1532    {(yyval)=range(parsestate,(yyvsp[(2) - (7)]),(yyvsp[(4) - (7)]),(yyvsp[(6) - (7)]));;}
1533    break;
1534
1535  case 25:
1536
1537/* Line 1464 of yacc.c  */
1538#line 102 "dce.y"
1539    {(yyval) = range1(parsestate,(yyvsp[(2) - (3)]));;}
1540    break;
1541
1542  case 26:
1543
1544/* Line 1464 of yacc.c  */
1545#line 108 "dce.y"
1546    {(yyval)=clauselist(parsestate,null,(yyvsp[(1) - (1)]));;}
1547    break;
1548
1549  case 27:
1550
1551/* Line 1464 of yacc.c  */
1552#line 110 "dce.y"
1553    {(yyval)=clauselist(parsestate,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)]));;}
1554    break;
1555
1556  case 28:
1557
1558/* Line 1464 of yacc.c  */
1559#line 115 "dce.y"
1560    {(yyval)=sel_clause(parsestate,1,(yyvsp[(2) - (6)]),(yyvsp[(3) - (6)]),(yyvsp[(5) - (6)]));;}
1561    break;
1562
1563  case 29:
1564
1565/* Line 1464 of yacc.c  */
1566#line 117 "dce.y"
1567    {(yyval)=sel_clause(parsestate,2,(yyvsp[(2) - (4)]),(yyvsp[(3) - (4)]),(yyvsp[(4) - (4)]));;}
1568    break;
1569
1570  case 30:
1571
1572/* Line 1464 of yacc.c  */
1573#line 119 "dce.y"
1574    {(yyval)=(yyvsp[(1) - (2)]);;}
1575    break;
1576
1577  case 31:
1578
1579/* Line 1464 of yacc.c  */
1580#line 124 "dce.y"
1581    {(yyval)=value_list(parsestate,null,(yyvsp[(1) - (1)]));;}
1582    break;
1583
1584  case 32:
1585
1586/* Line 1464 of yacc.c  */
1587#line 126 "dce.y"
1588    {(yyval)=value_list(parsestate,(yyvsp[(1) - (3)]),(yyvsp[(3) - (3)]));;}
1589    break;
1590
1591  case 33:
1592
1593/* Line 1464 of yacc.c  */
1594#line 131 "dce.y"
1595    {(yyval)=value(parsestate,(yyvsp[(1) - (1)]));;}
1596    break;
1597
1598  case 34:
1599
1600/* Line 1464 of yacc.c  */
1601#line 133 "dce.y"
1602    {(yyval)=value(parsestate,(yyvsp[(1) - (1)]));;}
1603    break;
1604
1605  case 35:
1606
1607/* Line 1464 of yacc.c  */
1608#line 135 "dce.y"
1609    {(yyval)=value(parsestate,(yyvsp[(1) - (1)]));;}
1610    break;
1611
1612  case 36:
1613
1614/* Line 1464 of yacc.c  */
1615#line 140 "dce.y"
1616    {(yyval)=constant(parsestate,(yyvsp[(1) - (1)]),SCAN_NUMBERCONST);;}
1617    break;
1618
1619  case 37:
1620
1621/* Line 1464 of yacc.c  */
1622#line 142 "dce.y"
1623    {(yyval)=constant(parsestate,(yyvsp[(1) - (1)]),SCAN_STRINGCONST);;}
1624    break;
1625
1626  case 38:
1627
1628/* Line 1464 of yacc.c  */
1629#line 147 "dce.y"
1630    {(yyval)=var(parsestate,(yyvsp[(1) - (1)]));;}
1631    break;
1632
1633  case 39:
1634
1635/* Line 1464 of yacc.c  */
1636#line 152 "dce.y"
1637    {(yyval)=indexpath(parsestate,null,(yyvsp[(1) - (1)]));;}
1638    break;
1639
1640  case 40:
1641
1642/* Line 1464 of yacc.c  */
1643#line 154 "dce.y"
1644    {(yyval)=indexpath(parsestate,(yyvsp[(1) - (3)]),(yyvsp[(3) - (3)]));;}
1645    break;
1646
1647  case 41:
1648
1649/* Line 1464 of yacc.c  */
1650#line 159 "dce.y"
1651    {(yyval)=indexer(parsestate,(yyvsp[(1) - (1)]),null);;}
1652    break;
1653
1654  case 42:
1655
1656/* Line 1464 of yacc.c  */
1657#line 161 "dce.y"
1658    {(yyval)=indexer(parsestate,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)]));;}
1659    break;
1660
1661  case 43:
1662
1663/* Line 1464 of yacc.c  */
1664#line 166 "dce.y"
1665    {(yyval)=array_indices(parsestate,null,(yyvsp[(1) - (1)]));;}
1666    break;
1667
1668  case 44:
1669
1670/* Line 1464 of yacc.c  */
1671#line 168 "dce.y"
1672    {(yyval)=array_indices(parsestate,(yyvsp[(1) - (2)]),(yyvsp[(2) - (2)]));;}
1673    break;
1674
1675  case 45:
1676
1677/* Line 1464 of yacc.c  */
1678#line 173 "dce.y"
1679    {(yyval)=function(parsestate,(yyvsp[(1) - (3)]),null);;}
1680    break;
1681
1682  case 46:
1683
1684/* Line 1464 of yacc.c  */
1685#line 175 "dce.y"
1686    {(yyval)=function(parsestate,(yyvsp[(1) - (4)]),(yyvsp[(3) - (4)]));;}
1687    break;
1688
1689  case 47:
1690
1691/* Line 1464 of yacc.c  */
1692#line 180 "dce.y"
1693    {(yyval)=arg_list(parsestate,null,(yyvsp[(1) - (1)]));;}
1694    break;
1695
1696  case 48:
1697
1698/* Line 1464 of yacc.c  */
1699#line 182 "dce.y"
1700    {(yyval)=arg_list(parsestate,(yyvsp[(1) - (3)]),(yyvsp[(3) - (3)]));;}
1701    break;
1702
1703  case 49:
1704
1705/* Line 1464 of yacc.c  */
1706#line 186 "dce.y"
1707    {(yyval)=makeselectiontag(CEO_EQ);;}
1708    break;
1709
1710  case 50:
1711
1712/* Line 1464 of yacc.c  */
1713#line 187 "dce.y"
1714    {(yyval)=makeselectiontag(CEO_GT);;}
1715    break;
1716
1717  case 51:
1718
1719/* Line 1464 of yacc.c  */
1720#line 188 "dce.y"
1721    {(yyval)=makeselectiontag(CEO_LT);;}
1722    break;
1723
1724  case 52:
1725
1726/* Line 1464 of yacc.c  */
1727#line 189 "dce.y"
1728    {(yyval)=makeselectiontag(CEO_NEQ);;}
1729    break;
1730
1731  case 53:
1732
1733/* Line 1464 of yacc.c  */
1734#line 190 "dce.y"
1735    {(yyval)=makeselectiontag(CEO_GE);;}
1736    break;
1737
1738  case 54:
1739
1740/* Line 1464 of yacc.c  */
1741#line 191 "dce.y"
1742    {(yyval)=makeselectiontag(CEO_LE);;}
1743    break;
1744
1745  case 55:
1746
1747/* Line 1464 of yacc.c  */
1748#line 192 "dce.y"
1749    {(yyval)=makeselectiontag(CEO_RE);;}
1750    break;
1751
1752  case 56:
1753
1754/* Line 1464 of yacc.c  */
1755#line 196 "dce.y"
1756    {(yyval) = (yyvsp[(1) - (1)]);;}
1757    break;
1758
1759  case 57:
1760
1761/* Line 1464 of yacc.c  */
1762#line 200 "dce.y"
1763    {(yyval) = checkobject((yyvsp[(1) - (1)]));;}
1764    break;
1765
1766  case 58:
1767
1768/* Line 1464 of yacc.c  */
1769#line 204 "dce.y"
1770    {(yyval) = checkobject((yyvsp[(1) - (1)]));;}
1771    break;
1772
1773  case 59:
1774
1775/* Line 1464 of yacc.c  */
1776#line 208 "dce.y"
1777    {(yyval) = checkobject((yyvsp[(1) - (1)]));;}
1778    break;
1779
1780
1781
1782/* Line 1464 of yacc.c  */
1783#line 1786 "dce.tab.c"
1784      default: break;
1785    }
1786  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1787
1788  YYPOPSTACK (yylen);
1789  yylen = 0;
1790  YY_STACK_PRINT (yyss, yyssp);
1791
1792  *++yyvsp = yyval;
1793
1794  /* Now `shift' the result of the reduction.  Determine what state
1795     that goes to, based on the state we popped back to and the rule
1796     number reduced by.  */
1797
1798  yyn = yyr1[yyn];
1799
1800  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1801  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1802    yystate = yytable[yystate];
1803  else
1804    yystate = yydefgoto[yyn - YYNTOKENS];
1805
1806  goto yynewstate;
1807
1808
1809/*------------------------------------.
1810| yyerrlab -- here on detecting error |
1811`------------------------------------*/
1812yyerrlab:
1813  /* If not already recovering from an error, report this error.  */
1814  if (!yyerrstatus)
1815    {
1816      ++yynerrs;
1817#if ! YYERROR_VERBOSE
1818      yyerror (parsestate, YY_("syntax error"));
1819#else
1820      {
1821        YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1822        if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1823          {
1824            YYSIZE_T yyalloc = 2 * yysize;
1825            if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1826              yyalloc = YYSTACK_ALLOC_MAXIMUM;
1827            if (yymsg != yymsgbuf)
1828              YYSTACK_FREE (yymsg);
1829            yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1830            if (yymsg)
1831              yymsg_alloc = yyalloc;
1832            else
1833              {
1834                yymsg = yymsgbuf;
1835                yymsg_alloc = sizeof yymsgbuf;
1836              }
1837          }
1838
1839        if (0 < yysize && yysize <= yymsg_alloc)
1840          {
1841            (void) yysyntax_error (yymsg, yystate, yychar);
1842            yyerror (parsestate, yymsg);
1843          }
1844        else
1845          {
1846            yyerror (parsestate, YY_("syntax error"));
1847            if (yysize != 0)
1848              goto yyexhaustedlab;
1849          }
1850      }
1851#endif
1852    }
1853
1854
1855
1856  if (yyerrstatus == 3)
1857    {
1858      /* If just tried and failed to reuse lookahead token after an
1859         error, discard it.  */
1860
1861      if (yychar <= YYEOF)
1862        {
1863          /* Return failure if at end of input.  */
1864          if (yychar == YYEOF)
1865            YYABORT;
1866        }
1867      else
1868        {
1869          yydestruct ("Error: discarding",
1870                      yytoken, &yylval, parsestate);
1871          yychar = YYEMPTY;
1872        }
1873    }
1874
1875  /* Else will try to reuse lookahead token after shifting the error
1876     token.  */
1877  goto yyerrlab1;
1878
1879
1880/*---------------------------------------------------.
1881| yyerrorlab -- error raised explicitly by YYERROR.  |
1882`---------------------------------------------------*/
1883yyerrorlab:
1884
1885  /* Pacify compilers like GCC when the user code never invokes
1886     YYERROR and the label yyerrorlab therefore never appears in user
1887     code.  */
1888  if (/*CONSTCOND*/ 0)
1889     goto yyerrorlab;
1890
1891  /* Do not reclaim the symbols of the rule which action triggered
1892     this YYERROR.  */
1893  YYPOPSTACK (yylen);
1894  yylen = 0;
1895  YY_STACK_PRINT (yyss, yyssp);
1896  yystate = *yyssp;
1897  goto yyerrlab1;
1898
1899
1900/*-------------------------------------------------------------.
1901| yyerrlab1 -- common code for both syntax error and YYERROR.  |
1902`-------------------------------------------------------------*/
1903yyerrlab1:
1904  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1905
1906  for (;;)
1907    {
1908      yyn = yypact[yystate];
1909      if (yyn != YYPACT_NINF)
1910        {
1911          yyn += YYTERROR;
1912          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1913            {
1914              yyn = yytable[yyn];
1915              if (0 < yyn)
1916                break;
1917            }
1918        }
1919
1920      /* Pop the current state because it cannot handle the error token.  */
1921      if (yyssp == yyss)
1922        YYABORT;
1923
1924
1925      yydestruct ("Error: popping",
1926                  yystos[yystate], yyvsp, parsestate);
1927      YYPOPSTACK (1);
1928      yystate = *yyssp;
1929      YY_STACK_PRINT (yyss, yyssp);
1930    }
1931
1932  *++yyvsp = yylval;
1933
1934
1935  /* Shift the error token.  */
1936  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1937
1938  yystate = yyn;
1939  goto yynewstate;
1940
1941
1942/*-------------------------------------.
1943| yyacceptlab -- YYACCEPT comes here.  |
1944`-------------------------------------*/
1945yyacceptlab:
1946  yyresult = 0;
1947  goto yyreturn;
1948
1949/*-----------------------------------.
1950| yyabortlab -- YYABORT comes here.  |
1951`-----------------------------------*/
1952yyabortlab:
1953  yyresult = 1;
1954  goto yyreturn;
1955
1956#if !defined(yyoverflow) || YYERROR_VERBOSE
1957/*-------------------------------------------------.
1958| yyexhaustedlab -- memory exhaustion comes here.  |
1959`-------------------------------------------------*/
1960yyexhaustedlab:
1961  yyerror (parsestate, YY_("memory exhausted"));
1962  yyresult = 2;
1963  /* Fall through.  */
1964#endif
1965
1966yyreturn:
1967  if (yychar != YYEMPTY)
1968     yydestruct ("Cleanup: discarding lookahead",
1969                 yytoken, &yylval, parsestate);
1970  /* Do not reclaim the symbols of the rule which action triggered
1971     this YYABORT or YYACCEPT.  */
1972  YYPOPSTACK (yylen);
1973  YY_STACK_PRINT (yyss, yyssp);
1974  while (yyssp != yyss)
1975    {
1976      yydestruct ("Cleanup: popping",
1977                  yystos[*yyssp], yyvsp, parsestate);
1978      YYPOPSTACK (1);
1979    }
1980#ifndef yyoverflow
1981  if (yyss != yyssa)
1982    YYSTACK_FREE (yyss);
1983#endif
1984#if YYERROR_VERBOSE
1985  if (yymsg != yymsgbuf)
1986    YYSTACK_FREE (yymsg);
1987#endif
1988  /* Make sure YYID is used.  */
1989  return YYID (yyresult);
1990}
1991
1992
1993
1994/* Line 1684 of yacc.c  */
1995#line 211 "dce.y"
1996
1997
Note: See TracBrowser for help on using the repository browser.