OPeNDAP Hyrax Back End Server (BES)  Updated for version 3.8.3
lex.he5dds.cc
Go to the documentation of this file.
1 #line 2 "lex.he5dds.cc"
2 
3 #line 4 "lex.he5dds.cc"
4 
5 #define YY_INT_ALIGNED short int
6 
7 /* A lexical scanner generated by flex */
8 
9 #define yy_create_buffer he5dds_create_buffer
10 #define yy_delete_buffer he5dds_delete_buffer
11 #define yy_flex_debug he5dds_flex_debug
12 #define yy_init_buffer he5dds_init_buffer
13 #define yy_flush_buffer he5dds_flush_buffer
14 #define yy_load_buffer_state he5dds_load_buffer_state
15 #define yy_switch_to_buffer he5dds_switch_to_buffer
16 #define yyin he5ddsin
17 #define yyleng he5ddsleng
18 #define yylex he5ddslex
19 #define yylineno he5ddslineno
20 #define yyout he5ddsout
21 #define yyrestart he5ddsrestart
22 #define yytext he5ddstext
23 #define yywrap he5ddswrap
24 #define yyalloc he5ddsalloc
25 #define yyrealloc he5ddsrealloc
26 #define yyfree he5ddsfree
27 
28 #define FLEX_SCANNER
29 #define YY_FLEX_MAJOR_VERSION 2
30 #define YY_FLEX_MINOR_VERSION 5
31 #define YY_FLEX_SUBMINOR_VERSION 35
32 #if YY_FLEX_SUBMINOR_VERSION > 0
33 #define FLEX_BETA
34 #endif
35 
36 /* First, we deal with platform-specific or compiler-specific issues. */
37 
38 /* begin standard C headers. */
39 #include <stdio.h>
40 #include <string.h>
41 #include <errno.h>
42 #include <stdlib.h>
43 
44 /* end standard C headers. */
45 
46 /* flex integer type definitions */
47 
48 #ifndef FLEXINT_H
49 #define FLEXINT_H
50 
51 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
52 
53 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
54 
55 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
56  * if you want the limit (max/min) macros for int types.
57  */
58 #ifndef __STDC_LIMIT_MACROS
59 #define __STDC_LIMIT_MACROS 1
60 #endif
61 
62 #include <inttypes.h>
63 typedef int8_t flex_int8_t;
64 typedef uint8_t flex_uint8_t;
65 typedef int16_t flex_int16_t;
66 typedef uint16_t flex_uint16_t;
67 typedef int32_t flex_int32_t;
68 typedef uint32_t flex_uint32_t;
69 typedef uint64_t flex_uint64_t;
70 #else
71 typedef signed char flex_int8_t;
72 typedef short int flex_int16_t;
73 typedef int flex_int32_t;
74 typedef unsigned char flex_uint8_t;
75 typedef unsigned short int flex_uint16_t;
76 typedef unsigned int flex_uint32_t;
77 #endif /* ! C99 */
78 
79 /* Limits of integral types. */
80 #ifndef INT8_MIN
81 #define INT8_MIN (-128)
82 #endif
83 #ifndef INT16_MIN
84 #define INT16_MIN (-32767-1)
85 #endif
86 #ifndef INT32_MIN
87 #define INT32_MIN (-2147483647-1)
88 #endif
89 #ifndef INT8_MAX
90 #define INT8_MAX (127)
91 #endif
92 #ifndef INT16_MAX
93 #define INT16_MAX (32767)
94 #endif
95 #ifndef INT32_MAX
96 #define INT32_MAX (2147483647)
97 #endif
98 #ifndef UINT8_MAX
99 #define UINT8_MAX (255U)
100 #endif
101 #ifndef UINT16_MAX
102 #define UINT16_MAX (65535U)
103 #endif
104 #ifndef UINT32_MAX
105 #define UINT32_MAX (4294967295U)
106 #endif
107 
108 #endif /* ! FLEXINT_H */
109 
110 #ifdef __cplusplus
111 
112 /* The "const" storage-class-modifier is valid. */
113 #define YY_USE_CONST
114 
115 #else /* ! __cplusplus */
116 
117 /* C99 requires __STDC__ to be defined as 1. */
118 #if defined (__STDC__)
119 
120 #define YY_USE_CONST
121 
122 #endif /* defined (__STDC__) */
123 #endif /* ! __cplusplus */
124 
125 #ifdef YY_USE_CONST
126 #define yyconst const
127 #else
128 #define yyconst
129 #endif
130 
131 /* Returned upon end-of-file. */
132 #define YY_NULL 0
133 
134 /* Promotes a possibly negative, possibly signed char to an unsigned
135  * integer for use as an array index. If the signed char is negative,
136  * we want to instead treat it as an 8-bit unsigned char, hence the
137  * double cast.
138  */
139 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
140 
141 /* Enter a start condition. This macro really ought to take a parameter,
142  * but we do it the disgusting crufty way forced on us by the ()-less
143  * definition of BEGIN.
144  */
145 #define BEGIN (yy_start) = 1 + 2 *
146 
147 /* Translate the current start state into a value that can be later handed
148  * to BEGIN to return to the state. The YYSTATE alias is for lex
149  * compatibility.
150  */
151 #define YY_START (((yy_start) - 1) / 2)
152 #define YYSTATE YY_START
153 
154 /* Action number for EOF rule of a given start state. */
155 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
156 
157 /* Special action meaning "start processing a new file". */
158 #define YY_NEW_FILE he5ddsrestart(he5ddsin )
159 
160 #define YY_END_OF_BUFFER_CHAR 0
161 
162 /* Size of default input buffer. */
163 #ifndef YY_BUF_SIZE
164 #define YY_BUF_SIZE 16384
165 #endif
166 
167 /* The state buf must be large enough to hold one state per character in the main buffer.
168  */
169 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
170 
171 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
172 #define YY_TYPEDEF_YY_BUFFER_STATE
173 typedef struct yy_buffer_state *YY_BUFFER_STATE;
174 #endif
175 
176 #ifndef YY_TYPEDEF_YY_SIZE_T
177 #define YY_TYPEDEF_YY_SIZE_T
178 typedef size_t yy_size_t;
179 #endif
180 
181 extern yy_size_t he5ddsleng;
182 
183 extern FILE *he5ddsin, *he5ddsout;
184 
185 #define EOB_ACT_CONTINUE_SCAN 0
186 #define EOB_ACT_END_OF_FILE 1
187 #define EOB_ACT_LAST_MATCH 2
188 
189  #define YY_LESS_LINENO(n)
190 
191 /* Return all but the first "n" matched characters back to the input stream. */
192 #define yyless(n) \
193  do \
194  { \
195  /* Undo effects of setting up he5ddstext. */ \
196  int yyless_macro_arg = (n); \
197  YY_LESS_LINENO(yyless_macro_arg);\
198  *yy_cp = (yy_hold_char); \
199  YY_RESTORE_YY_MORE_OFFSET \
200  (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
201  YY_DO_BEFORE_ACTION; /* set up he5ddstext again */ \
202  } \
203  while ( 0 )
204 
205 #define unput(c) yyunput( c, (yytext_ptr) )
206 
207 #ifndef YY_STRUCT_YY_BUFFER_STATE
208 #define YY_STRUCT_YY_BUFFER_STATE
209 struct yy_buffer_state
210  {
211  FILE *yy_input_file;
212 
213  char *yy_ch_buf; /* input buffer */
214  char *yy_buf_pos; /* current position in input buffer */
215 
216  /* Size of input buffer in bytes, not including room for EOB
217  * characters.
218  */
219  yy_size_t yy_buf_size;
220 
221  /* Number of characters read into yy_ch_buf, not including EOB
222  * characters.
223  */
224  yy_size_t yy_n_chars;
225 
226  /* Whether we "own" the buffer - i.e., we know we created it,
227  * and can realloc() it to grow it, and should free() it to
228  * delete it.
229  */
230  int yy_is_our_buffer;
231 
232  /* Whether this is an "interactive" input source; if so, and
233  * if we're using stdio for input, then we want to use getc()
234  * instead of fread(), to make sure we stop fetching input after
235  * each newline.
236  */
237  int yy_is_interactive;
238 
239  /* Whether we're considered to be at the beginning of a line.
240  * If so, '^' rules will be active on the next match, otherwise
241  * not.
242  */
243  int yy_at_bol;
244 
245  int yy_bs_lineno;
246  int yy_bs_column;
248  /* Whether to try to fill the input buffer when we reach the
249  * end of it.
250  */
251  int yy_fill_buffer;
252 
253  int yy_buffer_status;
254 
255 #define YY_BUFFER_NEW 0
256 #define YY_BUFFER_NORMAL 1
257  /* When an EOF's been seen but there's still some text to process
258  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
259  * shouldn't try reading from the input source any more. We might
260  * still have a bunch of tokens to match, though, because of
261  * possible backing-up.
262  *
263  * When we actually see the EOF, we change the status to "new"
264  * (via he5ddsrestart()), so that the user can continue scanning by
265  * just pointing he5ddsin at a new input file.
266  */
267 #define YY_BUFFER_EOF_PENDING 2
268 
269  };
270 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
271 
272 /* Stack of input buffers. */
273 static size_t yy_buffer_stack_top = 0;
274 static size_t yy_buffer_stack_max = 0;
275 static YY_BUFFER_STATE * yy_buffer_stack = 0;
277 /* We provide macros for accessing buffer states in case in the
278  * future we want to put the buffer states in a more general
279  * "scanner state".
280  *
281  * Returns the top of the stack, or NULL.
282  */
283 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
284  ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
285  : NULL)
286 
287 /* Same as previous macro, but useful when we know that the buffer stack is not
288  * NULL or when we need an lvalue. For internal use only.
289  */
290 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
291 
292 /* yy_hold_char holds the character lost when he5ddstext is formed. */
293 static char yy_hold_char;
294 static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
295 yy_size_t he5ddsleng;
296 
297 /* Points to current character in buffer. */
298 static char *yy_c_buf_p = (char *) 0;
299 static int yy_init = 0; /* whether we need to initialize */
300 static int yy_start = 0; /* start state number */
301 
302 /* Flag which is used to allow he5ddswrap()'s to do buffer switches
303  * instead of setting up a fresh he5ddsin. A bit of a hack ...
304  */
305 static int yy_did_buffer_switch_on_eof;
306 
307 void he5ddsrestart (FILE *input_file );
308 void he5dds_switch_to_buffer (YY_BUFFER_STATE new_buffer );
309 YY_BUFFER_STATE he5dds_create_buffer (FILE *file,int size );
310 void he5dds_delete_buffer (YY_BUFFER_STATE b );
311 void he5dds_flush_buffer (YY_BUFFER_STATE b );
312 void he5ddspush_buffer_state (YY_BUFFER_STATE new_buffer );
313 void he5ddspop_buffer_state (void );
314 
315 static void he5ddsensure_buffer_stack (void );
316 static void he5dds_load_buffer_state (void );
317 static void he5dds_init_buffer (YY_BUFFER_STATE b,FILE *file );
318 
319 #define YY_FLUSH_BUFFER he5dds_flush_buffer(YY_CURRENT_BUFFER )
320 
321 YY_BUFFER_STATE he5dds_scan_buffer (char *base,yy_size_t size );
322 YY_BUFFER_STATE he5dds_scan_string (yyconst char *yy_str );
323 YY_BUFFER_STATE he5dds_scan_bytes (yyconst char *bytes,yy_size_t len );
324 
325 void *he5ddsalloc (yy_size_t );
326 void *he5ddsrealloc (void *,yy_size_t );
327 void he5ddsfree (void * );
328 
329 #define yy_new_buffer he5dds_create_buffer
330 
331 #define yy_set_interactive(is_interactive) \
332  { \
333  if ( ! YY_CURRENT_BUFFER ){ \
334  he5ddsensure_buffer_stack (); \
335  YY_CURRENT_BUFFER_LVALUE = \
336  he5dds_create_buffer(he5ddsin,YY_BUF_SIZE ); \
337  } \
338  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
339  }
340 
341 #define yy_set_bol(at_bol) \
342  { \
343  if ( ! YY_CURRENT_BUFFER ){\
344  he5ddsensure_buffer_stack (); \
345  YY_CURRENT_BUFFER_LVALUE = \
346  he5dds_create_buffer(he5ddsin,YY_BUF_SIZE ); \
347  } \
348  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
349  }
350 
351 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
352 
353 /* Begin user sect3 */
354 
355 #define he5ddswrap(n) 1
356 #define YY_SKIP_YYWRAP
357 
358 typedef unsigned char YY_CHAR;
359 
360 FILE *he5ddsin = (FILE *) 0, *he5ddsout = (FILE *) 0;
361 
362 typedef int yy_state_type;
363 
364 extern int he5ddslineno;
365 
366 int he5ddslineno = 1;
367 
368 extern char *he5ddstext;
369 #define yytext_ptr he5ddstext
370 
371 static yy_state_type yy_get_previous_state (void );
372 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
373 static int yy_get_next_buffer (void );
374 static void yy_fatal_error (yyconst char msg[] );
375 
376 /* Done after the current pattern has been matched and before the
377  * corresponding action - sets up he5ddstext.
378  */
379 #define YY_DO_BEFORE_ACTION \
380  (yytext_ptr) = yy_bp; \
381  (yytext_ptr) -= (yy_more_len); \
382  he5ddsleng = (yy_size_t) (yy_cp - (yytext_ptr)); \
383  (yy_hold_char) = *yy_cp; \
384  *yy_cp = '\0'; \
385  (yy_c_buf_p) = yy_cp;
386 
387 #define YY_NUM_RULES 45
388 #define YY_END_OF_BUFFER 46
389 /* This struct is not used in this scanner,
390  but its presence is necessary. */
391 struct yy_trans_info
392  {
393  flex_int32_t yy_verify;
394  flex_int32_t yy_nxt;
395  };
396 static yyconst flex_int16_t yy_accept[248] =
397  { 0,
398  0, 0, 40, 40, 35, 35, 46, 44, 33, 34,
399  26, 31, 26, 28, 29, 26, 30, 26, 6, 32,
400  27, 26, 26, 26, 26, 26, 26, 26, 26, 26,
401  26, 26, 26, 45, 40, 41, 43, 45, 35, 36,
402  45, 45, 33, 26, 26, 26, 6, 7, 7, 6,
403  26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
404  26, 26, 26, 26, 26, 26, 26, 26, 26, 40,
405  41, 42, 35, 36, 37, 38, 39, 7, 26, 7,
406  26, 26, 26, 26, 5, 26, 26, 26, 26, 26,
407  26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
408 
409  26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
410  26, 20, 26, 26, 26, 26, 26, 26, 26, 26,
411  26, 26, 26, 26, 26, 1, 26, 26, 26, 26,
412  26, 26, 26, 26, 26, 12, 13, 26, 26, 26,
413  26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
414  3, 26, 26, 26, 26, 19, 26, 16, 26, 26,
415  22, 26, 26, 26, 26, 26, 26, 26, 26, 26,
416  26, 26, 26, 26, 26, 26, 26, 26, 26, 17,
417  26, 26, 26, 26, 26, 26, 26, 26, 9, 26,
418  2, 26, 26, 26, 26, 26, 26, 18, 26, 26,
419 
420  26, 9, 26, 4, 26, 26, 26, 26, 8, 26,
421  26, 26, 26, 26, 11, 26, 26, 26, 26, 26,
422  26, 25, 26, 26, 26, 26, 24, 21, 26, 26,
423  26, 26, 26, 26, 26, 23, 15, 26, 26, 26,
424  26, 26, 26, 10, 26, 14, 0
425  } ;
426 
427 static yyconst flex_int32_t yy_ec[256] =
428  { 0,
429  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
430  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
431  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
432  1, 4, 1, 5, 1, 1, 6, 1, 1, 7,
433  8, 9, 10, 11, 10, 12, 13, 14, 14, 14,
434  14, 14, 14, 14, 14, 14, 14, 6, 15, 1,
435  16, 1, 1, 1, 17, 18, 19, 20, 21, 22,
436  23, 24, 24, 25, 24, 26, 27, 28, 29, 30,
437  24, 31, 32, 33, 34, 24, 24, 35, 36, 37,
438  1, 38, 1, 1, 39, 1, 40, 6, 41, 42,
439 
440  43, 44, 45, 46, 47, 48, 6, 49, 50, 51,
441  52, 53, 6, 54, 55, 56, 6, 6, 57, 58,
442  59, 60, 61, 1, 61, 1, 1, 1, 1, 1,
443  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
444  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
445  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
446  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
447  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
448  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
449  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
450 
451  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
452  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
453  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
454  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
455  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
456  1, 1, 1, 1, 1
457  } ;
458 
459 static yyconst flex_int32_t yy_meta[62] =
460  { 0,
461  1, 2, 3, 2, 4, 2, 1, 1, 5, 2,
462  1, 2, 6, 7, 1, 1, 7, 7, 7, 7,
463  7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
464  7, 7, 7, 7, 7, 7, 7, 4, 7, 2,
465  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
466  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
467  1
468  } ;
469 
470 static yyconst flex_int16_t yy_base[257] =
471  { 0,
472  0, 0, 59, 60, 63, 64, 502, 561, 72, 561,
473  73, 561, 498, 561, 561, 68, 561, 69, 79, 561,
474  561, 76, 83, 77, 82, 85, 88, 84, 86, 87,
475  90, 92, 94, 561, 496, 561, 561, 0, 495, 561,
476  493, 0, 105, 112, 493, 97, 106, 127, 130, 133,
477  148, 113, 117, 101, 115, 122, 124, 119, 144, 150,
478  153, 154, 157, 158, 159, 162, 164, 166, 165, 491,
479  561, 561, 490, 561, 561, 561, 561, 167, 170, 172,
480  173, 175, 177, 178, 180, 188, 181, 183, 185, 187,
481  192, 193, 194, 195, 196, 198, 199, 200, 203, 204,
482 
483  212, 214, 218, 221, 222, 225, 227, 228, 234, 229,
484  230, 489, 231, 240, 244, 252, 241, 245, 257, 256,
485  260, 261, 262, 264, 263, 488, 265, 269, 268, 273,
486  272, 282, 274, 278, 284, 561, 561, 277, 283, 285,
487  287, 288, 290, 295, 294, 296, 291, 297, 298, 305,
488  487, 300, 299, 309, 310, 486, 312, 482, 322, 323,
489  480, 324, 325, 327, 326, 329, 330, 332, 333, 334,
490  335, 342, 337, 331, 348, 349, 352, 355, 359, 479,
491  354, 356, 358, 360, 361, 363, 368, 367, 0, 378,
492  478, 377, 381, 386, 387, 389, 388, 471, 392, 390,
493 
494  391, 0, 394, 470, 395, 397, 396, 401, 462, 406,
495  405, 409, 412, 407, 561, 413, 414, 416, 415, 422,
496  423, 458, 424, 427, 425, 426, 453, 452, 428, 430,
497  431, 434, 433, 438, 444, 451, 561, 440, 445, 446,
498  449, 454, 450, 561, 459, 561, 561, 505, 512, 518,
499  525, 532, 539, 546, 553, 88
500  } ;
501 
502 static yyconst flex_int16_t yy_def[257] =
503  { 0,
504  247, 1, 248, 248, 249, 249, 247, 247, 247, 247,
505  250, 247, 250, 247, 247, 250, 247, 250, 250, 247,
506  247, 250, 250, 250, 250, 250, 250, 250, 250, 250,
507  250, 250, 250, 247, 251, 247, 247, 252, 253, 247,
508  254, 255, 247, 250, 250, 250, 250, 250, 250, 250,
509  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
510  250, 250, 250, 250, 250, 250, 250, 250, 250, 251,
511  247, 247, 253, 247, 247, 247, 247, 250, 250, 250,
512  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
513  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
514 
515  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
516  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
517  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
518  250, 250, 250, 250, 250, 247, 247, 250, 250, 250,
519  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
520  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
521  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
522  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
523  250, 250, 250, 250, 250, 250, 250, 250, 256, 250,
524  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
525 
526  250, 256, 250, 250, 250, 250, 250, 250, 250, 250,
527  250, 250, 250, 250, 247, 250, 250, 250, 250, 250,
528  250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
529  250, 250, 250, 250, 250, 250, 247, 250, 250, 250,
530  250, 250, 250, 247, 250, 247, 0, 247, 247, 247,
531  247, 247, 247, 247, 247, 247
532  } ;
533 
534 static yyconst flex_int16_t yy_nxt[623] =
535  { 0,
536  8, 9, 10, 11, 12, 13, 14, 15, 8, 16,
537  17, 18, 13, 19, 20, 21, 13, 13, 22, 23,
538  24, 13, 25, 13, 13, 26, 13, 13, 27, 28,
539  13, 29, 13, 30, 31, 32, 33, 8, 13, 13,
540  13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
541  13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
542  34, 36, 36, 37, 37, 40, 40, 34, 34, 247,
543  247, 41, 41, 43, 43, 43, 44, 247, 247, 46,
544  247, 47, 48, 247, 247, 247, 247, 247, 247, 247,
545  49, 247, 50, 247, 202, 247, 38, 38, 247, 51,
546 
547  42, 42, 247, 53, 56, 61, 43, 247, 43, 67,
548  48, 68, 57, 43, 247, 44, 247, 49, 247, 50,
549  247, 51, 54, 247, 58, 247, 51, 52, 247, 55,
550  62, 247, 64, 69, 247, 59, 60, 63, 82, 66,
551  48, 85, 65, 78, 49, 247, 50, 51, 51, 247,
552  51, 247, 86, 51, 247, 247, 83, 79, 247, 247,
553  247, 80, 81, 247, 84, 247, 247, 247, 247, 51,
554  87, 247, 51, 247, 247, 51, 247, 90, 247, 247,
555  78, 247, 247, 80, 247, 80, 247, 51, 247, 247,
556  88, 100, 98, 247, 247, 247, 247, 247, 94, 247,
557 
558  247, 247, 106, 102, 247, 247, 89, 109, 92, 51,
559  96, 91, 97, 247, 95, 247, 101, 93, 104, 247,
560  103, 105, 247, 247, 107, 99, 247, 108, 247, 247,
561  247, 247, 247, 120, 110, 247, 112, 119, 114, 117,
562  111, 247, 247, 124, 121, 247, 247, 115, 116, 125,
563  113, 126, 131, 247, 128, 129, 118, 247, 247, 136,
564  122, 247, 247, 247, 247, 247, 247, 137, 123, 247,
565  247, 127, 133, 247, 247, 247, 134, 132, 247, 247,
566  146, 130, 140, 247, 247, 247, 247, 139, 247, 247,
567  138, 247, 247, 135, 145, 247, 247, 247, 247, 247,
568 
569  247, 247, 141, 150, 151, 154, 247, 147, 148, 155,
570  247, 247, 152, 247, 153, 143, 144, 158, 142, 156,
571  164, 149, 163, 247, 247, 247, 247, 247, 247, 159,
572  247, 247, 247, 247, 247, 247, 247, 157, 247, 165,
573  160, 162, 169, 247, 167, 161, 166, 178, 171, 247,
574  247, 168, 172, 247, 170, 247, 247, 247, 177, 247,
575  247, 247, 247, 189, 247, 175, 173, 179, 247, 247,
576  174, 180, 188, 192, 181, 176, 182, 183, 247, 247,
577  184, 191, 247, 187, 185, 186, 193, 247, 247, 247,
578  247, 247, 247, 247, 201, 247, 247, 247, 247, 190,
579 
580  194, 195, 247, 198, 196, 203, 247, 247, 247, 204,
581  247, 197, 215, 247, 247, 247, 247, 247, 199, 200,
582  205, 210, 216, 247, 247, 247, 247, 247, 247, 247,
583  212, 247, 247, 213, 247, 247, 206, 219, 209, 247,
584  211, 247, 207, 208, 214, 247, 247, 247, 237, 222,
585  247, 247, 247, 247, 247, 247, 217, 218, 220, 247,
586  247, 221, 225, 247, 227, 228, 230, 224, 223, 244,
587  239, 247, 247, 226, 246, 231, 236, 229, 232, 247,
588  247, 247, 233, 247, 238, 234, 235, 247, 247, 247,
589  247, 240, 74, 71, 247, 76, 242, 74, 71, 247,
590 
591  241, 247, 243, 247, 245, 35, 35, 35, 35, 35,
592  35, 35, 39, 39, 39, 39, 39, 39, 39, 45,
593  247, 247, 247, 45, 45, 70, 70, 70, 247, 70,
594  70, 70, 72, 72, 247, 72, 72, 72, 72, 73,
595  73, 73, 247, 247, 73, 73, 75, 75, 75, 75,
596  75, 247, 75, 77, 77, 247, 77, 77, 77, 77,
597  7, 247, 247, 247, 247, 247, 247, 247, 247, 247,
598  247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
599  247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
600  247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
601 
602  247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
603  247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
604  247, 247
605  } ;
606 
607 static yyconst flex_int16_t yy_chk[623] =
608  { 0,
609  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
610  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
611  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
612  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
613  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
614  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
615  1, 3, 4, 3, 4, 5, 6, 5, 6, 16,
616  18, 5, 6, 9, 11, 9, 11, 22, 24, 16,
617  19, 16, 18, 25, 23, 28, 26, 29, 30, 27,
618  19, 31, 19, 32, 256, 33, 3, 4, 46, 19,
619 
620  5, 6, 54, 23, 24, 27, 43, 47, 43, 31,
621  46, 32, 25, 44, 52, 44, 55, 47, 53, 47,
622  58, 19, 23, 56, 25, 57, 47, 22, 48, 23,
623  28, 49, 29, 33, 50, 25, 26, 28, 53, 30,
624  48, 56, 29, 49, 50, 59, 50, 48, 47, 51,
625  49, 60, 57, 50, 61, 62, 54, 51, 63, 64,
626  65, 51, 52, 66, 55, 67, 69, 68, 78, 48,
627  58, 79, 49, 80, 81, 50, 82, 61, 83, 84,
628  78, 85, 87, 79, 88, 80, 89, 78, 90, 86,
629  59, 82, 69, 91, 92, 93, 94, 95, 65, 96,
630 
631  97, 98, 87, 84, 99, 100, 60, 90, 63, 78,
632  67, 62, 68, 101, 66, 102, 83, 64, 85, 103,
633  84, 86, 104, 105, 88, 81, 106, 89, 107, 108,
634  110, 111, 113, 101, 91, 109, 93, 100, 95, 98,
635  92, 114, 117, 104, 101, 115, 118, 96, 97, 104,
636  94, 105, 109, 116, 107, 107, 99, 120, 119, 115,
637  102, 121, 122, 123, 125, 124, 127, 116, 103, 129,
638  128, 106, 111, 131, 130, 133, 113, 110, 138, 134,
639  125, 108, 119, 132, 139, 135, 140, 118, 141, 142,
640  117, 143, 147, 114, 124, 145, 144, 146, 148, 149,
641 
642  153, 152, 120, 130, 131, 134, 150, 127, 128, 135,
643  154, 155, 132, 157, 133, 122, 123, 140, 121, 138,
644  146, 129, 145, 159, 160, 162, 163, 165, 164, 141,
645  166, 167, 174, 168, 169, 170, 171, 139, 173, 147,
646  142, 144, 152, 172, 149, 143, 148, 164, 154, 175,
647  176, 150, 155, 177, 153, 181, 178, 182, 163, 183,
648  179, 184, 185, 175, 186, 160, 157, 165, 188, 187,
649  159, 166, 174, 178, 167, 162, 168, 169, 192, 190,
650  170, 177, 193, 173, 171, 172, 179, 194, 195, 197,
651  196, 200, 201, 199, 188, 203, 205, 207, 206, 176,
652 
653  181, 182, 208, 185, 183, 190, 211, 210, 214, 192,
654  212, 184, 206, 213, 216, 217, 219, 218, 186, 187,
655  193, 199, 207, 220, 221, 223, 225, 226, 224, 229,
656  201, 230, 231, 203, 233, 232, 194, 211, 197, 234,
657  200, 238, 195, 196, 205, 235, 239, 240, 233, 214,
658  241, 243, 236, 228, 227, 242, 208, 210, 212, 222,
659  245, 213, 218, 209, 220, 221, 224, 217, 216, 242,
660  235, 204, 198, 219, 245, 225, 232, 223, 226, 191,
661  180, 161, 229, 158, 234, 230, 231, 156, 151, 126,
662  112, 238, 73, 70, 45, 41, 240, 39, 35, 13,
663 
664  239, 7, 241, 0, 243, 248, 248, 248, 248, 248,
665  248, 248, 249, 249, 249, 249, 249, 249, 249, 250,
666  0, 0, 0, 250, 250, 251, 251, 251, 0, 251,
667  251, 251, 252, 252, 0, 252, 252, 252, 252, 253,
668  253, 253, 0, 0, 253, 253, 254, 254, 254, 254,
669  254, 0, 254, 255, 255, 0, 255, 255, 255, 255,
670  247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
671  247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
672  247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
673  247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
674 
675  247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
676  247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
677  247, 247
678  } ;
679 
680 static yy_state_type yy_last_accepting_state;
681 static char *yy_last_accepting_cpos;
682 
683 extern int he5dds_flex_debug;
684 int he5dds_flex_debug = 0;
685 
686 /* The intent behind this definition is that it'll catch
687  * any uses of REJECT which flex missed.
688  */
689 #define REJECT reject_used_but_not_detected
690 static int yy_more_flag = 0;
691 static int yy_more_len = 0;
692 #define yymore() ((yy_more_flag) = 1)
693 #define YY_MORE_ADJ (yy_more_len)
694 #define YY_RESTORE_YY_MORE_OFFSET
695 char *he5ddstext;
696 #line 1 "he5dds.lex"
697 #line 2 "he5dds.lex"
698 #include <string.h>
699 #include <assert.h>
700 
701 #ifndef YY_PROTO
702 #define YY_PROTO(proto) proto
703 #endif
704 
705 
706 #define YYSTYPE char *
707 #define YY_DECL int he5ddslex YY_PROTO(( void ))
708 #define YY_READ_BUF_SIZE 16384
709 #define ECHO if (fwrite( he5ddstext, he5ddsleng, 1, he5ddsout )) {}
710 /*#define YY_NO_UNPUT*/
711 #include "he5dds.tab.hh"
712 
713 int yy_line_num = 1;
714 static int start_line; /* used in quote and comment error handlers */
715 
716 
717 
718 #line 719 "lex.he5dds.cc"
719 
720 #define INITIAL 0
721 #define quote 1
722 #define comment 2
723 
724 #ifndef YY_NO_UNISTD_H
725 /* Special case for "unistd.h", since it is non-ANSI. We include it way
726  * down here because we want the user's section 1 to have been scanned first.
727  * The user has a chance to override it with an option.
728  */
729 #include <unistd.h>
730 #endif
731 
732 #ifndef YY_EXTRA_TYPE
733 #define YY_EXTRA_TYPE void *
734 #endif
735 
736 static int yy_init_globals (void );
737 
738 /* Accessor methods to globals.
739  These are made visible to non-reentrant scanners for convenience. */
740 
741 int he5ddslex_destroy (void );
742 
743 int he5ddsget_debug (void );
744 
745 void he5ddsset_debug (int debug_flag );
746 
747 YY_EXTRA_TYPE he5ddsget_extra (void );
748 
749 void he5ddsset_extra (YY_EXTRA_TYPE user_defined );
750 
751 FILE *he5ddsget_in (void );
752 
753 void he5ddsset_in (FILE * in_str );
754 
755 FILE *he5ddsget_out (void );
756 
757 void he5ddsset_out (FILE * out_str );
758 
759 yy_size_t he5ddsget_leng (void );
760 
761 char *he5ddsget_text (void );
762 
763 int he5ddsget_lineno (void );
764 
765 void he5ddsset_lineno (int line_number );
766 
767 /* Macros after this point can all be overridden by user definitions in
768  * section 1.
769  */
770 
771 #ifndef YY_SKIP_YYWRAP
772 #ifdef __cplusplus
773 extern "C" int he5ddswrap (void );
774 #else
775 extern int he5ddswrap (void );
776 #endif
777 #endif
778 
779  static void yyunput (int c,char *buf_ptr );
780 
781 #ifndef yytext_ptr
782 static void yy_flex_strncpy (char *,yyconst char *,int );
783 #endif
784 
785 #ifdef YY_NEED_STRLEN
786 static int yy_flex_strlen (yyconst char * );
787 #endif
788 
789 #ifndef YY_NO_INPUT
790 
791 #ifdef __cplusplus
792 static int yyinput (void );
793 #else
794 static int input (void );
795 #endif
796 
797 #endif
798 
799 /* Amount of stuff to slurp up with each read. */
800 #ifndef YY_READ_BUF_SIZE
801 #define YY_READ_BUF_SIZE 8192
802 #endif
803 
804 /* Copy whatever the last rule matched to the standard output. */
805 #ifndef ECHO
806 /* This used to be an fputs(), but since the string might contain NUL's,
807  * we now use fwrite().
808  */
809 #define ECHO fwrite( he5ddstext, he5ddsleng, 1, he5ddsout )
810 #endif
811 
812 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
813  * is returned in "result".
814  */
815 #ifndef YY_INPUT
816 #define YY_INPUT(buf,result,max_size) \
817  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
818  { \
819  int c = '*'; \
820  yy_size_t n; \
821  for ( n = 0; n < max_size && \
822  (c = getc( he5ddsin )) != EOF && c != '\n'; ++n ) \
823  buf[n] = (char) c; \
824  if ( c == '\n' ) \
825  buf[n++] = (char) c; \
826  if ( c == EOF && ferror( he5ddsin ) ) \
827  YY_FATAL_ERROR( "input in flex scanner failed" ); \
828  result = n; \
829  } \
830  else \
831  { \
832  errno=0; \
833  while ( (result = fread(buf, 1, max_size, he5ddsin))==0 && ferror(he5ddsin)) \
834  { \
835  if( errno != EINTR) \
836  { \
837  YY_FATAL_ERROR( "input in flex scanner failed" ); \
838  break; \
839  } \
840  errno=0; \
841  clearerr(he5ddsin); \
842  } \
843  }\
844 \
845 
846 #endif
847 
848 /* No semi-colon after return; correct usage is to write "yyterminate();" -
849  * we don't want an extra ';' after the "return" because that will cause
850  * some compilers to complain about unreachable statements.
851  */
852 #ifndef yyterminate
853 #define yyterminate() return YY_NULL
854 #endif
855 
856 /* Number of entries by which start-condition stack grows. */
857 #ifndef YY_START_STACK_INCR
858 #define YY_START_STACK_INCR 25
859 #endif
860 
861 /* Report a fatal error. */
862 #ifndef YY_FATAL_ERROR
863 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
864 #endif
865 
866 /* end tables serialization structures and prototypes */
867 
868 /* Default declaration of generated scanner - a define so the user can
869  * easily add parameters.
870  */
871 #ifndef YY_DECL
872 #define YY_DECL_IS_OURS 1
873 
874 extern int he5ddslex (void);
875 
876 #define YY_DECL int he5ddslex (void)
877 #endif /* !YY_DECL */
878 
879 /* Code executed at the beginning of each rule, after he5ddstext and he5ddsleng
880  * have been set up.
881  */
882 #ifndef YY_USER_ACTION
883 #define YY_USER_ACTION
884 #endif
885 
886 /* Code executed at the end of each rule. */
887 #ifndef YY_BREAK
888 #define YY_BREAK break;
889 #endif
890 
891 #define YY_RULE_SETUP \
892  YY_USER_ACTION
893 
896 YY_DECL
897 {
898  register yy_state_type yy_current_state;
899  register char *yy_cp, *yy_bp;
900  register int yy_act;
901 
902 #line 59 "he5dds.lex"
903 
904 
905 #line 906 "lex.he5dds.cc"
906 
907  if ( !(yy_init) )
908  {
909  (yy_init) = 1;
910 
911 #ifdef YY_USER_INIT
912  YY_USER_INIT;
913 #endif
914 
915  if ( ! (yy_start) )
916  (yy_start) = 1; /* first start state */
917 
918  if ( ! he5ddsin )
919  he5ddsin = stdin;
920 
921  if ( ! he5ddsout )
922  he5ddsout = stdout;
923 
924  if ( ! YY_CURRENT_BUFFER ) {
925  he5ddsensure_buffer_stack ();
926  YY_CURRENT_BUFFER_LVALUE =
927  he5dds_create_buffer(he5ddsin,YY_BUF_SIZE );
928  }
929 
930  he5dds_load_buffer_state( );
931  }
932 
933  while ( 1 ) /* loops until end-of-file is reached */
934  {
935  (yy_more_len) = 0;
936  if ( (yy_more_flag) )
937  {
938  (yy_more_len) = (yy_c_buf_p) - (yytext_ptr);
939  (yy_more_flag) = 0;
940  }
941  yy_cp = (yy_c_buf_p);
942 
943  /* Support of he5ddstext. */
944  *yy_cp = (yy_hold_char);
945 
946  /* yy_bp points to the position in yy_ch_buf of the start of
947  * the current run.
948  */
949  yy_bp = yy_cp;
950 
951  yy_current_state = (yy_start);
952 yy_match:
953  do
954  {
955  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
956  if ( yy_accept[yy_current_state] )
957  {
958  (yy_last_accepting_state) = yy_current_state;
959  (yy_last_accepting_cpos) = yy_cp;
960  }
961  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
962  {
963  yy_current_state = (int) yy_def[yy_current_state];
964  if ( yy_current_state >= 248 )
965  yy_c = yy_meta[(unsigned int) yy_c];
966  }
967  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
968  ++yy_cp;
969  }
970  while ( yy_base[yy_current_state] != 561 );
971 
972 yy_find_action:
973  yy_act = yy_accept[yy_current_state];
974  if ( yy_act == 0 )
975  { /* have to back up */
976  yy_cp = (yy_last_accepting_cpos);
977  yy_current_state = (yy_last_accepting_state);
978  yy_act = yy_accept[yy_current_state];
979  }
980 
981  YY_DO_BEFORE_ACTION;
982 
983 do_action: /* This label is used only to access EOF actions. */
984 
985  switch ( yy_act )
986  { /* beginning of action switch */
987  case 0: /* must back up */
988  /* undo the effects of YY_DO_BEFORE_ACTION */
989  *yy_cp = (yy_hold_char);
990  yy_cp = (yy_last_accepting_cpos);
991  yy_current_state = (yy_last_accepting_state);
992  goto yy_find_action;
993 
994 case 1:
995 YY_RULE_SETUP
996 #line 61 "he5dds.lex"
997 he5ddslval = he5ddstext; return GROUP;
998  YY_BREAK
999 case 2:
1000 YY_RULE_SETUP
1001 #line 62 "he5dds.lex"
1002 he5ddslval = he5ddstext; return END_GROUP;
1003  YY_BREAK
1004 case 3:
1005 YY_RULE_SETUP
1006 #line 63 "he5dds.lex"
1007 he5ddslval = he5ddstext; return OBJECT;
1008  YY_BREAK
1009 case 4:
1010 YY_RULE_SETUP
1011 #line 64 "he5dds.lex"
1012 he5ddslval = he5ddstext; return END_OBJECT;
1013  YY_BREAK
1014 case 5:
1015 YY_RULE_SETUP
1016 #line 65 "he5dds.lex"
1017 /* Ignore */
1018  YY_BREAK
1019 case 6:
1020 YY_RULE_SETUP
1021 #line 66 "he5dds.lex"
1022 he5ddslval = he5ddstext; return INT;
1023  YY_BREAK
1024 case 7:
1025 YY_RULE_SETUP
1026 #line 67 "he5dds.lex"
1027 he5ddslval = he5ddstext; return FLOAT;
1028  YY_BREAK
1029 case 8:
1030 YY_RULE_SETUP
1031 #line 68 "he5dds.lex"
1032 he5ddslval = he5ddstext; return PROJECTION;
1033  YY_BREAK
1034 case 9:
1035 YY_RULE_SETUP
1036 #line 69 "he5dds.lex"
1037 he5ddslval = he5ddstext; return DATA_TYPE;
1038  YY_BREAK
1039 case 10:
1040 YY_RULE_SETUP
1041 #line 70 "he5dds.lex"
1042 he5ddslval = he5ddstext; return PIXELREGISTRATION;
1043  YY_BREAK
1044 case 11:
1045 YY_RULE_SETUP
1046 #line 71 "he5dds.lex"
1047 he5ddslval = he5ddstext; return GRIDORIGIN;
1048  YY_BREAK
1049 case 12:
1050 YY_RULE_SETUP
1051 #line 72 "he5dds.lex"
1052 he5ddslval = he5ddstext; return XDIM;
1053  YY_BREAK
1054 case 13:
1055 YY_RULE_SETUP
1056 #line 73 "he5dds.lex"
1057 he5ddslval = he5ddstext; return YDIM;
1058  YY_BREAK
1059 case 14:
1060 YY_RULE_SETUP
1061 #line 74 "he5dds.lex"
1062 he5ddslval = he5ddstext; return UPPERLEFTPT;
1063  YY_BREAK
1064 case 15:
1065 YY_RULE_SETUP
1066 #line 75 "he5dds.lex"
1067 he5ddslval = he5ddstext; return LOWERRIGHTPT;
1068  YY_BREAK
1069 case 16:
1070 YY_RULE_SETUP
1071 #line 76 "he5dds.lex"
1072 he5ddslval = he5ddstext; return DEFAULT;
1073  YY_BREAK
1074 case 17:
1075 YY_RULE_SETUP
1076 #line 79 "he5dds.lex"
1077 he5ddslval = he5ddstext; return GRID_NAME;
1078  YY_BREAK
1079 case 18:
1080 YY_RULE_SETUP
1081 #line 80 "he5dds.lex"
1082 he5ddslval = he5ddstext; return SWATH_NAME;
1083  YY_BREAK
1084 case 19:
1085 YY_RULE_SETUP
1086 #line 81 "he5dds.lex"
1087 he5ddslval = he5ddstext; return ZA_NAME;
1088  YY_BREAK
1089 case 20:
1090 YY_RULE_SETUP
1091 #line 82 "he5dds.lex"
1092 he5ddslval = he5ddstext; return DIMENSION_SIZE;
1093  YY_BREAK
1094 case 21:
1095 YY_RULE_SETUP
1096 #line 83 "he5dds.lex"
1097 he5ddslval = he5ddstext; return DIMENSION_NAME;
1098  YY_BREAK
1099 case 22:
1100 YY_RULE_SETUP
1101 #line 84 "he5dds.lex"
1102 he5ddslval = he5ddstext; return DIMENSION_LIST;
1103  YY_BREAK
1104 case 23:
1105 YY_RULE_SETUP
1106 #line 85 "he5dds.lex"
1107 he5ddslval = he5ddstext; return COMPRESSION_TYPE;
1108  YY_BREAK
1109 case 24:
1110 YY_RULE_SETUP
1111 #line 86 "he5dds.lex"
1112 he5ddslval = he5ddstext; return DATA_FIELD_NAME;
1113  YY_BREAK
1114 case 25:
1115 YY_RULE_SETUP
1116 #line 87 "he5dds.lex"
1117 he5ddslval = he5ddstext; return GEO_FIELD_NAME;
1118  YY_BREAK
1119 case 26:
1120 YY_RULE_SETUP
1121 #line 88 "he5dds.lex"
1122 he5ddslval = he5ddstext; return STR;
1123  YY_BREAK
1124 case 27:
1125 YY_RULE_SETUP
1126 #line 89 "he5dds.lex"
1127 return (int)*he5ddstext;
1128  YY_BREAK
1129 case 28:
1130 YY_RULE_SETUP
1131 #line 90 "he5dds.lex"
1132 return (int)*he5ddstext;
1133  YY_BREAK
1134 case 29:
1135 YY_RULE_SETUP
1136 #line 91 "he5dds.lex"
1137 return (int)*he5ddstext;
1138  YY_BREAK
1139 case 30:
1140 YY_RULE_SETUP
1141 #line 92 "he5dds.lex"
1142 return (int)*he5ddstext;
1143  YY_BREAK
1144 case 31:
1145 YY_RULE_SETUP
1146 #line 93 "he5dds.lex"
1147 /* Ignore */
1148  YY_BREAK
1149 case 32:
1150 YY_RULE_SETUP
1151 #line 94 "he5dds.lex"
1152 /* Ignore */
1153  YY_BREAK
1154 case 33:
1155 YY_RULE_SETUP
1156 #line 96 "he5dds.lex"
1157 
1158  YY_BREAK
1159 case 34:
1160 /* rule 34 can match eol */
1161 YY_RULE_SETUP
1162 #line 97 "he5dds.lex"
1163 ++yy_line_num;
1164  YY_BREAK
1165 case YY_STATE_EOF(INITIAL):
1166 #line 98 "he5dds.lex"
1167 yy_init = 1; yy_line_num = 1; yyterminate();
1168  YY_BREAK
1169 case 35:
1170 YY_RULE_SETUP
1171 #line 99 "he5dds.lex"
1172 yymore();
1173  YY_BREAK
1174 case 36:
1175 /* rule 36 can match eol */
1176 YY_RULE_SETUP
1177 #line 100 "he5dds.lex"
1178 yymore(); ++yy_line_num;
1179  YY_BREAK
1180 case 37:
1181 YY_RULE_SETUP
1182 #line 101 "he5dds.lex"
1183 yymore();
1184  YY_BREAK
1185 case 38:
1186 /* rule 38 can match eol */
1187 YY_RULE_SETUP
1188 #line 102 "he5dds.lex"
1189 yymore(); ++yy_line_num;
1190  YY_BREAK
1191 case 39:
1192 YY_RULE_SETUP
1193 #line 103 "he5dds.lex"
1194 yymore();
1195  YY_BREAK
1196 case YY_STATE_EOF(comment):
1197 #line 104 "he5dds.lex"
1198 {
1199  char msg[256];
1200  sprintf(msg,
1201  "Unterminated comment (starts on line %d)\n",
1202  start_line);
1203  YY_FATAL_ERROR(msg);
1204  }
1205  YY_BREAK
1206 case 40:
1207 YY_RULE_SETUP
1208 #line 111 "he5dds.lex"
1209 yymore();
1210  YY_BREAK
1211 case 41:
1212 /* rule 41 can match eol */
1213 YY_RULE_SETUP
1214 #line 112 "he5dds.lex"
1215 yymore(); ++yy_line_num;
1216  YY_BREAK
1217 case 42:
1218 YY_RULE_SETUP
1219 #line 113 "he5dds.lex"
1220 yymore();
1221  YY_BREAK
1222 case 43:
1223 YY_RULE_SETUP
1224 #line 114 "he5dds.lex"
1225 {
1226  BEGIN(INITIAL);
1227 
1228  he5ddslval = he5ddstext;
1229 
1230  return STR;
1231  }
1232  YY_BREAK
1233 case YY_STATE_EOF(quote):
1234 #line 121 "he5dds.lex"
1235 {
1236  char msg[256];
1237  sprintf(msg,
1238  "Unterminated quote (starts on line %d)\n",
1239  start_line);
1240  YY_FATAL_ERROR(msg);
1241  }
1242  YY_BREAK
1243 case 44:
1244 /* rule 44 can match eol */
1245 YY_RULE_SETUP
1246 #line 129 "he5dds.lex"
1247 {
1248  if (he5ddstext) { /* suppress msgs about `' chars */
1249  fprintf(stderr, "Character '%c' (%d) is not",
1250  *he5ddstext, *he5ddstext);
1251  fprintf(stderr, " allowed (except within");
1252  fprintf(stderr, " quotes) and has been ignored\n");
1253  }
1254  }
1255  YY_BREAK
1256 case 45:
1257 YY_RULE_SETUP
1258 #line 137 "he5dds.lex"
1259 ECHO;
1260  YY_BREAK
1261 #line 1262 "lex.he5dds.cc"
1262 
1263  case YY_END_OF_BUFFER:
1264  {
1265  /* Amount of text matched not including the EOB char. */
1266  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1267 
1268  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1269  *yy_cp = (yy_hold_char);
1270  YY_RESTORE_YY_MORE_OFFSET
1271 
1272  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1273  {
1274  /* We're scanning a new file or input source. It's
1275  * possible that this happened because the user
1276  * just pointed he5ddsin at a new source and called
1277  * he5ddslex(). If so, then we have to assure
1278  * consistency between YY_CURRENT_BUFFER and our
1279  * globals. Here is the right place to do so, because
1280  * this is the first action (other than possibly a
1281  * back-up) that will match for the new input source.
1282  */
1283  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1284  YY_CURRENT_BUFFER_LVALUE->yy_input_file = he5ddsin;
1285  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1286  }
1287 
1288  /* Note that here we test for yy_c_buf_p "<=" to the position
1289  * of the first EOB in the buffer, since yy_c_buf_p will
1290  * already have been incremented past the NUL character
1291  * (since all states make transitions on EOB to the
1292  * end-of-buffer state). Contrast this with the test
1293  * in input().
1294  */
1295  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1296  { /* This was really a NUL. */
1297  yy_state_type yy_next_state;
1298 
1299  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1300 
1301  yy_current_state = yy_get_previous_state( );
1302 
1303  /* Okay, we're now positioned to make the NUL
1304  * transition. We couldn't have
1305  * yy_get_previous_state() go ahead and do it
1306  * for us because it doesn't know how to deal
1307  * with the possibility of jamming (and we don't
1308  * want to build jamming into it because then it
1309  * will run more slowly).
1310  */
1311 
1312  yy_next_state = yy_try_NUL_trans( yy_current_state );
1313 
1314  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1315 
1316  if ( yy_next_state )
1317  {
1318  /* Consume the NUL. */
1319  yy_cp = ++(yy_c_buf_p);
1320  yy_current_state = yy_next_state;
1321  goto yy_match;
1322  }
1323 
1324  else
1325  {
1326  yy_cp = (yy_c_buf_p);
1327  goto yy_find_action;
1328  }
1329  }
1330 
1331  else switch ( yy_get_next_buffer( ) )
1332  {
1333  case EOB_ACT_END_OF_FILE:
1334  {
1335  (yy_did_buffer_switch_on_eof) = 0;
1336 
1337  if ( he5ddswrap( ) )
1338  {
1339  /* Note: because we've taken care in
1340  * yy_get_next_buffer() to have set up
1341  * he5ddstext, we can now set up
1342  * yy_c_buf_p so that if some total
1343  * hoser (like flex itself) wants to
1344  * call the scanner after we return the
1345  * YY_NULL, it'll still work - another
1346  * YY_NULL will get returned.
1347  */
1348  (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1349 
1350  yy_act = YY_STATE_EOF(YY_START);
1351  goto do_action;
1352  }
1353 
1354  else
1355  {
1356  if ( ! (yy_did_buffer_switch_on_eof) )
1357  YY_NEW_FILE;
1358  }
1359  break;
1360  }
1361 
1362  case EOB_ACT_CONTINUE_SCAN:
1363  (yy_c_buf_p) =
1364  (yytext_ptr) + yy_amount_of_matched_text;
1365 
1366  yy_current_state = yy_get_previous_state( );
1367 
1368  yy_cp = (yy_c_buf_p);
1369  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1370  goto yy_match;
1371 
1372  case EOB_ACT_LAST_MATCH:
1373  (yy_c_buf_p) =
1374  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1375 
1376  yy_current_state = yy_get_previous_state( );
1377 
1378  yy_cp = (yy_c_buf_p);
1379  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1380  goto yy_find_action;
1381  }
1382  break;
1383  }
1384 
1385  default:
1386  YY_FATAL_ERROR(
1387  "fatal flex scanner internal error--no action found" );
1388  } /* end of action switch */
1389  } /* end of scanning one token */
1390 } /* end of he5ddslex */
1391 
1392 /* yy_get_next_buffer - try to read in a new buffer
1393  *
1394  * Returns a code representing an action:
1395  * EOB_ACT_LAST_MATCH -
1396  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1397  * EOB_ACT_END_OF_FILE - end of file
1398  */
1399 static int yy_get_next_buffer (void)
1400 {
1401  register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1402  register char *source = (yytext_ptr);
1403  register int number_to_move, i;
1404  int ret_val;
1405 
1406  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1407  YY_FATAL_ERROR(
1408  "fatal flex scanner internal error--end of buffer missed" );
1409 
1410  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1411  { /* Don't try to fill the buffer, so this is an EOF. */
1412  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1413  {
1414  /* We matched a single character, the EOB, so
1415  * treat this as a final EOF.
1416  */
1417  return EOB_ACT_END_OF_FILE;
1418  }
1419 
1420  else
1421  {
1422  /* We matched some text prior to the EOB, first
1423  * process it.
1424  */
1425  return EOB_ACT_LAST_MATCH;
1426  }
1427  }
1428 
1429  /* Try to read more data. */
1430 
1431  /* First move last chars to start of buffer. */
1432  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1433 
1434  for ( i = 0; i < number_to_move; ++i )
1435  *(dest++) = *(source++);
1436 
1437  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1438  /* don't do the read, it's not guaranteed to return an EOF,
1439  * just force an EOF
1440  */
1441  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1442 
1443  else
1444  {
1445  yy_size_t num_to_read =
1446  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1447 
1448  while ( num_to_read <= 0 )
1449  { /* Not enough room in the buffer - grow it. */
1450 
1451  /* just a shorter name for the current buffer */
1452  YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1453 
1454  int yy_c_buf_p_offset =
1455  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1456 
1457  if ( b->yy_is_our_buffer )
1458  {
1459  yy_size_t new_size = b->yy_buf_size * 2;
1460 
1461  if ( new_size <= 0 )
1462  b->yy_buf_size += b->yy_buf_size / 8;
1463  else
1464  b->yy_buf_size *= 2;
1465 
1466  b->yy_ch_buf = (char *)
1467  /* Include room in for 2 EOB chars. */
1468  he5ddsrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1469  }
1470  else
1471  /* Can't grow it, we don't own it. */
1472  b->yy_ch_buf = 0;
1473 
1474  if ( ! b->yy_ch_buf )
1475  YY_FATAL_ERROR(
1476  "fatal error - scanner input buffer overflow" );
1477 
1478  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1479 
1480  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1481  number_to_move - 1;
1482 
1483  }
1484 
1485  if ( num_to_read > YY_READ_BUF_SIZE )
1486  num_to_read = YY_READ_BUF_SIZE;
1487 
1488  /* Read in more data. */
1489  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1490  (yy_n_chars), num_to_read );
1491 
1492  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1493  }
1494 
1495  if ( (yy_n_chars) == 0 )
1496  {
1497  if ( number_to_move == YY_MORE_ADJ )
1498  {
1499  ret_val = EOB_ACT_END_OF_FILE;
1500  he5ddsrestart(he5ddsin );
1501  }
1502 
1503  else
1504  {
1505  ret_val = EOB_ACT_LAST_MATCH;
1506  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1507  YY_BUFFER_EOF_PENDING;
1508  }
1509  }
1510 
1511  else
1512  ret_val = EOB_ACT_CONTINUE_SCAN;
1513 
1514  if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1515  /* Extend the array by 50%, plus the number we really need. */
1516  yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1517  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) he5ddsrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1518  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1519  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1520  }
1521 
1522  (yy_n_chars) += number_to_move;
1523  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1524  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1525 
1526  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1527 
1528  return ret_val;
1529 }
1530 
1531 /* yy_get_previous_state - get the state just before the EOB char was reached */
1532 
1533  static yy_state_type yy_get_previous_state (void)
1534 {
1535  register yy_state_type yy_current_state;
1536  register char *yy_cp;
1537 
1538  yy_current_state = (yy_start);
1539 
1540  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1541  {
1542  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1543  if ( yy_accept[yy_current_state] )
1544  {
1545  (yy_last_accepting_state) = yy_current_state;
1546  (yy_last_accepting_cpos) = yy_cp;
1547  }
1548  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1549  {
1550  yy_current_state = (int) yy_def[yy_current_state];
1551  if ( yy_current_state >= 248 )
1552  yy_c = yy_meta[(unsigned int) yy_c];
1553  }
1554  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1555  }
1556 
1557  return yy_current_state;
1558 }
1559 
1560 /* yy_try_NUL_trans - try to make a transition on the NUL character
1561  *
1562  * synopsis
1563  * next_state = yy_try_NUL_trans( current_state );
1564  */
1565  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1566 {
1567  register int yy_is_jam;
1568  register char *yy_cp = (yy_c_buf_p);
1569 
1570  register YY_CHAR yy_c = 1;
1571  if ( yy_accept[yy_current_state] )
1572  {
1573  (yy_last_accepting_state) = yy_current_state;
1574  (yy_last_accepting_cpos) = yy_cp;
1575  }
1576  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1577  {
1578  yy_current_state = (int) yy_def[yy_current_state];
1579  if ( yy_current_state >= 248 )
1580  yy_c = yy_meta[(unsigned int) yy_c];
1581  }
1582  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1583  yy_is_jam = (yy_current_state == 247);
1584 
1585  return yy_is_jam ? 0 : yy_current_state;
1586 }
1587 
1588  static void yyunput (int c, register char * yy_bp )
1589 {
1590  register char *yy_cp;
1591 
1592  yy_cp = (yy_c_buf_p);
1593 
1594  /* undo effects of setting up he5ddstext */
1595  *yy_cp = (yy_hold_char);
1596 
1597  if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1598  { /* need to shift things up to make room */
1599  /* +2 for EOB chars. */
1600  register yy_size_t number_to_move = (yy_n_chars) + 2;
1601  register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1602  YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1603  register char *source =
1604  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1605 
1606  while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1607  *--dest = *--source;
1608 
1609  yy_cp += (int) (dest - source);
1610  yy_bp += (int) (dest - source);
1611  YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1612  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1613 
1614  if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1615  YY_FATAL_ERROR( "flex scanner push-back overflow" );
1616  }
1617 
1618  *--yy_cp = (char) c;
1619 
1620  (yytext_ptr) = yy_bp;
1621  (yy_hold_char) = *yy_cp;
1622  (yy_c_buf_p) = yy_cp;
1623 }
1624 
1625 #ifndef YY_NO_INPUT
1626 #ifdef __cplusplus
1627  static int yyinput (void)
1628 #else
1629  static int input (void)
1630 #endif
1631 
1632 {
1633  int c;
1634 
1635  *(yy_c_buf_p) = (yy_hold_char);
1636 
1637  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1638  {
1639  /* yy_c_buf_p now points to the character we want to return.
1640  * If this occurs *before* the EOB characters, then it's a
1641  * valid NUL; if not, then we've hit the end of the buffer.
1642  */
1643  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1644  /* This was really a NUL. */
1645  *(yy_c_buf_p) = '\0';
1646 
1647  else
1648  { /* need more input */
1649  yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1650  ++(yy_c_buf_p);
1651 
1652  switch ( yy_get_next_buffer( ) )
1653  {
1654  case EOB_ACT_LAST_MATCH:
1655  /* This happens because yy_g_n_b()
1656  * sees that we've accumulated a
1657  * token and flags that we need to
1658  * try matching the token before
1659  * proceeding. But for input(),
1660  * there's no matching to consider.
1661  * So convert the EOB_ACT_LAST_MATCH
1662  * to EOB_ACT_END_OF_FILE.
1663  */
1664 
1665  /* Reset buffer status. */
1666  he5ddsrestart(he5ddsin );
1667 
1668  /*FALLTHROUGH*/
1669 
1670  case EOB_ACT_END_OF_FILE:
1671  {
1672  if ( he5ddswrap( ) )
1673  return 0;
1674 
1675  if ( ! (yy_did_buffer_switch_on_eof) )
1676  YY_NEW_FILE;
1677 #ifdef __cplusplus
1678  return yyinput();
1679 #else
1680  return input();
1681 #endif
1682  }
1683 
1684  case EOB_ACT_CONTINUE_SCAN:
1685  (yy_c_buf_p) = (yytext_ptr) + offset;
1686  break;
1687  }
1688  }
1689  }
1690 
1691  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1692  *(yy_c_buf_p) = '\0'; /* preserve he5ddstext */
1693  (yy_hold_char) = *++(yy_c_buf_p);
1694 
1695  return c;
1696 }
1697 #endif /* ifndef YY_NO_INPUT */
1698 
1704  void he5ddsrestart (FILE * input_file )
1705 {
1706 
1707  if ( ! YY_CURRENT_BUFFER ){
1708  he5ddsensure_buffer_stack ();
1709  YY_CURRENT_BUFFER_LVALUE =
1710  he5dds_create_buffer(he5ddsin,YY_BUF_SIZE );
1711  }
1712 
1713  he5dds_init_buffer(YY_CURRENT_BUFFER,input_file );
1714  he5dds_load_buffer_state( );
1715 }
1716 
1721  void he5dds_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1722 {
1723 
1724  /* TODO. We should be able to replace this entire function body
1725  * with
1726  * he5ddspop_buffer_state();
1727  * he5ddspush_buffer_state(new_buffer);
1728  */
1729  he5ddsensure_buffer_stack ();
1730  if ( YY_CURRENT_BUFFER == new_buffer )
1731  return;
1732 
1733  if ( YY_CURRENT_BUFFER )
1734  {
1735  /* Flush out information for old buffer. */
1736  *(yy_c_buf_p) = (yy_hold_char);
1737  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1738  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1739  }
1740 
1741  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1742  he5dds_load_buffer_state( );
1743 
1744  /* We don't actually know whether we did this switch during
1745  * EOF (he5ddswrap()) processing, but the only time this flag
1746  * is looked at is after he5ddswrap() is called, so it's safe
1747  * to go ahead and always set it.
1748  */
1749  (yy_did_buffer_switch_on_eof) = 1;
1750 }
1751 
1752 static void he5dds_load_buffer_state (void)
1753 {
1754  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1755  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1756  he5ddsin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1757  (yy_hold_char) = *(yy_c_buf_p);
1758 }
1759 
1766  YY_BUFFER_STATE he5dds_create_buffer (FILE * file, int size )
1767 {
1768  YY_BUFFER_STATE b;
1769 
1770  b = (YY_BUFFER_STATE) he5ddsalloc(sizeof( struct yy_buffer_state ) );
1771  if ( ! b )
1772  YY_FATAL_ERROR( "out of dynamic memory in he5dds_create_buffer()" );
1773 
1774  b->yy_buf_size = size;
1775 
1776  /* yy_ch_buf has to be 2 characters longer than the size given because
1777  * we need to put in 2 end-of-buffer characters.
1778  */
1779  b->yy_ch_buf = (char *) he5ddsalloc(b->yy_buf_size + 2 );
1780  if ( ! b->yy_ch_buf )
1781  YY_FATAL_ERROR( "out of dynamic memory in he5dds_create_buffer()" );
1782 
1783  b->yy_is_our_buffer = 1;
1784 
1785  he5dds_init_buffer(b,file );
1786 
1787  return b;
1788 }
1789 
1794  void he5dds_delete_buffer (YY_BUFFER_STATE b )
1795 {
1796 
1797  if ( ! b )
1798  return;
1799 
1800  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1801  YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1802 
1803  if ( b->yy_is_our_buffer )
1804  he5ddsfree((void *) b->yy_ch_buf );
1805 
1806  he5ddsfree((void *) b );
1807 }
1808 
1809 #ifndef __cplusplus
1810 extern int isatty (int );
1811 #endif /* __cplusplus */
1812 
1813 /* Initializes or reinitializes a buffer.
1814  * This function is sometimes called more than once on the same buffer,
1815  * such as during a he5ddsrestart() or at EOF.
1816  */
1817  static void he5dds_init_buffer (YY_BUFFER_STATE b, FILE * file )
1818 
1819 {
1820  int oerrno = errno;
1821 
1822  he5dds_flush_buffer(b );
1823 
1824  b->yy_input_file = file;
1825  b->yy_fill_buffer = 1;
1826 
1827  /* If b is the current buffer, then he5dds_init_buffer was _probably_
1828  * called from he5ddsrestart() or through yy_get_next_buffer.
1829  * In that case, we don't want to reset the lineno or column.
1830  */
1831  if (b != YY_CURRENT_BUFFER){
1832  b->yy_bs_lineno = 1;
1833  b->yy_bs_column = 0;
1834  }
1835 
1836  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1837 
1838  errno = oerrno;
1839 }
1840 
1845  void he5dds_flush_buffer (YY_BUFFER_STATE b )
1846 {
1847  if ( ! b )
1848  return;
1849 
1850  b->yy_n_chars = 0;
1851 
1852  /* We always need two end-of-buffer characters. The first causes
1853  * a transition to the end-of-buffer state. The second causes
1854  * a jam in that state.
1855  */
1856  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1857  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1858 
1859  b->yy_buf_pos = &b->yy_ch_buf[0];
1860 
1861  b->yy_at_bol = 1;
1862  b->yy_buffer_status = YY_BUFFER_NEW;
1863 
1864  if ( b == YY_CURRENT_BUFFER )
1865  he5dds_load_buffer_state( );
1866 }
1867 
1874 void he5ddspush_buffer_state (YY_BUFFER_STATE new_buffer )
1875 {
1876  if (new_buffer == NULL)
1877  return;
1878 
1879  he5ddsensure_buffer_stack();
1880 
1881  /* This block is copied from he5dds_switch_to_buffer. */
1882  if ( YY_CURRENT_BUFFER )
1883  {
1884  /* Flush out information for old buffer. */
1885  *(yy_c_buf_p) = (yy_hold_char);
1886  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1887  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1888  }
1889 
1890  /* Only push if top exists. Otherwise, replace top. */
1891  if (YY_CURRENT_BUFFER)
1892  (yy_buffer_stack_top)++;
1893  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1894 
1895  /* copied from he5dds_switch_to_buffer. */
1896  he5dds_load_buffer_state( );
1897  (yy_did_buffer_switch_on_eof) = 1;
1898 }
1899 
1904 void he5ddspop_buffer_state (void)
1905 {
1906  if (!YY_CURRENT_BUFFER)
1907  return;
1908 
1909  he5dds_delete_buffer(YY_CURRENT_BUFFER );
1910  YY_CURRENT_BUFFER_LVALUE = NULL;
1911  if ((yy_buffer_stack_top) > 0)
1912  --(yy_buffer_stack_top);
1913 
1914  if (YY_CURRENT_BUFFER) {
1915  he5dds_load_buffer_state( );
1916  (yy_did_buffer_switch_on_eof) = 1;
1917  }
1918 }
1919 
1920 /* Allocates the stack if it does not exist.
1921  * Guarantees space for at least one push.
1922  */
1923 static void he5ddsensure_buffer_stack (void)
1924 {
1925  yy_size_t num_to_alloc;
1926 
1927  if (!(yy_buffer_stack)) {
1928 
1929  /* First allocation is just for 2 elements, since we don't know if this
1930  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1931  * immediate realloc on the next call.
1932  */
1933  num_to_alloc = 1;
1934  (yy_buffer_stack) = (struct yy_buffer_state**)he5ddsalloc
1935  (num_to_alloc * sizeof(struct yy_buffer_state*)
1936  );
1937  if ( ! (yy_buffer_stack) )
1938  YY_FATAL_ERROR( "out of dynamic memory in he5ddsensure_buffer_stack()" );
1939 
1940  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1941 
1942  (yy_buffer_stack_max) = num_to_alloc;
1943  (yy_buffer_stack_top) = 0;
1944  return;
1945  }
1946 
1947  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1948 
1949  /* Increase the buffer to prepare for a possible push. */
1950  int grow_size = 8 /* arbitrary grow size */;
1951 
1952  num_to_alloc = (yy_buffer_stack_max) + grow_size;
1953  (yy_buffer_stack) = (struct yy_buffer_state**)he5ddsrealloc
1954  ((yy_buffer_stack),
1955  num_to_alloc * sizeof(struct yy_buffer_state*)
1956  );
1957  if ( ! (yy_buffer_stack) )
1958  YY_FATAL_ERROR( "out of dynamic memory in he5ddsensure_buffer_stack()" );
1959 
1960  /* zero only the new slots.*/
1961  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1962  (yy_buffer_stack_max) = num_to_alloc;
1963  }
1964 }
1965 
1972 YY_BUFFER_STATE he5dds_scan_buffer (char * base, yy_size_t size )
1973 {
1974  YY_BUFFER_STATE b;
1975 
1976  if ( size < 2 ||
1977  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1978  base[size-1] != YY_END_OF_BUFFER_CHAR )
1979  /* They forgot to leave room for the EOB's. */
1980  return 0;
1981 
1982  b = (YY_BUFFER_STATE) he5ddsalloc(sizeof( struct yy_buffer_state ) );
1983  if ( ! b )
1984  YY_FATAL_ERROR( "out of dynamic memory in he5dds_scan_buffer()" );
1985 
1986  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1987  b->yy_buf_pos = b->yy_ch_buf = base;
1988  b->yy_is_our_buffer = 0;
1989  b->yy_input_file = 0;
1990  b->yy_n_chars = b->yy_buf_size;
1991  b->yy_is_interactive = 0;
1992  b->yy_at_bol = 1;
1993  b->yy_fill_buffer = 0;
1994  b->yy_buffer_status = YY_BUFFER_NEW;
1995 
1996  he5dds_switch_to_buffer(b );
1997 
1998  return b;
1999 }
2000 
2009 YY_BUFFER_STATE he5dds_scan_string (yyconst char * yystr )
2010 {
2011 
2012  return he5dds_scan_bytes(yystr,strlen(yystr) );
2013 }
2014 
2022 YY_BUFFER_STATE he5dds_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
2023 {
2024  YY_BUFFER_STATE b;
2025  char *buf;
2026  yy_size_t n, i;
2027 
2028  /* Get memory for full buffer, including space for trailing EOB's. */
2029  n = _yybytes_len + 2;
2030  buf = (char *) he5ddsalloc(n );
2031  if ( ! buf )
2032  YY_FATAL_ERROR( "out of dynamic memory in he5dds_scan_bytes()" );
2033 
2034  for ( i = 0; i < _yybytes_len; ++i )
2035  buf[i] = yybytes[i];
2036 
2037  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2038 
2039  b = he5dds_scan_buffer(buf,n );
2040  if ( ! b )
2041  YY_FATAL_ERROR( "bad buffer in he5dds_scan_bytes()" );
2042 
2043  /* It's okay to grow etc. this buffer, and we should throw it
2044  * away when we're done.
2045  */
2046  b->yy_is_our_buffer = 1;
2047 
2048  return b;
2049 }
2050 
2051 #ifndef YY_EXIT_FAILURE
2052 #define YY_EXIT_FAILURE 2
2053 #endif
2054 
2055 static void yy_fatal_error (yyconst char* msg )
2056 {
2057  (void) fprintf( stderr, "%s\n", msg );
2058  exit( YY_EXIT_FAILURE );
2059 }
2060 
2061 /* Redefine yyless() so it works in section 3 code. */
2062 
2063 #undef yyless
2064 #define yyless(n) \
2065  do \
2066  { \
2067  /* Undo effects of setting up he5ddstext. */ \
2068  int yyless_macro_arg = (n); \
2069  YY_LESS_LINENO(yyless_macro_arg);\
2070  he5ddstext[he5ddsleng] = (yy_hold_char); \
2071  (yy_c_buf_p) = he5ddstext + yyless_macro_arg; \
2072  (yy_hold_char) = *(yy_c_buf_p); \
2073  *(yy_c_buf_p) = '\0'; \
2074  he5ddsleng = yyless_macro_arg; \
2075  } \
2076  while ( 0 )
2077 
2078 /* Accessor methods (get/set functions) to struct members. */
2079 
2083 int he5ddsget_lineno (void)
2084 {
2085 
2086  return he5ddslineno;
2087 }
2088 
2092 FILE *he5ddsget_in (void)
2093 {
2094  return he5ddsin;
2095 }
2096 
2100 FILE *he5ddsget_out (void)
2101 {
2102  return he5ddsout;
2103 }
2104 
2108 yy_size_t he5ddsget_leng (void)
2109 {
2110  return he5ddsleng;
2111 }
2112 
2117 char *he5ddsget_text (void)
2118 {
2119  return he5ddstext;
2120 }
2121 
2126 void he5ddsset_lineno (int line_number )
2127 {
2128 
2129  he5ddslineno = line_number;
2130 }
2131 
2138 void he5ddsset_in (FILE * in_str )
2139 {
2140  he5ddsin = in_str ;
2141 }
2142 
2143 void he5ddsset_out (FILE * out_str )
2144 {
2145  he5ddsout = out_str ;
2146 }
2147 
2148 int he5ddsget_debug (void)
2149 {
2150  return he5dds_flex_debug;
2151 }
2152 
2153 void he5ddsset_debug (int bdebug )
2154 {
2155  he5dds_flex_debug = bdebug ;
2156 }
2157 
2158 static int yy_init_globals (void)
2159 {
2160  /* Initialization is the same as for the non-reentrant scanner.
2161  * This function is called from he5ddslex_destroy(), so don't allocate here.
2162  */
2163 
2164  (yy_buffer_stack) = 0;
2165  (yy_buffer_stack_top) = 0;
2166  (yy_buffer_stack_max) = 0;
2167  (yy_c_buf_p) = (char *) 0;
2168  (yy_init) = 0;
2169  (yy_start) = 0;
2170 
2171 /* Defined in main.c */
2172 #ifdef YY_STDINIT
2173  he5ddsin = stdin;
2174  he5ddsout = stdout;
2175 #else
2176  he5ddsin = (FILE *) 0;
2177  he5ddsout = (FILE *) 0;
2178 #endif
2179 
2180  /* For future reference: Set errno on error, since we are called by
2181  * he5ddslex_init()
2182  */
2183  return 0;
2184 }
2185 
2186 /* he5ddslex_destroy is for both reentrant and non-reentrant scanners. */
2187 int he5ddslex_destroy (void)
2188 {
2189 
2190  /* Pop the buffer stack, destroying each element. */
2191  while(YY_CURRENT_BUFFER){
2192  he5dds_delete_buffer(YY_CURRENT_BUFFER );
2193  YY_CURRENT_BUFFER_LVALUE = NULL;
2194  he5ddspop_buffer_state();
2195  }
2196 
2197  /* Destroy the stack itself. */
2198  he5ddsfree((yy_buffer_stack) );
2199  (yy_buffer_stack) = NULL;
2200 
2201  /* Reset the globals. This is important in a non-reentrant scanner so the next time
2202  * he5ddslex() is called, initialization will occur. */
2203  yy_init_globals( );
2204 
2205  return 0;
2206 }
2207 
2208 /*
2209  * Internal utility routines.
2210  */
2211 
2212 #ifndef yytext_ptr
2213 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2214 {
2215  register int i;
2216  for ( i = 0; i < n; ++i )
2217  s1[i] = s2[i];
2218 }
2219 #endif
2220 
2221 #ifdef YY_NEED_STRLEN
2222 static int yy_flex_strlen (yyconst char * s )
2223 {
2224  register int n;
2225  for ( n = 0; s[n]; ++n )
2226  ;
2227 
2228  return n;
2229 }
2230 #endif
2231 
2232 void *he5ddsalloc (yy_size_t size )
2233 {
2234  return (void *) malloc( size );
2235 }
2236 
2237 void *he5ddsrealloc (void * ptr, yy_size_t size )
2238 {
2239  /* The cast to (char *) in the following accommodates both
2240  * implementations that use char* generic pointers, and those
2241  * that use void* generic pointers. It works with the latter
2242  * because both ANSI C and C++ allow castless assignment from
2243  * any pointer type to void*, and deal with argument conversions
2244  * as though doing an assignment.
2245  */
2246  return (void *) realloc( (char *) ptr, size );
2247 }
2248 
2249 void he5ddsfree (void * ptr )
2250 {
2251  free( (char *) ptr ); /* see he5ddsrealloc() for (char *) cast */
2252 }
2253 
2254 #define YYTABLES_NAME "yytables"
2255 
2256 #line 137 "he5dds.lex"
2257 
2258 
2259 
yy_size_t
size_t yy_size_t
Definition: lex.he5dds.cc:178
flex_int8_t
signed char flex_int8_t
Definition: lex.he5dds.cc:71
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition: lex.he5dds.cc:155
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: lex.he5dds.cc:891
he5ddsget_out
FILE * he5ddsget_out(void)
Get the output stream.
Definition: lex.he5dds.cc:2100
free
void free(void *)
yytext_ptr
#define yytext_ptr
Definition: lex.he5dds.cc:369
yy_state_type
int yy_state_type
Definition: lex.he5dds.cc:362
he5dds_flex_debug
int he5dds_flex_debug
Definition: lex.he5dds.cc:684
flex_int32_t
int flex_int32_t
Definition: lex.he5dds.cc:73
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition: lex.he5dds.cc:139
YY_START
#define YY_START
Definition: lex.he5dds.cc:151
he5ddsset_lineno
void he5ddsset_lineno(int line_number)
Set the current line number.
Definition: lex.he5dds.cc:2126
he5ddsset_in
void he5ddsset_in(FILE *in_str)
Set the input stream.
Definition: lex.he5dds.cc:2138
he5ddslex
int he5ddslex(void)
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: lex.he5dds.cc:863
he5ddsalloc
void * he5ddsalloc(yy_size_t)
Definition: lex.he5dds.cc:2232
he5ddsget_lineno
int he5ddsget_lineno(void)
Get the current line number.
Definition: lex.he5dds.cc:2083
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition: lex.he5dds.cc:256
YY_BUFFER_EOF_PENDING
#define YY_BUFFER_EOF_PENDING
Definition: lex.he5dds.cc:267
he5dds_switch_to_buffer
void he5dds_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Switch to a different input buffer.
Definition: lex.he5dds.cc:1721
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition: lex.he5dds.cc:187
he5ddstext
char * he5ddstext
Definition: lex.he5dds.cc:695
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition: lex.he5dds.cc:186
he5dds_scan_bytes
YY_BUFFER_STATE he5dds_scan_bytes(yyconst char *bytes, yy_size_t len)
Setup the input buffer state to scan the given bytes.
Definition: lex.he5dds.cc:2022
INITIAL
#define INITIAL
Definition: lex.he5dds.cc:720
yy_bp
register char * yy_bp
Definition: lex.he5dds.cc:899
he5ddsget_debug
int he5ddsget_debug(void)
Definition: lex.he5dds.cc:2148
he5ddslineno
int he5ddslineno
Definition: lex.he5dds.cc:366
YY_DECL
#define YY_DECL
Definition: lex.he5dds.cc:707
he5ddslex_destroy
int he5ddslex_destroy(void)
Definition: lex.he5dds.cc:2187
yymore
#define yymore()
Definition: lex.he5dds.cc:692
quote
#define quote
Definition: lex.he5dds.cc:721
he5ddsset_debug
void he5ddsset_debug(int debug_flag)
Definition: lex.he5dds.cc:2153
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition: lex.he5dds.cc:255
flex_int16_t
short int flex_int16_t
Definition: lex.gse.cc:72
he5ddspop_buffer_state
void he5ddspop_buffer_state(void)
Removes and deletes the top of the stack, if present.
Definition: lex.he5dds.cc:1904
YY_NEW_FILE
#define YY_NEW_FILE
Definition: lex.he5dds.cc:158
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition: lex.he5dds.cc:816
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: lex.he5dds.cc:693
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: lex.he5dds.cc:164
flex_uint32_t
unsigned int flex_uint32_t
Definition: lex.he5dds.cc:76
he5dds_create_buffer
YY_BUFFER_STATE he5dds_create_buffer(FILE *file, int size)
Allocate and initialize an input buffer state.
Definition: lex.he5dds.cc:1766
he5ddsget_in
FILE * he5ddsget_in(void)
Get the input stream.
Definition: lex.he5dds.cc:2092
yy_current_state
YY_DECL register yy_state_type yy_current_state
The main scanner function which does all the work.
Definition: lex.gse.cc:743
flex_int16_t
short int flex_int16_t
Definition: lex.he5dds.cc:72
YY_END_OF_BUFFER_CHAR
#define YY_END_OF_BUFFER_CHAR
Definition: lex.he5dds.cc:160
YY_BREAK
#define YY_BREAK
Definition: lex.he5dds.cc:888
yy_cp
register char * yy_cp
Definition: lex.he5dds.cc:899
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: lex.he5dds.cc:379
yy_act
register int yy_act
Definition: lex.he5dds.cc:900
if
if(!(yy_init))
Definition: lex.he5dds.cc:907
NULL
#define NULL
Definition: wcsUtil.h:65
he5ddswrap
#define he5ddswrap(n)
Definition: lex.he5dds.cc:355
he5ddsrealloc
void * he5ddsrealloc(void *, yy_size_t)
Definition: lex.he5dds.cc:2237
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: lex.he5dds.cc:694
YY_BUFFER_STATE
struct yy_buffer_state * YY_BUFFER_STATE
Definition: lex.he5dds.cc:173
he5ddsfree
void he5ddsfree(void *)
Definition: lex.he5dds.cc:2249
he5ddsget_text
char * he5ddsget_text(void)
Get the current token.
Definition: lex.he5dds.cc:2117
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: lex.he5dds.cc:708
yy_line_num
int yy_line_num
Definition: lex.he5dds.cc:713
he5ddsin
FILE * he5ddsin
Definition: lex.he5dds.cc:360
he5ddsset_out
void he5ddsset_out(FILE *out_str)
Definition: lex.he5dds.cc:2143
he5ddspush_buffer_state
void he5ddspush_buffer_state(YY_BUFFER_STATE new_buffer)
Pushes the new state onto the stack.
Definition: lex.he5dds.cc:1874
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition: lex.he5dds.cc:185
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: lex.he5dds.cc:2052
isatty
int isatty(int)
he5ddsset_extra
void he5ddsset_extra(YY_EXTRA_TYPE user_defined)
flex_int32_t
int flex_int32_t
Definition: lex.gse.cc:73
yyconst
#define yyconst
Definition: lex.he5dds.cc:128
yyterminate
#define yyterminate()
Definition: lex.he5dds.cc:853
he5ddsget_extra
YY_EXTRA_TYPE he5ddsget_extra(void)
he5ddslval
YYSTYPE he5ddslval
YY_CHAR
unsigned char YY_CHAR
Definition: lex.gse.cc:358
YY_END_OF_BUFFER
#define YY_END_OF_BUFFER
Definition: lex.he5dds.cc:388
comment
#define comment
Definition: lex.he5dds.cc:722
YY_CHAR
unsigned char YY_CHAR
Definition: lex.he5dds.cc:358
he5dds_scan_string
YY_BUFFER_STATE he5dds_scan_string(yyconst char *yy_str)
Setup the input buffer state to scan a string.
Definition: lex.he5dds.cc:2009
flex_uint16_t
unsigned short int flex_uint16_t
Definition: lex.he5dds.cc:75
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: lex.he5dds.cc:290
malloc
void * malloc(YYSIZE_T)
he5ddsleng
yy_size_t he5ddsleng
Definition: lex.he5dds.cc:295
yy_size_t
size_t yy_size_t
Definition: lex.gse.cc:178
he5dds_scan_buffer
YY_BUFFER_STATE he5dds_scan_buffer(char *base, yy_size_t size)
Setup the input buffer state to scan directly from a user-specified character buffer.
Definition: lex.he5dds.cc:1972
ECHO
#define ECHO
Definition: lex.he5dds.cc:709
BEGIN
#define BEGIN
Definition: lex.he5dds.cc:145
he5ddsrestart
void he5ddsrestart(FILE *input_file)
Immediately switch to a different input stream.
Definition: lex.he5dds.cc:1704
he5ddsout
FILE * he5ddsout
Definition: lex.he5dds.cc:360
flex_uint8_t
unsigned char flex_uint8_t
Definition: lex.he5dds.cc:74
YY_EXTRA_TYPE
#define YY_EXTRA_TYPE
Definition: lex.he5dds.cc:733
YY_BUFFER_STATE
struct yy_buffer_state * YY_BUFFER_STATE
Definition: lex.gse.cc:173
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: lex.he5dds.cc:283
he5dds_delete_buffer
void he5dds_delete_buffer(YY_BUFFER_STATE b)
Destroy the buffer.
Definition: lex.he5dds.cc:1794
he5ddsget_leng
yy_size_t he5ddsget_leng(void)
Get the length of the current token.
Definition: lex.he5dds.cc:2108
he5dds_flush_buffer
void he5dds_flush_buffer(YY_BUFFER_STATE b)
Discard all buffered characters.
Definition: lex.he5dds.cc:1845