lex.cc_command.cpp

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

FILE *input_file;
#endif
	{
	if ( ! ace_cc_yy_current_buffer )
		ace_cc_yy_current_buffer = ace_cc_yy_create_buffer( ace_cc_yyin, ACE_CC_YY_BUF_SIZE );

	ace_cc_yy_init_buffer( ace_cc_yy_current_buffer, input_file );
	ace_cc_yy_load_buffer_state();
	}


#ifdef ACE_CC_YY_USE_PROTOS
void ace_cc_yy_switch_to_buffer( ACE_CC_YY_BUFFER_STATE new_buffer )
#else
void ace_cc_yy_switch_to_buffer( new_buffer )
ACE_CC_YY_BUFFER_STATE new_buffer;
#endif
	{
	if ( ace_cc_yy_current_buffer == new_buffer )
		return;

	if ( ace_cc_yy_current_buffer )
		{
		/* Flush out information for old buffer. */
		*ace_cc_yy_c_buf_p = ace_cc_yy_hold_char;
		ace_cc_yy_current_buffer->ace_cc_yy_buf_pos = ace_cc_yy_c_buf_p;
		ace_cc_yy_current_buffer->ace_cc_yy_n_chars = ace_cc_yy_n_chars;
		}

	ace_cc_yy_current_buffer = new_buffer;
	ace_cc_yy_load_buffer_state();

	/* We don't actually know whether we did this switch during
	 * EOF (ace_cc_yywrap()) processing, but the only time this flag
	 * is looked at is after ace_cc_yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
#if (ace_cc_yywrap() != 1)
	ace_cc_yy_did_buffer_switch_on_eof = 1;
#endif
	}


#ifdef ACE_CC_YY_USE_PROTOS
void ace_cc_yy_load_buffer_state( void )
#else
void ace_cc_yy_load_buffer_state()
#endif
	{
	ace_cc_yy_n_chars = ace_cc_yy_current_buffer->ace_cc_yy_n_chars;
	ace_cc_yytext_ptr = ace_cc_yy_c_buf_p = ace_cc_yy_current_buffer->ace_cc_yy_buf_pos;
	ace_cc_yyin = ace_cc_yy_current_buffer->ace_cc_yy_input_file;
	ace_cc_yy_hold_char = *ace_cc_yy_c_buf_p;
	}


#ifdef ACE_CC_YY_USE_PROTOS
ACE_CC_YY_BUFFER_STATE ace_cc_yy_create_buffer( FILE *file, int size )
#else
ACE_CC_YY_BUFFER_STATE ace_cc_yy_create_buffer( file, size )
FILE *file;
int size;
#endif
	{
	ACE_CC_YY_BUFFER_STATE b;

	b = (ACE_CC_YY_BUFFER_STATE) ace_cc_yy_flex_alloc( sizeof( struct ace_cc_yy_buffer_state ) );
	if ( ! b )
		ACE_CC_YY_FATAL_ERROR( "out of dynamic memory in ace_cc_yy_create_buffer()" );

	b->ace_cc_yy_buf_size = size;

	/* ace_cc_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->ace_cc_yy_ch_buf = (char *) ace_cc_yy_flex_alloc( b->ace_cc_yy_buf_size + 2 );
	if ( ! b->ace_cc_yy_ch_buf )
		ACE_CC_YY_FATAL_ERROR( "out of dynamic memory in ace_cc_yy_create_buffer()" );

	b->ace_cc_yy_is_our_buffer = 1;

	ace_cc_yy_init_buffer( b, file );

	return b;
	}


#ifdef ACE_CC_YY_USE_PROTOS
void ace_cc_yy_delete_buffer( ACE_CC_YY_BUFFER_STATE b )
#else
void ace_cc_yy_delete_buffer( b )
ACE_CC_YY_BUFFER_STATE b;
#endif
	{
	if ( ! b )
		return;

	if ( b == ace_cc_yy_current_buffer )
		ace_cc_yy_current_buffer = (ACE_CC_YY_BUFFER_STATE) 0;

	if ( b->ace_cc_yy_is_our_buffer )
		ace_cc_yy_flex_free( (void *) b->ace_cc_yy_ch_buf );

	ace_cc_yy_flex_free( (void *) b );
	}



#ifdef ACE_CC_YY_USE_PROTOS
void ace_cc_yy_init_buffer( ACE_CC_YY_BUFFER_STATE b, FILE *file )
#else
void ace_cc_yy_init_buffer( b, file )
ACE_CC_YY_BUFFER_STATE b;
FILE *file;
#endif


	{
	ace_cc_yy_flush_buffer( b );

	b->ace_cc_yy_input_file = file;
	b->ace_cc_yy_fill_buffer = 1;

#if ACE_CC_YY_ALWAYS_INTERACTIVE
	b->ace_cc_yy_is_interactive = 1;
#else
#if ACE_CC_YY_NEVER_INTERACTIVE
	b->ace_cc_yy_is_interactive = 0;
#else
	b->ace_cc_yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
#endif
#endif
	}


#ifdef ACE_CC_YY_USE_PROTOS
void ace_cc_yy_flush_buffer( ACE_CC_YY_BUFFER_STATE b )
#else
void ace_cc_yy_flush_buffer( b )
ACE_CC_YY_BUFFER_STATE b;
#endif

	{
	if ( ! b )
		return;

	b->ace_cc_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->ace_cc_yy_ch_buf[0] = ACE_CC_YY_END_OF_BUFFER_CHAR;
	b->ace_cc_yy_ch_buf[1] = ACE_CC_YY_END_OF_BUFFER_CHAR;

	b->ace_cc_yy_buf_pos = &b->ace_cc_yy_ch_buf[0];

	b->ace_cc_yy_at_bol = 1;
	b->ace_cc_yy_buffer_status = ACE_CC_YY_BUFFER_NEW;

	if ( b == ace_cc_yy_current_buffer )
		ace_cc_yy_load_buffer_state();
	}


#ifndef ACE_CC_YY_NO_SCAN_BUFFER
#ifdef ACE_CC_YY_USE_PROTOS
ACE_CC_YY_BUFFER_STATE ace_cc_yy_scan_buffer( char *base, ace_cc_yy_size_t size )
#else
ACE_CC_YY_BUFFER_STATE ace_cc_yy_scan_buffer( base, size )
char *base;
ace_cc_yy_size_t size;
#endif
	{
	ACE_CC_YY_BUFFER_STATE b;

	if ( size < 2 ||
	     base[size-2] != ACE_CC_YY_END_OF_BUFFER_CHAR ||
	     base[size-1] != ACE_CC_YY_END_OF_BUFFER_CHAR )
		/* They forgot to leave room for the EOB's. */
		return 0;

	b = (ACE_CC_YY_BUFFER_STATE) ace_cc_yy_flex_alloc( sizeof( struct ace_cc_yy_buffer_state ) );
	if ( ! b )
		ACE_CC_YY_FATAL_ERROR( "out of dynamic memory in ace_cc_yy_scan_buffer()" );

	b->ace_cc_yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
	b->ace_cc_yy_buf_pos = b->ace_cc_yy_ch_buf = base;
	b->ace_cc_yy_is_our_buffer = 0;
	b->ace_cc_yy_input_file = 0;
	b->ace_cc_yy_n_chars = b->ace_cc_yy_buf_size;
	b->ace_cc_yy_is_interactive = 0;
	b->ace_cc_yy_at_bol = 1;
	b->ace_cc_yy_fill_buffer = 0;
	b->ace_cc_yy_buffer_status = ACE_CC_YY_BUFFER_NEW;

	ace_cc_yy_switch_to_buffer( b );

	return b;
	}
