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

Merge topic 'clang-format-lexer'

Browse Source 
030556b7 cmListFileLexer: Revise C++ coding style using clang-format
e4a92dab cmListFileLexer: Update to flex 2.6
This commit is contained in:
Brad King 2016-05-18 09:30:50 -04:00 committed by CMake Topic Stage
commit 1e876b4691
3 changed files with 1072 additions and 1088 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Source/.gitattributes vendored
View File

@ -1,2 +1,5 @@
# Preserve upstream indentation style. # Preserve upstream indentation style.
cm_sha2.* whitespace=indent-with-non-tab cm_sha2.* whitespace=indent-with-non-tab
# Preserve indentation style in generated code.
cmListFileLexer.c whitespace=-tab-in-indent,-indent-with-non-tab

1884
Source/cmListFileLexer.c
View File

File diff suppressed because it is too large Load Diff

273
Source/cmListFileLexer.in.l
View File

@ -14,19 +14,16 @@
This file must be translated to C and modified to build everywhere. This file must be translated to C and modified to build everywhere.
Run flex like this: Run flex >= 2.6 like this:
flex --prefix=cmListFileLexer_yy -ocmListFileLexer.c cmListFileLexer.in.l flex --prefix=cmListFileLexer_yy -ocmListFileLexer.c cmListFileLexer.in.l
Modify cmListFileLexer.c: Modify cmListFileLexer.c:
- remove TABs - remove trailing whitespace: sed -i 's/\s*$//' cmListFileLexer.c
- remove use of the 'register' storage class specifier - remove blank lines at end of file
- remove the yyunput function
- add a statement "(void)yyscanner;" to the top of these methods:
yy_fatal_error, cmListFileLexer_yyalloc, cmListFileLexer_yyrealloc, cmListFileLexer_yyfree
- remove statement "yyscanner = NULL;" from cmListFileLexer_yylex_destroy - remove statement "yyscanner = NULL;" from cmListFileLexer_yylex_destroy
- remove all YY_BREAK lines occurring right after return statements - remove all YY_BREAK lines occurring right after return statements
- remove the isatty forward declaration - remove unnecessary cast to (int) in yy_get_next_buffer
*/ */
@ -45,7 +42,7 @@ Modify cmListFileLexer.c:
struct cmListFileLexer_s struct cmListFileLexer_s
{ {
cmListFileLexer_Token token; cmListFileLexer_Token token;
int bracket; yy_size_t bracket;
int comment; int comment;
int line; int line;
int column; int column;
@ -102,26 +99,20 @@ LEGACY {MAKEVAR}|{UNQUOTED}|\"({MAKEVAR}|{UNQUOTED}|[ \t[=])*\"
#?\[=*\[\n? { #?\[=*\[\n? {
const char* bracket = yytext; const char* bracket = yytext;
lexer->comment = yytext[0] == '#'; lexer->comment = yytext[0] == '#';
if(lexer->comment) if (lexer->comment) {
{
lexer->token.type = cmListFileLexer_Token_CommentBracket; lexer->token.type = cmListFileLexer_Token_CommentBracket;
bracket += 1; bracket += 1;
} } else {
else
{
lexer->token.type = cmListFileLexer_Token_ArgumentBracket; lexer->token.type = cmListFileLexer_Token_ArgumentBracket;
} }
cmListFileLexerSetToken(lexer, "", 0); cmListFileLexerSetToken(lexer, "", 0);
lexer->bracket = (int)(strchr(bracket+1, '[') - bracket); lexer->bracket = strchr(bracket+1, '[') - bracket;
if(yytext[yyleng-1] == '\n') if (yytext[yyleng-1] == '\n') {
{
++lexer->line; ++lexer->line;
lexer->column = 1; lexer->column = 1;
} } else {
else
{
lexer->column += yyleng; lexer->column += yyleng;
} }
BEGIN(BRACKET); BEGIN(BRACKET);
} }
@ -159,10 +150,9 @@ LEGACY {MAKEVAR}|{UNQUOTED}|\"({MAKEVAR}|{UNQUOTED}|[ \t[=])*\"
/* Handle ]]====]=======]*/ /* Handle ]]====]=======]*/
cmListFileLexerAppend(lexer, yytext, yyleng); cmListFileLexerAppend(lexer, yytext, yyleng);
lexer->column += yyleng; lexer->column += yyleng;
if(yyleng == lexer->bracket) if (yyleng == lexer->bracket) {
{
BEGIN(BRACKETEND); BEGIN(BRACKETEND);
} }
} }
<BRACKETEND>\] { <BRACKETEND>\] {
@ -291,30 +281,25 @@ static void cmListFileLexerSetToken(cmListFileLexer* lexer, const char* text,
lexer->token.column = lexer->column; lexer->token.column = lexer->column;
/* Use the same buffer if possible. */ /* Use the same buffer if possible. */
if(lexer->token.text) if (lexer->token.text) {
{ if (text && length < lexer->size) {
if(text && length < lexer->size)
{
strcpy(lexer->token.text, text); strcpy(lexer->token.text, text);
lexer->token.length = length; lexer->token.length = length;
return; return;
} }
free(lexer->token.text); free(lexer->token.text);
lexer->token.text = 0; lexer->token.text = 0;
lexer->size = 0; lexer->size = 0;
} }
/* Need to extend the buffer. */ /* Need to extend the buffer. */
if(text) if (text) {
{
lexer->token.text = strdup(text); lexer->token.text = strdup(text);
lexer->token.length = length; lexer->token.length = length;
lexer->size = length+1; lexer->size = length + 1;
} } else {
else
{
lexer->token.length = 0; lexer->token.length = 0;
} }
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
@ -326,22 +311,20 @@ static void cmListFileLexerAppend(cmListFileLexer* lexer, const char* text,
/* If the appended text will fit in the buffer, do not reallocate. */ /* If the appended text will fit in the buffer, do not reallocate. */
newSize = lexer->token.length + length + 1; newSize = lexer->token.length + length + 1;
if(lexer->token.text && newSize <= lexer->size) if (lexer->token.text && newSize <= lexer->size) {
{ strcpy(lexer->token.text + lexer->token.length, text);
strcpy(lexer->token.text+lexer->token.length, text);
lexer->token.length += length; lexer->token.length += length;
return; return;
} }
/* We need to extend the buffer. */ /* We need to extend the buffer. */
temp = malloc(newSize); temp = malloc(newSize);
if(lexer->token.text) if (lexer->token.text) {
{
memcpy(temp, lexer->token.text, lexer->token.length); memcpy(temp, lexer->token.text, lexer->token.length);
free(lexer->token.text); free(lexer->token.text);
} }
memcpy(temp+lexer->token.length, text, length); memcpy(temp + lexer->token.length, text, length);
temp[lexer->token.length+length] = 0; temp[lexer->token.length + length] = 0;
lexer->token.text = temp; lexer->token.text = temp;
lexer->token.length += length; lexer->token.length += length;
lexer->size = newSize; lexer->size = newSize;
@ -351,96 +334,84 @@ static void cmListFileLexerAppend(cmListFileLexer* lexer, const char* text,
static int cmListFileLexerInput(cmListFileLexer* lexer, char* buffer, static int cmListFileLexerInput(cmListFileLexer* lexer, char* buffer,
size_t bufferSize) size_t bufferSize)
{ {
if(lexer) if (lexer) {
{ if (lexer->file) {
if(lexer->file)
{
/* Convert CRLF -> LF explicitly. The C FILE "t"ext mode /* Convert CRLF -> LF explicitly. The C FILE "t"ext mode
does not convert newlines on all platforms. Move any does not convert newlines on all platforms. Move any
trailing CR to the start of the buffer for the next read. */ trailing CR to the start of the buffer for the next read. */
size_t cr = lexer->cr; size_t cr = lexer->cr;
size_t n; size_t n;
buffer[0] = '\r'; buffer[0] = '\r';
n = fread(buffer+cr, 1, bufferSize-cr, lexer->file); n = fread(buffer + cr, 1, bufferSize - cr, lexer->file);
if(n) if (n) {
{
char* o = buffer; char* o = buffer;
const char* i = buffer; const char* i = buffer;
const char* e; const char* e;
n += cr; n += cr;
cr = (buffer[n-1] == '\r')? 1:0; cr = (buffer[n - 1] == '\r') ? 1 : 0;
e = buffer + n - cr; e = buffer + n - cr;
while(i != e) while (i != e) {
{ if (i[0] == '\r' && i[1] == '\n') {
if(i[0] == '\r' && i[1] == '\n')
{
++i; ++i;
}
*o++ = *i++;
} }
n = o - buffer; *o++ = *i++;
} }
else n = o - buffer;
{ } else {
n = cr; n = cr;
cr = 0; cr = 0;
} }
lexer->cr = cr; lexer->cr = cr;
return n; return n;
} } else if (lexer->string_left) {
else if(lexer->string_left)
{
int length = lexer->string_left; int length = lexer->string_left;
if((int)bufferSize < length) { length = (int)bufferSize; } if ((int)bufferSize < length) {
length = (int)bufferSize;
}
memcpy(buffer, lexer->string_position, length); memcpy(buffer, lexer->string_position, length);
lexer->string_position += length; lexer->string_position += length;
lexer->string_left -= length; lexer->string_left -= length;
return length; return length;
}
} }
}
return 0; return 0;
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
static void cmListFileLexerInit(cmListFileLexer* lexer) static void cmListFileLexerInit(cmListFileLexer* lexer)
{ {
if(lexer->file || lexer->string_buffer) if (lexer->file || lexer->string_buffer) {
{
cmListFileLexer_yylex_init(&lexer->scanner); cmListFileLexer_yylex_init(&lexer->scanner);
cmListFileLexer_yyset_extra(lexer, lexer->scanner); cmListFileLexer_yyset_extra(lexer, lexer->scanner);
} }
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
static void cmListFileLexerDestroy(cmListFileLexer* lexer) static void cmListFileLexerDestroy(cmListFileLexer* lexer)
{ {
cmListFileLexerSetToken(lexer, 0, 0); cmListFileLexerSetToken(lexer, 0, 0);
if(lexer->file || lexer->string_buffer) if (lexer->file || lexer->string_buffer) {
{
cmListFileLexer_yylex_destroy(lexer->scanner); cmListFileLexer_yylex_destroy(lexer->scanner);
if(lexer->file) if (lexer->file) {
{
fclose(lexer->file); fclose(lexer->file);
lexer->file = 0; lexer->file = 0;
} }
if(lexer->string_buffer) if (lexer->string_buffer) {
{
free(lexer->string_buffer); free(lexer->string_buffer);
lexer->string_buffer = 0; lexer->string_buffer = 0;
lexer->string_left = 0; lexer->string_left = 0;
lexer->string_position = 0; lexer->string_position = 0;
}
} }
}
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
cmListFileLexer* cmListFileLexer_New() cmListFileLexer* cmListFileLexer_New()
{ {
cmListFileLexer* lexer = (cmListFileLexer*)malloc(sizeof(cmListFileLexer)); cmListFileLexer* lexer = (cmListFileLexer*)malloc(sizeof(cmListFileLexer));
if(!lexer) if (!lexer) {
{
return 0; return 0;
} }
memset(lexer, 0, sizeof(*lexer)); memset(lexer, 0, sizeof(*lexer));
lexer->line = 1; lexer->line = 1;
lexer->column = 1; lexer->column = 1;
@ -458,39 +429,28 @@ void cmListFileLexer_Delete(cmListFileLexer* lexer)
static cmListFileLexer_BOM cmListFileLexer_ReadBOM(FILE* f) static cmListFileLexer_BOM cmListFileLexer_ReadBOM(FILE* f)
{ {
unsigned char b[2]; unsigned char b[2];
if(fread(b, 1, 2, f) == 2) if (fread(b, 1, 2, f) == 2) {
{ if (b[0] == 0xEF && b[1] == 0xBB) {
if(b[0] == 0xEF && b[1] == 0xBB) if (fread(b, 1, 1, f) == 1 && b[0] == 0xBF) {
{
if(fread(b, 1, 1, f) == 1 && b[0] == 0xBF)
{
return cmListFileLexer_BOM_UTF8; return cmListFileLexer_BOM_UTF8;
}
} }
else if(b[0] == 0xFE && b[1] == 0xFF) } else if (b[0] == 0xFE && b[1] == 0xFF) {
{
/* UTF-16 BE */ /* UTF-16 BE */
return cmListFileLexer_BOM_UTF16BE; return cmListFileLexer_BOM_UTF16BE;
} } else if (b[0] == 0 && b[1] == 0) {
else if(b[0] == 0 && b[1] == 0) if (fread(b, 1, 2, f) == 2 && b[0] == 0xFE && b[1] == 0xFF) {
{
if(fread(b, 1, 2, f) == 2 && b[0] == 0xFE && b[1] == 0xFF)
{
return cmListFileLexer_BOM_UTF32BE; return cmListFileLexer_BOM_UTF32BE;
}
} }
else if(b[0] == 0xFF && b[1] == 0xFE) } else if (b[0] == 0xFF && b[1] == 0xFE) {
{
fpos_t p; fpos_t p;
fgetpos(f, &p); fgetpos(f, &p);
if(fread(b, 1, 2, f) == 2 && b[0] == 0 && b[1] == 0) if (fread(b, 1, 2, f) == 2 && b[0] == 0 && b[1] == 0) {
{
return cmListFileLexer_BOM_UTF32LE; return cmListFileLexer_BOM_UTF32LE;
} }
fsetpos(f, &p); fsetpos(f, &p);
return cmListFileLexer_BOM_UTF16LE; return cmListFileLexer_BOM_UTF16LE;
}
} }
}
rewind(f); rewind(f);
return cmListFileLexer_BOM_None; return cmListFileLexer_BOM_None;
} }
@ -501,8 +461,7 @@ int cmListFileLexer_SetFileName(cmListFileLexer* lexer, const char* name,
{ {
int result = 1; int result = 1;
cmListFileLexerDestroy(lexer); cmListFileLexerDestroy(lexer);
if(name) if (name) {
{
#ifdef _WIN32 #ifdef _WIN32
wchar_t* wname = cmsysEncoding_DupToWide(name); wchar_t* wname = cmsysEncoding_DupToWide(name);
lexer->file = _wfopen(wname, L"rb"); lexer->file = _wfopen(wname, L"rb");
@ -510,18 +469,14 @@ int cmListFileLexer_SetFileName(cmListFileLexer* lexer, const char* name,
#else #else
lexer->file = fopen(name, "rb"); lexer->file = fopen(name, "rb");
#endif #endif
if(lexer->file) if (lexer->file) {
{ if (bom) {
if(bom)
{
*bom = cmListFileLexer_ReadBOM(lexer->file); *bom = cmListFileLexer_ReadBOM(lexer->file);
}
} }
else } else {
{
result = 0; result = 0;
}
} }
}
cmListFileLexerInit(lexer); cmListFileLexerInit(lexer);
return result; return result;
} }
@ -531,21 +486,17 @@ int cmListFileLexer_SetString(cmListFileLexer* lexer, const char* text)
{ {
int result = 1; int result = 1;
cmListFileLexerDestroy(lexer); cmListFileLexerDestroy(lexer);
if(text) if (text) {
{
int length = (int)strlen(text); int length = (int)strlen(text);
lexer->string_buffer = (char*)malloc(length+1); lexer->string_buffer = (char*)malloc(length + 1);
if(lexer->string_buffer) if (lexer->string_buffer) {
{
strcpy(lexer->string_buffer, text); strcpy(lexer->string_buffer, text);
lexer->string_position = lexer->string_buffer; lexer->string_position = lexer->string_buffer;
lexer->string_left = length; lexer->string_left = length;
} } else {
else
{
result = 0; result = 0;
}
} }
}
cmListFileLexerInit(lexer); cmListFileLexerInit(lexer);
return result; return result;
} }
@ -553,45 +504,35 @@ int cmListFileLexer_SetString(cmListFileLexer* lexer, const char* text)
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
cmListFileLexer_Token* cmListFileLexer_Scan(cmListFileLexer* lexer) cmListFileLexer_Token* cmListFileLexer_Scan(cmListFileLexer* lexer)
{ {
if(!lexer->file) if (!lexer->file) {
{
return 0; return 0;
} }
if(cmListFileLexer_yylex(lexer->scanner, lexer)) if (cmListFileLexer_yylex(lexer->scanner, lexer)) {
{
return &lexer->token; return &lexer->token;
} } else {
else
{
cmListFileLexer_SetFileName(lexer, 0, 0); cmListFileLexer_SetFileName(lexer, 0, 0);
return 0; return 0;
} }
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
long cmListFileLexer_GetCurrentLine(cmListFileLexer* lexer) long cmListFileLexer_GetCurrentLine(cmListFileLexer* lexer)
{ {
if(lexer->file) if (lexer->file) {
{
return lexer->line; return lexer->line;
} } else {
else
{
return 0; return 0;
} }
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
long cmListFileLexer_GetCurrentColumn(cmListFileLexer* lexer) long cmListFileLexer_GetCurrentColumn(cmListFileLexer* lexer)
{ {
if(lexer->file) if (lexer->file) {
{
return lexer->column; return lexer->column;
} } else {
else
{
return 0; return 0;
} }
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
@ -599,21 +540,33 @@ const char* cmListFileLexer_GetTypeAsString(cmListFileLexer* lexer,
cmListFileLexer_Type type) cmListFileLexer_Type type)
{ {
(void)lexer; (void)lexer;
switch(type) switch (type) {
{ case cmListFileLexer_Token_None:
case cmListFileLexer_Token_None: return "nothing"; return "nothing";
case cmListFileLexer_Token_Space: return "space"; case cmListFileLexer_Token_Space:
case cmListFileLexer_Token_Newline: return "newline"; return "space";
case cmListFileLexer_Token_Identifier: return "identifier"; case cmListFileLexer_Token_Newline:
case cmListFileLexer_Token_ParenLeft: return "left paren"; return "newline";
case cmListFileLexer_Token_ParenRight: return "right paren"; case cmListFileLexer_Token_Identifier:
case cmListFileLexer_Token_ArgumentUnquoted: return "unquoted argument"; return "identifier";
case cmListFileLexer_Token_ArgumentQuoted: return "quoted argument"; case cmListFileLexer_Token_ParenLeft:
case cmListFileLexer_Token_ArgumentBracket: return "bracket argument"; return "left paren";
case cmListFileLexer_Token_CommentBracket: return "bracket comment"; case cmListFileLexer_Token_ParenRight:
case cmListFileLexer_Token_BadCharacter: return "bad character"; return "right paren";
case cmListFileLexer_Token_BadBracket: return "unterminated bracket"; case cmListFileLexer_Token_ArgumentUnquoted:
case cmListFileLexer_Token_BadString: return "unterminated string"; return "unquoted argument";
} case cmListFileLexer_Token_ArgumentQuoted:
return "quoted argument";
case cmListFileLexer_Token_ArgumentBracket:
return "bracket argument";
case cmListFileLexer_Token_CommentBracket:
return "bracket comment";
case cmListFileLexer_Token_BadCharacter:
return "bad character";
case cmListFileLexer_Token_BadBracket:
return "unterminated bracket";
case cmListFileLexer_Token_BadString:
return "unterminated string";
}
return "unknown token"; return "unknown token";
} }