source: lib/dagopts.c @ b36a3b7

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

poink

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