diff options
Diffstat (limited to 'contrib/llvm-project/clang/lib/Frontend/PrintPreprocessedOutput.cpp')
| -rw-r--r-- | contrib/llvm-project/clang/lib/Frontend/PrintPreprocessedOutput.cpp | 349 |
1 files changed, 141 insertions, 208 deletions
diff --git a/contrib/llvm-project/clang/lib/Frontend/PrintPreprocessedOutput.cpp b/contrib/llvm-project/clang/lib/Frontend/PrintPreprocessedOutput.cpp index b7259569595d..24ea1ccba207 100644 --- a/contrib/llvm-project/clang/lib/Frontend/PrintPreprocessedOutput.cpp +++ b/contrib/llvm-project/clang/lib/Frontend/PrintPreprocessedOutput.cpp @@ -95,20 +95,14 @@ private: 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 += "<uninit>"; EmittedTokensOnThisLine = false; @@ -116,13 +110,8 @@ public: 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 @@ public: 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 @@ public: 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 @@ public: 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 #<line>, 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<int> Ids) { - MoveToLine(Loc, /*RequireStartOfLine=*/true); + startNewLineIfNeeded(); + MoveToLine(Loc); OS << "#pragma warning(" << WarningSpec << ':'; for (ArrayRef<int>::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<Module *>(Tok.getAnnotationValue())); PP.Lex(Tok); - IsStartOfLine = true; continue; } else if (Tok.is(tok::annot_module_end)) { Callbacks->EndModule( reinterpret_cast<Module *>(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. |