From 19fcec84d8d7d21e796c7624e521b60d28ee21ed Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:45:59 +0200 Subject: Adding upstream version 16.2.11+ds. Signed-off-by: Daniel Baumann --- src/boost/tools/bcp/bcp_imp.cpp | 300 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 300 insertions(+) create mode 100644 src/boost/tools/bcp/bcp_imp.cpp (limited to 'src/boost/tools/bcp/bcp_imp.cpp') 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 +#include +#include +#include +#include +#include + +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::const_iterator i = m_module_list.begin(); + std::list::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::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::iterator m, n; + std::set 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(new bcp_implementation())); + return result; +} -- cgit v1.2.3