Rewrite the find_* functions

diff --git a/source/virtualfilesystem.cpp b/source/virtualfilesystem.cpp
index b5e16d440ca2ec26b6a97871dff226da102855fa..0dc8de604ffd4253e4ae51e4920ef4c95dd09d0a 100644 (file)
--- a/source/virtualfilesystem.cpp
+++ b/source/virtualfilesystem.cpp
@@ -13,17 +13,6 @@
 using namespace std;
 using namespace Msp;
 
-namespace {
-
-void update_hash(string &hash, const string &value)
-{
-       for(unsigned i=0; i<value.size(); ++i)
-               hash[i%hash.size()] ^= value[i];
-}
-
-}
-
-
 VirtualFileSystem::VirtualFileSystem(Builder &b):
        builder(b)
 {
@@ -40,116 +29,112 @@ FileTarget *VirtualFileSystem::get_target(const FS::Path &p) const
 void VirtualFileSystem::register_path(const FS::Path &path, FileTarget *t)
 {
        targets.insert(TargetMap::value_type(path.str(), t));
+       nonexistent.erase(path);
+       builder.get_logger().log("vfs", format("Path %s registered to %s", path, t->get_name()));
 }
 
 FileTarget *VirtualFileSystem::find_header(const string &name, const SearchPath &path)
 {
-       string hash(8, 0);
-       for(list<string>::const_iterator i=path.begin(); i!=path.end(); ++i)
-               update_hash(hash, *i);
-
-       string id = hash+name;
-       TargetMap::iterator i = include_cache.find(id);
-       if(i!=include_cache.end())
-               return i->second;
-
-       builder.get_logger().log("vfs", format("Looking for header %s with path %s", name, join(path.begin(), path.end())));
-
        // XXX This will cause trouble with multiple architectures in a single build
        const Tool *tool = builder.get_toolchain().get_tool_for_suffix(FS::extpart(FS::basename(name)), true);
        if(!tool)
                return 0;
        const Tool::SearchPath &syspath = tool->get_system_path();
 
-       FileTarget *tgt = 0;
-       for(SearchPath::const_iterator j=path.begin(); (!tgt && j!=path.end()); ++j)
-               tgt = get_header(FS::Path(*j)/name, *tool);
-       for(Tool::SearchPath::const_iterator j=syspath.begin(); (!tgt && j!=syspath.end()); ++j)
-               tgt = get_header(FS::Path(*j)/name, *tool);
+       list<FS::Path> combined_path(path.begin(), path.end());
+       combined_path.insert(combined_path.end(), syspath.begin(), syspath.end());
 
-       include_cache.insert(TargetMap::value_type(id, tgt));
+       for(list<FS::Path>::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<FileTarget *>(tool->create_source(filename));
+               }
 
-       return tgt;
+               builder.get_logger().log("vfs", format("Header %s not found in %s", name, i->str()));
+       }
+
+       return 0;
 }
 
 FileTarget *VirtualFileSystem::find_library(const string &lib, const SearchPath &path, LibMode mode)
 {
-       string hash(8, 0);
-       for(list<string>::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;
-
        const Tool &linker = builder.get_toolchain().get_tool("LINK");
        const Tool::SearchPath &syspath = linker.get_system_path();
 
-       builder.get_logger().log("vfs", format("Looking for library %s with path %s", lib, join(path.begin(), path.end())));
+       list<FS::Path> combined_path(path.begin(), path.end());
+       combined_path.insert(combined_path.end(), syspath.begin(), syspath.end());
 
-       FileTarget *tgt = 0;
-       for(SearchPath::const_iterator j=path.begin(); (!tgt && j!=path.end()); ++j)
-               tgt = get_library(lib, *j, mode);
-       for(Tool::SearchPath::const_iterator j=syspath.begin(); (!tgt && j!=syspath.end()); ++j)
-               tgt = get_library(lib, *j, mode);
-
-       library_cache.insert(TargetMap::value_type(id, tgt));
-
-       return tgt;
-}
-
-FileTarget *VirtualFileSystem::get_header(const FS::Path &fn, const Tool &tool)
-{
-       if(FileTarget *tgt = get_target(fn))
-               return tgt;
-
-       if(FS::is_reg(fn))
-               return dynamic_cast<FileTarget *>(tool.create_source(fn));
-
-       return 0;
-}
-
-FileTarget *VirtualFileSystem::get_library(const string &lib, const FS::Path &path, LibMode mode)
-{
        const Architecture &arch = builder.get_current_arch();
 
        /* Try dynamic libraries only if library mode permits it */
+       list<string> shared_names;
        if(mode!=ALL_STATIC)
        {
-               FS::Path fn = try_patterns(path, arch.get_shared_library_patterns(), lib);
-               if(!fn.empty())
-               {
-                       FileTarget *tgt = get_target(fn);
-                       if(!tgt)
-                               return new SharedLibrary(builder, fn);
-                       else if(mode==DYNAMIC || !tgt->get_package())
-                               return tgt;
-               }
+               const list<Pattern> &shared_patterns = arch.get_shared_library_patterns();
+               for(list<Pattern>::const_iterator i=shared_patterns.begin(); i!=shared_patterns.end(); ++i)
+                       shared_names.push_back(i->apply(lib));
        }
 
        /* Static libraries are always considered, since sometimes shared versions
        may not be available */
-       FS::Path fn = try_patterns(path, arch.get_static_library_patterns(), lib);
-       if(!fn.empty())
+       list<string> static_names;
+       const list<Pattern> &static_patterns = arch.get_static_library_patterns();
+       for(list<Pattern>::const_iterator i=static_patterns.begin(); i!=static_patterns.end(); ++i)
+               static_names.push_back(i->apply(lib));
+
+       for(list<FS::Path>::const_iterator i=combined_path.begin(); i!=combined_path.end(); ++i)
        {
-               if(FileTarget *tgt = get_target(fn))
-                       return tgt;
-               else
-                       return new StaticLibrary(builder, fn);
+               bool shared = true;
+               for(list<string>::const_iterator j=shared_names.begin(); j!=static_names.end(); )
+               {
+                       if(j==shared_names.end())
+                       {
+                               j = static_names.begin();
+                               shared = false;
+                               continue;
+                       }
+
+                       FS::Path filename = *i / *j;
+                       if(FileTarget *tgt = get_target(filename))
+                       {
+                               if(!shared || mode==DYNAMIC || !tgt->get_package())
+                               {
+                                       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(shared)
+                                       return new SharedLibrary(builder, filename);
+                               else
+                                       return new StaticLibrary(builder, filename);
+                       }
+
+                       ++j;
+               }
+
+               builder.get_logger().log("vfs", format("Library %s not found in %s", lib, i->str()));
        }
 
        return 0;
 }
 
-FS::Path VirtualFileSystem::try_patterns(const FS::Path &dir, const list<Pattern> &patterns, const string &base)
+bool VirtualFileSystem::file_exists(const FS::Path &filename)
 {
-       for(list<Pattern>::const_iterator i=patterns.begin(); i!=patterns.end(); ++i)
-       {
-               FS::Path full = dir/i->apply(base);
-               if(get_target(full) || FS::is_reg(full))
-                       return full;
-       }
-
-       return FS::Path();
+       if(nonexistent.count(filename))
+               return false;
+       if(FS::is_reg(filename))
+               return true;
+       nonexistent.insert(filename);
+       return false;
 }

diff --git a/source/virtualfilesystem.h b/source/virtualfilesystem.h
index b19d10e8b45382ae9d18f89d77a7eb55546fe885..f0cb7383fc9e26ea093d558cbb5bc2885d574f89 100644 (file)
--- a/source/virtualfilesystem.h
+++ b/source/virtualfilesystem.h
@@ -24,8 +24,7 @@ private:
 
        Builder &builder;
        TargetMap targets;
-       TargetMap include_cache;
-       TargetMap library_cache;
+       std::set<Msp::FS::Path> nonexistent;
 
 public:
        VirtualFileSystem(Builder &);
@@ -47,9 +46,7 @@ public:
        FileTarget *find_library(const std::string &, const SearchPath &, LibMode);
 
 private:
-       FileTarget *get_header(const Msp::FS::Path &, const Tool &);
-       FileTarget *get_library(const std::string &, const Msp::FS::Path &, LibMode);
-       Msp::FS::Path try_patterns(const Msp::FS::Path &, const std::list<Pattern> &, const std::string &);
+       bool file_exists(const Msp::FS::Path &);
 };
 
 #endif