blob: cfaf8a23b1180c921c0b62e4c2b6fe90a55596b6 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- PrintPreprocessedOutput.cpp - Implement the -E mode --------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This code simply runs the preprocessor on the input file and prints out the
11// result. This is the traditional behavior of the -E option.
12//
13//===----------------------------------------------------------------------===//
14
Eli Friedmanb09f6e12009-05-19 04:14:29 +000015#include "clang/Frontend/Utils.h"
Daniel Dunbar775bee72009-11-11 10:07:22 +000016#include "clang/Basic/Diagnostic.h"
17#include "clang/Basic/SourceManager.h"
18#include "clang/Frontend/PreprocessorOutputOptions.h"
Chris Lattnerf73903a2009-02-06 06:45:26 +000019#include "clang/Lex/MacroInfo.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000020#include "clang/Lex/PPCallbacks.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000021#include "clang/Lex/Pragma.h"
Daniel Dunbar775bee72009-11-11 10:07:22 +000022#include "clang/Lex/Preprocessor.h"
Chris Lattnerd7038e12009-02-13 00:46:04 +000023#include "clang/Lex/TokenConcatenation.h"
Chris Lattnerd8e30832007-07-24 06:57:14 +000024#include "llvm/ADT/SmallString.h"
Benjamin Kramer3ff2a4b2010-01-19 17:42:20 +000025#include "llvm/ADT/STLExtras.h"
Chris Lattnerabfe0942010-06-26 17:11:39 +000026#include "llvm/ADT/StringRef.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000027#include "llvm/Config/config.h"
Chris Lattnerdceb6a72008-08-17 01:47:12 +000028#include "llvm/Support/raw_ostream.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000029#include <cstdio>
30using namespace clang;
31
Chris Lattnerd82df3a2009-04-12 01:56:53 +000032/// PrintMacroDefinition - Print a macro definition in a form that will be
33/// properly accepted back as a definition.
34static void PrintMacroDefinition(const IdentifierInfo &II, const MacroInfo &MI,
35 Preprocessor &PP, llvm::raw_ostream &OS) {
36 OS << "#define " << II.getName();
Mike Stump1eb44332009-09-09 15:08:12 +000037
Chris Lattnerd82df3a2009-04-12 01:56:53 +000038 if (MI.isFunctionLike()) {
39 OS << '(';
Chris Lattner13d55582009-12-09 02:08:14 +000040 if (!MI.arg_empty()) {
Chris Lattnerd82df3a2009-04-12 01:56:53 +000041 MacroInfo::arg_iterator AI = MI.arg_begin(), E = MI.arg_end();
Chris Lattner13d55582009-12-09 02:08:14 +000042 for (; AI+1 != E; ++AI) {
43 OS << (*AI)->getName();
Chris Lattner807b93e2009-12-07 01:58:34 +000044 OS << ',';
Chris Lattner807b93e2009-12-07 01:58:34 +000045 }
Chris Lattner13d55582009-12-09 02:08:14 +000046
47 // Last argument.
48 if ((*AI)->getName() == "__VA_ARGS__")
49 OS << "...";
50 else
51 OS << (*AI)->getName();
Chris Lattnerd82df3a2009-04-12 01:56:53 +000052 }
Mike Stump1eb44332009-09-09 15:08:12 +000053
Chris Lattner807b93e2009-12-07 01:58:34 +000054 if (MI.isGNUVarargs())
55 OS << "..."; // #define foo(x...)
Kovarththanan Rajaratnama5d10c42010-03-07 07:30:06 +000056
Chris Lattnerd82df3a2009-04-12 01:56:53 +000057 OS << ')';
58 }
Mike Stump1eb44332009-09-09 15:08:12 +000059
Chris Lattnerd82df3a2009-04-12 01:56:53 +000060 // GCC always emits a space, even if the macro body is empty. However, do not
61 // want to emit two spaces if the first token has a leading space.
62 if (MI.tokens_empty() || !MI.tokens_begin()->hasLeadingSpace())
63 OS << ' ';
Mike Stump1eb44332009-09-09 15:08:12 +000064
Kovarththanan Rajaratnam19357542010-03-13 10:17:05 +000065 llvm::SmallString<128> SpellingBuffer;
Chris Lattnerd82df3a2009-04-12 01:56:53 +000066 for (MacroInfo::tokens_iterator I = MI.tokens_begin(), E = MI.tokens_end();
67 I != E; ++I) {
68 if (I->hasLeadingSpace())
69 OS << ' ';
Mike Stump1eb44332009-09-09 15:08:12 +000070
Benjamin Kramerddeea562010-02-27 13:44:12 +000071 OS << PP.getSpelling(*I, SpellingBuffer);
Chris Lattnerd82df3a2009-04-12 01:56:53 +000072 }
73}
74
Reid Spencer5f016e22007-07-11 17:01:13 +000075//===----------------------------------------------------------------------===//
76// Preprocessed token printer
77//===----------------------------------------------------------------------===//
78
Reid Spencer5f016e22007-07-11 17:01:13 +000079namespace {
80class PrintPPOutputPPCallbacks : public PPCallbacks {
81 Preprocessor &PP;
Chris Lattnerdf721402010-04-13 00:06:42 +000082 SourceManager &SM;
Chris Lattnerd7038e12009-02-13 00:46:04 +000083 TokenConcatenation ConcatInfo;
Chris Lattnere96de3e2008-08-17 03:12:02 +000084public:
85 llvm::raw_ostream &OS;
86private:
Reid Spencer5f016e22007-07-11 17:01:13 +000087 unsigned CurLine;
Daniel Dunbarf7c16d92010-08-24 22:44:13 +000088
89 /// The current include nesting level, used by header include dumping (-H).
90 unsigned CurrentIncludeDepth;
91
Reid Spencer5f016e22007-07-11 17:01:13 +000092 bool EmittedTokensOnThisLine;
Eli Friedman3e753e22009-06-02 07:55:39 +000093 bool EmittedMacroOnThisLine;
Chris Lattner9d728512008-10-27 01:19:25 +000094 SrcMgr::CharacteristicKind FileType;
Chris Lattnerd8e30832007-07-24 06:57:14 +000095 llvm::SmallString<512> CurFilename;
Daniel Dunbar737bdb42008-09-05 03:22:57 +000096 bool Initialized;
Eli Friedman12d3b1d2009-05-19 03:06:47 +000097 bool DisableLineMarkers;
98 bool DumpDefines;
Daniel Dunbarf7c16d92010-08-24 22:44:13 +000099 bool DumpHeaderIncludes;
Chris Lattnerf7449342009-12-07 01:42:56 +0000100 bool UseLineDirective;
Daniel Dunbarf7c16d92010-08-24 22:44:13 +0000101 bool HasProcessedPredefines;
Reid Spencer5f016e22007-07-11 17:01:13 +0000102public:
Eli Friedman12d3b1d2009-05-19 03:06:47 +0000103 PrintPPOutputPPCallbacks(Preprocessor &pp, llvm::raw_ostream &os,
Daniel Dunbarf7c16d92010-08-24 22:44:13 +0000104 bool lineMarkers, bool defines, bool headers)
Chris Lattnerdf721402010-04-13 00:06:42 +0000105 : PP(pp), SM(PP.getSourceManager()),
106 ConcatInfo(PP), OS(os), DisableLineMarkers(lineMarkers),
Daniel Dunbarf7c16d92010-08-24 22:44:13 +0000107 DumpDefines(defines), DumpHeaderIncludes(headers) {
108 CurLine = CurrentIncludeDepth = 0;
Chris Lattnerd8e30832007-07-24 06:57:14 +0000109 CurFilename += "<uninit>";
Reid Spencer5f016e22007-07-11 17:01:13 +0000110 EmittedTokensOnThisLine = false;
Eli Friedman3e753e22009-06-02 07:55:39 +0000111 EmittedMacroOnThisLine = false;
Chris Lattner0b9e7362008-09-26 21:18:42 +0000112 FileType = SrcMgr::C_User;
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000113 Initialized = false;
Daniel Dunbarf7c16d92010-08-24 22:44:13 +0000114 HasProcessedPredefines = false;
Kovarththanan Rajaratnama5d10c42010-03-07 07:30:06 +0000115
Chris Lattnerf7449342009-12-07 01:42:56 +0000116 // If we're in microsoft mode, use normal #line instead of line markers.
117 UseLineDirective = PP.getLangOptions().Microsoft;
Reid Spencer5f016e22007-07-11 17:01:13 +0000118 }
Mike Stump1eb44332009-09-09 15:08:12 +0000119
Reid Spencer5f016e22007-07-11 17:01:13 +0000120 void SetEmittedTokensOnThisLine() { EmittedTokensOnThisLine = true; }
Chris Lattnerf0f2b292007-07-23 06:09:34 +0000121 bool hasEmittedTokensOnThisLine() const { return EmittedTokensOnThisLine; }
Mike Stump1eb44332009-09-09 15:08:12 +0000122
Reid Spencer5f016e22007-07-11 17:01:13 +0000123 virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
Chris Lattner9d728512008-10-27 01:19:25 +0000124 SrcMgr::CharacteristicKind FileType);
Reid Spencer5f016e22007-07-11 17:01:13 +0000125 virtual void Ident(SourceLocation Loc, const std::string &str);
Mike Stump1eb44332009-09-09 15:08:12 +0000126 virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
Chris Lattnerc7d945d2009-01-16 19:25:54 +0000127 const std::string &Str);
Chris Lattnerabfe0942010-06-26 17:11:39 +0000128 virtual void PragmaMessage(SourceLocation Loc, llvm::StringRef Str);
Reid Spencer5f016e22007-07-11 17:01:13 +0000129
Chris Lattner5f180322007-12-09 21:11:08 +0000130 bool HandleFirstTokOnLine(Token &Tok);
Chris Lattner88aae912010-04-13 00:01:41 +0000131 bool MoveToLine(SourceLocation Loc) {
Chris Lattnerdf721402010-04-13 00:06:42 +0000132 return MoveToLine(SM.getPresumedLoc(Loc).getLine());
Chris Lattner88aae912010-04-13 00:01:41 +0000133 }
134 bool MoveToLine(unsigned LineNo);
135
Chris Lattner88773212010-04-14 03:57:19 +0000136 bool AvoidConcat(const Token &PrevPrevTok, const Token &PrevTok,
137 const Token &Tok) {
138 return ConcatInfo.AvoidConcat(PrevPrevTok, PrevTok, Tok);
Chris Lattnerd7038e12009-02-13 00:46:04 +0000139 }
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000140 void WriteLineInfo(unsigned LineNo, const char *Extra=0, unsigned ExtraLen=0);
Mike Stump1eb44332009-09-09 15:08:12 +0000141
Chris Lattner3ee211f2009-06-15 01:25:23 +0000142 void HandleNewlinesInToken(const char *TokStr, unsigned Len);
Mike Stump1eb44332009-09-09 15:08:12 +0000143
Chris Lattnerd82df3a2009-04-12 01:56:53 +0000144 /// MacroDefined - This hook is called whenever a macro definition is seen.
145 void MacroDefined(const IdentifierInfo *II, const MacroInfo *MI);
Mike Stump1eb44332009-09-09 15:08:12 +0000146
Benjamin Kramer2f054492010-08-07 22:27:00 +0000147 /// MacroUndefined - This hook is called whenever a macro #undef is seen.
148 void MacroUndefined(SourceLocation Loc, const IdentifierInfo *II,
149 const MacroInfo *MI);
Reid Spencer5f016e22007-07-11 17:01:13 +0000150};
Chris Lattner5db17c92008-04-08 04:16:20 +0000151} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +0000152
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000153void PrintPPOutputPPCallbacks::WriteLineInfo(unsigned LineNo,
154 const char *Extra,
155 unsigned ExtraLen) {
Eli Friedman3e753e22009-06-02 07:55:39 +0000156 if (EmittedTokensOnThisLine || EmittedMacroOnThisLine) {
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000157 OS << '\n';
158 EmittedTokensOnThisLine = false;
Eli Friedman3e753e22009-06-02 07:55:39 +0000159 EmittedMacroOnThisLine = false;
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000160 }
161
Chris Lattnerf7449342009-12-07 01:42:56 +0000162 // Emit #line directives or GNU line markers depending on what mode we're in.
163 if (UseLineDirective) {
164 OS << "#line" << ' ' << LineNo << ' ' << '"';
165 OS.write(&CurFilename[0], CurFilename.size());
166 OS << '"';
167 } else {
168 OS << '#' << ' ' << LineNo << ' ' << '"';
169 OS.write(&CurFilename[0], CurFilename.size());
170 OS << '"';
Kovarththanan Rajaratnama5d10c42010-03-07 07:30:06 +0000171
Steve Naroffd76fbda2009-12-06 01:02:14 +0000172 if (ExtraLen)
173 OS.write(Extra, ExtraLen);
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000174
Steve Naroffd76fbda2009-12-06 01:02:14 +0000175 if (FileType == SrcMgr::C_System)
176 OS.write(" 3", 2);
177 else if (FileType == SrcMgr::C_ExternCSystem)
178 OS.write(" 3 4", 4);
179 }
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000180 OS << '\n';
181}
182
Reid Spencer5f016e22007-07-11 17:01:13 +0000183/// MoveToLine - Move the output to the source line specified by the location
184/// object. We can do this by emitting some number of \n's, or be emitting a
Chris Lattner5f180322007-12-09 21:11:08 +0000185/// #line directive. This returns false if already at the specified line, true
186/// if some newlines were emitted.
Chris Lattner88aae912010-04-13 00:01:41 +0000187bool PrintPPOutputPPCallbacks::MoveToLine(unsigned LineNo) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000188 // If this line is "close enough" to the original line, just print newlines,
189 // otherwise print a #line directive.
Daniel Dunbarfd966842008-09-26 01:13:35 +0000190 if (LineNo-CurLine <= 8) {
Chris Lattner822f9402007-07-23 05:14:05 +0000191 if (LineNo-CurLine == 1)
Chris Lattnere96de3e2008-08-17 03:12:02 +0000192 OS << '\n';
Chris Lattner5f180322007-12-09 21:11:08 +0000193 else if (LineNo == CurLine)
Chris Lattnerf7cf85b2009-01-16 07:36:28 +0000194 return false; // Spelling line moved, but instantiation line didn't.
Chris Lattner822f9402007-07-23 05:14:05 +0000195 else {
196 const char *NewLines = "\n\n\n\n\n\n\n\n";
Chris Lattnere96de3e2008-08-17 03:12:02 +0000197 OS.write(NewLines, LineNo-CurLine);
Chris Lattner822f9402007-07-23 05:14:05 +0000198 }
Chris Lattner6133aeb2010-06-12 16:20:56 +0000199 } else if (!DisableLineMarkers) {
200 // Emit a #line or line marker.
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000201 WriteLineInfo(LineNo, 0, 0);
Chris Lattner6133aeb2010-06-12 16:20:56 +0000202 } else {
203 // Okay, we're in -P mode, which turns off line markers. However, we still
204 // need to emit a newline between tokens on different lines.
205 if (EmittedTokensOnThisLine || EmittedMacroOnThisLine) {
206 OS << '\n';
207 EmittedTokensOnThisLine = false;
208 EmittedMacroOnThisLine = false;
209 }
Mike Stump1eb44332009-09-09 15:08:12 +0000210 }
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000211
Mike Stump1eb44332009-09-09 15:08:12 +0000212 CurLine = LineNo;
Chris Lattner5f180322007-12-09 21:11:08 +0000213 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +0000214}
215
216
217/// FileChanged - Whenever the preprocessor enters or exits a #include file
218/// it invokes this handler. Update our conception of the current source
219/// position.
220void PrintPPOutputPPCallbacks::FileChanged(SourceLocation Loc,
221 FileChangeReason Reason,
Chris Lattner9d728512008-10-27 01:19:25 +0000222 SrcMgr::CharacteristicKind NewFileType) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000223 // Unless we are exiting a #include, make sure to skip ahead to the line the
224 // #include directive was at.
Chris Lattnerdf721402010-04-13 00:06:42 +0000225 SourceManager &SourceMgr = SM;
Chris Lattner88aae912010-04-13 00:01:41 +0000226
227 PresumedLoc UserLoc = SourceMgr.getPresumedLoc(Loc);
Chris Lattner86d0ef72010-04-14 04:28:50 +0000228 unsigned NewLine = UserLoc.getLine();
Daniel Dunbarf7c16d92010-08-24 22:44:13 +0000229
Reid Spencer5f016e22007-07-11 17:01:13 +0000230 if (Reason == PPCallbacks::EnterFile) {
Chris Lattner71d8bfb2009-01-30 18:44:17 +0000231 SourceLocation IncludeLoc = SourceMgr.getPresumedLoc(Loc).getIncludeLoc();
232 if (IncludeLoc.isValid())
233 MoveToLine(IncludeLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +0000234 } else if (Reason == PPCallbacks::SystemHeaderPragma) {
Chris Lattner88aae912010-04-13 00:01:41 +0000235 MoveToLine(NewLine);
Mike Stump1eb44332009-09-09 15:08:12 +0000236
Reid Spencer5f016e22007-07-11 17:01:13 +0000237 // TODO GCC emits the # directive for this directive on the line AFTER the
238 // directive and emits a bunch of spaces that aren't needed. Emulate this
239 // strange behavior.
240 }
Daniel Dunbarf7c16d92010-08-24 22:44:13 +0000241
242 // Adjust the current include depth.
243 if (Reason == PPCallbacks::EnterFile) {
244 ++CurrentIncludeDepth;
245 } else {
246 if (CurrentIncludeDepth)
247 --CurrentIncludeDepth;
248
249 // We track when we are done with the predefines by watching for the first
250 // place where we drop back to a nesting depth of 0.
251 if (CurrentIncludeDepth == 0 && !HasProcessedPredefines)
252 HasProcessedPredefines = true;
253 }
Chris Lattner88aae912010-04-13 00:01:41 +0000254
255 CurLine = NewLine;
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000256
Chris Lattnerd8e30832007-07-24 06:57:14 +0000257 CurFilename.clear();
Chris Lattner88aae912010-04-13 00:01:41 +0000258 CurFilename += UserLoc.getFilename();
Chris Lattnerd8e30832007-07-24 06:57:14 +0000259 Lexer::Stringify(CurFilename);
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000260 FileType = NewFileType;
261
Daniel Dunbarf7c16d92010-08-24 22:44:13 +0000262 // Dump the header include information, if enabled and we are past the
263 // predefines buffer.
264 if (DumpHeaderIncludes && HasProcessedPredefines &&
265 Reason == PPCallbacks::EnterFile) {
266 llvm::SmallString<256> Msg;
267 llvm::raw_svector_ostream OS(Msg);
268 for (unsigned i = 0; i != CurrentIncludeDepth; ++i)
269 OS << '.';
270 OS << ' ' << CurFilename << '\n';
271 llvm::errs() << OS.str();
272 }
273
274 if (DisableLineMarkers) return;
275
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000276 if (!Initialized) {
277 WriteLineInfo(CurLine);
278 Initialized = true;
Reid Spencer5f016e22007-07-11 17:01:13 +0000279 }
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000280
Reid Spencer5f016e22007-07-11 17:01:13 +0000281 switch (Reason) {
282 case PPCallbacks::EnterFile:
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000283 WriteLineInfo(CurLine, " 1", 2);
Reid Spencer5f016e22007-07-11 17:01:13 +0000284 break;
285 case PPCallbacks::ExitFile:
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000286 WriteLineInfo(CurLine, " 2", 2);
Reid Spencer5f016e22007-07-11 17:01:13 +0000287 break;
Mike Stump1eb44332009-09-09 15:08:12 +0000288 case PPCallbacks::SystemHeaderPragma:
289 case PPCallbacks::RenameFile:
Daniel Dunbar737bdb42008-09-05 03:22:57 +0000290 WriteLineInfo(CurLine);
291 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000292 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000293}
294
Chris Lattnerc7d945d2009-01-16 19:25:54 +0000295/// Ident - Handle #ident directives when read by the preprocessor.
Reid Spencer5f016e22007-07-11 17:01:13 +0000296///
297void PrintPPOutputPPCallbacks::Ident(SourceLocation Loc, const std::string &S) {
298 MoveToLine(Loc);
Mike Stump1eb44332009-09-09 15:08:12 +0000299
Chris Lattnere96de3e2008-08-17 03:12:02 +0000300 OS.write("#ident ", strlen("#ident "));
301 OS.write(&S[0], S.size());
Reid Spencer5f016e22007-07-11 17:01:13 +0000302 EmittedTokensOnThisLine = true;
303}
304
Chris Lattnerd82df3a2009-04-12 01:56:53 +0000305/// MacroDefined - This hook is called whenever a macro definition is seen.
306void PrintPPOutputPPCallbacks::MacroDefined(const IdentifierInfo *II,
307 const MacroInfo *MI) {
308 // Only print out macro definitions in -dD mode.
309 if (!DumpDefines ||
310 // Ignore __FILE__ etc.
311 MI->isBuiltinMacro()) return;
Mike Stump1eb44332009-09-09 15:08:12 +0000312
Chris Lattnerd82df3a2009-04-12 01:56:53 +0000313 MoveToLine(MI->getDefinitionLoc());
314 PrintMacroDefinition(*II, *MI, PP, OS);
Eli Friedman3e753e22009-06-02 07:55:39 +0000315 EmittedMacroOnThisLine = true;
Chris Lattnerd82df3a2009-04-12 01:56:53 +0000316}
317
Benjamin Kramer2f054492010-08-07 22:27:00 +0000318void PrintPPOutputPPCallbacks::MacroUndefined(SourceLocation Loc,
319 const IdentifierInfo *II,
320 const MacroInfo *MI) {
321 // Only print out macro definitions in -dD mode.
322 if (!DumpDefines) return;
323
324 MoveToLine(Loc);
325 OS << "#undef " << II->getName();
326 EmittedMacroOnThisLine = true;
327}
Chris Lattnerd82df3a2009-04-12 01:56:53 +0000328
Chris Lattnerc7d945d2009-01-16 19:25:54 +0000329void PrintPPOutputPPCallbacks::PragmaComment(SourceLocation Loc,
Mike Stump1eb44332009-09-09 15:08:12 +0000330 const IdentifierInfo *Kind,
Chris Lattnerc7d945d2009-01-16 19:25:54 +0000331 const std::string &Str) {
332 MoveToLine(Loc);
333 OS << "#pragma comment(" << Kind->getName();
Mike Stump1eb44332009-09-09 15:08:12 +0000334
Chris Lattnerc7d945d2009-01-16 19:25:54 +0000335 if (!Str.empty()) {
336 OS << ", \"";
Mike Stump1eb44332009-09-09 15:08:12 +0000337
Chris Lattnerc7d945d2009-01-16 19:25:54 +0000338 for (unsigned i = 0, e = Str.size(); i != e; ++i) {
339 unsigned char Char = Str[i];
Chris Lattner52a3e9e2009-01-16 22:13:37 +0000340 if (isprint(Char) && Char != '\\' && Char != '"')
Chris Lattnerc7d945d2009-01-16 19:25:54 +0000341 OS << (char)Char;
342 else // Output anything hard as an octal escape.
343 OS << '\\'
344 << (char)('0'+ ((Char >> 6) & 7))
345 << (char)('0'+ ((Char >> 3) & 7))
346 << (char)('0'+ ((Char >> 0) & 7));
347 }
348 OS << '"';
349 }
Mike Stump1eb44332009-09-09 15:08:12 +0000350
Chris Lattnerc7d945d2009-01-16 19:25:54 +0000351 OS << ')';
352 EmittedTokensOnThisLine = true;
353}
354
Chris Lattnerabfe0942010-06-26 17:11:39 +0000355void PrintPPOutputPPCallbacks::PragmaMessage(SourceLocation Loc,
356 llvm::StringRef Str) {
357 MoveToLine(Loc);
358 OS << "#pragma message(";
359
360 OS << '"';
361
362 for (unsigned i = 0, e = Str.size(); i != e; ++i) {
363 unsigned char Char = Str[i];
364 if (isprint(Char) && Char != '\\' && Char != '"')
365 OS << (char)Char;
366 else // Output anything hard as an octal escape.
367 OS << '\\'
368 << (char)('0'+ ((Char >> 6) & 7))
369 << (char)('0'+ ((Char >> 3) & 7))
370 << (char)('0'+ ((Char >> 0) & 7));
371 }
372 OS << '"';
373
374 OS << ')';
375 EmittedTokensOnThisLine = true;
376}
377
Chris Lattnerc7d945d2009-01-16 19:25:54 +0000378
Reid Spencer5f016e22007-07-11 17:01:13 +0000379/// HandleFirstTokOnLine - When emitting a preprocessed file in -E mode, this
Chris Lattner5f180322007-12-09 21:11:08 +0000380/// is called for the first token on each new line. If this really is the start
381/// of a new logical line, handle it and return true, otherwise return false.
382/// This may not be the start of a logical line because the "start of line"
Chris Lattnerf7cf85b2009-01-16 07:36:28 +0000383/// marker is set for spelling lines, not instantiation ones.
Chris Lattner5f180322007-12-09 21:11:08 +0000384bool PrintPPOutputPPCallbacks::HandleFirstTokOnLine(Token &Tok) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000385 // Figure out what line we went to and insert the appropriate number of
386 // newline characters.
Chris Lattner5f180322007-12-09 21:11:08 +0000387 if (!MoveToLine(Tok.getLocation()))
388 return false;
Mike Stump1eb44332009-09-09 15:08:12 +0000389
Reid Spencer5f016e22007-07-11 17:01:13 +0000390 // Print out space characters so that the first token on a line is
391 // indented for easy reading.
Chris Lattnerdf721402010-04-13 00:06:42 +0000392 unsigned ColNo = SM.getInstantiationColumnNumber(Tok.getLocation());
Mike Stump1eb44332009-09-09 15:08:12 +0000393
Reid Spencer5f016e22007-07-11 17:01:13 +0000394 // This hack prevents stuff like:
395 // #define HASH #
396 // HASH define foo bar
397 // From having the # character end up at column 1, which makes it so it
398 // is not handled as a #define next time through the preprocessor if in
399 // -fpreprocessed mode.
Chris Lattner057aaf62007-10-09 18:03:42 +0000400 if (ColNo <= 1 && Tok.is(tok::hash))
Chris Lattnere96de3e2008-08-17 03:12:02 +0000401 OS << ' ';
Mike Stump1eb44332009-09-09 15:08:12 +0000402
Reid Spencer5f016e22007-07-11 17:01:13 +0000403 // Otherwise, indent the appropriate number of spaces.
404 for (; ColNo > 1; --ColNo)
Chris Lattnere96de3e2008-08-17 03:12:02 +0000405 OS << ' ';
Mike Stump1eb44332009-09-09 15:08:12 +0000406
Chris Lattner5f180322007-12-09 21:11:08 +0000407 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +0000408}
409
Chris Lattner3ee211f2009-06-15 01:25:23 +0000410void PrintPPOutputPPCallbacks::HandleNewlinesInToken(const char *TokStr,
411 unsigned Len) {
412 unsigned NumNewlines = 0;
413 for (; Len; --Len, ++TokStr) {
414 if (*TokStr != '\n' &&
415 *TokStr != '\r')
416 continue;
Mike Stump1eb44332009-09-09 15:08:12 +0000417
Chris Lattner3ee211f2009-06-15 01:25:23 +0000418 ++NumNewlines;
Mike Stump1eb44332009-09-09 15:08:12 +0000419
Chris Lattner3ee211f2009-06-15 01:25:23 +0000420 // If we have \n\r or \r\n, skip both and count as one line.
421 if (Len != 1 &&
422 (TokStr[1] == '\n' || TokStr[1] == '\r') &&
423 TokStr[0] != TokStr[1])
424 ++TokStr, --Len;
425 }
Mike Stump1eb44332009-09-09 15:08:12 +0000426
Chris Lattner3ee211f2009-06-15 01:25:23 +0000427 if (NumNewlines == 0) return;
Mike Stump1eb44332009-09-09 15:08:12 +0000428
Chris Lattnered2d7c42009-06-15 04:08:28 +0000429 CurLine += NumNewlines;
Chris Lattner3ee211f2009-06-15 01:25:23 +0000430}
431
432
Reid Spencer5f016e22007-07-11 17:01:13 +0000433namespace {
434struct UnknownPragmaHandler : public PragmaHandler {
435 const char *Prefix;
436 PrintPPOutputPPCallbacks *Callbacks;
Mike Stump1eb44332009-09-09 15:08:12 +0000437
Reid Spencer5f016e22007-07-11 17:01:13 +0000438 UnknownPragmaHandler(const char *prefix, PrintPPOutputPPCallbacks *callbacks)
Argyrios Kyrtzidis9b36c3f2010-07-13 09:07:17 +0000439 : Prefix(prefix), Callbacks(callbacks) {}
Chris Lattnerd2177732007-07-20 16:59:19 +0000440 virtual void HandlePragma(Preprocessor &PP, Token &PragmaTok) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000441 // Figure out what line we went to and insert the appropriate number of
442 // newline characters.
443 Callbacks->MoveToLine(PragmaTok.getLocation());
Chris Lattnere96de3e2008-08-17 03:12:02 +0000444 Callbacks->OS.write(Prefix, strlen(Prefix));
Mike Stump1eb44332009-09-09 15:08:12 +0000445
Reid Spencer5f016e22007-07-11 17:01:13 +0000446 // Read and print all of the pragma tokens.
Chris Lattner057aaf62007-10-09 18:03:42 +0000447 while (PragmaTok.isNot(tok::eom)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000448 if (PragmaTok.hasLeadingSpace())
Chris Lattnere96de3e2008-08-17 03:12:02 +0000449 Callbacks->OS << ' ';
Reid Spencer5f016e22007-07-11 17:01:13 +0000450 std::string TokSpell = PP.getSpelling(PragmaTok);
Chris Lattnere96de3e2008-08-17 03:12:02 +0000451 Callbacks->OS.write(&TokSpell[0], TokSpell.size());
Reid Spencer5f016e22007-07-11 17:01:13 +0000452 PP.LexUnexpandedToken(PragmaTok);
453 }
Chris Lattnere96de3e2008-08-17 03:12:02 +0000454 Callbacks->OS << '\n';
Reid Spencer5f016e22007-07-11 17:01:13 +0000455 }
456};
457} // end anonymous namespace
458
Chris Lattnerf0f2b292007-07-23 06:09:34 +0000459
Chris Lattner59076ab2009-02-06 05:56:11 +0000460static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok,
461 PrintPPOutputPPCallbacks *Callbacks,
462 llvm::raw_ostream &OS) {
Benjamin Kramere3960072010-02-27 18:02:51 +0000463 char Buffer[256];
Chris Lattnerc54539c2010-06-15 21:06:38 +0000464 Token PrevPrevTok, PrevTok;
465 PrevPrevTok.startToken();
466 PrevTok.startToken();
Chris Lattner6f688e12007-10-10 20:45:16 +0000467 while (1) {
Mike Stump1eb44332009-09-09 15:08:12 +0000468
Reid Spencer5f016e22007-07-11 17:01:13 +0000469 // If this token is at the start of a line, emit newlines if needed.
Chris Lattner5f180322007-12-09 21:11:08 +0000470 if (Tok.isAtStartOfLine() && Callbacks->HandleFirstTokOnLine(Tok)) {
471 // done.
Mike Stump1eb44332009-09-09 15:08:12 +0000472 } else if (Tok.hasLeadingSpace() ||
Chris Lattnerf0f2b292007-07-23 06:09:34 +0000473 // If we haven't emitted a token on this line yet, PrevTok isn't
474 // useful to look at and no concatenation could happen anyway.
Chris Lattnerb638a302007-07-23 23:21:34 +0000475 (Callbacks->hasEmittedTokensOnThisLine() &&
Chris Lattnerf0f2b292007-07-23 06:09:34 +0000476 // Don't print "-" next to "-", it would form "--".
Chris Lattner88773212010-04-14 03:57:19 +0000477 Callbacks->AvoidConcat(PrevPrevTok, PrevTok, Tok))) {
Chris Lattnere96de3e2008-08-17 03:12:02 +0000478 OS << ' ';
Reid Spencer5f016e22007-07-11 17:01:13 +0000479 }
Mike Stump1eb44332009-09-09 15:08:12 +0000480
Benjamin Kramere3960072010-02-27 18:02:51 +0000481 if (IdentifierInfo *II = Tok.getIdentifierInfo()) {
482 OS << II->getName();
483 } else if (Tok.isLiteral() && !Tok.needsCleaning() &&
484 Tok.getLiteralData()) {
485 OS.write(Tok.getLiteralData(), Tok.getLength());
486 } else if (Tok.getLength() < 256) {
487 const char *TokPtr = Buffer;
488 unsigned Len = PP.getSpelling(Tok, TokPtr);
489 OS.write(TokPtr, Len);
Mike Stump1eb44332009-09-09 15:08:12 +0000490
Benjamin Kramere3960072010-02-27 18:02:51 +0000491 // Tokens that can contain embedded newlines need to adjust our current
492 // line number.
493 if (Tok.getKind() == tok::comment)
494 Callbacks->HandleNewlinesInToken(TokPtr, Len);
495 } else {
496 std::string S = PP.getSpelling(Tok);
497 OS.write(&S[0], S.size());
498
499 // Tokens that can contain embedded newlines need to adjust our current
500 // line number.
501 if (Tok.getKind() == tok::comment)
502 Callbacks->HandleNewlinesInToken(&S[0], S.size());
503 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000504 Callbacks->SetEmittedTokensOnThisLine();
Mike Stump1eb44332009-09-09 15:08:12 +0000505
Chris Lattner6f688e12007-10-10 20:45:16 +0000506 if (Tok.is(tok::eof)) break;
Mike Stump1eb44332009-09-09 15:08:12 +0000507
Chris Lattner88773212010-04-14 03:57:19 +0000508 PrevPrevTok = PrevTok;
Chris Lattner6f688e12007-10-10 20:45:16 +0000509 PrevTok = Tok;
510 PP.Lex(Tok);
511 }
Chris Lattner59076ab2009-02-06 05:56:11 +0000512}
513
Benjamin Kramer3ff2a4b2010-01-19 17:42:20 +0000514typedef std::pair<IdentifierInfo*, MacroInfo*> id_macro_pair;
515static int MacroIDCompare(const void* a, const void* b) {
516 const id_macro_pair *LHS = static_cast<const id_macro_pair*>(a);
517 const id_macro_pair *RHS = static_cast<const id_macro_pair*>(b);
518 return LHS->first->getName().compare(RHS->first->getName());
Chris Lattner2a2bb182009-02-10 22:28:19 +0000519}
Chris Lattner59076ab2009-02-06 05:56:11 +0000520
Daniel Dunbar775bee72009-11-11 10:07:22 +0000521static void DoPrintMacros(Preprocessor &PP, llvm::raw_ostream *OS) {
Daniel Dunbarc72cc502010-06-11 20:10:12 +0000522 // Ignore unknown pragmas.
Argyrios Kyrtzidis9b36c3f2010-07-13 09:07:17 +0000523 PP.AddPragmaHandler(new EmptyPragmaHandler());
Daniel Dunbarc72cc502010-06-11 20:10:12 +0000524
Eli Friedmanf1db5852009-05-19 01:32:34 +0000525 // -dM mode just scans and ignores all tokens in the files, then dumps out
526 // the macro table at the end.
Chris Lattnere127a0d2010-04-20 20:35:58 +0000527 PP.EnterMainSourceFile();
Eli Friedmanf1db5852009-05-19 01:32:34 +0000528
529 Token Tok;
530 do PP.Lex(Tok);
531 while (Tok.isNot(tok::eof));
532
Benjamin Kramer3ff2a4b2010-01-19 17:42:20 +0000533 llvm::SmallVector<id_macro_pair, 128>
534 MacrosByID(PP.macro_begin(), PP.macro_end());
535 llvm::array_pod_sort(MacrosByID.begin(), MacrosByID.end(), MacroIDCompare);
Eli Friedmanf1db5852009-05-19 01:32:34 +0000536
537 for (unsigned i = 0, e = MacrosByID.size(); i != e; ++i) {
538 MacroInfo &MI = *MacrosByID[i].second;
Mike Stump1eb44332009-09-09 15:08:12 +0000539 // Ignore computed macros like __LINE__ and friends.
Eli Friedmanf1db5852009-05-19 01:32:34 +0000540 if (MI.isBuiltinMacro()) continue;
541
542 PrintMacroDefinition(*MacrosByID[i].first, MI, PP, *OS);
Benjamin Kramer3ff2a4b2010-01-19 17:42:20 +0000543 *OS << '\n';
Eli Friedmanf1db5852009-05-19 01:32:34 +0000544 }
545}
546
Chris Lattner59076ab2009-02-06 05:56:11 +0000547/// DoPrintPreprocessedInput - This implements -E mode.
548///
Eli Friedman12d3b1d2009-05-19 03:06:47 +0000549void clang::DoPrintPreprocessedInput(Preprocessor &PP, llvm::raw_ostream *OS,
Daniel Dunbar29cf7462009-11-11 10:07:44 +0000550 const PreprocessorOutputOptions &Opts) {
Daniel Dunbar775bee72009-11-11 10:07:22 +0000551 // Show macros with no output is handled specially.
552 if (!Opts.ShowCPP) {
553 assert(Opts.ShowMacros && "Not yet implemented!");
554 DoPrintMacros(PP, OS);
555 return;
556 }
557
Chris Lattner59076ab2009-02-06 05:56:11 +0000558 // Inform the preprocessor whether we want it to retain comments or not, due
559 // to -C or -CC.
Daniel Dunbar775bee72009-11-11 10:07:22 +0000560 PP.SetCommentRetentionState(Opts.ShowComments, Opts.ShowMacroComments);
Eli Friedmanf54fce82009-05-19 01:02:07 +0000561
Eli Friedman12d3b1d2009-05-19 03:06:47 +0000562 PrintPPOutputPPCallbacks *Callbacks =
Daniel Dunbar775bee72009-11-11 10:07:22 +0000563 new PrintPPOutputPPCallbacks(PP, *OS, !Opts.ShowLineMarkers,
Daniel Dunbarf7c16d92010-08-24 22:44:13 +0000564 Opts.ShowMacros, Opts.ShowHeaderIncludes);
Argyrios Kyrtzidis9b36c3f2010-07-13 09:07:17 +0000565 PP.AddPragmaHandler(new UnknownPragmaHandler("#pragma", Callbacks));
Eli Friedmanf1db5852009-05-19 01:32:34 +0000566 PP.AddPragmaHandler("GCC", new UnknownPragmaHandler("#pragma GCC",
567 Callbacks));
Chris Lattner59076ab2009-02-06 05:56:11 +0000568
Kovarththanan Rajaratnama5d10c42010-03-07 07:30:06 +0000569 PP.addPPCallbacks(Callbacks);
Chris Lattner59076ab2009-02-06 05:56:11 +0000570
Eli Friedmanf1db5852009-05-19 01:32:34 +0000571 // After we have configured the preprocessor, enter the main file.
Chris Lattnere127a0d2010-04-20 20:35:58 +0000572 PP.EnterMainSourceFile();
Chris Lattner59076ab2009-02-06 05:56:11 +0000573
Eli Friedmanf1db5852009-05-19 01:32:34 +0000574 // Consume all of the tokens that come from the predefines buffer. Those
575 // should not be emitted into the output and are guaranteed to be at the
576 // start.
577 const SourceManager &SourceMgr = PP.getSourceManager();
578 Token Tok;
579 do PP.Lex(Tok);
580 while (Tok.isNot(tok::eof) && Tok.getLocation().isFileID() &&
581 !strcmp(SourceMgr.getPresumedLoc(Tok.getLocation()).getFilename(),
582 "<built-in>"));
Chris Lattner59076ab2009-02-06 05:56:11 +0000583
Eli Friedmanf1db5852009-05-19 01:32:34 +0000584 // Read all the preprocessed tokens, printing them out to the stream.
585 PrintPreprocessedTokens(PP, Tok, Callbacks, *OS);
586 *OS << '\n';
Reid Spencer5f016e22007-07-11 17:01:13 +0000587}
588