15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- PrintPreprocessedOutput.cpp - Implement the -E mode --------------===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This code simply runs the preprocessor on the input file and prints out the 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// result. This is the traditional behavior of the -E option. 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 15b09f6e15c59b89d5820db8ef40598eb1d1323c1fEli Friedman#include "clang/Frontend/Utils.h" 163f6f51e28231f65de9c2dd150a2d757b2162cfa3Jordan Rose#include "clang/Basic/CharInfo.h" 17775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar#include "clang/Basic/Diagnostic.h" 18775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar#include "clang/Basic/SourceManager.h" 19775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar#include "clang/Frontend/PreprocessorOutputOptions.h" 20f73903a1ded46748e1dfda151f5d037b7b3d31f9Chris Lattner#include "clang/Lex/MacroInfo.h" 215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Lex/PPCallbacks.h" 225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Lex/Pragma.h" 23775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar#include "clang/Lex/Preprocessor.h" 24d7038e18ef540a78fe6ce2a43125ce9b08fdbbc5Chris Lattner#include "clang/Lex/TokenConcatenation.h" 253ff2a4b861082f271bb769755ea6d1da4b3e6b8dBenjamin Kramer#include "llvm/ADT/STLExtras.h" 2655fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "llvm/ADT/SmallString.h" 27abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattner#include "llvm/ADT/StringRef.h" 28c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor#include "llvm/Support/ErrorHandling.h" 2955fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "llvm/Support/raw_ostream.h" 305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include <cstdio> 315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 33d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner/// PrintMacroDefinition - Print a macro definition in a form that will be 34d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner/// properly accepted back as a definition. 35d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattnerstatic void PrintMacroDefinition(const IdentifierInfo &II, const MacroInfo &MI, 365f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner Preprocessor &PP, raw_ostream &OS) { 37d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner OS << "#define " << II.getName(); 381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 39d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner if (MI.isFunctionLike()) { 40d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner OS << '('; 4113d555859cd643d657000401ebc88ca404d23bbaChris Lattner if (!MI.arg_empty()) { 42d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner MacroInfo::arg_iterator AI = MI.arg_begin(), E = MI.arg_end(); 4313d555859cd643d657000401ebc88ca404d23bbaChris Lattner for (; AI+1 != E; ++AI) { 4413d555859cd643d657000401ebc88ca404d23bbaChris Lattner OS << (*AI)->getName(); 45d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner OS << ','; 46807b93ee6ae2806b53131abc779d2b146d853aedChris Lattner } 4713d555859cd643d657000401ebc88ca404d23bbaChris Lattner 4813d555859cd643d657000401ebc88ca404d23bbaChris Lattner // Last argument. 4913d555859cd643d657000401ebc88ca404d23bbaChris Lattner if ((*AI)->getName() == "__VA_ARGS__") 5013d555859cd643d657000401ebc88ca404d23bbaChris Lattner OS << "..."; 5113d555859cd643d657000401ebc88ca404d23bbaChris Lattner else 5213d555859cd643d657000401ebc88ca404d23bbaChris Lattner OS << (*AI)->getName(); 53d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner } 54807b93ee6ae2806b53131abc779d2b146d853aedChris Lattner 55807b93ee6ae2806b53131abc779d2b146d853aedChris Lattner if (MI.isGNUVarargs()) 56807b93ee6ae2806b53131abc779d2b146d853aedChris Lattner OS << "..."; // #define foo(x...) 57a5d10c4df435964600e104ebef6a96b106e416b7Kovarththanan Rajaratnam 58d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner OS << ')'; 59d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner } 601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 61d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner // GCC always emits a space, even if the macro body is empty. However, do not 62d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner // want to emit two spaces if the first token has a leading space. 63d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner if (MI.tokens_empty() || !MI.tokens_begin()->hasLeadingSpace()) 64d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner OS << ' '; 651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 66f7ccbad5d9949e7ddd1cbef43d482553b811e026Dylan Noblesmith SmallString<128> SpellingBuffer; 67d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner for (MacroInfo::tokens_iterator I = MI.tokens_begin(), E = MI.tokens_end(); 68d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner I != E; ++I) { 69d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner if (I->hasLeadingSpace()) 70d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner OS << ' '; 711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 72ddeea5644367c9c153c9fee9e51bdea85ce43cbdBenjamin Kramer OS << PP.getSpelling(*I, SpellingBuffer); 73d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner } 74d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner} 75d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner 765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Preprocessed token printer 785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencernamespace { 815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerclass PrintPPOutputPPCallbacks : public PPCallbacks { 825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Preprocessor &PP; 83df721408f54f87a790fb986dfd64984472a1f892Chris Lattner SourceManager &SM; 84d7038e18ef540a78fe6ce2a43125ce9b08fdbbc5Chris Lattner TokenConcatenation ConcatInfo; 85e96de3e9134bee666f5cb1f5127b95e1c48c5bc2Chris Lattnerpublic: 865f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner raw_ostream &OS; 87e96de3e9134bee666f5cb1f5127b95e1c48c5bc2Chris Lattnerprivate: 885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer unsigned CurLine; 89f7c16d903f11814e2d6780e2a2e189b7a7afc4edDaniel Dunbar 905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer bool EmittedTokensOnThisLine; 910cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose bool EmittedDirectiveOnThisLine; 929d72851fec9e9c62570a027d42701562bbf29751Chris Lattner SrcMgr::CharacteristicKind FileType; 93f7ccbad5d9949e7ddd1cbef43d482553b811e026Dylan Noblesmith SmallString<512> CurFilename; 94737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar bool Initialized; 9512d3b1d98ec4463b733348e9fb8eadd19b365b0bEli Friedman bool DisableLineMarkers; 9612d3b1d98ec4463b733348e9fb8eadd19b365b0bEli Friedman bool DumpDefines; 97f7449346006d6b94b14a303eb82cad52c8e75413Chris Lattner bool UseLineDirective; 982a9be3e5b0c390f9189bb3dec2b2b6ba884f60ccDaniel Dunbar bool IsFirstFileEntered; 995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerpublic: 1005f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner PrintPPOutputPPCallbacks(Preprocessor &pp, raw_ostream &os, 101eef63e0997e0f6d6436736ea919b851cfe34955aDaniel Dunbar bool lineMarkers, bool defines) 102df721408f54f87a790fb986dfd64984472a1f892Chris Lattner : PP(pp), SM(PP.getSourceManager()), 103df721408f54f87a790fb986dfd64984472a1f892Chris Lattner ConcatInfo(PP), OS(os), DisableLineMarkers(lineMarkers), 104eef63e0997e0f6d6436736ea919b851cfe34955aDaniel Dunbar DumpDefines(defines) { 105eef63e0997e0f6d6436736ea919b851cfe34955aDaniel Dunbar CurLine = 0; 106d8e3083840fef752d11ca183f42786470ed061e3Chris Lattner CurFilename += "<uninit>"; 1075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmittedTokensOnThisLine = false; 1080cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose EmittedDirectiveOnThisLine = false; 1090b9e736308af5397f558ffc8e780c438c2fdb563Chris Lattner FileType = SrcMgr::C_User; 110737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar Initialized = false; 1112a9be3e5b0c390f9189bb3dec2b2b6ba884f60ccDaniel Dunbar IsFirstFileEntered = false; 112a5d10c4df435964600e104ebef6a96b106e416b7Kovarththanan Rajaratnam 113f7449346006d6b94b14a303eb82cad52c8e75413Chris Lattner // If we're in microsoft mode, use normal #line instead of line markers. 1144e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie UseLineDirective = PP.getLangOpts().MicrosoftExt; 1155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1170cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose void setEmittedTokensOnThisLine() { EmittedTokensOnThisLine = true; } 118f0f2b295437efecc0b52220b3f4a469fbb9aeac8Chris Lattner bool hasEmittedTokensOnThisLine() const { return EmittedTokensOnThisLine; } 1191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1200cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose void setEmittedDirectiveOnThisLine() { EmittedDirectiveOnThisLine = true; } 1210cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose bool hasEmittedDirectiveOnThisLine() const { 1220cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose return EmittedDirectiveOnThisLine; 1230cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose } 1240cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose 1250cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose bool startNewLineIfNeeded(bool ShouldUpdateCurrentLine = true); 126651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 127651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void FileChanged(SourceLocation Loc, FileChangeReason Reason, 128651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines SrcMgr::CharacteristicKind FileType, 129651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines FileID PrevFID) override; 130651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, 131651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines StringRef FileName, bool IsAngled, 132651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CharSourceRange FilenameRange, const FileEntry *File, 133651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines StringRef SearchPath, StringRef RelativePath, 134651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines const Module *Imported) override; 135651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void Ident(SourceLocation Loc, const std::string &str) override; 136651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void PragmaMessage(SourceLocation Loc, StringRef Namespace, 137651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines PragmaMessageKind Kind, StringRef Str) override; 138651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void PragmaDebug(SourceLocation Loc, StringRef DebugType) override; 139651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) override; 140651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) override; 141651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace, 142ef8225444452a1486bd721f3285301fe84643b00Stephen Hines diag::Severity Map, StringRef Str) override; 143651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void PragmaWarning(SourceLocation Loc, StringRef WarningSpec, 144651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines ArrayRef<int> Ids) override; 145651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void PragmaWarningPush(SourceLocation Loc, int Level) override; 146651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void PragmaWarningPop(SourceLocation Loc) override; 1475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1485f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattner bool HandleFirstTokOnLine(Token &Tok); 14943bb45d152b14e186689e159ac9be2e27787d5acHal Finkel 15043bb45d152b14e186689e159ac9be2e27787d5acHal Finkel /// Move to the line of the provided source location. This will 15143bb45d152b14e186689e159ac9be2e27787d5acHal Finkel /// return true if the output stream required adjustment or if 15243bb45d152b14e186689e159ac9be2e27787d5acHal Finkel /// the requested location is on the first line. 15388aae9188a64fe6385c7057af068aaeb8fc96b8eChris Lattner bool MoveToLine(SourceLocation Loc) { 154cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor PresumedLoc PLoc = SM.getPresumedLoc(Loc); 155cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor if (PLoc.isInvalid()) 156cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor return false; 15743bb45d152b14e186689e159ac9be2e27787d5acHal Finkel return MoveToLine(PLoc.getLine()) || (PLoc.getLine() == 1); 15888aae9188a64fe6385c7057af068aaeb8fc96b8eChris Lattner } 15988aae9188a64fe6385c7057af068aaeb8fc96b8eChris Lattner bool MoveToLine(unsigned LineNo); 16088aae9188a64fe6385c7057af068aaeb8fc96b8eChris Lattner 1618877321ca66b2887c2f377a7f724a62f34fdf1cdChris Lattner bool AvoidConcat(const Token &PrevPrevTok, const Token &PrevTok, 1628877321ca66b2887c2f377a7f724a62f34fdf1cdChris Lattner const Token &Tok) { 1638877321ca66b2887c2f377a7f724a62f34fdf1cdChris Lattner return ConcatInfo.AvoidConcat(PrevPrevTok, PrevTok, Tok); 164d7038e18ef540a78fe6ce2a43125ce9b08fdbbc5Chris Lattner } 1656bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines void WriteLineInfo(unsigned LineNo, const char *Extra=nullptr, 1666bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines unsigned ExtraLen=0); 16780c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor bool LineMarkersAreDisabled() const { return DisableLineMarkers; } 1683ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner void HandleNewlinesInToken(const char *TokStr, unsigned Len); 1691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 170d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner /// MacroDefined - This hook is called whenever a macro definition is seen. 171651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void MacroDefined(const Token &MacroNameTok, 172651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines const MacroDirective *MD) override; 1731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1742f05449fa1c9015a84b74c3308b856fc704662beBenjamin Kramer /// MacroUndefined - This hook is called whenever a macro #undef is seen. 175651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void MacroUndefined(const Token &MacroNameTok, 176651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines const MacroDirective *MD) override; 1775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}; 1785db17c9b5edb43e12196e565389b73e91a4fcb65Chris Lattner} // end anonymous namespace 1795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 180737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbarvoid PrintPPOutputPPCallbacks::WriteLineInfo(unsigned LineNo, 181737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar const char *Extra, 182737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar unsigned ExtraLen) { 1830cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false); 184737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar 185f7449346006d6b94b14a303eb82cad52c8e75413Chris Lattner // Emit #line directives or GNU line markers depending on what mode we're in. 186f7449346006d6b94b14a303eb82cad52c8e75413Chris Lattner if (UseLineDirective) { 187f7449346006d6b94b14a303eb82cad52c8e75413Chris Lattner OS << "#line" << ' ' << LineNo << ' ' << '"'; 1883432b7800d447267f4353e70a319f6f5a0bb4aabEli Friedman OS.write_escaped(CurFilename); 189f7449346006d6b94b14a303eb82cad52c8e75413Chris Lattner OS << '"'; 190f7449346006d6b94b14a303eb82cad52c8e75413Chris Lattner } else { 191f7449346006d6b94b14a303eb82cad52c8e75413Chris Lattner OS << '#' << ' ' << LineNo << ' ' << '"'; 1923432b7800d447267f4353e70a319f6f5a0bb4aabEli Friedman OS.write_escaped(CurFilename); 193f7449346006d6b94b14a303eb82cad52c8e75413Chris Lattner OS << '"'; 194a5d10c4df435964600e104ebef6a96b106e416b7Kovarththanan Rajaratnam 195d76fbda5da19c34752aa582e690a4dbd1cae39cdSteve Naroff if (ExtraLen) 196d76fbda5da19c34752aa582e690a4dbd1cae39cdSteve Naroff OS.write(Extra, ExtraLen); 197737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar 198d76fbda5da19c34752aa582e690a4dbd1cae39cdSteve Naroff if (FileType == SrcMgr::C_System) 199d76fbda5da19c34752aa582e690a4dbd1cae39cdSteve Naroff OS.write(" 3", 2); 200d76fbda5da19c34752aa582e690a4dbd1cae39cdSteve Naroff else if (FileType == SrcMgr::C_ExternCSystem) 201d76fbda5da19c34752aa582e690a4dbd1cae39cdSteve Naroff OS.write(" 3 4", 4); 202d76fbda5da19c34752aa582e690a4dbd1cae39cdSteve Naroff } 203737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar OS << '\n'; 204737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar} 205737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar 2065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// MoveToLine - Move the output to the source line specified by the location 2075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// object. We can do this by emitting some number of \n's, or be emitting a 2085f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattner/// #line directive. This returns false if already at the specified line, true 2095f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattner/// if some newlines were emitted. 21088aae9188a64fe6385c7057af068aaeb8fc96b8eChris Lattnerbool PrintPPOutputPPCallbacks::MoveToLine(unsigned LineNo) { 2115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this line is "close enough" to the original line, just print newlines, 2125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // otherwise print a #line directive. 213fd96684034c29c59a134dfec20d61c132e60ef30Daniel Dunbar if (LineNo-CurLine <= 8) { 214822f9406477554b7290a73a78d5d89308c157e05Chris Lattner if (LineNo-CurLine == 1) 215e96de3e9134bee666f5cb1f5127b95e1c48c5bc2Chris Lattner OS << '\n'; 2165f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattner else if (LineNo == CurLine) 2179f79a1f89695a79d5e29a72c28ffb59823b31cefChandler Carruth return false; // Spelling line moved, but expansion line didn't. 218822f9406477554b7290a73a78d5d89308c157e05Chris Lattner else { 219822f9406477554b7290a73a78d5d89308c157e05Chris Lattner const char *NewLines = "\n\n\n\n\n\n\n\n"; 220e96de3e9134bee666f5cb1f5127b95e1c48c5bc2Chris Lattner OS.write(NewLines, LineNo-CurLine); 221822f9406477554b7290a73a78d5d89308c157e05Chris Lattner } 2226133aeb97da5cab2d75c5f2c2f2561ea1b8fd0ffChris Lattner } else if (!DisableLineMarkers) { 2236133aeb97da5cab2d75c5f2c2f2561ea1b8fd0ffChris Lattner // Emit a #line or line marker. 2246bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines WriteLineInfo(LineNo, nullptr, 0); 2256133aeb97da5cab2d75c5f2c2f2561ea1b8fd0ffChris Lattner } else { 2266133aeb97da5cab2d75c5f2c2f2561ea1b8fd0ffChris Lattner // Okay, we're in -P mode, which turns off line markers. However, we still 2276133aeb97da5cab2d75c5f2c2f2561ea1b8fd0ffChris Lattner // need to emit a newline between tokens on different lines. 2280cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false); 2291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 230737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar 2311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CurLine = LineNo; 2325f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattner return true; 2335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2350cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rosebool 2360cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan RosePrintPPOutputPPCallbacks::startNewLineIfNeeded(bool ShouldUpdateCurrentLine) { 2370cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose if (EmittedTokensOnThisLine || EmittedDirectiveOnThisLine) { 23880c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor OS << '\n'; 23980c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor EmittedTokensOnThisLine = false; 2400cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose EmittedDirectiveOnThisLine = false; 2410cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose if (ShouldUpdateCurrentLine) 2420cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose ++CurLine; 24380c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor return true; 24480c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor } 24580c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor 24680c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor return false; 24780c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor} 2485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// FileChanged - Whenever the preprocessor enters or exits a #include file 2505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// it invokes this handler. Update our conception of the current source 2515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// position. 2525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid PrintPPOutputPPCallbacks::FileChanged(SourceLocation Loc, 2535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer FileChangeReason Reason, 254c892c5fa92db137ff68d95afb13fe969d17f4fb2Argyrios Kyrtzidis SrcMgr::CharacteristicKind NewFileType, 255c892c5fa92db137ff68d95afb13fe969d17f4fb2Argyrios Kyrtzidis FileID PrevFID) { 2565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Unless we are exiting a #include, make sure to skip ahead to the line the 2575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // #include directive was at. 258df721408f54f87a790fb986dfd64984472a1f892Chris Lattner SourceManager &SourceMgr = SM; 25988aae9188a64fe6385c7057af068aaeb8fc96b8eChris Lattner 26088aae9188a64fe6385c7057af068aaeb8fc96b8eChris Lattner PresumedLoc UserLoc = SourceMgr.getPresumedLoc(Loc); 261cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor if (UserLoc.isInvalid()) 262cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor return; 263cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor 26486d0ef74303e9164a0860ce849af597d34f937abChris Lattner unsigned NewLine = UserLoc.getLine(); 265f7c16d903f11814e2d6780e2a2e189b7a7afc4edDaniel Dunbar 2665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Reason == PPCallbacks::EnterFile) { 267cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor SourceLocation IncludeLoc = UserLoc.getIncludeLoc(); 26871d8bfb560735e8d47105cf434409ed347267830Chris Lattner if (IncludeLoc.isValid()) 26971d8bfb560735e8d47105cf434409ed347267830Chris Lattner MoveToLine(IncludeLoc); 2705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else if (Reason == PPCallbacks::SystemHeaderPragma) { 271142b35e25b579e2a883d6ca37c3c1121f562f242Jordan Rose // GCC emits the # directive for this directive on the line AFTER the 272142b35e25b579e2a883d6ca37c3c1121f562f242Jordan Rose // directive and emits a bunch of spaces that aren't needed. This is because 273142b35e25b579e2a883d6ca37c3c1121f562f242Jordan Rose // otherwise we will emit a line marker for THIS line, which requires an 274142b35e25b579e2a883d6ca37c3c1121f562f242Jordan Rose // extra blank line after the directive to avoid making all following lines 275142b35e25b579e2a883d6ca37c3c1121f562f242Jordan Rose // off by one. We can do better by simply incrementing NewLine here. 276142b35e25b579e2a883d6ca37c3c1121f562f242Jordan Rose NewLine += 1; 2775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 27888aae9188a64fe6385c7057af068aaeb8fc96b8eChris Lattner 27988aae9188a64fe6385c7057af068aaeb8fc96b8eChris Lattner CurLine = NewLine; 280737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar 281d8e3083840fef752d11ca183f42786470ed061e3Chris Lattner CurFilename.clear(); 28288aae9188a64fe6385c7057af068aaeb8fc96b8eChris Lattner CurFilename += UserLoc.getFilename(); 283737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar FileType = NewFileType; 284737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar 285086cc83a84bfab60685b69e3afa3e4500daebb4dEli Friedman if (DisableLineMarkers) { 286086cc83a84bfab60685b69e3afa3e4500daebb4dEli Friedman startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false); 287086cc83a84bfab60685b69e3afa3e4500daebb4dEli Friedman return; 288086cc83a84bfab60685b69e3afa3e4500daebb4dEli Friedman } 289f7c16d903f11814e2d6780e2a2e189b7a7afc4edDaniel Dunbar 290737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar if (!Initialized) { 291737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar WriteLineInfo(CurLine); 292737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar Initialized = true; 2935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 294737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar 2952a9be3e5b0c390f9189bb3dec2b2b6ba884f60ccDaniel Dunbar // Do not emit an enter marker for the main file (which we expect is the first 2962a9be3e5b0c390f9189bb3dec2b2b6ba884f60ccDaniel Dunbar // entered file). This matches gcc, and improves compatibility with some tools 2972a9be3e5b0c390f9189bb3dec2b2b6ba884f60ccDaniel Dunbar // which track the # line markers as a way to determine when the preprocessed 2982a9be3e5b0c390f9189bb3dec2b2b6ba884f60ccDaniel Dunbar // output is in the context of the main file. 2992a9be3e5b0c390f9189bb3dec2b2b6ba884f60ccDaniel Dunbar if (Reason == PPCallbacks::EnterFile && !IsFirstFileEntered) { 3002a9be3e5b0c390f9189bb3dec2b2b6ba884f60ccDaniel Dunbar IsFirstFileEntered = true; 3012a9be3e5b0c390f9189bb3dec2b2b6ba884f60ccDaniel Dunbar return; 3022a9be3e5b0c390f9189bb3dec2b2b6ba884f60ccDaniel Dunbar } 3032a9be3e5b0c390f9189bb3dec2b2b6ba884f60ccDaniel Dunbar 3045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Reason) { 3055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PPCallbacks::EnterFile: 306737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar WriteLineInfo(CurLine, " 1", 2); 3075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 3085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PPCallbacks::ExitFile: 309737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar WriteLineInfo(CurLine, " 2", 2); 310737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar break; 3111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case PPCallbacks::SystemHeaderPragma: 3121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case PPCallbacks::RenameFile: 313737bdb418c8283d53cb16dbf660de29bcd077b6cDaniel Dunbar WriteLineInfo(CurLine); 3145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 3155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 31815aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidisvoid PrintPPOutputPPCallbacks::InclusionDirective(SourceLocation HashLoc, 31915aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis const Token &IncludeTok, 32015aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis StringRef FileName, 32115aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis bool IsAngled, 32215aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis CharSourceRange FilenameRange, 32315aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis const FileEntry *File, 32415aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis StringRef SearchPath, 32515aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis StringRef RelativePath, 32615aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis const Module *Imported) { 32715aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis // When preprocessing, turn implicit imports into @imports. 32815aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis // FIXME: This is a stop-gap until a more comprehensive "preprocessing with 32915aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis // modules" solution is introduced. 33015aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis if (Imported) { 33115aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis startNewLineIfNeeded(); 33215aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis MoveToLine(HashLoc); 33315aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis OS << "@import " << Imported->getFullModuleName() << ";" 33415aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis << " /* clang -E: implicit import for \"" << File->getName() << "\" */"; 33556f6e09562568437e852eba192c17869beba1d49Argyrios Kyrtzidis EmittedTokensOnThisLine = true; 33615aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis } 33715aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis} 33815aa81a4746697311f71f5802ce27c7dc98b2ff3Argyrios Kyrtzidis 339c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner/// Ident - Handle #ident directives when read by the preprocessor. 3405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 3415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid PrintPPOutputPPCallbacks::Ident(SourceLocation Loc, const std::string &S) { 3425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer MoveToLine(Loc); 3431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 344e96de3e9134bee666f5cb1f5127b95e1c48c5bc2Chris Lattner OS.write("#ident ", strlen("#ident ")); 345e96de3e9134bee666f5cb1f5127b95e1c48c5bc2Chris Lattner OS.write(&S[0], S.size()); 3465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer EmittedTokensOnThisLine = true; 3475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 349d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner/// MacroDefined - This hook is called whenever a macro definition is seen. 3502aa9267cf193e5eceb9fd24a51b51c031b606fe9Craig Silversteinvoid PrintPPOutputPPCallbacks::MacroDefined(const Token &MacroNameTok, 351c515978bd3a703aa733f846a0094ffa84d149074Argyrios Kyrtzidis const MacroDirective *MD) { 352c56fff7fd231aebf4b152f60f8f11ef91835c48aArgyrios Kyrtzidis const MacroInfo *MI = MD->getMacroInfo(); 353d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner // Only print out macro definitions in -dD mode. 354d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner if (!DumpDefines || 355d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner // Ignore __FILE__ etc. 356d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner MI->isBuiltinMacro()) return; 3571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 358d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner MoveToLine(MI->getDefinitionLoc()); 3592aa9267cf193e5eceb9fd24a51b51c031b606fe9Craig Silverstein PrintMacroDefinition(*MacroNameTok.getIdentifierInfo(), *MI, PP, OS); 3600cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose setEmittedDirectiveOnThisLine(); 361d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner} 362d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner 3632aa9267cf193e5eceb9fd24a51b51c031b606fe9Craig Silversteinvoid PrintPPOutputPPCallbacks::MacroUndefined(const Token &MacroNameTok, 364c515978bd3a703aa733f846a0094ffa84d149074Argyrios Kyrtzidis const MacroDirective *MD) { 3652f05449fa1c9015a84b74c3308b856fc704662beBenjamin Kramer // Only print out macro definitions in -dD mode. 3662f05449fa1c9015a84b74c3308b856fc704662beBenjamin Kramer if (!DumpDefines) return; 3672f05449fa1c9015a84b74c3308b856fc704662beBenjamin Kramer 3682aa9267cf193e5eceb9fd24a51b51c031b606fe9Craig Silverstein MoveToLine(MacroNameTok.getLocation()); 3692aa9267cf193e5eceb9fd24a51b51c031b606fe9Craig Silverstein OS << "#undef " << MacroNameTok.getIdentifierInfo()->getName(); 3700cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose setEmittedDirectiveOnThisLine(); 3712f05449fa1c9015a84b74c3308b856fc704662beBenjamin Kramer} 372d82df3ad430397d7f9ef511e7c5157f997c41f53Chris Lattner 373a7ff62f9443efa3b13a28a1e566d4625b15b8553Aaron Ballmanstatic void outputPrintable(llvm::raw_ostream& OS, 374c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner const std::string &Str) { 375c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner for (unsigned i = 0, e = Str.size(); i != e; ++i) { 376c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner unsigned char Char = Str[i]; 3773f6f51e28231f65de9c2dd150a2d757b2162cfa3Jordan Rose if (isPrintable(Char) && Char != '\\' && Char != '"') 378c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner OS << (char)Char; 379c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner else // Output anything hard as an octal escape. 380c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner OS << '\\' 381c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner << (char)('0'+ ((Char >> 6) & 7)) 382c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner << (char)('0'+ ((Char >> 3) & 7)) 383c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner << (char)('0'+ ((Char >> 0) & 7)); 384c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner } 385a7ff62f9443efa3b13a28a1e566d4625b15b8553Aaron Ballman} 386a7ff62f9443efa3b13a28a1e566d4625b15b8553Aaron Ballman 387abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattnervoid PrintPPOutputPPCallbacks::PragmaMessage(SourceLocation Loc, 388076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs StringRef Namespace, 389076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs PragmaMessageKind Kind, 3905f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef Str) { 3910cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose startNewLineIfNeeded(); 392abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattner MoveToLine(Loc); 393076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs OS << "#pragma "; 394076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs if (!Namespace.empty()) 395076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs OS << Namespace << ' '; 396076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs switch (Kind) { 397076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs case PMK_Message: 398f5ae4dd6bf2310fbf4b192137aecd21248a08449Andy Gibbs OS << "message(\""; 399076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs break; 400076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs case PMK_Warning: 401688f2a1fc1ac38e8b7b602ab8afc69cdfa7492bfAndy Gibbs OS << "warning \""; 402076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs break; 403076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs case PMK_Error: 404688f2a1fc1ac38e8b7b602ab8afc69cdfa7492bfAndy Gibbs OS << "error \""; 405076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs break; 406076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs } 407abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattner 408a7ff62f9443efa3b13a28a1e566d4625b15b8553Aaron Ballman outputPrintable(OS, Str); 409abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattner OS << '"'; 410f5ae4dd6bf2310fbf4b192137aecd21248a08449Andy Gibbs if (Kind == PMK_Message) 411f5ae4dd6bf2310fbf4b192137aecd21248a08449Andy Gibbs OS << ')'; 4120cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose setEmittedDirectiveOnThisLine(); 413abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattner} 414abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattner 41585192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Sirajvoid PrintPPOutputPPCallbacks::PragmaDebug(SourceLocation Loc, 41685192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj StringRef DebugType) { 41785192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj startNewLineIfNeeded(); 41885192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj MoveToLine(Loc); 41985192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj 42085192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj OS << "#pragma clang __debug "; 42185192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj OS << DebugType; 42285192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj 42385192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj setEmittedDirectiveOnThisLine(); 42485192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj} 42585192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj 426c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregorvoid PrintPPOutputPPCallbacks:: 4275f9e272e632e951b1efe824cd16acb4d96077930Chris LattnerPragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) { 4280cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose startNewLineIfNeeded(); 429c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor MoveToLine(Loc); 430c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor OS << "#pragma " << Namespace << " diagnostic push"; 4310cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose setEmittedDirectiveOnThisLine(); 432c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor} 433c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor 434c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregorvoid PrintPPOutputPPCallbacks:: 4355f9e272e632e951b1efe824cd16acb4d96077930Chris LattnerPragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) { 4360cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose startNewLineIfNeeded(); 437c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor MoveToLine(Loc); 438c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor OS << "#pragma " << Namespace << " diagnostic pop"; 4390cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose setEmittedDirectiveOnThisLine(); 440c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor} 441c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor 442ef8225444452a1486bd721f3285301fe84643b00Stephen Hinesvoid PrintPPOutputPPCallbacks::PragmaDiagnostic(SourceLocation Loc, 443ef8225444452a1486bd721f3285301fe84643b00Stephen Hines StringRef Namespace, 444ef8225444452a1486bd721f3285301fe84643b00Stephen Hines diag::Severity Map, 445ef8225444452a1486bd721f3285301fe84643b00Stephen Hines StringRef Str) { 4460cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose startNewLineIfNeeded(); 447c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor MoveToLine(Loc); 448c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor OS << "#pragma " << Namespace << " diagnostic "; 449d7a3e2c5f61cd4893f95b69a424fe4def3aa0f69Benjamin Kramer switch (Map) { 450ef8225444452a1486bd721f3285301fe84643b00Stephen Hines case diag::Severity::Remark: 451651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines OS << "remark"; 452651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines break; 453ef8225444452a1486bd721f3285301fe84643b00Stephen Hines case diag::Severity::Warning: 454c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor OS << "warning"; 455c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor break; 456ef8225444452a1486bd721f3285301fe84643b00Stephen Hines case diag::Severity::Error: 457c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor OS << "error"; 458c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor break; 459ef8225444452a1486bd721f3285301fe84643b00Stephen Hines case diag::Severity::Ignored: 460c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor OS << "ignored"; 461c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor break; 462ef8225444452a1486bd721f3285301fe84643b00Stephen Hines case diag::Severity::Fatal: 463c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor OS << "fatal"; 464c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor break; 465c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor } 466c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor OS << " \"" << Str << '"'; 4670cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose setEmittedDirectiveOnThisLine(); 468c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor} 469c7d945d053f122eba704ef14c518db2ae595c562Chris Lattner 4702ee042dee9f7693665e28463955401905474a284Reid Klecknervoid PrintPPOutputPPCallbacks::PragmaWarning(SourceLocation Loc, 4712ee042dee9f7693665e28463955401905474a284Reid Kleckner StringRef WarningSpec, 4722ee042dee9f7693665e28463955401905474a284Reid Kleckner ArrayRef<int> Ids) { 4732ee042dee9f7693665e28463955401905474a284Reid Kleckner startNewLineIfNeeded(); 4742ee042dee9f7693665e28463955401905474a284Reid Kleckner MoveToLine(Loc); 4752ee042dee9f7693665e28463955401905474a284Reid Kleckner OS << "#pragma warning(" << WarningSpec << ':'; 4762ee042dee9f7693665e28463955401905474a284Reid Kleckner for (ArrayRef<int>::iterator I = Ids.begin(), E = Ids.end(); I != E; ++I) 4772ee042dee9f7693665e28463955401905474a284Reid Kleckner OS << ' ' << *I; 4782ee042dee9f7693665e28463955401905474a284Reid Kleckner OS << ')'; 4792ee042dee9f7693665e28463955401905474a284Reid Kleckner setEmittedDirectiveOnThisLine(); 4802ee042dee9f7693665e28463955401905474a284Reid Kleckner} 4812ee042dee9f7693665e28463955401905474a284Reid Kleckner 4822ee042dee9f7693665e28463955401905474a284Reid Klecknervoid PrintPPOutputPPCallbacks::PragmaWarningPush(SourceLocation Loc, 4832ee042dee9f7693665e28463955401905474a284Reid Kleckner int Level) { 4842ee042dee9f7693665e28463955401905474a284Reid Kleckner startNewLineIfNeeded(); 4852ee042dee9f7693665e28463955401905474a284Reid Kleckner MoveToLine(Loc); 4862ee042dee9f7693665e28463955401905474a284Reid Kleckner OS << "#pragma warning(push"; 48772c26c0d47eb850db18b784403260bce0632c478Reid Kleckner if (Level >= 0) 4882ee042dee9f7693665e28463955401905474a284Reid Kleckner OS << ", " << Level; 4892ee042dee9f7693665e28463955401905474a284Reid Kleckner OS << ')'; 4902ee042dee9f7693665e28463955401905474a284Reid Kleckner setEmittedDirectiveOnThisLine(); 4912ee042dee9f7693665e28463955401905474a284Reid Kleckner} 4922ee042dee9f7693665e28463955401905474a284Reid Kleckner 4932ee042dee9f7693665e28463955401905474a284Reid Klecknervoid PrintPPOutputPPCallbacks::PragmaWarningPop(SourceLocation Loc) { 4942ee042dee9f7693665e28463955401905474a284Reid Kleckner startNewLineIfNeeded(); 4952ee042dee9f7693665e28463955401905474a284Reid Kleckner MoveToLine(Loc); 4962ee042dee9f7693665e28463955401905474a284Reid Kleckner OS << "#pragma warning(pop)"; 4972ee042dee9f7693665e28463955401905474a284Reid Kleckner setEmittedDirectiveOnThisLine(); 4982ee042dee9f7693665e28463955401905474a284Reid Kleckner} 4992ee042dee9f7693665e28463955401905474a284Reid Kleckner 5005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// HandleFirstTokOnLine - When emitting a preprocessed file in -E mode, this 5015f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattner/// is called for the first token on each new line. If this really is the start 5025f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattner/// of a new logical line, handle it and return true, otherwise return false. 5035f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattner/// This may not be the start of a logical line because the "start of line" 5049f79a1f89695a79d5e29a72c28ffb59823b31cefChandler Carruth/// marker is set for spelling lines, not expansion ones. 5055f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattnerbool PrintPPOutputPPCallbacks::HandleFirstTokOnLine(Token &Tok) { 5065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Figure out what line we went to and insert the appropriate number of 5075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // newline characters. 5085f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattner if (!MoveToLine(Tok.getLocation())) 5095f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattner return false; 5101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Print out space characters so that the first token on a line is 5125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // indented for easy reading. 513a77c031cb66f75d22672070052cc6e0205289ff8Chandler Carruth unsigned ColNo = SM.getExpansionColumnNumber(Tok.getLocation()); 5141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 515651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // The first token on a line can have a column number of 1, yet still expect 516651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // leading white space, if a macro expansion in column 1 starts with an empty 517651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // macro argument, or an empty nested macro expansion. In this case, move the 518651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // token to column 2. 519651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (ColNo == 1 && Tok.hasLeadingSpace()) 520651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines ColNo = 2; 521651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 5225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // This hack prevents stuff like: 5235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // #define HASH # 5245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // HASH define foo bar 5255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // From having the # character end up at column 1, which makes it so it 5265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // is not handled as a #define next time through the preprocessor if in 5275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // -fpreprocessed mode. 528057aaf6304a5f59bcafa7b46c19625bb779af1d1Chris Lattner if (ColNo <= 1 && Tok.is(tok::hash)) 529e96de3e9134bee666f5cb1f5127b95e1c48c5bc2Chris Lattner OS << ' '; 5301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Otherwise, indent the appropriate number of spaces. 5325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (; ColNo > 1; --ColNo) 533e96de3e9134bee666f5cb1f5127b95e1c48c5bc2Chris Lattner OS << ' '; 5341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5355f1803210b24b79c1a20f88aa8b0c62191e9d1cbChris Lattner return true; 5365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 5383ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattnervoid PrintPPOutputPPCallbacks::HandleNewlinesInToken(const char *TokStr, 5393ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner unsigned Len) { 5403ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner unsigned NumNewlines = 0; 5413ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner for (; Len; --Len, ++TokStr) { 5423ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner if (*TokStr != '\n' && 5433ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner *TokStr != '\r') 5443ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner continue; 5451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5463ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner ++NumNewlines; 5471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5483ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner // If we have \n\r or \r\n, skip both and count as one line. 5493ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner if (Len != 1 && 5503ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner (TokStr[1] == '\n' || TokStr[1] == '\r') && 5513ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner TokStr[0] != TokStr[1]) 5523ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner ++TokStr, --Len; 5533ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner } 5541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5553ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner if (NumNewlines == 0) return; 5561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 557ed2d7c4ffd4112ddf10cb95e48428bae0b36377aChris Lattner CurLine += NumNewlines; 5583ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner} 5593ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner 5603ee211fd15dfeeb51bb69681084cdfcea427f314Chris Lattner 5615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencernamespace { 5625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerstruct UnknownPragmaHandler : public PragmaHandler { 5635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const char *Prefix; 5645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PrintPPOutputPPCallbacks *Callbacks; 5651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer UnknownPragmaHandler(const char *prefix, PrintPPOutputPPCallbacks *callbacks) 5679b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis : Prefix(prefix), Callbacks(callbacks) {} 568651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 569651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &PragmaTok) override { 5705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Figure out what line we went to and insert the appropriate number of 5715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // newline characters. 5720cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose Callbacks->startNewLineIfNeeded(); 5735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Callbacks->MoveToLine(PragmaTok.getLocation()); 574e96de3e9134bee666f5cb1f5127b95e1c48c5bc2Chris Lattner Callbacks->OS.write(Prefix, strlen(Prefix)); 5755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Read and print all of the pragma tokens. 57684021556baceb76eedf7d44be8ba71d9b8cfaccePeter Collingbourne while (PragmaTok.isNot(tok::eod)) { 5775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (PragmaTok.hasLeadingSpace()) 578e96de3e9134bee666f5cb1f5127b95e1c48c5bc2Chris Lattner Callbacks->OS << ' '; 5795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::string TokSpell = PP.getSpelling(PragmaTok); 580e96de3e9134bee666f5cb1f5127b95e1c48c5bc2Chris Lattner Callbacks->OS.write(&TokSpell[0], TokSpell.size()); 581651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 582651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // Expand macros in pragmas with -fms-extensions. The assumption is that 583651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // the majority of pragmas in such a file will be Microsoft pragmas. 584651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (PP.getLangOpts().MicrosoftExt) 585651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines PP.Lex(PragmaTok); 586651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines else 587651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines PP.LexUnexpandedToken(PragmaTok); 5885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 5890cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose Callbacks->setEmittedDirectiveOnThisLine(); 5905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 5915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}; 5925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} // end anonymous namespace 5935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 594f0f2b295437efecc0b52220b3f4a469fbb9aeac8Chris Lattner 59559076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattnerstatic void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok, 59659076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner PrintPPOutputPPCallbacks *Callbacks, 5975f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner raw_ostream &OS) { 598cf2c2e9588a12a716615850cc5bfacd9b20f68efJordan Rose bool DropComments = PP.getLangOpts().TraditionalCPP && 599cf2c2e9588a12a716615850cc5bfacd9b20f68efJordan Rose !PP.getCommentRetentionState(); 600cf2c2e9588a12a716615850cc5bfacd9b20f68efJordan Rose 601e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer char Buffer[256]; 602c54539cd173e20d8b179b9488fabfc5eb4cf5ee6Chris Lattner Token PrevPrevTok, PrevTok; 603c54539cd173e20d8b179b9488fabfc5eb4cf5ee6Chris Lattner PrevPrevTok.startToken(); 604c54539cd173e20d8b179b9488fabfc5eb4cf5ee6Chris Lattner PrevTok.startToken(); 60559076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner while (1) { 6060cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose if (Callbacks->hasEmittedDirectiveOnThisLine()) { 6070cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose Callbacks->startNewLineIfNeeded(); 6080cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose Callbacks->MoveToLine(Tok.getLocation()); 6090cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose } 6101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 61159076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner // If this token is at the start of a line, emit newlines if needed. 61259076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner if (Tok.isAtStartOfLine() && Callbacks->HandleFirstTokOnLine(Tok)) { 61359076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner // done. 6141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } else if (Tok.hasLeadingSpace() || 61559076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner // If we haven't emitted a token on this line yet, PrevTok isn't 61659076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner // useful to look at and no concatenation could happen anyway. 61759076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner (Callbacks->hasEmittedTokensOnThisLine() && 61859076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner // Don't print "-" next to "-", it would form "--". 6198877321ca66b2887c2f377a7f724a62f34fdf1cdChris Lattner Callbacks->AvoidConcat(PrevPrevTok, PrevTok, Tok))) { 62059076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner OS << ' '; 62159076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner } 6221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 623cf2c2e9588a12a716615850cc5bfacd9b20f68efJordan Rose if (DropComments && Tok.is(tok::comment)) { 624cf2c2e9588a12a716615850cc5bfacd9b20f68efJordan Rose // Skip comments. Normally the preprocessor does not generate 625cf2c2e9588a12a716615850cc5bfacd9b20f68efJordan Rose // tok::comment nodes at all when not keeping comments, but under 626cf2c2e9588a12a716615850cc5bfacd9b20f68efJordan Rose // -traditional-cpp the lexer keeps /all/ whitespace, including comments. 627cf2c2e9588a12a716615850cc5bfacd9b20f68efJordan Rose SourceLocation StartLoc = Tok.getLocation(); 628cf2c2e9588a12a716615850cc5bfacd9b20f68efJordan Rose Callbacks->MoveToLine(StartLoc.getLocWithOffset(Tok.getLength())); 629651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } else if (Tok.is(tok::annot_module_include) || 630651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Tok.is(tok::annot_module_begin) || 631651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Tok.is(tok::annot_module_end)) { 63226297f57634994b4ae47a0774c372d6944265bb2Richard Smith // PrintPPOutputPPCallbacks::InclusionDirective handles producing 63326297f57634994b4ae47a0774c372d6944265bb2Richard Smith // appropriate output here. Ignore this token entirely. 63426297f57634994b4ae47a0774c372d6944265bb2Richard Smith PP.Lex(Tok); 63526297f57634994b4ae47a0774c372d6944265bb2Richard Smith continue; 636cf2c2e9588a12a716615850cc5bfacd9b20f68efJordan Rose } else if (IdentifierInfo *II = Tok.getIdentifierInfo()) { 637e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer OS << II->getName(); 638e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer } else if (Tok.isLiteral() && !Tok.needsCleaning() && 639e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer Tok.getLiteralData()) { 640e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer OS.write(Tok.getLiteralData(), Tok.getLength()); 641e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer } else if (Tok.getLength() < 256) { 642e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer const char *TokPtr = Buffer; 643e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer unsigned Len = PP.getSpelling(Tok, TokPtr); 644e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer OS.write(TokPtr, Len); 645e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer 646e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer // Tokens that can contain embedded newlines need to adjust our current 647e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer // line number. 6486aad4a31b35df07fe818f193fcfd3c0197aea467Jordan Rose if (Tok.getKind() == tok::comment || Tok.getKind() == tok::unknown) 649e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer Callbacks->HandleNewlinesInToken(TokPtr, Len); 650e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer } else { 651e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer std::string S = PP.getSpelling(Tok); 652e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer OS.write(&S[0], S.size()); 653e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer 654e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer // Tokens that can contain embedded newlines need to adjust our current 655e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer // line number. 6566aad4a31b35df07fe818f193fcfd3c0197aea467Jordan Rose if (Tok.getKind() == tok::comment || Tok.getKind() == tok::unknown) 657e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer Callbacks->HandleNewlinesInToken(&S[0], S.size()); 658e396007efa010568d7ac7dff15762aec7653fc63Benjamin Kramer } 6590cdd1fe3ec29b5cbff9a728966ace5c5b5d614f7Jordan Rose Callbacks->setEmittedTokensOnThisLine(); 6601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 66159076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner if (Tok.is(tok::eof)) break; 6621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6638877321ca66b2887c2f377a7f724a62f34fdf1cdChris Lattner PrevPrevTok = PrevTok; 66459076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner PrevTok = Tok; 66559076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner PP.Lex(Tok); 66659076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner } 66759076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner} 66859076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner 669b3958476b21702a15f64f09d2862506d03dffe7bDmitri Gribenkotypedef std::pair<const IdentifierInfo *, MacroInfo *> id_macro_pair; 670767b3d2000a00c56e1a3c19372810e2b7d66b76cBenjamin Kramerstatic int MacroIDCompare(const id_macro_pair *LHS, const id_macro_pair *RHS) { 6713ff2a4b861082f271bb769755ea6d1da4b3e6b8dBenjamin Kramer return LHS->first->getName().compare(RHS->first->getName()); 6722a2bb1855a23b5415d3f6d0e1699c3c37c12ad28Chris Lattner} 67359076ab80b67774ee9e90d9d906c7877cb99f07bChris Lattner 6745f9e272e632e951b1efe824cd16acb4d96077930Chris Lattnerstatic void DoPrintMacros(Preprocessor &PP, raw_ostream *OS) { 675c72cc5072cdc1a1a6e05f9d0f962f293a69248c4Daniel Dunbar // Ignore unknown pragmas. 6766bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines PP.IgnorePragmas(); 677c72cc5072cdc1a1a6e05f9d0f962f293a69248c4Daniel Dunbar 678f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman // -dM mode just scans and ignores all tokens in the files, then dumps out 679f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman // the macro table at the end. 680e127a0d80155b45dafe77f2b4380e5fa111a3345Chris Lattner PP.EnterMainSourceFile(); 681f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman 682f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman Token Tok; 683f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman do PP.Lex(Tok); 684f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman while (Tok.isNot(tok::eof)); 685f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman 6868a64bb58c3b24d7d97895e435bbc0965c99bd3beAlexander Kornienko SmallVector<id_macro_pair, 128> MacrosByID; 6878a64bb58c3b24d7d97895e435bbc0965c99bd3beAlexander Kornienko for (Preprocessor::macro_iterator I = PP.macro_begin(), E = PP.macro_end(); 6888a64bb58c3b24d7d97895e435bbc0965c99bd3beAlexander Kornienko I != E; ++I) { 6898a64bb58c3b24d7d97895e435bbc0965c99bd3beAlexander Kornienko if (I->first->hasMacroDefinition()) 690c56fff7fd231aebf4b152f60f8f11ef91835c48aArgyrios Kyrtzidis MacrosByID.push_back(id_macro_pair(I->first, I->second->getMacroInfo())); 6918a64bb58c3b24d7d97895e435bbc0965c99bd3beAlexander Kornienko } 6923ff2a4b861082f271bb769755ea6d1da4b3e6b8dBenjamin Kramer llvm::array_pod_sort(MacrosByID.begin(), MacrosByID.end(), MacroIDCompare); 693f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman 694f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman for (unsigned i = 0, e = MacrosByID.size(); i != e; ++i) { 695f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman MacroInfo &MI = *MacrosByID[i].second; 6961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Ignore computed macros like __LINE__ and friends. 697f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman if (MI.isBuiltinMacro()) continue; 698f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman 699f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman PrintMacroDefinition(*MacrosByID[i].first, MI, PP, *OS); 7003ff2a4b861082f271bb769755ea6d1da4b3e6b8dBenjamin Kramer *OS << '\n'; 701f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman } 702f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman} 703f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman 7045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// DoPrintPreprocessedInput - This implements -E mode. 7055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 7065f9e272e632e951b1efe824cd16acb4d96077930Chris Lattnervoid clang::DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS, 70729cf746aef63b1984c013448e843a290b2badf7bDaniel Dunbar const PreprocessorOutputOptions &Opts) { 708775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar // Show macros with no output is handled specially. 709775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar if (!Opts.ShowCPP) { 710775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar assert(Opts.ShowMacros && "Not yet implemented!"); 711775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar DoPrintMacros(PP, OS); 712775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar return; 713775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar } 714775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar 7155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Inform the preprocessor whether we want it to retain comments or not, due 7165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // to -C or -CC. 717775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar PP.SetCommentRetentionState(Opts.ShowComments, Opts.ShowMacroComments); 718f54fce8ff8818cde6b421265f709319f5fea0844Eli Friedman 71912d3b1d98ec4463b733348e9fb8eadd19b365b0bEli Friedman PrintPPOutputPPCallbacks *Callbacks = 720775bee71ad21c84bc130af22ac47c1c8e0f9e72fDaniel Dunbar new PrintPPOutputPPCallbacks(PP, *OS, !Opts.ShowLineMarkers, 721eef63e0997e0f6d6436736ea919b851cfe34955aDaniel Dunbar Opts.ShowMacros); 7229b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis PP.AddPragmaHandler(new UnknownPragmaHandler("#pragma", Callbacks)); 7231397399de1cff90e0cb3b1d72097d34bd1a11759Chris Lattner PP.AddPragmaHandler("GCC", new UnknownPragmaHandler("#pragma GCC",Callbacks)); 7241397399de1cff90e0cb3b1d72097d34bd1a11759Chris Lattner PP.AddPragmaHandler("clang", 7251397399de1cff90e0cb3b1d72097d34bd1a11759Chris Lattner new UnknownPragmaHandler("#pragma clang", Callbacks)); 726f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman 727a5d10c4df435964600e104ebef6a96b106e416b7Kovarththanan Rajaratnam PP.addPPCallbacks(Callbacks); 728f54fce8ff8818cde6b421265f709319f5fea0844Eli Friedman 729f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman // After we have configured the preprocessor, enter the main file. 730e127a0d80155b45dafe77f2b4380e5fa111a3345Chris Lattner PP.EnterMainSourceFile(); 731f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman 732f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman // Consume all of the tokens that come from the predefines buffer. Those 733f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman // should not be emitted into the output and are guaranteed to be at the 734f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman // start. 735f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman const SourceManager &SourceMgr = PP.getSourceManager(); 736f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman Token Tok; 737cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor do { 738cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor PP.Lex(Tok); 739cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor if (Tok.is(tok::eof) || !Tok.getLocation().isFileID()) 740cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor break; 741cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor 742cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor PresumedLoc PLoc = SourceMgr.getPresumedLoc(Tok.getLocation()); 743cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor if (PLoc.isInvalid()) 744cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor break; 745cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor 746cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor if (strcmp(PLoc.getFilename(), "<built-in>")) 747cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor break; 748cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor } while (true); 749f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman 750f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman // Read all the preprocessed tokens, printing them out to the stream. 751f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman PrintPreprocessedTokens(PP, Tok, Callbacks, *OS); 752f1db58547a7004eefeca08b44f3e7da71ba578a2Eli Friedman *OS << '\n'; 7535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 754