Renamed YY_CURRENT_BUFFER_FAST to YY_CURRENT_BUFFER_LVALUE to better reflect

its purpose.

1 files changed, 48 insertions, 48 deletions

diff --git a/flex.skl b/flex.skl
index c4d70d1..0626a4d 100644
--- a/flex.skl
+++ b/flex.skl
@@ -414,7 +414,7 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /*<< Stack as an array. */
 /* Same as previous macro, but useful when we know that the buffer stack is not
  * NULL or when we need an lvalue. For internal use only.
  */
-#define YY_CURRENT_BUFFER_FAST YY_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)]
+#define YY_CURRENT_BUFFER_LVALUE YY_G(yy_buffer_stack)[YY_G(yy_buffer_stack_top)]
 
 %push
 %c-only Standard (non-C++) definition
@@ -472,23 +472,23 @@ void yyfree YY_PARAMS(( void * YY_PROTO_LAST_ARG ));
 	{ \
 	if ( ! YY_CURRENT_BUFFER ){ \
         yyensure_buffer_stack (YY_CALL_ONLY_ARG); \
-		YY_CURRENT_BUFFER_FAST =    \
+		YY_CURRENT_BUFFER_LVALUE =    \
             yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); \
 	} \
-	YY_CURRENT_BUFFER_FAST->yy_is_interactive = is_interactive; \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 	}
 
 #define yy_set_bol(at_bol) \
 	{ \
 	if ( ! YY_CURRENT_BUFFER ){\
         yyensure_buffer_stack (YY_CALL_ONLY_ARG); \
-		YY_CURRENT_BUFFER_FAST =    \
+		YY_CURRENT_BUFFER_LVALUE =    \
             yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG); \
 	} \
-	YY_CURRENT_BUFFER_FAST->yy_at_bol = at_bol; \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 	}
 
-#define YY_AT_BOL() (YY_CURRENT_BUFFER_FAST->yy_at_bol)
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 
 %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here
 
@@ -957,7 +957,7 @@ YY_DECL
 
 		if ( ! YY_CURRENT_BUFFER ) {
 			yyensure_buffer_stack (YY_CALL_ONLY_ARG);
-			YY_CURRENT_BUFFER_FAST =
+			YY_CURRENT_BUFFER_LVALUE =
 				yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG);
 		}
 
@@ -1003,7 +1003,7 @@ do_action:	/* This label is used only to access EOF actions. */
 		*yy_cp = YY_G(yy_hold_char);
 		YY_RESTORE_YY_MORE_OFFSET
 
-		if ( YY_CURRENT_BUFFER_FAST->yy_buffer_status == YY_BUFFER_NEW )
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 			{
 			/* We're scanning a new file or input source.  It's
 			 * possible that this happened because the user
@@ -1014,9 +1014,9 @@ do_action:	/* This label is used only to access EOF actions. */
 			 * this is the first action (other than possibly a
 			 * back-up) that will match for the new input source.
 			 */
-			YY_G(yy_n_chars) = YY_CURRENT_BUFFER_FAST->yy_n_chars;
-			YY_CURRENT_BUFFER_FAST->yy_input_file = yyin;
-			YY_CURRENT_BUFFER_FAST->yy_buffer_status = YY_BUFFER_NORMAL;
+			YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 			}
 
 		/* Note that here we test for yy_c_buf_p "<=" to the position
@@ -1026,7 +1026,7 @@ do_action:	/* This label is used only to access EOF actions. */
 		 * end-of-buffer state).  Contrast this with the test
 		 * in input().
 		 */
-		if ( YY_G(yy_c_buf_p) <= &YY_CURRENT_BUFFER_FAST->yy_ch_buf[YY_G(yy_n_chars)] )
+		if ( YY_G(yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] )
 			{ /* This was really a NUL. */
 			yy_state_type yy_next_state;
 
@@ -1105,7 +1105,7 @@ do_action:	/* This label is used only to access EOF actions. */
 
 			case EOB_ACT_LAST_MATCH:
 				YY_G(yy_c_buf_p) =
-				&YY_CURRENT_BUFFER_FAST->yy_ch_buf[YY_G(yy_n_chars)];
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)];
 
 				yy_current_state = yy_get_previous_state( YY_CALL_ONLY_ARG );
 
