contrib/llvm/tools/clang/include/clang/Basic/PartialDiagnostic.h

   1 //===--- PartialDiagnostic.h - Diagnostic "closures" ------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements a partial diagnostic that can be emitted anwyhere
  11 //  in a DiagnosticBuilder stream.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_PARTIALDIAGNOSTIC_H
  16 #define LLVM_CLANG_PARTIALDIAGNOSTIC_H
  17
  18 #include "clang/Basic/Diagnostic.h"
  19 #include "clang/Basic/SourceLocation.h"
  20 #include "llvm/ADT/STLExtras.h"
  21 #include "llvm/Support/DataTypes.h"
  22 #include <cassert>
  23
  24 namespace clang {
  25
  26 class PartialDiagnostic {
  27 public:
  28   struct Storage {
  29     Storage() : NumDiagArgs(0), NumDiagRanges(0), NumFixItHints(0) { }
  30
  31     enum {
  32         /// MaxArguments - The maximum number of arguments we can hold. We
  33         /// currently only support up to 10 arguments (%0-%9).
  34         /// A single diagnostic with more than that almost certainly has to
  35         /// be simplified anyway.
  36         MaxArguments = DiagnosticsEngine::MaxArguments
  37     };
  38
  39     /// NumDiagArgs - This contains the number of entries in Arguments.
  40     unsigned char NumDiagArgs;
  41
  42     /// NumDiagRanges - This is the number of ranges in the DiagRanges array.
  43     unsigned char NumDiagRanges;
  44
  45     /// \brief The number of code modifications hints in the
  46     /// FixItHints array.
  47     unsigned char NumFixItHints;
  48
  49     /// DiagArgumentsKind - This is an array of ArgumentKind::ArgumentKind enum
  50     /// values, with one for each argument.  This specifies whether the argument
  51     /// is in DiagArgumentsStr or in DiagArguments.
  52     unsigned char DiagArgumentsKind[MaxArguments];
  53
  54     /// DiagArgumentsVal - The values for the various substitution positions.
  55     /// This is used when the argument is not an std::string. The specific value
  56     /// is mangled into an intptr_t and the interpretation depends on exactly
  57     /// what sort of argument kind it is.
  58     intptr_t DiagArgumentsVal[MaxArguments];
  59
  60     /// \brief The values for the various substitution positions that have
  61     /// string arguments.
  62     std::string DiagArgumentsStr[MaxArguments];
  63
  64     /// DiagRanges - The list of ranges added to this diagnostic.  It currently
  65     /// only support 10 ranges, could easily be extended if needed.
  66     CharSourceRange DiagRanges[10];
  67
  68     enum { MaxFixItHints = DiagnosticsEngine::MaxFixItHints };
  69
  70     /// FixItHints - If valid, provides a hint with some code
  71     /// to insert, remove, or modify at a particular position.
  72     FixItHint FixItHints[MaxFixItHints];
  73   };
  74
  75   /// \brief An allocator for Storage objects, which uses a small cache to
  76   /// objects, used to reduce malloc()/free() traffic for partial diagnostics.
  77   class StorageAllocator {
  78     static const unsigned NumCached = 16;
  79     Storage Cached[NumCached];
  80     Storage *FreeList[NumCached];
  81     unsigned NumFreeListEntries;
  82
  83   public:
  84     StorageAllocator();
  85     ~StorageAllocator();
  86
  87     /// \brief Allocate new storage.
  88     Storage *Allocate() {
  89       if (NumFreeListEntries == 0)
  90         return new Storage;
  91
  92       Storage *Result = FreeList[--NumFreeListEntries];
  93       Result->NumDiagArgs = 0;
  94       Result->NumDiagRanges = 0;
  95       Result->NumFixItHints = 0;
  96       return Result;
  97     }
  98
  99     /// \brief Free the given storage object.
 100     void Deallocate(Storage *S) {
 101       if (S >= Cached && S <= Cached + NumCached) {
 102         FreeList[NumFreeListEntries++] = S;
 103         return;
 104       }
 105
 106       delete S;
 107     }
 108   };
 109
 110 private:
 111   // NOTE: Sema assumes that PartialDiagnostic is location-invariant
 112   // in the sense that its bits can be safely memcpy'ed and destructed
 113   // in the new location.
 114
 115   /// DiagID - The diagnostic ID.
 116   mutable unsigned DiagID;
 117
 118   /// DiagStorage - Storage for args and ranges.
 119   mutable Storage *DiagStorage;
 120
 121   /// \brief Allocator used to allocate storage for this diagnostic.
 122   StorageAllocator *Allocator;
 123
 124   /// \brief Retrieve storage for this particular diagnostic.
 125   Storage *getStorage() const {
 126     if (DiagStorage)
 127       return DiagStorage;
 128
 129     if (Allocator)
 130       DiagStorage = Allocator->Allocate();
 131     else {
 132       assert(Allocator != reinterpret_cast<StorageAllocator *>(~uintptr_t(0)));
 133       DiagStorage = new Storage;
 134     }
 135     return DiagStorage;
 136   }
 137
 138   void freeStorage() {
 139     if (!DiagStorage)
 140       return;
 141
 142     if (Allocator)
 143       Allocator->Deallocate(DiagStorage);
 144     else if (Allocator != reinterpret_cast<StorageAllocator *>(~uintptr_t(0)))
 145       delete DiagStorage;
 146     DiagStorage = 0;
 147   }
 148
 149   void AddSourceRange(const CharSourceRange &R) const {
 150     if (!DiagStorage)
 151       DiagStorage = getStorage();
 152
 153     assert(DiagStorage->NumDiagRanges <
 154            llvm::array_lengthof(DiagStorage->DiagRanges) &&
 155            "Too many arguments to diagnostic!");
 156     DiagStorage->DiagRanges[DiagStorage->NumDiagRanges++] = R;
 157   }
 158
 159   void AddFixItHint(const FixItHint &Hint) const {
 160     if (Hint.isNull())
 161       return;
 162
 163     if (!DiagStorage)
 164       DiagStorage = getStorage();
 165
 166     assert(DiagStorage->NumFixItHints < Storage::MaxFixItHints &&
 167            "Too many code modification hints!");
 168     if (DiagStorage->NumFixItHints >= Storage::MaxFixItHints)
 169       return;  // Don't crash in release builds
 170     DiagStorage->FixItHints[DiagStorage->NumFixItHints++]
 171       = Hint;
 172   }
 173
 174 public:
 175   PartialDiagnostic(unsigned DiagID, StorageAllocator &Allocator)
 176     : DiagID(DiagID), DiagStorage(0), Allocator(&Allocator) { }
 177
 178   PartialDiagnostic(const PartialDiagnostic &Other)
 179     : DiagID(Other.DiagID), DiagStorage(0), Allocator(Other.Allocator)
 180   {
 181     if (Other.DiagStorage) {
 182       DiagStorage = getStorage();
 183       *DiagStorage = *Other.DiagStorage;
 184     }
 185   }
 186
 187   PartialDiagnostic(const PartialDiagnostic &Other, Storage *DiagStorage)
 188     : DiagID(Other.DiagID), DiagStorage(DiagStorage),
 189       Allocator(reinterpret_cast<StorageAllocator *>(~uintptr_t(0)))
 190   {
 191     if (Other.DiagStorage)
 192       *this->DiagStorage = *Other.DiagStorage;
 193   }
 194
 195   PartialDiagnostic(const Diagnostic &Other, StorageAllocator &Allocator)
 196     : DiagID(Other.getID()), DiagStorage(0), Allocator(&Allocator)
 197   {
 198     // Copy arguments.
 199     for (unsigned I = 0, N = Other.getNumArgs(); I != N; ++I) {
 200       if (Other.getArgKind(I) == DiagnosticsEngine::ak_std_string)
 201         AddString(Other.getArgStdStr(I));
 202       else
 203         AddTaggedVal(Other.getRawArg(I), Other.getArgKind(I));
 204     }
 205
 206     // Copy source ranges.
 207     for (unsigned I = 0, N = Other.getNumRanges(); I != N; ++I)
 208       AddSourceRange(Other.getRange(I));
 209
 210     // Copy fix-its.
 211     for (unsigned I = 0, N = Other.getNumFixItHints(); I != N; ++I)
 212       AddFixItHint(Other.getFixItHint(I));
 213   }
 214
 215   PartialDiagnostic &operator=(const PartialDiagnostic &Other) {
 216     DiagID = Other.DiagID;
 217     if (Other.DiagStorage) {
 218       if (!DiagStorage)
 219         DiagStorage = getStorage();
 220
 221       *DiagStorage = *Other.DiagStorage;
 222     } else {
 223       freeStorage();
 224     }
 225
 226     return *this;
 227   }
 228
 229   ~PartialDiagnostic() {
 230     freeStorage();
 231   }
 232
 233   unsigned getDiagID() const { return DiagID; }
 234
 235   void AddTaggedVal(intptr_t V, DiagnosticsEngine::ArgumentKind Kind) const {
 236     if (!DiagStorage)
 237       DiagStorage = getStorage();
 238
 239     assert(DiagStorage->NumDiagArgs < Storage::MaxArguments &&
 240            "Too many arguments to diagnostic!");
 241     DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs] = Kind;
 242     DiagStorage->DiagArgumentsVal[DiagStorage->NumDiagArgs++] = V;
 243   }
 244
 245   void AddString(StringRef V) const {
 246     if (!DiagStorage)
 247       DiagStorage = getStorage();
 248
 249     assert(DiagStorage->NumDiagArgs < Storage::MaxArguments &&
 250            "Too many arguments to diagnostic!");
 251     DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs]
 252       = DiagnosticsEngine::ak_std_string;
 253     DiagStorage->DiagArgumentsStr[DiagStorage->NumDiagArgs++] = V;
 254   }
 255
 256   void Emit(const DiagnosticBuilder &DB) const {
 257     if (!DiagStorage)
 258       return;
 259
 260     // Add all arguments.
 261     for (unsigned i = 0, e = DiagStorage->NumDiagArgs; i != e; ++i) {
 262       if ((DiagnosticsEngine::ArgumentKind)DiagStorage->DiagArgumentsKind[i]
 263             == DiagnosticsEngine::ak_std_string)
 264         DB.AddString(DiagStorage->DiagArgumentsStr[i]);
 265       else
 266         DB.AddTaggedVal(DiagStorage->DiagArgumentsVal[i],
 267             (DiagnosticsEngine::ArgumentKind)DiagStorage->DiagArgumentsKind[i]);
 268     }
 269
 270     // Add all ranges.
 271     for (unsigned i = 0, e = DiagStorage->NumDiagRanges; i != e; ++i)
 272       DB.AddSourceRange(DiagStorage->DiagRanges[i]);
 273
 274     // Add all fix-its.
 275     for (unsigned i = 0, e = DiagStorage->NumFixItHints; i != e; ++i)
 276       DB.AddFixItHint(DiagStorage->FixItHints[i]);
 277   }
 278
 279   /// \brief Clear out this partial diagnostic, giving it a new diagnostic ID
 280   /// and removing all of its arguments, ranges, and fix-it hints.
 281   void Reset(unsigned DiagID = 0) {
 282     this->DiagID = DiagID;
 283     freeStorage();
 284   }
 285
 286   bool hasStorage() const { return DiagStorage != 0; }
 287
 288   friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 289                                              unsigned I) {
 290     PD.AddTaggedVal(I, DiagnosticsEngine::ak_uint);
 291     return PD;
 292   }
 293
 294   friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 295                                              int I) {
 296     PD.AddTaggedVal(I, DiagnosticsEngine::ak_sint);
 297     return PD;
 298   }
 299
 300   friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 301                                                     const char *S) {
 302     PD.AddTaggedVal(reinterpret_cast<intptr_t>(S),
 303                     DiagnosticsEngine::ak_c_string);
 304     return PD;
 305   }
 306
 307   friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 308                                                     StringRef S) {
 309
 310     PD.AddString(S);
 311     return PD;
 312   }
 313
 314   friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 315                                                     const SourceRange &R) {
 316     PD.AddSourceRange(CharSourceRange::getTokenRange(R));
 317     return PD;
 318   }
 319
 320   friend inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 321                                                     const CharSourceRange &R) {
 322     PD.AddSourceRange(R);
 323     return PD;
 324   }
 325
 326   friend const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
 327                                              const FixItHint &Hint) {
 328     PD.AddFixItHint(Hint);
 329     return PD;
 330   }
 331
 332 };
 333
 334 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
 335                                            const PartialDiagnostic &PD) {
 336   PD.Emit(DB);
 337   return DB;
 338 }
 339
 340 /// \brief A partial diagnostic along with the source location where this
 341 /// diagnostic occurs.
 342 typedef std::pair<SourceLocation, PartialDiagnostic> PartialDiagnosticAt;
 343
 344 }  // end namespace clang
 345 #endif