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(int 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;
}
}
}
}
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;
}
