309 lines
12 KiB
C++
309 lines
12 KiB
C++
//===--- HeaderSearch.cpp - Resolve Header File Locations ---===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file was developed by Chris Lattner and is distributed under
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the DirectoryLookup and HeaderSearch interfaces.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Basic/FileManager.h"
|
|
#include "clang/Lex/HeaderSearch.h"
|
|
#include "clang/Lex/IdentifierTable.h"
|
|
#include "llvm/System/Path.h"
|
|
#include "llvm/ADT/SmallString.h"
|
|
#include <iostream>
|
|
using namespace llvm;
|
|
using namespace clang;
|
|
|
|
HeaderSearch::HeaderSearch(FileManager &FM) : FileMgr(FM) {
|
|
SystemDirIdx = 0;
|
|
NoCurDirSearch = false;
|
|
|
|
NumIncluded = 0;
|
|
NumMultiIncludeFileOptzn = 0;
|
|
NumFrameworkLookups = NumSubFrameworkLookups = 0;
|
|
}
|
|
|
|
void HeaderSearch::PrintStats() {
|
|
std::cerr << "\n*** HeaderSearch Stats:\n";
|
|
std::cerr << FileInfo.size() << " files tracked.\n";
|
|
unsigned NumOnceOnlyFiles = 0, MaxNumIncludes = 0, NumSingleIncludedFiles = 0;
|
|
for (unsigned i = 0, e = FileInfo.size(); i != e; ++i) {
|
|
NumOnceOnlyFiles += FileInfo[i].isImport;
|
|
if (MaxNumIncludes < FileInfo[i].NumIncludes)
|
|
MaxNumIncludes = FileInfo[i].NumIncludes;
|
|
NumSingleIncludedFiles += FileInfo[i].NumIncludes == 1;
|
|
}
|
|
std::cerr << " " << NumOnceOnlyFiles << " #import/#pragma once files.\n";
|
|
std::cerr << " " << NumSingleIncludedFiles << " included exactly once.\n";
|
|
std::cerr << " " << MaxNumIncludes << " max times a file is included.\n";
|
|
|
|
std::cerr << " " << NumIncluded << " #include/#include_next/#import.\n";
|
|
std::cerr << " " << NumMultiIncludeFileOptzn << " #includes skipped due to"
|
|
<< " the multi-include optimization.\n";
|
|
|
|
std::cerr << NumFrameworkLookups << " framework lookups.\n";
|
|
std::cerr << NumSubFrameworkLookups << " subframework lookups.\n";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Header File Location.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
const FileEntry *HeaderSearch::DoFrameworkLookup(const DirectoryEntry *Dir,
|
|
const std::string &Filename) {
|
|
// Framework names must have a '/' in the filename.
|
|
std::string::size_type SlashPos = Filename.find('/');
|
|
if (SlashPos == std::string::npos) return 0;
|
|
|
|
const DirectoryEntry *&CacheLookup =
|
|
FrameworkMap[std::string(Filename.begin(), Filename.begin()+SlashPos)];
|
|
|
|
// If it is some other directory, fail.
|
|
if (CacheLookup && CacheLookup != Dir)
|
|
return 0;
|
|
|
|
// FrameworkName = "/System/Library/Frameworks/"
|
|
std::string FrameworkName = Dir->getName();
|
|
if (FrameworkName.empty() || FrameworkName[FrameworkName.size()-1] != '/')
|
|
FrameworkName += '/';
|
|
|
|
// FrameworkName = "/System/Library/Frameworks/Cocoa"
|
|
FrameworkName += std::string(Filename.begin(), Filename.begin()+SlashPos);
|
|
|
|
// FrameworkName = "/System/Library/Frameworks/Cocoa.framework/"
|
|
FrameworkName += ".framework/";
|
|
|
|
if (CacheLookup == 0) {
|
|
++NumFrameworkLookups;
|
|
|
|
// If the framework dir doesn't exist, we fail.
|
|
if (!sys::Path(FrameworkName).exists())
|
|
return 0;
|
|
|
|
// Otherwise, if it does, remember that this is the right direntry for this
|
|
// framework.
|
|
CacheLookup = Dir;
|
|
}
|
|
|
|
// Check "/System/Library/Frameworks/Cocoa.framework/Headers/file.h"
|
|
std::string HeadersFilename = FrameworkName + "Headers/" +
|
|
std::string(Filename.begin()+SlashPos+1, Filename.end());
|
|
if (const FileEntry *FE = FileMgr.getFile(HeadersFilename))
|
|
return FE;
|
|
|
|
// Check "/System/Library/Frameworks/Cocoa.framework/PrivateHeaders/file.h"
|
|
std::string PrivateHeadersFilename = FrameworkName + "PrivateHeaders/" +
|
|
std::string(Filename.begin()+SlashPos+1, Filename.end());
|
|
return FileMgr.getFile(PrivateHeadersFilename);
|
|
}
|
|
|
|
/// LookupFile - Given a "foo" or <foo> reference, look up the indicated file,
|
|
/// return null on failure. isAngled indicates whether the file reference is
|
|
/// for system #include's or not (i.e. using <> instead of ""). CurFileEnt, if
|
|
/// non-null, indicates where the #including file is, in case a relative search
|
|
/// is needed.
|
|
const FileEntry *HeaderSearch::LookupFile(const std::string &Filename,
|
|
bool isAngled,
|
|
const DirectoryLookup *FromDir,
|
|
const DirectoryLookup *&CurDir,
|
|
const FileEntry *CurFileEnt) {
|
|
// If 'Filename' is absolute, check to see if it exists and no searching.
|
|
// FIXME: Portability. This should be a sys::Path interface, this doesn't
|
|
// handle things like C:\foo.txt right, nor win32 \\network\device\blah.
|
|
if (Filename[0] == '/') {
|
|
CurDir = 0;
|
|
|
|
// If this was an #include_next "/absolute/file", fail.
|
|
if (FromDir) return 0;
|
|
|
|
// Otherwise, just return the file.
|
|
return FileMgr.getFile(Filename);
|
|
}
|
|
|
|
SmallString<1024> TmpDir;
|
|
|
|
// Step #0, unless disabled, check to see if the file is in the #includer's
|
|
// directory. This search is not done for <> headers.
|
|
if (CurFileEnt && !isAngled && !NoCurDirSearch) {
|
|
// Concatenate the requested file onto the directory.
|
|
// FIXME: Portability. Filename concatenation should be in sys::Path.
|
|
TmpDir += CurFileEnt->getDir()->getName();
|
|
TmpDir.push_back('/');
|
|
TmpDir.append(Filename.begin(), Filename.end());
|
|
if (const FileEntry *FE = FileMgr.getFile(TmpDir.begin(), TmpDir.end())) {
|
|
// Leave CurDir unset.
|
|
|
|
// This file is a system header or C++ unfriendly if the old file is.
|
|
getFileInfo(FE).DirInfo = getFileInfo(CurFileEnt).DirInfo;
|
|
return FE;
|
|
}
|
|
TmpDir.clear();
|
|
}
|
|
|
|
CurDir = 0;
|
|
|
|
// If this is a system #include, ignore the user #include locs.
|
|
unsigned i = isAngled ? SystemDirIdx : 0;
|
|
|
|
// If this is a #include_next request, start searching after the directory the
|
|
// file was found in.
|
|
if (FromDir)
|
|
i = FromDir-&SearchDirs[0];
|
|
|
|
// Check each directory in sequence to see if it contains this file.
|
|
for (; i != SearchDirs.size(); ++i) {
|
|
const FileEntry *FE = 0;
|
|
if (!SearchDirs[i].isFramework()) {
|
|
// FIXME: Portability. Adding file to dir should be in sys::Path.
|
|
// Concatenate the requested file onto the directory.
|
|
TmpDir.clear();
|
|
TmpDir += SearchDirs[i].getDir()->getName();
|
|
TmpDir.push_back('/');
|
|
TmpDir.append(Filename.begin(), Filename.end());
|
|
FE = FileMgr.getFile(TmpDir.begin(), TmpDir.end());
|
|
} else {
|
|
FE = DoFrameworkLookup(SearchDirs[i].getDir(), Filename);
|
|
}
|
|
|
|
if (FE) {
|
|
CurDir = &SearchDirs[i];
|
|
|
|
// This file is a system header or C++ unfriendly if the dir is.
|
|
getFileInfo(FE).DirInfo = CurDir->getDirCharacteristic();
|
|
return FE;
|
|
}
|
|
}
|
|
|
|
// Otherwise, didn't find it.
|
|
return 0;
|
|
}
|
|
|
|
/// LookupSubframeworkHeader - Look up a subframework for the specified
|
|
/// #include file. For example, if #include'ing <HIToolbox/HIToolbox.h> from
|
|
/// within ".../Carbon.framework/Headers/Carbon.h", check to see if HIToolbox
|
|
/// is a subframework within Carbon.framework. If so, return the FileEntry
|
|
/// for the designated file, otherwise return null.
|
|
const FileEntry *HeaderSearch::
|
|
LookupSubframeworkHeader(const std::string &Filename,
|
|
const FileEntry *ContextFileEnt) {
|
|
// Framework names must have a '/' in the filename. Find it.
|
|
std::string::size_type SlashPos = Filename.find('/');
|
|
if (SlashPos == std::string::npos) return 0;
|
|
|
|
// Look up the base framework name of the ContextFileEnt.
|
|
const char *ContextName = ContextFileEnt->getName();
|
|
|
|
// If the context info wasn't a framework, couldn't be a subframework.
|
|
const char *FrameworkPos = strstr(ContextName, ".framework/");
|
|
if (FrameworkPos == 0)
|
|
return 0;
|
|
|
|
SmallString<1024> FrameworkName(ContextName,
|
|
FrameworkPos+strlen(".framework/"));
|
|
|
|
// Append Frameworks/HIToolbox.framework/
|
|
FrameworkName += "Frameworks/";
|
|
FrameworkName.append(Filename.begin(), Filename.begin()+SlashPos);
|
|
FrameworkName += ".framework/";
|
|
|
|
const DirectoryEntry *&CacheLookup =
|
|
FrameworkMap[std::string(Filename.begin(), Filename.begin()+SlashPos)];
|
|
|
|
// Some other location?
|
|
if (CacheLookup && strcmp(CacheLookup->getName(), FrameworkName.c_str()) != 0)
|
|
return 0;
|
|
|
|
// Cache subframework.
|
|
if (CacheLookup == 0) {
|
|
++NumSubFrameworkLookups;
|
|
|
|
// If the framework dir doesn't exist, we fail.
|
|
const DirectoryEntry *Dir = FileMgr.getDirectory(FrameworkName.begin(),
|
|
FrameworkName.end());
|
|
if (Dir == 0) return 0;
|
|
|
|
// Otherwise, if it does, remember that this is the right direntry for this
|
|
// framework.
|
|
CacheLookup = Dir;
|
|
}
|
|
|
|
const FileEntry *FE = 0;
|
|
|
|
// Check ".../Frameworks/HIToolbox.framework/Headers/HIToolbox.h"
|
|
SmallString<1024> HeadersFilename(FrameworkName);
|
|
HeadersFilename += "Headers/";
|
|
HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
|
|
if (!(FE = FileMgr.getFile(HeadersFilename.begin(),
|
|
HeadersFilename.end()))) {
|
|
|
|
// Check ".../Frameworks/HIToolbox.framework/PrivateHeaders/HIToolbox.h"
|
|
HeadersFilename = FrameworkName;
|
|
HeadersFilename += "PrivateHeaders/";
|
|
HeadersFilename.append(Filename.begin()+SlashPos+1, Filename.end());
|
|
if (!(FE = FileMgr.getFile(HeadersFilename.begin(), HeadersFilename.end())))
|
|
return 0;
|
|
}
|
|
|
|
// This file is a system header or C++ unfriendly if the old file is.
|
|
getFileInfo(FE).DirInfo = getFileInfo(ContextFileEnt).DirInfo;
|
|
return FE;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// File Info Management.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
/// getFileInfo - Return the PerFileInfo structure for the specified
|
|
/// FileEntry.
|
|
HeaderSearch::PerFileInfo &HeaderSearch::getFileInfo(const FileEntry *FE) {
|
|
if (FE->getUID() >= FileInfo.size())
|
|
FileInfo.resize(FE->getUID()+1);
|
|
return FileInfo[FE->getUID()];
|
|
}
|
|
|
|
/// ShouldEnterIncludeFile - Mark the specified file as a target of of a
|
|
/// #include, #include_next, or #import directive. Return false if #including
|
|
/// the file will have no effect or true if we should include it.
|
|
bool HeaderSearch::ShouldEnterIncludeFile(const FileEntry *File, bool isImport){
|
|
++NumIncluded; // Count # of attempted #includes.
|
|
|
|
// Get information about this file.
|
|
PerFileInfo &FileInfo = getFileInfo(File);
|
|
|
|
// If this is a #import directive, check that we have not already imported
|
|
// this header.
|
|
if (isImport) {
|
|
// If this has already been imported, don't import it again.
|
|
FileInfo.isImport = true;
|
|
|
|
// Has this already been #import'ed or #include'd?
|
|
if (FileInfo.NumIncludes) return false;
|
|
} else {
|
|
// Otherwise, if this is a #include of a file that was previously #import'd
|
|
// or if this is the second #include of a #pragma once file, ignore it.
|
|
if (FileInfo.isImport)
|
|
return false;
|
|
}
|
|
|
|
// Next, check to see if the file is wrapped with #ifndef guards. If so, and
|
|
// if the macro that guards it is defined, we know the #include has no effect.
|
|
if (FileInfo.ControllingMacro && FileInfo.ControllingMacro->getMacroInfo()) {
|
|
++NumMultiIncludeFileOptzn;
|
|
return false;
|
|
}
|
|
|
|
// Increment the number of times this file has been included.
|
|
++FileInfo.NumIncludes;
|
|
|
|
return true;
|
|
}
|
|
|
|
|