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);
}
}
}
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;
}
//
// now perform output:
//
if(m_list_namespaces)
{
// List the namespaces, in two lists, headers and source files
// first, then everything else afterwards:
//
boost::regex important_file("boost/.*|libs/[^/]*/(?:[^/]*/)?/src/.*");
std::map<std::string, fs::path>::const_iterator i, j;
i = m_top_namespaces.begin();
j = m_top_namespaces.end();
std::cout << "\n\nThe top level namespaces found for header and source files were:\n";
while(i != j)
{
if(regex_match(i->second.string(), important_file))
std::cout << i->first << " (from " << i->second << ")" << std::endl;
++i;
}
i = m_top_namespaces.begin();
std::cout << "\n\nThe top level namespaces found for all other source files were:\n";
while(i != j)
{
if(!regex_match(i->second.string(), important_file))
std::cout << i->first << " (from " << i->second << ")" << std::endl;
++i;
}
return 0;
}
std::set<fs::path, path_less>::iterator m, n;
std::set<fs::path, path_less> short_paths;
m = m_copy_paths.begin();
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;
}
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.native_file_string());
std::runtime_error e(msg);
boost::throw_exception(e);
}
// start by building a list of permitted files
// if m_cvs_mode is true:
if(m_cvs_mode)
{
scan_cvs_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)) {
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;
try{
module = fs::path(*i);
exmodule = fs::path(*i + ".hpp");
}
catch(...)
{
module = fs::path(*i, fs::native);
exmodule = fs::path(*i + ".hpp", fs::native);
}
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;
}
//
// now perform output:
//
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;
}
