Updated Boost to 1.42.

author: Remko Tronçon <git@el-tramo.be> 2010-04-11 18:19:17 (GMT)
committer: Remko Tronçon <git@el-tramo.be> 2010-04-11 19:20:07 (GMT)
commit: 857e44c156a1dbefcb49bb5792c4384cebd8762a (patch)
tree: 11947fb81ad9c502627f1b2bb8f090fb8d53c107 /3rdParty/Boost/src/tools/bcp
parent: 77d4eb7588e113beaa03f3347523b26adefdeb06 (diff)
download: swift-857e44c156a1dbefcb49bb5792c4384cebd8762a.zip
swift-857e44c156a1dbefcb49bb5792c4384cebd8762a.tar.bz2
10 files changed, 634 insertions, 83 deletions
diff --git a/3rdParty/Boost/src/tools/bcp/add_dependent_lib.cpp b/3rdParty/Boost/src/tools/bcp/add_dependent_lib.cpp
new file mode 100644
index 0000000..bb1818a
--- /dev/null
+++ b/3rdParty/Boost/src/tools/bcp/add_dependent_lib.cpp
@@ -0,0 +1,216 @@
+/*
+ *
+ * Copyright (c) 2009 Dr John Maddock
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * This file implements the following:
+ *    void bcp_implementation::add_path(const fs::path& p)
+ *    void bcp_implementation::add_directory(const fs::path& p)
+ *    void bcp_implementation::add_file(const fs::path& p)
+ *    void bcp_implementation::add_dependent_lib(const std::string& libname, const fs::path& p, const fileview& view)
+ */
+
+#include "bcp_imp.hpp"
+#include "fileview.hpp"
+#include <boost/regex.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <boost/filesystem/exception.hpp>
+#include <iostream>
+
+//
+// This file contains the code required to work out whether the source/header file being scanned
+// is actually dependent upon some library's source code or not.
+//
+
+static std::map<std::string, boost::regex> scanner;
+
+static std::map<std::string, std::set<std::string> > free_function_names;
+static std::map<std::string, std::set<std::string> > class_names;
+static std::map<std::string, std::set<std::string> > variable_names;
+
+static void init_library_scanner(const fs::path& p, bool cvs_mode, const std::string& libname, bool recurse = false)
+{
+   /*
+   if(free_function_names.count(libname) == 0)
+   {
+      free_function_names[libname] = "[\\x0]";
+      class_names[libname] = "[\\x0]";
+      variable_names[libname] = "[\\x0]";
+   }
+   */
+   //
+   // Don't add files created by build system:
+   //
+   if((p.leaf() == "bin") || (p.leaf() == "bin-stage"))
+      return; 
+   //
+   // Don't add version control directories:
+   //
+   if((p.leaf() == "CVS") || (p.leaf() == ".svn"))
+      return; 
+   //
+   // don't add directories not under version control:
+   //
+   if(cvs_mode && !fs::exists(p / "CVS/Entries"))
+      return;
+   if(cvs_mode && !fs::exists(p / ".svn/entries"))
+      return;
+   //
+   // Enumerate files and directories:
+   //
+   fs::directory_iterator i(p);
+   fs::directory_iterator j;
+   while(i != j)
+   {
+      if(fs::is_directory(*i))
+         init_library_scanner(*i, cvs_mode, libname, true);
+      if(bcp_implementation::is_source_file(*i))
+      {
+         static boost::regex function_scanner(
+            "(?|"                       // Branch reset group
+               "(?:\\<\\w+\\>[^>;{},:]*)"  // Return type
+               "(?:"
+                  "(\\<\\w+\\>)"           // Maybe class name
+                  "\\s*"
+                  "(?:<[^>;{]*>)?"         // Maybe template specialisation
+                  "::\\s*)?"
+               "(\\<(?!throw|if|while|for|catch)\\w+\\>)" // function name
+               "\\s*"
+               "\\("
+                  "[^\\(\\);{}]*"          // argument list
+               "\\)"
+               "\\s*"
+               "\\{"                       // start of definition
+            "|"
+               "(\\<\\w+\\>)"              // Maybe class name
+               "\\s*"
+               "(?:<[^>;{]*>)?"            // Maybe template specialisation
+               "::\\s*"
+               "~?\\1"                     // function name, same as class name
+               "\\s*"
+               "\\("
+                  "[^\\(\\);{}]*"          // argument list
+               "\\)"
+               "\\s*"
+               "\\{"                       // start of definition
+            ")"                            // end branch reset
+            );
+         fileview view(*i);
+         boost::regex_iterator<const char*> a(view.begin(), view.end(), function_scanner);
+         boost::regex_iterator<const char*> b;
+         while(a != b)
+         {
+            if((*a)[1].matched)
+            {
+               std::string n = a->str(1);
+               class_names[libname].insert(n);
+            }
+            else
+            {
+               std::string n = a->str(2);
+               free_function_names[libname].insert(n);
+            }
+            ++a;
+         }
+      }
+      ++i;
+   }
+
+   if(recurse == false)
+   {
+      //
+      // Build the regular expressions:
+      //
+      const char* e1 = 
+         "^(?>[[:blank:]]*)(?!#)[^;{}\\r\\n]*"
+         "(?|"
+         "(?:class|struct)[^:;{}#]*"
+         "(";
+      // list of class names goes here...
+      const char* e2 = 
+         ")\\s*(?:<[^;{>]*>\\s*)?(?::[^;{]*)?\\{"
+         "|"
+         "\\<(?!return)\\w+\\>[^:;{}#=<>!~%.\\w]*(";
+         // List of function names goes here...
+      const char* e3 = 
+         ")\\s*\\([^;()]*\\)\\s*;)";
+
+      std::string class_name_list;
+      std::set<std::string>::const_iterator i = class_names[libname].begin(), j = class_names[libname].end();
+      if(i != j)
+      {
+         class_name_list = *i;
+         ++i;
+         while(i != j)
+         {
+            class_name_list += "|" + *i;
+            ++i;
+         }
+      }
+      else
+      {
+         class_name_list = "[\\x0]";
+      }
+      std::string function_name_list;
+      i = free_function_names[libname].begin();
+      j = free_function_names[libname].end();
+      if(i != j)
+      {
+         function_name_list = *i;
+         ++i;
+         while(i != j)
+         {
+            function_name_list += "|" + *i;
+            ++i;
+         }
+      }
+      else
+      {
+         function_name_list = "[\\x0]";
+      }
+
+      scanner[libname] = boost::regex(e1 + class_name_list + e2 + function_name_list + e3);
+   }
+}
+
+void bcp_implementation::add_dependent_lib(const std::string& libname, const fs::path& p, const fileview& view)
+{
+   //
+   // if the boost library libname has source associated with it
+   // then add the source to our list:
+   //
+   if(fs::exists(m_boost_path / "libs" / libname / "src"))
+   {
+      if(!m_dependencies.count(fs::path("libs") / libname / "src")) 
+      {
+         if(scanner.count(libname) == 0)
+            init_library_scanner(m_boost_path / "libs" / libname / "src", m_cvs_mode, libname);
+         boost::cmatch what;
+         if(regex_search(view.begin(), view.end(), what, scanner[libname]))
+         {
+            std::cout << "INFO: tracking source dependencies of library " << libname
+               << " due to presence of \"" << what << "\" in file " << p << std::endl;
+            //std::cout << "Full text match was: " << what << std::endl;
+            m_dependencies[fs::path("libs") / libname / "src"] = p; // set up dependency tree
+            add_path(fs::path("libs") / libname / "src");
+
+            if(fs::exists(m_boost_path / "libs" / libname / "build"))
+            {
+               if(!m_dependencies.count(fs::path("libs") / libname / "build")) 
+               {
+                  m_dependencies[fs::path("libs") / libname / "build"] = p; // set up dependency tree
+                  add_path(fs::path("libs") / libname / "build");
+                  //m_dependencies[fs::path("boost-build.jam")] = p;
+                  //add_path(fs::path("boost-build.jam"));
+                  m_dependencies[fs::path("Jamroot")] = p;
+                  add_path(fs::path("Jamroot"));
+                  //m_dependencies[fs::path("tools/build")] = p;
+                  //add_path(fs::path("tools/build"));
+               }
+            }
+         }
+      }
+   }
+}
diff --git a/3rdParty/Boost/src/tools/bcp/add_path.cpp b/3rdParty/Boost/src/tools/bcp/add_path.cpp
index 200500d..04530c6 100644
--- a/3rdParty/Boost/src/tools/bcp/add_path.cpp
+++ b/3rdParty/Boost/src/tools/bcp/add_path.cpp
@@ -9,7 +9,7 @@
  *    void bcp_implementation::add_path(const fs::path& p)
  *    void bcp_implementation::add_directory(const fs::path& p)
  *    void bcp_implementation::add_file(const fs::path& p)
