1
2#line 3 "ncgenl.c"
3
4#define  YY_INT_ALIGNED short int
5
6/* A lexical scanner generated by flex */
7
8#define yy_create_buffer ncg_create_buffer
9#define yy_delete_buffer ncg_delete_buffer
10#define yy_flex_debug ncg_flex_debug
11#define yy_init_buffer ncg_init_buffer
12#define yy_flush_buffer ncg_flush_buffer
13#define yy_load_buffer_state ncg_load_buffer_state
14#define yy_switch_to_buffer ncg_switch_to_buffer
15#define yyin ncgin
16#define yyleng ncgleng
17#define yylex ncglex
18#define yylineno ncglineno
19#define yyout ncgout
20#define yyrestart ncgrestart
21#define yytext ncgtext
22#define yywrap ncgwrap
23#define yyalloc ncgalloc
24#define yyrealloc ncgrealloc
25#define yyfree ncgfree
26
27#define FLEX_SCANNER
28#define YY_FLEX_MAJOR_VERSION 2
29#define YY_FLEX_MINOR_VERSION 5
30#define YY_FLEX_SUBMINOR_VERSION 35
31#if YY_FLEX_SUBMINOR_VERSION > 0
32#define FLEX_BETA
33#endif
34
35/* First, we deal with  platform-specific or compiler-specific issues. */
36
37/* begin standard C headers. */
38#include <stdio.h>
39#include <string.h>
40#include <errno.h>
41#include <stdlib.h>
42
43/* end standard C headers. */
44
45/* flex integer type definitions */
46
47#ifndef FLEXINT_H
48#define FLEXINT_H
49
50/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
51
52#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
53
54/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
55 * if you want the limit (max/min) macros for int types.
56 */
57#ifndef __STDC_LIMIT_MACROS
58#define __STDC_LIMIT_MACROS 1
59#endif
60
61#include <inttypes.h>
62typedef int8_t flex_int8_t;
63typedef uint8_t flex_uint8_t;
64typedef int16_t flex_int16_t;
65typedef uint16_t flex_uint16_t;
66typedef int32_t flex_int32_t;
67typedef uint32_t flex_uint32_t;
68typedef uint64_t flex_uint64_t;
69#else
70typedef signed char flex_int8_t;
71typedef short int flex_int16_t;
72typedef int flex_int32_t;
73typedef unsigned char flex_uint8_t;
74typedef unsigned short int flex_uint16_t;
75typedef unsigned int flex_uint32_t;
76#endif /* ! C99 */
77
78/* Limits of integral types. */
79#ifndef INT8_MIN
80#define INT8_MIN               (-128)
81#endif
82#ifndef INT16_MIN
83#define INT16_MIN              (-32767-1)
84#endif
85#ifndef INT32_MIN
86#define INT32_MIN              (-2147483647-1)
87#endif
88#ifndef INT8_MAX
89#define INT8_MAX               (127)
90#endif
91#ifndef INT16_MAX
92#define INT16_MAX              (32767)
93#endif
94#ifndef INT32_MAX
95#define INT32_MAX              (2147483647)
96#endif
97#ifndef UINT8_MAX
98#define UINT8_MAX              (255U)
99#endif
100#ifndef UINT16_MAX
101#define UINT16_MAX             (65535U)
102#endif
103#ifndef UINT32_MAX
104#define UINT32_MAX             (4294967295U)
105#endif
106
107#endif /* ! FLEXINT_H */
108
109#ifdef __cplusplus
110
111/* The "const" storage-class-modifier is valid. */
112#define YY_USE_CONST
113
114#else /* ! __cplusplus */
115
116/* C99 requires __STDC__ to be defined as 1. */
117#if defined (__STDC__)
118
119#define YY_USE_CONST
120
121#endif /* defined (__STDC__) */
122#endif /* ! __cplusplus */
123
124#ifdef YY_USE_CONST
125#define yyconst const
126#else
127#define yyconst
128#endif
129
130/* Returned upon end-of-file. */
131#define YY_NULL 0
132
133/* Promotes a possibly negative, possibly signed char to an unsigned
134 * integer for use as an array index.  If the signed char is negative,
135 * we want to instead treat it as an 8-bit unsigned char, hence the
136 * double cast.
137 */
138#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
139
140/* Enter a start condition.  This macro really ought to take a parameter,
141 * but we do it the disgusting crufty way forced on us by the ()-less
142 * definition of BEGIN.
143 */
144#define BEGIN (yy_start) = 1 + 2 *
145
146/* Translate the current start state into a value that can be later handed
147 * to BEGIN to return to the state.  The YYSTATE alias is for lex
148 * compatibility.
149 */
150#define YY_START (((yy_start) - 1) / 2)
151#define YYSTATE YY_START
152
153/* Action number for EOF rule of a given start state. */
154#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
155
156/* Special action meaning "start processing a new file". */
157#define YY_NEW_FILE ncgrestart(ncgin  )
158
159#define YY_END_OF_BUFFER_CHAR 0
160
161/* Size of default input buffer. */
162#ifndef YY_BUF_SIZE
163#define YY_BUF_SIZE 16384
164#endif
165
166/* The state buf must be large enough to hold one state per character in the main buffer.
167 */
168#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
169
170#ifndef YY_TYPEDEF_YY_BUFFER_STATE
171#define YY_TYPEDEF_YY_BUFFER_STATE
172typedef struct yy_buffer_state *YY_BUFFER_STATE;
173#endif
174
175#ifndef YY_TYPEDEF_YY_SIZE_T
176#define YY_TYPEDEF_YY_SIZE_T
177typedef size_t yy_size_t;
178#endif
179
180extern yy_size_t ncgleng;
181
182extern FILE *ncgin, *ncgout;
183
184#define EOB_ACT_CONTINUE_SCAN 0
185#define EOB_ACT_END_OF_FILE 1
186#define EOB_ACT_LAST_MATCH 2
187
188    #define YY_LESS_LINENO(n)
189
190/* Return all but the first "n" matched characters back to the input stream. */
191#define yyless(n) \
192 do \
193 { \
194 /* Undo effects of setting up ncgtext. */ \
195        int yyless_macro_arg = (n); \
196        YY_LESS_LINENO(yyless_macro_arg);\
197 *yy_cp = (yy_hold_char); \
198 YY_RESTORE_YY_MORE_OFFSET \
199 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
200 YY_DO_BEFORE_ACTION; /* set up ncgtext again */ \
201 } \
202 while ( 0 )
203
204#define unput(cyyunputc, (yytext_ptr)  )
205
206#ifndef YY_STRUCT_YY_BUFFER_STATE
207#define YY_STRUCT_YY_BUFFER_STATE
208struct yy_buffer_state
209 {
210 FILE *yy_input_file;
211
212 char *yy_ch_buf; /* input buffer */
213 char *yy_buf_pos; /* current position in input buffer */
214
215 /* Size of input buffer in bytes, not including room for EOB
216  * characters.
217  */
218 yy_size_t yy_buf_size;
219
220 /* Number of characters read into yy_ch_buf, not including EOB
221  * characters.
222  */
223 yy_size_t yy_n_chars;
224
225 /* Whether we "own" the buffer - i.e., we know we created it,
226  * and can realloc() it to grow it, and should free() it to
227  * delete it.
228  */
229 int yy_is_our_buffer;
230
231 /* Whether this is an "interactive" input source; if so, and
232  * if we're using stdio for input, then we want to use getc()
233  * instead of fread(), to make sure we stop fetching input after
234  * each newline.
235  */
236 int yy_is_interactive;
237
238 /* Whether we're considered to be at the beginning of a line.
239  * If so, '^' rules will be active on the next match, otherwise
240  * not.
241  */
242 int yy_at_bol;
243
244    int yy_bs_lineno; /**< The line count. */
245    int yy_bs_column; /**< The column count. */
246
247 /* Whether to try to fill the input buffer when we reach the
248  * end of it.
249  */
250 int yy_fill_buffer;
251
252 int yy_buffer_status;
253
254#define YY_BUFFER_NEW 0
255#define YY_BUFFER_NORMAL 1
256 /* When an EOF's been seen but there's still some text to process
257  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
258  * shouldn't try reading from the input source any more.  We might
259  * still have a bunch of tokens to match, though, because of
260  * possible backing-up.
261  *
262  * When we actually see the EOF, we change the status to "new"
263  * (via ncgrestart()), so that the user can continue scanning by
264  * just pointing ncgin at a new input file.
265  */
266#define YY_BUFFER_EOF_PENDING 2
267
268 };
269#endif /* !YY_STRUCT_YY_BUFFER_STATE */
270
271/* Stack of input buffers. */
272static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
273static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
274static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
275
276/* We provide macros for accessing buffer states in case in the
277 * future we want to put the buffer states in a more general
278 * "scanner state".
279 *
280 * Returns the top of the stack, or NULL.
281 */
282#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
283                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
284                          : NULL)
285
286/* Same as previous macro, but useful when we know that the buffer stack is not
287 * NULL or when we need an lvalue. For internal use only.
288 */
289#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
290
291/* yy_hold_char holds the character lost when ncgtext is formed. */
292static char yy_hold_char;
293static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
294yy_size_t ncgleng;
295
296/* Points to current character in buffer. */
297static char *yy_c_buf_p = (char *) 0;
298static int yy_init = 0; /* whether we need to initialize */
299static int yy_start = 0; /* start state number */
300
301/* Flag which is used to allow ncgwrap()'s to do buffer switches
302 * instead of setting up a fresh ncgin.  A bit of a hack ...
303 */
304static int yy_did_buffer_switch_on_eof;
305
306void ncgrestart (FILE *input_file  );
307void ncg_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
308YY_BUFFER_STATE ncg_create_buffer (FILE *file,int size  );
309void ncg_delete_buffer (YY_BUFFER_STATE b  );
310void ncg_flush_buffer (YY_BUFFER_STATE b  );
311void ncgpush_buffer_state (YY_BUFFER_STATE new_buffer  );
312void ncgpop_buffer_state (void );
313
314static void ncgensure_buffer_stack (void );
315static void ncg_load_buffer_state (void );
316static void ncg_init_buffer (YY_BUFFER_STATE b,FILE *file  );
317
318#define YY_FLUSH_BUFFER ncg_flush_buffer(YY_CURRENT_BUFFER )
319
320YY_BUFFER_STATE ncg_scan_buffer (char *base,yy_size_t size  );
321YY_BUFFER_STATE ncg_scan_string (yyconst char *yy_str  );
322YY_BUFFER_STATE ncg_scan_bytes (yyconst char *bytes,yy_size_t len  );
323
324void *ncgalloc (yy_size_t  );
325void *ncgrealloc (void *,yy_size_t  );
326void ncgfree (void *  );
327
328#define yy_new_buffer ncg_create_buffer
329
330#define yy_set_interactive(is_interactive) \
331 { \
332 if ( ! YY_CURRENT_BUFFER ){ \
333        ncgensure_buffer_stack (); \
334 YY_CURRENT_BUFFER_LVALUE =    \
335            ncg_create_buffer(ncgin,YY_BUF_SIZE ); \
336 } \
337 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
338 }
339
340#define yy_set_bol(at_bol) \
341 { \
342 if ( ! YY_CURRENT_BUFFER ){\
343        ncgensure_buffer_stack (); \
344 YY_CURRENT_BUFFER_LVALUE =    \
345            ncg_create_buffer(ncgin,YY_BUF_SIZE ); \
346 } \
347 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
348 }
349
350#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
351
352/* Begin user sect3 */
353
354typedef unsigned char YY_CHAR;
355
356FILE *ncgin = (FILE *) 0, *ncgout = (FILE *) 0;
357
358typedef int yy_state_type;
359
360extern int ncglineno;
361
362int ncglineno = 1;
363
364extern char *ncgtext;
365#define yytext_ptr ncgtext
366
367static yy_state_type yy_get_previous_state (void );
368static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
369static int yy_get_next_buffer (void );
370static void yy_fatal_error (yyconst char msg[]  );
371
372/* Done after the current pattern has been matched and before the
373 * corresponding action - sets up ncgtext.
374 */
375#define YY_DO_BEFORE_ACTION \
376 (yytext_ptr) = yy_bp; \
377 ncgleng = (yy_size_t) (yy_cp - yy_bp); \
378 (yy_hold_char) = *yy_cp; \
379 *yy_cp = '\0'; \
380 (yy_c_buf_p) = yy_cp;
381
382#define YY_NUM_RULES 48
383#define YY_END_OF_BUFFER 49
384/* This struct is not used in this scanner,
385   but its presence is necessary. */
386struct yy_trans_info
387 {
388 flex_int32_t yy_verify;
389 flex_int32_t yy_nxt;
390 };
391static yyconst flex_int16_t yy_accept[417] =
392    {   0,
393        0,    0,   45,   45,    0,    0,   49,   47,    1,   43,
394       47,   47,   47,   47,   37,   31,   35,   35,   34,   34,
395       34,   34,   34,   34,   34,   47,   34,   34,   34,   34,
396       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
397       34,   34,   47,   47,   47,   45,   48,   33,   48,    1,
398        0,    3,    0,    0,    0,   37,   35,    0,    0,   37,
399       37,    0,   38,   44,    2,   31,    0,    0,    0,    0,
400       35,   35,   35,   35,    0,   34,    0,    0,    0,    0,
401       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
402       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
403
404       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
405       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
406       34,   34,   34,    0,    0,   45,    0,   46,   33,   39,
407        0,    0,    0,    0,   37,    0,    0,   37,    2,   31,
408        0,    0,    0,    0,    0,    0,    0,    4,    0,    0,
409       34,   34,   34,   34,   34,   34,   30,   27,   34,   34,
410       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
411       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
412       14,   34,   27,   34,   34,   34,   34,   34,   34,   34,
413       34,   34,   34,   34,   34,    0,   42,    0,    0,   37,
414
415        0,   31,    0,    0,    0,    0,    0,    0,    0,    4,
416       36,   36,    0,   34,   34,   28,   34,   34,   29,   34,
417       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
418       34,   34,   10,    9,   34,   34,   34,   34,    6,   34,
419       34,   34,   34,   14,   34,   34,   34,    8,   34,   34,
420       34,   34,   15,   34,   34,   34,   34,    0,    0,   28,
421        0,   31,    0,    0,    0,    0,    0,    0,    0,   34,
422       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
423       34,   34,   34,   34,   34,   34,   34,   23,   34,   34,
424       34,   16,   34,   34,   34,   34,   12,   34,   34,   11,
425
426       34,   34,   15,   34,   34,   34,   40,   41,    0,    0,
427        0,    0,   34,   34,   34,   25,   34,   34,   34,   34,
428       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
429       34,   18,   24,   34,    7,    5,   20,   17,   34,   34,
430       13,   34,    0,    0,   34,   34,   34,   34,   34,   34,
431       34,   34,   34,   32,   34,   34,   34,   34,   34,   34,
432       34,   34,   34,   34,   34,    0,   34,   26,   34,   34,
433       34,   34,   34,   34,   34,   34,   34,    5,   34,   34,
434       34,   34,   26,   26,   19,   34,   34,   34,   34,   34,
435       34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
436
437       34,   34,   22,   34,   34,   34,   21,   34,   34,   34,
438       34,   34,   34,   34,   34,    0
439    } ;
440
441static yyconst flex_int32_t yy_ec[256] =
442    {   0,
443        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
444        1,    2,    2,    1,    1,    1,    1,    1,    1,    1,
445        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
446        1,    4,    5,    6,    5,    5,    5,    5,    7,    5,
447        5,    8,    9,    5,   10,   11,   12,   13,   14,   15,
448       16,   17,   14,   18,   14,   19,   19,   20,    5,    5,
449        5,    5,    5,   21,   22,   23,   24,   25,   26,   27,
450       28,   28,   29,   28,   28,   30,   31,   32,   28,   33,
451       28,   28,   34,   35,   36,   37,   28,   38,   28,   28,
452        5,   39,    5,    5,   40,    5,   41,   42,   43,   44,
453
454       45,   46,   47,   48,   49,   28,   50,   51,   52,   53,
455       54,   55,   56,   57,   58,   59,   60,   61,   28,   38,
456       62,   63,   64,    5,    5,    5,    1,   65,   65,   65,
457       65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
458       65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
459       65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
460       65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
461       65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
462       65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
463       65,   66,   66,   66,   66,   66,   66,   66,   66,   66,
464
465       66,   66,   66,   66,   66,   66,   66,   66,   66,   66,
466       66,   66,   66,   66,    1,    1,    1,    1,    1,    1,
467        1,    1,    1,   67,   67,   67,   67,   67,   67,   67,
468       67,   67,   67,   67,   67,   67,   67,   67,   67,   68,
469       68,   68,   68,   68,   68,   68,   68,    1,    1,    1,
470        1,    1,    1,    1,    1
471    } ;
472
473static yyconst flex_int32_t yy_meta[69] =
474    {   0,
475        1,    1,    2,    1,    1,    1,    3,    4,    5,    5,
476        6,    7,    8,    8,    8,    8,    8,    8,    8,    1,
477        5,    9,    9,    9,    9,   10,    9,   11,   12,   13,
478       11,   11,   11,   13,   11,   11,   11,   11,   11,   11,
479        9,    9,    9,    9,   10,    9,   11,   11,   11,   11,
480       13,   11,   11,   11,   11,   11,   11,   13,   11,   11,
481       11,   11,   11,   14,    1,   11,   11,   11
482    } ;
483
484static yyconst flex_int16_t yy_base[435] =
485    {   0,
486        0,    0,  325,  321,  264,  255,  318, 2347,   67, 2347,
487       64,  269,   61,   62,   95,   77,  136,  259,   51,   61,
488      188,   97,  118,  150,   65,  195,  233,  153,  183,  222,
489      241,  202,  207,  213,  238,  246,  243,  257,  268,  264,
490      298,  276,  221,  219,  218,  270,  236,    0, 2347,   79,
491       87, 2347,  244,  238,  344,    0,  206,  358,  190,    0,
492     2347,  370, 2347, 2347,    0,  342,  377,  177,  175,  174,
493      200, 2347,   54,  377,    0,  254,  397,  171,  170,  169,
494      358,   85,  404,  373,  376,  398,  391,  406,  412,  417,
495      421,  428,  432,  451,  454,  443,  473,  476,  486,  489,
496
497      494,  499,  511,  508,  520,  530,  546,  542,  550,  553,
498      556,  560,  563,  566,  586,  598,  602,  605,  608,  623,
499      612,  644,  647,  168,  167,  222,  217, 2347,    0, 2347,
500      221,  680,  219,  703,  710,  179,  728,  749,    0,  691,
501      666,  765,  159,  158,  135,  130,  128,  651,  125,  123,
502      739,  716,  721,  751,  764,  770,  757,  775,  783,  760,
503      794,  800,  806,  809,  813,  824,  820,  844,  839,  830,
504      854,  850,  862,  869,  874,  886,  904,  893,  908,  917,
505      947,  934,  912,  964,  943,  954,  900,  930,  950,  967,
506      980,  984,  989, 1004, 1010,  118, 2347,  735,    0, 2347,
507
508       50, 1015, 1047,  117,  115,  112,  110,  108,  104,  904,
509       72, 2347,  103, 1028, 1034, 1041, 1045, 1049, 1052, 1058,
510     1075, 1071, 1082, 1093, 1088, 1101, 1106, 1113, 1097, 1132,
511     1118, 1137, 1067, 1123, 1148, 1157, 1144, 1162, 1127, 1167,
512     1153, 1192, 1197, 1179, 1202, 1209, 1183, 1213, 1223, 1218,
513     1234, 1227, 1260, 1249, 1267, 1264, 1270,  160,  154, 2347,
514      107, 1275, 1340,   93,   91,   77,   73,   72,   70, 1284,
515     1310, 1314, 1327, 1330, 1317, 1323, 1333, 1349, 1363, 1366,
516     1353, 1369, 1374, 1399, 1383, 1387, 1404, 2347, 1417, 1413,
517     1437, 1420, 1423, 1434, 1453, 1467, 1430, 1456, 1443, 1474,
518
519     1477, 1489, 1486, 1498, 1492, 1507, 2347, 2347,   85,   65,
520       59,   36, 1532, 1523, 1511, 1528, 1545, 1548, 1542, 1553,
521     1563, 1578, 1566, 1584, 1598, 1589, 1603, 1620, 1633, 1610,
522     1640, 1629, 2347, 1645, 1651, 1654, 2347, 1659, 1664, 1676,
523     1671, 1685,   39,   27, 1694, 1702, 1710, 1690, 1715, 1720,
524     1727, 1724, 1734, 1745, 1759, 1765, 1769, 1776, 1779, 1784,
525     1795, 1799, 1802, 1809, 1819,   24, 1814, 1832, 1849, 1840,
526     1853, 1845, 1858, 1865, 1884, 1870, 1875, 1889, 1895, 1900,
527     1905, 1919,   36, 1908, 1914, 1925, 1939, 1930, 1944, 1963,
528     1977, 1956, 1960, 1951, 1981, 1974, 1994, 1998, 2019, 1986,
529
530     2007, 2030, 2347, 2033, 2037, 2040, 2347, 2044, 2051, 2075,
531     2082, 2086, 2089, 2092, 2098, 2347, 2166, 2180, 2194, 2208,
532     2217, 2226, 2235, 2248, 2262, 2275, 2289, 2299, 2305, 2313,
533     2315, 2321, 2327, 2333
534    } ;
535
536static yyconst flex_int16_t yy_def[435] =
537    {   0,
538      416,    1,  417,  417,  418,  418,  416,  416,  416,  416,
539      419,  420,  416,  421,  416,  422,  416,   17,  423,  423,
540      423,  423,  423,  423,  423,  416,  423,  423,  423,  423,
541       21,  423,  423,  423,  423,  423,  423,  423,  423,  423,
542      423,  423,  416,  416,  416,  424,  424,  425,  416,  416,
543      419,  416,  419,  416,  426,   15,   17,  416,  416,   15,
544      416,  416,  416,  416,  427,  428,  416,  416,  416,  416,
545       17,  416,  416,  416,  429,  423,  416,  416,  416,  416,
546      423,   21,   21,  423,  423,  423,  423,  423,  423,  423,
547      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
548
549      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
550      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
551      423,  423,  423,  416,  416,  424,  424,  416,  425,  416,
552      416,  416,  430,  416,  416,  416,  416,  416,  427,  428,
553      431,  416,  416,  416,  416,  416,  416,  432,  416,  416,
554      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
555      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
556      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
557      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
558      423,  423,  423,  423,  423,  416,  416,  416,  433,  416,
559
560      416,  434,  416,  416,  416,  416,  416,  416,  416,  432,
561      416,  416,  416,  423,  423,  423,  423,  423,  423,  423,
562      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
563      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
564      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
565      423,  423,  423,  423,  423,  423,  423,  416,  416,  416,
566      416,  434,  416,  416,  416,  416,  416,  416,  416,  423,
567      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
568      423,  423,  423,  423,  423,  423,  423,  416,  423,  423,
569      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
570
571      423,  423,  423,  423,  423,  423,  416,  416,  416,  416,
572      416,  416,  423,  423,  423,  423,  423,  423,  423,  423,
573      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
574      423,  423,  416,  423,  423,  423,  416,  423,  423,  423,
575      423,  423,  416,  416,  423,  423,  423,  423,  423,  423,
576      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
577      423,  423,  423,  423,  423,  416,  423,  423,  423,  423,
578      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
579      423,  423,  416,  423,  423,  423,  423,  423,  423,  423,
580      423,  423,  423,  423,  423,  423,  423,  423,  423,  423,
581
582      423,  423,  416,  423,  423,  423,  416,  423,  423,  423,
583      423,  423,  423,  423,  423,    0,  416,  416,  416,  416,
584      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
585      416,  416,  416,  416
586    } ;
587
588static yyconst flex_int16_t yy_nxt[2416] =
589    {   0,
590        8,    9,   10,    9,    8,   11,   12,    8,   13,   14,
591       15,   16,   17,   18,   18,   18,   18,   18,   18,    8,
592        8,   19,   19,   19,   20,   21,   22,   19,   23,   19,
593       19,   24,   19,   19,   19,   25,   19,   19,   26,   27,
594       19,   28,   29,   30,   31,   32,   33,   19,   34,   19,
595       35,   19,   36,   37,   19,   19,   38,   39,   40,   41,
596       42,   19,   19,    8,    8,   43,   44,   45,   50,   52,
597       50,   56,   56,   57,   57,   57,   57,   57,   57,   57,
598       50,  260,   50,   72,   64,  383,   58,   58,   65,   77,
599       59,  262,   52,   76,   76,  260,   90,  366,  261,   77,
600
601      202,  212,   53,   77,   72,   58,   58,   60,   60,   60,
602       60,   60,   60,   60,   81,   67,   78,   79,   80,   61,
603       62,   63,  212,  344,   61,   53,   78,   79,   80,  262,
604       78,   79,   80,  343,  140,   77,  312,  202,   61,   62,
605       63,  311,   68,   69,   70,   61,   56,   84,   71,   71,
606       71,   71,   71,   71,   71,  310,   77,  262,   72,  309,
607      308,   58,   78,   79,   80,   73,  307,   76,   66,   72,
608       85,   74,  269,   75,  140,   86,  268,   72,   87,  267,
609       58,  202,   91,   78,   79,   80,   73,  213,   77,   76,
610       88,   77,  209,   72,   66,   74,   82,   82,   89,  208,
611
612       83,   83,   83,   83,   83,   83,   83,   91,   91,   91,
613       91,   91,   91,   91,   99,   78,   79,   80,   78,   79,
614       80,   77,  207,  140,  201,  197,   77,  197,  416,  127,
615      100,  196,   91,  150,  149,   76,  101,  416,  147,  146,
616       77,   66,  136,  416,  130,   77,  416,  128,   78,   79,
617       80,   77,  106,   78,   79,   80,   92,   93,   94,   95,
618       77,   96,  102,  107,   97,  108,   98,   78,   79,   80,
619      103,   77,   78,   79,   80,  104,   77,  127,   78,   79,
620       80,   77,  125,  124,   77,   91,  110,   78,   79,   80,
621      111,  109,   77,  105,  112,   77,  416,  113,   78,   79,
622
623       80,  114,   77,   78,   79,   80,   77,   55,   78,   79,
624       80,   78,   79,   80,   77,  115,  123,  416,   49,   78,
625       79,   80,   78,   79,   80,  117,  116,   49,   47,   78,
626       79,   80,   47,   78,   79,   80,   77,  416,  416,  118,
627      416,   78,   79,   80,  416,  416,  119,  416,  120,  416,
628      121,  416,  416,  141,  416,  122,  132,  132,  132,  132,
629      132,  132,  416,   78,   79,   80,  134,  134,  416,  416,
630      135,  135,  135,  135,  135,  135,  135,  416,  137,  137,
631      142,  133,  138,  138,  138,  138,  138,  138,  138,   66,
632       66,   66,   66,   66,   66,   66,   77,  416,  416,   72,
633
634       76,   76,   76,   76,   76,  416,   73,  143,  144,  145,
635       72,   77,   76,   76,   77,  416,   76,  151,   72,  416,
636      157,  155,  416,   78,   79,   80,  154,   73,  152,   77,
637      153,  416,  156,  152,   72,   76,   77,  158,   78,   79,
638       80,   78,   79,   80,   77,  416,  159,  152,  416,  153,
639       77,  416,  416,  416,  152,   77,   78,   79,   80,   77,
640       76,  416,  157,   78,   79,   80,   77,  416,  416,  416,
641       77,   78,   79,   80,  416,  160,  161,   78,   79,   80,
642      416,   77,   78,   79,   80,  416,   78,   79,   80,   77,
643      416,  416,   77,   78,   79,   80,  167,   78,   79,   80,
644
645      166,  416,  163,  162,  164,  416,  416,  165,   78,   79,
646       80,   77,  416,  416,   77,  416,   78,   79,   80,   78,
647       79,   80,  416,  169,   77,  416,  168,   77,  416,  173,
648      416,  416,   77,  416,  170,  171,  416,   77,   78,   79,
649       80,   78,   79,   80,  172,  174,   77,  416,  416,   77,
650      416,   78,   79,   80,   78,   79,   80,  175,   77,   78,
651       79,   80,  176,  416,   78,   79,   80,  177,   77,  416,
652      416,  416,  416,   78,   79,   80,   78,   79,   80,  178,
653       77,  416,  416,  179,   77,   78,   79,   80,   77,  416,
654      416,   77,  416,  416,   77,   78,   79,   80,   77,  180,
655
656      181,   77,  182,  185,   77,  183,  186,   78,   79,   80,
657      157,   78,   79,   80,  184,   78,   79,   80,   78,   79,
658       80,   78,   79,   80,   77,   78,   79,   80,   78,   79,
659       80,   78,   79,   80,  416,  416,   77,  416,  416,  187,
660       77,  416,  416,   77,  416,  416,   77,  416,  416,  416,
661       77,   78,   79,   80,  188,  416,  189,  416,  416,  416,
662      191,   77,  193,   78,   79,   80,  190,   78,   79,   80,
663       78,   79,   80,   78,   79,   80,  192,   78,   79,   80,
664      211,  416,   77,  416,  212,   77,  197,  416,   78,   79,
665       80,  194,  198,  198,  198,  198,  198,  198,  416,  416,
666
667      416,  211,  141,  195,  203,  416,  416,  416,  212,   78,
668       79,   80,   78,   79,   80,  135,  135,  135,  135,  135,
669      135,  135,  135,  135,  135,  135,  135,  135,  135,  142,
670      416,  204,  205,  206,  200,  416,   63,  416,  416,  200,
671      138,  138,  138,  138,  138,  138,  138,  258,  258,  258,
672      258,  258,  258,  200,   77,   63,  143,  144,  145,   77,
673      200,  138,  138,  138,  138,  138,  138,  138,  140,  140,
674      140,  140,  140,   61,  416,   63,  416,   77,   61,  416,
675      214,   78,   79,   80,  140,  416,   78,   79,   80,   77,
676      416,  215,   61,  218,   63,   77,  416,  416,   77,   61,
677
678      416,  416,   77,  140,   78,   79,   80,  416,   77,  216,
679      416,  220,  217,   77,  416,  416,   78,   79,   80,  221,
680      219,   77,   78,   79,   80,   78,   79,   80,  140,   78,
681       79,   80,   77,  416,  416,   78,   79,   80,   77,  222,
682       78,   79,   80,  223,   77,  416,  416,   77,   78,   79,
683       80,   77,  228,  225,  416,  227,  224,  416,   77,   78,
684       79,   80,   77,  416,  416,   78,   79,   80,   77,  226,
685      229,   78,   79,   80,   78,   79,   80,   77,   78,   79,
686       80,  416,   77,  231,  416,   78,   79,   80,   77,   78,
687       79,   80,   77,  416,  233,   78,   79,   80,  230,  416,
688
689       77,  416,  416,  416,   78,   79,   80,   77,  232,   78,
690       79,   80,   77,  416,  236,   78,   79,   80,  234,   78,
691       79,   80,  416,  235,   77,  416,  416,   78,   79,   80,
692      237,   77,  416,  211,   78,   79,   80,  212,   77,   78,
693       79,   80,   77,  416,  239,  238,   77,  416,  240,  416,
694       77,   78,   79,   80,  211,   77,  249,  219,   78,   79,
695       80,  212,  416,  416,  242,   78,   79,   80,   77,   78,
696       79,   80,   77,   78,   79,   80,  241,   78,   79,   80,
697      244,   77,   78,   79,   80,   77,  416,  245,   77,  250,
698      416,  243,   77,  416,  251,   78,   79,   80,  247,   78,
699
700       79,   80,   77,  416,  248,   77,  246,  416,   78,   79,
701       80,  416,   78,   79,   80,   78,   79,   80,   77,   78,
702       79,   80,   77,  416,  416,  252,  141,   77,  416,   78,
703       79,   80,   78,   79,   80,  416,  254,  255,  253,  416,
704      416,  416,   77,  416,  416,   78,   79,   80,   77,   78,
705       79,   80,  416,  263,   78,   79,   80,  256,  257,  202,
706      202,  202,  202,  202,  202,  202,   77,  416,  416,   78,
707       79,   80,   77,  273,  416,   78,   79,   80,  270,   77,
708      264,  265,  266,   77,  416,  416,  416,   77,  274,  416,
709       77,  416,  271,   78,   79,   80,   77,  272,  416,   78,
710
711       79,   80,  416,  416,  416,   77,   78,   79,   80,   77,
712       78,   79,   80,   77,   78,   79,   80,   78,   79,   80,
713       77,  276,  416,   78,   79,   80,   77,  275,  416,  416,
714      277,   77,   78,   79,   80,   77,   78,   79,   80,   77,
715       78,   79,   80,  278,   77,  283,  279,   78,   79,   80,
716      281,   77,  280,   78,   79,   80,   77,  416,   78,   79,
717       80,   77,   78,   79,   80,   77,   78,   79,   80,  282,
718       77,   78,   79,   80,  285,   77,  288,  284,   78,   79,
719       80,  286,   77,   78,   79,   80,   77,  416,   78,   79,
720       80,   77,   78,   79,   80,   77,  289,   78,   79,   80,
721
722       77,  287,   78,   79,   80,   77,  416,  291,  292,   78,
723       79,   80,  290,   78,   79,   80,  416,   77,   78,   79,
724       80,   77,   78,   79,   80,  248,  294,   78,   79,   80,
725       77,  416,   78,   79,   80,   77,  416,  416,  416,  416,
726       77,  416,  296,  293,   78,   79,   80,   77,   78,   79,
727       80,   77,  295,  416,  416,  416,   77,   78,   79,   80,
728      298,   77,   78,   79,   80,   77,  416,   78,   79,   80,
729      416,  300,   77,  416,   78,   79,   80,  301,   78,   79,
730       80,  297,  416,   78,   79,   80,  141,   77,   78,   79,
731       80,  299,   78,   79,   80,  303,  416,  416,   77,   78,
732
733       79,   80,   77,  416,  302,   77,  416,  416,   77,  416,
734      306,  416,  416,  263,   78,   79,   80,  416,  304,  416,
735      305,  416,   77,  416,  416,   78,   79,   80,  313,   78,
736       79,   80,   78,   79,   80,   78,   79,   80,  314,  416,
737      264,  265,  266,  262,  262,  262,  262,  262,   77,   78,
738       79,   80,   77,  316,  416,   77,  416,  416,  317,  262,
739      416,   77,  315,  319,  416,   77,  318,  416,   77,  416,
740      416,   77,  416,  320,  416,   78,   79,   80,  262,   78,
741       79,   80,   78,   79,   80,  321,  416,   77,   78,   79,
742       80,   77,   78,   79,   80,   78,   79,   80,   78,   79,
743
744       80,   77,  416,  262,   77,  322,  323,   77,  416,  416,
745      416,  324,   77,  416,   78,   79,   80,  416,   78,   79,
746       80,   77,  325,  328,  326,   77,  416,  416,   78,   79,
747       80,   78,   79,   80,   78,   79,   80,   77,  416,   78,
748       79,   80,   77,  329,  327,  416,  416,  416,   78,   79,
749       80,   77,   78,   79,   80,   77,  333,  332,   77,  416,
750      316,   77,  337,  330,   78,   79,   80,  334,   77,   78,
751       79,   80,   77,  416,  331,   77,  416,  416,   78,   79,
752       80,   77,   78,   79,   80,   78,   79,   80,   78,   79,
753       80,   77,  416,  338,   77,   78,   79,   80,  316,   78,
754
755       79,   80,   78,   79,   80,   77,  416,  416,   78,   79,
756       80,  335,   77,  416,  336,   77,  416,  416,   78,   79,
757       80,   78,   79,   80,   77,  416,  416,   77,  416,  416,
758       77,  416,   78,   79,   80,  339,   77,  416,  416,   78,
759       79,   80,   78,   79,   80,   77,  340,  416,  342,   77,
760      341,   78,   79,   80,   78,   79,   80,   78,   79,   80,
761      345,   77,  416,   78,   79,   80,   77,  416,  416,  347,
762       77,  416,   78,   79,   80,  346,   78,   79,   80,  348,
763       77,  349,  416,   77,  416,  416,   77,  416,   78,   79,
764       80,   77,  416,   78,   79,   80,  416,   78,   79,   80,
765
766      350,   77,  416,  352,   77,  351,  416,   78,   79,   80,
767       78,   79,   80,   78,   79,   80,   77,  416,   78,   79,
768       80,  416,   77,  416,  354,  353,  355,   77,   78,   79,
769       80,   78,   79,   80,  416,  416,   77,  416,  416,  354,
770      416,   77,  416,   78,   79,   80,  416,  416,   77,   78,
771       79,   80,  356,  357,   78,   79,   80,  416,   77,  416,
772      416,  416,  360,   78,   79,   80,  358,   77,   78,   79,
773       80,   77,  416,  416,  359,   78,   79,   80,   77,  416,
774      416,  416,  416,   77,  416,   78,   79,   80,  361,   77,
775      416,  416,   77,  416,   78,   79,   80,   77,   78,   79,
776
777       80,  244,   77,  416,  416,   78,   79,   80,  363,   77,
778       78,   79,   80,  362,   77,  369,   78,   79,   80,   78,
779       79,   80,  416,   77,   78,   79,   80,  416,   77,   78,
780       79,   80,   77,  416,  364,  365,   78,   79,   80,  416,
781       77,   78,   79,   80,  416,  416,  367,  216,   77,  416,
782       78,   79,   80,   77,  416,   78,   79,   80,   77,   78,
783       79,   80,   77,  370,  371,   77,  416,   78,   79,   80,
784      416,  368,   77,  416,  373,   78,   79,   80,  374,  372,
785       78,   79,   80,   77,  416,   78,   79,   80,  416,   78,
786       79,   80,   78,   79,   80,  416,  416,   77,  416,   78,
787
788       79,   80,  375,   77,  416,  416,  416,   77,  416,  376,
789       78,   79,   80,  354,   77,  416,  416,   77,  416,  416,
790      354,  416,   77,  416,   78,   79,   80,  378,  416,  377,
791       78,   79,   80,   77,   78,   79,   80,   77,  416,  416,
792       77,   78,   79,   80,   78,   79,   80,   77,  379,   78,
793       79,   80,   77,  381,  416,  380,  416,   77,  303,  384,
794       78,   79,   80,  382,   78,   79,   80,   78,   79,   80,
795       77,  416,  416,  385,   78,   79,   80,  216,   77,   78,
796       79,   80,  387,   77,   78,   79,   80,   77,  416,  388,
797      416,   77,  416,  416,  416,  416,   77,   78,   79,   80,
798
799      416,  416,  386,   77,  416,   78,   79,   80,   77,  416,
800       78,   79,   80,   77,   78,   79,   80,  389,   78,   79,
801       80,  390,   77,   78,   79,   80,  392,   77,  393,  391,
802       78,   79,   80,   77,  416,   78,   79,   80,   77,  416,
803       78,   79,   80,   77,  378,  416,   77,  394,  385,   78,
804       79,   80,   77,  416,   78,   79,   80,   77,  416,  416,
805       78,   79,   80,   77,  416,   78,   79,   80,   77,  396,
806       78,   79,   80,   78,   79,   80,  395,   77,  399,   78,
807       79,   80,   77,  397,   78,   79,   80,  398,  354,   77,
808       78,   79,   80,  354,   77,   78,   79,   80,   77,  416,
809
810      403,   77,  401,  416,   78,   79,   80,  416,  402,   78,
811       79,   80,   77,  416,  400,   77,   78,   79,   80,   77,
812      416,   78,   79,   80,   77,   78,   79,   80,   78,   79,
813       80,  354,   77,  354,  405,  416,   77,  416,  416,   78,
814       79,   80,   78,   79,   80,   77,   78,   79,   80,  407,
815      416,   78,   79,   80,  404,  354,  406,   77,  416,   78,
816       79,   80,  416,   78,   79,   80,  416,  416,   77,  416,
817      416,   77,   78,   79,   80,   77,  410,  408,   77,  416,
818      416,  409,   77,  416,   78,   79,   80,  416,  416,   77,
819      416,  416,  416,  416,  354,   78,   79,   80,   78,   79,
820
821       80,  416,   78,   79,   80,   78,   79,   80,  354,   78,
822       79,   80,  416,   77,  416,  416,   78,   79,   80,  411,
823       77,  416,  416,  416,   77,  416,  416,   77,  416,  416,
824       77,  416,  416,  416,  416,  416,   77,  414,  412,  416,
825       78,   79,   80,  413,  416,  415,  416,   78,   79,   80,
826      354,   78,   79,   80,   78,   79,   80,   78,   79,   80,
827      416,  416,  416,   78,   79,   80,   46,   46,   46,   46,
828       46,   46,   46,   46,   46,   46,   46,   46,   46,   46,
829       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
830       48,   48,   48,   48,   51,   51,   51,   51,   51,   51,
831
832       51,   51,   51,   51,   51,   51,   51,   51,   54,   54,
833       54,   54,   54,   54,   54,   54,   54,   54,   54,   54,
834       54,   54,   57,  416,   57,  416,   57,  416,   57,   66,
835      416,  416,   66,  416,   66,   66,   66,   66,   66,   76,
836       76,  416,   76,   76,   76,   76,   76,   76,  126,  126,
837      126,  126,  126,  126,  126,  126,  126,  126,  126,  126,
838      126,  126,  129,  129,  129,  129,  129,  129,  129,  129,
839      129,  129,  129,  129,  129,  131,  416,  131,  131,  131,
840      131,  131,  131,  131,  131,  131,  131,  131,  131,  139,
841      416,  139,  139,  139,  139,  139,  139,  139,  139,  139,
842
843      139,  139,  139,  140,  140,  140,  140,  140,  140,  140,
844      140,  140,  148,  148,  148,  199,  416,  416,  416,  416,
845      199,  199,  199,  202,  202,  202,  202,  202,  210,  210,
846      210,  416,  416,  210,  259,  259,  259,  262,  262,  262,
847      262,  262,  262,  262,  262,  262,    7,  416,  416,  416,
848      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
849      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
850      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
851      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
852      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
853
854      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
855      416,  416,  416,  416,  416
856    } ;
857
858static yyconst flex_int16_t yy_chk[2416] =
859    {   0,
860        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
861        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
862        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
863        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
864        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
865        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
866        1,    1,    1,    1,    1,    1,    1,    1,    9,   11,
867        9,   13,   14,   13,   13,   13,   13,   13,   13,   13,
868       50,  383,   50,   73,   16,  366,   13,   14,   16,   19,
869       14,  344,   51,   82,   82,  201,   25,  343,  201,   20,
870
871      312,  211,   11,   25,   73,   13,   14,   15,   15,   15,
872       15,   15,   15,   15,   20,   16,   19,   19,   19,   15,
873       15,   15,  211,  311,   15,   51,   20,   20,   20,  310,
874       25,   25,   25,  309,  269,   22,  268,  267,   15,   15,
875       15,  266,   16,   16,   16,   15,   17,   22,   17,   17,
876       17,   17,   17,   17,   17,  265,   23,  264,   17,  261,
877      259,   17,   22,   22,   22,   17,  258,  213,  209,   17,
878       23,   17,  208,   17,  207,   24,  206,   17,   24,  205,
879       17,  204,  196,   23,   23,   23,   17,  150,   24,  149,
880       24,   28,  147,   17,  146,   17,   21,   21,   24,  145,
881
882       21,   21,   21,   21,   21,   21,   21,   26,   26,   26,
883       26,   26,   26,   26,   28,   24,   24,   24,   28,   28,
884       28,   29,  144,  143,  136,  133,   21,  131,  127,  126,
885       29,  125,  124,   80,   79,   78,   29,   71,   70,   69,
886       32,   68,   59,   57,   54,   33,   53,   47,   29,   29,
887       29,   34,   32,   21,   21,   21,   27,   27,   27,   27,
888       30,   27,   30,   33,   27,   34,   27,   32,   32,   32,
889       30,   27,   33,   33,   33,   30,   35,   46,   34,   34,
890       34,   37,   45,   44,   36,   43,   36,   30,   30,   30,
891       36,   35,   76,   31,   36,   38,   18,   37,   27,   27,
892
893       27,   38,   40,   35,   35,   35,   39,   12,   37,   37,
894       37,   36,   36,   36,   42,   39,   42,    7,    6,   76,
895       76,   76,   38,   38,   38,   40,   39,    5,    4,   40,
896       40,   40,    3,   39,   39,   39,   41,    0,    0,   41,
897        0,   42,   42,   42,    0,    0,   41,    0,   41,    0,
898       41,    0,    0,   66,    0,   41,   55,   55,   55,   55,
899       55,   55,    0,   41,   41,   41,   58,   58,    0,    0,
900       58,   58,   58,   58,   58,   58,   58,    0,   62,   62,
901       66,   55,   62,   62,   62,   62,   62,   62,   62,   67,
902       67,   67,   67,   67,   67,   67,   81,    0,    0,   74,
903
904       77,   77,   77,   77,   77,    0,   74,   66,   66,   66,
905       74,   84,   83,   83,   85,    0,   77,   81,   74,    0,
906       87,   85,    0,   81,   81,   81,   84,   74,   83,   87,
907       83,    0,   86,   83,   74,   77,   86,   88,   84,   84,
908       84,   85,   85,   85,   88,    0,   90,   83,    0,   83,
909       89,    0,    0,    0,   83,   90,   87,   87,   87,   91,
910       77,    0,   89,   86,   86,   86,   92,    0,    0,    0,
911       93,   88,   88,   88,    0,   92,   93,   89,   89,   89,
912        0,   96,   90,   90,   90,    0,   91,   91,   91,   94,
913        0,    0,   95,   92,   92,   92,   97,   93,   93,   93,
914
915       96,    0,   95,   94,   95,    0,    0,   95,   96,   96,
916       96,   97,    0,    0,   98,    0,   94,   94,   94,   95,
917       95,   95,    0,   98,   99,    0,   97,  100,    0,  100,
918        0,    0,  101,    0,   98,   98,    0,  102,   97,   97,
919       97,   98,   98,   98,   99,  101,  104,    0,    0,  103,
920        0,   99,   99,   99,  100,  100,  100,  102,  105,  101,
921      101,  101,  103,    0,  102,  102,  102,  104,  106,    0,
922        0,    0,    0,  104,  104,  104,  103,  103,  103,  105,
923      108,    0,    0,  106,  107,  105,  105,  105,  109,    0,
924        0,  110,    0,    0,  111,  106,  106,  106,  112,  107,
925
926      108,  113,  109,  113,  114,  110,  114,  108,  108,  108,
927      112,  107,  107,  107,  111,  109,  109,  109,  110,  110,
928      110,  111,  111,  111,  115,  112,  112,  112,  113,  113,
929      113,  114,  114,  114,    0,    0,  116,    0,    0,  115,
930      117,    0,    0,  118,    0,    0,  119,    0,    0,    0,
931      121,  115,  115,  115,  116,    0,  117,    0,    0,    0,
932      119,  120,  121,  116,  116,  116,  118,  117,  117,  117,
933      118,  118,  118,  119,  119,  119,  120,  121,  121,  121,
934      148,    0,  122,    0,  148,  123,  132,    0,  120,  120,
935      120,  122,  132,  132,  132,  132,  132,  132,    0,    0,
936
937        0,  148,  140,  123,  141,    0,    0,    0,  148,  122,
938      122,  122,  123,  123,  123,  134,  134,  134,  134,  134,
939      134,  134,  135,  135,  135,  135,  135,  135,  135,  140,
940        0,  141,  141,  141,  135,    0,  135,    0,    0,  135,
941      137,  137,  137,  137,  137,  137,  137,  198,  198,  198,
942      198,  198,  198,  135,  152,  135,  140,  140,  140,  153,
943      135,  138,  138,  138,  138,  138,  138,  138,  142,  142,
944      142,  142,  142,  138,    0,  138,    0,  151,  138,    0,
945      151,  152,  152,  152,  142,    0,  153,  153,  153,  154,
946        0,  154,  138,  156,  138,  157,    0,    0,  160,  138,
947
948        0,    0,  155,  142,  151,  151,  151,    0,  156,  155,
949        0,  159,  155,  158,    0,    0,  154,  154,  154,  160,
950      158,  159,  157,  157,  157,  160,  160,  160,  142,  155,
951      155,  155,  161,    0,    0,  156,  156,  156,  162,  161,
952      158,  158,  158,  162,  163,    0,    0,  164,  159,  159,
953      159,  165,  167,  164,    0,  166,  163,    0,  167,  161,
954      161,  161,  166,    0,    0,  162,  162,  162,  170,  165,
955      168,  163,  163,  163,  164,  164,  164,  169,  165,  165,
956      165,    0,  168,  170,    0,  167,  167,  167,  172,  166,
957      166,  166,  171,    0,  172,  170,  170,  170,  169,    0,
958
959      173,    0,    0,    0,  169,  169,  169,  174,  171,  168,
960      168,  168,  175,    0,  175,  172,  172,  172,  173,  171,
961      171,  171,    0,  174,  176,    0,    0,  173,  173,  173,
962      176,  178,    0,  210,  174,  174,  174,  210,  187,  175,
963      175,  175,  177,    0,  178,  177,  179,    0,  179,    0,
964      183,  176,  176,  176,  210,  180,  187,  183,  178,  178,
965      178,  210,    0,    0,  181,  187,  187,  187,  188,  177,
966      177,  177,  182,  179,  179,  179,  180,  183,  183,  183,
967      182,  185,  180,  180,  180,  181,    0,  184,  189,  188,
968        0,  181,  186,    0,  189,  188,  188,  188,  185,  182,
969
970      182,  182,  184,    0,  186,  190,  184,    0,  185,  185,
971      185,    0,  181,  181,  181,  189,  189,  189,  191,  186,
972      186,  186,  192,    0,    0,  190,  202,  193,    0,  184,
973      184,  184,  190,  190,  190,    0,  192,  193,  191,    0,
974        0,    0,  194,    0,    0,  191,  191,  191,  195,  192,
975      192,  192,    0,  202,  193,  193,  193,  194,  195,  203,
976      203,  203,  203,  203,  203,  203,  214,    0,    0,  194,
977      194,  194,  215,  218,    0,  195,  195,  195,  214,  216,
978      202,  202,  202,  217,    0,    0,    0,  218,  220,    0,
979      219,    0,  215,  214,  214,  214,  220,  217,    0,  215,
980
981      215,  215,    0,    0,    0,  233,  216,  216,  216,  222,
982      217,  217,  217,  221,  218,  218,  218,  219,  219,  219,
983      223,  222,    0,  220,  220,  220,  225,  221,    0,    0,
984      223,  224,  233,  233,  233,  229,  222,  222,  222,  226,
985      221,  221,  221,  224,  227,  229,  225,  223,  223,  223,
986      227,  228,  226,  225,  225,  225,  231,    0,  224,  224,
987      224,  234,  229,  229,  229,  239,  226,  226,  226,  228,
988      230,  227,  227,  227,  231,  232,  236,  230,  228,  228,
989      228,  232,  237,  231,  231,  231,  235,    0,  234,  234,
990      234,  241,  239,  239,  239,  236,  237,  230,  230,  230,
991
992      238,  235,  232,  232,  232,  240,    0,  241,  242,  237,
993      237,  237,  238,  235,  235,  235,    0,  244,  241,  241,
994      241,  247,  236,  236,  236,  240,  245,  238,  238,  238,
995      242,    0,  240,  240,  240,  243,    0,    0,    0,    0,
996      245,    0,  247,  243,  244,  244,  244,  246,  247,  247,
997      247,  248,  246,    0,    0,    0,  250,  242,  242,  242,
998      250,  249,  243,  243,  243,  252,    0,  245,  245,  245,
999        0,  252,  251,    0,  246,  246,  246,  253,  248,  248,
1000      248,  249,    0,  250,  250,  250,  262,  254,  249,  249,
1001      249,  251,  252,  252,  252,  254,    0,    0,  253,  251,
1002
1003      251,  251,  256,    0,  253,  255,    0,    0,  257,    0,
1004      257,    0,    0,  262,  254,  254,  254,    0,  255,    0,
1005      256,    0,  270,    0,    0,  253,  253,  253,  270,  256,
1006      256,  256,  255,  255,  255,  257,  257,  257,  271,    0,
1007      262,  262,  262,  263,  263,  263,  263,  263,  271,  270,
1008      270,  270,  272,  273,    0,  275,    0,    0,  274,  263,
1009        0,  276,  272,  276,    0,  273,  275,    0,  274,    0,
1010        0,  277,    0,  277,    0,  271,  271,  271,  263,  272,
1011      272,  272,  275,  275,  275,  278,    0,  278,  276,  276,
1012      276,  281,  273,  273,  273,  274,  274,  274,  277,  277,
1013
1014      277,  279,    0,  263,  280,  279,  280,  282,    0,    0,
1015        0,  281,  283,    0,  278,  278,  278,    0,  281,  281,
1016      281,  285,  282,  285,  283,  286,    0,    0,  279,  279,
1017      279,  280,  280,  280,  282,  282,  282,  284,    0,  283,
1018      283,  283,  287,  286,  284,    0,    0,    0,  285,  285,
1019      285,  290,  286,  286,  286,  289,  291,  290,  292,    0,
1020      294,  293,  299,  287,  284,  284,  284,  293,  297,  287,
1021      287,  287,  294,    0,  289,  291,    0,    0,  290,  290,
1022      290,  299,  289,  289,  289,  292,  292,  292,  293,  293,
1023      293,  295,    0,  301,  298,  297,  297,  297,  295,  294,
1024
1025      294,  294,  291,  291,  291,  296,    0,    0,  299,  299,
1026      299,  296,  300,    0,  298,  301,    0,    0,  295,  295,
1027      295,  298,  298,  298,  303,    0,    0,  302,    0,    0,
1028      305,    0,  296,  296,  296,  302,  304,    0,    0,  300,
1029      300,  300,  301,  301,  301,  306,  304,    0,  306,  315,
1030      305,  303,  303,  303,  302,  302,  302,  305,  305,  305,
1031      313,  314,    0,  304,  304,  304,  316,    0,    0,  315,
1032      313,    0,  306,  306,  306,  314,  315,  315,  315,  317,
1033      319,  318,    0,  317,    0,    0,  318,    0,  314,  314,
1034      314,  320,    0,  316,  316,  316,    0,  313,  313,  313,
1035
1036      319,  321,    0,  321,  323,  320,    0,  319,  319,  319,
1037      317,  317,  317,  318,  318,  318,  322,    0,  320,  320,
1038      320,    0,  324,    0,  323,  322,  324,  326,  321,  321,
1039      321,  323,  323,  323,    0,    0,  325,    0,    0,  326,
1040        0,  327,    0,  322,  322,  322,    0,    0,  330,  324,
1041      324,  324,  325,  327,  326,  326,  326,    0,  328,    0,
1042        0,    0,  330,  325,  325,  325,  328,  332,  327,  327,
1043      327,  329,    0,    0,  329,  330,  330,  330,  331,    0,
1044        0,    0,    0,  334,    0,  328,  328,  328,  331,  335,
1045        0,    0,  336,    0,  332,  332,  332,  338,  329,  329,
1046
1047      329,  334,  339,    0,    0,  331,  331,  331,  339,  341,
1048      334,  334,  334,  336,  340,  348,  335,  335,  335,  336,
1049      336,  336,    0,  342,  338,  338,  338,    0,  348,  339,
1050      339,  339,  345,    0,  340,  342,  341,  341,  341,    0,
1051      346,  340,  340,  340,    0,    0,  345,  346,  347,    0,
1052      342,  342,  342,  349,    0,  348,  348,  348,  350,  345,
1053      345,  345,  352,  349,  350,  351,    0,  346,  346,  346,
1054        0,  347,  353,    0,  352,  347,  347,  347,  353,  351,
1055      349,  349,  349,  354,    0,  350,  350,  350,    0,  352,
1056      352,  352,  351,  351,  351,    0,    0,  355,    0,  353,
1057
1058      353,  353,  355,  356,    0,    0,    0,  357,    0,  356,
1059      354,  354,  354,  357,  358,    0,    0,  359,    0,    0,
1060      358,    0,  360,    0,  355,  355,  355,  360,    0,  359,
1061      356,  356,  356,  361,  357,  357,  357,  362,    0,    0,
1062      363,  358,  358,  358,  359,  359,  359,  364,  361,  360,
1063      360,  360,  367,  364,    0,  362,    0,  365,  363,  367,
1064      361,  361,  361,  365,  362,  362,  362,  363,  363,  363,
1065      368,    0,    0,  369,  364,  364,  364,  368,  370,  367,
1066      367,  367,  371,  372,  365,  365,  365,  369,    0,  372,
1067        0,  371,    0,    0,    0,    0,  373,  368,  368,  368,
1068
1069        0,    0,  370,  374,    0,  370,  370,  370,  376,    0,
1070      372,  372,  372,  377,  369,  369,  369,  373,  371,  371,
1071      371,  374,  375,  373,  373,  373,  376,  378,  377,  375,
1072      374,  374,  374,  379,    0,  376,  376,  376,  380,    0,
1073      377,  377,  377,  381,  380,    0,  384,  379,  381,  375,
1074      375,  375,  385,    0,  378,  378,  378,  382,    0,    0,
1075      379,  379,  379,  386,    0,  380,  380,  380,  388,  386,
1076      381,  381,  381,  384,  384,  384,  382,  387,  390,  385,
1077      385,  385,  389,  387,  382,  382,  382,  388,  389,  394,
1078      386,  386,  386,  391,  392,  388,  388,  388,  393,    0,
1079
1080      395,  390,  393,    0,  387,  387,  387,    0,  394,  389,
1081      389,  389,  396,    0,  392,  391,  394,  394,  394,  395,
1082        0,  392,  392,  392,  400,  393,  393,  393,  390,  390,
1083      390,  396,  397,  399,  400,    0,  398,    0,    0,  396,
1084      396,  396,  391,  391,  391,  401,  395,  395,  395,  402,
1085        0,  400,  400,  400,  397,  398,  401,  399,    0,  397,
1086      397,  397,    0,  398,  398,  398,    0,    0,  402,    0,
1087        0,  404,  401,  401,  401,  405,  406,  404,  406,    0,
1088        0,  405,  408,    0,  399,  399,  399,    0,    0,  409,
1089        0,    0,    0,    0,  408,  402,  402,  402,  404,  404,
1090
1091      404,    0,  405,  405,  405,  406,  406,  406,  409,  408,
1092      408,  408,    0,  410,    0,    0,  409,  409,  409,  410,
1093      411,    0,    0,    0,  412,    0,    0,  413,    0,    0,
1094      414,    0,    0,    0,    0,    0,  415,  413,  411,    0,
1095      410,  410,  410,  412,    0,  414,    0,  411,  411,  411,
1096      415,  412,  412,  412,  413,  413,  413,  414,  414,  414,
1097        0,    0,    0,  415,  415,  415,  417,  417,  417,  417,
1098      417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
1099      418,  418,  418,  418,  418,  418,  418,  418,  418,  418,
1100      418,  418,  418,  418,  419,  419,  419,  419,  419,  419,
1101
1102      419,  419,  419,  419,  419,  419,  419,  419,  420,  420,
1103      420,  420,  420,  420,  420,  420,  420,  420,  420,  420,
1104      420,  420,  421,    0,  421,    0,  421,    0,  421,  422,
1105        0,    0,  422,    0,  422,  422,  422,  422,  422,  423,
1106      423,    0,  423,  423,  423,  423,  423,  423,  424,  424,
1107      424,  424,  424,  424,  424,  424,  424,  424,  424,  424,
1108      424,  424,  425,  425,  425,  425,  425,  425,  425,  425,
1109      425,  425,  425,  425,  425,  426,    0,  426,  426,  426,
1110      426,  426,  426,  426,  426,  426,  426,  426,  426,  427,
1111        0,  427,  427,  427,  427,  427,  427,  427,  427,  427,
1112
1113      427,  427,  427,  428,  428,  428,  428,  428,  428,  428,
1114      428,  428,  429,  429,  429,  430,    0,    0,    0,    0,
1115      430,  430,  430,  431,  431,  431,  431,  431,  432,  432,
1116      432,    0,    0,  432,  433,  433,  433,  434,  434,  434,
1117      434,  434,  434,  434,  434,  434,  416,  416,  416,  416,
1118      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
1119      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
1120      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
1121      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
1122      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
1123
1124      416,  416,  416,  416,  416,  416,  416,  416,  416,  416,
1125      416,  416,  416,  416,  416
1126    } ;
1127
1128static yy_state_type yy_last_accepting_state;
1129static char *yy_last_accepting_cpos;
1130
1131extern int ncg_flex_debug;
1132int ncg_flex_debug = 0;
1133
1134/* The intent behind this definition is that it'll catch
1135 * any uses of REJECT which flex missed.
1136 */
1137#define REJECT reject_used_but_not_detected
1138#define yymore() yymore_used_but_not_detected
1139#define YY_MORE_ADJ 0
1140#define YY_RESTORE_YY_MORE_OFFSET
1141char *ncgtext;
1142#line 1 "ncgen.l"
1143#line 2 "ncgen.l"
1144/*********************************************************************
1145 *   Copyright 1993, UCAR/Unidata
1146 *   See netcdf/COPYRIGHT file for copying and redistribution conditions.
1147 *   $Id: ncgen.l,v 1.24 2009/09/25 18:22:35 dmh Exp $
1148 *********************************************************************/
1149
1150/* Problems:
11511. We assume the input is true utf8.
1152   Unfortunately, we may actually get iso-latin-8859-1.
1153   This means that there will be ambiguity about the characters
1154   in the range 128-255 because they will look like n-byte unicode
1155   when they are 1-byte 8859 characters. Because of our encoding,
1156   8859 characters above 128 will be handles as n-byte utf8 and so
1157   will probably not lex correctly.
1158   Solution: assume utf8 and note in the documentation that
1159   ISO8859 is specifically unsupported.
11602. The netcdf function NC_check_name in string.c must be modified to
1161   conform to the use of UTF8.
11623. We actually have three tests for UTF8 of increasing correctness
1163   (in the sense that the least correct will allow some sequences that
1164    are technically illegal UTF8).
1165   The tests are derived from the table at
1166     http://www.w3.org/2005/03/23-lex-U
1167   We include lexical definitions for all three, but use the second version.
11684. Single character constants enclosed in '...' cannot be
1169   utf-8, so we assume they are by default encoded using the 1-byte
1170   subset of utf-8. It turns out that this subset is in fact
1171   equivalent to US-Ascii (7-bit).
1172   We could use ISO-8859-1, but that conflicts with UTF-8 above value 127.
1173*/
1174
1175/* lex specification for tokens for ncgen */
1176
1177/* Fill value used by ncdump from version 2.4 and later.  Should match
1178   definition of FILL_STRING in ../ncdump/vardata.h */
1179
1180#include "ncgen.h"
1181#include "ncgeny.h"
1182
1183#define FILL_STRING "_"
1184#define XDR_INT32_MIN (-2147483647-1)
1185#define XDR_INT32_MAX 2147483647
1186#define XDR_INT64_MIN  (-9223372036854775807LL-1)
1187#define XDR_INT64_MAX  (9223372036854775807LL)
1188
1189#undef DEBUG
1190#ifdef DEBUG
1191static int MIN_BYTE = NC_MIN_BYTE;
1192static int MIN_SHORT = NC_MIN_SHORT;
1193static int MIN_INT = NC_MIN_INT;
1194static int MAX_BYTE = NC_MAX_BYTE;
1195static int MAX_SHORT = NC_MAX_SHORT;
1196static int MAX_INT = NC_MAX_INT;
1197static int MAX_UBYTE = NC_MAX_UBYTE;
1198static int MAX_USHORT = NC_MAX_USHORT;
1199static unsigned int MAX_UINT = NC_MAX_UINT;
1200
1201#undef NC_MIN_BYTE
1202#undef NC_MIN_SHORT
1203#undef NC_MIN_INT
1204#undef NC_MAX_BYTE
1205#undef NC_MAX_SHORT
1206#undef NC_MAX_INT
1207#undef NC_MAX_UBYTE
1208#undef NC_MAX_USHORT
1209#undef NC_MAX_UINT
1210
1211#define NC_MIN_BYTE MIN_BYTE
1212#define NC_MIN_SHORT MIN_SHORT
1213#define NC_MIN_INT MIN_INT
1214#define NC_MAX_BYTE MAX_BYTE
1215#define NC_MAX_SHORT MAX_SHORT
1216#define NC_MAX_INT MAX_INT
1217#define NC_MAX_UBYTE MAX_UBYTE
1218#define NC_MAX_USHORT MAX_USHORT
1219#define NC_MAX_UINT MAX_UINT
1220#endif
1221
1222#define TAGCHARS "BbSsLlUu"
1223
1224#define tstdecimal(ch) ((ch) >= '0' && (ch) <= '9')
1225
1226/*Mnemonics*/
1227#define ISIDENT 1
1228
1229/* Define a fake constant indicating that
1230   no tag was specified */
1231#define NC_NOTAG (-1)
1232
1233char errstr[100]; /* for short error messages */
1234
1235int lineno;              /* line number for error messages */
1236Bytebufferlextext;           /* name or string with escapes removed */
1237
1238#define YY_BREAK                /* defining as nothing eliminates unreachable
1239    statement warnings from flex output,
1240                                   but make sure every action ends with
1241                                   "return" or "break"! */
1242
1243int specialconstants; /* 1 if nan, nanf, infinity, etc is used */
1244double double_val;             /* last double value read */
1245float float_val;               /* last float value read */
1246long long int64_val;           /* last int64 value read */
1247int int32_val;                 /* last int32 value read */
1248short int16_val;               /* last short value read */
1249unsigned long long uint64_val; /* last int64 value read */
1250unsigned int uint32_val;       /* last int32 value read */
1251unsigned short uint16_val;     /* last short value read */
1252char char_val;                 /* last char value read */
1253signed char byte_val;                 /* last byte value read */
1254unsigned char ubyte_val;       /* last byte value read */
1255
1256static Symbolmakepath(char* text);
1257static int lexdebug(int);
1258static unsigned long long parseULL(char* text, int*);
1259static nc_type downconvert(unsigned long long uint64, int*, int, int);
1260static int tagmatch(nc_type nct, int tag);
1261static int nct2lexeme(nc_type nct);
1262static int collecttag(char* text, char** stagp);
1263
1264struct Specialtoken specials[] = {
1265{"_FillValue",_FILLVALUE,_FILLVALUE_FLAG},
1266{"_Format",_FORMAT,_FORMAT_FLAG},
1267{"_Storage",_STORAGE,_STORAGE_FLAG},
1268{"_ChunkSizes",_CHUNKSIZES,_CHUNKSIZES_FLAG},
1269{"_Fletcher32",_FLETCHER32,_FLETCHER32_FLAG},
1270{"_DeflateLevel",_DEFLATELEVEL,_DEFLATE_FLAG},
1271{"_Shuffle",_SHUFFLE,_SHUFFLE_FLAG},
1272{"_Endianness",_ENDIANNESS,_ENDIAN_FLAG},
1273{"_NoFill",_NOFILL,_NOFILL_FLAG},
1274{"_NCProperties",_NCPROPS,_NCPROPS_FLAG},
1275{"_IsNetcdf4",_ISNETCDF4,_ISNETCDF4_FLAG},
1276{"_SuperblockVersion",_SUPERBLOCK,_SUPERBLOCK_FLAG},
1277{NULL,0} /* null terminate */
1278};
1279
1280
1281
1282/* The most correct (validating) version of UTF8 character set
1283   (Taken from: http://www.w3.org/2005/03/23-lex-U)
1284
1285The lines of the expression cover the UTF8 characters as follows:
12861. non-overlong 2-byte
12872. excluding overlongs
12883. straight 3-byte
12894. excluding surrogates
12905. straight 3-byte
12916. planes 1-3
12927. planes 4-15
12938. plane 16
1294
1295UTF8   ([\xC2-\xDF][\x80-\xBF])                       \
1296     | (\xE0[\xA0-\xBF][\x80-\xBF])                   \
1297     | ([\xE1-\xEC][\x80-\xBF][\x80-\xBF])            \
1298     | (\xED[\x80-\x9F][\x80-\xBF])                   \
1299     | ([\xEE-\xEF][\x80-\xBF][\x80-\xBF])            \
1300     | (\xF0[\x90-\xBF][\x80-\xBF][\x80-\xBF])        \
1301     | ([\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]) \
1302     | (\xF4[\x80-\x8F][\x80-\xBF][\x80-\xBF])        \
1303
1304*/
1305/* Wish there was some way to ifdef lex files */
1306/*The most relaxed version of UTF8 (not used)
1307UTF8 ([\xC0-\xD6].)|([\xE0-\xEF]..)|([\xF0-\xF7]...)
1308*/
1309/*The partially relaxed version of UTF8, and the one used here */
1310/* The old definition of ID
1311ID ([A-Za-z_]|{UTF8})([A-Z.@#\[\]a-z_0-9+-]|{UTF8})*
1312*/
1313/* Don't permit control characters or '/' in names, but other special
1314   chars OK if escaped.  Note that to preserve backwards
1315   compatibility, none of the characters _.@+- should be escaped, as
1316   they were previously permitted in names without escaping.  */
1317/* New definition to conform to a subset of string.c */
1318/* Capture a datasetidentifier */
1319/* DATASETID ([a-zA-Z0-9!#$%&*:;<=>?/^|~_.@+-]|{UTF8})* */
1320/* Note: this definition of string will work for utf8 as well,
1321   although it is a very relaxed definition
1322*/
1323#line 1324 "ncgenl.c"
1324
1325#define INITIAL 0
1326#define ST_C_COMMENT 1
1327#define TEXT 2
1328
1329#ifndef YY_NO_UNISTD_H
1330/* Special case for "unistd.h", since it is non-ANSI. We include it way
1331 * down here because we want the user's section 1 to have been scanned first.
1332 * The user has a chance to override it with an option.
1333 */
1334#include <unistd.h>
1335#endif
1336
1337#ifndef YY_EXTRA_TYPE
1338#define YY_EXTRA_TYPE void *
1339#endif
1340
1341static int yy_init_globals (void );
1342
1343/* Accessor methods to globals.
1344   These are made visible to non-reentrant scanners for convenience. */
1345
1346int ncglex_destroy (void );
1347
1348int ncgget_debug (void );
1349
1350void ncgset_debug (int debug_flag  );
1351
1352YY_EXTRA_TYPE ncgget_extra (void );
1353
1354void ncgset_extra (YY_EXTRA_TYPE user_defined  );
1355
1356FILE *ncgget_in (void );
1357
1358void ncgset_in  (FILE * in_str  );
1359
1360FILE *ncgget_out (void );
1361
1362void ncgset_out  (FILE * out_str  );
1363
1364yy_size_t ncgget_leng (void );
1365
1366char *ncgget_text (void );
1367
1368int ncgget_lineno (void );
1369
1370void ncgset_lineno (int line_number  );
1371
1372/* Macros after this point can all be overridden by user definitions in
1373 * section 1.
1374 */
1375
1376#ifndef YY_SKIP_YYWRAP
1377#ifdef __cplusplus
1378extern "C" int ncgwrap (void );
1379#else
1380extern int ncgwrap (void );
1381#endif
1382#endif
1383
1384    static void yyunput (int c,char *buf_ptr  );
1385
1386#ifndef yytext_ptr
1387static void yy_flex_strncpy (char *,yyconst char *,int );
1388#endif
1389
1390#ifdef YY_NEED_STRLEN
1391static int yy_flex_strlen (yyconst char * );
1392#endif
1393
1394#ifndef YY_NO_INPUT
1395
1396#ifdef __cplusplus
1397static int yyinput (void );
1398#else
1399static int input (void );
1400#endif
1401
1402#endif
1403
1404/* Amount of stuff to slurp up with each read. */
1405#ifndef YY_READ_BUF_SIZE
1406#define YY_READ_BUF_SIZE 8192
1407#endif
1408
1409/* Copy whatever the last rule matched to the standard output. */
1410#ifndef ECHO
1411/* This used to be an fputs(), but since the string might contain NUL's,
1412 * we now use fwrite().
1413 */
1414#define ECHO fwrite( ncgtextncgleng, 1, ncgout )
1415#endif
1416
1417/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1418 * is returned in "result".
1419 */
1420#ifndef YY_INPUT
1421#define YY_INPUT(buf,result,max_size) \
1422 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1423 { \
1424 int c = '*'; \
1425 yy_size_t n; \
1426 for ( n = 0; n < max_size && \
1427      (c = getc( ncgin )) != EOF && c != '\n'; ++n ) \
1428 buf[n] = (char) c; \
1429 if ( c == '\n' ) \
1430 buf[n++] = (char) c; \
1431 if ( c == EOF && ferror( ncgin ) ) \
1432 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1433 result = n; \
1434 } \
1435 else \
1436 { \
1437 errno=0; \
1438 while ( (result = fread(buf, 1, max_sizencgin))==0 && ferror(ncgin)) \
1439 { \
1440 if( errno != EINTR) \
1441 { \
1442 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1443 break; \
1444 } \
1445 errno=0; \
1446 clearerr(ncgin); \
1447 } \
1448 }\
1449\
1450
1451#endif
1452
1453/* No semi-colon after return; correct usage is to write "yyterminate();" -
1454 * we don't want an extra ';' after the "return" because that will cause
1455 * some compilers to complain about unreachable statements.
1456 */
1457#ifndef yyterminate
1458#define yyterminate() return YY_NULL
1459#endif
1460
1461/* Number of entries by which start-condition stack grows. */
1462#ifndef YY_START_STACK_INCR
1463#define YY_START_STACK_INCR 25
1464#endif
1465
1466/* Report a fatal error. */
1467#ifndef YY_FATAL_ERROR
1468#define YY_FATAL_ERROR(msgyy_fatal_errormsg )
1469#endif
1470
1471/* end tables serialization structures and prototypes */
1472
1473/* Default declaration of generated scanner - a define so the user can
1474 * easily add parameters.
1475 */
1476#ifndef YY_DECL
1477#define YY_DECL_IS_OURS 1
1478
1479extern int ncglex (void);
1480
1481#define YY_DECL int ncglex (void)
1482#endif /* !YY_DECL */
1483
1484/* Code executed at the beginning of each rule, after ncgtext and ncgleng
1485 * have been set up.
1486 */
1487#ifndef YY_USER_ACTION
1488#define YY_USER_ACTION
1489#endif
1490
1491/* Code executed at the end of each rule. */
1492#ifndef YY_BREAK
1493#define YY_BREAK break;
1494#endif
1495
1496#define YY_RULE_SETUP \
1497 YY_USER_ACTION
1498
1499/** The main scanner function which does all the work.
1500 */
1501YY_DECL
1502{
1503 register yy_state_type yy_current_state;
1504 register char *yy_cp, *yy_bp;
1505 register int yy_act;
1506
1507#line 217 "ncgen.l"
1508
1509#line 1510 "ncgenl.c"
1510
1511 if ( !(yy_init) )
1512 {
1513 (yy_init) = 1;
1514
1515#ifdef YY_USER_INIT
1516 YY_USER_INIT;
1517#endif
1518
1519 if ( ! (yy_start) )
1520 (yy_start) = 1; /* first start state */
1521
1522 if ( ! ncgin )
1523 ncgin = stdin;
1524
1525 if ( ! ncgout )
1526 ncgout = stdout;
1527
1528 if ( ! YY_CURRENT_BUFFER ) {
1529 ncgensure_buffer_stack ();
1530 YY_CURRENT_BUFFER_LVALUE =
1531 ncg_create_buffer(ncgin,YY_BUF_SIZE );
1532 }
1533
1534 ncg_load_buffer_state( );
1535 }
1536
1537 while ( 1 ) /* loops until end-of-file is reached */
1538 {
1539 yy_cp = (yy_c_buf_p);
1540
1541 /* Support of ncgtext. */
1542 *yy_cp = (yy_hold_char);
1543
1544 /* yy_bp points to the position in yy_ch_buf of the start of
1545  * the current run.
1546  */
1547 yy_bp = yy_cp;
1548
1549 yy_current_state = (yy_start);
1550yy_match:
1551 do
1552 {
1553 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1554 if ( yy_accept[yy_current_state] )
1555 {
1556 (yy_last_accepting_state) = yy_current_state;
1557 (yy_last_accepting_cpos) = yy_cp;
1558 }
1559 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1560 {
1561 yy_current_state = (int) yy_def[yy_current_state];
1562 if ( yy_current_state >= 417 )
1563 yy_c = yy_meta[(unsigned int) yy_c];
1564 }
1565 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1566 ++yy_cp;
1567 }
1568 while ( yy_base[yy_current_state] != 2347 );
1569
1570yy_find_action:
1571 yy_act = yy_accept[yy_current_state];
1572 if ( yy_act == 0 )
1573 { /* have to back up */
1574 yy_cp = (yy_last_accepting_cpos);
1575 yy_current_state = (yy_last_accepting_state);
1576 yy_act = yy_accept[yy_current_state];
1577 }
1578
1579 YY_DO_BEFORE_ACTION;
1580
1581do_action: /* This label is used only to access EOF actions. */
1582
1583 switch ( yy_act )
1584 { /* beginning of action switch */
1585 case 0: /* must back up */
1586 /* undo the effects of YY_DO_BEFORE_ACTION */
1587 *yy_cp = (yy_hold_char);
1588 yy_cp = (yy_last_accepting_cpos);
1589 yy_current_state = (yy_last_accepting_state);
1590 goto yy_find_action;
1591
1592case 1:
1593YY_RULE_SETUP
1594#line 218 "ncgen.l"
1595{ /* whitespace */
1596   break;
1597 }
1598 YY_BREAK
1599case 2:
1600YY_RULE_SETUP
1601#line 222 "ncgen.l"
1602{ /* comment */
1603                          break;
1604                        }
1605 YY_BREAK
1606case 3:
1607/* rule 3 can match eol */
1608YY_RULE_SETUP
1609#line 226 "ncgen.l"
1610{int len;
1611  /* In netcdf4, this will be used in a variety
1612                            of places, so only remove escapes */
1613/*
1614if(ncgleng > MAXTRST) {
1615yyerror("string too long, truncated\n");
1616ncgtext[MAXTRST-1] = '\0';
1617}
1618*/
1619         /* FIX: Assumes unescape also does normalization */
1620 bbSetalloc(lextext,ncgleng+1); /*+1 for nul */
1621 /* Adjust length */
1622         bbSetlength(lextext,ncgleng-2); /*-2 for quotes */
1623 len = unescape(bbContents(lextext),
1624                                       (char *)ncgtext+1,ncgleng-2,!ISIDENT);
1625 if(len < 0) {
1626     sprintf(errstr,"Illegal character: %s",ncgtext);
1627     yyerror(errstr);
1628 }
1629 bbSetlength(lextext,len);
1630 bbNull(lextext);
1631   return lexdebug(TERMSTRING);
1632         }
1633 YY_BREAK
1634case 4:
1635YY_RULE_SETUP
1636#line 250 "ncgen.l"
1637{ /* drop leading 0x; pad to even number of chars */
1638 char* p = ncgtext+2;
1639 int len = ncgleng - 2;
1640 bbClear(lextext);
1641         bbAppendn(lextext,p,len);
1642         if((len % 2) == 1) bbAppend(lextext,'0');
1643 bbNull(lextext);
1644 /* convert all chars to lower case */
1645 for(p=bbContents(lextext);(int)*p;p++) *p = tolower(*p);
1646 return lexdebug(OPAQUESTRING);
1647 }
1648 YY_BREAK
1649case 5:
1650YY_RULE_SETUP
1651#line 262 "ncgen.l"
1652{return lexdebug(COMPOUND);}
1653 YY_BREAK
1654case 6:
1655YY_RULE_SETUP
1656#line 263 "ncgen.l"
1657{return lexdebug(ENUM);}
1658 YY_BREAK
1659case 7:
1660YY_RULE_SETUP
1661#line 264 "ncgen.l"
1662{return lexdebug(OPAQUE);}
1663 YY_BREAK
1664case 8:
1665YY_RULE_SETUP
1666#line 266 "ncgen.l"
1667{return lexdebug(FLOAT_K);}
1668 YY_BREAK
1669case 9:
1670YY_RULE_SETUP
1671#line 267 "ncgen.l"
1672{return lexdebug(CHAR_K);}
1673 YY_BREAK
1674case 10:
1675YY_RULE_SETUP
1676#line 268 "ncgen.l"
1677{return lexdebug(BYTE_K);}
1678 YY_BREAK
1679case 11:
1680YY_RULE_SETUP
1681#line 269 "ncgen.l"
1682{return lexdebug(UBYTE_K);}
1683 YY_BREAK
1684case 12:
1685YY_RULE_SETUP
1686#line 270 "ncgen.l"
1687{return lexdebug(SHORT_K);}
1688 YY_BREAK
1689case 13:
1690YY_RULE_SETUP
1691#line 271 "ncgen.l"
1692{return lexdebug(USHORT_K);}
1693 YY_BREAK
1694case 14:
1695YY_RULE_SETUP
1696#line 272 "ncgen.l"
1697{return lexdebug(INT_K);}
1698 YY_BREAK
1699case 15:
1700YY_RULE_SETUP
1701#line 273 "ncgen.l"
1702{return lexdebug(UINT_K);}
1703 YY_BREAK
1704case 16:
1705YY_RULE_SETUP
1706#line 274 "ncgen.l"
1707{return lexdebug(INT64_K);}
1708 YY_BREAK
1709case 17:
1710YY_RULE_SETUP
1711#line 275 "ncgen.l"
1712{return lexdebug(UINT64_K);}
1713 YY_BREAK
1714case 18:
1715YY_RULE_SETUP
1716#line 276 "ncgen.l"
1717{return lexdebug(DOUBLE_K);}
1718 YY_BREAK
1719case 19:
1720YY_RULE_SETUP
1721#line 277 "ncgen.l"
1722{int32_val = -1;
1723  return lexdebug(NC_UNLIMITED_K);}
1724 YY_BREAK
1725case 20:
1726YY_RULE_SETUP
1727#line 280 "ncgen.l"
1728{return lexdebug(TYPES);}
1729 YY_BREAK
1730case 21:
1731YY_RULE_SETUP
1732#line 281 "ncgen.l"
1733{return lexdebug(DIMENSIONS);}
1734 YY_BREAK
1735case 22:
1736YY_RULE_SETUP
1737#line 282 "ncgen.l"
1738{return lexdebug(VARIABLES);}
1739 YY_BREAK
1740case 23:
1741YY_RULE_SETUP
1742#line 283 "ncgen.l"
1743{return lexdebug(DATA);}
1744 YY_BREAK
1745case 24:
1746YY_RULE_SETUP
1747#line 284 "ncgen.l"
1748{return lexdebug(GROUP);}
1749 YY_BREAK
1750case 25:
1751YY_RULE_SETUP
1752#line 286 "ncgen.l"
1753{BEGIN(TEXT);return lexdebug(NETCDF);}
1754 YY_BREAK
1755case 26:
1756YY_RULE_SETUP
1757#line 288 "ncgen.l"
1758{ /* missing value (pre-2.4 backward compatibility) */
1759                if (ncgtext[0] == '-') {
1760     double_val = NEGNC_INFINITE;
1761                } else {
1762     double_val = NC_INFINITE;
1763                }
1764 specialconstants = 1;
1765 return lexdebug(DOUBLE_CONST);
1766 }
1767 YY_BREAK
1768case 27:
1769YY_RULE_SETUP
1770#line 297 "ncgen.l"
1771{ /* missing value (pre-2.4 backward compatibility) */
1772 double_val = NAN;
1773 specialconstants = 1;
1774 return lexdebug(DOUBLE_CONST);
1775 }
1776 YY_BREAK
1777case 28:
1778YY_RULE_SETUP
1779#line 303 "ncgen.l"
1780{/* missing value (pre-2.4 backward compatibility)*/
1781                if (ncgtext[0] == '-') {
1782     float_val = NEGNC_INFINITEF;
1783                } else {
1784     float_val = NC_INFINITEF;
1785                }
1786 specialconstants = 1;
1787 return lexdebug(FLOAT_CONST);
1788 }
1789 YY_BREAK
1790case 29:
1791YY_RULE_SETUP
1792#line 312 "ncgen.l"
1793{ /* missing value (pre-2.4 backward compatibility) */
1794 float_val = NANF;
1795 specialconstants = 1;
1796 return lexdebug(FLOAT_CONST);
1797 }
1798 YY_BREAK
1799case 30:
1800YY_RULE_SETUP
1801#line 318 "ncgen.l"
1802{
1803#ifdef USE_NETCDF4
1804 if(l_flag == L_C || l_flag == L_BINARY)
1805     return lexdebug(NIL);
1806 yyerror("NIL only allowed for netcdf-4 and for -lc or -lb");
1807#else
1808 yyerror("NIL only allowed for netcdf-4 and for -lc or -lb");
1809#endif
1810 }
1811 YY_BREAK
1812case 31:
1813YY_RULE_SETUP
1814#line 328 "ncgen.l"
1815{
1816 bbClear(lextext);
1817 bbAppendn(lextext,(char*)ncgtext,ncgleng+1); /* include null */
1818         bbNull(lextext);
1819 yylval.sym = makepath(bbContents(lextext));
1820 return lexdebug(PATH);
1821 }
1822 YY_BREAK
1823case 32:
1824YY_RULE_SETUP
1825#line 337 "ncgen.l"
1826{struct Specialtokenst;
1827 bbClear(lextext);
1828 bbAppendn(lextext,(char*)ncgtext,ncgleng+1); /* include null */
1829 bbNull(lextext);
1830 for(st=specials;st->name;st++) {
1831     if(strcmp(bbContents(lextext),st->name)==0) {return lexdebug(st->token);}
1832 }
1833 return 0;
1834 }
1835 YY_BREAK
1836case 33:
1837/* rule 33 can match eol */
1838YY_RULE_SETUP
1839#line 347 "ncgen.l"
1840{
1841     int c;
1842     char* p; char* q;
1843     /* copy the trimmed name */
1844     bbClear(lextext);
1845     bbAppendn(lextext,(char*)ncgtext,ncgleng+1); /* include null */
1846     bbNull(lextext);
1847     p = bbContents(lextext);
1848     q = p;
1849     while((c=*p++)) {if(c > ' ') *q++ = c;}
1850     *q = '\0';
1851     datasetname = bbDup(lextext);
1852     BEGIN(INITIAL);
1853     return lexdebug(DATASETID);
1854 }
1855 YY_BREAK
1856case 34:
1857YY_RULE_SETUP
1858#line 363 "ncgen.l"
1859{ char* id; int len;
1860     bbClear(lextext);
1861     bbAppendn(lextext,(char*)ncgtext,ncgleng+1); /* include null */
1862     bbNull(lextext);
1863     id = bbContents(lextext);
1864     len = unescape(id,id,bbLength(lextext),ISIDENT);
1865     bbSetlength(lextext,len);
1866     if (STREQ(idFILL_STRING)) return lexdebug(FILLMARKER);
1867     yylval.sym = install(id);
1868     return lexdebug(IDENT);
1869 }
1870 YY_BREAK
1871case 35:
1872YY_RULE_SETUP
1873#line 375 "ncgen.l"
1874{
1875 /*
1876   We need to try to see what size of integer ((u)int).
1877   Technically, the user should specify, but...
1878   If out of any integer range, then complain
1879 */
1880     int slen = strlen(ncgtext);
1881     char* stag = NULL;
1882     int tag = NC_NAT;
1883     int signchar = 0;
1884     int isneg = 0;
1885     int c = ncgtext[0];
1886     int fail = 0;
1887     nc_type nct = 0;
1888     char* pos = NULL;
1889     int hasU = 0;
1890
1891     /* capture the tag string */
1892     tag = collecttag(ncgtext,&stag);
1893     if(tag == NC_NAT) {
1894 sprintf(errstr,"Illegal integer suffix: %s",stag);
1895 yyerror(errstr);
1896 goto done;
1897     }
1898     /* drop the tag from the input text */
1899     ncgtext[slen - strlen(stag)] = '\0';
1900     hasU = isuinttype(tag);
1901     if(!tstdecimal(c)) {
1902 pos = ncgtext+1;
1903 isneg = (c == '-');
1904     } else
1905         pos = ncgtext;
1906     if(isneg && hasU) {
1907 sprintf(errstr,"Unsigned integer cannot be signed: %s",ncgtext);
1908 yyerror(errstr);
1909 goto done;
1910     }
1911     uint64_val = parseULL(pos,&fail);
1912     if(fail) {
1913 sprintf(errstr,"integer constant out of range: %s",ncgtext);
1914 yyerror(errstr);
1915 goto done;
1916     }
1917     /* Down convert to smallest possible range */
1918     nct = downconvert(uint64_val,&tag,isneg,hasU);
1919     switch (k_flag) {
1920     case NC_FORMAT_64BIT_DATA:
1921     case NC_FORMAT_NETCDF4:
1922     return lexdebug(nct2lexeme(nct));
1923     case NC_FORMAT_CLASSIC:
1924     case NC_FORMAT_64BIT_OFFSET:
1925     case NC_FORMAT_NETCDF4_CLASSIC:
1926     if(nct > NC_INT) {
1927 sprintf(errstr,"Illegal integer constant for classic format: %s",ncgtext);
1928 yyerror(errstr);
1929 goto done;
1930     }
1931     }
1932
1933     if(!tagmatch(nct,tag))  {
1934 semwarn(lineno,"Warning: Integer out of range for tag: %s; tag treated as changed.",ncgtext);
1935     }
1936     return lexdebug(nct2lexeme(nct));
1937done: return 0;
1938     }
1939 YY_BREAK
1940case 36:
1941YY_RULE_SETUP
1942#line 441 "ncgen.l"
1943{
1944 int c;
1945 int token = 0;
1946 int slen = strlen(ncgtext);
1947 char* stag = NULL;
1948         int tag = NC_NAT;
1949 char* hex = ncgtext+2; /* point to first true hex digit */
1950 int xlen = (slen - 3);  /* true hex length */
1951
1952 ncgtext[slen-1] = '\0';
1953         /* capture the tag string */
1954 tag = collecttag(ncgtext,&stag);
1955 if(tag == NC_NAT) {
1956     sprintf(errstr,"Illegal integer suffix: %s",stag);
1957     yyerror(errstr);
1958     goto done;
1959 }
1960 ncgtext[slen - strlen(stag)] = '\0';
1961         if(xlen > 16) { /* truncate hi order digits */
1962     hex += (xlen - 16);
1963 }
1964 /* convert to an unsigned long long */
1965 uint64_val = 0;
1966 while((c=*hex++)) {
1967     unsigned int hexdigit = (c <= '9'?(c-'0'):(c-'a')+0xa);
1968     uint64_val = ((uint64_val << 4) | hexdigit);
1969 }
1970 switch (tag) {
1971 case NC_USHORT:
1972     uint16_val = (unsigned short)uint64_val;
1973     token = USHORT_CONST;
1974     break;
1975 case NC_UINT:
1976     token = UINT_CONST;
1977     break;
1978 case NC_UINT64:
1979     token = UINT64_CONST;
1980     break;
1981 default: /* should never happen */
1982     if (sscanf((char*)ncgtext, "%i", &uint32_val) != 1) {
1983         sprintf(errstr,"bad unsigned int constant: %s",(char*)ncgtext);
1984         yyerror(errstr);
1985     }
1986     token = UINT_CONST;
1987 }
1988 return lexdebug(token);
1989     }
1990 YY_BREAK
1991case 37:
1992YY_RULE_SETUP
1993#line 488 "ncgen.l"
1994{
1995 if (sscanf((char*)ncgtext, "%le", &double_val) != 1) {
1996     sprintf(errstr,"bad long or double constant: %s",(char*)ncgtext);
1997     yyerror(errstr);
1998 }
1999                return lexdebug(DOUBLE_CONST);
2000                }
2001 YY_BREAK
2002case 38:
2003YY_RULE_SETUP
2004#line 495 "ncgen.l"
2005{
2006 if (sscanf((char*)ncgtext, "%e", &float_val) != 1) {
2007     sprintf(errstr,"bad float constant: %s",(char*)ncgtext);
2008     yyerror(errstr);
2009 }
2010                return lexdebug(FLOAT_CONST);
2011                }
2012 YY_BREAK
2013case 39:
2014/* rule 39 can match eol */
2015YY_RULE_SETUP
2016#line 502 "ncgen.l"
2017{
2018         (void) sscanf((char*)&ncgtext[1],"%c",&byte_val);
2019 return lexdebug(BYTE_CONST);
2020                }
2021 YY_BREAK
2022case 40:
2023YY_RULE_SETUP
2024#line 506 "ncgen.l"
2025{
2026 int oct = unescapeoct(&ncgtext[2]);
2027 if(oct < 0) {
2028     sprintf(errstr,"bad octal character constant: %s",(char*)ncgtext);
2029     yyerror(errstr);
2030 }
2031         byte_val = (unsigned int)oct;
2032 return lexdebug(BYTE_CONST);
2033                }
2034 YY_BREAK
2035case 41:
2036YY_RULE_SETUP
2037#line 515 "ncgen.l"
2038{
2039 int hex = unescapehex(&ncgtext[3]);
2040 if(byte_val < 0) {
2041     sprintf(errstr,"bad hex character constant: %s",(char*)ncgtext);
2042     yyerror(errstr);
2043 }
2044 byte_val = (unsigned int)hex;
2045 return lexdebug(BYTE_CONST);
2046                }
2047 YY_BREAK
2048case 42:
2049YY_RULE_SETUP
2050#line 524 "ncgen.l"
2051{
2052        switch ((char)ncgtext[2]) {
2053           case 'a': byte_val = '\007'; break; /* not everyone under-
2054        * stands '\a' yet */
2055                case 'b': byte_val = '\b'; break;
2056   case 'f': byte_val = '\f'; break;
2057   case 'n': byte_val = '\n'; break;
2058   case 'r': byte_val = '\r'; break;
2059   case 't': byte_val = '\t'; break;
2060   case 'v': byte_val = '\v'; break;
2061   case '\\': byte_val = '\\'; break;
2062   case '?': byte_val = '\177'; break;
2063   case '\'': byte_val = '\''; break;
2064   default: byte_val = (char)ncgtext[2];
2065            }
2066 return lexdebug(BYTE_CONST);
2067                }
2068 YY_BREAK
2069case 43:
2070/* rule 43 can match eol */
2071YY_RULE_SETUP
2072#line 542 "ncgen.l"
2073{
2074 lineno++ ;
2075                break;
2076 }
2077 YY_BREAK
2078case 44:
2079YY_RULE_SETUP
2080#line 547 "ncgen.l"
2081{/*initial*/
2082     BEGIN(ST_C_COMMENT);
2083     break;
2084 }
2085 YY_BREAK
2086case 45:
2087/* rule 45 can match eol */
2088YY_RULE_SETUP
2089#line 552 "ncgen.l"
2090{/* continuation */
2091      break;
2092 }
2093 YY_BREAK
2094case 46:
2095YY_RULE_SETUP
2096#line 556 "ncgen.l"
2097{/* final */
2098     BEGIN(INITIAL);
2099     break;
2100 }
2101 YY_BREAK
2102case YY_STATE_EOF(ST_C_COMMENT):
2103#line 561 "ncgen.l"
2104{/* final, error */
2105     fprintf(stderr,"unterminated /**/ comment");
2106     BEGIN(INITIAL);
2107     break;
2108 }
2109 YY_BREAK
2110case 47:
2111YY_RULE_SETUP
2112#line 567 "ncgen.l"
2113{/* Note: this next rule will not work for UTF8 characters */
2114 return lexdebug(ncgtext[0]) ;
2115 }
2116 YY_BREAK
2117case 48:
2118YY_RULE_SETUP
2119#line 570 "ncgen.l"
2120ECHO;
2121 YY_BREAK
2122#line 2123 "ncgenl.c"
2123case YY_STATE_EOF(INITIAL):
2124case YY_STATE_EOF(TEXT):
2125 yyterminate();
2126
2127 case YY_END_OF_BUFFER:
2128 {
2129 /* Amount of text matched not including the EOB char. */
2130 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2131
2132 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2133 *yy_cp = (yy_hold_char);
2134 YY_RESTORE_YY_MORE_OFFSET
2135
2136 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2137 {
2138 /* We're scanning a new file or input source.  It's
2139  * possible that this happened because the user
2140  * just pointed ncgin at a new source and called
2141  * ncglex().  If so, then we have to assure
2142  * consistency between YY_CURRENT_BUFFER and our
2143  * globals.  Here is the right place to do so, because
2144  * this is the first action (other than possibly a
2145  * back-up) that will match for the new input source.
2146  */
2147 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2148 YY_CURRENT_BUFFER_LVALUE->yy_input_file = ncgin;
2149 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2150 }
2151
2152 /* Note that here we test for yy_c_buf_p "<=" to the position
2153  * of the first EOB in the buffer, since yy_c_buf_p will
2154  * already have been incremented past the NUL character
2155  * (since all states make transitions on EOB to the
2156  * end-of-buffer state).  Contrast this with the test
2157  * in input().
2158  */
2159 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2160 { /* This was really a NUL. */
2161 yy_state_type yy_next_state;
2162
2163 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2164
2165 yy_current_state = yy_get_previous_state(  );
2166
2167 /* Okay, we're now positioned to make the NUL
2168  * transition.  We couldn't have
2169  * yy_get_previous_state() go ahead and do it
2170  * for us because it doesn't know how to deal
2171  * with the possibility of jamming (and we don't
2172  * want to build jamming into it because then it
2173  * will run more slowly).
2174  */
2175
2176 yy_next_state = yy_try_NUL_transyy_current_state );
2177
2178 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2179
2180 if ( yy_next_state )
2181 {
2182 /* Consume the NUL. */
2183 yy_cp = ++(yy_c_buf_p);
2184 yy_current_state = yy_next_state;
2185 goto yy_match;
2186 }
2187
2188 else
2189 {
2190 yy_cp = (yy_c_buf_p);
2191 goto yy_find_action;
2192 }
2193 }
2194
2195 else switch ( yy_get_next_buffer(  ) )
2196 {
2197 case EOB_ACT_END_OF_FILE:
2198 {
2199 (yy_did_buffer_switch_on_eof) = 0;
2200
2201 if ( ncgwrap( ) )
2202 {
2203 /* Note: because we've taken care in
2204  * yy_get_next_buffer() to have set up
2205  * ncgtext, we can now set up
2206  * yy_c_buf_p so that if some total
2207  * hoser (like flex itself) wants to
2208  * call the scanner after we return the
2209  * YY_NULL, it'll still work - another
2210  * YY_NULL will get returned.
2211  */
2212 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2213
2214 yy_act = YY_STATE_EOF(YY_START);
2215 goto do_action;
2216 }
2217
2218 else
2219 {
2220 if ( ! (yy_did_buffer_switch_on_eof) )
2221 YY_NEW_FILE;
2222 }
2223 break;
2224 }
2225
2226 case EOB_ACT_CONTINUE_SCAN:
2227 (yy_c_buf_p) =
2228 (yytext_ptr) + yy_amount_of_matched_text;
2229
2230 yy_current_state = yy_get_previous_state(  );
2231
2232 yy_cp = (yy_c_buf_p);
2233 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2234 goto yy_match;
2235
2236 case EOB_ACT_LAST_MATCH:
2237 (yy_c_buf_p) =
2238 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2239
2240 yy_current_state = yy_get_previous_state(  );
2241
2242 yy_cp = (yy_c_buf_p);
2243 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2244 goto yy_find_action;
2245 }
2246 break;
2247 }
2248
2249 default:
2250 YY_FATAL_ERROR(
2251 "fatal flex scanner internal error--no action found" );
2252 } /* end of action switch */
2253 } /* end of scanning one token */
2254} /* end of ncglex */
2255
2256/* yy_get_next_buffer - try to read in a new buffer
2257 *
2258 * Returns a code representing an action:
2259 * EOB_ACT_LAST_MATCH -
2260 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2261 * EOB_ACT_END_OF_FILE - end of file
2262 */
2263static int yy_get_next_buffer (void)
2264{
2265     register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2266 register char *source = (yytext_ptr);
2267 register int number_to_movei;
2268 int ret_val;
2269
2270 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2271 YY_FATAL_ERROR(
2272 "fatal flex scanner internal error--end of buffer missed" );
2273
2274 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2275 { /* Don't try to fill the buffer, so this is an EOF. */
2276 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2277 {
2278 /* We matched a single character, the EOB, so
2279  * treat this as a final EOF.
2280  */
2281 return EOB_ACT_END_OF_FILE;
2282 }
2283
2284 else
2285 {
2286 /* We matched some text prior to the EOB, first
2287  * process it.
2288  */
2289 return EOB_ACT_LAST_MATCH;
2290 }
2291 }
2292
2293 /* Try to read more data. */
2294
2295 /* First move last chars to start of buffer. */
2296 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2297
2298 for ( i = 0; i < number_to_move; ++i )
2299 *(dest++) = *(source++);
2300
2301 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2302 /* don't do the read, it's not guaranteed to return an EOF,
2303  * just force an EOF
2304  */
2305 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2306
2307 else
2308 {
2309 yy_size_t num_to_read =
2310 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2311
2312 while ( num_to_read <= 0 )
2313 { /* Not enough room in the buffer - grow it. */
2314
2315 /* just a shorter name for the current buffer */
2316 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
2317
2318 int yy_c_buf_p_offset =
2319 (int) ((yy_c_buf_p) - b->yy_ch_buf);
2320
2321 if ( b->yy_is_our_buffer )
2322 {
2323 yy_size_t new_size = b->yy_buf_size * 2;
2324
2325 if ( new_size <= 0 )
2326 b->yy_buf_size += b->yy_buf_size / 8;
2327 else
2328 b->yy_buf_size *= 2;
2329
2330 b->yy_ch_buf = (char *)
2331 /* Include room in for 2 EOB chars. */
2332 ncgrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
2333 }
2334 else
2335 /* Can't grow it, we don't own it. */
2336 b->yy_ch_buf = 0;
2337
2338 if ( ! b->yy_ch_buf )
2339 YY_FATAL_ERROR(
2340 "fatal error - scanner input buffer overflow" );
2341
2342 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2343
2344 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2345 number_to_move - 1;
2346
2347 }
2348
2349 if ( num_to_read > YY_READ_BUF_SIZE )
2350 num_to_read = YY_READ_BUF_SIZE;
2351
2352 /* Read in more data. */
2353 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2354 (yy_n_chars), num_to_read );
2355
2356 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2357 }
2358
2359 if ( (yy_n_chars) == 0 )
2360 {
2361 if ( number_to_move == YY_MORE_ADJ )
2362 {
2363 ret_val = EOB_ACT_END_OF_FILE;
2364 ncgrestart(ncgin  );
2365 }
2366
2367 else
2368 {
2369 ret_val = EOB_ACT_LAST_MATCH;
2370 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2371 YY_BUFFER_EOF_PENDING;
2372 }
2373 }
2374
2375 else
2376 ret_val = EOB_ACT_CONTINUE_SCAN;
2377
2378 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2379 /* Extend the array by 50%, plus the number we really need. */
2380 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2381 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) ncgrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
2382 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2383 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2384 }
2385
2386 (yy_n_chars) += number_to_move;
2387 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2388 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2389
2390 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2391
2392 return ret_val;
2393}
2394
2395/* yy_get_previous_state - get the state just before the EOB char was reached */
2396
2397    static yy_state_type yy_get_previous_state (void)
2398{
2399 register yy_state_type yy_current_state;
2400 register char *yy_cp;
2401
2402 yy_current_state = (yy_start);
2403
2404 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJyy_cp < (yy_c_buf_p); ++yy_cp )
2405 {
2406 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2407 if ( yy_accept[yy_current_state] )
2408 {
2409 (yy_last_accepting_state) = yy_current_state;
2410 (yy_last_accepting_cpos) = yy_cp;
2411 }
2412 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2413 {
2414 yy_current_state = (int) yy_def[yy_current_state];
2415 if ( yy_current_state >= 417 )
2416 yy_c = yy_meta[(unsigned int) yy_c];
2417 }
2418 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2419 }
2420
2421 return yy_current_state;
2422}
2423
2424/* yy_try_NUL_trans - try to make a transition on the NUL character
2425 *
2426 * synopsis
2427 * next_state = yy_try_NUL_trans( current_state );
2428 */
2429    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
2430{
2431 register int yy_is_jam;
2432     register char *yy_cp = (yy_c_buf_p);
2433
2434 register YY_CHAR yy_c = 1;
2435 if ( yy_accept[yy_current_state] )
2436 {
2437 (yy_last_accepting_state) = yy_current_state;
2438 (yy_last_accepting_cpos) = yy_cp;
2439 }
2440 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2441 {
2442 yy_current_state = (int) yy_def[yy_current_state];
2443 if ( yy_current_state >= 417 )
2444 yy_c = yy_meta[(unsigned int) yy_c];
2445 }
2446 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2447 yy_is_jam = (yy_current_state == 416);
2448
2449 return yy_is_jam ? 0 : yy_current_state;
2450}
2451
2452    static void yyunput (int c, register char * yy_bp )
2453{
2454 register char *yy_cp;
2455
2456    yy_cp = (yy_c_buf_p);
2457
2458 /* undo effects of setting up ncgtext */
2459 *yy_cp = (yy_hold_char);
2460
2461 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2462 { /* need to shift things up to make room */
2463 /* +2 for EOB chars. */
2464 register yy_size_t number_to_move = (yy_n_chars) + 2;
2465 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2466 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2467 register char *source =
2468 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2469
2470 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2471 *--dest = *--source;
2472
2473 yy_cp += (int) (dest - source);
2474 yy_bp += (int) (dest - source);
2475 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2476 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2477
2478 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2479 YY_FATAL_ERROR( "flex scanner push-back overflow" );
2480 }
2481
2482 *--yy_cp = (char) c;
2483
2484 (yytext_ptr) = yy_bp;
2485 (yy_hold_char) = *yy_cp;
2486 (yy_c_buf_p) = yy_cp;
2487}
2488
2489#ifndef YY_NO_INPUT
2490#ifdef __cplusplus
2491    static int yyinput (void)
2492#else
2493    static int input  (void)
2494#endif
2495
2496{
2497 int c;
2498
2499 *(yy_c_buf_p) = (yy_hold_char);
2500
2501 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2502 {
2503 /* yy_c_buf_p now points to the character we want to return.
2504  * If this occurs *before* the EOB characters, then it's a
2505  * valid NUL; if not, then we've hit the end of the buffer.
2506  */
2507 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2508 /* This was really a NUL. */
2509 *(yy_c_buf_p) = '\0';
2510
2511 else
2512 { /* need more input */
2513 yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
2514 ++(yy_c_buf_p);
2515
2516 switch ( yy_get_next_buffer(  ) )
2517 {
2518 case EOB_ACT_LAST_MATCH:
2519 /* This happens because yy_g_n_b()
2520  * sees that we've accumulated a
2521  * token and flags that we need to
2522  * try matching the token before
2523  * proceeding.  But for input(),
2524  * there's no matching to consider.
2525  * So convert the EOB_ACT_LAST_MATCH
2526  * to EOB_ACT_END_OF_FILE.
2527  */
2528
2529 /* Reset buffer status. */
2530 ncgrestart(ncgin );
2531
2532 /*FALLTHROUGH*/
2533
2534 case EOB_ACT_END_OF_FILE:
2535 {
2536 if ( ncgwrap( ) )
2537 return 0;
2538
2539 if ( ! (yy_did_buffer_switch_on_eof) )
2540 YY_NEW_FILE;
2541#ifdef __cplusplus
2542 return yyinput();
2543#else
2544 return input();
2545#endif
2546 }
2547
2548 case EOB_ACT_CONTINUE_SCAN:
2549 (yy_c_buf_p) = (yytext_ptr) + offset;
2550 break;
2551 }
2552 }
2553 }
2554
2555 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
2556 *(yy_c_buf_p) = '\0'; /* preserve ncgtext */
2557 (yy_hold_char) = *++(yy_c_buf_p);
2558
2559 return c;
2560}
2561#endif /* ifndef YY_NO_INPUT */
2562
2563/** Immediately switch to a different input stream.
2564 * @param input_file A readable stream.
2565 *
2566 * @note This function does not reset the start condition to @c INITIAL .
2567 */
2568    void ncgrestart  (FILE * input_file )
2569{
2570
2571 if ( ! YY_CURRENT_BUFFER ){
2572        ncgensure_buffer_stack ();
2573 YY_CURRENT_BUFFER_LVALUE =
2574            ncg_create_buffer(ncgin,YY_BUF_SIZE );
2575 }
2576
2577 ncg_init_buffer(YY_CURRENT_BUFFER,input_file );
2578 ncg_load_buffer_state( );
2579}
2580
2581/** Switch to a different input buffer.
2582 * @param new_buffer The new input buffer.
2583 *
2584 */
2585    void ncg_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
2586{
2587
2588 /* TODO. We should be able to replace this entire function body
2589  * with
2590  * ncgpop_buffer_state();
2591  * ncgpush_buffer_state(new_buffer);
2592     */
2593 ncgensure_buffer_stack ();
2594 if ( YY_CURRENT_BUFFER == new_buffer )
2595 return;
2596
2597 if ( YY_CURRENT_BUFFER )
2598 {
2599 /* Flush out information for old buffer. */
2600 *(yy_c_buf_p) = (yy_hold_char);
2601 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2602 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2603 }
2604
2605 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2606 ncg_load_buffer_state( );
2607
2608 /* We don't actually know whether we did this switch during
2609  * EOF (ncgwrap()) processing, but the only time this flag
2610  * is looked at is after ncgwrap() is called, so it's safe
2611  * to go ahead and always set it.
2612  */
2613 (yy_did_buffer_switch_on_eof) = 1;
2614}
2615
2616static void ncg_load_buffer_state  (void)
2617{
2618     (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2619 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2620 ncgin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2621 (yy_hold_char) = *(yy_c_buf_p);
2622}
2623
2624/** Allocate and initialize an input buffer state.
2625 * @param file A readable stream.
2626 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2627 *
2628 * @return the allocated buffer state.
2629 */
2630    YY_BUFFER_STATE ncg_create_buffer  (FILE * file, int  size )
2631{
2632 YY_BUFFER_STATE b;
2633
2634 b = (YY_BUFFER_STATEncgalloc(sizeof( struct yy_buffer_state )  );
2635 if ( ! b )
2636 YY_FATAL_ERROR( "out of dynamic memory in ncg_create_buffer()" );
2637
2638 b->yy_buf_size = size;
2639
2640 /* yy_ch_buf has to be 2 characters longer than the size given because
2641  * we need to put in 2 end-of-buffer characters.
2642  */
2643 b->yy_ch_buf = (char *) ncgalloc(b->yy_buf_size + 2  );
2644 if ( ! b->yy_ch_buf )
2645 YY_FATAL_ERROR( "out of dynamic memory in ncg_create_buffer()" );
2646
2647 b->yy_is_our_buffer = 1;
2648
2649 ncg_init_buffer(b,file );
2650
2651 return b;
2652}
2653
2654/** Destroy the buffer.
2655 * @param b a buffer created with ncg_create_buffer()
2656 *
2657 */
2658    void ncg_delete_buffer (YY_BUFFER_STATE  b )
2659{
2660
2661 if ( ! b )
2662 return;
2663
2664 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2665 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2666
2667 if ( b->yy_is_our_buffer )
2668 ncgfree((void *) b->yy_ch_buf  );
2669
2670 ncgfree((void *) b  );
2671}
2672
2673#ifndef __cplusplus
2674extern int isatty (int );
2675#endif /* __cplusplus */
2676
2677/* Initializes or reinitializes a buffer.
2678 * This function is sometimes called more than once on the same buffer,
2679 * such as during a ncgrestart() or at EOF.
2680 */
2681    static void ncg_init_buffer  (YY_BUFFER_STATE  bFILE * file )
2682
2683{
2684 int oerrno = errno;
2685
2686 ncg_flush_buffer(b );
2687
2688 b->yy_input_file = file;
2689 b->yy_fill_buffer = 1;
2690
2691    /* If b is the current buffer, then ncg_init_buffer was _probably_
2692     * called from ncgrestart() or through yy_get_next_buffer.
2693     * In that case, we don't want to reset the lineno or column.
2694     */
2695    if (b != YY_CURRENT_BUFFER){
2696        b->yy_bs_lineno = 1;
2697        b->yy_bs_column = 0;
2698    }
2699
2700        b->yy_is_interactive = file ? (isattyfileno(file) ) > 0) : 0;
2701
2702 errno = oerrno;
2703}
2704
2705/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2706 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2707 *
2708 */
2709    void ncg_flush_buffer (YY_BUFFER_STATE  b )
2710{
2711     if ( ! b )
2712 return;
2713
2714 b->yy_n_chars = 0;
2715
2716 /* We always need two end-of-buffer characters.  The first causes
2717  * a transition to the end-of-buffer state.  The second causes
2718  * a jam in that state.
2719  */
2720 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2721 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2722
2723 b->yy_buf_pos = &b->yy_ch_buf[0];
2724
2725 b->yy_at_bol = 1;
2726 b->yy_buffer_status = YY_BUFFER_NEW;
2727
2728 if ( b == YY_CURRENT_BUFFER )
2729 ncg_load_buffer_state( );
2730}
2731
2732/** Pushes the new state onto the stack. The new state becomes
2733 *  the current state. This function will allocate the stack
2734 *  if necessary.
2735 *  @param new_buffer The new state.
2736 *
2737 */
2738void ncgpush_buffer_state (YY_BUFFER_STATE new_buffer )
2739{
2740     if (new_buffer == NULL)
2741 return;
2742
2743 ncgensure_buffer_stack();
2744
2745 /* This block is copied from ncg_switch_to_buffer. */
2746 if ( YY_CURRENT_BUFFER )
2747 {
2748 /* Flush out information for old buffer. */
2749 *(yy_c_buf_p) = (yy_hold_char);
2750 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2751 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2752 }
2753
2754 /* Only push if top exists. Otherwise, replace top. */
2755 if (YY_CURRENT_BUFFER)
2756 (yy_buffer_stack_top)++;
2757 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2758
2759 /* copied from ncg_switch_to_buffer. */
2760 ncg_load_buffer_state( );
2761 (yy_did_buffer_switch_on_eof) = 1;
2762}
2763
2764/** Removes and deletes the top of the stack, if present.
2765 *  The next element becomes the new top.
2766 *
2767 */
2768void ncgpop_buffer_state (void)
2769{
2770     if (!YY_CURRENT_BUFFER)
2771 return;
2772
2773 ncg_delete_buffer(YY_CURRENT_BUFFER );
2774 YY_CURRENT_BUFFER_LVALUE = NULL;
2775 if ((yy_buffer_stack_top) > 0)
2776 --(yy_buffer_stack_top);
2777
2778 if (YY_CURRENT_BUFFER) {
2779 ncg_load_buffer_state( );
2780 (yy_did_buffer_switch_on_eof) = 1;
2781 }
2782}
2783
2784/* Allocates the stack if it does not exist.
2785 *  Guarantees space for at least one push.
2786 */
2787static void ncgensure_buffer_stack (void)
2788{
2789 yy_size_t num_to_alloc;
2790
2791 if (!(yy_buffer_stack)) {
2792
2793 /* First allocation is just for 2 elements, since we don't know if this
2794  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2795  * immediate realloc on the next call.
2796         */
2797 num_to_alloc = 1;
2798 (yy_buffer_stack) = (struct yy_buffer_state**)ncgalloc
2799 (num_to_alloc * sizeof(struct yy_buffer_state*)
2800 );
2801 if ( ! (yy_buffer_stack) )
2802 YY_FATAL_ERROR( "out of dynamic memory in ncgensure_buffer_stack()" );
2803
2804 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2805
2806 (yy_buffer_stack_max) = num_to_alloc;
2807 (yy_buffer_stack_top) = 0;
2808 return;
2809 }
2810
2811 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2812
2813 /* Increase the buffer to prepare for a possible push. */
2814 int grow_size = 8 /* arbitrary grow size */;
2815
2816 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2817 (yy_buffer_stack) = (struct yy_buffer_state**)ncgrealloc
2818 ((yy_buffer_stack),
2819 num_to_alloc * sizeof(struct yy_buffer_state*)
2820 );
2821 if ( ! (yy_buffer_stack) )
2822 YY_FATAL_ERROR( "out of dynamic memory in ncgensure_buffer_stack()" );
2823
2824 /* zero only the new slots.*/
2825 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2826 (yy_buffer_stack_max) = num_to_alloc;
2827 }
2828}
2829
2830/** Setup the input buffer state to scan directly from a user-specified character buffer.
2831 * @param base the character buffer
2832 * @param size the size in bytes of the character buffer
2833 *
2834 * @return the newly allocated buffer state object.
2835 */
2836YY_BUFFER_STATE ncg_scan_buffer  (char * baseyy_size_t  size )
2837{
2838 YY_BUFFER_STATE b;
2839
2840 if ( size < 2 ||
2841      base[size-2] != YY_END_OF_BUFFER_CHAR ||
2842      base[size-1] != YY_END_OF_BUFFER_CHAR )
2843 /* They forgot to leave room for the EOB's. */
2844 return 0;
2845
2846 b = (YY_BUFFER_STATEncgalloc(sizeof( struct yy_buffer_state )  );
2847 if ( ! b )
2848 YY_FATAL_ERROR( "out of dynamic memory in ncg_scan_buffer()" );
2849
2850 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2851 b->yy_buf_pos = b->yy_ch_buf = base;
2852 b->yy_is_our_buffer = 0;
2853 b->yy_input_file = 0;
2854 b->yy_n_chars = b->yy_buf_size;
2855 b->yy_is_interactive = 0;
2856 b->yy_at_bol = 1;
2857 b->yy_fill_buffer = 0;
2858 b->yy_buffer_status = YY_BUFFER_NEW;
2859
2860 ncg_switch_to_buffer(b  );
2861
2862 return b;
2863}
2864
2865/** Setup the input buffer state to scan a string. The next call to ncglex() will
2866 * scan from a @e copy of @a str.
2867 * @param yystr a NUL-terminated string to scan
2868 *
2869 * @return the newly allocated buffer state object.
2870 * @note If you want to scan bytes that may contain NUL values, then use
2871 *       ncg_scan_bytes() instead.
2872 */
2873YY_BUFFER_STATE ncg_scan_string (yyconst char * yystr )
2874{
2875
2876 return ncg_scan_bytes(yystr,strlen(yystr) );
2877}
2878
2879/** Setup the input buffer state to scan the given bytes. The next call to ncglex() will
2880 * scan from a @e copy of @a bytes.
2881 * @param bytes the byte buffer to scan
2882 * @param len the number of bytes in the buffer pointed to by @a bytes.
2883 *
2884 * @return the newly allocated buffer state object.
2885 */
2886YY_BUFFER_STATE ncg_scan_bytes  (yyconst char * yybytesyy_size_t  _yybytes_len )
2887{
2888 YY_BUFFER_STATE b;
2889 char *buf;
2890 yy_size_t ni;
2891
2892 /* Get memory for full buffer, including space for trailing EOB's. */
2893 n = _yybytes_len + 2;
2894 buf = (char *) ncgalloc(n  );
2895 if ( ! buf )
2896 YY_FATAL_ERROR( "out of dynamic memory in ncg_scan_bytes()" );
2897
2898 for ( i = 0; i < _yybytes_len; ++i )
2899 buf[i] = yybytes[i];
2900
2901 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2902
2903 b = ncg_scan_buffer(buf,n );
2904 if ( ! b )
2905 YY_FATAL_ERROR( "bad buffer in ncg_scan_bytes()" );
2906
2907 /* It's okay to grow etc. this buffer, and we should throw it
2908  * away when we're done.
2909  */
2910 b->yy_is_our_buffer = 1;
2911
2912 return b;
2913}
2914
2915#ifndef YY_EXIT_FAILURE
2916#define YY_EXIT_FAILURE 2
2917#endif
2918
2919static void yy_fatal_error (yyconst char* msg )
2920{
2921     (void) fprintf( stderr, "%s\n", msg );
2922 exit( YY_EXIT_FAILURE );
2923}
2924
2925/* Redefine yyless() so it works in section 3 code. */
2926
2927#undef yyless
2928#define yyless(n) \
2929 do \
2930 { \
2931 /* Undo effects of setting up ncgtext. */ \
2932        int yyless_macro_arg = (n); \
2933        YY_LESS_LINENO(yyless_macro_arg);\
2934 ncgtext[ncgleng] = (yy_hold_char); \
2935 (yy_c_buf_p) = ncgtext + yyless_macro_arg; \
2936 (yy_hold_char) = *(yy_c_buf_p); \
2937 *(yy_c_buf_p) = '\0'; \
2938 ncgleng = yyless_macro_arg; \
2939 } \
2940 while ( 0 )
2941
2942/* Accessor  methods (get/set functions) to struct members. */
2943
2944/** Get the current line number.
2945 *
2946 */
2947int ncgget_lineno  (void)
2948{
2949
2950    return ncglineno;
2951}
2952
2953/** Get the input stream.
2954 *
2955 */
2956FILE *ncgget_in  (void)
2957{
2958        return ncgin;
2959}
2960
2961/** Get the output stream.
2962 *
2963 */
2964FILE *ncgget_out  (void)
2965{
2966        return ncgout;
2967}
2968
2969/** Get the length of the current token.
2970 *
2971 */
2972yy_size_t ncgget_leng  (void)
2973{
2974        return ncgleng;
2975}
2976
2977/** Get the current token.
2978 *
2979 */
2980
2981char *ncgget_text  (void)
2982{
2983        return ncgtext;
2984}
2985
2986/** Set the current line number.
2987 * @param line_number
2988 *
2989 */
2990void ncgset_lineno (int  line_number )
2991{
2992
2993    ncglineno = line_number;
2994}
2995
2996/** Set the input stream. This does not discard the current
2997 * input buffer.
2998 * @param in_str A readable stream.
2999 *
3000 * @see ncg_switch_to_buffer
3001 */
3002void ncgset_in (FILE *  in_str )
3003{
3004        ncgin = in_str ;
3005}
3006
3007void ncgset_out (FILE *  out_str )
3008{
3009        ncgout = out_str ;
3010}
3011
3012int ncgget_debug  (void)
3013{
3014        return ncg_flex_debug;
3015}
3016
3017void ncgset_debug (int  bdebug )
3018{
3019        ncg_flex_debug = bdebug ;
3020}
3021
3022static int yy_init_globals (void)
3023{
3024        /* Initialization is the same as for the non-reentrant scanner.
3025     * This function is called from ncglex_destroy(), so don't allocate here.
3026     */
3027
3028    (yy_buffer_stack) = 0;
3029    (yy_buffer_stack_top) = 0;
3030    (yy_buffer_stack_max) = 0;
3031    (yy_c_buf_p) = (char *) 0;
3032    (yy_init) = 0;
3033    (yy_start) = 0;
3034
3035/* Defined in main.c */
3036#ifdef YY_STDINIT
3037    ncgin = stdin;
3038    ncgout = stdout;
3039#else
3040    ncgin = (FILE *) 0;
3041    ncgout = (FILE *) 0;
3042#endif
3043
3044    /* For future reference: Set errno on error, since we are called by
3045     * ncglex_init()
3046     */
3047    return 0;
3048}
3049
3050/* ncglex_destroy is for both reentrant and non-reentrant scanners. */
3051int ncglex_destroy  (void)
3052{
3053
3054    /* Pop the buffer stack, destroying each element. */
3055 while(YY_CURRENT_BUFFER){
3056 ncg_delete_buffer(YY_CURRENT_BUFFER  );
3057 YY_CURRENT_BUFFER_LVALUE = NULL;
3058 ncgpop_buffer_state();
3059 }
3060
3061 /* Destroy the stack itself. */
3062 ncgfree((yy_buffer_stack) );
3063 (yy_buffer_stack) = NULL;
3064
3065    /* Reset the globals. This is important in a non-reentrant scanner so the next time
3066     * ncglex() is called, initialization will occur. */
3067    yy_init_globals( );
3068
3069    return 0;
3070}
3071
3072/*
3073 * Internal utility routines.
3074 */
3075
3076#ifndef yytext_ptr
3077static void yy_flex_strncpy (char* s1yyconst char * s2, int n )
3078{
3079 register int i;
3080 for ( i = 0; i < n; ++i )
3081 s1[i] = s2[i];
3082}
3083#endif
3084
3085#ifdef YY_NEED_STRLEN
3086static int yy_flex_strlen (yyconst char * s )
3087{
3088 register int n;
3089 for ( n = 0; s[n]; ++n )
3090 ;
3091
3092 return n;
3093}
3094#endif
3095
3096void *ncgalloc (yy_size_t  size )
3097{
3098 return (void *) malloc( size );
3099}
3100
3101void *ncgrealloc  (void * ptryy_size_t  size )
3102{
3103 /* The cast to (char *) in the following accommodates both
3104  * implementations that use char* generic pointers, and those
3105  * that use void* generic pointers.  It works with the latter
3106  * because both ANSI C and C++ allow castless assignment from
3107  * any pointer type to void*, and deal with argument conversions
3108  * as though doing an assignment.
3109  */
3110 return (void *) realloc( (char *) ptrsize );
3111}
3112
3113void ncgfree (void * ptr )
3114{
3115 free( (char *) ptr ); /* see ncgrealloc() for (char *) cast */
3116}
3117
3118#define YYTABLES_NAME "yytables"
3119
3120#line 570 "ncgen.l"
3121
3122
3123static int
3124lexdebug(int token)
3125{
3126    if(debug >= 2)
3127    {
3128 char* text = ncgtext;
3129 text[ncgleng] = 0;
3130        fprintf(stderr,"Token=%d |%s| line=%d\n",token,text,lineno);
3131    }
3132    return token;
3133}
3134
3135int
3136lex_init(void)
3137{
3138    lineno = 1;
3139    lextext = bbNew();
3140    if(0) unput(0); /* keep -Wall quiet */
3141    return 0;
3142}
3143
3144static Symbol*
3145makepath(char* text0)
3146{
3147    /* Create a reference symbol.
3148       Convert path to a sequence of symbols.
3149       Use last name as symbol name (with root group reference ('/') as exception).
3150    */
3151    Symbolrefsym = NULL;
3152    /* walk the path converting to a sequence of symbols */
3153    if(strcmp(text0,"/")==0) {
3154 /* special case of root reference */
3155 refsym = rootgroup;
3156    } else {
3157        Listprefix = listnew();
3158 /* split the text into IDENT chunks, convert to symbols */
3159        Symbolcontainer = rootgroup;
3160 char *ident, *p;
3161        char* text = strdup(text0);
3162 int c,lastident;
3163 ident=text+1; p=ident; /* skip leading '/' */
3164 do {
3165     lastident = 0;
3166     switch ((c=*p)) {
3167     default: p++; break;
3168     case '\\': p++; if(*p == '/') p++; break;
3169     case '\0': /* treat null terminator like trailing '/' (mostly) */
3170 lastident=1; /* this is the last ident in the path */
3171 /*fall thru */
3172     case '/':
3173 *p='\0';
3174 if(!lastident) {
3175     unescape(ident,ident,strlen(ident),ISIDENT);
3176     refsym = lookupingroup(NC_GRP,ident,container);
3177     if(refsym == NULL) {
3178         sprintf(errstr,"Undefined or forward referenced group: %s",ident);
3179         yyerror(errstr);
3180 refsym = rootgroup;
3181     } else {
3182         listpush(prefix,(void*)refsym);
3183     }
3184 } else { /* lastident is true */
3185     unescape(ident,ident,strlen(ident),ISIDENT);
3186     refsym = install(ident);
3187     refsym->objectclass = NC_GRP;/* tentative */
3188     refsym->ref.is_ref = 1;
3189     refsym->container = container;
3190     refsym->subnodes = listnew();
3191 }
3192 container = refsym;
3193         ident=p+1; p=ident;
3194         break;
3195     }
3196 } while(c != '\0');
3197        refsym->prefix = prefix;
3198 free(text);
3199    }
3200    return refsym;
3201}
3202
3203/*
3204Parse a simple string of digits into an unsigned long long
3205Return the value.
3206*/
3207static unsigned long long
3208parseULL(char* text, int* failp)
3209{
3210    int result = 0;
3211    extern int errno;
3212    char* endptr;
3213    unsigned long long uint64 = 0;
3214
3215    errno = 0; endptr = NULL;
3216    assert(tstdecimal(text[0]));
3217#ifdef HAVE_STRTOULL
3218    uint64 = strtoull(text,&endptr,10);
3219    if(errno == ERANGE) {
3220 if(failp) *failp = ERANGE;
3221 return 0;
3222    }
3223#else /*!(defined HAVE_STRTOLL && defined HAVE_STRTOULL)*/
3224    sscanf((char*)text, "%llu", &uint64);
3225    /* Have no useful way to detect out of range */
3226#endif /*!(defined HAVE_STRTOLL && defined HAVE_STRTOULL)*/
3227    return uint64;
3228}
3229
3230
3231/**
3232Given the raw bits, the sign char, the tag, and hasU
3233fill in the appropriate *_val field
3234and return the type.
3235Note that we cannot return unsigned types if running pure netcdf classic.
3236The rule is to pick the smallest enclosing type.
3237
3238The rule used here is that the tag (the suffix, if any)
3239always takes precedence and the value is modified to conform
3240if possible, otherwise out-of-range is signalled.
3241For historical reasons (ncgen3), values that fit as unsigned
3242are acceptable for the signed tag and conversion is attempted;
3243e.g. 65535s; is legal and is return as a negative short.
3244*/
3245static nc_type
3246downconvert(unsigned long long uint64, int* tagp, int isneg, int hasU)
3247{
3248    nc_type nct = NC_NAT;
3249    int tag = *tagp;
3250    int bit63set = (uint64 >> 63);
3251    long long int64 = *((long long*)&uint64);
3252
3253    if(isneg && hasU) {
3254 return (*tagp = NC_NAT);
3255    }
3256    /* To simplify the code, we look for special case of NC_UINT64
3257       constants that will not fit into an NC_INT64 constant.
3258     */
3259    if(tag == NC_UINT64 && bit63set) {
3260        uint64_val = uint64;
3261 return tag;
3262    }
3263    /* At this point we need deal only with int64 value */
3264    /* Apply the isneg */
3265    if(isneg)
3266 int64 = - int64;
3267
3268    if(tag == NC_NOTAG) {
3269        /* If we have no other info, then assume NC_(U)INT(64) */
3270 if(int64 >= NC_MIN_INT && int64 <= NC_MAX_INT) {
3271     nct = (tag = NC_INT);
3272     int32_val = (signed int)int64;
3273 } else if(int64 >= 0 && int64 <= NC_MAX_UINT) {
3274         nct = (tag = NC_UINT);
3275         uint32_val = (unsigned int)int64;
3276 } else if(int64 < 0) {
3277 nct = (tag = NC_INT64);
3278         int64_val = (signed long long)int64;
3279 } else {
3280         nct = (tag = NC_UINT64);
3281         uint64_val = (unsigned long long)int64;
3282 }
3283        goto done;
3284    }
3285    if(isuinttype(tag) && int64 < 0)
3286 goto outofrange;
3287    switch (tag) {
3288    case NC_UBYTE:
3289     if(int64 <= NC_MAX_UBYTE) {
3290         nct = NC_UBYTE;
3291         ubyte_val = (unsigned char)int64;
3292     } else
3293 goto outofrange;
3294     break;
3295    case NC_USHORT:
3296     if(int64 <= NC_MAX_USHORT) {
3297         nct = NC_USHORT;
3298         uint16_val = (unsigned short)int64;
3299     } else
3300        goto outofrange;
3301     break;
3302    case NC_UINT:
3303     if(int64 <= NC_MAX_UINT) {
3304         nct = NC_UINT;
3305         uint32_val = (unsigned int)int64;
3306     } else
3307 goto outofrange;
3308     break;
3309    case NC_UINT64:
3310            if(int64 <= NC_MAX_UINT64) {
3311         nct = NC_UINT64;
3312         uint64_val = uint64;
3313     } else
3314 goto outofrange;
3315     break;
3316    case NC_INT64:
3317     nct = NC_INT64;
3318     int64_val = int64;
3319     break;
3320    case NC_BYTE:
3321     nct = NC_BYTE;
3322     byte_val = (signed char)int64;
3323     break;
3324    case NC_SHORT:
3325     nct = NC_SHORT;
3326     int16_val = (signed short)int64;
3327     break;
3328    case NC_INT:
3329     nct = NC_INT;
3330     int32_val = (signed int)int64;
3331     break;
3332    default:
3333     goto outofrange;
3334    }
3335
3336done:
3337    *tagp = tag;
3338    return nct;
3339outofrange:
3340    yyerror("Value out of range");
3341    return NC_NAT;
3342}
3343
3344static int
3345nct2lexeme(nc_type nct)
3346{
3347    switch(nct) {
3348    case NC_BYTE: return BYTE_CONST;
3349    case NC_CHAR: return CHAR_CONST;
3350    case NC_SHORT: return SHORT_CONST;
3351    case NC_INT: return INT_CONST;
3352    case NC_UBYTE: return UBYTE_CONST;
3353    case NC_USHORT: return USHORT_CONST;
3354    case NC_UINT: return UINT_CONST;
3355    case NC_INT64: return INT64_CONST;
3356    case NC_UINT64: return UINT64_CONST;
3357    }
3358    return 0;
3359}
3360
3361static int
3362tagmatch(nc_type nct, int tag)
3363{
3364    if(tag == NC_NAT || tag ==  NC_NOTAG)
3365 return 1;
3366    return nct == tag;
3367}
3368
3369/* capture the tag string */
3370static int
3371collecttag(char* text, char** stagp)
3372{
3373    char* stag0;
3374#define MAXTAGLEN 3
3375    char stag[MAXTAGLEN+1];
3376    int slen = strlen(text);
3377    int staglen;
3378    int tag = NC_NAT;
3379    int hasU = 0;
3380
3381    for(stag0 = text+(slen-1);stag0 > 0;stag0--) {
3382 if(strchr(TAGCHARS,*stag0) == NULL) {stag0++; break;}
3383    }
3384    if(stagp) *stagp = stag0;
3385    staglen = strlen(stag0);
3386    if(staglen == 0)
3387 return NC_NOTAG;
3388    if(staglen > MAXTAGLEN)
3389 return tag;
3390    strncpy(stag,stag0,sizeof(stag));
3391    stag[MAXTAGLEN] = '\0';
3392    if(stag[0] == 'U' || stag[0] == 'u') {
3393 hasU = 1;
3394    memmove(stag,stag+1,MAXTAGLEN);
3395 staglen--;
3396    } else if(stag[staglen-1] == 'U' || stag[staglen-1] == 'u') {
3397 hasU = 1;
3398 staglen--;
3399 stag[staglen] = '\0';
3400    }
3401    if(strlen(stag) == 0 && hasU) {
3402 tag = NC_UINT64;
3403    } else if(strlen(stag) == 1) {
3404 switch (stag[0]) {
3405 case 'B': case 'b': tag = (hasU ? NC_UBYTE : NC_BYTE); break;
3406 case 'S': case 's': tag = (hasU ? NC_USHORT : NC_SHORT); break;
3407 case 'L': case 'l': tag = (hasU ? NC_UINT : NC_INT); break;
3408 default: break;
3409 }
3410    } else if(strcasecmp(stag,"ll") == 0) {
3411 tag = (hasU ? NC_UINT64 : NC_INT64);
3412    }
3413    if(tag == NC_NAT) {
3414 if(strlen(stag) > 0)
3415     return tag;
3416 tag = NC_NAT;
3417    }
3418    return tag;
3419}
3420


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