X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fvirtualfilesystem.cpp;h=820fb5b670bfc600a6df879bdc2c15f26ef39452;hb=f5413fd8f007164591af26be9ded15ee7c707540;hp=be646cdbb9c494afab313bd46ef56fb5add140d3;hpb=7e5ac6af8987bf12f3e338d00e96e8cb74f3534b;p=builder.git diff --git a/source/virtualfilesystem.cpp b/source/virtualfilesystem.cpp index be646cd..820fb5b 100644 --- a/source/virtualfilesystem.cpp +++ b/source/virtualfilesystem.cpp @@ -1,27 +1,20 @@ +#include #include +#include #include #include #include "builder.h" #include "csourcefile.h" -#include "misc.h" +#include "executable.h" +#include "importlibrary.h" #include "sharedlibrary.h" -#include "systemlibrary.h" +#include "staticlibrary.h" +#include "tool.h" #include "virtualfilesystem.h" using namespace std; using namespace Msp; -namespace { - -void update_hash(string &hash, const string &value) -{ - for(unsigned i=0; iget_name())); } -FileTarget *VirtualFileSystem::find_header(const string &include, const FS::Path &from, const list &path) +FileTarget *VirtualFileSystem::find_header(const string &name, Tool *tool, const SearchPath &path, bool use_syspath) { - string hash(8, 0); - if(include[0]=='\"') - update_hash(hash, from.str()); - for(list::const_iterator i=path.begin(); i!=path.end(); ++i) - update_hash(hash, *i); - - string id = hash+include; - TargetMap::iterator i = include_cache.find(id); - if(i!=include_cache.end()) - return i->second; - - static string cxx_ver; - if(cxx_ver.empty()) - { - // XXX This needs to go elsewhere - /*StringList argv; - argv.push_back(current_arch->get_tool("CXX")); - argv.push_back("--version"); - if(RegMatch m = Regex("[0-9]\\.[0-9.]+").match(run_command(argv))) - { - cxx_ver = m[0].str; - while(!cxx_ver.empty() && !FS::is_dir(FS::Path("/usr/include/c++")/cxx_ver)) - { - string::size_type dot = cxx_ver.rfind('.'); - if(dot==string::npos) - break; - cxx_ver.erase(dot); - } - if(verbose>=5) - IO::print("C++ version is %s\n", cxx_ver); - } - else*/ - cxx_ver = "-"; - } + if(!tool) + tool = builder.get_toolchain().get_tool_for_suffix(FS::extpart(FS::basename(name)), true); + if(!tool) + return 0; - string fn = include.substr(1); - if(builder.get_verbose()>=5) - IO::print("Looking for include %s from %s with path %s\n", fn, from, join(path.begin(), path.end())); + tool->prepare(); - SearchPath syspath; - const Architecture &arch = builder.get_current_arch(); - if(arch.is_native()) - syspath.push_back("/usr/include"); - else - syspath.push_back("/usr/"+arch.get_cross_prefix()+"/include"); - if(cxx_ver!="-") - syspath.push_back((FS::Path("/usr/include/c++/")/cxx_ver).str()); + list combined_path(path.begin(), path.end()); + if(use_syspath) + { + const Tool::SearchPath &syspath = tool->get_system_path(); + combined_path.insert(combined_path.end(), syspath.begin(), syspath.end()); + } - FileTarget *tgt = 0; - if(include[0]=='\"') - tgt = get_header(FS::Path(from)/fn); - for(list::const_iterator j=path.begin(); (!tgt && j!=path.end()); ++j) - tgt = get_header(FS::Path(*j)/fn); - for(list::const_iterator j=syspath.begin(); (!tgt && j!=syspath.end()); ++j) - tgt = get_header(FS::Path(*j)/fn); + for(list::const_iterator i=combined_path.begin(); i!=combined_path.end(); ++i) + { + FS::Path filename = *i/name; + if(FileTarget *tgt = get_target(filename)) + { + builder.get_logger().log("vfs", format("Header %s found in %s as existing %s", name, i->str(), tgt->get_type())); + return tgt; + } + else if(file_exists(filename)) + { + builder.get_logger().log("vfs", format("Header %s found in %s", name, i->str())); + return dynamic_cast(tool->create_source(filename)); + } - include_cache.insert(TargetMap::value_type(id, tgt)); + builder.get_logger().log("vfs", format("Header %s not found in %s", name, i->str())); + } - return tgt; + return 0; } -FileTarget *VirtualFileSystem::find_library(const string &lib, const list &path, LibMode mode) +FileTarget *VirtualFileSystem::find_library(const string &lib, const SearchPath &path, BuildInfo::LibraryMode mode, bool use_syspath) { - string hash(8, 0); - for(list::const_iterator i=path.begin(); i!=path.end(); ++i) - update_hash(hash, *i); - - string id = hash+string(1, mode)+lib; - TargetMap::iterator i = library_cache.find(id); - if(i!=library_cache.end()) - return i->second; - - SearchPath syspath; - const Architecture &arch = builder.get_current_arch(); - if(arch.is_native()) + list combined_path(path.begin(), path.end()); + if(use_syspath) { - syspath.push_back("/lib"); - syspath.push_back("/usr/lib"); - if(arch.match_name("pc-32-linux")) - syspath.push_back("/usr/lib/i386-linux-gnu"); - else if(arch.match_name("pc-64-linux")) - syspath.push_back("/usr/lib/x86_64-linux-gnu"); + Tool &linker = builder.get_toolchain().get_tool("LINK"); + linker.prepare(); + const Tool::SearchPath &syspath = linker.get_system_path(); + combined_path.insert(combined_path.end(), syspath.begin(), syspath.end()); } - else - syspath.push_back("/usr/"+arch.get_cross_prefix()+"/lib"); - if(builder.get_verbose()>=5) - IO::print("Looking for library %s with path %s\n", lib, join(path.begin(), path.end())); + const Architecture &arch = builder.get_current_arch(); - FileTarget *tgt = 0; - for(StringList::const_iterator j=path.begin(); (!tgt && j!=path.end()); ++j) - tgt = get_library(lib, *j, mode); - for(StringList::iterator j=syspath.begin(); (!tgt && j!=syspath.end()); ++j) - tgt = get_library(lib, *j, mode); + list shared_names; + if(mode!=BuildInfo::FORCE_STATIC) + shared_names = Pattern::apply_list(arch.get_shared_library_patterns(), lib); - library_cache.insert(TargetMap::value_type(id, tgt)); + list static_names; + if(mode!=BuildInfo::FORCE_DYNAMIC) + static_names = Pattern::apply_list(arch.get_static_library_patterns(), lib); - return tgt; -} + for(list::const_iterator i=combined_path.begin(); i!=combined_path.end(); ++i) + { + const list *cur_names = (mode>=BuildInfo::DYNAMIC ? &shared_names : &static_names); + for(list::const_iterator j=cur_names->begin(); j!=cur_names->end(); ) + { + FS::Path filename = *i / *j; + if(FileTarget *tgt = get_target(filename)) + { + builder.get_logger().log("vfs", format("Library %s (%s) found in %s as existing %s", lib, *j, i->str(), tgt->get_type())); + return tgt; + } + else if(file_exists(filename)) + { + builder.get_logger().log("vfs", format("Library %s (%s) found in %s", lib, *j, i->str())); + if(cur_names==&shared_names) + { + /* XXX Hack: create ImportLibraries here; they should be handled + separately, but I need a more generic way of handling all these + filename patterns */ + if(FS::extpart(*j)==".a") + return new ImportLibrary(builder, filename); + return new SharedLibrary(builder, filename); + } + else + return new StaticLibrary(builder, filename); + } -FileTarget *VirtualFileSystem::get_header(const FS::Path &fn) -{ - FileTarget *tgt = get_target(fn); - if(tgt) - return tgt; + if(++j==cur_names->end()) + { + if(mode==BuildInfo::DYNAMIC && cur_names==&shared_names) + cur_names = &static_names; + else if(mode==BuildInfo::STATIC && cur_names==&static_names) + cur_names = &shared_names; + else + break; + j = cur_names->begin(); + } + } - if(FS::is_reg(fn)) - { - tgt = new CSourceFile(builder, fn); - return tgt; + builder.get_logger().log("vfs", format("Library %s not found in %s", lib, i->str())); } + return 0; } -FileTarget *VirtualFileSystem::get_library(const string &lib, const FS::Path &path, LibMode mode) +FileTarget *VirtualFileSystem::find_binary(const string &name) { - // Populate a list of candidate filenames - StringList candidates; - - const Architecture &arch = builder.get_current_arch(); - if(mode!=ALL_STATIC) + SearchPath path; + if(FS::Path(name).is_absolute()) + path.push_back("/"); + else if(const char *env_path = getenv("PATH")) { - // XXX Should probably let the Architecture populate the list - if(arch.get_system()=="windows") - { - candidates.push_back("lib"+lib+".dll"); - candidates.push_back(lib+".dll"); - } - else - candidates.push_back("lib"+lib+".so"); + vector parts = split(env_path, ':'); + for(vector::const_iterator i=parts.begin(); i!=parts.end(); ++i) + path.push_back(*i); } - - /* Static libraries are always considered, since sometimes shared versions - may not be available */ - candidates.push_back("lib"+lib+".a"); - if(arch.get_system()=="windows") - candidates.push_back("lib"+lib+".dll.a"); - - for(StringList::iterator i=candidates.begin(); i!=candidates.end(); ++i) + else { - FS::Path full = path/ *i; - FileTarget *tgt = get_target(full); + path.push_back("/bin"); + path.push_back("/usr/bin"); + } - if(tgt) + for(SearchPath::const_iterator i=path.begin(); i!=path.end(); ++i) + { + FS::Path filename = *i/name; + if(FileTarget *tgt = get_target(filename)) { - Target *real_tgt = tgt->get_real_target(); - - /* Ignore dynamic libraries from local packages unless library mode is - DYNAMIC */ - if(dynamic_cast(real_tgt) && mode!=DYNAMIC) - continue; - else if(tgt) - return tgt; + builder.get_logger().log("vfs", format("Binary %s found in %s as existing %s", name, *i, tgt->get_type())); + return tgt; } - else if(FS::is_reg(full)) + else if(file_exists(filename)) { - tgt = new SystemLibrary(builder, full.str()); - return tgt; + builder.get_logger().log("vfs", format("Binary %s found in %s", name, *i)); + return new Executable(builder, filename); } + + builder.get_logger().log("vfs", format("Binary %s not found in %s", name, *i)); } return 0; } + +bool VirtualFileSystem::file_exists(const FS::Path &filename) +{ + if(nonexistent.count(filename)) + return false; + if(FS::is_reg(filename)) + return true; + nonexistent.insert(filename); + return false; +}