1/* A Bison parser, made by GNU Bison 2.3.  */
2
3/* Skeleton implementation for Bison's Yacc-like parsers in C
4
5   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6   Free Software Foundation, Inc.
7
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2, or (at your option)
11   any later version.
12
13   This program is distributed in the hope that it will be useful,
14   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   GNU General Public License for more details.
17
18   You should have received a copy of the GNU General Public License
19   along with this program; if not, write to the Free Software
20   Foundation, Inc., 51 Franklin Street, Fifth Floor,
21   Boston, MA 02110-1301, USA.  */
22
23/* As a special exception, you may create a larger work that contains
24   part or all of the Bison parser skeleton and distribute that work
25   under terms of your choice, so long as that work isn't itself a
26   parser generator using the skeleton or a modified version thereof
27   as a parser skeleton.  Alternatively, if you modify or redistribute
28   the parser skeleton itself, you may (at your option) remove this
29   special exception, which will cause the skeleton and the resulting
30   Bison output files to be licensed under the GNU General Public
31   License without this special exception.
32
33   This special exception was added by the Free Software Foundation in
34   version 2.2 of Bison.  */
35
36/* C LALR(1) parser skeleton written by Richard Stallman, by
37   simplifying the original so-called "semantic" parser.  */
38
39/* All symbols defined below should begin with yy or YY, to avoid
40   infringing on user name space.  This should be done even for local
41   variables, as they might otherwise be expanded by user macros.
42   There are some unavoidable exceptions within include files to
43   define necessary library symbols; they are noted "INFRINGES ON
44   USER NAME SPACE" below.  */
45
46/* Identify Bison output.  */
47#define YYBISON 1
48
49/* Bison version.  */
50#define YYBISON_VERSION "2.3"
51
52/* Skeleton name.  */
53#define YYSKELETON_NAME "yacc.c"
54
55/* Pure parsers.  */
56#define YYPURE 0
57
58/* Using locations.  */
59#define YYLSP_NEEDED 0
60
61/* Substitute the variable and function names.  */
62#define yyparse ncgparse
63#define yylex   ncglex
64#define yyerror ncgerror
65#define yylval  ncglval
66#define yychar  ncgchar
67#define yydebug ncgdebug
68#define yynerrs ncgnerrs
69
70
71/* Tokens.  */
72#ifndef YYTOKENTYPE
73# define YYTOKENTYPE
74   /* Put the tokens into the symbol table, so that GDB and other debuggers
75      know about them.  */
76   enum yytokentype {
77     NC_UNLIMITED_K = 258,
78     CHAR_K = 259,
79     BYTE_K = 260,
80     SHORT_K = 261,
81     INT_K = 262,
82     FLOAT_K = 263,
83     DOUBLE_K = 264,
84     UBYTE_K = 265,
85     USHORT_K = 266,
86     UINT_K = 267,
87     INT64_K = 268,
88     UINT64_K = 269,
89     IDENT = 270,
90     TERMSTRING = 271,
91     CHAR_CONST = 272,
92     BYTE_CONST = 273,
93     SHORT_CONST = 274,
94     INT_CONST = 275,
95     INT64_CONST = 276,
96     UBYTE_CONST = 277,
97     USHORT_CONST = 278,
98     UINT_CONST = 279,
99     UINT64_CONST = 280,
100     FLOAT_CONST = 281,
101     DOUBLE_CONST = 282,
102     DIMENSIONS = 283,
103     VARIABLES = 284,
104     NETCDF = 285,
105     DATA = 286,
106     TYPES = 287,
107     COMPOUND = 288,
108     ENUM = 289,
109     OPAQUE = 290,
110     OPAQUESTRING = 291,
111     GROUP = 292,
112     PATH = 293,
113     FILLMARKER = 294,
114     NIL = 295,
115     _FILLVALUE = 296,
116     _FORMAT = 297,
117     _STORAGE = 298,
118     _CHUNKSIZES = 299,
119     _DEFLATELEVEL = 300,
120     _SHUFFLE = 301,
121     _ENDIANNESS = 302,
122     _NOFILL = 303,
123     _FLETCHER32 = 304,
124     _NCPROPS = 305,
125     _ISNETCDF4 = 306,
126     _SUPERBLOCK = 307,
127     DATASETID = 308
128   };
129#endif
130/* Tokens.  */
131#define NC_UNLIMITED_K 258
132#define CHAR_K 259
133#define BYTE_K 260
134#define SHORT_K 261
135#define INT_K 262
136#define FLOAT_K 263
137#define DOUBLE_K 264
138#define UBYTE_K 265
139#define USHORT_K 266
140#define UINT_K 267
141#define INT64_K 268
142#define UINT64_K 269
143#define IDENT 270
144#define TERMSTRING 271
145#define CHAR_CONST 272
146#define BYTE_CONST 273
147#define SHORT_CONST 274
148#define INT_CONST 275
149#define INT64_CONST 276
150#define UBYTE_CONST 277
151#define USHORT_CONST 278
152#define UINT_CONST 279
153#define UINT64_CONST 280
154#define FLOAT_CONST 281
155#define DOUBLE_CONST 282
156#define DIMENSIONS 283
157#define VARIABLES 284
158#define NETCDF 285
159#define DATA 286
160#define TYPES 287
161#define COMPOUND 288
162#define ENUM 289
163#define OPAQUE 290
164#define OPAQUESTRING 291
165#define GROUP 292
166#define PATH 293
167#define FILLMARKER 294
168#define NIL 295
169#define _FILLVALUE 296
170#define _FORMAT 297
171#define _STORAGE 298
172#define _CHUNKSIZES 299
173#define _DEFLATELEVEL 300
174#define _SHUFFLE 301
175#define _ENDIANNESS 302
176#define _NOFILL 303
177#define _FLETCHER32 304
178#define _NCPROPS 305
179#define _ISNETCDF4 306
180#define _SUPERBLOCK 307
181#define DATASETID 308
182
183
184
185
186/* Copy the first part of user declarations.  */
187#line 11 "ncgen.y"
188
189/*
190static char SccsId[] = "$Id: ncgen.y,v 1.42 2010/05/18 21:32:46 dmh Exp $";
191*/
192#include        "includes.h"
193#include        "offsets.h"
194#include        "ncgeny.h"
195#include        "ncgen.h"
196
197/* Following are in ncdump (for now)*/
198/* Need some (unused) definitions to get it to compile */
199#define ncatt_t void*
200#define ncvar_t void
201#include "nctime.h"
202
203/* parser controls */
204#define YY_NO_INPUT 1
205
206/* True if string a equals string b*/
207#define STREQ(ab)     (*(a) == *(b) && strcmp((a), (b)) == 0)
208#define VLENSIZE  (sizeof(nc_vlen_t))
209#define MAXFLOATDIM 4294967295.0
210
211/* mnemonic */
212typedef enum Attrkind {ATTRVARATTRGLOBALDONTKNOWAttrkind;
213
214typedef nc_vlen_t vlen_t;
215
216/* We retain the old representation of the symbol list
217   as a linked list.
218*/
219Symbolsymlist;
220
221/* Track rootgroup separately*/
222Symbolrootgroup;
223
224/* Track the group sequence */
225static Listgroupstack;
226
227/* Provide a separate sequence for accumulating values
228   during the parse.
229*/
230static Liststack;
231
232/* track homogeneity of types for data lists*/
233static nc_type consttype;
234
235/* Misc. */
236static int stackbase;
237static int stacklen;
238static int count;
239static int opaqueid; /* counter for opaque constants*/
240static int arrayuid; /* counter for pseudo-array types*/
241
242char* primtypenames[PRIMNO] = {
243"nat",
244"byte", "char", "short",
245"int", "float", "double",
246"ubyte", "ushort", "uint",
247"int64", "uint64",
248"string"
249};
250
251static int GLOBAL_SPECIAL = _NCPROPS_FLAG | _ISNETCDF4_FLAG | _SUPERBLOCK_FLAG | _FORMAT_FLAG ;
252
253/*Defined in ncgen.l*/
254extern int lineno;              /* line number for error messages */
255extern Bytebufferlextext;           /* name or string with escapes removed */
256
257extern double double_val;       /* last double value read */
258extern float float_val;         /* last float value read */
259extern long long int64_val;         /* last int64 value read */
260extern int int32_val;             /* last int32 value read */
261extern short int16_val;         /* last short value read */
262extern unsigned long long uint64_val;         /* last int64 value read */
263extern unsigned int uint32_val;             /* last int32 value read */
264extern unsigned short uint16_val;         /* last short value read */
265extern char char_val;           /* last char value read */
266extern signed char byte_val;    /* last byte value read */
267extern unsigned char ubyte_val;    /* last byte value read */
268
269/* Track definitions of dims, types, attributes, and vars*/
270Listgrpdefs;
271Listdimdefs;
272Listattdefs; /* variable-specific attributes*/
273Listgattdefs; /* global attributes only*/
274Listxattdefs; /* unknown attributes*/
275Listtypdefs;
276Listvardefs;
277Listcondefs; /* non-dimension constants used in type defs*/
278Listtmp;
279
280/* Forward */
281static NCConstant makeconstdata(nc_type);
282static NCConstant evaluate(SymbolfcnDatalistarglist);
283static NCConstant makeenumconstref(Symbol*);
284static void addtogroup(Symbol*);
285static Symbolcurrentgroup(void);
286static Symbolcreaterootgroup(const char*);
287static Symbolcreategroup(Symbol*);
288static int dupobjectcheck(nc_class,Symbol*);
289static void setpathcurrent(Symbolsym);
290static Symbolmakeattribute(Symbol*,Symbol*,Symbol*,Datalist*,Attrkind);
291static Symbolmakeprimitivetype(nc_type i);
292static Symbolmakespecial(int tagSymbolvsymSymboltsym, void* data, int isconst);
293static int containsfills(Datalistlist);
294static void datalistextend(DatalistdlNCConstantcon);
295static void vercheck(int ncid);
296static long long extractint(NCConstant con);
297
298int yylex(void);
299
300#ifndef NO_STDARG
301static void yyerror(const char *fmt, ...);
302#else
303static void yyerror(fmt,va_alist) const char* fmtva_dcl;
304#endif
305
306/* Extern */
307extern int lex_init(void);
308
309
310
311/* Enabling traces.  */
312#ifndef YYDEBUG
313# define YYDEBUG 1
314#endif
315
316/* Enabling verbose error messages.  */
317#ifdef YYERROR_VERBOSE
318# undef YYERROR_VERBOSE
319# define YYERROR_VERBOSE 1
320#else
321# define YYERROR_VERBOSE 1
322#endif
323
324/* Enabling the token table.  */
325#ifndef YYTOKEN_TABLE
326# define YYTOKEN_TABLE 0
327#endif
328
329#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
330typedef union YYSTYPE
331#line 136 "ncgen.y"
332{
333Symbolsym;
334unsigned long  size; /* allow for zero size to indicate e.g. UNLIMITED*/
335long           mark; /* track indices into the sequence*/
336int            nctype; /* for tracking attribute list type*/
337Datalist*      datalist;
338NCConstant       constant;
339}
340/* Line 193 of yacc.c.  */
341#line 342 "ncgeny.c"
342 YYSTYPE;
343# define yystype YYSTYPE /* obsolescent; will be withdrawn */
344# define YYSTYPE_IS_DECLARED 1
345# define YYSTYPE_IS_TRIVIAL 1
346#endif
347
348
349
350/* Copy the second part of user declarations.  */
351
352
353/* Line 216 of yacc.c.  */
354#line 355 "ncgeny.c"
355
356#ifdef short
357# undef short
358#endif
359
360#ifdef YYTYPE_UINT8
361typedef YYTYPE_UINT8 yytype_uint8;
362#else
363typedef unsigned char yytype_uint8;
364#endif
365
366#ifdef YYTYPE_INT8
367typedef YYTYPE_INT8 yytype_int8;
368#elif (defined __STDC__ || defined __C99__FUNC__ \
369     || defined __cplusplus || defined _MSC_VER)
370typedef signed char yytype_int8;
371#else
372typedef short int yytype_int8;
373#endif
374
375#ifdef YYTYPE_UINT16
376typedef YYTYPE_UINT16 yytype_uint16;
377#else
378typedef unsigned short int yytype_uint16;
379#endif
380
381#ifdef YYTYPE_INT16
382typedef YYTYPE_INT16 yytype_int16;
383#else
384typedef short int yytype_int16;
385#endif
386
387#ifndef YYSIZE_T
388# ifdef __SIZE_TYPE__
389#  define YYSIZE_T __SIZE_TYPE__
390# elif defined size_t
391#  define YYSIZE_T size_t
392# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
393     || defined __cplusplus || defined _MSC_VER)
394#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
395#  define YYSIZE_T size_t
396# else
397#  define YYSIZE_T unsigned int
398# endif
399#endif
400
401#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
402
403#ifndef YY_
404# if defined YYENABLE_NLS && YYENABLE_NLS
405#  if ENABLE_NLS
406#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
407#   define YY_(msgiddgettext ("bison-runtime", msgid)
408#  endif
409# endif
410# ifndef YY_
411#  define YY_(msgidmsgid
412# endif
413#endif
414
415/* Suppress unused-variable warnings by "using" E.  */
416#if ! defined lint || defined __GNUC__
417# define YYUSE(e) ((void) (e))
418#else
419# define YYUSE(e) /* empty */
420#endif
421
422/* Identity function, used to suppress warnings about constant conditions.  */
423#ifndef lint
424# define YYID(n) (n)
425#else
426#if (defined __STDC__ || defined __C99__FUNC__ \
427     || defined __cplusplus || defined _MSC_VER)
428static int
429YYID (int i)
430#else
431static int
432YYID (i)
433    int i;
434#endif
435{
436  return i;
437}
438#endif
439
440#if ! defined yyoverflow || YYERROR_VERBOSE
441
442/* The parser invokes alloca or malloc; define the necessary symbols.  */
443
444# ifdef YYSTACK_USE_ALLOCA
445#  if YYSTACK_USE_ALLOCA
446#   ifdef __GNUC__
447#    define YYSTACK_ALLOC __builtin_alloca
448#   elif defined __BUILTIN_VA_ARG_INCR
449#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
450#   elif defined _AIX
451#    define YYSTACK_ALLOC __alloca
452#   elif defined _MSC_VER
453#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
454#    define alloca _alloca
455#   else
456#    define YYSTACK_ALLOC alloca
457#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
458     || defined __cplusplus || defined _MSC_VER)
459#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
460#     ifndef _STDLIB_H
461#      define _STDLIB_H 1
462#     endif
463#    endif
464#   endif
465#  endif
466# endif
467
468# ifdef YYSTACK_ALLOC
469   /* Pacify GCC's `empty if-body' warning.  */
470#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
471#  ifndef YYSTACK_ALLOC_MAXIMUM
472    /* The OS might guarantee only one guard page at the bottom of the stack,
473       and a page size can be as small as 4096 bytes.  So we cannot safely
474       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
475       to allow for a few compiler-allocated temporary stack slots.  */
476#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
477#  endif
478# else
479#  define YYSTACK_ALLOC YYMALLOC
480#  define YYSTACK_FREE YYFREE
481#  ifndef YYSTACK_ALLOC_MAXIMUM
482#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
483#  endif
484#  if (defined __cplusplus && ! defined _STDLIB_H \
485       && ! ((defined YYMALLOC || defined malloc) \
486      && (defined YYFREE || defined free)))
487#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
488#   ifndef _STDLIB_H
489#    define _STDLIB_H 1
490#   endif
491#  endif
492#  ifndef YYMALLOC
493#   define YYMALLOC malloc
494#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
495     || defined __cplusplus || defined _MSC_VER)
496void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
497#   endif
498#  endif
499#  ifndef YYFREE
500#   define YYFREE free
501#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
502     || defined __cplusplus || defined _MSC_VER)
503void free (void *); /* INFRINGES ON USER NAME SPACE */
504#   endif
505#  endif
506# endif
507#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
508
509
510#if (! defined yyoverflow \
511     && (! defined __cplusplus \
512  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
513
514/* A type that is properly aligned for any stack member.  */
515union yyalloc
516{
517  yytype_int16 yyss;
518  YYSTYPE yyvs;
519  };
520
521/* The size of the maximum gap between one aligned stack and the next.  */
522# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
523
524/* The size of an array large to enough to hold all stacks, each with
525   N elements.  */
526# define YYSTACK_BYTES(N) \
527     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
528      + YYSTACK_GAP_MAXIMUM)
529
530/* Copy COUNT objects from FROM to TO.  The source and destination do
531   not overlap.  */
532# ifndef YYCOPY
533#  if defined __GNUC__ && 1 < __GNUC__
534#   define YYCOPY(ToFromCount) \
535      __builtin_memcpy (ToFrom, (Count) * sizeof (*(From)))
536#  else
537#   define YYCOPY(ToFromCount) \
538      do \
539 { \
540   YYSIZE_T yyi; \
541   for (yyi = 0; yyi < (Count); yyi++) \
542     (To)[yyi] = (From)[yyi]; \
543 } \
544      while (YYID (0))
545#  endif
546# endif
547
548/* Relocate STACK from its old location to the new one.  The
549   local variables YYSIZE and YYSTACKSIZE give the old and new number of
550   elements in the stack, and YYPTR gives the new location of the
551   stack.  Advance YYPTR to a properly aligned location for the next
552   stack.  */
553# define YYSTACK_RELOCATE(Stack) \
554    do \
555      { \
556 YYSIZE_T yynewbytes; \
557 YYCOPY (&yyptr->StackStackyysize); \
558 Stack = &yyptr->Stack; \
559 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
560 yyptr += yynewbytes / sizeof (*yyptr); \
561      } \
562    while (YYID (0))
563
564#endif
565
566/* YYFINAL -- State number of the termination state.  */
567#define YYFINAL  5
568/* YYLAST -- Last index in YYTABLE.  */
569#define YYLAST   370
570
571/* YYNTOKENS -- Number of terminals.  */
572#define YYNTOKENS  63
573/* YYNNTS -- Number of nonterminals.  */
574#define YYNNTS  67
575/* YYNRULES -- Number of rules.  */
576#define YYNRULES  151
577/* YYNRULES -- Number of states.  */
578#define YYNSTATES  258
579
580/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
581#define YYUNDEFTOK  2
582#define YYMAXUTOK   308
583
584#define YYTRANSLATE(YYX) \
585  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
586
587/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
588static const yytype_uint8 yytranslate[] =
589{
590       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
591       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
592       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
593       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
594      59,    60,    61,     2,    57,     2,     2,     2,     2,     2,
595       2,     2,     2,     2,     2,     2,     2,     2,    62,    56,
596       2,    58,     2,     2,     2,     2,     2,     2,     2,     2,
597       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
598       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
599       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
600       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
601       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
602       2,     2,     2,    54,     2,    55,     2,     2,     2,     2,
603       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
604       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
605       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
606       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
607       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
608       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
609       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
610       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
611       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
612       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
613       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
614       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
615       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
616       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
617      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
618      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
619      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
620      45,    46,    47,    48,    49,    50,    51,    52,    53
621};
622
623#if YYDEBUG
624/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
625   YYRHS.  */
626static const yytype_uint16 yyprhs[] =
627{
628       0,     0,     3,     7,     9,    14,    20,    21,    24,    25,
629      26,    36,    37,    39,    42,    44,    47,    49,    51,    54,
630      57,    60,    63,    66,    67,    69,    76,    78,    82,    86,
631      92,    98,   104,   107,   111,   114,   116,   118,   120,   122,
632     124,   126,   128,   130,   132,   134,   136,   137,   139,   142,
633     145,   149,   151,   153,   155,   159,   163,   167,   169,   170,
634     172,   175,   178,   182,   184,   186,   189,   191,   195,   198,
635     199,   203,   205,   209,   211,   213,   217,   220,   221,   225,
636     227,   231,   233,   235,   237,   239,   241,   243,   244,   248,
637     253,   258,   263,   268,   275,   281,   287,   294,   300,   306,
638     312,   318,   324,   330,   336,   341,   343,   345,   346,   348,
639     351,   354,   358,   362,   364,   366,   367,   369,   373,   375,
640     379,   381,   383,   385,   387,   389,   391,   393,   398,   400,
641     404,   406,   408,   410,   412,   414,   416,   418,   420,   422,
642     424,   426,   428,   430,   434,   436,   438,   440,   442,   444,
643     446,   448
644};
645
646/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
647static const yytype_int16 yyrhs[] =
648{
649      64,     0,    -1,    30,    65,    66,    -1,    53,    -1,    54,
650      67,    68,    55,    -1,   110,    72,    87,    93,   113,    -1,
651      -1,    68,    69,    -1,    -1,    -1,    37,   129,    54,    70,
652      67,    68,    71,    55,   110,    -1,    -1,    32,    -1,    32,
653      73,    -1,    75,    -1,    73,    75,    -1,   129,    -1,    76,
654      -1,   111,    56,    -1,    78,    77,    -1,    83,    77,    -1,
655      82,    77,    -1,    81,    77,    -1,    -1,    56,    -1,    86,
656      34,    74,    54,    79,    55,    -1,    80,    -1,    79,    57,
657      80,    -1,   129,    58,   126,    -1,    35,    59,    20,    60,
658      74,    -1,   108,    59,    61,    60,    74,    -1,    33,    74,
659      54,    84,    55,    -1,    85,    56,    -1,    84,    85,    56,
660      -1,   108,   102,    -1,     4,    -1,     5,    -1,     6,    -1,
661       7,    -1,     8,    -1,     9,    -1,    10,    -1,    11,    -1,
662      12,    -1,    13,    -1,    14,    -1,    -1,    28,    -1,    28,
663      88,    -1,    89,    56,    -1,    88,    89,    56,    -1,    90,
664      -1,   111,    -1,    91,    -1,    90,    57,    91,    -1,    92,
665      58,   126,    -1,    92,    58,     3,    -1,   129,    -1,    -1,
666      29,    -1,    29,    94,    -1,    95,    56,    -1,    94,    95,
667      56,    -1,    96,    -1,   111,    -1,   108,    97,    -1,    98,
668      -1,    97,    57,    98,    -1,   129,    99,    -1,    -1,    59,
669     100,    60,    -1,   101,    -1,   100,    57,   101,    -1,   112,
670      -1,   103,    -1,   102,    57,   103,    -1,   129,   104,    -1,
671      -1,    59,   105,    60,    -1,   106,    -1,   105,    57,   106,
672      -1,    24,    -1,    20,    -1,   109,    -1,   109,    -1,   112,
673      -1,    86,    -1,    -1,   111,    56,   110,    -1,    62,    50,
674      58,   127,    -1,    62,    51,    58,   128,    -1,    62,    52,
675      58,   126,    -1,    62,   129,    58,   116,    -1,   108,   109,
676      62,   129,    58,   116,    -1,   109,    62,   129,    58,   116,
677      -1,   109,    62,    41,    58,   116,    -1,   108,   109,    62,
678      41,    58,   116,    -1,   109,    62,    43,    58,   127,    -1,
679     109,    62,    44,    58,   125,    -1,   109,    62,    49,    58,
680     128,    -1,   109,    62,    45,    58,   126,    -1,   109,    62,
681      46,    58,   128,    -1,   109,    62,    47,    58,   127,    -1,
682     109,    62,    48,    58,   128,    -1,    62,    42,    58,   127,
683      -1,   129,    -1,    38,    -1,    -1,    31,    -1,    31,   114,
684      -1,   115,    56,    -1,   114,   115,    56,    -1,   107,    58,
685     116,    -1,   117,    -1,   118,    -1,    -1,   119,    -1,   116,
686      57,   119,    -1,   120,    -1,    54,   116,    55,    -1,   124,
687      -1,    36,    -1,    39,    -1,    40,    -1,   121,    -1,   122,
688      -1,   112,    -1,   129,    59,   123,    60,    -1,   124,    -1,
689     123,    57,   124,    -1,    17,    -1,    18,    -1,    19,    -1,
690      20,    -1,    21,    -1,    22,    -1,    23,    -1,    24,    -1,
691      25,    -1,    26,    -1,    27,    -1,    16,    -1,   126,    -1,
692     125,    57,   126,    -1,    20,    -1,    24,    -1,    21,    -1,
693      25,    -1,    16,    -1,   127,    -1,   126,    -1,    15,    -1
694};
695
696/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
697static const yytype_uint16 yyrline[] =
698{
699       0,   216,   216,   222,   224,   231,   238,   238,   241,   250,
700     240,   255,   256,   257,   261,   261,   263,   273,   273,   276,
701     277,   278,   279,   282,   282,   285,   315,   317,   334,   343,
702     355,   369,   402,   403,   406,   420,   421,   422,   423,   424,
703     425,   426,   427,   428,   429,   430,   433,   434,   435,   438,
704     439,   442,   442,   444,   445,   449,   456,   466,   478,   479,
705     480,   483,   484,   487,   487,   489,   511,   515,   519,   546,
706     547,   550,   551,   555,   569,   573,   578,   607,   608,   612,
707     613,   618,   628,   648,   659,   670,   689,   696,   696,   699,
708     701,   703,   705,   707,   716,   727,   729,   731,   733,   735,
709     737,   739,   741,   743,   745,   750,   757,   766,   767,   768,
710     771,   772,   775,   779,   780,   784,   788,   789,   794,   795,
711     799,   800,   801,   802,   803,   804,   808,   812,   816,   818,
712     823,   824,   825,   826,   827,   828,   829,   830,   831,   832,
713     833,   834,   838,   839,   843,   845,   847,   849,   854,   858,
714     859,   865
715};
716#endif
717
718#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
719/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
720   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
721static const char *const yytname[] =
722{
723  "$end", "error", "$undefined", "NC_UNLIMITED_K", "CHAR_K", "BYTE_K",
724  "SHORT_K", "INT_K", "FLOAT_K", "DOUBLE_K", "UBYTE_K", "USHORT_K",
725  "UINT_K", "INT64_K", "UINT64_K", "IDENT", "TERMSTRING", "CHAR_CONST",
726  "BYTE_CONST", "SHORT_CONST", "INT_CONST", "INT64_CONST", "UBYTE_CONST",
727  "USHORT_CONST", "UINT_CONST", "UINT64_CONST", "FLOAT_CONST",
728  "DOUBLE_CONST", "DIMENSIONS", "VARIABLES", "NETCDF", "DATA", "TYPES",
729  "COMPOUND", "ENUM", "OPAQUE", "OPAQUESTRING", "GROUP", "PATH",
730  "FILLMARKER", "NIL", "_FILLVALUE", "_FORMAT", "_STORAGE", "_CHUNKSIZES",
731  "_DEFLATELEVEL", "_SHUFFLE", "_ENDIANNESS", "_NOFILL", "_FLETCHER32",
732  "_NCPROPS", "_ISNETCDF4", "_SUPERBLOCK", "DATASETID", "'{'", "'}'",
733  "';'", "','", "'='", "'('", "')'", "'*'", "':'", "$accept", "ncdesc",
734  "datasetid", "rootgroup", "groupbody", "subgrouplist", "namedgroup",
735  "@1", "@2", "typesection", "typedecls", "typename", "type_or_attr_decl",
736  "typedecl", "optsemicolon", "enumdecl", "enumidlist", "enumid",
737  "opaquedecl", "vlendecl", "compounddecl", "fields", "field", "primtype",
738  "dimsection", "dimdecls", "dim_or_attr_decl", "dimdeclist", "dimdecl",
739  "dimd", "vasection", "vadecls", "vadecl_or_attr", "vardecl", "varlist",
740  "varspec", "dimspec", "dimlist", "dimref", "fieldlist", "fieldspec",
741  "fielddimspec", "fielddimlist", "fielddim", "varref", "typeref",
742  "type_var_ref", "attrdecllist", "attrdecl", "path", "datasection",
743  "datadecls", "datadecl", "datalist", "datalist0", "datalist1",
744  "dataitem", "constdata", "econstref", "function", "arglist",
745  "simpleconstant", "intlist", "constint", "conststring", "constbool",
746  "ident", 0
747};
748#endif
749
750# ifdef YYPRINT
751/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
752   token YYLEX-NUM.  */
753static const yytype_uint16 yytoknum[] =
754{
755       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
756     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
757     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
758     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
759     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
760     305,   306,   307,   308,   123,   125,    59,    44,    61,    40,
761      41,    42,    58
762};
763# endif
764
765/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
766static const yytype_uint8 yyr1[] =
767{
768       0,    63,    64,    65,    66,    67,    68,    68,    70,    71,
769      69,    72,    72,    72,    73,    73,    74,    75,    75,    76,
770      76,    76,    76,    77,    77,    78,    79,    79,    80,    81,
771      82,    83,    84,    84,    85,    86,    86,    86,    86,    86,
772      86,    86,    86,    86,    86,    86,    87,    87,    87,    88,
773      88,    89,    89,    90,    90,    91,    91,    92,    93,    93,
774      93,    94,    94,    95,    95,    96,    97,    97,    98,    99,
775      99,   100,   100,   101,   102,   102,   103,   104,   104,   105,
776     105,   106,   106,   107,   108,   109,   109,   110,   110,   111,
777     111,   111,   111,   111,   111,   111,   111,   111,   111,   111,
778     111,   111,   111,   111,   111,   112,   112,   113,   113,   113,
779     114,   114,   115,   116,   116,   117,   118,   118,   119,   119,
780     120,   120,   120,   120,   120,   120,   121,   122,   123,   123,
781     124,   124,   124,   124,   124,   124,   124,   124,   124,   124,
782     124,   124,   125,   125,   126,   126,   126,   126,   127,   128,
783     128,   129
784};
785
786/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
787static const yytype_uint8 yyr2[] =
788{
789       0,     2,     3,     1,     4,     5,     0,     2,     0,     0,
790       9,     0,     1,     2,     1,     2,     1,     1,     2,     2,
791       2,     2,     2,     0,     1,     6,     1,     3,     3,     5,
792       5,     5,     2,     3,     2,     1,     1,     1,     1,     1,
793       1,     1,     1,     1,     1,     1,     0,     1,     2,     2,
794       3,     1,     1,     1,     3,     3,     3,     1,     0,     1,
795       2,     2,     3,     1,     1,     2,     1,     3,     2,     0,
796       3,     1,     3,     1,     1,     3,     2,     0,     3,     1,
797       3,     1,     1,     1,     1,     1,     1,     0,     3,     4,
798       4,     4,     4,     6,     5,     5,     6,     5,     5,     5,
799       5,     5,     5,     5,     4,     1,     1,     0,     1,     2,
800       2,     3,     3,     1,     1,     0,     1,     3,     1,     3,
801       1,     1,     1,     1,     1,     1,     1,     4,     1,     3,
802       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
803       1,     1,     1,     3,     1,     1,     1,     1,     1,     1,
804       1,     1
805};
806
807/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
808   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
809   means the default is an error.  */
810static const yytype_uint8 yydefact[] =
811{
812       0,     0,     0,     3,     0,     1,    87,     2,    35,    36,
813      37,    38,    39,    40,    41,    42,    43,    44,    45,   151,
814     106,     0,     6,    86,     0,    84,    11,     0,    85,   105,
815       0,     0,     0,     0,     0,     0,     0,     0,    12,    46,
816      87,     0,     0,     0,     0,   115,     0,     4,     7,     0,
817       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
818       0,    13,    14,    17,    23,    23,    23,    23,    86,     0,
819       0,    47,    58,    88,   148,   104,    89,   144,   146,   145,
820     147,   150,   149,    90,    91,   141,   130,   131,   132,   133,
821     134,   135,   136,   137,   138,   139,   140,   121,   122,   123,
822     115,   126,    92,   113,   114,   116,   118,   124,   125,   120,
823     105,     0,     0,     0,   115,     0,     0,     0,     0,     0,
824       0,     0,   115,     0,    16,     0,    15,    24,    19,    22,
825      21,    20,     0,     0,    18,    48,     0,    51,    53,     0,
826      52,   105,    59,   107,     0,     0,     0,     8,   115,   115,
827      95,    97,    98,   142,   100,   101,   102,   103,    99,    94,
828       0,     0,     0,     0,     0,    49,     0,     0,    60,     0,
829      63,     0,    64,   108,     5,   119,   117,     0,   128,    87,
830      96,    93,     0,     0,     0,     0,    84,     0,     0,     0,
831      50,    54,    57,    56,    55,     0,    61,    65,    66,    69,
832       0,    83,   109,     0,     0,   127,     6,   143,    31,     0,
833      32,    34,    74,    77,    29,     0,    26,     0,    30,    62,
834       0,     0,    68,   115,     0,   110,   129,     9,    33,     0,
835       0,    76,    25,     0,     0,    67,    69,     0,    71,    73,
836     112,   111,     0,    75,    82,    81,     0,    79,    27,    28,
837       0,    70,    87,     0,    78,    72,    10,    80
838};
839
840/* YYDEFGOTO[NTERM-NUM].  */
841static const yytype_int16 yydefgoto[] =
842{
843      -1,     2,     4,     7,    22,    35,    48,   179,   242,    39,
844      61,   123,    62,    63,   128,    64,   215,   216,    65,    66,
845      67,   183,   184,    23,    72,   135,   136,   137,   138,   139,
846     143,   168,   169,   170,   197,   198,   222,   237,   238,   211,
847     212,   231,   246,   247,   200,    24,    25,    26,    27,    28,
848     174,   202,   203,   102,   103,   104,   105,   106,   107,   108,
849     177,   109,   152,    81,    82,    83,    29
850};
851
852/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
853   STATE-NUM.  */
854#define YYPACT_NINF -133
855static const yytype_int16 yypact[] =
856{
857     -11,   -48,    20,  -133,   -19,  -133,   210,  -133,  -133,  -133,
858    -133,  -133,  -133,  -133,  -133,  -133,  -133,  -133,  -133,  -133,
859    -133,    -3,  -133,  -133,   332,   -16,     8,    -4,  -133,  -133,
860      18,    19,    29,    41,    48,   -22,    47,   128,    56,    75,
861     210,    94,    94,   136,    33,   281,   102,  -133,  -133,     2,
862      63,    64,    65,    68,    71,    74,    76,    77,    78,   102,
863      82,    56,  -133,  -133,    81,    81,    81,    81,    99,   222,
864      88,   210,   117,  -133,  -133,  -133,  -133,  -133,  -133,  -133,
865    -133,  -133,  -133,  -133,  -133,  -133,  -133,  -133,  -133,  -133,
866    -133,  -133,  -133,  -133,  -133,  -133,  -133,  -133,  -133,  -133,
867     281,  -133,    90,  -133,  -133,  -133,  -133,  -133,  -133,  -133,
868      89,    97,    91,   100,   281,    94,    33,    33,   136,    94,
869     136,   136,   281,   105,  -133,   142,  -133,  -133,  -133,  -133,
870    -133,  -133,   102,   109,  -133,   210,   107,   121,  -133,   123,
871    -133,   125,   210,   148,    35,   281,   333,  -133,   281,   281,
872      90,  -133,   129,  -133,  -133,  -133,  -133,  -133,  -133,    90,
873     332,   127,   131,   130,   132,  -133,   102,    95,   210,   133,
874    -133,   332,  -133,   332,  -133,  -133,  -133,   -23,  -133,   210,
875      90,    90,    33,   278,   135,   102,  -133,   102,   102,   102,
876    -133,  -133,  -133,  -133,  -133,   137,  -133,   138,  -133,   -32,
877     139,  -133,   332,   140,   333,  -133,  -133,  -133,  -133,   144,
878    -133,   141,  -133,   145,  -133,    45,  -133,   143,  -133,  -133,
879     102,   -12,  -133,   281,   147,  -133,  -133,   157,  -133,   102,
880      -2,  -133,  -133,   102,    33,  -133,   146,    25,  -133,  -133,
881      90,  -133,   151,  -133,  -133,  -133,    26,  -133,  -133,  -133,
882     -12,  -133,   210,    -2,  -133,  -133,  -133,  -133
883};
884
885/* YYPGOTO[NTERM-NUM].  */
886static const yytype_int16 yypgoto[] =
887{
888    -133,  -133,  -133,  -133,    28,     4,  -133,  -133,  -133,  -133,
889    -133,  -109,   150,  -133,    30,  -133,  -133,     5,  -133,  -133,
890    -133,  -133,    57,   -25,  -133,  -133,   104,  -133,    79,  -133,
891    -133,  -133,    73,  -133,  -133,    22,  -133,  -133,    -7,  -133,
892      15,  -133,  -133,    -6,  -133,   -29,   -18,   -39,   -30,   -41,
893    -133,  -133,    44,   -93,  -133,  -133,   106,  -133,  -133,  -133,
894    -133,  -132,  -133,   -42,   -31,   -76,   -21
895};
896
897/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
898   positive, shift that token.  If negative, reduce the rule which
899   number is the opposite.  If zero, do what YYDEFACT says.
900   If YYTABLE_NINF, syntax error.  */
901#define YYTABLE_NINF -106
902static const yytype_int16 yytable[] =
903{
904      34,    73,    84,    19,   101,     3,    36,   144,    70,    69,
905      75,    76,    19,    68,   178,    46,    58,    19,   244,     1,
906       5,   150,   245,   162,   110,   111,    20,   221,   113,   159,
907    -105,    70,    69,    47,   204,     6,    68,   205,   124,    30,
908      38,   140,   155,   112,   157,   158,    37,    31,    32,    33,
909     141,    36,    40,    77,    78,   180,   181,    79,    80,   101,
910       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
911      18,    19,   226,   101,   153,   154,    41,    42,   214,   110,
912     218,   101,   250,   253,   151,   251,   254,    43,   156,    59,
913     175,    60,   145,   110,    20,   129,   130,   131,   193,    44,
914     232,   110,   233,    71,   101,   140,    45,   101,   101,    49,
915      74,   124,   172,   171,   141,    77,    78,    19,    21,    79,
916      80,   114,   115,   116,   110,   194,   117,   110,   110,   118,
917     240,   185,   119,   132,   120,   121,   122,   127,   172,   171,
918     207,   125,   186,    19,   134,   192,   142,   145,   146,   148,
919     199,   147,    74,    36,   185,   201,    77,    78,   149,   160,
920      79,    80,   161,   165,   213,   186,   124,   217,   124,    50,
921     163,    51,    52,    53,    54,    55,    56,    57,   166,   173,
922     239,   167,   101,   -57,   201,   188,   182,   187,   190,   196,
923     189,   210,   249,   219,    46,   220,   225,   223,   229,   236,
924     228,   234,   110,   241,   230,   221,   252,   206,   213,   239,
925     227,   126,   217,   256,     8,     9,    10,    11,    12,    13,
926      14,    15,    16,    17,    18,    19,     8,     9,    10,    11,
927      12,    13,    14,    15,    16,    17,    18,    19,   248,   164,
928     209,   195,   235,   255,   243,   191,   224,   257,    20,     0,
929       0,   176,     0,     0,     0,     0,     0,     0,     0,     0,
930      20,     0,     0,     0,     0,     0,     0,     0,     0,     0,
931       0,     0,    21,     0,     0,     0,     0,     0,     0,     0,
932       0,   133,     8,     9,    10,    11,    12,    13,    14,    15,
933      16,    17,    18,    19,     0,     0,    19,    85,    86,    87,
934      88,    89,    90,    91,    92,    93,    94,    95,    96,     0,
935       0,     0,     0,     0,     0,     0,    20,    97,     0,    20,
936      98,    99,     0,     0,     0,     0,     0,     0,     0,     0,
937       0,     0,     0,   208,     0,   100,     8,     9,    10,    11,
938      12,    13,    14,    15,    16,    17,    18,    19,     0,    85,
939      86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
940      96,     0,     0,     0,     0,     0,     0,     0,     0,     0,
941      20
942};
943
944static const yytype_int16 yycheck[] =
945{
946      21,    40,    44,    15,    45,    53,    24,   100,    38,    38,
947      41,    42,    15,    38,   146,    37,    37,    15,    20,    30,
948       0,   114,    24,   132,    45,    46,    38,    59,    49,   122,
949      62,    61,    61,    55,    57,    54,    61,    60,    59,    42,
950      32,    71,   118,    41,   120,   121,    62,    50,    51,    52,
951      71,    69,    56,    20,    21,   148,   149,    24,    25,   100,
952       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
953      14,    15,   204,   114,   116,   117,    58,    58,   187,   100,
954     189,   122,    57,    57,   115,    60,    60,    58,   119,    33,
955      55,    35,    57,   114,    38,    65,    66,    67,     3,    58,
956      55,   122,    57,    28,   145,   135,    58,   148,   149,    62,
957      16,   132,   142,   142,   135,    20,    21,    15,    62,    24,
958      25,    58,    58,    58,   145,   167,    58,   148,   149,    58,
959     223,   160,    58,    34,    58,    58,    58,    56,   168,   168,
960     182,    59,   160,    15,    56,   166,    29,    57,    59,    58,
961     171,    54,    16,   171,   183,   173,    20,    21,    58,    54,
962      24,    25,    20,    56,   185,   183,   187,   188,   189,    41,
963      61,    43,    44,    45,    46,    47,    48,    49,    57,    31,
964     221,    58,   223,    58,   202,    54,    57,    60,    56,    56,
965      60,    56,   234,    56,    37,    57,    56,    58,    57,   220,
966      56,    58,   223,    56,    59,    59,    55,   179,   229,   250,
967     206,    61,   233,   252,     4,     5,     6,     7,     8,     9,
968      10,    11,    12,    13,    14,    15,     4,     5,     6,     7,
969       8,     9,    10,    11,    12,    13,    14,    15,   233,   135,
970     183,   168,   220,   250,   229,   166,   202,   253,    38,    -1,
971      -1,   145,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
972      38,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
973      -1,    -1,    62,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
974      -1,    59,     4,     5,     6,     7,     8,     9,    10,    11,
975      12,    13,    14,    15,    -1,    -1,    15,    16,    17,    18,
976      19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
977      -1,    -1,    -1,    -1,    -1,    -1,    38,    36,    -1,    38,
978      39,    40,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
979      -1,    -1,    -1,    55,    -1,    54,     4,     5,     6,     7,
980       8,     9,    10,    11,    12,    13,    14,    15,    -1,    16,
981      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
982      27,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
983      38
984};
985
986/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
987   symbol of state STATE-NUM.  */
988static const yytype_uint8 yystos[] =
989{
990       0,    30,    64,    53,    65,     0,    54,    66,     4,     5,
991       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
992      38,    62,    67,    86,   108,   109,   110,   111,   112,   129,
993      42,    50,    51,    52,   129,    68,   109,    62,    32,    72,
994      56,    58,    58,    58,    58,    58,    37,    55,    69,    62,
995      41,    43,    44,    45,    46,    47,    48,    49,   129,    33,
996      35,    73,    75,    76,    78,    81,    82,    83,    86,   108,
997     111,    28,    87,   110,    16,   127,   127,    20,    21,    24,
998      25,   126,   127,   128,   126,    16,    17,    18,    19,    20,
999      21,    22,    23,    24,    25,    26,    27,    36,    39,    40,
1000      54,   112,   116,   117,   118,   119,   120,   121,   122,   124,
1001     129,   129,    41,   129,    58,    58,    58,    58,    58,    58,
1002      58,    58,    58,    74,   129,    59,    75,    56,    77,    77,
1003      77,    77,    34,    59,    56,    88,    89,    90,    91,    92,
1004     111,   129,    29,    93,   116,    57,    59,    54,    58,    58,
1005     116,   127,   125,   126,   126,   128,   127,   128,   128,   116,
1006      54,    20,    74,    61,    89,    56,    57,    58,    94,    95,
1007      96,   108,   111,    31,   113,    55,   119,   123,   124,    70,
1008     116,   116,    57,    84,    85,   108,   109,    60,    54,    60,
1009      56,    91,   129,     3,   126,    95,    56,    97,    98,   129,
1010     107,   109,   114,   115,    57,    60,    67,   126,    55,    85,
1011      56,   102,   103,   129,    74,    79,    80,   129,    74,    56,
1012      57,    59,    99,    58,   115,    56,   124,    68,    56,    57,
1013      59,   104,    55,    57,    58,    98,   129,   100,   101,   112,
1014     116,    56,    71,   103,    20,    24,   105,   106,    80,   126,
1015      57,    60,    55,    57,    60,   101,   110,   106
1016};
1017
1018#define yyerrok (yyerrstatus = 0)
1019#define yyclearin (yychar = YYEMPTY)
1020#define YYEMPTY (-2)
1021#define YYEOF 0
1022
1023#define YYACCEPT goto yyacceptlab
1024#define YYABORT goto yyabortlab
1025#define YYERROR goto yyerrorlab
1026
1027
1028/* Like YYERROR except do call yyerror.  This remains here temporarily
1029   to ease the transition to the new meaning of YYERROR, for GCC.
1030   Once GCC version 2 has supplanted version 1, this can go.  */
1031
1032#define YYFAIL goto yyerrlab
1033
1034#define YYRECOVERING()  (!!yyerrstatus)
1035
1036#define YYBACKUP(TokenValue) \
1037do \
1038  if (yychar == YYEMPTY && yylen == 1) \
1039    { \
1040      yychar = (Token); \
1041      yylval = (Value); \
1042      yytoken = YYTRANSLATE (yychar); \
1043      YYPOPSTACK (1); \
1044      goto yybackup; \
1045    } \
1046  else \
1047    { \
1048      yyerror (YY_("syntax error: cannot back up")); \
1049      YYERROR; \
1050    } \
1051while (YYID (0))
1052
1053
1054#define YYTERROR 1
1055#define YYERRCODE 256
1056
1057
1058/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1059   If N is 0, then set CURRENT to the empty location which ends
1060   the previous symbol: RHS[0] (always defined).  */
1061
1062#define YYRHSLOC(RhsK) ((Rhs)[K])
1063#ifndef YYLLOC_DEFAULT
1064# define YYLLOC_DEFAULT(CurrentRhsN) \
1065    do \
1066      if (YYID (N))                                                    \
1067 { \
1068   (Current).first_line   = YYRHSLOC (Rhs, 1).first_line; \
1069   (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1070   (Current).last_line    = YYRHSLOC (RhsN).last_line; \
1071   (Current).last_column  = YYRHSLOC (RhsN).last_column; \
1072 } \
1073      else \
1074 { \
1075   (Current).first_line   = (Current).last_line   = \
1076     YYRHSLOC (Rhs, 0).last_line; \
1077   (Current).first_column = (Current).last_column = \
1078     YYRHSLOC (Rhs, 0).last_column; \
1079 } \
1080    while (YYID (0))
1081#endif
1082
1083
1084/* YY_LOCATION_PRINT -- Print the location on the stream.
1085   This macro was not mandated originally: define only if we know
1086   we won't break user code: when these are the locations we know.  */
1087
1088#ifndef YY_LOCATION_PRINT
1089# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1090#  define YY_LOCATION_PRINT(FileLoc) \
1091     fprintf (File, "%d.%d-%d.%d", \
1092       (Loc).first_line, (Loc).first_column, \
1093       (Loc).last_line,  (Loc).last_column)
1094# else
1095#  define YY_LOCATION_PRINT(FileLoc) ((void) 0)
1096# endif
1097#endif
1098
1099
1100/* YYLEX -- calling `yylex' with the right arguments.  */
1101
1102#ifdef YYLEX_PARAM
1103# define YYLEX yylex (YYLEX_PARAM)
1104#else
1105# define YYLEX yylex ()
1106#endif
1107
1108/* Enable debugging if requested.  */
1109#if YYDEBUG
1110
1111# ifndef YYFPRINTF
1112#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1113#  define YYFPRINTF fprintf
1114# endif
1115
1116# define YYDPRINTF(Args) \
1117do { \
1118  if (yydebug) \
1119    YYFPRINTF Args; \
1120} while (YYID (0))
1121
1122# define YY_SYMBOL_PRINT(TitleTypeValueLocation)   \
1123do {   \
1124  if (yydebug)   \
1125    {   \
1126      YYFPRINTF (stderr, "%s ", Title);   \
1127      yy_symbol_print (stderr,   \
1128   TypeValue); \
1129      YYFPRINTF (stderr, "\n");   \
1130    }   \
1131} while (YYID (0))
1132
1133
1134/*--------------------------------.
1135| Print this symbol on YYOUTPUT.  |
1136`--------------------------------*/
1137
1138/*ARGSUSED*/
1139#if (defined __STDC__ || defined __C99__FUNC__ \
1140     || defined __cplusplus || defined _MSC_VER)
1141static void
1142yy_symbol_value_print (FILE *yyoutput, int yytypeYYSTYPE const * const yyvaluep)
1143#else
1144static void
1145yy_symbol_value_print (yyoutputyytypeyyvaluep)
1146    FILE *yyoutput;
1147    int yytype;
1148    YYSTYPE const * const yyvaluep;
1149#endif
1150{
1151  if (!yyvaluep)
1152    return;
1153# ifdef YYPRINT
1154  if (yytype < YYNTOKENS)
1155    YYPRINT (yyoutputyytoknum[yytype], *yyvaluep);
1156# else
1157  YYUSE (yyoutput);
1158# endif
1159  switch (yytype)
1160    {
1161      default:
1162 break;
1163    }
1164}
1165
1166
1167/*--------------------------------.
1168| Print this symbol on YYOUTPUT.  |
1169`--------------------------------*/
1170
1171#if (defined __STDC__ || defined __C99__FUNC__ \
1172     || defined __cplusplus || defined _MSC_VER)
1173static void
1174yy_symbol_print (FILE *yyoutput, int yytypeYYSTYPE const * const yyvaluep)
1175#else
1176static void
1177yy_symbol_print (yyoutputyytypeyyvaluep)
1178    FILE *yyoutput;
1179    int yytype;
1180    YYSTYPE const * const yyvaluep;
1181#endif
1182{
1183  if (yytype < YYNTOKENS)
1184    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1185  else
1186    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1187
1188  yy_symbol_value_print (yyoutputyytypeyyvaluep);
1189  YYFPRINTF (yyoutput, ")");
1190}
1191
1192/*------------------------------------------------------------------.
1193| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1194| TOP (included).                                                   |
1195`------------------------------------------------------------------*/
1196
1197#if (defined __STDC__ || defined __C99__FUNC__ \
1198     || defined __cplusplus || defined _MSC_VER)
1199static void
1200yy_stack_print (yytype_int16 *bottomyytype_int16 *top)
1201#else
1202static void
1203yy_stack_print (bottomtop)
1204    yytype_int16 *bottom;
1205    yytype_int16 *top;
1206#endif
1207{
1208  YYFPRINTF (stderr, "Stack now");
1209  for (; bottom <= top; ++bottom)
1210    YYFPRINTF (stderr, " %d", *bottom);
1211  YYFPRINTF (stderr, "\n");
1212}
1213
1214# define YY_STACK_PRINT(BottomTop) \
1215do { \
1216  if (yydebug) \
1217    yy_stack_print ((Bottom), (Top)); \
1218} while (YYID (0))
1219
1220
1221/*------------------------------------------------.
1222| Report that the YYRULE is going to be reduced.  |
1223`------------------------------------------------*/
1224
1225#if (defined __STDC__ || defined __C99__FUNC__ \
1226     || defined __cplusplus || defined _MSC_VER)
1227static void
1228yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1229#else
1230static void
1231yy_reduce_print (yyvspyyrule)
1232    YYSTYPE *yyvsp;
1233    int yyrule;
1234#endif
1235{
1236  int yynrhs = yyr2[yyrule];
1237  int yyi;
1238  unsigned long int yylno = yyrline[yyrule];
1239  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1240      yyrule - 1, yylno);
1241  /* The symbols being reduced.  */
1242  for (yyi = 0; yyi < yynrhsyyi++)
1243    {
1244      fprintf (stderr, "   $%d = ", yyi + 1);
1245      yy_symbol_print (stderryyrhs[yyprhs[yyrule] + yyi],
1246        &(yyvsp[(yyi + 1) - (yynrhs)])
1247                );
1248      fprintf (stderr, "\n");
1249    }
1250}
1251
1252# define YY_REDUCE_PRINT(Rule) \
1253do { \
1254  if (yydebug) \
1255    yy_reduce_print (yyvspRule); \
1256} while (YYID (0))
1257
1258/* Nonzero means print parse trace.  It is left uninitialized so that
1259   multiple parsers can coexist.  */
1260int yydebug;
1261#else /* !YYDEBUG */
1262# define YYDPRINTF(Args)
1263# define YY_SYMBOL_PRINT(TitleTypeValueLocation)
1264# define YY_STACK_PRINT(BottomTop)
1265# define YY_REDUCE_PRINT(Rule)
1266#endif /* !YYDEBUG */
1267
1268
1269/* YYINITDEPTH -- initial size of the parser's stacks.  */
1270#ifndef YYINITDEPTH
1271# define YYINITDEPTH 200
1272#endif
1273
1274/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1275   if the built-in stack extension method is used).
1276
1277   Do not make this value too large; the results are undefined if
1278   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1279   evaluated with infinite-precision integer arithmetic.  */
1280
1281#ifndef YYMAXDEPTH
1282# define YYMAXDEPTH 10000
1283#endif
1284
1285
1286
1287#if YYERROR_VERBOSE
1288
1289# ifndef yystrlen
1290#  if defined __GLIBC__ && defined _STRING_H
1291#   define yystrlen strlen
1292#  else
1293/* Return the length of YYSTR.  */
1294#if (defined __STDC__ || defined __C99__FUNC__ \
1295     || defined __cplusplus || defined _MSC_VER)
1296static YYSIZE_T
1297yystrlen (const char *yystr)
1298#else
1299static YYSIZE_T
1300yystrlen (yystr)
1301    const char *yystr;
1302#endif
1303{
1304  YYSIZE_T yylen;
1305  for (yylen = 0; yystr[yylen]; yylen++)
1306    continue;
1307  return yylen;
1308}
1309#  endif
1310# endif
1311
1312# ifndef yystpcpy
1313#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1314#   define yystpcpy stpcpy
1315#  else
1316/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1317   YYDEST.  */
1318#if (defined __STDC__ || defined __C99__FUNC__ \
1319     || defined __cplusplus || defined _MSC_VER)
1320static char *
1321yystpcpy (char *yydest, const char *yysrc)
1322#else
1323static char *
1324yystpcpy (yydestyysrc)
1325    char *yydest;
1326    const char *yysrc;
1327#endif
1328{
1329  char *yyd = yydest;
1330  const char *yys = yysrc;
1331
1332  while ((*yyd++ = *yys++) != '\0')
1333    continue;
1334
1335  return yyd - 1;
1336}
1337#  endif
1338# endif
1339
1340# ifndef yytnamerr
1341/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1342   quotes and backslashes, so that it's suitable for yyerror.  The
1343   heuristic is that double-quoting is unnecessary unless the string
1344   contains an apostrophe, a comma, or backslash (other than
1345   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1346   null, do not copy; instead, return the length of what the result
1347   would have been.  */
1348static YYSIZE_T
1349yytnamerr (char *yyres, const char *yystr)
1350{
1351  if (*yystr == '"')
1352    {
1353      YYSIZE_T yyn = 0;
1354      char const *yyp = yystr;
1355
1356      for (;;)
1357 switch (*++yyp)
1358   {
1359   case '\'':
1360   case ',':
1361     goto do_not_strip_quotes;
1362
1363   case '\\':
1364     if (*++yyp != '\\')
1365       goto do_not_strip_quotes;
1366     /* Fall through.  */
1367   default:
1368     if (yyres)
1369       yyres[yyn] = *yyp;
1370     yyn++;
1371     break;
1372
1373   case '"':
1374     if (yyres)
1375       yyres[yyn] = '\0';
1376     return yyn;
1377   }
1378    do_not_strip_quotes: ;
1379    }
1380
1381  if (! yyres)
1382    return yystrlen (yystr);
1383
1384  return yystpcpy (yyresyystr) - yyres;
1385}
1386# endif
1387
1388/* Copy into YYRESULT an error message about the unexpected token
1389   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
1390   including the terminating null byte.  If YYRESULT is null, do not
1391   copy anything; just return the number of bytes that would be
1392   copied.  As a special case, return 0 if an ordinary "syntax error"
1393   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1394   size calculation.  */
1395static YYSIZE_T
1396yysyntax_error (char *yyresult, int yystate, int yychar)
1397{
1398  int yyn = yypact[yystate];
1399
1400  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1401    return 0;
1402  else
1403    {
1404      int yytype = YYTRANSLATE (yychar);
1405      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1406      YYSIZE_T yysize = yysize0;
1407      YYSIZE_T yysize1;
1408      int yysize_overflow = 0;
1409      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1410      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1411      int yyx;
1412
1413# if 0
1414      /* This is so xgettext sees the translatable formats that are
1415  constructed on the fly.  */
1416      YY_("syntax error, unexpected %s");
1417      YY_("syntax error, unexpected %s, expecting %s");
1418      YY_("syntax error, unexpected %s, expecting %s or %s");
1419      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1420      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1421# endif
1422      char *yyfmt;
1423      char const *yyf;
1424      static char const yyunexpected[] = "syntax error, unexpected %s";
1425      static char const yyexpecting[] = ", expecting %s";
1426      static char const yyor[] = " or %s";
1427      char yyformat[sizeof yyunexpected
1428     + sizeof yyexpecting - 1
1429     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1430        * (sizeof yyor - 1))];
1431      char const *yyprefix = yyexpecting;
1432
1433      /* Start YYX at -YYN if negative to avoid negative indexes in
1434  YYCHECK.  */
1435      int yyxbegin = yyn < 0 ? -yyn : 0;
1436
1437      /* Stay within bounds of both yycheck and yytname.  */
1438      int yychecklim = YYLAST - yyn + 1;
1439      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1440      int yycount = 1;
1441
1442      yyarg[0] = yytname[yytype];
1443      yyfmt = yystpcpy (yyformatyyunexpected);
1444
1445      for (yyx = yyxbeginyyx < yyxend; ++yyx)
1446 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1447   {
1448     if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1449       {
1450 yycount = 1;
1451 yysize = yysize0;
1452 yyformat[sizeof yyunexpected - 1] = '\0';
1453 break;
1454       }
1455     yyarg[yycount++] = yytname[yyx];
1456     yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1457     yysize_overflow |= (yysize1 < yysize);
1458     yysize = yysize1;
1459     yyfmt = yystpcpy (yyfmtyyprefix);
1460     yyprefix = yyor;
1461   }
1462
1463      yyf = YY_(yyformat);
1464      yysize1 = yysize + yystrlen (yyf);
1465      yysize_overflow |= (yysize1 < yysize);
1466      yysize = yysize1;
1467
1468      if (yysize_overflow)
1469 return YYSIZE_MAXIMUM;
1470
1471      if (yyresult)
1472 {
1473   /* Avoid sprintf, as that infringes on the user's name space.
1474      Don't have undefined behavior even if the translation
1475      produced a string with the wrong number of "%s"s.  */
1476   char *yyp = yyresult;
1477   int yyi = 0;
1478   while ((*yyp = *yyf) != '\0')
1479     {
1480       if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1481 {
1482   yyp += yytnamerr (yypyyarg[yyi++]);
1483   yyf += 2;
1484 }
1485       else
1486 {
1487   yyp++;
1488   yyf++;
1489 }
1490     }
1491 }
1492      return yysize;
1493    }
1494}
1495#endif /* YYERROR_VERBOSE */
1496
1497
1498/*-----------------------------------------------.
1499| Release the memory associated to this symbol.  |
1500`-----------------------------------------------*/
1501
1502/*ARGSUSED*/
1503#if (defined __STDC__ || defined __C99__FUNC__ \
1504     || defined __cplusplus || defined _MSC_VER)
1505static void
1506yydestruct (const char *yymsg, int yytypeYYSTYPE *yyvaluep)
1507#else
1508static void
1509yydestruct (yymsgyytypeyyvaluep)
1510    const char *yymsg;
1511    int yytype;
1512    YYSTYPE *yyvaluep;
1513#endif
1514{
1515  YYUSE (yyvaluep);
1516
1517  if (!yymsg)
1518    yymsg = "Deleting";
1519  YY_SYMBOL_PRINT (yymsgyytypeyyvaluepyylocationp);
1520
1521  switch (yytype)
1522    {
1523
1524      default:
1525 break;
1526    }
1527}
1528
1529
1530/* Prevent warnings from -Wmissing-prototypes.  */
1531
1532#ifdef YYPARSE_PARAM
1533#if defined __STDC__ || defined __cplusplus
1534int yyparse (void *YYPARSE_PARAM);
1535#else
1536int yyparse ();
1537#endif
1538#else /* ! YYPARSE_PARAM */
1539#if defined __STDC__ || defined __cplusplus
1540int yyparse (void);
1541#else
1542int yyparse ();
1543#endif
1544#endif /* ! YYPARSE_PARAM */
1545
1546
1547
1548/* The look-ahead symbol.  */
1549int yychar;
1550
1551/* The semantic value of the look-ahead symbol.  */
1552YYSTYPE yylval;
1553
1554/* Number of syntax errors so far.  */
1555int yynerrs;
1556
1557
1558
1559/*----------.
1560| yyparse.  |
1561`----------*/
1562
1563#ifdef YYPARSE_PARAM
1564#if (defined __STDC__ || defined __C99__FUNC__ \
1565     || defined __cplusplus || defined _MSC_VER)
1566int
1567yyparse (void *YYPARSE_PARAM)
1568#else
1569int
1570yyparse (YYPARSE_PARAM)
1571    void *YYPARSE_PARAM;
1572#endif
1573#else /* ! YYPARSE_PARAM */
1574#if (defined __STDC__ || defined __C99__FUNC__ \
1575     || defined __cplusplus || defined _MSC_VER)
1576int
1577yyparse (void)
1578#else
1579int
1580yyparse ()
1581
1582#endif
1583#endif
1584{
1585
1586  int yystate;
1587  int yyn;
1588  int yyresult;
1589  /* Number of tokens to shift before error messages enabled.  */
1590  int yyerrstatus;
1591  /* Look-ahead token as an internal (translated) token number.  */
1592  int yytoken = 0;
1593#if YYERROR_VERBOSE
1594  /* Buffer for error messages, and its allocated size.  */
1595  char yymsgbuf[128];
1596  char *yymsg = yymsgbuf;
1597  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1598#endif
1599
1600  /* Three stacks and their tools:
1601     `yyss': related to states,
1602     `yyvs': related to semantic values,
1603     `yyls': related to locations.
1604
1605     Refer to the stacks thru separate pointers, to allow yyoverflow
1606     to reallocate them elsewhere.  */
1607
1608  /* The state stack.  */
1609  yytype_int16 yyssa[YYINITDEPTH];
1610  yytype_int16 *yyss = yyssa;
1611  yytype_int16 *yyssp;
1612
1613  /* The semantic value stack.  */
1614  YYSTYPE yyvsa[YYINITDEPTH];
1615  YYSTYPE *yyvs = yyvsa;
1616  YYSTYPE *yyvsp;
1617
1618
1619
1620#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1621
1622  YYSIZE_T yystacksize = YYINITDEPTH;
1623
1624  /* The variables used to return semantic value and location from the
1625     action routines.  */
1626  YYSTYPE yyval;
1627
1628
1629  /* The number of symbols on the RHS of the reduced rule.
1630     Keep to zero when no symbol should be popped.  */
1631  int yylen = 0;
1632
1633  YYDPRINTF ((stderr, "Starting parse\n"));
1634
1635  yystate = 0;
1636  yyerrstatus = 0;
1637  yynerrs = 0;
1638  yychar = YYEMPTY; /* Cause a token to be read.  */
1639
1640  /* Initialize stack pointers.
1641     Waste one element of value and location stack
1642     so that they stay on the same level as the state stack.
1643     The wasted elements are never initialized.  */
1644
1645  yyssp = yyss;
1646  yyvsp = yyvs;
1647
1648  goto yysetstate;
1649
1650/*------------------------------------------------------------.
1651| yynewstate -- Push a new state, which is found in yystate.  |
1652`------------------------------------------------------------*/
1653 yynewstate:
1654  /* In all cases, when you get here, the value and location stacks
1655     have just been pushed.  So pushing a state here evens the stacks.  */
1656  yyssp++;
1657
1658 yysetstate:
1659  *yyssp = yystate;
1660
1661  if (yyss + yystacksize - 1 <= yyssp)
1662    {
1663      /* Get the current used size of the three stacks, in elements.  */
1664      YYSIZE_T yysize = yyssp - yyss + 1;
1665
1666#ifdef yyoverflow
1667      {
1668 /* Give user a chance to reallocate the stack.  Use copies of
1669    these so that the &'s don't force the real ones into
1670    memory.  */
1671 YYSTYPE *yyvs1 = yyvs;
1672 yytype_int16 *yyss1 = yyss;
1673
1674
1675 /* Each stack pointer address is followed by the size of the
1676    data in use in that stack, in bytes.  This used to be a
1677    conditional around just the two extra args, but that might
1678    be undefined if yyoverflow is a macro.  */
1679 yyoverflow (YY_("memory exhausted"),
1680     &yyss1yysize * sizeof (*yyssp),
1681     &yyvs1yysize * sizeof (*yyvsp),
1682
1683     &yystacksize);
1684
1685 yyss = yyss1;
1686 yyvs = yyvs1;
1687      }
1688#else /* no yyoverflow */
1689# ifndef YYSTACK_RELOCATE
1690      goto yyexhaustedlab;
1691# else
1692      /* Extend the stack our own way.  */
1693      if (YYMAXDEPTH <= yystacksize)
1694 goto yyexhaustedlab;
1695      yystacksize *= 2;
1696      if (YYMAXDEPTH < yystacksize)
1697 yystacksize = YYMAXDEPTH;
1698
1699      {
1700 yytype_int16 *yyss1 = yyss;
1701 union yyalloc *yyptr =
1702   (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1703 if (! yyptr)
1704   goto yyexhaustedlab;
1705 YYSTACK_RELOCATE (yyss);
1706 YYSTACK_RELOCATE (yyvs);
1707
1708#  undef YYSTACK_RELOCATE
1709 if (yyss1 != yyssa)
1710   YYSTACK_FREE (yyss1);
1711      }
1712# endif
1713#endif /* no yyoverflow */
1714
1715      yyssp = yyss + yysize - 1;
1716      yyvsp = yyvs + yysize - 1;
1717
1718
1719      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1720   (unsigned long int) yystacksize));
1721
1722      if (yyss + yystacksize - 1 <= yyssp)
1723 YYABORT;
1724    }
1725
1726  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1727
1728  goto yybackup;
1729
1730/*-----------.
1731| yybackup.  |
1732`-----------*/
1733yybackup:
1734
1735  /* Do appropriate processing given the current state.  Read a
1736     look-ahead token if we need one and don't already have one.  */
1737
1738  /* First try to decide what to do without reference to look-ahead token.  */
1739  yyn = yypact[yystate];
1740  if (yyn == YYPACT_NINF)
1741    goto yydefault;
1742
1743  /* Not known => get a look-ahead token if don't already have one.  */
1744
1745  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1746  if (yychar == YYEMPTY)
1747    {
1748      YYDPRINTF ((stderr, "Reading a token: "));
1749      yychar = YYLEX;
1750    }
1751
1752  if (yychar <= YYEOF)
1753    {
1754      yychar = yytoken = YYEOF;
1755      YYDPRINTF ((stderr, "Now at end of input.\n"));
1756    }
1757  else
1758    {
1759      yytoken = YYTRANSLATE (yychar);
1760      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1761    }
1762
1763  /* If the proper action on seeing token YYTOKEN is to reduce or to
1764     detect an error, take that action.  */
1765  yyn += yytoken;
1766  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1767    goto yydefault;
1768  yyn = yytable[yyn];
1769  if (yyn <= 0)
1770    {
1771      if (yyn == 0 || yyn == YYTABLE_NINF)
1772 goto yyerrlab;
1773      yyn = -yyn;
1774      goto yyreduce;
1775    }
1776
1777  if (yyn == YYFINAL)
1778    YYACCEPT;
1779
1780  /* Count tokens shifted since error; after three, turn off error
1781     status.  */
1782  if (yyerrstatus)
1783    yyerrstatus--;
1784
1785  /* Shift the look-ahead token.  */
1786  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1787
1788  /* Discard the shifted token unless it is eof.  */
1789  if (yychar != YYEOF)
1790    yychar = YYEMPTY;
1791
1792  yystate = yyn;
1793  *++yyvsp = yylval;
1794
1795  goto yynewstate;
1796
1797
1798/*-----------------------------------------------------------.
1799| yydefault -- do the default action for the current state.  |
1800`-----------------------------------------------------------*/
1801yydefault:
1802  yyn = yydefact[yystate];
1803  if (yyn == 0)
1804    goto yyerrlab;
1805  goto yyreduce;
1806
1807
1808/*-----------------------------.
1809| yyreduce -- Do a reduction.  |
1810`-----------------------------*/
1811yyreduce:
1812  /* yyn is the number of a rule to reduce with.  */
1813  yylen = yyr2[yyn];
1814
1815  /* If YYLEN is nonzero, implement the default value of the action:
1816     `$$ = $1'.
1817
1818     Otherwise, the following line sets YYVAL to garbage.
1819     This behavior is undocumented and Bison
1820     users should not rely upon it.  Assigning to YYVAL
1821     unconditionally makes the parser a bit smaller, and it avoids a
1822     GCC warning that YYVAL may be used uninitialized.  */
1823  yyval = yyvsp[1-yylen];
1824
1825
1826  YY_REDUCE_PRINT (yyn);
1827  switch (yyn)
1828    {
1829        case 2:
1830#line 219 "ncgen.y"
1831    {if (error_count > 0) YYABORT;;}
1832    break;
1833
1834  case 3:
1835#line 222 "ncgen.y"
1836    {createrootgroup(datasetname);;}
1837    break;
1838
1839  case 8:
1840#line 241 "ncgen.y"
1841    {
1842 Symbolid = (yyvsp[(2) - (3)].sym);
1843                markcdf4("Group specification");
1844 if(creategroup(id) == NULL)
1845                    yyerror("duplicate group declaration within parent group for %s",
1846                                id->name);
1847            ;}
1848    break;
1849
1850  case 9:
1851#line 250 "ncgen.y"
1852    {listpop(groupstack);;}
1853    break;
1854
1855  case 12:
1856#line 256 "ncgen.y"
1857    {;}
1858    break;
1859
1860  case 13:
1861#line 258 "ncgen.y"
1862    {markcdf4("Type specification");;}
1863    break;
1864
1865  case 16:
1866#line 264 "ncgen.y"
1867    { /* Use when defining a type */
1868              (yyvsp[(1) - (1)].sym)->objectclass = NC_TYPE;
1869              if(dupobjectcheck(NC_TYPE,(yyvsp[(1) - (1)].sym)))
1870                    yyerror("duplicate type declaration for %s",
1871                            (yyvsp[(1) - (1)].sym)->name);
1872              listpush(typdefs,(void*)(yyvsp[(1) - (1)].sym));
1873     ;}
1874    break;
1875
1876  case 17:
1877#line 273 "ncgen.y"
1878    {;}
1879    break;
1880
1881  case 18:
1882#line 273 "ncgen.y"
1883    {;}
1884    break;
1885
1886  case 25:
1887#line 287 "ncgen.y"
1888    {
1889 int i;
1890                addtogroup((yyvsp[(3) - (6)].sym)); /* sets prefix*/
1891                (yyvsp[(3) - (6)].sym)->objectclass=NC_TYPE;
1892                (yyvsp[(3) - (6)].sym)->subclass=NC_ENUM;
1893                (yyvsp[(3) - (6)].sym)->typ.basetype=(yyvsp[(1) - (6)].sym);
1894                (yyvsp[(3) - (6)].sym)->typ.size = (yyvsp[(1) - (6)].sym)->typ.size;
1895                (yyvsp[(3) - (6)].sym)->typ.alignment = (yyvsp[(1) - (6)].sym)->typ.alignment;
1896                stackbase=(yyvsp[(5) - (6)].mark);
1897                stacklen=listlength(stack);
1898                (yyvsp[(3) - (6)].sym)->subnodes = listnew();
1899                /* Variety of field fixups*/
1900 /* 1. add in the enum values*/
1901 /* 2. make this type be their container*/
1902 /* 3. make constant names visible in the group*/
1903 /* 4. set field basetype to be same as enum basetype*/
1904                for(i=stackbase;i<stacklen;i++) {
1905                   Symboleid = (Symbol*)listget(stack,i);
1906    assert(eid->subclass == NC_ECONST);
1907    addtogroup(eid);
1908                   listpush((yyvsp[(3) - (6)].sym)->subnodes,(void*)eid);
1909                   eid->container = (yyvsp[(3) - (6)].sym);
1910    eid->typ.basetype = (yyvsp[(3) - (6)].sym)->typ.basetype;
1911                }
1912                listsetlength(stack,stackbase);/* remove stack nodes*/
1913              ;}
1914    break;
1915
1916  case 26:
1917#line 316 "ncgen.y"
1918    {(yyval.mark)=listlength(stack); listpush(stack,(void*)(yyvsp[(1) - (1)].sym));;}
1919    break;
1920
1921  case 27:
1922#line 318 "ncgen.y"
1923    {
1924     int i;
1925     (yyval.mark)=(yyvsp[(1) - (3)].mark);
1926     /* check for duplicates*/
1927     stackbase=(yyvsp[(1) - (3)].mark);
1928     stacklen=listlength(stack);
1929     for(i=stackbase;i<stacklen;i++) {
1930       Symbolelem = (Symbol*)listget(stack,i);
1931       if(strcmp((yyvsp[(3) - (3)].sym)->name,elem->name)==0)
1932                   yyerror("duplicate enum declaration for %s",
1933                          elem->name);
1934     }
1935     listpush(stack,(void*)(yyvsp[(3) - (3)].sym));
1936 ;}
1937    break;
1938
1939  case 28:
1940#line 335 "ncgen.y"
1941    {
1942            (yyvsp[(1) - (3)].sym)->objectclass=NC_TYPE;
1943            (yyvsp[(1) - (3)].sym)->subclass=NC_ECONST;
1944            (yyvsp[(1) - (3)].sym)->typ.econst=(yyvsp[(3) - (3)].constant);
1945     (yyval.sym)=(yyvsp[(1) - (3)].sym);
1946        ;}
1947    break;
1948
1949  case 29:
1950#line 344 "ncgen.y"
1951    {
1952     vercheck(NC_OPAQUE);
1953                    addtogroup((yyvsp[(5) - (5)].sym)); /*sets prefix*/
1954                    (yyvsp[(5) - (5)].sym)->objectclass=NC_TYPE;
1955                    (yyvsp[(5) - (5)].sym)->subclass=NC_OPAQUE;
1956                    (yyvsp[(5) - (5)].sym)->typ.typecode=NC_OPAQUE;
1957                    (yyvsp[(5) - (5)].sym)->typ.size=int32_val;
1958                    (yyvsp[(5) - (5)].sym)->typ.alignment=nctypealignment(NC_OPAQUE);
1959                ;}
1960    break;
1961
1962  case 30:
1963#line 356 "ncgen.y"
1964    {
1965                    Symbolbasetype = (yyvsp[(1) - (5)].sym);
1966     vercheck(NC_VLEN);
1967                    addtogroup((yyvsp[(5) - (5)].sym)); /*sets prefix*/
1968                    (yyvsp[(5) - (5)].sym)->objectclass=NC_TYPE;
1969                    (yyvsp[(5) - (5)].sym)->subclass=NC_VLEN;
1970                    (yyvsp[(5) - (5)].sym)->typ.basetype=basetype;
1971                    (yyvsp[(5) - (5)].sym)->typ.typecode=NC_VLEN;
1972                    (yyvsp[(5) - (5)].sym)->typ.size=VLENSIZE;
1973                    (yyvsp[(5) - (5)].sym)->typ.alignment=nctypealignment(NC_VLEN);
1974                ;}
1975    break;
1976
1977  case 31:
1978#line 370 "ncgen.y"
1979    {
1980     int i,j;
1981     vercheck(NC_COMPOUND);
1982            addtogroup((yyvsp[(2) - (5)].sym));
1983     /* check for duplicate field names*/
1984     stackbase=(yyvsp[(4) - (5)].mark);
1985     stacklen=listlength(stack);
1986     for(i=stackbase;i<stacklen;i++) {
1987       Symbolelem1 = (Symbol*)listget(stack,i);
1988       for(j=i+1;j<stacklen;j++) {
1989           Symbolelem2 = (Symbol*)listget(stack,j);
1990           if(strcmp(elem1->name,elem2->name)==0) {
1991             yyerror("duplicate field declaration for %s",elem1->name);
1992   }
1993       }
1994     }
1995     (yyvsp[(2) - (5)].sym)->objectclass=NC_TYPE;
1996            (yyvsp[(2) - (5)].sym)->subclass=NC_COMPOUND;
1997            (yyvsp[(2) - (5)].sym)->typ.basetype=NULL;
1998            (yyvsp[(2) - (5)].sym)->typ.typecode=NC_COMPOUND;
1999     (yyvsp[(2) - (5)].sym)->subnodes = listnew();
2000     /* Add in the fields*/
2001     for(i=stackbase;i<stacklen;i++) {
2002         Symbolfsym = (Symbol*)listget(stack,i);
2003 fsym->container = (yyvsp[(2) - (5)].sym);
2004          listpush((yyvsp[(2) - (5)].sym)->subnodes,(void*)fsym);
2005     }
2006     listsetlength(stack,stackbase);/* remove stack nodes*/
2007          ;}
2008    break;
2009
2010  case 32:
2011#line 402 "ncgen.y"
2012    {(yyval.mark)=(yyvsp[(1) - (2)].mark);;}
2013    break;
2014
2015  case 33:
2016#line 403 "ncgen.y"
2017    {(yyval.mark)=(yyvsp[(1) - (3)].mark);;}
2018    break;
2019
2020  case 34:
2021#line 407 "ncgen.y"
2022    {
2023     int i;
2024     (yyval.mark)=(yyvsp[(2) - (2)].mark);
2025     stackbase=(yyvsp[(2) - (2)].mark);
2026     stacklen=listlength(stack);
2027     /* process each field in the fieldlist*/
2028            for(i=stackbase;i<stacklen;i++) {
2029                Symbolf = (Symbol*)listget(stack,i);
2030 f->typ.basetype = (yyvsp[(1) - (2)].sym);
2031            }
2032        ;}
2033    break;
2034
2035  case 35:
2036#line 420 "ncgen.y"
2037    { (yyval.sym) = primsymbols[NC_CHAR]; ;}
2038    break;
2039
2040  case 36:
2041#line 421 "ncgen.y"
2042    { (yyval.sym) = primsymbols[NC_BYTE]; ;}
2043    break;
2044
2045  case 37:
2046#line 422 "ncgen.y"
2047    { (yyval.sym) = primsymbols[NC_SHORT]; ;}
2048    break;
2049
2050  case 38:
2051#line 423 "ncgen.y"
2052    { (yyval.sym) = primsymbols[NC_INT]; ;}
2053    break;
2054
2055  case 39:
2056#line 424 "ncgen.y"
2057    { (yyval.sym) = primsymbols[NC_FLOAT]; ;}
2058    break;
2059
2060  case 40:
2061#line 425 "ncgen.y"
2062    { (yyval.sym) = primsymbols[NC_DOUBLE]; ;}
2063    break;
2064
2065  case 41:
2066#line 426 "ncgen.y"
2067    { vercheck(NC_UBYTE); (yyval.sym) = primsymbols[NC_UBYTE]; ;}
2068    break;
2069
2070  case 42:
2071#line 427 "ncgen.y"
2072    { vercheck(NC_USHORT); (yyval.sym) = primsymbols[NC_USHORT]; ;}
2073    break;
2074
2075  case 43:
2076#line 428 "ncgen.y"
2077    { vercheck(NC_UINT); (yyval.sym) = primsymbols[NC_UINT]; ;}
2078    break;
2079
2080  case 44:
2081#line 429 "ncgen.y"
2082    { vercheck(NC_INT64); (yyval.sym) = primsymbols[NC_INT64]; ;}
2083    break;
2084
2085  case 45:
2086#line 430 "ncgen.y"
2087    { vercheck(NC_UINT64); (yyval.sym) = primsymbols[NC_UINT64]; ;}
2088    break;
2089
2090  case 47:
2091#line 434 "ncgen.y"
2092    {;}
2093    break;
2094
2095  case 48:
2096#line 435 "ncgen.y"
2097    {;}
2098    break;
2099
2100  case 51:
2101#line 442 "ncgen.y"
2102    {;}
2103    break;
2104
2105  case 52:
2106#line 442 "ncgen.y"
2107    {;}
2108    break;
2109
2110  case 55:
2111#line 450 "ncgen.y"
2112    {
2113 (yyvsp[(1) - (3)].sym)->dim.declsize = (size_t)extractint((yyvsp[(3) - (3)].constant));
2114#ifdef GENDEBUG1
2115fprintf(stderr,"dimension: %s = %llu\n",(yyvsp[(1) - (3)].sym)->name,(unsigned long long)(yyvsp[(1) - (3)].sym)->dim.declsize);
2116#endif
2117       ;}
2118    break;
2119
2120  case 56:
2121#line 457 "ncgen.y"
2122    {
2123         (yyvsp[(1) - (3)].sym)->dim.declsize = NC_UNLIMITED;
2124         (yyvsp[(1) - (3)].sym)->dim.isunlimited = 1;
2125#ifdef GENDEBUG1
2126fprintf(stderr,"dimension: %s = UNLIMITED\n",(yyvsp[(1) - (3)].sym)->name);
2127#endif
2128    ;}
2129    break;
2130
2131  case 57:
2132#line 467 "ncgen.y"
2133    {
2134                     (yyvsp[(1) - (1)].sym)->objectclass=NC_DIM;
2135                     if(dupobjectcheck(NC_DIM,(yyvsp[(1) - (1)].sym)))
2136                        yyerror( "Duplicate dimension declaration for %s",
2137                                (yyvsp[(1) - (1)].sym)->name);
2138      addtogroup((yyvsp[(1) - (1)].sym));
2139      (yyval.sym)=(yyvsp[(1) - (1)].sym);
2140      listpush(dimdefs,(void*)(yyvsp[(1) - (1)].sym));
2141                   ;}
2142    break;
2143
2144  case 59:
2145#line 479 "ncgen.y"
2146    {;}
2147    break;
2148
2149  case 60:
2150#line 480 "ncgen.y"
2151    {;}
2152    break;
2153
2154  case 63:
2155#line 487 "ncgen.y"
2156    {;}
2157    break;
2158
2159  case 64:
2160#line 487 "ncgen.y"
2161    {;}
2162    break;
2163
2164  case 65:
2165#line 490 "ncgen.y"
2166    {
2167     int i;
2168     stackbase=(yyvsp[(2) - (2)].mark);
2169     stacklen=listlength(stack);
2170     /* process each variable in the varlist*/
2171             for(i=stackbase;i<stacklen;i++) {
2172                 Symbolsym = (Symbol*)listget(stack,i);
2173 sym->objectclass = NC_VAR;
2174         if(dupobjectcheck(NC_VAR,sym)) {
2175                            yyerror("Duplicate variable declaration for %s",
2176                                    sym->name);
2177 } else {
2178        sym->typ.basetype = (yyvsp[(1) - (2)].sym);
2179                     addtogroup(sym);
2180             listpush(vardefs,(void*)sym);
2181 }
2182     }
2183     listsetlength(stack,stackbase);/* remove stack nodes*/
2184 ;}
2185    break;
2186
2187  case 66:
2188#line 512 "ncgen.y"
2189    {(yyval.mark)=listlength(stack);
2190                 listpush(stack,(void*)(yyvsp[(1) - (1)].sym));
2191 ;}
2192    break;
2193
2194  case 67:
2195#line 516 "ncgen.y"
2196    {(yyval.mark)=(yyvsp[(1) - (3)].mark); listpush(stack,(void*)(yyvsp[(3) - (3)].sym));;}
2197    break;
2198
2199  case 68:
2200#line 520 "ncgen.y"
2201    {
2202     int i;
2203     Dimset dimset;
2204     stacklen=listlength(stack);
2205     stackbase=(yyvsp[(2) - (2)].mark);
2206     count = stacklen - stackbase;
2207     if(count >= NC_MAX_VAR_DIMS) {
2208 yyerror("%s has too many dimensions",(yyvsp[(1) - (2)].sym)->name);
2209 count = NC_MAX_VAR_DIMS - 1;
2210 stacklen = stackbase + count;
2211     }
2212               dimset.ndims = count;
2213     /* extract the actual dimensions*/
2214     if(dimset.ndims > 0) {
2215         for(i=0;i<count;i++) {
2216     Symboldsym = (Symbol*)listget(stack,stackbase+i);
2217     dimset.dimsyms[i] = dsym;
2218 }
2219 (yyvsp[(1) - (2)].sym)->typ.dimset = dimset;
2220     }
2221     (yyvsp[(1) - (2)].sym)->typ.basetype = NULL; /* not yet known*/
2222                    (yyvsp[(1) - (2)].sym)->objectclass=NC_VAR;
2223     listsetlength(stack,stackbase);/* remove stack nodes*/
2224     ;}
2225    break;
2226
2227  case 69:
2228#line 546 "ncgen.y"
2229    {(yyval.mark)=listlength(stack);;}
2230    break;
2231
2232  case 70:
2233#line 547 "ncgen.y"
2234    {(yyval.mark)=(yyvsp[(2) - (3)].mark);;}
2235    break;
2236
2237  case 71:
2238#line 550 "ncgen.y"
2239    {(yyval.mark)=listlength(stack); listpush(stack,(void*)(yyvsp[(1) - (1)].sym));;}
2240    break;
2241
2242  case 72:
2243#line 552 "ncgen.y"
2244    {(yyval.mark)=(yyvsp[(1) - (3)].mark); listpush(stack,(void*)(yyvsp[(3) - (3)].sym));;}
2245    break;
2246
2247  case 73:
2248#line 556 "ncgen.y"
2249    {Symboldimsym = (yyvsp[(1) - (1)].sym);
2250 dimsym->objectclass = NC_DIM;
2251 /* Find the actual dimension*/
2252 dimsym = locate(dimsym);
2253 if(dimsym == NULL) {
2254     derror("Undefined or forward referenced dimension: %s",(yyvsp[(1) - (1)].sym)->name);
2255     YYABORT;
2256 }
2257 (yyval.sym)=dimsym;
2258     ;}
2259    break;
2260
2261  case 74:
2262#line 570 "ncgen.y"
2263    {(yyval.mark)=listlength(stack);
2264             listpush(stack,(void*)(yyvsp[(1) - (1)].sym));
2265     ;}
2266    break;
2267
2268  case 75:
2269#line 574 "ncgen.y"
2270    {(yyval.mark)=(yyvsp[(1) - (3)].mark); listpush(stack,(void*)(yyvsp[(3) - (3)].sym));;}
2271    break;
2272
2273  case 76:
2274#line 579 "ncgen.y"
2275    {
2276 int i;
2277 Dimset dimset;
2278 stackbase=(yyvsp[(2) - (2)].mark);
2279 stacklen=listlength(stack);
2280 count = stacklen - stackbase;
2281 if(count >= NC_MAX_VAR_DIMS) {
2282     yyerror("%s has too many dimensions",(yyvsp[(1) - (2)].sym)->name);
2283     count = NC_MAX_VAR_DIMS - 1;
2284     stacklen = stackbase + count;
2285 }
2286           dimset.ndims = count;
2287 if(count > 0) {
2288     /* extract the actual dimensions*/
2289     for(i=0;i<count;i++) {
2290         Symboldsym = (Symbol*)listget(stack,stackbase+i);
2291         dimset.dimsyms[i] = dsym;
2292     }
2293     (yyvsp[(1) - (2)].sym)->typ.dimset = dimset;
2294 }
2295 (yyvsp[(1) - (2)].sym)->typ.basetype = NULL; /* not yet known*/
2296                (yyvsp[(1) - (2)].sym)->objectclass=NC_TYPE;
2297                (yyvsp[(1) - (2)].sym)->subclass=NC_FIELD;
2298 listsetlength(stack,stackbase);/* remove stack nodes*/
2299 (yyval.sym) = (yyvsp[(1) - (2)].sym);
2300     ;}
2301    break;
2302
2303  case 77:
2304#line 607 "ncgen.y"
2305    {(yyval.mark)=listlength(stack);;}
2306    break;
2307
2308  case 78:
2309#line 608 "ncgen.y"
2310    {(yyval.mark)=(yyvsp[(2) - (3)].mark);;}
2311    break;
2312
2313  case 79:
2314#line 612 "ncgen.y"
2315    {(yyval.mark)=listlength(stack); listpush(stack,(void*)(yyvsp[(1) - (1)].sym));;}
2316    break;
2317
2318  case 80:
2319#line 614 "ncgen.y"
2320    {(yyval.mark)=(yyvsp[(1) - (3)].mark); listpush(stack,(void*)(yyvsp[(3) - (3)].sym));;}
2321    break;
2322
2323  case 81:
2324#line 619 "ncgen.y"
2325    {  /* Anonymous integer dimension.
2326          Can only occur in type definitions*/
2327      char anon[32];
2328      sprintf(anon,"const%u",uint32_val);
2329      (yyval.sym) = install(anon);
2330      (yyval.sym)->objectclass = NC_DIM;
2331      (yyval.sym)->dim.isconstant = 1;
2332      (yyval.sym)->dim.declsize = uint32_val;
2333     ;}
2334    break;
2335
2336  case 82:
2337#line 629 "ncgen.y"
2338    {  /* Anonymous integer dimension.
2339          Can only occur in type definitions*/
2340      char anon[32];
2341      if(int32_val <= 0) {
2342 derror("field dimension must be positive");
2343 YYABORT;
2344      }
2345      sprintf(anon,"const%d",int32_val);
2346      (yyval.sym) = install(anon);
2347      (yyval.sym)->objectclass = NC_DIM;
2348      (yyval.sym)->dim.isconstant = 1;
2349      (yyval.sym)->dim.declsize = int32_val;
2350     ;}
2351    break;
2352
2353  case 83:
2354#line 649 "ncgen.y"
2355    {Symbolvsym = (yyvsp[(1) - (1)].sym);
2356 if(vsym->objectclass != NC_VAR) {
2357     derror("Undefined or forward referenced variable: %s",vsym->name);
2358     YYABORT;
2359 }
2360 (yyval.sym)=vsym;
2361     ;}
2362    break;
2363
2364  case 84:
2365#line 660 "ncgen.y"
2366    {Symboltsym = (yyvsp[(1) - (1)].sym);
2367 if(tsym->objectclass != NC_TYPE) {
2368     derror("Undefined or forward referenced type: %s",tsym->name);
2369     YYABORT;
2370 }
2371 (yyval.sym)=tsym;
2372     ;}
2373    break;
2374
2375  case 85:
2376#line 671 "ncgen.y"
2377    {Symboltvsym = (yyvsp[(1) - (1)].sym); Symbolsym;
2378 /* disambiguate*/
2379 tvsym->objectclass = NC_VAR;
2380 sym = locate(tvsym);
2381 if(sym == NULL) {
2382     tvsym->objectclass = NC_TYPE;
2383     sym = locate(tvsym);
2384     if(tvsym == NULL) {
2385         derror("Undefined or forward referenced name: %s",(yyvsp[(1) - (1)].sym)->name);
2386         YYABORT;
2387     } else tvsym = sym;
2388 } else tvsym = sym;
2389 if(tvsym == NULL) {
2390     derror("Undefined name (line %d): %s",(yyvsp[(1) - (1)].sym)->lineno,(yyvsp[(1) - (1)].sym)->name);
2391     YYABORT;
2392 }
2393 (yyval.sym)=tvsym;
2394     ;}
2395    break;
2396
2397  case 86:
2398#line 689 "ncgen.y"
2399    {(yyval.sym)=(yyvsp[(1) - (1)].sym);;}
2400    break;
2401
2402  case 87:
2403#line 696 "ncgen.y"
2404    {;}
2405    break;
2406
2407  case 88:
2408#line 696 "ncgen.y"
2409    {;}
2410    break;
2411
2412  case 89:
2413#line 700 "ncgen.y"
2414    {(yyval.sym) = makespecial(_NCPROPS_FLAG,NULL,NULL,(void*)&(yyvsp[(4) - (4)].constant),ATTRGLOBAL);;}
2415    break;
2416
2417  case 90:
2418#line 702 "ncgen.y"
2419    {(yyval.sym) = makespecial(_ISNETCDF4_FLAG,NULL,NULL,(void*)&(yyvsp[(4) - (4)].constant),ATTRGLOBAL);;}
2420    break;
2421
2422  case 91:
2423#line 704 "ncgen.y"
2424    {(yyval.sym) = makespecial(_SUPERBLOCK_FLAG,NULL,NULL,(void*)&(yyvsp[(4) - (4)].constant),ATTRGLOBAL);;}
2425    break;
2426
2427  case 92:
2428#line 706 "ncgen.y"
2429    { (yyval.sym)=makeattribute((yyvsp[(2) - (4)].sym),NULL,NULL,(yyvsp[(4) - (4)].datalist),ATTRGLOBAL);;}
2430    break;
2431
2432  case 93:
2433#line 708 "ncgen.y"
2434    {Symboltsym = (yyvsp[(1) - (6)].sym); Symbolvsym = (yyvsp[(2) - (6)].sym); Symbolasym = (yyvsp[(4) - (6)].sym);
2435 if(vsym->objectclass == NC_VAR) {
2436     (yyval.sym)=makeattribute(asym,vsym,tsym,(yyvsp[(6) - (6)].datalist),ATTRVAR);
2437 } else {
2438     derror("Doubly typed attribute: %s",asym->name);
2439     YYABORT;
2440 }
2441     ;}
2442    break;
2443
2444  case 94:
2445#line 717 "ncgen.y"
2446    {Symbolsym = (yyvsp[(1) - (5)].sym); Symbolasym = (yyvsp[(3) - (5)].sym);
2447 if(sym->objectclass == NC_VAR) {
2448     (yyval.sym)=makeattribute(asym,sym,NULL,(yyvsp[(5) - (5)].datalist),ATTRVAR);
2449 } else if(sym->objectclass == NC_TYPE) {
2450     (yyval.sym)=makeattribute(asym,NULL,sym,(yyvsp[(5) - (5)].datalist),ATTRGLOBAL);
2451 } else {
2452     derror("Attribute prefix not a variable or type: %s",asym->name);
2453     YYABORT;
2454 }
2455     ;}
2456    break;
2457
2458  case 95:
2459#line 728 "ncgen.y"
2460    {(yyval.sym) = makespecial(_FILLVALUE_FLAG,(yyvsp[(1) - (5)].sym),NULL,(void*)(yyvsp[(5) - (5)].datalist),0);;}
2461    break;
2462
2463  case 96:
2464#line 730 "ncgen.y"
2465    {(yyval.sym) = makespecial(_FILLVALUE_FLAG,(yyvsp[(2) - (6)].sym),(yyvsp[(1) - (6)].sym),(void*)(yyvsp[(6) - (6)].datalist),0);;}
2466    break;
2467
2468  case 97:
2469#line 732 "ncgen.y"
2470    {(yyval.sym) = makespecial(_STORAGE_FLAG,(yyvsp[(1) - (5)].sym),NULL,(void*)&(yyvsp[(5) - (5)].constant),1);;}
2471    break;
2472
2473  case 98:
2474#line 734 "ncgen.y"
2475    {(yyval.sym) = makespecial(_CHUNKSIZES_FLAG,(yyvsp[(1) - (5)].sym),NULL,(void*)(yyvsp[(5) - (5)].datalist),0);;}
2476    break;
2477
2478  case 99:
2479#line 736 "ncgen.y"
2480    {(yyval.sym) = makespecial(_FLETCHER32_FLAG,(yyvsp[(1) - (5)].sym),NULL,(void*)&(yyvsp[(5) - (5)].constant),1);;}
2481    break;
2482
2483  case 100:
2484#line 738 "ncgen.y"
2485    {(yyval.sym) = makespecial(_DEFLATE_FLAG,(yyvsp[(1) - (5)].sym),NULL,(void*)&(yyvsp[(5) - (5)].constant),1);;}
2486    break;
2487
2488  case 101:
2489#line 740 "ncgen.y"
2490    {(yyval.sym) = makespecial(_SHUFFLE_FLAG,(yyvsp[(1) - (5)].sym),NULL,(void*)&(yyvsp[(5) - (5)].constant),1);;}
2491    break;
2492
2493  case 102:
2494#line 742 "ncgen.y"
2495    {(yyval.sym) = makespecial(_ENDIAN_FLAG,(yyvsp[(1) - (5)].sym),NULL,(void*)&(yyvsp[(5) - (5)].constant),1);;}
2496    break;
2497
2498  case 103:
2499#line 744 "ncgen.y"
2500    {(yyval.sym) = makespecial(_NOFILL_FLAG,(yyvsp[(1) - (5)].sym),NULL,(void*)&(yyvsp[(5) - (5)].constant),1);;}
2501    break;
2502
2503  case 104:
2504#line 746 "ncgen.y"
2505    {(yyval.sym) = makespecial(_FORMAT_FLAG,NULL,NULL,(void*)&(yyvsp[(4) - (4)].constant),1);;}
2506    break;
2507
2508  case 105:
2509#line 751 "ncgen.y"
2510    {
2511         (yyval.sym)=(yyvsp[(1) - (1)].sym);
2512                (yyvsp[(1) - (1)].sym)->ref.is_ref=1;
2513                (yyvsp[(1) - (1)].sym)->is_prefixed=0;
2514                setpathcurrent((yyvsp[(1) - (1)].sym));
2515     ;}
2516    break;
2517
2518  case 106:
2519#line 758 "ncgen.y"
2520    {
2521         (yyval.sym)=(yyvsp[(1) - (1)].sym);
2522                (yyvsp[(1) - (1)].sym)->ref.is_ref=1;
2523                (yyvsp[(1) - (1)].sym)->is_prefixed=1;
2524         /* path is set in ncgen.l*/
2525     ;}
2526    break;
2527
2528  case 108:
2529#line 767 "ncgen.y"
2530    {;}
2531    break;
2532
2533  case 109:
2534#line 768 "ncgen.y"
2535    {;}
2536    break;
2537
2538  case 112:
2539#line 776 "ncgen.y"
2540    {(yyvsp[(1) - (3)].sym)->data = (yyvsp[(3) - (3)].datalist);;}
2541    break;
2542
2543  case 113:
2544#line 779 "ncgen.y"
2545    {(yyval.datalist) = (yyvsp[(1) - (1)].datalist);;}
2546    break;
2547
2548  case 114:
2549#line 780 "ncgen.y"
2550    {(yyval.datalist) = (yyvsp[(1) - (1)].datalist);;}
2551    break;
2552
2553  case 115:
2554#line 784 "ncgen.y"
2555    {(yyval.datalist) = builddatalist(0);;}
2556    break;
2557
2558  case 116:
2559#line 788 "ncgen.y"
2560    {(yyval.datalist) = builddatalist(0); datalistextend((yyval.datalist),&((yyvsp[(1) - (1)].constant)));;}
2561    break;
2562
2563  case 117:
2564#line 790 "ncgen.y"
2565    {datalistextend((yyvsp[(1) - (3)].datalist),&((yyvsp[(3) - (3)].constant))); (yyval.datalist)=(yyvsp[(1) - (3)].datalist);;}
2566    break;
2567
2568  case 118:
2569#line 794 "ncgen.y"
2570    {(yyval.constant)=(yyvsp[(1) - (1)].constant);;}
2571    break;
2572
2573  case 119:
2574#line 795 "ncgen.y"
2575    {(yyval.constant)=builddatasublist((yyvsp[(2) - (3)].datalist));;}
2576    break;
2577
2578  case 120:
2579#line 799 "ncgen.y"
2580    {(yyval.constant)=(yyvsp[(1) - (1)].constant);;}
2581    break;
2582
2583  case 121:
2584#line 800 "ncgen.y"
2585    {(yyval.constant)=makeconstdata(NC_OPAQUE);;}
2586    break;
2587
2588  case 122:
2589#line 801 "ncgen.y"
2590    {(yyval.constant)=makeconstdata(NC_FILLVALUE);;}
2591    break;
2592
2593  case 123:
2594#line 802 "ncgen.y"
2595    {(yyval.constant)=makeconstdata(NC_NIL);;}
2596    break;
2597
2598  case 124:
2599#line 803 "ncgen.y"
2600    {(yyval.constant)=(yyvsp[(1) - (1)].constant);;}
2601    break;
2602
2603  case 126:
2604#line 808 "ncgen.y"
2605    {(yyval.constant) = makeenumconstref((yyvsp[(1) - (1)].sym));;}
2606    break;
2607
2608  case 127:
2609#line 812 "ncgen.y"
2610    {(yyval.constant)=evaluate((yyvsp[(1) - (4)].sym),(yyvsp[(3) - (4)].datalist));;}
2611    break;
2612
2613  case 128:
2614#line 817 "ncgen.y"
2615    {(yyval.datalist) = builddatalist(0); datalistextend((yyval.datalist),&((yyvsp[(1) - (1)].constant)));;}
2616    break;
2617
2618  case 129:
2619#line 819 "ncgen.y"
2620    {datalistextend((yyvsp[(1) - (3)].datalist),&((yyvsp[(3) - (3)].constant))); (yyval.datalist)=(yyvsp[(1) - (3)].datalist);;}
2621    break;
2622
2623  case 130:
2624#line 823 "ncgen.y"
2625    {(yyval.constant)=makeconstdata(NC_CHAR);;}
2626    break;
2627
2628  case 131:
2629#line 824 "ncgen.y"
2630    {(yyval.constant)=makeconstdata(NC_BYTE);;}
2631    break;
2632
2633  case 132:
2634#line 825 "ncgen.y"
2635    {(yyval.constant)=makeconstdata(NC_SHORT);;}
2636    break;
2637
2638  case 133:
2639#line 826 "ncgen.y"
2640    {(yyval.constant)=makeconstdata(NC_INT);;}
2641    break;
2642
2643  case 134:
2644#line 827 "ncgen.y"
2645    {(yyval.constant)=makeconstdata(NC_INT64);;}
2646    break;
2647
2648  case 135:
2649#line 828 "ncgen.y"
2650    {(yyval.constant)=makeconstdata(NC_UBYTE);;}
2651    break;
2652
2653  case 136:
2654#line 829 "ncgen.y"
2655    {(yyval.constant)=makeconstdata(NC_USHORT);;}
2656    break;
2657
2658  case 137:
2659#line 830 "ncgen.y"
2660    {(yyval.constant)=makeconstdata(NC_UINT);;}
2661    break;
2662
2663  case 138:
2664#line 831 "ncgen.y"
2665    {(yyval.constant)=makeconstdata(NC_UINT64);;}
2666    break;
2667
2668  case 139:
2669#line 832 "ncgen.y"
2670    {(yyval.constant)=makeconstdata(NC_FLOAT);;}
2671    break;
2672
2673  case 140:
2674#line 833 "ncgen.y"
2675    {(yyval.constant)=makeconstdata(NC_DOUBLE);;}
2676    break;
2677
2678  case 141:
2679#line 834 "ncgen.y"
2680    {(yyval.constant)=makeconstdata(NC_STRING);;}
2681    break;
2682
2683  case 142:
2684#line 838 "ncgen.y"
2685    {(yyval.datalist) = builddatalist(0); datalistextend((yyval.datalist),&((yyvsp[(1) - (1)].constant)));;}
2686    break;
2687
2688  case 143:
2689#line 839 "ncgen.y"
2690    {(yyval.datalist)=(yyvsp[(1) - (3)].datalist); datalistextend((yyvsp[(1) - (3)].datalist),&((yyvsp[(3) - (3)].constant)));;}
2691    break;
2692
2693  case 144:
2694#line 844 "ncgen.y"
2695    {(yyval.constant)=makeconstdata(NC_INT);;}
2696    break;
2697
2698  case 145:
2699#line 846 "ncgen.y"
2700    {(yyval.constant)=makeconstdata(NC_UINT);;}
2701    break;
2702
2703  case 146:
2704#line 848 "ncgen.y"
2705    {(yyval.constant)=makeconstdata(NC_INT64);;}
2706    break;
2707
2708  case 147:
2709#line 850 "ncgen.y"
2710    {(yyval.constant)=makeconstdata(NC_UINT64);;}
2711    break;
2712
2713  case 148:
2714#line 854 "ncgen.y"
2715    {(yyval.constant)=makeconstdata(NC_STRING);;}
2716    break;
2717
2718  case 149:
2719#line 858 "ncgen.y"
2720    {(yyval.constant)=(yyvsp[(1) - (1)].constant);;}
2721    break;
2722
2723  case 150:
2724#line 859 "ncgen.y"
2725    {(yyval.constant)=(yyvsp[(1) - (1)].constant);;}
2726    break;
2727
2728  case 151:
2729#line 865 "ncgen.y"
2730    {(yyval.sym)=(yyvsp[(1) - (1)].sym);;}
2731    break;
2732
2733
2734/* Line 1267 of yacc.c.  */
2735#line 2736 "ncgeny.c"
2736      default: break;
2737    }
2738  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2739
2740  YYPOPSTACK (yylen);
2741  yylen = 0;
2742  YY_STACK_PRINT (yyssyyssp);
2743
2744  *++yyvsp = yyval;
2745
2746
2747  /* Now `shift' the result of the reduction.  Determine what state
2748     that goes to, based on the state we popped back to and the rule
2749     number reduced by.  */
2750
2751  yyn = yyr1[yyn];
2752
2753  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2754  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2755    yystate = yytable[yystate];
2756  else
2757    yystate = yydefgoto[yyn - YYNTOKENS];
2758
2759  goto yynewstate;
2760
2761
2762/*------------------------------------.
2763| yyerrlab -- here on detecting error |
2764`------------------------------------*/
2765yyerrlab:
2766  /* If not already recovering from an error, report this error.  */
2767  if (!yyerrstatus)
2768    {
2769      ++yynerrs;
2770#if ! YYERROR_VERBOSE
2771      yyerror (YY_("syntax error"));
2772#else
2773      {
2774 YYSIZE_T yysize = yysyntax_error (0, yystateyychar);
2775 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
2776   {
2777     YYSIZE_T yyalloc = 2 * yysize;
2778     if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
2779       yyalloc = YYSTACK_ALLOC_MAXIMUM;
2780     if (yymsg != yymsgbuf)
2781       YYSTACK_FREE (yymsg);
2782     yymsg = (char *) YYSTACK_ALLOC (yyalloc);
2783     if (yymsg)
2784       yymsg_alloc = yyalloc;
2785     else
2786       {
2787 yymsg = yymsgbuf;
2788 yymsg_alloc = sizeof yymsgbuf;
2789       }
2790   }
2791
2792 if (0 < yysize && yysize <= yymsg_alloc)
2793   {
2794     (void) yysyntax_error (yymsgyystateyychar);
2795     yyerror (yymsg);
2796   }
2797 else
2798   {
2799     yyerror (YY_("syntax error"));
2800     if (yysize != 0)
2801       goto yyexhaustedlab;
2802   }
2803      }
2804#endif
2805    }
2806
2807
2808
2809  if (yyerrstatus == 3)
2810    {
2811      /* If just tried and failed to reuse look-ahead token after an
2812  error, discard it.  */
2813
2814      if (yychar <= YYEOF)
2815 {
2816   /* Return failure if at end of input.  */
2817   if (yychar == YYEOF)
2818     YYABORT;
2819 }
2820      else
2821 {
2822   yydestruct ("Error: discarding",
2823       yytoken, &yylval);
2824   yychar = YYEMPTY;
2825 }
2826    }
2827
2828  /* Else will try to reuse look-ahead token after shifting the error
2829     token.  */
2830  goto yyerrlab1;
2831
2832
2833/*---------------------------------------------------.
2834| yyerrorlab -- error raised explicitly by YYERROR.  |
2835`---------------------------------------------------*/
2836yyerrorlab:
2837
2838  /* Pacify compilers like GCC when the user code never invokes
2839     YYERROR and the label yyerrorlab therefore never appears in user
2840     code.  */
2841  if (/*CONSTCOND*/ 0)
2842     goto yyerrorlab;
2843
2844  /* Do not reclaim the symbols of the rule which action triggered
2845     this YYERROR.  */
2846  YYPOPSTACK (yylen);
2847  yylen = 0;
2848  YY_STACK_PRINT (yyssyyssp);
2849  yystate = *yyssp;
2850  goto yyerrlab1;
2851
2852
2853/*-------------------------------------------------------------.
2854| yyerrlab1 -- common code for both syntax error and YYERROR.  |
2855`-------------------------------------------------------------*/
2856yyerrlab1:
2857  yyerrstatus = 3; /* Each real token shifted decrements this.  */
2858
2859  for (;;)
2860    {
2861      yyn = yypact[yystate];
2862      if (yyn != YYPACT_NINF)
2863 {
2864   yyn += YYTERROR;
2865   if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2866     {
2867       yyn = yytable[yyn];
2868       if (0 < yyn)
2869 break;
2870     }
2871 }
2872
2873      /* Pop the current state because it cannot handle the error token.  */
2874      if (yyssp == yyss)
2875 YYABORT;
2876
2877
2878      yydestruct ("Error: popping",
2879   yystos[yystate], yyvsp);
2880      YYPOPSTACK (1);
2881      yystate = *yyssp;
2882      YY_STACK_PRINT (yyssyyssp);
2883    }
2884
2885  if (yyn == YYFINAL)
2886    YYACCEPT;
2887
2888  *++yyvsp = yylval;
2889
2890
2891  /* Shift the error token.  */
2892  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvspyylsp);
2893
2894  yystate = yyn;
2895  goto yynewstate;
2896
2897
2898/*-------------------------------------.
2899| yyacceptlab -- YYACCEPT comes here.  |
2900`-------------------------------------*/
2901yyacceptlab:
2902  yyresult = 0;
2903  goto yyreturn;
2904
2905/*-----------------------------------.
2906| yyabortlab -- YYABORT comes here.  |
2907`-----------------------------------*/
2908yyabortlab:
2909  yyresult = 1;
2910  goto yyreturn;
2911
2912#ifndef yyoverflow
2913/*-------------------------------------------------.
2914| yyexhaustedlab -- memory exhaustion comes here.  |
2915`-------------------------------------------------*/
2916yyexhaustedlab:
2917  yyerror (YY_("memory exhausted"));
2918  yyresult = 2;
2919  /* Fall through.  */
2920#endif
2921
2922yyreturn:
2923  if (yychar != YYEOF && yychar != YYEMPTY)
2924     yydestruct ("Cleanup: discarding lookahead",
2925  yytoken, &yylval);
2926  /* Do not reclaim the symbols of the rule which action triggered
2927     this YYABORT or YYACCEPT.  */
2928  YYPOPSTACK (yylen);
2929  YY_STACK_PRINT (yyssyyssp);
2930  while (yyssp != yyss)
2931    {
2932      yydestruct ("Cleanup: popping",
2933   yystos[*yyssp], yyvsp);
2934      YYPOPSTACK (1);
2935    }
2936#ifndef yyoverflow
2937  if (yyss != yyssa)
2938    YYSTACK_FREE (yyss);
2939#endif
2940#if YYERROR_VERBOSE
2941  if (yymsg != yymsgbuf)
2942    YYSTACK_FREE (yymsg);
2943#endif
2944  /* Make sure YYID is used.  */
2945  return YYID (yyresult);
2946}
2947
2948
2949#line 868 "ncgen.y"
2950
2951
2952#ifndef NO_STDARG
2953static void
2954yyerror(const char *fmt, ...)
2955#else
2956static void
2957yyerror(fmt,va_alist) const char* fmtva_dcl
2958#endif
2959{
2960    va_list argv;
2961    vastart(argv,fmt);
2962    (void)fprintf(stderr,"%s: %s line %d: ", prognamecdlnamelineno);
2963    vderror(fmt,argv);
2964    vaend(argv,fmt);
2965}
2966
2967/* undefine yywrap macro, in case we are using bison instead of yacc */
2968#ifdef yywrap
2969#undef yywrap
2970#endif
2971
2972static int
2973ncgwrap(void)                    /* returns 1 on EOF if no more input */
2974{
2975    return  1;
2976}
2977
2978/* get lexical input routine generated by lex  */
2979#include "ncgenl.c"
2980
2981/* Really should init our data within this file */
2982void
2983parse_init(void)
2984{
2985    int i;
2986    opaqueid = 0;
2987    arrayuid = 0;
2988    symlist = NULL;
2989    stack = listnew();
2990    groupstack = listnew();
2991    consttype = NC_NAT;
2992    grpdefs = listnew();
2993    dimdefs = listnew();
2994    attdefs = listnew();
2995    gattdefs = listnew();
2996    xattdefs = listnew();
2997    typdefs = listnew();
2998    vardefs = listnew();
2999    condefs = listnew();
3000    tmp = listnew();
3001    /* Create the primitive types */
3002    for(i=NC_NAT+1;i<=NC_STRING;i++) {
3003        primsymbols[i] = makeprimitivetype(i);
3004    }
3005    lex_init();
3006}
3007
3008static Symbol*
3009makeprimitivetype(nc_type nctype)
3010{
3011    Symbolsym = install(primtypenames[nctype]);
3012    sym->objectclass=NC_TYPE;
3013    sym->subclass=NC_PRIM;
3014    sym->ncid = nctype;
3015    sym->typ.typecode = nctype;
3016    sym->typ.size = ncsize(nctype);
3017    sym->typ.nelems = 1;
3018    sym->typ.alignment = nctypealignment(nctype);
3019    /* Make the basetype circular so we can always ask for it */
3020    sym->typ.basetype = sym;
3021    sym->prefix = listnew();
3022    return sym;
3023}
3024
3025/* Symbol table operations for ncgen tool */
3026/* install sname in symbol table even if it is already there */
3027Symbol*
3028install(const char *sname)
3029{
3030    Symbolsp;
3031    sp = (Symbol*) emalloc (sizeof (struct Symbol));
3032    memset((void*)sp,0,sizeof(struct Symbol));
3033    sp->name = nulldup(sname);
3034    sp->next = symlist;
3035    sp->lineno = lineno;
3036    sp->location = currentgroup();
3037    sp->container = currentgroup();
3038    symlist = sp;
3039    return sp;
3040}
3041
3042
3043static Symbol*
3044currentgroup(void)
3045{
3046    if(listlength(groupstack) == 0) return rootgroup;
3047    return (Symbol*)listtop(groupstack);
3048}
3049
3050static Symbol*
3051createrootgroup(const char* dataset)
3052{
3053    Symbolgsym = install(dataset);
3054    gsym->objectclass = NC_GRP;
3055    gsym->container = NULL;
3056    gsym->subnodes = listnew();
3057    gsym->grp.is_root = 1;
3058    gsym->prefix = listnew();
3059    listpush(grpdefs,(void*)gsym);
3060    rootgroup = gsym;
3061    return gsym;
3062}
3063
3064static Symbol*
3065creategroup(Symbol * gsym)
3066{
3067    /* See if this group already exists in currentgroup */
3068    gsym->objectclass = NC_GRP;
3069    if(dupobjectcheck(NC_GRP,gsym)) {
3070        derror("Duplicate group name in same scope: %s",gsym->name);
3071 return NULL;
3072    }
3073    addtogroup(gsym);
3074    gsym->subnodes = listnew();
3075    listpush(groupstack,(void*)gsym);
3076    listpush(grpdefs,(void*)gsym);
3077    return gsym;
3078}
3079
3080static NCConstant
3081makeconstdata(nc_type nctype)
3082{
3083    NCConstant con = nullconstant;
3084    consttype = nctype;
3085    con.nctype = nctype;
3086    con.lineno = lineno;
3087    con.filled = 0;
3088    switch (nctype) {
3089 case NC_CHARcon.value.charv = char_val; break;
3090        case NC_BYTEcon.value.int8v = byte_val; break;
3091        case NC_SHORTcon.value.int16v = int16_val; break;
3092        case NC_INTcon.value.int32v = int32_val; break;
3093        case NC_FLOAT:
3094     con.value.floatv = float_val;
3095     break;
3096        case NC_DOUBLE:
3097     con.value.doublev = double_val;
3098     break;
3099        case NC_STRING: { /* convert to a set of chars*/
3100     size_t len;
3101     len = bbLength(lextext);
3102     con.value.stringv.len = len;
3103     con.value.stringv.stringv = bbDup(lextext);
3104     bbClear(lextext);
3105     }
3106     break;
3107
3108 /* Allow these constants even in netcdf-3 */
3109        case NC_UBYTEcon.value.uint8v = ubyte_val; break;
3110        case NC_USHORTcon.value.uint16v = uint16_val; break;
3111        case NC_UINTcon.value.uint32v = uint32_val; break;
3112        case NC_INT64con.value.int64v = int64_val; break;
3113        case NC_UINT64con.value.uint64v = uint64_val; break;
3114
3115#ifdef USE_NETCDF4
3116 case NC_OPAQUE: {
3117     char* s;
3118     int len;
3119     len = bbLength(lextext);
3120     s = (char*)emalloc(len+1);
3121     strncpy(s,bbContents(lextext),len);
3122     s[len] = '\0';
3123     con.value.opaquev.stringv = s;
3124     con.value.opaquev.len = len;
3125     } break;
3126
3127 case NC_NIL:
3128     break; /* no associated value*/
3129#endif
3130
3131 case NC_FILLVALUE:
3132     break; /* no associated value*/
3133
3134 default:
3135     yyerror("Data constant: unexpected NC type: %s",
3136     nctypename(nctype));
3137     con.value.stringv.stringv = NULL;
3138     con.value.stringv.len = 0;
3139    }
3140    return con;
3141}
3142
3143static NCConstant
3144makeenumconstref(Symbolrefsym)
3145{
3146    NCConstant con;
3147
3148    markcdf4("Enum type");
3149    consttype = NC_ENUM;
3150    con.nctype = NC_ECONST;
3151    con.lineno = lineno;
3152    con.filled = 0;
3153    refsym->objectclass = NC_TYPE;
3154    refsym->subclass = NC_ECONST;
3155    con.value.enumv = refsym;
3156    return con;
3157}
3158
3159static void
3160addtogroup(Symbolsym)
3161{
3162    Symbolgrp = currentgroup();
3163    sym->container = grp;
3164    listpush(grp->subnodes,(void*)sym);
3165    setpathcurrent(sym);
3166}
3167
3168/* Check for duplicate name of given type within current group*/
3169static int
3170dupobjectcheck(nc_class objectclassSymbolpattern)
3171{
3172    int i;
3173    Symbolgrp;
3174    if(pattern == NULL) return 0;
3175    grp = pattern->container;
3176    if(grp == NULL || grp->subnodes == NULL) return 0;
3177    for(i=0;i<listlength(grp->subnodes);i++) {
3178 Symbolsym = (Symbol*)listget(grp->subnodes,i);
3179 if(!sym->ref.is_ref && sym->objectclass == objectclass
3180    && strcmp(sym->name,pattern->name)==0) return 1;
3181    }
3182    return 0;
3183}
3184
3185static void
3186setpathcurrent(Symbolsym)
3187{
3188    sym->is_prefixed = 0;
3189    sym->prefix = prefixdup(groupstack);
3190}
3191
3192/* Convert an nc_type code to the corresponding Symbol*/
3193Symbol*
3194basetypefor(nc_type nctype)
3195{
3196    return primsymbols[nctype];
3197}
3198
3199static int
3200truefalse(NCConstantcon, int tag)
3201{
3202    if(con->nctype == NC_STRING) {
3203 char* sdata = con->value.stringv.stringv;
3204 if(strncmp(sdata,"false",NC_MAX_NAME) == 0
3205           || strncmp(sdata,"0",NC_MAX_NAME) == 0)
3206     return 0;
3207 else if(strncmp(sdata,"true",NC_MAX_NAME) == 0
3208           || strncmp(sdata,"1",NC_MAX_NAME) == 0)
3209     return 1;
3210 else goto fail;
3211    } else if(con->value.int32v < 0 || con->value.int32v > 1)
3212 goto fail;
3213    return con->value.int32v;
3214
3215fail:
3216    derror("%s: illegal value",specialname(tag));
3217    return 0;
3218}
3219
3220/* Since this may be affected by the _Format attribute, which
3221   may come last, capture all the special info and sort it out
3222   in semantics.
3223*/
3224static Symbol*
3225makespecial(int tagSymbolvsymSymboltsym, void* data, int isconst)
3226{
3227    Symbolattr = NULL;
3228    Datalistlist;
3229    NCConstantcon;
3230    NCConstant iconst;
3231    int tf = 0;
3232    char* sdata = NULL;
3233    int idata =  -1;
3234
3235    if((GLOBAL_SPECIAL & tag) != 0) {
3236        if(vsym != NULL) {
3237            derror("_Format: must be global attribute");
3238            vsym = NULL;
3239        }
3240    } else {
3241        if(vsym == NULL) {
3242     derror("%s: must have non-NULL vsym", specialname(tag));
3243     return NULL;
3244        }
3245    }
3246
3247    if(tag != _FILLVALUE_FLAG && tag != _FORMAT_FLAG)
3248        /*Main.*/specials_flag++;
3249
3250    if(isconst) {
3251 con = (NCConstant*)data;
3252 list = builddatalist(1);
3253        dlappend(list,(NCConstant*)data);
3254    } else {
3255        list = (Datalist*)data;
3256        con = (NCConstant*)list->data;
3257    }
3258
3259    switch (tag) {
3260    case _FLETCHER32_FLAG:
3261    case _SHUFFLE_FLAG:
3262    case _ISNETCDF4_FLAG:
3263    case _NOFILL_FLAG:
3264 iconst.nctype = (con->nctype == NC_STRING?NC_STRING:NC_INT);
3265 convert1(con,&iconst);
3266 tf = truefalse(&iconst,tag);
3267 break;
3268    case _FORMAT_FLAG:
3269    case _STORAGE_FLAG:
3270    case _NCPROPS_FLAG:
3271    case _ENDIAN_FLAG:
3272 iconst.nctype = NC_STRING;
3273 convert1(con,&iconst);
3274 if(iconst.nctype == NC_STRING)
3275     sdata = iconst.value.stringv.stringv;
3276 else
3277     derror("%s: illegal value",specialname(tag));
3278 break;
3279    case _SUPERBLOCK_FLAG:
3280    case _DEFLATE_FLAG:
3281 iconst.nctype = NC_INT;
3282 convert1(con,&iconst);
3283 if(iconst.nctype == NC_INT)
3284     idata = iconst.value.int32v;
3285 else
3286     derror("%s: illegal value",specialname(tag));
3287 break;
3288    case _CHUNKSIZES_FLAG:
3289    case _FILLVALUE_FLAG:
3290 /* Handle below */
3291 break;
3292    default: PANIC1("unexpected special tag: %d",tag);
3293    }
3294
3295    if(tag == _FORMAT_FLAG) {
3296 /* Watch out: this is a global attribute */
3297 struct Kvalueskvalue;
3298 int found = 0;
3299 /* Use the table in main.c */
3300        for(kvalue = legalkindskvalue->namekvalue++) {
3301          if(sdata) {
3302            if(strcmp(sdatakvalue->name) == 0) {
3303              globalspecials._Format = kvalue->k_flag;
3304       /*Main.*/format_attribute = 1;
3305              found = 1;
3306              break;
3307            }
3308          }
3309 }
3310 if(!found)
3311     derror("_Format: illegal value: %s",sdata);
3312    } else if((GLOBAL_SPECIAL & tag) != 0) {
3313 if(tag == _ISNETCDF4_FLAG)
3314     globalspecials._IsNetcdf4 = tf;
3315 else if(tag == _SUPERBLOCK_FLAG)
3316     globalspecials._Superblock = idata;
3317 else if(tag == _NCPROPS_FLAG)
3318     globalspecials._NCProperties = strdup(sdata);
3319    } else {
3320        Specialdataspecial;
3321        /* Set up special info */
3322        special = &vsym->var.special;
3323        if(tag == _FILLVALUE_FLAG) {
3324            special->_Fillvalue = list;
3325            /* fillvalue must be a single value*/
3326            if(list->length != 1)
3327                derror("_FillValue: must be a single (possibly compound) value",
3328                            vsym->name);
3329            /* check that the attribute value contains no fill values*/
3330            if(containsfills(list)) {
3331                derror("Attribute data may not contain fill values (i.e. _ )");
3332            }
3333            /* _FillValue is also a real attribute*/
3334            if(vsym->objectclass != NC_VAR) {
3335                derror("_FillValue attribute not associated with variable: %s",vsym->name);
3336            }
3337            if(tsym  == NULLtsym = vsym->typ.basetype;
3338            else if(vsym->typ.basetype != tsym) {
3339                derror("_FillValue attribute type does not match variable type: %s",vsym->name);
3340            }
3341            attr = makeattribute(install("_FillValue"),vsym,tsym,list,ATTRVAR);
3342        } else switch (tag) {
3343     /* These will be output as attributes later */
3344            case _STORAGE_FLAG:
3345              if(!sdata)
3346                derror("_Storage: illegal NULL value");
3347              else if(strcmp(sdata,"contiguous") == 0)
3348                special->_Storage = NC_CONTIGUOUS;
3349              else if(strcmp(sdata,"chunked") == 0)
3350                special->_Storage = NC_CHUNKED;
3351              else
3352                derror("_Storage: illegal value: %s",sdata);
3353              special->flags |= _STORAGE_FLAG;
3354              break;
3355          case _FLETCHER32_FLAG:
3356                special->_Fletcher32 = tf;
3357                special->flags |= _FLETCHER32_FLAG;
3358                break;
3359            case _DEFLATE_FLAG:
3360                special->_DeflateLevel = idata;
3361                special->flags |= _DEFLATE_FLAG;
3362                break;
3363            case _SHUFFLE_FLAG:
3364                special->_Shuffle = tf;
3365                special->flags |= _SHUFFLE_FLAG;
3366                break;
3367            case _ENDIAN_FLAG:
3368              if(!sdata)
3369                derror("_Endianness: illegal NULL value");
3370              else if(strcmp(sdata,"little") == 0)
3371                special->_Endianness = 1;
3372              else if(strcmp(sdata,"big") == 0)
3373                special->_Endianness = 2;
3374              else
3375                derror("_Endianness: illegal value: %s",sdata);
3376              special->flags |= _ENDIAN_FLAG;
3377              break;
3378          case _NOFILL_FLAG:
3379                special->_Fill = (1 - tf); /* negate */
3380                special->flags |= _NOFILL_FLAG;
3381                break;
3382          case _CHUNKSIZES_FLAG: {
3383                int i;
3384                special->nchunks = list->length;
3385                special->_ChunkSizes = (size_t*)emalloc(sizeof(size_t)*special->nchunks);
3386                for(i=0;i<special->nchunks;i++) {
3387                    iconst.nctype = NC_INT;
3388                    convert1(&list->data[i],&iconst);
3389                    if(iconst.nctype == NC_INT) {
3390                        special->_ChunkSizes[i] = (size_t)iconst.value.int32v;
3391                    } else {
3392                        efree(special->_ChunkSizes);
3393                        derror("%s: illegal value",specialname(tag));
3394                    }
3395                }
3396                special->flags |= _CHUNKSIZES_FLAG;
3397                /* Chunksizes => storage == chunked */
3398                special->flags |= _STORAGE_FLAG;
3399                special->_Storage = NC_CHUNKED;
3400                } break;
3401            default: PANIC1("makespecial: illegal token: %d",tag);
3402         }
3403    }
3404    return attr;
3405}
3406
3407static Symbol*
3408makeattribute(Symbolasym,
3409 Symbolvsym,
3410 Symboltsym,
3411 Datalistdata,
3412 Attrkind kind) /* global var or unknown*/
3413{
3414    asym->objectclass = NC_ATT;
3415    asym->data = data;
3416    switch (kind) {
3417    case ATTRVAR:
3418        asym->att.var = vsym;
3419        asym->typ.basetype = tsym;
3420        listpush(attdefs,(void*)asym);
3421        addtogroup(asym);
3422 break;
3423    case ATTRGLOBAL:
3424        asym->att.var = NULL; /* NULL => NC_GLOBAL*/
3425        asym->typ.basetype = tsym;
3426        listpush(gattdefs,(void*)asym);
3427        addtogroup(asym);
3428 break;
3429    default: PANIC1("unexpected attribute type: %d",kind);
3430    }
3431    /* finally; check that the attribute value contains no fill values*/
3432    if(containsfills(data)) {
3433 derror("Attribute data may not contain fill values (i.e. _ ): %s",asym->name);
3434    }
3435    return asym;
3436}
3437
3438static long long
3439extractint(NCConstant con)
3440{
3441    switch (con.nctype) {
3442    case NC_BYTE: return (long long)(con.value.int8v);
3443    case NC_SHORT: return (long long)(con.value.int16v);
3444    case NC_INT: return (long long)(con.value.int32v);
3445    case NC_UBYTE: return (long long)(con.value.uint8v);
3446    case NC_USHORT: return (long long)(con.value.uint16v);
3447    case NC_UINT: return (long long)(con.value.uint32v);
3448    case NC_INT64: return (long long)(con.value.int64v);
3449    default:
3450 derror("Not a signed integer type: %d",con.nctype);
3451 break;
3452    }
3453    return 0;
3454}
3455
3456static int
3457containsfills(Datalistlist)
3458{
3459    if(list != NULL) {
3460        int i;
3461        NCConstantcon = list->data;
3462        for(i=0;i<list->length;i++,con++) {
3463     if(con->nctype == NC_COMPOUND) {
3464         if(containsfills(con->value.compoundv)) return 1;
3465     } else if(con->nctype == NC_FILLVALUE) return 1;
3466 }
3467    }
3468    return 0;
3469}
3470
3471static void
3472datalistextend(DatalistdlNCConstantcon)
3473{
3474    dlappend(dl,con);
3475}
3476
3477static void
3478vercheck(int tid)
3479{
3480    switch (tid) {
3481    case NC_UBYTEmarkcdf5("netCDF4/5 type: UBYTE"); break;
3482    case NC_USHORTmarkcdf5("netCDF4/5 type: USHORT"); break;
3483    case NC_UINTmarkcdf5("netCDF4/5 type: UINT"); break;
3484    case NC_INT64markcdf5("netCDF4/5 type: INT64"); break;
3485    case NC_UINT64markcdf5("netCDF4/5 type: UINT64"); break;
3486    case NC_STRINGmarkcdf4("netCDF4 type: STRING"); break;
3487    case NC_VLENmarkcdf4("netCDF4 type: VLEN"); break;
3488    case NC_OPAQUEmarkcdf4("netCDF4 type: OPAQUE"); break;
3489    case NC_ENUMmarkcdf4("netCDF4 type: ENUM"); break;
3490    case NC_COMPOUNDmarkcdf4("netCDF4 type: COMPOUND"); break;
3491    default: break;
3492    }
3493}
3494
3495const char*
3496specialname(int tag)
3497{
3498    struct Specialtokenspp = specials;
3499    for(;spp->name;spp++) {
3500 if(spp->tag == tag)
3501     return spp->name;
3502    }
3503    return "<unknown>";
3504}
3505
3506/*
3507Since the arguments are all simple constants,
3508we can evaluate the function immediately
3509and return its value.
3510Note that currently, only a single value can
3511be returned.
3512*/
3513
3514static NCConstant
3515evaluate(SymbolfcnDatalistarglist)
3516{
3517    NCConstant result = nullconstant;
3518
3519    /* prepare the result */
3520    result.lineno = fcn->lineno;
3521
3522    if(strcasecmp(fcn->name,"time") == 0) {
3523        char* timekind = NULL;
3524        char* timevalue = NULL;
3525        result.nctype = NC_DOUBLE;
3526        result.value.doublev = 0;
3527 /* int time([string],string) */
3528 switch (arglist->length) {
3529 case 2:
3530     if(arglist->data[1].nctype != NC_STRING) {
3531         derror("Expected function signature: time([string,]string)");
3532         goto done;
3533     }
3534     /* fall thru */
3535 case 1:
3536     if(arglist->data[0].nctype != NC_STRING) {
3537         derror("Expected function signature: time([string,]string)");
3538         goto done;
3539     }
3540     break;
3541 case 0:
3542 default:
3543     derror("Expected function signature: time([string,]string)");
3544     goto done;
3545 }
3546 if(arglist->length == 2) {
3547     timekind = arglist->data[0].value.stringv.stringv;
3548            timevalue = arglist->data[1].value.stringv.stringv;
3549 } else
3550            timevalue = arglist->data[0].value.stringv.stringv;
3551 if(timekind == NULL) { /* use cd time as the default */
3552            cdCompTime comptime;
3553     CdTime cdtime;
3554     cdCalenType timetype = cdStandard;
3555     cdChar2Comp(timetype,timevalue,&comptime);
3556     /* convert comptime to cdTime */
3557     cdtime.year = comptime.year;
3558     cdtime.month = comptime.month;
3559     cdtime.day = comptime.day;
3560     cdtime.hour = comptime.hour;
3561     cdtime.baseYear = 1970;
3562     cdtime.timeType = CdChron;
3563     /* convert to double value */
3564     Cdh2e(&cdtime,&result.value.doublev);
3565        } else {
3566     derror("Time conversion '%s' not supported",timekind);
3567     goto done;
3568 }
3569    } else { /* Unknown function */
3570 derror("Unknown function name: %s",fcn->name);
3571 goto done;
3572    }
3573
3574done:
3575    return result;
3576}
3577


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