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