#endif


#ifndef ACE_CC_YY_NO_SCAN_STRING
#ifdef ACE_CC_YY_USE_PROTOS
ACE_CC_YY_BUFFER_STATE ace_cc_yy_scan_string( ace_cc_yyconst char *ace_cc_yy_str )
#else
ACE_CC_YY_BUFFER_STATE ace_cc_yy_scan_string( ace_cc_yy_str )
ace_cc_yyconst char *ace_cc_yy_str;
#endif
	{
	int len;
	for ( len = 0; ace_cc_yy_str[len]; ++len )
		;

	return ace_cc_yy_scan_bytes( ace_cc_yy_str, len );
	}
#endif


#ifndef ACE_CC_YY_NO_SCAN_BYTES
#ifdef ACE_CC_YY_USE_PROTOS
ACE_CC_YY_BUFFER_STATE ace_cc_yy_scan_bytes( ace_cc_yyconst char *bytes, int len )
#else
ACE_CC_YY_BUFFER_STATE ace_cc_yy_scan_bytes( bytes, len )
ace_cc_yyconst char *bytes;
int len;
#endif
	{
	ACE_CC_YY_BUFFER_STATE b;
	char *buf;
	ace_cc_yy_size_t n;
	int i;

	/* Get memory for full buffer, including space for trailing EOB's. */
	n = len + 2;
	buf = (char *) ace_cc_yy_flex_alloc( n );
	if ( ! buf )
		ACE_CC_YY_FATAL_ERROR( "out of dynamic memory in ace_cc_yy_scan_bytes()" );

	for ( i = 0; i < len; ++i )
		buf[i] = bytes[i];

	buf[len] = buf[len+1] = ACE_CC_YY_END_OF_BUFFER_CHAR;

	b = ace_cc_yy_scan_buffer( buf, n );
	if ( ! b )
		ACE_CC_YY_FATAL_ERROR( "bad buffer in ace_cc_yy_scan_bytes()" );

	/* It's okay to grow etc. this buffer, and we should throw it
	 * away when we're done.
	 */
	b->ace_cc_yy_is_our_buffer = 1;

	return b;
	}