- *    void bcp_implementation::add_dependent_lib(const std::string& libname)
+ *    void bcp_implementation::add_dependent_lib(const std::string& libname, const fs::path& p, const fileview& view)
  */
 
 #include "bcp_imp.hpp"
@@ -23,7 +23,7 @@
 void bcp_implementation::add_path(const fs::path& p)
 {
    fs::path normalized_path = p;
-   normalized_path.normalize();
+    normalized_path.normalize();
    if(fs::exists(m_boost_path / normalized_path))
    {
       if(fs::is_directory(m_boost_path / normalized_path))
@@ -34,6 +34,7 @@ void bcp_implementation::add_path(const fs::path& p)
    else
    {
       std::cerr << "CAUTION: dependent file " << p.string() << " does not exist." << std::endl;
+      std::cerr << "   Found while scanning file " << m_dependencies[p].string() << std::endl;
    }
 }
 
@@ -71,8 +72,10 @@ void bcp_implementation::add_directory(const fs::path& p)
       if(m_boost_path.string().size())
          s.erase(0, m_boost_path.string().size() + 1);
       if(!m_dependencies.count(fs::path(s))) 
+      {
          m_dependencies[fs::path(s)] = p; // set up dependency tree
-      add_path(fs::path(s));
+         add_path(fs::path(s));
+      }
       ++i;
    }
 }
@@ -100,6 +103,37 @@ void bcp_implementation::add_file(const fs::path& p)
    {
       add_file_dependencies(p, false);
    }
+   if(is_jam_file(p) && m_namespace_name.size() && ((std::distance(p.begin(), p.end()) < 3) || (*p.begin() != "tools") || (*++p.begin() != "build")))
+   {
+      //
+      // We're doing a rename of namespaces and library names
+      // so scan for names of libraries:
+      //
+      static const boost::regex e(
+         "\\<lib\\s+(boost\\w+)\\s+[:;]"
+         );
+
+      fileview view(m_boost_path / p);
+      boost::regex_token_iterator<const char*> i(view.begin(), view.end(), e, 1);
+      boost::regex_token_iterator<const char*> j;
+      while(i != j)
+      {
+         m_lib_names.insert(*i);
+         ++i;
+      }
+      static const std::pair<fs::path, std::string> specials_library_names[] = {
+            std::pair<fs::path, std::string>("libs/python/build/Jamfile.v2", "boost_python"),
+            std::pair<fs::path, std::string>("libs/python/build/Jamfile.v2", "boost_python3"),
+      };
+
+      for(unsigned int n = 0; n < (sizeof(specials_library_names)/sizeof(specials_library_names[0])); ++n)
+      {
+         if(0 == compare_paths(specials_library_names[n].first, p))
+         {
+            m_lib_names.insert(specials_library_names[n].second);
+         }
+      }
+   }
    //
    // if this is a html file, scan for dependencies:
    //
