_ZN4args14ArgumentParserC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 3412| 6.71k| { 3413| 6.71k| Description(description_); 3414| 6.71k| Epilog(epilog_); 3415| 6.71k| LongPrefix("--"); 3416| 6.71k| ShortPrefix("-"); 3417| 6.71k| LongSeparator("="); 3418| 6.71k| Terminator("--"); 3419| 6.71k| SetArgumentSeparations(true, true, true, true); 3420| 6.71k| matched = true; 3421| 6.71k| } _ZN4args7CommandC2Ev: 2231| 6.71k| Command() = default; _ZN4args5Group10Validators8DontCareERKS0_: 1700| 2.60k| { 1701| 2.60k| return true; 1702| 2.60k| } _ZN4args5GroupC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS1_8functionIFbRKS0_EEENS_7OptionsE: 1715| 6.71k| Group(const std::string &help_ = std::string(), const std::function &validator_ = Validators::DontCare, Options options_ = {}) : Base(help_, options_), validator(validator_) 1716| 6.71k| { 1717| 6.71k| parent = nullptr; 1718| 6.71k| } _ZN4args4BaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_7OptionsE: 1024| 87.2k| Base(const std::string &help_, Options options_ = {}) : options(options_), help(help_) {} _ZNK4args4Base7MatchedEv: 1038| 150k| { 1039| 150k| return matched; 1040| 150k| } _ZN4args4Base11GetCommandsEv: 1060| 73.8k| { 1061| 73.8k| return {}; 1062| 73.8k| } _ZNK4args4Base7IsGroupEv: 1065| 41.7k| { 1066| 41.7k| return false; 1067| 41.7k| } _ZN4args4Base5MatchERKNS_10EitherFlagE: 1075| 2.16k| { 1076| 2.16k| return nullptr; 1077| 2.16k| } _ZN4args4Base17GetNextPositionalEv: 1080| 55.7k| { 1081| 55.7k| return nullptr; 1082| 55.7k| } _ZNK4args4Base13HasPositionalEv: 1095| 181k| { 1096| 181k| return false; 1097| 181k| } _ZNK4args4Base10HasCommandEv: 1100| 120k| { 1101| 120k| return false; 1102| 120k| } _ZN4args4Base5ResetEv: 1129| 73.8k| { 1130| 73.8k| matched = false; 1131| |#ifdef ARGS_NOEXCEPT 1132| | error = Error::None; 1133| | errorMsg.clear(); 1134| |#endif 1135| 73.8k| } _ZN4args4BaseD2Ev: 1025| 87.2k| virtual ~Base() {} _ZNK4args5Group7MatchedEv: 1888| 4.95k| { 1889| 4.95k| return validator(*this); 1890| 4.95k| } _ZNK4args5Group8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 1791| 3.53k| { 1792| 3.53k| for (Base *child: Children()) ------------------ | Branch (1792:33): [True: 7.07k, False: 3.53k] ------------------ 1793| 7.07k| { 1794| 7.07k| child->Validate(shortPrefix, longPrefix); 1795| 7.07k| } 1796| 3.53k| } _ZNK4args5Group8ChildrenEv: 1758| 461k| { 1759| 461k| return children; 1760| 461k| } _ZNK4args5Group14GetDescriptionERKNS_10HelpParamsEj: 1902| 26.8k| { 1903| 26.8k| std::vector> descriptions; 1904| | 1905| | // Push that group description on the back if not empty 1906| 26.8k| unsigned addindent = 0; 1907| 26.8k| if (!help.empty()) ------------------ | Branch (1907:21): [True: 1.80k, False: 25.0k] ------------------ 1908| 1.80k| { 1909| 1.80k| descriptions.emplace_back(help, "", indent); 1910| 1.80k| addindent = 1; 1911| 1.80k| } 1912| | 1913| 26.8k| for (Base *child: Children()) ------------------ | Branch (1913:33): [True: 53.6k, False: 26.8k] ------------------ 1914| 53.6k| { 1915| 53.6k| if ((child->GetOptions() & Options::HiddenFromDescription) != Options::None) ------------------ | Branch (1915:25): [True: 0, False: 53.6k] ------------------ 1916| 0| { 1917| 0| continue; 1918| 0| } 1919| | 1920| 53.6k| auto groupDescriptions = child->GetDescription(params, indent + addindent); 1921| 53.6k| descriptions.insert( 1922| 53.6k| std::end(descriptions), 1923| 53.6k| std::make_move_iterator(std::begin(groupDescriptions)), 1924| 53.6k| std::make_move_iterator(std::end(groupDescriptions))); 1925| 53.6k| } 1926| 26.8k| return descriptions; 1927| 26.8k| } _ZN4argsanENS_7OptionsES0_: 809| 833k| { 810| 833k| return static_cast(static_cast(lhs) & static_cast(rhs)); 811| 833k| } _ZNK4args4Base10GetOptionsEv: 1028| 823k| { 1029| 823k| return options; 1030| 823k| } _ZN4args5Group11GetCommandsEv: 1951| 13.4k| { 1952| 13.4k| std::vector res; 1953| 13.4k| for (const auto &child : Children()) ------------------ | Branch (1953:40): [True: 80.5k, False: 13.4k] ------------------ 1954| 80.5k| { 1955| 80.5k| auto subparsers = child->GetCommands(); 1956| 80.5k| res.insert(std::end(res), std::begin(subparsers), std::end(subparsers)); 1957| 80.5k| } 1958| 13.4k| return res; 1959| 13.4k| } _ZNK4args5Group7IsGroupEv: 1962| 18.3k| { 1963| 18.3k| return true; 1964| 18.3k| } _ZN4args5Group5MatchERKNS_10EitherFlagE: 1768| 7.97k| { 1769| 7.97k| for (Base *child: Children()) ------------------ | Branch (1769:33): [True: 37.2k, False: 2.16k] ------------------ 1770| 37.2k| { 1771| 37.2k| if (FlagBase *match = child->Match(flag)) ------------------ | Branch (1771:35): [True: 5.80k, False: 31.4k] ------------------ 1772| 5.80k| { 1773| 5.80k| return match; 1774| 5.80k| } 1775| 37.2k| } 1776| 2.16k| return nullptr; 1777| 7.97k| } _ZN4args5Group17GetNextPositionalEv: 1803| 12.3k| { 1804| 12.3k| for (Base *child: Children()) ------------------ | Branch (1804:33): [True: 72.7k, False: 6.19k] ------------------ 1805| 72.7k| { 1806| 72.7k| if (auto next = child->GetNextPositional()) ------------------ | Branch (1806:30): [True: 6.19k, False: 66.5k] ------------------ 1807| 6.19k| { 1808| 6.19k| return next; 1809| 6.19k| } 1810| 72.7k| } 1811| 6.19k| return nullptr; 1812| 12.3k| } _ZNK4args5Group7HasFlagEv: 1819| 46.9k| { 1820| 46.9k| return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasFlag(); }); 1821| 46.9k| } _ZZNK4args5Group7HasFlagEvENKUlPNS_4BaseEE_clES2_: 1820| 46.9k| return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasFlag(); }); _ZNK4args5Group13HasPositionalEv: 1828| 40.2k| { 1829| 40.2k| return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasPositional(); }); 1830| 40.2k| } _ZZNK4args5Group13HasPositionalEvENKUlPNS_4BaseEE_clES2_: 1829| 221k| return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasPositional(); }); _ZNK4args5Group10HasCommandEv: 1837| 21.8k| { 1838| 21.8k| return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); }); 1839| 21.8k| } _ZZNK4args5Group10HasCommandEvENKUlPNS_4BaseEE_clES2_: 1838| 131k| return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); }); _ZNK4args5Group14GetProgramLineERKNS_10HelpParamsE: 1932| 53.6k| { 1933| 53.6k| std::vector names; 1934| 53.6k| for (Base *child: Children()) ------------------ | Branch (1934:33): [True: 322k, False: 53.6k] ------------------ 1935| 322k| { 1936| 322k| if ((child->GetOptions() & Options::HiddenFromUsage) != Options::None) ------------------ | Branch (1936:25): [True: 18.9k, False: 303k] ------------------ 1937| 18.9k| { 1938| 18.9k| continue; 1939| 18.9k| } 1940| | 1941| 303k| auto groupNames = child->GetProgramLine(params); 1942| 303k| names.insert( 1943| 303k| std::end(names), 1944| 303k| std::make_move_iterator(std::begin(groupNames)), 1945| 303k| std::make_move_iterator(std::end(groupNames))); 1946| 303k| } 1947| 53.6k| return names; 1948| 53.6k| } _ZN4args5Group5ResetEv: 1967| 13.4k| { 1968| 13.4k| Base::Reset(); 1969| | 1970| 13.4k| for (auto &child: Children()) ------------------ | Branch (1970:33): [True: 80.5k, False: 13.4k] ------------------ 1971| 80.5k| { 1972| 80.5k| child->Reset(); 1973| 80.5k| } 1974| |#ifdef ARGS_NOEXCEPT 1975| | error = Error::None; 1976| | errorMsg.clear(); 1977| |#endif 1978| 13.4k| } _ZN4args7Command5ResetEv: 2683| 6.71k| { 2684| 6.71k| Group::Reset(); 2685| 6.71k| selectedCommand = nullptr; 2686| 6.71k| subparserProgramLine.clear(); 2687| 6.71k| subparserDescription.clear(); 2688| 6.71k| subparserHasFlag = false; 2689| 6.71k| subparserHasPositional = false; 2690| 6.71k| subparserHasCommand = false; 2691| |#ifdef ARGS_NOEXCEPT 2692| | subparserError = Error::None; 2693| |#endif 2694| 6.71k| } _ZN4args7Command11DescriptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 2304| 6.71k| { this->description = description_; } _ZN4args7Command6EpilogERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 2314| 6.71k| { this->epilog = epilog_; } _ZN4args14ArgumentParser22SetArgumentSeparationsEbbbb: 3526| 6.71k| { 3527| 6.71k| this->allowJoinedShortValue = allowJoinedShortValue_; 3528| 6.71k| this->allowJoinedLongValue = allowJoinedLongValue_; 3529| 6.71k| this->allowSeparateShortValue = allowSeparateShortValue_; 3530| 6.71k| this->allowSeparateLongValue = allowSeparateLongValue_; 3531| | 3532| 6.71k| this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " "; ------------------ | Branch (3532:50): [True: 6.71k, False: 0] ------------------ 3533| 6.71k| this->helpParams.shortSeparator = allowJoinedShortValue ? "" : " "; ------------------ | Branch (3533:51): [True: 6.71k, False: 0] ------------------ 3534| 6.71k| } _ZN4args5GroupD2Ev: 1725| 13.4k| virtual ~Group() {} _ZNK4args7Command7MatchedEv: 2337| 94.9k| { return Base::Matched(); } _ZNK4args7Command8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 2632| 4.95k| { 2633| 4.95k| if (!Matched()) ------------------ | Branch (2633:21): [True: 0, False: 4.95k] ------------------ 2634| 0| { 2635| 0| return; 2636| 0| } 2637| | 2638| 4.95k| auto onValidationError = [&] 2639| 4.95k| { 2640| 4.95k| std::ostringstream problem; 2641| 4.95k| problem << "Group validation failed somewhere!"; 2642| |#ifdef ARGS_NOEXCEPT 2643| | error = Error::Validation; 2644| | errorMsg = problem.str(); 2645| |#else 2646| 4.95k| throw ValidationError(problem.str()); 2647| 4.95k|#endif 2648| 4.95k| }; 2649| | 2650| 4.95k| for (Base *child: Children()) ------------------ | Branch (2650:33): [True: 46.6k, False: 4.95k] ------------------ 2651| 46.6k| { 2652| 46.6k| if (child->IsGroup() && !child->Matched()) ------------------ | Branch (2652:25): [True: 4.95k, False: 41.7k] | Branch (2652:45): [True: 1.41k, False: 3.53k] ------------------ 2653| 1.41k| { 2654| 1.41k| onValidationError(); 2655| 1.41k| } 2656| | 2657| 46.6k| child->Validate(shortprefix, longprefix); 2658| 46.6k| } 2659| | 2660| 4.95k| if (subparser != nullptr) ------------------ | Branch (2660:21): [True: 0, False: 4.95k] ------------------ 2661| 0| { 2662| 0| subparser->Validate(shortprefix, longprefix); 2663| 0| if (!subparser->Matched()) ------------------ | Branch (2663:25): [True: 0, False: 0] ------------------ 2664| 0| { 2665| 0| onValidationError(); 2666| 0| } 2667| 0| } 2668| | 2669| 4.95k| if (selectedCommand == nullptr && commandIsRequired && (Group::HasCommand() || subparserHasCommand)) ------------------ | Branch (2669:21): [True: 3.53k, False: 1.41k] | Branch (2669:51): [True: 3.53k, False: 0] | Branch (2669:73): [True: 0, False: 3.53k] | Branch (2669:96): [True: 0, False: 3.53k] ------------------ 2670| 0| { 2671| 0| std::ostringstream problem; 2672| 0| problem << "Command is required"; 2673| |#ifdef ARGS_NOEXCEPT 2674| | error = Error::Validation; 2675| | errorMsg = problem.str(); 2676| |#else 2677| 0| throw ValidationError(problem.str()); 2678| 0|#endif 2679| 0| } 2680| 4.95k| } _ZZNK4args7Command8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_ENKUlvE_clEv: 2639| 1.41k| { 2640| 1.41k| std::ostringstream problem; 2641| 1.41k| problem << "Group validation failed somewhere!"; 2642| |#ifdef ARGS_NOEXCEPT 2643| | error = Error::Validation; 2644| | errorMsg = problem.str(); 2645| |#else 2646| 1.41k| throw ValidationError(problem.str()); 2647| 1.41k|#endif 2648| 1.41k| }; _ZN4args15ValidationErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 507| 1.41k| ValidationError(const std::string &problem) : Error(problem) {} _ZN4args5ErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 480| 3.17k| Error(const std::string &problem) : std::runtime_error(problem) {} _ZN4args7Command11GetCommandsEv: 2535| 6.71k| { 2536| 6.71k| if (selectedCommand != nullptr) ------------------ | Branch (2536:21): [True: 0, False: 6.71k] ------------------ 2537| 0| { 2538| 0| return selectedCommand->GetCommands(); 2539| 0| } 2540| | 2541| 6.71k| if (Matched()) ------------------ | Branch (2541:21): [True: 6.71k, False: 0] ------------------ 2542| 6.71k| { 2543| 6.71k| return Group::GetCommands(); 2544| 6.71k| } 2545| | 2546| 0| return { this }; 2547| 6.71k| } _ZNK4args4Base6IsFlagEv: 1070| 20.1k| { 1071| 20.1k| return false; 1072| 20.1k| } _ZN4args7Command5MatchERKNS_10EitherFlagE: 2356| 5.69k| { 2357| 5.69k| if (selectedCommand != nullptr) ------------------ | Branch (2357:21): [True: 0, False: 5.69k] ------------------ 2358| 0| { 2359| 0| if (auto *res = selectedCommand->Match(flag)) ------------------ | Branch (2359:31): [True: 0, False: 0] ------------------ 2360| 0| { 2361| 0| return res; 2362| 0| } 2363| | 2364| 0| for (auto *child: Children()) ------------------ | Branch (2364:37): [True: 0, False: 0] ------------------ 2365| 0| { 2366| 0| if ((child->GetOptions() & Options::Global) != Options::None) ------------------ | Branch (2366:29): [True: 0, False: 0] ------------------ 2367| 0| { 2368| 0| if (auto *res = child->Match(flag)) ------------------ | Branch (2368:39): [True: 0, False: 0] ------------------ 2369| 0| { 2370| 0| return res; 2371| 0| } 2372| 0| } 2373| 0| } 2374| | 2375| 0| return nullptr; 2376| 0| } 2377| | 2378| 5.69k| if (subparser != nullptr) ------------------ | Branch (2378:21): [True: 0, False: 5.69k] ------------------ 2379| 0| { 2380| 0| return subparser->Match(flag); 2381| 0| } 2382| | 2383| 5.69k| return Matched() ? Group::Match(flag) : nullptr; ------------------ | Branch (2383:24): [True: 5.69k, False: 0] ------------------ 2384| 5.69k| } _ZN4args7Command17GetNextPositionalEv: 2420| 6.19k| { 2421| 6.19k| if (selectedCommand != nullptr) ------------------ | Branch (2421:21): [True: 0, False: 6.19k] ------------------ 2422| 0| { 2423| 0| if (auto *res = selectedCommand->GetNextPositional()) ------------------ | Branch (2423:31): [True: 0, False: 0] ------------------ 2424| 0| { 2425| 0| return res; 2426| 0| } 2427| | 2428| 0| for (auto *child: Children()) ------------------ | Branch (2428:37): [True: 0, False: 0] ------------------ 2429| 0| { 2430| 0| if ((child->GetOptions() & Options::Global) != Options::None) ------------------ | Branch (2430:29): [True: 0, False: 0] ------------------ 2431| 0| { 2432| 0| if (auto *res = child->GetNextPositional()) ------------------ | Branch (2432:39): [True: 0, False: 0] ------------------ 2433| 0| { 2434| 0| return res; 2435| 0| } 2436| 0| } 2437| 0| } 2438| | 2439| 0| return nullptr; 2440| 0| } 2441| | 2442| 6.19k| if (subparser != nullptr) ------------------ | Branch (2442:21): [True: 0, False: 6.19k] ------------------ 2443| 0| { 2444| 0| return subparser->GetNextPositional(); 2445| 0| } 2446| | 2447| 6.19k| return Matched() ? Group::GetNextPositional() : nullptr; ------------------ | Branch (2447:24): [True: 6.19k, False: 0] ------------------ 2448| 6.19k| } _ZNK4args7Command7HasFlagEv: 2451| 20.1k| { 2452| 20.1k| return subparserHasFlag || Group::HasFlag(); ------------------ | Branch (2452:24): [True: 0, False: 20.1k] | Branch (2452:44): [True: 20.1k, False: 0] ------------------ 2453| 20.1k| } _ZNK4args7Command13HasPositionalEv: 2456| 20.1k| { 2457| 20.1k| return subparserHasPositional || Group::HasPositional(); ------------------ | Branch (2457:24): [True: 0, False: 20.1k] | Branch (2457:50): [True: 20.1k, False: 0] ------------------ 2458| 20.1k| } _ZN4args14ArgumentParser5ResetEv: 3664| 6.71k| { 3665| 6.71k| Command::Reset(); 3666| 6.71k| matched = true; 3667| 6.71k| readCompletion = false; 3668| 6.71k| } _ZN4args14ArgumentParser10LongPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 3448| 13.4k| { 3449| 13.4k| this->longprefix = longprefix_; 3450| 13.4k| this->helpParams.longPrefix = longprefix_; 3451| 13.4k| } _ZN4args14ArgumentParser11ShortPrefixERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 3460| 13.4k| { 3461| 13.4k| this->shortprefix = shortprefix_; 3462| 13.4k| this->helpParams.shortPrefix = shortprefix_; 3463| 13.4k| } _ZN4args14ArgumentParser13LongSeparatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 3472| 13.4k| { 3473| 13.4k| if (longseparator_.empty()) ------------------ | Branch (3473:21): [True: 0, False: 13.4k] ------------------ 3474| 0| { 3475| 0| const std::string errorMessage("longseparator can not be set to empty"); 3476| |#ifdef ARGS_NOEXCEPT 3477| | error = Error::Usage; 3478| | errorMsg = errorMessage; 3479| |#else 3480| 0| throw UsageError(errorMessage); 3481| 0|#endif 3482| 0| } else 3483| 13.4k| { 3484| 13.4k| this->longseparator = longseparator_; 3485| 13.4k| this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " "; ------------------ | Branch (3485:54): [True: 13.4k, False: 0] ------------------ 3486| 13.4k| } 3487| 13.4k| } _ZN4args14ArgumentParser10TerminatorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 3496| 13.4k| { this->terminator = terminator_; } _ZN4args10EitherFlagC2Ec: 575| 565k| EitherFlag(const char flag) : isShort(true), shortFlag(flag), longFlag() {} _ZN4args10EitherFlagC2EPKc: 574| 53.6k| EitherFlag(const char *flag) : isShort(false), shortFlag(), longFlag(flag) {} _ZN4args7MatcherC2ESt16initializer_listINS_10EitherFlagEE: 680| 60.3k| Matcher(EitherFlag::GetShort(in), EitherFlag::GetLong(in)) {} _ZN4args10EitherFlag8GetShortESt16initializer_listIS0_E: 595| 60.3k| { 596| 60.3k| std::unordered_set shortFlags; 597| 60.3k| for (const EitherFlag &flag: flags) ------------------ | Branch (597:40): [True: 107k, False: 60.3k] ------------------ 598| 107k| { 599| 107k| if (flag.isShort) ------------------ | Branch (599:21): [True: 53.6k, False: 53.6k] ------------------ 600| 53.6k| { 601| 53.6k| shortFlags.insert(flag.shortFlag); 602| 53.6k| } 603| 107k| } 604| 60.3k| return shortFlags; 605| 60.3k| } _ZN4args10EitherFlag7GetLongESt16initializer_listIS0_E: 580| 60.3k| { 581| 60.3k| std::unordered_set longFlags; 582| 60.3k| for (const EitherFlag &flag: flags) ------------------ | Branch (582:40): [True: 107k, False: 60.3k] ------------------ 583| 107k| { 584| 107k| if (!flag.isShort) ------------------ | Branch (584:21): [True: 53.6k, False: 53.6k] ------------------ 585| 53.6k| { 586| 53.6k| longFlags.insert(flag.longFlag); 587| 53.6k| } 588| 107k| } 589| 60.3k| return longFlags; 590| 60.3k| } _ZN4args7MatcherC2INSt3__113unordered_setIcNS2_4hashIcEENS2_8equal_toIcEENS2_9allocatorIcEEEENS3_INS2_12basic_stringIcNS2_11char_traitsIcEES9_EENS4_ISE_EENS6_ISE_EENS8_ISE_EEEEEEOT_OT0_: 664| 60.3k| Matcher(std::begin(shortIn), std::end(shortIn), std::begin(longIn), std::end(longIn)) 665| 60.3k| {} _ZN4args7MatcherC2INSt3__121__hash_const_iteratorIPNS2_11__hash_nodeIcPvEEEENS3_IPNS4_INS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES5_EEEEEET_SI_T0_SJ_: 639| 60.3k| shortFlags(shortFlagsStart, shortFlagsEnd), 640| 60.3k| longFlags(longFlagsStart, longFlagsEnd) 641| 60.3k| { 642| 60.3k| if (shortFlags.empty() && longFlags.empty()) ------------------ | Branch (642:21): [True: 6.71k, False: 53.6k] | Branch (642:43): [True: 0, False: 6.71k] ------------------ 643| 0| { 644| 0|#ifndef ARGS_NOEXCEPT 645| 0| throw UsageError("empty Matcher"); 646| 0|#endif 647| 0| } 648| 60.3k| } _ZN4args8HelpFlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherENS_7OptionsE: 3816| 6.71k| HelpFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_ = {}): Flag(group_, name_, help_, std::move(matcher_), options_) {} _ZN4args4FlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherENS_7OptionsE: 3781| 26.8k| Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): FlagBase(name_, help_, std::move(matcher_), options_) 3782| 26.8k| { 3783| 26.8k| group_.Add(*this); 3784| 26.8k| } _ZN4args8FlagBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_ONS_7MatcherENS_7OptionsE: 1352| 60.3k| FlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : NamedBase(name_, help_, options_), matcher(std::move(matcher_)) {} _ZN4args9NamedBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_NS_7OptionsE: 1185| 73.8k| NamedBase(const std::string &name_, const std::string &help_, Options options_ = {}) : Base(help_, options_), name(name_) {} _ZN4args9NamedBaseD2Ev: 1186| 73.8k| virtual ~NamedBase() {} _ZNK4args9NamedBase13GetNameStringERKNS_10HelpParamsE: 1168| 53.6k| virtual std::string GetNameString(const HelpParams&) const { return Name(); } _ZN4args7MatcherC2EOS0_: 682| 60.3k| Matcher(Matcher &&other) noexcept : shortFlags(std::move(other.shortFlags)), longFlags(std::move(other.longFlags)) 683| 60.3k| {} _ZN4args5Group3AddERNS_4BaseE: 1730| 80.5k| { 1731| 80.5k| children.emplace_back(&child); 1732| | 1733| 80.5k| if(child.IsFlag()) { ------------------ | Branch (1733:20): [True: 60.3k, False: 20.1k] ------------------ 1734| 60.3k|#ifndef ARGS_NOEXCEPT 1735| | // Detection runs from the child's own constructor, so a 1736| | // duplicate throws before that constructor completes and the 1737| | // child's storage is released while the stack unwinds. Undo 1738| | // the registration first, or a caller that catches the error 1739| | // leaves this group holding a pointer to a dead object. 1740| 60.3k| try 1741| 60.3k| { 1742| 60.3k| SignalDetectDuplicates(); 1743| 60.3k| } 1744| 60.3k| catch (...) 1745| 60.3k| { 1746| 0| children.pop_back(); 1747| 0| throw; 1748| 0| } 1749| |#else 1750| | SignalDetectDuplicates(); 1751| |#endif 1752| 60.3k| } 1753| 80.5k| } _ZN4args5Group22SignalDetectDuplicatesEv: 1984| 73.8k| { 1985| 73.8k| if(parent != nullptr) parent->SignalDetectDuplicates(); ------------------ | Branch (1985:20): [True: 13.4k, False: 60.3k] ------------------ 1986| 60.3k| else DetectDuplicateFlags(); 1987| 73.8k| } _ZN4args5Group20DetectDuplicateFlagsEv: 1994| 60.3k| { 1995| 60.3k| std::unordered_set usedShortFlags; 1996| 60.3k| std::unordered_set usedLongFlags; 1997| 60.3k| DetectDuplicateFlags(usedShortFlags, usedLongFlags); 1998| 60.3k| } _ZN4args5Group20DetectDuplicateFlagsERNSt3__113unordered_setIcNS1_4hashIcEENS1_8equal_toIcEENS1_9allocatorIcEEEERNS2_INS1_12basic_stringIcNS1_11char_traitsIcEES8_EENS3_ISE_EENS5_ISE_EENS7_ISE_EEEE: 2003| 73.8k| { 2004| 73.8k| for (Base *child: Children()) ------------------ | Branch (2004:33): [True: 315k, False: 73.8k] ------------------ 2005| 315k| { 2006| 315k| if(auto flag = dynamic_cast(child)) ------------------ | Branch (2006:29): [True: 301k, False: 13.4k] ------------------ 2007| 301k| { 2008| | // Check for duplicate flags, setting a usage error on the 2009| | // flag if a duplicate is detected. 2010| 301k| for(EitherFlag flagString: flag->GetMatcher().GetFlagStrings()) ------------------ | Branch (2010:50): [True: 563k, False: 301k] ------------------ 2011| 563k| { 2012| 563k| if(flagString.isShort) ------------------ | Branch (2012:32): [True: 268k, False: 295k] ------------------ 2013| 268k| { 2014| 268k| if(usedShortFlags.count(flagString.shortFlag)) ------------------ | Branch (2014:36): [True: 0, False: 268k] ------------------ 2015| 0| { 2016| |#ifdef ARGS_NOEXCEPT 2017| | flag->SetUsageError(); 2018| |#else 2019| 0| throw ParseError("duplicate short flag detected"); 2020| 0|#endif 2021| 0| } 2022| 268k| else 2023| 268k| { 2024| 268k| usedShortFlags.insert(flagString.shortFlag); 2025| 268k| } 2026| 268k| } 2027| 295k| else 2028| 295k| { 2029| 295k| if(usedLongFlags.count(flagString.longFlag)) ------------------ | Branch (2029:36): [True: 0, False: 295k] ------------------ 2030| 0| { 2031| |#ifdef ARGS_NOEXCEPT 2032| | flag->SetUsageError(); 2033| |#else 2034| 0| throw ParseError("duplicate long flag detected"); 2035| 0|#endif 2036| 0| } 2037| 295k| else 2038| 295k| { 2039| 295k| usedLongFlags.insert(flagString.longFlag); 2040| 295k| } 2041| 295k| } 2042| 563k| } 2043| 301k| } 2044| 13.4k| else if(auto group = dynamic_cast(child)) ------------------ | Branch (2044:34): [True: 13.4k, False: 0] ------------------ 2045| 13.4k| { 2046| | // A command opens its own flag namespace and runs its 2047| | // own duplicate detection as a separate root, so a flag 2048| | // reused either side of a command boundary is not a 2049| | // genuine duplicate. Only descend into plain groups 2050| | // here; IsGroup() is false for a Command. 2051| 13.4k| if(group->IsGroup()) ------------------ | Branch (2051:28): [True: 13.4k, False: 0] ------------------ 2052| 13.4k| { 2053| 13.4k| group->DetectDuplicateFlags(usedShortFlags, usedLongFlags); 2054| 13.4k| } 2055| 13.4k| } 2056| 315k| } 2057| 73.8k| } _ZNK4args8FlagBase10GetMatcherEv: 1388| 301k| { 1389| 301k| return matcher; 1390| 301k| } _ZNK4args7Matcher14GetFlagStringsEv: 711| 525k| { 712| 525k| std::vector flagStrings; 713| 525k| flagStrings.reserve(shortFlags.size() + longFlags.size()); 714| 525k| for (const char flag: shortFlags) ------------------ | Branch (714:37): [True: 464k, False: 525k] ------------------ 715| 464k| { 716| 464k| flagStrings.emplace_back(flag); 717| 464k| } 718| 525k| for (const std::string &flag: longFlags) ------------------ | Branch (718:45): [True: 491k, False: 525k] ------------------ 719| 491k| { 720| 491k| flagStrings.emplace_back(flag); 721| 491k| } 722| 525k| return flagStrings; 723| 525k| } _ZN4args10EitherFlagC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 573| 523k| EitherFlag(const std::string &flag) : isShort(false), shortFlag(), longFlag(flag) {} _ZN4args10ParseErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 498| 1.61k| ParseError(const std::string &problem) : Error(problem) {} _ZN4args8FlagBaseD2Ev: 1354| 60.3k| virtual ~FlagBase() {} _ZN4args4Flag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE: 3805| 3.18k| { 3806| 3.18k| } _ZNK4args8FlagBase8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 1393| 41.7k| { 1394| 41.7k| if (!Matched() && IsRequired()) ------------------ | Branch (1394:21): [True: 41.3k, False: 369] | Branch (1394:35): [True: 0, False: 41.3k] ------------------ 1395| 0| { 1396| 0| std::ostringstream problem; 1397| 0| problem << "Flag '" << matcher.GetLongOrAny().str(shortPrefix, longPrefix) << "' is required"; 1398| |#ifdef ARGS_NOEXCEPT 1399| | error = Error::Required; 1400| | errorMsg = problem.str(); 1401| |#else 1402| 0| throw RequiredError(problem.str()); 1403| 0|#endif 1404| 0| } 1405| 41.7k| } _ZNK4args4Base10IsRequiredEv: 1033| 174k| { 1034| 174k| return (GetOptions() & Options::Required) != Options::None; 1035| 174k| } _ZNK4args7Matcher12GetLongOrAnyEv: 728| 29.0k| { 729| 29.0k| if (!longFlags.empty()) ------------------ | Branch (729:21): [True: 25.5k, False: 3.51k] ------------------ 730| 25.5k| { 731| 25.5k| return *longFlags.begin(); 732| 25.5k| } 733| | 734| 3.51k| if (!shortFlags.empty()) ------------------ | Branch (734:21): [True: 3.51k, False: 0] ------------------ 735| 3.51k| { 736| 3.51k| return *shortFlags.begin(); 737| 3.51k| } 738| | 739| | // should be unreachable 740| 0| return ' '; 741| 3.51k| } _ZNK4args10EitherFlag3strERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 613| 72.3k| { 614| 72.3k| return isShort ? shortPrefix + std::string(1, shortFlag) : longPrefix + longFlag; ------------------ | Branch (614:20): [True: 41.5k, False: 30.7k] ------------------ 615| 72.3k| } _ZNK4args9NamedBase14GetDescriptionERKNS_10HelpParamsEj: 1221| 277k| { 1222| 277k| std::tuple description; 1223| 277k| std::get<0>(description) = GetNameString(params); 1224| 277k| std::get<1>(description) = help; 1225| 277k| std::get<2>(description) = indentLevel; 1226| | 1227| 277k| AddDescriptionPostfix(std::get<1>(description), choicesStringManual, detail::Join(choicesStrings, ", "), params.addChoices, detail::Join(GetChoicesStrings(params), ", "), params.choiceString); 1228| 277k| AddDescriptionPostfix(std::get<1>(description), defaultStringManual, defaultString, params.addDefault, GetDefaultString(params), params.defaultString); 1229| | 1230| 277k| return { std::move(description) }; 1231| 277k| } _ZNK4args9NamedBase21AddDescriptionPostfixERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbRKS7_bSA_SA_: 1171| 554k| { 1172| 554k| if (isManual && !manual.empty()) ------------------ | Branch (1172:21): [True: 0, False: 554k] | Branch (1172:33): [True: 0, False: 0] ------------------ 1173| 0| { 1174| 0| dest += str; 1175| 0| dest += manual; 1176| 0| } 1177| 554k| else if (!isManual && isGenerated && !generated.empty()) ------------------ | Branch (1177:26): [True: 554k, False: 0] | Branch (1177:39): [True: 220k, False: 333k] | Branch (1177:54): [True: 33.0k, False: 187k] ------------------ 1178| 33.0k| { 1179| 33.0k| dest += str; 1180| 33.0k| dest += generated; 1181| 33.0k| } 1182| 554k| } _ZN4args6detail4JoinINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEES9_RKT_RKS9_: 367| 554k| { 368| 554k| std::string res; 369| | 370| | // Safely compute reservation size to avoid unbounded reallocations 371| 554k| using size_type = std::string::size_type; 372| 554k| size_type total = 0; 373| 554k| size_type count = 0; 374| 554k| const size_type delim_size = static_cast(delimiter.size()); 375| 554k| bool can_reserve = true; 376| | 377| 554k| for (const auto &element : array) ------------------ | Branch (377:38): [True: 80.5k, False: 554k] ------------------ 378| 80.5k| { 379| 80.5k| const size_type elem_size = static_cast(element.size()); 380| 80.5k| if (!SafeAdd(total, elem_size, total)) ------------------ | Branch (380:21): [True: 0, False: 80.5k] ------------------ 381| 0| { 382| 0| can_reserve = false; 383| 0| break; 384| 0| } 385| 80.5k| ++count; 386| 80.5k| } 387| | 388| 554k| if (can_reserve && count > 1) ------------------ | Branch (388:17): [True: 554k, False: 0] | Branch (388:32): [True: 26.8k, False: 527k] ------------------ 389| 26.8k| { 390| 26.8k| size_type delim_count = count - 1; 391| 26.8k| size_type delim_total = 0; 392| 26.8k| if (!SafeMultiply(delim_count, delim_size, delim_total) || ------------------ | Branch (392:21): [True: 0, False: 26.8k] ------------------ 393| 26.8k| !SafeAdd(total, delim_total, total)) ------------------ | Branch (393:21): [True: 0, False: 26.8k] ------------------ 394| 0| { 395| 0| can_reserve = false; 396| 0| } 397| 26.8k| } 398| | 399| 554k| if (can_reserve && total > 0) ------------------ | Branch (399:17): [True: 554k, False: 0] | Branch (399:32): [True: 26.8k, False: 527k] ------------------ 400| 26.8k| { 401| 26.8k| res.reserve(total); 402| 26.8k| } 403| | 404| 554k| bool first = true; 405| 554k| for (const auto &element : array) ------------------ | Branch (405:38): [True: 80.5k, False: 554k] ------------------ 406| 80.5k| { 407| 80.5k| if (!first) ------------------ | Branch (407:21): [True: 53.6k, False: 26.8k] ------------------ 408| 53.6k| { 409| 53.6k| res += delimiter; 410| 53.6k| } 411| 80.5k| res += element; 412| 80.5k| first = false; 413| 80.5k| } 414| | 415| 554k| return res; 416| 554k| } _ZN4args7SafeAddImEEbT_S1_RS1_: 109| 609k| { 110| 609k| static_assert(std::is_integral::value, "SafeAdd requires integral types."); 111| 609k| if (std::is_unsigned::value) ------------------ | Branch (111:13): [True: 609k, Folded] ------------------ 112| 609k| { 113| 609k| using U = typename std::make_unsigned::type; 114| 609k| const U ua = static_cast(a); 115| 609k| const U ub = static_cast(b); 116| 609k| const U maxv = std::numeric_limits::max(); 117| 609k| if (ua > maxv - ub) ------------------ | Branch (117:17): [True: 0, False: 609k] ------------------ 118| 0| { 119| 0| return false; 120| 0| } 121| 609k| out = static_cast(ua + ub); 122| 609k| return true; 123| 609k| } 124| 0| else 125| 0| { 126| 0|#if defined(__clang__) || defined(__GNUC__) 127| 0| return !__builtin_add_overflow(a, b, &out); 128| |#else 129| | // Fallback bounds check 130| | if (b > 0 && a > std::numeric_limits::max() - b) 131| | { 132| | return false; 133| | } 134| | if (b < 0 && a < std::numeric_limits::min() - b) 135| | { 136| | return false; 137| | } 138| | out = a + b; 139| | return true; 140| |#endif 141| 0| } 142| 609k| } _ZN4args12SafeMultiplyImEEbT_S1_RS1_: 149| 26.8k| { 150| 26.8k| static_assert(std::is_integral::value, "SafeMultiply requires integral types."); 151| | 152| 26.8k| if (a == 0 || b == 0) ------------------ | Branch (152:13): [True: 0, False: 26.8k] | Branch (152:23): [True: 0, False: 26.8k] ------------------ 153| 0| { 154| 0| out = 0; 155| 0| return true; 156| 0| } 157| | 158| 26.8k| if (std::is_unsigned::value) ------------------ | Branch (158:13): [True: 26.8k, Folded] ------------------ 159| 26.8k| { 160| 26.8k| using U = typename std::make_unsigned::type; 161| 26.8k| const U ua = static_cast(a); 162| 26.8k| const U ub = static_cast(b); 163| 26.8k| const U maxv = std::numeric_limits::max(); 164| 26.8k| if (ub > maxv / ua) ------------------ | Branch (164:17): [True: 0, False: 26.8k] ------------------ 165| 0| { 166| 0| return false; 167| 0| } 168| 26.8k| out = static_cast(ua * ub); 169| 26.8k| return true; 170| 26.8k| } 171| 0| else 172| 0| { 173| 0|#if defined(__clang__) || defined(__GNUC__) 174| 0| return !__builtin_mul_overflow(a, b, &out); 175| |#else 176| | // Fallback bounds check 177| | if (a == -1 && b == std::numeric_limits::min()) 178| | { 179| | return false; 180| | } 181| | if (b == -1 && a == std::numeric_limits::min()) 182| | { 183| | return false; 184| | } 185| | if ((a > 0 && b > 0 && a > std::numeric_limits::max() / b) || 186| | (a > 0 && b < 0 && b < std::numeric_limits::min() / a) || 187| | (a < 0 && b > 0 && a < std::numeric_limits::min() / b) || 188| | (a < 0 && b < 0 && a < std::numeric_limits::max() / b)) 189| | { 190| | return false; 191| | } 192| | out = a * b; 193| | return true; 194| |#endif 195| 0| } 196| 26.8k| } _ZNK4args8FlagBase6IsFlagEv: 1357| 60.3k| { 1358| 60.3k| return true; 1359| 60.3k| } _ZN4args8FlagBase5MatchERKNS_10EitherFlagE: 1362| 32.8k| { 1363| 32.8k| if (matcher.Match(flag)) ------------------ | Branch (1363:21): [True: 4.61k, False: 28.2k] ------------------ 1364| 4.61k| { 1365| 4.61k| if ((GetOptions() & Options::Single) != Options::None && matched) ------------------ | Branch (1365:25): [True: 0, False: 4.61k] | Branch (1365:78): [True: 0, False: 0] ------------------ 1366| 0| { 1367| 0| std::ostringstream problem; 1368| 0| problem << "Flag '" << flag.str() << "' was passed multiple times, but is only allowed to be passed once"; 1369| |#ifdef ARGS_NOEXCEPT 1370| | error = Error::Extra; 1371| | errorMsg = problem.str(); 1372| |#else 1373| 0| throw ExtraError(problem.str()); 1374| 0|#endif 1375| 0| } 1376| 4.61k| matched = true; 1377| 4.61k| return this; 1378| 4.61k| } 1379| 28.2k| return nullptr; 1380| 32.8k| } _ZNK4args7Matcher5MatchERKNS_10EitherFlagE: 704| 32.8k| { 705| 32.8k| return flag.isShort ? Match(flag.shortFlag) : Match(flag.longFlag); ------------------ | Branch (705:24): [True: 28.4k, False: 4.41k] ------------------ 706| 32.8k| } _ZNK4args7Matcher5MatchEc: 690| 28.4k| { 691| 28.4k| return shortFlags.find(flag) != shortFlags.end(); 692| 28.4k| } _ZNK4args7Matcher5MatchERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 697| 4.41k| { 698| 4.41k| return longFlags.find(flag) != longFlags.end(); 699| 4.41k| } _ZNK4args10EitherFlag3strEv: 608| 392k| { 609| 392k| return isShort ? std::string(1, shortFlag) : longFlag; ------------------ | Branch (609:20): [True: 196k, False: 196k] ------------------ 610| 392k| } _ZNK4args8FlagBase7HasFlagEv: 1427| 46.9k| { 1428| 46.9k| return true; 1429| 46.9k| } _ZNK4args8FlagBase14GetProgramLineERKNS_10HelpParamsE: 1408| 222k| { 1409| 222k| if (!params.proglineShowFlags) ------------------ | Branch (1409:21): [True: 150k, False: 72.3k] ------------------ 1410| 150k| { 1411| 150k| return {}; 1412| 150k| } 1413| | 1414| 72.3k| const std::string postfix = NumberOfArguments() == 0 ? std::string() : Name(); ------------------ | Branch (1414:45): [True: 28.3k, False: 43.9k] ------------------ 1415| 72.3k| const EitherFlag flag = params.proglinePreferShortFlags ? matcher.GetShortOrAny() : matcher.GetLongOrAny(); ------------------ | Branch (1415:41): [True: 43.2k, False: 29.0k] ------------------ 1416| 72.3k| std::string res = flag.str(params.shortPrefix, params.longPrefix); 1417| 72.3k| if (!postfix.empty()) ------------------ | Branch (1417:21): [True: 43.9k, False: 28.3k] ------------------ 1418| 43.9k| { 1419| 43.9k| res += params.proglineValueOpen + postfix + params.proglineValueClose; 1420| 43.9k| } 1421| | 1422| 72.3k| return { IsRequired() ? params.proglineRequiredOpen + res + params.proglineRequiredClose ------------------ | Branch (1422:26): [True: 0, False: 72.3k] ------------------ 1423| 72.3k| : params.proglineNonrequiredOpen + res + params.proglineNonrequiredClose }; 1424| 222k| } _ZN4argseqERKNS_5NargsES2_: 997| 150k| { 998| 150k| return lhs.min == rhs.min && lhs.max == rhs.max; ------------------ | Branch (998:20): [True: 57.9k, False: 92.6k] | Branch (998:42): [True: 57.9k, False: 0] ------------------ 999| 150k| } _ZN4args5NargsC2Em: 992| 305k| Nargs(size_t num_) : min{num_}, max{num_} 993| 305k| { 994| 305k| } _ZNK4args7Matcher13GetShortOrAnyEv: 746| 43.2k| { 747| 43.2k| if (!shortFlags.empty()) ------------------ | Branch (747:21): [True: 38.0k, False: 5.27k] ------------------ 748| 38.0k| { 749| 38.0k| return *shortFlags.begin(); 750| 38.0k| } 751| | 752| 5.27k| if (!longFlags.empty()) ------------------ | Branch (752:21): [True: 5.27k, False: 0] ------------------ 753| 5.27k| { 754| 5.27k| return *longFlags.begin(); 755| 5.27k| } 756| | 757| | // should be unreachable 758| 0| return ' '; 759| 5.27k| } _ZNK4args9NamedBase16GetDefaultStringERKNS_10HelpParamsE: 1164| 196k| virtual std::string GetDefaultString(const HelpParams&) const { return {}; } _ZNK4args9NamedBase17GetChoicesStringsERKNS_10HelpParamsE: 1166| 250k| virtual std::vector GetChoicesStrings(const HelpParams&) const { return {}; } _ZNK4args8FlagBase13GetNameStringERKNS_10HelpParamsE: 1323| 223k| { 1324| 223k| const std::string postfix = !params.showValueName || NumberOfArguments() == 0 ? std::string() : Name(); ------------------ | Branch (1324:45): [True: 145k, False: 78.2k] | Branch (1324:70): [True: 29.6k, False: 48.6k] ------------------ 1325| 223k| std::string flags; 1326| 223k| const auto flagStrings = matcher.GetFlagStrings(); 1327| 223k| const bool useValueNameOnce = flagStrings.size() == 1 ? false : params.useValueNameOnce; ------------------ | Branch (1327:47): [True: 53.6k, False: 169k] ------------------ 1328| 616k| for (auto it = flagStrings.begin(); it != flagStrings.end(); ++it) ------------------ | Branch (1328:53): [True: 392k, False: 223k] ------------------ 1329| 392k| { 1330| 392k| auto &flag = *it; 1331| 392k| if (it != flagStrings.begin()) ------------------ | Branch (1331:25): [True: 169k, False: 223k] ------------------ 1332| 169k| { 1333| 169k| flags += ", "; 1334| 169k| } 1335| | 1336| 392k| flags += flag.isShort ? params.shortPrefix : params.longPrefix; ------------------ | Branch (1336:30): [True: 196k, False: 196k] ------------------ 1337| 392k| flags += flag.str(); 1338| | 1339| 392k| if (!postfix.empty() && (!useValueNameOnce || it + 1 == flagStrings.end())) ------------------ | Branch (1339:25): [True: 87.5k, False: 305k] | Branch (1339:25): [True: 64.5k, False: 328k] | Branch (1339:46): [True: 41.5k, False: 46.0k] | Branch (1339:67): [True: 23.0k, False: 23.0k] ------------------ 1340| 64.5k| { 1341| 64.5k| flags += flag.isShort ? params.shortSeparator : params.longSeparator; ------------------ | Branch (1341:34): [True: 15.9k, False: 48.6k] ------------------ 1342| 64.5k| flags += params.valueOpen + postfix + params.valueClose; 1343| 64.5k| } 1344| 392k| } 1345| | 1346| 223k| return flags; 1347| 223k| } _ZNK4args9NamedBase4NameEv: 1234| 127k| { 1235| 127k| return name; 1236| 127k| } _ZNK4args4Flag17NumberOfArgumentsEv: 3800| 61.3k| { 3801| 61.3k| return 0; 3802| 61.3k| } _ZN4args8HelpFlag10ParseValueERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE: 3821| 142| { 3822| |#ifdef ARGS_NOEXCEPT 3823| | error = Error::Help; 3824| | errorMsg = Name(); 3825| |#else 3826| 142| throw Help(Name()); 3827| 142|#endif 3828| 142| } _ZN4args4HelpC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 543| 142| Help(const std::string &flag) : Error(flag) {} _ZN4args7MatcherD2Ev: 685| 120k| ~Matcher() {} _ZN4args11CounterFlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherEiNS_7OptionsE: 3848| 6.71k| Flag(group_, name_, help_, std::move(matcher_), options_), startcount(startcount_), count(startcount_) {} _ZN4args11CounterFlag5MatchERKNS_10EitherFlagE: 3853| 5.37k| { 3854| 5.37k| auto me = FlagBase::Match(arg); 3855| 5.37k| if (me) ------------------ | Branch (3855:21): [True: 1.99k, False: 3.37k] ------------------ 3856| 1.99k| { 3857| |#ifdef ARGS_NOEXCEPT 3858| | // Suppress increment when FlagBase::Match recorded an 3859| | // error on this same call (e.g. Options::Single violated). 3860| | // In non-noexcept mode that path would have thrown before 3861| | // reaching here and the count would not have advanced. 3862| | if (GetError() != Error::None) 3863| | { 3864| | return me; 3865| | } 3866| |#endif 3867| 1.99k| ++count; 3868| 1.99k| } 3869| 5.37k| return me; 3870| 5.37k| } _ZN4args11CounterFlag5ResetEv: 3888| 6.71k| { 3889| 6.71k| FlagBase::Reset(); 3890| 6.71k| count = startcount; 3891| 6.71k| } _ZN4args5Group10Validators9AtMostOneERKS0_: 1678| 375| { 1679| 375| return group.MatchedChildren() <= 1; 1680| 375| } _ZNK4args5Group15MatchedChildrenEv: 1844| 2.88k| { 1845| | // Cast to avoid warnings from -Wsign-conversion 1846| 2.88k| return static_cast::size_type>( 1847| 2.88k| std::count_if(std::begin(Children()), std::end(Children()), [](const Base *child){return child->Matched();})); 1848| 2.88k| } _ZZNK4args5Group15MatchedChildrenEvENKUlPKNS_4BaseEE_clES3_: 1847| 5.77k| std::count_if(std::begin(Children()), std::end(Children()), [](const Base *child){return child->Matched();})); _ZN4args5Group10Validators10AtLeastOneERKS0_: 1673| 1.00k| { 1674| 1.00k| return group.MatchedChildren() >= 1; 1675| 1.00k| } _ZN4args5Group10Validators3XorERKS0_: 1668| 433| { 1669| 433| return group.MatchedChildren() == 1; 1670| 433| } _ZN4args5Group10Validators9AllOrNoneERKS0_: 1688| 541| { 1689| 541| return (All(group) || None(group)); ------------------ | Branch (1689:29): [True: 2, False: 539] | Branch (1689:43): [True: 523, False: 16] ------------------ 1690| 541| } _ZN4args5Group10Validators3AllERKS0_: 1683| 541| { 1684| 541| return group.Children().size() == group.MatchedChildren(); 1685| 541| } _ZN4args5Group10Validators4NoneERKS0_: 1710| 539| { 1711| 539| return group.MatchedChildren() == 0; 1712| 539| } _ZN4args5GroupC2ERS0_RKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS2_8functionIFbRKS0_EEENS_7OptionsE: 1720| 6.71k| Group(Group &group_, const std::string &help_ = std::string(), const std::function &validator_ = Validators::DontCare, Options options_ = {}) : Base(help_, options_), validator(validator_) 1721| 6.71k| { 1722| 6.71k| group_.Add(*this); 1723| 6.71k| parent = &group_; 1724| 6.71k| } _ZN4args4FlagC2ERNS_5GroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_ONS_7MatcherEb: 3786| 6.71k| Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false): Flag(group_, name_, help_, std::move(matcher_), extraError_ ? Options::Single : Options::None) ------------------ | Branch (3786:186): [True: 0, False: 6.71k] ------------------ 3787| 6.71k| { 3788| 6.71k| } _ZNK4args14ArgumentParser4HelpEv: 3657| 13.4k| { 3658| 13.4k| std::ostringstream help_; 3659| 13.4k| Help(help_); 3660| 13.4k| return help_.str(); 3661| 13.4k| } _ZNK4args14ArgumentParser4HelpERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEE: 3539| 20.1k| { 3540| 20.1k| auto &command = SelectedCommand(); 3541| 20.1k| const auto &commandDescription = command.Description().empty() ? command.Help() : command.Description(); ------------------ | Branch (3541:50): [True: 17.6k, False: 2.47k] ------------------ 3542| 20.1k| const auto desc_indent = helpParams.descriptionindent; 3543| 20.1k| const auto effective_desc_width = (helpParams.width > desc_indent) ? helpParams.width - desc_indent : 0; ------------------ | Branch (3543:51): [True: 14.4k, False: 5.64k] ------------------ 3544| 20.1k| const auto description_text = Wrap(commandDescription, effective_desc_width); 3545| 20.1k| const auto epilog_text = Wrap(command.Epilog(), effective_desc_width); 3546| | 3547| 20.1k| const bool hasoptions = command.HasFlag(); 3548| 20.1k| const bool hasarguments = command.HasPositional(); 3549| | 3550| 20.1k| std::vector prognameline; 3551| 20.1k| prognameline.push_back(helpParams.usageString); 3552| 20.1k| prognameline.push_back(Prog()); 3553| 20.1k| auto commandProgLine = command.GetProgramLine(helpParams); 3554| 20.1k| prognameline.insert(prognameline.end(), commandProgLine.begin(), commandProgLine.end()); 3555| | 3556| 20.1k| const auto prog_sum = helpParams.progindent + helpParams.progtailindent; 3557| 20.1k| const auto effective_prog_width = (helpParams.width > prog_sum) ? helpParams.width - prog_sum : 0; ------------------ | Branch (3557:51): [True: 14.0k, False: 6.06k] ------------------ 3558| 20.1k| const auto effective_prog_first = (helpParams.width > helpParams.progindent) ? helpParams.width - helpParams.progindent : 0; ------------------ | Branch (3558:51): [True: 14.6k, False: 5.45k] ------------------ 3559| 20.1k| const auto proglines = Wrap(prognameline.begin(), prognameline.end(), 3560| 20.1k| effective_prog_width, 3561| 20.1k| effective_prog_first); 3562| 20.1k| auto progit = std::begin(proglines); 3563| 20.1k| if (progit != std::end(proglines)) ------------------ | Branch (3563:21): [True: 20.1k, False: 0] ------------------ 3564| 20.1k| { 3565| 20.1k| help_ << std::string(helpParams.progindent, ' ') << *progit << '\n'; 3566| 20.1k| ++progit; 3567| 20.1k| } 3568| 40.5k| for (; progit != std::end(proglines); ++progit) ------------------ | Branch (3568:24): [True: 20.4k, False: 20.1k] ------------------ 3569| 20.4k| { 3570| 20.4k| help_ << std::string(helpParams.progtailindent, ' ') << *progit << '\n'; 3571| 20.4k| } 3572| | 3573| 20.1k| help_ << '\n'; 3574| | 3575| 20.1k| if (!description_text.empty()) ------------------ | Branch (3575:21): [True: 2.06k, False: 18.0k] ------------------ 3576| 2.06k| { 3577| 2.06k| for (const auto &line: description_text) ------------------ | Branch (3577:42): [True: 6.03k, False: 2.06k] ------------------ 3578| 6.03k| { 3579| 6.03k| help_ << std::string(helpParams.descriptionindent, ' ') << line << "\n"; 3580| 6.03k| } 3581| 2.06k| help_ << "\n"; 3582| 2.06k| } 3583| | 3584| 20.1k| bool lastDescriptionIsNewline = false; 3585| | 3586| 20.1k| if (!helpParams.optionsString.empty()) ------------------ | Branch (3586:21): [True: 2.62k, False: 17.5k] ------------------ 3587| 2.62k| { 3588| 2.62k| help_ << std::string(helpParams.progindent, ' ') << helpParams.optionsString << "\n\n"; 3589| 2.62k| } 3590| | 3591| 20.1k| for (const auto &desc: command.GetDescription(helpParams, 0)) ------------------ | Branch (3591:38): [True: 209k, False: 20.1k] ------------------ 3592| 209k| { 3593| 209k| lastDescriptionIsNewline = std::get<0>(desc).empty() && std::get<1>(desc).empty(); ------------------ | Branch (3593:48): [True: 0, False: 209k] | Branch (3593:77): [True: 0, False: 0] ------------------ 3594| 209k| const auto groupindent = std::get<2>(desc) * helpParams.eachgroupindent; 3595| 209k| const auto flag_sum = helpParams.flagindent + helpParams.helpindent + helpParams.gutter; 3596| 209k| const auto effective_flag_width = (helpParams.width > flag_sum) ? helpParams.width - flag_sum : 0; ------------------ | Branch (3596:55): [True: 127k, False: 81.6k] ------------------ 3597| 209k| const auto flags = Wrap(std::get<0>(desc), effective_flag_width); 3598| 209k| const auto info_sum = helpParams.helpindent + groupindent; 3599| 209k| const auto effective_info_width = (helpParams.width > info_sum) ? helpParams.width - info_sum : 0; ------------------ | Branch (3599:55): [True: 133k, False: 75.9k] ------------------ 3600| 209k| const auto info = Wrap(std::get<1>(desc), effective_info_width); 3601| | 3602| 209k| std::string::size_type flagssize = 0; 3603| 505k| for (auto flagsit = std::begin(flags); flagsit != std::end(flags); ++flagsit) ------------------ | Branch (3603:60): [True: 296k, False: 209k] ------------------ 3604| 296k| { 3605| 296k| if (flagsit != std::begin(flags)) ------------------ | Branch (3605:29): [True: 87.1k, False: 209k] ------------------ 3606| 87.1k| { 3607| 87.1k| help_ << '\n'; 3608| 87.1k| } 3609| 296k| help_ << std::string(groupindent + helpParams.flagindent, ' ') << *flagsit; 3610| 296k| flagssize = Glyphs(*flagsit); 3611| 296k| } 3612| | 3613| 209k| auto infoit = std::begin(info); 3614| | // groupindent is on both sides of this inequality, and therefore can be removed 3615| 209k| if ((helpParams.flagindent + flagssize + helpParams.gutter) > helpParams.helpindent || infoit == std::end(info) || helpParams.addNewlineBeforeDescription) ------------------ | Branch (3615:25): [True: 104k, False: 105k] | Branch (3615:25): [True: 195k, False: 13.6k] | Branch (3615:108): [True: 74.5k, False: 30.5k] | Branch (3615:136): [True: 16.9k, False: 13.6k] ------------------ 3616| 195k| { 3617| 195k| help_ << '\n'; 3618| 195k| } else 3619| 13.6k| { 3620| | // groupindent is on both sides of the minus sign, and therefore doesn't actually need to be in here 3621| 13.6k| const auto indent_sum = helpParams.flagindent + flagssize; 3622| 13.6k| const auto effective_space = (helpParams.helpindent > indent_sum) ? helpParams.helpindent - indent_sum : 0; ------------------ | Branch (3622:54): [True: 13.5k, False: 78] ------------------ 3623| 13.6k| help_ << std::string(effective_space, ' ') << *infoit << '\n'; 3624| 13.6k| ++infoit; 3625| 13.6k| } 3626| 296k| for (; infoit != std::end(info); ++infoit) ------------------ | Branch (3626:28): [True: 87.5k, False: 209k] ------------------ 3627| 87.5k| { 3628| 87.5k| help_ << std::string(groupindent + helpParams.helpindent, ' ') << *infoit << '\n'; 3629| 87.5k| } 3630| 209k| } 3631| 20.1k| if (hasoptions && hasarguments && helpParams.showTerminator) ------------------ | Branch (3631:21): [True: 20.1k, False: 0] | Branch (3631:35): [True: 20.1k, False: 0] | Branch (3631:51): [True: 6.69k, False: 13.4k] ------------------ 3632| 6.69k| { 3633| 6.69k| lastDescriptionIsNewline = false; 3634| 6.69k| const auto effective_term_width = (helpParams.width > helpParams.flagindent) ? helpParams.width - helpParams.flagindent : 0; ------------------ | Branch (3634:55): [True: 6.00k, False: 687] ------------------ 3635| 6.69k| for (const auto &item: Wrap(std::string("\"") + terminator + "\" can be used to terminate flag options and force all following arguments to be treated as positional options", effective_term_width)) ------------------ | Branch (3635:42): [True: 26.4k, False: 6.69k] ------------------ 3636| 26.4k| { 3637| 26.4k| help_ << std::string(helpParams.flagindent, ' ') << item << '\n'; 3638| 26.4k| } 3639| 6.69k| } 3640| | 3641| 20.1k| if (!lastDescriptionIsNewline) ------------------ | Branch (3641:21): [True: 20.1k, False: 0] ------------------ 3642| 20.1k| { 3643| 20.1k| help_ << "\n"; 3644| 20.1k| } 3645| | 3646| 20.1k| for (const auto &line: epilog_text) ------------------ | Branch (3646:38): [True: 2.95k, False: 20.1k] ------------------ 3647| 2.95k| { 3648| 2.95k| help_ << std::string(helpParams.descriptionindent, ' ') << line << "\n"; 3649| 2.95k| } 3650| 20.1k| } _ZNK4args7Command15SelectedCommandEv: 2250| 20.1k| { 2251| 20.1k| const Command *res = this; 2252| 20.1k| while (res->selectedCommand != nullptr) ------------------ | Branch (2252:24): [True: 0, False: 20.1k] ------------------ 2253| 0| { 2254| 0| res = res->selectedCommand; 2255| 0| } 2256| | 2257| 20.1k| return *res; 2258| 20.1k| } _ZNK4args7Command11DescriptionEv: 2299| 22.6k| { return description; } _ZNK4args7Command4HelpEv: 2324| 17.6k| { return help; } _ZN4args4WrapERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEmm: 429| 586k| { 430| | // Preserve existing line breaks 431| 586k| const auto newlineloc = in.find('\n'); 432| 586k| if (newlineloc != in.npos) ------------------ | Branch (432:13): [True: 60.4k, False: 525k] ------------------ 433| 60.4k| { 434| 60.4k| auto first = Wrap(std::string(in, 0, newlineloc), width); 435| 60.4k| auto second = Wrap(std::string(in, newlineloc + 1), width); 436| 60.4k| first.insert( 437| 60.4k| std::end(first), 438| 60.4k| std::make_move_iterator(std::begin(second)), 439| 60.4k| std::make_move_iterator(std::end(second))); 440| 60.4k| return first; 441| 60.4k| } 442| | 443| 525k| std::istringstream stream(in); 444| 525k| std::string::size_type indent = 0; 445| | 446| 525k| for (auto c : in) ------------------ | Branch (446:21): [True: 317k, False: 216k] ------------------ 447| 317k| { 448| 317k| if (!std::isspace(static_cast(c))) ------------------ | Branch (448:17): [True: 309k, False: 8.51k] ------------------ 449| 309k| { 450| 309k| break; 451| 309k| } 452| 8.51k| ++indent; 453| 8.51k| } 454| | 455| 525k| return Wrap(std::istream_iterator(stream), std::istream_iterator(), 456| 525k| width, firstlinewidth, indent); 457| 586k| } _ZN4args4WrapINSt3__116istream_iteratorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEcS5_lEEEENS1_6vectorIS8_NS6_IS8_EEEET_SD_mmm: 282| 525k| { 283| 525k| std::vector output; 284| 525k| std::string line(firstlineindent, ' '); 285| 525k| bool empty = true; 286| | 287| 525k| if (firstlinewidth == 0) ------------------ | Branch (287:13): [True: 525k, False: 0] ------------------ 288| 525k| { 289| 525k| firstlinewidth = width; 290| 525k| } 291| | 292| 525k| auto currentwidth = firstlinewidth; 293| | 294| 1.19M| for (auto it = begin; it != end; ++it) ------------------ | Branch (294:31): [True: 666k, False: 525k] ------------------ 295| 666k| { 296| 666k| if (it->empty()) ------------------ | Branch (296:17): [True: 0, False: 666k] ------------------ 297| 0| { 298| 0| continue; 299| 0| } 300| | 301| 666k| if (*it == "\n") ------------------ | Branch (301:17): [True: 0, False: 666k] ------------------ 302| 0| { 303| 0| if (!empty) ------------------ | Branch (303:21): [True: 0, False: 0] ------------------ 304| 0| { 305| 0| output.push_back(line); 306| 0| line.clear(); 307| 0| empty = true; 308| 0| currentwidth = width; 309| 0| } 310| | 311| 0| continue; 312| 0| } 313| | 314| 666k| auto itemsize = Glyphs(*it); 315| | 316| | // Refactored to prevent integer overflow 317| 666k| bool needsWrap = false; 318| 666k| if (itemsize >= currentwidth) ------------------ | Branch (318:17): [True: 240k, False: 425k] ------------------ 319| 240k| { 320| 240k| needsWrap = true; 321| 240k| } 322| 425k| else 323| 425k| { 324| 425k| size_t remainingWidth = (currentwidth > itemsize) ? (currentwidth - itemsize) : 0; ------------------ | Branch (324:41): [True: 425k, False: 0] ------------------ 325| 425k| size_t nextLength = 0; 326| 425k| if (!SafeAdd(line.length(), static_cast(1), nextLength) || nextLength > remainingWidth) ------------------ | Branch (326:21): [True: 0, False: 425k] | Branch (326:124): [True: 10.4k, False: 414k] ------------------ 327| 10.4k| { 328| 10.4k| needsWrap = true; 329| 10.4k| } 330| 425k| } 331| | 332| 666k| if (needsWrap) ------------------ | Branch (332:17): [True: 251k, False: 414k] ------------------ 333| 251k| { 334| 251k| if (!empty) ------------------ | Branch (334:21): [True: 125k, False: 126k] ------------------ 335| 125k| { 336| 125k| output.push_back(line); 337| 125k| line.clear(); 338| 125k| empty = true; 339| 125k| currentwidth = width; 340| 125k| } 341| 251k| } 342| | 343| 666k| if (itemsize > 0) ------------------ | Branch (343:17): [True: 664k, False: 2.00k] ------------------ 344| 664k| { 345| 664k| if (!empty) ------------------ | Branch (345:21): [True: 231k, False: 432k] ------------------ 346| 231k| { 347| 231k| line += ' '; 348| 231k| } 349| | 350| 664k| line += *it; 351| 664k| empty = false; 352| 664k| } 353| 666k| } 354| | 355| 525k| if (!empty) ------------------ | Branch (355:13): [True: 307k, False: 217k] ------------------ 356| 307k| { 357| 307k| output.push_back(line); 358| 307k| } 359| | 360| 525k| return output; 361| 525k| } _ZNK4args7Command6EpilogEv: 2309| 20.1k| { return epilog; } _ZNK4args14ArgumentParser4ProgEv: 3435| 20.1k| { return helpParams.programName; } _ZN4args4WrapINSt3__111__wrap_iterIPNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEENS1_6vectorIS8_NS6_IS8_EEEET_SE_mmm: 282| 20.1k| { 283| 20.1k| std::vector output; 284| 20.1k| std::string line(firstlineindent, ' '); 285| 20.1k| bool empty = true; 286| | 287| 20.1k| if (firstlinewidth == 0) ------------------ | Branch (287:13): [True: 5.45k, False: 14.6k] ------------------ 288| 5.45k| { 289| 5.45k| firstlinewidth = width; 290| 5.45k| } 291| | 292| 20.1k| auto currentwidth = firstlinewidth; 293| | 294| 157k| for (auto it = begin; it != end; ++it) ------------------ | Branch (294:31): [True: 137k, False: 20.1k] ------------------ 295| 137k| { 296| 137k| if (it->empty()) ------------------ | Branch (296:17): [True: 37.8k, False: 99.5k] ------------------ 297| 37.8k| { 298| 37.8k| continue; 299| 37.8k| } 300| | 301| 99.5k| if (*it == "\n") ------------------ | Branch (301:17): [True: 546, False: 99.0k] ------------------ 302| 546| { 303| 546| if (!empty) ------------------ | Branch (303:21): [True: 27, False: 519] ------------------ 304| 27| { 305| 27| output.push_back(line); 306| 27| line.clear(); 307| 27| empty = true; 308| 27| currentwidth = width; 309| 27| } 310| | 311| 546| continue; 312| 546| } 313| | 314| 99.0k| auto itemsize = Glyphs(*it); 315| | 316| | // Refactored to prevent integer overflow 317| 99.0k| bool needsWrap = false; 318| 99.0k| if (itemsize >= currentwidth) ------------------ | Branch (318:17): [True: 22.3k, False: 76.7k] ------------------ 319| 22.3k| { 320| 22.3k| needsWrap = true; 321| 22.3k| } 322| 76.7k| else 323| 76.7k| { 324| 76.7k| size_t remainingWidth = (currentwidth > itemsize) ? (currentwidth - itemsize) : 0; ------------------ | Branch (324:41): [True: 76.7k, False: 0] ------------------ 325| 76.7k| size_t nextLength = 0; 326| 76.7k| if (!SafeAdd(line.length(), static_cast(1), nextLength) || nextLength > remainingWidth) ------------------ | Branch (326:21): [True: 0, False: 76.7k] | Branch (326:124): [True: 4.39k, False: 72.3k] ------------------ 327| 4.39k| { 328| 4.39k| needsWrap = true; 329| 4.39k| } 330| 76.7k| } 331| | 332| 99.0k| if (needsWrap) ------------------ | Branch (332:17): [True: 26.7k, False: 72.3k] ------------------ 333| 26.7k| { 334| 26.7k| if (!empty) ------------------ | Branch (334:21): [True: 20.4k, False: 6.30k] ------------------ 335| 20.4k| { 336| 20.4k| output.push_back(line); 337| 20.4k| line.clear(); 338| 20.4k| empty = true; 339| 20.4k| currentwidth = width; 340| 20.4k| } 341| 26.7k| } 342| | 343| 99.0k| if (itemsize > 0) ------------------ | Branch (343:17): [True: 98.7k, False: 264] ------------------ 344| 98.7k| { 345| 98.7k| if (!empty) ------------------ | Branch (345:21): [True: 58.2k, False: 40.5k] ------------------ 346| 58.2k| { 347| 58.2k| line += ' '; 348| 58.2k| } 349| | 350| 98.7k| line += *it; 351| 98.7k| empty = false; 352| 98.7k| } 353| 99.0k| } 354| | 355| 20.1k| if (!empty) ------------------ | Branch (355:13): [True: 20.1k, False: 0] ------------------ 356| 20.1k| { 357| 20.1k| output.push_back(line); 358| 20.1k| } 359| | 360| 20.1k| return output; 361| 20.1k| } _ZN4args6GlyphsERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 92| 1.06M| { 93| 1.06M| std::string::size_type length = 0; 94| 1.06M| for (const char c: string_) ------------------ | Branch (94:26): [True: 7.12M, False: 1.06M] ------------------ 95| 7.12M| { 96| 7.12M| if ((c & 0xc0) != 0x80) ------------------ | Branch (96:17): [True: 7.05M, False: 72.9k] ------------------ 97| 7.05M| { 98| 7.05M| ++length; 99| 7.05M| } 100| 7.12M| } 101| 1.06M| return length; 102| 1.06M| } _ZN4argslsERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEERKNS_14ArgumentParserE: 3771| 6.71k| { 3772| 6.71k| parser.Help(os); 3773| 6.71k| return os; 3774| 6.71k| } _ZNK4args7Command14GetDescriptionERKNS_10HelpParamsEj: 2550| 26.8k| { 2551| 26.8k| std::vector> descriptions; 2552| 26.8k| unsigned addindent = 0; 2553| | 2554| 26.8k| UpdateSubparserHelp(params); 2555| | 2556| 26.8k| if (!Matched()) ------------------ | Branch (2556:21): [True: 0, False: 26.8k] ------------------ 2557| 0| { 2558| 0| if (params.showCommandFullHelp) ------------------ | Branch (2558:25): [True: 0, False: 0] ------------------ 2559| 0| { 2560| 0| std::ostringstream s; 2561| 0| bool empty = true; 2562| 0| for (const auto &progline: GetCommandProgramLine(params)) ------------------ | Branch (2562:50): [True: 0, False: 0] ------------------ 2563| 0| { 2564| 0| if (!empty) ------------------ | Branch (2564:33): [True: 0, False: 0] ------------------ 2565| 0| { 2566| 0| s << ' '; 2567| 0| } 2568| 0| else 2569| 0| { 2570| 0| empty = false; 2571| 0| } 2572| | 2573| 0| s << progline; 2574| 0| } 2575| | 2576| 0| descriptions.emplace_back(s.str(), "", indent); 2577| 0| } 2578| 0| else 2579| 0| { 2580| 0| descriptions.emplace_back(Name(), help, indent); 2581| 0| } 2582| | 2583| 0| if (!params.showCommandChildren && !params.showCommandFullHelp) ------------------ | Branch (2583:25): [True: 0, False: 0] | Branch (2583:56): [True: 0, False: 0] ------------------ 2584| 0| { 2585| 0| return descriptions; 2586| 0| } 2587| | 2588| 0| addindent = 1; 2589| 0| } 2590| | 2591| 26.8k| if (params.showCommandFullHelp && !Matched()) ------------------ | Branch (2591:21): [True: 8.86k, False: 17.9k] | Branch (2591:51): [True: 0, False: 8.86k] ------------------ 2592| 0| { 2593| 0| descriptions.emplace_back("", "", indent + addindent); 2594| 0| descriptions.emplace_back(Description().empty() ? Help() : Description(), "", indent + addindent); ------------------ | Branch (2594:47): [True: 0, False: 0] ------------------ 2595| 0| descriptions.emplace_back("", "", indent + addindent); 2596| 0| } 2597| | 2598| 26.8k| for (Base *child: Children()) ------------------ | Branch (2598:33): [True: 268k, False: 26.8k] ------------------ 2599| 268k| { 2600| 268k| if ((child->GetOptions() & Options::HiddenFromDescription) != Options::None) ------------------ | Branch (2600:25): [True: 18.2k, False: 250k] ------------------ 2601| 18.2k| { 2602| 18.2k| continue; 2603| 18.2k| } 2604| | 2605| 250k| auto groupDescriptions = child->GetDescription(params, indent + addindent); 2606| 250k| descriptions.insert( 2607| 250k| std::end(descriptions), 2608| 250k| std::make_move_iterator(std::begin(groupDescriptions)), 2609| 250k| std::make_move_iterator(std::end(groupDescriptions))); 2610| 250k| } 2611| | 2612| 26.8k| for (auto childDescription: subparserDescription) ------------------ | Branch (2612:43): [True: 0, False: 26.8k] ------------------ 2613| 0| { 2614| 0| std::get<2>(childDescription) += indent + addindent; 2615| 0| descriptions.push_back(std::move(childDescription)); 2616| 0| } 2617| | 2618| 26.8k| if (params.showCommandFullHelp && !Matched()) ------------------ | Branch (2618:21): [True: 8.86k, False: 17.9k] | Branch (2618:51): [True: 0, False: 8.86k] ------------------ 2619| 0| { 2620| 0| descriptions.emplace_back("", "", indent + addindent); 2621| 0| if (!Epilog().empty()) ------------------ | Branch (2621:25): [True: 0, False: 0] ------------------ 2622| 0| { 2623| 0| descriptions.emplace_back(Epilog(), "", indent + addindent); 2624| 0| descriptions.emplace_back("", "", indent + addindent); 2625| 0| } 2626| 0| } 2627| | 2628| 26.8k| return descriptions; 2629| 26.8k| } _ZNK4args7Command19UpdateSubparserHelpERKNS_10HelpParamsE: 2261| 53.6k| { 2262| 53.6k| if (parserCoroutine) ------------------ | Branch (2262:21): [True: 0, False: 53.6k] ------------------ 2263| 0| { 2264| 0| RaiiSubparser coro(*this, params); 2265| 0|#ifndef ARGS_NOEXCEPT 2266| 0| try 2267| 0| { 2268| 0| parserCoroutine(coro.Parser()); 2269| 0| } 2270| 0| catch (args::SubparserError&) 2271| 0| { 2272| 0| } 2273| |#else 2274| | parserCoroutine(coro.Parser()); 2275| |#endif 2276| 0| } 2277| 53.6k| } _ZNK4args7Command21GetCommandProgramLineERKNS_10HelpParamsE: 2466| 26.8k| { 2467| 26.8k| UpdateSubparserHelp(params); 2468| | 2469| 26.8k| std::vector res; 2470| | 2471| 26.8k| if ((subparserHasFlag || Group::HasFlag()) && params.showProglineOptions && !params.proglineShowFlags) ------------------ | Branch (2471:22): [True: 0, False: 26.8k] | Branch (2471:42): [True: 26.8k, False: 0] | Branch (2471:63): [True: 8.88k, False: 17.9k] | Branch (2471:93): [True: 3.60k, False: 5.28k] ------------------ 2472| 3.60k| { 2473| 3.60k| res.push_back(params.proglineOptions); 2474| 3.60k| } 2475| | 2476| 26.8k| auto group_res = Group::GetProgramLine(params); 2477| 26.8k| std::move(std::move(group_res).begin(), std::move(group_res).end(), std::back_inserter(res)); 2478| | 2479| 26.8k| res.insert(res.end(), subparserProgramLine.begin(), subparserProgramLine.end()); 2480| | 2481| 26.8k| if (!params.proglineCommand.empty() && (Group::HasCommand() || subparserHasCommand)) ------------------ | Branch (2481:21): [True: 7.40k, False: 19.4k] | Branch (2481:57): [True: 0, False: 7.40k] | Branch (2481:80): [True: 0, False: 7.40k] ------------------ 2482| 0| { 2483| 0| res.insert(res.begin(), commandIsRequired ? params.proglineCommand : "[" + params.proglineCommand + "]"); ------------------ | Branch (2483:45): [True: 0, False: 0] ------------------ 2484| 0| } 2485| | 2486| 26.8k| if (!Name().empty()) ------------------ | Branch (2486:21): [True: 0, False: 26.8k] ------------------ 2487| 0| { 2488| 0| res.insert(res.begin(), Name()); 2489| 0| } 2490| | 2491| 26.8k| if (!ProglinePostfix().empty()) ------------------ | Branch (2491:21): [True: 0, False: 26.8k] ------------------ 2492| 0| { 2493| 0| std::string line; 2494| 0| for (auto c : ProglinePostfix()) ------------------ | Branch (2494:33): [True: 0, False: 0] ------------------ 2495| 0| { 2496| 0| if (std::isspace(static_cast(c))) ------------------ | Branch (2496:29): [True: 0, False: 0] ------------------ 2497| 0| { 2498| 0| if (!line.empty()) ------------------ | Branch (2498:33): [True: 0, False: 0] ------------------ 2499| 0| { 2500| 0| res.push_back(line); 2501| 0| line.clear(); 2502| 0| } 2503| | 2504| 0| if (c == '\n') ------------------ | Branch (2504:33): [True: 0, False: 0] ------------------ 2505| 0| { 2506| 0| res.push_back("\n"); 2507| 0| } 2508| 0| } 2509| 0| else 2510| 0| { 2511| 0| line += c; 2512| 0| } 2513| 0| } 2514| | 2515| 0| if (!line.empty()) ------------------ | Branch (2515:25): [True: 0, False: 0] ------------------ 2516| 0| { 2517| 0| res.push_back(line); 2518| 0| } 2519| 0| } 2520| | 2521| 26.8k| return res; 2522| 26.8k| } _ZNK4args7Command15ProglinePostfixEv: 2289| 26.8k| { return proglinePostfix; } _ZNK4args7Command4NameEv: 2319| 26.8k| { return name; } _ZNK4args7Command14GetProgramLineERKNS_10HelpParamsE: 2525| 26.8k| { 2526| 26.8k| if (!Matched()) ------------------ | Branch (2526:21): [True: 0, False: 26.8k] ------------------ 2527| 0| { 2528| 0| return {}; 2529| 0| } 2530| | 2531| 26.8k| return GetCommandProgramLine(params); 2532| 26.8k| } _ZN4args14ArgumentParser9ParseArgsINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEEDTclsr3stdE5beginfp_EERKT_: 3698| 6.71k| { 3699| 6.71k| return ParseArgs(std::begin(args), std::end(args)); 3700| 6.71k| } _ZN4args14ArgumentParser9ParseArgsINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SD_SD_: 3678| 6.71k| { 3679| | // Reset all Matched statuses and errors 3680| 6.71k| Reset(); 3681| |#ifdef ARGS_NOEXCEPT 3682| | error = GetError(); 3683| | if (error != Error::None) 3684| | { 3685| | return end; 3686| | } 3687| |#endif 3688| 6.71k| return Parse(begin, end); 3689| 6.71k| } _ZN4args14ArgumentParser5ParseINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEET_SD_SD_: 3198| 6.71k| { 3199| 6.71k| bool terminated = false; 3200| 6.71k| std::vector commands = GetCommands(); 3201| | 3202| | // Check all arg chunks 3203| 16.0k| for (auto it = begin; it != end; ++it) ------------------ | Branch (3203:39): [True: 9.30k, False: 6.71k] ------------------ 3204| 9.30k| { 3205| 9.30k| if (Complete(it, end, terminated)) ------------------ | Branch (3205:25): [True: 0, False: 9.30k] ------------------ 3206| 0| { 3207| 0| return end; 3208| 0| } 3209| | 3210| 9.30k| const auto &chunk = *it; 3211| | 3212| 9.30k| if (!terminated && chunk == terminator) ------------------ | Branch (3212:25): [True: 8.65k, False: 650] | Branch (3212:40): [True: 222, False: 8.42k] ------------------ 3213| 222| { 3214| 222| terminated = true; 3215| 9.07k| } else if (!terminated && ParseOption(chunk) == OptionType::LongFlag) ------------------ | Branch (3215:32): [True: 8.42k, False: 650] | Branch (3215:47): [True: 700, False: 7.72k] ------------------ 3216| 700| { 3217| 700| if (!ParseLong(it, end)) ------------------ | Branch (3217:29): [True: 0, False: 700] ------------------ 3218| 0| { 3219| 0| return it; 3220| 0| } 3221| 8.37k| } else if (!terminated && ParseOption(chunk) == OptionType::ShortFlag) ------------------ | Branch (3221:32): [True: 7.72k, False: 650] | Branch (3221:47): [True: 2.18k, False: 5.54k] ------------------ 3222| 2.18k| { 3223| 2.18k| if (!ParseShort(it, end)) ------------------ | Branch (3223:29): [True: 0, False: 2.18k] ------------------ 3224| 0| { 3225| 0| return it; 3226| 0| } 3227| 6.19k| } else if (!terminated && !commands.empty()) ------------------ | Branch (3227:32): [True: 5.54k, False: 650] | Branch (3227:47): [True: 0, False: 5.54k] ------------------ 3228| 0| { 3229| 0| auto itCommand = std::find_if(commands.begin(), commands.end(), [&chunk](Command *c) { return c->Name() == chunk; }); 3230| 0| if (itCommand == commands.end()) ------------------ | Branch (3230:29): [True: 0, False: 0] ------------------ 3231| 0| { 3232| 0| const std::string errorMessage("Unknown command: " + chunk); 3233| 0|#ifndef ARGS_NOEXCEPT 3234| 0| throw ParseError(errorMessage); 3235| |#else 3236| | error = Error::Parse; 3237| | errorMsg = errorMessage; 3238| | return it; 3239| |#endif 3240| 0| } 3241| | 3242| 0| SelectCommand(*itCommand); 3243| | 3244| 0| if (const auto &coroutine = GetCoroutine()) ------------------ | Branch (3244:41): [True: 0, False: 0] ------------------ 3245| 0| { 3246| 0| ++it; 3247| 0| RaiiSubparser coro(*this, std::vector(it, end)); 3248| 0| coroutine(coro.Parser()); 3249| |#ifdef ARGS_NOEXCEPT 3250| | error = GetError(); 3251| | if (error != Error::None) 3252| | { 3253| | return end; 3254| | } 3255| | 3256| | if (!coro.Parser().IsParsed()) 3257| | { 3258| | error = Error::Usage; 3259| | return end; 3260| | } 3261| |#else 3262| 0| if (!coro.Parser().IsParsed()) ------------------ | Branch (3262:33): [True: 0, False: 0] ------------------ 3263| 0| { 3264| 0| throw UsageError("Subparser::Parse was not called"); 3265| 0| } 3266| 0|#endif 3267| | 3268| 0| break; 3269| 0| } 3270| | 3271| 0| commands = GetCommands(); 3272| 0| } else 3273| 6.19k| { 3274| 6.19k| auto pos = GetNextPositional(); 3275| 6.19k| if (pos) ------------------ | Branch (3275:29): [True: 6.19k, False: 0] ------------------ 3276| 6.19k| { 3277| 6.19k| pos->ParseValue(chunk); 3278| |#ifdef ARGS_NOEXCEPT 3279| | if (pos->GetError() != Error::None) 3280| | { 3281| | return it; 3282| | } 3283| |#endif 3284| | 3285| 6.19k| if (pos->KickOut()) ------------------ | Branch (3285:33): [True: 0, False: 6.19k] ------------------ 3286| 0| { 3287| 0| return ++it; 3288| 0| } 3289| 6.19k| } else 3290| 0| { 3291| 0| const std::string errorMessage("Passed in argument, but no positional arguments were ready to receive it: " + chunk); 3292| 0|#ifndef ARGS_NOEXCEPT 3293| 0| throw ParseError(errorMessage); 3294| |#else 3295| | error = Error::Parse; 3296| | errorMsg = errorMessage; 3297| | return it; 3298| |#endif 3299| 0| } 3300| 6.19k| } 3301| | 3302| 9.30k| if (!readCompletion && completion != nullptr && completion->Matched()) ------------------ | Branch (3302:25): [True: 7.54k, False: 1.75k] | Branch (3302:44): [True: 0, False: 7.54k] | Branch (3302:69): [True: 0, False: 0] ------------------ 3303| 0| { 3304| |#ifdef ARGS_NOEXCEPT 3305| | if (completion->GetError() != Error::None) 3306| | { 3307| | error = completion->GetError(); 3308| | if (errorMsg.empty()) 3309| | { 3310| | errorMsg = completion->GetErrorMsg(); 3311| | } 3312| | return it; 3313| | } 3314| | 3315| | error = Error::Completion; 3316| |#endif 3317| 0| readCompletion = true; 3318| 0| ++it; 3319| 0| const auto argsLeft = static_cast(std::distance(it, end)); 3320| 0| if (completion->cword == 0 || argsLeft <= 1 || completion->cword >= argsLeft) ------------------ | Branch (3320:29): [True: 0, False: 0] | Branch (3320:55): [True: 0, False: 0] | Branch (3320:72): [True: 0, False: 0] ------------------ 3321| 0| { 3322| 0|#ifndef ARGS_NOEXCEPT 3323| 0| throw Completion(""); 3324| |#else 3325| | return end; 3326| |#endif 3327| 0| } 3328| | 3329| 0| ++it; 3330| 0| std::vector curArgs; 3331| 0| curArgs.reserve(completion->cword); 3332| 0| auto curIt = it; 3333| 0| for (size_t idx = 0; idx < completion->cword && curIt != end; ++idx, ++curIt) ------------------ | Branch (3333:46): [True: 0, False: 0] | Branch (3333:73): [True: 0, False: 0] ------------------ 3334| 0| { 3335| 0| curArgs.push_back(*curIt); 3336| 0| } 3337| | 3338| 0| if (completion->syntax == "bash") ------------------ | Branch (3338:29): [True: 0, False: 0] ------------------ 3339| 0| { 3340| | // bash tokenizes --flag=value as --flag=value 3341| | // Security fix: Use size_t arithmetic throughout to avoid conversion issues 3342| 0| for (size_t idx = 0; idx < curArgs.size(); ) ------------------ | Branch (3342:50): [True: 0, False: 0] ------------------ 3343| 0| { 3344| 0| if (idx > 0 && curArgs[idx] == "=") ------------------ | Branch (3344:37): [True: 0, False: 0] | Branch (3344:48): [True: 0, False: 0] ------------------ 3345| 0| { 3346| 0| size_t prev_idx = idx - 1; // Safe since we checked idx > 0 3347| 0| curArgs[prev_idx] += "="; 3348| 0| size_t next_idx = 0; 3349| 0| if (SafeAdd(idx, static_cast(1), next_idx) && next_idx < curArgs.size()) ------------------ | Branch (3349:41): [True: 0, False: 0] | Branch (3349:99): [True: 0, False: 0] ------------------ 3350| 0| { 3351| 0| curArgs[prev_idx] += curArgs[next_idx]; 3352| | // Erase the '=' token and the following value token. 3353| 0| size_t erase_end = 0; 3354| 0| if (SafeAdd(next_idx, static_cast(1), erase_end)) ------------------ | Branch (3354:45): [True: 0, False: 0] ------------------ 3355| 0| { 3356| 0| typedef std::vector::difference_type diff_t; 3357| 0| curArgs.erase(curArgs.begin() + static_cast(idx), 3358| 0| curArgs.begin() + static_cast(erase_end)); 3359| 0| } 3360| 0| } else 3361| 0| { 3362| | // Safe erase of single '=' token at the end 3363| 0| typedef std::vector::difference_type diff_t; 3364| 0| curArgs.erase(curArgs.begin() + static_cast(idx)); 3365| 0| } 3366| | // Do not increment idx - next element slides into current position 3367| 0| } else 3368| 0| { 3369| 0| ++idx; 3370| 0| } 3371| 0| } 3372| | 3373| 0| } 3374| 0|#ifndef ARGS_NOEXCEPT 3375| 0| try 3376| 0| { 3377| 0| Parse(curArgs.begin(), curArgs.end()); 3378| 0| throw Completion(""); 3379| 0| } 3380| 0| catch (Completion &) 3381| 0| { 3382| 0| throw; 3383| 0| } 3384| 0| catch (args::Error&) 3385| 0| { 3386| 0| throw Completion(""); 3387| 0| } 3388| |#else 3389| | // Discard the nested Parse's return value: it points 3390| | // into the local curArgs vector, which is destroyed 3391| | // when this function returns, leaving the caller with 3392| | // a dangling iterator that would be compared against 3393| | // the outer `end` in ParseCLI. Return the outer 3394| | // `end` instead so the iterator stays in the caller's 3395| | // container. 3396| | Parse(curArgs.begin(), curArgs.end()); 3397| | error = Error::Completion; 3398| | errorMsg.clear(); 3399| | return end; 3400| |#endif 3401| 0| } 3402| 9.30k| } 3403| | 3404| 6.71k| Validate(shortprefix, longprefix); 3405| 6.71k| return end; 3406| 6.71k| } _ZN4args14ArgumentParser8CompleteINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbT_SD_b: 3070| 9.30k| { 3071| 9.30k| auto nextIt = it; 3072| 9.30k| if (!readCompletion || (++nextIt != end)) ------------------ | Branch (3072:21): [True: 9.30k, False: 0] | Branch (3072:40): [True: 0, False: 0] ------------------ 3073| 9.30k| { 3074| 9.30k| return false; 3075| 9.30k| } 3076| | 3077| 0| const auto &chunk = *it; 3078| 0| auto pos = GetNextPositional(); 3079| 0| std::vector commands = GetCommands(); 3080| 0| const auto optionType = ParseOption(chunk, true); 3081| | 3082| | // Once the terminator has been seen the parser treats every 3083| | // following chunk as positional, so only positional choices are 3084| | // valid completions here. Suggesting flags or commands past the 3085| | // terminator offers candidates the parser would then reject. 3086| 0| if (!terminated && !commands.empty() && (chunk.empty() || optionType == OptionType::Positional)) ------------------ | Branch (3086:21): [True: 0, False: 0] | Branch (3086:36): [True: 0, False: 0] | Branch (3086:58): [True: 0, False: 0] | Branch (3086:75): [True: 0, False: 0] ------------------ 3087| 0| { 3088| 0| for (auto &cmd : commands) ------------------ | Branch (3088:36): [True: 0, False: 0] ------------------ 3089| 0| { 3090| 0| if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None) ------------------ | Branch (3090:29): [True: 0, False: 0] ------------------ 3091| 0| { 3092| 0| AddCompletionReply(chunk, cmd->Name()); 3093| 0| } 3094| 0| } 3095| 0| } else 3096| 0| { 3097| 0| bool hasPositionalCompletion = true; 3098| | 3099| 0| if (!terminated && !commands.empty()) ------------------ | Branch (3099:25): [True: 0, False: 0] | Branch (3099:40): [True: 0, False: 0] ------------------ 3100| 0| { 3101| 0| for (auto &cmd : commands) ------------------ | Branch (3101:40): [True: 0, False: 0] ------------------ 3102| 0| { 3103| 0| if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None) ------------------ | Branch (3103:33): [True: 0, False: 0] ------------------ 3104| 0| { 3105| 0| AddCompletionReply(chunk, cmd->Name()); 3106| 0| } 3107| 0| } 3108| 0| } else if (pos) ------------------ | Branch (3108:32): [True: 0, False: 0] ------------------ 3109| 0| { 3110| 0| if ((pos->GetOptions() & Options::HiddenFromCompletion) == Options::None) ------------------ | Branch (3110:29): [True: 0, False: 0] ------------------ 3111| 0| { 3112| 0| auto choices = pos->HelpChoices(helpParams); 3113| 0| hasPositionalCompletion = !choices.empty() || optionType != OptionType::Positional; ------------------ | Branch (3113:55): [True: 0, False: 0] | Branch (3113:75): [True: 0, False: 0] ------------------ 3114| 0| for (auto &choice : choices) ------------------ | Branch (3114:47): [True: 0, False: 0] ------------------ 3115| 0| { 3116| 0| AddCompletionReply(chunk, choice); 3117| 0| } 3118| 0| } 3119| 0| } 3120| | 3121| 0| if (!terminated && hasPositionalCompletion) ------------------ | Branch (3121:25): [True: 0, False: 0] | Branch (3121:40): [True: 0, False: 0] ------------------ 3122| 0| { 3123| 0| auto flags = GetAllFlags(); 3124| 0| for (auto flag : flags) ------------------ | Branch (3124:40): [True: 0, False: 0] ------------------ 3125| 0| { 3126| 0| if ((flag->GetOptions() & Options::HiddenFromCompletion) != Options::None) ------------------ | Branch (3126:33): [True: 0, False: 0] ------------------ 3127| 0| { 3128| 0| continue; 3129| 0| } 3130| | 3131| 0| auto &matcher = flag->GetMatcher(); 3132| 0| if (!AddCompletionReply(chunk, matcher.GetShortOrAny().str(shortprefix, longprefix))) ------------------ | Branch (3132:33): [True: 0, False: 0] ------------------ 3133| 0| { 3134| 0| for (auto &flagName : matcher.GetFlagStrings()) ------------------ | Branch (3134:53): [True: 0, False: 0] ------------------ 3135| 0| { 3136| 0| if (AddCompletionReply(chunk, flagName.str(shortprefix, longprefix))) ------------------ | Branch (3136:41): [True: 0, False: 0] ------------------ 3137| 0| { 3138| 0| break; 3139| 0| } 3140| 0| } 3141| 0| } 3142| 0| } 3143| | 3144| 0| if (optionType == OptionType::LongFlag && allowJoinedLongValue) ------------------ | Branch (3144:29): [True: 0, False: 0] | Branch (3144:67): [True: 0, False: 0] ------------------ 3145| 0| { 3146| 0| const auto separator = longseparator.empty() ? chunk.npos : chunk.find(longseparator); ------------------ | Branch (3146:52): [True: 0, False: 0] ------------------ 3147| | // Only attempt joined-value completion when the 3148| | // separator lies at or past the long prefix, so 3149| | // there is a (possibly empty) flag name between 3150| | // them. With a custom longseparator that overlaps 3151| | // the prefix (e.g. LongSeparator("-") under the 3152| | // default "--" prefix), an attacker-controlled 3153| | // completion word like "--x" puts the separator 3154| | // inside the prefix, making `arg` shorter than 3155| | // longprefix. arg.substr(longprefix.size()) would 3156| | // then throw std::out_of_range, which escapes the 3157| | // parser as a non-args exception (bypassing the 3158| | // documented catch(args::Error) idiom) and is 3159| | // thrown even under ARGS_NOEXCEPT. 3160| 0| if (separator != chunk.npos && separator >= longprefix.size()) ------------------ | Branch (3160:33): [True: 0, False: 0] | Branch (3160:60): [True: 0, False: 0] ------------------ 3161| 0| { 3162| 0| std::string arg(chunk, 0, separator); 3163| 0| if (auto flag = this->Match(arg.substr(longprefix.size()))) ------------------ | Branch (3163:42): [True: 0, False: 0] ------------------ 3164| 0| { 3165| 0| for (auto &choice : flag->HelpChoices(helpParams)) ------------------ | Branch (3165:55): [True: 0, False: 0] ------------------ 3166| 0| { 3167| 0| AddCompletionReply(chunk, arg + longseparator + choice); 3168| 0| } 3169| 0| } 3170| 0| } 3171| 0| } else if (optionType == OptionType::ShortFlag && allowJoinedShortValue) ------------------ | Branch (3171:36): [True: 0, False: 0] | Branch (3171:75): [True: 0, False: 0] ------------------ 3172| 0| { 3173| 0| if (chunk.size() > shortprefix.size() + 1) ------------------ | Branch (3173:33): [True: 0, False: 0] ------------------ 3174| 0| { 3175| 0| auto arg = chunk.at(shortprefix.size()); 3176| | //TODO: support -abcVALUE where a and b take no value 3177| 0| if (auto flag = this->Match(arg)) ------------------ | Branch (3177:42): [True: 0, False: 0] ------------------ 3178| 0| { 3179| 0| for (auto &choice : flag->HelpChoices(helpParams)) ------------------ | Branch (3179:55): [True: 0, False: 0] ------------------ 3180| 0| { 3181| 0| AddCompletionReply(chunk, shortprefix + arg + choice); 3182| 0| } 3183| 0| } 3184| 0| } 3185| 0| } 3186| 0| } 3187| 0| } 3188| | 3189| 0|#ifndef ARGS_NOEXCEPT 3190| 0| throw Completion(completion->Get()); 3191| |#else 3192| | return true; 3193| |#endif 3194| 9.30k| } _ZN4args14ArgumentParser11ParseOptionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb: 2751| 16.1k| { 2752| 16.1k| const bool matchesLong = s.find(longprefix) == 0 && (allowEmpty || s.length() > longprefix.length()); ------------------ | Branch (2752:42): [True: 744, False: 15.4k] | Branch (2752:70): [True: 0, False: 744] | Branch (2752:84): [True: 700, False: 44] ------------------ 2753| 16.1k| const bool matchesShort = s.find(shortprefix) == 0 && (allowEmpty || s.length() > shortprefix.length()); ------------------ | Branch (2753:43): [True: 6.85k, False: 9.30k] | Branch (2753:72): [True: 0, False: 6.85k] | Branch (2753:86): [True: 4.80k, False: 2.05k] ------------------ 2754| | 2755| | // A chunk can start with both prefixes when one is a prefix of 2756| | // the other, or when the long prefix is empty (every string 2757| | // starts with it). Resolve to the longer, more specific prefix: 2758| | // this keeps the default "--"/"-" preference for long flags 2759| | // while letting a short flag be recognised under an empty long 2760| | // prefix instead of being swallowed as a nameless long flag. 2761| 16.1k| if (matchesLong && matchesShort) ------------------ | Branch (2761:21): [True: 700, False: 15.4k] | Branch (2761:36): [True: 433, False: 267] ------------------ 2762| 433| { 2763| 433| return longprefix.length() >= shortprefix.length() ? OptionType::LongFlag : OptionType::ShortFlag; ------------------ | Branch (2763:28): [True: 433, False: 0] ------------------ 2764| 433| } 2765| | 2766| 15.7k| if (matchesLong) ------------------ | Branch (2766:21): [True: 267, False: 15.4k] ------------------ 2767| 267| { 2768| 267| return OptionType::LongFlag; 2769| 267| } 2770| | 2771| 15.4k| if (matchesShort) ------------------ | Branch (2771:21): [True: 4.36k, False: 11.0k] ------------------ 2772| 4.36k| { 2773| 4.36k| return OptionType::ShortFlag; 2774| 4.36k| } 2775| | 2776| 11.0k| return OptionType::Positional; 2777| 15.4k| } _ZN4args14ArgumentParser9ParseLongINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SD_: 2898| 700| { 2899| 700| const auto &chunk = *it; 2900| 700| const auto argchunk = chunk.substr(longprefix.size()); 2901| | // Try to separate it, in case of a separator: 2902| 700| const auto separator = longseparator.empty() ? argchunk.npos : argchunk.find(longseparator); ------------------ | Branch (2902:40): [True: 0, False: 700] ------------------ 2903| | // If the separator is in the argument, separate it. 2904| 700| const auto arg = (separator != argchunk.npos ? ------------------ | Branch (2904:35): [True: 323, False: 377] ------------------ 2905| 323| std::string(argchunk, 0, separator) 2906| 700| : argchunk); 2907| 700| const auto joined = (separator != argchunk.npos ? ------------------ | Branch (2907:38): [True: 323, False: 377] ------------------ 2908| 323| argchunk.substr(separator + longseparator.size()) 2909| 700| : std::string()); 2910| | 2911| 700| if (auto flag = Match(arg)) ------------------ | Branch (2911:26): [True: 420, False: 280] ------------------ 2912| 420| { 2913| |#ifdef ARGS_NOEXCEPT 2914| | // Match() may set the flag's error (e.g. Error::Extra when 2915| | // Options::Single is violated). In non-noexcept mode that 2916| | // path throws and parsing stops before the value is read; 2917| | // in noexcept mode we must mirror that and skip the value 2918| | // parsing so the previously-stored value is preserved. 2919| | if (flag->GetError() != Error::None) 2920| | { 2921| | return false; 2922| | } 2923| |#endif 2924| 420| std::vector values; 2925| 420| const std::string errorMessage = ParseArgsValues(*flag, arg, it, end, allowSeparateLongValue, allowJoinedLongValue, 2926| 420| separator != argchunk.npos, joined, false, values); 2927| 420| if (!errorMessage.empty()) ------------------ | Branch (2927:25): [True: 0, False: 420] ------------------ 2928| 0| { 2929| 0|#ifndef ARGS_NOEXCEPT 2930| 0| throw ParseError(errorMessage); 2931| |#else 2932| | error = Error::Parse; 2933| | errorMsg = errorMessage; 2934| | return false; 2935| |#endif 2936| 0| } 2937| | 2938| 420| if (!readCompletion) ------------------ | Branch (2938:25): [True: 420, False: 0] ------------------ 2939| 420| { 2940| 420| flag->ParseValue(values); 2941| |#ifdef ARGS_NOEXCEPT 2942| | // Non-noexcept ParseValue paths throw on Help, reader 2943| | // failure, or Map miss, which halts parsing. Mirror 2944| | // that here so a later parser-level error (e.g. an 2945| | // unknown flag) cannot shadow the flag's error in 2946| | // ArgumentParser::GetError(). 2947| | if (flag->GetError() != Error::None) 2948| | { 2949| | return false; 2950| | } 2951| |#endif 2952| 420| } 2953| | 2954| 420| if (flag->KickOut()) ------------------ | Branch (2954:25): [True: 0, False: 420] ------------------ 2955| 0| { 2956| 0| ++it; 2957| 0| return false; 2958| 0| } 2959| 420| } else 2960| 280| { 2961| 280| const std::string errorMessage("Flag could not be matched: " + arg); 2962| 280|#ifndef ARGS_NOEXCEPT 2963| 280| throw ParseError(errorMessage); 2964| |#else 2965| | error = Error::Parse; 2966| | errorMsg = errorMessage; 2967| | return false; 2968| |#endif 2969| 280| } 2970| | 2971| 420| return true; 2972| 700| } _ZN4args14ArgumentParser15ParseArgsValuesINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEES9_RNS_8FlagBaseERSA_RT_SG_bbbSF_bRNS2_6vectorIS9_NS7_IS9_EEEE: 2815| 4.61k| { 2816| 4.61k| values.clear(); 2817| | 2818| 4.61k| Nargs nargs = flag.NumberOfArguments(); 2819| | 2820| 4.61k| if (hasJoined && !allowJoined && (nargs.min != 0 || !canDiscardJoined)) ------------------ | Branch (2820:21): [True: 3.43k, False: 1.18k] | Branch (2820:34): [True: 0, False: 3.43k] | Branch (2820:51): [True: 0, False: 0] | Branch (2820:69): [True: 0, False: 0] ------------------ 2821| 0| { 2822| 0| return "Flag '" + arg + "' was passed a joined argument, but these are disallowed"; 2823| 0| } 2824| | 2825| 4.61k| if (hasJoined) ------------------ | Branch (2825:21): [True: 3.43k, False: 1.18k] ------------------ 2826| 3.43k| { 2827| 3.43k| if (!canDiscardJoined || (allowJoined && nargs.max != 0)) ------------------ | Branch (2827:25): [True: 285, False: 3.14k] | Branch (2827:47): [True: 3.14k, False: 0] | Branch (2827:62): [True: 334, False: 2.81k] ------------------ 2828| 619| { 2829| 619| values.push_back(joinedArg); 2830| 619| } 2831| 3.43k| } else if (!allowSeparate) ------------------ | Branch (2831:28): [True: 0, False: 1.18k] ------------------ 2832| 0| { 2833| 0| if (nargs.min != 0) ------------------ | Branch (2833:25): [True: 0, False: 0] ------------------ 2834| 0| { 2835| 0| return "Flag '" + arg + "' was passed a separate argument, but these are disallowed"; 2836| 0| } 2837| 1.18k| } else if (allowSeparate && (!hasJoined || !values.empty())) { ------------------ | Branch (2837:28): [True: 1.18k, False: 0] | Branch (2837:46): [True: 1.18k, False: 0] | Branch (2837:60): [True: 0, False: 0] ------------------ 2838| | // Only gather separate values when they are allowed. A joined 2839| | // value that was discarded rather than taken (short chunks such 2840| | // as -nf when joined short values are off) means this flag isn't 2841| | // taking an argument here, so the rest of the chunk is flags. 2842| 1.18k| auto valueIt = it; 2843| 1.18k| ++valueIt; 2844| | 2845| 1.64k| while (valueIt != end && ------------------ | Branch (2845:28): [True: 1.33k, False: 312] ------------------ 2846| 1.33k| *valueIt != terminator && ------------------ | Branch (2846:28): [True: 1.28k, False: 50] ------------------ 2847| 1.28k| values.size() < nargs.max && ------------------ | Branch (2847:28): [True: 464, False: 822] ------------------ 2848| 464| (values.size() < nargs.min || ParseOption(*valueIt) == OptionType::Positional)) ------------------ | Branch (2848:29): [True: 464, False: 0] | Branch (2848:58): [True: 0, False: 0] ------------------ 2849| 464| { 2850| 464| if (Complete(flag, valueIt, end)) ------------------ | Branch (2850:29): [True: 0, False: 464] ------------------ 2851| 0| { 2852| | // Park `it` on the completion position rather than 2853| | // `end`. In ARGS_NOEXCEPT mode Complete returns 2854| | // true (no throw), so the caller's for-loop will 2855| | // run its ++it after we return; advancing an 2856| | // already-end iterator is undefined behavior and 2857| | // causes a subsequent out-of-bounds read of the 2858| | // arg vector. Since Complete only fires when 2859| | // ++nextIt == end, valueIt is the last element, 2860| | // and ++(it=valueIt) safely lands on end. 2861| 0| it = valueIt; 2862| 0| return ""; 2863| 0| } 2864| | 2865| 464| values.push_back(*valueIt); 2866| 464| ++it; 2867| 464| ++valueIt; 2868| 464| } 2869| 1.18k| } 2870| | 2871| 4.61k| if (values.size() > nargs.max) ------------------ | Branch (2871:21): [True: 0, False: 4.61k] ------------------ 2872| 0| { 2873| 0| return "Passed an argument into a non-argument flag: " + arg; 2874| 4.61k| } else if (values.size() < nargs.min) ------------------ | Branch (2874:28): [True: 205, False: 4.41k] ------------------ 2875| 205| { 2876| 205| if (nargs.min == 1 && nargs.max == 1) ------------------ | Branch (2876:25): [True: 205, False: 0] | Branch (2876:43): [True: 205, False: 0] ------------------ 2877| 205| { 2878| 205| return "Flag '" + arg + "' requires an argument but received none"; 2879| 205| } else if (nargs.min == 1) ------------------ | Branch (2879:32): [True: 0, False: 0] ------------------ 2880| 0| { 2881| 0| return "Flag '" + arg + "' requires at least one argument but received none"; 2882| 0| } else if (nargs.min != nargs.max) ------------------ | Branch (2882:32): [True: 0, False: 0] ------------------ 2883| 0| { 2884| 0| return "Flag '" + arg + "' requires at least " + std::to_string(nargs.min) + 2885| 0| " arguments but received " + std::to_string(values.size()); 2886| 0| } else 2887| 0| { 2888| 0| return "Flag '" + arg + "' requires " + std::to_string(nargs.min) + 2889| 0| " arguments but received " + std::to_string(values.size()); 2890| 0| } 2891| 205| } 2892| | 2893| 4.41k| return {}; 2894| 4.61k| } _ZN4args14ArgumentParser8CompleteINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRNS_8FlagBaseET_SF_: 2781| 464| { 2782| 464| auto nextIt = it; 2783| 464| if (!readCompletion || (++nextIt != end)) ------------------ | Branch (2783:21): [True: 464, False: 0] | Branch (2783:40): [True: 0, False: 0] ------------------ 2784| 464| { 2785| 464| return false; 2786| 464| } 2787| | 2788| 0| const auto &chunk = *it; 2789| 0| for (auto &choice : flag.HelpChoices(helpParams)) ------------------ | Branch (2789:35): [True: 0, False: 0] ------------------ 2790| 0| { 2791| 0| AddCompletionReply(chunk, choice); 2792| 0| } 2793| | 2794| 0|#ifndef ARGS_NOEXCEPT 2795| 0| throw Completion(completion->Get()); 2796| |#else 2797| | return true; 2798| |#endif 2799| 464| } _ZN4args14ArgumentParser10ParseShortINSt3__111__wrap_iterIPKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEbRT_SD_: 2976| 2.18k| { 2977| 2.18k| const auto &chunk = *it; 2978| 2.18k| const auto argchunk = chunk.substr(shortprefix.size()); 2979| 5.64k| for (auto argit = std::begin(argchunk); argit != std::end(argchunk); ++argit) ------------------ | Branch (2979:57): [True: 4.99k, False: 647] ------------------ 2980| 4.99k| { 2981| 4.99k| const auto arg = *argit; 2982| | 2983| 4.99k| if (auto flag = Match(arg)) ------------------ | Branch (2983:30): [True: 4.19k, False: 801] ------------------ 2984| 4.19k| { 2985| |#ifdef ARGS_NOEXCEPT 2986| | // See ParseLong: if Match recorded an error 2987| | // (e.g. Options::Single violation), bail before the 2988| | // value is parsed so the prior value is preserved. 2989| | if (flag->GetError() != Error::None) 2990| | { 2991| | return false; 2992| | } 2993| |#endif 2994| 4.19k| const std::string value(argit + 1, std::end(argchunk)); 2995| 4.19k| std::vector values; 2996| 4.19k| const std::string errorMessage = ParseArgsValues(*flag, std::string(1, arg), it, end, 2997| 4.19k| allowSeparateShortValue, allowJoinedShortValue, 2998| 4.19k| !value.empty(), value, !value.empty(), values); 2999| | 3000| 4.19k| if (!errorMessage.empty()) ------------------ | Branch (3000:29): [True: 205, False: 3.99k] ------------------ 3001| 205| { 3002| 205|#ifndef ARGS_NOEXCEPT 3003| 205| throw ParseError(errorMessage); 3004| |#else 3005| | error = Error::Parse; 3006| | errorMsg = errorMessage; 3007| | return false; 3008| |#endif 3009| 205| } 3010| | 3011| 3.99k| if (!readCompletion) ------------------ | Branch (3011:29): [True: 3.99k, False: 0] ------------------ 3012| 3.99k| { 3013| 3.99k| flag->ParseValue(values); 3014| |#ifdef ARGS_NOEXCEPT 3015| | // See ParseLong: ensure a flag-level error from 3016| | // ParseValue (Help, Parse, Map) halts parsing so 3017| | // it cannot be shadowed by a later parser error. 3018| | if (flag->GetError() != Error::None) 3019| | { 3020| | return false; 3021| | } 3022| |#endif 3023| 3.99k| } 3024| | 3025| 3.99k| if (flag->KickOut()) ------------------ | Branch (3025:29): [True: 0, False: 3.99k] ------------------ 3026| 0| { 3027| 0| ++it; 3028| 0| return false; 3029| 0| } 3030| | 3031| 3.99k| if (!values.empty()) ------------------ | Branch (3031:29): [True: 531, False: 3.46k] ------------------ 3032| 531| { 3033| 531| break; 3034| 531| } 3035| 3.99k| } else 3036| 801| { 3037| 801| const std::string errorMessage("Flag could not be matched: '" + std::string(1, arg) + "'"); 3038| 801|#ifndef ARGS_NOEXCEPT 3039| 801| throw ParseError(errorMessage); 3040| |#else 3041| | error = Error::Parse; 3042| | errorMsg = errorMessage; 3043| | return false; 3044| |#endif 3045| 801| } 3046| 4.99k| } 3047| | 3048| 1.17k| return true; 3049| 2.18k| } _ZNK4args4Base7KickOutEv: 1124| 10.1k| { 1125| 10.1k| return (options & Options::KickOut) != Options::None; 1126| 10.1k| } _ZN4args9ValueFlagIiNS_11ValueReaderEEC2ERNS_5GroupERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_ONS_7MatcherERKib: 4139| 6.71k| ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), const bool extraError_ = false): ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, extraError_ ? Options::Single : Options::None) ------------------ | Branch (4139:241): [True: 0, False: 6.71k] ------------------ 4140| 6.71k| { 4141| 6.71k| } _ZN4args9ValueFlagIiNS_11ValueReaderEEC2ERNS_5GroupERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_ONS_7MatcherERKiNS_7OptionsE: 4134| 6.71k| ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), value(defaultValue_), defaultValue(defaultValue_) 4135| 6.71k| { 4136| 6.71k| group_.Add(*this); 4137| 6.71k| } _ZN4args13ValueFlagBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_ONS_7MatcherENS_7OptionsE: 1483| 33.5k| ValueFlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : FlagBase(name_, help_, std::move(matcher_), options_) {} _ZN4args9ValueFlagIiNS_11ValueReaderEE5ResetEv: 4164| 6.71k| { 4165| 6.71k| ValueFlagBase::Reset(); 4166| 6.71k| value = defaultValue; 4167| 6.71k| } _ZNK4args9ValueFlagIiNS_11ValueReaderEE16GetDefaultStringERKNS_10HelpParamsE: 4125| 26.8k| { 4126| 26.8k| return detail::ToString(defaultValue); 4127| 26.8k| } _ZN4args6detail8ToStringIiEENSt3__19enable_ifIXsr21IsConvertableToStringIT_EE5valueENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE4typeERKS4_: 1268| 26.8k| { 1269| 26.8k| std::ostringstream s; 1270| 26.8k| s << value; 1271| 26.8k| return s.str(); 1272| 26.8k| } _ZNK4args13ValueFlagBase17NumberOfArgumentsEv: 1487| 93.8k| { 1488| 93.8k| return 1; 1489| 93.8k| } _ZN4args9ValueFlagIiNS_11ValueReaderEE10ParseValueERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE: 4150| 361| { 4151| 361| const std::string &value_ = values_.at(0); 4152| | 4153| |#ifdef ARGS_NOEXCEPT 4154| | if (!reader(name, value_, this->value)) 4155| | { 4156| | error = Error::Parse; 4157| | } 4158| |#else 4159| 361| reader(name, value_, this->value); 4160| 361|#endif 4161| 361| } _ZN4args11ValueReaderclIiEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 361| { 4086| 361| const bool success = ParseNumericValue(value, destination); 4087| 361| if (!success) ------------------ | Branch (4087:17): [True: 138, False: 223] ------------------ 4088| 138| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 138| std::ostringstream problem; 4094| 138| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 138| throw ParseError(problem.str()); 4096| 138|#endif 4097| 138| } 4098| 223| return true; 4099| 361| } _ZN4args11ValueReader17ParseNumericValueIiEENSt3__19enable_ifIXaaaaaaaasr3std11is_integralIT_EE5valuentsr3std7is_sameIS4_bEE5valuentsr3std7is_sameIS4_cEE5valuentsr3std7is_sameIS4_aEE5valuentsr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 3968| 361| { 3969| 361| if (HasUnsignedNegativeSign(value)) ------------------ | Branch (3969:17): [True: 0, False: 361] ------------------ 3970| 0| { 3971| 0| return false; 3972| 0| } 3973| | 3974| 361| const char *begin = value.c_str(); 3975| | // The true end of the value, derived from its length rather than 3976| | // from the first NUL. strtoull/strtoll treat the buffer as a C 3977| | // string and stop at an embedded '\0', so checking `*end == '\0'` 3978| | // for "no trailing data" is defeated by a value like "12\0junk": 3979| | // end lands on the embedded NUL and the junk after it is silently 3980| | // accepted. Comparing against `stop` validates the whole string 3981| | // and matches the istringstream-based reader used for other types. 3982| 361| const char *const stop = begin + value.size(); 3983| | 3984| | // C++11-compatible: use strtoull/strtoll. Hardening retained from 3985| | // the original from_chars draft (errno save/restore, ERANGE check, 3986| | // narrowing range check, trailing-whitespace tolerance). No 3987| | // unconditional dependency on / C++17. 3988| 361| const int saved_errno = errno; 3989| 361| errno = 0; 3990| | 3991| 361| char *end = nullptr; 3992| | 3993| 361| if (std::is_unsigned::value) ------------------ | Branch (3993:17): [Folded, False: 361] ------------------ 3994| 0| { 3995| 0| const unsigned long long parsed = std::strtoull(begin, &end, 0); 3996| 0| if (end == begin) ------------------ | Branch (3996:21): [True: 0, False: 0] ------------------ 3997| 0| { 3998| 0| errno = saved_errno; 3999| 0| return false; 4000| 0| } 4001| 0| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4001:24): [True: 0, False: 0] | Branch (4001:39): [True: 0, False: 0] ------------------ 4002| 0| { 4003| 0| ++end; 4004| 0| } 4005| 0| if (end != stop || errno == ERANGE || ------------------ | Branch (4005:21): [True: 0, False: 0] | Branch (4005:36): [True: 0, False: 0] ------------------ 4006| 0| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4006:21): [True: 0, False: 0] ------------------ 4007| 0| { 4008| 0| errno = saved_errno; 4009| 0| return false; 4010| 0| } 4011| | 4012| 0| destination = static_cast(parsed); 4013| 0| } 4014| 361| else 4015| 361| { 4016| 361| const long long parsed = std::strtoll(begin, &end, 0); 4017| 361| if (end == begin) ------------------ | Branch (4017:21): [True: 69, False: 292] ------------------ 4018| 69| { 4019| 69| errno = saved_errno; 4020| 69| return false; 4021| 69| } 4022| 421| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4022:24): [True: 143, False: 278] | Branch (4022:39): [True: 129, False: 14] ------------------ 4023| 129| { 4024| 129| ++end; 4025| 129| } 4026| 292| if (end != stop || errno == ERANGE || ------------------ | Branch (4026:21): [True: 14, False: 278] | Branch (4026:36): [True: 0, False: 278] ------------------ 4027| 278| parsed < static_cast(std::numeric_limits::min()) || ------------------ | Branch (4027:21): [True: 48, False: 230] ------------------ 4028| 230| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4028:21): [True: 7, False: 223] ------------------ 4029| 69| { 4030| 69| errno = saved_errno; 4031| 69| return false; 4032| 69| } 4033| | 4034| 223| destination = static_cast(parsed); 4035| 223| } 4036| | 4037| 361| errno = saved_errno; 4038| 223| return true; 4039| 361| } _ZN4args11ValueReader23HasUnsignedNegativeSignIiEENSt3__19enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 3954| 361| { 3955| 361| return false; 3956| 361| } _ZN4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEEC2ERNS_5GroupERKS7_SD_ONS_7MatcherESD_b: 4139| 6.71k| ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), const bool extraError_ = false): ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, extraError_ ? Options::Single : Options::None) ------------------ | Branch (4139:241): [True: 0, False: 6.71k] ------------------ 4140| 6.71k| { 4141| 6.71k| } _ZN4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEEC2ERNS_5GroupERKS7_SD_ONS_7MatcherESD_NS_7OptionsE: 4134| 6.71k| ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), value(defaultValue_), defaultValue(defaultValue_) 4135| 6.71k| { 4136| 6.71k| group_.Add(*this); 4137| 6.71k| } _ZN4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEE5ResetEv: 4164| 6.71k| { 4165| 6.71k| ValueFlagBase::Reset(); 4166| 6.71k| value = defaultValue; 4167| 6.71k| } _ZNK4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEE16GetDefaultStringERKNS_10HelpParamsE: 4125| 26.8k| { 4126| 26.8k| return detail::ToString(defaultValue); 4127| 26.8k| } _ZN4args6detail8ToStringINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_9enable_ifIXsr21IsConvertableToStringIT_EE5valueES8_E4typeERKSA_: 1268| 107k| { 1269| 107k| std::ostringstream s; 1270| 107k| s << value; 1271| 107k| return s.str(); 1272| 107k| } _ZN4args11ValueReaderclINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_9enable_ifIXsr3std13is_assignableIT_S8_EE5valueEbE4typeERKS8_SE_RSA_: 4104| 6.73k| { 4105| 6.73k| destination = value; 4106| 6.73k| return true; 4107| 6.73k| } _ZN4args9ValueFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEED2Ev: 4147| 6.71k| virtual ~ValueFlag() {} _ZN4args13ValueFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEEC2ERNS_5GroupERKS7_SF_ONS_7MatcherERKNS1_6vectorIS7_NS5_IS7_EEEENS_7OptionsE: 4481| 6.71k| ValueFlagBase(name_, help_, std::move(matcher_), options_), values(defaultValues_), defaultValues(defaultValues_) 4482| 6.71k| { 4483| 6.71k| group_.Add(*this); 4484| 6.71k| } _ZN4args13ValueFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE5MatchERKNS_10EitherFlagE: 4552| 3.01k| { 4553| 3.01k| const bool wasMatched = Matched(); 4554| 3.01k| auto me = FlagBase::Match(arg); 4555| 3.01k| if (me && !wasMatched) ------------------ | Branch (4555:21): [True: 557, False: 2.45k] | Branch (4555:27): [True: 298, False: 259] ------------------ 4556| 298| { 4557| 298| values.clear(); 4558| 298| } 4559| 3.01k| return me; 4560| 3.01k| } _ZN4args13ValueFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE5ResetEv: 4546| 6.71k| { 4547| 6.71k| ValueFlagBase::Reset(); 4548| 6.71k| values = defaultValues; 4549| 6.71k| } _ZNK4args13ValueFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE4NameEv: 4541| 18.5k| { 4542| 18.5k| return name + std::string("..."); 4543| 18.5k| } _ZN4args13ValueFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE10ParseValueERKNS1_6vectorIS7_NS5_IS7_EEEE: 4489| 359| { 4490| 359| const std::string &value_ = values_.at(0); 4491| | 4492| 359| T v{}; 4493| |#ifdef ARGS_NOEXCEPT 4494| | if (!reader(name, value_, v)) 4495| | { 4496| | error = Error::Parse; 4497| | return; 4498| | } 4499| |#else 4500| 359| reader(name, value_, v); 4501| 359|#endif 4502| 359| values.insert(std::end(values), v); 4503| 359| } _ZN4args13ValueFlagListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEED2Ev: 4486| 6.71k| virtual ~ValueFlagList() {} _ZN4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEEC2ERNS_5GroupERKS7_SF_ONS_7MatcherERKNS1_13unordered_mapIS7_iNS1_4hashIS7_EENS1_8equal_toIS7_EENS5_INS1_4pairISE_iEEEEEERKib: 4626| 6.71k| MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map &map_, const T &defaultValue_ = T(), const bool extraError_ = false): MapFlag(group_, name_, help_, std::move(matcher_), map_, defaultValue_, extraError_ ? Options::Single : Options::None) ------------------ | Branch (4626:266): [True: 0, False: 6.71k] ------------------ 4627| 6.71k| { 4628| 6.71k| } _ZN4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEEC2ERNS_5GroupERKS7_SF_ONS_7MatcherERKNS1_13unordered_mapIS7_iNS1_4hashIS7_EENS1_8equal_toIS7_EENS5_INS1_4pairISE_iEEEEEERKiNS_7OptionsE: 4621| 6.71k| MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map &map_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), map(map_), value(defaultValue_), defaultValue(defaultValue_) 4622| 6.71k| { 4623| 6.71k| group_.Add(*this); 4624| 6.71k| } _ZN4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEE5ResetEv: 4703| 6.71k| { 4704| 6.71k| ValueFlagBase::Reset(); 4705| 6.71k| value = defaultValue; 4706| 6.71k| } _ZNK4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEE17GetChoicesStringsERKNS_10HelpParamsE: 4615| 26.8k| { 4616| 26.8k| return detail::MapKeysToStrings(map); 4617| 26.8k| } _ZN4args6detail16MapKeysToStringsINSt3__113unordered_mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4hashIS9_EENS2_8equal_toIS9_EENS7_INS2_4pairIKS9_iEEEEEEEENS2_6vectorIS9_NS7_IS9_EEEERKT_: 1299| 26.8k| { 1300| 26.8k| std::vector res; 1301| 26.8k| using K = typename std::decayfirst)>::type; 1302| 26.8k| if (IsConvertableToString::value) ------------------ | Branch (1302:17): [True: 26.8k, Folded] ------------------ 1303| 26.8k| { 1304| 26.8k| for (const auto &p : map) ------------------ | Branch (1304:36): [True: 80.5k, False: 26.8k] ------------------ 1305| 80.5k| { 1306| 80.5k| res.push_back(detail::ToString(p.first)); 1307| 80.5k| } 1308| | 1309| 26.8k| std::sort(res.begin(), res.end()); 1310| 26.8k| } 1311| 26.8k| return res; 1312| 26.8k| } _ZN4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEE10ParseValueERKNS1_6vectorIS7_NS5_IS7_EEEE: 4637| 180| { 4638| 180| const std::string &value_ = values_.at(0); 4639| | 4640| 180| K key{}; 4641| |#ifdef ARGS_NOEXCEPT 4642| | if (!reader(name, value_, key)) 4643| | { 4644| | error = Error::Parse; 4645| | return; 4646| | } 4647| |#else 4648| 180| reader(name, value_, key); 4649| 180|#endif 4650| 180| auto it = map.find(key); 4651| 180| if (it == std::end(map)) ------------------ | Branch (4651:21): [True: 155, False: 25] ------------------ 4652| 155| { 4653| 155| std::ostringstream problem; 4654| 155| problem << "Could not find key '" << key << "' in map for arg '" << name << "'"; 4655| |#ifdef ARGS_NOEXCEPT 4656| | error = Error::Map; 4657| | errorMsg = problem.str(); 4658| |#else 4659| 155| throw MapError(problem.str()); 4660| 155|#endif 4661| 155| } else 4662| 25| { 4663| 25| this->value = it->second; 4664| 25| } 4665| 180| } _ZN4args8MapErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 525| 155| MapError(const std::string &problem) : ParseError(problem) {} _ZN4args7MapFlagINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS_11ValueReaderENS_6detail13unordered_mapEED2Ev: 4634| 6.71k| virtual ~MapFlag() {} _ZN4args9ValueFlagIdNS_11ValueReaderEEC2ERNS_5GroupERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_ONS_7MatcherERKdb: 4139| 6.71k| ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), const bool extraError_ = false): ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, extraError_ ? Options::Single : Options::None) ------------------ | Branch (4139:241): [True: 0, False: 6.71k] ------------------ 4140| 6.71k| { 4141| 6.71k| } _ZN4args9ValueFlagIdNS_11ValueReaderEEC2ERNS_5GroupERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESD_ONS_7MatcherERKdNS_7OptionsE: 4134| 6.71k| ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), value(defaultValue_), defaultValue(defaultValue_) 4135| 6.71k| { 4136| 6.71k| group_.Add(*this); 4137| 6.71k| } _ZN4args9ValueFlagIdNS_11ValueReaderEE5ResetEv: 4164| 6.71k| { 4165| 6.71k| ValueFlagBase::Reset(); 4166| 6.71k| value = defaultValue; 4167| 6.71k| } _ZNK4args9ValueFlagIdNS_11ValueReaderEE16GetDefaultStringERKNS_10HelpParamsE: 4125| 26.8k| { 4126| 26.8k| return detail::ToString(defaultValue); 4127| 26.8k| } _ZN4args6detail8ToStringIdEENSt3__19enable_ifIXsr21IsConvertableToStringIT_EE5valueENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE4typeERKS4_: 1268| 26.8k| { 1269| 26.8k| std::ostringstream s; 1270| 26.8k| s << value; 1271| 26.8k| return s.str(); 1272| 26.8k| } _ZN4args9ValueFlagIdNS_11ValueReaderEE10ParseValueERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE: 4150| 183| { 4151| 183| const std::string &value_ = values_.at(0); 4152| | 4153| |#ifdef ARGS_NOEXCEPT 4154| | if (!reader(name, value_, this->value)) 4155| | { 4156| | error = Error::Parse; 4157| | } 4158| |#else 4159| 183| reader(name, value_, this->value); 4160| 183|#endif 4161| 183| } _ZN4args11ValueReaderclIdEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 183| { 4086| 183| const bool success = ParseNumericValue(value, destination); 4087| 183| if (!success) ------------------ | Branch (4087:17): [True: 38, False: 145] ------------------ 4088| 38| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 38| std::ostringstream problem; 4094| 38| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 38| throw ParseError(problem.str()); 4096| 38|#endif 4097| 38| } 4098| 145| return true; 4099| 183| } _ZN4args11ValueReader17ParseNumericValueIdEENSt3__19enable_ifIXoooooooontsr3std11is_integralIT_EE5valuesr3std7is_sameIS4_bEE5valuesr3std7is_sameIS4_cEE5valuesr3std7is_sameIS4_aEE5valuesr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 4050| 183| { 4051| 183| std::istringstream ss(value); 4052| | // Pin parsing to the C locale so that the decimal separator and 4053| | // thousands grouping behavior do not silently depend on whatever 4054| | // std::locale::global was last set to elsewhere in the process. 4055| | // Without this, e.g. "3.14" parses as 3 (with ".14" trailing) in 4056| | // any locale whose numpunct facet treats ',' as the decimal point. 4057| 183| ss.imbue(std::locale::classic()); 4058| 183| ss >> destination; 4059| 183| if (ss.fail()) ------------------ | Branch (4059:17): [True: 15, False: 168] ------------------ 4060| 15| { 4061| 15| return false; 4062| 15| } 4063| | 4064| | // Check for trailing garbage by attempting to extract any remaining characters. 4065| | // Do not use 'ss >> std::ws' followed by peek(), as std::ws can set failbit 4066| | // on EOF, causing false rejection of valid input. 4067| 168| char extra = '\0'; 4068| 168| ss >> std::ws >> extra; 4069| | // If extraction succeeded, there's trailing garbage (return false). 4070| | // If extraction failed due to EOF only (goodbit after ws extraction), it's valid (return true). 4071| | // If extraction failed for other reasons, it's invalid (return false). 4072| 168| if (ss.fail()) ------------------ | Branch (4072:17): [True: 145, False: 23] ------------------ 4073| 145| { 4074| | // Clear the failbit to check if EOF is the only issue 4075| 145| ss.clear(ss.rdstate() & ~std::ios::failbit); 4076| 145| return ss.eof(); 4077| 145| } 4078| | // Extraction succeeded, meaning there's trailing garbage 4079| 23| return false; 4080| 168| } _ZN4args10PositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEEC2ERNS_5GroupERKS7_SD_SD_NS_7OptionsE: 4894| 6.71k| Positional(Group &group_, const std::string &name_, const std::string &help_, const T &defaultValue_ = T(), Options options_ = {}): PositionalBase(name_, help_, options_), value(defaultValue_), defaultValue(defaultValue_) 4895| 6.71k| { 4896| 6.71k| group_.Add(*this); 4897| 6.71k| } _ZN4args14PositionalBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_NS_7OptionsE: 1601| 13.4k| PositionalBase(const std::string &name_, const std::string &help_, Options options_ = {}) : NamedBase(name_, help_, options_), ready(true) {} _ZN4args14PositionalBase5ResetEv: 1612| 13.4k| { 1613| 13.4k| matched = false; 1614| 13.4k| ready = true; 1615| |#ifdef ARGS_NOEXCEPT 1616| | error = Error::None; 1617| | errorMsg.clear(); 1618| |#endif 1619| 13.4k| } _ZNK4args14PositionalBase8ValidateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 1638| 7.07k| { 1639| 7.07k| if (IsRequired() && !Matched()) ------------------ | Branch (1639:21): [True: 0, False: 7.07k] | Branch (1639:37): [True: 0, False: 0] ------------------ 1640| 0| { 1641| 0| std::ostringstream problem; 1642| 0| problem << "Option '" << Name() << "' is required"; 1643| |#ifdef ARGS_NOEXCEPT 1644| | error = Error::Required; 1645| | errorMsg = problem.str(); 1646| |#else 1647| 0| throw RequiredError(problem.str()); 1648| 0|#endif 1649| 0| } 1650| 7.07k| } _ZN4args14PositionalBase17GetNextPositionalEv: 1622| 10.8k| { 1623| 10.8k| return Ready() ? this : nullptr; ------------------ | Branch (1623:24): [True: 6.19k, False: 4.61k] ------------------ 1624| 10.8k| } _ZN4args14PositionalBase5ReadyEv: 1605| 10.8k| { 1606| 10.8k| return ready; 1607| 10.8k| } _ZNK4args14PositionalBase13HasPositionalEv: 1627| 20.1k| { 1628| 20.1k| return true; 1629| 20.1k| } _ZNK4args14PositionalBase14GetProgramLineERKNS_10HelpParamsE: 1632| 53.6k| { 1633| 53.6k| return { IsRequired() ? params.proglineRequiredOpen + Name() + params.proglineRequiredClose ------------------ | Branch (1633:26): [True: 0, False: 53.6k] ------------------ 1634| 53.6k| : params.proglineNonrequiredOpen + Name() + params.proglineNonrequiredClose }; 1635| 53.6k| } _ZN4args10PositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEE5ResetEv: 4956| 6.71k| { 4957| 6.71k| PositionalBase::Reset(); 4958| 6.71k| value = defaultValue; 4959| 6.71k| } _ZN4args10PositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEE10ParseValueERKS7_: 4906| 1.58k| { 4907| |#ifdef ARGS_NOEXCEPT 4908| | if (!reader(name, value_, this->value)) 4909| | { 4910| | error = Error::Parse; 4911| | return; 4912| | } 4913| |#else 4914| 1.58k| reader(name, value_, this->value); 4915| 1.58k|#endif 4916| 1.58k| ready = false; 4917| 1.58k| matched = true; 4918| 1.58k| } _ZN4args10PositionalINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11ValueReaderEED2Ev: 4903| 6.71k| virtual ~Positional() {} _ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEEC2ERNS_5GroupERKS7_SF_RKNS1_6vectorIS7_NS5_IS7_EEEENS_7OptionsE: 4994| 6.71k| PositionalList(Group &group_, const std::string &name_, const std::string &help_, const Container &defaultValues_ = Container(), Options options_ = {}): PositionalBase(name_, help_, options_), values(defaultValues_), defaultValues(defaultValues_) 4995| 6.71k| { 4996| 6.71k| group_.Add(*this); 4997| 6.71k| } _ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE17GetNextPositionalEv: 5068| 4.61k| { 5069| 4.61k| const bool wasMatched = Matched(); 5070| 4.61k| auto me = PositionalBase::GetNextPositional(); 5071| 4.61k| if (me && !wasMatched) ------------------ | Branch (5071:21): [True: 4.61k, False: 0] | Branch (5071:27): [True: 1.19k, False: 3.41k] ------------------ 5072| 1.19k| { 5073| 1.19k| values.clear(); 5074| 1.19k| } 5075| 4.61k| return me; 5076| 4.61k| } _ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE5ResetEv: 5062| 6.71k| { 5063| 6.71k| PositionalBase::Reset(); 5064| 6.71k| values = defaultValues; 5065| 6.71k| } _ZNK4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE4NameEv: 5022| 53.6k| { 5023| 53.6k| return name + std::string("..."); 5024| 53.6k| } _ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEE10ParseValueERKS7_: 5006| 4.61k| { 5007| 4.61k| T v{}; 5008| |#ifdef ARGS_NOEXCEPT 5009| | if (!reader(name, value_, v)) 5010| | { 5011| | error = Error::Parse; 5012| | return; 5013| | } 5014| |#else 5015| 4.61k| reader(name, value_, v); 5016| 4.61k|#endif 5017| 4.61k| values.insert(std::end(values), v); 5018| 4.61k| matched = true; 5019| 4.61k| } _ZN4args14PositionalListINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_6detail6vectorENS_11ValueReaderEED2Ev: 5003| 6.71k| virtual ~PositionalList() {} LLVMFuzzerTestOneInput: 70| 6.71k|{ 71| 6.71k| FuzzedDataProvider fdp(data, size); 72| | 73| | // -- Schema, with fuzzer-varied text -------------------------------------- 74| 6.71k| args::ArgumentParser parser(fdp.ConsumeRandomLengthString(64), 75| 6.71k| fdp.ConsumeRandomLengthString(64)); 76| | 77| 6.71k| try 78| 6.71k| { 79| 6.71k| parser.LongPrefix(kLongPrefixes[fdp.ConsumeIntegralInRange(0, ArraySize(kLongPrefixes) - 1)]); 80| 6.71k| parser.ShortPrefix(kShortPrefixes[fdp.ConsumeIntegralInRange(0, ArraySize(kShortPrefixes) - 1)]); 81| 6.71k| parser.LongSeparator(kLongSeparators[fdp.ConsumeIntegralInRange(0, ArraySize(kLongSeparators) - 1)]); 82| 6.71k| parser.Terminator(kTerminators[fdp.ConsumeIntegralInRange(0, ArraySize(kTerminators) - 1)]); 83| 6.71k| } 84| 6.71k| catch (...) 85| 6.71k| { 86| 0| } 87| | 88| 6.71k| args::HelpFlag help(parser, "help", "Displays this help menu", {'h', "help"}); 89| | 90| 6.71k| args::Options flagOptions = args::Options::None; 91| 6.71k| switch (fdp.ConsumeIntegralInRange(0, 3)) 92| 6.71k| { 93| 962| case 1: ------------------ | Branch (93:9): [True: 962, False: 5.74k] ------------------ 94| 962| flagOptions = args::Options::HiddenFromDescription; 95| 962| break; 96| 1.05k| case 2: ------------------ | Branch (96:9): [True: 1.05k, False: 5.66k] ------------------ 97| 1.05k| flagOptions = args::Options::HiddenFromUsage; 98| 1.05k| break; 99| 1.32k| case 3: ------------------ | Branch (99:9): [True: 1.32k, False: 5.38k] ------------------ 100| 1.32k| flagOptions = args::Options::Hidden; 101| 1.32k| break; 102| 3.37k| default: ------------------ | Branch (102:9): [True: 3.37k, False: 3.33k] ------------------ 103| 3.37k| break; 104| 6.71k| } 105| | 106| 6.71k| args::Flag alpha(parser, "alpha", fdp.ConsumeRandomLengthString(64), {'a', "alpha"}, flagOptions); 107| 6.71k| args::CounterFlag beta(parser, "beta", fdp.ConsumeRandomLengthString(64), {'b', "beta"}, 0, flagOptions); 108| 6.71k| args::ValueFlag number(parser, "number", fdp.ConsumeRandomLengthString(64), {'n', "number"}, fdp.ConsumeIntegral()); 109| 6.71k| args::ValueFlag text(parser, "text", fdp.ConsumeRandomLengthString(64), {"text"}, fdp.ConsumeRandomLengthString(24)); 110| 6.71k| args::ValueFlagList words(parser, "words", fdp.ConsumeRandomLengthString(64), {'w', "words"}); 111| | 112| | // Must be std::unordered_map: MapFlag's Map template parameter defaults 113| | // to args::detail::unordered_map and std::map does not convert. 114| 6.71k| const std::unordered_map choices{{"red", 1}, {"green", 2}, {"blue", 3}}; 115| 6.71k| args::MapFlag colour(parser, "colour", fdp.ConsumeRandomLengthString(64), {'c', "colour"}, choices); 116| | 117| 6.71k| args::Group group(parser, fdp.ConsumeRandomLengthString(32), 118| 6.71k| kGroupValidators[fdp.ConsumeIntegralInRange(0, ArraySize(kGroupValidators) - 1)]); 119| 6.71k| args::ValueFlag gamma(group, "gamma", fdp.ConsumeRandomLengthString(64), {'g', "gamma"}, 0.5); 120| 6.71k| args::Flag delta(group, "delta", fdp.ConsumeRandomLengthString(64), {'d'}); 121| | 122| 6.71k| args::Positional source(parser, "source", fdp.ConsumeRandomLengthString(64)); 123| 6.71k| args::PositionalList extra(parser, "extra", fdp.ConsumeRandomLengthString(64)); 124| | 125| | // -- Every HelpParams field, including pathological narrow widths --------- 126| 6.71k| parser.helpParams.width = fdp.ConsumeIntegralInRange(0, 300); 127| 6.71k| parser.helpParams.progindent = fdp.ConsumeIntegralInRange(0, 16); 128| 6.71k| parser.helpParams.progtailindent = fdp.ConsumeIntegralInRange(0, 16); 129| 6.71k| parser.helpParams.descriptionindent = fdp.ConsumeIntegralInRange(0, 16); 130| 6.71k| parser.helpParams.flagindent = fdp.ConsumeIntegralInRange(0, 24); 131| 6.71k| parser.helpParams.helpindent = fdp.ConsumeIntegralInRange(0, 96); 132| 6.71k| parser.helpParams.eachgroupindent = fdp.ConsumeIntegralInRange(0, 8); 133| 6.71k| parser.helpParams.gutter = fdp.ConsumeIntegralInRange(0, 8); 134| 6.71k| parser.helpParams.showTerminator = fdp.ConsumeBool(); 135| 6.71k| parser.helpParams.showProglineOptions = fdp.ConsumeBool(); 136| 6.71k| parser.helpParams.showProglinePositionals = fdp.ConsumeBool(); 137| 6.71k| parser.helpParams.showCommandChildren = fdp.ConsumeBool(); 138| 6.71k| parser.helpParams.showCommandFullHelp = fdp.ConsumeBool(); 139| 6.71k| parser.helpParams.proglineShowFlags = fdp.ConsumeBool(); 140| 6.71k| parser.helpParams.proglinePreferShortFlags = fdp.ConsumeBool(); 141| 6.71k| parser.helpParams.useValueNameOnce = fdp.ConsumeBool(); 142| 6.71k| parser.helpParams.showValueName = fdp.ConsumeBool(); 143| 6.71k| parser.helpParams.addNewlineBeforeDescription = fdp.ConsumeBool(); 144| 6.71k| parser.helpParams.addChoices = fdp.ConsumeBool(); 145| 6.71k| parser.helpParams.addDefault = fdp.ConsumeBool(); 146| 6.71k| parser.helpParams.programName = fdp.ConsumeRandomLengthString(24); 147| 6.71k| parser.helpParams.usageString = fdp.ConsumeRandomLengthString(24); 148| 6.71k| parser.helpParams.optionsString = fdp.ConsumeRandomLengthString(24); 149| 6.71k| parser.helpParams.proglineOptions = fdp.ConsumeRandomLengthString(16); 150| 6.71k| parser.helpParams.proglineCommand = fdp.ConsumeRandomLengthString(16); 151| 6.71k| parser.helpParams.valueOpen = fdp.ConsumeRandomLengthString(8); 152| 6.71k| parser.helpParams.valueClose = fdp.ConsumeRandomLengthString(8); 153| 6.71k| parser.helpParams.choiceString = fdp.ConsumeRandomLengthString(16); 154| 6.71k| parser.helpParams.defaultString = fdp.ConsumeRandomLengthString(16); 155| | 156| | // -- Parse a token mix so rendering runs against varied matched state ----- 157| 6.71k| const size_t tokenCount = fdp.ConsumeIntegralInRange(0, 8); 158| 6.71k| std::vector argv; 159| 6.71k| argv.reserve(tokenCount); 160| 20.5k| for (size_t i = 0; i < tokenCount; ++i) ------------------ | Branch (160:24): [True: 13.7k, False: 6.71k] ------------------ 161| 13.7k| { 162| 13.7k| if (fdp.ConsumeBool()) ------------------ | Branch (162:13): [True: 4.14k, False: 9.64k] ------------------ 163| 4.14k| { 164| 4.14k| argv.emplace_back(kTokens[fdp.ConsumeIntegralInRange(0, ArraySize(kTokens) - 1)]); 165| 4.14k| } 166| 9.64k| else 167| 9.64k| { 168| 9.64k| argv.emplace_back(fdp.ConsumeRandomLengthString(16)); 169| 9.64k| } 170| 13.7k| } 171| | 172| 6.71k| try 173| 6.71k| { 174| 6.71k| parser.ParseArgs(argv); 175| 6.71k| } 176| 6.71k| catch (...) 177| 6.71k| { 178| 3.17k| } 179| | 180| | // -- Render through every help path ---------------------------------------- 181| 6.71k| g_sink += parser.Help().size(); 182| | 183| 6.71k| std::ostringstream stream; 184| 6.71k| stream << parser; 185| 6.71k| g_sink += stream.str().size(); 186| | 187| 6.71k| g_sink += parser.GetDescription(parser.helpParams, 0).size(); 188| 6.71k| g_sink += parser.GetProgramLine(parser.helpParams).size(); 189| | 190| | // Re-render with flipped boolean toggles to hit the alternate branches. 191| 6.71k| parser.helpParams.addChoices = !parser.helpParams.addChoices; 192| 6.71k| parser.helpParams.addDefault = !parser.helpParams.addDefault; 193| 6.71k| parser.helpParams.addNewlineBeforeDescription = !parser.helpParams.addNewlineBeforeDescription; 194| 6.71k| g_sink += parser.Help().size(); 195| | 196| 6.71k| return 0; 197| 6.71k|} help_render_fuzzer.cpp:_ZN12_GLOBAL__N_19ArraySizeIKPKcLm4EEEmRAT0__T_: 63| 13.4k|{ 64| 13.4k| return N; 65| 13.4k|} help_render_fuzzer.cpp:_ZN12_GLOBAL__N_19ArraySizeIKPKcLm3EEEmRAT0__T_: 63| 13.4k|{ 64| 13.4k| return N; 65| 13.4k|} help_render_fuzzer.cpp:_ZN12_GLOBAL__N_19ArraySizeIKPFbRKN4args5GroupEELm5EEEmRAT0__T_: 63| 6.71k|{ 64| 6.71k| return N; 65| 6.71k|} help_render_fuzzer.cpp:_ZN12_GLOBAL__N_19ArraySizeIKPKcLm27EEEmRAT0__T_: 63| 4.14k|{ 64| 4.14k| return N; 65| 4.14k|}