1/* A Bison parser, made by GNU Bison 2.6.4.  */
2
3/* Bison implementation for Yacc-like parsers in C
4
5      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
6
7   This program is free software: you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation, either version 3 of the License, or
10   (at your option) any later version.
11
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20/* As a special exception, you may create a larger work that contains
21   part or all of the Bison parser skeleton and distribute that work
22   under terms of your choice, so long as that work isn't itself a
23   parser generator using the skeleton or a modified version thereof
24   as a parser skeleton.  Alternatively, if you modify or redistribute
25   the parser skeleton itself, you may (at your option) remove this
26   special exception, which will cause the skeleton and the resulting
27   Bison output files to be licensed under the GNU General Public
28   License without this special exception.
29
30   This special exception was added by the Free Software Foundation in
31   version 2.2 of Bison.  */
32
33/* C LALR(1) parser skeleton written by Richard Stallman, by
34   simplifying the original so-called "semantic" parser.  */
35
36/* All symbols defined below should begin with yy or YY, to avoid
37   infringing on user name space.  This should be done even for local
38   variables, as they might otherwise be expanded by user macros.
39   There are some unavoidable exceptions within include files to
40   define necessary library symbols; they are noted "INFRINGES ON
41   USER NAME SPACE" below.  */
42
43/* Identify Bison output.  */
44#define YYBISON 1
45
46/* Bison version.  */
47#define YYBISON_VERSION "2.6.4"
48
49/* Skeleton name.  */
50#define YYSKELETON_NAME "yacc.c"
51
52/* Pure parsers.  */
53#define YYPURE 0
54
55/* Push parsers.  */
56#define YYPUSH 0
57
58/* Pull parsers.  */
59#define YYPULL 1
60
61
62/* Substitute the variable and function names.  */
63#define yyparse         ncgparse
64#define yylex           ncglex
65#define yyerror         ncgerror
66#define yylval          ncglval
67#define yychar          ncgchar
68#define yydebug         ncgdebug
69#define yynerrs         ncgnerrs
70
71/* Copy the first part of user declarations.  */
72/* Line 358 of yacc.c  */
73#line 9 "ncgen.y"
74
75#ifdef sccs
76static char SccsId[] = "$Id: ncgen.y,v 1.34 2010/03/31 18:18:41 dmh Exp $";
77#endif
78#include        "config.h"
79#include        <string.h>
80#include <stdlib.h>
81#include "netcdf.h"
82#include  "generic.h"
83#include        "ncgen.h"
84#include "genlib.h" /* for grow_darray() et al */
85
86typedef struct Symbol { /* symbol table entry */
87 char     *name;
88 struct Symbol   *next;
89 unsigned is_dim : 1; /* appears as netCDF dimension */
90 unsigned is_var : 1; /* appears as netCDF variable */
91 unsigned is_att : 1; /* appears as netCDF attribute */
92 int             dnum;         /* handle as a dimension */
93 int             vnum;         /* handle as a variable */
94 } *YYSTYPE1;
95
96/* True if string a equals string b*/
97#define STREQ(ab) (*(a) == *(b) && strcmp((a), (b)) == 0)
98#define NC_UNSPECIFIED ((nc_type)0) /* unspecified (as yet) type */
99
100#define YYSTYPE YYSTYPE1
101YYSTYPE symlist; /* symbol table: linked list */
102
103extern int derror_count; /* counts errors in netcdf definition */
104extern int lineno; /* line number for error messages */
105
106static int not_a_string; /* whether last constant read was a string */
107static char termstring[MAXTRST]; /* last terminal string read */
108static double double_val; /* last double value read */
109static float float_val; /* last float value read */
110static int int_val; /* last int value read */
111static short short_val; /* last short value read */
112static char char_val; /* last char value read */
113static signed char byte_val; /* last byte value read */
114
115static nc_type type_code; /* holds declared type for variables */
116static nc_type atype_code; /* holds derived type for attributes */
117static char *netcdfname; /* to construct netcdf file name */
118static void *att_space; /* pointer to block for attribute values */
119static nc_type valtype; /* type code for list of attribute values  */
120
121static char *char_valp; /* pointers used to accumulate data values */
122static signed char *byte_valp;
123static short *short_valp;
124static int *int_valp;
125static float *float_valp;
126static double *double_valp;
127static void *rec_cur; /* pointer to where next data value goes */
128static void *rec_start; /* start of space for data */
129
130/* Forward declarations */
131void defatt();
132void equalatt();
133
134#ifdef YYLEX_PARAM
135int yylex(YYLEX_PARAM);
136#else
137int yylex();
138#endif
139
140#ifdef vms
141void yyerror(char*);
142#else
143int yyerror(char*);
144#endif
145
146/* Line 358 of yacc.c  */
147#line 148 "ncgen.tab.c"
148
149# ifndef YY_NULL
150#  if defined __cplusplus && 201103L <= __cplusplus
151#   define YY_NULL nullptr
152#  else
153#   define YY_NULL 0
154#  endif
155# endif
156
157/* Enabling verbose error messages.  */
158#ifdef YYERROR_VERBOSE
159# undef YYERROR_VERBOSE
160# define YYERROR_VERBOSE 1
161#else
162# define YYERROR_VERBOSE 0
163#endif
164
165/* In a future release of Bison, this section will be replaced
166   by #include "ncgen.tab.h".  */
167#ifndef YY_NCG_NCGEN_TAB_H_INCLUDED
168# define YY_NCG_NCGEN_TAB_H_INCLUDED
169/* Enabling traces.  */
170#ifndef YYDEBUG
171# define YYDEBUG 0
172#endif
173#if YYDEBUG
174extern int ncgdebug;
175#endif
176
177/* Tokens.  */
178#ifndef YYTOKENTYPE
179# define YYTOKENTYPE
180   /* Put the tokens into the symbol table, so that GDB and other debuggers
181      know about them.  */
182   enum yytokentype {
183     NC_UNLIMITED_K = 258,
184     BYTE_K = 259,
185     CHAR_K = 260,
186     SHORT_K = 261,
187     INT_K = 262,
188     FLOAT_K = 263,
189     DOUBLE_K = 264,
190     IDENT = 265,
191     TERMSTRING = 266,
192     BYTE_CONST = 267,
193     CHAR_CONST = 268,
194     SHORT_CONST = 269,
195     INT_CONST = 270,
196     FLOAT_CONST = 271,
197     DOUBLE_CONST = 272,
198     DIMENSIONS = 273,
199     VARIABLES = 274,
200     NETCDF = 275,
201     DATA = 276,
202     FILLVALUE = 277
203   };
204#endif
205
206
207#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
208typedef int YYSTYPE;
209# define YYSTYPE_IS_TRIVIAL 1
210# define yystype YYSTYPE /* obsolescent; will be withdrawn */
211# define YYSTYPE_IS_DECLARED 1
212#endif
213
214extern YYSTYPE ncglval;
215
216#ifdef YYPARSE_PARAM
217#if defined __STDC__ || defined __cplusplus
218int ncgparse (void *YYPARSE_PARAM);
219#else
220int ncgparse ();
221#endif
222#else /* ! YYPARSE_PARAM */
223#if defined __STDC__ || defined __cplusplus
224int ncgparse (void);
225#else
226int ncgparse ();
227#endif
228#endif /* ! YYPARSE_PARAM */
229
230#endif /* !YY_NCG_NCGEN_TAB_H_INCLUDED  */
231
232/* Copy the second part of user declarations.  */
233
234/* Line 377 of yacc.c  */
235#line 236 "ncgen.tab.c"
236
237#ifdef short
238# undef short
239#endif
240
241#ifdef YYTYPE_UINT8
242typedef YYTYPE_UINT8 yytype_uint8;
243#else
244typedef unsigned char yytype_uint8;
245#endif
246
247#ifdef YYTYPE_INT8
248typedef YYTYPE_INT8 yytype_int8;
249#elif (defined __STDC__ || defined __C99__FUNC__ \
250     || defined __cplusplus || defined _MSC_VER)
251typedef signed char yytype_int8;
252#else
253typedef short int yytype_int8;
254#endif
255
256#ifdef YYTYPE_UINT16
257typedef YYTYPE_UINT16 yytype_uint16;
258#else
259typedef unsigned short int yytype_uint16;
260#endif
261
262#ifdef YYTYPE_INT16
263typedef YYTYPE_INT16 yytype_int16;
264#else
265typedef short int yytype_int16;
266#endif
267
268#ifndef YYSIZE_T
269# ifdef __SIZE_TYPE__
270#  define YYSIZE_T __SIZE_TYPE__
271# elif defined size_t
272#  define YYSIZE_T size_t
273# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
274     || defined __cplusplus || defined _MSC_VER)
275#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
276#  define YYSIZE_T size_t
277# else
278#  define YYSIZE_T unsigned int
279# endif
280#endif
281
282#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
283
284#ifndef YY_
285# if defined YYENABLE_NLS && YYENABLE_NLS
286#  if ENABLE_NLS
287#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
288#   define YY_(Msgiddgettext ("bison-runtime", Msgid)
289#  endif
290# endif
291# ifndef YY_
292#  define YY_(MsgidMsgid
293# endif
294#endif
295
296/* Suppress unused-variable warnings by "using" E.  */
297#if ! defined lint || defined __GNUC__
298# define YYUSE(E) ((void) (E))
299#else
300# define YYUSE(E) /* empty */
301#endif
302
303/* Identity function, used to suppress warnings about constant conditions.  */
304#ifndef lint
305# define YYID(N) (N)
306#else
307#if (defined __STDC__ || defined __C99__FUNC__ \
308     || defined __cplusplus || defined _MSC_VER)
309static int
310YYID (int yyi)
311#else
312static int
313YYID (yyi)
314    int yyi;
315#endif
316{
317  return yyi;
318}
319#endif
320
321#if ! defined yyoverflow || YYERROR_VERBOSE
322
323/* The parser invokes alloca or malloc; define the necessary symbols.  */
324
325# ifdef YYSTACK_USE_ALLOCA
326#  if YYSTACK_USE_ALLOCA
327#   ifdef __GNUC__
328#    define YYSTACK_ALLOC __builtin_alloca
329#   elif defined __BUILTIN_VA_ARG_INCR
330#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
331#   elif defined _AIX
332#    define YYSTACK_ALLOC __alloca
333#   elif defined _MSC_VER
334#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
335#    define alloca _alloca
336#   else
337#    define YYSTACK_ALLOC alloca
338#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
339     || defined __cplusplus || defined _MSC_VER)
340#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
341      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
342#     ifndef EXIT_SUCCESS
343#      define EXIT_SUCCESS 0
344#     endif
345#    endif
346#   endif
347#  endif
348# endif
349
350# ifdef YYSTACK_ALLOC
351   /* Pacify GCC's `empty if-body' warning.  */
352#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
353#  ifndef YYSTACK_ALLOC_MAXIMUM
354    /* The OS might guarantee only one guard page at the bottom of the stack,
355       and a page size can be as small as 4096 bytes.  So we cannot safely
356       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
357       to allow for a few compiler-allocated temporary stack slots.  */
358#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
359#  endif
360# else
361#  define YYSTACK_ALLOC YYMALLOC
362#  define YYSTACK_FREE YYFREE
363#  ifndef YYSTACK_ALLOC_MAXIMUM
364#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
365#  endif
366#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
367       && ! ((defined YYMALLOC || defined malloc) \
368      && (defined YYFREE || defined free)))
369#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
370#   ifndef EXIT_SUCCESS
371#    define EXIT_SUCCESS 0
372#   endif
373#  endif
374#  ifndef YYMALLOC
375#   define YYMALLOC malloc
376#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
377     || defined __cplusplus || defined _MSC_VER)
378void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
379#   endif
380#  endif
381#  ifndef YYFREE
382#   define YYFREE free
383#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
384     || defined __cplusplus || defined _MSC_VER)
385void free (void *); /* INFRINGES ON USER NAME SPACE */
386#   endif
387#  endif
388# endif
389#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
390
391
392#if (! defined yyoverflow \
393     && (! defined __cplusplus \
394  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
395
396/* A type that is properly aligned for any stack member.  */
397union yyalloc
398{
399  yytype_int16 yyss_alloc;
400  YYSTYPE yyvs_alloc;
401};
402
403/* The size of the maximum gap between one aligned stack and the next.  */
404# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
405
406/* The size of an array large to enough to hold all stacks, each with
407   N elements.  */
408# define YYSTACK_BYTES(N) \
409     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
410      + YYSTACK_GAP_MAXIMUM)
411
412# define YYCOPY_NEEDED 1
413
414/* Relocate STACK from its old location to the new one.  The
415   local variables YYSIZE and YYSTACKSIZE give the old and new number of
416   elements in the stack, and YYPTR gives the new location of the
417   stack.  Advance YYPTR to a properly aligned location for the next
418   stack.  */
419# define YYSTACK_RELOCATE(Stack_allocStack) \
420    do \
421      { \
422 YYSIZE_T yynewbytes; \
423 YYCOPY (&yyptr->Stack_allocStackyysize); \
424 Stack = &yyptr->Stack_alloc; \
425 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
426 yyptr += yynewbytes / sizeof (*yyptr); \
427      } \
428    while (YYID (0))
429
430#endif
431
432#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
433/* Copy COUNT objects from SRC to DST.  The source and destination do
434   not overlap.  */
435# ifndef YYCOPY
436#  if defined __GNUC__ && 1 < __GNUC__
437#   define YYCOPY(DstSrcCount) \
438      __builtin_memcpy (DstSrc, (Count) * sizeof (*(Src)))
439#  else
440#   define YYCOPY(DstSrcCount)              \
441      do                                        \
442        {                                       \
443          YYSIZE_T yyi;                         \
444          for (yyi = 0; yyi < (Count); yyi++)   \
445            (Dst)[yyi] = (Src)[yyi];            \
446        }                                       \
447      while (YYID (0))
448#  endif
449# endif
450#endif /* !YYCOPY_NEEDED */
451
452/* YYFINAL -- State number of the termination state.  */
453#define YYFINAL  4
454/* YYLAST -- Last index in YYTABLE.  */
455#define YYLAST   78
456
457/* YYNTOKENS -- Number of terminals.  */
458#define YYNTOKENS  31
459/* YYNNTS -- Number of nonterminals.  */
460#define YYNNTS  42
461/* YYNRULES -- Number of rules.  */
462#define YYNRULES  79
463/* YYNRULES -- Number of states.  */
464#define YYNSTATES  112
465
466/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
467#define YYUNDEFTOK  2
468#define YYMAXUTOK   277
469
470#define YYTRANSLATE(YYX) \
471  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
472
473/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
474static const yytype_uint8 yytranslate[] =
475{
476       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
477       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
478       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
479       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
480      28,    29,     2,     2,    26,     2,     2,     2,     2,     2,
481       2,     2,     2,     2,     2,     2,     2,     2,    30,    25,
482       2,    27,     2,     2,     2,     2,     2,     2,     2,     2,
483       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
484       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
485       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
486       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
487       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
488       2,     2,     2,    23,     2,    24,     2,     2,     2,     2,
489       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
490       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
491       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
492       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
493       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
494       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
495       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
496       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
497       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
498       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
499       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
500       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
501       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
502       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
503      15,    16,    17,    18,    19,    20,    21,    22
504};
505
506#if YYDEBUG
507/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
508   YYRHS.  */
509static const yytype_uint8 yyprhs[] =
510{
511       0,     0,     3,     4,     5,    14,    15,    18,    21,    25,
512      27,    31,    35,    39,    43,    45,    47,    48,    51,    53,
513      56,    60,    62,    64,    66,    69,    73,    76,    78,    80,
514      82,    84,    86,    88,    90,    94,    95,    99,   101,   102,
515     106,   108,   112,   114,   115,   120,   121,   126,   130,   133,
516     135,   137,   139,   143,   145,   147,   149,   151,   153,   155,
517     157,   159,   160,   163,   165,   168,   172,   173,   178,   180,
518     184,   185,   188,   190,   192,   194,   196,   198,   200,   202
519};
520
521/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
522static const yytype_int8 yyrhs[] =
523{
524      32,     0,    -1,    -1,    -1,    20,    23,    33,    35,    41,
525      34,    65,    24,    -1,    -1,    18,    36,    -1,    37,    25,
526      -1,    36,    37,    25,    -1,    38,    -1,    37,    26,    38,
527      -1,    39,    27,    15,    -1,    39,    27,    17,    -1,    39,
528      27,     3,    -1,    40,    -1,    10,    -1,    -1,    19,    42,
529      -1,    44,    -1,    43,    25,    -1,    42,    43,    25,    -1,
530      45,    -1,    54,    -1,    56,    -1,    56,    25,    -1,    44,
531      56,    25,    -1,    46,    47,    -1,     4,    -1,     5,    -1,
532       6,    -1,     7,    -1,     8,    -1,     9,    -1,    48,    -1,
533      47,    26,    48,    -1,    -1,    50,    49,    51,    -1,    10,
534      -1,    -1,    28,    52,    29,    -1,    53,    -1,    52,    26,
535      53,    -1,    40,    -1,    -1,    58,    55,    27,    62,    -1,
536      -1,    59,    57,    27,    62,    -1,    60,    30,    61,    -1,
537      30,    61,    -1,    50,    -1,    10,    -1,    63,    -1,    62,
538      26,    63,    -1,    64,    -1,    13,    -1,    11,    -1,    12,
539      -1,    14,    -1,    15,    -1,    16,    -1,    17,    -1,    -1,
540      21,    66,    -1,    21,    -1,    67,    25,    -1,    66,    67,
541      25,    -1,    -1,    60,    68,    27,    69,    -1,    70,    -1,
542      69,    26,    70,    -1,    -1,    71,    72,    -1,    13,    -1,
543      11,    -1,    12,    -1,    14,    -1,    15,    -1,    16,    -1,
544      17,    -1,    22,    -1
545};
546
547/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
548static const yytype_uint16 yyrline[] =
549{
550       0,   114,   114,   117,   112,   130,   131,   133,   134,   136,
551     137,   139,   145,   156,   164,   181,   183,   184,   185,   187,
552     188,   190,   190,   190,   192,   193,   195,   197,   198,   199,
553     200,   201,   202,   204,   205,   208,   207,   246,   248,   249,
554     251,   252,   254,   276,   275,   285,   284,   294,   296,   302,
555     312,   323,   324,   326,   335,   341,   354,   360,   366,   372,
556     378,   386,   387,   388,   391,   392,   395,   394,   461,   462,
557     465,   465,   517,   543,   598,   624,   650,   676,   702,   731
558};
559#endif
560
561#if YYDEBUG || YYERROR_VERBOSE || 0
562/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
563   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
564static const char *const yytname[] =
565{
566  "$end", "error", "$undefined", "NC_UNLIMITED_K", "BYTE_K", "CHAR_K",
567  "SHORT_K", "INT_K", "FLOAT_K", "DOUBLE_K", "IDENT", "TERMSTRING",
568  "BYTE_CONST", "CHAR_CONST", "SHORT_CONST", "INT_CONST", "FLOAT_CONST",
569  "DOUBLE_CONST", "DIMENSIONS", "VARIABLES", "NETCDF", "DATA", "FILLVALUE",
570  "'{'", "'}'", "';'", "','", "'='", "'('", "')'", "':'", "$accept",
571  "ncdesc", "$@1", "$@2", "dimsection", "dimdecls", "dimdecline",
572  "dimdecl", "dimd", "dim", "vasection", "vadecls", "vadecl", "gattdecls",
573  "vardecl", "type", "varlist", "varspec", "$@3", "var", "dimspec",
574  "dimlist", "vdim", "attdecl", "$@4", "gattdecl", "$@5", "att", "gatt",
575  "avar", "attr", "attvallist", "aconst", "attconst", "datasection",
576  "datadecls", "datadecl", "$@6", "constlist", "dconst", "$@7", "const", YY_NULL
577};
578#endif
579
580# ifdef YYPRINT
581/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
582   token YYLEX-NUM.  */
583static const yytype_uint16 yytoknum[] =
584{
585       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
586     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
587     275,   276,   277,   123,   125,    59,    44,    61,    40,    41,
588      58
589};
590# endif
591
592/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
593static const yytype_uint8 yyr1[] =
594{
595       0,    31,    33,    34,    32,    35,    35,    36,    36,    37,
596      37,    38,    38,    38,    39,    40,    41,    41,    41,    42,
597      42,    43,    43,    43,    44,    44,    45,    46,    46,    46,
598      46,    46,    46,    47,    47,    49,    48,    50,    51,    51,
599      52,    52,    53,    55,    54,    57,    56,    58,    59,    60,
600      61,    62,    62,    63,    64,    64,    64,    64,    64,    64,
601      64,    65,    65,    65,    66,    66,    68,    67,    69,    69,
602      71,    70,    72,    72,    72,    72,    72,    72,    72,    72
603};
604
605/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
606static const yytype_uint8 yyr2[] =
607{
608       0,     2,     0,     0,     8,     0,     2,     2,     3,     1,
609       3,     3,     3,     3,     1,     1,     0,     2,     1,     2,
610       3,     1,     1,     1,     2,     3,     2,     1,     1,     1,
611       1,     1,     1,     1,     3,     0,     3,     1,     0,     3,
612       1,     3,     1,     0,     4,     0,     4,     3,     2,     1,
613       1,     1,     3,     1,     1,     1,     1,     1,     1,     1,
614       1,     0,     2,     1,     2,     3,     0,     4,     1,     3,
615       0,     2,     1,     1,     1,     1,     1,     1,     1,     1
616};
617
618/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
619   Performed when YYTABLE doesn't specify something else to do.  Zero
620   means the default is an error.  */
621static const yytype_uint8 yydefact[] =
622{
623       0,     0,     0,     2,     1,     5,     0,    16,    15,     6,
624       0,     9,     0,    14,     0,     0,     3,    18,     0,    45,
625       0,     7,     0,     0,    27,    28,    29,    30,    31,    32,
626      37,    17,     0,    21,     0,    49,    22,    23,    43,     0,
627      50,    48,    61,     0,    24,     0,     8,    10,    13,    11,
628      12,     0,    19,    26,    33,    35,     0,     0,    63,     0,
629      25,     0,    20,     0,    38,     0,    47,    66,    62,     0,
630       4,    55,    56,    54,    57,    58,    59,    60,    46,    51,
631      53,    34,     0,    36,    44,     0,     0,    64,     0,    42,
632       0,    40,    70,    65,    52,     0,    39,    67,    68,     0,
633      41,    70,    73,    74,    72,    75,    76,    77,    78,    79,
634      71,    69
635};
636
637/* YYDEFGOTO[NTERM-NUM].  */
638static const yytype_int8 yydefgoto[] =
639{
640      -1,     2,     5,    42,     7,     9,    10,    11,    12,    13,
641      16,    31,    32,    17,    33,    34,    53,    54,    64,    35,
642      83,    90,    91,    36,    56,    37,    45,    38,    19,    39,
643      41,    78,    79,    80,    59,    68,    69,    85,    97,    98,
644      99,   110
645};
646
647/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
648   STATE-NUM.  */
649#define YYPACT_NINF -73
650static const yytype_int8 yypact[] =
651{
652      10,     3,    31,   -73,   -73,    19,    36,     6,   -73,    36,
653       7,   -73,    20,   -73,    -3,    38,   -73,    21,    24,   -73,
654       9,   -73,    36,     5,   -73,   -73,   -73,   -73,   -73,   -73,
655     -73,    -3,    25,   -73,    42,   -73,   -73,   -73,   -73,    23,
656     -73,   -73,    33,    30,   -73,    29,   -73,   -73,   -73,   -73,
657     -73,    32,   -73,    34,   -73,   -73,    35,    38,    42,    37,
658     -73,    28,   -73,    42,    39,    28,   -73,   -73,    42,    40,
659     -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,    43,   -73,
660     -73,   -73,    36,   -73,    43,    41,    45,   -73,    28,   -73,
661     -17,   -73,   -73,   -73,   -73,    36,   -73,    46,   -73,     2,
662     -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,   -73,
663     -73,   -73
664};
665
666/* YYPGOTO[NTERM-NUM].  */
667static const yytype_int8 yypgoto[] =
668{
669     -73,   -73,   -73,   -73,   -73,   -73,    49,    44,   -73,   -72,
670     -73,   -73,    47,   -73,   -73,   -73,   -73,    -4,   -73,   -34,
671     -73,   -73,   -32,   -73,   -73,     4,   -73,   -73,   -73,   -30,
672      14,    -1,   -15,   -73,   -73,   -73,     8,   -73,   -73,   -27,
673     -73,   -73
674};
675
676/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
677   positive, shift that token.  If negative, reduce the rule which
678   number is the opposite.  If YYTABLE_NINF, syntax error.  */
679#define YYTABLE_NINF -1
680static const yytype_uint8 yytable[] =
681{
682      55,    24,    25,    26,    27,    28,    29,    30,    48,    95,
683      89,    18,    96,   102,   103,   104,   105,   106,   107,   108,
684      49,    43,    50,    89,   109,    14,     3,    15,    67,    55,
685       1,     4,    21,    22,    46,    22,    15,     6,    67,    71,
686      72,    73,    74,    75,    76,    77,     8,    23,    40,    44,
687      52,    15,    30,    57,    58,    60,    61,    62,    20,    81,
688      63,    70,    65,   100,    84,    87,    47,    82,    92,    88,
689      93,    66,   101,    94,   111,     0,    86,     0,    51
690};
691
692#define yypact_value_is_default(Yystate) \
693  (!!((Yystate) == (-73)))
694
695#define yytable_value_is_error(Yytable_value) \
696  YYID (0)
697
698static const yytype_int8 yycheck[] =
699{
700      34,     4,     5,     6,     7,     8,     9,    10,     3,    26,
701      82,     7,    29,    11,    12,    13,    14,    15,    16,    17,
702      15,    17,    17,    95,    22,    19,    23,    30,    58,    63,
703      20,     0,    25,    26,    25,    26,    30,    18,    68,    11,
704      12,    13,    14,    15,    16,    17,    10,    27,    10,    25,
705      25,    30,    10,    30,    21,    25,    27,    25,     9,    63,
706      26,    24,    27,    95,    65,    25,    22,    28,    27,    26,
707      25,    57,    26,    88,   101,    -1,    68,    -1,    31
708};
709
710/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
711   symbol of state STATE-NUM.  */
712static const yytype_uint8 yystos[] =
713{
714       0,    20,    32,    23,     0,    33,    18,    35,    10,    36,
715      37,    38,    39,    40,    19,    30,    41,    44,    56,    59,
716      37,    25,    26,    27,     4,     5,     6,     7,     8,     9,
717      10,    42,    43,    45,    46,    50,    54,    56,    58,    60,
718      10,    61,    34,    56,    25,    57,    25,    38,     3,    15,
719      17,    43,    25,    47,    48,    50,    55,    30,    21,    65,
720      25,    27,    25,    26,    49,    27,    61,    60,    66,    67,
721      24,    11,    12,    13,    14,    15,    16,    17,    62,    63,
722      64,    48,    28,    51,    62,    68,    67,    25,    26,    40,
723      52,    53,    27,    25,    63,    26,    29,    69,    70,    71,
724      53,    26,    11,    12,    13,    14,    15,    16,    17,    22,
725      72,    70
726};
727
728#define yyerrok (yyerrstatus = 0)
729#define yyclearin (yychar = YYEMPTY)
730#define YYEMPTY (-2)
731#define YYEOF 0
732
733#define YYACCEPT goto yyacceptlab
734#define YYABORT goto yyabortlab
735#define YYERROR goto yyerrorlab
736
737
738/* Like YYERROR except do call yyerror.  This remains here temporarily
739   to ease the transition to the new meaning of YYERROR, for GCC.
740   Once GCC version 2 has supplanted version 1, this can go.  However,
741   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
742   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
743   discussed.  */
744
745#define YYFAIL goto yyerrlab
746#if defined YYFAIL
747  /* This is here to suppress warnings from the GCC cpp's
748     -Wunused-macros.  Normally we don't worry about that warning, but
749     some users do, and we want to make it easy for users to remove
750     YYFAIL uses, which will produce warnings from Bison 2.5.  */
751#endif
752
753#define YYRECOVERING()  (!!yyerrstatus)
754
755#define YYBACKUP(TokenValue)                                  \
756do                                                              \
757  if (yychar == YYEMPTY)                                        \
758    {                                                           \
759      yychar = (Token);                                         \
760      yylval = (Value);                                         \
761      YYPOPSTACK (yylen);                                       \
762      yystate = *yyssp;                                         \
763      goto yybackup;                                            \
764    }                                                           \
765  else                                                          \
766    {                                                           \
767      yyerror (YY_("syntax error: cannot back up")); \
768      YYERROR; \
769    } \
770while (YYID (0))
771
772
773#define YYTERROR 1
774#define YYERRCODE 256
775
776/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
777   If N is 0, then set CURRENT to the empty location which ends
778   the previous symbol: RHS[0] (always defined).  */
779
780#ifndef YYLLOC_DEFAULT
781# define YYLLOC_DEFAULT(CurrentRhsN)                                \
782    do                                                                  \
783      if (YYID (N))                                                     \
784        {                                                               \
785          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
786          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
787          (Current).last_line    = YYRHSLOC (RhsN).last_line;         \
788          (Current).last_column  = YYRHSLOC (RhsN).last_column;       \
789        }                                                               \
790      else                                                              \
791        {                                                               \
792          (Current).first_line   = (Current).last_line   =              \
793            YYRHSLOC (Rhs, 0).last_line;                                \
794          (Current).first_column = (Current).last_column =              \
795            YYRHSLOC (Rhs, 0).last_column;                              \
796        }                                                               \
797    while (YYID (0))
798#endif
799
800#define YYRHSLOC(RhsK) ((Rhs)[K])
801
802
803
804/* This macro is provided for backward compatibility. */
805
806#ifndef YY_LOCATION_PRINT
807# define YY_LOCATION_PRINT(FileLoc) ((void) 0)
808#endif
809
810
811/* YYLEX -- calling `yylex' with the right arguments.  */
812
813#ifdef YYLEX_PARAM
814# define YYLEX yylex (YYLEX_PARAM)
815#else
816# define YYLEX yylex ()
817#endif
818
819/* Enable debugging if requested.  */
820#if YYDEBUG
821
822# ifndef YYFPRINTF
823#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
824#  define YYFPRINTF fprintf
825# endif
826
827# define YYDPRINTF(Args) \
828do { \
829  if (yydebug) \
830    YYFPRINTF Args; \
831} while (YYID (0))
832
833# define YY_SYMBOL_PRINT(TitleTypeValueLocation)   \
834do {   \
835  if (yydebug)   \
836    {   \
837      YYFPRINTF (stderr, "%s ", Title);   \
838      yy_symbol_print (stderr,   \
839   TypeValue); \
840      YYFPRINTF (stderr, "\n");   \
841    }   \
842} while (YYID (0))
843
844
845/*--------------------------------.
846| Print this symbol on YYOUTPUT.  |
847`--------------------------------*/
848
849/*ARGSUSED*/
850#if (defined __STDC__ || defined __C99__FUNC__ \
851     || defined __cplusplus || defined _MSC_VER)
852static void
853yy_symbol_value_print (FILE *yyoutput, int yytypeYYSTYPE const * const yyvaluep)
854#else
855static void
856yy_symbol_value_print (yyoutputyytypeyyvaluep)
857    FILE *yyoutput;
858    int yytype;
859    YYSTYPE const * const yyvaluep;
860#endif
861{
862  FILE *yyo = yyoutput;
863  YYUSE (yyo);
864  if (!yyvaluep)
865    return;
866# ifdef YYPRINT
867  if (yytype < YYNTOKENS)
868    YYPRINT (yyoutputyytoknum[yytype], *yyvaluep);
869# else
870  YYUSE (yyoutput);
871# endif
872  switch (yytype)
873    {
874      default:
875 break;
876    }
877}
878
879
880/*--------------------------------.
881| Print this symbol on YYOUTPUT.  |
882`--------------------------------*/
883
884#if (defined __STDC__ || defined __C99__FUNC__ \
885     || defined __cplusplus || defined _MSC_VER)
886static void
887yy_symbol_print (FILE *yyoutput, int yytypeYYSTYPE const * const yyvaluep)
888#else
889static void
890yy_symbol_print (yyoutputyytypeyyvaluep)
891    FILE *yyoutput;
892    int yytype;
893    YYSTYPE const * const yyvaluep;
894#endif
895{
896  if (yytype < YYNTOKENS)
897    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
898  else
899    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
900
901  yy_symbol_value_print (yyoutputyytypeyyvaluep);
902  YYFPRINTF (yyoutput, ")");
903}
904
905/*------------------------------------------------------------------.
906| yy_stack_print -- Print the state stack from its BOTTOM up to its |
907| TOP (included).                                                   |
908`------------------------------------------------------------------*/
909
910#if (defined __STDC__ || defined __C99__FUNC__ \
911     || defined __cplusplus || defined _MSC_VER)
912static void
913yy_stack_print (yytype_int16 *yybottomyytype_int16 *yytop)
914#else
915static void
916yy_stack_print (yybottomyytop)
917    yytype_int16 *yybottom;
918    yytype_int16 *yytop;
919#endif
920{
921  YYFPRINTF (stderr, "Stack now");
922  for (; yybottom <= yytopyybottom++)
923    {
924      int yybot = *yybottom;
925      YYFPRINTF (stderr, " %d", yybot);
926    }
927  YYFPRINTF (stderr, "\n");
928}
929
930# define YY_STACK_PRINT(BottomTop) \
931do { \
932  if (yydebug) \
933    yy_stack_print ((Bottom), (Top)); \
934} while (YYID (0))
935
936
937/*------------------------------------------------.
938| Report that the YYRULE is going to be reduced.  |
939`------------------------------------------------*/
940
941#if (defined __STDC__ || defined __C99__FUNC__ \
942     || defined __cplusplus || defined _MSC_VER)
943static void
944yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
945#else
946static void
947yy_reduce_print (yyvspyyrule)
948    YYSTYPE *yyvsp;
949    int yyrule;
950#endif
951{
952  int yynrhs = yyr2[yyrule];
953  int yyi;
954  unsigned long int yylno = yyrline[yyrule];
955  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
956      yyrule - 1, yylno);
957  /* The symbols being reduced.  */
958  for (yyi = 0; yyi < yynrhsyyi++)
959    {
960      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
961      yy_symbol_print (stderryyrhs[yyprhs[yyrule] + yyi],
962        &(yyvsp[(yyi + 1) - (yynrhs)])
963                );
964      YYFPRINTF (stderr, "\n");
965    }
966}
967
968# define YY_REDUCE_PRINT(Rule) \
969do { \
970  if (yydebug) \
971    yy_reduce_print (yyvspRule); \
972} while (YYID (0))
973
974/* Nonzero means print parse trace.  It is left uninitialized so that
975   multiple parsers can coexist.  */
976int yydebug;
977#else /* !YYDEBUG */
978# define YYDPRINTF(Args)
979# define YY_SYMBOL_PRINT(TitleTypeValueLocation)
980# define YY_STACK_PRINT(BottomTop)
981# define YY_REDUCE_PRINT(Rule)
982#endif /* !YYDEBUG */
983
984
985/* YYINITDEPTH -- initial size of the parser's stacks.  */
986#ifndef YYINITDEPTH
987# define YYINITDEPTH 200
988#endif
989
990/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
991   if the built-in stack extension method is used).
992
993   Do not make this value too large; the results are undefined if
994   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
995   evaluated with infinite-precision integer arithmetic.  */
996
997#ifndef YYMAXDEPTH
998# define YYMAXDEPTH 10000
999#endif
1000
1001
1002#if YYERROR_VERBOSE
1003
1004# ifndef yystrlen
1005#  if defined __GLIBC__ && defined _STRING_H
1006#   define yystrlen strlen
1007#  else
1008/* Return the length of YYSTR.  */
1009#if (defined __STDC__ || defined __C99__FUNC__ \
1010     || defined __cplusplus || defined _MSC_VER)
1011static YYSIZE_T
1012yystrlen (const char *yystr)
1013#else
1014static YYSIZE_T
1015yystrlen (yystr)
1016    const char *yystr;
1017#endif
1018{
1019  YYSIZE_T yylen;
1020  for (yylen = 0; yystr[yylen]; yylen++)
1021    continue;
1022  return yylen;
1023}
1024#  endif
1025# endif
1026
1027# ifndef yystpcpy
1028#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1029#   define yystpcpy stpcpy
1030#  else
1031/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1032   YYDEST.  */
1033#if (defined __STDC__ || defined __C99__FUNC__ \
1034     || defined __cplusplus || defined _MSC_VER)
1035static char *
1036yystpcpy (char *yydest, const char *yysrc)
1037#else
1038static char *
1039yystpcpy (yydestyysrc)
1040    char *yydest;
1041    const char *yysrc;
1042#endif
1043{
1044  char *yyd = yydest;
1045  const char *yys = yysrc;
1046
1047  while ((*yyd++ = *yys++) != '\0')
1048    continue;
1049
1050  return yyd - 1;
1051}
1052#  endif
1053# endif
1054
1055# ifndef yytnamerr
1056/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1057   quotes and backslashes, so that it's suitable for yyerror.  The
1058   heuristic is that double-quoting is unnecessary unless the string
1059   contains an apostrophe, a comma, or backslash (other than
1060   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1061   null, do not copy; instead, return the length of what the result
1062   would have been.  */
1063static YYSIZE_T
1064yytnamerr (char *yyres, const char *yystr)
1065{
1066  if (*yystr == '"')
1067    {
1068      YYSIZE_T yyn = 0;
1069      char const *yyp = yystr;
1070
1071      for (;;)
1072 switch (*++yyp)
1073   {
1074   case '\'':
1075   case ',':
1076     goto do_not_strip_quotes;
1077
1078   case '\\':
1079     if (*++yyp != '\\')
1080       goto do_not_strip_quotes;
1081     /* Fall through.  */
1082   default:
1083     if (yyres)
1084       yyres[yyn] = *yyp;
1085     yyn++;
1086     break;
1087
1088   case '"':
1089     if (yyres)
1090       yyres[yyn] = '\0';
1091     return yyn;
1092   }
1093    do_not_strip_quotes: ;
1094    }
1095
1096  if (! yyres)
1097    return yystrlen (yystr);
1098
1099  return yystpcpy (yyresyystr) - yyres;
1100}
1101# endif
1102
1103/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1104   about the unexpected token YYTOKEN for the state stack whose top is
1105   YYSSP.
1106
1107   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
1108   not large enough to hold the message.  In that case, also set
1109   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
1110   required number of bytes is too large to store.  */
1111static int
1112yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1113                yytype_int16 *yyssp, int yytoken)
1114{
1115  YYSIZE_T yysize0 = yytnamerr (YY_NULLyytname[yytoken]);
1116  YYSIZE_T yysize = yysize0;
1117  YYSIZE_T yysize1;
1118  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1119  /* Internationalized format string. */
1120  const char *yyformat = YY_NULL;
1121  /* Arguments of yyformat. */
1122  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1123  /* Number of reported tokens (one for the "unexpected", one per
1124     "expected"). */
1125  int yycount = 0;
1126
1127  /* There are many possibilities here to consider:
1128     - Assume YYFAIL is not used.  It's too flawed to consider.  See
1129       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1130       for details.  YYERROR is fine as it does not invoke this
1131       function.
1132     - If this state is a consistent state with a default action, then
1133       the only way this function was invoked is if the default action
1134       is an error action.  In that case, don't check for expected
1135       tokens because there are none.
1136     - The only way there can be no lookahead present (in yychar) is if
1137       this state is a consistent state with a default action.  Thus,
1138       detecting the absence of a lookahead is sufficient to determine
1139       that there is no unexpected or expected token to report.  In that
1140       case, just report a simple "syntax error".
1141     - Don't assume there isn't a lookahead just because this state is a
1142       consistent state with a default action.  There might have been a
1143       previous inconsistent state, consistent state with a non-default
1144       action, or user semantic action that manipulated yychar.
1145     - Of course, the expected token list depends on states to have
1146       correct lookahead information, and it depends on the parser not
1147       to perform extra reductions after fetching a lookahead from the
1148       scanner and before detecting a syntax error.  Thus, state merging
1149       (from LALR or IELR) and default reductions corrupt the expected
1150       token list.  However, the list is correct for canonical LR with
1151       one exception: it will still contain any token that will not be
1152       accepted due to an error action in a later state.
1153  */
1154  if (yytoken != YYEMPTY)
1155    {
1156      int yyn = yypact[*yyssp];
1157      yyarg[yycount++] = yytname[yytoken];
1158      if (!yypact_value_is_default (yyn))
1159        {
1160          /* Start YYX at -YYN if negative to avoid negative indexes in
1161             YYCHECK.  In other words, skip the first -YYN actions for
1162             this state because they are default actions.  */
1163          int yyxbegin = yyn < 0 ? -yyn : 0;
1164          /* Stay within bounds of both yycheck and yytname.  */
1165          int yychecklim = YYLAST - yyn + 1;
1166          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1167          int yyx;
1168
1169          for (yyx = yyxbeginyyx < yyxend; ++yyx)
1170            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1171                && !yytable_value_is_error (yytable[yyx + yyn]))
1172              {
1173                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1174                  {
1175                    yycount = 1;
1176                    yysize = yysize0;
1177                    break;
1178                  }
1179                yyarg[yycount++] = yytname[yyx];
1180                yysize1 = yysize + yytnamerr (YY_NULLyytname[yyx]);
1181                if (! (yysize <= yysize1
1182                       && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1183                  return 2;
1184                yysize = yysize1;
1185              }
1186        }
1187    }
1188
1189  switch (yycount)
1190    {
1191# define YYCASE_(NS)                      \
1192      case N:                               \
1193        yyformat = S;                       \
1194      break
1195      YYCASE_(0, YY_("syntax error"));
1196      YYCASE_(1, YY_("syntax error, unexpected %s"));
1197      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1198      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1199      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1200      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1201# undef YYCASE_
1202    }
1203
1204  yysize1 = yysize + yystrlen (yyformat);
1205  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1206    return 2;
1207  yysize = yysize1;
1208
1209  if (*yymsg_alloc < yysize)
1210    {
1211      *yymsg_alloc = 2 * yysize;
1212      if (! (yysize <= *yymsg_alloc
1213             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1214        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1215      return 1;
1216    }
1217
1218  /* Avoid sprintf, as that infringes on the user's name space.
1219     Don't have undefined behavior even if the translation
1220     produced a string with the wrong number of "%s"s.  */
1221  {
1222    char *yyp = *yymsg;
1223    int yyi = 0;
1224    while ((*yyp = *yyformat) != '\0')
1225      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1226        {
1227          yyp += yytnamerr (yypyyarg[yyi++]);
1228          yyformat += 2;
1229        }
1230      else
1231        {
1232          yyp++;
1233          yyformat++;
1234        }
1235  }
1236  return 0;
1237}
1238#endif /* YYERROR_VERBOSE */
1239
1240/*-----------------------------------------------.
1241| Release the memory associated to this symbol.  |
1242`-----------------------------------------------*/
1243
1244/*ARGSUSED*/
1245#if (defined __STDC__ || defined __C99__FUNC__ \
1246     || defined __cplusplus || defined _MSC_VER)
1247static void
1248yydestruct (const char *yymsg, int yytypeYYSTYPE *yyvaluep)
1249#else
1250static void
1251yydestruct (yymsgyytypeyyvaluep)
1252    const char *yymsg;
1253    int yytype;
1254    YYSTYPE *yyvaluep;
1255#endif
1256{
1257  YYUSE (yyvaluep);
1258
1259  if (!yymsg)
1260    yymsg = "Deleting";
1261  YY_SYMBOL_PRINT (yymsgyytypeyyvaluepyylocationp);
1262
1263  switch (yytype)
1264    {
1265
1266      default:
1267 break;
1268    }
1269}
1270
1271
1272
1273
1274/* The lookahead symbol.  */
1275int yychar;
1276
1277
1278#ifndef YYLVAL_INITIALIZE
1279# define YYLVAL_INITIALIZE()
1280#endif
1281#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1282# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1283# define YY_IGNORE_MAYBE_UNINITIALIZED_END
1284#endif
1285
1286/* The semantic value of the lookahead symbol.  */
1287YYSTYPE yylval;
1288
1289/* Number of syntax errors so far.  */
1290int yynerrs;
1291
1292
1293/*----------.
1294| yyparse.  |
1295`----------*/
1296
1297#ifdef YYPARSE_PARAM
1298#if (defined __STDC__ || defined __C99__FUNC__ \
1299     || defined __cplusplus || defined _MSC_VER)
1300int
1301yyparse (void *YYPARSE_PARAM)
1302#else
1303int
1304yyparse (YYPARSE_PARAM)
1305    void *YYPARSE_PARAM;
1306#endif
1307#else /* ! YYPARSE_PARAM */
1308#if (defined __STDC__ || defined __C99__FUNC__ \
1309     || defined __cplusplus || defined _MSC_VER)
1310int
1311yyparse (void)
1312#else
1313int
1314yyparse ()
1315
1316#endif
1317#endif
1318{
1319    int yystate;
1320    /* Number of tokens to shift before error messages enabled.  */
1321    int yyerrstatus;
1322
1323    /* The stacks and their tools:
1324       `yyss': related to states.
1325       `yyvs': related to semantic values.
1326
1327       Refer to the stacks through separate pointers, to allow yyoverflow
1328       to reallocate them elsewhere.  */
1329
1330    /* The state stack.  */
1331    yytype_int16 yyssa[YYINITDEPTH];
1332    yytype_int16 *yyss;
1333    yytype_int16 *yyssp;
1334
1335    /* The semantic value stack.  */
1336    YYSTYPE yyvsa[YYINITDEPTH];
1337    YYSTYPE *yyvs;
1338    YYSTYPE *yyvsp;
1339
1340    YYSIZE_T yystacksize;
1341
1342  int yyn;
1343  int yyresult;
1344  /* Lookahead token as an internal (translated) token number.  */
1345  int yytoken = 0;
1346  /* The variables used to return semantic value and location from the
1347     action routines.  */
1348  YYSTYPE yyval;
1349
1350#if YYERROR_VERBOSE
1351  /* Buffer for error messages, and its allocated size.  */
1352  char yymsgbuf[128];
1353  char *yymsg = yymsgbuf;
1354  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1355#endif
1356
1357#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1358
1359  /* The number of symbols on the RHS of the reduced rule.
1360     Keep to zero when no symbol should be popped.  */
1361  int yylen = 0;
1362
1363  yyss = yyssa;
1364  yyvs = yyvsa;
1365  yystacksize = YYINITDEPTH;
1366
1367  YYDPRINTF ((stderr, "Starting parse\n"));
1368
1369  yystate = 0;
1370  yyerrstatus = 0;
1371  yynerrs = 0;
1372  yychar = YYEMPTY; /* Cause a token to be read.  */
1373
1374  /* Initialize stack pointers.
1375     Waste one element of value and location stack
1376     so that they stay on the same level as the state stack.
1377     The wasted elements are never initialized.  */
1378  yyssp = yyss;
1379  yyvsp = yyvs;
1380
1381  YYLVAL_INITIALIZE ();
1382  goto yysetstate;
1383
1384/*------------------------------------------------------------.
1385| yynewstate -- Push a new state, which is found in yystate.  |
1386`------------------------------------------------------------*/
1387 yynewstate:
1388  /* In all cases, when you get here, the value and location stacks
1389     have just been pushed.  So pushing a state here evens the stacks.  */
1390  yyssp++;
1391
1392 yysetstate:
1393  *yyssp = yystate;
1394
1395  if (yyss + yystacksize - 1 <= yyssp)
1396    {
1397      /* Get the current used size of the three stacks, in elements.  */
1398      YYSIZE_T yysize = yyssp - yyss + 1;
1399
1400#ifdef yyoverflow
1401      {
1402 /* Give user a chance to reallocate the stack.  Use copies of
1403    these so that the &'s don't force the real ones into
1404    memory.  */
1405 YYSTYPE *yyvs1 = yyvs;
1406 yytype_int16 *yyss1 = yyss;
1407
1408 /* Each stack pointer address is followed by the size of the
1409    data in use in that stack, in bytes.  This used to be a
1410    conditional around just the two extra args, but that might
1411    be undefined if yyoverflow is a macro.  */
1412 yyoverflow (YY_("memory exhausted"),
1413     &yyss1yysize * sizeof (*yyssp),
1414     &yyvs1yysize * sizeof (*yyvsp),
1415     &yystacksize);
1416
1417 yyss = yyss1;
1418 yyvs = yyvs1;
1419      }
1420#else /* no yyoverflow */
1421# ifndef YYSTACK_RELOCATE
1422      goto yyexhaustedlab;
1423# else
1424      /* Extend the stack our own way.  */
1425      if (YYMAXDEPTH <= yystacksize)
1426 goto yyexhaustedlab;
1427      yystacksize *= 2;
1428      if (YYMAXDEPTH < yystacksize)
1429 yystacksize = YYMAXDEPTH;
1430
1431      {
1432 yytype_int16 *yyss1 = yyss;
1433 union yyalloc *yyptr =
1434   (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1435 if (! yyptr)
1436   goto yyexhaustedlab;
1437 YYSTACK_RELOCATE (yyss_allocyyss);
1438 YYSTACK_RELOCATE (yyvs_allocyyvs);
1439#  undef YYSTACK_RELOCATE
1440 if (yyss1 != yyssa)
1441   YYSTACK_FREE (yyss1);
1442      }
1443# endif
1444#endif /* no yyoverflow */
1445
1446      yyssp = yyss + yysize - 1;
1447      yyvsp = yyvs + yysize - 1;
1448
1449      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1450   (unsigned long int) yystacksize));
1451
1452      if (yyss + yystacksize - 1 <= yyssp)
1453 YYABORT;
1454    }
1455
1456  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1457
1458  if (yystate == YYFINAL)
1459    YYACCEPT;
1460
1461  goto yybackup;
1462
1463/*-----------.
1464| yybackup.  |
1465`-----------*/
1466yybackup:
1467
1468  /* Do appropriate processing given the current state.  Read a
1469     lookahead token if we need one and don't already have one.  */
1470
1471  /* First try to decide what to do without reference to lookahead token.  */
1472  yyn = yypact[yystate];
1473  if (yypact_value_is_default (yyn))
1474    goto yydefault;
1475
1476  /* Not known => get a lookahead token if don't already have one.  */
1477
1478  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1479  if (yychar == YYEMPTY)
1480    {
1481      YYDPRINTF ((stderr, "Reading a token: "));
1482      yychar = YYLEX;
1483    }
1484
1485  if (yychar <= YYEOF)
1486    {
1487      yychar = yytoken = YYEOF;
1488      YYDPRINTF ((stderr, "Now at end of input.\n"));
1489    }
1490  else
1491    {
1492      yytoken = YYTRANSLATE (yychar);
1493      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1494    }
1495
1496  /* If the proper action on seeing token YYTOKEN is to reduce or to
1497     detect an error, take that action.  */
1498  yyn += yytoken;
1499  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1500    goto yydefault;
1501  yyn = yytable[yyn];
1502  if (yyn <= 0)
1503    {
1504      if (yytable_value_is_error (yyn))
1505        goto yyerrlab;
1506      yyn = -yyn;
1507      goto yyreduce;
1508    }
1509
1510  /* Count tokens shifted since error; after three, turn off error
1511     status.  */
1512  if (yyerrstatus)
1513    yyerrstatus--;
1514
1515  /* Shift the lookahead token.  */
1516  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1517
1518  /* Discard the shifted token.  */
1519  yychar = YYEMPTY;
1520
1521  yystate = yyn;
1522  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1523  *++yyvsp = yylval;
1524  YY_IGNORE_MAYBE_UNINITIALIZED_END
1525
1526  goto yynewstate;
1527
1528
1529/*-----------------------------------------------------------.
1530| yydefault -- do the default action for the current state.  |
1531`-----------------------------------------------------------*/
1532yydefault:
1533  yyn = yydefact[yystate];
1534  if (yyn == 0)
1535    goto yyerrlab;
1536  goto yyreduce;
1537
1538
1539/*-----------------------------.
1540| yyreduce -- Do a reduction.  |
1541`-----------------------------*/
1542yyreduce:
1543  /* yyn is the number of a rule to reduce with.  */
1544  yylen = yyr2[yyn];
1545
1546  /* If YYLEN is nonzero, implement the default value of the action:
1547     `$$ = $1'.
1548
1549     Otherwise, the following line sets YYVAL to garbage.
1550     This behavior is undocumented and Bison
1551     users should not rely upon it.  Assigning to YYVAL
1552     unconditionally makes the parser a bit smaller, and it avoids a
1553     GCC warning that YYVAL may be used uninitialized.  */
1554  yyval = yyvsp[1-yylen];
1555
1556
1557  YY_REDUCE_PRINT (yyn);
1558  switch (yyn)
1559    {
1560        case 2:
1561/* Line 1813 of yacc.c  */
1562#line 114 "ncgen.y"
1563    { init_netcdf(); }
1564    break;
1565
1566  case 3:
1567/* Line 1813 of yacc.c  */
1568#line 117 "ncgen.y"
1569    {
1570        if (derror_count == 0)
1571  define_netcdf(netcdfname);
1572        if (derror_count > 0)
1573    exit(6);
1574    }
1575    break;
1576
1577  case 4:
1578/* Line 1813 of yacc.c  */
1579#line 125 "ncgen.y"
1580    {
1581        if (derror_count == 0)
1582  close_netcdf();
1583    }
1584    break;
1585
1586  case 11:
1587/* Line 1813 of yacc.c  */
1588#line 140 "ncgen.y"
1589    { if (int_val <= 0)
1590  derror("dimension length must be positive");
1591      dims[ndims].size = int_val;
1592      ndims++;
1593    }
1594    break;
1595
1596  case 12:
1597/* Line 1813 of yacc.c  */
1598#line 146 "ncgen.y"
1599    { /* for rare case where 2^31 < dimsize < 2^32 */
1600        if (double_val <= 0)
1601  derror("dimension length must be positive");
1602        if (double_val > 4294967295.0)
1603  derror("dimension too large");
1604        if (double_val - (size_t) double_val > 0)
1605  derror("dimension length must be an integer");
1606        dims[ndims].size = (size_t) double_val;
1607        ndims++;
1608                   }
1609    break;
1610
1611  case 13:
1612/* Line 1813 of yacc.c  */
1613#line 157 "ncgen.y"
1614    {  if (rec_dim != -1)
1615  derror("only one NC_UNLIMITED dimension allowed");
1616      rec_dim = ndims; /* the unlimited (record) dimension */
1617      dims[ndims].size = NC_UNLIMITED;
1618      ndims++;
1619    }
1620    break;
1621
1622  case 14:
1623/* Line 1813 of yacc.c  */
1624#line 165 "ncgen.y"
1625    {
1626     if ((yyvsp[(1) - (1)])->is_dim == 1) {
1627         derror( "duplicate dimension declaration for %s",
1628                 (yyvsp[(1) - (1)])->name);
1629      }
1630              (yyvsp[(1) - (1)])->is_dim = 1;
1631      (yyvsp[(1) - (1)])->dnum = ndims;
1632      /* make sure dims array will hold dimensions */
1633      grow_darray(ndims,  /* must hold ndims+1 dims */
1634  &dims); /* grow as needed */
1635      dims[ndims].name = (char *) emalloc(strlen((yyvsp[(1) - (1)])->name)+1);
1636      (void) strcpy(dims[ndims].name, (yyvsp[(1) - (1)])->name);
1637      /* name for use in generated Fortran and C variables */
1638      dims[ndims].lname = decodify((yyvsp[(1) - (1)])->name);
1639    }
1640    break;
1641
1642  case 27:
1643/* Line 1813 of yacc.c  */
1644#line 197 "ncgen.y"
1645    { type_code = NC_BYTE; }
1646    break;
1647
1648  case 28:
1649/* Line 1813 of yacc.c  */
1650#line 198 "ncgen.y"
1651    { type_code = NC_CHAR; }
1652    break;
1653
1654  case 29:
1655/* Line 1813 of yacc.c  */
1656#line 199 "ncgen.y"
1657    { type_code = NC_SHORT; }
1658    break;
1659
1660  case 30:
1661/* Line 1813 of yacc.c  */
1662#line 200 "ncgen.y"
1663    { type_code = NC_INT; }
1664    break;
1665
1666  case 31:
1667/* Line 1813 of yacc.c  */
1668#line 201 "ncgen.y"
1669    { type_code = NC_FLOAT; }
1670    break;
1671
1672  case 32:
1673/* Line 1813 of yacc.c  */
1674#line 202 "ncgen.y"
1675    { type_code = NC_DOUBLE; }
1676    break;
1677
1678  case 35:
1679/* Line 1813 of yacc.c  */
1680#line 208 "ncgen.y"
1681    {
1682     static struct vars dummyvar;
1683
1684     dummyvar.name = "dummy";
1685     dummyvar.type = NC_DOUBLE;
1686     dummyvar.ndims = 0;
1687     dummyvar.dims = 0;
1688     dummyvar.fill_value.doublev = NC_FILL_DOUBLE;
1689     dummyvar.has_data = 0;
1690
1691     nvdims = 0;
1692     /* make sure variable not re-declared */
1693     if ((yyvsp[(1) - (1)])->is_var == 1) {
1694        derror( "duplicate variable declaration for %s",
1695                (yyvsp[(1) - (1)])->name);
1696     }
1697             (yyvsp[(1) - (1)])->is_var = 1;
1698     (yyvsp[(1) - (1)])->vnum = nvars;
1699     /* make sure vars array will hold variables */
1700     grow_varray(nvars,  /* must hold nvars+1 vars */
1701 &vars); /* grow as needed */
1702     vars[nvars] = dummyvar; /* to make Purify happy */
1703     vars[nvars].name = (char *) emalloc(strlen((yyvsp[(1) - (1)])->name)+1);
1704     (void) strcpy(vars[nvars].name, (yyvsp[(1) - (1)])->name);
1705     /* name for use in generated Fortran and C variables */
1706     vars[nvars].lname = decodify((yyvsp[(1) - (1)])->name);
1707     vars[nvars].type = type_code;
1708     /* set default fill value.  You can override this with
1709      * the variable attribute "_FillValue". */
1710     nc_getfill(type_code, &vars[nvars].fill_value);
1711     vars[nvars].has_data = 0; /* has no data (yet) */
1712    }
1713    break;
1714
1715  case 36:
1716/* Line 1813 of yacc.c  */
1717#line 241 "ncgen.y"
1718    {
1719     vars[nvars].ndims = nvdims;
1720     nvars++;
1721    }
1722    break;
1723
1724  case 42:
1725/* Line 1813 of yacc.c  */
1726#line 255 "ncgen.y"
1727    {
1728     if (nvdims >= NC_MAX_VAR_DIMS) {
1729        derror("%s has too many dimensions",vars[nvars].name);
1730     }
1731     if ((yyvsp[(1) - (1)])->is_dim == 1)
1732        dimnum = (yyvsp[(1) - (1)])->dnum;
1733     else {
1734        derror( "%s is not declared as a dimension",
1735        (yyvsp[(1) - (1)])->name);
1736                dimnum = ndims;
1737     }
1738     if (rec_dim != -1 && dimnum == rec_dim && nvdims != 0) {
1739        derror("unlimited dimension must be first");
1740     }
1741     grow_iarray(nvdims, /* must hold nvdims+1 ints */
1742 &vars[nvars].dims); /* grow as needed */
1743     vars[nvars].dims[nvdims] = dimnum;
1744                    nvdims++;
1745    }
1746    break;
1747
1748  case 43:
1749/* Line 1813 of yacc.c  */
1750#line 276 "ncgen.y"
1751    {
1752                   defatt();
1753    }
1754    break;
1755
1756  case 44:
1757/* Line 1813 of yacc.c  */
1758#line 280 "ncgen.y"
1759    {
1760                   equalatt();
1761    }
1762    break;
1763
1764  case 45:
1765/* Line 1813 of yacc.c  */
1766#line 285 "ncgen.y"
1767    {
1768                   defatt();
1769    }
1770    break;
1771
1772  case 46:
1773/* Line 1813 of yacc.c  */
1774#line 289 "ncgen.y"
1775    {
1776                   equalatt();
1777    }
1778    break;
1779
1780  case 48:
1781/* Line 1813 of yacc.c  */
1782#line 297 "ncgen.y"
1783    {
1784     varnum = NC_GLOBAL;  /* handle of "global" attribute */
1785    }
1786    break;
1787
1788  case 49:
1789/* Line 1813 of yacc.c  */
1790#line 303 "ncgen.y"
1791    { if ((yyvsp[(1) - (1)])->is_var == 1)
1792        varnum = (yyvsp[(1) - (1)])->vnum;
1793     else {
1794       derror("%s not declared as a variable, fatal error",
1795      (yyvsp[(1) - (1)])->name);
1796       YYABORT;
1797       }
1798    }
1799    break;
1800
1801  case 50:
1802/* Line 1813 of yacc.c  */
1803#line 313 "ncgen.y"
1804    {
1805        /* make sure atts array will hold attributes */
1806        grow_aarray(natts,  /* must hold natts+1 atts */
1807    &atts); /* grow as needed */
1808        atts[natts].name = (char *) emalloc(strlen((yyvsp[(1) - (1)])->name)+1);
1809        (void) strcpy(atts[natts].name,(yyvsp[(1) - (1)])->name);
1810        /* name for use in generated Fortran and C variables */
1811        atts[natts].lname = decodify((yyvsp[(1) - (1)])->name);
1812    }
1813    break;
1814
1815  case 53:
1816/* Line 1813 of yacc.c  */
1817#line 327 "ncgen.y"
1818    {
1819     if (valtype == NC_UNSPECIFIED)
1820       valtype = atype_code;
1821     if (valtype != atype_code)
1822       derror("values for attribute must be all of same type");
1823    }
1824    break;
1825
1826  case 54:
1827/* Line 1813 of yacc.c  */
1828#line 336 "ncgen.y"
1829    {
1830        atype_code = NC_CHAR;
1831        *char_valp++ = char_val;
1832        valnum++;
1833    }
1834    break;
1835
1836  case 55:
1837/* Line 1813 of yacc.c  */
1838#line 342 "ncgen.y"
1839    {
1840        atype_code = NC_CHAR;
1841        {
1842    /* don't null-terminate attribute strings */
1843    size_t len = strlen(termstring);
1844    if (len == 0) /* need null if that's only value */
1845        len = 1;
1846    (void)strncpy(char_valp,termstring,len);
1847    valnum += len;
1848    char_valp += len;
1849        }
1850    }
1851    break;
1852
1853  case 56:
1854/* Line 1813 of yacc.c  */
1855#line 355 "ncgen.y"
1856    {
1857        atype_code = NC_BYTE;
1858        *byte_valp++ = byte_val;
1859        valnum++;
1860    }
1861    break;
1862
1863  case 57:
1864/* Line 1813 of yacc.c  */
1865#line 361 "ncgen.y"
1866    {
1867        atype_code = NC_SHORT;
1868        *short_valp++ = short_val;
1869        valnum++;
1870    }
1871    break;
1872
1873  case 58:
1874/* Line 1813 of yacc.c  */
1875#line 367 "ncgen.y"
1876    {
1877        atype_code = NC_INT;
1878        *int_valp++ = int_val;
1879        valnum++;
1880    }
1881    break;
1882
1883  case 59:
1884/* Line 1813 of yacc.c  */
1885#line 373 "ncgen.y"
1886    {
1887        atype_code = NC_FLOAT;
1888        *float_valp++ = float_val;
1889        valnum++;
1890    }
1891    break;
1892
1893  case 60:
1894/* Line 1813 of yacc.c  */
1895#line 379 "ncgen.y"
1896    {
1897        atype_code = NC_DOUBLE;
1898        *double_valp++ = double_val;
1899        valnum++;
1900    }
1901    break;
1902
1903  case 66:
1904/* Line 1813 of yacc.c  */
1905#line 395 "ncgen.y"
1906    {
1907        valtype = vars[varnum].type; /* variable type */
1908        valnum = 0; /* values accumulated for variable */
1909        vars[varnum].has_data = 1;
1910        /* compute dimensions product */
1911        var_size = nctypesize(valtype);
1912        if (vars[varnum].ndims == 0) { /* scalar */
1913    var_len = 1;
1914        } else if (vars[varnum].dims[0] == rec_dim) {
1915    var_len = 1; /* one record for unlimited vars */
1916        } else {
1917    var_len = dims[vars[varnum].dims[0]].size;
1918        }
1919        for(dimnum = 1; dimnum < vars[varnum].ndimsdimnum++)
1920  var_len = var_len*dims[vars[varnum].dims[dimnum]].size;
1921        /* allocate memory for variable data */
1922        if (var_len*var_size != (size_t)(var_len*var_size)) {
1923    derror("variable %s too large for memory",
1924   vars[varnum].name);
1925    exit(9);
1926        }
1927        rec_len = var_len;
1928        rec_start = malloc ((size_t)(rec_len*var_size));
1929        if (rec_start == 0) {
1930    derror ("out of memory\n");
1931    exit(3);
1932        }
1933        rec_cur = rec_start;
1934        switch (valtype) {
1935  case NC_CHAR:
1936    char_valp = (char *) rec_start;
1937    break;
1938  case NC_BYTE:
1939    byte_valp = (signed char *) rec_start;
1940    break;
1941  case NC_SHORT:
1942    short_valp = (short *) rec_start;
1943    break;
1944  case NC_INT:
1945    int_valp = (int *) rec_start;
1946    break;
1947  case NC_FLOAT:
1948    float_valp = (float *) rec_start;
1949    break;
1950  case NC_DOUBLE:
1951    double_valp = (double *) rec_start;
1952    break;
1953  default: break;
1954        }
1955  }
1956    break;
1957
1958  case 67:
1959/* Line 1813 of yacc.c  */
1960#line 446 "ncgen.y"
1961    {
1962        if (valnum < var_len) { /* leftovers */
1963    nc_fill(valtype,
1964     var_len - valnum,
1965     rec_cur,
1966     vars[varnum].fill_value);
1967        }
1968        /* put out var_len values */
1969        /* vars[varnum].nrecs = valnum / rec_len; */
1970        vars[varnum].nrecs = var_len / rec_len;
1971        if (derror_count == 0)
1972    put_variable(rec_start);
1973        free ((char *) rec_start);
1974  }
1975    break;
1976
1977  case 70:
1978/* Line 1813 of yacc.c  */
1979#line 465 "ncgen.y"
1980    {
1981        if(valnum >= var_len) {
1982    if (vars[varnum].dims[0] != rec_dim) { /* not recvar */
1983        derror("too many values for this variable, %d >= %d",
1984       valnumvar_len);
1985        exit (4);
1986    } else { /* a record variable, so grow data
1987       container and increment var_len by
1988       multiple of record size */
1989        ptrdiff_t rec_inc = (char *)rec_cur
1990    - (char *)rec_start;
1991        var_len = rec_len * (1 + valnum / rec_len);
1992        rec_start = erealloc(rec_startvar_len*var_size);
1993        rec_cur = (char *)rec_start + rec_inc;
1994        char_valp = (char *) rec_cur;
1995        byte_valp = (signed char *) rec_cur;
1996        short_valp = (short *) rec_cur;
1997        int_valp = (int *) rec_cur;
1998        float_valp = (float *) rec_cur;
1999        double_valp = (double *) rec_cur;
2000    }
2001        }
2002        not_a_string = 1;
2003                   }
2004    break;
2005
2006  case 71:
2007/* Line 1813 of yacc.c  */
2008#line 490 "ncgen.y"
2009    {
2010        if (not_a_string) {
2011    switch (valtype) {
2012      case NC_CHAR:
2013        rec_cur = (void *) char_valp;
2014        break;
2015      case NC_BYTE:
2016        rec_cur = (void *) byte_valp;
2017        break;
2018      case NC_SHORT:
2019        rec_cur = (void *) short_valp;
2020        break;
2021      case NC_INT:
2022        rec_cur = (void *) int_valp;
2023        break;
2024      case NC_FLOAT:
2025        rec_cur = (void *) float_valp;
2026        break;
2027      case NC_DOUBLE:
2028        rec_cur = (void *) double_valp;
2029        break;
2030      default: break;
2031    }
2032        }
2033    }
2034    break;
2035
2036  case 72:
2037/* Line 1813 of yacc.c  */
2038#line 518 "ncgen.y"
2039    {
2040        atype_code = NC_CHAR;
2041        switch (valtype) {
2042  case NC_CHAR:
2043    *char_valp++ = char_val;
2044    break;
2045  case NC_BYTE:
2046    *byte_valp++ = char_val;
2047    break;
2048  case NC_SHORT:
2049    *short_valp++ = char_val;
2050    break;
2051  case NC_INT:
2052    *int_valp++ = char_val;
2053    break;
2054  case NC_FLOAT:
2055    *float_valp++ = char_val;
2056    break;
2057  case NC_DOUBLE:
2058    *double_valp++ = char_val;
2059    break;
2060  default: break;
2061        }
2062        valnum++;
2063    }
2064    break;
2065
2066  case 73:
2067/* Line 1813 of yacc.c  */
2068#line 544 "ncgen.y"
2069    {
2070        not_a_string = 0;
2071        atype_code = NC_CHAR;
2072        {
2073    size_t len = strlen(termstring);
2074
2075    if(valnum + len > var_len) {
2076        if (vars[varnum].dims[0] != rec_dim) {
2077    derror("too many values for this variable, %d>%d",
2078   valnum+lenvar_len);
2079    exit (5);
2080        } else {/* a record variable so grow it */
2081    ptrdiff_t rec_inc = (char *)rec_cur
2082        - (char *)rec_start;
2083    var_len += rec_len * (len + valnum - var_len)/rec_len;
2084    rec_start = erealloc(rec_startvar_len*var_size);
2085    rec_cur = (char *)rec_start + rec_inc;
2086    char_valp = (char *) rec_cur;
2087        }
2088    }
2089    switch (valtype) {
2090      case NC_CHAR:
2091        {
2092    int ld;
2093    size_t isl;
2094    (void)strncpy(char_valp,termstring,len);
2095    ld = vars[varnum].ndims-1;
2096    if (ld > 0) {/* null-fill to size of last dim */
2097        sl = dims[vars[varnum].dims[ld]].size;
2098        for (i =len;i<sl;i++)
2099    char_valp[i] = '\0';
2100        if (sl < len)
2101    sl = len;
2102        valnum += sl;
2103        char_valp += sl;
2104    } else { /* scalar or 1D strings */
2105        valnum += len;
2106        char_valp += len;
2107    }
2108    rec_cur = (void *) char_valp;
2109        }
2110        break;
2111      case NC_BYTE:
2112      case NC_SHORT:
2113      case NC_INT:
2114      case NC_FLOAT:
2115      case NC_DOUBLE:
2116        derror("string value invalid for %s variable",
2117       nctype(valtype));
2118        break;
2119      default: break;
2120    }
2121        }
2122    }
2123    break;
2124
2125  case 74:
2126/* Line 1813 of yacc.c  */
2127#line 599 "ncgen.y"
2128    {
2129        atype_code = NC_BYTE;
2130        switch (valtype) {
2131  case NC_CHAR:
2132    *char_valp++ = byte_val;
2133    break;
2134  case NC_BYTE:
2135    *byte_valp++ = byte_val;
2136    break;
2137  case NC_SHORT:
2138    *short_valp++ = byte_val;
2139    break;
2140  case NC_INT:
2141    *int_valp++ = byte_val;
2142    break;
2143  case NC_FLOAT:
2144    *float_valp++ = byte_val;
2145    break;
2146  case NC_DOUBLE:
2147    *double_valp++ = byte_val;
2148    break;
2149  default: break;
2150        }
2151        valnum++;
2152    }
2153    break;
2154
2155  case 75:
2156/* Line 1813 of yacc.c  */
2157#line 625 "ncgen.y"
2158    {
2159        atype_code = NC_SHORT;
2160        switch (valtype) {
2161  case NC_CHAR:
2162    *char_valp++ = short_val;
2163    break;
2164  case NC_BYTE:
2165    *byte_valp++ = short_val;
2166    break;
2167  case NC_SHORT:
2168    *short_valp++ = short_val;
2169    break;
2170  case NC_INT:
2171    *int_valp++ = short_val;
2172    break;
2173  case NC_FLOAT:
2174    *float_valp++ = short_val;
2175    break;
2176  case NC_DOUBLE:
2177    *double_valp++ = short_val;
2178    break;
2179  default: break;
2180        }
2181        valnum++;
2182    }
2183    break;
2184
2185  case 76:
2186/* Line 1813 of yacc.c  */
2187#line 651 "ncgen.y"
2188    {
2189        atype_code = NC_INT;
2190        switch (valtype) {
2191  case NC_CHAR:
2192    *char_valp++ = int_val;
2193    break;
2194  case NC_BYTE:
2195    *byte_valp++ = int_val;
2196    break;
2197  case NC_SHORT:
2198    *short_valp++ = int_val;
2199    break;
2200  case NC_INT:
2201    *int_valp++ = int_val;
2202    break;
2203  case NC_FLOAT:
2204    *float_valp++ = int_val;
2205    break;
2206  case NC_DOUBLE:
2207    *double_valp++ = int_val;
2208    break;
2209  default: break;
2210        }
2211        valnum++;
2212    }
2213    break;
2214
2215  case 77:
2216/* Line 1813 of yacc.c  */
2217#line 677 "ncgen.y"
2218    {
2219        atype_code = NC_FLOAT;
2220        switch (valtype) {
2221  case NC_CHAR:
2222    *char_valp++ = float_val;
2223    break;
2224  case NC_BYTE:
2225    *byte_valp++ = float_val;
2226    break;
2227  case NC_SHORT:
2228    *short_valp++ = float_val;
2229    break;
2230  case NC_INT:
2231    *int_valp++ = float_val;
2232    break;
2233  case NC_FLOAT:
2234    *float_valp++ = float_val;
2235    break;
2236  case NC_DOUBLE:
2237    *double_valp++ = float_val;
2238    break;
2239  default: break;
2240        }
2241        valnum++;
2242    }
2243    break;
2244
2245  case 78:
2246/* Line 1813 of yacc.c  */
2247#line 703 "ncgen.y"
2248    {
2249        atype_code = NC_DOUBLE;
2250        switch (valtype) {
2251  case NC_CHAR:
2252    *char_valp++ = double_val;
2253    break;
2254  case NC_BYTE:
2255    *byte_valp++ = double_val;
2256    break;
2257  case NC_SHORT:
2258    *short_valp++ = double_val;
2259    break;
2260  case NC_INT:
2261    *int_valp++ = double_val;
2262    break;
2263  case NC_FLOAT:
2264    if (double_val == NC_FILL_DOUBLE)
2265      *float_valp++ = NC_FILL_FLOAT;
2266    else
2267      *float_valp++ = double_val;
2268    break;
2269  case NC_DOUBLE:
2270    *double_valp++ = double_val;
2271    break;
2272  default: break;
2273        }
2274        valnum++;
2275    }
2276    break;
2277
2278  case 79:
2279/* Line 1813 of yacc.c  */
2280#line 732 "ncgen.y"
2281    {
2282        /* store fill_value */
2283        switch (valtype) {
2284        case NC_CHAR:
2285    nc_fill(valtype, 1, (void *)char_valp++,
2286    vars[varnum].fill_value);
2287    break;
2288        case NC_BYTE:
2289    nc_fill(valtype, 1, (void *)byte_valp++,
2290    vars[varnum].fill_value);
2291    break;
2292        case NC_SHORT:
2293    nc_fill(valtype, 1, (void *)short_valp++,
2294    vars[varnum].fill_value);
2295    break;
2296        case NC_INT:
2297    nc_fill(valtype, 1, (void *)int_valp++,
2298    vars[varnum].fill_value);
2299    break;
2300        case NC_FLOAT:
2301    nc_fill(valtype, 1, (void *)float_valp++,
2302    vars[varnum].fill_value);
2303    break;
2304        case NC_DOUBLE:
2305    nc_fill(valtype, 1, (void *)double_valp++,
2306    vars[varnum].fill_value);
2307    break;
2308 default: break;
2309        }
2310        valnum++;
2311    }
2312    break;
2313
2314
2315/* Line 1813 of yacc.c  */
2316#line 2317 "ncgen.tab.c"
2317      default: break;
2318    }
2319  /* User semantic actions sometimes alter yychar, and that requires
2320     that yytoken be updated with the new translation.  We take the
2321     approach of translating immediately before every use of yytoken.
2322     One alternative is translating here after every semantic action,
2323     but that translation would be missed if the semantic action invokes
2324     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2325     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
2326     incorrect destructor might then be invoked immediately.  In the
2327     case of YYERROR or YYBACKUP, subsequent parser actions might lead
2328     to an incorrect destructor call or verbose syntax error message
2329     before the lookahead is translated.  */
2330  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2331
2332  YYPOPSTACK (yylen);
2333  yylen = 0;
2334  YY_STACK_PRINT (yyssyyssp);
2335
2336  *++yyvsp = yyval;
2337
2338  /* Now `shift' the result of the reduction.  Determine what state
2339     that goes to, based on the state we popped back to and the rule
2340     number reduced by.  */
2341
2342  yyn = yyr1[yyn];
2343
2344  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2345  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2346    yystate = yytable[yystate];
2347  else
2348    yystate = yydefgoto[yyn - YYNTOKENS];
2349
2350  goto yynewstate;
2351
2352
2353/*------------------------------------.
2354| yyerrlab -- here on detecting error |
2355`------------------------------------*/
2356yyerrlab:
2357  /* Make sure we have latest lookahead translation.  See comments at
2358     user semantic actions for why this is necessary.  */
2359  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2360
2361  /* If not already recovering from an error, report this error.  */
2362  if (!yyerrstatus)
2363    {
2364      ++yynerrs;
2365#if ! YYERROR_VERBOSE
2366      yyerror (YY_("syntax error"));
2367#else
2368# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2369                                        yysspyytoken)
2370      {
2371        char const *yymsgp = YY_("syntax error");
2372        int yysyntax_error_status;
2373        yysyntax_error_status = YYSYNTAX_ERROR;
2374        if (yysyntax_error_status == 0)
2375          yymsgp = yymsg;
2376        else if (yysyntax_error_status == 1)
2377          {
2378            if (yymsg != yymsgbuf)
2379              YYSTACK_FREE (yymsg);
2380            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2381            if (!yymsg)
2382              {
2383                yymsg = yymsgbuf;
2384                yymsg_alloc = sizeof yymsgbuf;
2385                yysyntax_error_status = 2;
2386              }
2387            else
2388              {
2389                yysyntax_error_status = YYSYNTAX_ERROR;
2390                yymsgp = yymsg;
2391              }
2392          }
2393        yyerror (yymsgp);
2394        if (yysyntax_error_status == 2)
2395          goto yyexhaustedlab;
2396      }
2397# undef YYSYNTAX_ERROR
2398#endif
2399    }
2400
2401
2402
2403  if (yyerrstatus == 3)
2404    {
2405      /* If just tried and failed to reuse lookahead token after an
2406  error, discard it.  */
2407
2408      if (yychar <= YYEOF)
2409 {
2410   /* Return failure if at end of input.  */
2411   if (yychar == YYEOF)
2412     YYABORT;
2413 }
2414      else
2415 {
2416   yydestruct ("Error: discarding",
2417       yytoken, &yylval);
2418   yychar = YYEMPTY;
2419 }
2420    }
2421
2422  /* Else will try to reuse lookahead token after shifting the error
2423     token.  */
2424  goto yyerrlab1;
2425
2426
2427/*---------------------------------------------------.
2428| yyerrorlab -- error raised explicitly by YYERROR.  |
2429`---------------------------------------------------*/
2430yyerrorlab:
2431
2432  /* Pacify compilers like GCC when the user code never invokes
2433     YYERROR and the label yyerrorlab therefore never appears in user
2434     code.  */
2435  if (/*CONSTCOND*/ 0)
2436     goto yyerrorlab;
2437
2438  /* Do not reclaim the symbols of the rule which action triggered
2439     this YYERROR.  */
2440  YYPOPSTACK (yylen);
2441  yylen = 0;
2442  YY_STACK_PRINT (yyssyyssp);
2443  yystate = *yyssp;
2444  goto yyerrlab1;
2445
2446
2447/*-------------------------------------------------------------.
2448| yyerrlab1 -- common code for both syntax error and YYERROR.  |
2449`-------------------------------------------------------------*/
2450yyerrlab1:
2451  yyerrstatus = 3; /* Each real token shifted decrements this.  */
2452
2453  for (;;)
2454    {
2455      yyn = yypact[yystate];
2456      if (!yypact_value_is_default (yyn))
2457 {
2458   yyn += YYTERROR;
2459   if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2460     {
2461       yyn = yytable[yyn];
2462       if (0 < yyn)
2463 break;
2464     }
2465 }
2466
2467      /* Pop the current state because it cannot handle the error token.  */
2468      if (yyssp == yyss)
2469 YYABORT;
2470
2471
2472      yydestruct ("Error: popping",
2473   yystos[yystate], yyvsp);
2474      YYPOPSTACK (1);
2475      yystate = *yyssp;
2476      YY_STACK_PRINT (yyssyyssp);
2477    }
2478
2479  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2480  *++yyvsp = yylval;
2481  YY_IGNORE_MAYBE_UNINITIALIZED_END
2482
2483
2484  /* Shift the error token.  */
2485  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvspyylsp);
2486
2487  yystate = yyn;
2488  goto yynewstate;
2489
2490
2491/*-------------------------------------.
2492| yyacceptlab -- YYACCEPT comes here.  |
2493`-------------------------------------*/
2494yyacceptlab:
2495  yyresult = 0;
2496  goto yyreturn;
2497
2498/*-----------------------------------.
2499| yyabortlab -- YYABORT comes here.  |
2500`-----------------------------------*/
2501yyabortlab:
2502  yyresult = 1;
2503  goto yyreturn;
2504
2505#if !defined yyoverflow || YYERROR_VERBOSE
2506/*-------------------------------------------------.
2507| yyexhaustedlab -- memory exhaustion comes here.  |
2508`-------------------------------------------------*/
2509yyexhaustedlab:
2510  yyerror (YY_("memory exhausted"));
2511  yyresult = 2;
2512  /* Fall through.  */
2513#endif
2514
2515yyreturn:
2516  if (yychar != YYEMPTY)
2517    {
2518      /* Make sure we have latest lookahead translation.  See comments at
2519         user semantic actions for why this is necessary.  */
2520      yytoken = YYTRANSLATE (yychar);
2521      yydestruct ("Cleanup: discarding lookahead",
2522                  yytoken, &yylval);
2523    }
2524  /* Do not reclaim the symbols of the rule which action triggered
2525     this YYABORT or YYACCEPT.  */
2526  YYPOPSTACK (yylen);
2527  YY_STACK_PRINT (yyssyyssp);
2528  while (yyssp != yyss)
2529    {
2530      yydestruct ("Cleanup: popping",
2531   yystos[*yyssp], yyvsp);
2532      YYPOPSTACK (1);
2533    }
2534#ifndef yyoverflow
2535  if (yyss != yyssa)
2536    YYSTACK_FREE (yyss);
2537#endif
2538#if YYERROR_VERBOSE
2539  if (yymsg != yymsgbuf)
2540    YYSTACK_FREE (yymsg);
2541#endif
2542  /* Make sure YYID is used.  */
2543  return YYID (yyresult);
2544}
2545
2546
2547/* Line 2076 of yacc.c  */
2548#line 767 "ncgen.y"
2549
2550
2551/* HELPER PROGRAMS */
2552void defatt()
2553{
2554    valnum = 0;
2555    valtype = NC_UNSPECIFIED;
2556    /* get a large block for attributes, realloc later */
2557    att_space = emalloc(MAX_NC_ATTSIZE);
2558    /* make all kinds of pointers point to it */
2559    char_valp = (char *) att_space;
2560    byte_valp = (signed char *) att_space;
2561    short_valp = (short *) att_space;
2562    int_valp = (int *) att_space;
2563    float_valp = (float *) att_space;
2564    double_valp = (double *) att_space;
2565}
2566
2567void equalatt()
2568{
2569    /* check if duplicate attribute for this var */
2570    int i;
2571    for(i=0; i<nattsi++) { /* expensive */
2572        if(atts[i].var == varnum &&
2573           STREQ(atts[i].name,atts[natts].name)) {
2574            derror("duplicate attribute %s:%s",
2575                   vars[varnum].name,atts[natts].name);
2576        }
2577    }
2578    atts[natts].var = varnum ;
2579    atts[natts].type = valtype;
2580    atts[natts].len = valnum;
2581    /* shrink space down to what was really needed */
2582    att_space = erealloc(att_spacevalnum*nctypesize(valtype));
2583    atts[natts].val = att_space;
2584    if (STREQ(atts[natts].name_FillValue) &&
2585        atts[natts].var != NC_GLOBAL) {
2586        nc_putfill(atts[natts].type,atts[natts].val,
2587                   &vars[atts[natts].var].fill_value);
2588        if(atts[natts].type != vars[atts[natts].var].type) {
2589            derror("variable %s: %s type mismatch",
2590                   vars[atts[natts].var].name_FillValue);
2591        }
2592    }
2593    natts++;
2594}
2595/* PROGRAMS */
2596
2597#ifdef vms
2598void
2599#else
2600int
2601#endif
2602yyerror( /* called for yacc syntax error */
2603     char *s)
2604{
2605 derror(s);
2606#ifndef vms
2607 return -1;
2608#endif
2609}
2610
2611/* undefine yywrap macro, in case we are using bison instead of yacc */
2612#ifdef yywrap
2613#undef yywrap
2614#endif
2615
2616int
2617ncgwrap(void) /* returns 1 on EOF if no more input */
2618{
2619    return  1;
2620}
2621
2622
2623/* Symbol table operations for ncgen tool */
2624
2625/* Find CDL name in symbol table (linear search).  Note, this has a
2626 * side-effect: it handles escape characters in the name, deleting
2627 * single escape characters from the CDL name, before looking it up.
2628 */
2629YYSTYPE lookup(char *sname)
2630{
2631    YYSTYPE sp;
2632    deescapify(sname); /* delete escape chars from names,
2633  * e.g. 'ab\:cd\ ef' becomes
2634  * 'ab:cd ef' */
2635    for (sp = symlistsp != (YYSTYPE) 0; sp = sp -> next)
2636 if (STREQ(sp -> namesname)) {
2637     return sp;
2638 }
2639    return 0; /* 0 ==> not found */
2640}
2641
2642YYSTYPE install(  /* install sname in symbol table */
2643 const char *sname)
2644{
2645    YYSTYPE sp;
2646
2647    sp = (YYSTYPEemalloc (sizeof (struct Symbol));
2648    sp -> name = (char *) emalloc (strlen (sname) + 1);/* +1 for '\0' */
2649    (void) strcpy (sp -> namesname);
2650    sp -> next = symlist; /* put at front of list */
2651    sp -> is_dim = 0;
2652    sp -> is_var = 0;
2653    sp -> is_att = 0;
2654    symlist = sp;
2655    return sp;
2656}
2657
2658void
2659clearout(void) /* reset symbol table to empty */
2660{
2661    YYSTYPE sptp;
2662    for (sp = symlistsp != (YYSTYPE) 0;) {
2663 tp = sp -> next;
2664 free (sp -> name);
2665 free ((char *) sp);
2666 sp = tp;
2667    }
2668    symlist = 0;
2669}
2670
2671/* get lexical input routine generated by lex  */
2672
2673/* Keep compile quiet */
2674#define YY_NO_UNPUT
2675#define YY_NO_INPUT
2676
2677#include "ncgenyy.c"


HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017 | Polyhedron Solutions - INTERNAL USE | COMMERCIAL (Any O/S) SN 4AKIed