Index: tools/clang/include/clang/Basic/DiagnosticCommonKinds.td ================================================================== --- tools/clang/include/clang/Basic/DiagnosticCommonKinds.td +++ tools/clang/include/clang/Basic/DiagnosticCommonKinds.td @@ -39,10 +39,11 @@ // Parse && Lex def err_expected_colon : Error<"expected ':'">; def err_expected_colon_after_setter_name : Error< "method name referenced in property setter attribute " "must end with ':'">; +def err_expected_string_literal : Error<"expected string literal">; def err_invalid_string_udl : Error< "string literal with user-defined suffix cannot be used here">; def err_invalid_character_udl : Error< "character literal with user-defined suffix cannot be used here">; def err_invalid_numeric_udl : Error< Index: tools/clang/include/clang/Basic/DiagnosticParseKinds.td ================================================================== --- tools/clang/include/clang/Basic/DiagnosticParseKinds.td +++ tools/clang/include/clang/Basic/DiagnosticParseKinds.td @@ -229,11 +229,10 @@ "did you mean to use %0 as the selector name instead of %1">; def err_label_end_of_compound_statement : Error< "label at end of compound statement: expected statement">; def err_address_of_label_outside_fn : Error< "use of address-of-label extension outside of a function body">; -def err_expected_string_literal : Error<"expected string literal">; def err_asm_operand_wide_string_literal : Error< "cannot use %select{unicode|wide}0 string literal in 'asm'">; def err_expected_selector_for_method : Error< "expected selector for Objective-C method">; def err_expected_property_name : Error<"expected property name">; Index: tools/clang/include/clang/Lex/Preprocessor.h ================================================================== --- tools/clang/include/clang/Lex/Preprocessor.h +++ tools/clang/include/clang/Lex/Preprocessor.h @@ -693,10 +693,27 @@ case CLK_LexAfterModuleImport: LexAfterModuleImport(Result); break; } } void LexAfterModuleImport(Token &Result); + + /// \brief Lex a string literal, which may be the concatenation of multiple + /// string literals and may even come from macro expansion. + /// \returns true on success, false if a error diagnostic has been generated. + bool LexStringLiteral(Token &Result, std::string &String, + bool AllowMacroExpansion) { + if (AllowMacroExpansion) + Lex(Result); + else + LexUnexpandedToken(Result); + return FinishLexStringLiteral(Result, String, AllowMacroExpansion); + } + + /// \brief Complete the lexing of a string literal where the first token has + /// already been lexed (see LexStringLiteral). + bool FinishLexStringLiteral(Token &Result, std::string &String, + bool AllowMacroExpansion); /// LexNonComment - Lex a token. If it's a comment, keep lexing until we get /// something not a comment. This is useful in -E -C mode where comments /// would foul up preprocessor directive handling. void LexNonComment(Token &Result) { Index: tools/clang/lib/Lex/PPMacroExpansion.cpp ================================================================== --- tools/clang/lib/Lex/PPMacroExpansion.cpp +++ tools/clang/lib/Lex/PPMacroExpansion.cpp @@ -19,11 +19,11 @@ #include "clang/Basic/FileManager.h" #include "clang/Basic/TargetInfo.h" #include "clang/Lex/LexDiagnostic.h" #include "clang/Lex/CodeCompletionHandler.h" #include "clang/Lex/ExternalPreprocessorSource.h" -#include "clang/Lex/LiteralSupport.h" +#include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Config/llvm-config.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Support/ErrorHandling.h" @@ -1275,73 +1275,50 @@ Tok.setKind(tok::numeric_constant); } else if (II == Ident__has_warning) { // The argument should be a parenthesized string literal. // The argument to these builtins should be a parenthesized identifier. SourceLocation StartLoc = Tok.getLocation(); - bool IsValid = false; bool Value = false; // Read the '('. - Lex(Tok); + LexUnexpandedToken(Tok); do { - if (Tok.is(tok::l_paren)) { - // Read the string. - Lex(Tok); - - // We need at least one string literal. - if (!Tok.is(tok::string_literal)) { - StartLoc = Tok.getLocation(); - IsValid = false; - // Eat tokens until ')'. - do Lex(Tok); while (!(Tok.is(tok::r_paren) || Tok.is(tok::eod))); - break; - } - - // String concatenation allows multiple strings, which can even come - // from macro expansion. - SmallVector StrToks; - while (Tok.is(tok::string_literal)) { - // Complain about, and drop, any ud-suffix. - if (Tok.hasUDSuffix()) - Diag(Tok, diag::err_invalid_string_udl); - StrToks.push_back(Tok); + if (Tok.isNot(tok::l_paren)) { + Diag(StartLoc, diag::err_warning_check_malformed); + break; + } + + LexUnexpandedToken(Tok); + std::string WarningName; + SourceLocation StrStartLoc = Tok.getLocation(); + if (!FinishLexStringLiteral(Tok, WarningName, /*MacroExpansion=*/false)) { + // Eat tokens until ')'. + do { LexUnexpandedToken(Tok); - } - - // Is the end a ')'? - if (!(IsValid = Tok.is(tok::r_paren))) - break; - - // Concatenate and parse the strings. - StringLiteralParser Literal(&StrToks[0], StrToks.size(), *this); - assert(Literal.isAscii() && "Didn't allow wide strings in"); - if (Literal.hadError) - break; - if (Literal.Pascal) { - Diag(Tok, diag::warn_pragma_diagnostic_invalid); - break; - } - - StringRef WarningName(Literal.GetString()); - - if (WarningName.size() < 3 || WarningName[0] != '-' || - WarningName[1] != 'W') { - Diag(StrToks[0].getLocation(), diag::warn_has_warning_invalid_option); - break; - } - - // Finally, check if the warning flags maps to a diagnostic group. - // We construct a SmallVector here to talk to getDiagnosticIDs(). - // Although we don't use the result, this isn't a hot path, and not - // worth special casing. - llvm::SmallVector Diags; - Value = !getDiagnostics().getDiagnosticIDs()-> - getDiagnosticsInGroup(WarningName.substr(2), Diags); + } while (Tok.isNot(tok::r_paren)&& Tok.isNot(tok::eod)); + break; + } + + // Is the end a ')'? + if (Tok.isNot(tok::r_paren)) { + Diag(StartLoc, diag::err_warning_check_malformed); + break; + } + + if (WarningName.size() < 3 || WarningName[0] != '-' || + WarningName[1] != 'W') { + Diag(StrStartLoc, diag::warn_has_warning_invalid_option); + break; } + + // Finally, check if the warning flags maps to a diagnostic group. + // We construct a SmallVector here to talk to getDiagnosticIDs(). + // Although we don't use the result, this isn't a hot path, and not + // worth special casing. + llvm::SmallVector Diags; + Value = !getDiagnostics().getDiagnosticIDs()-> + getDiagnosticsInGroup(WarningName.substr(2), Diags); } while (false); - - if (!IsValid) - Diag(StartLoc, diag::err_warning_check_malformed); OS << (int)Value; Tok.setKind(tok::numeric_constant); } else if (II == Ident__building_module) { // The argument to this builtin should be an identifier. The Index: tools/clang/lib/Lex/Pragma.cpp ================================================================== --- tools/clang/lib/Lex/Pragma.cpp +++ tools/clang/lib/Lex/Pragma.cpp @@ -500,42 +500,13 @@ } // Read the optional string if present. Lex(Tok); std::string ArgumentString; - if (Tok.is(tok::comma)) { - Lex(Tok); // eat the comma. - - // We need at least one string. - if (Tok.isNot(tok::string_literal)) { - Diag(Tok.getLocation(), diag::err_pragma_comment_malformed); - return; - } - - // String concatenation allows multiple strings, which can even come from - // macro expansion. - // "foo " "bar" "Baz" - SmallVector StrToks; - while (Tok.is(tok::string_literal)) { - if (Tok.hasUDSuffix()) - Diag(Tok, diag::err_invalid_string_udl); - StrToks.push_back(Tok); - Lex(Tok); - } - - // Concatenate and parse the strings. - StringLiteralParser Literal(&StrToks[0], StrToks.size(), *this); - assert(Literal.isAscii() && "Didn't allow wide strings in"); - if (Literal.hadError) - return; - if (Literal.Pascal) { - Diag(StrToks[0].getLocation(), diag::err_pragma_comment_malformed); - return; - } - - ArgumentString = Literal.GetString(); - } + if (Tok.is(tok::comma) && !LexStringLiteral(Tok, ArgumentString, + /*MacroExpansion=*/true)) + return; // FIXME: If the kind is "compiler" warn if the string is present (it is // ignored). // FIXME: 'lib' requires a comment string. // FIXME: 'linker' requires a comment string, and has a specific list of @@ -585,38 +556,13 @@ default: Diag(MessageLoc, diag::err_pragma_message_malformed); return; } - // We need at least one string. - if (Tok.isNot(tok::string_literal)) { - Diag(Tok.getLocation(), diag::err_pragma_message_malformed); + std::string MessageString; + if (!FinishLexStringLiteral(Tok, MessageString, /*MacroExpansion=*/true)) return; - } - - // String concatenation allows multiple strings, which can even come from - // macro expansion. - // "foo " "bar" "Baz" - SmallVector StrToks; - while (Tok.is(tok::string_literal)) { - if (Tok.hasUDSuffix()) - Diag(Tok, diag::err_invalid_string_udl); - StrToks.push_back(Tok); - Lex(Tok); - } - - // Concatenate and parse the strings. - StringLiteralParser Literal(&StrToks[0], StrToks.size(), *this); - assert(Literal.isAscii() && "Didn't allow wide strings in"); - if (Literal.hadError) - return; - if (Literal.Pascal) { - Diag(StrToks[0].getLocation(), diag::err_pragma_message_malformed); - return; - } - - StringRef MessageString(Literal.GetString()); if (ExpectClosingParen) { if (Tok.isNot(tok::r_paren)) { Diag(Tok.getLocation(), diag::err_pragma_message_malformed); return; @@ -1088,54 +1034,31 @@ PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); return; } PP.LexUnexpandedToken(Tok); + SourceLocation StringLoc = Tok.getLocation(); - // We need at least one string. - if (Tok.isNot(tok::string_literal)) { - PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token); + std::string WarningName; + if (!PP.FinishLexStringLiteral(Tok, WarningName, /*MacroExpansion=*/false)) return; - } - - // String concatenation allows multiple strings, which can even come from - // macro expansion. - // "foo " "bar" "Baz" - SmallVector StrToks; - while (Tok.is(tok::string_literal)) { - StrToks.push_back(Tok); - PP.LexUnexpandedToken(Tok); - } if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token); return; } - // Concatenate and parse the strings. - StringLiteralParser Literal(&StrToks[0], StrToks.size(), PP); - assert(Literal.isAscii() && "Didn't allow wide strings in"); - if (Literal.hadError) - return; - if (Literal.Pascal) { - PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); - return; - } - - StringRef WarningName(Literal.GetString()); - if (WarningName.size() < 3 || WarningName[0] != '-' || WarningName[1] != 'W') { - PP.Diag(StrToks[0].getLocation(), - diag::warn_pragma_diagnostic_invalid_option); + PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option); return; } if (PP.getDiagnostics().setDiagnosticGroupMapping(WarningName.substr(2), Map, DiagLoc)) - PP.Diag(StrToks[0].getLocation(), - diag::warn_pragma_diagnostic_unknown_warning) << WarningName; + PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning) + << WarningName; else if (Callbacks) Callbacks->PragmaDiagnostic(DiagLoc, Namespace, Map, WarningName); } }; Index: tools/clang/lib/Lex/Preprocessor.cpp ================================================================== --- tools/clang/lib/Lex/Preprocessor.cpp +++ tools/clang/lib/Lex/Preprocessor.cpp @@ -35,10 +35,11 @@ #include "clang/Lex/PreprocessingRecord.h" #include "clang/Lex/ScratchBuffer.h" #include "clang/Lex/LexDiagnostic.h" #include "clang/Lex/CodeCompletionHandler.h" #include "clang/Lex/ModuleLoader.h" +#include "clang/Lex/LiteralSupport.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/TargetInfo.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/SmallString.h" @@ -686,10 +687,48 @@ /*IsIncludeDirective=*/false); if (Callbacks) Callbacks->moduleImport(ModuleImportLoc, ModuleImportPath, Imported); } } + +bool Preprocessor::FinishLexStringLiteral(Token &Result, std::string &String, + bool AllowMacroExpansion) { + // We need at least one string literal. + if (Result.isNot(tok::string_literal)) { + Diag(Result, diag::err_expected_string_literal); + return false; + } + + // Lex string literal tokens, optionally with macro expansion. + SmallVector StrToks; + do { + StrToks.push_back(Result); + + if (Result.hasUDSuffix()) + Diag(Result, diag::err_invalid_string_udl); + + if (AllowMacroExpansion) + Lex(Result); + else + LexUnexpandedToken(Result); + } while (Result.is(tok::string_literal)); + + // Concatenate and parse the strings. + StringLiteralParser Literal(&StrToks[0], StrToks.size(), *this); + assert(Literal.isAscii() && "Didn't allow wide strings in"); + + if (Literal.hadError) + return false; + + if (Literal.Pascal) { + Diag(StrToks[0].getLocation(), diag::err_expected_string_literal); + return false; + } + + String = Literal.GetString(); + return true; +} void Preprocessor::addCommentHandler(CommentHandler *Handler) { assert(Handler && "NULL comment handler"); assert(std::find(CommentHandlers.begin(), CommentHandlers.end(), Handler) == CommentHandlers.end() && "Comment handler already registered"); Index: tools/clang/test/Preprocessor/pragma_diagnostic.c ================================================================== --- tools/clang/test/Preprocessor/pragma_diagnostic.c +++ tools/clang/test/Preprocessor/pragma_diagnostic.c @@ -21,12 +21,12 @@ #define foo error #pragma GCC diagnostic foo "-Wundef" // expected-warning {{pragma diagnostic expected 'error', 'warning', 'ignored', 'fatal', 'push', or 'pop'}} -#pragma GCC diagnostic error 42 // expected-warning {{unexpected token in pragma diagnostic}} +#pragma GCC diagnostic error 42 // expected-error {{expected string literal}} #pragma GCC diagnostic error "-Wundef" 42 // expected-warning {{unexpected token in pragma diagnostic}} #pragma GCC diagnostic error "invalid-name" // expected-warning {{pragma diagnostic expected option name (e.g. "-Wundef")}} #pragma GCC diagnostic error "-Winvalid-name" // expected-warning {{unknown warning group '-Winvalid-name', ignored}} Index: tools/clang/test/Preprocessor/pragma_microsoft.c ================================================================== --- tools/clang/test/Preprocessor/pragma_microsoft.c +++ tools/clang/test/Preprocessor/pragma_microsoft.c @@ -9,11 +9,11 @@ #pragma comment(linker," bar=" BAR) #pragma comment( user, "Compiled on " __DATE__ " at " __TIME__ ) #pragma comment(foo) // expected-error {{unknown kind of pragma comment}} -#pragma comment(compiler,) // expected-error {{pragma comment requires}} +#pragma comment(compiler,) // expected-error {{expected string literal}} #define foo compiler #pragma comment(foo) // macro expand kind. #pragma comment(foo) x // expected-error {{pragma comment requires}} #pragma comment(user, "foo\abar\nbaz\tsome thing") Index: tools/clang/test/Preprocessor/warning_tests.c ================================================================== --- tools/clang/test/Preprocessor/warning_tests.c +++ tools/clang/test/Preprocessor/warning_tests.c @@ -9,13 +9,17 @@ // expected-warning@+2 {{Should have -Wparentheses}} #if __has_warning("-Wparentheses") #warning Should have -Wparentheses #endif -#if __has_warning(-Wfoo) // expected-error {{builtin warning check macro requires a parenthesized string}} +#if __has_warning(-Wfoo) // expected-error {{expected string literal}} #endif // expected-warning@+3 {{Not a valid warning flag}} #if __has_warning("-Wnot-a-valid-warning-flag-at-all") #else #warning Not a valid warning flag #endif + +// expected-error@+1 {{builtin warning check macro requires a parenthesized string}} +#if __has_warning "not valid" +#endif