Index: cfe/trunk/include/clang/Basic/DiagnosticLexKinds.td =================================================================== --- cfe/trunk/include/clang/Basic/DiagnosticLexKinds.td +++ cfe/trunk/include/clang/Basic/DiagnosticLexKinds.td @@ -506,6 +506,17 @@ ExtWarn<"#pragma warning expected a warning number">, InGroup; +// - #pragma execution_character_set(...) +def warn_pragma_exec_charset_expected : + ExtWarn<"#pragma execution_character_set expected '%0'">, + InGroup; +def warn_pragma_exec_charset_spec_invalid : + ExtWarn<"#pragma execution_character_set expected 'push' or 'pop'">, + InGroup; +def warn_pragma_exec_charset_push_invalid : + ExtWarn<"#pragma execution_character_set invalid value '%0', only 'UTF-8' is supported">, + InGroup; + def err__Pragma_malformed : Error< "_Pragma takes a parenthesized string literal">; def err_pragma_message_malformed : Error< Index: cfe/trunk/include/clang/Lex/PPCallbacks.h =================================================================== --- cfe/trunk/include/clang/Lex/PPCallbacks.h +++ cfe/trunk/include/clang/Lex/PPCallbacks.h @@ -239,6 +239,14 @@ virtual void PragmaWarningPop(SourceLocation Loc) { } + /// Callback invoked when a \#pragma execution_character_set(push) directive + /// is read. + virtual void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) {} + + /// Callback invoked when a \#pragma execution_character_set(pop) directive + /// is read. + virtual void PragmaExecCharsetPop(SourceLocation Loc) {} + /// Callback invoked when a \#pragma clang assume_nonnull begin directive /// is read. virtual void PragmaAssumeNonNullBegin(SourceLocation Loc) {} @@ -477,6 +485,16 @@ Second->PragmaWarningPop(Loc); } + void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override { + First->PragmaExecCharsetPush(Loc, Str); + Second->PragmaExecCharsetPush(Loc, Str); + } + + void PragmaExecCharsetPop(SourceLocation Loc) override { + First->PragmaExecCharsetPop(Loc); + Second->PragmaExecCharsetPop(Loc); + } + void PragmaAssumeNonNullBegin(SourceLocation Loc) override { First->PragmaAssumeNonNullBegin(Loc); Second->PragmaAssumeNonNullBegin(Loc); Index: cfe/trunk/lib/Frontend/PrintPreprocessedOutput.cpp =================================================================== --- cfe/trunk/lib/Frontend/PrintPreprocessedOutput.cpp +++ cfe/trunk/lib/Frontend/PrintPreprocessedOutput.cpp @@ -143,6 +143,8 @@ ArrayRef Ids) override; void PragmaWarningPush(SourceLocation Loc, int Level) override; void PragmaWarningPop(SourceLocation Loc) override; + void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override; + void PragmaExecCharsetPop(SourceLocation Loc) override; void PragmaAssumeNonNullBegin(SourceLocation Loc) override; void PragmaAssumeNonNullEnd(SourceLocation Loc) override; @@ -553,6 +555,24 @@ setEmittedDirectiveOnThisLine(); } +void PrintPPOutputPPCallbacks::PragmaExecCharsetPush(SourceLocation Loc, + StringRef Str) { + startNewLineIfNeeded(); + MoveToLine(Loc); + OS << "#pragma character_execution_set(push"; + if (!Str.empty()) + OS << ", " << Str; + OS << ')'; + setEmittedDirectiveOnThisLine(); +} + +void PrintPPOutputPPCallbacks::PragmaExecCharsetPop(SourceLocation Loc) { + startNewLineIfNeeded(); + MoveToLine(Loc); + OS << "#pragma character_execution_set(pop)"; + setEmittedDirectiveOnThisLine(); +} + void PrintPPOutputPPCallbacks:: PragmaAssumeNonNullBegin(SourceLocation Loc) { startNewLineIfNeeded(); Index: cfe/trunk/lib/Lex/Pragma.cpp =================================================================== --- cfe/trunk/lib/Lex/Pragma.cpp +++ cfe/trunk/lib/Lex/Pragma.cpp @@ -1368,6 +1368,70 @@ } }; +/// "\#pragma execution_character_set(...)". MSVC supports this pragma only +/// for "UTF-8". We parse it and ignore it if UTF-8 is provided and warn +/// otherwise to avoid -Wunknown-pragma warnings. +struct PragmaExecCharsetHandler : public PragmaHandler { + PragmaExecCharsetHandler() : PragmaHandler("execution_character_set") {} + + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &Tok) override { + // Parse things like: + // execution_character_set(push, "UTF-8") + // execution_character_set(pop) + SourceLocation DiagLoc = Tok.getLocation(); + PPCallbacks *Callbacks = PP.getPPCallbacks(); + + PP.Lex(Tok); + if (Tok.isNot(tok::l_paren)) { + PP.Diag(Tok, diag::warn_pragma_exec_charset_expected) << "("; + return; + } + + PP.Lex(Tok); + IdentifierInfo *II = Tok.getIdentifierInfo(); + + if (II && II->isStr("push")) { + // #pragma execution_character_set( push[ , string ] ) + PP.Lex(Tok); + if (Tok.is(tok::comma)) { + PP.Lex(Tok); + + std::string ExecCharset; + if (!PP.FinishLexStringLiteral(Tok, ExecCharset, + "pragma execution_character_set", + /*MacroExpansion=*/false)) + return; + + // MSVC supports either of these, but nothing else. + if (ExecCharset != "UTF-8" && ExecCharset != "utf-8") { + PP.Diag(Tok, diag::warn_pragma_exec_charset_push_invalid) << ExecCharset; + return; + } + } + if (Callbacks) + Callbacks->PragmaExecCharsetPush(DiagLoc, "UTF-8"); + } else if (II && II->isStr("pop")) { + // #pragma execution_character_set( pop ) + PP.Lex(Tok); + if (Callbacks) + Callbacks->PragmaExecCharsetPop(DiagLoc); + } else { + PP.Diag(Tok, diag::warn_pragma_exec_charset_spec_invalid); + return; + } + + if (Tok.isNot(tok::r_paren)) { + PP.Diag(Tok, diag::warn_pragma_exec_charset_expected) << ")"; + return; + } + + PP.Lex(Tok); + if (Tok.isNot(tok::eod)) + PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma execution_character_set"; + } +}; + /// PragmaIncludeAliasHandler - "\#pragma include_alias("...")". struct PragmaIncludeAliasHandler : public PragmaHandler { PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {} @@ -1823,6 +1887,7 @@ // MS extensions. if (LangOpts.MicrosoftExt) { AddPragmaHandler(new PragmaWarningHandler()); + AddPragmaHandler(new PragmaExecCharsetHandler()); AddPragmaHandler(new PragmaIncludeAliasHandler()); AddPragmaHandler(new PragmaHdrstopHandler()); } Index: cfe/trunk/test/Preprocessor/pragma_microsoft.c =================================================================== --- cfe/trunk/test/Preprocessor/pragma_microsoft.c +++ cfe/trunk/test/Preprocessor/pragma_microsoft.c @@ -198,3 +198,21 @@ #pragma optimize("g", // expected-warning{{missing argument to '#pragma optimize'; expected 'on' or 'off'}} #pragma optimize("g",xyz // expected-warning{{unexpected argument 'xyz' to '#pragma optimize'; expected 'on' or 'off'}} #pragma optimize("g",on) // expected-warning{{#pragma optimize' is not supported}} + +#pragma execution_character_set // expected-warning {{expected '('}} +#pragma execution_character_set( // expected-warning {{expected 'push' or 'pop'}} +#pragma execution_character_set() // expected-warning {{expected 'push' or 'pop'}} +#pragma execution_character_set(asdf // expected-warning {{expected 'push' or 'pop'}} +#pragma execution_character_set(asdf) // expected-warning {{expected 'push' or 'pop'}} +#pragma execution_character_set(push // expected-warning {{expected ')'}} +#pragma execution_character_set(pop,) // expected-warning {{expected ')'}} +#pragma execution_character_set(pop,"asdf") // expected-warning {{expected ')'}} +#pragma execution_character_set(push, // expected-error {{expected string literal}} +#pragma execution_character_set(push,) // expected-error {{expected string literal}} +#pragma execution_character_set(push,asdf) // expected-error {{expected string literal}} +#pragma execution_character_set(push, "asdf") // expected-warning {{only 'UTF-8' is supported}} + +#pragma execution_character_set(push) +#pragma execution_character_set(push, "utf-8") +#pragma execution_character_set(push, "UTF-8") +#pragma execution_character_set(pop) \ No newline at end of file Index: clang-tools-extra/trunk/pp-trace/PPCallbacksTracker.h =================================================================== --- clang-tools-extra/trunk/pp-trace/PPCallbacksTracker.h +++ clang-tools-extra/trunk/pp-trace/PPCallbacksTracker.h @@ -134,6 +134,9 @@ llvm::ArrayRef Ids) override; void PragmaWarningPush(clang::SourceLocation Loc, int Level) override; void PragmaWarningPop(clang::SourceLocation Loc) override; + void PragmaExecCharsetPush(clang::SourceLocation Loc, + clang::StringRef Str) override; + void PragmaExecCharsetPop(clang::SourceLocation Loc) override; void MacroExpands(const clang::Token &MacroNameTok, const clang::MacroDefinition &MD, clang::SourceRange Range, const clang::MacroArgs *Args) override; Index: clang-tools-extra/trunk/pp-trace/PPCallbacksTracker.cpp =================================================================== --- clang-tools-extra/trunk/pp-trace/PPCallbacksTracker.cpp +++ clang-tools-extra/trunk/pp-trace/PPCallbacksTracker.cpp @@ -297,6 +297,22 @@ appendArgument("Loc", Loc); } +// Callback invoked when a #pragma execution_character_set(push) directive +// is read. +void PPCallbacksTracker::PragmaExecCharsetPush(clang::SourceLocation Loc, + clang::StringRef Str) { + beginCallback("PragmaExecCharsetPush"); + appendArgument("Loc", Loc); + appendArgument("Charset", Str); +} + +// Callback invoked when a #pragma execution_character_set(pop) directive +// is read. +void PPCallbacksTracker::PragmaExecCharsetPop(clang::SourceLocation Loc) { + beginCallback("PragmaExecCharsetPop"); + appendArgument("Loc", Loc); +} + // Called by Preprocessor::HandleMacroExpandedIdentifier when a // macro invocation is found. void