1/* File created from flex.skl via mkskel.sh */
2
3#include "flexdef.h"
4
5const char *skel[] = {
6  "/* A lexical scanner generated by flex */",
7  "",
8  "/* Scanner skeleton version:",
9  " * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $",
10  " */",
11  "",
12  "#define FLEX_SCANNER",
13  "#define YY_FLEX_MAJOR_VERSION 2",
14  "#define YY_FLEX_MINOR_VERSION 5",
15  "",
16  "%-",
17  "#include <stdio.h>",
18  "%*",
19  "",
20  "",
21  "/* cfront 1.2 defines \"c_plusplus\" instead of \"__cplusplus\" */",
22  "#ifdef c_plusplus",
23  "#ifndef __cplusplus",
24  "#define __cplusplus",
25  "#endif",
26  "#endif",
27  "",
28  "",
29  "#ifdef __cplusplus",
30  "",
31  "#include <stdlib.h>",
32  "%+",
33  "class istream;",
34  "%*",
35  "#include <unistd.h>",
36  "",
37  "/* Use prototypes in function declarations. */",
38  "#define YY_USE_PROTOS",
39  "",
40  "/* The \"const\" storage-class-modifier is valid. */",
41  "#define YY_USE_CONST",
42  "",
43  "#else	/* ! __cplusplus */",
44  "",
45  "#if __STDC__",
46  "",
47  "#define YY_USE_PROTOS",
48  "#define YY_USE_CONST",
49  "",
50  "#endif	/* __STDC__ */",
51  "#endif	/* ! __cplusplus */",
52  "",
53  "#ifdef __TURBOC__",
54  " #pragma warn -rch",
55  " #pragma warn -use",
56  "#include <io.h>",
57  "#include <stdlib.h>",
58  "#define YY_USE_CONST",
59  "#define YY_USE_PROTOS",
60  "#endif",
61  "",
62  "#ifdef YY_USE_CONST",
63  "#define yyconst const",
64  "#else",
65  "#define yyconst",
66  "#endif",
67  "",
68  "",
69  "#ifdef YY_USE_PROTOS",
70  "#define YY_PROTO(proto) proto",
71  "#else",
72  "#define YY_PROTO(proto) ()",
73  "#endif",
74  "",
75  "/* Returned upon end-of-file. */",
76  "#define YY_NULL 0",
77  "",
78  "/* Promotes a possibly negative, possibly signed char to an unsigned",
79  " * integer for use as an array index.  If the signed char is negative,",
80  " * we want to instead treat it as an 8-bit unsigned char, hence the",
81  " * double cast.",
82  " */",
83  "#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)",
84  "",
85  "/* Enter a start condition.  This macro really ought to take a parameter,",
86  " * but we do it the disgusting crufty way forced on us by the ()-less",
87  " * definition of BEGIN.",
88  " */",
89  "#define BEGIN yy_start = 1 + 2 *",
90  "",
91  "/* Translate the current start state into a value that can be later handed",
92  " * to BEGIN to return to the state.  The YYSTATE alias is for lex",
93  " * compatibility.",
94  " */",
95  "#define YY_START ((yy_start - 1) / 2)",
96  "#define YYSTATE YY_START",
97  "",
98  "/* Action number for EOF rule of a given start state. */",
99  "#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)",
100  "",
101  "/* Special action meaning \"start processing a new file\". */",
102  "#define YY_NEW_FILE yyrestart( yyin )",
103  "",
104  "#define YY_END_OF_BUFFER_CHAR 0",
105  "",
106  "/* Size of default input buffer. */",
107  "#define YY_BUF_SIZE 16384",
108  "",
109  "typedef struct yy_buffer_state *YY_BUFFER_STATE;",
110  "",
111  "extern int yyleng;",
112  "%-",
113  "extern FILE *yyin, *yyout;",
114  "%*",
115  "",
116  "#define EOB_ACT_CONTINUE_SCAN 0",
117  "#define EOB_ACT_END_OF_FILE 1",
118  "#define EOB_ACT_LAST_MATCH 2",
119  "",
120  "/* The funky do-while in the following #define is used to turn the definition",
121  " * int a single C statement (which needs a semi-colon terminator).  This",
122  " * avoids problems with code like:",
123  " *",
124  " * 	if ( condition_holds )",
125  " *		yyless( 5 );",
126  " *	else",
127  " *		do_something_else();",
128  " *",
129  " * Prior to using the do-while the compiler would get upset at the",
130  " * \"else\" because it interpreted the \"if\" statement as being all",
131  " * done when it reached the ';' after the yyless() call.",
132  " */",
133  "",
134  "/* Return all but the first 'n' matched characters back to the input stream. */",
135  "",
136  "#define yyless(n) \\",
137  "	do \\",
138  "		{ \\",
139  "		/* Undo effects of setting up yytext. */ \\",
140  "		*yy_cp = yy_hold_char; \\",
141  "		YY_RESTORE_YY_MORE_OFFSET \\",
142  "		yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \\",
143  "		YY_DO_BEFORE_ACTION; /* set up yytext again */ \\",
144  "		} \\",
145  "	while ( 0 )",
146  "",
147  "#define unput(c) yyunput( c, yytext_ptr )",
148  "",
149  "/* The following is because we cannot portably get our hands on size_t",
150  " * (without autoconf's help, which isn't available because we want",
151  " * flex-generated scanners to compile on their own).",
152  " */",
153  "typedef unsigned int yy_size_t;",
154  "",
155  "",
156  "struct yy_buffer_state",
157  "	{",
158  "%-",
159  "	FILE *yy_input_file;",
160  "%+",
161  "	istream* yy_input_file;",
162  "%*",
163  "",
164  "	char *yy_ch_buf;		/* input buffer */",
165  "	char *yy_buf_pos;		/* current position in input buffer */",
166  "",
167  "	/* Size of input buffer in bytes, not including room for EOB",
168  "	 * characters.",
169  "	 */",
170  "	yy_size_t yy_buf_size;",
171  "",
172  "	/* Number of characters read into yy_ch_buf, not including EOB",
173  "	 * characters.",
174  "	 */",
175  "	int yy_n_chars;",
176  "",
177  "	/* Whether we \"own\" the buffer - i.e., we know we created it,",
178  "	 * and can realloc() it to grow it, and should free() it to",
179  "	 * delete it.",
180  "	 */",
181  "	int yy_is_our_buffer;",
182  "",
183  "	/* Whether this is an \"interactive\" input source; if so, and",
184  "	 * if we're using stdio for input, then we want to use getc()",
185  "	 * instead of fread(), to make sure we stop fetching input after",
186  "	 * each newline.",
187  "	 */",
188  "	int yy_is_interactive;",
189  "",
190  "	/* Whether we're considered to be at the beginning of a line.",
191  "	 * If so, '^' rules will be active on the next match, otherwise",
192  "	 * not.",
193  "	 */",
194  "	int yy_at_bol;",
195  "",
196  "	/* Whether to try to fill the input buffer when we reach the",
197  "	 * end of it.",
198  "	 */",
199  "	int yy_fill_buffer;",
200  "",
201  "	int yy_buffer_status;",
202  "#define YY_BUFFER_NEW 0",
203  "#define YY_BUFFER_NORMAL 1",
204  "	/* When an EOF's been seen but there's still some text to process",
205  "	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we",
206  "	 * shouldn't try reading from the input source any more.  We might",
207  "	 * still have a bunch of tokens to match, though, because of",
208  "	 * possible backing-up.",
209  "	 *",
210  "	 * When we actually see the EOF, we change the status to \"new\"",
211  "	 * (via yyrestart()), so that the user can continue scanning by",
212  "	 * just pointing yyin at a new input file.",
213  "	 */",
214  "#define YY_BUFFER_EOF_PENDING 2",
215  "	};",
216  "",
217  "%- Standard (non-C++) definition",
218  "static YY_BUFFER_STATE yy_current_buffer = 0;",
219  "%*",
220  "",
221  "/* We provide macros for accessing buffer states in case in the",
222  " * future we want to put the buffer states in a more general",
223  " * \"scanner state\".",
224  " */",
225  "#define YY_CURRENT_BUFFER yy_current_buffer",
226  "",
227  "",
228  "%- Standard (non-C++) definition",
229  "/* yy_hold_char holds the character lost when yytext is formed. */",
230  "static char yy_hold_char;",
231  "",
232  "static int yy_n_chars;		/* number of characters read into yy_ch_buf */",
233  "",
234  "",
235  "int yyleng;",
236  "",
237  "/* Points to current character in buffer. */",
238  "static char *yy_c_buf_p = (char *) 0;",
239  "static int yy_init = 1;		/* whether we need to initialize */",
240  "static int yy_start = 0;	/* start state number */",
241  "",
242  "/* Flag which is used to allow yywrap()'s to do buffer switches",
243  " * instead of setting up a fresh yyin.  A bit of a hack ...",
244  " */",
245  "static int yy_did_buffer_switch_on_eof;",
246  "",
247  "void yyrestart YY_PROTO(( FILE *input_file ));",
248  "",
249  "void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));",
250  "void yy_load_buffer_state YY_PROTO(( void ));",
251  "YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));",
252  "void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));",
253  "void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));",
254  "void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));",
255  "#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )",
256  "",
257  "YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));",
258  "YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));",
259  "YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));",
260  "%*",
261  "",
262  "static void *yy_flex_alloc YY_PROTO(( yy_size_t ));",
263  "static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));",
264  "static void yy_flex_free YY_PROTO(( void * ));",
265  "",
266  "#define yy_new_buffer yy_create_buffer",
267  "",
268  "#define yy_set_interactive(is_interactive) \\",
269  "	{ \\",
270  "	if ( ! yy_current_buffer ) \\",
271  "		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \\",
272  "	yy_current_buffer->yy_is_interactive = is_interactive; \\",
273  "	}",
274  "",
275  "#define yy_set_bol(at_bol) \\",
276  "	{ \\",
277  "	if ( ! yy_current_buffer ) \\",
278  "		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \\",
279  "	yy_current_buffer->yy_at_bol = at_bol; \\",
280  "	}",
281  "",
282  "#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)",
283  "",
284  "%% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here",
285  "",
286  "%- Standard (non-C++) definition",
287  "static yy_state_type yy_get_previous_state YY_PROTO(( void ));",
288  "static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));",
289  "static int yy_get_next_buffer YY_PROTO(( void ));",
290  "static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));",
291  "%*",
292  "",
293  "/* Done after the current pattern has been matched and before the",
294  " * corresponding action - sets up yytext.",
295  " */",
296  "#define YY_DO_BEFORE_ACTION \\",
297  "	yytext_ptr = yy_bp; \\",
298  "%% code to fiddle yytext and yyleng for yymore() goes here",
299  "	yy_hold_char = *yy_cp; \\",
300  "	*yy_cp = '\\0'; \\",
301  "%% code to copy yytext_ptr to yytext[] goes here, if %array",
302  "	yy_c_buf_p = yy_cp;",
303  "",
304  "%% data tables for the DFA and the user's section 1 definitions go here",
305  "",
306  "/* Macros after this point can all be overridden by user definitions in",
307  " * section 1.",
308  " */",
309  "",
310  "#ifndef YY_SKIP_YYWRAP",
311  "#ifdef __cplusplus",
312  "extern \"C\" int yywrap YY_PROTO(( void ));",
313  "#else",
314  "extern int yywrap YY_PROTO(( void ));",
315  "#endif",
316  "#endif",
317  "",
318  "%-",
319  "#ifndef YY_NO_UNPUT",
320  "static void yyunput YY_PROTO(( int c, char *buf_ptr ));",
321  "#endif",
322  "%*",
323  "",
324  "#ifndef yytext_ptr",
325  "static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));",
326  "#endif",
327  "",
328  "#ifdef YY_NEED_STRLEN",
329  "static int yy_flex_strlen YY_PROTO(( yyconst char * ));",
330  "#endif",
331  "",
332  "#ifndef YY_NO_INPUT",
333  "%- Standard (non-C++) definition",
334  "#ifdef __cplusplus",
335  "static int yyinput YY_PROTO(( void ));",
336  "#else",
337  "static int input YY_PROTO(( void ));",
338  "#endif",
339  "%*",
340  "#endif",
341  "",
342  "#if YY_STACK_USED",
343  "static int yy_start_stack_ptr = 0;",
344  "static int yy_start_stack_depth = 0;",
345  "static int *yy_start_stack = 0;",
346  "#ifndef YY_NO_PUSH_STATE",
347  "static void yy_push_state YY_PROTO(( int new_state ));",
348  "#endif",
349  "#ifndef YY_NO_POP_STATE",
350  "static void yy_pop_state YY_PROTO(( void ));",
351  "#endif",
352  "#ifndef YY_NO_TOP_STATE",
353  "static int yy_top_state YY_PROTO(( void ));",
354  "#endif",
355  "",
356  "#else",
357  "#define YY_NO_PUSH_STATE 1",
358  "#define YY_NO_POP_STATE 1",
359  "#define YY_NO_TOP_STATE 1",
360  "#endif",
361  "",
362  "#ifdef YY_MALLOC_DECL",
363  "YY_MALLOC_DECL",
364  "#else",
365  "#if __STDC__",
366  "#ifndef __cplusplus",
367  "#include <stdlib.h>",
368  "#endif",
369  "#else",
370  "/* Just try to get by without declaring the routines.  This will fail",
371  " * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)",
372  " * or sizeof(void*) != sizeof(int).",
373  " */",
374  "#endif",
375  "#endif",
376  "",
377  "/* Amount of stuff to slurp up with each read. */",
378  "#ifndef YY_READ_BUF_SIZE",
379  "#define YY_READ_BUF_SIZE 8192",
380  "#endif",
381  "",
382  "/* Copy whatever the last rule matched to the standard output. */",
383  "",
384  "#ifndef ECHO",
385  "%- Standard (non-C++) definition",
386  "/* This used to be an fputs(), but since the string might contain NUL's,",
387  " * we now use fwrite().",
388  " */",
389  "#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )",
390  "%+ C++ definition",
391  "#define ECHO LexerOutput( yytext, yyleng )",
392  "%*",
393  "#endif",
394  "",
395  "/* Gets input and stuffs it into \"buf\".  number of characters read, or YY_NULL,",
396  " * is returned in \"result\".",
397  " */",
398  "#ifndef YY_INPUT",
399  "#define YY_INPUT(buf,result,max_size) \\",
400  "%% fread()/read() definition of YY_INPUT goes here unless we're doing C++",
401  "%+ C++ definition",
402  "	if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \\",
403  "		YY_FATAL_ERROR( \"input in flex scanner failed\" );",
404  "%*",
405  "#endif",
406  "",
407  "/* No semi-colon after return; correct usage is to write \"yyterminate();\" -",
408  " * we don't want an extra ';' after the \"return\" because that will cause",
409  " * some compilers to complain about unreachable statements.",
410  " */",
411  "#ifndef yyterminate",
412  "#define yyterminate() return YY_NULL",
413  "#endif",
414  "",
415  "/* Number of entries by which start-condition stack grows. */",
416  "#ifndef YY_START_STACK_INCR",
417  "#define YY_START_STACK_INCR 25",
418  "#endif",
419  "",
420  "/* Report a fatal error. */",
421  "#ifndef YY_FATAL_ERROR",
422  "%-",
423  "#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )",
424  "%+",
425  "#define YY_FATAL_ERROR(msg) LexerError( msg )",
426  "%*",
427  "#endif",
428  "",
429  "/* Default declaration of generated scanner - a define so the user can",
430  " * easily add parameters.",
431  " */",
432  "#ifndef YY_DECL",
433  "%- Standard (non-C++) definition",
434  "#define YY_DECL int yylex YY_PROTO(( void ))",
435  "%+ C++ definition",
436  "#define YY_DECL int yyFlexLexer::yylex()",
437  "%*",
438  "#endif",
439  "",
440  "/* Code executed at the beginning of each rule, after yytext and yyleng",
441  " * have been set up.",
442  " */",
443  "#ifndef YY_USER_ACTION",
444  "#define YY_USER_ACTION",
445  "#endif",
446  "",
447  "/* Code executed at the end of each rule. */",
448  "#ifndef YY_BREAK",
449  "#define YY_BREAK break;",
450  "#endif",
451  "",
452  "%% YY_RULE_SETUP definition goes here",
453  "",
454  "YY_DECL",
455  "	{",
456  "	register yy_state_type yy_current_state;",
457  "	register char *yy_cp, *yy_bp;",
458  "	register int yy_act;",
459  "",
460  "%% user's declarations go here",
461  "",
462  "	if ( yy_init )",
463  "		{",
464  "		yy_init = 0;",
465  "",
466  "#ifdef YY_USER_INIT",
467  "		YY_USER_INIT;",
468  "#endif",
469  "",
470  "		if ( ! yy_start )",
471  "			yy_start = 1;	/* first start state */",
472  "",
473  "		if ( ! yyin )",
474  "%-",
475  "			yyin = stdin;",
476  "%+",
477  "			yyin = &cin;",
478  "%*",
479  "",
480  "		if ( ! yyout )",
481  "%-",
482  "			yyout = stdout;",
483  "%+",
484  "			yyout = &cout;",
485  "%*",
486  "",
487  "		if ( ! yy_current_buffer )",
488  "			yy_current_buffer =",
489  "				yy_create_buffer( yyin, YY_BUF_SIZE );",
490  "",
491  "		yy_load_buffer_state();",
492  "		}",
493  "",
494  "	while ( 1 )		/* loops until end-of-file is reached */",
495  "		{",
496  "%% yymore()-related code goes here",
497  "		yy_cp = yy_c_buf_p;",
498  "",
499  "		/* Support of yytext. */",
500  "		*yy_cp = yy_hold_char;",
501  "",
502  "		/* yy_bp points to the position in yy_ch_buf of the start of",
503  "		 * the current run.",
504  "		 */",
505  "		yy_bp = yy_cp;",
506  "",
507  "%% code to set up and find next match goes here",
508  "",
509  "yy_find_action:",
510  "%% code to find the action number goes here",
511  "",
512  "		YY_DO_BEFORE_ACTION;",
513  "",
514  "%% code for yylineno update goes here",
515  "",
516  "do_action:	/* This label is used only to access EOF actions. */",
517  "",
518  "%% debug code goes here",
519  "",
520  "		switch ( yy_act )",
521  "	{ /* beginning of action switch */",
522  "%% actions go here",
523  "",
524  "	case YY_END_OF_BUFFER:",
525  "		{",
526  "		/* Amount of text matched not including the EOB char. */",
527  "		int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;",
528  "",
529  "		/* Undo the effects of YY_DO_BEFORE_ACTION. */",
530  "		*yy_cp = yy_hold_char;",
531  "		YY_RESTORE_YY_MORE_OFFSET",
532  "",
533  "		if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )",
534  "			{",
535  "			/* We're scanning a new file or input source.  It's",
536  "			 * possible that this happened because the user",
537  "			 * just pointed yyin at a new source and called",
538  "			 * yylex().  If so, then we have to assure",
539  "			 * consistency between yy_current_buffer and our",
540  "			 * globals.  Here is the right place to do so, because",
541  "			 * this is the first action (other than possibly a",
542  "			 * back-up) that will match for the new input source.",
543  "			 */",
544  "			yy_n_chars = yy_current_buffer->yy_n_chars;",
545  "			yy_current_buffer->yy_input_file = yyin;",
546  "			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;",
547  "			}",
548  "",
549  "		/* Note that here we test for yy_c_buf_p \"<=\" to the position",
550  "		 * of the first EOB in the buffer, since yy_c_buf_p will",
551  "		 * already have been incremented past the NUL character",
552  "		 * (since all states make transitions on EOB to the",
553  "		 * end-of-buffer state).  Contrast this with the test",
554  "		 * in input().",
555  "		 */",
556  "		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )",
557  "			{ /* This was really a NUL. */",
558  "			yy_state_type yy_next_state;",
559  "",
560  "			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;",
561  "",
562  "			yy_current_state = yy_get_previous_state();",
563  "",
564  "			/* Okay, we're now positioned to make the NUL",
565  "			 * transition.  We couldn't have",
566  "			 * yy_get_previous_state() go ahead and do it",
567  "			 * for us because it doesn't know how to deal",
568  "			 * with the possibility of jamming (and we don't",
569  "			 * want to build jamming into it because then it",
570  "			 * will run more slowly).",
571  "			 */",
572  "",
573  "			yy_next_state = yy_try_NUL_trans( yy_current_state );",
574  "",
575  "			yy_bp = yytext_ptr + YY_MORE_ADJ;",
576  "",
577  "			if ( yy_next_state )",
578  "				{",
579  "				/* Consume the NUL. */",
580  "				yy_cp = ++yy_c_buf_p;",
581  "				yy_current_state = yy_next_state;",
582  "				goto yy_match;",
583  "				}",
584  "",
585  "			else",
586  "				{",
587  "%% code to do back-up for compressed tables and set up yy_cp goes here",
588  "				goto yy_find_action;",
589  "				}",
590  "			}",
591  "",
592  "		else switch ( yy_get_next_buffer() )",
593  "			{",
594  "			case EOB_ACT_END_OF_FILE:",
595  "				{",
596  "				yy_did_buffer_switch_on_eof = 0;",
597  "",
598  "				if ( yywrap() )",
599  "					{",
600  "					/* Note: because we've taken care in",
601  "					 * yy_get_next_buffer() to have set up",
602  "					 * yytext, we can now set up",
603  "					 * yy_c_buf_p so that if some total",
604  "					 * hoser (like flex itself) wants to",
605  "					 * call the scanner after we return the",
606  "					 * YY_NULL, it'll still work - another",
607  "					 * YY_NULL will get returned.",
608  "					 */",
609  "					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;",
610  "",
611  "					yy_act = YY_STATE_EOF(YY_START);",
612  "					goto do_action;",
613  "					}",
614  "",
615  "				else",
616  "					{",
617  "					if ( ! yy_did_buffer_switch_on_eof )",
618  "						YY_NEW_FILE;",
619  "					}",
620  "				break;",
621  "				}",
622  "",
623  "			case EOB_ACT_CONTINUE_SCAN:",
624  "				yy_c_buf_p =",
625  "					yytext_ptr + yy_amount_of_matched_text;",
626  "",
627  "				yy_current_state = yy_get_previous_state();",
628  "",
629  "				yy_cp = yy_c_buf_p;",
630  "				yy_bp = yytext_ptr + YY_MORE_ADJ;",
631  "				goto yy_match;",
632  "",
633  "			case EOB_ACT_LAST_MATCH:",
634  "				yy_c_buf_p =",
635  "				&yy_current_buffer->yy_ch_buf[yy_n_chars];",
636  "",
637  "				yy_current_state = yy_get_previous_state();",
638  "",
639  "				yy_cp = yy_c_buf_p;",
640  "				yy_bp = yytext_ptr + YY_MORE_ADJ;",
641  "				goto yy_find_action;",
642  "			}",
643  "		break;",
644  "		}",
645  "",
646  "	default:",
647  "		YY_FATAL_ERROR(",
648  "			\"fatal flex scanner internal error--no action found\" );",
649  "	} /* end of action switch */",
650  "		} /* end of scanning one token */",
651  "	} /* end of yylex */",
652  "",
653  "%+",
654  "yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )",
655  "	{",
656  "	yyin = arg_yyin;",
657  "	yyout = arg_yyout;",
658  "	yy_c_buf_p = 0;",
659  "	yy_init = 1;",
660  "	yy_start = 0;",
661  "	yy_flex_debug = 0;",
662  "	yylineno = 1;	// this will only get updated if %option yylineno",
663  "",
664  "	yy_did_buffer_switch_on_eof = 0;",
665  "",
666  "	yy_looking_for_trail_begin = 0;",
667  "	yy_more_flag = 0;",
668  "	yy_more_len = 0;",
669  "	yy_more_offset = yy_prev_more_offset = 0;",
670  "",
671  "	yy_start_stack_ptr = yy_start_stack_depth = 0;",
672  "	yy_start_stack = 0;",
673  "",
674  "	yy_current_buffer = 0;",
675  "",
676  "#ifdef YY_USES_REJECT",
677  "	yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];",
678  "#else",
679  "	yy_state_buf = 0;",
680  "#endif",
681  "	}",
682  "",
683  "yyFlexLexer::~yyFlexLexer()",
684  "	{",
685  "	delete yy_state_buf;",
686  "	yy_delete_buffer( yy_current_buffer );",
687  "	}",
688  "",
689  "void yyFlexLexer::switch_streams( istream* new_in, ostream* new_out )",
690  "	{",
691  "	if ( new_in )",
692  "		{",
693  "		yy_delete_buffer( yy_current_buffer );",
694  "		yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );",
695  "		}",
696  "",
697  "	if ( new_out )",
698  "		yyout = new_out;",
699  "	}",
700  "",
701  "#ifdef YY_INTERACTIVE",
702  "int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )",
703  "#else",
704  "int yyFlexLexer::LexerInput( char* buf, int max_size )",
705  "#endif",
706  "	{",
707  "	if ( yyin->eof() || yyin->fail() )",
708  "		return 0;",
709  "",
710  "#ifdef YY_INTERACTIVE",
711  "	yyin->get( buf[0] );",
712  "",
713  "	if ( yyin->eof() )",
714  "		return 0;",
715  "",
716  "	if ( yyin->bad() )",
717  "		return -1;",
718  "",
719  "	return 1;",
720  "",
721  "#else",
722  "	(void) yyin->read( buf, max_size );",
723  "",
724  "	if ( yyin->bad() )",
725  "		return -1;",
726  "	else",
727  "		return yyin->gcount();",
728  "#endif",
729  "	}",
730  "",
731  "void yyFlexLexer::LexerOutput( const char* buf, int size )",
732  "	{",
733  "	(void) yyout->write( buf, size );",
734  "	}",
735  "%*",
736  "",
737  "/* yy_get_next_buffer - try to read in a new buffer",
738  " *",
739  " * Returns a code representing an action:",
740  " *	EOB_ACT_LAST_MATCH -",
741  " *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position",
742  " *	EOB_ACT_END_OF_FILE - end of file",
743  " */",
744  "",
745  "%-",
746  "static int yy_get_next_buffer()",
747  "%+",
748  "int yyFlexLexer::yy_get_next_buffer()",
749  "%*",
750  "	{",
751  "	register char *dest = yy_current_buffer->yy_ch_buf;",
752  "	register char *source = yytext_ptr;",
753  "	register int number_to_move, i;",
754  "	int ret_val;",
755  "",
756  "	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )",
757  "		YY_FATAL_ERROR(",
758  "		\"fatal flex scanner internal error--end of buffer missed\" );",
759  "",
760  "	if ( yy_current_buffer->yy_fill_buffer == 0 )",
761  "		{ /* Don't try to fill the buffer, so this is an EOF. */",
762  "		if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )",
763  "			{",
764  "			/* We matched a single character, the EOB, so",
765  "			 * treat this as a final EOF.",
766  "			 */",
767  "			return EOB_ACT_END_OF_FILE;",
768  "			}",
769  "",
770  "		else",
771  "			{",
772  "			/* We matched some text prior to the EOB, first",
773  "			 * process it.",
774  "			 */",
775  "			return EOB_ACT_LAST_MATCH;",
776  "			}",
777  "		}",
778  "",
779  "	/* Try to read more data. */",
780  "",
781  "	/* First move last chars to start of buffer. */",
782  "	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;",
783  "",
784  "	for ( i = 0; i < number_to_move; ++i )",
785  "		*(dest++) = *(source++);",
786  "",
787  "	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )",
788  "		/* don't do the read, it's not guaranteed to return an EOF,",
789  "		 * just force an EOF",
790  "		 */",
791  "		yy_current_buffer->yy_n_chars = yy_n_chars = 0;",
792  "",
793  "	else",
794  "		{",
795  "		int num_to_read =",
796  "			yy_current_buffer->yy_buf_size - number_to_move - 1;",
797  "",
798  "		while ( num_to_read <= 0 )",
799  "			{ /* Not enough room in the buffer - grow it. */",
800  "#ifdef YY_USES_REJECT",
801  "			YY_FATAL_ERROR(",
802  "\"input buffer overflow, can't enlarge buffer because scanner uses REJECT\" );",
803  "#else",
804  "",
805  "			/* just a shorter name for the current buffer */",
806  "			YY_BUFFER_STATE b = yy_current_buffer;",
807  "",
808  "			int yy_c_buf_p_offset =",
809  "				(int) (yy_c_buf_p - b->yy_ch_buf);",
810  "",
811  "			if ( b->yy_is_our_buffer )",
812  "				{",
813  "				int new_size = b->yy_buf_size * 2;",
814  "",
815  "				if ( new_size <= 0 )",
816  "					b->yy_buf_size += b->yy_buf_size / 8;",
817  "				else",
818  "					b->yy_buf_size *= 2;",
819  "",
820  "				b->yy_ch_buf = (char *)",
821  "					/* Include room in for 2 EOB chars. */",
822  "					yy_flex_realloc( (void *) b->yy_ch_buf,",
823  "							 b->yy_buf_size + 2 );",
824  "				}",
825  "			else",
826  "				/* Can't grow it, we don't own it. */",
827  "				b->yy_ch_buf = 0;",
828  "",
829  "			if ( ! b->yy_ch_buf )",
830  "				YY_FATAL_ERROR(",
831  "				\"fatal error - scanner input buffer overflow\" );",
832  "",
833  "			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];",
834  "",
835  "			num_to_read = yy_current_buffer->yy_buf_size -",
836  "						number_to_move - 1;",
837  "#endif",
838  "			}",
839  "",
840  "		if ( num_to_read > YY_READ_BUF_SIZE )",
841  "			num_to_read = YY_READ_BUF_SIZE;",
842  "",
843  "		/* Read in more data. */",
844  "		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),",
845  "			yy_n_chars, num_to_read );",
846  "",
847  "		yy_current_buffer->yy_n_chars = yy_n_chars;",
848  "		}",
849  "",
850  "	if ( yy_n_chars == 0 )",
851  "		{",
852  "		if ( number_to_move == YY_MORE_ADJ )",
853  "			{",
854  "			ret_val = EOB_ACT_END_OF_FILE;",
855  "			yyrestart( yyin );",
856  "			}",
857  "",
858  "		else",
859  "			{",
860  "			ret_val = EOB_ACT_LAST_MATCH;",
861  "			yy_current_buffer->yy_buffer_status =",
862  "				YY_BUFFER_EOF_PENDING;",
863  "			}",
864  "		}",
865  "",
866  "	else",
867  "		ret_val = EOB_ACT_CONTINUE_SCAN;",
868  "",
869  "	yy_n_chars += number_to_move;",
870  "	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;",
871  "	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;",
872  "",
873  "	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];",
874  "",
875  "	return ret_val;",
876  "	}",
877  "",
878  "",
879  "/* yy_get_previous_state - get the state just before the EOB char was reached */",
880  "",
881  "%-",
882  "static yy_state_type yy_get_previous_state()",
883  "%+",
884  "yy_state_type yyFlexLexer::yy_get_previous_state()",
885  "%*",
886  "	{",
887  "	register yy_state_type yy_current_state;",
888  "	register char *yy_cp;",
889  "",
890  "%% code to get the start state into yy_current_state goes here",
891  "",
892  "	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )",
893  "		{",
894  "%% code to find the next state goes here",
895  "		}",
896  "",
897  "	return yy_current_state;",
898  "	}",
899  "",
900  "",
901  "/* yy_try_NUL_trans - try to make a transition on the NUL character",
902  " *",
903  " * synopsis",
904  " *	next_state = yy_try_NUL_trans( current_state );",
905  " */",
906  "",
907  "%-",
908  "#ifdef YY_USE_PROTOS",
909  "static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )",
910  "#else",
911  "static yy_state_type yy_try_NUL_trans( yy_current_state )",
912  "yy_state_type yy_current_state;",
913  "#endif",
914  "%+",
915  "yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )",
916  "%*",
917  "	{",
918  "	register int yy_is_jam;",
919  "%% code to find the next state, and perhaps do backing up, goes here",
920  "",
921  "	return yy_is_jam ? 0 : yy_current_state;",
922  "	}",
923  "",
924  "",
925  "%-",
926  "#ifndef YY_NO_UNPUT",
927  "#ifdef YY_USE_PROTOS",
928  "static void yyunput( int c, register char *yy_bp )",
929  "#else",
930  "static void yyunput( c, yy_bp )",
931  "int c;",
932  "register char *yy_bp;",
933  "#endif",
934  "%+",
935  "void yyFlexLexer::yyunput( int c, register char* yy_bp )",
936  "%*",
937  "	{",
938  "	register char *yy_cp = yy_c_buf_p;",
939  "",
940  "	/* undo effects of setting up yytext */",
941  "	*yy_cp = yy_hold_char;",
942  "",
943  "	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )",
944  "		{ /* need to shift things up to make room */",
945  "		/* +2 for EOB chars. */",
946  "		register int number_to_move = yy_n_chars + 2;",
947  "		register char *dest = &yy_current_buffer->yy_ch_buf[",
948  "					yy_current_buffer->yy_buf_size + 2];",
949  "		register char *source =",
950  "				&yy_current_buffer->yy_ch_buf[number_to_move];",
951  "",
952  "		while ( source > yy_current_buffer->yy_ch_buf )",
953  "			*--dest = *--source;",
954  "",
955  "		yy_cp += (int) (dest - source);",
956  "		yy_bp += (int) (dest - source);",
957  "		yy_current_buffer->yy_n_chars =",
958  "			yy_n_chars = yy_current_buffer->yy_buf_size;",
959  "",
960  "		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )",
961  "			YY_FATAL_ERROR( \"flex scanner push-back overflow\" );",
962  "		}",
963  "",
964  "	*--yy_cp = (char) c;",
965  "",
966  "%% update yylineno here",
967  "",
968  "	yytext_ptr = yy_bp;",
969  "	yy_hold_char = *yy_cp;",
970  "	yy_c_buf_p = yy_cp;",
971  "	}",
972  "%-",
973  "#endif	/* ifndef YY_NO_UNPUT */",
974  "%*",
975  "",
976  "",
977  "%-",
978  "#ifdef __cplusplus",
979  "static int yyinput()",
980  "#else",
981  "static int input()",
982  "#endif",
983  "%+",
984  "int yyFlexLexer::yyinput()",
985  "%*",
986  "	{",
987  "	int c;",
988  "",
989  "	*yy_c_buf_p = yy_hold_char;",
990  "",
991  "	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )",
992  "		{",
993  "		/* yy_c_buf_p now points to the character we want to return.",
994  "		 * If this occurs *before* the EOB characters, then it's a",
995  "		 * valid NUL; if not, then we've hit the end of the buffer.",
996  "		 */",
997  "		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )",
998  "			/* This was really a NUL. */",
999  "			*yy_c_buf_p = '\\0';",
1000  "",
1001  "		else",
1002  "			{ /* need more input */",
1003  "			int offset = yy_c_buf_p - yytext_ptr;",
1004  "			++yy_c_buf_p;",
1005  "",
1006  "			switch ( yy_get_next_buffer() )",
1007  "				{",
1008  "				case EOB_ACT_LAST_MATCH:",
1009  "					/* This happens because yy_g_n_b()",
1010  "					 * sees that we've accumulated a",
1011  "					 * token and flags that we need to",
1012  "					 * try matching the token before",
1013  "					 * proceeding.  But for input(),",
1014  "					 * there's no matching to consider.",
1015  "					 * So convert the EOB_ACT_LAST_MATCH",
1016  "					 * to EOB_ACT_END_OF_FILE.",
1017  "					 */",
1018  "",
1019  "					/* Reset buffer status. */",
1020  "					yyrestart( yyin );",
1021  "",
1022  "					/* fall through */",
1023  "",
1024  "				case EOB_ACT_END_OF_FILE:",
1025  "					{",
1026  "					if ( yywrap() )",
1027  "						return EOF;",
1028  "",
1029  "					if ( ! yy_did_buffer_switch_on_eof )",
1030  "						YY_NEW_FILE;",
1031  "#ifdef __cplusplus",
1032  "					return yyinput();",
1033  "#else",
1034  "					return input();",
1035  "#endif",
1036  "					}",
1037  "",
1038  "				case EOB_ACT_CONTINUE_SCAN:",
1039  "					yy_c_buf_p = yytext_ptr + offset;",
1040  "					break;",
1041  "				}",
1042  "			}",
1043  "		}",
1044  "",
1045  "	c = *(unsigned char *) yy_c_buf_p;	/* cast for 8-bit char's */",
1046  "	*yy_c_buf_p = '\\0';	/* preserve yytext */",
1047  "	yy_hold_char = *++yy_c_buf_p;",
1048  "",
1049  "%% update BOL and yylineno",
1050  "",
1051  "	return c;",
1052  "	}",
1053  "",
1054  "",
1055  "%-",
1056  "#ifdef YY_USE_PROTOS",
1057  "void yyrestart( FILE *input_file )",
1058  "#else",
1059  "void yyrestart( input_file )",
1060  "FILE *input_file;",
1061  "#endif",
1062  "%+",
1063  "void yyFlexLexer::yyrestart( istream* input_file )",
1064  "%*",
1065  "	{",
1066  "	if ( ! yy_current_buffer )",
1067  "		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );",
1068  "",
1069  "	yy_init_buffer( yy_current_buffer, input_file );",
1070  "	yy_load_buffer_state();",
1071  "	}",
1072  "",
1073  "",
1074  "%-",
1075  "#ifdef YY_USE_PROTOS",
1076  "void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )",
1077  "#else",
1078  "void yy_switch_to_buffer( new_buffer )",
1079  "YY_BUFFER_STATE new_buffer;",
1080  "#endif",
1081  "%+",
1082  "void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )",
1083  "%*",
1084  "	{",
1085  "	if ( yy_current_buffer == new_buffer )",
1086  "		return;",
1087  "",
1088  "	if ( yy_current_buffer )",
1089  "		{",
1090  "		/* Flush out information for old buffer. */",
1091  "		*yy_c_buf_p = yy_hold_char;",
1092  "		yy_current_buffer->yy_buf_pos = yy_c_buf_p;",
1093  "		yy_current_buffer->yy_n_chars = yy_n_chars;",
1094  "		}",
1095  "",
1096  "	yy_current_buffer = new_buffer;",
1097  "	yy_load_buffer_state();",
1098  "",
1099  "	/* We don't actually know whether we did this switch during",
1100  "	 * EOF (yywrap()) processing, but the only time this flag",
1101  "	 * is looked at is after yywrap() is called, so it's safe",
1102  "	 * to go ahead and always set it.",
1103  "	 */",
1104  "	yy_did_buffer_switch_on_eof = 1;",
1105  "	}",
1106  "",
1107  "",
1108  "%-",
1109  "#ifdef YY_USE_PROTOS",
1110  "void yy_load_buffer_state( void )",
1111  "#else",
1112  "void yy_load_buffer_state()",
1113  "#endif",
1114  "%+",
1115  "void yyFlexLexer::yy_load_buffer_state()",
1116  "%*",
1117  "	{",
1118  "	yy_n_chars = yy_current_buffer->yy_n_chars;",
1119  "	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;",
1120  "	yyin = yy_current_buffer->yy_input_file;",
1121  "	yy_hold_char = *yy_c_buf_p;",
1122  "	}",
1123  "",
1124  "",
1125  "%-",
1126  "#ifdef YY_USE_PROTOS",
1127  "YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )",
1128  "#else",
1129  "YY_BUFFER_STATE yy_create_buffer( file, size )",
1130  "FILE *file;",
1131  "int size;",
1132  "#endif",
1133  "%+",
1134  "YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )",
1135  "%*",
1136  "	{",
1137  "	YY_BUFFER_STATE b;",
1138  "",
1139  "	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );",
1140  "	if ( ! b )",
1141  "		YY_FATAL_ERROR( \"out of dynamic memory in yy_create_buffer()\" );",
1142  "",
1143  "	b->yy_buf_size = size;",
1144  "",
1145  "	/* yy_ch_buf has to be 2 characters longer than the size given because",
1146  "	 * we need to put in 2 end-of-buffer characters.",
1147  "	 */",
1148  "	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );",
1149  "	if ( ! b->yy_ch_buf )",
1150  "		YY_FATAL_ERROR( \"out of dynamic memory in yy_create_buffer()\" );",
1151  "",
1152  "	b->yy_is_our_buffer = 1;",
1153  "",
1154  "	yy_init_buffer( b, file );",
1155  "",
1156  "	return b;",
1157  "	}",
1158  "",
1159  "",
1160  "%-",
1161  "#ifdef YY_USE_PROTOS",
1162  "void yy_delete_buffer( YY_BUFFER_STATE b )",
1163  "#else",
1164  "void yy_delete_buffer( b )",
1165  "YY_BUFFER_STATE b;",
1166  "#endif",
1167  "%+",
1168  "void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )",
1169  "%*",
1170  "	{",
1171  "	if ( ! b )",
1172  "		return;",
1173  "",
1174  "	if ( b == yy_current_buffer )",
1175  "		yy_current_buffer = (YY_BUFFER_STATE) 0;",
1176  "",
1177  "	if ( b->yy_is_our_buffer )",
1178  "		yy_flex_free( (void *) b->yy_ch_buf );",
1179  "",
1180  "	yy_flex_free( (void *) b );",
1181  "	}",
1182  "",
1183  "",
1184  "%-",
1185  "#ifndef YY_ALWAYS_INTERACTIVE",
1186  "#ifndef YY_NEVER_INTERACTIVE",
1187  "extern int isatty YY_PROTO(( int ));",
1188  "#endif",
1189  "#endif",
1190  "",
1191  "#ifdef YY_USE_PROTOS",
1192  "void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )",
1193  "#else",
1194  "void yy_init_buffer( b, file )",
1195  "YY_BUFFER_STATE b;",
1196  "FILE *file;",
1197  "#endif",
1198  "",
1199  "%+",
1200  "extern \"C\" int isatty YY_PROTO(( int ));",
1201  "void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )",
1202  "%*",
1203  "",
1204  "	{",
1205  "	yy_flush_buffer( b );",
1206  "",
1207  "	b->yy_input_file = file;",
1208  "	b->yy_fill_buffer = 1;",
1209  "",
1210  "%-",
1211  "#if YY_ALWAYS_INTERACTIVE",
1212  "	b->yy_is_interactive = 1;",
1213  "#else",
1214  "#if YY_NEVER_INTERACTIVE",
1215  "	b->yy_is_interactive = 0;",
1216  "#else",
1217  "	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;",
1218  "#endif",
1219  "#endif",
1220  "%+",
1221  "	b->yy_is_interactive = 0;",
1222  "%*",
1223  "	}",
1224  "",
1225  "",
1226  "%-",
1227  "#ifdef YY_USE_PROTOS",
1228  "void yy_flush_buffer( YY_BUFFER_STATE b )",
1229  "#else",
1230  "void yy_flush_buffer( b )",
1231  "YY_BUFFER_STATE b;",
1232  "#endif",
1233  "",
1234  "%+",
1235  "void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )",
1236  "%*",
1237  "	{",
1238  "	if ( ! b )",
1239  "		return;",
1240  "",
1241  "	b->yy_n_chars = 0;",
1242  "",
1243  "	/* We always need two end-of-buffer characters.  The first causes",
1244  "	 * a transition to the end-of-buffer state.  The second causes",
1245  "	 * a jam in that state.",
1246  "	 */",
1247  "	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;",
1248  "	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;",
1249  "",
1250  "	b->yy_buf_pos = &b->yy_ch_buf[0];",
1251  "",
1252  "	b->yy_at_bol = 1;",
1253  "	b->yy_buffer_status = YY_BUFFER_NEW;",
1254  "",
1255  "	if ( b == yy_current_buffer )",
1256  "		yy_load_buffer_state();",
1257  "	}",
1258  "%*",
1259  "",
1260  "",
1261  "#ifndef YY_NO_SCAN_BUFFER",
1262  "%-",
1263  "#ifdef YY_USE_PROTOS",
1264  "YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )",
1265  "#else",
1266  "YY_BUFFER_STATE yy_scan_buffer( base, size )",
1267  "char *base;",
1268  "yy_size_t size;",
1269  "#endif",
1270  "	{",
1271  "	YY_BUFFER_STATE b;",
1272  "",
1273  "	if ( size < 2 ||",
1274  "	     base[size-2] != YY_END_OF_BUFFER_CHAR ||",
1275  "	     base[size-1] != YY_END_OF_BUFFER_CHAR )",
1276  "		/* They forgot to leave room for the EOB's. */",
1277  "		return 0;",
1278  "",
1279  "	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );",
1280  "	if ( ! b )",
1281  "		YY_FATAL_ERROR( \"out of dynamic memory in yy_scan_buffer()\" );",
1282  "",
1283  "	b->yy_buf_size = size - 2;	/* \"- 2\" to take care of EOB's */",
1284  "	b->yy_buf_pos = b->yy_ch_buf = base;",
1285  "	b->yy_is_our_buffer = 0;",
1286  "	b->yy_input_file = 0;",
1287  "	b->yy_n_chars = b->yy_buf_size;",
1288  "	b->yy_is_interactive = 0;",
1289  "	b->yy_at_bol = 1;",
1290  "	b->yy_fill_buffer = 0;",
1291  "	b->yy_buffer_status = YY_BUFFER_NEW;",
1292  "",
1293  "	yy_switch_to_buffer( b );",
1294  "",
1295  "	return b;",
1296  "	}",
1297  "%*",
1298  "#endif",
1299  "",
1300  "",
1301  "#ifndef YY_NO_SCAN_STRING",
1302  "%-",
1303  "#ifdef YY_USE_PROTOS",
1304  "YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )",
1305  "#else",
1306  "YY_BUFFER_STATE yy_scan_string( yy_str )",
1307  "yyconst char *yy_str;",
1308  "#endif",
1309  "	{",
1310  "	int len;",
1311  "	for ( len = 0; yy_str[len]; ++len )",
1312  "		;",
1313  "",
1314  "	return yy_scan_bytes( yy_str, len );",
1315  "	}",
1316  "%*",
1317  "#endif",
1318  "",
1319  "",
1320  "#ifndef YY_NO_SCAN_BYTES",
1321  "%-",
1322  "#ifdef YY_USE_PROTOS",
1323  "YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )",
1324  "#else",
1325  "YY_BUFFER_STATE yy_scan_bytes( bytes, len )",
1326  "yyconst char *bytes;",
1327  "int len;",
1328  "#endif",
1329  "	{",
1330  "	YY_BUFFER_STATE b;",
1331  "	char *buf;",
1332  "	yy_size_t n;",
1333  "	int i;",
1334  "",
1335  "	/* Get memory for full buffer, including space for trailing EOB's. */",
1336  "	n = len + 2;",
1337  "	buf = (char *) yy_flex_alloc( n );",
1338  "	if ( ! buf )",
1339  "		YY_FATAL_ERROR( \"out of dynamic memory in yy_scan_bytes()\" );",
1340  "",
1341  "	for ( i = 0; i < len; ++i )",
1342  "		buf[i] = bytes[i];",
1343  "",
1344  "	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;",
1345  "",
1346  "	b = yy_scan_buffer( buf, n );",
1347  "	if ( ! b )",
1348  "		YY_FATAL_ERROR( \"bad buffer in yy_scan_bytes()\" );",
1349  "",
1350  "	/* It's okay to grow etc. this buffer, and we should throw it",
1351  "	 * away when we're done.",
1352  "	 */",
1353  "	b->yy_is_our_buffer = 1;",
1354  "",
1355  "	return b;",
1356  "	}",
1357  "%*",
1358  "#endif",
1359  "",
1360  "",
1361  "#ifndef YY_NO_PUSH_STATE",
1362  "%-",
1363  "#ifdef YY_USE_PROTOS",
1364  "static void yy_push_state( int new_state )",
1365  "#else",
1366  "static void yy_push_state( new_state )",
1367  "int new_state;",
1368  "#endif",
1369  "%+",
1370  "void yyFlexLexer::yy_push_state( int new_state )",
1371  "%*",
1372  "	{",
1373  "	if ( yy_start_stack_ptr >= yy_start_stack_depth )",
1374  "		{",
1375  "		yy_size_t new_size;",
1376  "",
1377  "		yy_start_stack_depth += YY_START_STACK_INCR;",
1378  "		new_size = yy_start_stack_depth * sizeof( int );",
1379  "",
1380  "		if ( ! yy_start_stack )",
1381  "			yy_start_stack = (int *) yy_flex_alloc( new_size );",
1382  "",
1383  "		else",
1384  "			yy_start_stack = (int *) yy_flex_realloc(",
1385  "					(void *) yy_start_stack, new_size );",
1386  "",
1387  "		if ( ! yy_start_stack )",
1388  "			YY_FATAL_ERROR(",
1389  "			\"out of memory expanding start-condition stack\" );",
1390  "		}",
1391  "",
1392  "	yy_start_stack[yy_start_stack_ptr++] = YY_START;",
1393  "",
1394  "	BEGIN(new_state);",
1395  "	}",
1396  "#endif",
1397  "",
1398  "",
1399  "#ifndef YY_NO_POP_STATE",
1400  "%-",
1401  "static void yy_pop_state()",
1402  "%+",
1403  "void yyFlexLexer::yy_pop_state()",
1404  "%*",
1405  "	{",
1406  "	if ( --yy_start_stack_ptr < 0 )",
1407  "		YY_FATAL_ERROR( \"start-condition stack underflow\" );",
1408  "",
1409  "	BEGIN(yy_start_stack[yy_start_stack_ptr]);",
1410  "	}",
1411  "#endif",
1412  "",
1413  "",
1414  "#ifndef YY_NO_TOP_STATE",
1415  "%-",
1416  "static int yy_top_state()",
1417  "%+",
1418  "int yyFlexLexer::yy_top_state()",
1419  "%*",
1420  "	{",
1421  "	return yy_start_stack[yy_start_stack_ptr - 1];",
1422  "	}",
1423  "#endif",
1424  "",
1425  "#ifndef YY_EXIT_FAILURE",
1426  "#define YY_EXIT_FAILURE 2",
1427  "#endif",
1428  "",
1429  "%-",
1430  "#ifdef YY_USE_PROTOS",
1431  "static void yy_fatal_error( yyconst char msg[] )",
1432  "#else",
1433  "static void yy_fatal_error( msg )",
1434  "char msg[];",
1435  "#endif",
1436  "	{",
1437  "	(void) fprintf( stderr, \"%s\\n\", msg );",
1438  "	exit( YY_EXIT_FAILURE );",
1439  "	}",
1440  "",
1441  "%+",
1442  "",
1443  "void yyFlexLexer::LexerError( yyconst char msg[] )",
1444  "	{",
1445  "	cerr << msg << '\\n';",
1446  "	exit( YY_EXIT_FAILURE );",
1447  "	}",
1448  "%*",
1449  "",
1450  "",
1451  "/* Redefine yyless() so it works in section 3 code. */",
1452  "",
1453  "#undef yyless",
1454  "#define yyless(n) \\",
1455  "	do \\",
1456  "		{ \\",
1457  "		/* Undo effects of setting up yytext. */ \\",
1458  "		yytext[yyleng] = yy_hold_char; \\",
1459  "		yy_c_buf_p = yytext + n; \\",
1460  "		yy_hold_char = *yy_c_buf_p; \\",
1461  "		*yy_c_buf_p = '\\0'; \\",
1462  "		yyleng = n; \\",
1463  "		} \\",
1464  "	while ( 0 )",
1465  "",
1466  "",
1467  "/* Internal utility routines. */",
1468  "",
1469  "#ifndef yytext_ptr",
1470  "#ifdef YY_USE_PROTOS",
1471  "static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )",
1472  "#else",
1473  "static void yy_flex_strncpy( s1, s2, n )",
1474  "char *s1;",
1475  "yyconst char *s2;",
1476  "int n;",
1477  "#endif",
1478  "	{",
1479  "	register int i;",
1480  "	for ( i = 0; i < n; ++i )",
1481  "		s1[i] = s2[i];",
1482  "	}",
1483  "#endif",
1484  "",
1485  "#ifdef YY_NEED_STRLEN",
1486  "#ifdef YY_USE_PROTOS",
1487  "static int yy_flex_strlen( yyconst char *s )",
1488  "#else",
1489  "static int yy_flex_strlen( s )",
1490  "yyconst char *s;",
1491  "#endif",
1492  "	{",
1493  "	register int n;",
1494  "	for ( n = 0; s[n]; ++n )",
1495  "		;",
1496  "",
1497  "	return n;",
1498  "	}",
1499  "#endif",
1500  "",
1501  "",
1502  "#ifdef YY_USE_PROTOS",
1503  "static void *yy_flex_alloc( yy_size_t size )",
1504  "#else",
1505  "static void *yy_flex_alloc( size )",
1506  "yy_size_t size;",
1507  "#endif",
1508  "	{",
1509  "	return (void *) malloc( size );",
1510  "	}",
1511  "",
1512  "#ifdef YY_USE_PROTOS",
1513  "static void *yy_flex_realloc( void *ptr, yy_size_t size )",
1514  "#else",
1515  "static void *yy_flex_realloc( ptr, size )",
1516  "void *ptr;",
1517  "yy_size_t size;",
1518  "#endif",
1519  "	{",
1520  "	/* The cast to (char *) in the following accommodates both",
1521  "	 * implementations that use char* generic pointers, and those",
1522  "	 * that use void* generic pointers.  It works with the latter",
1523  "	 * because both ANSI C and C++ allow castless assignment from",
1524  "	 * any pointer type to void*, and deal with argument conversions",
1525  "	 * as though doing an assignment.",
1526  "	 */",
1527  "	return (void *) realloc( (char *) ptr, size );",
1528  "	}",
1529  "",
1530  "#ifdef YY_USE_PROTOS",
1531  "static void yy_flex_free( void *ptr )",
1532  "#else",
1533  "static void yy_flex_free( ptr )",
1534  "void *ptr;",
1535  "#endif",
1536  "	{",
1537  "	free( ptr );",
1538  "	}",
1539  "",
1540  "#if YY_MAIN",
1541  "int main()",
1542  "	{",
1543  "	yylex();",
1544  "	return 0;",
1545  "	}",
1546  "#endif",
1547  0
1548};
1549