From 483eb2f56657e8e7f419ab1a4fab8dce9ade8609 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 20:24:20 +0200 Subject: Adding upstream version 14.2.21. Signed-off-by: Daniel Baumann --- src/boost/libs/xpressive/example/Jamfile.v2 | 24 + src/boost/libs/xpressive/example/example.vcproj | 738 ++++++++++++++++++++++++ src/boost/libs/xpressive/example/main.cpp | 257 +++++++++ src/boost/libs/xpressive/example/numbers.cpp | 167 ++++++ 4 files changed, 1186 insertions(+) create mode 100644 src/boost/libs/xpressive/example/Jamfile.v2 create mode 100644 src/boost/libs/xpressive/example/example.vcproj create mode 100644 src/boost/libs/xpressive/example/main.cpp create mode 100644 src/boost/libs/xpressive/example/numbers.cpp (limited to 'src/boost/libs/xpressive/example') diff --git a/src/boost/libs/xpressive/example/Jamfile.v2 b/src/boost/libs/xpressive/example/Jamfile.v2 new file mode 100644 index 00000000..ab9cd5d2 --- /dev/null +++ b/src/boost/libs/xpressive/example/Jamfile.v2 @@ -0,0 +1,24 @@ +# (C) Copyright 2004: Eric Niebler +# 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) + +project + : requirements + msvc-8.0:_SCL_SECURE_NO_DEPRECATE + msvc-9.0:_SCL_SECURE_NO_DEPRECATE + msvc,stlport:_STLP_EXPOSE_GLOBALS_IMPLEMENTATION + ; + +exe examples + : + main.cpp + : + $(BOOST_ROOT) + ; + +exe numbers + : + numbers.cpp + : + $(BOOST_ROOT) + ; diff --git a/src/boost/libs/xpressive/example/example.vcproj b/src/boost/libs/xpressive/example/example.vcproj new file mode 100644 index 00000000..0e54599d --- /dev/null +++ b/src/boost/libs/xpressive/example/example.vcproj @@ -0,0 +1,738 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/boost/libs/xpressive/example/main.cpp b/src/boost/libs/xpressive/example/main.cpp new file mode 100644 index 00000000..8992f0fc --- /dev/null +++ b/src/boost/libs/xpressive/example/main.cpp @@ -0,0 +1,257 @@ +/////////////////////////////////////////////////////////////////////////////// +// main.hpp +// +// Copyright 2004 Eric Niebler. 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 +#include +#include + +using namespace boost::xpressive; + +/////////////////////////////////////////////////////////////////////////////// +// Displays nested results to std::cout with indenting +// +// Display a tree of nested results +// +// Here is a helper class to demonstrate how you might display a tree of nested results: +struct output_nested_results +{ + int tabs_; + + output_nested_results(int tabs = 0) + : tabs_(tabs) + { + } + + template< typename BidiIterT > + void operator ()( match_results< BidiIterT > const &what ) const + { + // first, do some indenting + typedef typename std::iterator_traits< BidiIterT >::value_type char_type; + char_type space_ch = char_type(' '); + std::fill_n( std::ostream_iterator( std::cout ), tabs_ * 4, space_ch ); + + // output the match + std::cout << what[0] << '\n'; + + // output any nested matches + std::for_each( + what.nested_results().begin(), + what.nested_results().end(), + output_nested_results( tabs_ + 1 ) ); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// See if a whole string matches a regex +// +// This program outputs the following: +// +// hello world! +// hello +// world + +void example1() +{ + std::string hello( "hello world!" ); + + sregex rex = sregex::compile( "(\\w+) (\\w+)!" ); + smatch what; + + if( regex_match( hello, what, rex ) ) + { + std::cout << what[0] << '\n'; // whole match + std::cout << what[1] << '\n'; // first capture + std::cout << what[2] << '\n'; // second capture + } +} + +/////////////////////////////////////////////////////////////////////////////// +// See if a string contains a sub-string that matches a regex +// +// Notice in this example how we use custom mark_tags to make the pattern +// more readable. We can use the mark_tags later to index into the match_results<>. +// +// This program outputs the following: +// +// 5/30/1973 +// 30 +// 5 +// 1973 +// / + +void example2() +{ + char const *str = "I was born on 5/30/1973 at 7am."; + + // define some custom mark_tags with names more meaningful than s1, s2, etc. + mark_tag day(1), month(2), year(3), delim(4); + + // this regex finds a date + cregex date = (month= repeat<1,2>(_d)) // find the month ... + >> (delim= (set= '/','-')) // followed by a delimiter ... + >> (day= repeat<1,2>(_d)) >> delim // and a day followed by the same delimiter ... + >> (year= repeat<1,2>(_d >> _d)); // and the year. + + cmatch what; + + if( regex_search( str, what, date ) ) + { + std::cout << what[0] << '\n'; // whole match + std::cout << what[day] << '\n'; // the day + std::cout << what[month] << '\n'; // the month + std::cout << what[year] << '\n'; // the year + std::cout << what[delim] << '\n'; // the delimiter + } +} + +/////////////////////////////////////////////////////////////////////////////// +// Replace all sub-strings that match a regex +// +// The following program finds dates in a string and marks them up with pseudo-HTML. +// +// This program outputs the following: +// +// I was born on 5/30/1973 at 7am. + +void example3() +{ + std::string str( "I was born on 5/30/1973 at 7am." ); + + // essentially the same regex as in the previous example, but using a dynamic regex + sregex date = sregex::compile( "(\\d{1,2})([/-])(\\d{1,2})\\2((?:\\d{2}){1,2})" ); + + // As in Perl, $& is a reference to the sub-string that matched the regex + std::string format( "$&" ); + + str = regex_replace( str, date, format ); + std::cout << str << '\n'; +} + +/////////////////////////////////////////////////////////////////////////////// +// Find all the sub-strings that match a regex and step through them one at a time +// +// The following program finds the words in a wide-character string. It uses wsregex_iterator. +// Notice that dereferencing a wsregex_iterator yields a wsmatch object. +// +// This program outputs the following: +// +// This +// is +// his +// face + +void example4() +{ + #ifndef BOOST_XPRESSIVE_NO_WREGEX + std::wstring str( L"This is his face." ); + + // find a whole word + wsregex token = +alnum; + + wsregex_iterator cur( str.begin(), str.end(), token ); + wsregex_iterator end; + + for( ; cur != end; ++cur ) + { + wsmatch const &what = *cur; + std::wcout << what[0] << L'\n'; + } + #endif +} + +/////////////////////////////////////////////////////////////////////////////// +// Split a string into tokens that each match a regex +// +// The following program finds race times in a string and displays first the minutes +// and then the seconds. It uses regex_token_iterator<>. +// +// This program outputs the following: +// +// 4 +// 40 +// 3 +// 35 +// 2 +// 32 + +void example5() +{ + std::string str( "Eric: 4:40, Karl: 3:35, Francesca: 2:32" ); + + // find a race time + sregex time = sregex::compile( "(\\d):(\\d\\d)" ); + + // for each match, the token iterator should first take the value of + // the first marked sub-expression followed by the value of the second + // marked sub-expression + int const subs[] = { 1, 2 }; + + sregex_token_iterator cur( str.begin(), str.end(), time, subs ); + sregex_token_iterator end; + + for( ; cur != end; ++cur ) + { + std::cout << *cur << '\n'; + } +} + +/////////////////////////////////////////////////////////////////////////////// +// Split a string using a regex as a delimiter +// +// The following program takes some text that has been marked up with html and strips +// out the mark-up. It uses a regex that matches an HTML tag and a regex_token_iterator<> +// that returns the parts of the string that do not match the regex. +// +// This program outputs the following: +// +// {Now }{is the time }{for all good men}{ to come to the aid of their}{ country.} + +void example6() +{ + std::string str( "Now is the time for all good men to come to the aid of their country." ); + + // find an HTML tag + sregex html = '<' >> optional('/') >> +_w >> '>'; + + // the -1 below directs the token iterator to display the parts of + // the string that did NOT match the regular expression. + sregex_token_iterator cur( str.begin(), str.end(), html, -1 ); + sregex_token_iterator end; + + for( ; cur != end; ++cur ) + { + std::cout << '{' << *cur << '}'; + } + std::cout << '\n'; +} + +/////////////////////////////////////////////////////////////////////////////// +// main +int main() +{ + std::cout << "\n\nExample 1:\n\n"; + example1(); + + std::cout << "\n\nExample 2:\n\n"; + example2(); + + std::cout << "\n\nExample 3:\n\n"; + example3(); + + std::cout << "\n\nExample 4:\n\n"; + example4(); + + std::cout << "\n\nExample 5:\n\n"; + example5(); + + std::cout << "\n\nExample 6:\n\n"; + example6(); + + std::cout << "\n\n" << std::flush; + + return 0; +} diff --git a/src/boost/libs/xpressive/example/numbers.cpp b/src/boost/libs/xpressive/example/numbers.cpp new file mode 100644 index 00000000..4e591bbb --- /dev/null +++ b/src/boost/libs/xpressive/example/numbers.cpp @@ -0,0 +1,167 @@ +/////////////////////////////////////////////////////////////////////////////// +// numbers.cpp +// +// Copyright 2008 David Jenkins. 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) + +#if defined(_MSC_VER) +//disbale warning C4996: 'std::xxx' was declared deprecated +# pragma warning(disable:4996) +#endif + +#include +#include +#include +#include // for 'map_list_of()' +#include +#include + +/////////////////////////////////////////////////////////////////////////////// +// Match all named numbers in a string and return their integer values +// +// For example, given the input string: +// "one two sixty three thousand ninety five eleven" +// the program will output: +// "one = 1" +// "two = 2" +// "sixty three thousand ninety five = 63095" +// "eleven = 11" + +void example1() +{ + using namespace boost::xpressive; + using namespace boost::assign; + + // initialize the maps for named numbers + std::map< std::string, int > ones_map = + map_list_of("one",1)("two",2)("three",3)("four",4)("five",5) + ("six",6)("seven",7)("eight",8)("nine",9); + + std::map< std::string, int > teens_map = + map_list_of("ten",10)("eleven",11)("twelve",12)("thirteen",13) + ("fourteen",14)("fifteen",15)("sixteen",16)("seventeen",17) + ("eighteen",18)("nineteen",19); + + std::map< std::string, int > tens_map = + map_list_of("twenty",20)("thirty",30)("fourty",40) + ("fifty",50)("sixty",60)("seventy",70)("eighty",80)("ninety",90); + + std::map< std::string, int > specials_map = + map_list_of("zero",0)("dozen",12)("score",20); + + // n is the integer result + local n(0); + // temp stores intermediate values + local temp(0); + + // initialize the regular expressions for named numbers + sregex tens_rx = + // use skip directive to skip whitespace between words + skip(_s) + ( + ( a3 = teens_map ) + | + ( a2 = tens_map ) >> !( a1 = ones_map ) + | + ( a1 = ones_map ) + ) + [ n += (a3|0) + (a2|0) + (a1|0) ]; + + sregex hundreds_rx = + skip(_s) + ( + tens_rx >> + !( + as_xpr("hundred") [ n *= 100 ] + >> !tens_rx + ) + ) + ; + + sregex specials_rx = // regex for special number names like dozen + skip(_s) + ( + // Note: this uses two attribues, a1 and a2, and it uses + // a default attribute value of 1 for a1. + ( !( a1 = ones_map ) >> ( a2 = specials_map ) ) + [ n = (a1|1) * a2 ] + >> !( "and" >> tens_rx ) + ) + ; + + sregex number_rx = + bow + >> + skip(_s|punct) + ( + specials_rx // special numbers + | + ( // normal numbers + !( hundreds_rx >> "million" ) [ temp += n * 1000000, n = 0 ] + >> + !( hundreds_rx >> "thousand" ) [ temp += n * 1000, n = 0 ] + >> + !hundreds_rx + ) + [n += temp, temp = 0 ] + ); + + // this is the input string + std::string str( "one two three eighteen twenty two " + "nine hundred ninety nine twelve " + "eight hundred sixty three thousand ninety five " + "sixty five hundred ten " + "two million eight hundred sixty three thousand ninety five " + "zero sixty five hundred thousand " + "extra stuff " + "two dozen " + "four score and seven"); + + // the MATCHING results of iterating through the string are: + // one = 1 + // two = 2 + // three = 3 + // eighteen = 18 + // twenty two = 22 + // nine hundred ninety nine = 999 + // twelve = 12 + // eight hundred sixty three thousand ninety five = 863095 + // sixty five hundred ten = 6510 + // two million eight hundred sixty three thousand ninety five = 2863095 + // zero = 0 + // sixty five hundred thousand = 6500000 + // two dozen = 24 + // four score and seven = 87 + sregex_token_iterator cur( str.begin(), str.end(), number_rx ); + sregex_token_iterator end; + + for( ; cur != end; ++cur ) + { + if ((*cur).length() > 0) + std::cout << *cur << " = " << n.get() << '\n'; + n.get() = 0; + } + std::cout << '\n'; + // the NON-MATCHING results of iterating through the string are: + // extra = unmatched + // stuff = unmatched + sregex_token_iterator cur2( str.begin(), str.end(), number_rx, -1 ); + for( ; cur2 != end; ++cur2 ) + { + if ((*cur2).length() > 0) + std::cout << *cur2 << " = unmatched" << '\n'; + } +} + +/////////////////////////////////////////////////////////////////////////////// +// main +int main() +{ + std::cout << "\n\nExample 1:\n\n"; + example1(); + + std::cout << "\n\n" << std::flush; + + return 0; +} -- cgit v1.2.3