@@ -126,6 +160,14 @@ void bcp_implementation::add_file(const fs::path& p)
             s.erase(s.size() - 1);
          }
          //
+         // Remove any target suffix:
+         //
+         std::string::size_type n = s.find('#');
+         if(n != std::string::npos)
+         {
+            s.erase(n);
+         }
+         //
          // if the name starts with ./ remove it
          // or we'll get an error:
          if(s.compare(0, 2, "./") == 0)
@@ -136,8 +178,10 @@ void bcp_implementation::add_file(const fs::path& p)
             // rather than a URL:
             fs::path dep(p.branch_path() / s);
             if(!m_dependencies.count(dep)) 
+            {
                m_dependencies[dep] = p; // set up dependency tree
-            add_path(dep);
+               add_path(dep);
+            }
          }
          ++i;
       }
@@ -178,6 +222,18 @@ static const std::pair<fs::path, fs::path>
       std::pair<fs::path, fs::path>("boost/mpl/map/aux_/include_preprocessed.hpp", "boost/mpl/map/aux_/preprocessed"),
       std::pair<fs::path, fs::path>("boost/mpl/list/aux_/include_preprocessed.hpp", "boost/mpl/list/aux_/preprocessed"),
       std::pair<fs::path, fs::path>("libs/graph/src/python/visitor.hpp", "libs/graph/src/python"),
+      std::pair<fs::path, fs::path>("boost/test/detail/config.hpp", "libs/test/src"),
+      std::pair<fs::path, fs::path>("boost/test/detail/config.hpp", "libs/test/build"),
+      std::pair<fs::path, fs::path>("boost/typeof.hpp", "boost/typeof/incr_registration_group.hpp"),
+      std::pair<fs::path, fs::path>("boost/function_types/detail/pp_loop.hpp", "boost/function_types/detail/pp_cc_loop"),
+      std::pair<fs::path, fs::path>("boost/function_types/components.hpp", "boost/function_types/detail/components_impl"),
+      std::pair<fs::path, fs::path>("boost/function_types/detail/pp_loop.hpp", "boost/function_types/detail"),
+      std::pair<fs::path, fs::path>("boost/math/tools/rational.hpp", "boost/math/tools/detail"),
+      std::pair<fs::path, fs::path>("boost/proto/repeat.hpp", "boost/proto/detail/local.hpp"),
+      std::pair<fs::path, fs::path>("boost/signals/signal_template.hpp", "boost/function"),
+      std::pair<fs::path, fs::path>("boost/preprocessor/slot/counter.hpp", "boost/preprocessor/slot/detail/counter.hpp"),
+      std::pair<fs::path, fs::path>("boost/graph/distributed/detail/tag_allocator.hpp", "libs/graph_parallel"),
+      std::pair<fs::path, fs::path>("boost/graph/distributed/mpi_process_group.hpp", "libs/graph_parallel"),
    };
 
    for(unsigned int n = 0; n < (sizeof(specials)/sizeof(specials[0])); ++n)
@@ -185,33 +241,15 @@ static const std::pair<fs::path, fs::path>
       if(0 == compare_paths(specials[n].first, p))
       {
          if(!m_dependencies.count(specials[n].second)) 
+         {
             m_dependencies[specials[n].second] = p; // set up dependency tree
-         add_path(specials[n].second);
+            add_path(specials[n].second);
+         }
       }
    }
 
 }
 
