// 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

"\\)"

"\\{" // start of definition

"|"

"(\\<\\w+\\>)" // Maybe class name

"\\s*"

"(?:<[^>;{]*>)?" // Maybe template specialisation

"::\\s*"

"~?\\1" // function name, same as class name

"\\s*"

"\\("

"[^\\(\\);{}]*" // argument list

"\\)"

"\\{" // 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 =

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]";

}

/*

*

* Copyright (c) 2003 Dr John Maddock

* 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/regex.hpp>

#include <fstream>

#include <iterator>

#include <algorithm>

#include <iostream>

struct get_new_library_name

get_new_library_name(const std::string& n) : m_new_name(n) {}

template <class I>

std::string operator()(const boost::match_results<I>& what)

{

std::string s = what[0];

std::string::size_type n = s.find("boost");

if(n == std::string::npos)

{

s.insert(0, m_new_name);

}

else

{

s.replace(n, 5, m_new_name);

}

return s;

}

private:

std::string m_new_name;

};

void bcp_implementation::copy_path(const fs::path& p)

{

assert(!fs::is_directory(m_boost_path / p));

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")

{

static std::vector<char> v1, v2;

v1.clear();

v2.clear();

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();

if(m_unix_lines)

else

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();

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();

if(m_unix_lines)

else

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.

// ends up in v2: we then swap v1 and v2, and clear v2.

//

static std::vector<char> v1, v2;

v1.clear();

v2.clear();

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*\\))"

")"

);

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(

/*

"\\s*"

"("

"\\{"

"(?:"

"(?>[^\\{\\}/]+)"

"(?>"

"(?:"

"(?1)"

"|//[^\\n]+$"

"|/[^/]"

"|(?:^\\s*#[^\\n]*"

"(?:(?<=\\\\)\\n[^\\n]*)*)"

")"

"[^\\{\\}]+"

")*"

")*"

"\\}"

")"

*/

/*

"\\s*\\{.*"

"\\})([^\\{\\};]*)\\z"

*/

"(namespace)(\\s+)(" + m_namespace_name + ")"

"(adstl|phoenix|rapidxml)?(\\s*\\{)"

);

"$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();

}

if(m_unix_lines)

else

if(v1.size())

os.write(&*v1.begin(), v1.size());

os.close();

}

else if(m_unix_lines && !is_binary_file(p))

{

std::istreambuf_iterator<char> isi(is);

std::istreambuf_iterator<char> end;

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);

}

}

/*

*

* Copyright (c) 2003 Dr John Maddock

* 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 <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();

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