_ZN5boost9addressofIKNS_10filesystem4pathEEEPT_RS4_: 39| 11.1k|{ 40| 11.1k| return __builtin_addressof(o); 41| 11.1k|} _ZN5boost10filesystem4pathC2EONSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 399| 2.18k| path(string_type&& s) noexcept : m_pathname(static_cast< string_type&& >(s)) 400| 2.18k| { 401| 2.18k| } _ZNK5boost10filesystem4path13has_extensionEv: 1011| 545| bool has_extension() const { return !extension().empty(); } _ZNK5boost10filesystem4path5emptyEv: 1001| 1.83k| bool empty() const noexcept { return m_pathname.empty(); } _ZNK5boost10filesystem4path9extensionEv: 1602| 1.09k|{ 1603| 1.09k| return BOOST_FILESYSTEM_VERSIONED_SYM(detail::path_algorithms::extension)(*this); ------------------ | | 34| 1.09k|#define BOOST_FILESYSTEM_VERSIONED_SYM(sym) BOOST_JOIN(sym, BOOST_JOIN(_v, BOOST_FILESYSTEM_VERSION)) ------------------ 1604| 1.09k|} _ZN5boost10filesystem4path17replace_extensionERKS1_: 1581| 545|{ 1582| 545| BOOST_FILESYSTEM_VERSIONED_SYM(detail::path_algorithms::replace_extension)(*this, new_extension); ------------------ | | 34| 545|#define BOOST_FILESYSTEM_VERSIONED_SYM(sym) BOOST_JOIN(sym, BOOST_JOIN(_v, BOOST_FILESYSTEM_VERSION)) ------------------ 1583| 545| return *this; 1584| 545|} _ZN5boost10filesystem4path6concatERKS1_: 624| 1.09k| { 625| 1.09k| m_pathname.append(p.m_pathname); 626| 1.09k| return *this; 627| 1.09k| } _ZN5boost10filesystem4path6appendERKS1_: 1551| 1.09k|{ 1552| 1.09k| BOOST_FILESYSTEM_VERSIONED_SYM(detail::path_algorithms::append)(*this, p.m_pathname.data(), p.m_pathname.data() + p.m_pathname.size()); ------------------ | | 34| 1.09k|#define BOOST_FILESYSTEM_VERSIONED_SYM(sym) BOOST_JOIN(sym, BOOST_JOIN(_v, BOOST_FILESYSTEM_VERSION)) ------------------ 1553| 1.09k| return *this; 1554| 1.09k|} _ZN5boost10filesystem4pathdVERKS1_: 1508| 545|{ 1509| 545| return append(p); 1510| 545|} _ZN5boost10filesystem4pathpLERKS1_: 1503| 545|{ 1504| 545| return concat(p); 1505| 545|} _ZNK5boost10filesystem4path15filename_is_dotEv: 1529| 545|{ 1530| | // implicit dot is tricky, so actually call filename(); see path::filename() example 1531| | // in reference.html 1532| 545| path p(filename()); 1533| 545| return p.size() == 1 && *p.c_str() == dot; ------------------ | Branch (1533:12): [True: 209, False: 336] | Branch (1533:29): [True: 94, False: 115] ------------------ 1534| 545|} _ZNK5boost10filesystem4path8filenameEv: 1592| 545|{ 1593| 545| return BOOST_FILESYSTEM_VERSIONED_SYM(detail::path_algorithms::filename)(*this); ------------------ | | 34| 545|#define BOOST_FILESYSTEM_VERSIONED_SYM(sym) BOOST_JOIN(sym, BOOST_JOIN(_v, BOOST_FILESYSTEM_VERSION)) ------------------ 1594| 545|} _ZNK5boost10filesystem4path4sizeEv: 860| 545| string_type::size_type size() const noexcept { return m_pathname.size(); } _ZNK5boost10filesystem4path5c_strEv: 859| 209| const value_type* c_str() const noexcept { return m_pathname.c_str(); } _ZN5boost10filesystem4path15remove_filenameEv: 1575| 545|{ 1576| 545| BOOST_FILESYSTEM_VERSIONED_SYM(detail::path_algorithms::remove_filename)(*this); ------------------ | | 34| 545|#define BOOST_FILESYSTEM_VERSIONED_SYM(sym) BOOST_JOIN(sym, BOOST_JOIN(_v, BOOST_FILESYSTEM_VERSION)) ------------------ 1577| 545| return *this; 1578| 545|} _ZN5boost10filesystem4path4swapERS1_: 835| 545| void swap(path& rhs) noexcept { m_pathname.swap(rhs.m_pathname); } _ZNK5boost10filesystem4path14root_directoryEv: 980| 545| { 981| 545| detail::path_algorithms::substring root_dir = detail::path_algorithms::find_root_directory(*this); 982| 545| const value_type* p = m_pathname.c_str() + root_dir.pos; 983| 545| return path(p, p + root_dir.size); 984| 545| } _ZN5boost10filesystem4pathC2EPKcS3_: 421| 4.02k| path(const value_type* begin, const value_type* end) : m_pathname(begin, end) {} _ZNK5boost10filesystem4path13relative_pathEv: 987| 545| { 988| 545| detail::path_algorithms::substring rel_path = detail::path_algorithms::find_relative_path(*this); 989| 545| const value_type* p = m_pathname.c_str() + rel_path.pos; 990| 545| return path(p, p + rel_path.size); 991| 545| } _ZNK5boost10filesystem4path11parent_pathEv: 993| 545| path parent_path() const { return path(m_pathname.c_str(), m_pathname.c_str() + detail::path_algorithms::find_parent_path_size(*this)); } _ZNK5boost10filesystem4path8has_stemEv: 1010| 545| bool has_stem() const { return !stem().empty(); } _ZNK5boost10filesystem4path4stemEv: 1597| 545|{ 1598| 545| return BOOST_FILESYSTEM_VERSIONED_SYM(detail::path_algorithms::stem)(*this); ------------------ | | 34| 545|#define BOOST_FILESYSTEM_VERSIONED_SYM(sym) BOOST_JOIN(sym, BOOST_JOIN(_v, BOOST_FILESYSTEM_VERSION)) ------------------ 1599| 545|} _ZN5boost10filesystem4pathC2Ev: 336| 22.5k| path() noexcept {} _ZN5boost10filesystem4pathC2ERKS1_: 337| 3.61k| path(path const& p) : m_pathname(p.m_pathname) {} _ZN5boost10filesystem4pathC2EPKc: 340| 112| path(const value_type* s) : m_pathname(s) {} _ZN5boost10filesystem4pathaSEONSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 406| 8.23k| { 407| 8.23k| m_pathname = static_cast< string_type&& >(p); 408| 8.23k| return *this; 409| 8.23k| } _ZN5boost10filesystem4path6assignEPKcS3_: 542| 118| { 543| 118| m_pathname.assign(begin, end); 544| 118| return *this; 545| 118| } _ZN5boost10filesystem4path5clearEv: 827| 1.19k| void clear() noexcept { m_pathname.clear(); } _ZNK5boost10filesystem4path6nativeEv: 858| 11.0k| string_type const& native() const noexcept { return m_pathname; } _ZNK5boost10filesystem11path_detail13path_iterator11dereferenceEv: 1080| 12.5k| path const& dereference() const { return m_element; } _ZNK5boost10filesystem11path_detail13path_iterator5equalERKS2_: 1083| 17.1k| { 1084| 17.1k| return m_path_ptr == rhs.m_path_ptr && m_pos == rhs.m_pos; ------------------ | Branch (1084:16): [True: 17.1k, False: 0] | Branch (1084:48): [True: 7.46k, False: 9.64k] ------------------ 1085| 17.1k| } _ZN5boost10filesystem6detail22is_directory_separatorEc: 1417| 34.8k|{ 1418| 34.8k| return c == path::separator 1419| |#ifdef BOOST_WINDOWS_API 1420| | || c == path::preferred_separator 1421| |#endif 1422| 34.8k| ; 1423| 34.8k|} _ZN5boost10filesystem6detail15path_algorithms15has_filename_v4ERKNS0_4pathE: 1448| 278|{ 1449| 278| return path_algorithms::find_filename_v4_size(p) > 0; 1450| 278|} _ZN5boost10filesystem6detail15path_algorithms9append_v4ERNS0_4pathERKS3_: 1469| 668|{ 1470| 668| path_algorithms::append_v4(left, right.m_pathname.c_str(), right.m_pathname.c_str() + right.m_pathname.size()); 1471| 668|} _ZN5boost9iteratorsneINS_10filesystem11path_detail13path_iteratorEKNS2_4pathENS0_27bidirectional_traversal_tagERS6_lS4_S6_S7_S8_lEENS0_6detail23enable_if_interoperableIT_T4_NS_3mpl6apply2INS9_12always_bool2ESB_SC_E4typeEE4typeERKNS0_15iterator_facadeISB_T0_T1_T2_T3_EERKNSK_ISC_T5_T6_T7_T8_EE: 961| 10.4k| { \ 962| 10.4k| /* For those compilers that do not support enable_if */ \ 963| 10.4k| BOOST_STATIC_ASSERT(( \ ------------------ | | 71| 10.4k|# define BOOST_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__) ------------------ 964| 10.4k| is_interoperable< Derived1, Derived2 >::value \ 965| 10.4k| )); \ 966| 10.4k| return_prefix iterator_core_access::base_op( \ 967| 10.4k| *static_cast(&lhs) \ 968| 10.4k| , *static_cast(&rhs) \ 969| 10.4k| , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ ------------------ | | 956| 10.4k|# define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible() ------------------ 970| 10.4k| ); \ 971| 10.4k| } _ZN5boost9iterators20iterator_core_access5equalINS_10filesystem11path_detail13path_iteratorES5_EEbRKT_RKT0_N4mpl_5bool_ILb1EEE: 648| 17.1k| { 649| 17.1k| return f1.equal(f2); 650| 17.1k| } _ZNK5boost9iterators6detail20iterator_facade_baseINS_10filesystem11path_detail13path_iteratorEKNS3_4pathENS0_27bidirectional_traversal_tagERS7_lLb0ELb0EEdeEv: 736| 12.5k| { 737| 12.5k| return iterator_core_access::dereference(this->derived()); 738| 12.5k| } _ZNK5boost9iterators6detail20iterator_facade_baseINS_10filesystem11path_detail13path_iteratorEKNS3_4pathENS0_27bidirectional_traversal_tagERS7_lLb0ELb0EE7derivedEv: 761| 23.6k| { 762| 23.6k| return *static_cast(this); 763| 23.6k| } _ZN5boost9iterators20iterator_core_access11dereferenceINS_10filesystem11path_detail13path_iteratorEEENT_9referenceERKS6_: 630| 12.5k| { 631| 12.5k| return f.dereference(); 632| 12.5k| } _ZN5boost9iteratorseqINS_10filesystem11path_detail13path_iteratorEKNS2_4pathENS0_27bidirectional_traversal_tagERS6_lS4_S6_S7_S8_lEENS0_6detail23enable_if_interoperableIT_T4_NS_3mpl6apply2INS9_12always_bool2ESB_SC_E4typeEE4typeERKNS0_15iterator_facadeISB_T0_T1_T2_T3_EERKNSK_ISC_T5_T6_T7_T8_EE: 961| 6.71k| { \ 962| 6.71k| /* For those compilers that do not support enable_if */ \ 963| 6.71k| BOOST_STATIC_ASSERT(( \ ------------------ | | 71| 6.71k|# define BOOST_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__) ------------------ 964| 6.71k| is_interoperable< Derived1, Derived2 >::value \ 965| 6.71k| )); \ 966| 6.71k| return_prefix iterator_core_access::base_op( \ 967| 6.71k| *static_cast(&lhs) \ 968| 6.71k| , *static_cast(&rhs) \ 969| 6.71k| , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ ------------------ | | 956| 6.71k|# define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible() ------------------ 970| 6.71k| ); \ 971| 6.71k| } _ZNK5boost9iterators6detail20iterator_facade_baseINS_10filesystem11path_detail13path_iteratorEKNS3_4pathENS0_27bidirectional_traversal_tagERS7_lLb0ELb0EEptEv: 741| 11.1k| { 742| 11.1k| return operator_arrow_dispatch_::apply(*this->derived()); 743| 11.1k| } _ZN5boost9iterators6detail23operator_arrow_dispatchIRKNS_10filesystem4pathEPS5_E5applyES6_: 426| 11.1k| { 427| 11.1k| return boost::addressof(x); 428| 11.1k| } _ZNK5boost17integral_constantIbLb1EEcvRKN4mpl_5bool_ILb1EEEEv: 81| 17.1k| { 82| 17.1k| static const char data[sizeof(long)] = { 0 }; 83| 17.1k| static const void* pdata = data; 84| 17.1k| return *(reinterpret_cast*>(pdata)); 85| 17.1k| } _ZN5boost10filesystem6detail15path_algorithms9append_v3ERNS0_4pathEPKcS6_: 478| 1.09k|{ 479| 1.09k| if (begin != end) ------------------ | Branch (479:9): [True: 504, False: 586] ------------------ 480| 504| { 481| 504| if (BOOST_LIKELY(begin < p.m_pathname.data() || begin >= (p.m_pathname.data() + p.m_pathname.size()))) ------------------ | | 74| 1.00k|#define BOOST_LIKELY(x) __builtin_expect(x, 1) | | ------------------ | | | Branch (74:25): [True: 504, False: 0] | | | Branch (74:42): [True: 0, False: 504] | | | Branch (74:42): [True: 504, False: 0] | | ------------------ ------------------ 482| 504| { 483| 504| if (!detail::is_directory_separator(*begin)) ------------------ | Branch (483:17): [True: 292, False: 212] ------------------ 484| 292| path_algorithms::append_separator_if_needed(p); 485| 504| p.m_pathname.append(begin, end); 486| 504| } 487| 0| else 488| 0| { 489| | // overlapping source 490| 0| string_type rhs(begin, end); 491| 0| path_algorithms::append_v3(p, rhs.data(), rhs.data() + rhs.size()); 492| 0| } 493| 504| } 494| 1.09k|} _ZN5boost10filesystem6detail15path_algorithms9append_v4ERNS0_4pathEPKcS6_: 497| 1.21k|{ 498| 1.21k| if (begin != end) ------------------ | Branch (498:9): [True: 935, False: 278] ------------------ 499| 935| { 500| 935| if (BOOST_LIKELY(begin < p.m_pathname.data() || begin >= (p.m_pathname.data() + p.m_pathname.size()))) ------------------ | | 74| 1.29k|#define BOOST_LIKELY(x) __builtin_expect(x, 1) | | ------------------ | | | Branch (74:25): [True: 935, False: 0] | | | Branch (74:42): [True: 571, False: 364] | | | Branch (74:42): [True: 364, False: 0] | | ------------------ ------------------ 501| 935| { 502| 935| const size_type that_size = end - begin; 503| 935| size_type that_root_name_size = 0; 504| 935| size_type that_root_dir_pos = find_root_directory_start(begin, that_size, that_root_name_size); 505| | 506| | // if (p.is_absolute()) 507| 935| if 508| 935| ( 509| |#if defined(BOOST_WINDOWS_API) 510| | that_root_name_size > 0 && 511| |#endif 512| 935| that_root_dir_pos < that_size ------------------ | Branch (512:17): [True: 63, False: 872] ------------------ 513| 935| ) 514| 63| { 515| 118| return_assign: 516| 118| p.assign(begin, end); 517| 118| return; 518| 63| } 519| | 520| 872| size_type this_root_name_size = 0; 521| 872| find_root_directory_start(p.m_pathname.c_str(), p.m_pathname.size(), this_root_name_size); 522| | 523| 872| if 524| 872| ( 525| 872| that_root_name_size > 0 && ------------------ | Branch (525:17): [True: 56, False: 816] ------------------ 526| 872| (that_root_name_size != this_root_name_size || std::memcmp(p.m_pathname.c_str(), begin, this_root_name_size * sizeof(value_type)) != 0) ------------------ | Branch (526:18): [True: 20, False: 36] | Branch (526:64): [True: 35, False: 1] ------------------ 527| 872| ) 528| 55| { 529| 55| goto return_assign; 530| 55| } 531| | 532| 817| if (that_root_dir_pos < that_size) ------------------ | Branch (532:17): [True: 0, False: 817] ------------------ 533| 0| { 534| | // Remove root directory (if any) and relative path to replace with those from p 535| 0| p.m_pathname.erase(p.m_pathname.begin() + this_root_name_size, p.m_pathname.end()); 536| 0| } 537| | 538| 817| const value_type* const that_path = begin + that_root_name_size; 539| 817| if (!detail::is_directory_separator(*that_path)) ------------------ | Branch (539:17): [True: 817, False: 0] ------------------ 540| 817| path_algorithms::append_separator_if_needed(p); 541| 817| p.m_pathname.append(that_path, end); 542| 817| } 543| 0| else 544| 0| { 545| | // overlapping source 546| 0| string_type rhs(begin, end); 547| 0| path_algorithms::append_v4(p, rhs.data(), rhs.data() + rhs.size()); 548| 0| } 549| 935| } 550| 278| else if (path_algorithms::has_filename_v4(p)) ------------------ | Branch (550:14): [True: 50, False: 228] ------------------ 551| 50| { 552| 50| p.m_pathname.push_back(path::preferred_separator); 553| 50| } 554| 1.21k|} _ZN5boost10filesystem6detail15path_algorithms14lex_compare_v4ENS0_11path_detail13path_iteratorERKS4_S4_S6_: 584| 4.56k|{ 585| 5.07k| for (; first1 != last1 && first2 != last2;) ------------------ | Branch (585:12): [True: 3.08k, False: 1.99k] | Branch (585:31): [True: 3.06k, False: 16] ------------------ 586| 3.06k| { 587| 3.06k| if (first1->native() < first2->native()) ------------------ | Branch (587:13): [True: 623, False: 2.44k] ------------------ 588| 623| return -1; 589| 2.44k| if (first2->native() < first1->native()) ------------------ | Branch (589:13): [True: 1.93k, False: 509] ------------------ 590| 1.93k| return 1; 591| 509| BOOST_ASSERT(first2->native() == first1->native()); ------------------ | | 66| 509|# define BOOST_ASSERT(expr) assert(expr) ------------------ 592| 509| path_algorithms::increment_v4(first1); 593| 509| path_algorithms::increment_v4(first2); 594| 509| } 595| 2.01k| if (first1 == last1 && first2 == last2) ------------------ | Branch (595:9): [True: 1.99k, False: 16] | Branch (595:28): [True: 509, False: 1.48k] ------------------ 596| 509| return 0; 597| 1.50k| return first1 == last1 ? -1 : 1; ------------------ | Branch (597:12): [True: 1.48k, False: 16] ------------------ 598| 2.01k|} _ZN5boost10filesystem6detail15path_algorithms10compare_v4ERKNS0_4pathES5_: 606| 4.56k|{ 607| 4.56k| return path_algorithms::lex_compare_v4(left.begin(), left.end(), right.begin(), right.end()); 608| 4.56k|} _ZN5boost10filesystem6detail15path_algorithms26append_separator_if_neededERNS0_4pathE: 613| 1.10k|{ 614| 1.10k| if (!p.m_pathname.empty() && ------------------ | Branch (614:9): [True: 864, False: 245] | Branch (614:9): [True: 751, False: 358] ------------------ 615| |#ifdef BOOST_WINDOWS_API 616| | *(p.m_pathname.end() - 1) != colon && 617| |#endif 618| 1.10k| !detail::is_directory_separator(*(p.m_pathname.end() - 1))) ------------------ | Branch (618:9): [True: 751, False: 113] ------------------ 619| 751| { 620| 751| string_type::size_type tmp(p.m_pathname.size()); 621| 751| p.m_pathname.push_back(path::preferred_separator); 622| 751| return tmp; 623| 751| } 624| 358| return 0; 625| 1.10k|} _ZN5boost10filesystem6detail15path_algorithms18remove_filename_v3ERNS0_4pathE: 646| 545|{ 647| 545| p.remove_filename_and_trailing_separators(); 648| 545|} _ZN5boost10filesystem6detail15path_algorithms18remove_filename_v4ERNS0_4pathE: 651| 545|{ 652| 545| size_type filename_size = path_algorithms::find_filename_v4_size(p); 653| 545| p.m_pathname.erase(p.m_pathname.begin() + (p.m_pathname.size() - filename_size), p.m_pathname.end()); 654| 545|} _ZN5boost10filesystem6detail15path_algorithms20replace_extension_v3ERNS0_4pathERKS3_: 657| 545|{ 658| | // erase existing extension, including the dot, if any 659| 545| size_type ext_pos = p.m_pathname.size() - path_algorithms::extension_v3(p).m_pathname.size(); 660| 545| p.m_pathname.erase(p.m_pathname.begin() + ext_pos, p.m_pathname.end()); 661| | 662| 545| if (!new_extension.empty()) ------------------ | Branch (662:9): [True: 186, False: 359] ------------------ 663| 186| { 664| | // append new_extension, adding the dot if necessary 665| 186| if (new_extension.m_pathname[0] != path::dot) ------------------ | Branch (665:13): [True: 179, False: 7] ------------------ 666| 179| p.m_pathname.push_back(path::dot); 667| 186| p.m_pathname.append(new_extension.m_pathname); 668| 186| } 669| 545|} _ZN5boost10filesystem6detail15path_algorithms19find_root_directoryERKNS0_4pathE: 708| 545|{ 709| 545| substring root_dir; 710| 545| size_type root_name_size = 0; 711| 545| root_dir.pos = find_root_directory_start(p.m_pathname.c_str(), p.m_pathname.size(), root_name_size); 712| 545| root_dir.size = static_cast< std::size_t >(root_dir.pos < p.m_pathname.size()); 713| 545| return root_dir; 714| 545|} _ZN5boost10filesystem6detail15path_algorithms18find_relative_pathERKNS0_4pathE: 717| 545|{ 718| 545| size_type root_name_size = 0; 719| 545| size_type root_dir_pos = find_root_directory_start(p.m_pathname.c_str(), p.m_pathname.size(), root_name_size); 720| | 721| | // Skip root name, root directory and any duplicate separators 722| 545| size_type size = root_name_size; 723| 545| if (root_dir_pos < p.m_pathname.size()) ------------------ | Branch (723:9): [True: 86, False: 459] ------------------ 724| 86| { 725| 86| size = root_dir_pos + 1; 726| | 727| 122| for (size_type n = p.m_pathname.size(); size < n; ++size) ------------------ | Branch (727:49): [True: 95, False: 27] ------------------ 728| 95| { 729| 95| if (!detail::is_directory_separator(p.m_pathname[size])) ------------------ | Branch (729:17): [True: 59, False: 36] ------------------ 730| 59| break; 731| 95| } 732| 86| } 733| | 734| 545| substring rel_path; 735| 545| rel_path.pos = size; 736| 545| rel_path.size = p.m_pathname.size() - size; 737| | 738| 545| return rel_path; 739| 545|} _ZN5boost10filesystem6detail15path_algorithms21find_parent_path_sizeERKNS0_4pathE: 742| 1.63k|{ 743| 1.63k| const size_type size = p.m_pathname.size(); 744| 1.63k| size_type root_name_size = 0; 745| 1.63k| size_type root_dir_pos = find_root_directory_start(p.m_pathname.c_str(), size, root_name_size); 746| | 747| 1.63k| size_type filename_size = find_filename_size(p.m_pathname, root_name_size, size); 748| 1.63k| size_type end_pos = size - filename_size; 749| 2.61k| while (true) ------------------ | Branch (749:12): [Folded - Ignored] ------------------ 750| 2.61k| { 751| 2.61k| if (end_pos <= root_name_size) ------------------ | Branch (751:13): [True: 820, False: 1.79k] ------------------ 752| 820| { 753| | // Keep the root name as the parent path if there was a filename 754| 820| if (filename_size == 0) ------------------ | Branch (754:17): [True: 626, False: 194] ------------------ 755| 626| end_pos = 0u; 756| 820| break; 757| 820| } 758| | 759| 1.79k| --end_pos; 760| | 761| 1.79k| if (!detail::is_directory_separator(p.m_pathname[end_pos])) ------------------ | Branch (761:13): [True: 618, False: 1.18k] ------------------ 762| 618| { 763| 618| ++end_pos; 764| 618| break; 765| 618| } 766| | 767| 1.18k| if (end_pos == root_dir_pos) ------------------ | Branch (767:13): [True: 197, False: 983] ------------------ 768| 197| { 769| | // Keep the trailing root directory if there was a filename 770| 197| end_pos += filename_size > 0; 771| 197| break; 772| 197| } 773| 1.18k| } 774| | 775| 1.63k| return end_pos; 776| 1.63k|} _ZN5boost10filesystem6detail15path_algorithms11filename_v3ERKNS0_4pathE: 779| 2.72k|{ 780| 2.72k| const size_type size = p.m_pathname.size(); 781| 2.72k| size_type root_name_size = 0; 782| 2.72k| size_type root_dir_pos = find_root_directory_start(p.m_pathname.c_str(), size, root_name_size); 783| 2.72k| size_type filename_size, pos; 784| 2.72k| if (root_dir_pos < size && detail::is_directory_separator(p.m_pathname[size - 1]) && is_root_separator(p.m_pathname, root_dir_pos, size - 1)) ------------------ | Branch (784:9): [True: 746, False: 1.97k] | Branch (784:32): [True: 367, False: 379] | Branch (784:90): [True: 197, False: 170] ------------------ 785| 197| { 786| | // Return root directory 787| 197| pos = root_dir_pos; 788| 197| filename_size = 1u; 789| 197| } 790| 2.52k| else if (root_name_size == size) ------------------ | Branch (790:14): [True: 1.17k, False: 1.35k] ------------------ 791| 1.17k| { 792| | // Return root name 793| 1.17k| pos = 0u; 794| 1.17k| filename_size = root_name_size; 795| 1.17k| } 796| 1.35k| else 797| 1.35k| { 798| 1.35k| filename_size = find_filename_size(p.m_pathname, root_name_size, size); 799| 1.35k| pos = size - filename_size; 800| 1.35k| if (filename_size == 0u && pos > root_name_size && detail::is_directory_separator(p.m_pathname[pos - 1]) && !is_root_separator(p.m_pathname, root_dir_pos, pos - 1)) ------------------ | Branch (800:13): [True: 337, False: 1.01k] | Branch (800:36): [True: 337, False: 0] | Branch (800:60): [True: 337, False: 0] | Branch (800:117): [True: 337, False: 0] ------------------ 801| 337| return detail::dot_path(); 802| 1.35k| } 803| | 804| 2.38k| const value_type* ptr = p.m_pathname.c_str() + pos; 805| 2.38k| return path(ptr, ptr + filename_size); 806| 2.72k|} _ZN5boost10filesystem6detail15path_algorithms21find_filename_v4_sizeERKNS0_4pathE: 809| 823|{ 810| 823| const size_type size = p.m_pathname.size(); 811| 823| size_type root_name_size = 0; 812| 823| find_root_directory_start(p.m_pathname.c_str(), size, root_name_size); 813| 823| return find_filename_size(p.m_pathname, root_name_size, size); 814| 823|} _ZN5boost10filesystem6detail15path_algorithms7stem_v3ERKNS0_4pathE: 817| 545|{ 818| 545| path name(path_algorithms::filename_v3(p)); 819| 545| if (path_algorithms::compare_v4(name, detail::dot_path()) != 0 && path_algorithms::compare_v4(name, detail::dot_dot_path()) != 0) ------------------ | Branch (819:9): [True: 472, False: 73] | Branch (819:71): [True: 468, False: 4] ------------------ 820| 468| { 821| 468| size_type pos = name.m_pathname.rfind(path::dot); 822| 468| if (pos != string_type::npos) ------------------ | Branch (822:13): [True: 15, False: 453] ------------------ 823| 15| name.m_pathname.erase(name.m_pathname.begin() + pos, name.m_pathname.end()); 824| 468| } 825| 545| return name; 826| 545|} _ZN5boost10filesystem6detail15path_algorithms12extension_v3ERKNS0_4pathE: 841| 1.63k|{ 842| 1.63k| path name(path_algorithms::filename_v3(p)); 843| 1.63k| if (path_algorithms::compare_v4(name, detail::dot_path()) == 0 || path_algorithms::compare_v4(name, detail::dot_dot_path()) == 0) ------------------ | Branch (843:9): [True: 228, False: 1.40k] | Branch (843:71): [True: 3, False: 1.40k] ------------------ 844| 231| return path(); 845| 1.40k| size_type pos(name.m_pathname.rfind(path::dot)); 846| 1.40k| return pos == string_type::npos ? path() : path(name.m_pathname.c_str() + pos); ------------------ | Branch (846:12): [True: 1.29k, False: 108] ------------------ 847| 1.63k|} _ZN5boost10filesystem4path39remove_filename_and_trailing_separatorsEv: 882| 1.09k|{ 883| 1.09k| size_type end_pos = detail::path_algorithms::find_parent_path_size(*this); 884| 1.09k| m_pathname.erase(m_pathname.begin() + end_pos, m_pathname.end()); 885| 1.09k| return *this; 886| 1.09k|} _ZN5boost10filesystem4path16replace_filenameERKS1_: 896| 545|{ 897| 545| detail::path_algorithms::remove_filename_v4(*this); 898| 545| detail::path_algorithms::append_v4(*this, replacement.m_pathname.data(), replacement.m_pathname.data() + replacement.m_pathname.size()); 899| 545| return *this; 900| 545|} _ZNK5boost10filesystem4path18lexically_relativeERKS1_: 905| 545|{ 906| 545| path::iterator b = begin(), e = end(), base_b = base.begin(), base_e = base.end(); 907| 545| std::pair< path::iterator, path::iterator > mm = detail::mismatch(b, e, base_b, base_e); 908| 545| if (mm.first == b && mm.second == base_b) ------------------ | Branch (908:9): [True: 404, False: 141] | Branch (908:26): [True: 404, False: 0] ------------------ 909| 404| return path(); 910| 141| if (mm.first == e && mm.second == base_e) ------------------ | Branch (910:9): [True: 4, False: 137] | Branch (910:26): [True: 4, False: 0] ------------------ 911| 4| return detail::dot_path(); 912| | 913| 137| std::ptrdiff_t n = 0; 914| 239| for (; mm.second != base_e; detail::path_algorithms::increment_v4(mm.second)) ------------------ | Branch (914:12): [True: 102, False: 137] ------------------ 915| 102| { 916| 102| path const& p = *mm.second; 917| 102| if (detail::path_algorithms::compare_v4(p, detail::dot_dot_path()) == 0) ------------------ | Branch (917:13): [True: 6, False: 96] ------------------ 918| 6| --n; 919| 96| else if (!p.empty() && detail::path_algorithms::compare_v4(p, detail::dot_path()) != 0) ------------------ | Branch (919:18): [True: 58, False: 38] | Branch (919:32): [True: 40, False: 18] ------------------ 920| 40| ++n; 921| 102| } 922| 137| if (n < 0) ------------------ | Branch (922:9): [True: 6, False: 131] ------------------ 923| 6| return path(); 924| 131| if (n == 0 && (mm.first == e || mm.first->empty())) ------------------ | Branch (924:9): [True: 102, False: 29] | Branch (924:20): [True: 0, False: 102] | Branch (924:37): [True: 0, False: 102] ------------------ 925| 0| return detail::dot_path(); 926| | 927| 131| path tmp; 928| 171| for (; n > 0; --n) ------------------ | Branch (928:12): [True: 40, False: 131] ------------------ 929| 40| detail::path_algorithms::append_v4(tmp, detail::dot_dot_path()); 930| 759| for (; mm.first != e; detail::path_algorithms::increment_v4(mm.first)) ------------------ | Branch (930:12): [True: 628, False: 131] ------------------ 931| 628| detail::path_algorithms::append_v4(tmp, *mm.first); 932| 131| return tmp; 933| 131|} _ZN5boost10filesystem6detail15path_algorithms12increment_v4ERNS0_11path_detail13path_iteratorE: 1180| 2.10k|{ 1181| 2.10k| const size_type size = it.m_path_ptr->m_pathname.size(); 1182| 2.10k| BOOST_ASSERT_MSG(it.m_pos <= size, "path::iterator increment past end()"); ------------------ | | 67| 2.10k|# define BOOST_ASSERT_MSG(expr, msg) assert((expr)&&(msg)) ------------------ 1183| | 1184| 2.10k| if (it.m_element.m_pathname.empty() && (it.m_pos + 1) == size && detail::is_directory_separator(it.m_path_ptr->m_pathname[it.m_pos])) ------------------ | Branch (1184:9): [True: 88, False: 2.01k] | Branch (1184:44): [True: 88, False: 0] | Branch (1184:70): [True: 88, False: 0] ------------------ 1185| 88| { 1186| | // The iterator was pointing to the last empty element of the path; set to end. 1187| 88| it.m_pos = size; 1188| 88| return; 1189| 88| } 1190| | 1191| | // increment to position past current element; if current element is implicit dot, 1192| | // this will cause m_pos to represent the end iterator 1193| 2.01k| it.m_pos += it.m_element.m_pathname.size(); 1194| | 1195| | // if the end is reached, we are done 1196| 2.01k| if (it.m_pos >= size) ------------------ | Branch (1196:9): [True: 1.19k, False: 821] ------------------ 1197| 1.19k| { 1198| 1.19k| BOOST_ASSERT_MSG(it.m_pos == size, "path::iterator increment after the referenced path was modified"); ------------------ | | 67| 1.19k|# define BOOST_ASSERT_MSG(expr, msg) assert((expr)&&(msg)) ------------------ 1199| 1.19k| it.m_element.clear(); // aids debugging 1200| 1.19k| return; 1201| 1.19k| } 1202| | 1203| | // process separator (Windows drive spec is only case not a separator) 1204| 821| if (detail::is_directory_separator(it.m_path_ptr->m_pathname[it.m_pos])) ------------------ | Branch (1204:9): [True: 716, False: 105] ------------------ 1205| 716| { 1206| 716| size_type root_name_size = 0; 1207| 716| size_type root_dir_pos = find_root_directory_start(it.m_path_ptr->m_pathname.c_str(), size, root_name_size); 1208| | 1209| | // detect root directory and set iterator value to the separator if it is 1210| 716| if (it.m_pos == root_dir_pos && it.m_element.m_pathname.size() == root_name_size) ------------------ | Branch (1210:13): [True: 21, False: 695] | Branch (1210:41): [True: 21, False: 0] ------------------ 1211| 21| { 1212| 21| it.m_element.m_pathname = path::separator; // generic format; see docs 1213| 21| return; 1214| 21| } 1215| | 1216| | // skip separators until m_pos points to the start of the next element 1217| 1.66k| while (it.m_pos != size && detail::is_directory_separator(it.m_path_ptr->m_pathname[it.m_pos])) ------------------ | Branch (1217:16): [True: 1.55k, False: 101] | Branch (1217:36): [True: 965, False: 594] ------------------ 1218| 965| { 1219| 965| ++it.m_pos; 1220| 965| } 1221| | 1222| | // detect trailing separator 1223| 695| if (it.m_pos == size && ------------------ | Branch (1223:13): [True: 101, False: 594] ------------------ 1224| 695| !is_root_separator(it.m_path_ptr->m_pathname, root_dir_pos, it.m_pos - 1)) ------------------ | Branch (1224:13): [True: 88, False: 13] ------------------ 1225| 88| { 1226| 88| --it.m_pos; 1227| 88| it.m_element.m_pathname.clear(); 1228| 88| return; 1229| 88| } 1230| 695| } 1231| | 1232| | // get m_element 1233| 712| size_type end_pos = it.m_path_ptr->m_pathname.find_first_of(separators, it.m_pos); 1234| 712| if (end_pos == string_type::npos) ------------------ | Branch (1234:9): [True: 139, False: 573] ------------------ 1235| 139| end_pos = size; 1236| 712| const path::value_type* p = it.m_path_ptr->m_pathname.c_str(); 1237| 712| it.m_element.m_pathname.assign(p + it.m_pos, p + end_pos); 1238| 712|} _ZNK5boost10filesystem4path5beginEv: 1365| 10.2k|{ 1366| 10.2k| iterator itr; 1367| 10.2k| itr.m_path_ptr = this; 1368| | 1369| 10.2k| size_type element_size; 1370| 10.2k| first_element(m_pathname, itr.m_pos, element_size); 1371| | 1372| 10.2k| if (element_size > 0) ------------------ | Branch (1372:9): [True: 8.23k, False: 1.99k] ------------------ 1373| 8.23k| { 1374| 8.23k| itr.m_element = m_pathname.substr(itr.m_pos, element_size); 1375| |#ifdef BOOST_WINDOWS_API 1376| | if (itr.m_element.m_pathname.size() == 1u && itr.m_element.m_pathname[0] == path::preferred_separator) 1377| | itr.m_element.m_pathname[0] = path::separator; 1378| |#endif 1379| 8.23k| } 1380| | 1381| 10.2k| return itr; 1382| 10.2k|} _ZNK5boost10filesystem4path3endEv: 1385| 10.2k|{ 1386| 10.2k| iterator itr; 1387| 10.2k| itr.m_path_ptr = this; 1388| 10.2k| itr.m_pos = m_pathname.size(); 1389| 10.2k| return itr; 1390| 10.2k|} _ZN5boost10filesystem6detail8dot_pathEv: 1706| 2.57k|{ 1707| 2.57k| return get_dot_path(); 1708| 2.57k|} _ZN5boost10filesystem6detail12dot_dot_pathEv: 1711| 2.02k|{ 1712| 2.02k| return get_dot_dot_path(); 1713| 2.02k|} path.cpp:_ZN12_GLOBAL__N_114find_separatorEPKcm: 113| 1.44k|{ 114| 1.44k| const char* sep = static_cast< const char* >(std::memchr(p, '/', size)); 115| 1.44k| size_type pos = size; 116| 1.44k| if (BOOST_LIKELY(!!sep)) ------------------ | | 74| 1.44k|#define BOOST_LIKELY(x) __builtin_expect(x, 1) | | ------------------ | | | Branch (74:25): [True: 445, False: 1.00k] | | ------------------ ------------------ 117| 445| pos = sep - p; 118| 1.44k| return pos; 119| 1.44k|} _ZN5boost10filesystem6detail8mismatchENS0_11path_detail13path_iteratorES3_S3_S3_: 157| 545|{ 158| 722| for (; it1 != it1end && it2 != it2end && path_algorithms::compare_v4(*it1, *it2) == 0;) ------------------ | Branch (158:12): [True: 524, False: 198] | Branch (158:29): [True: 349, False: 175] | Branch (158:46): [True: 177, False: 172] ------------------ 159| 177| { 160| 177| path_algorithms::increment_v4(it1); 161| 177| path_algorithms::increment_v4(it2); 162| 177| } 163| 545| return std::make_pair(it1, it2); 164| 545|} path.cpp:_ZN12_GLOBAL__N_117is_root_separatorERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEmm: 950| 805|{ 951| 805| BOOST_ASSERT_MSG(pos < str.size() && fs::detail::is_directory_separator(str[pos]), "precondition violation"); ------------------ | | 67| 805|# define BOOST_ASSERT_MSG(expr, msg) assert((expr)&&(msg)) ------------------ 952| | 953| | // root_dir_pos points at the leftmost separator, we need to skip any duplicate separators right of root dir 954| 1.27k| while (pos > root_dir_pos && fs::detail::is_directory_separator(str[pos - 1])) ------------------ | Branch (954:12): [True: 861, False: 414] | Branch (954:34): [True: 470, False: 391] ------------------ 955| 470| --pos; 956| | 957| 805| return pos == root_dir_pos; 958| 805|} path.cpp:_ZN12_GLOBAL__N_118find_filename_sizeERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEmm: 964| 3.81k|{ 965| 3.81k| size_type pos = end_pos; 966| 9.01k| while (pos > root_name_size) ------------------ | Branch (966:12): [True: 7.15k, False: 1.86k] ------------------ 967| 7.15k| { 968| 7.15k| --pos; 969| | 970| 7.15k| if (fs::detail::is_directory_separator(str[pos])) ------------------ | Branch (970:13): [True: 1.95k, False: 5.20k] ------------------ 971| 1.95k| { 972| 1.95k| ++pos; // filename starts past the separator 973| 1.95k| break; 974| 1.95k| } 975| 7.15k| } 976| | 977| 3.81k| return end_pos - pos; 978| 3.81k|} path.cpp:_ZN12_GLOBAL__N_125find_root_directory_startEPKcmRm: 984| 17.0k|{ 985| 17.0k| root_name_size = 0; 986| 17.0k| if (size == 0) ------------------ | Branch (986:9): [True: 2.74k, False: 14.2k] ------------------ 987| 2.74k| return 0; 988| | 989| 14.2k| bool parsing_root_name = false; 990| 14.2k| size_type pos = 0; 991| | 992| | // case "//", possibly followed by more characters 993| 14.2k| if (fs::detail::is_directory_separator(path[0])) ------------------ | Branch (993:9): [True: 4.02k, False: 10.2k] ------------------ 994| 4.02k| { 995| 4.02k| if (size >= 2 && fs::detail::is_directory_separator(path[1])) ------------------ | Branch (995:13): [True: 3.18k, False: 836] | Branch (995:26): [True: 1.87k, False: 1.30k] ------------------ 996| 1.87k| { 997| 1.87k| if (size == 2) ------------------ | Branch (997:17): [True: 138, False: 1.74k] ------------------ 998| 138| { 999| | // The whole path is just a pair of separators 1000| 138| root_name_size = 2; 1001| 138| return 2; 1002| 138| } 1003| |#ifdef BOOST_WINDOWS_API 1004| | // https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file 1005| | // cases "\\?\" and "\\.\" 1006| | else if (size >= 4 && (path[2] == questionmark || path[2] == fs::path::dot) && fs::detail::is_directory_separator(path[3])) 1007| | { 1008| | parsing_root_name = true; 1009| | pos += 4; 1010| | } 1011| |#endif 1012| 1.74k| else if (fs::detail::is_directory_separator(path[2])) ------------------ | Branch (1012:22): [True: 291, False: 1.44k] ------------------ 1013| 291| { 1014| | // The path starts with three directory separators, which is interpreted as a root directory followed by redundant separators 1015| 291| return 0; 1016| 291| } 1017| 1.44k| else 1018| 1.44k| { 1019| | // case "//net {/}" 1020| 1.44k| parsing_root_name = true; 1021| 1.44k| pos += 2; 1022| 1.44k| goto find_next_separator; 1023| 1.44k| } 1024| 1.87k| } 1025| |#ifdef BOOST_WINDOWS_API 1026| | // https://stackoverflow.com/questions/23041983/path-prefixes-and 1027| | // case "\??\" (NT path prefix) 1028| | else if (size >= 4 && path[1] == questionmark && path[2] == questionmark && fs::detail::is_directory_separator(path[3])) 1029| | { 1030| | parsing_root_name = true; 1031| | pos += 4; 1032| | } 1033| |#endif 1034| 2.14k| else 1035| 2.14k| { 1036| | // The path starts with a separator, possibly followed by a non-separator character 1037| 2.14k| return 0; 1038| 2.14k| } 1039| 4.02k| } 1040| | 1041| |#ifdef BOOST_WINDOWS_API 1042| | // case "c:" or "prn:" 1043| | // Note: There is ambiguity in a "c:x" path interpretation. It could either mean a file "x" located at the current directory for drive C:, 1044| | // or an alternative stream "x" of a file "c". Windows API resolve this as the former, and so do we. 1045| | if ((size - pos) >= 2 && fs::detail::is_letter(path[pos])) 1046| | { 1047| | size_type i = pos + 1; 1048| | for (; i < size; ++i) 1049| | { 1050| | if (!is_device_name_char(path[i])) 1051| | break; 1052| | } 1053| | 1054| | if (i < size && path[i] == colon) 1055| | { 1056| | pos = i + 1; 1057| | root_name_size = pos; 1058| | parsing_root_name = false; 1059| | 1060| | if (pos < size && fs::detail::is_directory_separator(path[pos])) 1061| | return pos; 1062| | } 1063| | } 1064| |#endif 1065| | 1066| 10.2k| if (!parsing_root_name) ------------------ | Branch (1066:9): [True: 10.2k, False: 0] ------------------ 1067| 10.2k| return size; 1068| | 1069| 1.44k|find_next_separator: 1070| 1.44k| pos += find_separator(path + pos, size - pos); 1071| 1.44k| if (parsing_root_name) ------------------ | Branch (1071:9): [True: 1.44k, False: 0] ------------------ 1072| 1.44k| root_name_size = pos; 1073| | 1074| 1.44k| return pos; 1075| 10.2k|} path.cpp:_ZN12_GLOBAL__N_113first_elementERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERmS9_: 138| 10.2k|{ 139| 10.2k| first_element(src, element_pos, element_size, src.size()); 140| 10.2k|} path.cpp:_ZN12_GLOBAL__N_113first_elementERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERmS9_m: 1088| 10.2k|{ 1089| 10.2k| element_pos = 0; 1090| 10.2k| element_size = 0; 1091| 10.2k| if (src.empty()) ------------------ | Branch (1091:9): [True: 1.99k, False: 8.23k] ------------------ 1092| 1.99k| return; 1093| | 1094| 8.23k| size_type root_name_size = 0; 1095| 8.23k| size_type root_dir_pos = find_root_directory_start(src.c_str(), size, root_name_size); 1096| | 1097| | // First element is the root name, if there is one 1098| 8.23k| if (root_name_size > 0) ------------------ | Branch (1098:9): [True: 637, False: 7.59k] ------------------ 1099| 637| { 1100| 637| element_size = root_name_size; 1101| 637| return; 1102| 637| } 1103| | 1104| | // Otherwise, the root directory 1105| 7.59k| if (root_dir_pos < size) ------------------ | Branch (1105:9): [True: 722, False: 6.87k] ------------------ 1106| 722| { 1107| 722| element_pos = root_dir_pos; 1108| 722| element_size = 1u; 1109| 722| return; 1110| 722| } 1111| | 1112| | // Otherwise, the first filename or directory name in a relative path 1113| 6.87k| size_type end_pos = src.find_first_of(separators); 1114| 6.87k| if (end_pos == string_type::npos) ------------------ | Branch (1114:9): [True: 6.69k, False: 177] ------------------ 1115| 6.69k| end_pos = src.size(); 1116| 6.87k| element_size = end_pos; 1117| 6.87k|} path.cpp:_ZN12_GLOBAL__N_112get_dot_pathEv: 1637| 2.57k|{ 1638| 2.57k| return g_dot_path; 1639| 2.57k|} path.cpp:_ZN12_GLOBAL__N_116get_dot_dot_pathEv: 1642| 2.02k|{ 1643| 2.02k| return g_dot_dot_path; 1644| 2.02k|} LLVMFuzzerTestOneInput: 19| 545|{ 20| 545| FuzzedDataProvider fdp(data, size); 21| 545| try { 22| 545| boost::filesystem::path p(fdp.ConsumeRandomLengthString(5)); 23| | 24| 545| p.replace_filename(fdp.ConsumeRandomLengthString(5)); 25| | 26| 545| p.has_extension(); 27| 545| p.extension(); 28| 545| p.replace_extension(fdp.ConsumeRandomLengthString(3)); 29| | 30| 545| boost::filesystem::path p1(fdp.ConsumeRandomLengthString(5)); 31| 545| p.concat(p1); 32| 545| p.append(p1); 33| 545| p.remove_filename_and_trailing_separators(); 34| 545| p /= (p1); 35| 545| p += (p1); 36| | 37| 545| p.lexically_relative(p1); 38| 545| p.filename_is_dot(); 39| 545| p.remove_filename(); 40| | 41| 545| p.swap(p1); 42| 545| p.root_directory(); 43| 545| p.relative_path(); 44| 545| p.parent_path(); 45| 545| p.has_stem(); 46| 545| } catch(...) { 47| 0| } 48| 545| return 0; 49| 545|}