Context Navigation

source: lib/dagopts.c @ 24b42dd

4.0.1-hotfixescachetimestampsdevelopdpdk-ndagetsilivegetfragoffhelplibtrace4ndag_formatpfringrc-4.0.1rc-4.0.2rc-4.0.3rc-4.0.4ringdecrementfixringperformanceringtimestampfixes

Last change on this file since 24b42dd was b36a3b7, checked in by Daniel Lawson <dlawson@…>, 18 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
48	extern 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
125	typedef struct yy_buffer_state *YY_BUFFER_STATE;
126
127	extern int yyleng;
128	extern 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	*/
167	typedef unsigned int yy_size_t;
168
169
170	struct 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
227	static 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. */
237	static char yy_hold_char;
238
239	static int yy_n_chars; /* number of characters read into yy_ch_buf */
240
241
242	int yyleng;
243
244	/* Points to current character in buffer. */
245	static char yy_c_buf_p = (char ) 0;
246	static int yy_init = 1; /* whether we need to initialize */
247	static 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	*/
252	static int yy_did_buffer_switch_on_eof;
253
254	void yyrestart YY_PROTO(( FILE *input_file ));
255
256	void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
257	void yy_load_buffer_state YY_PROTO(( void ));
258	YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
259	void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
260	void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
261	void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
262	#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
263
264	YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
265	YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
266	YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
267
268	static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
269	static void yy_flex_realloc YY_PROTO(( void , yy_size_t ));
270	static 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
290	typedef unsigned char YY_CHAR;
291	FILE yyin = (FILE ) 0, yyout = (FILE ) 0;
292	typedef int yy_state_type;
293	extern char *yytext;
294	#define yytext_ptr yytext
295
296	static yy_state_type yy_get_previous_state YY_PROTO(( void ));
297	static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
298	static int yy_get_next_buffer YY_PROTO(( void ));
299	static 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
313	static 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
343	static 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
375	static 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
383	static 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
413	static 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
443	static 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
485	static 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
527	static yy_state_type yy_last_accepting_state;
528	static 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
537	char *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
557	int 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
566	extern "C" int yywrap YY_PROTO(( void ));
567	#else
568	extern int yywrap YY_PROTO(( void ));
569	#endif
570	#endif
571
572	#ifndef YY_NO_UNPUT
573	static void yyunput YY_PROTO(( int c, char *buf_ptr ));
574	#endif
575
576	#ifndef yytext_ptr
577	static void yy_flex_strncpy YY_PROTO(( char , yyconst char , int ));
578	#endif
579
580	#ifdef YY_NEED_STRLEN
581	static int yy_flex_strlen YY_PROTO(( yyconst char * ));
582	#endif
583
584	#ifndef YY_NO_INPUT
585	#ifdef __cplusplus
586	static int yyinput YY_PROTO(( void ));
587	#else
588	static int input YY_PROTO(( void ));
589	#endif
590	#endif
591
592	#if YY_STACK_USED
593	static int yy_start_stack_ptr = 0;
594	static int yy_start_stack_depth = 0;
595	static int *yy_start_stack = 0;
596	#ifndef YY_NO_PUSH_STATE
597	static void yy_push_state YY_PROTO(( int new_state ));
598	#endif
599	#ifndef YY_NO_POP_STATE
600	static void yy_pop_state YY_PROTO(( void ));
601	#endif
602	#ifndef YY_NO_TOP_STATE
603	static 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
613	YY_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
714	YY_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;
763	yy_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
783	yy_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
795	do_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
807	case 1:
808	YY_RULE_SETUP
809	#line 26 "dagopts.l"
810	{ return T_DEFAULT; }
811	YY_BREAK
812	case 2:
813	YY_RULE_SETUP
814	#line 27 "dagopts.l"
815	{ return T_ATM; }
816	YY_BREAK
817	case 3:
818	YY_RULE_SETUP
819	#line 28 "dagopts.l"
820	{ return T_POS; }
821	YY_BREAK
822	case 4:
823	YY_RULE_SETUP
824	#line 29 "dagopts.l"
825	{ return T_RAW; }
826	YY_BREAK
827	case 5:
828	YY_RULE_SETUP
829	#line 30 "dagopts.l"
830	{ return T_LINK_OC1; }
831	YY_BREAK
832	case 6:
833	YY_RULE_SETUP
834	#line 31 "dagopts.l"
835	{ return T_LINK_OC3; }
836	YY_BREAK
837	case 7:
838	YY_RULE_SETUP
839	#line 32 "dagopts.l"
840	{ return T_LINK_OC12; }
841	YY_BREAK
842	case 8:
843	YY_RULE_SETUP
844	#line 33 "dagopts.l"
845	{ return T_LINK_OC48; }
846	YY_BREAK
847	case 9:
848	YY_RULE_SETUP
849	#line 34 "dagopts.l"
850	{ return T_LINK_OC192; }
851	YY_BREAK
852	case 10:
853	YY_RULE_SETUP
854	#line 35 "dagopts.l"
855	{ return T_POS_CRC16; }
856	YY_BREAK
857	case 11:
858	YY_RULE_SETUP
859	#line 36 "dagopts.l"
860	{ return T_POS_CRC32; }
861	YY_BREAK
862	case 12:
863	YY_RULE_SETUP
864	#line 37 "dagopts.l"
865	{ return T_ETH; }
866	YY_BREAK
867	case 13:
868	YY_RULE_SETUP
869	#line 38 "dagopts.l"
870	{ return T_ETH_10; }
871	YY_BREAK
872	case 14:
873	YY_RULE_SETUP
874	#line 39 "dagopts.l"
875	{ return T_ETH_100; }
876	YY_BREAK
877	case 15:
878	YY_RULE_SETUP
879	#line 40 "dagopts.l"
880	{ return T_ETH_AUTO; }
881	YY_BREAK
882	case 16:
883	YY_RULE_SETUP
884	#line 41 "dagopts.l"
885	{ return (yytext[0]!='n') ? T_SONET_MASTER : T_SONET_SLAVE; }
886	YY_BREAK
887	case 17:
888	YY_RULE_SETUP
889	#line 42 "dagopts.l"
890	{ return (yytext[0]!='n') ? T_SONET_SLAVE : T_SONET_MASTER; }
891	YY_BREAK
892	case 18:
893	YY_RULE_SETUP
894	#line 43 "dagopts.l"
895	{ yylval = (yytext[0]!='n') ; return T_SONET_SCRAMBLE; }
896	YY_BREAK
897	case 19:
898	YY_RULE_SETUP
899	#line 44 "dagopts.l"
900	{ yylval = (yytext[0]!='n') ; return T_ATM_ADD_HEC; }
901	YY_BREAK
902	case 20:
903	YY_RULE_SETUP
904	#line 45 "dagopts.l"
905	{ yylval = (yytext[0]!='n') ; return T_ATM_FIX_HEC; }
906	YY_BREAK
907	case 21:
908	YY_RULE_SETUP
909	#line 46 "dagopts.l"
910	{ yylval = (yytext[0]!='n') ; return T_ATM_PASS_HEC; }
911	YY_BREAK
912	case 22:
913	YY_RULE_SETUP
914	#line 47 "dagopts.l"
915	{ yylval = (yytext[0]!='n') ; return T_ATM_PASS_IDLE; }
916	YY_BREAK
917	case 23:
918	YY_RULE_SETUP
919	#line 48 "dagopts.l"
920	{ yylval = (yytext[0]!='n') ; return T_ATM_LCELL; }
921	YY_BREAK
922	case 24:
923	YY_RULE_SETUP
924	#line 49 "dagopts.l"
925	{ yylval = (yytext[0]!='n') ; return T_ATM_PLOAD_SCRAMBLE; }
926	YY_BREAK
927	case 25:
928	YY_RULE_SETUP
929	#line 50 "dagopts.l"
930	{ yylval = (yytext[1]!='o') ; return T_ETH_NIC; }
931	YY_BREAK
932	case 26:
933	YY_RULE_SETUP
934	#line 51 "dagopts.l"
935	{ yylval = (yytext[0]!='n') ; return T_GPP_VARLEN; }
936	YY_BREAK
937	case 27:
938	YY_RULE_SETUP
939	#line 52 "dagopts.l"
940	{ yylval = 0 ; return T_GPP_VARLEN; }
941	YY_BREAK
942	case 28:
943	YY_RULE_SETUP
944	#line 53 "dagopts.l"
945	{ yylval = (yytext[0]!='n') ; return T_LINK_ADM; }
946	YY_BREAK
947	case 29:
948	YY_RULE_SETUP
949	#line 54 "dagopts.l"
950	{ yylval = (yytext[0]!='n') ; return T_LINK_CRC; }
951	YY_BREAK
952	case 30:
953	YY_RULE_SETUP
954	#line 55 "dagopts.l"
955	{ yylval = (yytext[0]!='n') ; return T_LINK_DCR; }
956	YY_BREAK
957	case 31:
958	YY_RULE_SETUP
959	#line 56 "dagopts.l"
960	{ yylval = (yytext[0]!='n') ; return T_LINK_DISCARD; }
961	YY_BREAK
962	case 32:
963	YY_RULE_SETUP
964	#line 57 "dagopts.l"
965	{ yylval = (yytext[0]!='n') ; return T_LINK_EQL; }
966	YY_BREAK
967	case 33:
968	YY_RULE_SETUP
969	#line 58 "dagopts.l"
970	{ yylval = (yytext[0]!='n') ; return T_LINK_FCL; }
971	YY_BREAK
972	case 34:
973	YY_RULE_SETUP
974	#line 59 "dagopts.l"
975	{ yylval = (yytext[0]!='n') ; return T_LINK_HGAIN; }
976	YY_BREAK
977	case 35:
978	YY_RULE_SETUP
979	#line 60 "dagopts.l"
980	{ yylval = (yytext[0]!='n') ; return T_LINK_LASER; }
981	YY_BREAK
982	case 36:
983	YY_RULE_SETUP
984	#line 61 "dagopts.l"
985	{ yylval = (yytext[0]!='n') ; return T_LINK_LT0; }
986	YY_BREAK
987	case 37:
988	YY_RULE_SETUP
989	#line 62 "dagopts.l"
990	{ yylval = (yytext[0]!='n') ; return T_LINK_LT1; }
991	YY_BREAK
992	case 38:
993	YY_RULE_SETUP
994	#line 63 "dagopts.l"
995	{ yylval = (yytext[0]!='n') ; return T_LINK_M23; }
996	YY_BREAK
997	case 39:
998	YY_RULE_SETUP
999	#line 64 "dagopts.l"
1000	{ yylval = (yytext[0]!='n') ; return T_LINK_RESET; }
1001	YY_BREAK
1002	case 40:
1003	#line 66 "dagopts.l"
1004	case 41:
1005	YY_RULE_SETUP
1006	#line 66 "dagopts.l"
1007	{ yylval = (yytext[0]!='n') ; return T_LINK_LSEQL; }
1008	YY_BREAK
1009	case 42:
1010	#line 68 "dagopts.l"
1011	case 43:
1012	YY_RULE_SETUP
1013	#line 68 "dagopts.l"
1014	{ yylval = (yytext[0]!='n') ; return T_LINK_LSFCL; }
1015	YY_BREAK
1016	case 44:
1017	YY_RULE_SETUP
1018	#line 69 "dagopts.l"
1019	{ yylval = (yytext[0]!='n') ; return T_POS_MAXCHECK; }
1020	YY_BREAK
1021	case 45:
1022	YY_RULE_SETUP
1023	#line 70 "dagopts.l"
1024	{ yylval = (yytext[0]!='n') ; return T_POS_MINCHECK; }
1025	YY_BREAK
1026	case 46:
1027	YY_RULE_SETUP
1028	#line 71 "dagopts.l"
1029	{ yylval = (yytext[0]!='n') ; return T_POS_RXPKTS; }
1030	YY_BREAK
1031	case 47:
1032	YY_RULE_SETUP
1033	#line 72 "dagopts.l"
1034	{ yylval = (yytext[0]!='n') ; return T_POS_SCRAMBLE; }
1035	YY_BREAK
1036	case 48:
1037	YY_RULE_SETUP
1038	#line 73 "dagopts.l"
1039	{ yylval = (yytext[0]!='n') ; return T_POS_TXPKTS; }
1040	YY_BREAK
1041	case 49:
1042	YY_RULE_SETUP
1043	#line 74 "dagopts.l"
1044	{ yylval = strtoul(&yytext[5], NULL, 0) ; return T_GPP_SLEN; }
1045	YY_BREAK
1046	case 50:
1047	YY_RULE_SETUP
1048	#line 75 "dagopts.l"
1049	{ yylval = strtoul(&yytext[7], NULL, 0) ; return T_ATM_NCELLS; }
1050	YY_BREAK
1051	case 51:
1052	YY_RULE_SETUP
1053	#line 76 "dagopts.l"
1054	{ yylval = (yytext[0]!='d') ; return T_GPP_ENABLE_A; }
1055	YY_BREAK
1056	case 52:
1057	YY_RULE_SETUP
1058	#line 77 "dagopts.l"
1059	{ yylval = (yytext[0]!='d') ; return T_GPP_ENABLE_B; }
1060	YY_BREAK
1061	case 53:
1062	YY_RULE_SETUP
1063	#line 78 "dagopts.l"
1064
1065	YY_BREAK
1066	case 54:
1067	YY_RULE_SETUP
1068	#line 79 "dagopts.l"
1069
1070	YY_BREAK
1071	case 55:
1072	YY_RULE_SETUP
1073	#line 80 "dagopts.l"
1074	{ return T_ERROR; }
1075	YY_BREAK
1076	case 56:
1077	YY_RULE_SETUP
1078	#line 81 "dagopts.l"
1079
1080	YY_BREAK
1081	case 57:
1082	YY_RULE_SETUP
1083	#line 82 "dagopts.l"
1084	ECHO;
1085	YY_BREAK
1086	case 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
1227	static 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
1359	static 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
1394	static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1395	#else
1396	static yy_state_type yy_try_NUL_trans( yy_current_state )
1397	yy_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
1424	static void yyunput( int c, register char *yy_bp )
1425	#else
1426	static void yyunput( c, yy_bp )
1427	int c;
1428	register 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
1468	static int yyinput()
1469	#else
1470	static 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
1541	void yyrestart( FILE *input_file )
1542	#else
1543	void yyrestart( input_file )
1544	FILE *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
1556	void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1557	#else
1558	void yy_switch_to_buffer( new_buffer )
1559	YY_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
1586	void yy_load_buffer_state( void )
1587	#else
1588	void 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
1599	YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1600	#else
1601	YY_BUFFER_STATE yy_create_buffer( file, size )
1602	FILE *file;
1603	int 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
1630	void yy_delete_buffer( YY_BUFFER_STATE b )
1631	#else
1632	void yy_delete_buffer( b )
1633	YY_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
1654	extern int isatty YY_PROTO(( int ));
1655	#endif
1656	#endif
1657	#endif
1658
1659	#ifdef YY_USE_PROTOS
1660	void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1661	#else
1662	void yy_init_buffer( b, file )
1663	YY_BUFFER_STATE b;
1664	FILE *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
1687	void yy_flush_buffer( YY_BUFFER_STATE b )
1688	#else
1689	void yy_flush_buffer( b )
1690	YY_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
1718	YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1719	#else
1720	YY_BUFFER_STATE yy_scan_buffer( base, size )
1721	char *base;
1722	yy_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
1756	YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1757	#else
1758	YY_BUFFER_STATE yy_scan_string( yy_str )
1759	yyconst 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
1773	YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1774	#else
1775	YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1776	yyconst char *bytes;
1777	int 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
1812	static void yy_push_state( int new_state )
1813	#else
1814	static void yy_push_state( new_state )
1815	int 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
1845	static 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
1856	static 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
1867	static void yy_fatal_error( yyconst char msg[] )
1868	#else
1869	static void yy_fatal_error( msg )
1870	char 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
1899	static void yy_flex_strncpy( char s1, yyconst char s2, int n )
1900	#else
1901	static void yy_flex_strncpy( s1, s2, n )
1902	char *s1;
1903	yyconst char *s2;
1904	int 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
1915	static int yy_flex_strlen( yyconst char *s )
1916	#else
1917	static int yy_flex_strlen( s )
1918	yyconst 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
1931	static void *yy_flex_alloc( yy_size_t size )
1932	#else
1933	static void *yy_flex_alloc( size )
1934	yy_size_t size;
1935	#endif
1936	{
1937	return (void *) malloc( size );
1938	}
1939
1940	#ifdef YY_USE_PROTOS
1941	static void yy_flex_realloc( void ptr, yy_size_t size )
1942	#else
1943	static void *yy_flex_realloc( ptr, size )
1944	void *ptr;
1945	yy_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
1959	static void yy_flex_free( void *ptr )
1960	#else
1961	static void yy_flex_free( ptr )
1962	void *ptr;
1963	#endif
1964	{
1965	free( ptr );
1966	}
1967
1968	#if YY_MAIN
1969	int 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	*/
1982	int
1983	yywrap()
1984	{
1985	return 1;
1986	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: