contrib/llvm/tools/clang/include/clang/Lex/PreprocessingRecord.h

   1 //===--- PreprocessingRecord.h - Record of Preprocessing --------*- 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 defines the PreprocessingRecord class, which maintains a record
  11 //  of what occurred during preprocessing.
  12 //
  13 //===----------------------------------------------------------------------===//
  14 #ifndef LLVM_CLANG_LEX_PREPROCESSINGRECORD_H
  15 #define LLVM_CLANG_LEX_PREPROCESSINGRECORD_H
  16
  17 #include "clang/Lex/PPCallbacks.h"
  18 #include "clang/Basic/SourceLocation.h"
  19 #include "llvm/ADT/DenseMap.h"
  20 #include "llvm/Support/Allocator.h"
  21 #include <vector>
  22
  23 namespace clang {
  24   class IdentifierInfo;
  25   class PreprocessingRecord;
  26 }
  27
  28 /// \brief Allocates memory within a Clang preprocessing record.
  29 void* operator new(size_t bytes, clang::PreprocessingRecord& PR,
  30                    unsigned alignment = 8) throw();
  31
  32 /// \brief Frees memory allocated in a Clang preprocessing record.
  33 void operator delete(void* ptr, clang::PreprocessingRecord& PR,
  34                      unsigned) throw();
  35
  36 namespace clang {
  37   class MacroDefinition;
  38
  39   /// \brief Base class that describes a preprocessed entity, which may be a
  40   /// preprocessor directive or macro instantiation.
  41   class PreprocessedEntity {
  42   public:
  43     /// \brief The kind of preprocessed entity an object describes.
  44     enum EntityKind {
  45       /// \brief A macro instantiation.
  46       MacroInstantiationKind,
  47
  48       /// \brief A preprocessing directive whose kind is not specified.
  49       ///
  50       /// This kind will be used for any preprocessing directive that does not
  51       /// have a more specific kind within the \c DirectiveKind enumeration.
  52       PreprocessingDirectiveKind,
  53
  54       /// \brief A macro definition.
  55       MacroDefinitionKind,
  56
  57       FirstPreprocessingDirective = PreprocessingDirectiveKind,
  58       LastPreprocessingDirective = MacroDefinitionKind
  59     };
  60
  61   private:
  62     /// \brief The kind of preprocessed entity that this object describes.
  63     EntityKind Kind;
  64
  65     /// \brief The source range that covers this preprocessed entity.
  66     SourceRange Range;
  67
  68   protected:
  69     PreprocessedEntity(EntityKind Kind, SourceRange Range)
  70       : Kind(Kind), Range(Range) { }
  71
  72   public:
  73     /// \brief Retrieve the kind of preprocessed entity stored in this object.
  74     EntityKind getKind() const { return Kind; }
  75
  76     /// \brief Retrieve the source range that covers this entire preprocessed
  77     /// entity.
  78     SourceRange getSourceRange() const { return Range; }
  79
  80     // Implement isa/cast/dyncast/etc.
  81     static bool classof(const PreprocessedEntity *) { return true; }
  82
  83     // Only allow allocation of preprocessed entities using the allocator
  84     // in PreprocessingRecord or by doing a placement new.
  85     void* operator new(size_t bytes, PreprocessingRecord& PR,
  86                        unsigned alignment = 8) throw() {
  87       return ::operator new(bytes, PR, alignment);
  88     }
  89
  90     void* operator new(size_t bytes, void* mem) throw() {
  91       return mem;
  92     }
  93
  94     void operator delete(void* ptr, PreprocessingRecord& PR,
  95                          unsigned alignment) throw() {
  96       return ::operator delete(ptr, PR, alignment);
  97     }
  98
  99     void operator delete(void*, std::size_t) throw() { }
 100     void operator delete(void*, void*) throw() { }
 101
 102   private:
 103     // Make vanilla 'new' and 'delete' illegal for preprocessed entities.
 104     void* operator new(size_t bytes) throw();
 105     void operator delete(void* data) throw();
 106   };
 107
 108   /// \brief Records the location of a macro instantiation.
 109   class MacroInstantiation : public PreprocessedEntity {
 110     /// \brief The name of the macro being instantiation.
 111     IdentifierInfo *Name;
 112
 113     /// \brief The definition of this macro.
 114     MacroDefinition *Definition;
 115
 116   public:
 117     MacroInstantiation(IdentifierInfo *Name, SourceRange Range,
 118                        MacroDefinition *Definition)
 119       : PreprocessedEntity(MacroInstantiationKind, Range), Name(Name),
 120         Definition(Definition) { }
 121
 122     /// \brief The name of the macro being instantiated.
 123     IdentifierInfo *getName() const { return Name; }
 124
 125     /// \brief The definition of the macro being instantiated.
 126     MacroDefinition *getDefinition() const { return Definition; }
 127
 128     // Implement isa/cast/dyncast/etc.
 129     static bool classof(const PreprocessedEntity *PE) {
 130       return PE->getKind() == MacroInstantiationKind;
 131     }
 132     static bool classof(const MacroInstantiation *) { return true; }
 133
 134   };
 135
 136   /// \brief Records the presence of a preprocessor directive.
 137   class PreprocessingDirective : public PreprocessedEntity {
 138   public:
 139     PreprocessingDirective(EntityKind Kind, SourceRange Range)
 140       : PreprocessedEntity(Kind, Range) { }
 141
 142     // Implement isa/cast/dyncast/etc.
 143     static bool classof(const PreprocessedEntity *PD) {
 144       return PD->getKind() >= FirstPreprocessingDirective &&
 145              PD->getKind() <= LastPreprocessingDirective;
 146     }
 147     static bool classof(const PreprocessingDirective *) { return true; }
 148   };
 149
 150   /// \brief Record the location of a macro definition.
 151   class MacroDefinition : public PreprocessingDirective {
 152     /// \brief The name of the macro being defined.
 153     const IdentifierInfo *Name;
 154
 155     /// \brief The location of the macro name in the macro definition.
 156     SourceLocation Location;
 157
 158   public:
 159     explicit MacroDefinition(const IdentifierInfo *Name, SourceLocation Location,
 160                              SourceRange Range)
 161       : PreprocessingDirective(MacroDefinitionKind, Range), Name(Name),
 162         Location(Location) { }
 163
 164     /// \brief Retrieve the name of the macro being defined.
 165     const IdentifierInfo *getName() const { return Name; }
 166
 167     /// \brief Retrieve the location of the macro name in the definition.
 168     SourceLocation getLocation() const { return Location; }
 169
 170     // Implement isa/cast/dyncast/etc.
 171     static bool classof(const PreprocessedEntity *PE) {
 172       return PE->getKind() == MacroDefinitionKind;
 173     }
 174     static bool classof(const MacroDefinition *) { return true; }
 175   };
 176
 177   /// \brief An abstract class that should be subclassed by any external source
 178   /// of preprocessing record entries.
 179   class ExternalPreprocessingRecordSource {
 180   public:
 181     virtual ~ExternalPreprocessingRecordSource();
 182
 183     /// \brief Read any preallocated preprocessed entities from the external
 184     /// source.
 185     virtual void ReadPreprocessedEntities() = 0;
 186   };
 187
 188   /// \brief A record of the steps taken while preprocessing a source file,
 189   /// including the various preprocessing directives processed, macros
 190   /// instantiated, etc.
 191   class PreprocessingRecord : public PPCallbacks {
 192     /// \brief Allocator used to store preprocessing objects.
 193     llvm::BumpPtrAllocator BumpAlloc;
 194
 195     /// \brief The set of preprocessed entities in this record, in order they
 196     /// were seen.
 197     std::vector<PreprocessedEntity *> PreprocessedEntities;
 198
 199     /// \brief Mapping from MacroInfo structures to their definitions.
 200     llvm::DenseMap<const MacroInfo *, MacroDefinition *> MacroDefinitions;
 201
 202     /// \brief External source of preprocessed entities.
 203     ExternalPreprocessingRecordSource *ExternalSource;
 204
 205     /// \brief The number of preallocated entities (that are known to the
 206     /// external source).
 207     unsigned NumPreallocatedEntities;
 208
 209     /// \brief Whether we have already loaded all of the preallocated entities.
 210     mutable bool LoadedPreallocatedEntities;
 211
 212     void MaybeLoadPreallocatedEntities() const ;
 213
 214   public:
 215     PreprocessingRecord();
 216
 217     /// \brief Allocate memory in the preprocessing record.
 218     void *Allocate(unsigned Size, unsigned Align = 8) {
 219       return BumpAlloc.Allocate(Size, Align);
 220     }
 221
 222     /// \brief Deallocate memory in the preprocessing record.
 223     void Deallocate(void *Ptr) { }
 224
 225     // Iteration over the preprocessed entities.
 226     typedef std::vector<PreprocessedEntity *>::iterator iterator;
 227     typedef std::vector<PreprocessedEntity *>::const_iterator const_iterator;
 228     iterator begin(bool OnlyLocalEntities = false);
 229     iterator end(bool OnlyLocalEntities = false);
 230     const_iterator begin(bool OnlyLocalEntities = false) const;
 231     const_iterator end(bool OnlyLocalEntities = false) const;
 232
 233     /// \brief Add a new preprocessed entity to this record.
 234     void addPreprocessedEntity(PreprocessedEntity *Entity);
 235
 236     /// \brief Set the external source for preprocessed entities.
 237     void SetExternalSource(ExternalPreprocessingRecordSource &Source,
 238                            unsigned NumPreallocatedEntities);
 239
 240     /// \brief Set the preallocated entry at the given index to the given
 241     /// preprocessed entity.
 242     void SetPreallocatedEntity(unsigned Index, PreprocessedEntity *Entity);
 243
 244     /// \brief Register a new macro definition.
 245     void RegisterMacroDefinition(MacroInfo *Macro, MacroDefinition *MD);
 246
 247     /// \brief Retrieve the preprocessed entity at the given index.
 248     PreprocessedEntity *getPreprocessedEntity(unsigned Index) {
 249       assert(Index < PreprocessedEntities.size() &&
 250              "Out-of-bounds preprocessed entity");
 251       return PreprocessedEntities[Index];
 252     }
 253
 254     /// \brief Retrieve the macro definition that corresponds to the given
 255     /// \c MacroInfo.
 256     MacroDefinition *findMacroDefinition(const MacroInfo *MI);
 257
 258     virtual void MacroExpands(const Token &Id, const MacroInfo* MI);
 259     virtual void MacroDefined(const IdentifierInfo *II, const MacroInfo *MI);
 260     virtual void MacroUndefined(const IdentifierInfo *II, const MacroInfo *MI);
 261   };
 262 } // end namespace clang
 263
 264 inline void* operator new(size_t bytes, clang::PreprocessingRecord& PR,
 265                           unsigned alignment) throw() {
 266   return PR.Allocate(bytes, alignment);
 267 }
 268
 269 inline void operator delete(void* ptr, clang::PreprocessingRecord& PR,
 270                             unsigned) throw() {
 271   PR.Deallocate(ptr);
 272 }
 273
 274 #endif // LLVM_CLANG_LEX_PREPROCESSINGRECORD_H