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

   1 //===--- PTHManager.h - Manager object for PTH processing -------*- 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 PTHManager interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_PTHMANAGER_H
  15 #define LLVM_CLANG_PTHMANAGER_H
  16
  17 #include "clang/Lex/PTHLexer.h"
  18 #include "clang/Basic/LangOptions.h"
  19 #include "clang/Basic/IdentifierTable.h"
  20 #include "clang/Basic/Diagnostic.h"
  21 #include "llvm/ADT/DenseMap.h"
  22 #include "llvm/Support/Allocator.h"
  23 #include <string>
  24
  25 namespace llvm {
  26   class MemoryBuffer;
  27 }
  28
  29 namespace clang {
  30
  31 class FileEntry;
  32 class PTHLexer;
  33 class DiagnosticsEngine;
  34 class FileSystemStatCache;
  35
  36 class PTHManager : public IdentifierInfoLookup {
  37   friend class PTHLexer;
  38
  39   /// The memory mapped PTH file.
  40   const llvm::MemoryBuffer* Buf;
  41
  42   /// Alloc - Allocator used for IdentifierInfo objects.
  43   llvm::BumpPtrAllocator Alloc;
  44
  45   /// IdMap - A lazily generated cache mapping from persistent identifiers to
  46   ///  IdentifierInfo*.
  47   IdentifierInfo** PerIDCache;
  48
  49   /// FileLookup - Abstract data structure used for mapping between files
  50   ///  and token data in the PTH file.
  51   void* FileLookup;
  52
  53   /// IdDataTable - Array representing the mapping from persistent IDs to the
  54   ///  data offset within the PTH file containing the information to
  55   ///  reconsitute an IdentifierInfo.
  56   const unsigned char* const IdDataTable;
  57
  58   /// SortedIdTable - Abstract data structure mapping from strings to
  59   ///  persistent IDs.  This is used by get().
  60   void* StringIdLookup;
  61
  62   /// NumIds - The number of identifiers in the PTH file.
  63   const unsigned NumIds;
  64
  65   /// PP - The Preprocessor object that will use this PTHManager to create
  66   ///  PTHLexer objects.
  67   Preprocessor* PP;
  68
  69   /// SpellingBase - The base offset within the PTH memory buffer that
  70   ///  contains the cached spellings for literals.
  71   const unsigned char* const SpellingBase;
  72
  73   /// OriginalSourceFile - A null-terminated C-string that specifies the name
  74   ///  if the file (if any) that was to used to generate the PTH cache.
  75   const char* OriginalSourceFile;
  76
  77   /// This constructor is intended to only be called by the static 'Create'
  78   /// method.
  79   PTHManager(const llvm::MemoryBuffer* buf, void* fileLookup,
  80              const unsigned char* idDataTable, IdentifierInfo** perIDCache,
  81              void* stringIdLookup, unsigned numIds,
  82              const unsigned char* spellingBase, const char *originalSourceFile);
  83
  84   // Do not implement.
  85   PTHManager();
  86   void operator=(const PTHManager&);
  87
  88   /// getSpellingAtPTHOffset - Used by PTHLexer classes to get the cached
  89   ///  spelling for a token.
  90   unsigned getSpellingAtPTHOffset(unsigned PTHOffset, const char*& Buffer);
  91
  92   /// GetIdentifierInfo - Used to reconstruct IdentifierInfo objects from the
  93   ///  PTH file.
  94   inline IdentifierInfo* GetIdentifierInfo(unsigned PersistentID) {
  95     // Check if the IdentifierInfo has already been resolved.
  96     if (IdentifierInfo* II = PerIDCache[PersistentID])
  97       return II;
  98     return LazilyCreateIdentifierInfo(PersistentID);
  99   }
 100   IdentifierInfo* LazilyCreateIdentifierInfo(unsigned PersistentID);
 101
 102 public:
 103   // The current PTH version.
 104   enum { Version = 9 };
 105
 106   ~PTHManager();
 107
 108   /// getOriginalSourceFile - Return the full path to the original header
 109   ///  file name that was used to generate the PTH cache.
 110   const char* getOriginalSourceFile() const {
 111     return OriginalSourceFile;
 112   }
 113
 114   /// get - Return the identifier token info for the specified named identifier.
 115   ///  Unlike the version in IdentifierTable, this returns a pointer instead
 116   ///  of a reference.  If the pointer is NULL then the IdentifierInfo cannot
 117   ///  be found.
 118   IdentifierInfo *get(StringRef Name);
 119
 120   /// Create - This method creates PTHManager objects.  The 'file' argument
 121   ///  is the name of the PTH file.  This method returns NULL upon failure.
 122   static PTHManager *Create(const std::string& file, DiagnosticsEngine &Diags);
 123
 124   void setPreprocessor(Preprocessor *pp) { PP = pp; }
 125
 126   /// CreateLexer - Return a PTHLexer that "lexes" the cached tokens for the
 127   ///  specified file.  This method returns NULL if no cached tokens exist.
 128   ///  It is the responsibility of the caller to 'delete' the returned object.
 129   PTHLexer *CreateLexer(FileID FID);
 130
 131   /// createStatCache - Returns a FileSystemStatCache object for use with
 132   ///  FileManager objects.  These objects use the PTH data to speed up
 133   ///  calls to stat by memoizing their results from when the PTH file
 134   ///  was generated.
 135   FileSystemStatCache *createStatCache();
 136 };
 137
 138 }  // end namespace clang
 139
 140 #endif