| //===--- PreprocessingRecord.h - Record of Preprocessing --------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file defines the PreprocessingRecord class, which maintains a record |
| // of what occurred during preprocessing. |
| // |
| //===----------------------------------------------------------------------===// |
| #ifndef LLVM_CLANG_LEX_PREPROCESSINGRECORD_H |
| #define LLVM_CLANG_LEX_PREPROCESSINGRECORD_H |
| |
| #include "clang/Lex/PPCallbacks.h" |
| #include "clang/Basic/SourceLocation.h" |
| #include "llvm/ADT/DenseMap.h" |
| #include "llvm/Support/Allocator.h" |
| #include <vector> |
| |
| namespace clang { |
| class IdentifierInfo; |
| class PreprocessingRecord; |
| } |
| |
| /// \brief Allocates memory within a Clang preprocessing record. |
| void* operator new(size_t bytes, clang::PreprocessingRecord& PR, |
| unsigned alignment = 8) throw(); |
| |
| /// \brief Frees memory allocated in a Clang preprocessing record. |
| void operator delete(void* ptr, clang::PreprocessingRecord& PR, |
| unsigned) throw(); |
| |
| namespace clang { |
| class MacroDefinition; |
| class FileEntry; |
| |
| /// \brief Base class that describes a preprocessed entity, which may be a |
| /// preprocessor directive or macro expansion. |
| class PreprocessedEntity { |
| public: |
| /// \brief The kind of preprocessed entity an object describes. |
| enum EntityKind { |
| /// \brief A macro expansion. |
| MacroExpansionKind, |
| |
| /// \brief A preprocessing directive whose kind is not specified. |
| /// |
| /// This kind will be used for any preprocessing directive that does not |
| /// have a more specific kind within the \c DirectiveKind enumeration. |
| PreprocessingDirectiveKind, |
| |
| /// \brief A macro definition. |
| MacroDefinitionKind, |
| |
| /// \brief An inclusion directive, such as \c #include, \c |
| /// #import, or \c #include_next. |
| InclusionDirectiveKind, |
| |
| FirstPreprocessingDirective = PreprocessingDirectiveKind, |
| LastPreprocessingDirective = InclusionDirectiveKind |
| }; |
| |
| private: |
| /// \brief The kind of preprocessed entity that this object describes. |
| EntityKind Kind; |
| |
| /// \brief The source range that covers this preprocessed entity. |
| SourceRange Range; |
| |
| protected: |
| PreprocessedEntity(EntityKind Kind, SourceRange Range) |
| : Kind(Kind), Range(Range) { } |
| |
| public: |
| /// \brief Retrieve the kind of preprocessed entity stored in this object. |
| EntityKind getKind() const { return Kind; } |
| |
| /// \brief Retrieve the source range that covers this entire preprocessed |
| /// entity. |
| SourceRange getSourceRange() const { return Range; } |
| |
| // Implement isa/cast/dyncast/etc. |
| static bool classof(const PreprocessedEntity *) { return true; } |
| |
| // Only allow allocation of preprocessed entities using the allocator |
| // in PreprocessingRecord or by doing a placement new. |
| void* operator new(size_t bytes, PreprocessingRecord& PR, |
| unsigned alignment = 8) throw() { |
| return ::operator new(bytes, PR, alignment); |
| } |
| |
| void* operator new(size_t bytes, void* mem) throw() { |
| return mem; |
| } |
| |
| void operator delete(void* ptr, PreprocessingRecord& PR, |
| unsigned alignment) throw() { |
| return ::operator delete(ptr, PR, alignment); |
| } |
| |
| void operator delete(void*, std::size_t) throw() { } |
| void operator delete(void*, void*) throw() { } |
| |
| private: |
| // Make vanilla 'new' and 'delete' illegal for preprocessed entities. |
| void* operator new(size_t bytes) throw(); |
| void operator delete(void* data) throw(); |
| }; |
| |
| /// \brief Records the location of a macro expansion. |
| class MacroExpansion : public PreprocessedEntity { |
| /// \brief The name of the macro being expanded. |
| IdentifierInfo *Name; |
| |
| /// \brief The definition of this macro. |
| MacroDefinition *Definition; |
| |
| public: |
| MacroExpansion(IdentifierInfo *Name, SourceRange Range, |
| MacroDefinition *Definition) |
| : PreprocessedEntity(MacroExpansionKind, Range), Name(Name), |
| Definition(Definition) { } |
| |
| /// \brief The name of the macro being expanded. |
| IdentifierInfo *getName() const { return Name; } |
| |
| /// \brief The definition of the macro being expanded. |
| MacroDefinition *getDefinition() const { return Definition; } |
| |
| // Implement isa/cast/dyncast/etc. |
| static bool classof(const PreprocessedEntity *PE) { |
| return PE->getKind() == MacroExpansionKind; |
| } |
| static bool classof(const MacroExpansion *) { return true; } |
| |
| }; |
| |
| /// \brief Records the presence of a preprocessor directive. |
| class PreprocessingDirective : public PreprocessedEntity { |
| public: |
| PreprocessingDirective(EntityKind Kind, SourceRange Range) |
| : PreprocessedEntity(Kind, Range) { } |
| |
| // Implement isa/cast/dyncast/etc. |
| static bool classof(const PreprocessedEntity *PD) { |
| return PD->getKind() >= FirstPreprocessingDirective && |
| PD->getKind() <= LastPreprocessingDirective; |
| } |
| static bool classof(const PreprocessingDirective *) { return true; } |
| }; |
| |
| /// \brief Record the location of a macro definition. |
| class MacroDefinition : public PreprocessingDirective { |
| /// \brief The name of the macro being defined. |
| const IdentifierInfo *Name; |
| |
| /// \brief The location of the macro name in the macro definition. |
| SourceLocation Location; |
| |
| public: |
| explicit MacroDefinition(const IdentifierInfo *Name, SourceLocation Location, |
| SourceRange Range) |
| : PreprocessingDirective(MacroDefinitionKind, Range), Name(Name), |
| Location(Location) { } |
| |
| /// \brief Retrieve the name of the macro being defined. |
| const IdentifierInfo *getName() const { return Name; } |
| |
| /// \brief Retrieve the location of the macro name in the definition. |
| SourceLocation getLocation() const { return Location; } |
| |
| // Implement isa/cast/dyncast/etc. |
| static bool classof(const PreprocessedEntity *PE) { |
| return PE->getKind() == MacroDefinitionKind; |
| } |
| static bool classof(const MacroDefinition *) { return true; } |
| }; |
| |
| /// \brief Record the location of an inclusion directive, such as an |
| /// \c #include or \c #import statement. |
| class InclusionDirective : public PreprocessingDirective { |
| public: |
| /// \brief The kind of inclusion directives known to the |
| /// preprocessor. |
| enum InclusionKind { |
| /// \brief An \c #include directive. |
| Include, |
| /// \brief An Objective-C \c #import directive. |
| Import, |
| /// \brief A GNU \c #include_next directive. |
| IncludeNext, |
| /// \brief A Clang \c #__include_macros directive. |
| IncludeMacros |
| }; |
| |
| private: |
| /// \brief The name of the file that was included, as written in |
| /// the source. |
| StringRef FileName; |
| |
| /// \brief Whether the file name was in quotation marks; otherwise, it was |
| /// in angle brackets. |
| unsigned InQuotes : 1; |
| |
| /// \brief The kind of inclusion directive we have. |
| /// |
| /// This is a value of type InclusionKind. |
| unsigned Kind : 2; |
| |
| /// \brief The file that was included. |
| const FileEntry *File; |
| |
| public: |
| InclusionDirective(PreprocessingRecord &PPRec, |
| InclusionKind Kind, StringRef FileName, |
| bool InQuotes, const FileEntry *File, SourceRange Range); |
| |
| /// \brief Determine what kind of inclusion directive this is. |
| InclusionKind getKind() const { return static_cast<InclusionKind>(Kind); } |
| |
| /// \brief Retrieve the included file name as it was written in the source. |
| StringRef getFileName() const { return FileName; } |
| |
| /// \brief Determine whether the included file name was written in quotes; |
| /// otherwise, it was written in angle brackets. |
| bool wasInQuotes() const { return InQuotes; } |
| |
| /// \brief Retrieve the file entry for the actual file that was included |
| /// by this directive. |
| const FileEntry *getFile() const { return File; } |
| |
| // Implement isa/cast/dyncast/etc. |
| static bool classof(const PreprocessedEntity *PE) { |
| return PE->getKind() == InclusionDirectiveKind; |
| } |
| static bool classof(const InclusionDirective *) { return true; } |
| }; |
| |
| /// \brief An abstract class that should be subclassed by any external source |
| /// of preprocessing record entries. |
| class ExternalPreprocessingRecordSource { |
| public: |
| virtual ~ExternalPreprocessingRecordSource(); |
| |
| /// \brief Read any preallocated preprocessed entities from the external |
| /// source. |
| virtual void ReadPreprocessedEntities() = 0; |
| |
| /// \brief Read the preprocessed entity at the given offset. |
| virtual PreprocessedEntity * |
| ReadPreprocessedEntityAtOffset(uint64_t Offset) = 0; |
| }; |
| |
| /// \brief A record of the steps taken while preprocessing a source file, |
| /// including the various preprocessing directives processed, macros |
| /// expanded, etc. |
| class PreprocessingRecord : public PPCallbacks { |
| /// \brief Whether we should include nested macro expansions in |
| /// the preprocessing record. |
| bool IncludeNestedMacroExpansions; |
| |
| /// \brief Allocator used to store preprocessing objects. |
| llvm::BumpPtrAllocator BumpAlloc; |
| |
| /// \brief The set of preprocessed entities in this record, in order they |
| /// were seen. |
| std::vector<PreprocessedEntity *> PreprocessedEntities; |
| |
| /// \brief The set of preprocessed entities in this record that have been |
| /// loaded from external sources. |
| /// |
| /// The entries in this vector are loaded lazily from the external source, |
| /// and are referenced by the iterator using negative indices. |
| std::vector<PreprocessedEntity *> LoadedPreprocessedEntities; |
| |
| /// \brief Mapping from MacroInfo structures to their definitions. |
| llvm::DenseMap<const MacroInfo *, MacroDefinition *> MacroDefinitions; |
| |
| /// \brief External source of preprocessed entities. |
| ExternalPreprocessingRecordSource *ExternalSource; |
| |
| /// \brief Whether we have already loaded all of the preallocated entities. |
| mutable bool LoadedPreallocatedEntities; |
| |
| void MaybeLoadPreallocatedEntities() const ; |
| |
| public: |
| /// \brief Construct a new preprocessing record. |
| explicit PreprocessingRecord(bool IncludeNestedMacroExpansions); |
| |
| /// \brief Allocate memory in the preprocessing record. |
| void *Allocate(unsigned Size, unsigned Align = 8) { |
| return BumpAlloc.Allocate(Size, Align); |
| } |
| |
| /// \brief Deallocate memory in the preprocessing record. |
| void Deallocate(void *Ptr) { } |
| |
| size_t getTotalMemory() const; |
| |
| // Iteration over the preprocessed entities. |
| class iterator { |
| PreprocessingRecord *Self; |
| |
| /// \brief Position within the preprocessed entity sequence. |
| /// |
| /// In a complete iteration, the Position field walks the range [-M, N), |
| /// where negative values are used to indicate preprocessed entities |
| /// loaded from the external source while non-negative values are used to |
| /// indicate preprocessed entities introduced by the current preprocessor. |
| /// However, to provide iteration in source order (for, e.g., chained |
| /// precompiled headers), dereferencing the iterator flips the negative |
| /// values (corresponding to loaded entities), so that position -M |
| /// corresponds to element 0 in the loaded entities vector, position -M+1 |
| /// corresponds to element 1 in the loaded entities vector, etc. This |
| /// gives us a reasonably efficient, source-order walk. |
| int Position; |
| |
| public: |
| typedef PreprocessedEntity *value_type; |
| typedef value_type& reference; |
| typedef value_type* pointer; |
| typedef std::random_access_iterator_tag iterator_category; |
| typedef int difference_type; |
| |
| iterator() : Self(0), Position(0) { } |
| |
| iterator(PreprocessingRecord *Self, int Position) |
| : Self(Self), Position(Position) { } |
| |
| reference operator*() const { |
| if (Position < 0) |
| return Self->LoadedPreprocessedEntities.end()[Position]; |
| return Self->PreprocessedEntities[Position]; |
| } |
| |
| pointer operator->() const { |
| if (Position < 0) |
| return &Self->LoadedPreprocessedEntities.end()[Position]; |
| |
| return &Self->PreprocessedEntities[Position]; |
| } |
| |
| reference operator[](difference_type D) { |
| return *(*this + D); |
| } |
| |
| iterator &operator++() { |
| ++Position; |
| return *this; |
| } |
| |
| iterator operator++(int) { |
| iterator Prev(*this); |
| ++Position; |
| return Prev; |
| } |
| |
| iterator &operator--() { |
| --Position; |
| return *this; |
| } |
| |
| iterator operator--(int) { |
| iterator Prev(*this); |
| --Position; |
| return Prev; |
| } |
| |
| friend bool operator==(const iterator &X, const iterator &Y) { |
| return X.Position == Y.Position; |
| } |
| |
| friend bool operator!=(const iterator &X, const iterator &Y) { |
| return X.Position != Y.Position; |
| } |
| |
| friend bool operator<(const iterator &X, const iterator &Y) { |
| return X.Position < Y.Position; |
| } |
| |
| friend bool operator>(const iterator &X, const iterator &Y) { |
| return X.Position > Y.Position; |
| } |
| |
| friend bool operator<=(const iterator &X, const iterator &Y) { |
| return X.Position < Y.Position; |
| } |
| |
| friend bool operator>=(const iterator &X, const iterator &Y) { |
| return X.Position > Y.Position; |
| } |
| |
| friend iterator& operator+=(iterator &X, difference_type D) { |
| X.Position += D; |
| return X; |
| } |
| |
| friend iterator& operator-=(iterator &X, difference_type D) { |
| X.Position -= D; |
| return X; |
| } |
| |
| friend iterator operator+(iterator X, difference_type D) { |
| X.Position += D; |
| return X; |
| } |
| |
| friend iterator operator+(difference_type D, iterator X) { |
| X.Position += D; |
| return X; |
| } |
| |
| friend difference_type operator-(const iterator &X, const iterator &Y) { |
| return X.Position - Y.Position; |
| } |
| |
| friend iterator operator-(iterator X, difference_type D) { |
| X.Position -= D; |
| return X; |
| } |
| }; |
| friend class iterator; |
| |
| iterator begin(bool OnlyLocalEntities = false); |
| iterator end(bool OnlyLocalEntities = false); |
| |
| /// \brief Add a new preprocessed entity to this record. |
| void addPreprocessedEntity(PreprocessedEntity *Entity); |
| |
| /// \brief Set the external source for preprocessed entities. |
| void SetExternalSource(ExternalPreprocessingRecordSource &Source); |
| |
| /// \brief Retrieve the external source for preprocessed entities. |
| ExternalPreprocessingRecordSource *getExternalSource() const { |
| return ExternalSource; |
| } |
| |
| /// \brief Allocate space for a new set of loaded preprocessed entities. |
| /// |
| /// \returns The index into the set of loaded preprocessed entities, which |
| /// corresponds to the first newly-allocated entity. |
| unsigned allocateLoadedEntities(unsigned NumEntities); |
| |
| /// \brief Set the preallocated entry at the given index to the given |
| /// preprocessed entity, which was loaded from the external source. |
| void setLoadedPreallocatedEntity(unsigned Index, |
| PreprocessedEntity *Entity); |
| |
| /// \brief Register a new macro definition. |
| void RegisterMacroDefinition(MacroInfo *Macro, MacroDefinition *MD); |
| |
| /// \brief Retrieve the loaded preprocessed entity at the given index. |
| PreprocessedEntity *getLoadedPreprocessedEntity(unsigned Index) { |
| assert(Index < LoadedPreprocessedEntities.size() && |
| "Out-of bounds loaded preprocessed entity"); |
| return LoadedPreprocessedEntities[Index]; |
| } |
| |
| /// \brief Determine the number of preprocessed entities that were |
| /// loaded (or can be loaded) from an external source. |
| unsigned getNumLoadedPreprocessedEntities() const { |
| return LoadedPreprocessedEntities.size(); |
| } |
| |
| /// \brief Retrieve the macro definition that corresponds to the given |
| /// \c MacroInfo. |
| MacroDefinition *findMacroDefinition(const MacroInfo *MI); |
| |
| virtual void MacroExpands(const Token &Id, const MacroInfo* MI); |
| virtual void MacroDefined(const Token &Id, const MacroInfo *MI); |
| virtual void MacroUndefined(const Token &Id, const MacroInfo *MI); |
| virtual void InclusionDirective(SourceLocation HashLoc, |
| const Token &IncludeTok, |
| StringRef FileName, |
| bool IsAngled, |
| const FileEntry *File, |
| SourceLocation EndLoc, |
| StringRef SearchPath, |
| StringRef RelativePath); |
| }; |
| } // end namespace clang |
| |
| inline void* operator new(size_t bytes, clang::PreprocessingRecord& PR, |
| unsigned alignment) throw() { |
| return PR.Allocate(bytes, alignment); |
| } |
| |
| inline void operator delete(void* ptr, clang::PreprocessingRecord& PR, |
| unsigned) throw() { |
| PR.Deallocate(ptr); |
| } |
| |
| #endif // LLVM_CLANG_LEX_PREPROCESSINGRECORD_H |