@@ -1228,16 +1228,16 @@ static int yy_get_next_buffer YYFARGS0(void)
 int yyFlexLexer::yy_get_next_buffer()
 %pop
 	{
-	register char *dest = YY_CURRENT_BUFFER_FAST->yy_ch_buf;
+	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
 	register char *source = YY_G(yytext_ptr);
 	register int number_to_move, i;
 	int ret_val;
 
-	if ( YY_G(yy_c_buf_p) > &YY_CURRENT_BUFFER_FAST->yy_ch_buf[YY_G(yy_n_chars) + 1] )
+	if ( YY_G(yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] )
 		YY_FATAL_ERROR(
 		"fatal flex scanner internal error--end of buffer missed" );
 
-	if ( YY_CURRENT_BUFFER_FAST->yy_fill_buffer == 0 )
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
 		{ /* Don't try to fill the buffer, so this is an EOF. */
 		if ( YY_G(yy_c_buf_p) - YY_G(yytext_ptr) - YY_MORE_ADJ == 1 )
 			{
@@ -1264,16 +1264,16 @@ int yyFlexLexer::yy_get_next_buffer()
 	for ( i = 0; i < number_to_move; ++i )
 		*(dest++) = *(source++);
 
-	if ( YY_CURRENT_BUFFER_FAST->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
 		/* don't do the read, it's not guaranteed to return an EOF,
 		 * just force an EOF
 		 */
-		YY_CURRENT_BUFFER_FAST->yy_n_chars = YY_G(yy_n_chars) = 0;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars) = 0;
 
 	else
 		{
 			size_t num_to_read =
-			YY_CURRENT_BUFFER_FAST->yy_buf_size - number_to_move - 1;
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 
 		while ( num_to_read <= 0 )
 			{ /* Not enough room in the buffer - grow it. */
@@ -1312,7 +1312,7 @@ int yyFlexLexer::yy_get_next_buffer()
 
 			YY_G(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
 
-			num_to_read = YY_CURRENT_BUFFER_FAST->yy_buf_size -
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
 						number_to_move - 1;
 #endif
 			}
@@ -1321,10 +1321,10 @@ int yyFlexLexer::yy_get_next_buffer()
 			num_to_read = YY_READ_BUF_SIZE;
 
 		/* Read in more data. */
-		YY_INPUT( (&YY_CURRENT_BUFFER_FAST->yy_ch_buf[number_to_move]),
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
 			YY_G(yy_n_chars), num_to_read );
 
-		YY_CURRENT_BUFFER_FAST->yy_n_chars = YY_G(yy_n_chars);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
 		}
 
 	if ( YY_G(yy_n_chars) == 0 )
@@ -1338,7 +1338,7 @@ int yyFlexLexer::yy_get_next_buffer()
 		else
 			{
 			ret_val = EOB_ACT_LAST_MATCH;
-			YY_CURRENT_BUFFER_FAST->yy_buffer_status =
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
 				YY_BUFFER_EOF_PENDING;
 			}
 		}
@@ -1347,10 +1347,10 @@ int yyFlexLexer::yy_get_next_buffer()
 		ret_val = EOB_ACT_CONTINUE_SCAN;
 
 	YY_G(yy_n_chars) += number_to_move;
-	YY_CURRENT_BUFFER_FAST->yy_ch_buf[YY_G(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
-	YY_CURRENT_BUFFER_FAST->yy_ch_buf[YY_G(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
 
-	YY_G(yytext_ptr) = &YY_CURRENT_BUFFER_FAST->yy_ch_buf[0];
+	YY_G(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 
 	return ret_val;
 	}
@@ -1412,24 +1412,24 @@ int yyFlexLexer::yy_get_next_buffer()
 	/* undo effects of setting up yytext */
 	*yy_cp = YY_G(yy_hold_char);
 
-	if ( yy_cp < YY_CURRENT_BUFFER_FAST->yy_ch_buf + 2 )
+	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 		{ /* need to shift things up to make room */
 		/* +2 for EOB chars. */
 		register int number_to_move = YY_G(yy_n_chars) + 2;
-		register char *dest = &YY_CURRENT_BUFFER_FAST->yy_ch_buf[
-					YY_CURRENT_BUFFER_FAST->yy_buf_size + 2];
+		register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
 		register char *source =
-				&YY_CURRENT_BUFFER_FAST->yy_ch_buf[number_to_move];
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
 
-		while ( source > YY_CURRENT_BUFFER_FAST->yy_ch_buf )
+		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
 			*--dest = *--source;
 
 		yy_cp += (int) (dest - source);
 		yy_bp += (int) (dest - source);
-		YY_CURRENT_BUFFER_FAST->yy_n_chars =
-			YY_G(yy_n_chars) = YY_CURRENT_BUFFER_FAST->yy_buf_size;
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+			YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
 
-		if ( yy_cp < YY_CURRENT_BUFFER_FAST->yy_ch_buf + 2 )
+		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 			YY_FATAL_ERROR( "flex scanner push-back overflow" );
 		}
 
@@ -1473,7 +1473,7 @@ int yyFlexLexer::yy_get_next_buffer()
 		 * 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_G(yy_c_buf_p) < &YY_CURRENT_BUFFER_FAST->yy_ch_buf[YY_G(yy_n_chars)] )
+		if ( YY_G(yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_G(yy_n_chars)] )
 			/* This was really a NUL. */
 			*YY_G(yy_c_buf_p) = '\0';
 
@@ -1543,7 +1543,7 @@ int yyFlexLexer::yy_get_next_buffer()
 	{
 	if ( ! YY_CURRENT_BUFFER ){
         yyensure_buffer_stack (YY_CALL_ONLY_ARG);
-		YY_CURRENT_BUFFER_FAST =
+		YY_CURRENT_BUFFER_LVALUE =
             yy_create_buffer( yyin, YY_BUF_SIZE YY_CALL_LAST_ARG);
 	}
 
@@ -1571,11 +1571,11 @@ int yyFlexLexer::yy_get_next_buffer()
 		{
 		/* Flush out information for old buffer. */
 		*YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
-		YY_CURRENT_BUFFER_FAST->yy_buf_pos = YY_G(yy_c_buf_p);
-		YY_CURRENT_BUFFER_FAST->yy_n_chars = YY_G(yy_n_chars);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
 		}
 
-	YY_CURRENT_BUFFER_FAST = new_buffer;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
 	yy_load_buffer_state( YY_CALL_ONLY_ARG );
 
 	/* We don't actually know whether we did this switch during
@@ -1594,9 +1594,9 @@ int yyFlexLexer::yy_get_next_buffer()
     void yyFlexLexer::yy_load_buffer_state()
 %pop
 	{
-	YY_G(yy_n_chars) = YY_CURRENT_BUFFER_FAST->yy_n_chars;
-	YY_G(yytext_ptr) = YY_G(yy_c_buf_p) = YY_CURRENT_BUFFER_FAST->yy_buf_pos;
-	yyin = YY_CURRENT_BUFFER_FAST->yy_input_file;
+	YY_G(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	YY_G(yytext_ptr) = YY_G(yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
 	YY_G(yy_hold_char) = *YY_G(yy_c_buf_p);
 	}
 
@@ -1640,7 +1640,7 @@ int yyFlexLexer::yy_get_next_buffer()
 		return;
 
 	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
-		YY_CURRENT_BUFFER_FAST = (YY_BUFFER_STATE) 0;
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 
 	if ( b->yy_is_our_buffer )
 		yyfree( (void *) b->yy_ch_buf YY_CALL_LAST_ARG );
@@ -1741,14 +1741,14 @@ void yypush_buffer_state YYFARGS1(YY_BUFFER_STATE,new_buffer)
 		{
 		/* Flush out information for old buffer. */
 		*YY_G(yy_c_buf_p) = YY_G(yy_hold_char);
-		YY_CURRENT_BUFFER_FAST->yy_buf_pos = YY_G(yy_c_buf_p);
-		YY_CURRENT_BUFFER_FAST->yy_n_chars = YY_G(yy_n_chars);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = YY_G(yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = YY_G(yy_n_chars);
 		}
 
 	/* Only push if top exists. Otherwise, replace top. */
 	if (YY_CURRENT_BUFFER)
 		YY_G(yy_buffer_stack_top)++;
-	YY_CURRENT_BUFFER_FAST = new_buffer;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
 
 	/* copied from yy_switch_to_buffer. */
 	yy_load_buffer_state( YY_CALL_ONLY_ARG );
@@ -1767,7 +1767,7 @@ void yypop_buffer_state YYFARGS0(void)
 		return;
 
 	yy_delete_buffer(YY_CURRENT_BUFFER YY_CALL_LAST_ARG);
-	YY_CURRENT_BUFFER_FAST = NULL;
+	YY_CURRENT_BUFFER_LVALUE = NULL;
 	if (YY_G(yy_buffer_stack_top) > 0)
 		--YY_G(yy_buffer_stack_top);
 
@@ -2232,7 +2232,7 @@ int yylex_destroy  YYFARGS0(void)
     /* Pop the buffer stack, destroying each element. */
 	while(YY_CURRENT_BUFFER){
 		yy_delete_buffer( YY_CURRENT_BUFFER YY_CALL_LAST_ARG );
-		YY_CURRENT_BUFFER_FAST = NULL;
+		YY_CURRENT_BUFFER_LVALUE = NULL;
 		yypop_buffer_state(YY_CALL_ONLY_ARG);
 	}