From 9399945f1a72cc424415dcb3ce52a6ac1677f514 Mon Sep 17 00:00:00 2001 From: Viktoria Maksimova Date: Thu, 29 Jul 2021 16:20:32 +0300 Subject: [PATCH] Revert "[Preprocessor] Implement -fminimize-whitespace." This reverts commit ae6b40000238e5faaaa319ffcfc713a15e459be8 to unblock the llorg->sycl pulldown. This fixes SYCL::fsycl-save-temps and SYCL::warnings failures which are soon expected to be addressed in community. --- clang/docs/ClangCommandLineReference.rst | 10 - .../clang/Basic/DiagnosticDriverKinds.td | 2 - clang/include/clang/Driver/Options.td | 3 - clang/include/clang/Driver/Types.h | 8 - .../Frontend/PreprocessorOutputOptions.h | 2 - clang/lib/Driver/ToolChains/Clang.cpp | 15 +- clang/lib/Driver/Types.cpp | 39 -- .../lib/Frontend/PrintPreprocessedOutput.cpp | 349 +++++++----------- clang/lib/Lex/Preprocessor.cpp | 6 - clang/test/Preprocessor/comment_save.c | 1 - clang/test/Preprocessor/first-line-indent.c | 7 - clang/test/Preprocessor/hash_line.c | 4 - .../line-directive-output-mincol.c | 11 - .../test/Preprocessor/line-directive-output.c | 1 - clang/test/Preprocessor/macro_space.c | 9 - .../minimize-whitespace-messages.c | 8 - clang/test/Preprocessor/minimize-whitespace.c | 55 --- clang/test/Preprocessor/print_line_include.c | 3 - clang/test/Preprocessor/stringize_space.c | 6 +- 19 files changed, 144 insertions(+), 395 deletions(-) delete mode 100644 clang/test/Preprocessor/line-directive-output-mincol.c delete mode 100644 clang/test/Preprocessor/minimize-whitespace-messages.c delete mode 100644 clang/test/Preprocessor/minimize-whitespace.c diff --git a/clang/docs/ClangCommandLineReference.rst b/clang/docs/ClangCommandLineReference.rst index 35a3fdd382b41..74557c5bd5814 100644 --- a/clang/docs/ClangCommandLineReference.rst +++ b/clang/docs/ClangCommandLineReference.rst @@ -2475,16 +2475,6 @@ Turn on loop unroller Use #line in preprocessed output -.. option:: -fminimize-whitespace, -fno-minimize-whitespace - -Ignore the whitespace from the input file when emitting preprocessor -output. It will only contain whitespace when necessary, e.g. to keep two -minus signs from merging into to an increment operator. Useful with the --P option to normalize whitespace such that two files with only formatting -changes are equal. - -Only valid with -E on C-like inputs and incompatible with -traditional-cpp. - .. option:: -fvalidate-ast-input-files-content Compute and store the hash of input files used to build an AST. Files with mismatching mtime's are considered valid if both contents is identical diff --git a/clang/include/clang/Basic/DiagnosticDriverKinds.td b/clang/include/clang/Basic/DiagnosticDriverKinds.td index 19599fa6b6ce3..33924090f1b3c 100644 --- a/clang/include/clang/Basic/DiagnosticDriverKinds.td +++ b/clang/include/clang/Basic/DiagnosticDriverKinds.td @@ -144,8 +144,6 @@ def warn_drv_mismatch_fpga_archive : Warning< def err_drv_unsupported_opt_dpcpp : Error<"option '%0' unsupported with DPC++">; def err_drv_argument_only_allowed_with : Error< "invalid argument '%0' only allowed with '%1'">; -def err_drv_minws_unsupported_input_type : Error< - "'-fminimize-whitespace' invalid for input of type %0">; def err_drv_amdgpu_ieee_without_no_honor_nans : Error< "invalid argument '-mno-amdgpu-ieee' only allowed with relaxed NaN handling">; def err_drv_argument_not_allowed_with : Error< diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index e00c7476c3c38..03d99535e8b73 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -1820,9 +1820,6 @@ def frewrite_map_file_EQ : Joined<["-"], "frewrite-map-file=">, defm use_line_directives : BoolFOption<"use-line-directives", PreprocessorOutputOpts<"UseLineDirectives">, DefaultFalse, PosFlag, NegFlag>; -defm minimize_whitespace : BoolFOption<"minimize-whitespace", - PreprocessorOutputOpts<"MinimizeWhitespace">, DefaultFalse, - PosFlag, NegFlag>; def ffreestanding : Flag<["-"], "ffreestanding">, Group, Flags<[CC1Option]>, HelpText<"Assert that the compilation takes place in a freestanding environment">, diff --git a/clang/include/clang/Driver/Types.h b/clang/include/clang/Driver/Types.h index 11d46fe8b6bc9..773182a1ebb3d 100644 --- a/clang/include/clang/Driver/Types.h +++ b/clang/include/clang/Driver/Types.h @@ -66,14 +66,6 @@ namespace types { /// isAcceptedByClang - Can clang handle this input type. bool isAcceptedByClang(ID Id); - /// isDerivedFromC - Is the input derived from C. - /// - /// That is, does the lexer follow the rules of - /// TokenConcatenation::AvoidConcat. If this is the case, the preprocessor may - /// add and remove whitespace between tokens. Used to determine whether the - /// input can be processed by -fminimize-whitespace. - bool isDerivedFromC(ID Id); - /// isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers). bool isCXX(ID Id); diff --git a/clang/include/clang/Frontend/PreprocessorOutputOptions.h b/clang/include/clang/Frontend/PreprocessorOutputOptions.h index 257538ee06065..72e5ad1137fb7 100644 --- a/clang/include/clang/Frontend/PreprocessorOutputOptions.h +++ b/clang/include/clang/Frontend/PreprocessorOutputOptions.h @@ -24,7 +24,6 @@ class PreprocessorOutputOptions { unsigned ShowIncludeDirectives : 1; ///< Print includes, imports etc. within preprocessed output. unsigned RewriteIncludes : 1; ///< Preprocess include directives only. unsigned RewriteImports : 1; ///< Include contents of transitively-imported modules. - unsigned MinimizeWhitespace : 1; ///< Ignore whitespace from input. public: PreprocessorOutputOptions() { @@ -37,7 +36,6 @@ class PreprocessorOutputOptions { ShowIncludeDirectives = 0; RewriteIncludes = 0; RewriteImports = 0; - MinimizeWhitespace = 0; } }; diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index 0e37152b361fd..4ccbb28eafac6 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -56,9 +56,8 @@ using namespace clang; using namespace llvm::opt; static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) { - if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC, - options::OPT_fminimize_whitespace, - options::OPT_fno_minimize_whitespace)) { + if (Arg *A = + Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC)) { if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) && !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) { D.Diag(clang::diag::err_drv_argument_only_allowed_with) @@ -6516,16 +6515,6 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, options::OPT_fno_use_line_directives, false)) CmdArgs.push_back("-fuse-line-directives"); - // -fno-minimize-whitespace is default. - if (Args.hasFlag(options::OPT_fminimize_whitespace, - options::OPT_fno_minimize_whitespace, false)) { - types::ID InputType = Inputs[0].getType(); - if (!isDerivedFromC(InputType)) - D.Diag(diag::err_drv_minws_unsupported_input_type) - << types::getTypeName(InputType); - CmdArgs.push_back("-fminimize-whitespace"); - } - // -fms-extensions=0 is default. if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, IsWindowsMSVC)) diff --git a/clang/lib/Driver/Types.cpp b/clang/lib/Driver/Types.cpp index d3918dae1b378..64d036de1d98e 100644 --- a/clang/lib/Driver/Types.cpp +++ b/clang/lib/Driver/Types.cpp @@ -148,45 +148,6 @@ bool types::isAcceptedByClang(ID Id) { } } -bool types::isDerivedFromC(ID Id) { - switch (Id) { - default: - return false; - - case TY_PP_C: - case TY_C: - case TY_CL: - case TY_CLCXX: - case TY_PP_CUDA: - case TY_CUDA: - case TY_CUDA_DEVICE: - case TY_PP_HIP: - case TY_HIP: - case TY_HIP_DEVICE: - case TY_PP_ObjC: - case TY_PP_ObjC_Alias: - case TY_ObjC: - case TY_PP_CXX: - case TY_CXX: - case TY_PP_ObjCXX: - case TY_PP_ObjCXX_Alias: - case TY_ObjCXX: - case TY_RenderScript: - case TY_PP_CHeader: - case TY_CHeader: - case TY_CLHeader: - case TY_PP_ObjCHeader: - case TY_ObjCHeader: - case TY_PP_CXXHeader: - case TY_CXXHeader: - case TY_PP_ObjCXXHeader: - case TY_ObjCXXHeader: - case TY_CXXModule: - case TY_PP_CXXModule: - return true; - } -} - bool types::isObjC(ID Id) { switch (Id) { default: diff --git a/clang/lib/Frontend/PrintPreprocessedOutput.cpp b/clang/lib/Frontend/PrintPreprocessedOutput.cpp index b7259569595d6..24ea1ccba207f 100644 --- a/clang/lib/Frontend/PrintPreprocessedOutput.cpp +++ b/clang/lib/Frontend/PrintPreprocessedOutput.cpp @@ -95,20 +95,14 @@ class PrintPPOutputPPCallbacks : public PPCallbacks { bool DumpIncludeDirectives; bool UseLineDirectives; bool IsFirstFileEntered; - bool MinimizeWhitespace; - - Token PrevTok; - Token PrevPrevTok; - public: PrintPPOutputPPCallbacks(Preprocessor &pp, raw_ostream &os, bool lineMarkers, bool defines, bool DumpIncludeDirectives, - bool UseLineDirectives, bool MinimizeWhitespace) + bool UseLineDirectives) : PP(pp), SM(PP.getSourceManager()), ConcatInfo(PP), OS(os), DisableLineMarkers(lineMarkers), DumpDefines(defines), DumpIncludeDirectives(DumpIncludeDirectives), - UseLineDirectives(UseLineDirectives), - MinimizeWhitespace(MinimizeWhitespace) { + UseLineDirectives(UseLineDirectives) { CurLine = 0; CurFilename += ""; EmittedTokensOnThisLine = false; @@ -116,13 +110,8 @@ class PrintPPOutputPPCallbacks : public PPCallbacks { FileType = SrcMgr::C_User; Initialized = false; IsFirstFileEntered = false; - - PrevTok.startToken(); - PrevPrevTok.startToken(); } - bool isMinimizeWhitespace() const { return MinimizeWhitespace; } - void setEmittedTokensOnThisLine() { EmittedTokensOnThisLine = true; } bool hasEmittedTokensOnThisLine() const { return EmittedTokensOnThisLine; } @@ -131,12 +120,7 @@ class PrintPPOutputPPCallbacks : public PPCallbacks { return EmittedDirectiveOnThisLine; } - /// Ensure that the output stream position is at the beginning of a new line - /// and inserts one if it does not. It is intended to ensure that directives - /// inserted by the directives not from the input source (such as #line) are - /// in the first column. To insert newlines that represent the input, use - /// MoveToLine(/*...*/, /*RequireStartOfLine=*/true). - void startNewLineIfNeeded(); + bool startNewLineIfNeeded(bool ShouldUpdateCurrentLine = true); void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, @@ -164,45 +148,18 @@ class PrintPPOutputPPCallbacks : public PPCallbacks { void PragmaAssumeNonNullBegin(SourceLocation Loc) override; void PragmaAssumeNonNullEnd(SourceLocation Loc) override; - /// Insert whitespace before emitting the next token. - /// - /// @param Tok Next token to be emitted. - /// @param RequireSpace Ensure at least one whitespace is emitted. Useful - /// if non-tokens have been emitted to the stream. - /// @param RequireSameLine Never emit newlines. Useful when semantics depend - /// on being on the same line, such as directives. - void HandleWhitespaceBeforeTok(const Token &Tok, bool RequireSpace, - bool RequireSameLine); + bool HandleFirstTokOnLine(Token &Tok); /// Move to the line of the provided source location. This will - /// return true if a newline was inserted or if - /// the requested location is the first token on the first line. - /// In these cases the next output will be the first column on the line and - /// make it possible to insert indention. The newline was inserted - /// implicitly when at the beginning of the file. - /// - /// @param Tok Token where to move to. - /// @param RequiresStartOfLine Whether the next line depends on being in the - /// first column, such as a directive. - /// - /// @return Whether column adjustments are necessary. - bool MoveToLine(const Token &Tok, bool RequireStartOfLine) { - PresumedLoc PLoc = SM.getPresumedLoc(Tok.getLocation()); - if (PLoc.isInvalid()) - return false; - bool IsFirstInFile = Tok.isAtStartOfLine() && PLoc.getLine() == 1; - return MoveToLine(PLoc.getLine(), RequireStartOfLine) || IsFirstInFile; - } - - /// Move to the line of the provided source location. Returns true if a new - /// line was inserted. - bool MoveToLine(SourceLocation Loc, bool RequireStartOfLine) { + /// return true if the output stream required adjustment or if + /// the requested location is on the first line. + bool MoveToLine(SourceLocation Loc) { PresumedLoc PLoc = SM.getPresumedLoc(Loc); if (PLoc.isInvalid()) return false; - return MoveToLine(PLoc.getLine(), RequireStartOfLine); + return MoveToLine(PLoc.getLine()) || (PLoc.getLine() == 1); } - bool MoveToLine(unsigned LineNo, bool RequireStartOfLine); + bool MoveToLine(unsigned LineNo); bool AvoidConcat(const Token &PrevPrevTok, const Token &PrevTok, const Token &Tok) { @@ -230,7 +187,7 @@ class PrintPPOutputPPCallbacks : public PPCallbacks { void PrintPPOutputPPCallbacks::WriteLineInfo(unsigned LineNo, const char *Extra, unsigned ExtraLen) { - startNewLineIfNeeded(); + startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false); // Emit #line directives or GNU line markers depending on what mode we're in. if (UseLineDirectives) { @@ -257,57 +214,43 @@ void PrintPPOutputPPCallbacks::WriteLineInfo(unsigned LineNo, /// object. We can do this by emitting some number of \n's, or be emitting a /// #line directive. This returns false if already at the specified line, true /// if some newlines were emitted. -bool PrintPPOutputPPCallbacks::MoveToLine(unsigned LineNo, - bool RequireStartOfLine) { - // If it is required to start a new line or finish the current, insert - // vertical whitespace now and take it into account when moving to the - // expected line. - bool StartedNewLine = false; - if ((RequireStartOfLine && EmittedTokensOnThisLine) || - EmittedDirectiveOnThisLine) { - OS << '\n'; - StartedNewLine = true; - CurLine += 1; - EmittedTokensOnThisLine = false; - EmittedDirectiveOnThisLine = false; - } - +bool PrintPPOutputPPCallbacks::MoveToLine(unsigned LineNo) { // If this line is "close enough" to the original line, just print newlines, // otherwise print a #line directive. - if (CurLine == LineNo) { - // Nothing to do if we are already on the correct line. - } else if (!StartedNewLine && (!MinimizeWhitespace || !DisableLineMarkers) && - LineNo - CurLine == 1) { - // Printing a single line has priority over printing a #line directive, even - // when minimizing whitespace which otherwise would print #line directives - // for every single line. - OS << '\n'; - StartedNewLine = true; - } else if (!MinimizeWhitespace && LineNo - CurLine <= 8) { - const char *NewLines = "\n\n\n\n\n\n\n\n"; - OS.write(NewLines, LineNo - CurLine); - StartedNewLine = true; + if (LineNo-CurLine <= 8) { + if (LineNo-CurLine == 1) + OS << '\n'; + else if (LineNo == CurLine) + return false; // Spelling line moved, but expansion line didn't. + else { + const char *NewLines = "\n\n\n\n\n\n\n\n"; + OS.write(NewLines, LineNo-CurLine); + } } else if (!DisableLineMarkers) { // Emit a #line or line marker. WriteLineInfo(LineNo, nullptr, 0); - StartedNewLine = true; - } - - if (StartedNewLine) { - EmittedTokensOnThisLine = false; - EmittedDirectiveOnThisLine = false; + } else { + // Okay, we're in -P mode, which turns off line markers. However, we still + // need to emit a newline between tokens on different lines. + startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false); } CurLine = LineNo; - return StartedNewLine; + return true; } -void PrintPPOutputPPCallbacks::startNewLineIfNeeded() { +bool +PrintPPOutputPPCallbacks::startNewLineIfNeeded(bool ShouldUpdateCurrentLine) { if (EmittedTokensOnThisLine || EmittedDirectiveOnThisLine) { OS << '\n'; EmittedTokensOnThisLine = false; EmittedDirectiveOnThisLine = false; + if (ShouldUpdateCurrentLine) + ++CurLine; + return true; } + + return false; } /// FileChanged - Whenever the preprocessor enters or exits a #include file @@ -330,7 +273,7 @@ void PrintPPOutputPPCallbacks::FileChanged(SourceLocation Loc, if (Reason == PPCallbacks::EnterFile) { SourceLocation IncludeLoc = UserLoc.getIncludeLoc(); if (IncludeLoc.isValid()) - MoveToLine(IncludeLoc, /*RequireStartOfLine=*/false); + MoveToLine(IncludeLoc); } else if (Reason == PPCallbacks::SystemHeaderPragma) { // GCC emits the # directive for this directive on the line AFTER the // directive and emits a bunch of spaces that aren't needed. This is because @@ -347,8 +290,7 @@ void PrintPPOutputPPCallbacks::FileChanged(SourceLocation Loc, FileType = NewFileType; if (DisableLineMarkers) { - if (!MinimizeWhitespace) - startNewLineIfNeeded(); + startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false); return; } @@ -394,13 +336,15 @@ void PrintPPOutputPPCallbacks::InclusionDirective( // In -dI mode, dump #include directives prior to dumping their content or // interpretation. if (DumpIncludeDirectives) { - MoveToLine(HashLoc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(HashLoc); const std::string TokenText = PP.getSpelling(IncludeTok); assert(!TokenText.empty()); OS << "#" << TokenText << " " << (IsAngled ? '<' : '"') << FileName << (IsAngled ? '>' : '"') << " /* clang -E -dI */"; setEmittedDirectiveOnThisLine(); + startNewLineIfNeeded(); } // When preprocessing, turn implicit imports into module import pragmas. @@ -409,13 +353,17 @@ void PrintPPOutputPPCallbacks::InclusionDirective( case tok::pp_include: case tok::pp_import: case tok::pp_include_next: - MoveToLine(HashLoc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(HashLoc); OS << "#pragma clang module import " << Imported->getFullModuleName(true) << " /* clang -E: implicit import for " << "#" << PP.getSpelling(IncludeTok) << " " << (IsAngled ? '<' : '"') << FileName << (IsAngled ? '>' : '"') << " */"; - setEmittedDirectiveOnThisLine(); + // Since we want a newline after the pragma, but not a #, start a + // new line immediately. + EmittedTokensOnThisLine = true; + startNewLineIfNeeded(); break; case tok::pp___include_macros: @@ -450,11 +398,11 @@ void PrintPPOutputPPCallbacks::EndModule(const Module *M) { /// Ident - Handle #ident directives when read by the preprocessor. /// void PrintPPOutputPPCallbacks::Ident(SourceLocation Loc, StringRef S) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + MoveToLine(Loc); OS.write("#ident ", strlen("#ident ")); OS.write(S.begin(), S.size()); - setEmittedTokensOnThisLine(); + EmittedTokensOnThisLine = true; } /// MacroDefined - This hook is called whenever a macro definition is seen. @@ -466,7 +414,7 @@ void PrintPPOutputPPCallbacks::MacroDefined(const Token &MacroNameTok, // Ignore __FILE__ etc. MI->isBuiltinMacro()) return; - MoveToLine(MI->getDefinitionLoc(), /*RequireStartOfLine=*/true); + MoveToLine(MI->getDefinitionLoc()); PrintMacroDefinition(*MacroNameTok.getIdentifierInfo(), *MI, PP, OS); setEmittedDirectiveOnThisLine(); } @@ -477,7 +425,7 @@ void PrintPPOutputPPCallbacks::MacroUndefined(const Token &MacroNameTok, // Only print out macro definitions in -dD mode. if (!DumpDefines) return; - MoveToLine(MacroNameTok.getLocation(), /*RequireStartOfLine=*/true); + MoveToLine(MacroNameTok.getLocation()); OS << "#undef " << MacroNameTok.getIdentifierInfo()->getName(); setEmittedDirectiveOnThisLine(); } @@ -498,7 +446,8 @@ void PrintPPOutputPPCallbacks::PragmaMessage(SourceLocation Loc, StringRef Namespace, PragmaMessageKind Kind, StringRef Str) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma "; if (!Namespace.empty()) OS << Namespace << ' '; @@ -523,7 +472,8 @@ void PrintPPOutputPPCallbacks::PragmaMessage(SourceLocation Loc, void PrintPPOutputPPCallbacks::PragmaDebug(SourceLocation Loc, StringRef DebugType) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma clang __debug "; OS << DebugType; @@ -533,14 +483,16 @@ void PrintPPOutputPPCallbacks::PragmaDebug(SourceLocation Loc, void PrintPPOutputPPCallbacks:: PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma " << Namespace << " diagnostic push"; setEmittedDirectiveOnThisLine(); } void PrintPPOutputPPCallbacks:: PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma " << Namespace << " diagnostic pop"; setEmittedDirectiveOnThisLine(); } @@ -549,7 +501,8 @@ void PrintPPOutputPPCallbacks::PragmaDiagnostic(SourceLocation Loc, StringRef Namespace, diag::Severity Map, StringRef Str) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma " << Namespace << " diagnostic "; switch (Map) { case diag::Severity::Remark: @@ -575,7 +528,8 @@ void PrintPPOutputPPCallbacks::PragmaDiagnostic(SourceLocation Loc, void PrintPPOutputPPCallbacks::PragmaWarning(SourceLocation Loc, StringRef WarningSpec, ArrayRef Ids) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma warning(" << WarningSpec << ':'; for (ArrayRef::iterator I = Ids.begin(), E = Ids.end(); I != E; ++I) OS << ' ' << *I; @@ -585,7 +539,8 @@ void PrintPPOutputPPCallbacks::PragmaWarning(SourceLocation Loc, void PrintPPOutputPPCallbacks::PragmaWarningPush(SourceLocation Loc, int Level) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma warning(push"; if (Level >= 0) OS << ", " << Level; @@ -594,14 +549,16 @@ void PrintPPOutputPPCallbacks::PragmaWarningPush(SourceLocation Loc, } void PrintPPOutputPPCallbacks::PragmaWarningPop(SourceLocation Loc) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma warning(pop)"; setEmittedDirectiveOnThisLine(); } void PrintPPOutputPPCallbacks::PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma character_execution_set(push"; if (!Str.empty()) OS << ", " << Str; @@ -610,80 +567,64 @@ void PrintPPOutputPPCallbacks::PragmaExecCharsetPush(SourceLocation Loc, } void PrintPPOutputPPCallbacks::PragmaExecCharsetPop(SourceLocation Loc) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma character_execution_set(pop)"; setEmittedDirectiveOnThisLine(); } void PrintPPOutputPPCallbacks:: PragmaAssumeNonNullBegin(SourceLocation Loc) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma clang assume_nonnull begin"; setEmittedDirectiveOnThisLine(); } void PrintPPOutputPPCallbacks:: PragmaAssumeNonNullEnd(SourceLocation Loc) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma clang assume_nonnull end"; setEmittedDirectiveOnThisLine(); } -void PrintPPOutputPPCallbacks::HandleWhitespaceBeforeTok(const Token &Tok, - bool RequireSpace, - bool RequireSameLine) { - // These tokens are not expanded to anything and don't need whitespace before - // them. - if (Tok.is(tok::eof) || - (Tok.isAnnotation() && !Tok.is(tok::annot_header_unit) && - !Tok.is(tok::annot_module_begin) && !Tok.is(tok::annot_module_end))) - return; +/// HandleFirstTokOnLine - When emitting a preprocessed file in -E mode, this +/// is called for the first token on each new line. If this really is the start +/// of a new logical line, handle it and return true, otherwise return false. +/// This may not be the start of a logical line because the "start of line" +/// marker is set for spelling lines, not expansion ones. +bool PrintPPOutputPPCallbacks::HandleFirstTokOnLine(Token &Tok) { + // Figure out what line we went to and insert the appropriate number of + // newline characters. + if (!MoveToLine(Tok.getLocation())) + return false; + + // Print out space characters so that the first token on a line is + // indented for easy reading. + unsigned ColNo = SM.getExpansionColumnNumber(Tok.getLocation()); + + // The first token on a line can have a column number of 1, yet still expect + // leading white space, if a macro expansion in column 1 starts with an empty + // macro argument, or an empty nested macro expansion. In this case, move the + // token to column 2. + if (ColNo == 1 && Tok.hasLeadingSpace()) + ColNo = 2; + + // This hack prevents stuff like: + // #define HASH # + // HASH define foo bar + // From having the # character end up at column 1, which makes it so it + // is not handled as a #define next time through the preprocessor if in + // -fpreprocessed mode. + if (ColNo <= 1 && Tok.is(tok::hash)) + OS << ' '; - if (!RequireSameLine && MoveToLine(Tok, /*RequireStartOfLine=*/false)) { - if (MinimizeWhitespace) { - // Avoid interpreting hash as a directive under -fpreprocessed. - if (Tok.is(tok::hash)) - OS << ' '; - } else { - // Print out space characters so that the first token on a line is - // indented for easy reading. - unsigned ColNo = SM.getExpansionColumnNumber(Tok.getLocation()); - - // The first token on a line can have a column number of 1, yet still - // expect leading white space, if a macro expansion in column 1 starts - // with an empty macro argument, or an empty nested macro expansion. In - // this case, move the token to column 2. - if (ColNo == 1 && Tok.hasLeadingSpace()) - ColNo = 2; - - // This hack prevents stuff like: - // #define HASH # - // HASH define foo bar - // From having the # character end up at column 1, which makes it so it - // is not handled as a #define next time through the preprocessor if in - // -fpreprocessed mode. - if (ColNo <= 1 && Tok.is(tok::hash)) - OS << ' '; - - // Otherwise, indent the appropriate number of spaces. - for (; ColNo > 1; --ColNo) - OS << ' '; - } - } else { - // Insert whitespace between the previous and next token if either - // - The caller requires it - // - The input had whitespace between them and we are not in - // whitespace-minimization mode - // - The whitespace is necessary to keep the tokens apart and there is not - // already a newline between them - if (RequireSpace || (!MinimizeWhitespace && Tok.hasLeadingSpace()) || - ((EmittedTokensOnThisLine || EmittedTokensOnThisLine) && - AvoidConcat(PrevPrevTok, PrevTok, Tok))) - OS << ' '; - } + // Otherwise, indent the appropriate number of spaces. + for (; ColNo > 1; --ColNo) + OS << ' '; - PrevPrevTok = PrevTok; - PrevTok = Tok; + return true; } void PrintPPOutputPPCallbacks::HandleNewlinesInToken(const char *TokStr, @@ -727,9 +668,9 @@ struct UnknownPragmaHandler : public PragmaHandler { Token &PragmaTok) override { // Figure out what line we went to and insert the appropriate number of // newline characters. - Callbacks->MoveToLine(PragmaTok.getLocation(), /*RequireStartOfLine=*/true); + Callbacks->startNewLineIfNeeded(); + Callbacks->MoveToLine(PragmaTok.getLocation()); Callbacks->OS.write(Prefix, strlen(Prefix)); - Callbacks->setEmittedTokensOnThisLine(); if (ShouldExpandTokens) { // The first token does not have expanded macros. Expand them, if @@ -741,16 +682,21 @@ struct UnknownPragmaHandler : public PragmaHandler { /*IsReinject=*/false); PP.Lex(PragmaTok); } + Token PrevToken; + Token PrevPrevToken; + PrevToken.startToken(); + PrevPrevToken.startToken(); // Read and print all of the pragma tokens. - bool IsFirst = true; while (PragmaTok.isNot(tok::eod)) { - Callbacks->HandleWhitespaceBeforeTok(PragmaTok, /*RequireSpace=*/IsFirst, - /*RequireSameLine=*/true); - IsFirst = false; + if (PragmaTok.hasLeadingSpace() || + Callbacks->AvoidConcat(PrevPrevToken, PrevToken, PragmaTok)) + Callbacks->OS << ' '; std::string TokSpell = PP.getSpelling(PragmaTok); Callbacks->OS.write(&TokSpell[0], TokSpell.size()); - Callbacks->setEmittedTokensOnThisLine(); + + PrevPrevToken = PrevToken; + PrevToken = PragmaTok; if (ShouldExpandTokens) PP.Lex(PragmaTok); @@ -769,41 +715,44 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok, bool DropComments = PP.getLangOpts().TraditionalCPP && !PP.getCommentRetentionState(); - bool IsStartOfLine = false; char Buffer[256]; + Token PrevPrevTok, PrevTok; + PrevPrevTok.startToken(); + PrevTok.startToken(); while (1) { - // Two lines joined with line continuation ('\' as last character on the - // line) must be emitted as one line even though Tok.getLine() returns two - // different values. In this situation Tok.isAtStartOfLine() is false even - // though it may be the first token on the lexical line. When - // dropping/skipping a token that is at the start of a line, propagate the - // start-of-line-ness to the next token to not append it to the previous - // line. - IsStartOfLine = IsStartOfLine || Tok.isAtStartOfLine(); - - Callbacks->HandleWhitespaceBeforeTok(Tok, /*RequireSpace=*/false, - /*RequireSameLine=*/!IsStartOfLine); + if (Callbacks->hasEmittedDirectiveOnThisLine()) { + Callbacks->startNewLineIfNeeded(); + Callbacks->MoveToLine(Tok.getLocation()); + } + + // If this token is at the start of a line, emit newlines if needed. + if (Tok.isAtStartOfLine() && Callbacks->HandleFirstTokOnLine(Tok)) { + // done. + } else if (Tok.hasLeadingSpace() || + // If we haven't emitted a token on this line yet, PrevTok isn't + // useful to look at and no concatenation could happen anyway. + (Callbacks->hasEmittedTokensOnThisLine() && + // Don't print "-" next to "-", it would form "--". + Callbacks->AvoidConcat(PrevPrevTok, PrevTok, Tok))) { + OS << ' '; + } if (DropComments && Tok.is(tok::comment)) { // Skip comments. Normally the preprocessor does not generate // tok::comment nodes at all when not keeping comments, but under // -traditional-cpp the lexer keeps /all/ whitespace, including comments. - PP.Lex(Tok); - continue; + SourceLocation StartLoc = Tok.getLocation(); + Callbacks->MoveToLine(StartLoc.getLocWithOffset(Tok.getLength())); } else if (Tok.is(tok::eod)) { // Don't print end of directive tokens, since they are typically newlines // that mess up our line tracking. These come from unknown pre-processor // directives or hash-prefixed comments in standalone assembly files. PP.Lex(Tok); - // FIXME: The token on the next line after #include should have - // Tok.isAtStartOfLine() set. - IsStartOfLine = true; continue; } else if (Tok.is(tok::annot_module_include)) { // PrintPPOutputPPCallbacks::InclusionDirective handles producing // appropriate output here. Ignore this token entirely. PP.Lex(Tok); - IsStartOfLine = true; continue; } else if (Tok.is(tok::annot_module_begin)) { // FIXME: We retrieve this token after the FileChanged callback, and @@ -815,13 +764,11 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok, Callbacks->BeginModule( reinterpret_cast(Tok.getAnnotationValue())); PP.Lex(Tok); - IsStartOfLine = true; continue; } else if (Tok.is(tok::annot_module_end)) { Callbacks->EndModule( reinterpret_cast(Tok.getAnnotationValue())); PP.Lex(Tok); - IsStartOfLine = true; continue; } else if (Tok.is(tok::annot_header_unit)) { // This is a header-name that has been (effectively) converted into a @@ -849,17 +796,8 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok, // Tokens that can contain embedded newlines need to adjust our current // line number. - // FIXME: The token may end with a newline in which case - // setEmittedDirectiveOnThisLine/setEmittedTokensOnThisLine afterwards is - // wrong. if (Tok.getKind() == tok::comment || Tok.getKind() == tok::unknown) Callbacks->HandleNewlinesInToken(TokPtr, Len); - if (Tok.is(tok::comment) && Len >= 2 && TokPtr[0] == '/' && - TokPtr[1] == '/') { - // It's a line comment; - // Ensure that we don't concatenate anything behind it. - Callbacks->setEmittedDirectiveOnThisLine(); - } } else { std::string S = PP.getSpelling(Tok); OS.write(S.data(), S.size()); @@ -868,17 +806,13 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok, // line number. if (Tok.getKind() == tok::comment || Tok.getKind() == tok::unknown) Callbacks->HandleNewlinesInToken(S.data(), S.size()); - if (Tok.is(tok::comment) && S.size() >= 2 && S[0] == '/' && S[1] == '/') { - // It's a line comment; - // Ensure that we don't concatenate anything behind it. - Callbacks->setEmittedDirectiveOnThisLine(); - } } Callbacks->setEmittedTokensOnThisLine(); - IsStartOfLine = false; if (Tok.is(tok::eof)) break; + PrevPrevTok = PrevTok; + PrevTok = Tok; PP.Lex(Tok); } } @@ -936,8 +870,7 @@ void clang::DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS, PrintPPOutputPPCallbacks *Callbacks = new PrintPPOutputPPCallbacks( PP, *OS, !Opts.ShowLineMarkers, Opts.ShowMacros, - Opts.ShowIncludeDirectives, Opts.UseLineDirectives, - Opts.MinimizeWhitespace); + Opts.ShowIncludeDirectives, Opts.UseLineDirectives); // Expand macros in pragmas with -fms-extensions. The assumption is that // the majority of pragmas in such a file will be Microsoft pragmas. diff --git a/clang/lib/Lex/Preprocessor.cpp b/clang/lib/Lex/Preprocessor.cpp index 32ea8791d29a8..e376fff904329 100644 --- a/clang/lib/Lex/Preprocessor.cpp +++ b/clang/lib/Lex/Preprocessor.cpp @@ -716,12 +716,6 @@ IdentifierInfo *Preprocessor::LookUpIdentifierInfo(Token &Identifier) const { } // Update the token info (identifier info and appropriate token kind). - // FIXME: the raw_identifier may contain leading whitespace which is removed - // from the cleaned identifier token. The SourceLocation should be updated to - // refer to the non-whitespace character. For instance, the text "\\\nB" (a - // line continuation before 'B') is parsed as a single tok::raw_identifier and - // is cleaned to tok::identifier "B". After cleaning the token's length is - // still 3 and the SourceLocation refers to the location of the backslash. Identifier.setIdentifierInfo(II); if (getLangOpts().MSVCCompat && II->isCPlusPlusOperatorKeyword() && getSourceManager().isInSystemHeader(Identifier.getLocation())) diff --git a/clang/test/Preprocessor/comment_save.c b/clang/test/Preprocessor/comment_save.c index 84eaed0a2272f..1100ea29bba9c 100644 --- a/clang/test/Preprocessor/comment_save.c +++ b/clang/test/Preprocessor/comment_save.c @@ -1,5 +1,4 @@ // RUN: %clang_cc1 -E -C %s | FileCheck -strict-whitespace %s -// RUN: %clang_cc1 -E -C -fminimize-whitespace %s | FileCheck -strict-whitespace %s // foo // CHECK: // foo diff --git a/clang/test/Preprocessor/first-line-indent.c b/clang/test/Preprocessor/first-line-indent.c index 9aafa9ce43521..d220d57a28201 100644 --- a/clang/test/Preprocessor/first-line-indent.c +++ b/clang/test/Preprocessor/first-line-indent.c @@ -1,14 +1,7 @@ foo // RUN: %clang_cc1 -E %s | FileCheck -strict-whitespace %s -// RUN: %clang_cc1 -E -fminimize-whitespace %s | FileCheck -strict-whitespace %s --check-prefix=MINCOL -// RUN: %clang_cc1 -E -fminimize-whitespace -P %s | FileCheck -strict-whitespace %s --check-prefix=MINWS bar // CHECK: {{^ }}foo // CHECK: {{^ }}bar -// MINCOL: {{^}}foo -// MINCOL: {{^}}bar - -// MINWS: {{^}}foo bar - diff --git a/clang/test/Preprocessor/hash_line.c b/clang/test/Preprocessor/hash_line.c index 1b5064fe549dc..c4de9f04044e2 100644 --- a/clang/test/Preprocessor/hash_line.c +++ b/clang/test/Preprocessor/hash_line.c @@ -4,10 +4,6 @@ // CHECK-NEXT: {{^ #$}} // CHECK-NEXT: {{^2$}} // CHECK-NEXT: {{^ #$}} - -// RUN: %clang_cc1 -E -P -fminimize-whitespace %s | FileCheck --strict-whitespace %s --check-prefix=MINWS -// MINWS: {{^}}1#2#{{$}} - #define EMPTY #define IDENTITY(X) X 1 diff --git a/clang/test/Preprocessor/line-directive-output-mincol.c b/clang/test/Preprocessor/line-directive-output-mincol.c deleted file mode 100644 index 0f2466ebee971..0000000000000 --- a/clang/test/Preprocessor/line-directive-output-mincol.c +++ /dev/null @@ -1,11 +0,0 @@ -// RUN: %clang_cc1 -E -fminimize-whitespace %s 2>&1 | FileCheck %s -strict-whitespace - -// CHECK: # 6 "{{.*}}line-directive-output-mincol.c" -// CHECK-NEXT: int x; -// CHECK-NEXT: int y; -int x; -int y; -// CHECK-NEXT: # 10 "{{.*}}line-directive-output-mincol.c" -// CHECK-NEXT: int z; -int z; - diff --git a/clang/test/Preprocessor/line-directive-output.c b/clang/test/Preprocessor/line-directive-output.c index 5e3dec155cad4..caeb88dd855cc 100644 --- a/clang/test/Preprocessor/line-directive-output.c +++ b/clang/test/Preprocessor/line-directive-output.c @@ -1,5 +1,4 @@ // RUN: %clang_cc1 -E %s 2>&1 | FileCheck %s -strict-whitespace -// RUN: %clang_cc1 -E -fminimize-whitespace %s 2>&1 | FileCheck %s -strict-whitespace // PR6101 int a; // CHECK: # 1 "{{.*}}line-directive-output.c" diff --git a/clang/test/Preprocessor/macro_space.c b/clang/test/Preprocessor/macro_space.c index 0734bca9ea59a..13e531fff1511 100644 --- a/clang/test/Preprocessor/macro_space.c +++ b/clang/test/Preprocessor/macro_space.c @@ -1,5 +1,4 @@ // RUN: %clang_cc1 -E %s | FileCheck --strict-whitespace %s -// RUN: %clang_cc1 -E -P -fminimize-whitespace %s | FileCheck --strict-whitespace %s --check-prefix=MINWS #define FOO1() #define FOO2(x)x @@ -14,32 +13,24 @@ TEST(FOO1,) // CHECK: FOO1 <> < > <> <> < > <> < > < > -// MINWS: FOO1<><><><><><><><> TEST(FOO2,) // CHECK: FOO2 <> < > <> <> < > <> < > < > -// MINWS-SAME: FOO2<><><><><><><><> TEST(FOO3,) // CHECK: FOO3 <> < > <> <> < > <> < > < > -// MINWS-SAME: FOO3<><><><><><><><> TEST(FOO4,) // CHECK: FOO4 < > < > < > < > < > < > < > < > -// MINWS-SAME: FOO4<><><><><><><><> TEST(FOO5,) // CHECK: FOO5 < > < > < > < > < > < > < > < > -// MINWS-SAME: FOO5<><><><><><><><> TEST(FOO6,) // CHECK: FOO6 <[]> < []> <[]> <[]> <[] > <[]> <[] > < []> -// MINWS-SAME: FOO6<[]><[]><[]><[]><[]><[]><[]><[]> TEST(FOO7,) // CHECK: FOO7 <[ ]> < [ ]> <[ ]> <[ ]> <[ ] > <[ ]> <[ ] > < [ ]> -// MINWS-SAME: FOO7<[]><[]><[]><[]><[]><[]><[]><[]> TEST(FOO8,) // CHECK: FOO8 <[ ]> < [ ]> <[ ]> <[ ]> <[ ] > <[ ]> <[ ] > < [ ]> -// MINWS-SAME: FOO8<[]><[]><[]><[]><[]><[]><[]><[]> diff --git a/clang/test/Preprocessor/minimize-whitespace-messages.c b/clang/test/Preprocessor/minimize-whitespace-messages.c deleted file mode 100644 index a78ddb471fb7c..0000000000000 --- a/clang/test/Preprocessor/minimize-whitespace-messages.c +++ /dev/null @@ -1,8 +0,0 @@ -// RUN: not %clang -c -fminimize-whitespace %s 2>&1 | FileCheck %s --check-prefix=ON -// ON: error: invalid argument '-fminimize-whitespace' only allowed with '-E' - -// RUN: not %clang -c -fno-minimize-whitespace %s 2>&1 | FileCheck %s --check-prefix=OFF -// OFF: error: invalid argument '-fno-minimize-whitespace' only allowed with '-E' - -// RUN: not %clang -E -fminimize-whitespace -x assembler-with-cpp %s 2>&1 | FileCheck %s --check-prefix=ASM -// ASM: error: '-fminimize-whitespace' invalid for input of type assembler-with-cpp diff --git a/clang/test/Preprocessor/minimize-whitespace.c b/clang/test/Preprocessor/minimize-whitespace.c deleted file mode 100644 index 3608e318dc135..0000000000000 --- a/clang/test/Preprocessor/minimize-whitespace.c +++ /dev/null @@ -1,55 +0,0 @@ -// RUN: %clang_cc1 -fminimize-whitespace -E %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=MINCOL -// RUN: %clang_cc1 -fminimize-whitespace -E -C %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=MINCCOL -// RUN: %clang_cc1 -fminimize-whitespace -E -P %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=MINWS -// RUN: %clang_cc1 -fminimize-whitespace -E -C -P %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=MINCWS - -#define NOT_OMP omp something -#define HASH # - - int a; /* span-comment */ - int b ; // line-comment - _Pragma ( "omp barrier" ) x // more line-comments - #pragma omp nothing // another comment -HASH pragma NOT_OMP - int e; // again a line - int \ -f ; - - -// MINCOL: {{^}}# 9 "{{.*}}minimize-whitespace.c"{{$}} -// MINCOL: {{^}}int a;{{$}} -// MINCOL-NEXT: {{^}}int b;{{$}} -// MINCOL-NEXT: {{^}}#pragma omp barrier{{$}} -// MINCOL-NEXT: # 11 "{{.*}}minimize-whitespace.c" -// MINCOL-NEXT: {{^}}x{{$}} -// MINCOL-NEXT: {{^}}#pragma omp nothing{{$}} -// MINCOL-NEXT: {{^ }}#pragma omp something{{$}} -// MINCOL-NEXT: {{^}}int e;{{$}} -// MINCOL-NEXT: {{^}}int f;{{$}} - -// FIXME: Comments after pragmas disappear, even without -fminimize-whitespace -// MINCCOL: {{^}}# 9 "{{.*}}minimize-whitespace.c"{{$}} -// MINCCOL: {{^}}int a;/* span-comment */{{$}} -// MINCCOL-NEXT: {{^}}int b;// line-comment{{$}} -// MINCCOL-NEXT: {{^}}#pragma omp barrier{{$}} -// MINCCOL-NEXT: # 11 "{{.*}}minimize-whitespace.c" -// MINCCOL-NEXT: {{^}}x// more line-comments{{$}} -// MINCCOL-NEXT: {{^}}#pragma omp nothing{{$}} -// MINCCOL-NEXT: {{^ }}#pragma omp something{{$}} -// MINCCOL-NEXT: {{^}}int e;// again a line{{$}} -// MINCCOL-NEXT: {{^}}int f;{{$}} - -// MINWS: {{^}}int a;int b;{{$}} -// MINWS-NEXT: {{^}}#pragma omp barrier{{$}} -// MINWS-NEXT: {{^}}x{{$}} -// MINWS-NEXT: {{^}}#pragma omp nothing{{$}} -// MINWS-NEXT: {{^ }}#pragma omp something int e;int f;{{$}} - -// FIXME: Comments after pragmas disappear, even without -fminimize-whitespace -// MINCWS: {{^}}int a;/* span-comment */int b;// line-comment{{$}} -// MINCWS-NEXT: {{^}}#pragma omp barrier{{$}} -// MINCWS-NEXT: {{^}}x// more line-comments{{$}} -// MINCWS-NEXT: {{^}}#pragma omp nothing{{$}} -// MINCWS-NEXT: {{^ }}#pragma omp something int e;// again a line{{$}} -// MINCWS-NEXT: {{^}}int f; - diff --git a/clang/test/Preprocessor/print_line_include.c b/clang/test/Preprocessor/print_line_include.c index 4810fbca99b1e..d65873cb73668 100644 --- a/clang/test/Preprocessor/print_line_include.c +++ b/clang/test/Preprocessor/print_line_include.c @@ -2,8 +2,5 @@ // CHECK: int x; // CHECK-NEXT: int x; -// RUN: %clang_cc1 -E -P -fminimize-whitespace %s | FileCheck %s --check-prefix=MINWS --strict-whitespace -// MINWS: {{^}}int x;int x;{{$}} - #include "print_line_include.h" #include "print_line_include.h" diff --git a/clang/test/Preprocessor/stringize_space.c b/clang/test/Preprocessor/stringize_space.c index 43276264eb4e7..cbc7386cd09b3 100644 --- a/clang/test/Preprocessor/stringize_space.c +++ b/clang/test/Preprocessor/stringize_space.c @@ -1,18 +1,16 @@ // RUN: %clang_cc1 -E %s | FileCheck --strict-whitespace %s -// RUN: %clang_cc1 -E -P -fminimize-whitespace %s | FileCheck --strict-whitespace %s --check-prefix=MINWS #define A(b) -#b , - #b , -# b , - # b A() // CHECK: {{^}}-"" , - "" , -"" , - ""{{$}} -// MINWS: {{^}}-"",-"",-"",-"" + #define t(x) #x t(a c) // CHECK: {{^}}"a c"{{$}} -// MINWS-SAME: "a c" #define str(x) #x #define f(x) str(-x) @@ -20,7 +18,6 @@ f( 1) // CHECK: {{^}}"-1" -// MINWS-SAME: "-1" #define paste(a,b) str(a