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

   1 //===--- DirectoryLookup.h - Info for searching for headers -----*- 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 DirectoryLookup interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_LEX_DIRECTORYLOOKUP_H
  15 #define LLVM_CLANG_LEX_DIRECTORYLOOKUP_H
  16
  17 #include "clang/Basic/SourceManager.h"
  18
  19 namespace llvm {
  20   class StringRef;
  21   template <typename T> class SmallVectorImpl;
  22 }
  23 namespace clang {
  24 class HeaderMap;
  25 class DirectoryEntry;
  26 class FileEntry;
  27 class HeaderSearch;
  28
  29 /// DirectoryLookup - This class represents one entry in the search list that
  30 /// specifies the search order for directories in #include directives.  It
  31 /// represents either a directory, a framework, or a headermap.
  32 ///
  33 class DirectoryLookup {
  34 public:
  35   enum LookupType_t {
  36     LT_NormalDir,
  37     LT_Framework,
  38     LT_HeaderMap
  39   };
  40 private:
  41   union {  // This union is discriminated by isHeaderMap.
  42     /// Dir - This is the actual directory that we're referring to for a normal
  43     /// directory or a framework.
  44     const DirectoryEntry *Dir;
  45
  46     /// Map - This is the HeaderMap if this is a headermap lookup.
  47     ///
  48     const HeaderMap *Map;
  49   } u;
  50
  51   /// DirCharacteristic - The type of directory this is: this is an instance of
  52   /// SrcMgr::CharacteristicKind.
  53   unsigned DirCharacteristic : 2;
  54
  55   /// UserSupplied - True if this is a user-supplied directory.
  56   ///
  57   bool UserSupplied : 1;
  58
  59   /// LookupType - This indicates whether this DirectoryLookup object is a
  60   /// normal directory, a framework, or a headermap.
  61   unsigned LookupType : 2;
  62 public:
  63   /// DirectoryLookup ctor - Note that this ctor *does not take ownership* of
  64   /// 'dir'.
  65   DirectoryLookup(const DirectoryEntry *dir, SrcMgr::CharacteristicKind DT,
  66                   bool isUser, bool isFramework)
  67     : DirCharacteristic(DT), UserSupplied(isUser),
  68      LookupType(isFramework ? LT_Framework : LT_NormalDir) {
  69     u.Dir = dir;
  70   }
  71
  72   /// DirectoryLookup ctor - Note that this ctor *does not take ownership* of
  73   /// 'map'.
  74   DirectoryLookup(const HeaderMap *map, SrcMgr::CharacteristicKind DT,
  75                   bool isUser)
  76     : DirCharacteristic(DT), UserSupplied(isUser), LookupType(LT_HeaderMap) {
  77     u.Map = map;
  78   }
  79
  80   /// getLookupType - Return the kind of directory lookup that this is: either a
  81   /// normal directory, a framework path, or a HeaderMap.
  82   LookupType_t getLookupType() const { return (LookupType_t)LookupType; }
  83
  84   /// getName - Return the directory or filename corresponding to this lookup
  85   /// object.
  86   const char *getName() const;
  87
  88   /// getDir - Return the directory that this entry refers to.
  89   ///
  90   const DirectoryEntry *getDir() const { return isNormalDir() ? u.Dir : 0; }
  91
  92   /// getFrameworkDir - Return the directory that this framework refers to.
  93   ///
  94   const DirectoryEntry *getFrameworkDir() const {
  95     return isFramework() ? u.Dir : 0;
  96   }
  97
  98   /// getHeaderMap - Return the directory that this entry refers to.
  99   ///
 100   const HeaderMap *getHeaderMap() const { return isHeaderMap() ? u.Map : 0; }
 101
 102   /// isNormalDir - Return true if this is a normal directory, not a header map.
 103   bool isNormalDir() const { return getLookupType() == LT_NormalDir; }
 104
 105   /// isFramework - True if this is a framework directory.
 106   ///
 107   bool isFramework() const { return getLookupType() == LT_Framework; }
 108
 109   /// isHeaderMap - Return true if this is a header map, not a normal directory.
 110   bool isHeaderMap() const { return getLookupType() == LT_HeaderMap; }
 111
 112   /// DirCharacteristic - The type of directory this is, one of the DirType enum
 113   /// values.
 114   SrcMgr::CharacteristicKind getDirCharacteristic() const {
 115     return (SrcMgr::CharacteristicKind)DirCharacteristic;
 116   }
 117
 118   /// isUserSupplied - True if this is a user-supplied directory.
 119   ///
 120   bool isUserSupplied() const { return UserSupplied; }
 121
 122
 123   /// LookupFile - Lookup the specified file in this search path, returning it
 124   /// if it exists or returning null if not.
 125   ///
 126   /// \param Filename The file to look up relative to the search paths.
 127   ///
 128   /// \param HS The header search instance to search with.
 129   ///
 130   /// \param SearchPath If not NULL, will be set to the search path relative
 131   /// to which the file was found.
 132   ///
 133   /// \param RelativePath If not NULL, will be set to the path relative to
 134   /// SearchPath at which the file was found. This only differs from the
 135   /// Filename for framework includes.
 136   const FileEntry *LookupFile(llvm::StringRef Filename, HeaderSearch &HS,
 137                               llvm::SmallVectorImpl<char> *SearchPath,
 138                               llvm::SmallVectorImpl<char> *RelativePath) const;
 139
 140 private:
 141   const FileEntry *DoFrameworkLookup(
 142       llvm::StringRef Filename, HeaderSearch &HS,
 143       llvm::SmallVectorImpl<char> *SearchPath,
 144       llvm::SmallVectorImpl<char> *RelativePath) const;
 145
 146 };
 147
 148 }  // end namespace clang
 149
 150 #endif