-void bcp_implementation::add_dependent_lib(const std::string& libname, const fs::path& p)
-{
-   //
-   // if the boost library libname has source associated with it
-   // then add the source to our list:
-   //
-   if(fs::exists(m_boost_path / "libs" / libname / "src"))
-   {
-      if(!m_dependencies.count(fs::path("libs") / libname / "src")) 
-         m_dependencies[fs::path("libs") / libname / "src"] = p; // set up dependency tree
-      add_path(fs::path("libs") / libname / "src");
-      if(fs::exists(m_boost_path / "libs" / libname / "build"))
-      {
-         if(!m_dependencies.count(fs::path("libs") / libname / "build")) 
-            m_dependencies[fs::path("libs") / libname / "build"] = p; // set up dependency tree
-         add_path(fs::path("libs") / libname / "build");
-      }
-   }
-}
-
 void bcp_implementation::add_file_dependencies(const fs::path& p, bool scanfile)
 {
    static const boost::regex e(
@@ -263,14 +301,18 @@ void bcp_implementation::add_file_dependencies(const fs::path& p, bool scanfile)
       if(fs::exists(test_file) && !fs::is_directory(test_file) && (p.branch_path().string() != "boost"))
       {
          if(!m_dependencies.count(p.branch_path() / include_file)) 
+         {
             m_dependencies[p.branch_path() / include_file] = p;
-         add_path(p.branch_path() / include_file);
+            add_path(p.branch_path() / include_file);
+         }
       }
       else if(fs::exists(m_boost_path / include_file))
       {
          if(!m_dependencies.count(include_file)) 
+         {
             m_dependencies[include_file] = p;
-         add_path(include_file);
+            add_path(include_file);
+         }
       }
       ++i;
    }
@@ -278,7 +320,7 @@ void bcp_implementation::add_file_dependencies(const fs::path& p, bool scanfile)
    // Now we need to scan for Boost.Preprocessor includes that
    // are included via preprocessor iteration:
    //
-   boost::regex ppfiles("^[[:blank:]]*#[[:blank:]]*define[[:blank:]]+(?:BOOST_PP_FILENAME|BOOST_PP_ITERATION_PARAMS|BOOST_PP_INDIRECT_SELF)[^\\n]+?[\"<]([^\">]+)[\">]");
+   static const boost::regex ppfiles("^[[:blank:]]*#[[:blank:]]*define[[:blank:]]+(?:BOOST_PP_FILENAME|BOOST_PP_ITERATION_PARAMS|BOOST_PP_INDIRECT_SELF)[^\\n]+?[\"<]([^\">]+)[\">]");
    i = boost::regex_token_iterator<const char*>(view.begin(), view.end(), ppfiles, 1);
    while(i != j)
    {
@@ -302,14 +344,18 @@ void bcp_implementation::add_file_dependencies(const fs::path& p, bool scanfile)
       if(fs::exists(test_file) && !fs::is_directory(test_file) && (p.branch_path().string() != "boost"))
       {
          if(!m_dependencies.count(p.branch_path() / include_file)) 
+         {
             m_dependencies[p.branch_path() / include_file] = p;
-         add_path(p.branch_path() / include_file);
+            add_path(p.branch_path() / include_file);
+         }
       }
       else if(fs::exists(m_boost_path / include_file))
       {
          if(!m_dependencies.count(include_file)) 
+         {
             m_dependencies[include_file] = p;
-         add_path(include_file);
+            add_path(include_file);
+         }
       }
       else
       {
@@ -325,6 +371,8 @@ void bcp_implementation::add_file_dependencies(const fs::path& p, bool scanfile)
    // we know about and are correctly handled as special cases:
    //
    static const std::string known_macros[] = {
+      "AUX778076_INCLUDE_STRING",
+      "BOOST_PP_STRINGIZE(boost/mpl/aux_/preprocessed/AUX778076_PREPROCESSED_HEADER)",
       "BOOST_USER_CONFIG",
       "BOOST_COMPILER_CONFIG",
       "BOOST_STDLIB_CONFIG",
@@ -367,16 +415,49 @@ void bcp_implementation::add_file_dependencies(const fs::path& p, bool scanfile)
       "BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_VECTOR_C_HEADER)",
       "BOOST_REGEX_USER_CONFIG",
       "BGL_PYTHON_EVENTS_HEADER",
-   };
+      "B1",
+      "B2",
+      "BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()",
+      "BOOST_SLIST_HEADER",
+      "BOOST_HASH_SET_HEADER",
+      "BOOST_HASH_MAP_HEADER",
+      "BOOST_INTRUSIVE_INVARIANT_ASSERT_INCLUDE",
+      "BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT_INCLUDE",
+      "BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT_INCLUDE",
+      "BOOST_FT_loop",
+      "BOOST_FT_AL_PREPROCESSED",
+      "BOOST_FT_AL_INCLUDE_FILE",
+      "__FILE__",
+      "BOOST_FT_cc_file",
+      "BOOST_FT_variate_file",
+      "BOOST_USER_CONFIG",
+      "BOOST_HEADER()",
+      "BOOST_TR1_STD_HEADER(utility)",
+      "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(tuple))",
+      "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(random))",
+      "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(array))",
+      "BOOST_TR1_HEADER(cmath)",
+      "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(complex))",
+      "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(functional))",
+      "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(memory))",
+      "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(regex))",
+      "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(type_traits))",
+      "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(unordered_map))",
+      "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(unordered_set))",
+      "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(utility))",
+      "BOOST_PROTO_LOCAL_ITERATE()",
+      "BOOST_SIGNAL_FUNCTION_N_HEADER",
+      "BOOST_PP_UPDATE_COUNTER()",
+  };
 
-   boost::regex indirect_includes("^[[:blank:]]*#[[:blank:]]*include[[:blank:]]+([^\"<][^\n]*?)[[:blank:]]*$");
+   static const boost::regex indirect_includes("^[[:blank:]]*#[[:blank:]]*include[[:blank:]]+([^\"<][^\n]*?)[[:blank:]]*$");
    i = boost::regex_token_iterator<const char*>(view.begin(), view.end(), indirect_includes, 1);
    while(i != j)
    {
       const std::string* known_macros_end = known_macros + sizeof(known_macros)/sizeof(known_macros[0]);
       if(known_macros_end == std::find(known_macros, known_macros_end, i->str()))
       {
-         std::cerr << "CAUTION: don't know how to trace depenencies through macro: " << *i << " in file: " << p.string() << std::endl;
+         std::cerr << "CAUTION: don't know how to trace depenencies through macro: \"" << *i << "\" in file: " << p.string() << std::endl;
       }
       ++i;
    }
@@ -389,27 +470,49 @@ void bcp_implementation::add_file_dependencies(const fs::path& p, bool scanfile)
    boost::cmatch what;
    if(boost::regex_search(view.begin(), view.end(), what, m))
    {
-      add_dependent_lib("test", p);
+      add_dependent_lib("test", p, view);
    }
-   //
-   // grab the name of the library to which the header belongs, 
-   // and if that library has source then add the source to our
-   // list:
-   //
-   // this regex catches boost/libname.hpp or boost/libname/whatever:
-   //
-   static const boost::regex lib1("boost/([^\\./]+)(?!detail).*");
-   boost::smatch swhat;
-   if(boost::regex_match(p.string(), swhat, lib1))
+   if(!scanfile)
    {
-      add_dependent_lib(swhat.str(1), p);
+      //
+      // grab the name of the library to which the header belongs, 
+      // and if that library has source then add the source to our
+      // list:
+      //
+      // this regex catches boost/libname.hpp or boost/libname/whatever:
+      //
+      static const boost::regex lib1("boost/([^\\./]+)(?!detail).*");
+      boost::smatch swhat;
+      if(boost::regex_match(p.string(), swhat, lib1))
+      {
+         add_dependent_lib(swhat.str(1), p, view);
+      }
+      //
+      // and this one catches boost/x/y/whatever (for example numeric/ublas):
+      //
+      static const boost::regex lib2("boost/([^/]+/[^/]+)/(?!detail).*");
+      if(boost::regex_match(p.string(), swhat, lib2))
+      {
+         add_dependent_lib(swhat.str(1), p, view);
+      }
    }
-   //
-   // and this one catches boost/x/y/whatever (for example numeric/ublas):
-   //
-   static const boost::regex lib2("boost/([^/]+/[^/]+)/(?!detail).*");
-   if(boost::regex_match(p.string(), swhat, lib2))
+   if(m_list_namespaces)
    {
-      add_dependent_lib(swhat.str(1), p);
+      //
+      // scan for top level namespaces and add to our list:
+      //
+      static const boost::regex namespace_scanner(
+         "^(?<!\\\\\\n)[[:blank:]]*+namespace\\s++(\\w++)\\s++(\\{[^{}]*(?:(?2)[^{}]*)*\\})"
+         );
+      i = boost::regex_token_iterator<const char*>(view.begin(), view.end(), namespace_scanner, 1);
+      while(i != j)
+      {
+         if(m_top_namespaces.count(*i) == 0)
+         {
+            //std::cout << *i << " (Found in " << p << ")" << std::endl;
+            m_top_namespaces[*i] = p;
+         }
+         ++i;
+      }
    }
 }
diff --git a/3rdParty/Boost/src/tools/bcp/bcp.hpp b/3rdParty/Boost/src/tools/bcp/bcp.hpp
index 41bb070..ea2b4d0 100644
--- a/3rdParty/Boost/src/tools/bcp/bcp.hpp
+++ b/3rdParty/Boost/src/tools/bcp/bcp.hpp
@@ -29,6 +29,9 @@ public:
    virtual void set_boost_path(const char* p) = 0;
    virtual void set_destination(const char* p) = 0;
    virtual void add_module(const char* p) = 0;
+   virtual void set_namespace(const char* name) = 0;
+   virtual void set_namespace_alias(bool) = 0;
+   virtual void set_namespace_list(bool) = 0;
 
    virtual int run() = 0;
 
diff --git a/3rdParty/Boost/src/tools/bcp/bcp_imp.cpp b/3rdParty/Boost/src/tools/bcp/bcp_imp.cpp
index f00f022..c5d7fb4 100644
--- a/3rdParty/Boost/src/tools/bcp/bcp_imp.cpp
+++ b/3rdParty/Boost/src/tools/bcp/bcp_imp.cpp
@@ -18,7 +18,9 @@
 #include <string>
 
 bcp_implementation::bcp_implementation()
-  : m_list_mode(false), m_list_summary_mode(false), m_license_mode(false), m_cvs_mode(false), m_svn_mode(false), m_unix_lines(false), m_scan_mode(false), m_bsl_convert_mode(false), m_bsl_summary_mode(false)
+  : m_list_mode(false), m_list_summary_mode(false), m_license_mode(false), m_cvs_mode(false), 
+  m_svn_mode(false), m_unix_lines(false), m_scan_mode(false), m_bsl_convert_mode(false), 
+  m_bsl_summary_mode(false), m_namespace_alias(false), m_list_namespaces(false)
 {
 }
 
@@ -100,6 +102,22 @@ void bcp_implementation::add_module(const char* p)
    m_module_list.push_back(p);
 }
 
