summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '3rdParty/Boost/src/tools/bcp')
-rw-r--r--3rdParty/Boost/src/tools/bcp/add_dependent_lib.cpp216
-rw-r--r--3rdParty/Boost/src/tools/bcp/add_path.cpp205
-rw-r--r--3rdParty/Boost/src/tools/bcp/bcp.hpp3
-rw-r--r--3rdParty/Boost/src/tools/bcp/bcp_imp.cpp49
-rw-r--r--3rdParty/Boost/src/tools/bcp/bcp_imp.hpp45
-rw-r--r--3rdParty/Boost/src/tools/bcp/copy_path.cpp142
-rw-r--r--3rdParty/Boost/src/tools/bcp/file_types.cpp21
-rw-r--r--3rdParty/Boost/src/tools/bcp/licence_info.cpp1
-rw-r--r--3rdParty/Boost/src/tools/bcp/main.cpp33
-rw-r--r--3rdParty/Boost/src/tools/bcp/output_licence_info.cpp2
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))