1
2#line 3 "lex.ncg.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;
68#else
69typedef signed char flex_int8_t;
70typedef short int flex_int16_t;
71typedef int flex_int32_t;
72typedef unsigned char flex_uint8_t;
73typedef unsigned short int flex_uint16_t;
74typedef unsigned int flex_uint32_t;
75#endif /* ! C99 */
76
77/* Limits of integral types. */
78#ifndef INT8_MIN
79#define INT8_MIN               (-128)
80#endif
81#ifndef INT16_MIN
82#define INT16_MIN              (-32767-1)
83#endif
84#ifndef INT32_MIN
85#define INT32_MIN              (-2147483647-1)
86#endif
87#ifndef INT8_MAX
88#define INT8_MAX               (127)
89#endif
90#ifndef INT16_MAX
91#define INT16_MAX              (32767)
92#endif
93#ifndef INT32_MAX
94#define INT32_MAX              (2147483647)
95#endif
96#ifndef UINT8_MAX
97#define UINT8_MAX              (255U)
98#endif
99#ifndef UINT16_MAX
100#define UINT16_MAX             (65535U)
101#endif
102#ifndef UINT32_MAX
103#define UINT32_MAX             (4294967295U)
104#endif
105
106#endif /* ! FLEXINT_H */
107
108#ifdef __cplusplus
109
110/* The "const" storage-class-modifier is valid. */
111#define YY_USE_CONST
112
113#else /* ! __cplusplus */
114
115/* C99 requires __STDC__ to be defined as 1. */
116#if defined (__STDC__)
117
118#define YY_USE_CONST
119
120#endif /* defined (__STDC__) */
121#endif /* ! __cplusplus */
122
123#ifdef YY_USE_CONST
124#define yyconst const
125#else
126#define yyconst
127#endif
128
129/* Returned upon end-of-file. */
130#define YY_NULL 0
131
132/* Promotes a possibly negative, possibly signed char to an unsigned
133 * integer for use as an array index.  If the signed char is negative,
134 * we want to instead treat it as an 8-bit unsigned char, hence the
135 * double cast.
136 */
137#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
138
139/* Enter a start condition.  This macro really ought to take a parameter,
140 * but we do it the disgusting crufty way forced on us by the ()-less
141 * definition of BEGIN.
142 */
143#define BEGIN (yy_start) = 1 + 2 *
144
145/* Translate the current start state into a value that can be later handed
146 * to BEGIN to return to the state.  The YYSTATE alias is for lex
147 * compatibility.
148 */
149#define YY_START (((yy_start) - 1) / 2)
150#define YYSTATE YY_START
151
152/* Action number for EOF rule of a given start state. */
153#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
154
155/* Special action meaning "start processing a new file". */
156#define YY_NEW_FILE ncgrestart(ncgin  )
157
158#define YY_END_OF_BUFFER_CHAR 0
159
160/* Size of default input buffer. */
161#ifndef YY_BUF_SIZE
162#define YY_BUF_SIZE 16384
163#endif
164
165/* The state buf must be large enough to hold one state per character in the main buffer.
166 */
167#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
168
169#ifndef YY_TYPEDEF_YY_BUFFER_STATE
170#define YY_TYPEDEF_YY_BUFFER_STATE
171typedef struct yy_buffer_state *YY_BUFFER_STATE;
172#endif
173
174extern int ncgleng;
175
176extern FILE *ncgin, *ncgout;
177
178#define EOB_ACT_CONTINUE_SCAN 0
179#define EOB_ACT_END_OF_FILE 1
180#define EOB_ACT_LAST_MATCH 2
181
182    #define YY_LESS_LINENO(n)
183
184/* Return all but the first "n" matched characters back to the input stream. */
185#define yyless(n) \
186 do \
187 { \
188 /* Undo effects of setting up ncgtext. */ \
189        int yyless_macro_arg = (n); \
190        YY_LESS_LINENO(yyless_macro_arg);\
191 *yy_cp = (yy_hold_char); \
192 YY_RESTORE_YY_MORE_OFFSET \
193 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
194 YY_DO_BEFORE_ACTION; /* set up ncgtext again */ \
195 } \
196 while ( 0 )
197
198#define unput(cyyunputc, (yytext_ptr)  )
199
200#ifndef YY_TYPEDEF_YY_SIZE_T
201#define YY_TYPEDEF_YY_SIZE_T
202typedef size_t yy_size_t;
203#endif
204
205#ifndef YY_STRUCT_YY_BUFFER_STATE
206#define YY_STRUCT_YY_BUFFER_STATE
207struct yy_buffer_state
208 {
209 FILE *yy_input_file;
210
211 char *yy_ch_buf; /* input buffer */
212 char *yy_buf_pos; /* current position in input buffer */
213
214 /* Size of input buffer in bytes, not including room for EOB
215  * characters.
216  */
217 yy_size_t yy_buf_size;
218
219 /* Number of characters read into yy_ch_buf, not including EOB
220  * characters.
221  */
222 int yy_n_chars;
223
224 /* Whether we "own" the buffer - i.e., we know we created it,
225  * and can realloc() it to grow it, and should free() it to
226  * delete it.
227  */
228 int yy_is_our_buffer;
229
230 /* Whether this is an "interactive" input source; if so, and
231  * if we're using stdio for input, then we want to use getc()
232  * instead of fread(), to make sure we stop fetching input after
233  * each newline.
234  */
235 int yy_is_interactive;
236
237 /* Whether we're considered to be at the beginning of a line.
238  * If so, '^' rules will be active on the next match, otherwise
239  * not.
240  */
241 int yy_at_bol;
242
243    int yy_bs_lineno; /**< The line count. */
244    int yy_bs_column; /**< The column count. */
245
246 /* Whether to try to fill the input buffer when we reach the
247  * end of it.
248  */
249 int yy_fill_buffer;
250
251 int yy_buffer_status;
252
253#define YY_BUFFER_NEW 0
254#define YY_BUFFER_NORMAL 1
255 /* When an EOF's been seen but there's still some text to process
256  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
257  * shouldn't try reading from the input source any more.  We might
258  * still have a bunch of tokens to match, though, because of
259  * possible backing-up.
260  *
261  * When we actually see the EOF, we change the status to "new"
262  * (via ncgrestart()), so that the user can continue scanning by
263  * just pointing ncgin at a new input file.
264  */
265#define YY_BUFFER_EOF_PENDING 2
266
267 };
268#endif /* !YY_STRUCT_YY_BUFFER_STATE */
269
270/* Stack of input buffers. */
271static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
272static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
273static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
274
275/* We provide macros for accessing buffer states in case in the
276 * future we want to put the buffer states in a more general
277 * "scanner state".
278 *
279 * Returns the top of the stack, or NULL.
280 */
281#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
282                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
283                          : NULL)
284
285/* Same as previous macro, but useful when we know that the buffer stack is not
286 * NULL or when we need an lvalue. For internal use only.
287 */
288#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
289
290/* yy_hold_char holds the character lost when ncgtext is formed. */
291static char yy_hold_char;
292static int yy_n_chars; /* number of characters read into yy_ch_buf */
293int ncgleng;
294
295/* Points to current character in buffer. */
296static char *yy_c_buf_p = (char *) 0;
297static int yy_init = 0; /* whether we need to initialize */
298static int yy_start = 0; /* start state number */
299
300/* Flag which is used to allow ncgwrap()'s to do buffer switches
301 * instead of setting up a fresh ncgin.  A bit of a hack ...
302 */
303static int yy_did_buffer_switch_on_eof;
304
305void ncgrestart (FILE *input_file  );
306void ncg_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
307YY_BUFFER_STATE ncg_create_buffer (FILE *file,int size  );
308void ncg_delete_buffer (YY_BUFFER_STATE b  );
309void ncg_flush_buffer (YY_BUFFER_STATE b  );
310void ncgpush_buffer_state (YY_BUFFER_STATE new_buffer  );
311void ncgpop_buffer_state (void );
312
313static void ncgensure_buffer_stack (void );
314static void ncg_load_buffer_state (void );
315static void ncg_init_buffer (YY_BUFFER_STATE b,FILE *file  );
316
317#define YY_FLUSH_BUFFER ncg_flush_buffer(YY_CURRENT_BUFFER )
318
319YY_BUFFER_STATE ncg_scan_buffer (char *base,yy_size_t size  );
320YY_BUFFER_STATE ncg_scan_string (yyconst char *yy_str  );
321YY_BUFFER_STATE ncg_scan_bytes (yyconst char *bytes,int len  );
322
323void *ncgalloc (yy_size_t  );
324void *ncgrealloc (void *,yy_size_t  );
325void ncgfree (void *  );
326
327#define yy_new_buffer ncg_create_buffer
328
329#define yy_set_interactive(is_interactive) \
330 { \
331 if ( ! YY_CURRENT_BUFFER ){ \
332        ncgensure_buffer_stack (); \
333 YY_CURRENT_BUFFER_LVALUE =    \
334            ncg_create_buffer(ncgin,YY_BUF_SIZE ); \
335 } \
336 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
337 }
338
339#define yy_set_bol(at_bol) \
340 { \
341 if ( ! YY_CURRENT_BUFFER ){\
342        ncgensure_buffer_stack (); \
343 YY_CURRENT_BUFFER_LVALUE =    \
344            ncg_create_buffer(ncgin,YY_BUF_SIZE ); \
345 } \
346 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
347 }
348
349#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
350
351/* Begin user sect3 */
352
353typedef unsigned char YY_CHAR;
354
355FILE *ncgin = (FILE *) 0, *ncgout = (FILE *) 0;
356
357typedef int yy_state_type;
358
359extern int ncglineno;
360
361int ncglineno = 1;
362
363extern char *ncgtext;
364#define yytext_ptr ncgtext
365
366static yy_state_type yy_get_previous_state (void );
367static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
368static int yy_get_next_buffer (void );
369static void yy_fatal_error (yyconst char msg[]  );
370
371/* Done after the current pattern has been matched and before the
372 * corresponding action - sets up ncgtext.
373 */
374#define YY_DO_BEFORE_ACTION \
375 (yytext_ptr) = yy_bp; \
376 ncgleng = (size_t) (yy_cp - yy_bp); \
377 (yy_hold_char) = *yy_cp; \
378 *yy_cp = '\0'; \
379 (yy_c_buf_p) = yy_cp;
380
381#define YY_NUM_RULES 30
382#define YY_END_OF_BUFFER 31
383/* This struct is not used in this scanner,
384   but its presence is necessary. */
385struct yy_trans_info
386 {
387 flex_int32_t yy_verify;
388 flex_int32_t yy_nxt;
389 };
390static yyconst flex_int16_t yy_accept[236] =
391    {   0,
392        0,    0,   31,   29,   28,   17,   29,   29,   29,   29,
393       19,   29,   22,   22,   16,   16,   16,   16,   16,   16,
394       16,   16,   29,   16,   16,   16,   16,   16,   16,   16,
395       16,   16,   16,   16,   29,   29,   29,   28,    0,    2,
396        0,    0,    0,   19,   22,   22,    0,    0,   19,   19,
397        0,   20,    1,   23,   23,   18,   23,   22,   21,    0,
398       22,   18,   16,    0,    0,    0,    0,   16,   16,   16,
399       16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
400       16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
401       16,   16,    0,    0,   24,    0,    0,    0,    0,    0,
402
403       19,    0,    0,   19,    1,   23,   19,   23,    0,    0,
404       16,   16,   16,   16,   16,   16,   16,   16,   14,   16,
405       16,   16,   16,   16,   16,   16,   16,    7,   16,   16,
406       16,   16,   16,   16,    0,   27,   25,    0,    0,   19,
407        0,   19,   20,   19,    0,   16,   16,   16,   16,   15,
408       16,   16,   16,   16,    5,    4,   16,   16,   16,   16,
409       16,    7,   16,   16,    3,   16,   16,   16,   25,    0,
410       26,    0,   15,    0,   12,   16,   16,   16,   16,   16,
411       16,   16,   16,   16,   16,   16,   16,    6,   16,   16,
412        0,   16,   16,   16,   16,   16,   16,   16,   16,    8,
413
414       16,   16,   16,    0,   16,   16,   16,   16,    0,   16,
415       16,   16,   16,   16,    0,   16,   16,   13,   13,   16,
416       16,   16,   16,   16,   14,   16,    9,   16,   16,   16,
417       16,   11,   16,   10,    0
418    } ;
419
420static yyconst flex_int32_t yy_ec[256] =
421    {   0,
422        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
423        1,    4,    4,    1,    1,    1,    1,    1,    1,    1,
424        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
425        1,    5,    6,    7,    6,    6,    6,    6,    8,    6,
426        6,    6,    9,    6,   10,   11,   12,   13,   14,   14,
427       14,   14,   14,   14,   14,   15,   15,   16,    6,    6,
428        6,    6,    6,   17,   18,   19,   20,   21,   22,   23,
429       24,   24,   25,   24,   24,   26,   27,   28,   29,   24,
430       24,   30,   31,   32,   33,   34,   24,   35,   24,   24,
431        6,   36,    6,    6,   24,    6,   37,   38,   39,   40,
432
433       41,   42,   43,   44,   45,   24,   24,   46,   47,   48,
434       49,   24,   24,   50,   51,   52,   53,   54,   24,   35,
435       55,   24,   56,    6,    6,    6,    1,   57,   57,   57,
436       57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
437       57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
438       57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
439       57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
440       57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
441       57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
442       57,   58,   58,   58,   58,   58,   58,   58,   58,   58,
443
444       58,   58,   58,   58,   58,   58,   58,   58,   58,   58,
445       58,   58,   58,   58,    1,    1,    1,    1,    1,    1,
446        1,    1,    1,   59,   59,   59,   59,   59,   59,   59,
447       59,   59,   59,   59,   59,   59,   59,   59,   59,   60,
448       60,   60,   60,   60,   60,   60,   60,    1,    1,    1,
449        1,    1,    1,    1,    1
450    } ;
451
452static yyconst flex_int32_t yy_meta[61] =
453    {   0,
454        1,    1,    2,    1,    1,    1,    1,    3,    4,    4,
455        4,    1,    5,    5,    5,    1,    4,    5,    5,    5,
456        5,    5,    5,    4,    4,    6,    4,    4,    4,    4,
457        4,    4,    4,    4,    4,    4,    5,    5,    5,    5,
458        5,    5,    4,    4,    4,    6,    4,    4,    4,    4,
459        4,    4,    4,    4,    4,    7,    1,    4,    4,    4
460    } ;
461
462static yyconst flex_int16_t yy_base[246] =
463    {   0,
464        0,    0,  327, 1206,   59, 1206,   55,  277,   54,   59,
465       88,  295,  124,  165,   30,   57,  159,   61,  141,  149,
466      154,  174,   64,  166,  179,  191,  184,  199,  205,  212,
467      219,  225,  232,  237,  244,  243,  237,   81,   87, 1206,
468      278,  259,   91,    0,  118,    0,  139,  204,    0, 1206,
469      289, 1206,    0,  240,   66,   72,  296, 1206, 1206,    0,
470        0, 1206,  257,  313,  189,  188,  174,  276,  287,  295,
471      324,  372,  292,  320,  308,  345,  363,  366,  375,  384,
472      379,  393,  410,  405,  413,  423,  418,  438,  443,  450,
473      458,  455,  172,  165, 1206,  197,  143,  196,  114,  274,
474
475      506,  156,  311,  521,    0, 1206,  528,  346,  140,  126,
476      521,  528,  517,  464,  524,  535,  554,  542,  549,  567,
477      579,  570,  574,  561,  582,  607,  599,  610,  613,  624,
478      616,  628,  644,  649,  124, 1206, 1206,  180,  159, 1206,
479       54,  230,  236, 1206,  101,  661,  664,  655,  595,  669,
480      682,  674,  689,  699,  695,  702,  710,  715,  720,  729,
481      740,  735,  746,  750,  755,  760,  775,  765, 1206,  133,
482     1206,  128, 1206,   65, 1206,  785,  790,  802,  794,  805,
483      811,  821,  815,  831,  841,  860,  850,  857,  866,  869,
484       63,  878,  887,  894,  897,  929,  903,  914,  922,  932,
485
486      935,  947,  950,   35,  968,  964,  975,  943,  120,  993,
487      996,  989, 1000, 1003,   25, 1009, 1028,    0,  122, 1021,
488     1035, 1041, 1038, 1054, 1206, 1071, 1067, 1075, 1081, 1088,
489     1092, 1206, 1100, 1206, 1206, 1160, 1167, 1171, 1177, 1184,
490     1187,   66, 1191, 1194, 1199
491    } ;
492
493static yyconst flex_int16_t yy_def[246] =
494    {   0,
495      235,    1,  235,  235,  235,  235,  236,  237,  235,  235,
496      235,  235,  235,  235,  238,  238,  238,  238,  238,  238,
497      238,  238,  235,  238,  238,  238,  238,  238,  238,  238,
498      238,  238,  238,  238,  235,  235,  235,  235,  236,  235,
499      236,  235,  239,   11,   14,   14,  235,  235,   11,  235,
500      235,  235,  240,   13,  241,  241,  241,  235,  235,  242,
501       14,  235,  238,  235,  235,  235,  235,  238,  238,  238,
502      238,  238,  238,  238,  238,  238,  238,  238,  238,  238,
503      238,  238,  238,  238,  238,  238,  238,  238,  238,  238,
504      238,  238,  235,  235,  235,  235,  235,  243,   45,  235,
505
506      235,  235,  235,  235,  240,  235,   57,  242,  235,  235,
507      238,  238,  238,  238,  238,  238,  238,  238,  238,  238,
508      238,  238,  238,  238,  238,  238,  238,  238,  238,  238,
509      238,  238,  238,  238,  235,  235,  235,  235,  244,  235,
510      235,  241,  241,  235,  235,  238,  238,  238,  238,  238,
511      238,  238,  238,  238,  238,  238,  238,  238,  238,  238,
512      238,  238,  238,  238,  238,  238,  238,  238,  235,  235,
513      235,  235,  235,  235,  235,  238,  238,  238,  238,  238,
514      238,  238,  238,  238,  238,  238,  238,  238,  238,  238,
515      235,  238,  238,  238,  238,  238,  238,  238,  238,  238,
516
517      238,  238,  238,  235,  238,  238,  238,  238,  245,  238,
518      238,  238,  238,  238,  235,  238,  238,  245,  245,  238,
519      238,  238,  238,  238,  235,  238,  238,  238,  238,  238,
520      238,  235,  238,  235,    0,  235,  235,  235,  235,  235,
521      235,  235,  235,  235,  235
522    } ;
523
524static yyconst flex_int16_t yy_nxt[1267] =
525    {   0,
526        4,    5,    6,    5,    5,    4,    7,    8,    9,   10,
527       11,   12,   13,   14,   14,    4,    4,   15,   15,   15,
528       16,   17,   18,   15,   19,   15,   15,   20,   15,   15,
529       15,   15,   21,   22,   15,   23,   15,   24,   25,   26,
530       17,   27,   15,   15,   28,   29,   15,   30,   15,   31,
531       32,   15,   33,   34,   15,    4,    4,   35,   36,   37,
532       38,   40,   38,   38,   44,   64,   45,   46,   46,   44,
533      108,   45,   46,   46,   68,   47,   79,   79,   79,  225,
534       47,   69,   38,   48,   38,   38,  215,   65,   66,   67,
535       41,  106,   64,   40,   47,  173,   64,  106,  174,   47,
536
537       49,   49,   49,   97,   97,   70,   73,  204,   50,   51,
538       52,  106,  191,   50,   65,   66,   67,  106,   65,   66,
539       67,  219,   41,  219,  219,   98,  219,   50,   51,   52,
540       99,   99,   99,   50,   44,  171,   54,   54,   54,  235,
541      169,   55,   56,   55,   55,   57,   55,  100,  100,   58,
542      137,  101,  101,  101,   59,  138,  138,   63,   60,  235,
543       55,   56,   55,   55,   57,   55,  171,   71,   71,   58,
544       75,   72,   72,   72,   59,   44,   64,   61,   61,   61,
545       79,   77,  145,   62,   64,   76,   47,  169,   74,   64,
546       58,   78,  170,  170,   64,   59,   63,  141,   65,   66,
547
548       67,   64,   62,  136,  136,   47,   65,   66,   67,   64,
549       58,   65,   66,   67,   64,   59,   65,   66,   67,   64,
550       80,  135,   81,   65,   66,   67,   64,   82,   79,   85,
551      110,   65,   66,   67,   64,   83,   65,   66,   67,   84,
552       64,   65,   66,   67,  109,   63,   86,   64,   65,   66,
553       67,  102,   88,   87,   64,  106,   65,   66,   67,   89,
554       64,  106,   65,   66,   67,  106,   95,   64,   90,   65,
555       66,   67,   64,   92,  235,  106,   65,   66,   67,   91,
556      235,  106,   65,   66,   67,  106,  101,  101,  101,   65,
557       66,   67,   64,   94,   65,   66,   67,  103,  103,   93,
558
559       79,  104,  104,  104,  100,  100,   53,  111,  107,  107,
560      107,   64,   43,  112,   65,   66,   67,   63,   63,   63,
561       63,  106,   64,  104,  104,  104,  235,   64,   63,  235,
562       64,  235,  235,   65,   66,   67,   72,   72,   72,  118,
563      116,  106,  235,   64,   65,   66,   67,  113,   63,   65,
564       66,   67,   65,   66,   67,   64,  235,  235,  235,   64,
565      235,  117,  235,  235,  235,   65,   66,   67,   63,  235,
566      235,  106,  119,  235,  235,  235,   59,   65,   66,   67,
567       64,   65,   66,   67,   72,   72,   72,  235,  120,  235,
568      235,  106,  114,  235,  115,  121,   59,  114,   64,  235,
569
570      235,   64,   65,   66,   67,  235,  235,   64,  235,  235,
571       64,  114,  235,  115,   64,  123,  235,  114,  235,   64,
572       65,   66,   67,   65,   66,   67,  235,  235,   64,   65,
573       66,   67,   65,   66,   67,  122,   65,   66,   67,  235,
574       64,   65,   66,   67,  124,   64,  235,  235,   64,  235,
575       65,   66,   67,   64,  235,  235,  125,  126,   64,  235,
576      235,  127,   65,   66,   67,  129,  235,   65,   66,   67,
577       65,   66,   67,   64,  128,   65,   66,   67,   64,  131,
578       65,   66,   67,  235,  235,   64,  235,  235,  235,  130,
579       64,  235,  235,   64,  235,   65,   66,   67,  132,   64,
580
581       65,   66,   67,  133,  134,  235,  235,   65,   66,   67,
582      235,  235,   65,   66,   67,   65,   66,   67,  101,  101,
583      101,   65,   66,   67,  235,  235,  140,  235,   52,  235,
584      235,  140,  235,  104,  104,  104,  235,  235,  146,  235,
585      235,   50,  235,   52,  235,  140,   50,   52,  142,  147,
586      143,  140,   64,  144,  148,  235,   64,  235,  235,   64,
587       50,  152,   52,   64,  235,  235,   50,  142,  235,  143,
588       64,  149,  235,  144,   65,   66,   67,   64,   65,   66,
589       67,   65,   66,   67,   64,   65,   66,   67,  235,   64,
590      235,  153,   65,   66,   67,  150,   64,  157,  151,   65,
591
592       66,   67,   64,  154,  235,   64,   65,   66,   67,   64,
593      155,   65,   66,   67,   64,  235,  235,   64,   65,   66,
594       67,  235,  158,  156,   65,   66,   67,   65,   66,   67,
595       64,   65,   66,   67,   64,  160,   65,   66,   67,   65,
596       66,   67,   64,  163,  159,   64,  178,  235,   64,  235,
597      161,   64,   65,   66,   67,  162,   65,   66,   67,   64,
598      235,  165,  164,   64,   65,   66,   67,   65,   66,   67,
599       65,   66,   67,   65,   66,   67,  175,  166,  235,   64,
600      235,   65,   66,   67,   64,   65,   66,   67,  167,  235,
601       64,  176,  235,  168,  180,  235,   64,  235,  235,   64,
602
603      177,   65,   66,   67,   64,  235,   65,   66,   67,   64,
604      235,  235,   65,   66,   67,  181,  182,   64,   65,   66,
605       67,   65,   66,   67,   64,  175,   65,   66,   67,  179,
606       64,   65,   66,   67,   64,  235,  235,   64,  235,   65,
607       66,   67,  235,  235,  235,   64,   65,   66,   67,  235,
608       64,  235,   65,   66,   67,   64,   65,   66,   67,   65,
609       66,   67,  183,  235,   64,  184,  186,   65,   66,   67,
610       64,  235,   65,   66,   67,   64,  235,   65,   66,   67,
611      165,   64,  185,  235,  235,   64,   65,   66,   67,  187,
612       64,  235,   65,   66,   67,   64,  235,   65,   66,   67,
613
614       64,  190,  235,   65,   66,   67,  235,   65,   66,   67,
615       64,  188,   65,   66,   67,  192,  235,   65,   66,   67,
616       64,  189,   65,   66,   67,   64,  194,  196,  235,   64,
617      193,  235,   65,   66,   67,  197,  235,   64,  195,  198,
618       64,  235,   65,   66,   67,  235,   64,   65,   66,   67,
619       64,   65,   66,   67,  235,  235,   64,  235,  235,   65,
620       66,   67,   65,   66,   67,  199,   64,  235,   65,   66,
621       67,  200,   65,   66,   67,  235,   64,  235,   65,   66,
622       67,  201,  196,  235,  235,   64,  235,  235,   65,   66,
623       67,  196,   64,  235,  235,   64,  235,  235,   65,   66,
624
625       67,   64,  205,  235,   64,  235,  203,   65,   66,   67,
626      202,  206,  235,   64,   65,   66,   67,   65,   66,   67,
627      235,  235,   64,   65,   66,   67,   65,   66,   67,   64,
628      209,  235,   64,  209,  210,   65,   66,   67,   64,  211,
629      235,  207,  235,  235,   65,   66,   67,  235,  208,   64,
630      235,   65,   66,   67,   65,   66,   67,   64,  235,  235,
631       65,   66,   67,  235,   64,  235,  212,   64,  235,  235,
632       64,   65,   66,   67,  235,  235,  235,  235,   64,   65,
633       66,   67,   64,  235,  162,   64,   65,   66,   67,   65,
634       66,   67,   65,   66,   67,  214,  216,  119,  213,   64,
635
636       65,   66,   67,   64,   65,   66,   67,   65,   66,   67,
637       64,  217,  235,  235,  220,  235,  150,  221,  235,  235,
638      235,   65,   66,   67,   64,   65,   66,   67,   64,  235,
639      235,   64,   65,   66,   67,   64,  226,  222,   64,  235,
640      223,  227,  235,  224,   64,  235,   65,   66,   67,  235,
641       65,   66,   67,   65,   66,   67,   64,   65,   66,   67,
642       65,   66,   67,   64,  235,  228,   65,   66,   67,  119,
643       64,  235,  235,   64,  235,  235,   64,  227,   65,   66,
644       67,  235,  235,  235,  235,   65,   66,   67,  229,   64,
645      232,  235,   65,   66,   67,   65,   66,   67,   65,   66,
646
647       67,  231,   64,  232,  230,  235,   64,  234,  235,  235,
648       64,   65,   66,   67,  235,  234,   64,  235,  235,  235,
649      235,  235,  235,   64,   65,   66,   67,   64,   65,   66,
650       67,  233,   65,   66,   67,   64,  235,  235,   65,   66,
651       67,  235,  235,  235,  235,   65,   66,   67,  235,   65,
652       66,   67,  235,  235,  235,  235,  235,   65,   66,   67,
653       39,   39,   39,   39,   39,   39,   39,   42,   42,   42,
654       42,   42,   42,   42,   63,   63,   63,   96,  235,   96,
655       96,   96,   96,   96,  105,  235,  105,  105,  105,  105,
656      105,   55,   55,  139,  235,  139,  172,  235,  172,  218,
657
658      218,  218,  218,  218,  218,    3,  235,  235,  235,  235,
659      235,  235,  235,  235,  235,  235,  235,  235,  235,  235,
660      235,  235,  235,  235,  235,  235,  235,  235,  235,  235,
661      235,  235,  235,  235,  235,  235,  235,  235,  235,  235,
662      235,  235,  235,  235,  235,  235,  235,  235,  235,  235,
663      235,  235,  235,  235,  235,  235,  235,  235,  235,  235,
664      235,  235,  235,  235,  235,  235
665    } ;
666
667static yyconst flex_int16_t yy_chk[1267] =
668    {   0,
669        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
670        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
671        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
672        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
673        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
674        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
675        5,    7,    5,    5,    9,   15,    9,    9,    9,   10,
676      242,   10,   10,   10,   16,    9,   23,   23,   23,  215,
677       10,   16,   38,   10,   38,   38,  204,   15,   15,   15,
678        7,   55,   16,   39,    9,  141,   18,   56,  141,   10,
679
680       11,   11,   11,   43,   43,   16,   18,  191,   11,   11,
681       11,   55,  174,   11,   16,   16,   16,   56,   18,   18,
682       18,  209,   39,  219,  209,   43,  219,   11,   11,   11,
683       45,   45,   45,   11,   13,  172,   13,   13,   13,   99,
684      170,   13,   13,   13,   13,   13,   13,   47,   47,   13,
685       97,   47,   47,   47,   13,   97,   97,  145,   13,   99,
686       13,   13,   13,   13,   13,   13,  139,   17,   17,   13,
687       20,   17,   17,   17,   13,   14,   19,   14,   14,   14,
688      135,   21,  110,   14,   20,   20,   14,  138,   19,   21,
689       14,   22,  138,  138,   17,   14,  109,  102,   19,   19,
690
691       19,   24,   14,   98,   96,   14,   20,   20,   20,   22,
692       14,   21,   21,   21,   25,   14,   17,   17,   17,   27,
693       24,   94,   25,   24,   24,   24,   26,   26,   93,   27,
694       67,   22,   22,   22,   28,   26,   25,   25,   25,   26,
695       29,   27,   27,   27,   66,   65,   28,   30,   26,   26,
696       26,   48,   30,   29,   31,  142,   28,   28,   28,   31,
697       32,  143,   29,   29,   29,   54,   42,   33,   32,   30,
698       30,   30,   34,   34,   54,  142,   31,   31,   31,   33,
699       41,  143,   32,   32,   32,   54,  100,  100,  100,   33,
700       33,   33,   63,   37,   34,   34,   34,   51,   51,   36,
701
702       35,   51,   51,   51,   57,   57,   12,   68,   57,   57,
703       57,   68,    8,   69,   63,   63,   63,   64,   64,   64,
704       64,   57,   69,  103,  103,  103,    3,   73,   64,    0,
705       70,    0,    0,   68,   68,   68,   71,   71,   71,   75,
706       73,   57,    0,   75,   69,   69,   69,   70,   64,   73,
707       73,   73,   70,   70,   70,   74,    0,    0,    0,   71,
708        0,   74,    0,    0,    0,   75,   75,   75,   64,    0,
709        0,  108,   76,    0,    0,    0,  108,   74,   74,   74,
710       76,   71,   71,   71,   72,   72,   72,    0,   77,    0,
711        0,  108,   72,    0,   72,   78,  108,   72,   77,    0,
712
713        0,   78,   76,   76,   76,    0,    0,   72,    0,    0,
714       79,   72,    0,   72,   81,   81,    0,   72,    0,   80,
715       77,   77,   77,   78,   78,   78,    0,    0,   82,   72,
716       72,   72,   79,   79,   79,   80,   81,   81,   81,    0,
717       84,   80,   80,   80,   82,   83,    0,    0,   85,    0,
718       82,   82,   82,   87,    0,    0,   83,   84,   86,    0,
719        0,   85,   84,   84,   84,   87,    0,   83,   83,   83,
720       85,   85,   85,   88,   86,   87,   87,   87,   89,   89,
721       86,   86,   86,    0,    0,   90,    0,    0,    0,   88,
722       92,    0,    0,   91,    0,   88,   88,   88,   90,  114,
723
724       89,   89,   89,   91,   92,    0,    0,   90,   90,   90,
725        0,    0,   92,   92,   92,   91,   91,   91,  101,  101,
726      101,  114,  114,  114,    0,    0,  101,    0,  101,    0,
727        0,  101,    0,  104,  104,  104,  107,  107,  111,    0,
728        0,  104,    0,  104,    0,  101,  104,  101,  107,  112,
729      107,  101,  113,  107,  113,    0,  111,    0,    0,  115,
730      104,  118,  104,  112,    0,    0,  104,  107,    0,  107,
731      116,  116,    0,  107,  113,  113,  113,  118,  111,  111,
732      111,  115,  115,  115,  119,  112,  112,  112,    0,  117,
733        0,  120,  116,  116,  116,  117,  124,  124,  117,  118,
734
735      118,  118,  120,  121,    0,  122,  119,  119,  119,  123,
736      122,  117,  117,  117,  121,    0,    0,  125,  124,  124,
737      124,    0,  125,  123,  120,  120,  120,  122,  122,  122,
738      149,  123,  123,  123,  127,  127,  121,  121,  121,  125,
739      125,  125,  126,  130,  126,  128,  149,    0,  129,    0,
740      128,  131,  149,  149,  149,  129,  127,  127,  127,  130,
741        0,  131,  130,  132,  126,  126,  126,  128,  128,  128,
742      129,  129,  129,  131,  131,  131,  146,  132,    0,  133,
743        0,  130,  130,  130,  134,  132,  132,  132,  133,    0,
744      148,  147,    0,  134,  152,    0,  146,    0,    0,  147,
745
746      148,  133,  133,  133,  150,    0,  134,  134,  134,  152,
747        0,    0,  148,  148,  148,  153,  154,  151,  146,  146,
748      146,  147,  147,  147,  153,  157,  150,  150,  150,  151,
749      155,  152,  152,  152,  154,    0,    0,  156,    0,  151,
750      151,  151,    0,    0,    0,  157,  153,  153,  153,    0,
751      158,    0,  155,  155,  155,  159,  154,  154,  154,  156,
752      156,  156,  158,    0,  160,  159,  163,  157,  157,  157,
753      162,    0,  158,  158,  158,  161,    0,  159,  159,  159,
754      160,  163,  161,    0,    0,  164,  160,  160,  160,  164,
755      165,    0,  162,  162,  162,  166,    0,  161,  161,  161,
756
757      168,  168,    0,  163,  163,  163,    0,  164,  164,  164,
758      167,  166,  165,  165,  165,  176,    0,  166,  166,  166,
759      176,  167,  168,  168,  168,  177,  178,  180,    0,  179,
760      177,    0,  167,  167,  167,  181,    0,  178,  179,  182,
761      180,    0,  176,  176,  176,    0,  181,  177,  177,  177,
762      183,  179,  179,  179,    0,    0,  182,    0,    0,  178,
763      178,  178,  180,  180,  180,  183,  184,    0,  181,  181,
764      181,  184,  183,  183,  183,    0,  185,    0,  182,  182,
765      182,  185,  186,    0,    0,  187,    0,    0,  184,  184,
766      184,  187,  188,    0,    0,  186,    0,    0,  185,  185,
767
768      185,  189,  192,    0,  190,    0,  190,  187,  187,  187,
769      189,  193,    0,  192,  188,  188,  188,  186,  186,  186,
770        0,    0,  193,  189,  189,  189,  190,  190,  190,  194,
771      196,    0,  195,  196,  197,  192,  192,  192,  197,  198,
772        0,  194,    0,    0,  193,  193,  193,    0,  195,  198,
773        0,  194,  194,  194,  195,  195,  195,  199,    0,    0,
774      197,  197,  197,    0,  196,    0,  199,  200,    0,    0,
775      201,  198,  198,  198,    0,    0,    0,    0,  208,  199,
776      199,  199,  202,    0,  201,  203,  196,  196,  196,  200,
777      200,  200,  201,  201,  201,  203,  205,  208,  202,  206,
778
779      208,  208,  208,  205,  202,  202,  202,  203,  203,  203,
780      207,  206,    0,    0,  210,    0,  207,  211,    0,    0,
781        0,  206,  206,  206,  212,  205,  205,  205,  210,    0,
782        0,  211,  207,  207,  207,  213,  216,  212,  214,    0,
783      213,  220,    0,  214,  216,    0,  212,  212,  212,    0,
784      210,  210,  210,  211,  211,  211,  220,  213,  213,  213,
785      214,  214,  214,  217,    0,  221,  216,  216,  216,  217,
786      221,    0,    0,  223,    0,    0,  222,  223,  220,  220,
787      220,    0,    0,    0,    0,  217,  217,  217,  222,  224,
788      228,    0,  221,  221,  221,  223,  223,  223,  222,  222,
789
790      222,  226,  227,  230,  224,    0,  226,  231,    0,    0,
791      228,  224,  224,  224,    0,  233,  229,    0,    0,    0,
792        0,    0,    0,  230,  227,  227,  227,  231,  226,  226,
793      226,  229,  228,  228,  228,  233,    0,    0,  229,  229,
794      229,    0,    0,    0,    0,  230,  230,  230,    0,  231,
795      231,  231,    0,    0,    0,    0,    0,  233,  233,  233,
796      236,  236,  236,  236,  236,  236,  236,  237,  237,  237,
797      237,  237,  237,  237,  238,  238,  238,  239,    0,  239,
798      239,  239,  239,  239,  240,    0,  240,  240,  240,  240,
799      240,  241,  241,  243,    0,  243,  244,    0,  244,  245,
800
801      245,  245,  245,  245,  245,  235,  235,  235,  235,  235,
802      235,  235,  235,  235,  235,  235,  235,  235,  235,  235,
803      235,  235,  235,  235,  235,  235,  235,  235,  235,  235,
804      235,  235,  235,  235,  235,  235,  235,  235,  235,  235,
805      235,  235,  235,  235,  235,  235,  235,  235,  235,  235,
806      235,  235,  235,  235,  235,  235,  235,  235,  235,  235,
807      235,  235,  235,  235,  235,  235
808    } ;
809
810static yy_state_type yy_last_accepting_state;
811static char *yy_last_accepting_cpos;
812
813extern int ncg_flex_debug;
814int ncg_flex_debug = 0;
815
816/* The intent behind this definition is that it'll catch
817 * any uses of REJECT which flex missed.
818 */
819#define REJECT reject_used_but_not_detected
820#define yymore() yymore_used_but_not_detected
821#define YY_MORE_ADJ 0
822#define YY_RESTORE_YY_MORE_OFFSET
823char *ncgtext;
824#line 1 "ncgen.l"
825#line 2 "ncgen.l"
826/*********************************************************************
827 *   Copyright 1993, UCAR/Unidata
828 *   See netcdf/COPYRIGHT file for copying and redistribution conditions.
829 *   $Id: ncgen.l,v 1.24 2009/12/29 18:42:36 dmh Exp $
830 *********************************************************************/
831
832/* Problems:
8331. Ideally, we assume the input is true ut8.
834   Unfortunately, we may actually get iso-latin-8859-1.
835   This means that there will be ambiguity about the characters
836   in the range 128-255 because they will look like n-byte unicode
837   when they are 1-byte 8859 characters. Because of our encoding,
838   8859 characters above 128 will be handles as n-byte utf8 and so
839   will probably not lex correctly.
840   Solution: assume utf8 and note in the documentation that
841   ISO8859 is specifically unsupported.
8422. The netcdf function NC_check_name in string.c must be modified to
843   conform to the use of UTF8.
8443. We actually have three tests for UTF8 of increasing correctness
845   (in the sense that the least correct will allow some sequences that
846    are technically illegal UTF8).
847   The tests are derived from the table at
848     http://www.w3.org/2005/03/23-lex-U
849   We include lexical definitions for all three, but use the second version.
850*/
851
852/* lex specification for tokens for ncgen */
853
854/* Fill value used by ncdump from version 2.4 and later.  Should match
855   definition of FILL_STRING in ../ncdump/vardata.h */
856#define FILL_STRING "_"
857#define XDR_INT_MIN (-2147483647-1)
858#define XDR_INT_MAX 2147483647
859
860char errstr[100]; /* for short error messages */
861
862#include <stdio.h>
863#include <string.h>
864#include <ctype.h>
865#include "genlib.h"
866#include "ncgentab.h"
867
868#define YY_BREAK                /* defining as nothing eliminates unreachable
869    statement warnings from flex output,
870                                   but make sure every action ends with
871                                   "return" or "break"! */
872
873/* The most correct (validating) version of UTF8 character set
874   (Taken from: http://www.w3.org/2005/03/23-lex-U)
875
876The lines of the expression cover the UTF8 characters as follows:
8771. non-overlong 2-byte
8782. excluding overlongs
8793. straight 3-byte
8804. excluding surrogates
8815. straight 3-byte
8826. planes 1-3
8837. planes 4-15
8848. plane 16
885
886UTF8   ([\xC2-\xDF][\x80-\xBF])                       \
887     | (\xE0[\xA0-\xBF][\x80-\xBF])                   \
888     | ([\xE1-\xEC][\x80-\xBF][\x80-\xBF])            \
889     | (\xED[\x80-\x9F][\x80-\xBF])                   \
890     | ([\xEE-\xEF][\x80-\xBF][\x80-\xBF])            \
891     | (\xF0[\x90-\xBF][\x80-\xBF][\x80-\xBF])        \
892     | ([\xF1-\xF3][\x80-\xBF][\x80-\xBF][\x80-\xBF]) \
893     | (\xF4[\x80-\x8F][\x80-\xBF][\x80-\xBF])        \
894
895*/
896/* Wish there was some way to ifdef lex files */
897/*The most relaxed version of UTF8 (not used)
898UTF8 ([\xC0-\xD6].)|([\xE0-\xEF]..)|([\xF0-\xF7]...)
899*/
900/*The partially relaxed version of UTF8, and the one used here */
901/* The old definition of ID
902ID ([A-Za-z_]|{UTF8})([A-Z.@#\[\]a-z_0-9+-]|{UTF8})*
903*/
904/* Don't permit control characters or '/' in names, but other special
905   chars OK if escaped.  Note that to preserve backwards
906   compatibility, none of the characters _.@+- should be escaped, as
907   they were previously permitted in names without escaping.  */
908/* New definition to conform to a subset of string.c */
909/* Note: this definition of string will work for utf8 as well,
910   although it is a very relaxed definition
911*/
912#line 913 "lex.ncg.c"
913
914#define INITIAL 0
915
916#ifndef YY_NO_UNISTD_H
917/* Special case for "unistd.h", since it is non-ANSI. We include it way
918 * down here because we want the user's section 1 to have been scanned first.
919 * The user has a chance to override it with an option.
920 */
921#include <unistd.h>
922#endif
923
924#ifndef YY_EXTRA_TYPE
925#define YY_EXTRA_TYPE void *
926#endif
927
928static int yy_init_globals (void );
929
930/* Accessor methods to globals.
931   These are made visible to non-reentrant scanners for convenience. */
932
933int ncglex_destroy (void );
934
935int ncgget_debug (void );
936
937void ncgset_debug (int debug_flag  );
938
939YY_EXTRA_TYPE ncgget_extra (void );
940
941void ncgset_extra (YY_EXTRA_TYPE user_defined  );
942
943FILE *ncgget_in (void );
944
945void ncgset_in  (FILE * in_str  );
946
947FILE *ncgget_out (void );
948
949void ncgset_out  (FILE * out_str  );
950
951int ncgget_leng (void );
952
953char *ncgget_text (void );
954
955int ncgget_lineno (void );
956
957void ncgset_lineno (int line_number  );
958
959/* Macros after this point can all be overridden by user definitions in
960 * section 1.
961 */
962
963#ifndef YY_SKIP_YYWRAP
964#ifdef __cplusplus
965extern "C" int ncgwrap (void );
966#else
967extern int ncgwrap (void );
968#endif
969#endif
970
971    static void yyunput (int c,char *buf_ptr  );
972
973#ifndef yytext_ptr
974static void yy_flex_strncpy (char *,yyconst char *,int );
975#endif
976
977#ifdef YY_NEED_STRLEN
978static int yy_flex_strlen (yyconst char * );
979#endif
980
981#ifndef YY_NO_INPUT
982
983#ifdef __cplusplus
984static int yyinput (void );
985#else
986static int input (void );
987#endif
988
989#endif
990
991/* Amount of stuff to slurp up with each read. */
992#ifndef YY_READ_BUF_SIZE
993#define YY_READ_BUF_SIZE 8192
994#endif
995
996/* Copy whatever the last rule matched to the standard output. */
997#ifndef ECHO
998/* This used to be an fputs(), but since the string might contain NUL's,
999 * we now use fwrite().
1000 */
1001#define ECHO do { if (fwrite( ncgtextncgleng, 1, ncgout )) {} } while (0)
1002#endif
1003
1004/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1005 * is returned in "result".
1006 */
1007#ifndef YY_INPUT
1008#define YY_INPUT(buf,result,max_size) \
1009 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1010 { \
1011 int c = '*'; \
1012 unsigned n; \
1013 for ( n = 0; n < max_size && \
1014      (c = getc( ncgin )) != EOF && c != '\n'; ++n ) \
1015 buf[n] = (char) c; \
1016 if ( c == '\n' ) \
1017 buf[n++] = (char) c; \
1018 if ( c == EOF && ferror( ncgin ) ) \
1019 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1020 result = n; \
1021 } \
1022 else \
1023 { \
1024 errno=0; \
1025 while ( (result = fread(buf, 1, max_sizencgin))==0 && ferror(ncgin)) \
1026 { \
1027 if( errno != EINTR) \
1028 { \
1029 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1030 break; \
1031 } \
1032 errno=0; \
1033 clearerr(ncgin); \
1034 } \
1035 }\
1036\
1037
1038#endif
1039
1040/* No semi-colon after return; correct usage is to write "yyterminate();" -
1041 * we don't want an extra ';' after the "return" because that will cause
1042 * some compilers to complain about unreachable statements.
1043 */
1044#ifndef yyterminate
1045#define yyterminate() return YY_NULL
1046#endif
1047
1048/* Number of entries by which start-condition stack grows. */
1049#ifndef YY_START_STACK_INCR
1050#define YY_START_STACK_INCR 25
1051#endif
1052
1053/* Report a fatal error. */
1054#ifndef YY_FATAL_ERROR
1055#define YY_FATAL_ERROR(msgyy_fatal_errormsg )
1056#endif
1057
1058/* end tables serialization structures and prototypes */
1059
1060/* Default declaration of generated scanner - a define so the user can
1061 * easily add parameters.
1062 */
1063#ifndef YY_DECL
1064#define YY_DECL_IS_OURS 1
1065
1066extern int ncglex (void);
1067
1068#define YY_DECL int ncglex (void)
1069#endif /* !YY_DECL */
1070
1071/* Code executed at the beginning of each rule, after ncgtext and ncgleng
1072 * have been set up.
1073 */
1074#ifndef YY_USER_ACTION
1075#define YY_USER_ACTION
1076#endif
1077
1078/* Code executed at the end of each rule. */
1079#ifndef YY_BREAK
1080#define YY_BREAK break;
1081#endif
1082
1083#define YY_RULE_SETUP \
1084 YY_USER_ACTION
1085
1086/** The main scanner function which does all the work.
1087 */
1088YY_DECL
1089{
1090 register yy_state_type yy_current_state;
1091 register char *yy_cp, *yy_bp;
1092 register int yy_act;
1093
1094#line 107 "ncgen.l"
1095
1096#line 1097 "lex.ncg.c"
1097
1098 if ( !(yy_init) )
1099 {
1100 (yy_init) = 1;
1101
1102#ifdef YY_USER_INIT
1103 YY_USER_INIT;
1104#endif
1105
1106 if ( ! (yy_start) )
1107 (yy_start) = 1; /* first start state */
1108
1109 if ( ! ncgin )
1110 ncgin = stdin;
1111
1112 if ( ! ncgout )
1113 ncgout = stdout;
1114
1115 if ( ! YY_CURRENT_BUFFER ) {
1116 ncgensure_buffer_stack ();
1117 YY_CURRENT_BUFFER_LVALUE =
1118 ncg_create_buffer(ncgin,YY_BUF_SIZE );
1119 }
1120
1121 ncg_load_buffer_state( );
1122 }
1123
1124 while ( 1 ) /* loops until end-of-file is reached */
1125 {
1126 yy_cp = (yy_c_buf_p);
1127
1128 /* Support of ncgtext. */
1129 *yy_cp = (yy_hold_char);
1130
1131 /* yy_bp points to the position in yy_ch_buf of the start of
1132  * the current run.
1133  */
1134 yy_bp = yy_cp;
1135
1136 yy_current_state = (yy_start);
1137yy_match:
1138 do
1139 {
1140 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1141 if ( yy_accept[yy_current_state] )
1142 {
1143 (yy_last_accepting_state) = yy_current_state;
1144 (yy_last_accepting_cpos) = yy_cp;
1145 }
1146 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1147 {
1148 yy_current_state = (int) yy_def[yy_current_state];
1149 if ( yy_current_state >= 236 )
1150 yy_c = yy_meta[(unsigned int) yy_c];
1151 }
1152 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1153 ++yy_cp;
1154 }
1155 while ( yy_base[yy_current_state] != 1206 );
1156
1157yy_find_action:
1158 yy_act = yy_accept[yy_current_state];
1159 if ( yy_act == 0 )
1160 { /* have to back up */
1161 yy_cp = (yy_last_accepting_cpos);
1162 yy_current_state = (yy_last_accepting_state);
1163 yy_act = yy_accept[yy_current_state];
1164 }
1165
1166 YY_DO_BEFORE_ACTION;
1167
1168do_action: /* This label is used only to access EOF actions. */
1169
1170 switch ( yy_act )
1171 { /* beginning of action switch */
1172 case 0: /* must back up */
1173 /* undo the effects of YY_DO_BEFORE_ACTION */
1174 *yy_cp = (yy_hold_char);
1175 yy_cp = (yy_last_accepting_cpos);
1176 yy_current_state = (yy_last_accepting_state);
1177 goto yy_find_action;
1178
1179case 1:
1180YY_RULE_SETUP
1181#line 108 "ncgen.l"
1182{ /* comment */
1183                          break;
1184                        }
1185 YY_BREAK
1186case 2:
1187/* rule 2 can match eol */
1188YY_RULE_SETUP
1189#line 112 "ncgen.l"
1190{
1191  if(ncgleng > MAXTRST) {
1192 yyerror("string too long, truncated\n");
1193         ncgtext[MAXTRST-1] = '\0';
1194  }
1195  expand_escapes(termstring,(char *)ncgtext,ncgleng);
1196    return (TERMSTRING);
1197         }
1198 YY_BREAK
1199case 3:
1200YY_RULE_SETUP
1201#line 121 "ncgen.l"
1202{return (FLOAT_K);}
1203 YY_BREAK
1204case 4:
1205YY_RULE_SETUP
1206#line 122 "ncgen.l"
1207{return (CHAR_K);}
1208 YY_BREAK
1209case 5:
1210YY_RULE_SETUP
1211#line 123 "ncgen.l"
1212{return (BYTE_K);}
1213 YY_BREAK
1214case 6:
1215YY_RULE_SETUP
1216#line 124 "ncgen.l"
1217{return (SHORT_K);}
1218 YY_BREAK
1219case 7:
1220YY_RULE_SETUP
1221#line 125 "ncgen.l"
1222{return (INT_K);}
1223 YY_BREAK
1224case 8:
1225YY_RULE_SETUP
1226#line 126 "ncgen.l"
1227{return (DOUBLE_K);}
1228 YY_BREAK
1229case 9:
1230YY_RULE_SETUP
1231#line 127 "ncgen.l"
1232{int_val = -1;
1233  return (NC_UNLIMITED_K);}
1234 YY_BREAK
1235case 10:
1236YY_RULE_SETUP
1237#line 130 "ncgen.l"
1238{return (DIMENSIONS);}
1239 YY_BREAK
1240case 11:
1241YY_RULE_SETUP
1242#line 131 "ncgen.l"
1243{return (VARIABLES);}
1244 YY_BREAK
1245case 12:
1246YY_RULE_SETUP
1247#line 132 "ncgen.l"
1248{return (DATA);}
1249 YY_BREAK
1250case 13:
1251/* rule 13 can match eol */
1252YY_RULE_SETUP
1253#line 133 "ncgen.l"
1254{
1255 char *s = (char*)ncgtext+strlen("netcdf");
1256 char *t = (char*)ncgtext+ncgleng-1;
1257 while (isspace(*s))
1258 s++;
1259 while (isspace(*t))
1260 t--;
1261 t++;
1262                if (t-s+1 < 1) {
1263                        yyerror("netCDF name required");
1264                        return (DATA); /* generate syntax error */
1265                }
1266 netcdfname = (char *) emalloc(t-s+1);
1267 (void) strncpy(netcdfnamest-s);
1268 netcdfname[t-s] = '\0';
1269 deescapify(netcdfname);  /* so "\5foo" becomes "5foo", for example */
1270 return (NETCDF);
1271 }
1272 YY_BREAK
1273case 14:
1274YY_RULE_SETUP
1275#line 151 "ncgen.l"
1276{ /* missing value (pre-2.4 backward compatibility) */
1277                if (ncgtext[0] == '-') {
1278     double_val = -NC_FILL_DOUBLE;
1279                } else {
1280     double_val = NC_FILL_DOUBLE;
1281                }
1282 return (DOUBLE_CONST);
1283 }
1284 YY_BREAK
1285case 15:
1286YY_RULE_SETUP
1287#line 159 "ncgen.l"
1288{ /* missing value (pre-2.4 backward compatibility) */
1289                if (ncgtext[0] == '-') {
1290     float_val = -NC_FILL_FLOAT;
1291                } else {
1292     float_val = NC_FILL_FLOAT;
1293                }
1294 return (FLOAT_CONST);
1295 }
1296 YY_BREAK
1297case 16:
1298YY_RULE_SETUP
1299#line 167 "ncgen.l"
1300{
1301                if (STREQ((char *)ncgtextFILL_STRING))
1302         return (FILLVALUE);
1303 if ((yylval = lookup((char *)ncgtext)) == NULL) {
1304 yylval = install((char *)ncgtext);
1305 }
1306 return (IDENT);
1307 }
1308 YY_BREAK
1309case 17:
1310/* rule 17 can match eol */
1311YY_RULE_SETUP
1312#line 176 "ncgen.l"
1313{
1314 lineno++ ;
1315                break;
1316 }
1317 YY_BREAK
1318case 18:
1319YY_RULE_SETUP
1320#line 181 "ncgen.l"
1321{
1322                int ii;
1323 if (sscanf((char*)ncgtext, "%d", &ii) != 1) {
1324     sprintf(errstr,"bad byte constant: %s",(char*)ncgtext);
1325     yyerror(errstr);
1326 }
1327                byte_val = ii;
1328 if (ii != (int)byte_val) {
1329     sprintf(errstr,"byte constant out of range (-128,127): %s",(char*)ncgtext);
1330     yyerror(errstr);
1331 }
1332 return (BYTE_CONST);
1333                }
1334 YY_BREAK
1335case 19:
1336YY_RULE_SETUP
1337#line 195 "ncgen.l"
1338{
1339 if (sscanf((char*)ncgtext, "%le", &double_val) != 1) {
1340     sprintf(errstr,"bad long or double constant: %s",(char*)ncgtext);
1341     yyerror(errstr);
1342 }
1343                return (DOUBLE_CONST);
1344                }
1345 YY_BREAK
1346case 20:
1347YY_RULE_SETUP
1348#line 202 "ncgen.l"
1349{
1350 if (sscanf((char*)ncgtext, "%e", &float_val) != 1) {
1351     sprintf(errstr,"bad float constant: %s",(char*)ncgtext);
1352     yyerror(errstr);
1353 }
1354                return (FLOAT_CONST);
1355                }
1356 YY_BREAK
1357case 21:
1358YY_RULE_SETUP
1359#line 209 "ncgen.l"
1360{
1361 if (sscanf((char*)ncgtext, "%hd", &short_val) != 1) {
1362     sprintf(errstr,"bad short constant: %s",(char*)ncgtext);
1363     yyerror(errstr);
1364 }
1365 return (SHORT_CONST);
1366         }
1367 YY_BREAK
1368case 22:
1369YY_RULE_SETUP
1370#line 216 "ncgen.l"
1371{
1372     char *ptr;
1373                errno = 0;
1374 double_val = strtod((char*)ncgtext, &ptr);
1375 if (errno != 0 && double_val == 0.0) {
1376     sprintf(errstr,"bad numerical constant: %s",(char*)ncgtext);
1377     yyerror(errstr);
1378 }
1379                if (double_val < XDR_INT_MIN ||double_val > XDR_INT_MAX) {
1380                    return DOUBLE_CONST;
1381                } else {
1382                    int_val = (int) double_val;
1383                    return INT_CONST;
1384                }
1385         }
1386 YY_BREAK
1387case 23:
1388YY_RULE_SETUP
1389#line 231 "ncgen.l"
1390{
1391     char *ptr;
1392                long long_val;
1393                errno = 0;
1394 long_val = strtol((char*)ncgtext, &ptr, 0);
1395 if (errno != 0) {
1396     sprintf(errstr,"bad long constant: %s",(char*)ncgtext);
1397     yyerror(errstr);
1398 }
1399                if (long_val < XDR_INT_MIN || long_val > XDR_INT_MAX) {
1400                    double_val = (double) long_val;
1401                    return DOUBLE_CONST;
1402                } else {
1403                    int_val = (int) long_val;
1404                    return INT_CONST;
1405                }
1406         }
1407 YY_BREAK
1408case 24:
1409/* rule 24 can match eol */
1410YY_RULE_SETUP
1411#line 248 "ncgen.l"
1412{
1413         (void) sscanf((char*)&ncgtext[1],"%c",&byte_val);
1414 return (BYTE_CONST);
1415                }
1416 YY_BREAK
1417case 25:
1418YY_RULE_SETUP
1419#line 252 "ncgen.l"
1420{
1421 byte_val = (char) strtol((char*)&ncgtext[2], (char **) 0, 8);
1422 return (BYTE_CONST);
1423                }
1424 YY_BREAK
1425case 26:
1426YY_RULE_SETUP
1427#line 256 "ncgen.l"
1428{
1429 byte_val = (char) strtol((char*)&ncgtext[3], (char **) 0, 16);
1430 return (BYTE_CONST);
1431                }
1432 YY_BREAK
1433case 27:
1434YY_RULE_SETUP
1435#line 260 "ncgen.l"
1436{
1437        switch ((char)ncgtext[2]) {
1438           case 'a': byte_val = '\007'; break; /* not everyone under-
1439        * stands '\a' yet */
1440                case 'b': byte_val = '\b'; break;
1441   case 'f': byte_val = '\f'; break;
1442   case 'n': byte_val = '\n'; break;
1443   case 'r': byte_val = '\r'; break;
1444   case 't': byte_val = '\t'; break;
1445   case 'v': byte_val = '\v'; break;
1446   case '\\': byte_val = '\\'; break;
1447   case '?': byte_val = '\177'; break;
1448   case '\'': byte_val = '\''; break;
1449   default: byte_val = (char)ncgtext[2];
1450            }
1451 return (BYTE_CONST);
1452                }
1453 YY_BREAK
1454case 28:
1455YY_RULE_SETUP
1456#line 278 "ncgen.l"
1457{ /* whitespace */
1458   break;
1459 }
1460 YY_BREAK
1461case 29:
1462YY_RULE_SETUP
1463#line 281 "ncgen.l"
1464{/* Note: this next rule will not work for UTF8 characters */
1465 return (ncgtext[0]) ;
1466 }
1467 YY_BREAK
1468case 30:
1469YY_RULE_SETUP
1470#line 285 "ncgen.l"
1471ECHO;
1472 YY_BREAK
1473#line 1474 "lex.ncg.c"
1474case YY_STATE_EOF(INITIAL):
1475 yyterminate();
1476
1477 case YY_END_OF_BUFFER:
1478 {
1479 /* Amount of text matched not including the EOB char. */
1480 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1481
1482 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1483 *yy_cp = (yy_hold_char);
1484 YY_RESTORE_YY_MORE_OFFSET
1485
1486 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1487 {
1488 /* We're scanning a new file or input source.  It's
1489  * possible that this happened because the user
1490  * just pointed ncgin at a new source and called
1491  * ncglex().  If so, then we have to assure
1492  * consistency between YY_CURRENT_BUFFER and our
1493  * globals.  Here is the right place to do so, because
1494  * this is the first action (other than possibly a
1495  * back-up) that will match for the new input source.
1496  */
1497 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1498 YY_CURRENT_BUFFER_LVALUE->yy_input_file = ncgin;
1499 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1500 }
1501
1502 /* Note that here we test for yy_c_buf_p "<=" to the position
1503  * of the first EOB in the buffer, since yy_c_buf_p will
1504  * already have been incremented past the NUL character
1505  * (since all states make transitions on EOB to the
1506  * end-of-buffer state).  Contrast this with the test
1507  * in input().
1508  */
1509 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1510 { /* This was really a NUL. */
1511 yy_state_type yy_next_state;
1512
1513 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1514
1515 yy_current_state = yy_get_previous_state(  );
1516
1517 /* Okay, we're now positioned to make the NUL
1518  * transition.  We couldn't have
1519  * yy_get_previous_state() go ahead and do it
1520  * for us because it doesn't know how to deal
1521  * with the possibility of jamming (and we don't
1522  * want to build jamming into it because then it
1523  * will run more slowly).
1524  */
1525
1526 yy_next_state = yy_try_NUL_transyy_current_state );
1527
1528 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1529
1530 if ( yy_next_state )
1531 {
1532 /* Consume the NUL. */
1533 yy_cp = ++(yy_c_buf_p);
1534 yy_current_state = yy_next_state;
1535 goto yy_match;
1536 }
1537
1538 else
1539 {
1540 yy_cp = (yy_c_buf_p);
1541 goto yy_find_action;
1542 }
1543 }
1544
1545 else switch ( yy_get_next_buffer(  ) )
1546 {
1547 case EOB_ACT_END_OF_FILE:
1548 {
1549 (yy_did_buffer_switch_on_eof) = 0;
1550
1551 if ( ncgwrap( ) )
1552 {
1553 /* Note: because we've taken care in
1554  * yy_get_next_buffer() to have set up
1555  * ncgtext, we can now set up
1556  * yy_c_buf_p so that if some total
1557  * hoser (like flex itself) wants to
1558  * call the scanner after we return the
1559  * YY_NULL, it'll still work - another
1560  * YY_NULL will get returned.
1561  */
1562 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1563
1564 yy_act = YY_STATE_EOF(YY_START);
1565 goto do_action;
1566 }
1567
1568 else
1569 {
1570 if ( ! (yy_did_buffer_switch_on_eof) )
1571 YY_NEW_FILE;
1572 }
1573 break;
1574 }
1575
1576 case EOB_ACT_CONTINUE_SCAN:
1577 (yy_c_buf_p) =
1578 (yytext_ptr) + yy_amount_of_matched_text;
1579
1580 yy_current_state = yy_get_previous_state(  );
1581
1582 yy_cp = (yy_c_buf_p);
1583 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1584 goto yy_match;
1585
1586 case EOB_ACT_LAST_MATCH:
1587 (yy_c_buf_p) =
1588 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1589
1590 yy_current_state = yy_get_previous_state(  );
1591
1592 yy_cp = (yy_c_buf_p);
1593 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1594 goto yy_find_action;
1595 }
1596 break;
1597 }
1598
1599 default:
1600 YY_FATAL_ERROR(
1601 "fatal flex scanner internal error--no action found" );
1602 } /* end of action switch */
1603 } /* end of scanning one token */
1604} /* end of ncglex */
1605
1606/* yy_get_next_buffer - try to read in a new buffer
1607 *
1608 * Returns a code representing an action:
1609 * EOB_ACT_LAST_MATCH -
1610 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1611 * EOB_ACT_END_OF_FILE - end of file
1612 */
1613static int yy_get_next_buffer (void)
1614{
1615     register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1616 register char *source = (yytext_ptr);
1617 register int number_to_movei;
1618 int ret_val;
1619
1620 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1621 YY_FATAL_ERROR(
1622 "fatal flex scanner internal error--end of buffer missed" );
1623
1624 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1625 { /* Don't try to fill the buffer, so this is an EOF. */
1626 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1627 {
1628 /* We matched a single character, the EOB, so
1629  * treat this as a final EOF.
1630  */
1631 return EOB_ACT_END_OF_FILE;
1632 }
1633
1634 else
1635 {
1636 /* We matched some text prior to the EOB, first
1637  * process it.
1638  */
1639 return EOB_ACT_LAST_MATCH;
1640 }
1641 }
1642
1643 /* Try to read more data. */
1644
1645 /* First move last chars to start of buffer. */
1646 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1647
1648 for ( i = 0; i < number_to_move; ++i )
1649 *(dest++) = *(source++);
1650
1651 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1652 /* don't do the read, it's not guaranteed to return an EOF,
1653  * just force an EOF
1654  */
1655 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1656
1657 else
1658 {
1659 int num_to_read =
1660 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1661
1662 while ( num_to_read <= 0 )
1663 { /* Not enough room in the buffer - grow it. */
1664
1665 /* just a shorter name for the current buffer */
1666 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1667
1668 int yy_c_buf_p_offset =
1669 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1670
1671 if ( b->yy_is_our_buffer )
1672 {
1673 int new_size = b->yy_buf_size * 2;
1674
1675 if ( new_size <= 0 )
1676 b->yy_buf_size += b->yy_buf_size / 8;
1677 else
1678 b->yy_buf_size *= 2;
1679
1680 b->yy_ch_buf = (char *)
1681 /* Include room in for 2 EOB chars. */
1682 ncgrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1683 }
1684 else
1685 /* Can't grow it, we don't own it. */
1686 b->yy_ch_buf = 0;
1687
1688 if ( ! b->yy_ch_buf )
1689 YY_FATAL_ERROR(
1690 "fatal error - scanner input buffer overflow" );
1691
1692 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1693
1694 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1695 number_to_move - 1;
1696
1697 }
1698
1699 if ( num_to_read > YY_READ_BUF_SIZE )
1700 num_to_read = YY_READ_BUF_SIZE;
1701
1702 /* Read in more data. */
1703 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1704 (yy_n_chars), (size_t) num_to_read );
1705
1706 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1707 }
1708
1709 if ( (yy_n_chars) == 0 )
1710 {
1711 if ( number_to_move == YY_MORE_ADJ )
1712 {
1713 ret_val = EOB_ACT_END_OF_FILE;
1714 ncgrestart(ncgin  );
1715 }
1716
1717 else
1718 {
1719 ret_val = EOB_ACT_LAST_MATCH;
1720 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1721 YY_BUFFER_EOF_PENDING;
1722 }
1723 }
1724
1725 else
1726 ret_val = EOB_ACT_CONTINUE_SCAN;
1727
1728 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1729 /* Extend the array by 50%, plus the number we really need. */
1730 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1731 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) ncgrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1732 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1733 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1734 }
1735
1736 (yy_n_chars) += number_to_move;
1737 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1738 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1739
1740 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1741
1742 return ret_val;
1743}
1744
1745/* yy_get_previous_state - get the state just before the EOB char was reached */
1746
1747    static yy_state_type yy_get_previous_state (void)
1748{
1749 register yy_state_type yy_current_state;
1750 register char *yy_cp;
1751
1752 yy_current_state = (yy_start);
1753
1754 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJyy_cp < (yy_c_buf_p); ++yy_cp )
1755 {
1756 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1757 if ( yy_accept[yy_current_state] )
1758 {
1759 (yy_last_accepting_state) = yy_current_state;
1760 (yy_last_accepting_cpos) = yy_cp;
1761 }
1762 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1763 {
1764 yy_current_state = (int) yy_def[yy_current_state];
1765 if ( yy_current_state >= 236 )
1766 yy_c = yy_meta[(unsigned int) yy_c];
1767 }
1768 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1769 }
1770
1771 return yy_current_state;
1772}
1773
1774/* yy_try_NUL_trans - try to make a transition on the NUL character
1775 *
1776 * synopsis
1777 * next_state = yy_try_NUL_trans( current_state );
1778 */
1779    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1780{
1781 register int yy_is_jam;
1782     register char *yy_cp = (yy_c_buf_p);
1783
1784 register YY_CHAR yy_c = 1;
1785 if ( yy_accept[yy_current_state] )
1786 {
1787 (yy_last_accepting_state) = yy_current_state;
1788 (yy_last_accepting_cpos) = yy_cp;
1789 }
1790 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1791 {
1792 yy_current_state = (int) yy_def[yy_current_state];
1793 if ( yy_current_state >= 236 )
1794 yy_c = yy_meta[(unsigned int) yy_c];
1795 }
1796 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1797 yy_is_jam = (yy_current_state == 235);
1798
1799 return yy_is_jam ? 0 : yy_current_state;
1800}
1801
1802    static void yyunput (int c, register char * yy_bp )
1803{
1804 register char *yy_cp;
1805
1806    yy_cp = (yy_c_buf_p);
1807
1808 /* undo effects of setting up ncgtext */
1809 *yy_cp = (yy_hold_char);
1810
1811 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1812 { /* need to shift things up to make room */
1813 /* +2 for EOB chars. */
1814 register int number_to_move = (yy_n_chars) + 2;
1815 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1816 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1817 register char *source =
1818 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1819
1820 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1821 *--dest = *--source;
1822
1823 yy_cp += (int) (dest - source);
1824 yy_bp += (int) (dest - source);
1825 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1826 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1827
1828 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1829 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1830 }
1831
1832 *--yy_cp = (char) c;
1833
1834 (yytext_ptr) = yy_bp;
1835 (yy_hold_char) = *yy_cp;
1836 (yy_c_buf_p) = yy_cp;
1837}
1838
1839#ifndef YY_NO_INPUT
1840#ifdef __cplusplus
1841    static int yyinput (void)
1842#else
1843    static int input  (void)
1844#endif
1845
1846{
1847 int c;
1848
1849 *(yy_c_buf_p) = (yy_hold_char);
1850
1851 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1852 {
1853 /* yy_c_buf_p now points to the character we want to return.
1854  * If this occurs *before* the EOB characters, then it's a
1855  * valid NUL; if not, then we've hit the end of the buffer.
1856  */
1857 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1858 /* This was really a NUL. */
1859 *(yy_c_buf_p) = '\0';
1860
1861 else
1862 { /* need more input */
1863 int offset = (yy_c_buf_p) - (yytext_ptr);
1864 ++(yy_c_buf_p);
1865
1866 switch ( yy_get_next_buffer(  ) )
1867 {
1868 case EOB_ACT_LAST_MATCH:
1869 /* This happens because yy_g_n_b()
1870  * sees that we've accumulated a
1871  * token and flags that we need to
1872  * try matching the token before
1873  * proceeding.  But for input(),
1874  * there's no matching to consider.
1875  * So convert the EOB_ACT_LAST_MATCH
1876  * to EOB_ACT_END_OF_FILE.
1877  */
1878
1879 /* Reset buffer status. */
1880 ncgrestart(ncgin );
1881
1882 /*FALLTHROUGH*/
1883
1884 case EOB_ACT_END_OF_FILE:
1885 {
1886 if ( ncgwrap( ) )
1887 return EOF;
1888
1889 if ( ! (yy_did_buffer_switch_on_eof) )
1890 YY_NEW_FILE;
1891#ifdef __cplusplus
1892 return yyinput();
1893#else
1894 return input();
1895#endif
1896 }
1897
1898 case EOB_ACT_CONTINUE_SCAN:
1899 (yy_c_buf_p) = (yytext_ptr) + offset;
1900 break;
1901 }
1902 }
1903 }
1904
1905 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1906 *(yy_c_buf_p) = '\0'; /* preserve ncgtext */
1907 (yy_hold_char) = *++(yy_c_buf_p);
1908
1909 return c;
1910}
1911#endif /* ifndef YY_NO_INPUT */
1912
1913/** Immediately switch to a different input stream.
1914 * @param input_file A readable stream.
1915 *
1916 * @note This function does not reset the start condition to @c INITIAL .
1917 */
1918    void ncgrestart  (FILE * input_file )
1919{
1920
1921 if ( ! YY_CURRENT_BUFFER ){
1922        ncgensure_buffer_stack ();
1923 YY_CURRENT_BUFFER_LVALUE =
1924            ncg_create_buffer(ncgin,YY_BUF_SIZE );
1925 }
1926
1927 ncg_init_buffer(YY_CURRENT_BUFFER,input_file );
1928 ncg_load_buffer_state( );
1929}
1930
1931/** Switch to a different input buffer.
1932 * @param new_buffer The new input buffer.
1933 *
1934 */
1935    void ncg_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1936{
1937
1938 /* TODO. We should be able to replace this entire function body
1939  * with
1940  * ncgpop_buffer_state();
1941  * ncgpush_buffer_state(new_buffer);
1942     */
1943 ncgensure_buffer_stack ();
1944 if ( YY_CURRENT_BUFFER == new_buffer )
1945 return;
1946
1947 if ( YY_CURRENT_BUFFER )
1948 {
1949 /* Flush out information for old buffer. */
1950 *(yy_c_buf_p) = (yy_hold_char);
1951 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1952 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1953 }
1954
1955 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1956 ncg_load_buffer_state( );
1957
1958 /* We don't actually know whether we did this switch during
1959  * EOF (ncgwrap()) processing, but the only time this flag
1960  * is looked at is after ncgwrap() is called, so it's safe
1961  * to go ahead and always set it.
1962  */
1963 (yy_did_buffer_switch_on_eof) = 1;
1964}
1965
1966static void ncg_load_buffer_state  (void)
1967{
1968     (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1969 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1970 ncgin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1971 (yy_hold_char) = *(yy_c_buf_p);
1972}
1973
1974/** Allocate and initialize an input buffer state.
1975 * @param file A readable stream.
1976 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1977 *
1978 * @return the allocated buffer state.
1979 */
1980    YY_BUFFER_STATE ncg_create_buffer  (FILE * file, int  size )
1981{
1982 YY_BUFFER_STATE b;
1983
1984 b = (YY_BUFFER_STATEncgalloc(sizeof( struct yy_buffer_state )  );
1985 if ( ! b )
1986 YY_FATAL_ERROR( "out of dynamic memory in ncg_create_buffer()" );
1987
1988 b->yy_buf_size = size;
1989
1990 /* yy_ch_buf has to be 2 characters longer than the size given because
1991  * we need to put in 2 end-of-buffer characters.
1992  */
1993 b->yy_ch_buf = (char *) ncgalloc(b->yy_buf_size + 2  );
1994 if ( ! b->yy_ch_buf )
1995 YY_FATAL_ERROR( "out of dynamic memory in ncg_create_buffer()" );
1996
1997 b->yy_is_our_buffer = 1;
1998
1999 ncg_init_buffer(b,file );
2000
2001 return b;
2002}
2003
2004/** Destroy the buffer.
2005 * @param b a buffer created with ncg_create_buffer()
2006 *
2007 */
2008    void ncg_delete_buffer (YY_BUFFER_STATE  b )
2009{
2010
2011 if ( ! b )
2012 return;
2013
2014 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2015 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2016
2017 if ( b->yy_is_our_buffer )
2018 ncgfree((void *) b->yy_ch_buf  );
2019
2020 ncgfree((void *) b  );
2021}
2022
2023#ifndef __cplusplus
2024extern int isatty (int );
2025#endif /* __cplusplus */
2026
2027/* Initializes or reinitializes a buffer.
2028 * This function is sometimes called more than once on the same buffer,
2029 * such as during a ncgrestart() or at EOF.
2030 */
2031    static void ncg_init_buffer  (YY_BUFFER_STATE  bFILE * file )
2032
2033{
2034 int oerrno = errno;
2035
2036 ncg_flush_buffer(b );
2037
2038 b->yy_input_file = file;
2039 b->yy_fill_buffer = 1;
2040
2041    /* If b is the current buffer, then ncg_init_buffer was _probably_
2042     * called from ncgrestart() or through yy_get_next_buffer.
2043     * In that case, we don't want to reset the lineno or column.
2044     */
2045    if (b != YY_CURRENT_BUFFER){
2046        b->yy_bs_lineno = 1;
2047        b->yy_bs_column = 0;
2048    }
2049
2050        b->yy_is_interactive = file ? (isattyfileno(file) ) > 0) : 0;
2051
2052 errno = oerrno;
2053}
2054
2055/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2056 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2057 *
2058 */
2059    void ncg_flush_buffer (YY_BUFFER_STATE  b )
2060{
2061     if ( ! b )
2062 return;
2063
2064 b->yy_n_chars = 0;
2065
2066 /* We always need two end-of-buffer characters.  The first causes
2067  * a transition to the end-of-buffer state.  The second causes
2068  * a jam in that state.
2069  */
2070 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2071 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2072
2073 b->yy_buf_pos = &b->yy_ch_buf[0];
2074
2075 b->yy_at_bol = 1;
2076 b->yy_buffer_status = YY_BUFFER_NEW;
2077
2078 if ( b == YY_CURRENT_BUFFER )
2079 ncg_load_buffer_state( );
2080}
2081
2082/** Pushes the new state onto the stack. The new state becomes
2083 *  the current state. This function will allocate the stack
2084 *  if necessary.
2085 *  @param new_buffer The new state.
2086 *
2087 */
2088void ncgpush_buffer_state (YY_BUFFER_STATE new_buffer )
2089{
2090     if (new_buffer == NULL)
2091 return;
2092
2093 ncgensure_buffer_stack();
2094
2095 /* This block is copied from ncg_switch_to_buffer. */
2096 if ( YY_CURRENT_BUFFER )
2097 {
2098 /* Flush out information for old buffer. */
2099 *(yy_c_buf_p) = (yy_hold_char);
2100 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2101 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2102 }
2103
2104 /* Only push if top exists. Otherwise, replace top. */
2105 if (YY_CURRENT_BUFFER)
2106 (yy_buffer_stack_top)++;
2107 YY_CURRENT_BUFFER_LVALUE = new_buffer;
2108
2109 /* copied from ncg_switch_to_buffer. */
2110 ncg_load_buffer_state( );
2111 (yy_did_buffer_switch_on_eof) = 1;
2112}
2113
2114/** Removes and deletes the top of the stack, if present.
2115 *  The next element becomes the new top.
2116 *
2117 */
2118void ncgpop_buffer_state (void)
2119{
2120     if (!YY_CURRENT_BUFFER)
2121 return;
2122
2123 ncg_delete_buffer(YY_CURRENT_BUFFER );
2124 YY_CURRENT_BUFFER_LVALUE = NULL;
2125 if ((yy_buffer_stack_top) > 0)
2126 --(yy_buffer_stack_top);
2127
2128 if (YY_CURRENT_BUFFER) {
2129 ncg_load_buffer_state( );
2130 (yy_did_buffer_switch_on_eof) = 1;
2131 }
2132}
2133
2134/* Allocates the stack if it does not exist.
2135 *  Guarantees space for at least one push.
2136 */
2137static void ncgensure_buffer_stack (void)
2138{
2139 int num_to_alloc;
2140
2141 if (!(yy_buffer_stack)) {
2142
2143 /* First allocation is just for 2 elements, since we don't know if this
2144  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2145  * immediate realloc on the next call.
2146         */
2147 num_to_alloc = 1;
2148 (yy_buffer_stack) = (struct yy_buffer_state**)ncgalloc
2149 (num_to_alloc * sizeof(struct yy_buffer_state*)
2150 );
2151 if ( ! (yy_buffer_stack) )
2152 YY_FATAL_ERROR( "out of dynamic memory in ncgensure_buffer_stack()" );
2153
2154 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2155
2156 (yy_buffer_stack_max) = num_to_alloc;
2157 (yy_buffer_stack_top) = 0;
2158 return;
2159 }
2160
2161 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2162
2163 /* Increase the buffer to prepare for a possible push. */
2164 int grow_size = 8 /* arbitrary grow size */;
2165
2166 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2167 (yy_buffer_stack) = (struct yy_buffer_state**)ncgrealloc
2168 ((yy_buffer_stack),
2169 num_to_alloc * sizeof(struct yy_buffer_state*)
2170 );
2171 if ( ! (yy_buffer_stack) )
2172 YY_FATAL_ERROR( "out of dynamic memory in ncgensure_buffer_stack()" );
2173
2174 /* zero only the new slots.*/
2175 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2176 (yy_buffer_stack_max) = num_to_alloc;
2177 }
2178}
2179
2180/** Setup the input buffer state to scan directly from a user-specified character buffer.
2181 * @param base the character buffer
2182 * @param size the size in bytes of the character buffer
2183 *
2184 * @return the newly allocated buffer state object.
2185 */
2186YY_BUFFER_STATE ncg_scan_buffer  (char * baseyy_size_t  size )
2187{
2188 YY_BUFFER_STATE b;
2189
2190 if ( size < 2 ||
2191      base[size-2] != YY_END_OF_BUFFER_CHAR ||
2192      base[size-1] != YY_END_OF_BUFFER_CHAR )
2193 /* They forgot to leave room for the EOB's. */
2194 return 0;
2195
2196 b = (YY_BUFFER_STATEncgalloc(sizeof( struct yy_buffer_state )  );
2197 if ( ! b )
2198 YY_FATAL_ERROR( "out of dynamic memory in ncg_scan_buffer()" );
2199
2200 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2201 b->yy_buf_pos = b->yy_ch_buf = base;
2202 b->yy_is_our_buffer = 0;
2203 b->yy_input_file = 0;
2204 b->yy_n_chars = b->yy_buf_size;
2205 b->yy_is_interactive = 0;
2206 b->yy_at_bol = 1;
2207 b->yy_fill_buffer = 0;
2208 b->yy_buffer_status = YY_BUFFER_NEW;
2209
2210 ncg_switch_to_buffer(b  );
2211
2212 return b;
2213}
2214
2215/** Setup the input buffer state to scan a string. The next call to ncglex() will
2216 * scan from a @e copy of @a str.
2217 * @param yystr a NUL-terminated string to scan
2218 *
2219 * @return the newly allocated buffer state object.
2220 * @note If you want to scan bytes that may contain NUL values, then use
2221 *       ncg_scan_bytes() instead.
2222 */
2223YY_BUFFER_STATE ncg_scan_string (yyconst char * yystr )
2224{
2225
2226 return ncg_scan_bytes(yystr,strlen(yystr) );
2227}
2228
2229/** Setup the input buffer state to scan the given bytes. The next call to ncglex() will
2230 * scan from a @e copy of @a bytes.
2231 * @param bytes the byte buffer to scan
2232 * @param len the number of bytes in the buffer pointed to by @a bytes.
2233 *
2234 * @return the newly allocated buffer state object.
2235 */
2236YY_BUFFER_STATE ncg_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
2237{
2238 YY_BUFFER_STATE b;
2239 char *buf;
2240 yy_size_t n;
2241 int i;
2242
2243 /* Get memory for full buffer, including space for trailing EOB's. */
2244 n = _yybytes_len + 2;
2245 buf = (char *) ncgalloc(n  );
2246 if ( ! buf )
2247 YY_FATAL_ERROR( "out of dynamic memory in ncg_scan_bytes()" );
2248
2249 for ( i = 0; i < _yybytes_len; ++i )
2250 buf[i] = yybytes[i];
2251
2252 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2253
2254 b = ncg_scan_buffer(buf,n );
2255 if ( ! b )
2256 YY_FATAL_ERROR( "bad buffer in ncg_scan_bytes()" );
2257
2258 /* It's okay to grow etc. this buffer, and we should throw it
2259  * away when we're done.
2260  */
2261 b->yy_is_our_buffer = 1;
2262
2263 return b;
2264}
2265
2266#ifndef YY_EXIT_FAILURE
2267#define YY_EXIT_FAILURE 2
2268#endif
2269
2270static void yy_fatal_error (yyconst char* msg )
2271{
2272     (void) fprintf( stderr, "%s\n", msg );
2273 exit( YY_EXIT_FAILURE );
2274}
2275
2276/* Redefine yyless() so it works in section 3 code. */
2277
2278#undef yyless
2279#define yyless(n) \
2280 do \
2281 { \
2282 /* Undo effects of setting up ncgtext. */ \
2283        int yyless_macro_arg = (n); \
2284        YY_LESS_LINENO(yyless_macro_arg);\
2285 ncgtext[ncgleng] = (yy_hold_char); \
2286 (yy_c_buf_p) = ncgtext + yyless_macro_arg; \
2287 (yy_hold_char) = *(yy_c_buf_p); \
2288 *(yy_c_buf_p) = '\0'; \
2289 ncgleng = yyless_macro_arg; \
2290 } \
2291 while ( 0 )
2292
2293/* Accessor  methods (get/set functions) to struct members. */
2294
2295/** Get the current line number.
2296 *
2297 */
2298int ncgget_lineno  (void)
2299{
2300
2301    return ncglineno;
2302}
2303
2304/** Get the input stream.
2305 *
2306 */
2307FILE *ncgget_in  (void)
2308{
2309        return ncgin;
2310}
2311
2312/** Get the output stream.
2313 *
2314 */
2315FILE *ncgget_out  (void)
2316{
2317        return ncgout;
2318}
2319
2320/** Get the length of the current token.
2321 *
2322 */
2323int ncgget_leng  (void)
2324{
2325        return ncgleng;
2326}
2327
2328/** Get the current token.
2329 *
2330 */
2331
2332char *ncgget_text  (void)
2333{
2334        return ncgtext;
2335}
2336
2337/** Set the current line number.
2338 * @param line_number
2339 *
2340 */
2341void ncgset_lineno (int  line_number )
2342{
2343
2344    ncglineno = line_number;
2345}
2346
2347/** Set the input stream. This does not discard the current
2348 * input buffer.
2349 * @param in_str A readable stream.
2350 *
2351 * @see ncg_switch_to_buffer
2352 */
2353void ncgset_in (FILE *  in_str )
2354{
2355        ncgin = in_str ;
2356}
2357
2358void ncgset_out (FILE *  out_str )
2359{
2360        ncgout = out_str ;
2361}
2362
2363int ncgget_debug  (void)
2364{
2365        return ncg_flex_debug;
2366}
2367
2368void ncgset_debug (int  bdebug )
2369{
2370        ncg_flex_debug = bdebug ;
2371}
2372
2373static int yy_init_globals (void)
2374{
2375        /* Initialization is the same as for the non-reentrant scanner.
2376     * This function is called from ncglex_destroy(), so don't allocate here.
2377     */
2378
2379    (yy_buffer_stack) = 0;
2380    (yy_buffer_stack_top) = 0;
2381    (yy_buffer_stack_max) = 0;
2382    (yy_c_buf_p) = (char *) 0;
2383    (yy_init) = 0;
2384    (yy_start) = 0;
2385
2386/* Defined in main.c */
2387#ifdef YY_STDINIT
2388    ncgin = stdin;
2389    ncgout = stdout;
2390#else
2391    ncgin = (FILE *) 0;
2392    ncgout = (FILE *) 0;
2393#endif
2394
2395    /* For future reference: Set errno on error, since we are called by
2396     * ncglex_init()
2397     */
2398    return 0;
2399}
2400
2401/* ncglex_destroy is for both reentrant and non-reentrant scanners. */
2402int ncglex_destroy  (void)
2403{
2404
2405    /* Pop the buffer stack, destroying each element. */
2406 while(YY_CURRENT_BUFFER){
2407 ncg_delete_buffer(YY_CURRENT_BUFFER  );
2408 YY_CURRENT_BUFFER_LVALUE = NULL;
2409 ncgpop_buffer_state();
2410 }
2411
2412 /* Destroy the stack itself. */
2413 ncgfree((yy_buffer_stack) );
2414 (yy_buffer_stack) = NULL;
2415
2416    /* Reset the globals. This is important in a non-reentrant scanner so the next time
2417     * ncglex() is called, initialization will occur. */
2418    yy_init_globals( );
2419
2420    return 0;
2421}
2422
2423/*
2424 * Internal utility routines.
2425 */
2426
2427#ifndef yytext_ptr
2428static void yy_flex_strncpy (char* s1yyconst char * s2, int n )
2429{
2430 register int i;
2431 for ( i = 0; i < n; ++i )
2432 s1[i] = s2[i];
2433}
2434#endif
2435
2436#ifdef YY_NEED_STRLEN
2437static int yy_flex_strlen (yyconst char * s )
2438{
2439 register int n;
2440 for ( n = 0; s[n]; ++n )
2441 ;
2442
2443 return n;
2444}
2445#endif
2446
2447void *ncgalloc (yy_size_t  size )
2448{
2449 return (void *) malloc( size );
2450}
2451
2452void *ncgrealloc  (void * ptryy_size_t  size )
2453{
2454 /* The cast to (char *) in the following accommodates both
2455  * implementations that use char* generic pointers, and those
2456  * that use void* generic pointers.  It works with the latter
2457  * because both ANSI C and C++ allow castless assignment from
2458  * any pointer type to void*, and deal with argument conversions
2459  * as though doing an assignment.
2460  */
2461 return (void *) realloc( (char *) ptrsize );
2462}
2463
2464void ncgfree (void * ptr )
2465{
2466 free( (char *) ptr ); /* see ncgrealloc() for (char *) cast */
2467}
2468
2469#define YYTABLES_NAME "yytables"
2470
2471#line 285 "ncgen.l"
2472
2473
2474
2475/* Hack to keep compile quiet */
2476void
2477ignore()
2478{
2479    yyunput(0,NULL);
2480
2481}
2482
2483


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