guc-file.c

PostgreSQL 8.1.4的源码 适用于Linux下的开源数据库系统

					/* Include room in for 2 EOB chars. */
					GUC_yy_flex_realloc( (void *) b->GUC_yy_ch_buf,
							 b->GUC_yy_buf_size + 2 );
				}
			else
				/* Can't grow it, we don't own it. */
				b->GUC_yy_ch_buf = 0;

			if ( ! b->GUC_yy_ch_buf )
				YY_FATAL_ERROR(
				"fatal error - scanner input buffer overflow" );

			GUC_yy_c_buf_p = &b->GUC_yy_ch_buf[GUC_yy_c_buf_p_offset];

			num_to_read = GUC_yy_current_buffer->GUC_yy_buf_size -
						number_to_move - 1;
#endif
			}

		if ( num_to_read > YY_READ_BUF_SIZE )
			num_to_read = YY_READ_BUF_SIZE;

		/* Read in more data. */
		YY_INPUT( (&GUC_yy_current_buffer->GUC_yy_ch_buf[number_to_move]),
			GUC_yy_n_chars, num_to_read );

		GUC_yy_current_buffer->GUC_yy_n_chars = GUC_yy_n_chars;
		}

	if ( GUC_yy_n_chars == 0 )
		{
		if ( number_to_move == YY_MORE_ADJ )
			{
			ret_val = EOB_ACT_END_OF_FILE;
			GUC_yyrestart( GUC_yyin );
			}

		else
			{
			ret_val = EOB_ACT_LAST_MATCH;
			GUC_yy_current_buffer->GUC_yy_buffer_status =
				YY_BUFFER_EOF_PENDING;
			}
		}

	else
		ret_val = EOB_ACT_CONTINUE_SCAN;

	GUC_yy_n_chars += number_to_move;
	GUC_yy_current_buffer->GUC_yy_ch_buf[GUC_yy_n_chars] = YY_END_OF_BUFFER_CHAR;
	GUC_yy_current_buffer->GUC_yy_ch_buf[GUC_yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

	GUC_yytext_ptr = &GUC_yy_current_buffer->GUC_yy_ch_buf[0];

	return ret_val;
	}


/* GUC_yy_get_previous_state - get the state just before the EOB char was reached */

static GUC_yy_state_type GUC_yy_get_previous_state()
	{
	register GUC_yy_state_type GUC_yy_current_state;
	register char *GUC_yy_cp;

	GUC_yy_current_state = GUC_yy_start;

	for ( GUC_yy_cp = GUC_yytext_ptr + YY_MORE_ADJ; GUC_yy_cp < GUC_yy_c_buf_p; ++GUC_yy_cp )
		{
		register YY_CHAR GUC_yy_c = (*GUC_yy_cp ? GUC_yy_ec[YY_SC_TO_UI(*GUC_yy_cp)] : 1);
		if ( GUC_yy_accept[GUC_yy_current_state] )
			{
			GUC_yy_last_accepting_state = GUC_yy_current_state;
			GUC_yy_last_accepting_cpos = GUC_yy_cp;
			}
		while ( GUC_yy_chk[GUC_yy_base[GUC_yy_current_state] + GUC_yy_c] != GUC_yy_current_state )
			{
			GUC_yy_current_state = (int) GUC_yy_def[GUC_yy_current_state];
			if ( GUC_yy_current_state >= 39 )
				GUC_yy_c = GUC_yy_meta[(unsigned int) GUC_yy_c];
			}
		GUC_yy_current_state = GUC_yy_nxt[GUC_yy_base[GUC_yy_current_state] + (unsigned int) GUC_yy_c];
		}

	return GUC_yy_current_state;
	}


/* GUC_yy_try_NUL_trans - try to make a transition on the NUL character
 *
 * synopsis
 *	next_state = GUC_yy_try_NUL_trans( current_state );
 */

#ifdef YY_USE_PROTOS
static GUC_yy_state_type GUC_yy_try_NUL_trans( GUC_yy_state_type GUC_yy_current_state )
#else
static GUC_yy_state_type GUC_yy_try_NUL_trans( GUC_yy_current_state )
GUC_yy_state_type GUC_yy_current_state;
#endif
	{
	register int GUC_yy_is_jam;
	register char *GUC_yy_cp = GUC_yy_c_buf_p;

	register YY_CHAR GUC_yy_c = 1;
	if ( GUC_yy_accept[GUC_yy_current_state] )
		{
		GUC_yy_last_accepting_state = GUC_yy_current_state;
		GUC_yy_last_accepting_cpos = GUC_yy_cp;
		}
	while ( GUC_yy_chk[GUC_yy_base[GUC_yy_current_state] + GUC_yy_c] != GUC_yy_current_state )
		{
		GUC_yy_current_state = (int) GUC_yy_def[GUC_yy_current_state];
		if ( GUC_yy_current_state >= 39 )
			GUC_yy_c = GUC_yy_meta[(unsigned int) GUC_yy_c];
		}
	GUC_yy_current_state = GUC_yy_nxt[GUC_yy_base[GUC_yy_current_state] + (unsigned int) GUC_yy_c];
	GUC_yy_is_jam = (GUC_yy_current_state == 38);

	return GUC_yy_is_jam ? 0 : GUC_yy_current_state;
	}


