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