mirror of
https://github.com/boostorg/filesystem.git
synced 2026-01-27 06:52:09 +00:00
678 lines
22 KiB
C++
678 lines
22 KiB
C++
// Generate Compiler Status HTML from jam regression test output -----------//
|
|
|
|
// (C) Copyright Beman Dawes 2002. Permission to copy,
|
|
// use, modify, sell and distribute this software is granted provided this
|
|
// copyright notice appears in all copies. This software is provided "as is"
|
|
// without express or implied warranty, and with no claim as to its
|
|
// suitability for any purpose.
|
|
|
|
/*******************************************************************************
|
|
|
|
This program was designed to work unchanged on all platforms and
|
|
configurations. All output which is platform or configuration dependent
|
|
is obtained from external sources such as the Jamfile, the residue
|
|
from jam execution, the tools/build/xxx-tools.jam files, or the output
|
|
of the config_info tests.
|
|
|
|
Please avoid adding platform or configuration dependencies during
|
|
program maintenance.
|
|
|
|
*******************************************************************************/
|
|
|
|
#include "boost/filesystem/operations.hpp"
|
|
#include "boost/filesystem/fstream.hpp"
|
|
#include "tiny_xml.hpp"
|
|
namespace fs = boost::filesystem;
|
|
namespace xml = boost::tiny_xml;
|
|
|
|
#include <cstdlib> // for abort
|
|
#include <string>
|
|
#include <vector>
|
|
#include <set>
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <ctime>
|
|
#include <stdexcept>
|
|
|
|
using std::string;
|
|
|
|
const string pass_msg( "Pass" );
|
|
const string warn_msg( "<font color=\"#FF9900\"><i>Warn</i></font>" );
|
|
const string fail_msg( "<font color=\"#FF0000\">"
|
|
"<big><i>Fail</i></big>"
|
|
"</font>" );
|
|
const string missing_residue_msg( "<i>Missing</i>" );
|
|
|
|
const std::size_t max_compile_msg_size = 10000;
|
|
|
|
namespace
|
|
{
|
|
fs::path boost_root_dir;
|
|
|
|
bool ignore_pass;
|
|
bool no_warn;
|
|
bool no_links;
|
|
|
|
fs::directory_iterator end_itr;
|
|
|
|
// It's immportant for reliability that we find the same compilers for each
|
|
// test, and that they match the column header. So save the names at the
|
|
// time column headings are generated.
|
|
std::vector<string> toolsets;
|
|
|
|
fs::ifstream jamfile;
|
|
fs::ofstream report;
|
|
fs::ofstream links_file;
|
|
string links_name;
|
|
|
|
string specific_compiler; // if running on one toolset only
|
|
|
|
const string empty_string;
|
|
|
|
// convert backslashes to forward slashes -----------------------------------//
|
|
|
|
void convert_backslashes( string & s )
|
|
{
|
|
for ( string::iterator itr = s.begin(); itr != s.end(); ++itr )
|
|
if ( *itr == '\\' ) *itr = '/';
|
|
}
|
|
|
|
// extra information from target directory string ---------------------------//
|
|
|
|
string extract_test_name( const string & s )
|
|
{
|
|
string t( s );
|
|
string::size_type pos = t.find( "/bin/" );
|
|
if ( pos != string::npos ) pos += 5;
|
|
else return "";
|
|
return t.substr( pos, t.find( ".", pos ) - pos );
|
|
}
|
|
|
|
// find_file ---------------------------------------------------------------//
|
|
// given a directory to recursively search
|
|
|
|
bool find_file( const fs::path & dir_path, const string & name,
|
|
fs::path & path_found, const string & ignore_dir_named="" )
|
|
{
|
|
if ( !fs::exists( dir_path ) ) return false;
|
|
for ( fs::directory_iterator itr( dir_path ); itr != end_itr; ++itr )
|
|
if ( fs::is_directory( *itr )
|
|
&& itr->leaf() != ignore_dir_named )
|
|
{
|
|
if ( find_file( *itr, name, path_found ) ) return true;
|
|
}
|
|
else if ( itr->leaf() == name )
|
|
{
|
|
path_found = *itr;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// platform_desc -----------------------------------------------------------//
|
|
// from boost-root/status/bin/config_info.test/xxx/.../config_info.output
|
|
|
|
string platform_desc( const fs::path & boost_root_dir )
|
|
{
|
|
string result;
|
|
fs::path dot_output_path;
|
|
|
|
// the gcc config_info "Detected Platform" sometimes reports "cygwin", so
|
|
// prefer any of the other compilers.
|
|
if ( find_file( boost_root_dir << "status/bin/config_info.test",
|
|
"config_info.output", dot_output_path, "gcc" )
|
|
|| find_file( boost_root_dir << "status/bin/config_info.test",
|
|
"config_info.output", dot_output_path ) )
|
|
{
|
|
fs::ifstream file( dot_output_path );
|
|
if ( file )
|
|
{
|
|
while( std::getline( file, result ) )
|
|
{
|
|
if ( result.find( "Detected Platform: " ) == 0 )
|
|
{
|
|
result.erase( 0, 19 );
|
|
return result;
|
|
}
|
|
}
|
|
result.clear();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// version_desc ------------------------------------------------------------//
|
|
// from boost-root/status/bin/config_info.test/xxx/.../config_info.output
|
|
|
|
string version_desc( const fs::path & boost_root_dir,
|
|
const string & compiler_name )
|
|
{
|
|
string result;
|
|
fs::path dot_output_path;
|
|
if ( find_file( boost_root_dir << "status/bin/config_info.test"
|
|
<< compiler_name, "config_info.output", dot_output_path ) )
|
|
{
|
|
fs::ifstream file( dot_output_path );
|
|
if ( file )
|
|
{
|
|
if( std::getline( file, result ) )
|
|
{
|
|
string::size_type pos = result.find( "version " );
|
|
if ( pos != string::npos )
|
|
{
|
|
result.erase( 0, pos+8 );
|
|
}
|
|
else result.clear();
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// compiler_desc -----------------------------------------------------------//
|
|
// from boost-root/tools/build/xxx-tools.jam
|
|
|
|
string compiler_desc( const fs::path & boost_root_dir,
|
|
const string & compiler_name )
|
|
{
|
|
string result;
|
|
fs::path tools_path( boost_root_dir << "tools/build" << compiler_name
|
|
+ "-tools.jam" );
|
|
fs::ifstream file( tools_path );
|
|
if ( file )
|
|
{
|
|
while( std::getline( file, result ) )
|
|
{
|
|
if ( result.substr( 0, 3 ) == "#//" )
|
|
{
|
|
result.erase( 0, 3 );
|
|
return result;
|
|
}
|
|
}
|
|
result.clear();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// test_type_desc ----------------------------------------------------------//
|
|
// from jamfile
|
|
|
|
string test_type_desc( const string & test_name )
|
|
{
|
|
// adding "/" and ".c" eliminates a couple of corner cases.
|
|
// ".c" rather than ".cpp" because regex library includes some .c tests
|
|
string search_name1( "/" + test_name + ".c" );
|
|
string search_name2( " " + test_name + " " );
|
|
|
|
string result;
|
|
if ( jamfile.is_open() )
|
|
{
|
|
jamfile.clear();
|
|
jamfile.seekg(0);
|
|
string line;
|
|
while( std::getline( jamfile, line ) )
|
|
{
|
|
if ( line.find( ".c" ) != string::npos )
|
|
{
|
|
if ( line.find( "run " ) != string::npos )
|
|
result = "run";
|
|
else if ( line.find( "run-fail " ) != string::npos )
|
|
result = "run-fail";
|
|
else if ( line.find( "link " ) != string::npos )
|
|
result = "link";
|
|
else if ( line.find( "link-fail " ) != string::npos )
|
|
result = "link-fail";
|
|
else if ( line.find( "compile " ) != string::npos )
|
|
result = "compile";
|
|
else if ( line.find( "compile-fail " ) != string::npos )
|
|
result = "compile-fail";
|
|
}
|
|
if ( result.size() &&
|
|
( line.find( search_name1 ) != string::npos
|
|
|| line.find( search_name2 ) != string::npos ) )
|
|
{
|
|
if ( line.find( "# compiler_status<always_show_run_output>" )
|
|
!= string::npos ) result.insert( 0, 1, '*' );
|
|
return result;
|
|
}
|
|
}
|
|
result.clear();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// target_directory --------------------------------------------------------//
|
|
// this amounts to a request to find a unique leaf directory
|
|
|
|
fs::path target_directory( const fs::path & root )
|
|
{
|
|
if ( !fs::exists( root ) ) return fs::path("no-such-path");
|
|
fs::path child;
|
|
for ( fs::directory_iterator itr( root ); itr != end_itr; ++itr )
|
|
{
|
|
if ( fs::is_directory( *itr ) )
|
|
{
|
|
if ( child.is_null() ) child = *itr;
|
|
else throw std::runtime_error(
|
|
string( "two target possibilities found: \"" )
|
|
+ child.generic_path() + "\" and \""
|
|
+ (*itr).generic_path() + "\"" );
|
|
}
|
|
}
|
|
if ( child.is_null() ) return root; // this dir has no children
|
|
return target_directory( child );
|
|
}
|
|
|
|
// element_content ---------------------------------------------------------//
|
|
|
|
const string & element_content(
|
|
const xml::element_ptr & root, const string & name )
|
|
{
|
|
static string empty_string;
|
|
xml::element_list::iterator itr;
|
|
for ( itr = root->elements.begin();
|
|
itr != root->elements.end() && (*itr)->name != name;
|
|
++itr ) {}
|
|
return itr != root->elements.end() ? (*itr)->content : empty_string;
|
|
}
|
|
|
|
// generate_report ---------------------------------------------------------//
|
|
|
|
// return 0 if nothing generated, 1 otherwise, except 2 if compiler msgs
|
|
int generate_report( const xml::element_ptr & db,
|
|
const string & test_name,
|
|
const string & toolset,
|
|
bool pass,
|
|
bool always_show_run_output = false )
|
|
{
|
|
// compile msgs sometimes modified, so make a local copy
|
|
string compile( (pass && no_warn)
|
|
? empty_string : element_content( db, "compile" ) );
|
|
|
|
const string & link( pass ? empty_string : element_content( db, "link" ) );
|
|
const string & run( (pass && !always_show_run_output)
|
|
? empty_string : element_content( db, "run" ) );
|
|
string lib( pass ? empty_string : element_content( db, "lib" ) );
|
|
|
|
// some compilers output the filename even if there are no errors or
|
|
// warnings; detect this if one line of output and it contains no space.
|
|
string::size_type pos = compile.find( '\n', 1 );
|
|
if ( pos != string::npos && compile.size()-pos <= 2
|
|
&& compile.find( ' ' ) == string::npos ) compile.clear();
|
|
|
|
if ( lib.empty() && compile.empty() && link.empty() && run.empty() )
|
|
return 0;
|
|
|
|
int result = 1; // some kind of msg for sure
|
|
|
|
// limit compile message length
|
|
if ( compile.size() > max_compile_msg_size )
|
|
{
|
|
compile.erase( max_compile_msg_size );
|
|
compile += "...\n (remainder deleted because of excessive size)\n";
|
|
}
|
|
|
|
links_file << "<h2><a name=\""
|
|
<< test_name << " " << toolset << "\">"
|
|
<< test_name << " / " << toolset << "</a></h2>\n";
|
|
|
|
if ( !compile.empty() )
|
|
{
|
|
++result;
|
|
links_file << "<h3>Compiler output:</h3><pre>"
|
|
<< compile << "</pre>\n";
|
|
}
|
|
if ( !link.empty() )
|
|
links_file << "<h3>Linker output:</h3><pre>" << link << "</pre>\n";
|
|
if ( !run.empty() )
|
|
links_file << "<h3>Run output:</h3><pre>" << run << "</pre>\n";
|
|
|
|
static std::set< string > failed_lib_target_dirs;
|
|
if ( !lib.empty() )
|
|
{
|
|
if ( lib[0] == '\n' ) lib.erase( 0, 1 );
|
|
string lib_test_name( extract_test_name( lib ) );
|
|
links_file << "<h3>Library build failure: </h3>\n"
|
|
"See <a href=\"#" << lib_test_name << " " << toolset << "\">"
|
|
<< lib_test_name << " / " << toolset << "</a>";
|
|
|
|
if ( failed_lib_target_dirs.find( lib ) == failed_lib_target_dirs.end() )
|
|
{
|
|
failed_lib_target_dirs.insert( lib );
|
|
fs::ifstream file( boost_root_dir << lib << "test_log.xml" );
|
|
if ( file )
|
|
{
|
|
xml::element_ptr db = xml::parse( file );
|
|
generate_report( db, lib_test_name, toolset, false );
|
|
}
|
|
else
|
|
{
|
|
links_file << "<h2><a name=\""
|
|
<< lib_test_name << " " << toolset << "\">"
|
|
<< lib_test_name << " / " << toolset << "</a></h2>\n"
|
|
"test_log.xml not found\n";
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// do_cell -----------------------------------------------------------------//
|
|
|
|
bool do_cell( const fs::path & test_dir,
|
|
const string & test_name,
|
|
const string & toolset,
|
|
string & target,
|
|
bool always_show_run_output )
|
|
// return true if any results except pass_msg
|
|
{
|
|
fs::path target_dir( target_directory( test_dir << toolset ) );
|
|
bool pass = false;
|
|
|
|
// missing jam residue
|
|
if ( fs::exists( target_dir << (test_name + ".success") ) ) pass = true;
|
|
else if ( !fs::exists( target_dir << (test_name + ".failure") )
|
|
&& !fs::exists( target_dir << "test_log.xml" ) )
|
|
{
|
|
target += "<td>" + missing_residue_msg + "</td>";
|
|
return true;
|
|
}
|
|
|
|
int anything_generated = 0;
|
|
|
|
if ( !no_links )
|
|
{
|
|
fs::ifstream file( target_dir << "test_log.xml" );
|
|
if ( !file ) // missing jam_log.xml
|
|
{
|
|
std::cerr << "Missing jam_log.xml in target \""
|
|
<< target_dir.generic_path() << "\"\n";
|
|
target += "<td>";
|
|
target += pass ? pass_msg : fail_msg;
|
|
target += "</td>";
|
|
return pass;
|
|
}
|
|
xml::element_ptr db = xml::parse( file );
|
|
|
|
// generate bookmarked report of results, and link to it
|
|
anything_generated
|
|
= generate_report( db, test_name, toolset, pass, always_show_run_output );
|
|
}
|
|
|
|
target += "<td>";
|
|
if ( anything_generated != 0 )
|
|
{
|
|
target += "<a href=\"";
|
|
target += links_name;
|
|
target += "#";
|
|
target += test_name;
|
|
target += " ";
|
|
target += toolset;
|
|
target += "\">";
|
|
target += pass ? (anything_generated < 2 ? pass_msg : warn_msg) : fail_msg;
|
|
target += "</a>";
|
|
}
|
|
else target += pass ? pass_msg : fail_msg;
|
|
target += "</td>";
|
|
return (anything_generated != 0) || !pass;
|
|
}
|
|
|
|
// do_row ------------------------------------------------------------------//
|
|
|
|
void do_row( const fs::path & boost_root_dir,
|
|
const fs::path & test_dir, // "c:/boost_root/status/bin/any_test.test"
|
|
const string & test_name, // "any_test"
|
|
string & target )
|
|
{
|
|
// get the path to the test program from the .test file contents
|
|
string test_path( test_name ); // test_name is default if missing .test
|
|
fs::path file_path;
|
|
if ( find_file( test_dir, test_name + ".test", file_path ) )
|
|
{
|
|
fs::ifstream file( file_path );
|
|
if ( file )
|
|
{
|
|
std::getline( file, test_path );
|
|
if ( test_path.size() )
|
|
{
|
|
if ( test_path[0] == '\"' ) // added for non-Win32 systems
|
|
{
|
|
test_path = test_path.erase( 0, 1 ); // strip "
|
|
test_path.erase( test_path.find( "\"" ) );
|
|
}
|
|
// test_path is now a disk path, so convert to URL style path
|
|
convert_backslashes( test_path );
|
|
string::size_type pos = test_path.find( "/libs/" );
|
|
if ( pos != string::npos ) test_path.replace( 0, pos, ".." );
|
|
}
|
|
}
|
|
}
|
|
|
|
// extract the library name from the test_path
|
|
string lib_name( test_path );
|
|
string::size_type pos = lib_name.find( "/libs/" );
|
|
if ( pos != string::npos )
|
|
{
|
|
lib_name.erase( 0, pos+6 );
|
|
pos = lib_name.find( "/" );
|
|
if ( pos != string::npos ) lib_name.erase( pos );
|
|
}
|
|
else lib_name.clear();
|
|
|
|
// find the library documentation path
|
|
string lib_docs_path( "../libs/" + lib_name + "/" );
|
|
fs::path cur_lib_docs_path( boost_root_dir << "libs" << lib_name );
|
|
if ( fs::exists( cur_lib_docs_path << "index.htm" ) )
|
|
lib_docs_path += "index.htm";
|
|
else if ( fs::exists( cur_lib_docs_path << "index.html" ) )
|
|
lib_docs_path += "index.html";
|
|
else if ( fs::exists( cur_lib_docs_path << "doc/index.htm" ) )
|
|
lib_docs_path += "doc/index.htm";
|
|
else if ( fs::exists( cur_lib_docs_path << "doc/index.html" ) )
|
|
lib_docs_path += "doc/index.html";
|
|
else if ( fs::exists( cur_lib_docs_path << (lib_name + ".htm") ) )
|
|
lib_docs_path += lib_name + ".htm";
|
|
else if ( fs::exists( cur_lib_docs_path << (lib_name + ".html") ) )
|
|
lib_docs_path += lib_name + ".html";
|
|
else if ( fs::exists( cur_lib_docs_path << "doc" << (lib_name + ".htm") ) )
|
|
lib_docs_path += lib_name + ".htm";
|
|
else if ( fs::exists( cur_lib_docs_path << "doc" << (lib_name + ".html") ) )
|
|
lib_docs_path += lib_name + ".html";
|
|
|
|
// generate the library name, test name, and test type table data
|
|
string::size_type row_start_pos = target.size();
|
|
target += "<tr><td><a href=\"" + lib_docs_path + "\">" + lib_name + "</a></td>";
|
|
target += "<td><a href=\"" + test_path + "\">" + test_name + "</a></td>";
|
|
|
|
string test_type = test_type_desc( test_name );
|
|
bool always_show_run_output = false;
|
|
if ( !test_type.empty() && test_type[0] == '*' )
|
|
{ always_show_run_output = true; test_type.erase( 0, 1 ); }
|
|
target += "<td>" + test_type + "</td>";
|
|
|
|
bool no_warn_save = no_warn;
|
|
if ( test_type.find( "fail" ) != string::npos ) no_warn = true;
|
|
|
|
// for each compiler, generate <td>...</td> html
|
|
bool anything_to_report = false;
|
|
for ( std::vector<string>::const_iterator itr=toolsets.begin();
|
|
itr != toolsets.end(); ++itr )
|
|
{
|
|
anything_to_report |= do_cell( test_dir, test_name, *itr, target,
|
|
always_show_run_output );
|
|
}
|
|
|
|
target += "</tr>";
|
|
if ( ignore_pass && !anything_to_report ) target.erase( row_start_pos );
|
|
no_warn = no_warn_save;
|
|
}
|
|
|
|
// do_table_body -----------------------------------------------------------//
|
|
|
|
void do_table_body(
|
|
const fs::path & boost_root_dir, const fs::path & build_dir )
|
|
{
|
|
// rows are held in a vector so they can be sorted, if desired.
|
|
std::vector<string> results;
|
|
|
|
// each test directory
|
|
for ( fs::directory_iterator itr( build_dir ); itr != end_itr; ++itr )
|
|
{
|
|
if ( fs::is_directory( *itr ) )
|
|
{
|
|
results.push_back( std::string() ); // no sort required, but leave code
|
|
// in place in case that changes
|
|
do_row( boost_root_dir, *itr,
|
|
itr->leaf().substr( 0, itr->leaf().size()-5 ),
|
|
results[results.size()-1] );
|
|
}
|
|
}
|
|
|
|
std::sort( results.begin(), results.end() );
|
|
|
|
for ( std::vector<string>::iterator v(results.begin());
|
|
v != results.end(); ++v )
|
|
{ report << *v << "\n"; }
|
|
}
|
|
|
|
// do_table ----------------------------------------------------------------//
|
|
|
|
void do_table( const fs::path & boost_root_dir )
|
|
{
|
|
// fs::path build_dir( boost_root_dir << "status" << "bin" );
|
|
fs::path build_dir( fs::initial_directory() << "bin" );
|
|
|
|
report << "<table border=\"1\" cellspacing=\"0\" cellpadding=\"5\">\n";
|
|
|
|
// generate the column headings
|
|
|
|
report << "<tr><td>Library</td><td>Test Name</td>\n"
|
|
"<td><a href=\"compiler_status.html#test-type\">Test Type</a></td>\n";
|
|
|
|
fs::directory_iterator itr( build_dir );
|
|
if ( itr != end_itr )
|
|
{
|
|
fs::directory_iterator compiler_itr( *itr );
|
|
if ( specific_compiler.empty() )
|
|
std::clog << "Using " << itr->generic_path() << " to determine compilers\n";
|
|
for (; compiler_itr != end_itr; ++compiler_itr )
|
|
{
|
|
if ( fs::is_directory( *compiler_itr ) // check just to be sure
|
|
&& compiler_itr->leaf() != "test" ) // avoid strange directory (Jamfile bug?)
|
|
{
|
|
if ( specific_compiler.size() != 0
|
|
&& specific_compiler != compiler_itr->leaf() ) continue;
|
|
toolsets.push_back( compiler_itr->leaf() );
|
|
string desc( compiler_desc( boost_root_dir,
|
|
compiler_itr->leaf() ) );
|
|
string vers( version_desc( boost_root_dir,
|
|
compiler_itr->leaf() ) );
|
|
report << "<td>"
|
|
<< (desc.size() ? desc : compiler_itr->leaf())
|
|
<< (vers.size() ? (string( "<br>" ) + vers ) : string( "" ))
|
|
<< "</td>\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
report << "</tr>\n";
|
|
|
|
// now the rest of the table body
|
|
|
|
do_table_body( boost_root_dir, build_dir );
|
|
|
|
report << "</table>\n";
|
|
}
|
|
|
|
} // unnamed namespace
|
|
|
|
// main --------------------------------------------------------------------//
|
|
|
|
#define BOOST_NO_CPP_MAIN_SUCCESS_MESSAGE
|
|
#include <libs/test/src/cpp_main.cpp>
|
|
|
|
int cpp_main( int argc, char * argv[] ) // note name!
|
|
{
|
|
while ( argc > 1 && *argv[1] == '-' )
|
|
{
|
|
if ( argc > 2 && std::strcmp( argv[1], "--compiler" ) == 0 )
|
|
{ specific_compiler = argv[2]; --argc; ++argv; }
|
|
else if ( std::strcmp( argv[1], "--ignore-pass" ) == 0 ) ignore_pass = true;
|
|
else if ( std::strcmp( argv[1], "--no-warn" ) == 0 ) no_warn = true;
|
|
else { std::cerr << "Unknown option: " << argv[1] << "\n"; argc = 1; }
|
|
--argc;
|
|
++argv;
|
|
}
|
|
|
|
if ( argc != 3 && argc != 4 )
|
|
{
|
|
std::cerr <<
|
|
"usage: compiler_status [options...] boost-root-dir status-file [links-file]\n"
|
|
"must be run from directory containing Jamfile\n"
|
|
" options: --compiler name Run for named compiler only\n"
|
|
" --ignore-pass Do not report tests which pass all compilers\n"
|
|
" --no-warn Warnings not reported if test passes\n"
|
|
"example: compiler_status --compiler gcc \\boost-root cs.html cs-links.html\n";
|
|
return 1;
|
|
}
|
|
|
|
boost_root_dir = fs::path( argv[1], fs::system_specific );
|
|
fs::path jamfile_path( fs::initial_directory() << "Jamfile" );
|
|
jamfile.open( jamfile_path );
|
|
if ( !jamfile )
|
|
{
|
|
std::cerr << "Could not open Jamfile: " << jamfile_path.file_path() << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
report.open( argv[2] );
|
|
if ( !report )
|
|
{
|
|
std::cerr << "Could not open report output file: " << argv[2] << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
if ( argc == 4 )
|
|
{
|
|
links_name = argv[3];
|
|
links_file.open( links_name );
|
|
if ( !links_file )
|
|
{
|
|
std::cerr << "Could not open links output file: " << links_name << std::endl;
|
|
return 1;
|
|
}
|
|
}
|
|
else no_links = true;
|
|
|
|
char run_date[128];
|
|
std::time_t tod;
|
|
std::time( &tod );
|
|
std::strftime( run_date, sizeof(run_date),
|
|
"%X UTC, %A %d %B %Y", std::gmtime( &tod ) );
|
|
|
|
report << "<html>\n"
|
|
"<head>\n"
|
|
"<title>Boost Compiler Status Automatic Test</title>\n"
|
|
"</head>\n"
|
|
"<body bgcolor=\"#ffffff\" text=\"#000000\">\n"
|
|
"<table border=\"0\">\n"
|
|
"<tr>\n"
|
|
"<td><img border=\"0\" src=\"../c++boost.gif\" width=\"277\" "
|
|
"height=\"86\"></td>\n"
|
|
"<td>\n"
|
|
"<h1>Compiler Status: " + platform_desc( boost_root_dir ) + "</h1>\n"
|
|
"<b>Run Date:</b> "
|
|
<< run_date
|
|
<< "\n</td>\n</table>\n<br>\n"
|
|
;
|
|
|
|
do_table( boost_root_dir );
|
|
|
|
report << "</body>\n"
|
|
"</html>\n"
|
|
;
|
|
|
|
return 0;
|
|
}
|