Renamed YY_CURRENT_BUFFER_FAST to YY_CURRENT_BUFFER_LVALUE to better reflect

its purpose.

diff --git a/flex.skl b/flex.skl
index c4d70d10fd3d32478924df3acfc46825307640aa..0626a4d348df560766f861a4d4c71bd465011852 100644 (file)
--- 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);
        }