| // (C) Copyright Eric Niebler 2006. |
| // Distributed under the Boost |
| // Software License, Version 1.0. (See accompanying file |
| // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| |
| #include <iostream> |
| #include <iomanip> |
| #include <fstream> |
| #include <deque> |
| #include <sstream> |
| #include <stdexcept> |
| #include <iterator> |
| #include "./regex_comparison.hpp" |
| |
| // |
| // globals: |
| // |
| bool time_boost = false; |
| bool time_greta = false; |
| bool time_safe_greta = false; |
| bool time_dynamic_xpressive = false; |
| bool time_static_xpressive = false; |
| //bool time_posix = false; |
| //bool time_pcre = false; |
| |
| bool test_matches = false; |
| bool test_short_twain = false; |
| bool test_long_twain = false; |
| |
| std::string xml_out_file; |
| std::string xml_contents; |
| std::list<results> result_list; |
| |
| int handle_argument(const std::string& what) |
| { |
| if(what == "-b") |
| time_boost = true; |
| else if(what == "-g") |
| time_greta = true; |
| else if(what == "-gs") |
| time_safe_greta = true; |
| else if(what == "-dx") |
| time_dynamic_xpressive = true; |
| else if(what == "-sx") |
| time_static_xpressive = true; |
| //else if(what == "-posix") |
| // time_posix = true; |
| //else if(what == "-pcre") |
| // time_pcre = true; |
| else if(what == "-all") |
| { |
| time_boost = true; |
| time_greta = true; |
| time_safe_greta = true; |
| time_dynamic_xpressive = true; |
| time_static_xpressive = true; |
| //time_posix = true; |
| //time_pcre = true; |
| } |
| else if(what == "-test-matches") |
| test_matches = true; |
| else if(what == "-test-short-twain") |
| test_short_twain = true; |
| else if(what == "-test-long-twain") |
| test_long_twain = true; |
| else if(what == "-test-all") |
| { |
| test_matches = true; |
| test_short_twain = true; |
| test_long_twain = true; |
| } |
| else if((what == "-h") || (what == "--help")) |
| return show_usage(); |
| else if((what[0] == '-') || (what[0] == '/')) |
| { |
| std::cerr << "Unknown argument: \"" << what << "\"" << std::endl; |
| return 1; |
| } |
| else if(xml_out_file.size() == 0) |
| { |
| xml_out_file = what; |
| } |
| else |
| { |
| std::cerr << "Unexpected argument: \"" << what << "\"" << std::endl; |
| return 1; |
| } |
| return 0; |
| } |
| |
| int show_usage() |
| { |
| std::cout << |
| "Usage\n" |
| "xprperf [-h] [library options] [test options] [xml_output_file]\n" |
| " -h Show help\n\n" |
| " library options:\n" |
| " -b Apply tests to boost library\n" |
| //" -ba Apply tests to boost library with a custom allocator\n" |
| //" -be Apply tests to experimental boost library\n" |
| //" -g Apply tests to GRETA library\n" |
| //" -gs Apply tests to GRETA library (in non-recursive mode)\n" |
| " -dx Apply tests to dynamic xpressive library\n" |
| " -sx Apply tests to static xpressive library\n" |
| //" -posix Apply tests to POSIX library\n" |
| //" -pcre Apply tests to PCRE library\n" |
| " -all Apply tests to all libraries\n\n" |
| " test options:\n" |
| " -test-matches Test short matches\n" |
| " -test-short-twain Test short searches\n" |
| " -test-long-twain Test long searches\n" |
| " -test-all Test everthing\n"; |
| return 1; |
| } |
| |
| void load_file(std::string& text, const char* file) |
| { |
| std::deque<char> temp_copy; |
| std::ifstream is(file); |
| if(!is.good()) |
| { |
| std::string msg("Unable to open file: \""); |
| msg.append(file); |
| msg.append("\""); |
| throw std::runtime_error(msg); |
| } |
| std::istreambuf_iterator<char> it(is); |
| std::copy(it, std::istreambuf_iterator<char>(), std::back_inserter(temp_copy)); |
| text.erase(); |
| text.reserve(temp_copy.size()); |
| text.append(temp_copy.begin(), temp_copy.end()); |
| } |
| |
| struct xml_double |
| { |
| double d_; |
| xml_double( double d ) : d_(d) {} |
| friend std::ostream & operator<<( std::ostream & out, xml_double const & xd ) |
| { |
| std::ostringstream tmp; |
| tmp << std::setprecision(out.precision()) << xd.d_; |
| std::string str = tmp.str(); |
| std::string::size_type i = str.find( '-' ); |
| if( i != std::string::npos ) |
| str.replace( i, 1, "‑" ); |
| return out << str; |
| } |
| }; |
| |
| void print_result(std::ostream& os, double time, double best) |
| { |
| static const char* suffixes[] = {"s", "ms", "us", "ns", "ps", }; |
| |
| if(time < 0) |
| { |
| os << "<entry>NA</entry>"; |
| return; |
| } |
| double rel = time / best; |
| bool highlight = ((rel > 0) && (rel < 1.1)); |
| unsigned suffix = 0; |
| while(time < 0) |
| { |
| time *= 1000; |
| ++suffix; |
| } |
| os << "<entry>"; |
| if(highlight) |
| os << "<phrase role=\"highlight\">"; |
| if(rel <= 1000) |
| os << std::setprecision(3) << xml_double(rel); |
| else |
| os << (int)rel; |
| os << "<para/>("; |
| if(time <= 1000) |
| os << std::setprecision(3) << xml_double(time); |
| else |
| os << (int)time; |
| os << suffixes[suffix] << ")"; |
| if(highlight) |
| os << "</phrase>"; |
| os << "</entry>"; |
| } |
| |
| void output_xml_results(bool show_description, const std::string& title, const std::string& filename) |
| { |
| std::stringstream os; |
| // Generate the copyright and license on the output file |
| os << "<!--\n" |
| " Copyright 2004 Eric Niebler.\n" |
| "\n" |
| " Distributed under the Boost Software License, Version 1.0.\n" |
| " (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n" |
| "-->\n"; |
| |
| if(result_list.size()) |
| { |
| // calculate the number of columns in this table |
| int num_cols = 1 + show_description + time_greta + time_safe_greta |
| + time_dynamic_xpressive + time_static_xpressive + time_boost; |
| |
| // |
| // start by outputting the table header: |
| // |
| os << "<informaltable frame=\"all\">\n"; |
| os << "<bridgehead renderas=\"sect4\">" |
| "<phrase role=\"table-title\">" << title << "</phrase>" |
| "</bridgehead>\n"; |
| os << "<tgroup cols=\"" << num_cols << "\">\n"; |
| os << "<thead>\n"; |
| os << "<row>\n"; |
| |
| if(time_static_xpressive) os << "<entry>static xpressive</entry>"; |
| if(time_dynamic_xpressive) os << "<entry>dynamic xpressive</entry>"; |
| if(time_greta) os << "<entry>GRETA</entry>"; |
| if(time_safe_greta) os << "<entry>GRETA<para/>(non-recursive mode)</entry>"; |
| if(time_boost) os << "<entry>Boost</entry>"; |
| //if(time_posix) os << "<entry>POSIX</entry>"; |
| //if(time_pcre) os << "<entry>PCRE</entry>"; |
| if(show_description) os << "<entry>Text</entry>"; |
| os << "<entry>Expression</entry>"; |
| os << "\n</row>\n"; |
| os << "</thead>\n"; |
| os << "<tbody>\n"; |
| |
| // |
| // Now enumerate through all the test results: |
| // |
| std::list<results>::const_iterator first, last; |
| first = result_list.begin(); |
| last = result_list.end(); |
| while(first != last) |
| { |
| os << "<row>\n"; |
| if(time_static_xpressive) print_result(os, first->static_xpressive_time, first->factor); |
| if(time_dynamic_xpressive) print_result(os, first->dynamic_xpressive_time, first->factor); |
| if(time_greta) print_result(os, first->greta_time, first->factor); |
| if(time_safe_greta) print_result(os, first->safe_greta_time, first->factor); |
| if(time_boost) print_result(os, first->boost_time, first->factor); |
| //if(time_posix) print_result(os, first->posix_time, first->factor); |
| //if(time_pcre) print_result(os, first->pcre_time, first->factor); |
| if(show_description) os << "<entry>" << first->description << "</entry>"; |
| os << "<entry><literal>" << first->expression << "</literal></entry>"; |
| os << "\n</row>\n"; |
| ++first; |
| } |
| |
| os << "</tbody>\n" |
| "</tgroup>\n" |
| "</informaltable>\n"; |
| |
| result_list.clear(); |
| } |
| else |
| { |
| os << "<para><emphasis>Results not available...</emphasis></para>\n"; |
| } |
| |
| std::ofstream file(filename.c_str()); |
| file << os.str(); |
| } |
