source: lib/dagopts.c @ 59c31da

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes
Last change on this file since 59c31da was 59c31da, checked in by Daniel Lawson <dlawson@…>, 17 years ago

fixes in trace.c for DAG support.
New dagapi / dagopts.c. Still need to find way to build these outside the source

  • Property mode set to 100644
File size: 52.3 KB
Line 
1#define yy_create_buffer dagopt_create_buffer
2#define yy_delete_buffer dagopt_delete_buffer
3#define yy_scan_buffer dagopt_scan_buffer
4#define yy_scan_string dagopt_scan_string
5#define yy_scan_bytes dagopt_scan_bytes
6#define yy_flex_debug dagopt_flex_debug
7#define yy_init_buffer dagopt_init_buffer
8#define yy_flush_buffer dagopt_flush_buffer
9#define yy_load_buffer_state dagopt_load_buffer_state
10#define yy_switch_to_buffer dagopt_switch_to_buffer
11#define yyin dagoptin
12#define yyleng dagoptleng
13#define yylex dagoptlex
14#define yyout dagoptout
15#define yyrestart dagoptrestart
16#define yytext dagopttext
17#define yywrap dagoptwrap
18
19/* A lexical scanner generated by flex */
20
21/* Scanner skeleton version:
22 * $Header$
23 */
24
25#define FLEX_SCANNER
26#define YY_FLEX_MAJOR_VERSION 2
27#define YY_FLEX_MINOR_VERSION 5
28
29#include <stdio.h>
30#include <errno.h>
31
32/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
33#ifdef c_plusplus
34#ifndef __cplusplus
35#define __cplusplus
36#endif
37#endif
38
39
40#ifdef __cplusplus
41
42#include <stdlib.h>
43#ifndef _WIN32
44#include <unistd.h>
45#else
46#ifndef YY_ALWAYS_INTERACTIVE
47#ifndef YY_NEVER_INTERACTIVE
48extern int isatty YY_PROTO(( int ));
49#endif
50#endif
51#endif
52
53/* Use prototypes in function declarations. */
54#define YY_USE_PROTOS
55
56/* The "const" storage-class-modifier is valid. */
57#define YY_USE_CONST
58
59#else   /* ! __cplusplus */
60
61#if __STDC__
62
63#define YY_USE_PROTOS
64#define YY_USE_CONST
65
66#endif  /* __STDC__ */
67#endif  /* ! __cplusplus */
68
69#ifdef __TURBOC__
70 #pragma warn -rch
71 #pragma warn -use
72#include <io.h>
73#include <stdlib.h>
74#define YY_USE_CONST
75#define YY_USE_PROTOS
76#endif
77
78#ifdef YY_USE_CONST
79#define yyconst const
80#else
81#define yyconst
82#endif
83
84
85#ifdef YY_USE_PROTOS
86#define YY_PROTO(proto) proto
87#else
88#define YY_PROTO(proto) ()
89#endif
90
91/* Returned upon end-of-file. */
92#define YY_NULL 0
93
94/* Promotes a possibly negative, possibly signed char to an unsigned
95 * integer for use as an array index.  If the signed char is negative,
96 * we want to instead treat it as an 8-bit unsigned char, hence the
97 * double cast.
98 */
99#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
100
101/* Enter a start condition.  This macro really ought to take a parameter,
102 * but we do it the disgusting crufty way forced on us by the ()-less
103 * definition of BEGIN.
104 */
105#define BEGIN yy_start = 1 + 2 *
106
107/* Translate the current start state into a value that can be later handed
108 * to BEGIN to return to the state.  The YYSTATE alias is for lex
109 * compatibility.
110 */
111#define YY_START ((yy_start - 1) / 2)
112#define YYSTATE YY_START
113
114/* Action number for EOF rule of a given start state. */
115#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
116
117/* Special action meaning "start processing a new file". */
118#define YY_NEW_FILE yyrestart( yyin )
119
120#define YY_END_OF_BUFFER_CHAR 0
121
122/* Size of default input buffer. */
123#define YY_BUF_SIZE 16384
124
125typedef struct yy_buffer_state *YY_BUFFER_STATE;
126
127extern int yyleng;
128extern FILE *yyin, *yyout;
129
130#define EOB_ACT_CONTINUE_SCAN 0
131#define EOB_ACT_END_OF_FILE 1
132#define EOB_ACT_LAST_MATCH 2
133
134/* The funky do-while in the following #define is used to turn the definition
135 * int a single C statement (which needs a semi-colon terminator).  This
136 * avoids problems with code like:
137 *
138 *      if ( condition_holds )
139 *              yyless( 5 );
140 *      else
141 *              do_something_else();
142 *
143 * Prior to using the do-while the compiler would get upset at the
144 * "else" because it interpreted the "if" statement as being all
145 * done when it reached the ';' after the yyless() call.
146 */
147
148/* Return all but the first 'n' matched characters back to the input stream. */
149
150#define yyless(n) \
151        do \
152                { \
153                /* Undo effects of setting up yytext. */ \
154                *yy_cp = yy_hold_char; \
155                YY_RESTORE_YY_MORE_OFFSET \
156                yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
157                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
158                } \
159        while ( 0 )
160
161#define unput(c) yyunput( c, yytext_ptr )
162
163/* The following is because we cannot portably get our hands on size_t
164 * (without autoconf's help, which isn't available because we want
165 * flex-generated scanners to compile on their own).
166 */
167typedef unsigned int yy_size_t;
168
169
170struct yy_buffer_state
171        {
172        FILE *yy_input_file;
173
174        char *yy_ch_buf;                /* input buffer */
175        char *yy_buf_pos;               /* current position in input buffer */
176
177        /* Size of input buffer in bytes, not including room for EOB
178         * characters.
179         */
180        yy_size_t yy_buf_size;
181
182        /* Number of characters read into yy_ch_buf, not including EOB
183         * characters.
184         */
185        int yy_n_chars;
186
187        /* Whether we "own" the buffer - i.e., we know we created it,
188         * and can realloc() it to grow it, and should free() it to
189         * delete it.
190         */
191        int yy_is_our_buffer;
192
193        /* Whether this is an "interactive" input source; if so, and
194         * if we're using stdio for input, then we want to use getc()
195         * instead of fread(), to make sure we stop fetching input after
196         * each newline.
197         */
198        int yy_is_interactive;
199
200        /* Whether we're considered to be at the beginning of a line.
201         * If so, '^' rules will be active on the next match, otherwise
202         * not.
203         */
204        int yy_at_bol;
205
206        /* Whether to try to fill the input buffer when we reach the
207         * end of it.
208         */
209        int yy_fill_buffer;
210
211        int yy_buffer_status;
212#define YY_BUFFER_NEW 0
213#define YY_BUFFER_NORMAL 1
214        /* When an EOF's been seen but there's still some text to process
215         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
216         * shouldn't try reading from the input source any more.  We might
217         * still have a bunch of tokens to match, though, because of
218         * possible backing-up.
219         *
220         * When we actually see the EOF, we change the status to "new"
221         * (via yyrestart()), so that the user can continue scanning by
222         * just pointing yyin at a new input file.
223         */
224#define YY_BUFFER_EOF_PENDING 2
225        };
226
227static YY_BUFFER_STATE yy_current_buffer = 0;
228
229/* We provide macros for accessing buffer states in case in the
230 * future we want to put the buffer states in a more general
231 * "scanner state".
232 */
233#define YY_CURRENT_BUFFER yy_current_buffer
234
235
236/* yy_hold_char holds the character lost when yytext is formed. */
237static char yy_hold_char;
238
239static int yy_n_chars;          /* number of characters read into yy_ch_buf */
240
241
242int yyleng;
243
244/* Points to current character in buffer. */
245static char *yy_c_buf_p = (char *) 0;
246static int yy_init = 1;         /* whether we need to initialize */
247static int yy_start = 0;        /* start state number */
248
249/* Flag which is used to allow yywrap()'s to do buffer switches
250 * instead of setting up a fresh yyin.  A bit of a hack ...
251 */
252static int yy_did_buffer_switch_on_eof;
253
254void yyrestart YY_PROTO(( FILE *input_file ));
255
256void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
257void yy_load_buffer_state YY_PROTO(( void ));
258YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
259void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
260void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
261void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
262#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
263
264YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
265YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
266YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
267
268static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
269static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
270static void yy_flex_free YY_PROTO(( void * ));
271
272#define yy_new_buffer yy_create_buffer
273
274#define yy_set_interactive(is_interactive) \
275        { \
276        if ( ! yy_current_buffer ) \
277                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
278        yy_current_buffer->yy_is_interactive = is_interactive; \
279        }
280
281#define yy_set_bol(at_bol) \
282        { \
283        if ( ! yy_current_buffer ) \
284                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
285        yy_current_buffer->yy_at_bol = at_bol; \
286        }
287
288#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
289
290typedef unsigned char YY_CHAR;
291FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
292typedef int yy_state_type;
293extern char *yytext;
294#define yytext_ptr yytext
295
296static yy_state_type yy_get_previous_state YY_PROTO(( void ));
297static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
298static int yy_get_next_buffer YY_PROTO(( void ));
299static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
300
301/* Done after the current pattern has been matched and before the
302 * corresponding action - sets up yytext.
303 */
304#define YY_DO_BEFORE_ACTION \
305        yytext_ptr = yy_bp; \
306        yyleng = (int) (yy_cp - yy_bp); \
307        yy_hold_char = *yy_cp; \
308        *yy_cp = '\0'; \
309        yy_c_buf_p = yy_cp;
310
311#define YY_NUM_RULES 65
312#define YY_END_OF_BUFFER 66
313static yyconst short int yy_accept[271] =
314    {   0,
315        0,    0,   66,   63,   64,   65,   63,   63,   63,   63,
316       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
317       63,   63,   63,   63,   13,   63,   63,   63,   63,   63,
318       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
319       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
320       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
321       63,   63,   58,   63,   63,   63,   63,   59,   63,   63,
322       14,   30,   63,   63,   63,   63,   63,    2,   63,   31,
323       32,   63,   63,   63,   63,   34,   12,   35,   63,   63,
324       63,   27,   63,   63,   63,   63,   63,   38,   39,   40,
325
326       63,   63,   63,   26,   63,   63,   63,   63,   63,   63,
327       63,   63,   63,   63,   63,   63,   63,   63,    5,    6,
328       63,   63,   63,    3,   63,    4,   63,   63,   63,   63,
329       63,   63,   63,   63,   63,   63,   63,   63,   15,   21,
330       20,   63,   63,   63,   16,   63,   63,   63,   63,   63,
331       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
332       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
333        7,   63,    5,    6,    8,   46,   47,   63,   63,   63,
334       63,   60,   63,   63,   63,   63,   63,   63,   63,   63,
335       23,   22,   63,   10,   11,   63,   63,   63,   63,   63,
336
337       29,   36,   37,   24,   63,   43,   45,   63,   63,   63,
338       63,   31,   63,    7,    9,    8,   63,   41,   63,   63,
339       63,   63,   18,   63,   63,   63,   63,   63,   63,   63,
340       63,   63,   62,   63,   53,   17,   42,   44,   63,    9,
341       63,   58,   48,   63,   63,   54,   63,   59,   50,   28,
342       63,   63,    1,   33,   56,   57,   63,   63,   63,   52,
343       63,   63,   51,   55,   63,   19,   61,   25,   49,    0
344    } ;
345
346static yyconst int yy_ec[256] =
347    {   0,
348        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
349        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
350        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
351        1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
352        1,    1,    1,    1,    1,    1,    1,    4,    5,    6,
353        7,    8,    9,   10,    9,   11,   12,    1,    1,    1,
354       13,    1,    1,    1,    1,    1,    1,    1,    1,    1,
355        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
356        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
357        1,    1,    1,    1,    1,    1,   14,   15,   16,   17,
358
359       18,   19,   20,   21,   22,    1,   23,   24,   25,   26,
360       27,   28,   29,   30,   31,   32,   33,   34,   35,   36,
361       37,    1,    1,    1,    1,    1,    1,    1,    1,    1,
362        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
363        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
364        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
365        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
366        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
367        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
368        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
369
370        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
371        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
372        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
373        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
374        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
375        1,    1,    1,    1,    1
376    } ;
377
378static yyconst int yy_meta[38] =
379    {   0,
380        1,    2,    2,    1,    1,    1,    1,    1,    1,    1,
381        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
382        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
383        1,    1,    1,    1,    1,    1,    1
384    } ;
385
386static yyconst short int yy_base[272] =
387    {   0,
388        0,    0,  360,    0,  361,  361,  355,   21,  328,   28,
389       19,   25,   35,   45,   50,   44,  341,   38,   56,   57,
390      320,  341,  340,    0,  349,  327,  329,  332,  332,  334,
391      331,  321,  313,  328,  313,  323,  310,  313,  325,  314,
392      316,  312,  299,  320,  313,   36,  314,  305,   61,   80,
393      323,  298,  292,  309,  310,   79,   83,   72,  294,  308,
394      288,  291,   74,  291,  293,   94,  305,   87,  288,  291,
395      312,    0,  279,  298,  289,  281,  281,    0,  283,  111,
396        0,  295,  103,  280,  292,    0,    0,    0,  288,  283,
397      283,    0,  285,  278,  281,  271,  283,    0,    0,    0,
398
399      266,  102,  273,    0,   90,  266,  108,  266,  278,  105,
400      112,  123,  271,  107,  113,  117,  256,  277,  134,  274,
401      278,  252,  261,    0,  256,    0,  267,  258,  260,  246,
402      267,  250,  245,  252,  245,  250,  252,  250,    0,    0,
403        0,  255,  241,  257,    0,  260,  263,  236,  234,  252,
404      252,  240,  246,  236,  241,  230,  235,  245,  233,  232,
405      237,  225,  237,  228,  235,  219,  218,  220,  233,  218,
406      229,  238,    0,    0,  227,    0,    0,  228,  209,  216,
407      207,    0,  213,  205,  218,  222,  201,  209,  200,  213,
408        0,    0,  205,    0,    0,  199,  204,  197,  153,  208,
409
410        0,    0,    0,    0,  162,    0,    0,  195,  200,  199,
411      191,  190,  204,    0,  203,    0,  193,    0,  180,  185,
412      200,  201,    0,  171,  182,  175,  180,  129,  139,  131,
413      120,  134,    0,  120,    0,    0,    0,    0,  135,    0,
414      132,    0,    0,  121,  180,    0,  126,    0,    0,    0,
415      112,   71,    0,    0,    0,    0,  189,   63,   64,    0,
416      198,   57,    0,    0,   50,    0,    0,    0,    0,  361,
417       38
418    } ;
419
420static yyconst short int yy_def[272] =
421    {   0,
422      270,    1,  270,  271,  270,  270,  271,  271,  271,  271,
423      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
424      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
425      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
426      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
427      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
428      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
429      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
430      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
431      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
432
433      271,  271,  271,  271,    8,  271,  271,  271,  271,  271,
434      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
435      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
436      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
437      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
438      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
439      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
440      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
441      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
442      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
443
444      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
445      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
446      271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
447      271,  271,  199,  271,  205,  271,  271,  271,  271,  271,
448      271,  271,  271,  271,  271,  224,  271,  271,  271,  271,
449      271,  271,  271,  271,  271,  271,  271,  271,  271,  245,
450      245,  271,  271,  257,  271,  271,  261,  271,  271,    0,
451      270
452    } ;
453
454static yyconst short int yy_nxt[399] =
455    {   0,
456        4,    5,    6,    4,    7,    4,    4,    4,    4,    4,
457        4,    4,    4,    8,    4,    9,   10,   11,   12,    4,
458       13,    4,    4,   14,   15,   16,   17,   18,    4,   19,
459       20,   21,    4,   22,   23,    4,    4,   26,   24,   27,
460       42,   28,   29,   35,   39,   36,   43,   40,   30,   37,
461       41,   31,   32,   33,   44,   51,   45,   38,   46,   54,
462       47,   92,   58,   52,   59,   55,   93,  269,   60,   61,
463       56,   48,   64,   62,  268,   49,   50,   65,   96,   97,
464       66,  266,   53,   98,   99,  122,  265,  119,   67,  120,
465      121,   63,  105,  123,  106,  107,  108,  109,  263,  110,
466
467      128,  129,  111,  112,  113,  130,  114,  133,  115,  116,
468      117,  134,  118,  136,  137,  146,   85,  147,  150,  162,
469      163,   24,   24,   35,   44,  167,   45,   47,   51,  166,
470       62,   58,   64,  255,  256,  262,   52,   60,  261,  171,
471      169,  148,   49,   50,  259,  172,  258,  257,  168,  173,
472      254,  253,  252,  251,  250,   53,  233,  233,  233,  233,
473      233,  233,  233,  233,  233,  235,  235,  235,  235,  235,
474      235,  235,  235,  235,  246,  246,  246,  246,  246,  246,
475      246,  246,  246,  260,  260,  260,  260,  260,  260,  260,
476      260,  260,  264,  264,  264,  264,  264,  264,  264,  264,
477
478      264,  267,  267,  267,  267,  267,  267,  267,  267,  267,
479      249,  248,  247,  245,  244,  243,  242,  241,  240,  150,
480      148,  239,  238,  237,  236,  234,  232,  231,  230,  229,
481      228,  227,  226,  225,  224,  223,  222,  221,  220,  219,
482      218,  217,  216,  215,  214,  137,  133,  129,   93,  213,
483      212,  211,  210,  209,  208,  207,  206,  205,  204,  203,
484       44,  202,  201,  200,  199,  198,  197,  196,  195,  194,
485      193,  192,  191,  190,  189,  188,  187,  186,  185,  184,
486      183,  182,  181,  180,  179,  178,  177,  176,  175,  174,
487       69,  170,   55,   42,   40,  165,  164,  161,  160,  159,
488
489      158,  157,  156,  155,  154,  153,  152,  151,  149,  145,
490      144,  143,  142,  141,  140,  139,   92,  138,  135,  132,
491      131,  127,  126,  125,  124,  104,  103,  102,  101,  100,
492       95,   94,   91,   90,   89,   88,   87,   86,   85,   84,
493       83,   82,   81,   80,   79,   78,   77,   76,   75,   74,
494       73,   72,   71,   70,   69,   68,   57,   34,   25,  270,
495        3,  270,  270,  270,  270,  270,  270,  270,  270,  270,
496      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
497      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
498      270,  270,  270,  270,  270,  270,  270,  270
499
500    } ;
501
502static yyconst short int yy_chk[399] =
503    {   0,
504        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
505        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
506        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
507        1,    1,    1,    1,    1,    1,    1,    8,  271,    8,
508       12,    8,    8,   10,   11,   10,   12,   11,    8,   10,
509       11,    8,    8,    8,   13,   15,   13,   10,   14,   16,
510       14,   46,   18,   15,   18,   16,   46,  265,   18,   19,
511       16,   14,   20,   19,  262,   14,   14,   20,   49,   49,
512       20,  259,   15,   50,   50,   58,  258,   57,   20,   57,
513       57,   19,   56,   58,   56,   56,   56,   56,  252,   56,
514
515       63,   63,   56,   56,   56,   63,   56,   66,   56,   56,
516       56,   66,   56,   68,   68,   80,   83,   80,   83,  102,
517      102,  105,  105,  107,  110,  111,  110,  111,  112,  107,
518      115,  114,  116,  234,  234,  251,  112,  114,  247,  119,
519      116,   80,  111,  111,  244,  119,  241,  239,  115,  119,
520      232,  231,  230,  229,  228,  112,  199,  199,  199,  199,
521      199,  199,  199,  199,  199,  205,  205,  205,  205,  205,
522      205,  205,  205,  205,  224,  224,  224,  224,  224,  224,
523      224,  224,  224,  245,  245,  245,  245,  245,  245,  245,
524      245,  245,  257,  257,  257,  257,  257,  257,  257,  257,
525
526      257,  261,  261,  261,  261,  261,  261,  261,  261,  261,
527      227,  226,  225,  222,  221,  220,  219,  217,  215,  213,
528      212,  211,  210,  209,  208,  200,  198,  197,  196,  193,
529      190,  189,  188,  187,  186,  185,  184,  183,  181,  180,
530      179,  178,  175,  172,  171,  170,  169,  168,  167,  166,
531      165,  164,  163,  162,  161,  160,  159,  158,  157,  156,
532      155,  154,  153,  152,  151,  150,  149,  148,  147,  146,
533      144,  143,  142,  138,  137,  136,  135,  134,  133,  132,
534      131,  130,  129,  128,  127,  125,  123,  122,  121,  120,
535      118,  117,  113,  109,  108,  106,  103,  101,   97,   96,
536
537       95,   94,   93,   91,   90,   89,   85,   84,   82,   79,
538       77,   76,   75,   74,   73,   71,   70,   69,   67,   65,
539       64,   62,   61,   60,   59,   55,   54,   53,   52,   51,
540       48,   47,   45,   44,   43,   42,   41,   40,   39,   38,
541       37,   36,   35,   34,   33,   32,   31,   30,   29,   28,
542       27,   26,   25,   23,   22,   21,   17,    9,    7,    3,
543      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
544      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
545      270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
546      270,  270,  270,  270,  270,  270,  270,  270
547
548    } ;
549
550static yy_state_type yy_last_accepting_state;
551static char *yy_last_accepting_cpos;
552
553/* The intent behind this definition is that it'll catch
554 * any uses of REJECT which flex missed.
555 */
556#define REJECT reject_used_but_not_detected
557#define yymore() yymore_used_but_not_detected
558#define YY_MORE_ADJ 0
559#define YY_RESTORE_YY_MORE_OFFSET
560char *yytext;
561#line 1 "dagopts.l"
562#define INITIAL 0
563/*
564 * Copyright (c) 2003 Endace Technology Ltd, Hamilton, New Zealand.
565 * All rights reserved.
566 *
567 * This source code is proprietary to Endace Technology Ltd and no part
568 * of it may be redistributed, published or disclosed except as outlined
569 * in the written contract supplied with this product.
570 *
571 * $Id$
572 */
573#line 12 "dagopts.l"
574
575# include       <dagtoken.h>
576# define        YY_NO_UNPUT
577
578#define yylval dagoptlval
579
580int     yylval;
581
582
583/* Macros after this point can all be overridden by user definitions in
584 * section 1.
585 */
586
587#ifndef YY_SKIP_YYWRAP
588#ifdef __cplusplus
589extern "C" int yywrap YY_PROTO(( void ));
590#else
591extern int yywrap YY_PROTO(( void ));
592#endif
593#endif
594
595#ifndef YY_NO_UNPUT
596static void yyunput YY_PROTO(( int c, char *buf_ptr ));
597#endif
598
599#ifndef yytext_ptr
600static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
601#endif
602
603#ifdef YY_NEED_STRLEN
604static int yy_flex_strlen YY_PROTO(( yyconst char * ));
605#endif
606
607#ifndef YY_NO_INPUT
608#ifdef __cplusplus
609static int yyinput YY_PROTO(( void ));
610#else
611static int input YY_PROTO(( void ));
612#endif
613#endif
614
615#if YY_STACK_USED
616static int yy_start_stack_ptr = 0;
617static int yy_start_stack_depth = 0;
618static int *yy_start_stack = 0;
619#ifndef YY_NO_PUSH_STATE
620static void yy_push_state YY_PROTO(( int new_state ));
621#endif
622#ifndef YY_NO_POP_STATE
623static void yy_pop_state YY_PROTO(( void ));
624#endif
625#ifndef YY_NO_TOP_STATE
626static int yy_top_state YY_PROTO(( void ));
627#endif
628
629#else
630#define YY_NO_PUSH_STATE 1
631#define YY_NO_POP_STATE 1
632#define YY_NO_TOP_STATE 1
633#endif
634
635#ifdef YY_MALLOC_DECL
636YY_MALLOC_DECL
637#else
638#if __STDC__
639#ifndef __cplusplus
640#include <stdlib.h>
641#endif
642#else
643/* Just try to get by without declaring the routines.  This will fail
644 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
645 * or sizeof(void*) != sizeof(int).
646 */
647#endif
648#endif
649
650/* Amount of stuff to slurp up with each read. */
651#ifndef YY_READ_BUF_SIZE
652#define YY_READ_BUF_SIZE 8192
653#endif
654
655/* Copy whatever the last rule matched to the standard output. */
656
657#ifndef ECHO
658/* This used to be an fputs(), but since the string might contain NUL's,
659 * we now use fwrite().
660 */
661#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
662#endif
663
664/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
665 * is returned in "result".
666 */
667#ifndef YY_INPUT
668#define YY_INPUT(buf,result,max_size) \
669        if ( yy_current_buffer->yy_is_interactive ) \
670                { \
671                int c = '*', n; \
672                for ( n = 0; n < max_size && \
673                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
674                        buf[n] = (char) c; \
675                if ( c == '\n' ) \
676                        buf[n++] = (char) c; \
677                if ( c == EOF && ferror( yyin ) ) \
678                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
679                result = n; \
680                } \
681        else \
682                { \
683                errno=0; \
684                while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
685                        { \
686                        if( errno != EINTR) \
687                                { \
688                                YY_FATAL_ERROR( "input in flex scanner failed" ); \
689                                break; \
690                                } \
691                        errno=0; \
692                        clearerr(yyin); \
693                        } \
694                }
695#endif
696
697/* No semi-colon after return; correct usage is to write "yyterminate();" -
698 * we don't want an extra ';' after the "return" because that will cause
699 * some compilers to complain about unreachable statements.
700 */
701#ifndef yyterminate
702#define yyterminate() return YY_NULL
703#endif
704
705/* Number of entries by which start-condition stack grows. */
706#ifndef YY_START_STACK_INCR
707#define YY_START_STACK_INCR 25
708#endif
709
710/* Report a fatal error. */
711#ifndef YY_FATAL_ERROR
712#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
713#endif
714
715/* Default declaration of generated scanner - a define so the user can
716 * easily add parameters.
717 */
718#ifndef YY_DECL
719#define YY_DECL int yylex YY_PROTO(( void ))
720#endif
721
722/* Code executed at the beginning of each rule, after yytext and yyleng
723 * have been set up.
724 */
725#ifndef YY_USER_ACTION
726#define YY_USER_ACTION
727#endif
728
729/* Code executed at the end of each rule. */
730#ifndef YY_BREAK
731#define YY_BREAK break;
732#endif
733
734#define YY_RULE_SETUP \
735        YY_USER_ACTION
736
737YY_DECL
738        {
739        register yy_state_type yy_current_state;
740        register char *yy_cp, *yy_bp;
741        register int yy_act;
742
743#line 22 "dagopts.l"
744
745
746        yylval = 0;     /* do this for every token not using yylval, to be on the safe side */
747
748
749        if ( yy_init )
750                {
751                yy_init = 0;
752
753#ifdef YY_USER_INIT
754                YY_USER_INIT;
755#endif
756
757                if ( ! yy_start )
758                        yy_start = 1;   /* first start state */
759
760                if ( ! yyin )
761                        yyin = stdin;
762
763                if ( ! yyout )
764                        yyout = stdout;
765
766                if ( ! yy_current_buffer )
767                        yy_current_buffer =
768                                yy_create_buffer( yyin, YY_BUF_SIZE );
769
770                yy_load_buffer_state();
771                }
772
773        while ( 1 )             /* loops until end-of-file is reached */
774                {
775                yy_cp = yy_c_buf_p;
776
777                /* Support of yytext. */
778                *yy_cp = yy_hold_char;
779
780                /* yy_bp points to the position in yy_ch_buf of the start of
781                 * the current run.
782                 */
783                yy_bp = yy_cp;
784
785                yy_current_state = yy_start;
786yy_match:
787                do
788                        {
789                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
790                        if ( yy_accept[yy_current_state] )
791                                {
792                                yy_last_accepting_state = yy_current_state;
793                                yy_last_accepting_cpos = yy_cp;
794                                }
795                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
796                                {
797                                yy_current_state = (int) yy_def[yy_current_state];
798                                if ( yy_current_state >= 271 )
799                                        yy_c = yy_meta[(unsigned int) yy_c];
800                                }
801                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
802                        ++yy_cp;
803                        }
804                while ( yy_base[yy_current_state] != 361 );
805
806yy_find_action:
807                yy_act = yy_accept[yy_current_state];
808                if ( yy_act == 0 )
809                        { /* have to back up */
810                        yy_cp = yy_last_accepting_cpos;
811                        yy_current_state = yy_last_accepting_state;
812                        yy_act = yy_accept[yy_current_state];
813                        }
814
815                YY_DO_BEFORE_ACTION;
816
817
818do_action:      /* This label is used only to access EOF actions. */
819
820
821                switch ( yy_act )
822        { /* beginning of action switch */
823                        case 0: /* must back up */
824                        /* undo the effects of YY_DO_BEFORE_ACTION */
825                        *yy_cp = yy_hold_char;
826                        yy_cp = yy_last_accepting_cpos;
827                        yy_current_state = yy_last_accepting_state;
828                        goto yy_find_action;
829
830case 1:
831YY_RULE_SETUP
832#line 26 "dagopts.l"
833{ return T_DEFAULT; }
834        YY_BREAK
835case 2:
836YY_RULE_SETUP
837#line 27 "dagopts.l"
838{ return T_ATM; }
839        YY_BREAK
840case 3:
841YY_RULE_SETUP
842#line 28 "dagopts.l"
843{ return T_POS; }
844        YY_BREAK
845case 4:
846YY_RULE_SETUP
847#line 29 "dagopts.l"
848{ return T_RAW; }
849        YY_BREAK
850case 5:
851YY_RULE_SETUP
852#line 30 "dagopts.l"
853{ return T_LINK_OC1; }
854        YY_BREAK
855case 6:
856YY_RULE_SETUP
857#line 31 "dagopts.l"
858{ return T_LINK_OC3; }
859        YY_BREAK
860case 7:
861YY_RULE_SETUP
862#line 32 "dagopts.l"
863{ return T_LINK_OC12; }
864        YY_BREAK
865case 8:
866YY_RULE_SETUP
867#line 33 "dagopts.l"
868{ return T_LINK_OC48; }
869        YY_BREAK
870case 9:
871YY_RULE_SETUP
872#line 34 "dagopts.l"
873{ return T_LINK_OC192; }
874        YY_BREAK
875case 10:
876YY_RULE_SETUP
877#line 35 "dagopts.l"
878{ return T_POS_CRC16; }
879        YY_BREAK
880case 11:
881YY_RULE_SETUP
882#line 36 "dagopts.l"
883{ return T_POS_CRC32; }
884        YY_BREAK
885case 12:
886YY_RULE_SETUP
887#line 37 "dagopts.l"
888{ return T_ETH; }
889        YY_BREAK
890case 13:
891YY_RULE_SETUP
892#line 38 "dagopts.l"
893{ return T_ETH_10; }
894        YY_BREAK
895case 14:
896YY_RULE_SETUP
897#line 39 "dagopts.l"
898{ return T_ETH_100; }
899        YY_BREAK
900case 15:
901YY_RULE_SETUP
902#line 40 "dagopts.l"
903{ return T_ETH_1000; }
904        YY_BREAK
905case 16:
906YY_RULE_SETUP
907#line 41 "dagopts.l"
908{ return T_ETH_AUTO; }
909        YY_BREAK
910case 17:
911YY_RULE_SETUP
912#line 42 "dagopts.l"
913{ return (yytext[0]!='n') ? T_SONET_MASTER : T_SONET_SLAVE; }
914        YY_BREAK
915case 18:
916YY_RULE_SETUP
917#line 43 "dagopts.l"
918{ return (yytext[0]!='n') ? T_SONET_SLAVE  : T_SONET_MASTER; }
919        YY_BREAK
920case 19:
921YY_RULE_SETUP
922#line 44 "dagopts.l"
923{ yylval = (yytext[0]!='n') ; return T_SONET_SCRAMBLE; }
924        YY_BREAK
925case 20:
926YY_RULE_SETUP
927#line 45 "dagopts.l"
928{ yylval = (yytext[0]!='n') ; return T_ATM_ADD_HEC; }
929        YY_BREAK
930case 21:
931YY_RULE_SETUP
932#line 46 "dagopts.l"
933{ yylval = (yytext[0]!='n') ; return T_ATM_FIX_HEC; }
934        YY_BREAK
935case 22:
936YY_RULE_SETUP
937#line 47 "dagopts.l"
938{ yylval = (yytext[0]!='n') ; return T_ATM_PASS_HEC; }
939        YY_BREAK
940case 23:
941YY_RULE_SETUP
942#line 48 "dagopts.l"
943{ yylval = (yytext[0]!='n') ; return T_ATM_PASS_IDLE; }
944        YY_BREAK
945case 24:
946YY_RULE_SETUP
947#line 49 "dagopts.l"
948{ yylval = (yytext[0]!='n') ; return T_ATM_LCELL; }
949        YY_BREAK
950case 25:
951YY_RULE_SETUP
952#line 50 "dagopts.l"
953{ yylval = (yytext[0]!='n') ; return T_ATM_PLOAD_SCRAMBLE; }
954        YY_BREAK
955case 26:
956YY_RULE_SETUP
957#line 51 "dagopts.l"
958{ yylval = (yytext[1]!='o') ; return T_ETH_NIC; }
959        YY_BREAK
960case 27:
961YY_RULE_SETUP
962#line 52 "dagopts.l"
963{ yylval = (yytext[0]!='l') ; return T_ETH_WAN; }
964        YY_BREAK
965case 28:
966YY_RULE_SETUP
967#line 53 "dagopts.l"
968{ yylval = (yytext[0]!='n') ; return T_GPP_VARLEN; }
969        YY_BREAK
970case 29:
971YY_RULE_SETUP
972#line 54 "dagopts.l"
973{ yylval = 0 ; return T_GPP_VARLEN; }
974        YY_BREAK
975case 30:
976YY_RULE_SETUP
977#line 55 "dagopts.l"
978{ yylval = (yytext[0]!='n') ; return T_LINK_ADM; }
979        YY_BREAK
980case 31:
981YY_RULE_SETUP
982#line 56 "dagopts.l"
983{ yylval = (yytext[0]!='n') ; return T_LINK_CRC; }
984        YY_BREAK
985case 32:
986YY_RULE_SETUP
987#line 57 "dagopts.l"
988{ yylval = (yytext[0]!='n') ; return T_LINK_DCR; }
989        YY_BREAK
990case 33:
991YY_RULE_SETUP
992#line 58 "dagopts.l"
993{ yylval = (yytext[0]!='n') ; return T_LINK_DISCARD; }
994        YY_BREAK
995case 34:
996YY_RULE_SETUP
997#line 59 "dagopts.l"
998{ yylval = (yytext[0]!='n') ; return T_LINK_EQL; }
999        YY_BREAK
1000case 35:
1001YY_RULE_SETUP
1002#line 60 "dagopts.l"
1003{ yylval = (yytext[0]!='n') ; return T_LINK_FCL; }
1004        YY_BREAK
1005case 36:
1006YY_RULE_SETUP
1007#line 61 "dagopts.l"
1008{ yylval = (yytext[0]!='n') ; return T_LINK_HGAIN; }
1009        YY_BREAK
1010case 37:
1011YY_RULE_SETUP
1012#line 62 "dagopts.l"
1013{ yylval = (yytext[0]!='n') ; return T_LINK_LASER; }
1014        YY_BREAK
1015case 38:
1016YY_RULE_SETUP
1017#line 63 "dagopts.l"
1018{ yylval = (yytext[0]!='n') ; return T_LINK_LT0; }
1019        YY_BREAK
1020case 39:
1021YY_RULE_SETUP
1022#line 64 "dagopts.l"
1023{ yylval = (yytext[0]!='n') ; return T_LINK_LT1; }
1024        YY_BREAK
1025case 40:
1026YY_RULE_SETUP
1027#line 65 "dagopts.l"
1028{ yylval = (yytext[0]!='n') ; return T_LINK_M23; }
1029        YY_BREAK
1030case 41:
1031YY_RULE_SETUP
1032#line 66 "dagopts.l"
1033{ yylval = (yytext[0]!='n') ; return T_LINK_RESET; }
1034        YY_BREAK
1035case 42:
1036#line 68 "dagopts.l"
1037case 43:
1038YY_RULE_SETUP
1039#line 68 "dagopts.l"
1040{ yylval = (yytext[0]!='n') ; return T_LINK_LSEQL; }
1041        YY_BREAK
1042case 44:
1043#line 70 "dagopts.l"
1044case 45:
1045YY_RULE_SETUP
1046#line 70 "dagopts.l"
1047{ yylval = (yytext[0]!='n') ; return T_LINK_LSFCL; }
1048        YY_BREAK
1049case 46:
1050YY_RULE_SETUP
1051#line 71 "dagopts.l"
1052{ yylval = (yytext[0]!='n') ; return T_POS_MAXCHECK; }
1053        YY_BREAK
1054case 47:
1055YY_RULE_SETUP
1056#line 72 "dagopts.l"
1057{ yylval = (yytext[0]!='n') ; return T_POS_MINCHECK; }
1058        YY_BREAK
1059case 48:
1060YY_RULE_SETUP
1061#line 73 "dagopts.l"
1062{ yylval = (yytext[0]!='n') ; return T_POS_RXPKTS; }
1063        YY_BREAK
1064case 49:
1065YY_RULE_SETUP
1066#line 74 "dagopts.l"
1067{ yylval = (yytext[0]!='n') ; return T_POS_SCRAMBLE; }
1068        YY_BREAK
1069case 50:
1070YY_RULE_SETUP
1071#line 75 "dagopts.l"
1072{ yylval = (yytext[0]!='n') ; return T_POS_TXPKTS; }
1073        YY_BREAK
1074case 51:
1075YY_RULE_SETUP
1076#line 76 "dagopts.l"
1077{ yylval = (yytext[0]!='n') ; return T_POS_CRCSTRIP; }
1078        YY_BREAK
1079case 52:
1080YY_RULE_SETUP
1081#line 77 "dagopts.l"
1082{ yylval = strtoul(&yytext[6], NULL, 0) ; return T_POS_MINLEN; }
1083        YY_BREAK
1084case 53:
1085YY_RULE_SETUP
1086#line 78 "dagopts.l"
1087{ yylval = strtoul(&yytext[5], NULL, 0) ; return T_POS_MAXLEN; }
1088        YY_BREAK
1089case 54:
1090YY_RULE_SETUP
1091#line 79 "dagopts.l"
1092{ yylval = strtoul(&yytext[5], NULL, 0) ; return T_GPP_SLEN; }
1093        YY_BREAK
1094case 55:
1095YY_RULE_SETUP
1096#line 80 "dagopts.l"
1097{ yylval = strtoul(&yytext[7], NULL, 0) ; return T_ATM_NCELLS; }
1098        YY_BREAK
1099case 56:
1100YY_RULE_SETUP
1101#line 81 "dagopts.l"
1102{ yylval = (yytext[0]!='d') ; return T_GPP_ENABLE_A; }
1103        YY_BREAK
1104case 57:
1105YY_RULE_SETUP
1106#line 82 "dagopts.l"
1107{ yylval = (yytext[0]!='d') ; return T_GPP_ENABLE_B; }
1108        YY_BREAK
1109case 58:
1110YY_RULE_SETUP
1111#line 83 "dagopts.l"
1112{ yylval = 0x1; return T_PBM_MEMCONFIG; }
1113        YY_BREAK
1114case 59:
1115YY_RULE_SETUP
1116#line 84 "dagopts.l"
1117{ yylval = 0x2; return T_PBM_MEMCONFIG; }
1118        YY_BREAK
1119case 60:
1120YY_RULE_SETUP
1121#line 85 "dagopts.l"
1122{ yylval = 0x3; return T_PBM_MEMCONFIG; }
1123        YY_BREAK
1124case 61:
1125YY_RULE_SETUP
1126#line 86 "dagopts.l"
1127
1128        YY_BREAK
1129case 62:
1130YY_RULE_SETUP
1131#line 87 "dagopts.l"
1132
1133        YY_BREAK
1134case 63:
1135YY_RULE_SETUP
1136#line 88 "dagopts.l"
1137{ return T_ERROR; }
1138        YY_BREAK
1139case 64:
1140YY_RULE_SETUP
1141#line 89 "dagopts.l"
1142
1143        YY_BREAK
1144case 65:
1145YY_RULE_SETUP
1146#line 90 "dagopts.l"
1147ECHO;
1148        YY_BREAK
1149case YY_STATE_EOF(INITIAL):
1150        yyterminate();
1151
1152        case YY_END_OF_BUFFER:
1153                {
1154                /* Amount of text matched not including the EOB char. */
1155                int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1156
1157                /* Undo the effects of YY_DO_BEFORE_ACTION. */
1158                *yy_cp = yy_hold_char;
1159                YY_RESTORE_YY_MORE_OFFSET
1160
1161                if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1162                        {
1163                        /* We're scanning a new file or input source.  It's
1164                         * possible that this happened because the user
1165                         * just pointed yyin at a new source and called
1166                         * yylex().  If so, then we have to assure
1167                         * consistency between yy_current_buffer and our
1168                         * globals.  Here is the right place to do so, because
1169                         * this is the first action (other than possibly a
1170                         * back-up) that will match for the new input source.
1171                         */
1172                        yy_n_chars = yy_current_buffer->yy_n_chars;
1173                        yy_current_buffer->yy_input_file = yyin;
1174                        yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1175                        }
1176
1177                /* Note that here we test for yy_c_buf_p "<=" to the position
1178                 * of the first EOB in the buffer, since yy_c_buf_p will
1179                 * already have been incremented past the NUL character
1180                 * (since all states make transitions on EOB to the
1181                 * end-of-buffer state).  Contrast this with the test
1182                 * in input().
1183                 */
1184                if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1185                        { /* This was really a NUL. */
1186                        yy_state_type yy_next_state;
1187
1188                        yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1189
1190                        yy_current_state = yy_get_previous_state();
1191
1192                        /* Okay, we're now positioned to make the NUL
1193                         * transition.  We couldn't have
1194                         * yy_get_previous_state() go ahead and do it
1195                         * for us because it doesn't know how to deal
1196                         * with the possibility of jamming (and we don't
1197                         * want to build jamming into it because then it
1198                         * will run more slowly).
1199                         */
1200
1201                        yy_next_state = yy_try_NUL_trans( yy_current_state );
1202
1203                        yy_bp = yytext_ptr + YY_MORE_ADJ;
1204
1205                        if ( yy_next_state )
1206                                {
1207                                /* Consume the NUL. */
1208                                yy_cp = ++yy_c_buf_p;
1209                                yy_current_state = yy_next_state;
1210                                goto yy_match;
1211                                }
1212
1213                        else
1214                                {
1215                                yy_cp = yy_c_buf_p;
1216                                goto yy_find_action;
1217                                }
1218                        }
1219
1220                else switch ( yy_get_next_buffer() )
1221                        {
1222                        case EOB_ACT_END_OF_FILE:
1223                                {
1224                                yy_did_buffer_switch_on_eof = 0;
1225
1226                                if ( yywrap() )
1227                                        {
1228                                        /* Note: because we've taken care in
1229                                         * yy_get_next_buffer() to have set up
1230                                         * yytext, we can now set up
1231                                         * yy_c_buf_p so that if some total
1232                                         * hoser (like flex itself) wants to
1233                                         * call the scanner after we return the
1234                                         * YY_NULL, it'll still work - another
1235                                         * YY_NULL will get returned.
1236                                         */
1237                                        yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1238
1239                                        yy_act = YY_STATE_EOF(YY_START);
1240                                        goto do_action;
1241                                        }
1242
1243                                else
1244                                        {
1245                                        if ( ! yy_did_buffer_switch_on_eof )
1246                                                YY_NEW_FILE;
1247                                        }
1248                                break;
1249                                }
1250
1251                        case EOB_ACT_CONTINUE_SCAN:
1252                                yy_c_buf_p =
1253                                        yytext_ptr + yy_amount_of_matched_text;
1254
1255                                yy_current_state = yy_get_previous_state();
1256
1257                                yy_cp = yy_c_buf_p;
1258                                yy_bp = yytext_ptr + YY_MORE_ADJ;
1259                                goto yy_match;
1260
1261                        case EOB_ACT_LAST_MATCH:
1262                                yy_c_buf_p =
1263                                &yy_current_buffer->yy_ch_buf[yy_n_chars];
1264
1265                                yy_current_state = yy_get_previous_state();
1266
1267                                yy_cp = yy_c_buf_p;
1268                                yy_bp = yytext_ptr + YY_MORE_ADJ;
1269                                goto yy_find_action;
1270                        }
1271                break;
1272                }
1273
1274        default:
1275                YY_FATAL_ERROR(
1276                        "fatal flex scanner internal error--no action found" );
1277        } /* end of action switch */
1278                } /* end of scanning one token */
1279        } /* end of yylex */
1280
1281
1282/* yy_get_next_buffer - try to read in a new buffer
1283 *
1284 * Returns a code representing an action:
1285 *      EOB_ACT_LAST_MATCH -
1286 *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1287 *      EOB_ACT_END_OF_FILE - end of file
1288 */
1289
1290static int yy_get_next_buffer()
1291        {
1292        register char *dest = yy_current_buffer->yy_ch_buf;
1293        register char *source = yytext_ptr;
1294        register int number_to_move, i;
1295        int ret_val;
1296
1297        if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1298                YY_FATAL_ERROR(
1299                "fatal flex scanner internal error--end of buffer missed" );
1300
1301        if ( yy_current_buffer->yy_fill_buffer == 0 )
1302                { /* Don't try to fill the buffer, so this is an EOF. */
1303                if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1304                        {
1305                        /* We matched a single character, the EOB, so
1306                         * treat this as a final EOF.
1307                         */
1308                        return EOB_ACT_END_OF_FILE;
1309                        }
1310
1311                else
1312                        {
1313                        /* We matched some text prior to the EOB, first
1314                         * process it.
1315                         */
1316                        return EOB_ACT_LAST_MATCH;
1317                        }
1318                }
1319
1320        /* Try to read more data. */
1321
1322        /* First move last chars to start of buffer. */
1323        number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1324
1325        for ( i = 0; i < number_to_move; ++i )
1326                *(dest++) = *(source++);
1327
1328        if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1329                /* don't do the read, it's not guaranteed to return an EOF,
1330                 * just force an EOF
1331                 */
1332                yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1333
1334        else
1335                {
1336                int num_to_read =
1337                        yy_current_buffer->yy_buf_size - number_to_move - 1;
1338
1339                while ( num_to_read <= 0 )
1340                        { /* Not enough room in the buffer - grow it. */
1341#ifdef YY_USES_REJECT
1342                        YY_FATAL_ERROR(
1343"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1344#else
1345
1346                        /* just a shorter name for the current buffer */
1347                        YY_BUFFER_STATE b = yy_current_buffer;
1348
1349                        int yy_c_buf_p_offset =
1350                                (int) (yy_c_buf_p - b->yy_ch_buf);
1351
1352                        if ( b->yy_is_our_buffer )
1353                                {
1354                                int new_size = b->yy_buf_size * 2;
1355
1356                                if ( new_size <= 0 )
1357                                        b->yy_buf_size += b->yy_buf_size / 8;
1358                                else
1359                                        b->yy_buf_size *= 2;
1360
1361                                b->yy_ch_buf = (char *)
1362                                        /* Include room in for 2 EOB chars. */
1363                                        yy_flex_realloc( (void *) b->yy_ch_buf,
1364                                                         b->yy_buf_size + 2 );
1365                                }
1366                        else
1367                                /* Can't grow it, we don't own it. */
1368                                b->yy_ch_buf = 0;
1369
1370                        if ( ! b->yy_ch_buf )
1371                                YY_FATAL_ERROR(
1372                                "fatal error - scanner input buffer overflow" );
1373
1374                        yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1375
1376                        num_to_read = yy_current_buffer->yy_buf_size -
1377                                                number_to_move - 1;
1378#endif
1379                        }
1380
1381                if ( num_to_read > YY_READ_BUF_SIZE )
1382                        num_to_read = YY_READ_BUF_SIZE;
1383
1384                /* Read in more data. */
1385                YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1386                        yy_n_chars, num_to_read );
1387
1388                yy_current_buffer->yy_n_chars = yy_n_chars;
1389                }
1390
1391        if ( yy_n_chars == 0 )
1392                {
1393                if ( number_to_move == YY_MORE_ADJ )
1394                        {
1395                        ret_val = EOB_ACT_END_OF_FILE;
1396                        yyrestart( yyin );
1397                        }
1398
1399                else
1400                        {
1401                        ret_val = EOB_ACT_LAST_MATCH;
1402                        yy_current_buffer->yy_buffer_status =
1403                                YY_BUFFER_EOF_PENDING;
1404                        }
1405                }
1406
1407        else
1408                ret_val = EOB_ACT_CONTINUE_SCAN;
1409
1410        yy_n_chars += number_to_move;
1411        yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1412        yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1413
1414        yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1415
1416        return ret_val;
1417        }
1418
1419
1420/* yy_get_previous_state - get the state just before the EOB char was reached */
1421
1422static yy_state_type yy_get_previous_state()
1423        {
1424        register yy_state_type yy_current_state;
1425        register char *yy_cp;
1426
1427        yy_current_state = yy_start;
1428
1429        for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1430                {
1431                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1432                if ( yy_accept[yy_current_state] )
1433                        {
1434                        yy_last_accepting_state = yy_current_state;
1435                        yy_last_accepting_cpos = yy_cp;
1436                        }
1437                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1438                        {
1439                        yy_current_state = (int) yy_def[yy_current_state];
1440                        if ( yy_current_state >= 271 )
1441                                yy_c = yy_meta[(unsigned int) yy_c];
1442                        }
1443                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1444                }
1445
1446        return yy_current_state;
1447        }
1448
1449
1450/* yy_try_NUL_trans - try to make a transition on the NUL character
1451 *
1452 * synopsis
1453 *      next_state = yy_try_NUL_trans( current_state );
1454 */
1455
1456#ifdef YY_USE_PROTOS
1457static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1458#else
1459static yy_state_type yy_try_NUL_trans( yy_current_state )
1460yy_state_type yy_current_state;
1461#endif
1462        {
1463        register int yy_is_jam;
1464        register char *yy_cp = yy_c_buf_p;
1465
1466        register YY_CHAR yy_c = 1;
1467        if ( yy_accept[yy_current_state] )
1468                {
1469                yy_last_accepting_state = yy_current_state;
1470                yy_last_accepting_cpos = yy_cp;
1471                }
1472        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1473                {
1474                yy_current_state = (int) yy_def[yy_current_state];
1475                if ( yy_current_state >= 271 )
1476                        yy_c = yy_meta[(unsigned int) yy_c];
1477                }
1478        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1479        yy_is_jam = (yy_current_state == 270);
1480
1481        return yy_is_jam ? 0 : yy_current_state;
1482        }
1483
1484
1485#ifndef YY_NO_UNPUT
1486#ifdef YY_USE_PROTOS
1487static void yyunput( int c, register char *yy_bp )
1488#else
1489static void yyunput( c, yy_bp )
1490int c;
1491register char *yy_bp;
1492#endif
1493        {
1494        register char *yy_cp = yy_c_buf_p;
1495
1496        /* undo effects of setting up yytext */
1497        *yy_cp = yy_hold_char;
1498
1499        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1500                { /* need to shift things up to make room */
1501                /* +2 for EOB chars. */
1502                register int number_to_move = yy_n_chars + 2;
1503                register char *dest = &yy_current_buffer->yy_ch_buf[
1504                                        yy_current_buffer->yy_buf_size + 2];
1505                register char *source =
1506                                &yy_current_buffer->yy_ch_buf[number_to_move];
1507
1508                while ( source > yy_current_buffer->yy_ch_buf )
1509                        *--dest = *--source;
1510
1511                yy_cp += (int) (dest - source);
1512                yy_bp += (int) (dest - source);
1513                yy_current_buffer->yy_n_chars =
1514                        yy_n_chars = yy_current_buffer->yy_buf_size;
1515
1516                if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1517                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
1518                }
1519
1520        *--yy_cp = (char) c;
1521
1522
1523        yytext_ptr = yy_bp;
1524        yy_hold_char = *yy_cp;
1525        yy_c_buf_p = yy_cp;
1526        }
1527#endif  /* ifndef YY_NO_UNPUT */
1528
1529
1530#ifdef __cplusplus
1531static int yyinput()
1532#else
1533static int input()
1534#endif
1535        {
1536        int c;
1537
1538        *yy_c_buf_p = yy_hold_char;
1539
1540        if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1541                {
1542                /* yy_c_buf_p now points to the character we want to return.
1543                 * If this occurs *before* the EOB characters, then it's a
1544                 * valid NUL; if not, then we've hit the end of the buffer.
1545                 */
1546                if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1547                        /* This was really a NUL. */
1548                        *yy_c_buf_p = '\0';
1549
1550                else
1551                        { /* need more input */
1552                        int offset = yy_c_buf_p - yytext_ptr;
1553                        ++yy_c_buf_p;
1554
1555                        switch ( yy_get_next_buffer() )
1556                                {
1557                                case EOB_ACT_LAST_MATCH:
1558                                        /* This happens because yy_g_n_b()
1559                                         * sees that we've accumulated a
1560                                         * token and flags that we need to
1561                                         * try matching the token before
1562                                         * proceeding.  But for input(),
1563                                         * there's no matching to consider.
1564                                         * So convert the EOB_ACT_LAST_MATCH
1565                                         * to EOB_ACT_END_OF_FILE.
1566                                         */
1567
1568                                        /* Reset buffer status. */
1569                                        yyrestart( yyin );
1570
1571                                        /* fall through */
1572
1573                                case EOB_ACT_END_OF_FILE:
1574                                        {
1575                                        if ( yywrap() )
1576                                                return EOF;
1577
1578                                        if ( ! yy_did_buffer_switch_on_eof )
1579                                                YY_NEW_FILE;
1580#ifdef __cplusplus
1581                                        return yyinput();
1582#else
1583                                        return input();
1584#endif
1585                                        }
1586
1587                                case EOB_ACT_CONTINUE_SCAN:
1588                                        yy_c_buf_p = yytext_ptr + offset;
1589                                        break;
1590                                }
1591                        }
1592                }
1593
1594        c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1595        *yy_c_buf_p = '\0';     /* preserve yytext */
1596        yy_hold_char = *++yy_c_buf_p;
1597
1598
1599        return c;
1600        }
1601
1602
1603#ifdef YY_USE_PROTOS
1604void yyrestart( FILE *input_file )
1605#else
1606void yyrestart( input_file )
1607FILE *input_file;
1608#endif
1609        {
1610        if ( ! yy_current_buffer )
1611                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1612
1613        yy_init_buffer( yy_current_buffer, input_file );
1614        yy_load_buffer_state();
1615        }
1616
1617
1618#ifdef YY_USE_PROTOS
1619void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1620#else
1621void yy_switch_to_buffer( new_buffer )
1622YY_BUFFER_STATE new_buffer;
1623#endif
1624        {
1625        if ( yy_current_buffer == new_buffer )
1626                return;
1627
1628        if ( yy_current_buffer )
1629                {
1630                /* Flush out information for old buffer. */
1631                *yy_c_buf_p = yy_hold_char;
1632                yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1633                yy_current_buffer->yy_n_chars = yy_n_chars;
1634                }
1635
1636        yy_current_buffer = new_buffer;
1637        yy_load_buffer_state();
1638
1639        /* We don't actually know whether we did this switch during
1640         * EOF (yywrap()) processing, but the only time this flag
1641         * is looked at is after yywrap() is called, so it's safe
1642         * to go ahead and always set it.
1643         */
1644        yy_did_buffer_switch_on_eof = 1;
1645        }
1646
1647
1648#ifdef YY_USE_PROTOS
1649void yy_load_buffer_state( void )
1650#else
1651void yy_load_buffer_state()
1652#endif
1653        {
1654        yy_n_chars = yy_current_buffer->yy_n_chars;
1655        yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1656        yyin = yy_current_buffer->yy_input_file;
1657        yy_hold_char = *yy_c_buf_p;
1658        }
1659
1660
1661#ifdef YY_USE_PROTOS
1662YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1663#else
1664YY_BUFFER_STATE yy_create_buffer( file, size )
1665FILE *file;
1666int size;
1667#endif
1668        {
1669        YY_BUFFER_STATE b;
1670
1671        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1672        if ( ! b )
1673                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1674
1675        b->yy_buf_size = size;
1676
1677        /* yy_ch_buf has to be 2 characters longer than the size given because
1678         * we need to put in 2 end-of-buffer characters.
1679         */
1680        b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1681        if ( ! b->yy_ch_buf )
1682                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1683
1684        b->yy_is_our_buffer = 1;
1685
1686        yy_init_buffer( b, file );
1687
1688        return b;
1689        }
1690
1691
1692#ifdef YY_USE_PROTOS
1693void yy_delete_buffer( YY_BUFFER_STATE b )
1694#else
1695void yy_delete_buffer( b )
1696YY_BUFFER_STATE b;
1697#endif
1698        {
1699        if ( ! b )
1700                return;
1701
1702        if ( b == yy_current_buffer )
1703                yy_current_buffer = (YY_BUFFER_STATE) 0;
1704
1705        if ( b->yy_is_our_buffer )
1706                yy_flex_free( (void *) b->yy_ch_buf );
1707
1708        yy_flex_free( (void *) b );
1709        }
1710
1711
1712#ifndef _WIN32
1713#include <unistd.h>
1714#else
1715#ifndef YY_ALWAYS_INTERACTIVE
1716#ifndef YY_NEVER_INTERACTIVE
1717extern int isatty YY_PROTO(( int ));
1718#endif
1719#endif
1720#endif
1721
1722#ifdef YY_USE_PROTOS
1723void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1724#else
1725void yy_init_buffer( b, file )
1726YY_BUFFER_STATE b;
1727FILE *file;
1728#endif
1729
1730
1731        {
1732        yy_flush_buffer( b );
1733
1734        b->yy_input_file = file;
1735        b->yy_fill_buffer = 1;
1736
1737#if YY_ALWAYS_INTERACTIVE
1738        b->yy_is_interactive = 1;
1739#else
1740#if YY_NEVER_INTERACTIVE
1741        b->yy_is_interactive = 0;
1742#else
1743        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1744#endif
1745#endif
1746        }
1747
1748
1749#ifdef YY_USE_PROTOS
1750void yy_flush_buffer( YY_BUFFER_STATE b )
1751#else
1752void yy_flush_buffer( b )
1753YY_BUFFER_STATE b;
1754#endif
1755
1756        {
1757        if ( ! b )
1758                return;
1759
1760        b->yy_n_chars = 0;
1761
1762        /* We always need two end-of-buffer characters.  The first causes
1763         * a transition to the end-of-buffer state.  The second causes
1764         * a jam in that state.
1765         */
1766        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1767        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1768
1769        b->yy_buf_pos = &b->yy_ch_buf[0];
1770
1771        b->yy_at_bol = 1;
1772        b->yy_buffer_status = YY_BUFFER_NEW;
1773
1774        if ( b == yy_current_buffer )
1775                yy_load_buffer_state();
1776        }
1777
1778
1779#ifndef YY_NO_SCAN_BUFFER
1780#ifdef YY_USE_PROTOS
1781YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1782#else
1783YY_BUFFER_STATE yy_scan_buffer( base, size )
1784char *base;
1785yy_size_t size;
1786#endif
1787        {
1788        YY_BUFFER_STATE b;
1789
1790        if ( size < 2 ||
1791             base[size-2] != YY_END_OF_BUFFER_CHAR ||
1792             base[size-1] != YY_END_OF_BUFFER_CHAR )
1793                /* They forgot to leave room for the EOB's. */
1794                return 0;
1795
1796        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1797        if ( ! b )
1798                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1799
1800        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1801        b->yy_buf_pos = b->yy_ch_buf = base;
1802        b->yy_is_our_buffer = 0;
1803        b->yy_input_file = 0;
1804        b->yy_n_chars = b->yy_buf_size;
1805        b->yy_is_interactive = 0;
1806        b->yy_at_bol = 1;
1807        b->yy_fill_buffer = 0;
1808        b->yy_buffer_status = YY_BUFFER_NEW;
1809
1810        yy_switch_to_buffer( b );
1811
1812        return b;
1813        }
1814#endif
1815
1816
1817#ifndef YY_NO_SCAN_STRING
1818#ifdef YY_USE_PROTOS
1819YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1820#else
1821YY_BUFFER_STATE yy_scan_string( yy_str )
1822yyconst char *yy_str;
1823#endif
1824        {
1825        int len;
1826        for ( len = 0; yy_str[len]; ++len )
1827                ;
1828
1829        return yy_scan_bytes( yy_str, len );
1830        }
1831#endif
1832
1833
1834#ifndef YY_NO_SCAN_BYTES
1835#ifdef YY_USE_PROTOS
1836YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1837#else
1838YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1839yyconst char *bytes;
1840int len;
1841#endif
1842        {
1843        YY_BUFFER_STATE b;
1844        char *buf;
1845        yy_size_t n;
1846        int i;
1847
1848        /* Get memory for full buffer, including space for trailing EOB's. */
1849        n = len + 2;
1850        buf = (char *) yy_flex_alloc( n );
1851        if ( ! buf )
1852                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1853
1854        for ( i = 0; i < len; ++i )
1855                buf[i] = bytes[i];
1856
1857        buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1858
1859        b = yy_scan_buffer( buf, n );
1860        if ( ! b )
1861                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1862
1863        /* It's okay to grow etc. this buffer, and we should throw it
1864         * away when we're done.
1865         */
1866        b->yy_is_our_buffer = 1;
1867
1868        return b;
1869        }
1870#endif
1871
1872
1873#ifndef YY_NO_PUSH_STATE
1874#ifdef YY_USE_PROTOS
1875static void yy_push_state( int new_state )
1876#else
1877static void yy_push_state( new_state )
1878int new_state;
1879#endif
1880        {
1881        if ( yy_start_stack_ptr >= yy_start_stack_depth )
1882                {
1883                yy_size_t new_size;
1884
1885                yy_start_stack_depth += YY_START_STACK_INCR;
1886                new_size = yy_start_stack_depth * sizeof( int );
1887
1888                if ( ! yy_start_stack )
1889                        yy_start_stack = (int *) yy_flex_alloc( new_size );
1890
1891                else
1892                        yy_start_stack = (int *) yy_flex_realloc(
1893                                        (void *) yy_start_stack, new_size );
1894
1895                if ( ! yy_start_stack )
1896                        YY_FATAL_ERROR(
1897                        "out of memory expanding start-condition stack" );
1898                }
1899
1900        yy_start_stack[yy_start_stack_ptr++] = YY_START;
1901
1902        BEGIN(new_state);
1903        }
1904#endif
1905
1906
1907#ifndef YY_NO_POP_STATE
1908static void yy_pop_state()
1909        {
1910        if ( --yy_start_stack_ptr < 0 )
1911                YY_FATAL_ERROR( "start-condition stack underflow" );
1912
1913        BEGIN(yy_start_stack[yy_start_stack_ptr]);
1914        }
1915#endif
1916
1917
1918#ifndef YY_NO_TOP_STATE
1919static int yy_top_state()
1920        {
1921        return yy_start_stack[yy_start_stack_ptr - 1];
1922        }
1923#endif
1924
1925#ifndef YY_EXIT_FAILURE
1926#define YY_EXIT_FAILURE 2
1927#endif
1928
1929#ifdef YY_USE_PROTOS
1930static void yy_fatal_error( yyconst char msg[] )
1931#else
1932static void yy_fatal_error( msg )
1933char msg[];
1934#endif
1935        {
1936        (void) fprintf( stderr, "%s\n", msg );
1937        exit( YY_EXIT_FAILURE );
1938        }
1939
1940
1941
1942/* Redefine yyless() so it works in section 3 code. */
1943
1944#undef yyless
1945#define yyless(n) \
1946        do \
1947                { \
1948                /* Undo effects of setting up yytext. */ \
1949                yytext[yyleng] = yy_hold_char; \
1950                yy_c_buf_p = yytext + n; \
1951                yy_hold_char = *yy_c_buf_p; \
1952                *yy_c_buf_p = '\0'; \
1953                yyleng = n; \
1954                } \
1955        while ( 0 )
1956
1957
1958/* Internal utility routines. */
1959
1960#ifndef yytext_ptr
1961#ifdef YY_USE_PROTOS
1962static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1963#else
1964static void yy_flex_strncpy( s1, s2, n )
1965char *s1;
1966yyconst char *s2;
1967int n;
1968#endif
1969        {
1970        register int i;
1971        for ( i = 0; i < n; ++i )
1972                s1[i] = s2[i];
1973        }
1974#endif
1975
1976#ifdef YY_NEED_STRLEN
1977#ifdef YY_USE_PROTOS
1978static int yy_flex_strlen( yyconst char *s )
1979#else
1980static int yy_flex_strlen( s )
1981yyconst char *s;
1982#endif
1983        {
1984        register int n;
1985        for ( n = 0; s[n]; ++n )
1986                ;
1987
1988        return n;
1989        }
1990#endif
1991
1992
1993#ifdef YY_USE_PROTOS
1994static void *yy_flex_alloc( yy_size_t size )
1995#else
1996static void *yy_flex_alloc( size )
1997yy_size_t size;
1998#endif
1999        {
2000        return (void *) malloc( size );
2001        }
2002
2003#ifdef YY_USE_PROTOS
2004static void *yy_flex_realloc( void *ptr, yy_size_t size )
2005#else
2006static void *yy_flex_realloc( ptr, size )
2007void *ptr;
2008yy_size_t size;
2009#endif
2010        {
2011        /* The cast to (char *) in the following accommodates both
2012         * implementations that use char* generic pointers, and those
2013         * that use void* generic pointers.  It works with the latter
2014         * because both ANSI C and C++ allow castless assignment from
2015         * any pointer type to void*, and deal with argument conversions
2016         * as though doing an assignment.
2017         */
2018        return (void *) realloc( (char *) ptr, size );
2019        }
2020
2021#ifdef YY_USE_PROTOS
2022static void yy_flex_free( void *ptr )
2023#else
2024static void yy_flex_free( ptr )
2025void *ptr;
2026#endif
2027        {
2028        free( ptr );
2029        }
2030
2031#if YY_MAIN
2032int main()
2033        {
2034        yylex();
2035        return 0;
2036        }
2037#endif
2038#line 90 "dagopts.l"
2039
2040
2041/*
2042 * Also define a yywrap.  Note that if we're using flex, it will
2043 * define a macro to map this identifier to dagoptwrap.
2044 */
2045int
2046yywrap()
2047{
2048        return 1;
2049}
Note: See TracBrowser for help on using the repository browser.