summaryrefslogtreecommitdiffstats
path: root/src/boost/tools/bcp
diff options
context:
space:
mode:
Diffstat (limited to 'src/boost/tools/bcp')
-rw-r--r--src/boost/tools/bcp/Jamfile.v236
-rw-r--r--src/boost/tools/bcp/README.md24
-rw-r--r--src/boost/tools/bcp/add_dependent_lib.cpp230
-rw-r--r--src/boost/tools/bcp/add_path.cpp569
-rw-r--r--src/boost/tools/bcp/bcp.hpp47
-rw-r--r--src/boost/tools/bcp/bcp_imp.cpp300
-rw-r--r--src/boost/tools/bcp/bcp_imp.hpp121
-rw-r--r--src/boost/tools/bcp/copy_path.cpp248
-rw-r--r--src/boost/tools/bcp/file_types.cpp72
-rw-r--r--src/boost/tools/bcp/fileview.cpp143
-rw-r--r--src/boost/tools/bcp/fileview.hpp72
-rw-r--r--src/boost/tools/bcp/index.html17
-rw-r--r--src/boost/tools/bcp/licence_info.cpp721
-rw-r--r--src/boost/tools/bcp/licence_info.hpp39
-rw-r--r--src/boost/tools/bcp/main.cpp183
-rw-r--r--src/boost/tools/bcp/output_licence_info.cpp410
-rw-r--r--src/boost/tools/bcp/path_operations.cpp41
-rw-r--r--src/boost/tools/bcp/scan_cvs_path.cpp147
-rw-r--r--src/boost/tools/bcp/scan_licence.cpp275
-rw-r--r--src/boost/tools/bcp/test/Jamfile.v225
20 files changed, 3720 insertions, 0 deletions
diff --git a/src/boost/tools/bcp/Jamfile.v2 b/src/boost/tools/bcp/Jamfile.v2
new file mode 100644
index 000000000..b89a15362
--- /dev/null
+++ b/src/boost/tools/bcp/Jamfile.v2
@@ -0,0 +1,36 @@
+# (C) Copyright John Maddock 2006.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+
+exe bcp
+ :
+ add_dependent_lib.cpp add_path.cpp bcp_imp.cpp copy_path.cpp file_types.cpp
+ fileview.cpp main.cpp path_operations.cpp scan_cvs_path.cpp
+ licence_info.cpp scan_licence.cpp output_licence_info.cpp
+ /boost/filesystem//boost_filesystem
+ /boost/regex//boost_regex
+ :
+ :
+ release
+ ;
+
+install dist-bin
+ :
+ bcp
+ :
+ <install-type>EXE
+ <location>../../dist/bin
+ :
+ release
+ ;
+
+install dist-lib
+ :
+ bcp
+ :
+ <install-type>LIB
+ <location>../../dist/lib
+ :
+ release
+ ;
+
diff --git a/src/boost/tools/bcp/README.md b/src/boost/tools/bcp/README.md
new file mode 100644
index 000000000..b3f2b4d72
--- /dev/null
+++ b/src/boost/tools/bcp/README.md
@@ -0,0 +1,24 @@
+BCP Tool [![Build Status](https://travis-ci.org/boostorg/bcp.svg?branch=develop)](https://travis-ci.org/boostorg/bcp)
+==================
+
+The bcp utility is a tool for extracting subsets of Boost, it's useful for Boost authors who want to distribute
+their library separately from Boost, and for Boost users who want to distribute a subset of Boost with their application.
+
+bcp can also report on which parts of Boost your code is dependent on, and what licences are used by those dependencies.
+
+The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/tools/bcp).
+
+| | Master | Develop |
+|------------------|----------|-------------|
+| Travis | [![Build Status](https://travis-ci.org/boostorg/bcp.svg?branch=master)](https://travis-ci.org/boostorg/bcp) | [![Build Status](https://travis-ci.org/boostorg/bcp.svg)](https://travis-ci.org/boostorg/bcp) |
+
+
+
+## Support, bugs and feature requests ##
+
+Bugs and feature requests can be reported through the [Gitub issue tracker](https://github.com/boostorg/bcp/issues)
+(see [open issues](https://github.com/boostorg/bcp/issues) and
+[closed issues](https://github.com/boostorg/bcp/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aclosed)).
+
+You can submit your changes through a [pull request](https://github.com/boostorg/bcp/pulls).
+
diff --git a/src/boost/tools/bcp/add_dependent_lib.cpp b/src/boost/tools/bcp/add_dependent_lib.cpp
new file mode 100644
index 000000000..48529142f
--- /dev/null
+++ b/src/boost/tools/bcp/add_dependent_lib.cpp
@@ -0,0 +1,230 @@
+/*
+ *
+ * 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*(?:BOOST[_A-Z]+\\s*)?"
+ "\\{" // start of definition
+ "|"
+ "(\\<\\w+\\>)" // Maybe class name
+ "\\s*"
+ "(?:<[^>;{]*>)?" // Maybe template specialisation
+ "::\\s*"
+ "~?\\1" // function name, same as class name
+ "\\s*"
+ "\\("
+ "[^\\(\\);{}]*" // argument list
+ "\\)"
+ "\\s*(?:BOOST[_A-Z]+\\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*(?:BOOST[_A-Z]+\\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"));
+ }
+ }
+ if(fs::exists(m_boost_path / "libs" / libname / "config"))
+ {
+ if(!m_dependencies.count(fs::path("libs") / libname / "config"))
+ {
+ m_dependencies[fs::path("libs") / libname / "config"] = p; // set up dependency tree
+ add_path(fs::path("libs") / libname / "config");
+ //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/src/boost/tools/bcp/add_path.cpp b/src/boost/tools/bcp/add_path.cpp
new file mode 100644
index 000000000..669fc92e7
--- /dev/null
+++ b/src/boost/tools/bcp/add_path.cpp
@@ -0,0 +1,569 @@
+/*
+ *
+ * Copyright (c) 2003 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>
+
+
+void bcp_implementation::add_path(const fs::path& p)
+{
+ fs::path normalized_path = p;
+ normalized_path.normalize();
+ if(fs::exists(m_boost_path / normalized_path))
+ {
+ if(fs::is_directory(m_boost_path / normalized_path))
+ add_directory(normalized_path);
+ else
+ add_file(normalized_path);
+ }
+ 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;
+ }
+}
+
+void bcp_implementation::add_directory(const fs::path& p)
+{
+ //
+ // 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(m_cvs_mode && !fs::exists(m_boost_path / p / "CVS/Entries"))
+ return;
+ if(m_svn_mode && !fs::exists(m_boost_path / p / ".svn/entries"))
+ return;
+ //
+ // enermerate files and directories:
+ //
+ fs::directory_iterator i(m_boost_path / p);
+ fs::directory_iterator j;
+ while(i != j)
+ {
+ //
+ // we need to convert *i back into
+ // a relative path, what follows is a hack:
+ //
+ std::string s(i->path().string());
+ if(m_boost_path.string().size())
+ s.erase(0, m_boost_path.string().size() + 1);
+ fs::path np = s;
+ if(!m_dependencies.count(np))
+ {
+ m_dependencies[np] = p; // set up dependency tree
+ add_pending_path(np);
+ }
+ ++i;
+ }
+}
+
+void bcp_implementation::add_file(const fs::path& p)
+{
+ //
+ // if the file does not exist in cvs then don't do anything with it:
+ //
+ if((m_cvs_mode || m_svn_mode) && (m_cvs_paths.find(p) == m_cvs_paths.end()))
+ return;
+ //
+ // if we've already seen the file return:
+ //
+ if(m_copy_paths.find(p) != m_copy_paths.end())
+ return;
+ //
+ // add the file to our list:
+ //
+ m_copy_paths.insert(p);
+ //
+ // if this is a source file, scan for dependencies:
+ //
+ if(is_source_file(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:
+ //
+ if(is_html_file(p))
+ {
+ static const boost::regex e(
+ "<(?:img[^>]*src=|link[^>]*href=)(\"[^\"]+\"|\\w+)[^>]*>"
+ );
+
+ 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)
+ {
+ //
+ // extract the dependent name:
+ //
+ std::string s(*i);
+ if(s[0] == '\"')
+ {
+ // remove quotes:
+ assert(s.size() > 2);
+ s.erase(0, 1);
+ 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)
+ s.erase(0, 2);
+ if(s.find(':') == std::string::npos)
+ {
+ // only concatonate if it's a relative path
+ // 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_pending_path(dep);
+ }
+ }
+ ++i;
+ }
+ }
+ //
+ // now scan for "special" dependencies:
+ // anything that we can't automatically detect...
+ //
+static const std::pair<fs::path, fs::path>
+ specials[] = {
+ std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "libs/predef/check"),
+ std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "libs/predef/tools"),
+ std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "tools/boost_install/boost-install.jam"),
+ std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "tools/boost_install/boost-install-dirs.jam"),
+ std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "tools/boost_install/Jamfile"),
+ std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "libs/headers"),
+ std::pair<fs::path, fs::path>("libs/test/build/Jamfile.v2", "libs/timer/src"),
+ std::pair<fs::path, fs::path>("libs/test/build/Jamfile.v2", "libs/timer/build"),
+ std::pair<fs::path, fs::path>("boost/atomic/capabilities.hpp", "boost/atomic/detail"),
+ std::pair<fs::path, fs::path>("boost/chrono/chrono.hpp", "libs/chrono/src"),
+ std::pair<fs::path, fs::path>("boost/chrono/chrono.hpp", "libs/chrono/build"),
+ std::pair<fs::path, fs::path>("boost/context/execution_context.hpp", "libs/context/src"),
+ std::pair<fs::path, fs::path>("boost/context/execution_context.hpp", "libs/context/build"),
+ std::pair<fs::path, fs::path>("boost/context/fcontext.hpp", "libs/context/src"),
+ std::pair<fs::path, fs::path>("boost/context/fcontext.hpp", "libs/context/build"),
+ std::pair<fs::path, fs::path>("boost/context/fixedsize_stack.hpp", "libs/context/src"),
+ std::pair<fs::path, fs::path>("boost/context/fixedsize_stack.hpp", "libs/context/build"),
+ std::pair<fs::path, fs::path>("boost/context/protected_fixedsize_stack.hpp", "libs/context/src"),
+ std::pair<fs::path, fs::path>("boost/context/protected_fixedsize_stack.hpp", "libs/context/build"),
+ std::pair<fs::path, fs::path>("boost/context/segmented_stack.hpp", "libs/context/src"),
+ std::pair<fs::path, fs::path>("boost/context/segmented_stack.hpp", "libs/context/build"),
+ std::pair<fs::path, fs::path>("boost/context/stack_context.hpp", "libs/context/src"),
+ std::pair<fs::path, fs::path>("boost/context/stack_context.hpp", "libs/context/build"),
+ std::pair<fs::path, fs::path>("boost/context/stack_traits.hpp", "libs/context/src"),
+ std::pair<fs::path, fs::path>("boost/context/stack_traits.hpp", "libs/context/build"),
+ std::pair<fs::path, fs::path>("boost/cerrno.hpp", "libs/system/build"),
+ std::pair<fs::path, fs::path>("boost/cerrno.hpp", "libs/system/src"),
+ std::pair<fs::path, fs::path>("libs/thread/build", "boost/system"),
+ std::pair<fs::path, fs::path>("libs/thread/build", "boost/cerrno.hpp"),
+ std::pair<fs::path, fs::path>("libs/thread/build", "boost/chrono"),
+ std::pair<fs::path, fs::path>("boost/filesystem/convenience.hpp", "boost/filesystem.hpp"),
+ std::pair<fs::path, fs::path>("boost/filesystem/exception.hpp", "boost/filesystem.hpp"),
+ std::pair<fs::path, fs::path>("boost/filesystem/fstream.hpp", "boost/filesystem.hpp"),
+ std::pair<fs::path, fs::path>("boost/filesystem/operations.hpp", "boost/filesystem.hpp"),
+ std::pair<fs::path, fs::path>("boost/filesystem/path.hpp", "boost/filesystem.hpp"),
+ std::pair<fs::path, fs::path>("boost/filesystem.hpp", "libs/filesystem/build"),
+ std::pair<fs::path, fs::path>("boost/filesystem.hpp", "libs/filesystem/v2"),
+ std::pair<fs::path, fs::path>("boost/filesystem.hpp", "libs/filesystem/v3"),
+ std::pair<fs::path, fs::path>("boost/config.hpp", "boost/config"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "libs/config/checks"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "libs/config/test"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "libs/headers/build"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "tools/boost_install/BoostConfig.cmake"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "tools/boost_install/BoostDetectToolset.cmake"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "tools/boost_install/boost-install.jam"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "tools/boost_install/boost-install-dirs.jam"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "boost-build.jam"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "boostcpp.jam"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "bootstrap.bat"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "bootstrap.sh"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "Jamroot"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "INSTALL"),
+ std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "LICENSE_1_0.txt"),
+ std::pair<fs::path, fs::path>("boost/preprocessor/iterate.hpp", "boost/preprocessor/iteration"),
+ std::pair<fs::path, fs::path>("boost/preprocessor/slot/slot.hpp", "boost/preprocessor/slot/detail"),
+ std::pair<fs::path, fs::path>("boost/function.hpp", "boost/function/detail"),
+ std::pair<fs::path, fs::path>("boost/regex/config.hpp", "boost/regex/user.hpp"),
+ std::pair<fs::path, fs::path>("boost/signals/signal_template.hpp", "boost/function"),
+ std::pair<fs::path, fs::path>("boost/mpl/list.hpp", "boost/mpl/list"),
+ std::pair<fs::path, fs::path>("boost/mpl/list_c.hpp", "boost/mpl/list"),
+ std::pair<fs::path, fs::path>("boost/mpl/vector.hpp", "boost/mpl/vector"),
+ std::pair<fs::path, fs::path>("boost/mpl/deque.hpp", "boost/mpl/vector"),
+ std::pair<fs::path, fs::path>("boost/mpl/vector_c.hpp", "boost/mpl/vector"),
+ std::pair<fs::path, fs::path>("boost/mpl/map.hpp", "boost/mpl/map"),
+ std::pair<fs::path, fs::path>("boost/mpl/set.hpp", "boost/mpl/set"),
+ std::pair<fs::path, fs::path>("boost/mpl/set_c.hpp", "boost/mpl/set"),
+ std::pair<fs::path, fs::path>("boost/mpl/aux_/include_preprocessed.hpp", "boost/mpl/aux_/preprocessed"),
+ std::pair<fs::path, fs::path>("boost/mpl/vector/aux_/include_preprocessed.hpp", "boost/mpl/vector/aux_/preprocessed"),
+ std::pair<fs::path, fs::path>("boost/mpl/set/aux_/include_preprocessed.hpp", "boost/mpl/set/aux_/preprocessed"),
+ 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/test/detail/config.hpp", "libs/predef/build.jam"),
+ std::pair<fs::path, fs::path>("boost/test/detail/config.hpp", "libs/predef/check"),
+ 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"),
+ std::pair<fs::path, fs::path>("libs/coroutine/build/Jamfile.v2", "libs/context/src"),
+ std::pair<fs::path, fs::path>("libs/coroutine/build/Jamfile.v2", "libs/context/build"),
+ std::pair<fs::path, fs::path>("libs/fiber/build/Jamfile.v2", "libs/context/src"),
+ std::pair<fs::path, fs::path>("libs/fiber/build/Jamfile.v2", "libs/context/build"),
+ };
+
+ for(unsigned int n = 0; n < (sizeof(specials)/sizeof(specials[0])); ++n)
+ {
+ 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_pending_path(specials[n].second);
+ }
+ }
+ }
+
+}
+
+void bcp_implementation::add_file_dependencies(const fs::path& p, bool scanfile)
+{
+ static const boost::regex e(
+ "^[[:blank:]]*(?://@bcp[[:blank:]]+([^\\n]*)\n)?#[[:blank:]]*include[[:blank:]]*[\"<]([^\">]+)[\">]"
+ );
+
+ if(!m_dependencies.count(p))
+ m_dependencies[p] = p; // set terminal dependency
+
+ fileview view;
+ if(scanfile)
+ view.open(p);
+ else
+ view.open(m_boost_path / p);
+ if(m_license_mode && !scanfile)
+ scan_license(p, view);
+ const int subs[] = { 1, 2 };
+ boost::regex_token_iterator<const char*> i(view.begin(), view.end(), e, subs);
+ boost::regex_token_iterator<const char*> j;
+ while(i != j)
+ {
+ //
+ // *i contains the name of the include file,
+ // check first for a file of that name in the
+ // same directory as the file we are scanning,
+ // and if that fails, then check the boost-root:
+ //
+ fs::path include_file;
+ try{
+ std::string discart_message = *i;
+ ++i;
+ if(discart_message.size())
+ {
+ // The include is optional and should be discarded:
+ std::cout << "Optional functionality won't be copied: " << discart_message << std::endl;
+ std::cout << "Add the file " << *i << " to the list of dependencies to extract to copy this functionality." << std::endl;
+ ++i;
+ continue;
+ }
+ include_file = i->str();
+ fs::path test_file(m_boost_path / p.branch_path() / include_file);
+ 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_pending_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_pending_path(include_file);
+ }
+ }
+ ++i;
+ }
+ catch(const fs::filesystem_error&)
+ {
+ std::cerr << "Can't parse filename " << *i << " included by file " << p.string() << std::endl;
+ ++i;
+ continue;
+ }
+ }
+ //
+ // Now we need to scan for Boost.Preprocessor includes that
+ // are included via preprocessor iteration:
+ //
+ static const boost::regex ppfiles("^[[:blank:]]*#[[:blank:]]*define[[:blank:]]+(?:BOOST_PP_FILENAME|BOOST_PP_ITERATION_PARAMS|BOOST_PP_INDIRECT_SELF)(?:[^\\n]|\\\\\\n)+?[\"<]([^\">]+)[\">]");
+ i = boost::regex_token_iterator<const char*>(view.begin(), view.end(), ppfiles, 1);
+ while(i != j)
+ {
+ //
+ // *i contains the name of the include file,
+ // check first for a file of that name in the
+ // same directory as the file we are scanning,
+ // and if that fails, then check the boost-root:
+ //
+ fs::path include_file;
+ try{
+ include_file = i->str();
+ }
+ catch(const fs::filesystem_error&)
+ {
+ std::cerr << "Can't parse filename " << *i << " included by file " << p.string() << std::endl;
+ ++i;
+ continue;
+ }
+ fs::path test_file(m_boost_path / p.branch_path() / include_file);
+ 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_pending_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_pending_path(include_file);
+ }
+ }
+ else
+ {
+ std::cerr << "CAUTION: Boost.Preprocessor iterated file " << include_file.string() << " does not exist." << std::endl;
+ }
+ ++i;
+ }
+
+ //
+ // Scan for any #include MACRO includes that we don't recognise.
+ //
+ // Begin by declaring all of the macros that get #included that
+ // 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",
+ "BOOST_PLATFORM_CONFIG",
+ "BOOST_PP_FILENAME_1",
+ "BOOST_PP_ITERATION_PARAMS_1",
+ "BOOST_PP_FILENAME_2",
+ "BOOST_PP_ITERATION_PARAMS_2",
+ "BOOST_PP_FILENAME_3",
+ "BOOST_PP_ITERATION_PARAMS_3",
+ "BOOST_PP_FILENAME_4",
+ "BOOST_PP_ITERATION_PARAMS_4",
+ "BOOST_PP_FILENAME_5",
+ "BOOST_PP_ITERATION_PARAMS_5",
+ "BOOST_PP_INDIRECT_SELF",
+ "BOOST_PP_INCLUDE_SELF()",
+ "BOOST_PP_ITERATE",
+ "BOOST_PP_LOCAL_ITERATE",
+ "BOOST_PP_ITERATE()",
+ "BOOST_PP_LOCAL_ITERATE()",
+ "BOOST_PP_ASSIGN_SLOT(1)",
+ "BOOST_PP_ASSIGN_SLOT(2)",
+ "BOOST_PP_ASSIGN_SLOT(3)",
+ "BOOST_PP_ASSIGN_SLOT(4)",
+ "BOOST_PP_ASSIGN_SLOT(5)",
+ "BOOST_ABI_PREFIX",
+ "BOOST_ABI_SUFFIX",
+ "BOOST_PP_STRINGIZE(boost/mpl/aux_/preprocessed/AUX_PREPROCESSED_HEADER)",
+ "BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_HEADER)",
+ "BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_LIST_C_HEADER)",
+ "BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_LIST_HEADER)",
+ "BOOST_PP_STRINGIZE(boost/mpl/map/aux_/preprocessed/AUX778076_HEADER)",
+ "BOOST_PP_STRINGIZE(boost/mpl/map/AUX778076_MAP_HEADER)",
+ "BOOST_PP_STRINGIZE(boost/mpl/set/aux_/preprocessed/AUX778076_HEADER)",
+ "BOOST_PP_STRINGIZE(boost/mpl/set/AUX778076_SET_HEADER)",
+ "BOOST_PP_STRINGIZE(boost/mpl/set/AUX778076_SET_C_HEADER)",
+ "BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_VECTOR_HEADER)",
+ "BOOST_PP_STRINGIZE(boost/mpl/vector/aux_/preprocessed/AUX778076_HEADER)",
+ "BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_DEQUE_HEADER)",
+ "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()",
+ };
+
+ 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;
+ }
+ ++i;
+ }
+ //
+ // if the file contains a cpp_main / unit_test_main / test_main
+ // it is dependent upon Boost.test even if it doesn't
+ // include any of the Boost.test headers directly.
+ //
+ static const boost::regex m("^\\s*int\\s+(?:cpp_main|test_main|unit_test_main)");
+ boost::cmatch what;
+ if(boost::regex_search(view.begin(), view.end(), what, m))
+ {
+ add_dependent_lib("test", p, view);
+ }
+ if(!scanfile)
+ {
+ //
+ // 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;
+ std::string gs(p.generic_string());
+ if(boost::regex_match(gs, 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).*");
+ gs = p.generic_string();
+ if(boost::regex_match(gs, swhat, lib2))
+ {
+ add_dependent_lib(swhat.str(1), p, view);
+ }
+ }
+ if(m_list_namespaces)
+ {
+ //
+ // 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/src/boost/tools/bcp/bcp.hpp b/src/boost/tools/bcp/bcp.hpp
new file mode 100644
index 000000000..bec63641c
--- /dev/null
+++ b/src/boost/tools/bcp/bcp.hpp
@@ -0,0 +1,47 @@
+/*
+ *
+ * Copyright (c) 2003 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)
+ *
+ */
+
+#include <boost/shared_ptr.hpp>
+
+#if defined(BOOST_FILESYSTEM_VERSION) && (BOOST_FILESYSTEM_VERSION != 3)
+# error "This library must be built with Boost.Filesystem version 3"
+#else
+#define BOOST_FILESYSTEM_VERSION 3
+#endif
+
+class bcp_application;
+typedef boost::shared_ptr<bcp_application> pbcp_application;
+
+class bcp_application
+{
+public:
+ virtual ~bcp_application();
+
+ virtual void enable_list_mode() = 0;
+ virtual void enable_summary_list_mode() = 0;
+ virtual void enable_cvs_mode() = 0;
+ virtual void enable_svn_mode() = 0;
+ virtual void enable_unix_lines() = 0;
+ virtual void enable_scan_mode() = 0;
+ virtual void enable_license_mode() = 0;
+ virtual void enable_bsl_convert_mode() = 0;
+ virtual void enable_bsl_summary_mode() = 0;
+ 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;
+
+ static pbcp_application create();
+};
+
+
diff --git a/src/boost/tools/bcp/bcp_imp.cpp b/src/boost/tools/bcp/bcp_imp.cpp
new file mode 100644
index 000000000..1fe8cf926
--- /dev/null
+++ b/src/boost/tools/bcp/bcp_imp.cpp
@@ -0,0 +1,300 @@
+/*
+ *
+ * Copyright (c) 2003 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 bcp_implementation virtuals.
+ */
+
+#include "bcp_imp.hpp"
+#include "licence_info.hpp"
+#include <boost/filesystem/operations.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <iostream>
+#include <stdexcept>
+#include <boost/regex.hpp>
+#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_namespace_alias(false), m_list_namespaces(false)
+{
+}
+
+bcp_implementation::~bcp_implementation()
+{
+}
+
+bcp_application::~bcp_application()
+{
+}
+
+void bcp_implementation::enable_list_mode()
+{
+ m_list_mode = true;
+}
+
+void bcp_implementation::enable_summary_list_mode()
+{
+ m_list_mode = true;
+ m_list_summary_mode = true;
+}
+
+void bcp_implementation::enable_cvs_mode()
+{
+ m_cvs_mode = true;
+}
+
+void bcp_implementation::enable_svn_mode()
+{
+ m_svn_mode = true;
+}
+
+void bcp_implementation::enable_scan_mode()
+{
+ m_scan_mode = true;
+}
+
+void bcp_implementation::enable_license_mode()
+{
+ m_license_mode = true;
+}
+
+void bcp_implementation::enable_bsl_convert_mode()
+{
+ m_bsl_convert_mode = true;
+}
+
+void bcp_implementation::enable_bsl_summary_mode()
+{
+ m_bsl_summary_mode = true;
+}
+
+void bcp_implementation::enable_unix_lines()
+{
+ m_unix_lines = true;
+}
+
+void bcp_implementation::set_boost_path(const char* p)
+{
+ // Hack to strip trailing slashes from the path
+ m_boost_path = (fs::path(p) / "boost").parent_path();
+ fs::path check = m_boost_path / "boost" / "version.hpp";
+ if(!fs::exists(check))
+ {
+ std::string s = "The Boost path appears to have been incorrectly set: could not find boost/version.hpp in ";
+ s += m_boost_path.string();
+ std::runtime_error e(s);
+ throw e;
+ }
+}
+
+void bcp_implementation::set_destination(const char* p)
+{
+ m_dest_path = fs::path(p);
+}
+
+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":
+ std::string s = p.generic_string();
+ std::string::size_type n = s.find('/');
+ if(n != std::string::npos)
+ {
+ n = s.find('/', n+1);
+ if(n != std::string::npos)
+ s.erase(n);
+ }
+ return s;
+}
+
+int bcp_implementation::run()
+{
+ //
+ // check output path is OK:
+ //
+ if(!m_list_mode && !m_license_mode && !fs::exists(m_dest_path))
+ {
+ std::string msg("Destination path does not exist: ");
+ msg.append(m_dest_path.string());
+ std::runtime_error e(msg);
+ boost::throw_exception(e);
+ }
+ //
+ // Check Boost path is OK if it hasn't been checked already:
+ //
+ if(m_boost_path == "")
+ {
+ set_boost_path("");
+ }
+ // start by building a list of permitted files
+ // if m_cvs_mode is true:
+ if(m_cvs_mode)
+ {
+ std::cerr << "CAUTION: Boost is no longer in CVS, cvs mode may not work anymore!!!" << std::endl;
+ scan_cvs_path(fs::path());
+ }
+ if(m_svn_mode)
+ {
+ scan_svn_path(fs::path());
+ }
+ //
+ // if in license mode, try to load more/blanket_permission.txt
+ //
+ fs::path blanket_permission(m_boost_path / "more" / "blanket-permission.txt");
+ if (fs::exists(blanket_permission)) {
+ fs::ifstream in(blanket_permission);
+ std::string line;
+ while (std::getline(in, line)) {
+ static const boost::regex e("([^(]+)\\(");
+ boost::smatch result;
+ if (boost::regex_search(line, result, e))
+ m_bsl_authors.insert(format_authors_name(result[1]));
+ }
+ }
+
+ //
+ // scan through modules looking for the equivalent
+ // file to add to our list:
+ //
+ std::list<std::string>::const_iterator i = m_module_list.begin();
+ std::list<std::string>::const_iterator j = m_module_list.end();
+ while(i != j)
+ {
+ //
+ // convert *i to a path - could be native or portable:
+ //
+ fs::path module;
+ fs::path exmodule;
+ module = fs::path(*i);
+ exmodule = fs::path(*i + ".hpp");
+
+ if(m_scan_mode)
+ {
+ // in scan mode each module must be a real file:
+ add_file_dependencies(module, true);
+ }
+ else
+ {
+ int count = 0;
+ if(fs::exists(m_boost_path / "tools" / module))
+ {
+ add_path(fs::path("tools") / module);
+ ++count;
+ }
+ if(fs::exists(m_boost_path / "libs" / module))
+ {
+ add_path(fs::path("libs") / module);
+ ++count;
+ }
+ if(fs::exists(m_boost_path / "boost" / module))
+ {
+ add_path(fs::path("boost") / module);
+ ++count;
+ }
+ if(fs::exists(m_boost_path / "boost" / exmodule))
+ {
+ add_path(fs::path("boost") / exmodule);
+ ++count;
+ }
+ if(fs::exists(m_boost_path / module))
+ {
+ add_path(module);
+ ++count;
+ }
+ }
+ ++i;
+ }
+ while (!m_pending_paths.empty())
+ {
+ add_path(m_pending_paths.front());
+ m_pending_paths.pop();
+ }
+ //
+ // 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.generic_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.generic_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();
+ n = m_copy_paths.end();
+ if(!m_license_mode)
+ {
+ while(m != n)
+ {
+ if(m_list_summary_mode)
+ {
+ fs::path p = get_short_path(*m);
+ if(short_paths.find(p) == short_paths.end())
+ {
+ short_paths.insert(p);
+ std::cout << p.string() << "\n";
+ }
+ }
+ else if(m_list_mode)
+ std::cout << m->string() << "\n";
+ else
+ copy_path(*m);
+ ++m;
+ }
+ }
+ else
+ output_license_info();
+ return 0;
+}
+
+pbcp_application bcp_application::create()
+{
+ pbcp_application result(static_cast<bcp_application*>(new bcp_implementation()));
+ return result;
+}
diff --git a/src/boost/tools/bcp/bcp_imp.hpp b/src/boost/tools/bcp/bcp_imp.hpp
new file mode 100644
index 000000000..ffe407237
--- /dev/null
+++ b/src/boost/tools/bcp/bcp_imp.hpp
@@ -0,0 +1,121 @@
+/*
+ *
+ * Copyright (c) 2003 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)
+ *
+ */
+
+#include "bcp.hpp"
+#include <string>
+#include <cstring>
+#include <list>
+#include <set>
+#include <map>
+#include <queue>
+#include <boost/filesystem/path.hpp>
+
+namespace fs = boost::filesystem;
+
+class fileview;
+
+//
+//path operations:
+//
+int compare_paths(const fs::path& a, const fs::path& b);
+inline bool equal_paths(const fs::path& a, const fs::path& b)
+{ return compare_paths(a, b) == 0; }
+
+struct path_less
+{
+ bool operator()(const fs::path& a, const fs::path& b)const
+ { return compare_paths(a, b) < 0; }
+};
+
+struct license_data
+{
+ std::set<fs::path, path_less> files;
+ std::set<std::string> authors;
+};
+
+class bcp_implementation
+ : public bcp_application
+{
+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:
+ //
+ void enable_list_mode();
+ void enable_summary_list_mode();
+ void enable_cvs_mode();
+ void enable_svn_mode();
+ void enable_unix_lines();
+ void enable_scan_mode();
+ void enable_license_mode();
+ void enable_bsl_convert_mode();
+ void enable_bsl_summary_mode();
+ 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();
+
+ // 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);
+ void add_pending_path(const fs::path& p) { m_pending_paths.push(p); }
+ void add_directory(const fs::path& p);
+ void add_file(const fs::path& p);
+ void copy_path(const fs::path& p);
+ void add_file_dependencies(const fs::path& p, bool scanfile);
+ 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);
+ void output_license_info();
+
+ std::list<std::string> m_module_list; // the modules to process
+ bool m_list_mode; // list files only
+ bool m_list_summary_mode; // list file summary only
+ bool m_license_mode; // generate license information for files listed
+ bool m_cvs_mode; // check cvs for files
+ bool m_svn_mode; // check svn for files
+ bool m_unix_lines; // fix line endings
+ 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::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
+ std::queue<fs::path, std::list<fs::path> > m_pending_paths; // Queue of paths we haven't scanned yet.
+};
+
diff --git a/src/boost/tools/bcp/copy_path.cpp b/src/boost/tools/bcp/copy_path.cpp
new file mode 100644
index 000000000..4143c79e6
--- /dev/null
+++ b/src/boost/tools/bcp/copy_path.cpp
@@ -0,0 +1,248 @@
+/*
+ *
+ * Copyright (c) 2003 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::copy_path(const fs::path& p)
+ * void bcp_implementation::create_path(const fs::path& p)
+ */
+
+#include "bcp_imp.hpp"
+#include "fileview.hpp"
+#include <boost/filesystem/operations.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/regex.hpp>
+#include <boost/assert.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)
+{
+ BOOST_ASSERT(!fs::is_directory(m_boost_path / p));
+ if(fs::exists(m_dest_path / p))
+ {
+ std::cout << "Copying (and overwriting) file: " << p.string() << "\n";
+ fs::remove(m_dest_path / p);
+ }
+ else
+ std::cout << "Copying file: " << p.string() << "\n";
+ //
+ // create the path to the new file if it doesn't already exist:
+ //
+ create_path(p.branch_path());
+ //
+ // do text based copy if requested:
+ //
+ if((p.leaf() == "Jamroot") && m_namespace_name.size())
+ {
+ static std::vector<char> v1, v2;
+ v1.clear();
+ v2.clear();
+ boost::filesystem::ifstream is((m_boost_path / p));
+ std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1));
+
+ static boost::regex libname_matcher;
+ if(libname_matcher.empty())
+ {
+ libname_matcher.assign("boost_");
+ }
+
+ regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), libname_matcher, m_namespace_name + "_");
+ std::swap(v1, v2);
+ v2.clear();
+
+ boost::filesystem::ofstream os;
+ if(m_unix_lines)
+ os.open((m_dest_path / p), std::ios_base::binary | std::ios_base::out);
+ else
+ os.open((m_dest_path / p), std::ios_base::out);
+ os.write(&*v1.begin(), v1.size());
+ os.close();
+ }
+ else if(m_namespace_name.size() && m_lib_names.size() && is_jam_file(p))
+ {
+ static std::vector<char> v1, v2;
+ v1.clear();
+ v2.clear();
+ boost::filesystem::ifstream is((m_boost_path / p));
+ 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();
+
+ boost::filesystem::ofstream os;
+ if(m_unix_lines)
+ os.open((m_dest_path / p), std::ios_base::binary | std::ios_base::out);
+ else
+ os.open((m_dest_path / p), 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();
+ boost::filesystem::ifstream is((m_boost_path / p));
+ 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+)?(?:(\\s*::\\s*)phoenix)?"
+ "|"
+ "(namespace\\s+(?:detail::)?)(adstl|phoenix|rapidxml)\\>"
+ "|"
+ "()\\<boost((?:_(?!intrusive_tags)\\w+)?\\s*(?:::))(?:(\\s*)phoenix)?"
+ "|"
+ "()\\<((?:adstl|phoenix|rapidxml)\\s*(?:::))"
+ "|"
+ "(namespace\\s+\\w+\\s*=\\s*(?:::\\s*)?)boost(_\\w+)?(?:(\\s*::\\s*)phoenix)?"
+ "|"
+ "(namespace\\s+\\w+\\s*=\\s*(?:::\\s*)?(?:\\w+\\s*::\\s*)?)(adstl|phoenix|rapidxml)\\>"
+ "|"
+ "(^\\s*#\\s*define\\s+\\w+\\s+)boost((?:_\\w+)?\\s*)$"
+ "|"
+ "(^\\s*#\\s*define[^\\n]+)((?:adstl|phoenix|rapidxml)\\s*)$"
+ "|"
+ "()boost(_asio_detail_posix_thread_function|_regex_free_static_mutex)"
+ "|"
+ "()\\<(lw_thread_routine|at_thread_exit|on_process_enter|on_process_exit|on_thread_enter|on_thread_exit|tss_cleanup_implemented)\\>"
+ "|"
+ "(BOOST_CLASS_REQUIRE4?[^;]*)boost((?:_\\w+)?\\s*,)"
+ "|"
+ "(::tr1::|TR1_DECL\\s+)boost(_\\w+\\s*)" // math tr1
+ "|"
+ "(\\(\\s*)boost(\\s*\\))\\s*(\\(\\s*)phoenix(\\s*\\))"
+ "|"
+ "(\\(\\s*)boost(\\s*\\))"
+ "|"
+ "(BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE[^\\)]*)boost(\\))"
+ ")"
+ );
+
+ regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), namespace_matcher, "$1" + m_namespace_name + "$2(?3$3" + m_namespace_name + "phoenix?4$4)", boost::regex_constants::format_all);
+ 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 + ")"
+ "(adstl|phoenix|rapidxml)?(\\s*\\{)"
+ );
+ regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), namespace_alias,
+ "$1 $3$4 {} $1 (?4$4:boost) = $3$4; $1$2$3$4$5", boost::regex_constants::format_all);
+ std::swap(v1, v2);
+ v2.clear();
+ }
+
+ boost::filesystem::ofstream os;
+ if(m_unix_lines)
+ os.open((m_dest_path / p), std::ios_base::binary | std::ios_base::out);
+ else
+ os.open((m_dest_path / p), std::ios_base::out);
+ if(v1.size())
+ os.write(&*v1.begin(), v1.size());
+ os.close();
+ }
+ else if(m_unix_lines && !is_binary_file(p))
+ {
+ boost::filesystem::ifstream is((m_boost_path / p));
+ std::istreambuf_iterator<char> isi(is);
+ std::istreambuf_iterator<char> end;
+
+ boost::filesystem::ofstream os((m_dest_path / p), std::ios_base::binary | std::ios_base::out);
+ std::ostreambuf_iterator<char> osi(os);
+
+ std::copy(isi, end, osi);
+ }
+ else
+ {
+ // binary copy:
+ fs::copy_file(m_boost_path / p, m_dest_path / p);
+ }
+}
+
+void bcp_implementation::create_path(const fs::path& p)
+{
+ if(!fs::exists(m_dest_path / p))
+ {
+ // recurse then create the path:
+ create_path(p.branch_path());
+ fs::create_directory(m_dest_path / p);
+ }
+}
+
+
diff --git a/src/boost/tools/bcp/file_types.cpp b/src/boost/tools/bcp/file_types.cpp
new file mode 100644
index 000000000..297d304cf
--- /dev/null
+++ b/src/boost/tools/bcp/file_types.cpp
@@ -0,0 +1,72 @@
+/*
+ *
+ * Copyright (c) 2003 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::is_source_file(const fs::path& p)
+ * void bcp_implementation::is_html_file(const fs::path& p)
+ * void bcp_implementation::is_binary_file(const fs::path& p)
+ */
+
+#include "bcp_imp.hpp"
+#include <boost/regex.hpp>
+
+bool bcp_implementation::is_source_file(const fs::path& p)
+{
+ static const boost::regex e(
+ ".*\\."
+ "(?:"
+ "c|cxx|h|hxx|inc|inl|.?pp|yy?"
+ ")",
+ boost::regex::perl | boost::regex::icase
+ );
+ return boost::regex_match(p.filename().generic_string(), e);
+}
+
+bool bcp_implementation::is_html_file(const fs::path& p)
+{
+ static const boost::regex e(
+ ".*\\."
+ "(?:"
+ "html?|css"
+ ")"
+ );
+ return boost::regex_match(p.filename().generic_string(), e);
+}
+
+bool bcp_implementation::is_binary_file(const fs::path& p)
+{
+ if(m_cvs_mode || m_svn_mode)
+ {
+ std::map<fs::path, bool, path_less>::iterator pos = m_cvs_paths.find(p);
+ if(pos != m_cvs_paths.end()) return pos->second;
+ }
+ static const boost::regex e(
+ ".*\\."
+ "(?:"
+ "c|cxx|cpp|h|hxx|hpp|inc|html?|css|mak|in"
+ ")"
+ "|"
+ "(Jamfile|makefile|configure)",
+ boost::regex::perl | boost::regex::icase);
+ return !boost::regex_match(p.leaf().generic_string(), 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().generic_string(), e);
+}
+
diff --git a/src/boost/tools/bcp/fileview.cpp b/src/boost/tools/bcp/fileview.cpp
new file mode 100644
index 000000000..36e785062
--- /dev/null
+++ b/src/boost/tools/bcp/fileview.cpp
@@ -0,0 +1,143 @@
+/*
+ *
+ * Copyright (c) 2003 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 fileview class
+ */
+
+#include "fileview.hpp"
+#include <boost/filesystem/fstream.hpp>
+#include <vector>
+#include <algorithm>
+#include <string>
+#include <fstream>
+#include <istream>
+#include <stdexcept>
+
+struct fileview::implementation
+{
+ std::vector<char> m_data;
+};
+
+
+// construct:
+fileview::fileview()
+{
+ pimpl.reset(new implementation());
+}
+
+fileview::fileview(const boost::filesystem::path& p)
+{
+ pimpl.reset(new implementation());
+ open(p);
+}
+
+fileview::~fileview()
+{
+}
+
+fileview::fileview(const fileview& )
+{
+}
+
+fileview& fileview::operator=(const fileview& that)
+{
+ pimpl = that.pimpl;
+ return *this;
+}
+
+void fileview::close()
+{
+ cow();
+ pimpl->m_data.clear();
+}
+
+void fileview::open(const boost::filesystem::path& p)
+{
+ cow();
+ boost::filesystem::ifstream is(p);
+ if(!is)
+ {
+ std::string msg("Bad file name: ");
+ msg += p.string();
+ std::runtime_error e(msg);
+ boost::throw_exception(e);
+ }
+ std::istreambuf_iterator<char> in(is);
+ std::istreambuf_iterator<char> end;
+ std::copy(in, end, std::back_inserter(pimpl->m_data));
+}
+
+// iterators:
+fileview::const_iterator fileview::begin() const
+{
+ return pimpl->m_data.size() ? &(pimpl->m_data[0]) : 0;
+}
+
+fileview::const_iterator fileview::end() const
+{
+ return begin() + pimpl->m_data.size();
+}
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+fileview::const_reverse_iterator fileview::rbegin() const
+{
+ return const_reverse_iterator(end());
+}
+
+fileview::const_reverse_iterator fileview::rend() const
+{
+ return const_reverse_iterator(begin());
+}
+#endif
+
+// capacity:
+fileview::size_type fileview::size() const
+{
+ return pimpl->m_data.size();
+}
+
+fileview::size_type fileview::max_size() const
+{
+ return pimpl->m_data.max_size();
+}
+
+bool fileview::empty() const
+{
+ return pimpl->m_data.empty();
+}
+
+// element access:
+fileview::const_reference fileview::operator[](fileview::size_type n) const
+{
+ return pimpl->m_data[n];
+}
+
+fileview::const_reference fileview::at(size_type n) const
+{
+ return pimpl->m_data.at(n);
+}
+
+fileview::const_reference fileview::front() const
+{
+ return pimpl->m_data.front();
+}
+
+fileview::const_reference fileview::back() const
+{
+ return pimpl->m_data.back();
+}
+
+void fileview::swap(fileview& that)
+{
+ pimpl.swap(that.pimpl);
+}
+
+void fileview::cow()
+{
+ if(!pimpl.unique())
+ pimpl.reset(new implementation(*pimpl));
+}
diff --git a/src/boost/tools/bcp/fileview.hpp b/src/boost/tools/bcp/fileview.hpp
new file mode 100644
index 000000000..fe76f84ea
--- /dev/null
+++ b/src/boost/tools/bcp/fileview.hpp
@@ -0,0 +1,72 @@
+/*
+ *
+ * Copyright (c) 2003 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)
+ *
+ */
+
+#if defined(BOOST_FILESYSTEM_VERSION) && (BOOST_FILESYSTEM_VERSION != 3)
+# error "This library must be built with Boost.Filesystem version 3"
+#else
+#define BOOST_FILESYSTEM_VERSION 3
+#endif
+
+#include <boost/shared_ptr.hpp>
+#include <boost/filesystem/path.hpp>
+
+class fileview
+{
+public:
+ // types:
+ typedef const char& reference;
+ typedef reference const_reference;
+ typedef const char* iterator; // See _lib.container.requirements_
+ typedef iterator const_iterator; // See _lib.container.requirements_
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef char value_type;
+ typedef const char* pointer;
+ typedef pointer const_pointer;
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+#endif
+
+ // construct:
+ fileview();
+ fileview(const boost::filesystem::path& p);
+ ~fileview();
+ fileview(const fileview& that);
+ fileview& operator=(const fileview& that);
+ void close();
+ void open(const boost::filesystem::path& p);
+
+ // iterators:
+ const_iterator begin() const;
+ const_iterator end() const;
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ const_reverse_iterator rbegin() const;
+ const_reverse_iterator rend() const;
+#endif
+
+ // capacity:
+ size_type size() const;
+ size_type max_size() const;
+ bool empty() const;
+
+ // element access:
+ const_reference operator[](size_type n) const;
+ const_reference at(size_type n) const;
+ const_reference front() const;
+ const_reference back() const;
+ void swap(fileview& that);
+
+private:
+ void cow();
+ struct implementation;
+ boost::shared_ptr<implementation> pimpl;
+};
+
+
diff --git a/src/boost/tools/bcp/index.html b/src/boost/tools/bcp/index.html
new file mode 100644
index 000000000..34e938c60
--- /dev/null
+++ b/src/boost/tools/bcp/index.html
@@ -0,0 +1,17 @@
+<html>
+ <head>
+ <meta http-equiv="refresh" content="0; URL=doc/html/index.html">
+ </head>
+ <body>
+ <p>
+ Automatic redirection failed, please go to <a href="doc/html/index.html">doc/html/index.html</a>.
+ </p>
+ <p>Copyright&nbsp;John Maddock 2007</p>
+ <p>Distributed under the Boost Software License, Version 1.0. (See accompanying file <a href="../../LICENSE_1_0.txt">
+ LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>).</p>
+ </body>
+</html>
+
+
+
+
diff --git a/src/boost/tools/bcp/licence_info.cpp b/src/boost/tools/bcp/licence_info.cpp
new file mode 100644
index 000000000..0e527fa48
--- /dev/null
+++ b/src/boost/tools/bcp/licence_info.cpp
@@ -0,0 +1,721 @@
+/*
+ *
+ * Copyright (c) 2003 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)
+ *
+ * boostinspect:noascii
+ */
+
+#include "licence_info.hpp"
+
+
+std::pair<const license_info*, int> get_licenses()
+{
+ static const char* generic_author_sig =
+ "(?:"
+ "(?:"
+ "Copyright|\\(c\\)|\xA9"
+ ")[[:blank:]]+"
+ "){1,2}"
+ "(?:"
+ "\\d[^[:alpha:]]+"
+ "([[:alpha:]]"
+ "(?:"
+ "(?!Use\\b|Permission\\b|All\\b|<P|(?:-\\s*)\\w+(?:://|@)|\\\\"
+ ")[^\\n\\d]"
+ ")+"
+ ")"
+ "|"
+ "([[:alpha:]][^\\n\\d]+"
+ "(?:\\n[^\\n\\d]+"
+ ")??"
+ ")(?:19|20)\\d{2}"
+ ")"
+ "|"
+ "Authors:[[:blank:]]+"
+ "([[:alpha:]][^\\n\\d]+"
+ "|"
+ "((?:The|This) code is considered to be in the public domain)"
+ ")";
+
+ static const char* generic_author_format =
+ "(?1$1)(?2$2)(?3$3)(?4Public Domain)";
+
+ static const license_info licenses[] =
+ {
+ license_info( boost::regex("distributed\\W+under"
+ "(\\W+the)?[^\"[:word:]]+Boost\\W+Software\\W+License\\W+Version\\W+1.0", boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Boost Software License, Version 1.0"
+ ,
+ "<P>Copyright (c) <I>Date</I> <I>Author</I></P>"
+ "<P>Distributed under the "
+ "Boost Software License, Version 1.0. (See accompanying file "
+ "LICENSE_1_0.txt or copy at <a href=\"http://www.boost.org/LICENSE_1_0.txt\">http://www.boost.org/LICENSE_1_0.txt)</a></P>"
+ )
+ ,
+ license_info( boost::regex("Use\\W+\\modification\\W+and\\W+distribution(\\W+is|\\W+are)\\W+subject\\W+to"
+ "(\\W+the)?[^\"[:word:]]+Boost\\W+Software\\W+License\\W+Version\\W+1.0", boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Boost Software License, Version 1.0 (variant #1)"
+ ,
+ "<P>Copyright (c) <I>Date</I> <I>Author</I></P>"
+ "<P>Use, modification and distribution is subject to the "
+ "Boost Software License, Version 1.0. (See accompanying file "
+ "LICENSE_1_0.txt or copy at <a href=\"http://www.boost.org/LICENSE_1_0.txt\">http://www.boost.org/LICENSE_1_0.txt)</a></P>"
+ )
+ ,
+ license_info( boost::regex("(?!is)\\w\\w\\W+subject\\W+to"
+ "(\\W+the)?[^\"[:word:]]+Boost\\W+Software\\W+License\\W+Version\\W+1.0", boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Boost Software License, Version 1.0 (variant #2)"
+ ,
+ "<P>Copyright (c) <I>Date</I> <I>Author</I></P>"
+ "<P>Subject to the "
+ "Boost Software License, Version 1.0. (See accompanying file "
+ "LICENSE_1_0.txt or copy at <a href=\"http://www.boost.org/LICENSE_1_0.txt\">http://www.boost.org/LICENSE_1_0.txt)</a></P>"
+ )
+ ,
+ license_info( boost::regex("Copyright\\W+(c)\\W+2001\\W+2002\\W+Python\\W+Software\\W+Foundation\\W+All\\W+Rights\\W+Reserved", boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Python Software License"
+ ,
+ "<p>Copyright (c) 2001, 2002 Python Software Foundation;</p>"
+ "<P>All Rights Reserved</P>"
+ )
+ ,
+ license_info( boost::regex("Permission\\W+to\\W+use\\W+copy\\W+modify\\W+distribute\\W+and\\W+sell\\W+this\\W+software\\W+and\\W+its\\W+documentation"
+ "\\W+for\\W+any\\W+purpose\\W+is\\W+hereby\\W+granted\\W+without\\W+fee"
+ "\\W+provided\\W+that\\W+the\\W+above\\W+copyright\\W+notice\\W+appears?\\W+in\\W+all\\W+copies\\W+and"
+ "\\W+that\\W+both\\W+(the|that)\\W+copyright\\W+notice\\W+and\\W+this\\W+permission\\W+notice\\W+appears?"
+ "\\W+in\\W+supporting\\W+documentation[^<>]{1, 100}\\W+no\\W+representations"
+ "\\W+(are\\W+made\\W+)?about\\W+the\\W+suitability\\W+of\\W+this\\W+software\\W+for\\W+any\\W+purpose"
+ "\\W+It\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or\\W+implied\\W+warranty"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "SGI Style License"
+ ,
+ "<P>Copyright (c) <I>Date</I><BR>"
+ "<I>Author</I><BR>"
+ "<BR>"
+ "Permission to use, copy, modify, distribute and sell this software "
+ "and its documentation for any purpose is hereby granted without fee, "
+ "provided that the above copyright notice appear in all copies and "
+ "that both that copyright notice and this permission notice appear "
+ "in supporting documentation. <I>Author</I> makes no representations "
+ "about the suitability of this software for any purpose. "
+ "It is provided \"as is\" without express or implied warranty.</P>"
+ )
+ ,
+ license_info( boost::regex("Permission\\W+to\\W+use\\W+copy\\W+modify\\W+distribute\\W+and\\W+sell\\W+this\\W+software"
+ "\\W+for\\W+any\\W+purpose\\W+is\\W+hereby\\W+granted\\W+without\\W+fee"
+ "\\W+provided\\W+that\\W+the\\W+above\\W+copyright\\W+notice\\W+appears?\\W+in\\W+all\\W+copies\\W+and"
+ "\\W+that\\W+both\\W+(the|that)\\W+copyright\\W+notice\\W+and\\W+this\\W+permission\\W+notice\\W+appears?"
+ "\\W+in\\W+supporting\\W+documentation[^<>]{1, 100}\\W+no\\W+representations"
+ "\\W+(are\\W+made\\W+)?about\\W+the\\W+suitability\\W+of\\W+this\\W+software\\W+for\\W+any\\W+purpose"
+ "\\W+It\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express(ed)?\\W+or\\W+implied\\W+warranty", boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #1"
+ ,
+ "<P>Copyright (c) <I>Date</I><BR>"
+ "<I>Author</I><BR>"
+ "<BR>"
+ "Permission to use, copy, modify, distribute and sell this software "
+ "for any purpose is hereby granted without fee, "
+ "provided that the above copyright notice appear in all copies and "
+ "that both that copyright notice and this permission notice appears? "
+ "in supporting documentation. <I>Author</I> makes no representations "
+ "about the suitability of this software for any purpose. "
+ "It is provided \"as is\" without express or implied warranty.</P>"
+ )
+ ,
+ license_info(
+ boost::regex(
+ "Permission\\W+to\\W+copy\\W+use\\W+modify\\W+sell\\W+and\\W+distribute\\W+this\\W+software"
+ "\\W+is\\W+granted\\W+provided\\W+this\\W+copyright\\W+notice\\W+appears\\W+in\\W+all\\W+copies"
+ "\\W+This\\W+software\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or\\W+implied"
+ "\\W+warranty\\W+and\\W+with\\W+no\\W+claim\\W+as\\W+to\\W+its\\W+suitability\\W+for\\W+any\\W+purpose"
+ , boost::regex::perl | boost::regex::icase
+ )
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #2"
+ ,
+ "<P>Copyright (c) <I>Date</I> <I>Author</I>.<BR><BR>\n"
+ "Permission to copy, use, modify, sell and distribute this software<BR>\n"
+ "is granted provided this copyright notice appears in all copies.<BR>\n"
+ "This software is provided \"as is\" without express or implied<BR>\n"
+ "warranty, and with no claim as to its suitability for any purpose.</P>\n"
+ )
+ ,
+ license_info(
+ boost::regex(
+ "Permission\\W+to\\W+copy\\W+use[^\"[:word:]]+modify\\W+sell\\W+and\\W+distribute\\W+this\\W+software\\W+is\\W+granted\\W+provided"
+ "\\W+this\\W+copyright\\W+notice\\W+appears\\W+in\\W+all\\W+copies\\W+This\\W+software\\W+is"
+ "\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or\\W+implied\\W+warranty\\W+and\\W+with"
+ "\\W+no\\W+claim\\W+at\\W+to\\W+its\\W+suitability\\W+for\\W+any\\W+purpose"
+ , boost::regex::perl | boost::regex::icase
+ )
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #3"
+ ,
+ "<P>(C) Copyright <I>Author</I> <I>Date</I>. Permission to copy, use, "
+ "modify, sell, and distribute this software is granted provided "
+ "this copyright notice appears in all copies. This software is "
+ "provided \"as is\" without express or implied warranty, and with "
+ "no claim at to its suitability for any purpose.</p>\n"
+ )
+ ,
+ license_info( boost::regex("Permission\\W+to\\W+copy\\W+use\\W+sell\\W+and\\W+distribute\\W+this\\W+software\\W+is\\W+granted"
+ "\\W+provided\\W+this\\W+copyright\\W+notice\\W+appears\\W+in\\W+all\\W+copies"
+ "\\W+Permission\\W+to\\W+modify\\W+the\\W+code\\W+and\\W+to\\W+distribute\\W+modified\\W+code\\W+is\\W+granted"
+ "\\W+provided\\W+this\\W+copyright\\W+notice\\W+appears\\W+in\\W+all\\W+copies\\W+and\\W+a\\W+notice"
+ "\\W+that\\W+the\\W+code\\W+was\\W+modified\\W+is\\W+included\\W+with\\W+the\\W+copyright\\W+notice"
+ "\\W+This\\W+software\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or\\W+implied\\W+warranty\\W+and\\W+with\\W+no\\W+claim\\W+as\\W+to\\W+its\\W+suitability\\W+for\\W+any\\W+purpose"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #4"
+ ,
+ "<P>Copyright (C) <I>Date Author</I><BR>"
+ "<BR>"
+ "Permission to copy, use, sell and distribute this software is granted\n"
+ "provided this copyright notice appears in all copies.\n"
+ "Permission to modify the code and to distribute modified code is granted\n"
+ "provided this copyright notice appears in all copies, and a notice\n"
+ "that the code was modified is included with the copyright notice.</P>\n"
+ "<P>This software is provided \"as is\" without express or implied warranty,\n"
+ "and with no claim as to its suitability for any purpose.</P>"
+ )
+ ,
+ license_info( boost::regex("This\\W+file\\W+is\\W+part\\W+of\\W+the\\W+(Boost\\W+Graph|Generic\\W+Graph\\W+Component)\\W+Library"
+ "\\W+You\\W+should\\W+have\\W+received\\W+a\\W+copy\\W+of\\W+the\\W+License\\W+Agreement\\W+for\\W+the"
+ "\\W+(Boost|Generic)\\W+Graph\\W+(Component\\W+)?Library\\W+along\\W+with\\W+the\\W+software;\\W+see\\W+the\\W+file\\W+LICENSE"
+ "(\\W+If\\W+not\\W+contact\\W+Office\\W+of\\W+Research\\W+University\\W+of\\W+Notre\\W+Dame\\W+Notre"
+ "\\W+Dame\\W+IN\\W+46556)?"
+ "\\W+Permission\\W+to\\W+modify\\W+the\\W+code\\W+and\\W+to\\W+distribute(\\W+modified|\\W+the)\\W+code\\W+is"
+ "\\W+granted\\W+provided\\W+the\\W+text\\W+of\\W+this\\W+NOTICE\\W+is\\W+retained\\W+a\\W+notice\\W+(that|if)"
+ "\\W+the\\W+code\\W+was\\W+modified\\W+is\\W+included\\W+with\\W+the\\W+above\\W+COPYRIGHT\\W+NOTICE\\W+and"
+ "\\W+with\\W+the\\W+COPYRIGHT\\W+NOTICE\\W+in\\W+the\\W+LICENSE\\W+file\\W+and\\W+that\\W+the\\W+LICENSE"
+ "\\W+file\\W+is\\W+distributed\\W+with\\W+the\\W+modified\\W+code\\W+"
+ "\\W+LICENSOR\\W+MAKES\\W+NO\\W+REPRESENTATIONS\\W+OR\\W+WARRANTIES\\W+EXPRESS\\W+OR\\W+IMPLIED"
+ "\\W+By\\W+way\\W+of\\W+example\\W+but\\W+not\\W+limitation\\W+Licensor\\W+MAKES\\W+NO"
+ "\\W+REPRESENTATIONS\\W+OR\\W+WARRANTIES\\W+OF\\W+MERCHANTABILITY\\W+OR\\W+FITNESS\\W+FOR\\W+ANY"
+ "\\W+PARTICULAR\\W+PURPOSE\\W+OR\\W+THAT\\W+THE\\W+USE\\W+OF\\W+THE\\W+LICENSED\\W+SOFTWARE\\W+COMPONENTS"
+ "\\W+OR\\W+DOCUMENTATION\\W+WILL\\W+NOT\\W+INFRINGE\\W+ANY\\W+PATENTS\\W+COPYRIGHTS\\W+TRADEMARKS"
+ "\\W+OR\\W+OTHER\\W+RIGHTS"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Boost.Graph license (Notre Dame)"
+ ,
+ "<P>Copyright <I>Date</I> University of Notre Dame.<BR>"
+ "Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek</P>"
+ "<P>This file is part of the Boost Graph Library</P>"
+ "<P>You should have received a copy of the <A href=\"http://www.boost.org/libs/graph/LICENCE\">License Agreement</a> for the "
+ "Boost Graph Library along with the software; see the file <A href=\"http://www.boost.org/libs/graph/LICENCE\">LICENSE</a>. "
+ "If not, contact Office of Research, University of Notre Dame, Notre "
+ "Dame, IN 46556.</P>"
+ "<P>Permission to modify the code and to distribute modified code is "
+ "granted, provided the text of this NOTICE is retained, a notice that "
+ "the code was modified is included with the above COPYRIGHT NOTICE and "
+ "with the COPYRIGHT NOTICE in the <A href=\"http://www.boost.org/libs/graph/LICENCE\">LICENSE</a> file, and that the <A href=\"http://www.boost.org/libs/graph/LICENCE\">LICENSE</a> "
+ "file is distributed with the modified code.</P>"
+ "<P>LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.<BR> "
+ "By way of example, but not limitation, Licensor MAKES NO "
+ "REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY "
+ "PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS "
+ "OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS "
+ "OR OTHER RIGHTS.</P>"
+ )
+ ,
+ license_info( boost::regex("This\\W+file\\W+is\\W+part\\W+of\\W+the\\W+(Boost\\W+Graph|Generic\\W+Graph\\W+Component)\\W+Library"
+ "\\W+You\\W+should\\W+have\\W+received\\W+a\\W+copy\\W+of\\W+the\\W+License\\W+Agreement\\W+for\\W+the"
+ "\\W+(Boost|Generic)\\W+Graph\\W+(Component\\W+)?Library\\W+along\\W+with\\W+the\\W+software;\\W+see\\W+the\\W+file\\W+LICENSE"
+ "(\\W+If\\W+not\\W+contact\\W+Office\\W+of\\W+Research\\W+Indiana\\W+University\\W+Bloomington\\W+IN\\W+47405)?"
+ "\\W+Permission\\W+to\\W+modify\\W+the\\W+code\\W+and\\W+to\\W+distribute(\\W+modified|\\W+the)\\W+code\\W+is"
+ "\\W+granted\\W+provided\\W+the\\W+text\\W+of\\W+this\\W+NOTICE\\W+is\\W+retained\\W+a\\W+notice\\W+(that|if)"
+ "\\W+the\\W+code\\W+was\\W+modified\\W+is\\W+included\\W+with\\W+the\\W+above\\W+COPYRIGHT\\W+NOTICE\\W+and"
+ "\\W+with\\W+the\\W+COPYRIGHT\\W+NOTICE\\W+in\\W+the\\W+LICENSE\\W+file\\W+and\\W+that\\W+the\\W+LICENSE"
+ "\\W+file\\W+is\\W+distributed\\W+with\\W+the\\W+modified\\W+code\\W+"
+ "\\W+LICENSOR\\W+MAKES\\W+NO\\W+REPRESENTATIONS\\W+OR\\W+WARRANTIES\\W+EXPRESS\\W+OR\\W+IMPLIED"
+ "\\W+By\\W+way\\W+of\\W+example\\W+but\\W+not\\W+limitation\\W+Licensor\\W+MAKES\\W+NO"
+ "\\W+REPRESENTATIONS\\W+OR\\W+WARRANTIES\\W+OF\\W+MERCHANTABILITY\\W+OR\\W+FITNESS\\W+FOR\\W+ANY"
+ "\\W+PARTICULAR\\W+PURPOSE\\W+OR\\W+THAT\\W+THE\\W+USE\\W+OF\\W+THE\\W+LICENSED\\W+SOFTWARE\\W+COMPONENTS"
+ "\\W+OR\\W+DOCUMENTATION\\W+WILL\\W+NOT\\W+INFRINGE\\W+ANY\\W+PATENTS\\W+COPYRIGHTS\\W+TRADEMARKS"
+ "\\W+OR\\W+OTHER\\W+RIGHTS"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Boost.Graph license (Indiana University)"
+ ,
+ "<P>Copyright <I>Date</I> Indiana University.<BR>"
+ "Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek</P>"
+ "<P>This file is part of the Boost Graph Library</P>"
+ "<P>You should have received a copy of the <A href=\"http://www.boost.org/libs/graph/LICENCE\">License Agreement</a> for the "
+ "Boost Graph Library along with the software; see the file <A href=\"http://www.boost.org/libs/graph/LICENCE\">LICENSE</a>. "
+ "If not, contact Office of Research, Indiana University, Bloomington,"
+ "IN 47404.</P>"
+ "<P>Permission to modify the code and to distribute modified code is "
+ "granted, provided the text of this NOTICE is retained, a notice that "
+ "the code was modified is included with the above COPYRIGHT NOTICE and "
+ "with the COPYRIGHT NOTICE in the <A href=\"http://www.boost.org/libs/graph/LICENCE\">LICENSE</a> file, and that the <A href=\"http://www.boost.org/libs/graph/LICENCE\">LICENSE</a> "
+ "file is distributed with the modified code.</P>"
+ "<P>LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.<BR> "
+ "By way of example, but not limitation, Licensor MAKES NO "
+ "REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY "
+ "PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS "
+ "OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS "
+ "OR OTHER RIGHTS.</P>"
+ )
+ ,
+ license_info( boost::regex("Permission\\W+to\\W+copy\\W+use\\W+modify\\W+sell\\W+and\\W+distribute\\W+this\\W+software\\W+is"
+ "[^\"[:word:]]+granted\\W+provided\\W+this\\W+copyright\\W+notice\\W+appears\\W+in\\W+all\\W+copies\\W+and"
+ "\\W+modified\\W+version\\W+are\\W+clearly\\W+marked\\W+as\\W+such\\W+This\\W+software\\W+is\\W+provided"
+ "\\W+as\\W+is\\W+without\\W+express\\W+or\\W+implied\\W+warranty\\W+and\\W+with\\W+no\\W+claim\\W+as\\W+to\\W+its"
+ "\\W+suitability\\W+for\\W+any\\W+purpose"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #5"
+ ,
+ "<P>Copyright (C) <I>Date Author</I></P>"
+ "<p>Permission to copy, use, modify, sell and distribute this software is "
+ "granted, provided this copyright notice appears in all copies and "
+ "modified version are clearly marked as such. This software is provided "
+ "\"as is\" without express or implied warranty, and with no claim as to its "
+ "suitability for any purpose.</P>"
+ )
+ ,
+ license_info( boost::regex("This\\W+file\\W+can\\W+be\\W+redistributed\\W+and\\W+or\\W+modified\\W+under\\W+the\\W+terms\\W+found"
+ "\\W+in\\W+copyright\\W+html"
+ "\\W+This\\W+software\\W+and\\W+its\\W+documentation\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or"
+ "\\W+implied\\W+warranty\\W+and\\W+with\\W+no\\W+claim\\W+as\\W+to\\W+its\\W+suitability\\W+for\\W+any\\W+purpose"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Boost.Pool license"
+ ,
+ "<P>This file can be redistributed and/or modified under the terms found "
+ "in <a href=\"http://www.boost.org/libs/pool/doc/copyright.html\">copyright.html</a></P>\n"
+ "<P>This software and its documentation is provided \"as is\" without express or "
+ "implied warranty, and with no claim as to its suitability for any purpose</P>"
+ )
+ ,
+ license_info(boost::regex("Permission\\W+to\\W+use\\W+copy\\W+modify\\W+sell\\W+and\\W+distribute\\W+this\\W+software"
+ "\\W+is\\W+hereby\\W+granted\\W+without\\W+fee\\W+provided\\W+that\\W+the\\W+above\\W+copyright\\W+notice"
+ "\\W+appears\\W+in\\W+all\\W+copies\\W+and\\W+that\\W+both\\W+that\\W+copyright\\W+notice\\W+and\\W+this"
+ "\\W+permission\\W+notice\\W+appear\\W+in\\W+supporting\\W+documentation"
+ "[^<>]{1,100}\\W+(make\\W+any\\W+representation|makes\\W+no\\W+representations)\\W+about\\W+the\\W+suitability\\W+of\\W+this"
+ "\\W+software\\W+for\\W+any\\W+purpose\\W+It\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or"
+ "\\W+implied\\W+warranty"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #6"
+ ,
+ "<P>Copyright <I>Author Data</I></P>"
+ "<P>Permission to use, copy, modify, sell, and distribute this software "
+ "is hereby granted without fee provided that the above copyright notice "
+ "appears in all copies and that both that copyright notice and this "
+ "permission notice appear in supporting documentation, "
+ "<I>Author</I> makes no representations about the suitability of this "
+ "software for any purpose. It is provided \"as is\" without express or "
+ "implied warranty.</P>"
+ )
+ ,
+ license_info( boost::regex("Permission\\W+to\\W+copy"
+ "[^\"[:word:]]+use\\W+modify\\W+sell\\W+and\\W+distribute\\W+this\\W+software\\W+is\\W+granted\\W+provided"
+ "\\W+this\\W+copyright\\W+notice\\W+appears\\W+in\\W+all\\W+copies\\W+of\\W+the\\W+source\\W+This"
+ "\\W+software\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or\\W+implied\\W+warranty"
+ "\\W+and\\W+with\\W+no\\W+claim\\W+as\\W+to\\W+its\\W+suitability\\W+for\\W+any\\W+purpose"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #7"
+ ,
+ "<P>Copyright <I>Author Date</I>. Permission to copy, "
+ "use, modify, sell and distribute this software is granted provided "
+ "this copyright notice appears in all copies of the source. This "
+ "software is provided \"as is\" without express or implied warranty, "
+ "and with no claim as to its suitability for any purpose."
+ )
+ ,
+ license_info(boost::regex("This\\W+software\\W+is\\W+provided\\W+as-is\\W+without\\W+any\\W+express\\W+or\\W+implied"
+ "\\W+warranty\\W+In\\W+no\\W+event\\W+will\\W+the\\W+copyright\\W+holder\\W+be\\W+held\\W+liable\\W+for"
+ "\\W+any\\W+damages\\W+arising\\W+from\\W+the\\W+use\\W+of\\W+this\\W+software"
+ "\\W+Permission\\W+is\\W+granted\\W+to\\W+anyone\\W+to\\W+use\\W+this\\W+software\\W+for\\W+any\\W+purpose"
+ "\\W+including\\W+commercial\\W+applications\\W+and\\W+to\\W+alter\\W+it\\W+and\\W+redistribute"
+ "\\W+it\\W+freely\\W+subject\\W+to\\W+the\\W+following\\W+restrictions:"
+ "\\W+1\\W+The\\W+origin\\W+of\\W+this\\W+software\\W+must\\W+not\\W+be\\W+misrepresented;\\W+you\\W+must"
+ "\\W+not\\W+claim\\W+that\\W+you\\W+wrote\\W+the\\W+original\\W+software\\W+If\\W+you\\W+use\\W+this"
+ "\\W+software\\W+in\\W+a\\W+product\\W+an\\W+acknowledgment\\W+in\\W+the\\W+product\\W+documentation"
+ "\\W+would\\W+be\\W+appreciated\\W+but\\W+is\\W+not\\W+required"
+ "\\W+2\\W+Altered\\W+source\\W+versions\\W+must\\W+be\\W+plainly\\W+marked\\W+as\\W+such\\W+and\\W+must"
+ "\\W+not\\W+be\\W+misrepresented\\W+as\\W+being\\W+the\\W+original\\W+software"
+ "\\W+3\\W+This\\W+notice\\W+may\\W+not\\W+be\\W+removed\\W+or\\W+altered\\W+from\\W+any\\W+source"
+ "\\W+distribution"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #8"
+ ,
+ "<P>Phoenix V0.9<BR>Copyright (c) <I>Date</I> Joel de Guzman</P>"
+ "<P>This software is provided 'as-is', without any express or implied "
+ "warranty. In no event will the copyright holder be held liable for "
+ "any damages arising from the use of this software.</P>"
+ "<P>Permission is granted to anyone to use this software for any purpose, "
+ "including commercial applications, and to alter it and redistribute "
+ "it freely, subject to the following restrictions:</P>"
+ "<P>1. The origin of this software must not be misrepresented; you must "
+ "not claim that you wrote the original software. If you use this "
+ "software in a product, an acknowledgment in the product documentation "
+ "would be appreciated but is not required.</P>"
+ "2. Altered source versions must be plainly marked as such, and must "
+ "not be misrepresented as being the original software. </P>"
+ "<P>3. This notice may not be removed or altered from any source "
+ "distribution. "
+ )
+ ,
+ license_info( boost::regex("Permission\\W+to\\W+use\\W+copy\\W+modify\\W+sell\\W+and\\W+distribute\\W+this\\W+software"
+ "\\W+is\\W+hereby\\W+granted\\W+without\\W+fee\\W+provided\\W+that\\W+the\\W+above\\W+copyright\\W+notice"
+ "\\W+appears\\W+in\\W+all\\W+copies\\W+and\\W+that\\W+both\\W+that\\W+copyright\\W+notice\\W+and\\W+this"
+ "\\W+permission\\W+notice\\W+appear\\W+in\\W+supporting\\W+documentation"
+ "\\W+None\\W+of\\W+the\\W+above\\W+authors\\W+nor.{1,100}make\\W+any"
+ "\\W+representation\\W+about\\W+the\\W+suitability\\W+of\\W+this\\W+software\\W+for\\W+any"
+ "\\W+purpose\\W+It\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or\\W+implied\\W+warranty"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #9"
+ ,
+ "<P>Copyright <I> Author Date</I><BR>"
+ "Permission to use, copy, modify, sell, and distribute this software "
+ "is hereby granted without fee provided that the above copyright notice "
+ "appears in all copies and that both that copyright notice and this "
+ "permission notice appear in supporting documentation, <BR>"
+ "None of the above authors nor <I>Author's Organisation</I> make any "
+ "representation about the suitability of this software for any "
+ "purpose. It is provided \"as is\" without express or implied warranty."
+ )
+ ,
+ license_info( boost::regex("Permission\\W+to\\W+use\\W+copy\\W+modify\\W+and\\W+distribute\\W+this\\W+software\\W+for\\W+any"
+ "\\W+purpose\\W+is\\W+hereby\\W+granted\\W+without\\W+fee\\W+provided\\W+that\\W+this\\W+copyright\\W+and"
+ "\\W+permissions\\W+notice\\W+appear\\W+in\\W+all\\W+copies\\W+and\\W+derivatives"
+ "\\W+This\\W+software\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or\\W+implied\\W+warranty"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #10"
+ ,
+ "<P>Copyright <I>Author Date</I>. All rights reserved.</P>"
+ "<P>Permission to use, copy, modify, and distribute this software for any "
+ "purpose is hereby granted without fee, provided that this copyright and "
+ "permissions notice appear in all copies and derivatives.</P>"
+ "<P>This software is provided \"as is\" without express or implied warranty.</P>"
+ )
+ ,
+ license_info( boost::regex("This\\W+material\\W+is\\W+provided\\W+as\\W+is\\W+with\\W+absolutely\\W+no\\W+warranty\\W+expressed"
+ "\\W+or\\W+implied\\W+Any\\W+use\\W+is\\W+at\\W+your\\W+own\\W+risk"
+ "\\W+Permission\\W+to\\W+use\\W+or\\W+copy\\W+this\\W+software\\W+for\\W+any\\W+purpose\\W+is\\W+hereby\\W+granted"
+ "\\W+without\\W+fee\\W+provided\\W+the\\W+above\\W+notices\\W+are\\W+retained\\W+on\\W+all\\W+copies"
+ "\\W+Permission\\W+to\\W+modify\\W+the\\W+code\\W+and\\W+to\\W+distribute\\W+modified\\W+code\\W+is\\W+granted"
+ "\\W+provided\\W+the\\W+above\\W+notices\\W+are\\W+retained\\W+and\\W+a\\W+notice\\W+that\\W+the\\W+code\\W+was"
+ "\\W+modified\\W+is\\W+included\\W+with\\W+the\\W+above\\W+copyright\\W+notice"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #11"
+ ,
+ "<P>This material is provided \"as is\", with absolutely no warranty expressed "
+ "or implied. Any use is at your own risk.</P>"
+ "<P>Permission to use or copy this software for any purpose is hereby granted "
+ "without fee, provided the above notices are retained on all copies. "
+ "Permission to modify the code and to distribute modified code is granted, "
+ "provided the above notices are retained, and a notice that the code was "
+ "modified is included with the above copyright notice.</P>"
+ )
+ ,
+ license_info( boost::regex("Permission\\W+to\\W+copy\\W+use\\W+and\\W+distribute\\W+this\\W+software\\W+is\\W+granted\\W+provided"
+ "\\W+that\\W+this\\W+copyright\\W+notice\\W+appears\\W+in\\W+all\\W+copies"
+ "\\W+Permission\\W+to\\W+modify\\W+the\\W+code\\W+and\\W+to\\W+distribute\\W+modified\\W+code\\W+is\\W+granted"
+ "\\W+provided\\W+that\\W+this\\W+copyright\\W+notice\\W+appears\\W+in\\W+all\\W+copies\\W+and\\W+a\\W+notice"
+ "\\W+that\\W+the\\W+code\\W+was\\W+modified\\W+is\\W+included\\W+with\\W+the\\W+copyright\\W+notice"
+ "\\W+This\\W+software\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or\\W+implied\\W+warranty\\W+and"
+ "\\W+with\\W+no\\W+claim\\W+as\\W+to\\W+its\\W+suitability\\W+for\\W+any\\W+purpose"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #12"
+ ,
+ "<P>Copyright (C) <I>Date Author</I></P><P>Permission to copy, use, and distribute this software is granted, provided "
+ "that this copyright notice appears in all copies.<BR>"
+ "Permission to modify the code and to distribute modified code is granted, "
+ "provided that this copyright notice appears in all copies, and a notice "
+ "that the code was modified is included with the copyright notice.</P>"
+ "<P>This software is provided \"as is\" without express or implied warranty, and "
+ "with no claim as to its suitability for any purpose.</P>"
+ )
+ ,
+ license_info( boost::regex("Permission\\W+to\\W+copy\\W+and\\W+use\\W+this\\W+software\\W+is\\W+granted"
+ "\\W+provided\\W+this\\W+copyright\\W+notice\\W+appears\\W+in\\W+all\\W+copies"
+ "\\W+Permission\\W+to\\W+modify\\W+the\\W+code\\W+and\\W+to\\W+distribute\\W+modified\\W+code\\W+is\\W+granted"
+ "\\W+provided\\W+this\\W+copyright\\W+notice\\W+appears\\W+in\\W+all\\W+copies\\W+and\\W+a\\W+notice"
+ "\\W+that\\W+the\\W+code\\W+was\\W+modified\\W+is\\W+included\\W+with\\W+the\\W+copyright\\W+notice"
+ "\\W+This\\W+software\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or\\W+implied\\W+warranty"
+ "\\W+and\\W+with\\W+no\\W+claim\\W+as\\W+to\\W+its\\W+suitability\\W+for\\W+any\\W+purpose"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #13"
+ ,
+ "<P>Copyright (C) <I>Date Author</I></P>"
+ "<P>Permission to copy and use this software is granted, "
+ "provided this copyright notice appears in all copies. "
+ "Permission to modify the code and to distribute modified code is granted, "
+ "provided this copyright notice appears in all copies, and a notice "
+ "that the code was modified is included with the copyright notice.</P>"
+ "<P>This software is provided \"as is\" without express or implied warranty, "
+ "and with no claim as to its suitability for any purpose.</P>"
+ )
+ ,
+ license_info( boost::regex("Copyright\\W+Kevlin\\W+Henney\\W+2000\\W+All\\W+rights\\W+reserved\\W+"
+ "Permission\\W+to\\W+use\\W+copy\\W+modify\\W+and\\W+distribute\\W+this\\W+software\\W+for\\W+any"
+ "\\W+purpose\\W+is\\W+hereby\\W+granted\\W+without\\W+fee\\W+provided\\W+that\\W+this\\W+copyright\\W+and"
+ "\\W+permissions\\W+notice\\W+appear\\W+in\\W+all\\W+copies\\W+and\\W+derivatives\\W+and\\W+that\\W+no"
+ "\\W+charge\\W+may\\W+be\\W+made\\W+for\\W+the\\W+software\\W+and\\W+its\\W+documentation\\W+except\\W+to\\W+cover"
+ "\\W+cost\\W+of\\W+distribution"
+ "\\W+This\\W+software\\W+is\\W+provided\\W+as\\W+is\\W+without\\W+express\\W+or\\W+implied\\W+warranty\\W+"
+ , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Old style Boost license #14"
+ ,
+ "<P>Copyright The Author, The Date. All rights reserved.</P>"
+ "<P>Permission to use, copy, modify, and distribute this software for any"
+ " purpose is hereby granted without fee, provided that this copyright and"
+ " permissions notice appear in all copies and derivatives, and that no"
+ " charge may be made for the software and its documentation except to cover"
+ " cost of distribution.</P>"
+ "<P>This software is provided \"as is\" without express or implied warranty.</P>"
+ )
+ ,
+ license_info( boost::regex("preprocessed\\W+version\\W+of\\W+boost/mpl/.*\\.hpp\\W+header\\W+see\\W+the\\W+original\\W+for\\W+copyright\\W+information", boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "SGI Style Licence (MPL preprocessed file)"
+ ,
+ "<P>Copyright (c) <I>Date</I><BR>"
+ "<I>Author</I><BR>"
+ "<BR>"
+ "Permission to use, copy, modify, distribute and sell this software "
+ "and its documentation for any purpose is hereby granted without fee, "
+ "provided that the above copyright notice appear in all copies and "
+ "that both that copyright notice and this permission notice appear "
+ "in supporting documentation. <I>Author</I> makes no representations "
+ "about the suitability of this software for any purpose. "
+ "It is provided \"as is\" without express or implied warranty.</P>"
+ )
+ ,
+ license_info( boost::regex(
+ "This\\W+file\\W+is\\W+part\\W+of\\W+jam\\W+"
+ "License\\W+is\\W+hereby\\W+granted\\W+to\\W+use\\W+this\\W+software\\W+and\\W+distribute\\W+it\\W+"
+ "freely\\W+as\\W+long\\W+as\\W+this\\W+copyright\\W+notice\\W+is\\W+retained\\W+and\\W+modifications\\W+"
+ "are\\W+clearly\\W+marked\\W+"
+ "ALL\\W+WARRANTIES\\W+ARE\\W+HEREBY\\W+DISCLAIMED"
+ "|"
+ "This\\W+file\\W+is\\W+part\\W+of\\W+Jam\\W+see\\W+jam\\.c\\W+for\\W+Copyright\\W+information"
+ "|This file has been donated to Jam"
+ "|Generated by mkjambase from Jambase" , boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig + std::string("|(Craig\\W+W\\W+McPheeters\\W+Alias\\W+Wavefront)|(Generated by mkjambase from Jambase)"), boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format + std::string("(?4Craig W. McPheeters, Alias|Wavefront)(?5Christopher Seiwald and Perforce Software, Inc)")
+ ,
+ "Perforce Jam License"
+ ,
+ "<P>Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc.</P>"
+ "<P>This file is part of jam.</P>"
+ "<P>License is hereby granted to use this software and distribute it "
+ "freely, as long as this copyright notice is retained and modifications "
+ " are clearly marked.</P>"
+ "<P>ALL WARRANTIES ARE HEREBY DISCLAIMED</P>"
+ )
+ ,
+ license_info( boost::regex(
+ "Permission\\W+is\\W+granted\\W+to\\W+anyone\\W+to\\W+use\\W+this\\W+software\\W+for\\W+any\\W+"
+ "purpose\\W+on\\W+any\\W+computer\\W+system\\W+and\\W+to\\W+redistribute\\W+it\\W+freely\\W+"
+ "subject\\W+to\\W+the\\W+following\\W+restrictions\\W+"
+ "1\\W+The\\W+author\\W+is\\W+not\\W+responsible\\W+for\\W+the\\W+consequences\\W+of\\W+use\\W+of\\W+"
+ "this\\W+software\\W+no\\W+matter\\W+how\\W+awful\\W+even\\W+if\\W+they\\W+arise\\W+"
+ "from\\W+defects\\W+in\\W+it\\W+"
+ "2\\W+The\\W+origin\\W+of\\W+this\\W+software\\W+must\\W+not\\W+be\\W+misrepresented\\W+either\\W+"
+ "by\\W+explicit\\W+claim\\W+or\\W+by\\W+omission\\W+"
+ "3\\W+Altered\\W+versions\\W+must\\W+be\\W+plainly\\W+marked\\W+as\\W+such\\W+and\\W+must\\W+not\\W+"
+ "be\\W+misrepresented\\W+as\\W+being\\W+the\\W+original\\W+software"
+ "|Definitions\\W+etc\\W+for\\W+regexp\\W+3\\W+routines", boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig + std::string("|(Definitions\\W+etc\\W+for\\W+regexp\\W+3\\W+routines)"), boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format + std::string("(?4University of Toronto)")
+ ,
+ "BSD Regex License"
+ ,
+ "<P>Copyright (c) 1986 by University of Toronto.</P>"
+ "<P>Written by Henry Spencer. Not derived from licensed software.</P>"
+ "<P>Permission is granted to anyone to use this software for any"
+ "purpose on any computer system, and to redistribute it freely,"
+ "subject to the following restrictions:</P>"
+ "<P>The author is not responsible for the consequences of use of"
+ "this software, no matter how awful, even if they arise"
+ "from defects in it.</P>"
+ "<p>The origin of this software must not be misrepresented, either"
+ "by explicit claim or by omission.</p>"
+ "<p>Altered versions must be plainly marked as such, and must not"
+ "be misrepresented as being the original software.</P>"
+ )
+ ,
+ license_info( boost::regex(
+ "Skeleton\\W+parser\\W+for\\W+Yacc\\W+like\\W+parsing\\W+with\\W+Bison\\W+"
+ "Copyright.{0,100}Free\\W+Software\\W+Foundation\\W+Inc\\W+"
+ "\\W+This\\W+program\\W+is\\W+free\\W+software\\W+you\\W+can\\W+redistribute\\W+it\\W+and\\W+or\\W+modify\\W+"
+ "it\\W+under\\W+the\\W+terms\\W+of\\W+the\\W+GNU\\W+General\\W+Public\\W+License\\W+as\\W+published\\W+by\\W+"
+ "the\\W+Free\\W+Software\\W+Foundation\\W+either\\W+version\\W+2\\W+or\\W+at\\W+your\\W+option\\W+"
+ "any\\W+later\\W+version"
+ "|"
+ // this part matches the start of jamgramtab.h which is under the same licence
+ // but bison does not output it's usual licence declaration:
+ "\\{\\s*\"!\"\\s*,\\s*_BANG_t\\s*\\}", boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig + std::string("|(\\{\\s*\"!\"\\s*,\\s*_BANG_t\\s*\\})"), boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format + std::string("(?4Free Software Foundation, Inc)")
+ ,
+ "GNU Parser Licence"
+ ,
+ "<P>Skeleton parser for Yacc-like parsing with Bison,<BR>"
+ "Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.</P>"
+ "<P>This program is free software; you can redistribute it and/or modify"
+ "it under the terms of the GNU General Public License as published by"
+ "the Free Software Foundation; either version 2, or (at your option)"
+ "any later version.</P>"
+ "<P>This program is distributed in the hope that it will be useful,"
+ "but WITHOUT ANY WARRANTY; without even the implied warranty of"
+ "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the"
+ "GNU General Public License for more details.</P>"
+ "<P>You should have received a copy of the GNU General Public License"
+ "along with this program; if not, write to the Free Software"
+ "Foundation, Inc., 59 Temple Place - Suite 330,"
+ "Boston, MA 02111-1307, USA.</P>"
+ "<P>As a special exception, when this file is copied by Bison into a"
+ "Bison output file, you may use that output file without restriction."
+ "This special exception was added by the Free Software Foundation"
+ "in version 1.24 of Bison.</P>"
+ )
+ ,
+ license_info( boost::regex(
+ "(?:The|This)\\W+code\\W+is\\W+considered\\W+to\\W+be\\W+in\\W+the\\W+public\\W+domain", boost::regex::perl | boost::regex::icase)
+ ,
+ boost::regex(generic_author_sig, boost::regex::perl | boost::regex::icase)
+ ,
+ generic_author_format
+ ,
+ "Public Domain"
+ ,
+ "<P>The code has no license terms, it has been explicity placed in the\n"
+ "public domain by it's author(s).</P>"
+ )
+ ,
+ };
+ return std::pair<const license_info*, int>(licenses, static_cast<int>(sizeof(licenses)/sizeof(licenses[0])));
+}
+
+std::string format_authors_name(const std::string& name)
+{
+ // put name into a consistent format, so that we don't get too much
+ // of a proliferation of names (lots of versions of the same basic form).
+
+ static const boost::regex e("(^)?[^-(<a-zA-ZÀ-þ]+(([(<].*)?$)?");
+ static const char* formatter = "(?1:(?2: ))";
+
+ return boost::regex_replace(name, e, formatter, boost::match_default | boost::format_all);
+}
+
diff --git a/src/boost/tools/bcp/licence_info.hpp b/src/boost/tools/bcp/licence_info.hpp
new file mode 100644
index 000000000..e4ced2572
--- /dev/null
+++ b/src/boost/tools/bcp/licence_info.hpp
@@ -0,0 +1,39 @@
+/*
+ *
+ * Copyright (c) 2003 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)
+ *
+ */
+
+#include <boost/regex.hpp>
+#include <utility>
+
+struct license_info
+{
+ boost::regex license_signature;
+ boost::regex copyright_signature;
+ std::string copyright_formatter;
+ std::string license_name;
+ std::string license_text;
+ //
+ // we should really be able to initialize license_info as an
+ // aggregate, but some compilers reject this, so use a constructor
+ //instead:
+ //
+ license_info(const boost::regex& e1,
+ const boost::regex& e2,
+ const std::string& s1,
+ const std::string& s2,
+ const std::string& s3)
+ : license_signature(e1),
+ copyright_signature(e2),
+ copyright_formatter(s1),
+ license_name(s2),
+ license_text(s3){}
+};
+
+std::pair<const license_info*, int> get_licenses();
+
+std::string format_authors_name(const std::string& name);
diff --git a/src/boost/tools/bcp/main.cpp b/src/boost/tools/bcp/main.cpp
new file mode 100644
index 000000000..214c6d820
--- /dev/null
+++ b/src/boost/tools/bcp/main.cpp
@@ -0,0 +1,183 @@
+/*
+ *
+ * Copyright (c) 2003 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 cpp_main entry point
+ */
+
+
+#include <iostream>
+#include <cstring>
+#include <string>
+#include <list>
+#include "bcp.hpp"
+#include <boost/filesystem/path.hpp>
+#include <boost/version.hpp>
+#include <boost/detail/lightweight_main.hpp>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{
+ using ::strcmp;
+ using ::strncmp;
+}
+#endif
+
+void show_usage()
+{
+ std::cout <<
+ "Usage:\n"
+ " bcp --list [options] module-list\n"
+ " bcp --list-short [options] module-list\n"
+ " bcp --report [options] module-list html-file\n"
+ " 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"
+ " --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";
+}
+
+bool filesystem_name_check( const std::string & )
+{
+ return true;
+}
+
+int cpp_main(int argc, char* argv[])
+{
+ //
+ // Before anything else replace Boost.filesystem's file
+ // name checker with one that does nothing (we only deal
+ // with files that already exist, if they're not portable
+ // names it's too late for us to do anything about it).
+ //
+ /*boost::filesystem::path::default_name_check(filesystem_name_check);*/
+ //
+ // without arguments just show help:
+ //
+ if(argc < 2)
+ {
+ std::cout << "Error: insufficient arguments, don't know what to do." << std::endl;
+ show_usage();
+ return 1;
+ }
+ //
+ // create the application object:
+ //
+ pbcp_application papp(bcp_application::create());
+ //
+ // work through args, and tell the application
+ // object what ir needs to do:
+ //
+ bool list_mode = false;
+ std::list<const char*> positional_args;
+ for(int i = 1; i < argc; ++i)
+ {
+ if(0 == std::strcmp("-h", argv[i])
+ || 0 == std::strcmp("--help", argv[i]))
+ {
+ show_usage();
+ return 0;
+ }
+ if(0 == std::strcmp("-v", argv[i])
+ || 0 == std::strcmp("--version", argv[i]))
+ {
+ std::cout << "bcp " << (BOOST_VERSION / 100000) << "." << (BOOST_VERSION / 100 % 1000) << "." << (BOOST_VERSION % 100) << std::endl;
+ std::cout << __DATE__ << std::endl;
+ return 0;
+ }
+ else if(0 == std::strcmp("--list", argv[i]))
+ {
+ list_mode = true;
+ papp->enable_list_mode();
+ }
+ else if(0 == std::strcmp("--list-short", argv[i]))
+ {
+ list_mode = true;
+ papp->enable_summary_list_mode();
+ }
+ else if(0 == std::strcmp("--report", argv[i]))
+ {
+ papp->enable_license_mode();
+ }
+ else if(0 == std::strcmp("--cvs", argv[i]))
+ {
+ papp->enable_cvs_mode();
+ }
+ else if(0 == std::strcmp("--svn", argv[i]))
+ {
+ papp->enable_svn_mode();
+ }
+ else if(0 == std::strcmp("--scan", argv[i]))
+ {
+ papp->enable_scan_mode();
+ }
+ else if(0 == std::strcmp("--bsl-convert", argv[i]))
+ {
+ papp->enable_bsl_convert_mode();
+ }
+ else if(0 == std::strcmp("--bsl-summary", argv[i]))
+ {
+ papp->enable_bsl_summary_mode();
+ }
+ else if(0 == std::strcmp("--unix-lines", argv[i]))
+ {
+ papp->enable_unix_lines();
+ }
+ else if(0 == std::strncmp("--boost=", argv[i], 8))
+ {
+ 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;
+ }
+ else
+ {
+ positional_args.push_back(argv[i]);
+ }
+ }
+ //
+ // Handle positional args last:
+ //
+ for(std::list<const char*>::const_iterator i = positional_args.begin();
+ i != positional_args.end(); ++i)
+ {
+ if(!list_mode && (i == --positional_args.end()))
+ papp->set_destination(*i);
+ else
+ papp->add_module(*i);
+ }
+ //
+ // run the application object:
+ //
+ return papp->run();
+}
+
+
+
diff --git a/src/boost/tools/bcp/output_licence_info.cpp b/src/boost/tools/bcp/output_licence_info.cpp
new file mode 100644
index 000000000..d42268fdb
--- /dev/null
+++ b/src/boost/tools/bcp/output_licence_info.cpp
@@ -0,0 +1,410 @@
+/*
+ *
+ * Copyright (c) 2003 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)
+ *
+ */
+
+#include "licence_info.hpp"
+#include "bcp_imp.hpp"
+#include "fileview.hpp"
+#include <fstream>
+#include <iomanip>
+#include <cstring>
+#include <stdexcept>
+#include <boost/lexical_cast.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <boost/throw_exception.hpp>
+
+//
+// split_path is a small helper for outputting a path name,
+// complete with a link to that path:
+//
+struct split_path
+{
+ const fs::path& root;
+ const fs::path& file;
+ split_path(const fs::path& r, const fs::path& f)
+ : root(r), file(f){}
+private:
+ split_path& operator=(const split_path&);
+};
+
+std::ostream& operator << (std::ostream& os, const split_path& p)
+{
+ os << "<a href=\"" << (p.root / p.file).string() << "\">" << p.file.string() << "</a>";
+ return os;
+}
+
+std::string make_link_target(const std::string& s)
+{
+ // convert an arbitrary string into something suitable
+ // for an <a> name:
+ std::string result;
+ for(unsigned i = 0; i < s.size(); ++i)
+ {
+ result.append(1, static_cast<std::string::value_type>(std::isalnum(s[i]) ? s[i] : '_'));
+ }
+ return result;
+}
+
+
+void bcp_implementation::output_license_info()
+{
+ std::pair<const license_info*, int> licenses = get_licenses();
+
+ std::map<int, license_data>::const_iterator i, j;
+ i = m_license_data.begin();
+ j = m_license_data.end();
+
+ std::ofstream os(m_dest_path.string().c_str());
+ if(!os)
+ {
+ std::string msg("Error opening ");
+ msg += m_dest_path.string();
+ msg += " for output.";
+ std::runtime_error e(msg);
+ boost::throw_exception(e);
+ }
+ os <<
+ "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\">\n"
+ "<html>\n"
+ "<head>\n"
+ "<title>Boost Licence Dependency Information";
+ if(m_module_list.size() == 1)
+ {
+ os << " for " << *(m_module_list.begin());
+ }
+ os <<
+ "</title>\n"
+ "</head>\n"
+ "<body>\n"
+ "<H1>Boost Licence Dependency Information";
+ if(m_module_list.size() == 1)
+ {
+ os << " for " << *(m_module_list.begin());
+ }
+ os <<
+ "</H1>\n"
+ "<H2>Contents</h2>\n"
+ "<pre><a href=\"#input\">Input Information</a>\n";
+ if(!m_bsl_summary_mode)
+ os << "<a href=\"#summary\">Licence Summary</a>\n";
+ os << "<a href=\"#details\">Licence Details</a>\n";
+
+ while(i != j)
+ {
+ // title:
+ os << " <A href=\"#" << make_link_target(licenses.first[i->first].license_name)
+ << "\">" << licenses.first[i->first].license_name << "</a>\n";
+ ++i;
+ }
+
+ os << "<a href=\"#files\">Files with no recognised license</a>\n"
+ "<a href=\"#authors\">Files with no recognised copyright holder</a>\n";
+ if(!m_bsl_summary_mode)
+ {
+ os <<
+ "Moving to the Boost Software License...\n"
+ " <a href=\"#bsl-converted\">Files that can be automatically converted to the Boost Software License</a>\n"
+ " <a href=\"#to-bsl\">Files that can be manually converted to the Boost Software License</a>\n"
+ " <a href=\"#not-to-bsl\">Files that can <b>NOT</b> be moved to the Boost Software License</a>\n"
+ " <a href=\"#need-bsl-authors\">Authors we need to move to the Boost Software License</a>\n"
+ "<a href=\"#copyright\">Copyright Holder Information</a>\n";
+ }
+ os <<
+ "<a href=\"#depend\">File Dependency Information</a>\n"
+ "</pre>";
+
+ //
+ // input Information:
+ //
+ os << "<a name=\"input\"></a><h2>Input Information</h2>\n";
+ if(m_scan_mode)
+ os << "<P>The following files were scanned for boost dependencies:<BR>";
+ else
+ os << "<P>The following Boost modules were checked:<BR>";
+
+ std::list<std::string>::const_iterator si = m_module_list.begin();
+ std::list<std::string>::const_iterator sj = m_module_list.end();
+ while(si != sj)
+ {
+ os << *si << "<BR>";
+ ++si;
+ }
+ os << "</p><p>The Boost path was: <code>" << m_boost_path.string() << "</code></P>";
+ //
+ // extract the boost version number from the boost directory tree,
+ // not from this app (which may have been built from a previous
+ // version):
+ //
+ fileview version_file(m_boost_path / "boost/version.hpp");
+ 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))
+ {
+ int version = boost::lexical_cast<int>(what.str(1));
+ os << "<p>The Boost version is: " << version / 100000 << "." << version / 100 % 1000 << "." << version % 100 << "</P>\n";
+ }
+
+ //
+ // output each license:
+ //
+ i = m_license_data.begin();
+ j = m_license_data.end();
+ if(!m_bsl_summary_mode)
+ {
+ //
+ // start with the summary:
+ //
+ os << "<a name=\"summary\"></a><h2>Licence Summary</h2>\n";
+ while(i != j)
+ {
+ // title:
+ os <<
+ "<H3>" << licenses.first[i->first].license_name << "</H3>\n";
+ // license text:
+ os << "<BLOCKQUOTE>" << licenses.first[i->first].license_text << "</BLOCKQUOTE>";
+ // Copyright holders:
+ os << "<P>This license is used by " << i->second.authors.size()
+ << " authors and " << i->second.files.size()
+ << " files <a href=\"#" << make_link_target(licenses.first[i->first].license_name) << "\">(see details)</a>";
+ os << "</P></BLOCKQUOTE>\n";
+ ++i;
+ }
+ }
+ //
+ // and now the details:
+ //
+ i = m_license_data.begin();
+ j = m_license_data.end();
+ int license_index = 0;
+ os << "<a name=\"details\"></a><h2>Licence Details</h2>\n";
+ while(i != j)
+ {
+ // title:
+ os <<
+ "<H3><A name=\"" << make_link_target(licenses.first[i->first].license_name)
+ << "\"></a>" << licenses.first[i->first].license_name << "</H3>\n";
+ // license text:
+ os << "<BLOCKQUOTE>" << licenses.first[i->first].license_text << "</BLOCKQUOTE>";
+ if(!m_bsl_summary_mode || (license_index >= 3))
+ {
+ // Copyright holders:
+ os << "<P>This license is used by the following " << i->second.authors.size() << " copyright holders:</P>\n<BLOCKQUOTE><P>";
+ std::set<std::string>::const_iterator x, y;
+ x = i->second.authors.begin();
+ y = i->second.authors.end();
+ while(x != y)
+ {
+ os << *x << "<BR>\n";
+ ++x;
+ }
+ os << "</P></BLOCKQUOTE>\n";
+ // Files using this license:
+ os << "<P>This license applies to the following " << i->second.files.size() << " files:</P>\n<BLOCKQUOTE><P>";
+ std::set<fs::path, path_less>::const_iterator m, n;
+ m = i->second.files.begin();
+ n = i->second.files.end();
+ while(m != n)
+ {
+ os << split_path(m_boost_path, *m) << "<br>\n";
+ ++m;
+ }
+ os << "</P></BLOCKQUOTE>\n";
+ }
+ else
+ {
+ os << "<P>This license is used by " << i->second.authors.size() << " authors (list omitted for brevity).</P>\n";
+ os << "<P>This license applies to " << i->second.files.size() << " files (list omitted for brevity).</P>\n";
+ }
+ ++license_index;
+ ++i;
+ }
+ //
+ // Output list of files not found to be under license control:
+ //
+ os << "<h2><a name=\"files\"></a>Files With No Recognisable Licence</h2>\n"
+ "<P>The following " << m_unknown_licenses.size() << " files had no recognisable license information:</P><BLOCKQUOTE><P>\n";
+ std::set<fs::path, path_less>::const_iterator i2, j2;
+ i2 = m_unknown_licenses.begin();
+ j2 = m_unknown_licenses.end();
+ while(i2 != j2)
+ {
+ os << split_path(m_boost_path, *i2) << "<br>\n";
+ ++i2;
+ }
+ os << "</p></BLOCKQUOTE>";
+ //
+ // Output list of files with no found copyright holder:
+ //
+ os << "<h2><a name=\"authors\"></a>Files With No Recognisable Copyright Holder</h2>\n"
+ "<P>The following " << m_unknown_authors.size() << " files had no recognisable copyright holder:</P>\n<BLOCKQUOTE><P>";
+ i2 = m_unknown_authors.begin();
+ j2 = m_unknown_authors.end();
+ while(i2 != j2)
+ {
+ os << split_path(m_boost_path, *i2) << "<br>\n";
+ ++i2;
+ }
+ os << "</p></BLOCKQUOTE>";
+ if(!m_bsl_summary_mode)
+ {
+ //
+ // Output list of files that have been moved over to the Boost
+ // Software License, along with enough information for human
+ // verification.
+ //
+ os << "<h2><a name=\"bsl-converted\"></a>Files that can be automatically converted to the Boost Software License</h2>\n"
+ << "<P>The following " << m_converted_to_bsl.size() << " files can be automatically converted to the Boost Software License, but require manual verification before they can be committed to CVS:</P>\n";
+ if (!m_converted_to_bsl.empty())
+ {
+ typedef std::map<fs::path, std::pair<std::string, std::string>, path_less>
+ ::const_iterator conv_iterator;
+ conv_iterator i = m_converted_to_bsl.begin(),
+ ie = m_converted_to_bsl.end();
+ int file_num = 1;
+ while (i != ie)
+ {
+ os << "<P>[" << file_num << "] File: <tt>" << split_path(m_boost_path, i->first)
+ << "</tt><br>\n<table border=\"1\">\n <tr>\n <td><pre>"
+ << i->second.first << "</pre></td>\n <td><pre>"
+ << i->second.second << "</pre></td>\n </tr>\n</table>\n";
+ ++i;
+ ++file_num;
+ }
+ }
+ //
+ // Output list of files that could be moved over to the Boost Software License
+ //
+ os << "<h2><a name=\"to-bsl\"></a>Files that could be converted to the Boost Software License</h2>\n"
+ "<P>The following " << m_can_migrate_to_bsl.size() << " files could be manually converted to the Boost Software License, but have not yet been:</P>\n<BLOCKQUOTE><P>";
+ i2 = m_can_migrate_to_bsl.begin();
+ j2 = m_can_migrate_to_bsl.end();
+ while(i2 != j2)
+ {
+ os << split_path(m_boost_path, *i2) << "<br>\n";
+ ++i2;
+ }
+ os << "</p></BLOCKQUOTE>";
+ //
+ // Output list of files that can not be moved over to the Boost Software License
+ //
+ os << "<h2><a name=\"not-to-bsl\"></a>Files that can NOT be converted to the Boost Software License</h2>\n"
+ "<P>The following " << m_cannot_migrate_to_bsl.size() << " files cannot be converted to the Boost Software License because we need the permission of more authors:</P>\n<BLOCKQUOTE><P>";
+ i2 = m_cannot_migrate_to_bsl.begin();
+ j2 = m_cannot_migrate_to_bsl.end();
+ while(i2 != j2)
+ {
+ os << split_path(m_boost_path, *i2) << "<br>\n";
+ ++i2;
+ }
+ os << "</p></BLOCKQUOTE>";
+ //
+ // Output list of authors that we need permission for to move to the BSL
+ //
+ os << "<h2><a name=\"need-bsl-authors\"></a>Authors we need for the BSL</h2>\n"
+ "<P>Permission of the following authors is needed before we can convert to the Boost Software License. The list of authors that have given their permission is contained in <code>more/blanket-permission.txt</code>.</P>\n<BLOCKQUOTE><P>";
+ std::copy(m_authors_for_bsl_migration.begin(), m_authors_for_bsl_migration.end(),
+ std::ostream_iterator<std::string>(os, "<br>\n"));
+ os << "</p></BLOCKQUOTE>";
+ //
+ // output a table of copyright information:
+ //
+ os << "<H2><a name=\"copyright\"></a>Copyright Holder Information</H2><table border=\"1\">\n";
+ std::map<std::string, std::set<fs::path, path_less> >::const_iterator ad, ead;
+ ad = m_author_data.begin();
+ ead = m_author_data.end();
+ while(ad != ead)
+ {
+ os << "<tr><td>" << ad->first << "</td><td>";
+ std::set<fs::path, path_less>::const_iterator fi, efi;
+ fi = ad->second.begin();
+ efi = ad->second.end();
+ while(fi != efi)
+ {
+ os << split_path(m_boost_path, *fi) << " ";
+ ++fi;
+ }
+ os << "</td></tr>\n";
+ ++ad;
+ }
+ os << "</table>\n";
+ }
+
+ //
+ // output file dependency information:
+ //
+ os << "<H2><a name=\"depend\"></a>File Dependency Information</H2><BLOCKQUOTE><pre>\n";
+ std::map<fs::path, fs::path, path_less>::const_iterator dep, last_dep;
+ std::set<fs::path, path_less>::const_iterator fi, efi;
+ fi = m_copy_paths.begin();
+ efi = m_copy_paths.end();
+ // if in summary mode, just figure out the "bad" files and print those only:
+ std::set<fs::path, path_less> bad_paths;
+ if(m_bsl_summary_mode)
+ {
+ bad_paths.insert(m_unknown_licenses.begin(), m_unknown_licenses.end());
+ bad_paths.insert(m_unknown_authors.begin(), m_unknown_authors.end());
+ bad_paths.insert(m_can_migrate_to_bsl.begin(), m_can_migrate_to_bsl.end());
+ bad_paths.insert(m_cannot_migrate_to_bsl.begin(), m_cannot_migrate_to_bsl.end());
+ typedef std::map<fs::path, std::pair<std::string, std::string>, path_less>
+ ::const_iterator conv_iterator;
+ conv_iterator i = m_converted_to_bsl.begin(),
+ ie = m_converted_to_bsl.end();
+ while(i != ie)
+ {
+ bad_paths.insert(i->first);
+ ++i;
+ }
+ fi = bad_paths.begin();
+ efi = bad_paths.end();
+ os << "<P>For brevity, only files not under the BSL are shown</P>\n";
+ }
+ while(fi != efi)
+ {
+ os << split_path(m_boost_path, *fi);
+ dep = m_dependencies.find(*fi);
+ last_dep = m_dependencies.end();
+ std::set<fs::path, path_less> seen_deps;
+ if (dep != last_dep)
+ while(true)
+ {
+ os << " -> ";
+ if(fs::exists(m_boost_path / dep->second))
+ os << split_path(m_boost_path, dep->second);
+ else if(fs::exists(dep->second))
+ os << split_path(fs::path(), dep->second);
+ else
+ os << dep->second.string();
+ if(seen_deps.find(dep->second) != seen_deps.end())
+ {
+ os << " <I>(Circular dependency!)</I>";
+ break; // circular dependency!!!
+ }
+ seen_deps.insert(dep->second);
+ last_dep = dep;
+ dep = m_dependencies.find(dep->second);
+ if((dep == m_dependencies.end()) || (0 == compare_paths(dep->second, last_dep->second)))
+ break;
+ }
+ os << "\n";
+ ++fi;
+ }
+ os << "</pre></BLOCKQUOTE>\n";
+
+ os << "</body></html>\n";
+
+ if(!os)
+ {
+ std::string msg("Error writing to ");
+ msg += m_dest_path.string();
+ msg += ".";
+ std::runtime_error e(msg);
+ boost::throw_exception(e);
+ }
+
+}
diff --git a/src/boost/tools/bcp/path_operations.cpp b/src/boost/tools/bcp/path_operations.cpp
new file mode 100644
index 000000000..aebbc4e6f
--- /dev/null
+++ b/src/boost/tools/bcp/path_operations.cpp
@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright (c) 2003 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 path comparisons
+ */
+
+
+#include "bcp_imp.hpp"
+#include <cctype>
+
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{
+ using ::tolower;
+}
+#endif
+
+
+int compare_paths(const fs::path& a, const fs::path& b)
+{
+ const std::string& as = a.generic_string();
+ const std::string& bs = b.generic_string();
+ std::string::const_iterator i, j, k, l;
+ i = as.begin();
+ j = as.end();
+ k = bs.begin();
+ l = bs.end();
+ while(i != j)
+ {
+ if(k == l)
+ return -1;
+ int r = std::tolower(*i) - std::tolower(*k);
+ if(r) return r;
+ ++i;
+ ++k;
+ }
+ return (k == l) ? 0 : 1;
+}
diff --git a/src/boost/tools/bcp/scan_cvs_path.cpp b/src/boost/tools/bcp/scan_cvs_path.cpp
new file mode 100644
index 000000000..6d2eb3a60
--- /dev/null
+++ b/src/boost/tools/bcp/scan_cvs_path.cpp
@@ -0,0 +1,147 @@
+/*
+ *
+ * Copyright (c) 2003-7 John Maddock
+ * Copyright (c) 2007 Bjorn Roald
+ * 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::scan_cvs_path(const fs::path& p)
+ */
+
+
+
+#include "bcp_imp.hpp"
+#include "fileview.hpp"
+#include <boost/regex.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <boost/detail/workaround.hpp>
+#include <iostream>
+
+void bcp_implementation::scan_cvs_path(const fs::path& p)
+{
+ //
+ // scan through the cvs admin files to build a list
+ // of all the files under cvs version control
+ // and whether they are text or binary:
+ //
+ static const char* file_list[] = { "CVS/Entries", "CVS/Entries.Log" };
+ static const boost::regex file_expression("^(?:A\\s+)?/([^/\\n]+)/[^/\\n]*/[^/\\n]*/[^k/\\n]*(kb[^/\\n]*)?/[^/\\n]*");
+ static const boost::regex dir_expression("^(?:A\\s+)?D/([^/\\n]+)/");
+ static const int file_subs[] = {1,2,};
+
+ for(std::size_t entry = 0; entry < sizeof(file_list)/sizeof(file_list[0]); ++entry)
+ {
+ fs::path entries(m_boost_path / p / file_list[entry]);
+ if(fs::exists(entries))
+ {
+ fileview view(entries);
+ boost::regex_token_iterator<const char*> i(view.begin(), view.end(), dir_expression, 1);
+ boost::regex_token_iterator<const char*> j;
+ while(i != j)
+ {
+ fs::path recursion_dir(p / i->str());
+ scan_cvs_path(recursion_dir);
+ ++i;
+ }
+ #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570))
+ std::vector<int> v(file_subs, file_subs + 2);
+ i = boost::regex_token_iterator<const char*>(view.begin(), view.end(), file_expression, v);
+ #else
+ i = boost::regex_token_iterator<const char*>(view.begin(), view.end(), file_expression, file_subs);
+ #endif
+ while(i != j)
+ {
+ fs::path file = p / i->str();
+ ++i;
+ bool binary = i->length() ? true : false;
+ ++i;
+ m_cvs_paths[file] = binary;
+ }
+
+ }
+ }
+}
+
+void bcp_implementation::scan_svn_path(const fs::path& p)
+{
+ //
+ // scan through the svn entries files to build a list
+ // of all the files under svn version control
+ // and whether they are text or binary:
+ //
+ static const boost::regex entry_expression("^\\f([^\\f]*)");
+ static const boost::regex entry_line_expression("\\n[[:blank:]]*([^\\n]*)");
+ // static const boost::regex
+ // mime_type_expression("\\nsvn:mime-type\\nV [[digit]]*\\n([^/]*)[^\\n]*");
+
+ fs::path entries(m_boost_path / p / ".svn" / "entries");
+ if(fs::exists(entries))
+ {
+ fileview view(entries);
+ boost::cregex_token_iterator
+ i(view.begin(), view.end(), entry_expression, 1), j;
+
+ while(i != j) // entries
+ {
+ std::string entr = i->str();
+ boost::sregex_token_iterator
+ atr_it(entr.begin(), entr.end(), entry_line_expression, 1), atr_j;
+
+ if(atr_it != atr_j)
+ {
+ std::string name = atr_it->str(); // name of file or directory
+ fs::path fpath = p / name;
+ if(++atr_it != atr_j)
+ {
+ std::string kind = atr_it->str();
+ if(kind == "file")
+ {
+ // find if binary, we asume text unless mime type is
+ // set in property file
+ bool binary = false; //
+
+ // skip some lines type | example
+ if( ++atr_it != atr_j && // revnum |
+ ++atr_it != atr_j && // url |
+ ++atr_it != atr_j && // repos |
+ ++atr_it != atr_j && // scedule attr |
+ ++atr_it != atr_j && // text timestamp | 2007-09-02T...
+ ++atr_it != atr_j && // checksum | 58f4bfa7860...
+ ++atr_it != atr_j && // cmt_date | 2007-05-09T...
+ ++atr_it != atr_j && // cmt_rev | 37654
+ ++atr_it != atr_j && // cmt_author | dgregor
+ ++atr_it != atr_j ) // has_props | has-props
+ {
+ if(atr_it->str() == "has-props")
+ {
+ // we need to check properties file for mime-type
+ // that does not start with "text/", if found file is binary
+ fs::path properties(m_boost_path / p / ".svn" / "prop-base"
+ / (name + ".svn-base") );
+ if(fs::exists(properties))
+ {
+ fileview prop(properties);
+
+ static const boost::regex mime_type(
+ "svn:mime-type[[:blank:]]*(?:\\n|\\r|\\r\\n)[^\\r\\n]*(?:\\n|\\r|\\r\\n)[[:blank:]]*text/");
+ binary = regex_search(prop.begin(), prop.end(), mime_type) ? false : true;
+ }
+ }
+ }
+ m_cvs_paths[fpath] = binary;
+ } // kind == "file"
+ else if(kind == "dir")
+ {
+ scan_svn_path(fpath); // recursion for directory entries
+ }
+ // else
+ // std::cerr << "WARNING: unknown entry kind for entry " << name
+ // << "in " << entries << std::endl;
+ }
+ }
+ ++i;
+ } // while
+ }
+}
diff --git a/src/boost/tools/bcp/scan_licence.cpp b/src/boost/tools/bcp/scan_licence.cpp
new file mode 100644
index 000000000..4dc461c14
--- /dev/null
+++ b/src/boost/tools/bcp/scan_licence.cpp
@@ -0,0 +1,275 @@
+/*
+ *
+ * Copyright (c) 2003 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)
+ *
+ */
+
+#include "licence_info.hpp"
+#include "bcp_imp.hpp"
+#include "fileview.hpp"
+#include <fstream>
+#include <iostream>
+
+
+const int boost_license_lines = 3;
+static const std::string boost_license_text[boost_license_lines] = {
+ "Distributed under 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)"
+};
+
+fileview::const_iterator
+context_before_license(const fileview& v, fileview::const_iterator start,
+ int context_lines = 3)
+{
+ char last_char = '\0';
+ while (start != v.begin() && context_lines >= 0) {
+ if (((*start == '\r') || (*start == '\n'))
+ && ((last_char == *start) || ((last_char != '\r') && (last_char != '\n'))))
+ --context_lines;
+
+ last_char = *start;
+ --start;
+ }
+
+ // Unless we hit the beginning, we need to step forward one to start
+ // on the next line.
+ if (start != v.begin()) ++start;
+
+ return start;
+}
+
+fileview::const_iterator
+context_after_license(const fileview& v, fileview::const_iterator end,
+ int context_lines = 3)
+{
+ char last_char = '\0';
+ while (end != v.end() && context_lines >= 0) {
+ if ((*end == '\r' || *end == '\n')
+ && (last_char == *end || (last_char != '\r' && last_char != '\n')))
+ --context_lines;
+
+ last_char = *end;
+ ++end;
+ }
+
+ return end;
+}
+
+static std::string
+find_prefix(const fileview& v, fileview::const_iterator start_of_line)
+{
+ while (start_of_line != v.begin()
+ && *start_of_line != '\n'
+ && *start_of_line != '\r')
+ --start_of_line;
+ if (start_of_line != v.begin())
+ ++start_of_line;
+
+ fileview::const_iterator first_noncomment_char = start_of_line;
+ while (*first_noncomment_char == '/'
+ || *first_noncomment_char == '*'
+ || *first_noncomment_char == ' '
+ || *first_noncomment_char == '#')
+ ++first_noncomment_char;
+
+ return std::string(start_of_line, first_noncomment_char);
+}
+
+static std::string
+html_escape(fileview::const_iterator first, fileview::const_iterator last)
+{
+ std::string result;
+ while (first != last) {
+ switch (*first) {
+ case '<': result += "&lt;"; break;
+ case '>': result += "&gt;"; break;
+ case '&': result += "&amp;"; break;
+ default: result += *first;
+ }
+ ++first;
+ }
+ return result;
+}
+
+static bool is_non_bsl_license(int index)
+{
+ return index > 2;
+}
+
+void bcp_implementation::scan_license(const fs::path& p, const fileview& v)
+{
+ std::pair<const license_info*, int> licenses = get_licenses();
+ //
+ // scan file for all the licenses in the list:
+ //
+ int license_count = 0;
+ int author_count = 0;
+ int nonbsl_author_count = 0;
+ bool has_non_bsl_license = false;
+ fileview::const_iterator start_of_license = v.begin(),
+ end_of_license = v.end();
+ bool start_in_middle_of_line = false;
+
+ for(int i = 0; i < licenses.second; ++i)
+ {
+ boost::match_results<fileview::const_iterator> m;
+ if(boost::regex_search(v.begin(), v.end(), m, licenses.first[i].license_signature))
+ {
+ start_of_license = m[0].first;
+ end_of_license = m[0].second;
+
+ if (is_non_bsl_license(i) && i < licenses.second - 1)
+ has_non_bsl_license = true;
+
+ // add this license to the list:
+ m_license_data[i].files.insert(p);
+ ++license_count;
+ //
+ // scan for the associated copyright declarations:
+ //
+ boost::regex_iterator<const char*> cpy(v.begin(), v.end(), licenses.first[i].copyright_signature);
+ boost::regex_iterator<const char*> ecpy;
+ while(cpy != ecpy)
+ {
+#if 0
+ // Not dealing with copyrights because we don't have the years
+ if ((*cpy)[0].first < start_of_license)
+ start_of_license = (*cpy)[0].first;
+ if ((*cpy)[0].second > end_of_license)
+ end_of_license = (*cpy)[0].second;
+#endif
+
+ // extract the copy holders as a list:
+ std::string author_list = cpy->format(licenses.first[i].copyright_formatter, boost::format_all);
+ // now enumerate that list for all the names:
+ static const boost::regex author_separator("(?:\\s*,(?!\\s*(?:inc|ltd)\\b)\\s*|\\s+(,\\s*)?(and|&)\\s+)|by\\s+", boost::regex::perl | boost::regex::icase);
+ boost::regex_token_iterator<std::string::const_iterator> atr(author_list.begin(), author_list.end(), author_separator, -1);
+ boost::regex_token_iterator<std::string::const_iterator> eatr;
+ while(atr != eatr)
+ {
+ // get the reformatted authors name:
+ std::string name = format_authors_name(*atr);
+ // add to list of authors for this file:
+ if(name.size() && name[0] != '-')
+ {
+ m_license_data[i].authors.insert(name);
+ // add file to author index:
+ m_author_data[name].insert(p);
+ ++author_count;
+
+ // If this is not the Boost Software License (license 0), and the author hasn't given
+ // blanket permission, note this for the report.
+ if (has_non_bsl_license
+ && m_bsl_authors.find(name) == m_bsl_authors.end()) {
+ ++nonbsl_author_count;
+ m_authors_for_bsl_migration.insert(name);
+ }
+ }
+ ++atr;
+ }
+ ++cpy;
+ }
+
+ while (start_of_license != v.begin()
+ && *start_of_license != '\r'
+ && *start_of_license != '\n'
+ && *start_of_license != '.')
+ --start_of_license;
+
+ if (start_of_license != v.begin()) {
+ if (*start_of_license == '.')
+ start_in_middle_of_line = true;
+ ++start_of_license;
+ }
+
+ while (end_of_license != v.end()
+ && *end_of_license != '\r'
+ && *end_of_license != '\n')
+ ++end_of_license;
+ }
+ }
+ if(license_count == 0)
+ m_unknown_licenses.insert(p);
+ if(license_count && !author_count)
+ m_unknown_authors.insert(p);
+
+ if (has_non_bsl_license) {
+ bool converted = false;
+ if (nonbsl_author_count == 0
+ && license_count == 1) {
+ // Grab a few lines of context
+ fileview::const_iterator context_start =
+ context_before_license(v, start_of_license);
+ fileview::const_iterator context_end =
+ context_after_license(v, end_of_license);
+
+ // TBD: For files that aren't C++ code, this will have to
+ // change.
+ std::string prefix = find_prefix(v, start_of_license);
+
+ // Create enough information to permit manual verification of
+ // the correctness of the transformation
+ std::string before_conversion =
+ html_escape(context_start, start_of_license);
+ before_conversion += "<b>";
+ before_conversion += html_escape(start_of_license, end_of_license);
+ before_conversion += "</b>";
+ before_conversion += html_escape(end_of_license, context_end);
+
+ std::string after_conversion =
+ html_escape(context_start, start_of_license);
+ if (start_in_middle_of_line)
+ after_conversion += '\n';
+
+ after_conversion += "<b>";
+ for (int i = 0; i < boost_license_lines; ++i) {
+ if (i > 0) after_conversion += '\n';
+ after_conversion += prefix + boost_license_text[i];
+ }
+ after_conversion += "</b>";
+ after_conversion += html_escape(end_of_license, context_end);
+
+ m_converted_to_bsl[p] =
+ std::make_pair(before_conversion, after_conversion);
+
+ // Perform the actual conversion
+ if (m_bsl_convert_mode) {
+ try{
+ std::ofstream out((m_boost_path / p).string().c_str());
+ if (!out) {
+ std::string msg("Cannot open file for license conversion: ");
+ msg += p.string();
+ std::runtime_error e(msg);
+ boost::throw_exception(e);
+ }
+
+ out << std::string(v.begin(), start_of_license);
+ if (start_in_middle_of_line)
+ out << std::endl;
+
+ for (int j = 0; j < boost_license_lines; ++j) {
+ if (j > 0) out << std::endl;
+ out << prefix << boost_license_text[j];
+ }
+ out << std::string(end_of_license, v.end());
+
+ converted = true;
+ }
+ catch(const std::exception& e)
+ {
+ std::cerr << e.what() << std::endl;
+ }
+ }
+ }
+
+ if (!converted) {
+ if (nonbsl_author_count > 0) m_cannot_migrate_to_bsl.insert(p);
+ else m_can_migrate_to_bsl.insert(p);
+ }
+ }
+}
+
diff --git a/src/boost/tools/bcp/test/Jamfile.v2 b/src/boost/tools/bcp/test/Jamfile.v2
new file mode 100644
index 000000000..bea522489
--- /dev/null
+++ b/src/boost/tools/bcp/test/Jamfile.v2
@@ -0,0 +1,25 @@
+# (C) Copyright John Maddock 2006.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+
+path-constant boost-path : ../../.. ;
+
+run
+ # sources
+ ../add_dependent_lib.cpp ../add_path.cpp ../bcp_imp.cpp ../copy_path.cpp ../file_types.cpp
+ ../fileview.cpp ../main.cpp ../path_operations.cpp ../scan_cvs_path.cpp
+ ../licence_info.cpp ../scan_licence.cpp ../output_licence_info.cpp
+ /boost/filesystem//boost_filesystem
+ /boost/regex//boost_regex
+ /boost/test//boost_prg_exec_monitor
+ : # args
+ --boost=$(boost-path) --list boost
+ : # input-files
+ : # requirements
+ release
+ : # target-name
+ bcp-test
+ : # default-build
+ release
+ ;
+