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