*/
int yy_is_interactive;
+ /* Whether we're considered to be at the beginning of a line.
+ * If so, '^' rules will be active on the next match, otherwise
+ * not.
+ */
+ int yy_at_bol;
+
/* Whether to try to fill the input buffer when we reach the
* end of it.
*/
void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
void yy_load_buffer_state YY_PROTO(( void ));
YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
-YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, char *start,
- yy_size_t size ));
+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
YY_BUFFER_STATE yy_scan_string YY_PROTO(( const char *str ));
YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( const char *bytes, int len ));
void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
yy_current_buffer->yy_is_interactive = is_interactive; \
}
+#define yy_set_bol(at_bol) \
+ { \
+ if ( ! yy_current_buffer ) \
+ yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+ yy_current_buffer->yy_at_bol = at_bol; \
+ }
+
+#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+
%% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here
#ifndef yywrap
#define YY_BREAK break;
#endif
+%% YY_RULE_SETUP definition goes here
+
YY_DECL
{
register yy_state_type yy_current_state;
YY_DO_BEFORE_ACTION;
-%% code for yylineno update goes here, if -l option
+%% code for yylineno update (if -l) goes here
do_action: /* This label is used only to access EOF actions. */
case YY_END_OF_BUFFER:
{
/* Amount of text matched not including the EOB char. */
- int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;
+ int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
/* Undo the effects of YY_DO_BEFORE_ACTION. */
*yy_cp = yy_hold_char;
%*
{
register char *dest = yy_current_buffer->yy_ch_buf;
- register char *source = yytext_ptr - 1; /* copy prev. char, too */
+ register char *source = yytext_ptr;
register int number_to_move, i;
int ret_val;
/* Try to read more data. */
/* First move last chars to start of buffer. */
- number_to_move = yy_c_buf_p - yytext_ptr;
+ number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
for ( i = 0; i < number_to_move; ++i )
*(dest++) = *(source++);
/* just a shorter name for the current buffer */
YY_BUFFER_STATE b = yy_current_buffer;
- int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;
+ int yy_c_buf_p_offset =
+ (int) (yy_c_buf_p - b->yy_ch_buf);
if ( b->yy_is_our_buffer )
{
- b->yy_buf_size *= 2;
+ int new_size = b->yy_buf_size * 2;
+
+ if ( new_size <= 0 )
+ b->yy_buf_size += b->yy_buf_size / 8;
+ else
+ b->yy_buf_size *= 2;
+
b->yy_ch_buf = (char *)
+ /* Include room in for 2 EOB chars. */
yy_flex_realloc( (void *) b->yy_ch_buf,
- b->yy_buf_size );
+ b->yy_buf_size + 2 );
}
else
/* Can't grow it, we don't own it. */
if ( yy_n_chars == 0 )
{
- if ( number_to_move - YY_MORE_ADJ == 1 )
+ if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
yyrestart( yyin );
yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
- /* yytext begins at the second character in yy_ch_buf; the first
- * character is the one which preceded it before reading in the latest
- * buffer; it needs to be kept around in case it's a newline, so
- * yy_get_previous_state() will have with '^' rules active.
- */
-
- yytext_ptr = &yy_current_buffer->yy_ch_buf[1];
+ yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
return ret_val;
}
while ( source > yy_current_buffer->yy_ch_buf )
*--dest = *--source;
- yy_cp += dest - source;
- yy_bp += dest - source;
+ yy_cp += (int) (dest - source);
+ yy_bp += (int) (dest - source);
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" );
}
- if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
- yy_cp[-2] = '\n';
-
*--yy_cp = (char) c;
%% update yylineno here, if doing -l
return EOF;
}
- YY_NEW_FILE;
+ if ( ! yy_did_buffer_switch_on_eof )
+ YY_NEW_FILE;
#ifdef __cplusplus
return yyinput();
#else
*yy_c_buf_p = '\0'; /* preserve yytext */
yy_hold_char = *++yy_c_buf_p;
+%% update yylineno here, if doing -l
+
return c;
}
%*
{
b->yy_input_file = file;
-
- /* We put in the '\n' and start reading from [1] so that an
- * initial match-at-newline will be true.
- */
-
- b->yy_ch_buf[0] = '\n';
- b->yy_n_chars = 1;
+ 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_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
- b->yy_buf_pos = &b->yy_ch_buf[1];
+ b->yy_buf_pos = &b->yy_ch_buf[0];
%-
#if YY_ALWAYS_INTERACTIVE
b->yy_is_interactive = 0;
%*
+ b->yy_at_bol = 1;
b->yy_fill_buffer = 1;
b->yy_buffer_status = YY_BUFFER_NEW;
#ifndef YY_NO_SCAN_BUFFER
%-
#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_scan_buffer( char *base, char *start, yy_size_t size )
+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
#else
-YY_BUFFER_STATE yy_scan_buffer( base, start, size )
-char *base, *start;
+YY_BUFFER_STATE yy_scan_buffer( base, size )
+char *base;
yy_size_t size;
#endif
{
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_ch_buf = base;
- b->yy_buf_pos = start;
+ 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_size_t n;
int i;
- /* Get memory for full buffer, including space for preceding '\n'
- * and trailing EOB's.
- */
- n = len + 3;
+ /* 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()" );
- buf[0] = '\n';
for ( i = 0; i < len; ++i )
- buf[i+1] = bytes[i];
+ buf[i] = bytes[i];
- buf[len+1] = buf[len+2] = YY_END_OF_BUFFER_CHAR;
+ buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
- b = yy_scan_buffer( buf, &buf[1], n );
+ b = yy_scan_buffer( buf, n );
if ( ! b )
YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
projects / flex / commitdiff