+void bcp_implementation::set_namespace(const char* name)
+{
+   m_namespace_name = name;
+}
+
+void bcp_implementation::set_namespace_alias(bool b)
+{
+   m_namespace_alias = b;
+}
+
+void bcp_implementation::set_namespace_list(bool b)
+{
+   m_list_namespaces = b;
+   m_list_mode = b;
+}
+
 fs::path get_short_path(const fs::path& p)
 {
    // truncate path no more than "x/y":
@@ -152,7 +170,7 @@ int bcp_implementation::run()
      fs::ifstream in(blanket_permission);
      std::string line;
      while (std::getline(in, line)) {
-       boost::regex e("([^(]+)\\(");
+       static const boost::regex e("([^(]+)\\(");
        boost::smatch result;
        if (boost::regex_search(line, result, e))
          m_bsl_authors.insert(format_authors_name(result[1]));
@@ -221,6 +239,33 @@ int bcp_implementation::run()
    //
    // now perform output:
    //
+   if(m_list_namespaces)
+   {
+      // List the namespaces, in two lists, headers and source files
+      // first, then everything else afterwards:
+      //
+      boost::regex important_file("boost/.*|libs/[^/]*/(?:[^/]*/)?/src/.*");
+      std::map<std::string, fs::path>::const_iterator i, j;
+      i = m_top_namespaces.begin();
+      j = m_top_namespaces.end();
+      std::cout << "\n\nThe top level namespaces found for header and source files were:\n";
+      while(i != j)
+      {
+         if(regex_match(i->second.string(), important_file))
+            std::cout << i->first << " (from " << i->second << ")" << std::endl;
+         ++i;
+      }
+
+      i = m_top_namespaces.begin();
+      std::cout << "\n\nThe top level namespaces found for all other source files were:\n";
+      while(i != j)
+      {
+         if(!regex_match(i->second.string(), important_file))
+            std::cout << i->first << " (from " << i->second << ")" << std::endl;
+         ++i;
+      }
+      return 0;
+   }
    std::set<fs::path, path_less>::iterator m, n;
    std::set<fs::path, path_less> short_paths;
    m = m_copy_paths.begin();
diff --git a/3rdParty/Boost/src/tools/bcp/bcp_imp.hpp b/3rdParty/Boost/src/tools/bcp/bcp_imp.hpp
index f65e0b2..9f45915 100644
--- a/3rdParty/Boost/src/tools/bcp/bcp_imp.hpp
+++ b/3rdParty/Boost/src/tools/bcp/bcp_imp.hpp
@@ -44,6 +44,9 @@ class bcp_implementation
 public:
    bcp_implementation();
    ~bcp_implementation();
+   static bool is_source_file(const fs::path& p);
+   static bool is_html_file(const fs::path& p);
+   static bool is_jam_file(const fs::path& p);
 private:
    //
    // the following are the overridden virtuals from the base class:
@@ -60,10 +63,14 @@ private:
    void set_boost_path(const char* p);
    void set_destination(const char* p);
    void add_module(const char* p);
+   void set_namespace(const char* name);
+   void set_namespace_alias(bool);
+   void set_namespace_list(bool);
 
    virtual int run();
-private:
+
    // internal helper functions:
+   bool is_binary_file(const fs::path& p);
    void scan_cvs_path(const fs::path& p);
    void scan_svn_path(const fs::path& p);
    void add_path(const fs::path& p);
@@ -71,10 +78,7 @@ private:
    void add_file(const fs::path& p);
    void copy_path(const fs::path& p);
    void add_file_dependencies(const fs::path& p, bool scanfile);
-   bool is_source_file(const fs::path& p);
-   bool is_html_file(const fs::path& p);
-   bool is_binary_file(const fs::path& p);
-   void add_dependent_lib(const std::string& libname, const fs::path& p);
+   void add_dependent_lib(const std::string& libname, const fs::path& p, const fileview& view);
    void create_path(const fs::path& p);
    // license code:
    void scan_license(const fs::path& p, const fileview& v);
@@ -90,18 +94,25 @@ private:
    bool m_scan_mode;                     // scan non-boost files.
    bool m_bsl_convert_mode;              // try to convert to the BSL
    bool m_bsl_summary_mode;              // summarise BSL issues only
+   bool m_namespace_alias;               // make "boost" a namespace alias when doing a namespace rename.
+   bool m_list_namespaces;               // list all the top level namespaces found.
    fs::path m_boost_path;                // the path to the boost root
    fs::path m_dest_path;                 // the path to copy to
-   std::map<fs::path, bool, path_less> m_cvs_paths;    // valid files under cvs control
-   std::set<fs::path, path_less> m_copy_paths;         // list of files to copy
-   std::map<int, license_data>   m_license_data;       // licenses in use
-   std::set<fs::path, path_less> m_unknown_licenses;   // files with no known license
-   std::set<fs::path, path_less> m_unknown_authors;    // files with no known copyright/author
-   std::set<fs::path, path_less> m_can_migrate_to_bsl; // files that can migrate to the BSL
-   std::set<fs::path, path_less> m_cannot_migrate_to_bsl; // files that cannot migrate to the BSL
-   std::set<std::string> m_bsl_authors;                // authors giving blanket permission to use the BSL
-   std::set<std::string> m_authors_for_bsl_migration;  // authors we need for BSL migration
-   std::map<fs::path, std::pair<std::string, std::string>, path_less> m_converted_to_bsl;
-   std::map<std::string, std::set<fs::path, path_less> > m_author_data;  // all the authors
-   std::map<fs::path, fs::path, path_less>               m_dependencies; // dependency information
+   std::map<fs::path, bool, path_less>                   m_cvs_paths;                  // valid files under cvs control
+   std::set<fs::path, path_less>                         m_copy_paths;                 // list of files to copy
+   std::map<int, license_data>                           m_license_data;               // licenses in use
+   std::set<fs::path, path_less>                         m_unknown_licenses;           // files with no known license
+   std::set<fs::path, path_less>                         m_unknown_authors;            // files with no known copyright/author
+   std::set<fs::path, path_less>                         m_can_migrate_to_bsl;         // files that can migrate to the BSL
+   std::set<fs::path, path_less>                         m_cannot_migrate_to_bsl;      // files that cannot migrate to the BSL
+   std::set<std::string>                                 m_bsl_authors;                // authors giving blanket permission to use the BSL
+   std::set<std::string>                                 m_authors_for_bsl_migration;  // authors we need for BSL migration
+   std::map<fs::path, std::pair<std::string, std::string>, path_less> 
+                                                         m_converted_to_bsl;
+   std::map<std::string, std::set<fs::path, path_less> > m_author_data;                // all the authors
+   std::map<fs::path, fs::path, path_less>               m_dependencies;               // dependency information
+   std::string                                           m_namespace_name;             // namespace rename.
+   std::set<std::string>                                 m_lib_names;                  // List of library binary names
+   std::map<std::string, fs::path>                       m_top_namespaces;             // List of top level namespace names
 };
+
diff --git a/3rdParty/Boost/src/tools/bcp/copy_path.cpp b/3rdParty/Boost/src/tools/bcp/copy_path.cpp
index c976865..af99b62 100644
--- a/3rdParty/Boost/src/tools/bcp/copy_path.cpp
+++ b/3rdParty/Boost/src/tools/bcp/copy_path.cpp
@@ -11,12 +11,36 @@
  */
 
 #include "bcp_imp.hpp"
+#include "fileview.hpp"
 #include <boost/filesystem/operations.hpp>
+#include <boost/regex.hpp>
 #include <fstream>
 #include <iterator>
 #include <algorithm>
 #include <iostream>
 
+struct get_new_library_name
+{ 
+   get_new_library_name(const std::string& n) : m_new_name(n) {}
+   template <class I>
+   std::string operator()(const boost::match_results<I>& what)
+   {
+      std::string s = what[0];
+      std::string::size_type n = s.find("boost");
+      if(n == std::string::npos)
+      {
+         s.insert(0, m_new_name);
+      }
+      else
+      {
+         s.replace(n, 5, m_new_name);
+      }
+      return s;
+   }
+private:
+   std::string m_new_name;
+};
+
 void bcp_implementation::copy_path(const fs::path& p)
 {
    assert(!fs::is_directory(m_boost_path / p));
@@ -34,7 +58,123 @@ void bcp_implementation::copy_path(const fs::path& p)
    //
    // do text based copy if requested:
    //
-   if(m_unix_lines && !is_binary_file(p))
+   if(m_namespace_name.size() && m_lib_names.size() && is_jam_file(p))
+   {
+      static std::vector<char> v1, v2;
+      v1.clear();
+      v2.clear();
+      std::ifstream is((m_boost_path / p).native_file_string().c_str());
+      std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1));
+
+      static boost::regex libname_matcher;
+      if(libname_matcher.empty())
+      {
+         std::string re = "\\<";
+         re += *m_lib_names.begin();
+         for(std::set<std::string>::const_iterator i = ++m_lib_names.begin(); i != m_lib_names.end(); ++i)
+         {
+            re += "|" + *i;
+         }
+         re += "\\>";
+         libname_matcher.assign(re);
+      }
+
+      regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), libname_matcher, get_new_library_name(m_namespace_name));
+      std::swap(v1, v2);
+      v2.clear();
+
+      std::ofstream os;
+      if(m_unix_lines)
+         os.open((m_dest_path / p).native_file_string().c_str(), std::ios_base::binary | std::ios_base::out);
+      else
+         os.open((m_dest_path / p).native_file_string().c_str(), std::ios_base::out);
+      os.write(&*v1.begin(), v1.size());
+      os.close();
+   }
+   else if(m_namespace_name.size() && is_source_file(p))
+   {
+      //
+      // v1 hold the current content, v2 is temp buffer.
+      // Each time we do a search and replace the new content 
+      // ends up in v2: we then swap v1 and v2, and clear v2.
+      //
+      static std::vector<char> v1, v2;
+      v1.clear();
+      v2.clear();
+      std::ifstream is((m_boost_path / p).native_file_string().c_str());
+      std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1));
+
+      static const boost::regex namespace_matcher(
+         "(?|"
+            "(namespace\\s+)boost(_\\w+)?"
+         "|"
+            "(namespace\\s+)(adstl|phoenix|rapidxml)\\>"
+         "|"
+            "()boost((?:_\\w+)?\\s*(?:::|,|\\)))"
+         "|"
+            "()((?:adstl|phoenix|rapidxml)\\s*(?:::|,|\\)))"
+         "|"
+            "(namespace\\s+\\w+\\s*=\\s*(?:::\\s*)?)boost(_\\w+)?"
+         "|"
+            "(namespace\\s+\\w+\\s*=\\s*(?:::\\s*)?)(adstl|phoenix|rapidxml)\\>"
+         "|"
+            "(^\\s*#\\s*define[^\\n]+)boost((?:_\\w+)?\\s*)$"
+         "|"
+            "(^\\s*#\\s*define[^\\n]+)((?:adstl|phoenix|rapidxml)\\s*)$"
+         ")"
+         );
+
+      regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), namespace_matcher, "$1" + m_namespace_name + "$2");
+      std::swap(v1, v2);
+      v2.clear();
+
+      if(m_namespace_alias)
+      {
+         static const boost::regex namespace_alias(
+            /*
+            "namespace\\s+" + m_namespace_name + 
+            "\\s*"
+            "("
+               "\\{"
+               "(?:"
+                  "(?>[^\\{\\}/]+)"
+                  "(?>"
+                     "(?:"
+                        "(?1)"
+                        "|//[^\\n]+$"
+                        "|/[^/]"
+                        "|(?:^\\s*#[^\\n]*"
+                           "(?:(?<=\\\\)\\n[^\\n]*)*)"
+                     ")"
+                     "[^\\{\\}]+"
+                  ")*"
+               ")*"
+               "\\}"
+            ")"
+            */
+            /*
+            "(namespace\\s+" + m_namespace_name + 
+            "\\s*\\{.*"
+            "\\})([^\\{\\};]*)\\z"
+            */
+            "namespace\\s+" + m_namespace_name + 
+            "\\s*\\{"
+            );
+         regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), namespace_alias, 
+            "namespace " + m_namespace_name + "{} namespace boost = " + m_namespace_name + "; namespace " + m_namespace_name + "{");
+         std::swap(v1, v2);
+         v2.clear();
+      }
+
+      std::ofstream os;
+      if(m_unix_lines)
+         os.open((m_dest_path / p).native_file_string().c_str(), std::ios_base::binary | std::ios_base::out);
+      else
+         os.open((m_dest_path / p).native_file_string().c_str(), std::ios_base::out);
+      os.write(&*v1.begin(), v1.size());
+      os.close();
+   }
+   else if(m_unix_lines && !is_binary_file(p))
    {
       std::ifstream is((m_boost_path / p).native_file_string().c_str());
       std::istreambuf_iterator<char> isi(is);
diff --git a/3rdParty/Boost/src/tools/bcp/file_types.cpp b/3rdParty/Boost/src/tools/bcp/file_types.cpp
index bc9ca31..abc0149 100644
--- a/3rdParty/Boost/src/tools/bcp/file_types.cpp
+++ b/3rdParty/Boost/src/tools/bcp/file_types.cpp
@@ -19,11 +19,11 @@ bool bcp_implementation::is_source_file(const fs::path& p)
    static const boost::regex e(
       ".*\\."
       "(?:"
-         "c|cxx|h|hxx|inc|.?pp|yy?"
+         "c|cxx|h|hxx|inc|inl|.?pp|yy?"
       ")", 
       boost::regex::perl | boost::regex::icase
       );
-   return boost::regex_match(p.string(), e);
+   return boost::regex_match(p.filename(), e);
 }
 
 bool bcp_implementation::is_html_file(const fs::path& p)
