tools/bcp/add_path.cpp

   1 /*
   2  *
   3  * Copyright (c) 2003 Dr John Maddock
   4  * Use, modification and distribution is subject to the
   5  * Boost Software License, Version 1.0. (See accompanying file
   6  * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   7  *
   8  * This file implements the following:
   9  *    void bcp_implementation::add_path(const fs::path& p)
  10  *    void bcp_implementation::add_directory(const fs::path& p)
  11  *    void bcp_implementation::add_file(const fs::path& p)
  12  *    void bcp_implementation::add_dependent_lib(const std::string& libname, const fs::path& p, const fileview& view)
  13  */
  14
  15 #include "bcp_imp.hpp"
  16 #include "fileview.hpp"
  17 #include <boost/regex.hpp>
  18 #include <boost/filesystem/operations.hpp>
  19 #include <boost/filesystem/exception.hpp>
  20 #include <iostream>
  21
  22
  23 void bcp_implementation::add_path(const fs::path& p)
  24 {
  25    fs::path normalized_path = p;
  26     normalized_path.normalize();
  27    if(fs::exists(m_boost_path / normalized_path))
  28    {
  29       if(fs::is_directory(m_boost_path / normalized_path))
  30          add_directory(normalized_path);
  31       else
  32          add_file(normalized_path);
  33    }
  34    else
  35    {
  36       std::cerr << "CAUTION: dependent file " << p.string() << " does not exist." << std::endl;
  37       std::cerr << "   Found while scanning file " << m_dependencies[p].string() << std::endl;
  38    }
  39 }
  40
  41 void bcp_implementation::add_directory(const fs::path& p)
  42 {
  43    //
  44    // Don't add files created by build system:
  45    //
  46    if((p.leaf() == "bin") || (p.leaf() == "bin-stage"))
  47       return;
  48    //
  49    // Don't add version control directories:
  50    //
  51    if((p.leaf() == "CVS") || (p.leaf() == ".svn"))
  52       return;
  53    //
  54    // don't add directories not under version control:
  55    //
  56    if(m_cvs_mode && !fs::exists(m_boost_path / p / "CVS/Entries"))
  57       return;
  58    if(m_svn_mode && !fs::exists(m_boost_path / p / ".svn/entries"))
  59       return;
  60    //
  61    // enermerate files and directories:
  62    //
  63    fs::directory_iterator i(m_boost_path / p);
  64    fs::directory_iterator j;
  65    while(i != j)
  66    {
  67       //
  68       // we need to convert *i back into
  69       // a relative path, what follows is a hack:
  70       //
  71       std::string s(i->path().string());
  72       if(m_boost_path.string().size())
  73          s.erase(0, m_boost_path.string().size() + 1);
  74       fs::path np = s;
  75       if(!m_dependencies.count(np))
  76       {
  77          m_dependencies[np] = p; // set up dependency tree
  78          add_pending_path(np);
  79       }
  80       ++i;
  81    }
  82 }
  83
  84 void bcp_implementation::add_file(const fs::path& p)
  85 {
  86    //
  87    // if the file does not exist in cvs then don't do anything with it:
  88    //
  89    if((m_cvs_mode || m_svn_mode) && (m_cvs_paths.find(p) == m_cvs_paths.end()))
  90       return;
  91    //
  92    // if we've already seen the file return:
  93    //
  94    if(m_copy_paths.find(p) != m_copy_paths.end())
  95       return;
  96    //
  97    // add the file to our list:
  98    //
  99    m_copy_paths.insert(p);
 100    //
 101    // if this is a source file, scan for dependencies:
 102    //
 103    if(is_source_file(p))
 104    {
 105       add_file_dependencies(p, false);
 106    }
 107    if(is_jam_file(p) && m_namespace_name.size() && ((std::distance(p.begin(), p.end()) < 3) || (*p.begin() != "tools") || (*++p.begin() != "build")))
 108    {
 109       //
 110       // We're doing a rename of namespaces and library names
 111       // so scan for names of libraries:
 112       //
 113       static const boost::regex e(
 114          "\\<lib\\s+(boost\\w+)\\s+[:;]"
 115          );
 116
 117       fileview view(m_boost_path / p);
 118       boost::regex_token_iterator<const char*> i(view.begin(), view.end(), e, 1);
 119       boost::regex_token_iterator<const char*> j;
 120       while(i != j)
 121       {
 122          m_lib_names.insert(*i);
 123          ++i;
 124       }
 125       static const std::pair<fs::path, std::string> specials_library_names[] = {
 126             std::pair<fs::path, std::string>("libs/python/build/Jamfile.v2", "boost_python"),
 127             std::pair<fs::path, std::string>("libs/python/build/Jamfile.v2", "boost_python3"),
 128       };
 129
 130       for(unsigned int n = 0; n < (sizeof(specials_library_names)/sizeof(specials_library_names[0])); ++n)
 131       {
 132          if(0 == compare_paths(specials_library_names[n].first, p))
 133          {
 134             m_lib_names.insert(specials_library_names[n].second);
 135          }
 136       }
 137    }
 138    //
 139    // if this is a html file, scan for dependencies:
 140    //
 141    if(is_html_file(p))
 142    {
 143       static const boost::regex e(
 144          "<(?:img[^>]*src=|link[^>]*href=)(\"[^\"]+\"|\\w+)[^>]*>"
 145          );
 146
 147       fileview view(m_boost_path / p);
 148       boost::regex_token_iterator<const char*> i(view.begin(), view.end(), e, 1);
 149       boost::regex_token_iterator<const char*> j;
 150       while(i != j)
 151       {
 152          //
 153          // extract the dependent name:
 154          //
 155          std::string s(*i);
 156          if(s[0] == '\"')
 157          {
 158             // remove quotes:
 159             assert(s.size() > 2);
 160             s.erase(0, 1);
 161             s.erase(s.size() - 1);
 162          }
 163          //
 164          // Remove any target suffix:
 165          //
 166          std::string::size_type n = s.find('#');
 167          if(n != std::string::npos)
 168          {
 169             s.erase(n);
 170          }
 171          //
 172          // if the name starts with ./ remove it
 173          // or we'll get an error:
 174          if(s.compare(0, 2, "./") == 0)
 175             s.erase(0, 2);
 176          if(s.find(':') == std::string::npos)
 177          {
 178             // only concatonate if it's a relative path
 179             // rather than a URL:
 180             fs::path dep(p.branch_path() / s);
 181             if(!m_dependencies.count(dep))
 182             {
 183                m_dependencies[dep] = p; // set up dependency tree
 184                add_pending_path(dep);
 185             }
 186          }
 187          ++i;
 188       }
 189    }
 190    //
 191    // now scan for "special" dependencies:
 192    // anything that we can't automatically detect...
 193    //
 194 static const std::pair<fs::path, fs::path>
 195    specials[] = {
 196       std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "libs/predef/check"),
 197       std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "libs/predef/tools"),
 198       std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "tools/boost_install/boost-install.jam"),
 199       std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "tools/boost_install/boost-install-dirs.jam"),
 200       std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "tools/boost_install/Jamfile"),
 201       std::pair<fs::path, fs::path>("tools/build/src/kernel/modules.jam", "libs/headers"),
 202       std::pair<fs::path, fs::path>("libs/test/build/Jamfile.v2", "libs/timer/src"),
 203       std::pair<fs::path, fs::path>("libs/test/build/Jamfile.v2", "libs/timer/build"),
 204       std::pair<fs::path, fs::path>("boost/atomic/capabilities.hpp", "boost/atomic/detail"),
 205       std::pair<fs::path, fs::path>("boost/chrono/chrono.hpp", "libs/chrono/src"),
 206       std::pair<fs::path, fs::path>("boost/chrono/chrono.hpp", "libs/chrono/build"),
 207       std::pair<fs::path, fs::path>("boost/context/execution_context.hpp", "libs/context/src"),
 208       std::pair<fs::path, fs::path>("boost/context/execution_context.hpp", "libs/context/build"),
 209       std::pair<fs::path, fs::path>("boost/context/fcontext.hpp", "libs/context/src"),
 210       std::pair<fs::path, fs::path>("boost/context/fcontext.hpp", "libs/context/build"),
 211       std::pair<fs::path, fs::path>("boost/context/fixedsize_stack.hpp", "libs/context/src"),
 212       std::pair<fs::path, fs::path>("boost/context/fixedsize_stack.hpp", "libs/context/build"),
 213       std::pair<fs::path, fs::path>("boost/context/protected_fixedsize_stack.hpp", "libs/context/src"),
 214       std::pair<fs::path, fs::path>("boost/context/protected_fixedsize_stack.hpp", "libs/context/build"),
 215       std::pair<fs::path, fs::path>("boost/context/segmented_stack.hpp", "libs/context/src"),
 216       std::pair<fs::path, fs::path>("boost/context/segmented_stack.hpp", "libs/context/build"),
 217       std::pair<fs::path, fs::path>("boost/context/stack_context.hpp", "libs/context/src"),
 218       std::pair<fs::path, fs::path>("boost/context/stack_context.hpp", "libs/context/build"),
 219       std::pair<fs::path, fs::path>("boost/context/stack_traits.hpp", "libs/context/src"),
 220       std::pair<fs::path, fs::path>("boost/context/stack_traits.hpp", "libs/context/build"),
 221       std::pair<fs::path, fs::path>("boost/cerrno.hpp", "libs/system/build"),
 222       std::pair<fs::path, fs::path>("boost/cerrno.hpp", "libs/system/src"),
 223       std::pair<fs::path, fs::path>("libs/thread/build", "boost/system"),
 224       std::pair<fs::path, fs::path>("libs/thread/build", "boost/cerrno.hpp"),
 225       std::pair<fs::path, fs::path>("libs/thread/build", "boost/chrono"),
 226       std::pair<fs::path, fs::path>("boost/filesystem/convenience.hpp", "boost/filesystem.hpp"),
 227       std::pair<fs::path, fs::path>("boost/filesystem/exception.hpp", "boost/filesystem.hpp"),
 228       std::pair<fs::path, fs::path>("boost/filesystem/fstream.hpp", "boost/filesystem.hpp"),
 229       std::pair<fs::path, fs::path>("boost/filesystem/operations.hpp", "boost/filesystem.hpp"),
 230       std::pair<fs::path, fs::path>("boost/filesystem/path.hpp", "boost/filesystem.hpp"),
 231       std::pair<fs::path, fs::path>("boost/filesystem.hpp", "libs/filesystem/build"),
 232       std::pair<fs::path, fs::path>("boost/filesystem.hpp", "libs/filesystem/v2"),
 233       std::pair<fs::path, fs::path>("boost/filesystem.hpp", "libs/filesystem/v3"),
 234       std::pair<fs::path, fs::path>("boost/config.hpp", "boost/config"),
 235       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "libs/config/checks"),
 236       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "libs/config/test"),
 237       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "libs/headers/build"),
 238       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "tools/boost_install/BoostConfig.cmake"),
 239       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "tools/boost_install/BoostDetectToolset.cmake"),
 240       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "tools/boost_install/boost-install.jam"),
 241       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "tools/boost_install/boost-install-dirs.jam"),
 242       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "boost-build.jam"),
 243       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "boostcpp.jam"),
 244       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "bootstrap.bat"),
 245       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "bootstrap.sh"),
 246       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "Jamroot"),
 247       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "INSTALL"),
 248       std::pair<fs::path, fs::path>("tools/build/boost-build.jam", "LICENSE_1_0.txt"),
 249       std::pair<fs::path, fs::path>("boost/preprocessor/iterate.hpp", "boost/preprocessor/iteration"),
 250       std::pair<fs::path, fs::path>("boost/preprocessor/slot/slot.hpp", "boost/preprocessor/slot/detail"),
 251       std::pair<fs::path, fs::path>("boost/function.hpp", "boost/function/detail"),
 252       std::pair<fs::path, fs::path>("boost/regex/config.hpp", "boost/regex/user.hpp"),
 253       std::pair<fs::path, fs::path>("boost/signals/signal_template.hpp", "boost/function"),
 254       std::pair<fs::path, fs::path>("boost/mpl/list.hpp", "boost/mpl/list"),
 255       std::pair<fs::path, fs::path>("boost/mpl/list_c.hpp", "boost/mpl/list"),
 256       std::pair<fs::path, fs::path>("boost/mpl/vector.hpp", "boost/mpl/vector"),
 257       std::pair<fs::path, fs::path>("boost/mpl/deque.hpp", "boost/mpl/vector"),
 258       std::pair<fs::path, fs::path>("boost/mpl/vector_c.hpp", "boost/mpl/vector"),
 259       std::pair<fs::path, fs::path>("boost/mpl/map.hpp", "boost/mpl/map"),
 260       std::pair<fs::path, fs::path>("boost/mpl/set.hpp", "boost/mpl/set"),
 261       std::pair<fs::path, fs::path>("boost/mpl/set_c.hpp", "boost/mpl/set"),
 262       std::pair<fs::path, fs::path>("boost/mpl/aux_/include_preprocessed.hpp", "boost/mpl/aux_/preprocessed"),
 263       std::pair<fs::path, fs::path>("boost/mpl/vector/aux_/include_preprocessed.hpp", "boost/mpl/vector/aux_/preprocessed"),
 264       std::pair<fs::path, fs::path>("boost/mpl/set/aux_/include_preprocessed.hpp", "boost/mpl/set/aux_/preprocessed"),
 265       std::pair<fs::path, fs::path>("boost/mpl/map/aux_/include_preprocessed.hpp", "boost/mpl/map/aux_/preprocessed"),
 266       std::pair<fs::path, fs::path>("boost/mpl/list/aux_/include_preprocessed.hpp", "boost/mpl/list/aux_/preprocessed"),
 267       std::pair<fs::path, fs::path>("libs/graph/src/python/visitor.hpp", "libs/graph/src/python"),
 268       std::pair<fs::path, fs::path>("boost/test/detail/config.hpp", "libs/test/src"),
 269       std::pair<fs::path, fs::path>("boost/test/detail/config.hpp", "libs/test/build"),
 270       std::pair<fs::path, fs::path>("boost/test/detail/config.hpp", "libs/predef/build.jam"),
 271       std::pair<fs::path, fs::path>("boost/test/detail/config.hpp", "libs/predef/check"),
 272       std::pair<fs::path, fs::path>("boost/typeof.hpp", "boost/typeof/incr_registration_group.hpp"),
 273       std::pair<fs::path, fs::path>("boost/function_types/detail/pp_loop.hpp", "boost/function_types/detail/pp_cc_loop"),
 274       std::pair<fs::path, fs::path>("boost/function_types/components.hpp", "boost/function_types/detail/components_impl"),
 275       std::pair<fs::path, fs::path>("boost/function_types/detail/pp_loop.hpp", "boost/function_types/detail"),
 276       std::pair<fs::path, fs::path>("boost/math/tools/rational.hpp", "boost/math/tools/detail"),
 277       std::pair<fs::path, fs::path>("boost/proto/repeat.hpp", "boost/proto/detail/local.hpp"),
 278       std::pair<fs::path, fs::path>("boost/signals/signal_template.hpp", "boost/function"),
 279       std::pair<fs::path, fs::path>("boost/preprocessor/slot/counter.hpp", "boost/preprocessor/slot/detail/counter.hpp"),
 280       std::pair<fs::path, fs::path>("boost/graph/distributed/detail/tag_allocator.hpp", "libs/graph_parallel"),
 281       std::pair<fs::path, fs::path>("boost/graph/distributed/mpi_process_group.hpp", "libs/graph_parallel"),
 282       std::pair<fs::path, fs::path>("libs/coroutine/build/Jamfile.v2", "libs/context/src"),
 283       std::pair<fs::path, fs::path>("libs/coroutine/build/Jamfile.v2", "libs/context/build"),
 284       std::pair<fs::path, fs::path>("libs/fiber/build/Jamfile.v2", "libs/context/src"),
 285       std::pair<fs::path, fs::path>("libs/fiber/build/Jamfile.v2", "libs/context/build"),
 286    };
 287
 288    for(unsigned int n = 0; n < (sizeof(specials)/sizeof(specials[0])); ++n)
 289    {
 290       if(0 == compare_paths(specials[n].first, p))
 291       {
 292          if(!m_dependencies.count(specials[n].second))
 293          {
 294             m_dependencies[specials[n].second] = p; // set up dependency tree
 295             add_pending_path(specials[n].second);
 296          }
 297       }
 298    }
 299
 300 }
 301
 302 void bcp_implementation::add_file_dependencies(const fs::path& p, bool scanfile)
 303 {
 304    static const boost::regex e(
 305       "^[[:blank:]]*(?://@bcp[[:blank:]]+([^\\n]*)\n)?#[[:blank:]]*include[[:blank:]]*[\"<]([^\">]+)[\">]"
 306       );
 307
 308    if(!m_dependencies.count(p))
 309       m_dependencies[p] = p; // set terminal dependency
 310
 311    fileview view;
 312    if(scanfile)
 313       view.open(p);
 314    else
 315       view.open(m_boost_path / p);
 316    if(m_license_mode && !scanfile)
 317       scan_license(p, view);
 318    const int subs[] = { 1, 2 };
 319    boost::regex_token_iterator<const char*> i(view.begin(), view.end(), e, subs);
 320    boost::regex_token_iterator<const char*> j;
 321    while(i != j)
 322    {
 323       //
 324       // *i contains the name of the include file,
 325       // check first for a file of that name in the
 326       // same directory as the file we are scanning,
 327       // and if that fails, then check the boost-root:
 328       //
 329       fs::path include_file;
 330       try{
 331          std::string discart_message = *i;
 332          ++i;
 333          if(discart_message.size())
 334          {
 335             // The include is optional and should be discarded:
 336             std::cout << "Optional functionality won't be copied: " << discart_message << std::endl;
 337             std::cout << "Add the file " << *i << " to the list of dependencies to extract to copy this functionality." << std::endl;
 338             ++i;
 339             continue;
 340          }
 341          include_file = i->str();
 342          fs::path test_file(m_boost_path / p.branch_path() / include_file);
 343          if(fs::exists(test_file) && !fs::is_directory(test_file) && (p.branch_path().string() != "boost"))
 344          {
 345             if(!m_dependencies.count(p.branch_path() / include_file))
 346             {
 347                m_dependencies[p.branch_path() / include_file] = p;
 348                add_pending_path(p.branch_path() / include_file);
 349             }
 350          }
 351          else if(fs::exists(m_boost_path / include_file))
 352          {
 353             if(!m_dependencies.count(include_file))
 354             {
 355                m_dependencies[include_file] = p;
 356                add_pending_path(include_file);
 357             }
 358          }
 359          ++i;
 360       }
 361       catch(const fs::filesystem_error&)
 362       {
 363          std::cerr << "Can't parse filename " << *i << " included by file " << p.string() << std::endl;
 364          ++i;
 365          continue;
 366       }
 367    }
 368    //
 369    // Now we need to scan for Boost.Preprocessor includes that
 370    // are included via preprocessor iteration:
 371    //
 372    static const boost::regex ppfiles("^[[:blank:]]*#[[:blank:]]*define[[:blank:]]+(?:BOOST_PP_FILENAME|BOOST_PP_ITERATION_PARAMS|BOOST_PP_INDIRECT_SELF)(?:[^\\n]|\\\\\\n)+?[\"<]([^\">]+)[\">]");
 373    i = boost::regex_token_iterator<const char*>(view.begin(), view.end(), ppfiles, 1);
 374    while(i != j)
 375    {
 376       //
 377       // *i contains the name of the include file,
 378       // check first for a file of that name in the
 379       // same directory as the file we are scanning,
 380       // and if that fails, then check the boost-root:
 381       //
 382       fs::path include_file;
 383       try{
 384          include_file = i->str();
 385       }
 386       catch(const fs::filesystem_error&)
 387       {
 388          std::cerr << "Can't parse filename " << *i << " included by file " << p.string() << std::endl;
 389          ++i;
 390          continue;
 391       }
 392       fs::path test_file(m_boost_path / p.branch_path() / include_file);
 393       if(fs::exists(test_file) && !fs::is_directory(test_file) && (p.branch_path().string() != "boost"))
 394       {
 395          if(!m_dependencies.count(p.branch_path() / include_file))
 396          {
 397             m_dependencies[p.branch_path() / include_file] = p;
 398             add_pending_path(p.branch_path() / include_file);
 399          }
 400       }
 401       else if(fs::exists(m_boost_path / include_file))
 402       {
 403          if(!m_dependencies.count(include_file))
 404          {
 405             m_dependencies[include_file] = p;
 406             add_pending_path(include_file);
 407          }
 408       }
 409       else
 410       {
 411          std::cerr << "CAUTION: Boost.Preprocessor iterated file " << include_file.string() << " does not exist." << std::endl;
 412       }
 413       ++i;
 414    }
 415
 416    //
 417    // Scan for any #include MACRO includes that we don't recognise.
 418    //
 419    // Begin by declaring all of the macros that get #included that
 420    // we know about and are correctly handled as special cases:
 421    //
 422    static const std::string known_macros[] = {
 423       "AUX778076_INCLUDE_STRING",
 424       "BOOST_PP_STRINGIZE(boost/mpl/aux_/preprocessed/AUX778076_PREPROCESSED_HEADER)",
 425       "BOOST_USER_CONFIG",
 426       "BOOST_COMPILER_CONFIG",
 427       "BOOST_STDLIB_CONFIG",
 428       "BOOST_PLATFORM_CONFIG",
 429       "BOOST_PP_FILENAME_1",
 430       "BOOST_PP_ITERATION_PARAMS_1",
 431       "BOOST_PP_FILENAME_2",
 432       "BOOST_PP_ITERATION_PARAMS_2",
 433       "BOOST_PP_FILENAME_3",
 434       "BOOST_PP_ITERATION_PARAMS_3",
 435       "BOOST_PP_FILENAME_4",
 436       "BOOST_PP_ITERATION_PARAMS_4",
 437       "BOOST_PP_FILENAME_5",
 438       "BOOST_PP_ITERATION_PARAMS_5",
 439       "BOOST_PP_INDIRECT_SELF",
 440       "BOOST_PP_INCLUDE_SELF()",
 441       "BOOST_PP_ITERATE",
 442       "BOOST_PP_LOCAL_ITERATE",
 443       "BOOST_PP_ITERATE()",
 444       "BOOST_PP_LOCAL_ITERATE()",
 445       "BOOST_PP_ASSIGN_SLOT(1)",
 446       "BOOST_PP_ASSIGN_SLOT(2)",
 447       "BOOST_PP_ASSIGN_SLOT(3)",
 448       "BOOST_PP_ASSIGN_SLOT(4)",
 449       "BOOST_PP_ASSIGN_SLOT(5)",
 450       "BOOST_ABI_PREFIX",
 451       "BOOST_ABI_SUFFIX",
 452       "BOOST_PP_STRINGIZE(boost/mpl/aux_/preprocessed/AUX_PREPROCESSED_HEADER)",
 453       "BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_HEADER)",
 454       "BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_LIST_C_HEADER)",
 455       "BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_LIST_HEADER)",
 456       "BOOST_PP_STRINGIZE(boost/mpl/map/aux_/preprocessed/AUX778076_HEADER)",
 457       "BOOST_PP_STRINGIZE(boost/mpl/map/AUX778076_MAP_HEADER)",
 458       "BOOST_PP_STRINGIZE(boost/mpl/set/aux_/preprocessed/AUX778076_HEADER)",
 459       "BOOST_PP_STRINGIZE(boost/mpl/set/AUX778076_SET_HEADER)",
 460       "BOOST_PP_STRINGIZE(boost/mpl/set/AUX778076_SET_C_HEADER)",
 461       "BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_VECTOR_HEADER)",
 462       "BOOST_PP_STRINGIZE(boost/mpl/vector/aux_/preprocessed/AUX778076_HEADER)",
 463       "BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_DEQUE_HEADER)",
 464       "BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_VECTOR_C_HEADER)",
 465       "BOOST_REGEX_USER_CONFIG",
 466       "BGL_PYTHON_EVENTS_HEADER",
 467       "B1",
 468       "B2",
 469       "BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()",
 470       "BOOST_SLIST_HEADER",
 471       "BOOST_HASH_SET_HEADER",
 472       "BOOST_HASH_MAP_HEADER",
 473       "BOOST_INTRUSIVE_INVARIANT_ASSERT_INCLUDE",
 474       "BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT_INCLUDE",
 475       "BOOST_INTRUSIVE_SAFE_HOOK_DESTRUCTOR_ASSERT_INCLUDE",
 476       "BOOST_FT_loop",
 477       "BOOST_FT_AL_PREPROCESSED",
 478       "BOOST_FT_AL_INCLUDE_FILE",
 479       "__FILE__",
 480       "BOOST_FT_cc_file",
 481       "BOOST_FT_variate_file",
 482       "BOOST_USER_CONFIG",
 483       "BOOST_HEADER()",
 484       "BOOST_TR1_STD_HEADER(utility)",
 485       "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(tuple))",
 486       "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(random))",
 487       "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(array))",
 488       "BOOST_TR1_HEADER(cmath)",
 489       "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(complex))",
 490       "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(functional))",
 491       "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(memory))",
 492       "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(regex))",
 493       "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(type_traits))",
 494       "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(unordered_map))",
 495       "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(unordered_set))",
 496       "BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(utility))",
 497       "BOOST_PROTO_LOCAL_ITERATE()",
 498       "BOOST_SIGNAL_FUNCTION_N_HEADER",
 499       "BOOST_PP_UPDATE_COUNTER()",
 500   };
 501
 502    static const boost::regex indirect_includes("^[[:blank:]]*#[[:blank:]]*include[[:blank:]]+([^\"<][^\n]*?)[[:blank:]]*$");
 503    i = boost::regex_token_iterator<const char*>(view.begin(), view.end(), indirect_includes, 1);
 504    while(i != j)
 505    {
 506       const std::string* known_macros_end = known_macros + sizeof(known_macros)/sizeof(known_macros[0]);
 507       if(known_macros_end == std::find(known_macros, known_macros_end, i->str()))
 508       {
 509          std::cerr << "CAUTION: don't know how to trace depenencies through macro: \"" << *i << "\" in file: " << p.string() << std::endl;
 510       }
 511       ++i;
 512    }
 513    //
 514    // if the file contains a cpp_main / unit_test_main / test_main
 515    // it is dependent upon Boost.test even if it doesn't
 516    // include any of the Boost.test headers directly.
 517    //
 518    static const boost::regex m("^\\s*int\\s+(?:cpp_main|test_main|unit_test_main)");
 519    boost::cmatch what;
 520    if(boost::regex_search(view.begin(), view.end(), what, m))
 521    {
 522       add_dependent_lib("test", p, view);
 523    }
 524    if(!scanfile)
 525    {
 526       //
 527       // grab the name of the library to which the header belongs,
 528       // and if that library has source then add the source to our
 529       // list:
 530       //
 531       // this regex catches boost/libname.hpp or boost/libname/whatever:
 532       //
 533       static const boost::regex lib1("boost/([^\\./]+)(?!detail).*");
 534       boost::smatch swhat;
 535       std::string gs(p.generic_string());
 536       if(boost::regex_match(gs, swhat, lib1))
 537       {
 538          add_dependent_lib(swhat.str(1), p, view);
 539       }
 540       //
 541       // and this one catches boost/x/y/whatever (for example numeric/ublas):
 542       //
 543       static const boost::regex lib2("boost/([^/]+/[^/]+)/(?!detail).*");
 544       gs = p.generic_string();
 545       if(boost::regex_match(gs, swhat, lib2))
 546       {
 547          add_dependent_lib(swhat.str(1), p, view);
 548       }
 549    }
 550    if(m_list_namespaces)
 551    {
 552       //
 553       // scan for top level namespaces and add to our list:
 554       //
 555       static const boost::regex namespace_scanner(
 556          "^(?<!\\\\\\n)[[:blank:]]*+namespace\\s++(\\w++)\\s++(\\{[^{}]*(?:(?2)[^{}]*)*\\})"
 557          );
 558       i = boost::regex_token_iterator<const char*>(view.begin(), view.end(), namespace_scanner, 1);
 559       while(i != j)
 560       {
 561          if(m_top_namespaces.count(*i) == 0)
 562          {
 563             //std::cout << *i << " (Found in " << p << ")" << std::endl;
 564             m_top_namespaces[*i] = p;
 565          }
 566          ++i;
 567       }
 568    }
 569 }