#ifndef YY_NO_UNPUT
#ifdef YY_USE_PROTOS
static void GUC_yyunput( int c, register char *GUC_yy_bp )
#else
static void GUC_yyunput( c, GUC_yy_bp )
int c;
register char *GUC_yy_bp;
#endif
	{
	register char *GUC_yy_cp = GUC_yy_c_buf_p;

	/* undo effects of setting up GUC_yytext */
	*GUC_yy_cp = GUC_yy_hold_char;

	if ( GUC_yy_cp < GUC_yy_current_buffer->GUC_yy_ch_buf + 2 )
		{ /* need to shift things up to make room */
		/* +2 for EOB chars. */
		register int number_to_move = GUC_yy_n_chars + 2;
		register char *dest = &GUC_yy_current_buffer->GUC_yy_ch_buf[
					GUC_yy_current_buffer->GUC_yy_buf_size + 2];
		register char *source =
				&GUC_yy_current_buffer->GUC_yy_ch_buf[number_to_move];

		while ( source > GUC_yy_current_buffer->GUC_yy_ch_buf )
			*--dest = *--source;

		GUC_yy_cp += (int) (dest - source);
		GUC_yy_bp += (int) (dest - source);
		GUC_yy_current_buffer->GUC_yy_n_chars =
			GUC_yy_n_chars = GUC_yy_current_buffer->GUC_yy_buf_size;

		if ( GUC_yy_cp < GUC_yy_current_buffer->GUC_yy_ch_buf + 2 )
			YY_FATAL_ERROR( "flex scanner push-back overflow" );
		}

	*--GUC_yy_cp = (char) c;


	GUC_yytext_ptr = GUC_yy_bp;
	GUC_yy_hold_char = *GUC_yy_cp;
	GUC_yy_c_buf_p = GUC_yy_cp;
	}
#endif	/* ifndef YY_NO_UNPUT */