@@ -34,7 +34,7 @@ bool bcp_implementation::is_html_file(const fs::path& p)
          "html?|css"
       ")"
       );
-   return boost::regex_match(p.string(), e);
+   return boost::regex_match(p.filename(), e);
 }
 
 bool bcp_implementation::is_binary_file(const fs::path& p)
@@ -55,3 +55,18 @@ bool bcp_implementation::is_binary_file(const fs::path& p)
    return !boost::regex_match(p.leaf(), e);
 
 }
+
+bool bcp_implementation::is_jam_file(const fs::path& p)
+{
+   static const boost::regex e(
+      ".*\\."
+      "(?:"
+         "jam|v2"
+      ")"
+      "|"
+      "(Jamfile|Jamroot)\\.?", 
+      boost::regex::perl | boost::regex::icase
+      );
+   return boost::regex_match(p.filename(), e);
+}
+
diff --git a/3rdParty/Boost/src/tools/bcp/licence_info.cpp b/3rdParty/Boost/src/tools/bcp/licence_info.cpp
index 2081f10..ab34b83 100644
--- a/3rdParty/Boost/src/tools/bcp/licence_info.cpp
+++ b/3rdParty/Boost/src/tools/bcp/licence_info.cpp
@@ -5,6 +5,7 @@
  * Boost Software License, Version 1.0. (See accompanying file 
  * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  *
+ *  boostinspect:noascii
  */
 
 #include "licence_info.hpp"
diff --git a/3rdParty/Boost/src/tools/bcp/main.cpp b/3rdParty/Boost/src/tools/bcp/main.cpp
index 16a1722..a152138 100644
--- a/3rdParty/Boost/src/tools/bcp/main.cpp
+++ b/3rdParty/Boost/src/tools/bcp/main.cpp
@@ -34,15 +34,17 @@ void show_usage()
       "   bcp [options] module-list output-path\n"
       "\n"
       "Options:\n"
-      "   --boost=path   sets the location of the boost tree to path\n"
-      "   --scan         treat the module list as a list of (possibly non-boost)\n" 
-      "                  files to scan for boost dependencies\n"
-      "   --cvs          only copy files under cvs version control\n"
-      "   --unix-lines   make sure that all copied files use Unix style line endings\n"
+      "   --boost=path     sets the location of the boost tree to path\n"
+      "   --scan           treat the module list as a list of (possibly non-boost)\n" 
+      "                    files to scan for boost dependencies\n"
+      "   --svn            only copy files under cvs version control\n"
+      "   --unix-lines     make sure that all copied files use Unix style line endings\n"
+      "   --namespace=name rename the boost namespace to name (also changes library names).\n"
+      "   --namespace-alias Makes namespace boost an alias of the namespace set with --namespace.\n"
       "\n"
-      "module-list:      a list of boost files or library names to copy\n"
-      "html-file:        the name of a html file to which the report will be written\n"
-      "output-path:      the path to which files will be copied\n";
+      "module-list:         a list of boost files or library names to copy\n"
+      "html-file:           the name of a html file to which the report will be written\n"
+      "output-path:         the path to which files will be copied\n";
 }
 
 bool filesystem_name_check( const std::string & name )
