_ZN4args11ValueReaderclIbEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 489, False: 8] ------------------ 4088| 489| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 489| std::ostringstream problem; 4094| 489| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 489| throw ParseError(problem.str()); 4096| 489|#endif 4097| 489| } 4098| 8| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIbEENSt3__19enable_ifIXoooooooontsr3std11is_integralIT_EE5valuesr3std7is_sameIS4_bEE5valuesr3std7is_sameIS4_cEE5valuesr3std7is_sameIS4_aEE5valuesr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 4050| 497| { 4051| 497| 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| 497| ss.imbue(std::locale::classic()); 4058| 497| ss >> destination; 4059| 497| if (ss.fail()) ------------------ | Branch (4059:17): [True: 317, False: 180] ------------------ 4060| 317| { 4061| 317| return false; 4062| 317| } 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| 180| char extra = '\0'; 4068| 180| 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| 180| if (ss.fail()) ------------------ | Branch (4072:17): [True: 8, False: 172] ------------------ 4073| 8| { 4074| | // Clear the failbit to check if EOF is the only issue 4075| 8| ss.clear(ss.rdstate() & ~std::ios::failbit); 4076| 8| return ss.eof(); 4077| 8| } 4078| | // Extraction succeeded, meaning there's trailing garbage 4079| 172| return false; 4080| 180| } _ZN4args10ParseErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 498| 4.42k| ParseError(const std::string &problem) : Error(problem) {} _ZN4args5ErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 480| 4.42k| Error(const std::string &problem) : std::runtime_error(problem) {} _ZN4args11ValueReaderclIcEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 465, False: 32] ------------------ 4088| 465| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 465| std::ostringstream problem; 4094| 465| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 465| throw ParseError(problem.str()); 4096| 465|#endif 4097| 465| } 4098| 32| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIcEENSt3__19enable_ifIXoooooooontsr3std11is_integralIT_EE5valuesr3std7is_sameIS4_bEE5valuesr3std7is_sameIS4_cEE5valuesr3std7is_sameIS4_aEE5valuesr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 4050| 497| { 4051| 497| 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| 497| ss.imbue(std::locale::classic()); 4058| 497| ss >> destination; 4059| 497| if (ss.fail()) ------------------ | Branch (4059:17): [True: 6, False: 491] ------------------ 4060| 6| { 4061| 6| return false; 4062| 6| } 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| 491| char extra = '\0'; 4068| 491| 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| 491| if (ss.fail()) ------------------ | Branch (4072:17): [True: 32, False: 459] ------------------ 4073| 32| { 4074| | // Clear the failbit to check if EOF is the only issue 4075| 32| ss.clear(ss.rdstate() & ~std::ios::failbit); 4076| 32| return ss.eof(); 4077| 32| } 4078| | // Extraction succeeded, meaning there's trailing garbage 4079| 459| return false; 4080| 491| } _ZN4args11ValueReaderclIaEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 465, False: 32] ------------------ 4088| 465| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 465| std::ostringstream problem; 4094| 465| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 465| throw ParseError(problem.str()); 4096| 465|#endif 4097| 465| } 4098| 32| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIaEENSt3__19enable_ifIXoooooooontsr3std11is_integralIT_EE5valuesr3std7is_sameIS4_bEE5valuesr3std7is_sameIS4_cEE5valuesr3std7is_sameIS4_aEE5valuesr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 4050| 497| { 4051| 497| 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| 497| ss.imbue(std::locale::classic()); 4058| 497| ss >> destination; 4059| 497| if (ss.fail()) ------------------ | Branch (4059:17): [True: 6, False: 491] ------------------ 4060| 6| { 4061| 6| return false; 4062| 6| } 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| 491| char extra = '\0'; 4068| 491| 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| 491| if (ss.fail()) ------------------ | Branch (4072:17): [True: 32, False: 459] ------------------ 4073| 32| { 4074| | // Clear the failbit to check if EOF is the only issue 4075| 32| ss.clear(ss.rdstate() & ~std::ios::failbit); 4076| 32| return ss.eof(); 4077| 32| } 4078| | // Extraction succeeded, meaning there's trailing garbage 4079| 459| return false; 4080| 491| } _ZN4args11ValueReaderclIhEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 465, False: 32] ------------------ 4088| 465| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 465| std::ostringstream problem; 4094| 465| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 465| throw ParseError(problem.str()); 4096| 465|#endif 4097| 465| } 4098| 32| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIhEENSt3__19enable_ifIXoooooooontsr3std11is_integralIT_EE5valuesr3std7is_sameIS4_bEE5valuesr3std7is_sameIS4_cEE5valuesr3std7is_sameIS4_aEE5valuesr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 4050| 497| { 4051| 497| 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| 497| ss.imbue(std::locale::classic()); 4058| 497| ss >> destination; 4059| 497| if (ss.fail()) ------------------ | Branch (4059:17): [True: 6, False: 491] ------------------ 4060| 6| { 4061| 6| return false; 4062| 6| } 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| 491| char extra = '\0'; 4068| 491| 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| 491| if (ss.fail()) ------------------ | Branch (4072:17): [True: 32, False: 459] ------------------ 4073| 32| { 4074| | // Clear the failbit to check if EOF is the only issue 4075| 32| ss.clear(ss.rdstate() & ~std::ios::failbit); 4076| 32| return ss.eof(); 4077| 32| } 4078| | // Extraction succeeded, meaning there's trailing garbage 4079| 459| return false; 4080| 491| } _ZN4args11ValueReaderclIsEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 436, False: 61] ------------------ 4088| 436| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 436| std::ostringstream problem; 4094| 436| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 436| throw ParseError(problem.str()); 4096| 436|#endif 4097| 436| } 4098| 61| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIsEENSt3__19enable_ifIXaaaaaaaasr3std11is_integralIT_EE5valuentsr3std7is_sameIS4_bEE5valuentsr3std7is_sameIS4_cEE5valuentsr3std7is_sameIS4_aEE5valuentsr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 3968| 497| { 3969| 497| if (HasUnsignedNegativeSign(value)) ------------------ | Branch (3969:17): [True: 0, False: 497] ------------------ 3970| 0| { 3971| 0| return false; 3972| 0| } 3973| | 3974| 497| 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| 497| 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| 497| const int saved_errno = errno; 3989| 497| errno = 0; 3990| | 3991| 497| char *end = nullptr; 3992| | 3993| 497| if (std::is_unsigned::value) ------------------ | Branch (3993:17): [Folded, False: 497] ------------------ 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| 497| else 4015| 497| { 4016| 497| const long long parsed = std::strtoll(begin, &end, 0); 4017| 497| if (end == begin) ------------------ | Branch (4017:21): [True: 51, False: 446] ------------------ 4018| 51| { 4019| 51| errno = saved_errno; 4020| 51| return false; 4021| 51| } 4022| 851| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4022:24): [True: 445, False: 406] | Branch (4022:39): [True: 405, False: 40] ------------------ 4023| 405| { 4024| 405| ++end; 4025| 405| } 4026| 446| if (end != stop || errno == ERANGE || ------------------ | Branch (4026:21): [True: 40, False: 406] | Branch (4026:36): [True: 55, False: 351] ------------------ 4027| 351| parsed < static_cast(std::numeric_limits::min()) || ------------------ | Branch (4027:21): [True: 123, False: 228] ------------------ 4028| 228| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4028:21): [True: 167, False: 61] ------------------ 4029| 385| { 4030| 385| errno = saved_errno; 4031| 385| return false; 4032| 385| } 4033| | 4034| 61| destination = static_cast(parsed); 4035| 61| } 4036| | 4037| 497| errno = saved_errno; 4038| 61| return true; 4039| 497| } _ZN4args11ValueReader23HasUnsignedNegativeSignIsEENSt3__19enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 3954| 497| { 3955| 497| return false; 3956| 497| } _ZN4args11ValueReaderclIiEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 306, False: 191] ------------------ 4088| 306| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 306| std::ostringstream problem; 4094| 306| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 306| throw ParseError(problem.str()); 4096| 306|#endif 4097| 306| } 4098| 191| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIiEENSt3__19enable_ifIXaaaaaaaasr3std11is_integralIT_EE5valuentsr3std7is_sameIS4_bEE5valuentsr3std7is_sameIS4_cEE5valuentsr3std7is_sameIS4_aEE5valuentsr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 3968| 497| { 3969| 497| if (HasUnsignedNegativeSign(value)) ------------------ | Branch (3969:17): [True: 0, False: 497] ------------------ 3970| 0| { 3971| 0| return false; 3972| 0| } 3973| | 3974| 497| 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| 497| 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| 497| const int saved_errno = errno; 3989| 497| errno = 0; 3990| | 3991| 497| char *end = nullptr; 3992| | 3993| 497| if (std::is_unsigned::value) ------------------ | Branch (3993:17): [Folded, False: 497] ------------------ 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| 497| else 4015| 497| { 4016| 497| const long long parsed = std::strtoll(begin, &end, 0); 4017| 497| if (end == begin) ------------------ | Branch (4017:21): [True: 51, False: 446] ------------------ 4018| 51| { 4019| 51| errno = saved_errno; 4020| 51| return false; 4021| 51| } 4022| 851| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4022:24): [True: 445, False: 406] | Branch (4022:39): [True: 405, False: 40] ------------------ 4023| 405| { 4024| 405| ++end; 4025| 405| } 4026| 446| if (end != stop || errno == ERANGE || ------------------ | Branch (4026:21): [True: 40, False: 406] | Branch (4026:36): [True: 55, False: 351] ------------------ 4027| 351| parsed < static_cast(std::numeric_limits::min()) || ------------------ | Branch (4027:21): [True: 67, False: 284] ------------------ 4028| 284| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4028:21): [True: 93, False: 191] ------------------ 4029| 255| { 4030| 255| errno = saved_errno; 4031| 255| return false; 4032| 255| } 4033| | 4034| 191| destination = static_cast(parsed); 4035| 191| } 4036| | 4037| 497| errno = saved_errno; 4038| 191| return true; 4039| 497| } _ZN4args11ValueReader23HasUnsignedNegativeSignIiEENSt3__19enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 3954| 497| { 3955| 497| return false; 3956| 497| } _ZN4args11ValueReaderclIlEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 146, False: 351] ------------------ 4088| 146| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 146| std::ostringstream problem; 4094| 146| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 146| throw ParseError(problem.str()); 4096| 146|#endif 4097| 146| } 4098| 351| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIlEENSt3__19enable_ifIXaaaaaaaasr3std11is_integralIT_EE5valuentsr3std7is_sameIS4_bEE5valuentsr3std7is_sameIS4_cEE5valuentsr3std7is_sameIS4_aEE5valuentsr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 3968| 497| { 3969| 497| if (HasUnsignedNegativeSign(value)) ------------------ | Branch (3969:17): [True: 0, False: 497] ------------------ 3970| 0| { 3971| 0| return false; 3972| 0| } 3973| | 3974| 497| 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| 497| 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| 497| const int saved_errno = errno; 3989| 497| errno = 0; 3990| | 3991| 497| char *end = nullptr; 3992| | 3993| 497| if (std::is_unsigned::value) ------------------ | Branch (3993:17): [Folded, False: 497] ------------------ 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| 497| else 4015| 497| { 4016| 497| const long long parsed = std::strtoll(begin, &end, 0); 4017| 497| if (end == begin) ------------------ | Branch (4017:21): [True: 51, False: 446] ------------------ 4018| 51| { 4019| 51| errno = saved_errno; 4020| 51| return false; 4021| 51| } 4022| 851| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4022:24): [True: 445, False: 406] | Branch (4022:39): [True: 405, False: 40] ------------------ 4023| 405| { 4024| 405| ++end; 4025| 405| } 4026| 446| if (end != stop || errno == ERANGE || ------------------ | Branch (4026:21): [True: 40, False: 406] | Branch (4026:36): [True: 55, False: 351] ------------------ 4027| 351| parsed < static_cast(std::numeric_limits::min()) || ------------------ | Branch (4027:21): [True: 0, False: 351] ------------------ 4028| 351| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4028:21): [True: 0, False: 351] ------------------ 4029| 95| { 4030| 95| errno = saved_errno; 4031| 95| return false; 4032| 95| } 4033| | 4034| 351| destination = static_cast(parsed); 4035| 351| } 4036| | 4037| 497| errno = saved_errno; 4038| 351| return true; 4039| 497| } _ZN4args11ValueReader23HasUnsignedNegativeSignIlEENSt3__19enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 3954| 497| { 3955| 497| return false; 3956| 497| } _ZN4args11ValueReaderclIxEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 146, False: 351] ------------------ 4088| 146| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 146| std::ostringstream problem; 4094| 146| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 146| throw ParseError(problem.str()); 4096| 146|#endif 4097| 146| } 4098| 351| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIxEENSt3__19enable_ifIXaaaaaaaasr3std11is_integralIT_EE5valuentsr3std7is_sameIS4_bEE5valuentsr3std7is_sameIS4_cEE5valuentsr3std7is_sameIS4_aEE5valuentsr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 3968| 497| { 3969| 497| if (HasUnsignedNegativeSign(value)) ------------------ | Branch (3969:17): [True: 0, False: 497] ------------------ 3970| 0| { 3971| 0| return false; 3972| 0| } 3973| | 3974| 497| 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| 497| 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| 497| const int saved_errno = errno; 3989| 497| errno = 0; 3990| | 3991| 497| char *end = nullptr; 3992| | 3993| 497| if (std::is_unsigned::value) ------------------ | Branch (3993:17): [Folded, False: 497] ------------------ 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| 497| else 4015| 497| { 4016| 497| const long long parsed = std::strtoll(begin, &end, 0); 4017| 497| if (end == begin) ------------------ | Branch (4017:21): [True: 51, False: 446] ------------------ 4018| 51| { 4019| 51| errno = saved_errno; 4020| 51| return false; 4021| 51| } 4022| 851| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4022:24): [True: 445, False: 406] | Branch (4022:39): [True: 405, False: 40] ------------------ 4023| 405| { 4024| 405| ++end; 4025| 405| } 4026| 446| if (end != stop || errno == ERANGE || ------------------ | Branch (4026:21): [True: 40, False: 406] | Branch (4026:36): [True: 55, False: 351] ------------------ 4027| 351| parsed < static_cast(std::numeric_limits::min()) || ------------------ | Branch (4027:21): [True: 0, False: 351] ------------------ 4028| 351| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4028:21): [True: 0, False: 351] ------------------ 4029| 95| { 4030| 95| errno = saved_errno; 4031| 95| return false; 4032| 95| } 4033| | 4034| 351| destination = static_cast(parsed); 4035| 351| } 4036| | 4037| 497| errno = saved_errno; 4038| 351| return true; 4039| 497| } _ZN4args11ValueReader23HasUnsignedNegativeSignIxEENSt3__19enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 3954| 497| { 3955| 497| return false; 3956| 497| } _ZN4args11ValueReaderclItEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 434, False: 63] ------------------ 4088| 434| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 434| std::ostringstream problem; 4094| 434| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 434| throw ParseError(problem.str()); 4096| 434|#endif 4097| 434| } 4098| 63| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueItEENSt3__19enable_ifIXaaaaaaaasr3std11is_integralIT_EE5valuentsr3std7is_sameIS4_bEE5valuentsr3std7is_sameIS4_cEE5valuentsr3std7is_sameIS4_aEE5valuentsr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 3968| 497| { 3969| 497| if (HasUnsignedNegativeSign(value)) ------------------ | Branch (3969:17): [True: 146, False: 351] ------------------ 3970| 146| { 3971| 146| return false; 3972| 146| } 3973| | 3974| 351| 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| 351| 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| 351| const int saved_errno = errno; 3989| 351| errno = 0; 3990| | 3991| 351| char *end = nullptr; 3992| | 3993| 351| if (std::is_unsigned::value) ------------------ | Branch (3993:17): [True: 351, Folded] ------------------ 3994| 351| { 3995| 351| const unsigned long long parsed = std::strtoull(begin, &end, 0); 3996| 351| if (end == begin) ------------------ | Branch (3996:21): [True: 49, False: 302] ------------------ 3997| 49| { 3998| 49| errno = saved_errno; 3999| 49| return false; 4000| 49| } 4001| 707| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4001:24): [True: 441, False: 266] | Branch (4001:39): [True: 405, False: 36] ------------------ 4002| 405| { 4003| 405| ++end; 4004| 405| } 4005| 302| if (end != stop || errno == ERANGE || ------------------ | Branch (4005:21): [True: 36, False: 266] | Branch (4005:36): [True: 1, False: 265] ------------------ 4006| 265| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4006:21): [True: 202, False: 63] ------------------ 4007| 239| { 4008| 239| errno = saved_errno; 4009| 239| return false; 4010| 239| } 4011| | 4012| 63| destination = static_cast(parsed); 4013| 63| } 4014| 0| else 4015| 0| { 4016| 0| const long long parsed = std::strtoll(begin, &end, 0); 4017| 0| if (end == begin) ------------------ | Branch (4017:21): [True: 0, False: 0] ------------------ 4018| 0| { 4019| 0| errno = saved_errno; 4020| 0| return false; 4021| 0| } 4022| 0| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4022:24): [True: 0, False: 0] | Branch (4022:39): [True: 0, False: 0] ------------------ 4023| 0| { 4024| 0| ++end; 4025| 0| } 4026| 0| if (end != stop || errno == ERANGE || ------------------ | Branch (4026:21): [True: 0, False: 0] | Branch (4026:36): [True: 0, False: 0] ------------------ 4027| 0| parsed < static_cast(std::numeric_limits::min()) || ------------------ | Branch (4027:21): [True: 0, False: 0] ------------------ 4028| 0| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4028:21): [True: 0, False: 0] ------------------ 4029| 0| { 4030| 0| errno = saved_errno; 4031| 0| return false; 4032| 0| } 4033| | 4034| 0| destination = static_cast(parsed); 4035| 0| } 4036| | 4037| 351| errno = saved_errno; 4038| 63| return true; 4039| 351| } _ZN4args11ValueReader23HasUnsignedNegativeSignItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valuesr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 3942| 497| { 3943| 497| const auto firstNonSpace = std::find_if_not(value.begin(), value.end(), [](char c) 3944| 497| { 3945| 497| return std::isspace(static_cast(c)) != 0; 3946| 497| }); 3947| | 3948| 497| return firstNonSpace != value.end() && *firstNonSpace == '-'; ------------------ | Branch (3948:20): [True: 491, False: 6] | Branch (3948:52): [True: 146, False: 345] ------------------ 3949| 497| } _ZZN4args11ValueReader23HasUnsignedNegativeSignItEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valuesr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENKUlcE_clEc: 3944| 843| { 3945| 843| return std::isspace(static_cast(c)) != 0; 3946| 843| }); _ZN4args11ValueReaderclIjEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 345, False: 152] ------------------ 4088| 345| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 345| std::ostringstream problem; 4094| 345| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 345| throw ParseError(problem.str()); 4096| 345|#endif 4097| 345| } 4098| 152| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIjEENSt3__19enable_ifIXaaaaaaaasr3std11is_integralIT_EE5valuentsr3std7is_sameIS4_bEE5valuentsr3std7is_sameIS4_cEE5valuentsr3std7is_sameIS4_aEE5valuentsr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 3968| 497| { 3969| 497| if (HasUnsignedNegativeSign(value)) ------------------ | Branch (3969:17): [True: 146, False: 351] ------------------ 3970| 146| { 3971| 146| return false; 3972| 146| } 3973| | 3974| 351| 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| 351| 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| 351| const int saved_errno = errno; 3989| 351| errno = 0; 3990| | 3991| 351| char *end = nullptr; 3992| | 3993| 351| if (std::is_unsigned::value) ------------------ | Branch (3993:17): [True: 351, Folded] ------------------ 3994| 351| { 3995| 351| const unsigned long long parsed = std::strtoull(begin, &end, 0); 3996| 351| if (end == begin) ------------------ | Branch (3996:21): [True: 49, False: 302] ------------------ 3997| 49| { 3998| 49| errno = saved_errno; 3999| 49| return false; 4000| 49| } 4001| 707| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4001:24): [True: 441, False: 266] | Branch (4001:39): [True: 405, False: 36] ------------------ 4002| 405| { 4003| 405| ++end; 4004| 405| } 4005| 302| if (end != stop || errno == ERANGE || ------------------ | Branch (4005:21): [True: 36, False: 266] | Branch (4005:36): [True: 1, False: 265] ------------------ 4006| 265| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4006:21): [True: 113, False: 152] ------------------ 4007| 150| { 4008| 150| errno = saved_errno; 4009| 150| return false; 4010| 150| } 4011| | 4012| 152| destination = static_cast(parsed); 4013| 152| } 4014| 0| else 4015| 0| { 4016| 0| const long long parsed = std::strtoll(begin, &end, 0); 4017| 0| if (end == begin) ------------------ | Branch (4017:21): [True: 0, False: 0] ------------------ 4018| 0| { 4019| 0| errno = saved_errno; 4020| 0| return false; 4021| 0| } 4022| 0| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4022:24): [True: 0, False: 0] | Branch (4022:39): [True: 0, False: 0] ------------------ 4023| 0| { 4024| 0| ++end; 4025| 0| } 4026| 0| if (end != stop || errno == ERANGE || ------------------ | Branch (4026:21): [True: 0, False: 0] | Branch (4026:36): [True: 0, False: 0] ------------------ 4027| 0| parsed < static_cast(std::numeric_limits::min()) || ------------------ | Branch (4027:21): [True: 0, False: 0] ------------------ 4028| 0| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4028:21): [True: 0, False: 0] ------------------ 4029| 0| { 4030| 0| errno = saved_errno; 4031| 0| return false; 4032| 0| } 4033| | 4034| 0| destination = static_cast(parsed); 4035| 0| } 4036| | 4037| 351| errno = saved_errno; 4038| 152| return true; 4039| 351| } _ZN4args11ValueReader23HasUnsignedNegativeSignIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valuesr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 3942| 497| { 3943| 497| const auto firstNonSpace = std::find_if_not(value.begin(), value.end(), [](char c) 3944| 497| { 3945| 497| return std::isspace(static_cast(c)) != 0; 3946| 497| }); 3947| | 3948| 497| return firstNonSpace != value.end() && *firstNonSpace == '-'; ------------------ | Branch (3948:20): [True: 491, False: 6] | Branch (3948:52): [True: 146, False: 345] ------------------ 3949| 497| } _ZZN4args11ValueReader23HasUnsignedNegativeSignIjEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valuesr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENKUlcE_clEc: 3944| 843| { 3945| 843| return std::isspace(static_cast(c)) != 0; 3946| 843| }); _ZN4args11ValueReaderclImEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 232, False: 265] ------------------ 4088| 232| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 232| std::ostringstream problem; 4094| 232| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 232| throw ParseError(problem.str()); 4096| 232|#endif 4097| 232| } 4098| 265| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueImEENSt3__19enable_ifIXaaaaaaaasr3std11is_integralIT_EE5valuentsr3std7is_sameIS4_bEE5valuentsr3std7is_sameIS4_cEE5valuentsr3std7is_sameIS4_aEE5valuentsr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 3968| 497| { 3969| 497| if (HasUnsignedNegativeSign(value)) ------------------ | Branch (3969:17): [True: 146, False: 351] ------------------ 3970| 146| { 3971| 146| return false; 3972| 146| } 3973| | 3974| 351| 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| 351| 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| 351| const int saved_errno = errno; 3989| 351| errno = 0; 3990| | 3991| 351| char *end = nullptr; 3992| | 3993| 351| if (std::is_unsigned::value) ------------------ | Branch (3993:17): [True: 351, Folded] ------------------ 3994| 351| { 3995| 351| const unsigned long long parsed = std::strtoull(begin, &end, 0); 3996| 351| if (end == begin) ------------------ | Branch (3996:21): [True: 49, False: 302] ------------------ 3997| 49| { 3998| 49| errno = saved_errno; 3999| 49| return false; 4000| 49| } 4001| 707| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4001:24): [True: 441, False: 266] | Branch (4001:39): [True: 405, False: 36] ------------------ 4002| 405| { 4003| 405| ++end; 4004| 405| } 4005| 302| if (end != stop || errno == ERANGE || ------------------ | Branch (4005:21): [True: 36, False: 266] | Branch (4005:36): [True: 1, False: 265] ------------------ 4006| 265| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4006:21): [True: 0, False: 265] ------------------ 4007| 37| { 4008| 37| errno = saved_errno; 4009| 37| return false; 4010| 37| } 4011| | 4012| 265| destination = static_cast(parsed); 4013| 265| } 4014| 0| else 4015| 0| { 4016| 0| const long long parsed = std::strtoll(begin, &end, 0); 4017| 0| if (end == begin) ------------------ | Branch (4017:21): [True: 0, False: 0] ------------------ 4018| 0| { 4019| 0| errno = saved_errno; 4020| 0| return false; 4021| 0| } 4022| 0| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4022:24): [True: 0, False: 0] | Branch (4022:39): [True: 0, False: 0] ------------------ 4023| 0| { 4024| 0| ++end; 4025| 0| } 4026| 0| if (end != stop || errno == ERANGE || ------------------ | Branch (4026:21): [True: 0, False: 0] | Branch (4026:36): [True: 0, False: 0] ------------------ 4027| 0| parsed < static_cast(std::numeric_limits::min()) || ------------------ | Branch (4027:21): [True: 0, False: 0] ------------------ 4028| 0| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4028:21): [True: 0, False: 0] ------------------ 4029| 0| { 4030| 0| errno = saved_errno; 4031| 0| return false; 4032| 0| } 4033| | 4034| 0| destination = static_cast(parsed); 4035| 0| } 4036| | 4037| 351| errno = saved_errno; 4038| 265| return true; 4039| 351| } _ZN4args11ValueReader23HasUnsignedNegativeSignImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valuesr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 3942| 497| { 3943| 497| const auto firstNonSpace = std::find_if_not(value.begin(), value.end(), [](char c) 3944| 497| { 3945| 497| return std::isspace(static_cast(c)) != 0; 3946| 497| }); 3947| | 3948| 497| return firstNonSpace != value.end() && *firstNonSpace == '-'; ------------------ | Branch (3948:20): [True: 491, False: 6] | Branch (3948:52): [True: 146, False: 345] ------------------ 3949| 497| } _ZZN4args11ValueReader23HasUnsignedNegativeSignImEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valuesr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENKUlcE_clEc: 3944| 843| { 3945| 843| return std::isspace(static_cast(c)) != 0; 3946| 843| }); _ZN4args11ValueReaderclIyEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 232, False: 265] ------------------ 4088| 232| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 232| std::ostringstream problem; 4094| 232| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 232| throw ParseError(problem.str()); 4096| 232|#endif 4097| 232| } 4098| 265| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIyEENSt3__19enable_ifIXaaaaaaaasr3std11is_integralIT_EE5valuentsr3std7is_sameIS4_bEE5valuentsr3std7is_sameIS4_cEE5valuentsr3std7is_sameIS4_aEE5valuentsr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 3968| 497| { 3969| 497| if (HasUnsignedNegativeSign(value)) ------------------ | Branch (3969:17): [True: 146, False: 351] ------------------ 3970| 146| { 3971| 146| return false; 3972| 146| } 3973| | 3974| 351| 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| 351| 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| 351| const int saved_errno = errno; 3989| 351| errno = 0; 3990| | 3991| 351| char *end = nullptr; 3992| | 3993| 351| if (std::is_unsigned::value) ------------------ | Branch (3993:17): [True: 351, Folded] ------------------ 3994| 351| { 3995| 351| const unsigned long long parsed = std::strtoull(begin, &end, 0); 3996| 351| if (end == begin) ------------------ | Branch (3996:21): [True: 49, False: 302] ------------------ 3997| 49| { 3998| 49| errno = saved_errno; 3999| 49| return false; 4000| 49| } 4001| 707| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4001:24): [True: 441, False: 266] | Branch (4001:39): [True: 405, False: 36] ------------------ 4002| 405| { 4003| 405| ++end; 4004| 405| } 4005| 302| if (end != stop || errno == ERANGE || ------------------ | Branch (4005:21): [True: 36, False: 266] | Branch (4005:36): [True: 1, False: 265] ------------------ 4006| 265| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4006:21): [True: 0, False: 265] ------------------ 4007| 37| { 4008| 37| errno = saved_errno; 4009| 37| return false; 4010| 37| } 4011| | 4012| 265| destination = static_cast(parsed); 4013| 265| } 4014| 0| else 4015| 0| { 4016| 0| const long long parsed = std::strtoll(begin, &end, 0); 4017| 0| if (end == begin) ------------------ | Branch (4017:21): [True: 0, False: 0] ------------------ 4018| 0| { 4019| 0| errno = saved_errno; 4020| 0| return false; 4021| 0| } 4022| 0| while (end != stop && std::isspace(static_cast(*end))) ------------------ | Branch (4022:24): [True: 0, False: 0] | Branch (4022:39): [True: 0, False: 0] ------------------ 4023| 0| { 4024| 0| ++end; 4025| 0| } 4026| 0| if (end != stop || errno == ERANGE || ------------------ | Branch (4026:21): [True: 0, False: 0] | Branch (4026:36): [True: 0, False: 0] ------------------ 4027| 0| parsed < static_cast(std::numeric_limits::min()) || ------------------ | Branch (4027:21): [True: 0, False: 0] ------------------ 4028| 0| parsed > static_cast(std::numeric_limits::max())) ------------------ | Branch (4028:21): [True: 0, False: 0] ------------------ 4029| 0| { 4030| 0| errno = saved_errno; 4031| 0| return false; 4032| 0| } 4033| | 4034| 0| destination = static_cast(parsed); 4035| 0| } 4036| | 4037| 351| errno = saved_errno; 4038| 265| return true; 4039| 351| } _ZN4args11ValueReader23HasUnsignedNegativeSignIyEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valuesr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 3942| 497| { 3943| 497| const auto firstNonSpace = std::find_if_not(value.begin(), value.end(), [](char c) 3944| 497| { 3945| 497| return std::isspace(static_cast(c)) != 0; 3946| 497| }); 3947| | 3948| 497| return firstNonSpace != value.end() && *firstNonSpace == '-'; ------------------ | Branch (3948:20): [True: 491, False: 6] | Branch (3948:52): [True: 146, False: 345] ------------------ 3949| 497| } _ZZN4args11ValueReader23HasUnsignedNegativeSignIyEENSt3__19enable_ifIXaasr3std11is_integralIT_EE5valuesr3std11is_unsignedIS4_EE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENKUlcE_clEc: 3944| 843| { 3945| 843| return std::isspace(static_cast(c)) != 0; 3946| 843| }); _ZN4args11ValueReaderclIfEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 91, False: 406] ------------------ 4088| 91| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 91| std::ostringstream problem; 4094| 91| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 91| throw ParseError(problem.str()); 4096| 91|#endif 4097| 91| } 4098| 406| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIfEENSt3__19enable_ifIXoooooooontsr3std11is_integralIT_EE5valuesr3std7is_sameIS4_bEE5valuesr3std7is_sameIS4_cEE5valuesr3std7is_sameIS4_aEE5valuesr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 4050| 497| { 4051| 497| 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| 497| ss.imbue(std::locale::classic()); 4058| 497| ss >> destination; 4059| 497| if (ss.fail()) ------------------ | Branch (4059:17): [True: 63, False: 434] ------------------ 4060| 63| { 4061| 63| return false; 4062| 63| } 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| 434| char extra = '\0'; 4068| 434| 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| 434| if (ss.fail()) ------------------ | Branch (4072:17): [True: 406, False: 28] ------------------ 4073| 406| { 4074| | // Clear the failbit to check if EOF is the only issue 4075| 406| ss.clear(ss.rdstate() & ~std::ios::failbit); 4076| 406| return ss.eof(); 4077| 406| } 4078| | // Extraction succeeded, meaning there's trailing garbage 4079| 28| return false; 4080| 434| } _ZN4args11ValueReaderclIdEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 88, False: 409] ------------------ 4088| 88| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 88| std::ostringstream problem; 4094| 88| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 88| throw ParseError(problem.str()); 4096| 88|#endif 4097| 88| } 4098| 409| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIdEENSt3__19enable_ifIXoooooooontsr3std11is_integralIT_EE5valuesr3std7is_sameIS4_bEE5valuesr3std7is_sameIS4_cEE5valuesr3std7is_sameIS4_aEE5valuesr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 4050| 497| { 4051| 497| 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| 497| ss.imbue(std::locale::classic()); 4058| 497| ss >> destination; 4059| 497| if (ss.fail()) ------------------ | Branch (4059:17): [True: 59, False: 438] ------------------ 4060| 59| { 4061| 59| return false; 4062| 59| } 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| 438| char extra = '\0'; 4068| 438| 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| 438| if (ss.fail()) ------------------ | Branch (4072:17): [True: 409, False: 29] ------------------ 4073| 409| { 4074| | // Clear the failbit to check if EOF is the only issue 4075| 409| ss.clear(ss.rdstate() & ~std::ios::failbit); 4076| 409| return ss.eof(); 4077| 409| } 4078| | // Extraction succeeded, meaning there's trailing garbage 4079| 29| return false; 4080| 438| } _ZN4args11ValueReaderclIeEENSt3__19enable_ifIXntsr3std13is_assignableIT_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE5valueEbE4typeERKSA_SE_RS4_: 4085| 497| { 4086| 497| const bool success = ParseNumericValue(value, destination); 4087| 497| if (!success) ------------------ | Branch (4087:17): [True: 86, False: 411] ------------------ 4088| 86| { 4089| |#ifdef ARGS_NOEXCEPT 4090| | (void)name; 4091| | return false; 4092| |#else 4093| 86| std::ostringstream problem; 4094| 86| problem << "Argument '" << name << "' received invalid value type '" << value << "'"; 4095| 86| throw ParseError(problem.str()); 4096| 86|#endif 4097| 86| } 4098| 411| return true; 4099| 497| } _ZN4args11ValueReader17ParseNumericValueIeEENSt3__19enable_ifIXoooooooontsr3std11is_integralIT_EE5valuesr3std7is_sameIS4_bEE5valuesr3std7is_sameIS4_cEE5valuesr3std7is_sameIS4_aEE5valuesr3std7is_sameIS4_hEE5valueEbE4typeERKNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS4_: 4050| 497| { 4051| 497| 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| 497| ss.imbue(std::locale::classic()); 4058| 497| ss >> destination; 4059| 497| if (ss.fail()) ------------------ | Branch (4059:17): [True: 56, False: 441] ------------------ 4060| 56| { 4061| 56| return false; 4062| 56| } 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| 441| char extra = '\0'; 4068| 441| 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| 441| if (ss.fail()) ------------------ | Branch (4072:17): [True: 411, False: 30] ------------------ 4073| 411| { 4074| | // Clear the failbit to check if EOF is the only issue 4075| 411| ss.clear(ss.rdstate() & ~std::ios::failbit); 4076| 411| return ss.eof(); 4077| 411| } 4078| | // Extraction succeeded, meaning there's trailing garbage 4079| 30| return false; 4080| 441| } LLVMFuzzerTestOneInput: 40| 497|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 41| | // Create a string from fuzzer input, preserving embedded NULs 42| 497| std::string input(reinterpret_cast(data), size); 43| | 44| 497| args::ValueReader reader; 45| | 46| | // Character-ish types (istringstream-based paths) 47| 497| g_sink += static_cast(AttemptConversion(reader, input)); 48| 497| g_sink += static_cast(AttemptConversion(reader, input)); 49| 497| g_sink += static_cast(AttemptConversion(reader, input)); 50| 497| g_sink += static_cast(AttemptConversion(reader, input)); 51| | 52| | // Test signed integer types (strtoll-based path, narrowing checks) 53| 497| g_sink += static_cast(AttemptConversion(reader, input)); 54| 497| g_sink += static_cast(AttemptConversion(reader, input)); 55| 497| g_sink += static_cast(AttemptConversion(reader, input)); 56| 497| g_sink += static_cast(AttemptConversion(reader, input)); 57| | 58| | // Test unsigned integer types (strtoull-based path, sign rejection) 59| 497| g_sink += static_cast(AttemptConversion(reader, input)); 60| 497| g_sink += static_cast(AttemptConversion(reader, input)); 61| 497| g_sink += static_cast(AttemptConversion(reader, input)); 62| 497| g_sink += static_cast(AttemptConversion(reader, input)); 63| | 64| | // Test floating point types (istringstream-based path) 65| 497| g_sink += static_cast(AttemptConversion(reader, input)); 66| 497| g_sink += static_cast(AttemptConversion(reader, input)); 67| 497| g_sink += static_cast(AttemptConversion(reader, input)); 68| | 69| 497| return 0; 70| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIbET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 489| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIcET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 465| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIaET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 465| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIhET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 465| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIsET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 436| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIiET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 306| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIlET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 146| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIxET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 146| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionItET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 434| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIjET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 345| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionImET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 232| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIyET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 232| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIfET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 91| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIdET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 88| } 37| 497| return destination; 38| 497|} numeric_parser_fuzzer.cpp:_ZL17AttemptConversionIeET_RN4args11ValueReaderERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 27| 497|{ 28| 497| T destination{}; 29| 497| try 30| 497| { 31| 497| reader("fuzz_test", input, destination); 32| 497| } 33| 497| catch (...) 34| 497| { 35| | // Expected rejection for values this type cannot represent. 36| 86| } 37| 497| return destination; 38| 497|}