register char *yy_cp = yy_c_buf_p;	/* undo effects of setting up yytext */	*yy_cp = yy_hold_char;	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )		{ /* need to shift things up to make room */		/* +2 for EOB chars. */		register int number_to_move = yy_n_chars + 2;		register char *dest = &yy_current_buffer->yy_ch_buf[					yy_current_buffer->yy_buf_size + 2];		register char *source =				&yy_current_buffer->yy_ch_buf[number_to_move];		while ( source > yy_current_buffer->yy_ch_buf )			*--dest = *--source;		yy_cp += (int) (dest - source);		yy_bp += (int) (dest - source);		yy_current_buffer->yy_n_chars =			yy_n_chars = yy_current_buffer->yy_buf_size;		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )			YY_FATAL_ERROR( "flex scanner push-back overflow" );		}	*--yy_cp = (char) c;	yytext_ptr = yy_bp;	yy_hold_char = *yy_cp;	yy_c_buf_p = yy_cp;	}#endif	/* ifndef YY_NO_UNPUT */#ifndef YY_NO_INPUT#ifdef __cplusplusstatic int yyinput()#elsestatic int input()#endif	{	int c;	*yy_c_buf_p = yy_hold_char;	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )		{		/* yy_c_buf_p now points to the character we want to return.		 * If this occurs *before* the EOB characters, then it's a		 * valid NUL; if not, then we've hit the end of the buffer.		 */		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )			/* This was really a NUL. */			*yy_c_buf_p = '\0';		else			{ /* need more input */			int offset = yy_c_buf_p - yytext_ptr;			++yy_c_buf_p;			switch ( yy_get_next_buffer() )				{				case EOB_ACT_LAST_MATCH:					/* This happens because yy_g_n_b()					 * sees that we've accumulated a					 * token and flags that we need to					 * try matching the token before					 * proceeding.  But for input(),					 * there's no matching to consider.					 * So convert the EOB_ACT_LAST_MATCH					 * to EOB_ACT_END_OF_FILE.					 */					/* Reset buffer status. */					yyrestart( yyin );					/* fall through */				case EOB_ACT_END_OF_FILE:					{					if ( yywrap() )						return EOF;					if ( ! yy_did_buffer_switch_on_eof )						YY_NEW_FILE;#ifdef __cplusplus					return yyinput();#else					return input();#endif					}				case EOB_ACT_CONTINUE_SCAN:					yy_c_buf_p = yytext_ptr + offset;					break;				}			}		}	c = *(unsigned char *) yy_c_buf_p;	/* cast for 8-bit char's */	*yy_c_buf_p = '\0';	/* preserve yytext */	yy_hold_char = *++yy_c_buf_p;	return c;	}#endif /* YY_NO_INPUT */#ifdef YY_USE_PROTOSvoid yyrestart( FILE *input_file )#elsevoid yyrestart( input_file )FILE *input_file;#endif	{	if ( ! yy_current_buffer )		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );	yy_init_buffer( yy_current_buffer, input_file );	yy_load_buffer_state();	}#ifdef YY_USE_PROTOSvoid yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )#elsevoid yy_switch_to_buffer( new_buffer )YY_BUFFER_STATE new_buffer;#endif	{	if ( yy_current_buffer == new_buffer )		return;	if ( yy_current_buffer )		{		/* Flush out information for old buffer. */		*yy_c_buf_p = yy_hold_char;		yy_current_buffer->yy_buf_pos = yy_c_buf_p;		yy_current_buffer->yy_n_chars = yy_n_chars;		}	yy_current_buffer = new_buffer;	yy_load_buffer_state();	/* We don't actually know whether we did this switch during	 * EOF (yywrap()) processing, but the only time this flag	 * is looked at is after yywrap() is called, so it's safe	 * to go ahead and always set it.	 */	yy_did_buffer_switch_on_eof = 1;	}#ifdef YY_USE_PROTOSvoid yy_load_buffer_state( void )#elsevoid yy_load_buffer_state()#endif	{	yy_n_chars = yy_current_buffer->yy_n_chars;	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;	yyin = yy_current_buffer->yy_input_file;	yy_hold_char = *yy_c_buf_p;	}#ifdef YY_USE_PROTOSYY_BUFFER_STATE yy_create_buffer( FILE *file, int size )#elseYY_BUFFER_STATE yy_create_buffer( file, size )FILE *file;int size;#endif	{	YY_BUFFER_STATE b;	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );	if ( ! b )		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );	b->yy_buf_size = size;	/* yy_ch_buf has to be 2 characters longer than the size given because	 * we need to put in 2 end-of-buffer characters.	 */	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );	if ( ! b->yy_ch_buf )		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );	b->yy_is_our_buffer = 1;	yy_init_buffer( b, file );	return b;	}#ifdef YY_USE_PROTOSvoid yy_delete_buffer( YY_BUFFER_STATE b )#elsevoid yy_delete_buffer( b )YY_BUFFER_STATE b;#endif	{	if ( ! b )		return;	if ( b == yy_current_buffer )		yy_current_buffer = (YY_BUFFER_STATE) 0;	if ( b->yy_is_our_buffer )		yy_flex_free( (void *) b->yy_ch_buf );	yy_flex_free( (void *) b );	}#ifdef YY_USE_PROTOSvoid yy_init_buffer( YY_BUFFER_STATE b, FILE *file )#elsevoid yy_init_buffer( b, file )YY_BUFFER_STATE b;FILE *file;#endif	{	yy_flush_buffer( b );	b->yy_input_file = file;	b->yy_fill_buffer = 1;#if YY_ALWAYS_INTERACTIVE	b->yy_is_interactive = 1;#else#if YY_NEVER_INTERACTIVE	b->yy_is_interactive = 0;#else	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;#endif#endif	}#ifdef YY_USE_PROTOSvoid yy_flush_buffer( YY_BUFFER_STATE b )#elsevoid yy_flush_buffer( b )YY_BUFFER_STATE b;#endif	{	if ( ! b )		return;	b->yy_n_chars = 0;	/* We always need two end-of-buffer characters.  The first causes	 * a transition to the end-of-buffer state.  The second causes	 * a jam in that state.	 */	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;	b->yy_buf_pos = &b->yy_ch_buf[0];	b->yy_at_bol = 1;	b->yy_buffer_status = YY_BUFFER_NEW;	if ( b == yy_current_buffer )		yy_load_buffer_state();	}#ifndef YY_NO_SCAN_BUFFER#ifdef YY_USE_PROTOSYY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )#elseYY_BUFFER_STATE yy_scan_buffer( base, size )char *base;yy_size_t size;#endif	{	YY_BUFFER_STATE b;	if ( size < 2 ||	     base[size-2] != YY_END_OF_BUFFER_CHAR ||	     base[size-1] != YY_END_OF_BUFFER_CHAR )		/* They forgot to leave room for the EOB's. */		return 0;	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );	if ( ! b )		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */	b->yy_buf_pos = b->yy_ch_buf = base;	b->yy_is_our_buffer = 0;	b->yy_input_file = 0;	b->yy_n_chars = b->yy_buf_size;	b->yy_is_interactive = 0;	b->yy_at_bol = 1;	b->yy_fill_buffer = 0;	b->yy_buffer_status = YY_BUFFER_NEW;	yy_switch_to_buffer( b );	return b;	}#endif#ifndef YY_NO_SCAN_STRING#ifdef YY_USE_PROTOSYY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )#elseYY_BUFFER_STATE yy_scan_string( yy_str )yyconst char *yy_str;#endif	{	int len;	for ( len = 0; yy_str[len]; ++len )		;	return yy_scan_bytes( yy_str, len );	}#endif#ifndef YY_NO_SCAN_BYTES#ifdef YY_USE_PROTOSYY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )#elseYY_BUFFER_STATE yy_scan_bytes( bytes, len )yyconst char *bytes;int len;#endif	{	YY_BUFFER_STATE b;	char *buf;	yy_size_t n;	int i;	/* Get memory for full buffer, including space for trailing EOB's. */	n = len + 2;	buf = (char *) yy_flex_alloc( n );	if ( ! buf )		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );	for ( i = 0; i < len; ++i )		buf[i] = bytes[i];	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;	b = yy_scan_buffer( buf, n );	if ( ! b )		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );	/* It's okay to grow etc. this buffer, and we should throw it	 * away when we're done.	 */	b->yy_is_our_buffer = 1;	return b;	}#endif#ifndef YY_NO_PUSH_STATE#ifdef YY_USE_PROTOSstatic void yy_push_state( int new_state )#elsestatic void yy_push_state( new_state )int new_state;#endif	{	if ( yy_start_stack_ptr >= yy_start_stack_depth )		{		yy_size_t new_size;		yy_start_stack_depth += YY_START_STACK_INCR;		new_size = yy_start_stack_depth * sizeof( int );		if ( ! yy_start_stack )			yy_start_stack = (int *) yy_flex_alloc( new_size );		else			yy_start_stack = (int *) yy_flex_realloc(					(void *) yy_start_stack, new_size );		if ( ! yy_start_stack )			YY_FATAL_ERROR(			"out of memory expanding start-condition stack" );		}	yy_start_stack[yy_start_stack_ptr++] = YY_START;	BEGIN(new_state);	}#endif#ifndef YY_NO_POP_STATEstatic void yy_pop_state()	{	if ( --yy_start_stack_ptr < 0 )		YY_FATAL_ERROR( "start-condition stack underflow" );	BEGIN(yy_start_stack[yy_start_stack_ptr]);	}#endif#ifndef YY_NO_TOP_STATEstatic int yy_top_state()	{	return yy_start_stack[yy_start_stack_ptr - 1];	}#endif#ifndef YY_EXIT_FAILURE#define YY_EXIT_FAILURE 2#endif#ifdef YY_USE_PROTOSstatic void yy_fatal_error( yyconst char msg[] )#elsestatic void yy_fatal_error( msg )char msg[];#endif	{	(void) fprintf( stderr, "%s\n", msg );	exit( YY_EXIT_FAILURE );	}/* Redefine yyless() so it works in section 3 code. */#undef yyless#define yyless(n) \	do \		{ \		/* Undo effects of setting up yytext. */ \		yytext[yyleng] = yy_hold_char; \		yy_c_buf_p = yytext + n; \		yy_hold_char = *yy_c_buf_p; \		*yy_c_buf_p = '\0'; \		yyleng = n; \		} \	while ( 0 )/* Internal utility routines. */#ifndef yytext_ptr#ifdef YY_USE_PROTOSstatic void yy_flex_strncpy( char *s1, yyconst char *s2, int n )#elsestatic void yy_flex_strncpy( s1, s2, n )char *s1;yyconst char *s2;int n;#endif	{	register int i;	for ( i = 0; i < n; ++i )		s1[i] = s2[i];	}#endif#ifdef YY_NEED_STRLEN#ifdef YY_USE_PROTOSstatic int yy_flex_strlen( yyconst char *s )#elsestatic int yy_flex_strlen( s )yyconst char *s;#endif	{	register int n;	for ( n = 0; s[n]; ++n )		;	return n;	}#endif#ifdef YY_USE_PROTOSstatic void *yy_flex_alloc( yy_size_t size )#elsestatic void *yy_flex_alloc( size )yy_size_t size;#endif	{	return (void *) malloc( size );	}#ifdef YY_USE_PROTOSstatic void *yy_flex_realloc( void *ptr, yy_size_t size )#elsestatic void *yy_flex_realloc( ptr, size )void *ptr;yy_size_t size;#endif	{	/* The cast to (char *) in the following accommodates both	 * implementations that use char* generic pointers, and those	 * that use void* generic pointers.  It works with the latter	 * because both ANSI C and C++ allow castless assignment from	 * any pointer type to void*, and deal with argument conversions	 * as though doing an assignment.	 */	return (void *) realloc( (char *) ptr, size );	}#ifdef YY_USE_PROTOSstatic void yy_flex_free( void *ptr )#elsestatic void yy_flex_free( ptr )void *ptr;#endif	{	free( ptr );	}#if YY_MAINint main()	{	yylex();	return 0;	}#endif#line 144 "exolex.l"intyywrap(void){  return 1;}static voidlex_eat_comment(void){  char c, c1;loop:  while ((c = input()) != '*' && c != 0)    {      if (c == '\n')	line++;    }  if ((c1 = input()) != '/' && c1 != 0)    {      unput(c1);      goto loop;    }}intyy_nextchar(void){  int c;  do {    c = input();  } while (c == ' ' || c == '\t' || c == '\v' || c == '\f' || c == '\n');  unput(c);  return c;}/* FIXME: this is a total KLUDGE (but well contained...) that I will someday   address when I have copious amounts of free time... */voidyy_setstream(FILE *stream){  int i;#define MAX_STREAMS	16  static struct {    FILE *stream;    YY_BUFFER_STATE buffer;  } streams[MAX_STREAMS] = { {NULL, NULL}, };  static int num_streams = 0;  static FILE *last_stream = NULL;  /* same stream? */  if (stream == last_stream)    return;  /* else, switch to new stream */  for (i=0; i < num_streams; i++)    {      if (streams[i].stream == stream)	{	  yy_switch_to_buffer(streams[i].buffer);	  return;	}    }  /* hrmmm... not found, create a new buffer for this stream */  if (num_streams == MAX_STREAMS)    fatal("out of lex buffer streams, increase MAX_STREAMS");  streams[num_streams].stream = stream;  streams[num_streams].buffer = yy_create_buffer(stream, YY_BUF_SIZE);  yy_switch_to_buffer(streams[num_streams].buffer);  num_streams++;}