@@ -64,6 +66,7 @@ int cpp_main(int argc, char* argv[])
    //
    if(argc < 2)
    {
+      std::cout << "Error: insufficient arguments, don't know what to do." << std::endl;
       show_usage();
       return 0;
    }
@@ -134,8 +137,22 @@ int cpp_main(int argc, char* argv[])
       {
          papp->set_boost_path(argv[i] + 8);
       }
+      else if(0 == std::strncmp("--namespace=", argv[i], 12))
+      {
+         papp->set_namespace(argv[i] + 12);
+      }
+      else if(0 == std::strncmp("--namespace-alias", argv[i], 17))
+      {
+         papp->set_namespace_alias(true);
+      }
+      else if(0 == std::strncmp("--list-namespaces", argv[i], 17))
+      {
+         list_mode = true;
+         papp->set_namespace_list(true);
+      }
       else if(argv[i][0] == '-')
       {
+         std::cout << "Error: Unknown argument " << argv[i] << std::endl;
          show_usage();
          return 1;
       }
diff --git a/3rdParty/Boost/src/tools/bcp/output_licence_info.cpp b/3rdParty/Boost/src/tools/bcp/output_licence_info.cpp
index 2196894..26eae7b 100644
--- a/3rdParty/Boost/src/tools/bcp/output_licence_info.cpp
+++ b/3rdParty/Boost/src/tools/bcp/output_licence_info.cpp
@@ -139,7 +139,7 @@ void bcp_implementation::output_license_info()
    // version):
    //
    fileview version_file(m_boost_path / "boost/version.hpp");
-   boost::regex version_regex(
+   static const boost::regex version_regex(
       "^[[:blank:]]*#[[:blank:]]*define[[:blank:]]+BOOST_VERSION[[:blank:]]+(\\d+)");
    boost::cmatch what;
    if(boost::regex_search(version_file.begin(), version_file.end(), what, version_regex))
author	Remko Tronçon <git@el-tramo.be>	2010-04-11 18:19:17 (GMT)
committer	Remko Tronçon <git@el-tramo.be>	2010-04-11 19:20:07 (GMT)
commit	857e44c156a1dbefcb49bb5792c4384cebd8762a (patch)
tree	11947fb81ad9c502627f1b2bb8f090fb8d53c107 /3rdParty/Boost/src/tools/bcp
parent	77d4eb7588e113beaa03f3347523b26adefdeb06 (diff)
download	swift-857e44c156a1dbefcb49bb5792c4384cebd8762a.zip swift-857e44c156a1dbefcb49bb5792c4384cebd8762a.tar.bz2