 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
100.0% |
2 / 2 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
100.0% |
2 / 2 |
| |
|
Line Coverage: |
100.0% |
7 / 7 |
| |
 |
|
 |
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 Diagnostic;
34 : class StatSysCallCache;
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 5: inline IdentifierInfo* GetIdentifierInfo(unsigned PersistentID) {
95 : // Check if the IdentifierInfo has already been resolved.
3: branch 0 taken
2: branch 1 taken
96 5: if (IdentifierInfo* II = PerIDCache[PersistentID])
97 3: return II;
98 2: 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 1: const char* getOriginalSourceFile() const {
111 1: 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(const char *NameStart, const char *NameEnd);
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, Diagnostic &Diags);
123 :
124 1: 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 StatSysCallCache 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 : StatSysCallCache *createStatCache();
136 : };
137 :
138 : } // end namespace clang
139 :
140 : #endif
Generated: 2010-02-10 01:31 by zcov