PreprocessingRecord.h revision b57a624f22b1efa873e0abac78128b69fba3d486
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 23namespace clang { 24 class IdentifierInfo; 25 class PreprocessingRecord; 26} 27 28/// \brief Allocates memory within a Clang preprocessing record. 29void* operator new(size_t bytes, clang::PreprocessingRecord& PR, 30 unsigned alignment = 8) throw(); 31 32/// \brief Frees memory allocated in a Clang preprocessing record. 33void operator delete(void* ptr, clang::PreprocessingRecord& PR, 34 unsigned) throw(); 35 36namespace 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 unsigned getNumPreallocatedEntities() const { 241 return NumPreallocatedEntities; 242 } 243 244 /// \brief Set the preallocated entry at the given index to the given 245 /// preprocessed entity. 246 void SetPreallocatedEntity(unsigned Index, PreprocessedEntity *Entity); 247 248 /// \brief Register a new macro definition. 249 void RegisterMacroDefinition(MacroInfo *Macro, MacroDefinition *MD); 250 251 /// \brief Retrieve the preprocessed entity at the given index. 252 PreprocessedEntity *getPreprocessedEntity(unsigned Index) { 253 assert(Index < PreprocessedEntities.size() && 254 "Out-of-bounds preprocessed entity"); 255 return PreprocessedEntities[Index]; 256 } 257 258 /// \brief Retrieve the macro definition that corresponds to the given 259 /// \c MacroInfo. 260 MacroDefinition *findMacroDefinition(const MacroInfo *MI); 261 262 virtual void MacroExpands(const Token &Id, const MacroInfo* MI); 263 virtual void MacroDefined(const IdentifierInfo *II, const MacroInfo *MI); 264 virtual void MacroUndefined(SourceLocation Loc, const IdentifierInfo *II, 265 const MacroInfo *MI); 266 }; 267} // end namespace clang 268 269inline void* operator new(size_t bytes, clang::PreprocessingRecord& PR, 270 unsigned alignment) throw() { 271 return PR.Allocate(bytes, alignment); 272} 273 274inline void operator delete(void* ptr, clang::PreprocessingRecord& PR, 275 unsigned) throw() { 276 PR.Deallocate(ptr); 277} 278 279#endif // LLVM_CLANG_LEX_PREPROCESSINGRECORD_H 280