BUG: Character + should be valid in a variable name.
This commit is contained in:
Brad King
parent
cba6306b86
commit
97c97730a6
@ -1,7 +1,6 @@
|
||||
#include "cmStandardIncludes.h"
|
||||
|
||||
|
||||
#line 2 "cmCommandArgumentLexer.cxx"
|
||||
|
||||
#line 4 "cmCommandArgumentLexer.cxx"
|
||||
|
||||
#define YY_INT_ALIGNED short int
|
||||
|
||||
@ -10,7 +9,7 @@
|
||||
#define FLEX_SCANNER
|
||||
#define YY_FLEX_MAJOR_VERSION 2
|
||||
#define YY_FLEX_MINOR_VERSION 5
|
||||
#define YY_FLEX_SUBMINOR_VERSION 31
|
||||
#define YY_FLEX_SUBMINOR_VERSION 33
|
||||
#if YY_FLEX_SUBMINOR_VERSION > 0
|
||||
#define FLEX_BETA
|
||||
#endif
|
||||
@ -32,7 +31,15 @@
|
||||
|
||||
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
|
||||
|
||||
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
|
||||
#if __STDC_VERSION__ >= 199901L
|
||||
|
||||
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
|
||||
* if you want the limit (max/min) macros for int types.
|
||||
*/
|
||||
#ifndef __STDC_LIMIT_MACROS
|
||||
#define __STDC_LIMIT_MACROS 1
|
||||
#endif
|
||||
|
||||
#include <inttypes.h>
|
||||
typedef int8_t flex_int8_t;
|
||||
typedef uint8_t flex_uint8_t;
|
||||
@ -155,6 +162,10 @@ int cmCommandArgument_yylex_init (yyscan_t* scanner);
|
||||
#define YY_BUF_SIZE 16384
|
||||
#endif
|
||||
|
||||
/* The state buf must be large enough to hold one state per character in the main buffer.
|
||||
*/
|
||||
#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
|
||||
|
||||
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
|
||||
#define YY_TYPEDEF_YY_BUFFER_STATE
|
||||
typedef struct yy_buffer_state *YY_BUFFER_STATE;
|
||||
@ -166,8 +177,7 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
|
||||
|
||||
#define YY_LESS_LINENO(n)
|
||||
|
||||
/* Return all but the first "n" matched characters back to the input
|
||||
stream. */
|
||||
/* Return all but the first "n" matched characters back to the input stream. */
|
||||
#define yyless(n) \
|
||||
do \
|
||||
{ \
|
||||
@ -181,6 +191,8 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
|
||||
} \
|
||||
while ( 0 )
|
||||
|
||||
#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
|
||||
|
||||
/* The following is because we cannot portably get our hands on size_t
|
||||
* (without autoconf's help, which isn't available because we want
|
||||
* flex-generated scanners to compile on their own).
|
||||
@ -247,9 +259,9 @@ struct yy_buffer_state
|
||||
* still have a bunch of tokens to match, though, because of
|
||||
* possible backing-up.
|
||||
*
|
||||
* When we actually see the EOF, we change the status to "new" (via
|
||||
* cmCommandArgument_yyrestart()), so that the user can continue scanning
|
||||
* by just pointing yyin at a new input file.
|
||||
* When we actually see the EOF, we change the status to "new"
|
||||
* (via cmCommandArgument_yyrestart()), so that the user can continue scanning by
|
||||
* just pointing yyin at a new input file.
|
||||
*/
|
||||
#define YY_BUFFER_EOF_PENDING 2
|
||||
|
||||
@ -266,29 +278,22 @@ struct yy_buffer_state
|
||||
? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
|
||||
: NULL)
|
||||
|
||||
/* 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.
|
||||
/* 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_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
|
||||
|
||||
void cmCommandArgument_yyrestart (FILE *input_file ,yyscan_t yyscanner );
|
||||
void cmCommandArgument_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,
|
||||
yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE cmCommandArgument_yy_create_buffer (FILE *file,int size ,
|
||||
yyscan_t yyscanner );
|
||||
void cmCommandArgument_yy_delete_buffer (YY_BUFFER_STATE b ,
|
||||
yyscan_t yyscanner );
|
||||
void cmCommandArgument_yy_flush_buffer (YY_BUFFER_STATE b ,
|
||||
yyscan_t yyscanner );
|
||||
void cmCommandArgument_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,
|
||||
yyscan_t yyscanner );
|
||||
void cmCommandArgument_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE cmCommandArgument_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
|
||||
void cmCommandArgument_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
|
||||
void cmCommandArgument_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
|
||||
void cmCommandArgument_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
|
||||
void cmCommandArgument_yypop_buffer_state (yyscan_t yyscanner );
|
||||
|
||||
static void cmCommandArgument_yyensure_buffer_stack (yyscan_t yyscanner );
|
||||
static void cmCommandArgument_yy_load_buffer_state (yyscan_t yyscanner );
|
||||
static void cmCommandArgument_yy_init_buffer (YY_BUFFER_STATE b,
|
||||
FILE *file ,
|
||||
yyscan_t yyscanner );
|
||||
static void cmCommandArgument_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
|
||||
|
||||
#define YY_FLUSH_BUFFER cmCommandArgument_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
|
||||
|
||||
@ -371,7 +376,7 @@ static yyconst flex_int32_t yy_ec[256] =
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 3, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 4, 4, 4, 4, 4, 4,
|
||||
1, 1, 4, 1, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 1, 1, 1,
|
||||
1, 1, 1, 5, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
@ -437,8 +442,8 @@ static yyconst flex_int16_t yy_chk[30] =
|
||||
#define yymore() yymore_used_but_not_detected
|
||||
#define YY_MORE_ADJ 0
|
||||
#define YY_RESTORE_YY_MORE_OFFSET
|
||||
|
||||
|
||||
#line 1 "cmCommandArgumentLexer.in.l"
|
||||
#line 2 "cmCommandArgumentLexer.in.l"
|
||||
/*=========================================================================
|
||||
|
||||
Program: CMake - Cross-Platform Makefile Generator
|
||||
@ -491,7 +496,7 @@ Modify cmCommandArgumentLexer.h:
|
||||
#include "cmCommandArgumentParserTokens.h"
|
||||
|
||||
/*--------------------------------------------------------------------------*/
|
||||
|
||||
#line 500 "cmCommandArgumentLexer.cxx"
|
||||
|
||||
#define INITIAL 0
|
||||
|
||||
@ -541,6 +546,8 @@ struct yyguts_t
|
||||
|
||||
}; /* end struct yyguts_t */
|
||||
|
||||
static int yy_init_globals (yyscan_t yyscanner );
|
||||
|
||||
/* Accessor methods to globals.
|
||||
These are made visible to non-reentrant scanners for convenience. */
|
||||
|
||||
@ -582,6 +589,8 @@ extern int cmCommandArgument_yywrap (yyscan_t yyscanner );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner);
|
||||
|
||||
#ifndef yytext_ptr
|
||||
static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
|
||||
#endif
|
||||
@ -613,8 +622,8 @@ static int input (yyscan_t yyscanner );
|
||||
#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
|
||||
#endif
|
||||
|
||||
/* Gets input and stuffs it into "buf". number of characters read, or
|
||||
* YY_NULL, is returned in "result".
|
||||
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
|
||||
* is returned in "result".
|
||||
*/
|
||||
#ifndef YY_INPUT
|
||||
#define YY_INPUT(buf,result,max_size) \
|
||||
@ -704,14 +713,14 @@ YY_DECL
|
||||
register int yy_act;
|
||||
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
|
||||
|
||||
#line 60 "cmCommandArgumentLexer.in.l"
|
||||
|
||||
|
||||
#line 720 "cmCommandArgumentLexer.cxx"
|
||||
|
||||
|
||||
|
||||
if ( yyg->yy_init )
|
||||
if ( !yyg->yy_init )
|
||||
{
|
||||
yyg->yy_init = 0;
|
||||
yyg->yy_init = 1;
|
||||
|
||||
#ifdef YY_USER_INIT
|
||||
YY_USER_INIT;
|
||||
@ -792,7 +801,7 @@ do_action: /* This label is used only to access EOF actions. */
|
||||
|
||||
case 1:
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 62 "cmCommandArgumentLexer.in.l"
|
||||
{
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
|
||||
@ -800,7 +809,7 @@ YY_RULE_SETUP
|
||||
}
|
||||
case 2:
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 68 "cmCommandArgumentLexer.in.l"
|
||||
{
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
|
||||
@ -808,7 +817,7 @@ YY_RULE_SETUP
|
||||
}
|
||||
case 3:
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 74 "cmCommandArgumentLexer.in.l"
|
||||
{
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
@ -817,7 +826,7 @@ YY_RULE_SETUP
|
||||
}
|
||||
case 4:
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 81 "cmCommandArgumentLexer.in.l"
|
||||
{
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
@ -826,7 +835,7 @@ YY_RULE_SETUP
|
||||
}
|
||||
case 5:
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 88 "cmCommandArgumentLexer.in.l"
|
||||
{
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
@ -835,7 +844,7 @@ YY_RULE_SETUP
|
||||
}
|
||||
case 6:
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 95 "cmCommandArgumentLexer.in.l"
|
||||
{
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
@ -843,7 +852,7 @@ YY_RULE_SETUP
|
||||
}
|
||||
case 7:
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 101 "cmCommandArgumentLexer.in.l"
|
||||
{
|
||||
if ( !yyextra->HandleEscapeSymbol(yylvalp, *(yytext+1)) )
|
||||
{
|
||||
@ -854,7 +863,7 @@ YY_RULE_SETUP
|
||||
case 8:
|
||||
/* rule 8 can match eol */
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 109 "cmCommandArgumentLexer.in.l"
|
||||
{
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
@ -862,7 +871,7 @@ YY_RULE_SETUP
|
||||
}
|
||||
case 9:
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 115 "cmCommandArgumentLexer.in.l"
|
||||
{
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
yylvalp->str = yyextra->DOLLARVariable;
|
||||
@ -870,7 +879,7 @@ YY_RULE_SETUP
|
||||
}
|
||||
case 10:
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 121 "cmCommandArgumentLexer.in.l"
|
||||
{
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
yylvalp->str = yyextra->LCURLYVariable;
|
||||
@ -878,7 +887,7 @@ YY_RULE_SETUP
|
||||
}
|
||||
case 11:
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 127 "cmCommandArgumentLexer.in.l"
|
||||
{
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
yylvalp->str = yyextra->BSLASHVariable;
|
||||
@ -886,10 +895,10 @@ YY_RULE_SETUP
|
||||
}
|
||||
case 12:
|
||||
YY_RULE_SETUP
|
||||
|
||||
#line 133 "cmCommandArgumentLexer.in.l"
|
||||
ECHO;
|
||||
YY_BREAK
|
||||
|
||||
#line 913 "cmCommandArgumentLexer.cxx"
|
||||
case YY_STATE_EOF(INITIAL):
|
||||
yyterminate();
|
||||
|
||||
@ -1076,10 +1085,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
|
||||
|
||||
else
|
||||
{
|
||||
size_t nuto_read =
|
||||
int num_to_read =
|
||||
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
|
||||
|
||||
while ( nuto_read <= 0 )
|
||||
while ( num_to_read <= 0 )
|
||||
{ /* Not enough room in the buffer - grow it. */
|
||||
|
||||
/* just a shorter name for the current buffer */
|
||||
@ -1111,17 +1120,17 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
|
||||
|
||||
yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
|
||||
|
||||
nuto_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
|
||||
num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
|
||||
number_to_move - 1;
|
||||
|
||||
}
|
||||
|
||||
if ( nuto_read > YY_READ_BUF_SIZE )
|
||||
nuto_read = YY_READ_BUF_SIZE;
|
||||
if ( num_to_read > YY_READ_BUF_SIZE )
|
||||
num_to_read = YY_READ_BUF_SIZE;
|
||||
|
||||
/* Read in more data. */
|
||||
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
|
||||
yyg->yy_n_chars, nuto_read );
|
||||
yyg->yy_n_chars, (size_t) num_to_read );
|
||||
|
||||
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
|
||||
}
|
||||
@ -1154,8 +1163,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
|
||||
return ret_val;
|
||||
}
|
||||
|
||||
/* yy_get_previous_state - get the state just before the EOB char was
|
||||
reached */
|
||||
/* yy_get_previous_state - get the state just before the EOB char was reached */
|
||||
|
||||
static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
|
||||
{
|
||||
@ -1193,7 +1201,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
|
||||
static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
|
||||
{
|
||||
register int yy_is_jam;
|
||||
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
|
||||
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
|
||||
register char *yy_cp = yyg->yy_c_buf_p;
|
||||
|
||||
register YY_CHAR yy_c = 1;
|
||||
@ -1214,6 +1222,44 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
|
||||
return yy_is_jam ? 0 : yy_current_state;
|
||||
}
|
||||
|
||||
static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)
|
||||
{
|
||||
register char *yy_cp;
|
||||
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
|
||||
|
||||
yy_cp = yyg->yy_c_buf_p;
|
||||
|
||||
/* undo effects of setting up yytext */
|
||||
*yy_cp = yyg->yy_hold_char;
|
||||
|
||||
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 = yyg->yy_n_chars + 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_LVALUE->yy_ch_buf[number_to_move];
|
||||
|
||||
while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
|
||||
*--dest = *--source;
|
||||
|
||||
yy_cp += (int) (dest - source);
|
||||
yy_bp += (int) (dest - source);
|
||||
YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
|
||||
yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
|
||||
|
||||
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
|
||||
YY_FATAL_ERROR( "flex scanner push-back overflow" );
|
||||
}
|
||||
|
||||
*--yy_cp = (char) c;
|
||||
|
||||
yyg->yytext_ptr = yy_bp;
|
||||
yyg->yy_hold_char = *yy_cp;
|
||||
yyg->yy_c_buf_p = yy_cp;
|
||||
}
|
||||
|
||||
#ifndef YY_NO_INPUT
|
||||
#ifdef __cplusplus
|
||||
static int yyinput (yyscan_t yyscanner)
|
||||
@ -1336,10 +1382,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
|
||||
YY_CURRENT_BUFFER_LVALUE = new_buffer;
|
||||
cmCommandArgument_yy_load_buffer_state(yyscanner );
|
||||
|
||||
/* We don't actually know whether we did this switch during EOF
|
||||
* (cmCommandArgument_yywrap()) processing, but the only time this flag is
|
||||
* looked at is after cmCommandArgument_yywrap() is called, so it's safe to
|
||||
* go ahead and always set it.
|
||||
/* We don't actually know whether we did this switch during
|
||||
* EOF (cmCommandArgument_yywrap()) processing, but the only time this flag
|
||||
* is looked at is after cmCommandArgument_yywrap() is called, so it's safe
|
||||
* to go ahead and always set it.
|
||||
*/
|
||||
yyg->yy_did_buffer_switch_on_eof = 1;
|
||||
}
|
||||
@ -1353,10 +1399,11 @@ static void cmCommandArgument_yy_load_buffer_state (yyscan_t yyscanner)
|
||||
yyg->yy_hold_char = *yyg->yy_c_buf_p;
|
||||
}
|
||||
|
||||
/** Allocate and initialize an input buffer state. @param file A readable
|
||||
* stream. @param size The character buffer size in bytes. When in doubt,
|
||||
* use @c YY_BUF_SIZE. @param yyscanner The scanner object. @return the
|
||||
* allocated buffer state.
|
||||
/** Allocate and initialize an input buffer state.
|
||||
* @param file A readable stream.
|
||||
* @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
|
||||
* @param yyscanner The scanner object.
|
||||
* @return the allocated buffer state.
|
||||
*/
|
||||
YY_BUFFER_STATE cmCommandArgument_yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
|
||||
{
|
||||
@ -1421,10 +1468,9 @@ extern int isatty (int );
|
||||
b->yy_input_file = file;
|
||||
b->yy_fill_buffer = 1;
|
||||
|
||||
/* If b is the current buffer, then cmCommandArgument_yy_init_buffer was
|
||||
* _probably_ called from cmCommandArgument_yyrestart() or through
|
||||
* yy_get_next_buffer. In that case, we don't want to reset the lineno
|
||||
* or column.
|
||||
/* If b is the current buffer, then cmCommandArgument_yy_init_buffer was _probably_
|
||||
* called from cmCommandArgument_yyrestart() or through yy_get_next_buffer.
|
||||
* In that case, we don't want to reset the lineno or column.
|
||||
*/
|
||||
if (b != YY_CURRENT_BUFFER){
|
||||
b->yy_bs_lineno = 1;
|
||||
@ -1436,9 +1482,9 @@ extern int isatty (int );
|
||||
errno = oerrno;
|
||||
}
|
||||
|
||||
/** Discard all buffered characters. On the next scan, YY_INPUT will be
|
||||
* called. @param b the buffer state to be flushed, usually @c
|
||||
* YY_CURRENT_BUFFER. @param yyscanner The scanner object.
|
||||
/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
|
||||
* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
|
||||
* @param yyscanner The scanner object.
|
||||
*/
|
||||
void cmCommandArgument_yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
|
||||
{
|
||||
@ -1523,7 +1569,7 @@ void cmCommandArgument_yypop_buffer_state (yyscan_t yyscanner)
|
||||
*/
|
||||
static void cmCommandArgument_yyensure_buffer_stack (yyscan_t yyscanner)
|
||||
{
|
||||
int nuto_alloc;
|
||||
int num_to_alloc;
|
||||
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
|
||||
|
||||
if (!yyg->yy_buffer_stack) {
|
||||
@ -1532,14 +1578,14 @@ static void cmCommandArgument_yyensure_buffer_stack (yyscan_t yyscanner)
|
||||
* scanner will even need a stack. We use 2 instead of 1 to avoid an
|
||||
* immediate realloc on the next call.
|
||||
*/
|
||||
nuto_alloc = 1;
|
||||
num_to_alloc = 1;
|
||||
yyg->yy_buffer_stack = (struct yy_buffer_state**)cmCommandArgument_yyalloc
|
||||
(nuto_alloc * sizeof(struct yy_buffer_state*)
|
||||
(num_to_alloc * sizeof(struct yy_buffer_state*)
|
||||
, yyscanner);
|
||||
|
||||
memset(yyg->yy_buffer_stack, 0, nuto_alloc * sizeof(struct yy_buffer_state*));
|
||||
memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
|
||||
|
||||
yyg->yy_buffer_stack_max = nuto_alloc;
|
||||
yyg->yy_buffer_stack_max = num_to_alloc;
|
||||
yyg->yy_buffer_stack_top = 0;
|
||||
return;
|
||||
}
|
||||
@ -1549,21 +1595,22 @@ static void cmCommandArgument_yyensure_buffer_stack (yyscan_t yyscanner)
|
||||
/* Increase the buffer to prepare for a possible push. */
|
||||
int grow_size = 8 /* arbitrary grow size */;
|
||||
|
||||
nuto_alloc = yyg->yy_buffer_stack_max + grow_size;
|
||||
num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
|
||||
yyg->yy_buffer_stack = (struct yy_buffer_state**)cmCommandArgument_yyrealloc
|
||||
(yyg->yy_buffer_stack,
|
||||
nuto_alloc * sizeof(struct yy_buffer_state*)
|
||||
num_to_alloc * sizeof(struct yy_buffer_state*)
|
||||
, yyscanner);
|
||||
|
||||
/* zero only the new slots.*/
|
||||
memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
|
||||
yyg->yy_buffer_stack_max = nuto_alloc;
|
||||
yyg->yy_buffer_stack_max = num_to_alloc;
|
||||
}
|
||||
}
|
||||
|
||||
/** Setup the input buffer state to scan directly from a user-specified
|
||||
* character buffer. @param base the character buffer @param size the size
|
||||
* in bytes of the character buffer @param yyscanner The scanner object.
|
||||
/** Setup the input buffer state to scan directly from a user-specified character buffer.
|
||||
* @param base the character buffer
|
||||
* @param size the size in bytes of the character buffer
|
||||
* @param yyscanner The scanner object.
|
||||
* @return the newly allocated buffer state object.
|
||||
*/
|
||||
YY_BUFFER_STATE cmCommandArgument_yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
|
||||
@ -1595,26 +1642,28 @@ YY_BUFFER_STATE cmCommandArgument_yy_scan_buffer (char * base, yy_size_t size
|
||||
return b;
|
||||
}
|
||||
|
||||
/** Setup the input buffer state to scan a string. The next call to
|
||||
* cmCommandArgument_yylex() will scan from a @e copy of @a str. @param str
|
||||
* a NUL-terminated string to scan @param yyscanner The scanner object.
|
||||
* @return the newly allocated buffer state object. @note If you want to
|
||||
* scan bytes that may contain NUL values, then use
|
||||
/** Setup the input buffer state to scan a string. The next call to cmCommandArgument_yylex() will
|
||||
* scan from a @e copy of @a str.
|
||||
* @param yystr a NUL-terminated string to scan
|
||||
* @param yyscanner The scanner object.
|
||||
* @return the newly allocated buffer state object.
|
||||
* @note If you want to scan bytes that may contain NUL values, then use
|
||||
* cmCommandArgument_yy_scan_bytes() instead.
|
||||
*/
|
||||
YY_BUFFER_STATE cmCommandArgument_yy_scan_string (yyconst char * yy_str , yyscan_t yyscanner)
|
||||
YY_BUFFER_STATE cmCommandArgument_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
|
||||
{
|
||||
|
||||
return cmCommandArgument_yy_scan_bytes(yy_str,strlen(yy_str) ,yyscanner);
|
||||
return cmCommandArgument_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
|
||||
}
|
||||
|
||||
/** Setup the input buffer state to scan the given bytes. The next call to
|
||||
* cmCommandArgument_yylex() will scan from a @e copy of @a bytes. @param
|
||||
* bytes the byte buffer to scan @param len the number of bytes in the buffer
|
||||
* pointed to by @a bytes. @param yyscanner The scanner object. @return the
|
||||
* newly allocated buffer state object.
|
||||
/** Setup the input buffer state to scan the given bytes. The next call to cmCommandArgument_yylex() will
|
||||
* scan from a @e copy of @a bytes.
|
||||
* @param bytes the byte buffer to scan
|
||||
* @param len the number of bytes in the buffer pointed to by @a bytes.
|
||||
* @param yyscanner The scanner object.
|
||||
* @return the newly allocated buffer state object.
|
||||
*/
|
||||
YY_BUFFER_STATE cmCommandArgument_yy_scan_bytes (yyconst char * bytes, int len , yyscan_t yyscanner)
|
||||
YY_BUFFER_STATE cmCommandArgument_yy_scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner)
|
||||
{
|
||||
YY_BUFFER_STATE b;
|
||||
char *buf;
|
||||
@ -1622,15 +1671,15 @@ YY_BUFFER_STATE cmCommandArgument_yy_scan_bytes (yyconst char * bytes, int len
|
||||
int i;
|
||||
|
||||
/* Get memory for full buffer, including space for trailing EOB's. */
|
||||
n = len + 2;
|
||||
n = _yybytes_len + 2;
|
||||
buf = (char *) cmCommandArgument_yyalloc(n ,yyscanner );
|
||||
if ( ! buf )
|
||||
YY_FATAL_ERROR( "out of dynamic memory in cmCommandArgument_yy_scan_bytes()" );
|
||||
|
||||
for ( i = 0; i < len; ++i )
|
||||
buf[i] = bytes[i];
|
||||
for ( i = 0; i < _yybytes_len; ++i )
|
||||
buf[i] = yybytes[i];
|
||||
|
||||
buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
|
||||
buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
|
||||
|
||||
b = cmCommandArgument_yy_scan_buffer(buf,n ,yyscanner);
|
||||
if ( ! b )
|
||||
@ -1780,12 +1829,7 @@ void cmCommandArgument_yyset_column (int column_no , yyscan_t yyscanner)
|
||||
|
||||
/* column is only valid if an input buffer exists. */
|
||||
if (! YY_CURRENT_BUFFER )
|
||||
{
|
||||
yy_fatal_error
|
||||
("cmCommandArgument_yyset_column called with no buffer" ,
|
||||
yyscanner);
|
||||
}
|
||||
|
||||
yy_fatal_error( "cmCommandArgument_yyset_column called with no buffer" , yyscanner);
|
||||
|
||||
yycolumn = column_no;
|
||||
}
|
||||
@ -1822,43 +1866,11 @@ void cmCommandArgument_yyset_debug (int bdebug , yyscan_t yyscanner)
|
||||
|
||||
/* Accessor methods for yylval and yylloc */
|
||||
|
||||
static int yy_init_globals (yyscan_t yyscanner)
|
||||
{
|
||||
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
|
||||
/* Initialization is the same as for the non-reentrant scanner.
|
||||
This function is called once per scanner lifetime. */
|
||||
|
||||
yyg->yy_buffer_stack = 0;
|
||||
yyg->yy_buffer_stack_top = 0;
|
||||
yyg->yy_buffer_stack_max = 0;
|
||||
yyg->yy_c_buf_p = (char *) 0;
|
||||
yyg->yy_init = 1;
|
||||
yyg->yy_start = 0;
|
||||
yyg->yy_start_stack_ptr = 0;
|
||||
yyg->yy_start_stack_depth = 0;
|
||||
yyg->yy_start_stack = (int *) 0;
|
||||
|
||||
/* Defined in main.c */
|
||||
#ifdef YY_STDINIT
|
||||
yyin = stdin;
|
||||
yyout = stdout;
|
||||
#else
|
||||
yyin = (FILE *) 0;
|
||||
yyout = (FILE *) 0;
|
||||
#endif
|
||||
|
||||
/* For future reference: Set errno on error, since we are called by
|
||||
* cmCommandArgument_yylex_init()
|
||||
*/
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* User-visible API */
|
||||
|
||||
/* cmCommandArgument_yylex_init is special because it creates the scanner
|
||||
* itself, so it is the ONLY reentrant function that doesn't take the scanner
|
||||
* as the last argument. That's why we explicitly handle the declaration,
|
||||
* instead of using our macros.
|
||||
/* cmCommandArgument_yylex_init is special because it creates the scanner itself, so it is
|
||||
* the ONLY reentrant function that doesn't take the scanner as the last argument.
|
||||
* That's why we explicitly handle the declaration, instead of using our macros.
|
||||
*/
|
||||
|
||||
int cmCommandArgument_yylex_init(yyscan_t* ptr_yy_globals)
|
||||
@ -1876,13 +1888,46 @@ int cmCommandArgument_yylex_init(yyscan_t* ptr_yy_globals)
|
||||
return 1;
|
||||
}
|
||||
|
||||
memset(*ptr_yy_globals,0,sizeof(struct yyguts_t));
|
||||
/* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
|
||||
memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
|
||||
|
||||
return yy_init_globals ( *ptr_yy_globals );
|
||||
}
|
||||
|
||||
/* cmCommandArgument_yylex_destroy is for both reentrant and non-reentrant
|
||||
scanners. */
|
||||
static int yy_init_globals (yyscan_t yyscanner)
|
||||
{
|
||||
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
|
||||
/* Initialization is the same as for the non-reentrant scanner.
|
||||
* This function is called from cmCommandArgument_yylex_destroy(), so don't allocate here.
|
||||
*/
|
||||
|
||||
yyg->yy_buffer_stack = 0;
|
||||
yyg->yy_buffer_stack_top = 0;
|
||||
yyg->yy_buffer_stack_max = 0;
|
||||
yyg->yy_c_buf_p = (char *) 0;
|
||||
yyg->yy_init = 0;
|
||||
yyg->yy_start = 0;
|
||||
|
||||
yyg->yy_start_stack_ptr = 0;
|
||||
yyg->yy_start_stack_depth = 0;
|
||||
yyg->yy_start_stack = NULL;
|
||||
|
||||
/* Defined in main.c */
|
||||
#ifdef YY_STDINIT
|
||||
yyin = stdin;
|
||||
yyout = stdout;
|
||||
#else
|
||||
yyin = (FILE *) 0;
|
||||
yyout = (FILE *) 0;
|
||||
#endif
|
||||
|
||||
/* For future reference: Set errno on error, since we are called by
|
||||
* cmCommandArgument_yylex_init()
|
||||
*/
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* cmCommandArgument_yylex_destroy is for both reentrant and non-reentrant scanners. */
|
||||
int cmCommandArgument_yylex_destroy (yyscan_t yyscanner)
|
||||
{
|
||||
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
|
||||
@ -1902,8 +1947,13 @@ int cmCommandArgument_yylex_destroy (yyscan_t yyscanner)
|
||||
cmCommandArgument_yyfree(yyg->yy_start_stack ,yyscanner );
|
||||
yyg->yy_start_stack = NULL;
|
||||
|
||||
/* Reset the globals. This is important in a non-reentrant scanner so the next time
|
||||
* cmCommandArgument_yylex() is called, initialization will occur. */
|
||||
yy_init_globals( yyscanner);
|
||||
|
||||
/* Destroy the main struct (reentrant only). */
|
||||
cmCommandArgument_yyfree ( yyscanner , yyscanner );
|
||||
yyscanner = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1912,11 +1962,9 @@ int cmCommandArgument_yylex_destroy (yyscan_t yyscanner)
|
||||
*/
|
||||
|
||||
#ifndef yytext_ptr
|
||||
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ,
|
||||
yyscan_t yyscanner)
|
||||
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
|
||||
{
|
||||
register int i;
|
||||
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
|
||||
for ( i = 0; i < n; ++i )
|
||||
s1[i] = s2[i];
|
||||
}
|
||||
@ -1926,7 +1974,6 @@ static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ,
|
||||
static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
|
||||
{
|
||||
register int n;
|
||||
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
|
||||
for ( n = 0; s[n]; ++n )
|
||||
;
|
||||
|
||||
@ -1953,25 +2000,12 @@ void *cmCommandArgument_yyrealloc (void * ptr, yy_size_t size , yyscan_t)
|
||||
|
||||
void cmCommandArgument_yyfree (void * ptr , yyscan_t)
|
||||
{
|
||||
free( (char *) ptr );
|
||||
/* see cmCommandArgument_yyrealloc() for (char *) cast */
|
||||
free( (char *) ptr ); /* see cmCommandArgument_yyrealloc() for (char *) cast */
|
||||
}
|
||||
|
||||
#define YYTABLES_NAME "yytables"
|
||||
|
||||
#undef YY_NEW_FILE
|
||||
#undef YY_FLUSH_BUFFER
|
||||
#undef yy_set_bol
|
||||
#undef yy_new_buffer
|
||||
#undef yy_set_interactive
|
||||
#undef yytext_ptr
|
||||
#undef YY_DO_BEFORE_ACTION
|
||||
|
||||
#ifdef YY_DECL_IS_OURS
|
||||
#undef YY_DECL_IS_OURS
|
||||
#undef YY_DECL
|
||||
#endif
|
||||
|
||||
#line 133 "cmCommandArgumentLexer.in.l"
|
||||
|
||||
|
||||
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
#define FLEX_SCANNER
|
||||
#define YY_FLEX_MAJOR_VERSION 2
|
||||
#define YY_FLEX_MINOR_VERSION 5
|
||||
#define YY_FLEX_SUBMINOR_VERSION 31
|
||||
#define YY_FLEX_SUBMINOR_VERSION 33
|
||||
#if YY_FLEX_SUBMINOR_VERSION > 0
|
||||
#define FLEX_BETA
|
||||
#endif
|
||||
@ -36,6 +36,14 @@
|
||||
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
|
||||
|
||||
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
|
||||
|
||||
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
|
||||
* if you want the limit (max/min) macros for int types.
|
||||
*/
|
||||
#ifndef __STDC_LIMIT_MACROS
|
||||
#define __STDC_LIMIT_MACROS 1
|
||||
#endif
|
||||
|
||||
#include <inttypes.h>
|
||||
typedef int8_t flex_int8_t;
|
||||
typedef uint8_t flex_uint8_t;
|
||||
|
||||
@ -59,13 +59,13 @@ Modify cmCommandArgumentLexer.h:
|
||||
|
||||
%%
|
||||
|
||||
\$[A-Za-z0-9/_.-]+\{ {
|
||||
\$[A-Za-z0-9/_.+-]+\{ {
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
|
||||
return cal_NCURLY;
|
||||
}
|
||||
|
||||
@[A-Za-z0-9/_.-]+@ {
|
||||
@[A-Za-z0-9/_.+-]+@ {
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
|
||||
return cal_ATNAME;
|
||||
@ -74,25 +74,25 @@ Modify cmCommandArgumentLexer.h:
|
||||
"${" {
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
yylvalp->str = yyextra->m_DCURLYVariable;
|
||||
yylvalp->str = yyextra->DCURLYVariable;
|
||||
return cal_DCURLY;
|
||||
}
|
||||
|
||||
"}" {
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
yylvalp->str = yyextra->m_RCURLYVariable;
|
||||
yylvalp->str = yyextra->RCURLYVariable;
|
||||
return cal_RCURLY;
|
||||
}
|
||||
|
||||
"@" {
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
yylvalp->str = yyextra->m_ATVariable;
|
||||
yylvalp->str = yyextra->ATVariable;
|
||||
return cal_AT;
|
||||
}
|
||||
|
||||
[A-Za-z0-9/_.-]+ {
|
||||
[A-Za-z0-9/_.+-]+ {
|
||||
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
|
||||
yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
return cal_NAME;
|
||||
@ -114,19 +114,19 @@ Modify cmCommandArgumentLexer.h:
|
||||
|
||||
"$" {
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
yylvalp->str = yyextra->m_DOLLARVariable;
|
||||
yylvalp->str = yyextra->DOLLARVariable;
|
||||
return cal_DOLLAR;
|
||||
}
|
||||
|
||||
"{" {
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
yylvalp->str = yyextra->m_LCURLYVariable;
|
||||
yylvalp->str = yyextra->LCURLYVariable;
|
||||
return cal_LCURLY;
|
||||
}
|
||||
|
||||
"\\" {
|
||||
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
|
||||
yylvalp->str = yyextra->m_BSLASHVariable;
|
||||
yylvalp->str = yyextra->BSLASHVariable;
|
||||
return cal_BSLASH;
|
||||
}
|
||||
|
||||
|
||||
@ -83,7 +83,8 @@ ENDIF(NOT FILE_IS_NEWER "${file}" "${CMAKE_CURRENT_SOURCE_DIR}/InputFile.h.in")
|
||||
# Test configuration of the string
|
||||
SET(TEST_DEFINED 123)
|
||||
SET(TEST_NOT_DEFINED)
|
||||
STRING(CONFIGURE "${infile}" infile @ONLY)
|
||||
STRING(CONFIGURE "${infile}" infile+-/out @ONLY)
|
||||
SET(infile "${infile+-/out}")
|
||||
|
||||
# Write include file to a file
|
||||
STRING(REGEX REPLACE "includefile" "${file}" outfile "${infile}")
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user