blob: 67ea056417f6828bfb8b2c5d52faa8bd38ea4c02 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- Diagnostic.cpp - C Language Family Diagnostic Handling -----------===//
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 file implements the Diagnostic-related interfaces.
11//
12//===----------------------------------------------------------------------===//
13
Ted Kremenekec55c942010-04-12 19:54:17 +000014#include "clang/Basic/Diagnostic.h"
Chris Lattner43b628c2008-11-19 07:32:16 +000015#include "clang/Basic/IdentifierTable.h"
Ted Kremenekec55c942010-04-12 19:54:17 +000016#include "clang/Basic/PartialDiagnostic.h"
Chris Lattnerf4c83962008-11-19 06:51:40 +000017#include "llvm/ADT/SmallVector.h"
Daniel Dunbar23e47c62009-10-17 18:12:14 +000018#include "llvm/Support/raw_ostream.h"
Ted Kremenek03201fb2011-03-21 18:40:07 +000019#include "llvm/Support/CrashRecoveryContext.h"
20
Reid Spencer5f016e22007-07-11 17:01:13 +000021using namespace clang;
22
David Blaikied6471f72011-09-25 23:23:43 +000023static void DummyArgToStringFn(DiagnosticsEngine::ArgumentKind AK, intptr_t QT,
Chris Lattner3fdf4b02008-11-23 09:21:17 +000024 const char *Modifier, unsigned ML,
25 const char *Argument, unsigned ArgLen,
David Blaikied6471f72011-09-25 23:23:43 +000026 const DiagnosticsEngine::ArgumentValue *PrevArgs,
Chris Lattnerb54d8af2009-10-20 05:25:22 +000027 unsigned NumPrevArgs,
Chris Lattner5f9e2722011-07-23 10:55:15 +000028 SmallVectorImpl<char> &Output,
Chandler Carruth0673cb32011-07-11 17:49:21 +000029 void *Cookie,
Chris Lattner5f9e2722011-07-23 10:55:15 +000030 SmallVectorImpl<intptr_t> &QualTypeVals) {
Chris Lattner3fdf4b02008-11-23 09:21:17 +000031 const char *Str = "<can't format argument>";
Chris Lattner22caddc2008-11-23 09:13:29 +000032 Output.append(Str, Str+strlen(Str));
33}
34
35
David Blaikied6471f72011-09-25 23:23:43 +000036DiagnosticsEngine::DiagnosticsEngine(
37 const llvm::IntrusiveRefCntPtr<DiagnosticIDs> &diags,
David Blaikie78ad0b92011-09-25 23:39:51 +000038 DiagnosticConsumer *client, bool ShouldOwnClient)
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +000039 : Diags(diags), Client(client), OwnsDiagClient(ShouldOwnClient),
40 SourceMgr(0) {
Chris Lattner3fdf4b02008-11-23 09:21:17 +000041 ArgToStringFn = DummyArgToStringFn;
Chris Lattner92dd3862009-02-19 23:53:20 +000042 ArgToStringCookie = 0;
Mike Stump1eb44332009-09-09 15:08:12 +000043
Douglas Gregorcc5888d2010-07-31 00:40:00 +000044 AllExtensionsSilenced = 0;
45 IgnoreAllWarnings = false;
46 WarningsAsErrors = false;
Ted Kremenek1e473cc2011-08-18 01:12:56 +000047 EnableAllWarnings = false;
Douglas Gregorcc5888d2010-07-31 00:40:00 +000048 ErrorsAsFatal = false;
49 SuppressSystemWarnings = false;
50 SuppressAllDiagnostics = false;
51 ShowOverloads = Ovl_All;
52 ExtBehavior = Ext_Ignore;
53
54 ErrorLimit = 0;
55 TemplateBacktraceLimit = 0;
Richard Smith08d6e032011-12-16 19:06:07 +000056 ConstexprBacktraceLimit = 0;
Douglas Gregorcc5888d2010-07-31 00:40:00 +000057
Douglas Gregorabc563f2010-07-19 21:46:24 +000058 Reset();
Reid Spencer5f016e22007-07-11 17:01:13 +000059}
60
David Blaikied6471f72011-09-25 23:23:43 +000061DiagnosticsEngine::~DiagnosticsEngine() {
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +000062 if (OwnsDiagClient)
63 delete Client;
Chris Lattner182745a2007-12-02 01:09:57 +000064}
65
David Blaikie78ad0b92011-09-25 23:39:51 +000066void DiagnosticsEngine::setClient(DiagnosticConsumer *client,
David Blaikied6471f72011-09-25 23:23:43 +000067 bool ShouldOwnClient) {
Douglas Gregor4f5e21e2011-01-31 22:04:05 +000068 if (OwnsDiagClient && Client)
69 delete Client;
70
71 Client = client;
72 OwnsDiagClient = ShouldOwnClient;
73}
Chris Lattner04ae2df2009-07-12 21:18:45 +000074
David Blaikied6471f72011-09-25 23:23:43 +000075void DiagnosticsEngine::pushMappings(SourceLocation Loc) {
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +000076 DiagStateOnPushStack.push_back(GetCurDiagState());
Chris Lattner04ae2df2009-07-12 21:18:45 +000077}
78
David Blaikied6471f72011-09-25 23:23:43 +000079bool DiagnosticsEngine::popMappings(SourceLocation Loc) {
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +000080 if (DiagStateOnPushStack.empty())
Chris Lattner04ae2df2009-07-12 21:18:45 +000081 return false;
82
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +000083 if (DiagStateOnPushStack.back() != GetCurDiagState()) {
84 // State changed at some point between push/pop.
85 PushDiagStatePoint(DiagStateOnPushStack.back(), Loc);
86 }
87 DiagStateOnPushStack.pop_back();
Chris Lattner04ae2df2009-07-12 21:18:45 +000088 return true;
89}
90
David Blaikied6471f72011-09-25 23:23:43 +000091void DiagnosticsEngine::Reset() {
Douglas Gregorabc563f2010-07-19 21:46:24 +000092 ErrorOccurred = false;
93 FatalErrorOccurred = false;
Douglas Gregor85bea972011-07-06 17:40:26 +000094 UnrecoverableErrorOccurred = false;
Douglas Gregorabc563f2010-07-19 21:46:24 +000095
96 NumWarnings = 0;
97 NumErrors = 0;
98 NumErrorsSuppressed = 0;
Argyrios Kyrtzidisc0a575f2011-07-29 01:25:44 +000099 TrapNumErrorsOccurred = 0;
100 TrapNumUnrecoverableErrorsOccurred = 0;
Douglas Gregor85bea972011-07-06 17:40:26 +0000101
Douglas Gregorabc563f2010-07-19 21:46:24 +0000102 CurDiagID = ~0U;
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000103 // Set LastDiagLevel to an "unset" state. If we set it to 'Ignored', notes
David Blaikied6471f72011-09-25 23:23:43 +0000104 // using a DiagnosticsEngine associated to a translation unit that follow
105 // diagnostics from a DiagnosticsEngine associated to anoter t.u. will not be
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000106 // displayed.
107 LastDiagLevel = (DiagnosticIDs::Level)-1;
Douglas Gregorabc563f2010-07-19 21:46:24 +0000108 DelayedDiagID = 0;
Argyrios Kyrtzidisdc0a2da2011-03-26 18:58:17 +0000109
110 // Clear state related to #pragma diagnostic.
111 DiagStates.clear();
112 DiagStatePoints.clear();
113 DiagStateOnPushStack.clear();
114
115 // Create a DiagState and DiagStatePoint representing diagnostic changes
116 // through command-line.
117 DiagStates.push_back(DiagState());
118 PushDiagStatePoint(&DiagStates.back(), SourceLocation());
Douglas Gregorabc563f2010-07-19 21:46:24 +0000119}
Reid Spencer5f016e22007-07-11 17:01:13 +0000120
David Blaikied6471f72011-09-25 23:23:43 +0000121void DiagnosticsEngine::SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000122 StringRef Arg2) {
Douglas Gregor93ea5cb2010-03-22 15:10:57 +0000123 if (DelayedDiagID)
124 return;
125
126 DelayedDiagID = DiagID;
Douglas Gregor9e2dac92010-03-22 15:47:45 +0000127 DelayedDiagArg1 = Arg1.str();
128 DelayedDiagArg2 = Arg2.str();
Douglas Gregor93ea5cb2010-03-22 15:10:57 +0000129}
130
David Blaikied6471f72011-09-25 23:23:43 +0000131void DiagnosticsEngine::ReportDelayed() {
Douglas Gregor93ea5cb2010-03-22 15:10:57 +0000132 Report(DelayedDiagID) << DelayedDiagArg1 << DelayedDiagArg2;
133 DelayedDiagID = 0;
134 DelayedDiagArg1.clear();
135 DelayedDiagArg2.clear();
136}
137
David Blaikied6471f72011-09-25 23:23:43 +0000138DiagnosticsEngine::DiagStatePointsTy::iterator
139DiagnosticsEngine::GetDiagStatePointForLoc(SourceLocation L) const {
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +0000140 assert(!DiagStatePoints.empty());
141 assert(DiagStatePoints.front().Loc.isInvalid() &&
142 "Should have created a DiagStatePoint for command-line");
143
144 FullSourceLoc Loc(L, *SourceMgr);
145 if (Loc.isInvalid())
146 return DiagStatePoints.end() - 1;
147
148 DiagStatePointsTy::iterator Pos = DiagStatePoints.end();
149 FullSourceLoc LastStateChangePos = DiagStatePoints.back().Loc;
150 if (LastStateChangePos.isValid() &&
151 Loc.isBeforeInTranslationUnitThan(LastStateChangePos))
152 Pos = std::upper_bound(DiagStatePoints.begin(), DiagStatePoints.end(),
153 DiagStatePoint(0, Loc));
154 --Pos;
155 return Pos;
156}
157
158/// \brief This allows the client to specify that certain
159/// warnings are ignored. Notes can never be mapped, errors can only be
160/// mapped to fatal, and WARNINGs and EXTENSIONs can be mapped arbitrarily.
161///
162/// \param The source location that this change of diagnostic state should
163/// take affect. It can be null if we are setting the latest state.
David Blaikied6471f72011-09-25 23:23:43 +0000164void DiagnosticsEngine::setDiagnosticMapping(diag::kind Diag, diag::Mapping Map,
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +0000165 SourceLocation L) {
166 assert(Diag < diag::DIAG_UPPER_LIMIT &&
167 "Can only map builtin diagnostics");
168 assert((Diags->isBuiltinWarningOrExtension(Diag) ||
169 (Map == diag::MAP_FATAL || Map == diag::MAP_ERROR)) &&
170 "Cannot map errors into warnings!");
171 assert(!DiagStatePoints.empty());
172
173 FullSourceLoc Loc(L, *SourceMgr);
174 FullSourceLoc LastStateChangePos = DiagStatePoints.back().Loc;
Argyrios Kyrtzidis87429a02011-11-09 01:24:17 +0000175 DiagnosticMappingInfo MappingInfo = makeMappingInfo(Map, L);
Daniel Dunbar53201a82011-10-04 21:17:24 +0000176
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +0000177 // Common case; setting all the diagnostics of a group in one place.
178 if (Loc.isInvalid() || Loc == LastStateChangePos) {
Daniel Dunbar09ea68d2011-09-29 01:34:47 +0000179 GetCurDiagState()->setMappingInfo(Diag, MappingInfo);
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +0000180 return;
181 }
182
183 // Another common case; modifying diagnostic state in a source location
184 // after the previous one.
185 if ((Loc.isValid() && LastStateChangePos.isInvalid()) ||
186 LastStateChangePos.isBeforeInTranslationUnitThan(Loc)) {
Chris Lattnerfc8f0e12011-04-15 05:22:18 +0000187 // A diagnostic pragma occurred, create a new DiagState initialized with
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +0000188 // the current one and a new DiagStatePoint to record at which location
189 // the new state became active.
190 DiagStates.push_back(*GetCurDiagState());
191 PushDiagStatePoint(&DiagStates.back(), Loc);
Daniel Dunbar09ea68d2011-09-29 01:34:47 +0000192 GetCurDiagState()->setMappingInfo(Diag, MappingInfo);
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +0000193 return;
194 }
195
196 // We allow setting the diagnostic state in random source order for
197 // completeness but it should not be actually happening in normal practice.
198
199 DiagStatePointsTy::iterator Pos = GetDiagStatePointForLoc(Loc);
200 assert(Pos != DiagStatePoints.end());
201
202 // Update all diagnostic states that are active after the given location.
203 for (DiagStatePointsTy::iterator
204 I = Pos+1, E = DiagStatePoints.end(); I != E; ++I) {
Daniel Dunbar09ea68d2011-09-29 01:34:47 +0000205 GetCurDiagState()->setMappingInfo(Diag, MappingInfo);
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +0000206 }
207
208 // If the location corresponds to an existing point, just update its state.
209 if (Pos->Loc == Loc) {
Daniel Dunbar09ea68d2011-09-29 01:34:47 +0000210 GetCurDiagState()->setMappingInfo(Diag, MappingInfo);
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +0000211 return;
212 }
213
214 // Create a new state/point and fit it into the vector of DiagStatePoints
215 // so that the vector is always ordered according to location.
216 Pos->Loc.isBeforeInTranslationUnitThan(Loc);
217 DiagStates.push_back(*Pos->State);
218 DiagState *NewState = &DiagStates.back();
Daniel Dunbar09ea68d2011-09-29 01:34:47 +0000219 GetCurDiagState()->setMappingInfo(Diag, MappingInfo);
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +0000220 DiagStatePoints.insert(Pos+1, DiagStatePoint(NewState,
221 FullSourceLoc(Loc, *SourceMgr)));
222}
223
Daniel Dunbar3f839462011-09-29 01:47:16 +0000224bool DiagnosticsEngine::setDiagnosticGroupMapping(
225 StringRef Group, diag::Mapping Map, SourceLocation Loc)
226{
227 // Get the diagnostics in this group.
228 llvm::SmallVector<diag::kind, 8> GroupDiags;
229 if (Diags->getDiagnosticsInGroup(Group, GroupDiags))
230 return true;
231
232 // Set the mapping.
233 for (unsigned i = 0, e = GroupDiags.size(); i != e; ++i)
234 setDiagnosticMapping(GroupDiags[i], Map, Loc);
235
236 return false;
237}
238
Daniel Dunbar4aa8f2b2011-09-29 00:53:47 +0000239bool DiagnosticsEngine::setDiagnosticGroupWarningAsError(StringRef Group,
240 bool Enabled) {
Daniel Dunbara5e41332011-09-29 01:52:06 +0000241 // If we are enabling this feature, just set the diagnostic mappings to map to
242 // errors.
243 if (Enabled)
244 return setDiagnosticGroupMapping(Group, diag::MAP_ERROR);
245
246 // Otherwise, we want to set the diagnostic mapping's "no Werror" bit, and
247 // potentially downgrade anything already mapped to be a warning.
248
249 // Get the diagnostics in this group.
250 llvm::SmallVector<diag::kind, 8> GroupDiags;
251 if (Diags->getDiagnosticsInGroup(Group, GroupDiags))
252 return true;
253
254 // Perform the mapping change.
255 for (unsigned i = 0, e = GroupDiags.size(); i != e; ++i) {
256 DiagnosticMappingInfo &Info = GetCurDiagState()->getOrAddMappingInfo(
257 GroupDiags[i]);
258
Daniel Dunbarbe1aa412011-09-29 01:58:05 +0000259 if (Info.getMapping() == diag::MAP_ERROR ||
260 Info.getMapping() == diag::MAP_FATAL)
261 Info.setMapping(diag::MAP_WARNING);
262
Daniel Dunbara5e41332011-09-29 01:52:06 +0000263 Info.setNoWarningAsError(true);
264 }
265
266 return false;
Daniel Dunbar4aa8f2b2011-09-29 00:53:47 +0000267}
268
269bool DiagnosticsEngine::setDiagnosticGroupErrorAsFatal(StringRef Group,
270 bool Enabled) {
Daniel Dunbara5e41332011-09-29 01:52:06 +0000271 // If we are enabling this feature, just set the diagnostic mappings to map to
272 // fatal errors.
273 if (Enabled)
274 return setDiagnosticGroupMapping(Group, diag::MAP_FATAL);
275
276 // Otherwise, we want to set the diagnostic mapping's "no Werror" bit, and
277 // potentially downgrade anything already mapped to be an error.
278
279 // Get the diagnostics in this group.
280 llvm::SmallVector<diag::kind, 8> GroupDiags;
281 if (Diags->getDiagnosticsInGroup(Group, GroupDiags))
282 return true;
283
284 // Perform the mapping change.
285 for (unsigned i = 0, e = GroupDiags.size(); i != e; ++i) {
286 DiagnosticMappingInfo &Info = GetCurDiagState()->getOrAddMappingInfo(
287 GroupDiags[i]);
288
Daniel Dunbarbe1aa412011-09-29 01:58:05 +0000289 if (Info.getMapping() == diag::MAP_FATAL)
290 Info.setMapping(diag::MAP_ERROR);
291
Daniel Dunbara5e41332011-09-29 01:52:06 +0000292 Info.setNoErrorAsFatal(true);
293 }
294
295 return false;
Daniel Dunbar4aa8f2b2011-09-29 00:53:47 +0000296}
297
David Blaikied6471f72011-09-25 23:23:43 +0000298void DiagnosticsEngine::Report(const StoredDiagnostic &storedDiag) {
Argyrios Kyrtzidise59abb52011-05-05 07:54:59 +0000299 assert(CurDiagID == ~0U && "Multiple diagnostics in flight at once!");
300
301 CurDiagLoc = storedDiag.getLocation();
302 CurDiagID = storedDiag.getID();
303 NumDiagArgs = 0;
304
305 NumDiagRanges = storedDiag.range_size();
306 assert(NumDiagRanges < sizeof(DiagRanges)/sizeof(DiagRanges[0]) &&
307 "Too many arguments to diagnostic!");
308 unsigned i = 0;
309 for (StoredDiagnostic::range_iterator
310 RI = storedDiag.range_begin(),
311 RE = storedDiag.range_end(); RI != RE; ++RI)
312 DiagRanges[i++] = *RI;
313
314 NumFixItHints = storedDiag.fixit_size();
David Blaikied6471f72011-09-25 23:23:43 +0000315 assert(NumFixItHints < DiagnosticsEngine::MaxFixItHints &&
316 "Too many fix-it hints!");
Argyrios Kyrtzidise59abb52011-05-05 07:54:59 +0000317 i = 0;
318 for (StoredDiagnostic::fixit_iterator
319 FI = storedDiag.fixit_begin(),
320 FE = storedDiag.fixit_end(); FI != FE; ++FI)
321 FixItHints[i++] = *FI;
322
David Blaikie78ad0b92011-09-25 23:39:51 +0000323 assert(Client && "DiagnosticConsumer not set!");
Argyrios Kyrtzidise59abb52011-05-05 07:54:59 +0000324 Level DiagLevel = storedDiag.getLevel();
David Blaikie40847cf2011-09-26 01:18:08 +0000325 Diagnostic Info(this, storedDiag.getMessage());
Argyrios Kyrtzidise59abb52011-05-05 07:54:59 +0000326 Client->HandleDiagnostic(DiagLevel, Info);
327 if (Client->IncludeInDiagnosticCounts()) {
David Blaikied6471f72011-09-25 23:23:43 +0000328 if (DiagLevel == DiagnosticsEngine::Warning)
Argyrios Kyrtzidise59abb52011-05-05 07:54:59 +0000329 ++NumWarnings;
330 }
331
332 CurDiagID = ~0U;
333}
334
Douglas Gregorb5350412010-10-13 17:22:14 +0000335void DiagnosticBuilder::FlushCounts() {
336 DiagObj->NumDiagArgs = NumArgs;
337 DiagObj->NumDiagRanges = NumRanges;
338 DiagObj->NumFixItHints = NumFixItHints;
339}
340
Douglas Gregor93ea5cb2010-03-22 15:10:57 +0000341bool DiagnosticBuilder::Emit() {
342 // If DiagObj is null, then its soul was stolen by the copy ctor
343 // or the user called Emit().
344 if (DiagObj == 0) return false;
345
346 // When emitting diagnostics, we set the final argument count into
David Blaikied6471f72011-09-25 23:23:43 +0000347 // the DiagnosticsEngine object.
Douglas Gregorb5350412010-10-13 17:22:14 +0000348 FlushCounts();
Douglas Gregor93ea5cb2010-03-22 15:10:57 +0000349
350 // Process the diagnostic, sending the accumulated information to the
David Blaikie78ad0b92011-09-25 23:39:51 +0000351 // DiagnosticConsumer.
Douglas Gregor93ea5cb2010-03-22 15:10:57 +0000352 bool Emitted = DiagObj->ProcessDiag();
353
354 // Clear out the current diagnostic object.
Douglas Gregor9e2dac92010-03-22 15:47:45 +0000355 unsigned DiagID = DiagObj->CurDiagID;
Douglas Gregor93ea5cb2010-03-22 15:10:57 +0000356 DiagObj->Clear();
357
358 // If there was a delayed diagnostic, emit it now.
Douglas Gregor9e2dac92010-03-22 15:47:45 +0000359 if (DiagObj->DelayedDiagID && DiagObj->DelayedDiagID != DiagID)
Douglas Gregor93ea5cb2010-03-22 15:10:57 +0000360 DiagObj->ReportDelayed();
361
362 // This diagnostic is dead.
363 DiagObj = 0;
364
365 return Emitted;
366}
367
Nico Weber7bfaaae2008-08-10 19:59:06 +0000368
David Blaikie78ad0b92011-09-25 23:39:51 +0000369DiagnosticConsumer::~DiagnosticConsumer() {}
Nico Weber7bfaaae2008-08-10 19:59:06 +0000370
David Blaikie78ad0b92011-09-25 23:39:51 +0000371void DiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
David Blaikie40847cf2011-09-26 01:18:08 +0000372 const Diagnostic &Info) {
Argyrios Kyrtzidisf2224d82010-11-18 20:06:46 +0000373 if (!IncludeInDiagnosticCounts())
374 return;
375
David Blaikied6471f72011-09-25 23:23:43 +0000376 if (DiagLevel == DiagnosticsEngine::Warning)
Argyrios Kyrtzidisf2224d82010-11-18 20:06:46 +0000377 ++NumWarnings;
David Blaikied6471f72011-09-25 23:23:43 +0000378 else if (DiagLevel >= DiagnosticsEngine::Error)
Argyrios Kyrtzidisf2224d82010-11-18 20:06:46 +0000379 ++NumErrors;
380}
Chris Lattnerf4c83962008-11-19 06:51:40 +0000381
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000382/// ModifierIs - Return true if the specified modifier matches specified string.
383template <std::size_t StrLen>
384static bool ModifierIs(const char *Modifier, unsigned ModifierLen,
385 const char (&Str)[StrLen]) {
386 return StrLen-1 == ModifierLen && !memcmp(Modifier, Str, StrLen-1);
387}
388
John McCall909c1822010-01-14 20:11:39 +0000389/// ScanForward - Scans forward, looking for the given character, skipping
390/// nested clauses and escaped characters.
391static const char *ScanFormat(const char *I, const char *E, char Target) {
392 unsigned Depth = 0;
393
394 for ( ; I != E; ++I) {
395 if (Depth == 0 && *I == Target) return I;
396 if (Depth != 0 && *I == '}') Depth--;
397
398 if (*I == '%') {
399 I++;
400 if (I == E) break;
401
402 // Escaped characters get implicitly skipped here.
403
404 // Format specifier.
405 if (!isdigit(*I) && !ispunct(*I)) {
406 for (I++; I != E && !isdigit(*I) && *I != '{'; I++) ;
407 if (I == E) break;
408 if (*I == '{')
409 Depth++;
410 }
411 }
412 }
413 return E;
414}
415
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000416/// HandleSelectModifier - Handle the integer 'select' modifier. This is used
417/// like this: %select{foo|bar|baz}2. This means that the integer argument
418/// "%2" has a value from 0-2. If the value is 0, the diagnostic prints 'foo'.
419/// If the value is 1, it prints 'bar'. If it has the value 2, it prints 'baz'.
420/// This is very useful for certain classes of variant diagnostics.
David Blaikie40847cf2011-09-26 01:18:08 +0000421static void HandleSelectModifier(const Diagnostic &DInfo, unsigned ValNo,
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000422 const char *Argument, unsigned ArgumentLen,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000423 SmallVectorImpl<char> &OutStr) {
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000424 const char *ArgumentEnd = Argument+ArgumentLen;
Mike Stump1eb44332009-09-09 15:08:12 +0000425
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000426 // Skip over 'ValNo' |'s.
427 while (ValNo) {
John McCall909c1822010-01-14 20:11:39 +0000428 const char *NextVal = ScanFormat(Argument, ArgumentEnd, '|');
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000429 assert(NextVal != ArgumentEnd && "Value for integer select modifier was"
430 " larger than the number of options in the diagnostic string!");
431 Argument = NextVal+1; // Skip this string.
432 --ValNo;
433 }
Mike Stump1eb44332009-09-09 15:08:12 +0000434
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000435 // Get the end of the value. This is either the } or the |.
John McCall909c1822010-01-14 20:11:39 +0000436 const char *EndPtr = ScanFormat(Argument, ArgumentEnd, '|');
John McCall9f286142010-01-13 23:58:20 +0000437
438 // Recursively format the result of the select clause into the output string.
439 DInfo.FormatDiagnostic(Argument, EndPtr, OutStr);
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000440}
441
442/// HandleIntegerSModifier - Handle the integer 's' modifier. This adds the
443/// letter 's' to the string if the value is not 1. This is used in cases like
444/// this: "you idiot, you have %4 parameter%s4!".
445static void HandleIntegerSModifier(unsigned ValNo,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000446 SmallVectorImpl<char> &OutStr) {
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000447 if (ValNo != 1)
448 OutStr.push_back('s');
449}
450
John McCall3be16b72010-01-14 00:50:32 +0000451/// HandleOrdinalModifier - Handle the integer 'ord' modifier. This
452/// prints the ordinal form of the given integer, with 1 corresponding
453/// to the first ordinal. Currently this is hard-coded to use the
454/// English form.
455static void HandleOrdinalModifier(unsigned ValNo,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000456 SmallVectorImpl<char> &OutStr) {
John McCall3be16b72010-01-14 00:50:32 +0000457 assert(ValNo != 0 && "ValNo must be strictly positive!");
458
459 llvm::raw_svector_ostream Out(OutStr);
460
461 // We could use text forms for the first N ordinals, but the numeric
462 // forms are actually nicer in diagnostics because they stand out.
463 Out << ValNo;
464
465 // It is critically important that we do this perfectly for
466 // user-written sequences with over 100 elements.
467 switch (ValNo % 100) {
468 case 11:
469 case 12:
470 case 13:
471 Out << "th"; return;
472 default:
473 switch (ValNo % 10) {
474 case 1: Out << "st"; return;
475 case 2: Out << "nd"; return;
476 case 3: Out << "rd"; return;
477 default: Out << "th"; return;
478 }
479 }
480}
481
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000482
Sebastian Redle4c452c2008-11-22 13:44:36 +0000483/// PluralNumber - Parse an unsigned integer and advance Start.
Chris Lattnerd2aa7c92009-04-15 17:13:42 +0000484static unsigned PluralNumber(const char *&Start, const char *End) {
Sebastian Redle4c452c2008-11-22 13:44:36 +0000485 // Programming 101: Parse a decimal number :-)
486 unsigned Val = 0;
487 while (Start != End && *Start >= '0' && *Start <= '9') {
488 Val *= 10;
489 Val += *Start - '0';
490 ++Start;
491 }
492 return Val;
493}
494
495/// TestPluralRange - Test if Val is in the parsed range. Modifies Start.
Chris Lattnerd2aa7c92009-04-15 17:13:42 +0000496static bool TestPluralRange(unsigned Val, const char *&Start, const char *End) {
Sebastian Redle4c452c2008-11-22 13:44:36 +0000497 if (*Start != '[') {
498 unsigned Ref = PluralNumber(Start, End);
499 return Ref == Val;
500 }
501
502 ++Start;
503 unsigned Low = PluralNumber(Start, End);
504 assert(*Start == ',' && "Bad plural expression syntax: expected ,");
505 ++Start;
506 unsigned High = PluralNumber(Start, End);
507 assert(*Start == ']' && "Bad plural expression syntax: expected )");
508 ++Start;
509 return Low <= Val && Val <= High;
510}
511
512/// EvalPluralExpr - Actual expression evaluator for HandlePluralModifier.
Chris Lattnerd2aa7c92009-04-15 17:13:42 +0000513static bool EvalPluralExpr(unsigned ValNo, const char *Start, const char *End) {
Sebastian Redle4c452c2008-11-22 13:44:36 +0000514 // Empty condition?
515 if (*Start == ':')
516 return true;
517
518 while (1) {
519 char C = *Start;
520 if (C == '%') {
521 // Modulo expression
522 ++Start;
523 unsigned Arg = PluralNumber(Start, End);
524 assert(*Start == '=' && "Bad plural expression syntax: expected =");
525 ++Start;
526 unsigned ValMod = ValNo % Arg;
527 if (TestPluralRange(ValMod, Start, End))
528 return true;
529 } else {
Sebastian Redle2065322008-11-27 07:28:14 +0000530 assert((C == '[' || (C >= '0' && C <= '9')) &&
Sebastian Redle4c452c2008-11-22 13:44:36 +0000531 "Bad plural expression syntax: unexpected character");
532 // Range expression
533 if (TestPluralRange(ValNo, Start, End))
534 return true;
535 }
536
537 // Scan for next or-expr part.
538 Start = std::find(Start, End, ',');
Mike Stump1eb44332009-09-09 15:08:12 +0000539 if (Start == End)
Sebastian Redle4c452c2008-11-22 13:44:36 +0000540 break;
541 ++Start;
542 }
543 return false;
544}
545
546/// HandlePluralModifier - Handle the integer 'plural' modifier. This is used
547/// for complex plural forms, or in languages where all plurals are complex.
548/// The syntax is: %plural{cond1:form1|cond2:form2|:form3}, where condn are
549/// conditions that are tested in order, the form corresponding to the first
550/// that applies being emitted. The empty condition is always true, making the
551/// last form a default case.
552/// Conditions are simple boolean expressions, where n is the number argument.
553/// Here are the rules.
554/// condition := expression | empty
555/// empty := -> always true
556/// expression := numeric [',' expression] -> logical or
557/// numeric := range -> true if n in range
558/// | '%' number '=' range -> true if n % number in range
559/// range := number
560/// | '[' number ',' number ']' -> ranges are inclusive both ends
561///
562/// Here are some examples from the GNU gettext manual written in this form:
563/// English:
564/// {1:form0|:form1}
565/// Latvian:
566/// {0:form2|%100=11,%10=0,%10=[2,9]:form1|:form0}
567/// Gaeilge:
568/// {1:form0|2:form1|:form2}
569/// Romanian:
570/// {1:form0|0,%100=[1,19]:form1|:form2}
571/// Lithuanian:
572/// {%10=0,%100=[10,19]:form2|%10=1:form0|:form1}
573/// Russian (requires repeated form):
574/// {%100=[11,14]:form2|%10=1:form0|%10=[2,4]:form1|:form2}
575/// Slovak
576/// {1:form0|[2,4]:form1|:form2}
577/// Polish (requires repeated form):
578/// {1:form0|%100=[10,20]:form2|%10=[2,4]:form1|:form2}
David Blaikie40847cf2011-09-26 01:18:08 +0000579static void HandlePluralModifier(const Diagnostic &DInfo, unsigned ValNo,
Sebastian Redle4c452c2008-11-22 13:44:36 +0000580 const char *Argument, unsigned ArgumentLen,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000581 SmallVectorImpl<char> &OutStr) {
Sebastian Redle4c452c2008-11-22 13:44:36 +0000582 const char *ArgumentEnd = Argument + ArgumentLen;
583 while (1) {
584 assert(Argument < ArgumentEnd && "Plural expression didn't match.");
585 const char *ExprEnd = Argument;
586 while (*ExprEnd != ':') {
587 assert(ExprEnd != ArgumentEnd && "Plural missing expression end");
588 ++ExprEnd;
589 }
590 if (EvalPluralExpr(ValNo, Argument, ExprEnd)) {
591 Argument = ExprEnd + 1;
John McCall909c1822010-01-14 20:11:39 +0000592 ExprEnd = ScanFormat(Argument, ArgumentEnd, '|');
John McCalle53a44b2010-10-14 01:55:31 +0000593
594 // Recursively format the result of the plural clause into the
595 // output string.
596 DInfo.FormatDiagnostic(Argument, ExprEnd, OutStr);
Sebastian Redle4c452c2008-11-22 13:44:36 +0000597 return;
598 }
John McCall909c1822010-01-14 20:11:39 +0000599 Argument = ScanFormat(Argument, ArgumentEnd - 1, '|') + 1;
Sebastian Redle4c452c2008-11-22 13:44:36 +0000600 }
601}
602
603
Chris Lattnerf4c83962008-11-19 06:51:40 +0000604/// FormatDiagnostic - Format this diagnostic into a string, substituting the
605/// formal arguments into the %0 slots. The result is appended onto the Str
606/// array.
David Blaikie40847cf2011-09-26 01:18:08 +0000607void Diagnostic::
Chris Lattner5f9e2722011-07-23 10:55:15 +0000608FormatDiagnostic(SmallVectorImpl<char> &OutStr) const {
Argyrios Kyrtzidise59abb52011-05-05 07:54:59 +0000609 if (!StoredDiagMessage.empty()) {
610 OutStr.append(StoredDiagMessage.begin(), StoredDiagMessage.end());
611 return;
612 }
613
Chris Lattner5f9e2722011-07-23 10:55:15 +0000614 StringRef Diag =
Argyrios Kyrtzidis477aab62011-05-25 05:05:01 +0000615 getDiags()->getDiagnosticIDs()->getDescription(getID());
Mike Stump1eb44332009-09-09 15:08:12 +0000616
Argyrios Kyrtzidis477aab62011-05-25 05:05:01 +0000617 FormatDiagnostic(Diag.begin(), Diag.end(), OutStr);
John McCall9f286142010-01-13 23:58:20 +0000618}
619
David Blaikie40847cf2011-09-26 01:18:08 +0000620void Diagnostic::
John McCall9f286142010-01-13 23:58:20 +0000621FormatDiagnostic(const char *DiagStr, const char *DiagEnd,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000622 SmallVectorImpl<char> &OutStr) const {
John McCall9f286142010-01-13 23:58:20 +0000623
Chris Lattnerb54d8af2009-10-20 05:25:22 +0000624 /// FormattedArgs - Keep track of all of the arguments formatted by
625 /// ConvertArgToString and pass them into subsequent calls to
626 /// ConvertArgToString, allowing the implementation to avoid redundancies in
627 /// obvious cases.
David Blaikied6471f72011-09-25 23:23:43 +0000628 SmallVector<DiagnosticsEngine::ArgumentValue, 8> FormattedArgs;
Chandler Carruth0673cb32011-07-11 17:49:21 +0000629
630 /// QualTypeVals - Pass a vector of arrays so that QualType names can be
631 /// compared to see if more information is needed to be printed.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000632 SmallVector<intptr_t, 2> QualTypeVals;
Chandler Carruth0673cb32011-07-11 17:49:21 +0000633 for (unsigned i = 0, e = getNumArgs(); i < e; ++i)
David Blaikied6471f72011-09-25 23:23:43 +0000634 if (getArgKind(i) == DiagnosticsEngine::ak_qualtype)
Chandler Carruth0673cb32011-07-11 17:49:21 +0000635 QualTypeVals.push_back(getRawArg(i));
636
Chris Lattnerf4c83962008-11-19 06:51:40 +0000637 while (DiagStr != DiagEnd) {
638 if (DiagStr[0] != '%') {
639 // Append non-%0 substrings to Str if we have one.
640 const char *StrEnd = std::find(DiagStr, DiagEnd, '%');
641 OutStr.append(DiagStr, StrEnd);
642 DiagStr = StrEnd;
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000643 continue;
John McCall909c1822010-01-14 20:11:39 +0000644 } else if (ispunct(DiagStr[1])) {
645 OutStr.push_back(DiagStr[1]); // %% -> %.
Chris Lattnerf4c83962008-11-19 06:51:40 +0000646 DiagStr += 2;
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000647 continue;
648 }
Mike Stump1eb44332009-09-09 15:08:12 +0000649
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000650 // Skip the %.
651 ++DiagStr;
Mike Stump1eb44332009-09-09 15:08:12 +0000652
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000653 // This must be a placeholder for a diagnostic argument. The format for a
654 // placeholder is one of "%0", "%modifier0", or "%modifier{arguments}0".
655 // The digit is a number from 0-9 indicating which argument this comes from.
656 // The modifier is a string of digits from the set [-a-z]+, arguments is a
657 // brace enclosed string.
658 const char *Modifier = 0, *Argument = 0;
659 unsigned ModifierLen = 0, ArgumentLen = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000660
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000661 // Check to see if we have a modifier. If so eat it.
662 if (!isdigit(DiagStr[0])) {
663 Modifier = DiagStr;
664 while (DiagStr[0] == '-' ||
665 (DiagStr[0] >= 'a' && DiagStr[0] <= 'z'))
666 ++DiagStr;
667 ModifierLen = DiagStr-Modifier;
Chris Lattnerf4c83962008-11-19 06:51:40 +0000668
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000669 // If we have an argument, get it next.
670 if (DiagStr[0] == '{') {
671 ++DiagStr; // Skip {.
672 Argument = DiagStr;
Mike Stump1eb44332009-09-09 15:08:12 +0000673
John McCall909c1822010-01-14 20:11:39 +0000674 DiagStr = ScanFormat(DiagStr, DiagEnd, '}');
675 assert(DiagStr != DiagEnd && "Mismatched {}'s in diagnostic string!");
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000676 ArgumentLen = DiagStr-Argument;
677 ++DiagStr; // Skip }.
Chris Lattnerf4c83962008-11-19 06:51:40 +0000678 }
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000679 }
Mike Stump1eb44332009-09-09 15:08:12 +0000680
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000681 assert(isdigit(*DiagStr) && "Invalid format for argument in diagnostic");
Chris Lattner22caddc2008-11-23 09:13:29 +0000682 unsigned ArgNo = *DiagStr++ - '0';
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000683
David Blaikied6471f72011-09-25 23:23:43 +0000684 DiagnosticsEngine::ArgumentKind Kind = getArgKind(ArgNo);
Chris Lattnerb54d8af2009-10-20 05:25:22 +0000685
686 switch (Kind) {
Chris Lattner08631c52008-11-23 21:45:46 +0000687 // ---- STRINGS ----
David Blaikied6471f72011-09-25 23:23:43 +0000688 case DiagnosticsEngine::ak_std_string: {
Chris Lattner22caddc2008-11-23 09:13:29 +0000689 const std::string &S = getArgStdStr(ArgNo);
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000690 assert(ModifierLen == 0 && "No modifiers for strings yet");
691 OutStr.append(S.begin(), S.end());
692 break;
693 }
David Blaikied6471f72011-09-25 23:23:43 +0000694 case DiagnosticsEngine::ak_c_string: {
Chris Lattner22caddc2008-11-23 09:13:29 +0000695 const char *S = getArgCStr(ArgNo);
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000696 assert(ModifierLen == 0 && "No modifiers for strings yet");
Daniel Dunbare46e3542009-04-20 06:13:16 +0000697
698 // Don't crash if get passed a null pointer by accident.
699 if (!S)
700 S = "(null)";
Mike Stump1eb44332009-09-09 15:08:12 +0000701
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000702 OutStr.append(S, S + strlen(S));
703 break;
704 }
Chris Lattner08631c52008-11-23 21:45:46 +0000705 // ---- INTEGERS ----
David Blaikied6471f72011-09-25 23:23:43 +0000706 case DiagnosticsEngine::ak_sint: {
Chris Lattner22caddc2008-11-23 09:13:29 +0000707 int Val = getArgSInt(ArgNo);
Mike Stump1eb44332009-09-09 15:08:12 +0000708
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000709 if (ModifierIs(Modifier, ModifierLen, "select")) {
John McCalle53a44b2010-10-14 01:55:31 +0000710 HandleSelectModifier(*this, (unsigned)Val, Argument, ArgumentLen,
711 OutStr);
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000712 } else if (ModifierIs(Modifier, ModifierLen, "s")) {
713 HandleIntegerSModifier(Val, OutStr);
Sebastian Redle4c452c2008-11-22 13:44:36 +0000714 } else if (ModifierIs(Modifier, ModifierLen, "plural")) {
John McCalle53a44b2010-10-14 01:55:31 +0000715 HandlePluralModifier(*this, (unsigned)Val, Argument, ArgumentLen,
716 OutStr);
John McCall3be16b72010-01-14 00:50:32 +0000717 } else if (ModifierIs(Modifier, ModifierLen, "ordinal")) {
718 HandleOrdinalModifier((unsigned)Val, OutStr);
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000719 } else {
720 assert(ModifierLen == 0 && "Unknown integer modifier");
Daniel Dunbar23e47c62009-10-17 18:12:14 +0000721 llvm::raw_svector_ostream(OutStr) << Val;
Chris Lattner30bc9652008-11-19 07:22:31 +0000722 }
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000723 break;
724 }
David Blaikied6471f72011-09-25 23:23:43 +0000725 case DiagnosticsEngine::ak_uint: {
Chris Lattner22caddc2008-11-23 09:13:29 +0000726 unsigned Val = getArgUInt(ArgNo);
Mike Stump1eb44332009-09-09 15:08:12 +0000727
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000728 if (ModifierIs(Modifier, ModifierLen, "select")) {
John McCall9f286142010-01-13 23:58:20 +0000729 HandleSelectModifier(*this, Val, Argument, ArgumentLen, OutStr);
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000730 } else if (ModifierIs(Modifier, ModifierLen, "s")) {
731 HandleIntegerSModifier(Val, OutStr);
Sebastian Redle4c452c2008-11-22 13:44:36 +0000732 } else if (ModifierIs(Modifier, ModifierLen, "plural")) {
John McCalle53a44b2010-10-14 01:55:31 +0000733 HandlePluralModifier(*this, (unsigned)Val, Argument, ArgumentLen,
734 OutStr);
John McCall3be16b72010-01-14 00:50:32 +0000735 } else if (ModifierIs(Modifier, ModifierLen, "ordinal")) {
736 HandleOrdinalModifier(Val, OutStr);
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000737 } else {
738 assert(ModifierLen == 0 && "Unknown integer modifier");
Daniel Dunbar23e47c62009-10-17 18:12:14 +0000739 llvm::raw_svector_ostream(OutStr) << Val;
Chris Lattner30bc9652008-11-19 07:22:31 +0000740 }
Chris Lattner22caddc2008-11-23 09:13:29 +0000741 break;
Chris Lattneraf7ae4e2008-11-21 07:50:02 +0000742 }
Chris Lattner08631c52008-11-23 21:45:46 +0000743 // ---- NAMES and TYPES ----
David Blaikied6471f72011-09-25 23:23:43 +0000744 case DiagnosticsEngine::ak_identifierinfo: {
Chris Lattner08631c52008-11-23 21:45:46 +0000745 const IdentifierInfo *II = getArgIdentifier(ArgNo);
746 assert(ModifierLen == 0 && "No modifiers for strings yet");
Daniel Dunbare46e3542009-04-20 06:13:16 +0000747
748 // Don't crash if get passed a null pointer by accident.
749 if (!II) {
750 const char *S = "(null)";
751 OutStr.append(S, S + strlen(S));
752 continue;
753 }
754
Daniel Dunbar01eb9b92009-10-18 21:17:35 +0000755 llvm::raw_svector_ostream(OutStr) << '\'' << II->getName() << '\'';
Chris Lattner08631c52008-11-23 21:45:46 +0000756 break;
757 }
David Blaikied6471f72011-09-25 23:23:43 +0000758 case DiagnosticsEngine::ak_qualtype:
759 case DiagnosticsEngine::ak_declarationname:
760 case DiagnosticsEngine::ak_nameddecl:
761 case DiagnosticsEngine::ak_nestednamespec:
762 case DiagnosticsEngine::ak_declcontext:
Chris Lattnerb54d8af2009-10-20 05:25:22 +0000763 getDiags()->ConvertArgToString(Kind, getRawArg(ArgNo),
Chris Lattner3fdf4b02008-11-23 09:21:17 +0000764 Modifier, ModifierLen,
Chris Lattnerb54d8af2009-10-20 05:25:22 +0000765 Argument, ArgumentLen,
766 FormattedArgs.data(), FormattedArgs.size(),
Chandler Carruth0673cb32011-07-11 17:49:21 +0000767 OutStr, QualTypeVals);
Chris Lattner22caddc2008-11-23 09:13:29 +0000768 break;
Nico Weber7bfaaae2008-08-10 19:59:06 +0000769 }
Chris Lattnerb54d8af2009-10-20 05:25:22 +0000770
771 // Remember this argument info for subsequent formatting operations. Turn
772 // std::strings into a null terminated string to make it be the same case as
773 // all the other ones.
David Blaikied6471f72011-09-25 23:23:43 +0000774 if (Kind != DiagnosticsEngine::ak_std_string)
Chris Lattnerb54d8af2009-10-20 05:25:22 +0000775 FormattedArgs.push_back(std::make_pair(Kind, getRawArg(ArgNo)));
776 else
David Blaikied6471f72011-09-25 23:23:43 +0000777 FormattedArgs.push_back(std::make_pair(DiagnosticsEngine::ak_c_string,
Chris Lattnerb54d8af2009-10-20 05:25:22 +0000778 (intptr_t)getArgStdStr(ArgNo).c_str()));
779
Nico Weber7bfaaae2008-08-10 19:59:06 +0000780 }
Nico Weber7bfaaae2008-08-10 19:59:06 +0000781}
Ted Kremenekcabe6682009-01-23 20:28:53 +0000782
Douglas Gregora88084b2010-02-18 18:08:43 +0000783StoredDiagnostic::StoredDiagnostic() { }
784
David Blaikied6471f72011-09-25 23:23:43 +0000785StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000786 StringRef Message)
Benjamin Kramera6a32e22010-11-19 17:36:51 +0000787 : ID(ID), Level(Level), Loc(), Message(Message) { }
Douglas Gregora88084b2010-02-18 18:08:43 +0000788
David Blaikied6471f72011-09-25 23:23:43 +0000789StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level,
David Blaikie40847cf2011-09-26 01:18:08 +0000790 const Diagnostic &Info)
Douglas Gregoraa5f1352010-11-19 16:18:16 +0000791 : ID(Info.getID()), Level(Level)
792{
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000793 assert((Info.getLocation().isInvalid() || Info.hasSourceManager()) &&
794 "Valid source location without setting a source manager for diagnostic");
795 if (Info.getLocation().isValid())
796 Loc = FullSourceLoc(Info.getLocation(), Info.getSourceManager());
Douglas Gregora88084b2010-02-18 18:08:43 +0000797 llvm::SmallString<64> Message;
798 Info.FormatDiagnostic(Message);
799 this->Message.assign(Message.begin(), Message.end());
800
801 Ranges.reserve(Info.getNumRanges());
802 for (unsigned I = 0, N = Info.getNumRanges(); I != N; ++I)
803 Ranges.push_back(Info.getRange(I));
804
Douglas Gregor849b2432010-03-31 17:46:05 +0000805 FixIts.reserve(Info.getNumFixItHints());
806 for (unsigned I = 0, N = Info.getNumFixItHints(); I != N; ++I)
807 FixIts.push_back(Info.getFixItHint(I));
Douglas Gregora88084b2010-02-18 18:08:43 +0000808}
809
David Blaikied6471f72011-09-25 23:23:43 +0000810StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000811 StringRef Message, FullSourceLoc Loc,
Chris Lattner2d3ba4f2011-07-23 17:14:25 +0000812 ArrayRef<CharSourceRange> Ranges,
813 ArrayRef<FixItHint> Fixits)
Douglas Gregorf62d43d2011-07-19 16:10:42 +0000814 : ID(ID), Level(Level), Loc(Loc), Message(Message)
815{
816 this->Ranges.assign(Ranges.begin(), Ranges.end());
817 this->FixIts.assign(FixIts.begin(), FixIts.end());
818}
819
Douglas Gregora88084b2010-02-18 18:08:43 +0000820StoredDiagnostic::~StoredDiagnostic() { }
821
Ted Kremenekcabe6682009-01-23 20:28:53 +0000822/// IncludeInDiagnosticCounts - This method (whose default implementation
823/// returns true) indicates whether the diagnostics handled by this
David Blaikie78ad0b92011-09-25 23:39:51 +0000824/// DiagnosticConsumer should be included in the number of diagnostics
David Blaikied6471f72011-09-25 23:23:43 +0000825/// reported by DiagnosticsEngine.
David Blaikie78ad0b92011-09-25 23:39:51 +0000826bool DiagnosticConsumer::IncludeInDiagnosticCounts() const { return true; }
Douglas Gregorfe6b2d42010-03-29 23:34:08 +0000827
David Blaikie99ba9e32011-12-20 02:48:34 +0000828void IgnoringDiagConsumer::anchor() { }
829
Douglas Gregorfe6b2d42010-03-29 23:34:08 +0000830PartialDiagnostic::StorageAllocator::StorageAllocator() {
831 for (unsigned I = 0; I != NumCached; ++I)
832 FreeList[I] = Cached + I;
833 NumFreeListEntries = NumCached;
834}
835
836PartialDiagnostic::StorageAllocator::~StorageAllocator() {
Ted Kremenek03201fb2011-03-21 18:40:07 +0000837 // Don't assert if we are in a CrashRecovery context, as this
838 // invariant may be invalidated during a crash.
Ted Kremenekcd1eecf2011-03-21 18:40:10 +0000839 assert((NumFreeListEntries == NumCached || llvm::CrashRecoveryContext::isRecoveringFromCrash()) && "A partial is on the lamb");
Douglas Gregorfe6b2d42010-03-29 23:34:08 +0000840}