_ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1400ELt9999ENS_9gregorian8bad_yearEEEEC2Et: 46| 503| BOOST_CXX14_CONSTEXPR constrained_value(value_type value) : value_((min)()) 47| 503| { 48| 503| assign(value); 49| 503| } _ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1400ELt9999ENS_9gregorian8bad_yearEEEE3minEv: 61| 1.00k| min BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::min)();} _ZN5boost2CV23simple_exception_policyItLt1400ELt9999ENS_9gregorian8bad_yearEE3minEv: 111| 1.00k| min BOOST_PREVENT_MACRO_SUBSTITUTION () { return min_value; } _ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1400ELt9999ENS_9gregorian8bad_yearEEEE6assignEt: 69| 503| { 70| | //adding 1 below gets rid of a compiler warning which occurs when the 71| | //min_value is 0 and the type is unsigned.... 72| 503| if (value+1 < (min)()+1) { ------------------ | Branch (72:11): [True: 207, False: 296] ------------------ 73| 207| value_policies::on_error(value_, value, min_violation); 74| 207| return; 75| 207| } 76| 296| if (value > (max)()) { ------------------ | Branch (76:11): [True: 7, False: 289] ------------------ 77| 7| value_policies::on_error(value_, value, max_violation); 78| 7| return; 79| 7| } 80| 289| value_ = value; 81| 289| } _ZN5boost2CV23simple_exception_policyItLt1400ELt9999ENS_9gregorian8bad_yearEE8on_errorEttNS0_14violation_enumE: 117| 214| { 118| 214| boost::throw_exception(actual_exception_type()); 119| 214| } _ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1400ELt9999ENS_9gregorian8bad_yearEEEE3maxEv: 57| 296| max BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::max)();} _ZN5boost2CV23simple_exception_policyItLt1400ELt9999ENS_9gregorian8bad_yearEE3maxEv: 114| 296| max BOOST_PREVENT_MACRO_SUBSTITUTION () { return max_value; } _ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1ELt12ENS_9gregorian9bad_monthEEEEC2Et: 46| 229| BOOST_CXX14_CONSTEXPR constrained_value(value_type value) : value_((min)()) 47| 229| { 48| 229| assign(value); 49| 229| } _ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1ELt12ENS_9gregorian9bad_monthEEEE3minEv: 61| 458| min BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::min)();} _ZN5boost2CV23simple_exception_policyItLt1ELt12ENS_9gregorian9bad_monthEE3minEv: 111| 458| min BOOST_PREVENT_MACRO_SUBSTITUTION () { return min_value; } _ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1ELt12ENS_9gregorian9bad_monthEEEE6assignEt: 69| 229| { 70| | //adding 1 below gets rid of a compiler warning which occurs when the 71| | //min_value is 0 and the type is unsigned.... 72| 229| if (value+1 < (min)()+1) { ------------------ | Branch (72:11): [True: 27, False: 202] ------------------ 73| 27| value_policies::on_error(value_, value, min_violation); 74| 27| return; 75| 27| } 76| 202| if (value > (max)()) { ------------------ | Branch (76:11): [True: 54, False: 148] ------------------ 77| 54| value_policies::on_error(value_, value, max_violation); 78| 54| return; 79| 54| } 80| 148| value_ = value; 81| 148| } _ZN5boost2CV23simple_exception_policyItLt1ELt12ENS_9gregorian9bad_monthEE8on_errorEttNS0_14violation_enumE: 117| 81| { 118| 81| boost::throw_exception(actual_exception_type()); 119| 81| } _ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1ELt12ENS_9gregorian9bad_monthEEEE3maxEv: 57| 202| max BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::max)();} _ZN5boost2CV23simple_exception_policyItLt1ELt12ENS_9gregorian9bad_monthEE3maxEv: 114| 202| max BOOST_PREVENT_MACRO_SUBSTITUTION () { return max_value; } _ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1ELt31ENS_9gregorian16bad_day_of_monthEEEEC2Et: 46| 148| BOOST_CXX14_CONSTEXPR constrained_value(value_type value) : value_((min)()) 47| 148| { 48| 148| assign(value); 49| 148| } _ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1ELt31ENS_9gregorian16bad_day_of_monthEEEE3minEv: 61| 296| min BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::min)();} _ZN5boost2CV23simple_exception_policyItLt1ELt31ENS_9gregorian16bad_day_of_monthEE3minEv: 111| 296| min BOOST_PREVENT_MACRO_SUBSTITUTION () { return min_value; } _ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1ELt31ENS_9gregorian16bad_day_of_monthEEEE6assignEt: 69| 148| { 70| | //adding 1 below gets rid of a compiler warning which occurs when the 71| | //min_value is 0 and the type is unsigned.... 72| 148| if (value+1 < (min)()+1) { ------------------ | Branch (72:11): [True: 6, False: 142] ------------------ 73| 6| value_policies::on_error(value_, value, min_violation); 74| 6| return; 75| 6| } 76| 142| if (value > (max)()) { ------------------ | Branch (76:11): [True: 21, False: 121] ------------------ 77| 21| value_policies::on_error(value_, value, max_violation); 78| 21| return; 79| 21| } 80| 121| value_ = value; 81| 121| } _ZN5boost2CV23simple_exception_policyItLt1ELt31ENS_9gregorian16bad_day_of_monthEE8on_errorEttNS0_14violation_enumE: 117| 27| { 118| 27| boost::throw_exception(actual_exception_type()); 119| 27| } _ZN5boost2CV17constrained_valueINS0_23simple_exception_policyItLt1ELt31ENS_9gregorian16bad_day_of_monthEEEE3maxEv: 57| 142| max BOOST_PREVENT_MACRO_SUBSTITUTION () {return (value_policies::max)();} _ZN5boost2CV23simple_exception_policyItLt1ELt31ENS_9gregorian16bad_day_of_monthEE3maxEv: 114| 142| max BOOST_PREVENT_MACRO_SUBSTITUTION () { return max_value; } _ZN5boost9date_time4dateINS_9gregorian4dateENS2_18gregorian_calendarENS2_13date_durationEEC2ENS2_9greg_yearENS2_10greg_monthENS2_8greg_dayE: 72| 61| : days_(calendar::day_number(ymd_type(y, m, d))) 73| 61| {} _ZNK5boost9date_time4dateINS_9gregorian4dateENS2_18gregorian_calendarENS2_13date_durationEE13is_not_a_dateEv: 117| 60| { 118| 60| return traits_type::is_not_a_number(days_); 119| 60| } _ZNK5boost9date_time4dateINS_9gregorian4dateENS2_18gregorian_calendarENS2_13date_durationEE15is_neg_infinityEv: 132| 60| { 133| 60| return traits_type::is_neg_inf(days_); 134| 60| } _ZNK5boost9date_time4dateINS_9gregorian4dateENS2_18gregorian_calendarENS2_13date_durationEE15is_pos_infinityEv: 127| 60| { 128| 60| return traits_type::is_pos_inf(days_); 129| 60| } _ZNK5boost9date_time4dateINS_9gregorian4dateENS2_18gregorian_calendarENS2_13date_durationEE14year_month_dayEv: 99| 60| { 100| 60| return calendar::from_day_number(days_); 101| 60| } _ZN5boost9date_time13simple_formatIcE18has_date_sep_charsEv: 48| 120| { 49| 120| return true; 50| 120| } _ZN5boost9date_time13simple_formatIcE14month_sep_charEv: 58| 60| { 59| 60| return '-'; 60| 60| } _ZN5boost9date_time13simple_formatIcE12month_formatEv: 39| 60| { 40| 60| return month_as_short_string; 41| 60| } _ZN5boost9date_time13simple_formatIcE12day_sep_charEv: 63| 60| { 64| 60| return '-'; 65| 60| } _ZN5boost9date_time14date_formatterINS_9gregorian4dateENS0_13simple_formatIcEEcE14date_to_stringES3_: 116| 60| { 117| 60| typedef typename date_type::ymd_type ymd_type; 118| 60| if (d.is_not_a_date()) { ------------------ | Branch (118:11): [True: 0, False: 60] ------------------ 119| 0| return string_type(format_type::not_a_date()); 120| 0| } 121| 60| if (d.is_neg_infinity()) { ------------------ | Branch (121:11): [True: 0, False: 60] ------------------ 122| 0| return string_type(format_type::neg_infinity()); 123| 0| } 124| 60| if (d.is_pos_infinity()) { ------------------ | Branch (124:11): [True: 0, False: 60] ------------------ 125| 0| return string_type(format_type::pos_infinity()); 126| 0| } 127| 60| ymd_type ymd = d.year_month_day(); 128| 60| return ymd_formatter::ymd_to_string(ymd); 129| 60| } _ZN5boost9date_time13ymd_formatterINS0_19year_month_day_baseINS_9gregorian9greg_yearENS3_10greg_monthENS3_8greg_dayEEENS0_13simple_formatIcEEcE13ymd_to_stringES7_: 83| 60| { 84| 60| typedef typename ymd_type::month_type month_type; 85| 60| std::basic_ostringstream ss; 86| | 87| | // Temporarily switch to classic locale to prevent possible formatting 88| | // of year with comma or other character (for example 2,008). 89| 60| ss.imbue(std::locale::classic()); 90| 60| ss << ymd.year; 91| 60| ss.imbue(std::locale()); 92| | 93| 60| if (format_type::has_date_sep_chars()) { ------------------ | Branch (93:11): [True: 60, False: 0] ------------------ 94| 60| ss << format_type::month_sep_char(); 95| 60| } 96| | //this name is a bit ugly, oh well.... 97| 60| month_formatter::format_month(ymd.month, ss); 98| 60| if (format_type::has_date_sep_chars()) { ------------------ | Branch (98:11): [True: 60, False: 0] ------------------ 99| 60| ss << format_type::day_sep_char(); 100| 60| } 101| 60| ss << std::setw(2) << std::setfill(ss.widen('0')) 102| 60| << ymd.day; 103| 60| return ss.str(); 104| 60| } _ZN5boost9date_time15month_formatterINS_9gregorian10greg_monthENS0_13simple_formatIcEEcE12format_monthERKS3_RNSt3__113basic_ostreamIcNS9_11char_traitsIcEEEE: 40| 60| { 41| 60| switch (format_type::month_format()) 42| 60| { 43| 60| case month_as_short_string: ------------------ | Branch (43:9): [True: 60, False: 0] ------------------ 44| 60| { 45| 60| os << month.as_short_string(); 46| 60| break; 47| 0| } 48| 0| case month_as_long_string: ------------------ | Branch (48:9): [True: 0, False: 60] ------------------ 49| 0| { 50| 0| os << month.as_long_string(); 51| 0| break; 52| 0| } 53| 0| case month_as_integer: ------------------ | Branch (53:9): [True: 0, False: 60] ------------------ 54| 0| { 55| 0| boost::io::basic_ios_fill_saver ifs(os); 56| 0| os << std::setw(2) << std::setfill(os.widen('0')) << month.as_number(); 57| 0| break; 58| 0| } 59| 0| default: ------------------ | Branch (59:9): [True: 0, False: 60] ------------------ 60| 0| break; 61| | 62| 60| } 63| 60| return os; 64| 60| } // format_month _ZN5boost9date_time10parse_dateINS_9gregorian4dateEEET_RKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEi: 130| 457| parse_date(const std::string& s, int order_spec = ymd_order_iso) { 131| 457| std::string spec_str; 132| 457| if(order_spec == ymd_order_iso) { ------------------ | Branch (132:10): [True: 457, False: 0] ------------------ 133| 457| spec_str = "ymd"; 134| 457| } 135| 0| else if(order_spec == ymd_order_dmy) { ------------------ | Branch (135:15): [True: 0, False: 0] ------------------ 136| 0| spec_str = "dmy"; 137| 0| } 138| 0| else { // (order_spec == ymd_order_us) 139| 0| spec_str = "mdy"; 140| 0| } 141| | 142| 457| typedef typename date_type::month_type month_type; 143| 457| unsigned pos = 0; 144| 457| unsigned short year(0), month(0), day(0); 145| 457| typedef typename std::basic_string::traits_type traits_type; 146| 457| typedef boost::char_separator char_separator_type; 147| 457| typedef boost::tokenizer::const_iterator, 149| 457| std::basic_string > tokenizer; 150| 457| typedef boost::tokenizer::const_iterator, 152| 457| std::basic_string >::iterator tokenizer_iterator; 153| | // may need more delimiters, these work for the regression tests 154| 457| const char sep_char[] = {',','-','.',' ','/','\0'}; 155| 457| char_separator_type sep(sep_char); 156| 457| tokenizer tok(s,sep); 157| 457| for(tokenizer_iterator beg=tok.begin(); 158| 1.12k| beg!=tok.end() && pos < spec_str.size(); ------------------ | Branch (158:11): [True: 782, False: 338] | Branch (158:11): [True: 779, False: 341] | Branch (158:29): [True: 779, False: 3] ------------------ 159| 779| ++beg, ++pos) { 160| 779| switch(spec_str.at(pos)) { 161| 420| case 'y': ------------------ | Branch (161:11): [True: 420, False: 359] ------------------ 162| 420| { 163| 420| year = boost::lexical_cast(*beg); 164| 420| break; 165| 0| } 166| 252| case 'm': ------------------ | Branch (166:11): [True: 252, False: 527] ------------------ 167| 252| { 168| 252| month = month_str_to_ushort(*beg); 169| 252| break; 170| 0| } 171| 107| case 'd': ------------------ | Branch (171:11): [True: 107, False: 672] ------------------ 172| 107| { 173| 107| day = boost::lexical_cast(*beg); 174| 107| break; 175| 0| } 176| 0| default: break; ------------------ | Branch (176:11): [True: 0, False: 779] ------------------ 177| 779| } //switch 178| 779| } 179| 341| return date_type(year, month, day); 180| 457| } _ZN5boost9date_time19month_str_to_ushortINS_9gregorian10greg_monthEEEtRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 62| 252| month_str_to_ushort(std::string const& s) { 63| 252| if((s.at(0) >= '0') && (s.at(0) <= '9')) { ------------------ | Branch (63:10): [True: 222, False: 30] | Branch (63:30): [True: 124, False: 98] ------------------ 64| 124| return boost::lexical_cast(s); 65| 124| } 66| 128| else { 67| 128| std::string str = convert_to_lower(s); 68| | //c++98 support 69| |#if defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) 70| | static std::map month_map; 71| | typedef std::map::value_type vtype; 72| | if( month_map.empty() ) { 73| | month_map.insert( vtype("jan", static_cast(1)) ); 74| | month_map.insert( vtype("january", static_cast(1)) ); 75| | month_map.insert( vtype("feb", static_cast(2)) ); 76| | month_map.insert( vtype("february", static_cast(2)) ); 77| | month_map.insert( vtype("mar", static_cast(3)) ); 78| | month_map.insert( vtype("march", static_cast(3)) ); 79| | month_map.insert( vtype("apr", static_cast(4)) ); 80| | month_map.insert( vtype("april", static_cast(4)) ); 81| | month_map.insert( vtype("may", static_cast(5)) ); 82| | month_map.insert( vtype("jun", static_cast(6)) ); 83| | month_map.insert( vtype("june", static_cast(6)) ); 84| | month_map.insert( vtype("jul", static_cast(7)) ); 85| | month_map.insert( vtype("july", static_cast(7)) ); 86| | month_map.insert( vtype("aug", static_cast(8)) ); 87| | month_map.insert( vtype("august", static_cast(8)) ); 88| | month_map.insert( vtype("sep", static_cast(9)) ); 89| | month_map.insert( vtype("september", static_cast(9)) ); 90| | month_map.insert( vtype("oct", static_cast(10)) ); 91| | month_map.insert( vtype("october", static_cast(10)) ); 92| | month_map.insert( vtype("nov", static_cast(11)) ); 93| | month_map.insert( vtype("november", static_cast(11)) ); 94| | month_map.insert( vtype("dec", static_cast(12)) ); 95| | month_map.insert( vtype("december", static_cast(12)) ); 96| | } 97| |#else //c+11 and beyond 98| 128| static std::map month_map = 99| 128| { { "jan", static_cast(1) }, { "january", static_cast(1) }, 100| 128| { "feb", static_cast(2) }, { "february", static_cast(2) }, 101| 128| { "mar", static_cast(3) }, { "march", static_cast(3) }, 102| 128| { "apr", static_cast(4) }, { "april", static_cast(4) }, 103| 128| { "may", static_cast(5) }, 104| 128| { "jun", static_cast(6) }, { "june", static_cast(6) }, 105| 128| { "jul", static_cast(7) }, { "july", static_cast(7) }, 106| 128| { "aug", static_cast(8) }, { "august", static_cast(8) }, 107| 128| { "sep", static_cast(9) }, { "september", static_cast(9) }, 108| 128| { "oct", static_cast(10) }, { "october", static_cast(10)}, 109| 128| { "nov", static_cast(11) }, { "november", static_cast(11)}, 110| 128| { "dec", static_cast(12) }, { "december", static_cast(12)} 111| 128| }; 112| 128|#endif 113| 128| std::map::const_iterator mitr = month_map.find( str ); 114| 128| if ( mitr != month_map.end() ) { ------------------ | Branch (114:14): [True: 2, False: 126] ------------------ 115| 2| return mitr->second; 116| 2| } 117| 128| } 118| 126| return 13; // intentionally out of range - name not found 119| 252| } _ZN5boost9date_time16convert_to_lowerENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 41| 128| { 42| 128|#if !defined(BOOST_DATE_TIME_NO_LOCALE) 43| 128| const std::locale loc(std::locale::classic()); 44| 128|#endif 45| 128| std::string::size_type i = 0, n = inp.length(); 46| 655| for (; i < n; ++i) { ------------------ | Branch (46:12): [True: 527, False: 128] ------------------ 47| 527| inp[i] = 48| |#if defined(BOOST_DATE_TIME_NO_LOCALE) 49| | static_cast(std::tolower(inp[i])); 50| |#else 51| | // tolower and others were brought in to std for borland >= v564 52| | // in compiler_config.hpp 53| 527| std::tolower(inp[i], loc); 54| 527|#endif 55| 527| } 56| 128| return inp; 57| 128| } _ZN5boost9date_time22parse_undelimited_dateINS_9gregorian4dateEEET_RKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 185| 60| parse_undelimited_date(const std::string& s) { 186| 60| int offsets[] = {4,2,2}; 187| 60| int pos = 0; 188| | //typename date_type::ymd_type ymd((year_type::min)(),1,1); 189| 60| unsigned short y = 0, m = 0, d = 0; 190| | 191| | /* The two bool arguments state that parsing will not wrap 192| | * (only the first 8 characters will be parsed) and partial 193| | * strings will not be parsed. 194| | * Ex: 195| | * "2005121" will parse 2005 & 12, but not the "1" */ 196| 60| boost::offset_separator osf(offsets, offsets+3, false, false); 197| | 198| 60| typedef typename boost::tokenizer::const_iterator, 200| 60| std::basic_string > tokenizer_type; 201| 60| tokenizer_type tok(s, osf); 202| 212| for(typename tokenizer_type::iterator ti=tok.begin(); ti!=tok.end();++ti) { ------------------ | Branch (202:61): [True: 170, False: 42] ------------------ 203| 170| unsigned short i = boost::lexical_cast(*ti); 204| 170| switch(pos) { 205| 59| case 0: y = i; break; ------------------ | Branch (205:9): [True: 59, False: 111] ------------------ 206| 51| case 1: m = i; break; ------------------ | Branch (206:9): [True: 51, False: 119] ------------------ 207| 42| case 2: d = i; break; ------------------ | Branch (207:9): [True: 42, False: 128] ------------------ 208| 0| default: break; ------------------ | Branch (208:9): [True: 0, False: 170] ------------------ 209| 170| } 210| 152| pos++; 211| 152| } 212| 42| return date_type(y,m,d); 213| 60| } _ZN5boost9gregorian16to_simple_stringERKNS0_4dateE: 39| 60| inline std::string to_simple_string(const date& d) { 40| 60| return to_simple_string_type(d); 41| 60| } _ZN5boost9gregorian21to_simple_string_typeIcEENSt3__112basic_stringIT_NS2_11char_traitsIS4_EENS2_9allocatorIS4_EEEERKNS0_4dateE: 33| 60| std::basic_string to_simple_string_type(const date& d) { 34| 60| return date_time::date_formatter,charT>::date_to_string(d); 35| 60| } _ZN5boost9gregorian4dateC2ENS0_9greg_yearENS0_10greg_monthENS0_8greg_dayE: 57| 61| : date_time::date(y, m, d) 58| 61| { 59| 61| if (gregorian_calendar::end_of_month_day(y, m) < d) { ------------------ | Branch (59:11): [True: 1, False: 60] ------------------ 60| 1| boost::throw_exception(bad_day_of_month(std::string("Day of month is not valid for year"))); 61| 1| } 62| 61| } _ZN5boost9gregorian8greg_dayC2Et: 45| 148| BOOST_CXX14_CONSTEXPR greg_day(value_type day_of_month) : greg_day_rep(day_of_month) {} _ZN5boost9gregorian16bad_day_of_monthC2Ev: 24| 27| std::out_of_range(std::string("Day of month value is out of range 1..31")) 25| 27| {} _ZNK5boost9gregorian8greg_daycvtEv: 47| 182| BOOST_CXX14_CONSTEXPR operator value_type() const {return value_;} _ZN5boost9gregorian16bad_day_of_monthC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 28| 1| std::out_of_range(s) 29| 1| {} _ZN5boost9gregorian10greg_monthC2Et: 59| 229| BOOST_CXX14_CONSTEXPR greg_month(value_type theMonth) : greg_month_rep(theMonth) {} _ZN5boost9gregorian9bad_monthC2Ev: 42| 81| bad_month() : std::out_of_range(std::string("Month number is out of range 1..12")) {} _ZNK5boost9gregorian10greg_monthcvtEv: 61| 183| BOOST_CXX14_CONSTEXPR operator value_type() const {return value_;} _ZNK5boost9gregorian10greg_month15as_short_stringEv: 69| 60| { 70| 60| static const char* const short_month_names[NumMonths] 71| 60| = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec", "NAM"}; 72| 60| return short_month_names[value_-1]; 73| 60| } _ZN5boost9gregorian9greg_yearC2Et: 42| 503| BOOST_CXX14_CONSTEXPR greg_year(value_type year) : greg_year_rep(year) {} _ZN5boost9gregorian8bad_yearC2Ev: 24| 214| std::out_of_range(std::string("Year is out of valid range: 1400..9999")) 25| 214| {} _ZNK5boost9gregorian9greg_yearcvtEv: 43| 206| BOOST_CXX14_CONSTEXPR operator value_type() const {return value_;} _ZN5boost9gregorian18from_simple_stringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 53| 457| inline date from_simple_string(const std::string& s) { 54| 457| return date_time::parse_date(s, date_time::ymd_order_iso); 55| 457| } _ZN5boost9gregorian23from_undelimited_stringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 68| 60| inline date from_undelimited_string(const std::string& s) { 69| 60| return date_time::parse_undelimited_date(s); 70| 60| } _ZN5boost9date_time23gregorian_calendar_baseINS0_19year_month_day_baseINS_9gregorian9greg_yearENS3_10greg_monthENS3_8greg_dayEEEjE10day_numberERKS7_: 76| 61| { 77| 61| unsigned short a = static_cast((14-ymd.month)/12); 78| 61| unsigned short y = static_cast(ymd.year + 4800 - a); 79| 61| unsigned short m = static_cast(ymd.month + 12*a - 3); 80| 61| unsigned long d = static_cast(ymd.day) + ((153*m + 2)/5) + 365*y + (y/4) - (y/100) + (y/400) - 32045; 81| 61| return static_cast(d); 82| 61| } _ZN5boost9date_time23gregorian_calendar_baseINS0_19year_month_day_baseINS_9gregorian9greg_yearENS3_10greg_monthENS3_8greg_dayEEEjE16end_of_month_dayES4_S5_: 185| 61| { 186| 61| switch (month) { 187| 12| case 2: ------------------ | Branch (187:5): [True: 12, False: 49] ------------------ 188| 12| if (is_leap_year(year)) { ------------------ | Branch (188:11): [True: 4, False: 8] ------------------ 189| 4| return 29; 190| 8| } else { 191| 8| return 28; 192| 8| } 193| 4| case 4: ------------------ | Branch (193:5): [True: 4, False: 57] ------------------ 194| 19| case 6: ------------------ | Branch (194:5): [True: 15, False: 46] ------------------ 195| 24| case 9: ------------------ | Branch (195:5): [True: 5, False: 56] ------------------ 196| 26| case 11: ------------------ | Branch (196:5): [True: 2, False: 59] ------------------ 197| 26| return 30; 198| 23| default: ------------------ | Branch (198:5): [True: 23, False: 38] ------------------ 199| 23| return 31; 200| 61| } 201| 61| } _ZN5boost9date_time23gregorian_calendar_baseINS0_19year_month_day_baseINS_9gregorian9greg_yearENS3_10greg_monthENS3_8greg_dayEEEjE12is_leap_yearES4_: 170| 12| { 171| | //divisible by 4, not if divisible by 100, but true if divisible by 400 172| 12| return (!(year % 4)) && ((year % 100) || (!(year % 400))); ------------------ | Branch (172:12): [True: 8, False: 4] | Branch (172:31): [True: 3, False: 5] | Branch (172:47): [True: 1, False: 4] ------------------ 173| 12| } _ZN5boost9date_time23gregorian_calendar_baseINS0_19year_month_day_baseINS_9gregorian9greg_yearENS3_10greg_monthENS3_8greg_dayEEEjE15from_day_numberEj: 115| 60| { 116| 60| date_int_type a = dayNumber + 32044; 117| 60| date_int_type b = (4*a + 3)/146097; 118| 60| date_int_type c = a-((146097*b)/4); 119| 60| date_int_type d = (4*c + 3)/1461; 120| 60| date_int_type e = c - (1461*d)/4; 121| 60| date_int_type m = (5*e + 2)/153; 122| 60| unsigned short day = static_cast(e - ((153*m + 2)/5) + 1); 123| 60| unsigned short month = static_cast(m + 3 - 12 * (m/10)); 124| 60| year_type year = static_cast(100*b + d - 4800 + (m/10)); 125| | //std::cout << year << "-" << month << "-" << day << "\n"; 126| | 127| 60| return ymd_type(static_cast(year),month,day); 128| 60| } _ZN5boost9date_time11int_adapterIjE15is_not_a_numberEj: 101| 60| { 102| 60| return (v == not_a_number().as_number()); 103| 60| } _ZN5boost9date_time11int_adapterIjE12not_a_numberEv: 65| 60| { 66| 60| return (::std::numeric_limits::max)()-1; 67| 60| } _ZN5boost9date_time11int_adapterIjEC2Ej: 50| 180| value_(v) 51| 180| {} _ZNK5boost9date_time11int_adapterIjE9as_numberEv: 190| 180| { 191| 180| return value_; 192| 180| } _ZN5boost9date_time11int_adapterIjE10is_neg_infEj: 93| 60| { 94| 60| return (v == neg_infinity().as_number()); 95| 60| } _ZN5boost9date_time11int_adapterIjE12neg_infinityEv: 61| 60| { 62| 60| return (::std::numeric_limits::min)(); 63| 60| } _ZN5boost9date_time11int_adapterIjE10is_pos_infEj: 97| 60| { 98| 60| return (v == pos_infinity().as_number()); 99| 60| } _ZN5boost9date_time11int_adapterIjE12pos_infinityEv: 57| 60| { 58| 60| return (::std::numeric_limits::max)(); 59| 60| } _ZN5boost9date_time19year_month_day_baseINS_9gregorian9greg_yearENS2_10greg_monthENS2_8greg_dayEEC2ES3_S4_S5_: 40| 121| year(y), 41| 121| month(m), 42| 121| day(d) 43| 121| {} _ZN5boost9iteratorsneINS_14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS4_11__wrap_iterIPKcEENS4_12basic_stringIcS6_NS4_9allocatorIcEEEEEESF_NS0_21forward_traversal_tagERKSF_lSG_SF_SH_SJ_lEENS0_6detail23enable_if_interoperableIT_T4_NS_3mpl6apply2INSK_12always_bool2ESM_SN_E4typeEE4typeERKNS0_15iterator_facadeISM_T0_T1_T2_T3_EERKNSV_ISN_T5_T6_T7_T8_EE: 961| 1.12k| { \ 962| 1.12k| /* For those compilers that do not support enable_if */ \ 963| 1.12k| BOOST_STATIC_ASSERT(( \ ------------------ | | 71| 1.12k|# define BOOST_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__) ------------------ 964| 1.12k| is_interoperable< Derived1, Derived2 >::value \ 965| 1.12k| )); \ 966| 1.12k| return_prefix iterator_core_access::base_op( \ 967| 1.12k| *static_cast(&lhs) \ 968| 1.12k| , *static_cast(&rhs) \ 969| 1.12k| , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ ------------------ | | 956| 1.12k|# define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible() ------------------ 970| 1.12k| ); \ 971| 1.12k| } _ZN5boost9iterators20iterator_core_access5equalINS_14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS5_11__wrap_iterIPKcEENS5_12basic_stringIcS7_NS5_9allocatorIcEEEEEESH_EEbRKT_RKT0_N4mpl_5bool_ILb1EEE: 648| 1.12k| { 649| 1.12k| return f1.equal(f2); 650| 1.12k| } _ZNK5boost9iterators6detail20iterator_facade_baseINS_14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS5_11__wrap_iterIPKcEENS5_12basic_stringIcS7_NS5_9allocatorIcEEEEEESG_NS0_21forward_traversal_tagERKSG_lLb0ELb0EEdeEv: 736| 779| { 737| 779| return iterator_core_access::dereference(this->derived()); 738| 779| } _ZN5boost9iterators20iterator_core_access11dereferenceINS_14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS5_11__wrap_iterIPKcEENS5_12basic_stringIcS7_NS5_9allocatorIcEEEEEEEENT_9referenceERKSI_: 630| 779| { 631| 779| return f.dereference(); 632| 779| } _ZNK5boost9iterators6detail20iterator_facade_baseINS_14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS5_11__wrap_iterIPKcEENS5_12basic_stringIcS7_NS5_9allocatorIcEEEEEESG_NS0_21forward_traversal_tagERKSG_lLb0ELb0EE7derivedEv: 761| 779| { 762| 779| return *static_cast(this); 763| 779| } _ZN5boost9iterators6detail20iterator_facade_baseINS_14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS5_11__wrap_iterIPKcEENS5_12basic_stringIcS7_NS5_9allocatorIcEEEEEESG_NS0_21forward_traversal_tagERKSG_lLb0ELb0EEppEv: 746| 663| { 747| 663| iterator_core_access::increment(this->derived()); 748| 663| return this->derived(); 749| 663| } _ZN5boost9iterators20iterator_core_access9incrementINS_14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS5_11__wrap_iterIPKcEENS5_12basic_stringIcS7_NS5_9allocatorIcEEEEEEEEvRT_: 636| 663| { 637| 663| f.increment(); 638| 663| } _ZN5boost9iterators6detail20iterator_facade_baseINS_14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS5_11__wrap_iterIPKcEENS5_12basic_stringIcS7_NS5_9allocatorIcEEEEEESG_NS0_21forward_traversal_tagERKSG_lLb0ELb0EE7derivedEv: 756| 1.32k| { 757| 1.32k| return *static_cast(this); 758| 1.32k| } _ZN5boost9iteratorsneINS_14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEESE_NS0_21forward_traversal_tagERKSE_lSF_SE_SG_SI_lEENS0_6detail23enable_if_interoperableIT_T4_NS_3mpl6apply2INSJ_12always_bool2ESL_SM_E4typeEE4typeERKNS0_15iterator_facadeISL_T0_T1_T2_T3_EERKNSU_ISM_T5_T6_T7_T8_EE: 961| 212| { \ 962| 212| /* For those compilers that do not support enable_if */ \ 963| 212| BOOST_STATIC_ASSERT(( \ ------------------ | | 71| 212|# define BOOST_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__) ------------------ 964| 212| is_interoperable< Derived1, Derived2 >::value \ 965| 212| )); \ 966| 212| return_prefix iterator_core_access::base_op( \ 967| 212| *static_cast(&lhs) \ 968| 212| , *static_cast(&rhs) \ 969| 212| , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ ------------------ | | 956| 212|# define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible() ------------------ 970| 212| ); \ 971| 212| } _ZN5boost9iterators20iterator_core_access5equalINS_14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEESG_EEbRKT_RKT0_N4mpl_5bool_ILb1EEE: 648| 212| { 649| 212| return f1.equal(f2); 650| 212| } _ZNK5boost9iterators6detail20iterator_facade_baseINS_14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEESF_NS0_21forward_traversal_tagERKSF_lLb0ELb0EEdeEv: 736| 170| { 737| 170| return iterator_core_access::dereference(this->derived()); 738| 170| } _ZN5boost9iterators20iterator_core_access11dereferenceINS_14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEEENT_9referenceERKSH_: 630| 170| { 631| 170| return f.dereference(); 632| 170| } _ZNK5boost9iterators6detail20iterator_facade_baseINS_14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEESF_NS0_21forward_traversal_tagERKSF_lLb0ELb0EE7derivedEv: 761| 170| { 762| 170| return *static_cast(this); 763| 170| } _ZN5boost9iterators6detail20iterator_facade_baseINS_14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEESF_NS0_21forward_traversal_tagERKSF_lLb0ELb0EEppEv: 746| 152| { 747| 152| iterator_core_access::increment(this->derived()); 748| 152| return this->derived(); 749| 152| } _ZN5boost9iterators20iterator_core_access9incrementINS_14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEEEvRT_: 636| 152| { 637| 152| f.increment(); 638| 152| } _ZN5boost9iterators6detail20iterator_facade_baseINS_14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEESF_NS0_21forward_traversal_tagERKSF_lLb0ELb0EE7derivedEv: 756| 304| { 757| 304| return *static_cast(this); 758| 304| } _ZN5boost12lexical_castItNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEET_RKT0_: 39| 821| { 40| 821| Target result = Target(); 41| | 42| 821| if (!boost::conversion::detail::try_lexical_convert(arg, result)) { ------------------ | Branch (42:13): [True: 134, False: 687] ------------------ 43| 134| boost::conversion::detail::throw_bad_cast(); 44| 134| } 45| | 46| 821| return result; 47| 821| } _ZN5boost10conversion6detail14throw_bad_castINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEtEEvv: 92| 134| inline void throw_bad_cast() { 93| 134| boost::throw_exception(bad_lexical_cast(typeid(S), typeid(T))); 94| 134| } _ZN5boost16bad_lexical_castC2ERKS0_: 53| 134| bad_lexical_cast(const bad_lexical_cast&) = default; _ZN5boost16bad_lexical_castC2ERKSt9type_infoS3_: 67| 134| : source(&source_type_arg), target(&target_type_arg) 68| 134| {} _ZN5boost6detail22lexical_converter_implItNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE11try_convertERKS8_Rt: 461| 821| static inline bool try_convert(const Source& arg, Target& result) { 462| 821| from_src_stream src_stream; 463| 821| if (!src_stream.stream_in(lcast::exact{arg})) ------------------ | Branch (463:21): [True: 0, False: 821] ------------------ 464| 0| return false; 465| | 466| 821| to_target_stream out(src_stream.cbegin(), src_stream.cend()); 467| 821| if (!out.stream_out(result)) ------------------ | Branch (467:21): [True: 134, False: 687] ------------------ 468| 134| return false; 469| | 470| 687| return true; 471| 821| } _ZN5boost6detail5lcast20optimized_src_streamIcNSt3__111char_traitsIcEELm2EEC2Ev: 124| 821| : start(buffer) 125| 821| , finish(buffer + CharacterBufferSize) 126| 821| {} _ZN5boost6detail5lcast20optimized_src_streamIcNSt3__111char_traitsIcEELm2EE9stream_inIS5_NS3_9allocatorIcEEEEbNS1_5exactINS3_12basic_stringIcT_T0_EEEE: 269| 821| bool stream_in(lcast::exact> x) noexcept { 270| 821| start = x.payload.data(); 271| 821| finish = start + x.payload.length(); 272| 821| return true; 273| 821| } _ZNK5boost6detail5lcast20optimized_src_streamIcNSt3__111char_traitsIcEELm2EE6cbeginEv: 128| 821| const CharT* cbegin() const noexcept { 129| 821| return start; 130| 821| } _ZNK5boost6detail5lcast20optimized_src_streamIcNSt3__111char_traitsIcEELm2EE4cendEv: 132| 821| const CharT* cend() const noexcept { 133| 821| return finish; 134| 821| } _ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEEC2EPKcS8_: 492| 821| : start(begin) 493| 821| , finish(end) 494| 821| {} _ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEE10stream_outERt: 625| 821| bool stream_out(unsigned short& output) { return shr_unsigned(output); } _ZN5boost6detail5lcast16to_target_streamIcNSt3__111char_traitsIcEEE12shr_unsignedItEEbRT_: 501| 821| bool shr_unsigned(Type& output) { 502| 821| if (start == finish) return false; ------------------ | Branch (502:17): [True: 0, False: 821] ------------------ 503| 821| CharT const minus = lcast_char_constants::minus; 504| 821| CharT const plus = lcast_char_constants::plus; 505| 821| bool const has_minus = Traits::eq(minus, *start); 506| | 507| | /* We won`t use `start' any more, so no need in decrementing it after */ 508| 821| if (has_minus || Traits::eq(plus, *start)) { ------------------ | Branch (508:17): [True: 91, False: 730] | Branch (508:30): [True: 6, False: 724] ------------------ 509| 97| ++start; 510| 97| } 511| | 512| 821| bool const succeed = lcast_ret_unsigned(output, start, finish).convert(); 513| | 514| 821| if (has_minus) { ------------------ | Branch (514:17): [True: 91, False: 730] ------------------ 515| 91| output = static_cast(0u - output); 516| 91| } 517| | 518| 821| return succeed; 519| 821| } _ZN5boost6detail18lcast_ret_unsignedINSt3__111char_traitsIcEEtcEC2ERtPKcS8_: 170| 821| : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end) 171| 821| { 172| 821|#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS 173| 821| static_assert(!std::numeric_limits::is_signed, ""); 174| | 175| | // GCC when used with flag -std=c++0x may not have std::numeric_limits 176| | // specializations for __int128 and unsigned __int128 types. 177| | // Try compilation with -std=gnu++0x or -std=gnu++11. 178| | // 179| | // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856 180| 821| static_assert(std::numeric_limits::is_specialized, 181| 821| "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast" 182| 821| ); 183| 821|#endif 184| 821| } _ZN5boost6detail18lcast_ret_unsignedINSt3__111char_traitsIcEEtcE7convertEv: 186| 821| inline bool convert() { 187| 821| CharT const czero = lcast_char_constants::zero; 188| 821| --m_end; 189| 821| m_value = static_cast(0); 190| | 191| 821| if (m_begin > m_end || *m_end < czero || *m_end >= czero + 10) ------------------ | Branch (191:21): [True: 3, False: 818] | Branch (191:40): [True: 45, False: 773] | Branch (191:58): [True: 38, False: 735] ------------------ 192| 86| return false; 193| 735| m_value = static_cast(*m_end - czero); 194| 735| --m_end; 195| | 196| |#ifdef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE 197| | return main_convert_loop(); 198| |#else 199| 735| std::locale loc; 200| 735| if (loc == std::locale::classic()) { ------------------ | Branch (200:21): [True: 735, False: 0] ------------------ 201| 735| return main_convert_loop(); 202| 735| } 203| | 204| 0| typedef std::numpunct numpunct; 205| 0| numpunct const& np = BOOST_USE_FACET(numpunct, loc); 206| 0| std::string const& grouping = np.grouping(); 207| 0| std::string::size_type const grouping_size = grouping.size(); 208| | 209| | /* According to Programming languages - C++ 210| | * we MUST check for correct grouping 211| | */ 212| 0| if (!grouping_size || grouping[0] <= 0) { ------------------ | Branch (212:21): [True: 0, False: 0] | Branch (212:39): [True: 0, False: 0] ------------------ 213| 0| return main_convert_loop(); 214| 0| } 215| | 216| 0| unsigned char current_grouping = 0; 217| 0| CharT const thousands_sep = np.thousands_sep(); 218| 0| char remained = static_cast(grouping[current_grouping] - 1); 219| | 220| 0| for (;m_end >= m_begin; --m_end) ------------------ | Branch (220:23): [True: 0, False: 0] ------------------ 221| 0| { 222| 0| if (remained) { ------------------ | Branch (222:25): [True: 0, False: 0] ------------------ 223| 0| if (!main_convert_iteration()) { ------------------ | Branch (223:29): [True: 0, False: 0] ------------------ 224| 0| return false; 225| 0| } 226| 0| --remained; 227| 0| } else { 228| 0| if ( !Traits::eq(*m_end, thousands_sep) ) //|| begin == end ) return false; ------------------ | Branch (228:30): [True: 0, False: 0] ------------------ 229| 0| { 230| | /* 231| | * According to Programming languages - C++ 232| | * Digit grouping is checked. That is, the positions of discarded 233| | * separators is examined for consistency with 234| | * use_facet >(loc ).grouping() 235| | * 236| | * BUT what if there is no separators at all and grouping() 237| | * is not empty? Well, we have no extraced separators, so we 238| | * won`t check them for consistency. This will allow us to 239| | * work with "C" locale from other locales 240| | */ 241| 0| return main_convert_loop(); 242| 0| } else { 243| 0| if (m_begin == m_end) return false; ------------------ | Branch (243:33): [True: 0, False: 0] ------------------ 244| 0| if (current_grouping < grouping_size - 1) ++current_grouping; ------------------ | Branch (244:33): [True: 0, False: 0] ------------------ 245| 0| remained = grouping[current_grouping]; 246| 0| } 247| 0| } 248| 0| } /*for*/ 249| | 250| 0| return true; 251| 0|#endif 252| 0| } _ZN5boost6detail18lcast_ret_unsignedINSt3__111char_traitsIcEEtcE17main_convert_loopEv: 285| 735| bool main_convert_loop() noexcept { 286| 1.62k| for ( ; m_end >= m_begin; --m_end) { ------------------ | Branch (286:25): [True: 938, False: 687] ------------------ 287| 938| if (!main_convert_iteration()) { ------------------ | Branch (287:25): [True: 48, False: 890] ------------------ 288| 48| return false; 289| 48| } 290| 938| } 291| | 292| 687| return true; 293| 735| } _ZN5boost6detail18lcast_ret_unsignedINSt3__111char_traitsIcEEtcE22main_convert_iterationEv: 260| 938| inline bool main_convert_iteration() noexcept { 261| 938| CharT const czero = lcast_char_constants::zero; 262| 938| T const maxv = (std::numeric_limits::max)(); 263| | 264| 938| m_multiplier_overflowed = m_multiplier_overflowed || (maxv/10 < m_multiplier); ------------------ | Branch (264:43): [True: 18, False: 920] | Branch (264:70): [True: 11, False: 909] ------------------ 265| 938| m_multiplier = static_cast(m_multiplier * 10); 266| | 267| 938| T const dig_value = static_cast(*m_end - czero); 268| 938| T const new_sub_value = static_cast(m_multiplier * dig_value); 269| | 270| | // We must correctly handle situations like `000000000000000000000000000001`. 271| | // So we take care of overflow only if `dig_value` is not '0'. 272| 938| if (*m_end < czero || *m_end >= czero + 10 // checking for correct digit ------------------ | Branch (272:21): [True: 24, False: 914] | Branch (272:39): [True: 4, False: 910] ------------------ 273| 938| || (dig_value && ( // checking for overflow of ... ------------------ | Branch (273:25): [True: 798, False: 112] ------------------ 274| 798| m_multiplier_overflowed // ... multiplier ------------------ | Branch (274:25): [True: 4, False: 794] ------------------ 275| 798| || static_cast(maxv / dig_value) < m_multiplier // ... subvalue ------------------ | Branch (275:28): [True: 2, False: 792] ------------------ 276| 798| || static_cast(maxv - new_sub_value) < m_value // ... whole expression ------------------ | Branch (276:28): [True: 14, False: 778] ------------------ 277| 798| )) 278| 938| ) return false; 279| | 280| 890| m_value = static_cast(m_value + new_sub_value); 281| | 282| 890| return true; 283| 938| } _ZN5boost10conversion6detail19try_lexical_convertItNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEbRKT0_RT_: 51| 821| { 52| 821| static_assert( 53| 821| !boost::is_volatile::value, 54| 821| "Boost.LexicalCast does not support volatile input"); 55| | 56| 821| typedef typename boost::detail::array_to_pointer_decay::type src; 57| | 58| 821| typedef boost::detail::is_arithmetic_and_not_xchars 59| 821| shall_we_copy_with_dynamic_check_t; 60| | 61| 821| typedef typename boost::conditional< 62| 821| shall_we_copy_with_dynamic_check_t::value, 63| 821| boost::detail::dynamic_num_converter_impl, 64| 821| boost::detail::lexical_converter_impl 65| 821| >::type caster_type; 66| | 67| 821| return caster_type::try_convert(arg, result); 68| 821| } _ZN5boost15throw_exceptionINS_16bad_lexical_castEEEvRKT_: 163| 134|{ 164| 134| throw_exception_assert_compatibility( e ); 165| 134| throw wrapexcept( e ); 166| 134|} _ZN5boost36throw_exception_assert_compatibilityERKSt9exception: 140| 457|inline void throw_exception_assert_compatibility( std::exception const & ) {} _ZN5boost10wrapexceptINS_16bad_lexical_castEEC2ERKS1_: 97| 134| explicit wrapexcept( E const & e ): E( e ) 98| 134| { 99| 134| copy_from( &e ); 100| 134| } _ZN5boost10wrapexceptINS_16bad_lexical_castEE9copy_fromEPKv: 87| 134| { 88| 134| } _ZN5boost15throw_exceptionINS_9gregorian8bad_yearEEEvRKT_: 163| 214|{ 164| 214| throw_exception_assert_compatibility( e ); 165| 214| throw wrapexcept( e ); 166| 214|} _ZN5boost10wrapexceptINS_9gregorian8bad_yearEEC2ERKS2_: 97| 214| explicit wrapexcept( E const & e ): E( e ) 98| 214| { 99| 214| copy_from( &e ); 100| 214| } _ZN5boost10wrapexceptINS_9gregorian8bad_yearEE9copy_fromEPKv: 87| 214| { 88| 214| } _ZN5boost15throw_exceptionINS_9gregorian9bad_monthEEEvRKT_: 163| 81|{ 164| 81| throw_exception_assert_compatibility( e ); 165| 81| throw wrapexcept( e ); 166| 81|} _ZN5boost10wrapexceptINS_9gregorian9bad_monthEEC2ERKS2_: 97| 81| explicit wrapexcept( E const & e ): E( e ) 98| 81| { 99| 81| copy_from( &e ); 100| 81| } _ZN5boost10wrapexceptINS_9gregorian9bad_monthEE9copy_fromEPKv: 87| 81| { 88| 81| } _ZN5boost15throw_exceptionINS_9gregorian16bad_day_of_monthEEEvRKT_: 163| 28|{ 164| 28| throw_exception_assert_compatibility( e ); 165| 28| throw wrapexcept( e ); 166| 28|} _ZN5boost10wrapexceptINS_9gregorian16bad_day_of_monthEEC2ERKS2_: 97| 28| explicit wrapexcept( E const & e ): E( e ) 98| 28| { 99| 28| copy_from( &e ); 100| 28| } _ZN5boost10wrapexceptINS_9gregorian16bad_day_of_monthEE9copy_fromEPKv: 87| 28| { 88| 28| } _ZN5boost14char_separatorIcNSt3__111char_traitsIcEEEC2EPKcS6_NS_18empty_token_policyE: 438| 457| : m_dropped_delims(dropped_delims), 439| 457| m_use_ispunct(false), 440| 457| m_use_isspace(false), 441| 457| m_empty_tokens(empty_tokens), 442| 457| m_output_done(false) 443| 457| { 444| | // Borland workaround 445| 457| if (kept_delims) ------------------ | Branch (445:11): [True: 0, False: 457] ------------------ 446| 0| m_kept_delims = kept_delims; 447| 457| } _ZN5boost14char_separatorIcNSt3__111char_traitsIcEEE5resetEv: 457| 1.57k| void reset() { } _ZN5boost14char_separatorIcNSt3__111char_traitsIcEEEclINS1_11__wrap_iterIPKcEENS1_12basic_stringIcS3_NS1_9allocatorIcEEEEEEbRT_SE_RT0_: 461| 1.08k| { 462| 1.08k| typedef tokenizer_detail::assign_or_plus_equal< 463| 1.08k| BOOST_DEDUCED_TYPENAME tokenizer_detail::get_iterator_category< 464| 1.08k| InputIterator 465| 1.08k| >::iterator_category 466| 1.08k| > assigner; 467| | 468| 1.08k| assigner::clear(tok); 469| | 470| | // skip past all dropped_delims 471| 1.08k| if (m_empty_tokens == drop_empty_tokens) ------------------ | Branch (471:11): [True: 1.08k, False: 0] ------------------ 472| 1.49k| for (; next != end && is_dropped(*next); ++next) ------------------ | Branch (472:16): [True: 1.18k, False: 307] | Branch (472:32): [True: 403, False: 782] ------------------ 473| 403| { } 474| | 475| 1.08k| InputIterator start(next); 476| | 477| 1.08k| if (m_empty_tokens == drop_empty_tokens) { ------------------ | Branch (477:11): [True: 1.08k, False: 0] ------------------ 478| | 479| 1.08k| if (next == end) ------------------ | Branch (479:13): [True: 307, False: 782] ------------------ 480| 307| return false; 481| | 482| | 483| | // if we are on a kept_delims move past it and stop 484| 782| if (is_kept(*next)) { ------------------ | Branch (484:13): [True: 0, False: 782] ------------------ 485| 0| assigner::plus_equal(tok,*next); 486| 0| ++next; 487| 0| } else 488| | // append all the non delim characters 489| 3.16k| for (; next != end && !is_dropped(*next) && !is_kept(*next); ++next) ------------------ | Branch (489:18): [True: 2.75k, False: 410] | Branch (489:33): [True: 2.38k, False: 372] | Branch (489:55): [True: 2.38k, False: 0] ------------------ 490| 2.38k| assigner::plus_equal(tok,*next); 491| 782| } 492| 0| else { // m_empty_tokens == keep_empty_tokens 493| | 494| | // Handle empty token at the end 495| 0| if (next == end) ------------------ | Branch (495:13): [True: 0, False: 0] ------------------ 496| 0| { 497| 0| if (m_output_done == false) ------------------ | Branch (497:15): [True: 0, False: 0] ------------------ 498| 0| { 499| 0| m_output_done = true; 500| 0| assigner::assign(start,next,tok); 501| 0| return true; 502| 0| } 503| 0| else 504| 0| return false; 505| 0| } 506| | 507| 0| if (is_kept(*next)) { ------------------ | Branch (507:13): [True: 0, False: 0] ------------------ 508| 0| if (m_output_done == false) ------------------ | Branch (508:15): [True: 0, False: 0] ------------------ 509| 0| m_output_done = true; 510| 0| else { 511| 0| assigner::plus_equal(tok,*next); 512| 0| ++next; 513| 0| m_output_done = false; 514| 0| } 515| 0| } 516| 0| else if (m_output_done == false && is_dropped(*next)) { ------------------ | Branch (516:18): [True: 0, False: 0] | Branch (516:44): [True: 0, False: 0] ------------------ 517| 0| m_output_done = true; 518| 0| } 519| 0| else { 520| 0| if (is_dropped(*next)) ------------------ | Branch (520:15): [True: 0, False: 0] ------------------ 521| 0| start=++next; 522| 0| for (; next != end && !is_dropped(*next) && !is_kept(*next); ++next) ------------------ | Branch (522:18): [True: 0, False: 0] | Branch (522:33): [True: 0, False: 0] | Branch (522:55): [True: 0, False: 0] ------------------ 523| 0| assigner::plus_equal(tok,*next); 524| 0| m_output_done = true; 525| 0| } 526| 0| } 527| 782| assigner::assign(start,next,tok); 528| 782| return true; 529| 1.08k| } _ZN5boost16tokenizer_detail20assign_or_plus_equalINSt3__126random_access_iterator_tagEE5clearINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvRT_: 293| 1.30k| static void clear(Token &) { } _ZNK5boost14char_separatorIcNSt3__111char_traitsIcEEE10is_droppedEc: 549| 3.94k| { 550| 3.94k| if (m_dropped_delims.length()) ------------------ | Branch (550:11): [True: 3.94k, False: 0] ------------------ 551| 3.94k| return m_dropped_delims.find(E) != string_type::npos; 552| 0| else if (m_use_isspace) { ------------------ | Branch (552:16): [True: 0, False: 0] ------------------ 553| 0| return Traits::isspace(E) != 0; 554| 0| } else 555| 0| return false; 556| 3.94k| } _ZNK5boost14char_separatorIcNSt3__111char_traitsIcEEE7is_keptEc: 540| 3.16k| { 541| 3.16k| if (m_kept_delims.length()) ------------------ | Branch (541:11): [True: 0, False: 3.16k] ------------------ 542| 0| return m_kept_delims.find(E) != string_type::npos; 543| 3.16k| else if (m_use_ispunct) { ------------------ | Branch (543:16): [True: 0, False: 3.16k] ------------------ 544| 0| return Traits::ispunct(E) != 0; 545| 0| } else 546| 3.16k| return false; 547| 3.16k| } _ZN5boost16tokenizer_detail20assign_or_plus_equalINSt3__126random_access_iterator_tagEE10plus_equalINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEcEEvRT_RKT0_: 287| 2.84k| static void plus_equal(Token &, const Value &) { } _ZN5boost16tokenizer_detail20assign_or_plus_equalINSt3__126random_access_iterator_tagEE6assignINS2_11__wrap_iterIPKcEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvT_SG_RT0_: 282| 952| static void assign(Iterator b, Iterator e, Token &t) { 283| 952| t.assign(b, e); 284| 952| } _ZN5boost16offset_separatorC2IPiEET_S3_bb: 355| 60| : offsets_(begin,end), current_offset_(0), 356| 60| wrap_offsets_(wrap_offsets), 357| 60| return_partial_last_(return_partial_last) { } _ZN5boost16offset_separator5resetEv: 363| 272| void reset() { 364| 272| current_offset_ = 0; 365| 272| } _ZN5boost16offset_separatorclINSt3__111__wrap_iterIPKcEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbRT_SD_RT0_: 369| 212| { 370| 212| typedef tokenizer_detail::assign_or_plus_equal< 371| 212| BOOST_DEDUCED_TYPENAME tokenizer_detail::get_iterator_category< 372| 212| InputIterator 373| 212| >::iterator_category 374| 212| > assigner; 375| | 376| 212| BOOST_ASSERT(!offsets_.empty()); ------------------ | | 66| 212|# define BOOST_ASSERT(expr) assert(expr) ------------------ 377| | 378| 212| assigner::clear(tok); 379| 212| InputIterator start(next); 380| | 381| 212| if (next == end) ------------------ | Branch (381:11): [True: 34, False: 178] ------------------ 382| 34| return false; 383| | 384| 178| if (current_offset_ == offsets_.size()) ------------------ | Branch (384:11): [True: 8, False: 170] ------------------ 385| 8| { 386| 8| if (wrap_offsets_) ------------------ | Branch (386:13): [True: 0, False: 8] ------------------ 387| 0| current_offset_=0; 388| 8| else 389| 8| return false; 390| 8| } 391| | 392| 170| int c = offsets_[current_offset_]; 393| 170| int i = 0; 394| 630| for (; i < c; ++i) { ------------------ | Branch (394:14): [True: 460, False: 170] ------------------ 395| 460| if (next == end)break; ------------------ | Branch (395:13): [True: 0, False: 460] ------------------ 396| 460| assigner::plus_equal(tok,*next++); 397| 460| } 398| 170| assigner::assign(start,next,tok); 399| | 400| 170| if (!return_partial_last_) ------------------ | Branch (400:11): [True: 170, False: 0] ------------------ 401| 170| if (i < (c-1) ) ------------------ | Branch (401:13): [True: 0, False: 170] ------------------ 402| 0| return false; 403| | 404| 170| ++current_offset_; 405| 170| return true; 406| 170| } _ZN5boost14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS2_11__wrap_iterIPKcEENS2_12basic_stringIcS4_NS2_9allocatorIcEEEEEC2ES5_S9_S9_: 80| 1.57k| : f_(f),begin_(begin),end_(e),valid_(false),tok_(){ initialize(); } _ZN5boost14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS2_11__wrap_iterIPKcEENS2_12basic_stringIcS4_NS2_9allocatorIcEEEEE10initializeEv: 70| 1.57k| void initialize(){ 71| 1.57k| if(valid_) return; ------------------ | Branch (71:14): [True: 0, False: 1.57k] ------------------ 72| 1.57k| f_.reset(); 73| 1.57k| valid_ = (begin_ != end_)? ------------------ | Branch (73:20): [True: 426, False: 1.15k] ------------------ 74| 1.15k| f_(begin_,end_,tok_):false; 75| 1.57k| } _ZNK5boost14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS2_11__wrap_iterIPKcEENS2_12basic_stringIcS4_NS2_9allocatorIcEEEEE5equalISE_EEbRKT_: 63| 1.12k| bool equal(const Other& a) const{ 64| 1.12k| return (a.valid_ && valid_) ------------------ | Branch (64:19): [True: 0, False: 1.12k] | Branch (64:31): [True: 0, False: 0] ------------------ 65| 1.12k| ?( (a.begin_==begin_) && (a.end_ == end_) ) ------------------ | Branch (65:18): [True: 0, False: 0] | Branch (65:40): [True: 0, False: 0] ------------------ 66| 1.12k| :(a.valid_==valid_); 67| | 68| 1.12k| } _ZNK5boost14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS2_11__wrap_iterIPKcEENS2_12basic_stringIcS4_NS2_9allocatorIcEEEEE11dereferenceEv: 58| 779| const Type& dereference() const { 59| 779| BOOST_ASSERT(valid_); ------------------ | | 66| 779|# define BOOST_ASSERT(expr) assert(expr) ------------------ 60| 779| return tok_; 61| 779| } _ZN5boost14token_iteratorINS_14char_separatorIcNSt3__111char_traitsIcEEEENS2_11__wrap_iterIPKcEENS2_12basic_stringIcS4_NS2_9allocatorIcEEEEE9incrementEv: 53| 663| void increment(){ 54| 663| BOOST_ASSERT(valid_); ------------------ | | 66| 663|# define BOOST_ASSERT(expr) assert(expr) ------------------ 55| 663| valid_ = f_(begin_,end_,tok_); 56| 663| } _ZN5boost14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2ES1_S6_S6_: 80| 272| : f_(f),begin_(begin),end_(e),valid_(false),tok_(){ initialize(); } _ZN5boost14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE10initializeEv: 70| 272| void initialize(){ 71| 272| if(valid_) return; ------------------ | Branch (71:14): [True: 0, False: 272] ------------------ 72| 272| f_.reset(); 73| 272| valid_ = (begin_ != end_)? ------------------ | Branch (73:20): [True: 60, False: 212] ------------------ 74| 212| f_(begin_,end_,tok_):false; 75| 272| } _ZNK5boost14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5equalISD_EEbRKT_: 63| 212| bool equal(const Other& a) const{ 64| 212| return (a.valid_ && valid_) ------------------ | Branch (64:19): [True: 0, False: 212] | Branch (64:31): [True: 0, False: 0] ------------------ 65| 212| ?( (a.begin_==begin_) && (a.end_ == end_) ) ------------------ | Branch (65:18): [True: 0, False: 0] | Branch (65:40): [True: 0, False: 0] ------------------ 66| 212| :(a.valid_==valid_); 67| | 68| 212| } _ZNK5boost14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE11dereferenceEv: 58| 170| const Type& dereference() const { 59| 170| BOOST_ASSERT(valid_); ------------------ | | 66| 170|# define BOOST_ASSERT(expr) assert(expr) ------------------ 60| 170| return tok_; 61| 170| } _ZN5boost14token_iteratorINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE9incrementEv: 53| 152| void increment(){ 54| 152| BOOST_ASSERT(valid_); ------------------ | | 66| 152|# define BOOST_ASSERT(expr) assert(expr) ------------------ 55| 152| valid_ = f_(begin_,end_,tok_); 56| 152| } _ZN5boost9tokenizerINS_14char_separatorIcNSt3__111char_traitsIcEEEENS2_11__wrap_iterIPKcEENS2_12basic_stringIcS4_NS2_9allocatorIcEEEEEC2ISD_EERKT_RKS5_: 63| 457| : first_(c.begin()), last_(c.end()), f_(f) { } _ZNK5boost9tokenizerINS_14char_separatorIcNSt3__111char_traitsIcEEEENS2_11__wrap_iterIPKcEENS2_12basic_stringIcS4_NS2_9allocatorIcEEEEE5beginEv: 86| 457| iter begin() const { return iter(f_,first_,last_); } _ZNK5boost9tokenizerINS_14char_separatorIcNSt3__111char_traitsIcEEEENS2_11__wrap_iterIPKcEENS2_12basic_stringIcS4_NS2_9allocatorIcEEEEE3endEv: 87| 1.12k| iter end() const { return iter(f_,last_,last_); } _ZN5boost9tokenizerINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2ISC_EERKT_RKS1_: 63| 60| : first_(c.begin()), last_(c.end()), f_(f) { } _ZNK5boost9tokenizerINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5beginEv: 86| 60| iter begin() const { return iter(f_,first_,last_); } _ZNK5boost9tokenizerINS_16offset_separatorENSt3__111__wrap_iterIPKcEENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE3endEv: 87| 212| iter end() const { return iter(f_,last_,last_); } _ZNK5boost17integral_constantIbLb1EEcvRKN4mpl_5bool_ILb1EEEEv: 81| 1.33k| { 82| 1.33k| static const char data[sizeof(long)] = { 0 }; 83| 1.33k| static const void* pdata = data; 84| 1.33k| return *(reinterpret_cast*>(pdata)); 85| 1.33k| } LLVMFuzzerTestOneInput: 20| 457|{ 21| 457| FuzzedDataProvider fdp(data, size); 22| | 23| 457| try { 24| 457| std::string s(fdp.ConsumeRandomLengthString(15)); 25| 457| date d(from_simple_string(s)); 26| 457| to_simple_string(d); 27| | 28| 457| date d1(from_undelimited_string(s)); 29| 457| to_iso_extended_string(d1); 30| | 31| 457| date::ymd_type ymd = d1.year_month_day(); 32| 457| greg_weekday wd = d1.day_of_week(); 33| 457| wd.as_long_string(); 34| 457| ymd.month.as_long_string(); 35| 457| } catch(...) { 36| 457| } 37| 457| return 0; 38| 457|}