#endif


#ifndef ACE_CC_YY_NO_PUSH_STATE
#ifdef ACE_CC_YY_USE_PROTOS
static void ace_cc_yy_push_state( int new_state )
#else
static void ace_cc_yy_push_state( new_state )
int new_state;
#endif
	{
	if ( ace_cc_yy_start_stack_ptr >= ace_cc_yy_start_stack_depth )
		{
		ace_cc_yy_size_t new_size;

		ace_cc_yy_start_stack_depth += ACE_CC_YY_START_STACK_INCR;
		new_size = ace_cc_yy_start_stack_depth * sizeof( int );

		if ( ! ace_cc_yy_start_stack )
			ace_cc_yy_start_stack = (int *) ace_cc_yy_flex_alloc( new_size );

		else
			ace_cc_yy_start_stack = (int *) ace_cc_yy_flex_realloc(
					(void *) ace_cc_yy_start_stack, new_size );

		if ( ! ace_cc_yy_start_stack )
			ACE_CC_YY_FATAL_ERROR(
			"out of memory expanding start-condition stack" );
		}

	ace_cc_yy_start_stack[ace_cc_yy_start_stack_ptr++] = ACE_CC_YY_START;

	BEGIN(new_state);
	}
#endif


#ifndef ACE_CC_YY_NO_POP_STATE
static void ace_cc_yy_pop_state()
	{
	if ( --ace_cc_yy_start_stack_ptr < 0 )
		ACE_CC_YY_FATAL_ERROR( "start-condition stack underflow" );

	BEGIN(ace_cc_yy_start_stack[ace_cc_yy_start_stack_ptr]);
	}
#endif


#ifndef ACE_CC_YY_NO_TOP_STATE
static int ace_cc_yy_top_state()
	{
	return ace_cc_yy_start_stack[ace_cc_yy_start_stack_ptr - 1];
	}
#endif

#ifndef ACE_CC_YY_EXIT_FAILURE
#define ACE_CC_YY_EXIT_FAILURE 2
#endif

#ifdef ACE_CC_YY_USE_PROTOS
static void ace_cc_yy_fatal_error( ace_cc_yyconst char msg[] )
#else
static void ace_cc_yy_fatal_error( msg )
char msg[];
#endif
	{
	(void) fprintf( stderr, "%s\n", msg );
	exit( ACE_CC_YY_EXIT_FAILURE );
	}



/* Redefine ace_cc_yyless() so it works in section 3 code. */

#undef ace_cc_yyless
#define ace_cc_yyless(n) \
	do \
		{ \
		/* Undo effects of setting up ace_cc_yytext. */ \
		ace_cc_yytext[ace_cc_yyleng] = ace_cc_yy_hold_char; \
		ace_cc_yy_c_buf_p = ace_cc_yytext + n; \
		ace_cc_yy_hold_char = *ace_cc_yy_c_buf_p; \
		*ace_cc_yy_c_buf_p = '\0'; \
		ace_cc_yyleng = n; \
		} \
	while ( 0 )


/* Internal utility routines. */

#ifndef ace_cc_yytext_ptr
#ifdef ACE_CC_YY_USE_PROTOS
static void ace_cc_yy_flex_strncpy( char *s1, ace_cc_yyconst char *s2, int n )
#else
static void ace_cc_yy_flex_strncpy( s1, s2, n )
char *s1;
ace_cc_yyconst char *s2;
int n;
#endif
	{
	register int i;
	for ( i = 0; i < n; ++i )
		s1[i] = s2[i];
	}
#endif

#ifdef ACE_CC_YY_NEED_STRLEN
#ifdef ACE_CC_YY_USE_PROTOS
static int ace_cc_yy_flex_strlen( ace_cc_yyconst char *s )
#else
static int ace_cc_yy_flex_strlen( s )
ace_cc_yyconst char *s;
#endif
	{
	register int n;
	for ( n = 0; s[n]; ++n )
		;

	return n;
	}
#endif


#ifdef ACE_CC_YY_USE_PROTOS
static void *ace_cc_yy_flex_alloc( ace_cc_yy_size_t size )
#else
static void *ace_cc_yy_flex_alloc( size )
ace_cc_yy_size_t size;
#endif
	{
	return (void *) malloc( size );
	}

#ifdef ACE_CC_YY_USE_PROTOS
static void *ace_cc_yy_flex_realloc( void *ptr, ace_cc_yy_size_t size )
#else
static void *ace_cc_yy_flex_realloc( ptr, size )
void *ptr;
ace_cc_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 ACE_CC_YY_USE_PROTOS
static void ace_cc_yy_flex_free( void *ptr )
#else
static void ace_cc_yy_flex_free( ptr )
void *ptr;
#endif
	{
	free( ACE_MALLOC_T (ptr) );
	}

#if ACE_CC_YY_MAIN
int main()
	{
	ace_cc_yylex();
	return 0;
	}
#endif