kolan/CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

BUG: Character + should be valid in a variable name.

Browse Source
This commit is contained in:
Brad King 2006-09-25 10:05:07 -04:00
parent cba6306b86
commit 97c97730a6
4 changed files with 857 additions and 814 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

360
Source/cmCommandArgumentLexer.cxx
View File

@ -1,7 +1,6 @@
#include "cmStandardIncludes.h" #line 2 "cmCommandArgumentLexer.cxx"
#line 4 "cmCommandArgumentLexer.cxx"
#define YY_INT_ALIGNED short int #define YY_INT_ALIGNED short int
@ -10,7 +9,7 @@
#define FLEX_SCANNER #define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 5 #define YY_FLEX_MINOR_VERSION 5
#define YY_FLEX_SUBMINOR_VERSION 31 #define YY_FLEX_SUBMINOR_VERSION 33
#if YY_FLEX_SUBMINOR_VERSION > 0 #if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA #define FLEX_BETA
#endif #endif
@ -32,7 +31,15 @@
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ /* 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> #include <inttypes.h>
typedef int8_t flex_int8_t; typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t; typedef uint8_t flex_uint8_t;
@ -155,6 +162,10 @@ int cmCommandArgument_yylex_init (yyscan_t* scanner);
#define YY_BUF_SIZE 16384 #define YY_BUF_SIZE 16384
#endif #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 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE #define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *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) #define YY_LESS_LINENO(n)
/* Return all but the first "n" matched characters back to the input /* Return all but the first "n" matched characters back to the input stream. */
stream. */
#define yyless(n) \ #define yyless(n) \
do \ do \
{ \ { \
@ -181,6 +191,8 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
} \ } \
while ( 0 ) while ( 0 )
#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
/* The following is because we cannot portably get our hands on size_t /* The following is because we cannot portably get our hands on size_t
* (without autoconf's help, which isn't available because we want * (without autoconf's help, which isn't available because we want
* flex-generated scanners to compile on their own). * 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 * still have a bunch of tokens to match, though, because of
* possible backing-up. * possible backing-up.
* *
* When we actually see the EOF, we change the status to "new" (via * When we actually see the EOF, we change the status to "new"
* cmCommandArgument_yyrestart()), so that the user can continue scanning * (via cmCommandArgument_yyrestart()), so that the user can continue scanning by
* by just pointing yyin at a new input file. * just pointing yyin at a new input file.
*/ */
#define YY_BUFFER_EOF_PENDING 2 #define YY_BUFFER_EOF_PENDING 2
@ -266,29 +278,22 @@ struct yy_buffer_state
? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
: NULL) : NULL)
/* Same as previous macro, but useful when we know that the buffer stack is /* Same as previous macro, but useful when we know that the buffer stack is not
* not NULL or when we need an lvalue. For internal use only. * 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] #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_yyrestart (FILE *input_file ,yyscan_t yyscanner );
void cmCommandArgument_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , void cmCommandArgument_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
yyscan_t yyscanner ); YY_BUFFER_STATE cmCommandArgument_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
YY_BUFFER_STATE cmCommandArgument_yy_create_buffer (FILE *file,int size , void cmCommandArgument_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
yyscan_t yyscanner ); void cmCommandArgument_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
void cmCommandArgument_yy_delete_buffer (YY_BUFFER_STATE b , void cmCommandArgument_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
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 ); void cmCommandArgument_yypop_buffer_state (yyscan_t yyscanner );
static void cmCommandArgument_yyensure_buffer_stack (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_load_buffer_state (yyscan_t yyscanner );
static void cmCommandArgument_yy_init_buffer (YY_BUFFER_STATE b, static void cmCommandArgument_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
FILE *file ,
yyscan_t yyscanner );
#define YY_FLUSH_BUFFER cmCommandArgument_yy_flush_buffer(YY_CURRENT_BUFFER ,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, 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, 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, 4, 4, 4, 4, 4, 4, 4, 1, 1, 1,
1, 1, 1, 5, 4, 4, 4, 4, 4, 4, 1, 1, 1, 5, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 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 yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0 #define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET #define YY_RESTORE_YY_MORE_OFFSET
#line 1 "cmCommandArgumentLexer.in.l"
#line 2 "cmCommandArgumentLexer.in.l"
/*========================================================================= /*=========================================================================
Program: CMake - Cross-Platform Makefile Generator Program: CMake - Cross-Platform Makefile Generator
@ -491,7 +496,7 @@ Modify cmCommandArgumentLexer.h:
#include "cmCommandArgumentParserTokens.h" #include "cmCommandArgumentParserTokens.h"
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
#line 500 "cmCommandArgumentLexer.cxx"
#define INITIAL 0 #define INITIAL 0
@ -541,6 +546,8 @@ struct yyguts_t
}; /* end struct yyguts_t */ }; /* end struct yyguts_t */
static int yy_init_globals (yyscan_t yyscanner );
/* Accessor methods to globals. /* Accessor methods to globals.
These are made visible to non-reentrant scanners for convenience. */ These are made visible to non-reentrant scanners for convenience. */
@ -582,6 +589,8 @@ extern int cmCommandArgument_yywrap (yyscan_t yyscanner );
#endif #endif
#endif #endif
static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner);
#ifndef yytext_ptr #ifndef yytext_ptr
static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner); static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
#endif #endif
@ -613,8 +622,8 @@ static int input (yyscan_t yyscanner );
#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
#endif #endif
/* Gets input and stuffs it into "buf". number of characters read, or /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
* YY_NULL, is returned in "result". * is returned in "result".
*/ */
#ifndef YY_INPUT #ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \ #define YY_INPUT(buf,result,max_size) \
@ -704,14 +713,14 @@ YY_DECL
register int yy_act; register int yy_act;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 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 #ifdef YY_USER_INIT
YY_USER_INIT; YY_USER_INIT;
@ -792,7 +801,7 @@ do_action: /* This label is used only to access EOF actions. */
case 1: case 1:
YY_RULE_SETUP YY_RULE_SETUP
#line 62 "cmCommandArgumentLexer.in.l"
{ {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2); yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
@ -800,7 +809,7 @@ YY_RULE_SETUP
} }
case 2: case 2:
YY_RULE_SETUP YY_RULE_SETUP
#line 68 "cmCommandArgumentLexer.in.l"
{ {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2); yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
@ -808,7 +817,7 @@ YY_RULE_SETUP
} }
case 3: case 3:
YY_RULE_SETUP YY_RULE_SETUP
#line 74 "cmCommandArgumentLexer.in.l"
{ {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
@ -817,7 +826,7 @@ YY_RULE_SETUP
} }
case 4: case 4:
YY_RULE_SETUP YY_RULE_SETUP
#line 81 "cmCommandArgumentLexer.in.l"
{ {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
@ -826,7 +835,7 @@ YY_RULE_SETUP
} }
case 5: case 5:
YY_RULE_SETUP YY_RULE_SETUP
#line 88 "cmCommandArgumentLexer.in.l"
{ {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
@ -835,7 +844,7 @@ YY_RULE_SETUP
} }
case 6: case 6:
YY_RULE_SETUP YY_RULE_SETUP
#line 95 "cmCommandArgumentLexer.in.l"
{ {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
@ -843,7 +852,7 @@ YY_RULE_SETUP
} }
case 7: case 7:
YY_RULE_SETUP YY_RULE_SETUP
#line 101 "cmCommandArgumentLexer.in.l"
{ {
if ( !yyextra->HandleEscapeSymbol(yylvalp, *(yytext+1)) ) if ( !yyextra->HandleEscapeSymbol(yylvalp, *(yytext+1)) )
{ {
@ -854,7 +863,7 @@ YY_RULE_SETUP
case 8: case 8:
/* rule 8 can match eol */ /* rule 8 can match eol */
YY_RULE_SETUP YY_RULE_SETUP
#line 109 "cmCommandArgumentLexer.in.l"
{ {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
@ -862,7 +871,7 @@ YY_RULE_SETUP
} }
case 9: case 9:
YY_RULE_SETUP YY_RULE_SETUP
#line 115 "cmCommandArgumentLexer.in.l"
{ {
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
yylvalp->str = yyextra->DOLLARVariable; yylvalp->str = yyextra->DOLLARVariable;
@ -870,7 +879,7 @@ YY_RULE_SETUP
} }
case 10: case 10:
YY_RULE_SETUP YY_RULE_SETUP
#line 121 "cmCommandArgumentLexer.in.l"
{ {
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
yylvalp->str = yyextra->LCURLYVariable; yylvalp->str = yyextra->LCURLYVariable;
@ -878,7 +887,7 @@ YY_RULE_SETUP
} }
case 11: case 11:
YY_RULE_SETUP YY_RULE_SETUP
#line 127 "cmCommandArgumentLexer.in.l"
{ {
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
yylvalp->str = yyextra->BSLASHVariable; yylvalp->str = yyextra->BSLASHVariable;
@ -886,10 +895,10 @@ YY_RULE_SETUP
} }
case 12: case 12:
YY_RULE_SETUP YY_RULE_SETUP
#line 133 "cmCommandArgumentLexer.in.l"
ECHO; ECHO;
YY_BREAK YY_BREAK
#line 913 "cmCommandArgumentLexer.cxx"
case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(INITIAL):
yyterminate(); yyterminate();
@ -1076,10 +1085,10 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
else else
{ {
size_t nuto_read = int num_to_read =
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 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. */ { /* Not enough room in the buffer - grow it. */
/* just a shorter name for the current buffer */ /* 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]; 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; number_to_move - 1;
} }
if ( nuto_read > YY_READ_BUF_SIZE ) if ( num_to_read > YY_READ_BUF_SIZE )
nuto_read = YY_READ_BUF_SIZE; num_to_read = YY_READ_BUF_SIZE;
/* Read in more data. */ /* Read in more data. */
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 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; 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; return ret_val;
} }
/* yy_get_previous_state - get the state just before the EOB char was /* yy_get_previous_state - get the state just before the EOB char was reached */
reached */
static yy_state_type yy_get_previous_state (yyscan_t yyscanner) 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) static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
{ {
register int yy_is_jam; 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 char *yy_cp = yyg->yy_c_buf_p;
register YY_CHAR yy_c = 1; 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; 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 #ifndef YY_NO_INPUT
#ifdef __cplusplus #ifdef __cplusplus
static int yyinput (yyscan_t yyscanner) 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; YY_CURRENT_BUFFER_LVALUE = new_buffer;
cmCommandArgument_yy_load_buffer_state(yyscanner ); cmCommandArgument_yy_load_buffer_state(yyscanner );
/* We don't actually know whether we did this switch during EOF /* We don't actually know whether we did this switch during
* (cmCommandArgument_yywrap()) processing, but the only time this flag is * EOF (cmCommandArgument_yywrap()) processing, but the only time this flag
* looked at is after cmCommandArgument_yywrap() is called, so it's safe to * is looked at is after cmCommandArgument_yywrap() is called, so it's safe
* go ahead and always set it. * to go ahead and always set it.
*/ */
yyg->yy_did_buffer_switch_on_eof = 1; 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; yyg->yy_hold_char = *yyg->yy_c_buf_p;
} }
/** Allocate and initialize an input buffer state. @param file A readable /** Allocate and initialize an input buffer state.
* stream. @param size The character buffer size in bytes. When in doubt, * @param file A readable stream.
* use @c YY_BUF_SIZE. @param yyscanner The scanner object. @return the * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
* allocated buffer state. * @param yyscanner The scanner object.
* @return the allocated buffer state.
*/ */
YY_BUFFER_STATE cmCommandArgument_yy_create_buffer (FILE * file, int size , yyscan_t yyscanner) 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_input_file = file;
b->yy_fill_buffer = 1; b->yy_fill_buffer = 1;
/* If b is the current buffer, then cmCommandArgument_yy_init_buffer was /* If b is the current buffer, then cmCommandArgument_yy_init_buffer was _probably_
* _probably_ called from cmCommandArgument_yyrestart() or through * called from cmCommandArgument_yyrestart() or through yy_get_next_buffer.
* yy_get_next_buffer. In that case, we don't want to reset the lineno * In that case, we don't want to reset the lineno or column.
* or column.
*/ */
if (b != YY_CURRENT_BUFFER){ if (b != YY_CURRENT_BUFFER){
b->yy_bs_lineno = 1; b->yy_bs_lineno = 1;
@ -1436,9 +1482,9 @@ extern int isatty (int );
errno = oerrno; errno = oerrno;
} }
/** Discard all buffered characters. On the next scan, YY_INPUT will be /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
* called. @param b the buffer state to be flushed, usually @c * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
* YY_CURRENT_BUFFER. @param yyscanner The scanner object. * @param yyscanner The scanner object.
*/ */
void cmCommandArgument_yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) 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) static void cmCommandArgument_yyensure_buffer_stack (yyscan_t yyscanner)
{ {
int nuto_alloc; int num_to_alloc;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if (!yyg->yy_buffer_stack) { 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 * scanner will even need a stack. We use 2 instead of 1 to avoid an
* immediate realloc on the next call. * immediate realloc on the next call.
*/ */
nuto_alloc = 1; num_to_alloc = 1;
yyg->yy_buffer_stack = (struct yy_buffer_state**)cmCommandArgument_yyalloc 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); , 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; yyg->yy_buffer_stack_top = 0;
return; return;
} }
@ -1549,21 +1595,22 @@ static void cmCommandArgument_yyensure_buffer_stack (yyscan_t yyscanner)
/* Increase the buffer to prepare for a possible push. */ /* Increase the buffer to prepare for a possible push. */
int grow_size = 8 /* arbitrary grow size */; 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 = (struct yy_buffer_state**)cmCommandArgument_yyrealloc
(yyg->yy_buffer_stack, (yyg->yy_buffer_stack,
nuto_alloc * sizeof(struct yy_buffer_state*) num_to_alloc * sizeof(struct yy_buffer_state*)
, yyscanner); , yyscanner);
/* zero only the new slots.*/ /* zero only the new slots.*/
memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 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 /** Setup the input buffer state to scan directly from a user-specified character buffer.
* character buffer. @param base the character buffer @param size the size * @param base the character buffer
* in bytes of the character buffer @param yyscanner The scanner object. * @param size the size in bytes of the character buffer
* @param yyscanner The scanner object.
* @return the newly allocated buffer state object. * @return the newly allocated buffer state object.
*/ */
YY_BUFFER_STATE cmCommandArgument_yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) 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; return b;
} }
/** Setup the input buffer state to scan a string. The next call to /** Setup the input buffer state to scan a string. The next call to cmCommandArgument_yylex() will
* cmCommandArgument_yylex() will scan from a @e copy of @a str. @param str * scan from a @e copy of @a str.
* a NUL-terminated string to scan @param yyscanner The scanner object. * @param yystr a NUL-terminated string to scan
* @return the newly allocated buffer state object. @note If you want to * @param yyscanner The scanner object.
* scan bytes that may contain NUL values, then use * @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. * 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 /** Setup the input buffer state to scan the given bytes. The next call to cmCommandArgument_yylex() will
* cmCommandArgument_yylex() will scan from a @e copy of @a bytes. @param * scan from a @e copy of @a bytes.
* bytes the byte buffer to scan @param len the number of bytes in the buffer * @param bytes the byte buffer to scan
* pointed to by @a bytes. @param yyscanner The scanner object. @return the * @param len the number of bytes in the buffer pointed to by @a bytes.
* newly allocated buffer state object. * @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; YY_BUFFER_STATE b;
char *buf; char *buf;
@ -1622,15 +1671,15 @@ YY_BUFFER_STATE cmCommandArgument_yy_scan_bytes (yyconst char * bytes, int len
int i; int i;
/* Get memory for full buffer, including space for trailing EOB's. */ /* Get memory for full buffer, including space for trailing EOB's. */
n = len + 2; n = _yybytes_len + 2;
buf = (char *) cmCommandArgument_yyalloc(n ,yyscanner ); buf = (char *) cmCommandArgument_yyalloc(n ,yyscanner );
if ( ! buf ) if ( ! buf )
YY_FATAL_ERROR( "out of dynamic memory in cmCommandArgument_yy_scan_bytes()" ); YY_FATAL_ERROR( "out of dynamic memory in cmCommandArgument_yy_scan_bytes()" );
for ( i = 0; i < len; ++i ) for ( i = 0; i < _yybytes_len; ++i )
buf[i] = bytes[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); b = cmCommandArgument_yy_scan_buffer(buf,n ,yyscanner);
if ( ! b ) 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. */ /* column is only valid if an input buffer exists. */
if (! YY_CURRENT_BUFFER ) 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; yycolumn = column_no;
} }
@ -1822,43 +1866,11 @@ void cmCommandArgument_yyset_debug (int bdebug , yyscan_t yyscanner)
/* Accessor methods for yylval and yylloc */ /* 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 */ /* User-visible API */
/* cmCommandArgument_yylex_init is special because it creates the scanner /* cmCommandArgument_yylex_init is special because it creates the scanner itself, so it is
* itself, so it is the ONLY reentrant function that doesn't take the scanner * the ONLY reentrant function that doesn't take the scanner as the last argument.
* as the last argument. That's why we explicitly handle the declaration, * That's why we explicitly handle the declaration, instead of using our macros.
* instead of using our macros.
*/ */
int cmCommandArgument_yylex_init(yyscan_t* ptr_yy_globals) int cmCommandArgument_yylex_init(yyscan_t* ptr_yy_globals)
@ -1876,13 +1888,46 @@ int cmCommandArgument_yylex_init(yyscan_t* ptr_yy_globals)
return 1; 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 ); return yy_init_globals ( *ptr_yy_globals );
} }
/* cmCommandArgument_yylex_destroy is for both reentrant and non-reentrant static int yy_init_globals (yyscan_t yyscanner)
scanners. */ {
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) int cmCommandArgument_yylex_destroy (yyscan_t yyscanner)
{ {
struct yyguts_t * yyg = (struct yyguts_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 ); cmCommandArgument_yyfree(yyg->yy_start_stack ,yyscanner );
yyg->yy_start_stack = NULL; 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). */ /* Destroy the main struct (reentrant only). */
cmCommandArgument_yyfree ( yyscanner , yyscanner ); cmCommandArgument_yyfree ( yyscanner , yyscanner );
yyscanner = NULL;
return 0; return 0;
} }
@ -1912,11 +1962,9 @@ int cmCommandArgument_yylex_destroy (yyscan_t yyscanner)
*/ */
#ifndef yytext_ptr #ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
yyscan_t yyscanner)
{ {
register int i; register int i;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
for ( i = 0; i < n; ++i ) for ( i = 0; i < n; ++i )
s1[i] = s2[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) static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
{ {
register int n; register int n;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
for ( n = 0; s[n]; ++n ) 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) void cmCommandArgument_yyfree (void * ptr , yyscan_t)
{ {
free( (char *) ptr ); free( (char *) ptr ); /* see cmCommandArgument_yyrealloc() for (char *) cast */
/* see cmCommandArgument_yyrealloc() for (char *) cast */
} }
#define YYTABLES_NAME "yytables" #define YYTABLES_NAME "yytables"
#undef YY_NEW_FILE #line 133 "cmCommandArgumentLexer.in.l"
#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

10
Source/cmCommandArgumentLexer.h
View File

@ -13,7 +13,7 @@
#define FLEX_SCANNER #define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 5 #define YY_FLEX_MINOR_VERSION 5
#define YY_FLEX_SUBMINOR_VERSION 31 #define YY_FLEX_SUBMINOR_VERSION 33
#if YY_FLEX_SUBMINOR_VERSION > 0 #if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA #define FLEX_BETA
#endif #endif
@ -36,6 +36,14 @@
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L #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> #include <inttypes.h>
typedef int8_t flex_int8_t; typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t; typedef uint8_t flex_uint8_t;

18
Source/cmCommandArgumentLexer.in.l
View File

@ -59,13 +59,13 @@ Modify cmCommandArgumentLexer.h:
%% %%
\$[A-Za-z0-9/_.-]+\{ { \$[A-Za-z0-9/_.+-]+\{ {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2); yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
return cal_NCURLY; return cal_NCURLY;
} }
@[A-Za-z0-9/_.-]+@ { @[A-Za-z0-9/_.+-]+@ {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2); yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
return cal_ATNAME; return cal_ATNAME;
@ -74,25 +74,25 @@ Modify cmCommandArgumentLexer.h:
"${" { "${" {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
yylvalp->str = yyextra->m_DCURLYVariable; yylvalp->str = yyextra->DCURLYVariable;
return cal_DCURLY; return cal_DCURLY;
} }
"}" { "}" {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
yylvalp->str = yyextra->m_RCURLYVariable; yylvalp->str = yyextra->RCURLYVariable;
return cal_RCURLY; return cal_RCURLY;
} }
"@" { "@" {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
yylvalp->str = yyextra->m_ATVariable; yylvalp->str = yyextra->ATVariable;
return cal_AT; return cal_AT;
} }
[A-Za-z0-9/_.-]+ { [A-Za-z0-9/_.+-]+ {
//std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl; //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
return cal_NAME; return cal_NAME;
@ -114,19 +114,19 @@ Modify cmCommandArgumentLexer.h:
"$" { "$" {
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
yylvalp->str = yyextra->m_DOLLARVariable; yylvalp->str = yyextra->DOLLARVariable;
return cal_DOLLAR; return cal_DOLLAR;
} }
"{" { "{" {
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
yylvalp->str = yyextra->m_LCURLYVariable; yylvalp->str = yyextra->LCURLYVariable;
return cal_LCURLY; return cal_LCURLY;
} }
"\\" { "\\" {
//yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext)); //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
yylvalp->str = yyextra->m_BSLASHVariable; yylvalp->str = yyextra->BSLASHVariable;
return cal_BSLASH; return cal_BSLASH;
} }

3
Tests/StringFileTest/CMakeLists.txt
View File

@ -83,7 +83,8 @@ ENDIF(NOT FILE_IS_NEWER "${file}" "${CMAKE_CURRENT_SOURCE_DIR}/InputFile.h.in")
# Test configuration of the string # Test configuration of the string
SET(TEST_DEFINED 123) SET(TEST_DEFINED 123)
SET(TEST_NOT_DEFINED) 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 # Write include file to a file
STRING(REGEX REPLACE "includefile" "${file}" outfile "${infile}") STRING(REGEX REPLACE "includefile" "${file}" outfile "${infile}")