#ifdef __cplusplus
static int GUC_yyinput()
#else
static int input()
#endif
	{
	int c;

	*GUC_yy_c_buf_p = GUC_yy_hold_char;

	if ( *GUC_yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
		{
		/* GUC_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 ( GUC_yy_c_buf_p < &GUC_yy_current_buffer->GUC_yy_ch_buf[GUC_yy_n_chars] )
			/* This was really a NUL. */
			*GUC_yy_c_buf_p = '\0';

		else
			{ /* need more input */
			int offset = GUC_yy_c_buf_p - GUC_yytext_ptr;
			++GUC_yy_c_buf_p;

			switch ( GUC_yy_get_next_buffer() )
				{
				case EOB_ACT_LAST_MATCH:
					/* This happens because GUC_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. */
					GUC_yyrestart( GUC_yyin );

					/* fall through */

				case EOB_ACT_END_OF_FILE:
					{
					if ( GUC_yywrap() )
						return EOF;

					if ( ! GUC_yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
#ifdef __cplusplus
					return GUC_yyinput();
#else
					return input();
#endif
					}

				case EOB_ACT_CONTINUE_SCAN:
					GUC_yy_c_buf_p = GUC_yytext_ptr + offset;
					break;
				}
			}
		}

	c = *(unsigned char *) GUC_yy_c_buf_p;	/* cast for 8-bit char's */
	*GUC_yy_c_buf_p = '\0';	/* preserve GUC_yytext */
	GUC_yy_hold_char = *++GUC_yy_c_buf_p;


	return c;
	}


#ifdef YY_USE_PROTOS
void GUC_yyrestart( FILE *input_file )
#else
void GUC_yyrestart( input_file )
FILE *input_file;
#endif
	{
	if ( ! GUC_yy_current_buffer )
		GUC_yy_current_buffer = GUC_yy_create_buffer( GUC_yyin, YY_BUF_SIZE );

	GUC_yy_init_buffer( GUC_yy_current_buffer, input_file );
	GUC_yy_load_buffer_state();
	}


#ifdef YY_USE_PROTOS
void GUC_yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
#else
void GUC_yy_switch_to_buffer( new_buffer )
YY_BUFFER_STATE new_buffer;
#endif
	{
	if ( GUC_yy_current_buffer == new_buffer )
		return;

	if ( GUC_yy_current_buffer )
		{
		/* Flush out information for old buffer. */
		*GUC_yy_c_buf_p = GUC_yy_hold_char;
		GUC_yy_current_buffer->GUC_yy_buf_pos = GUC_yy_c_buf_p;
		GUC_yy_current_buffer->GUC_yy_n_chars = GUC_yy_n_chars;
		}

	GUC_yy_current_buffer = new_buffer;
	GUC_yy_load_buffer_state();

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


#ifdef YY_USE_PROTOS
void GUC_yy_load_buffer_state( void )
#else
void GUC_yy_load_buffer_state()
#endif
	{
	GUC_yy_n_chars = GUC_yy_current_buffer->GUC_yy_n_chars;
	GUC_yytext_ptr = GUC_yy_c_buf_p = GUC_yy_current_buffer->GUC_yy_buf_pos;
	GUC_yyin = GUC_yy_current_buffer->GUC_yy_input_file;
	GUC_yy_hold_char = *GUC_yy_c_buf_p;
	}


#ifdef YY_USE_PROTOS
YY_BUFFER_STATE GUC_yy_create_buffer( FILE *file, int size )
#else
YY_BUFFER_STATE GUC_yy_create_buffer( file, size )
FILE *file;
int size;
#endif
	{
	YY_BUFFER_STATE b;

	b = (YY_BUFFER_STATE) GUC_yy_flex_alloc( sizeof( struct GUC_yy_buffer_state ) );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in GUC_yy_create_buffer()" );

	b->GUC_yy_buf_size = size;

	/* GUC_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->GUC_yy_ch_buf = (char *) GUC_yy_flex_alloc( b->GUC_yy_buf_size + 2 );
	if ( ! b->GUC_yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in GUC_yy_create_buffer()" );

	b->GUC_yy_is_our_buffer = 1;

	GUC_yy_init_buffer( b, file );

	return b;
	}


#ifdef YY_USE_PROTOS
void GUC_yy_delete_buffer( YY_BUFFER_STATE b )
#else
void GUC_yy_delete_buffer( b )
YY_BUFFER_STATE b;
#endif
	{
	if ( ! b )
		return;

	if ( b == GUC_yy_current_buffer )
		GUC_yy_current_buffer = (YY_BUFFER_STATE) 0;

	if ( b->GUC_yy_is_our_buffer )
		GUC_yy_flex_free( (void *) b->GUC_yy_ch_buf );

	GUC_yy_flex_free( (void *) b );
	}


#ifndef YY_ALWAYS_INTERACTIVE
#ifndef YY_NEVER_INTERACTIVE
extern int isatty YY_PROTO(( int ));
#endif
#endif

#ifdef YY_USE_PROTOS
void GUC_yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
#else
void GUC_yy_init_buffer( b, file )
YY_BUFFER_STATE b;
FILE *file;
#endif


	{
	GUC_yy_flush_buffer( b );

	b->GUC_yy_input_file = file;
	b->GUC_yy_fill_buffer = 1;

#if YY_ALWAYS_INTERACTIVE
	b->GUC_yy_is_interactive = 1;
#else
#if YY_NEVER_INTERACTIVE
	b->GUC_yy_is_interactive = 0;
#else
	b->GUC_yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
#endif
#endif
	}


#ifdef YY_USE_PROTOS
void GUC_yy_flush_buffer( YY_BUFFER_STATE b )
#else
void GUC_yy_flush_buffer( b )
YY_BUFFER_STATE b;
#endif

	{
	if ( ! b )
		return;

	b->GUC_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->GUC_yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->GUC_yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->GUC_yy_buf_pos = &b->GUC_yy_ch_buf[0];

	b->GUC_yy_at_bol = 1;
	b->GUC_yy_buffer_status = YY_BUFFER_NEW;

	if ( b == GUC_yy_current_buffer )
		GUC_yy_load_buffer_state();
	}


#ifndef YY_NO_SCAN_BUFFER
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE GUC_yy_scan_buffer( char *base, GUC_yy_size_t size )
#else
YY_BUFFER_STATE GUC_yy_scan_buffer( base, size )
char *base;
GUC_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) GUC_yy_flex_alloc( sizeof( struct GUC_yy_buffer_state ) );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in GUC_yy_scan_buffer()" );

	b->GUC_yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
	b->GUC_yy_buf_pos = b->GUC_yy_ch_buf = base;
	b->GUC_yy_is_our_buffer = 0;
	b->GUC_yy_input_file = 0;
	b->GUC_yy_n_chars = b->GUC_yy_buf_size;
	b->GUC_yy_is_interactive = 0;
	b->GUC_yy_at_bol = 1;
	b->GUC_yy_fill_buffer = 0;
	b->GUC_yy_buffer_status = YY_BUFFER_NEW;

	GUC_yy_switch_to_buffer( b );

	return b;
	}
#endif


#ifndef YY_NO_SCAN_STRING
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE GUC_yy_scan_string( GUC_yyconst char *GUC_yy_str )
#else
YY_BUFFER_STATE GUC_yy_scan_string( GUC_yy_str )
GUC_yyconst char *GUC_yy_str;
#endif
	{
	int len;
	for ( len = 0; GUC_yy_str[len]; ++len )
		;

	return GUC_yy_scan_bytes( GUC_yy_str, len );
	}
#endif


#ifndef YY_NO_SCAN_BYTES
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE GUC_yy_scan_bytes( GUC_yyconst char *bytes, int len )
#else
YY_BUFFER_STATE GUC_yy_scan_bytes( bytes, len )
GUC_yyconst char *bytes;
int len;
#endif
	{
	YY_BUFFER_STATE b;