LLVMFuzzerTestOneInput: 10| 2.68k|{ 11| 2.68k| std::string input(reinterpret_cast(data), size); 12| 2.68k| json_decoder decoder; 13| 2.68k| auto options = csv::csv_options{} 14| 2.68k| .assume_header(true) 15| 2.68k| .mapping_kind(csv::csv_mapping_kind::n_rows); 16| 2.68k| try { 17| 2.68k| csv::csv_string_reader reader1(input, decoder, options); 18| 2.68k| reader1.read(); 19| 2.68k| } 20| 2.68k| catch (jsoncons::ser_error e) {} 21| 2.68k| catch (jsoncons::json_runtime_error e) {} 22| 2.68k| catch (json_runtime_error e3) {} 23| 2.68k| return 0; 24| 2.68k|} _ZNK8jsoncons16allocator_holderINSt3__19allocatorIcEEE13get_allocatorEv: 30| 3.42M| { 31| 3.42M| return alloc_; 32| 3.42M| } _ZN8jsoncons16allocator_holderINSt3__19allocatorIcEEEC2Ev: 20| 3.42M| allocator_holder() = default; _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEED2Ev: 2791| 113M| { 2792| 113M| destroy(); 2793| 113M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE7destroyEv: 903| 113M| { 904| 113M| switch (storage_kind()) 905| 113M| { 906| 20.8k| case json_storage_kind::long_str: ------------------ | Branch (906:17): [True: 20.8k, False: 113M] ------------------ 907| 20.8k| { 908| 20.8k| if (cast().ptr_ != nullptr) ------------------ | Branch (908:25): [True: 20.8k, False: 0] ------------------ 909| 20.8k| { 910| 20.8k| long_string_storage::heap_string_factory_type::destroy(cast().ptr_); 911| 20.8k| } 912| 20.8k| break; 913| 0| } 914| 0| case json_storage_kind::byte_str: ------------------ | Branch (914:17): [True: 0, False: 113M] ------------------ 915| 0| if (cast().ptr_ != nullptr) ------------------ | Branch (915:25): [True: 0, False: 0] ------------------ 916| 0| { 917| 0| byte_string_storage::heap_string_factory_type::destroy(cast().ptr_); 918| 0| } 919| 0| break; 920| 3.42M| case json_storage_kind::array: ------------------ | Branch (920:17): [True: 3.42M, False: 110M] ------------------ 921| 3.42M| { 922| 3.42M| if (cast().ptr_ != nullptr) ------------------ | Branch (922:25): [True: 3.42M, False: 0] ------------------ 923| 3.42M| { 924| 3.42M| auto& stor = cast(); 925| 3.42M| typename array_storage::allocator_type alloc{stor.ptr_->get_allocator()}; 926| 3.42M| std::allocator_traits::destroy(alloc, ext_traits::to_plain_pointer(stor.ptr_)); 927| 3.42M| std::allocator_traits::deallocate(alloc, stor.ptr_,1); 928| 3.42M| } 929| 3.42M| break; 930| 0| } 931| 0| case json_storage_kind::object: ------------------ | Branch (931:17): [True: 0, False: 113M] ------------------ 932| 0| { 933| 0| if (cast().ptr_ != nullptr) ------------------ | Branch (933:25): [True: 0, False: 0] ------------------ 934| 0| { 935| 0| auto& stor = cast(); 936| 0| typename object_storage::allocator_type alloc{stor.ptr_->get_allocator()}; 937| 0| std::allocator_traits::destroy(alloc, ext_traits::to_plain_pointer(stor.ptr_)); 938| 0| std::allocator_traits::deallocate(alloc, stor.ptr_,1); 939| 0| } 940| 0| break; 941| 0| } 942| 110M| default: ------------------ | Branch (942:17): [True: 110M, False: 3.44M] ------------------ 943| 110M| break; 944| 113M| } 945| 113M| } _ZNK8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE12storage_kindEv: 1467| 302M| { 1468| | // It is legal to access 'common_.storage_kind_' even though 1469| | // common_ is not the active member of the union because 'storage_kind_' 1470| | // is a part of the common initial sequence of all union members 1471| | // as defined in 11.4-25 of the Standard. 1472| 302M| return static_cast(common_.storage_kind_); 1473| 302M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_19long_string_storageEEERT_v: 1009| 108k| { 1010| 108k| return cast(identity()); 1011| 108k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_19long_string_storageEEE: 1100| 108k| { 1101| 108k| return long_str_; 1102| 108k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_13array_storageEEERT_v: 1009| 75.3M| { 1010| 75.3M| return cast(identity()); 1011| 75.3M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_13array_storageEEE: 1130| 75.3M| { 1131| 75.3M| return array_; 1132| 75.3M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2EOS5_: 2312| 83.6M| { 2313| 83.6M| uninitialized_move(std::move(other)); 2314| 83.6M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE18uninitialized_moveEOS5_: 1307| 83.6M| { 1308| 83.6M| if (is_trivial_storage(other.storage_kind())) ------------------ | Branch (1308:17): [True: 71.7M, False: 11.8M] ------------------ 1309| 71.7M| { 1310| 71.7M| std::memcpy(static_cast(this), &other, sizeof(basic_json)); 1311| 71.7M| } 1312| 11.8M| else 1313| 11.8M| { 1314| 11.8M| switch (other.storage_kind()) 1315| 11.8M| { 1316| 22.9k| case json_storage_kind::long_str: ------------------ | Branch (1316:21): [True: 22.9k, False: 11.8M] ------------------ 1317| 22.9k| construct(other.cast()); 1318| 22.9k| other.construct(); 1319| 22.9k| break; 1320| 0| case json_storage_kind::byte_str: ------------------ | Branch (1320:21): [True: 0, False: 11.8M] ------------------ 1321| 0| construct(other.cast()); 1322| 0| other.construct(); 1323| 0| break; 1324| 11.8M| case json_storage_kind::array: ------------------ | Branch (1324:21): [True: 11.8M, False: 22.9k] ------------------ 1325| 11.8M| construct(other.cast()); 1326| 11.8M| other.construct(); 1327| 11.8M| break; 1328| 0| case json_storage_kind::object: ------------------ | Branch (1328:21): [True: 0, False: 11.8M] ------------------ 1329| 0| construct(other.cast()); 1330| 0| other.construct(); 1331| 0| break; 1332| 0| default: ------------------ | Branch (1332:21): [True: 0, False: 11.8M] ------------------ 1333| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1334| 0| break; 1335| 11.8M| } 1336| 11.8M| } 1337| 83.6M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_19long_string_storageEJRS7_EEEvDpOT0_: 1000| 22.9k| { 1001| 22.9k| ::new (&cast()) StorageType(std::forward(args)...); 1002| 22.9k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE19long_string_storageC2ERKS6_: 631| 22.9k| : storage_kind_(static_cast(json_storage_kind::long_str)), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_) 632| 22.9k| { 633| 22.9k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_12null_storageEJEEEvDpOT0_: 1000| 11.8M| { 1001| 11.8M| ::new (&cast()) StorageType(std::forward(args)...); 1002| 11.8M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_12null_storageEEERT_v: 1009| 11.9M| { 1010| 11.9M| return cast(identity()); 1011| 11.9M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_12null_storageEEE: 1020| 11.9M| { 1021| 11.9M| return null_; 1022| 11.9M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE12null_storageC2ENS_12semantic_tagE: 455| 11.9M| : storage_kind_(static_cast(json_storage_kind::null)), short_str_length_(0), tag_(tag) 456| 11.9M| { 457| 11.9M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_13array_storageEJRS7_EEEvDpOT0_: 1000| 11.8M| { 1001| 11.8M| ::new (&cast()) StorageType(std::forward(args)...); 1002| 11.8M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE13array_storageC2ERKS6_: 732| 11.8M| : storage_kind_(other.storage_kind_), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_) 733| 11.8M| { 734| 11.8M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE11array_rangeEv: 4755| 2.86M| { 4756| 2.86M| switch (storage_kind()) 4757| 2.86M| { 4758| 2.86M| case json_storage_kind::array: ------------------ | Branch (4758:17): [True: 2.86M, False: 0] ------------------ 4759| 2.86M| return array_range_type(cast().value().begin(), 4760| 2.86M| cast().value().end()); 4761| 0| case json_storage_kind::json_ref: ------------------ | Branch (4761:17): [True: 0, False: 2.86M] ------------------ 4762| 0| return cast().value().array_range(); 4763| 0| default: ------------------ | Branch (4763:17): [True: 0, False: 2.86M] ------------------ 4764| 0| JSONCONS_THROW(json_runtime_error("Not an array")); ------------------ | | 35| 0| #define JSONCONS_THROW(exception) throw exception ------------------ 4765| 2.86M| } 4766| 2.86M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE13array_storage5valueEv: 755| 41.4M| { 756| 41.4M| return *ptr_; 757| 41.4M| } _ZN8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_23order_preserving_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEEC2ERKS9_SF_: 353| 2.86M| : first_(first), last_(last) 354| 2.86M| { 355| 2.86M| } _ZNK8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_23order_preserving_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEE5beginEv: 358| 2.86M| { 359| 2.86M| return first_; 360| 2.86M| } _ZNK8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_23order_preserving_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEE3endEv: 362| 2.86M| { 363| 2.86M| return last_; 364| 2.86M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE5clearEv: 4151| 2.86M| { 4152| 2.86M| switch (storage_kind()) 4153| 2.86M| { 4154| 2.86M| case json_storage_kind::array: ------------------ | Branch (4154:17): [True: 2.86M, False: 0] ------------------ 4155| 2.86M| cast().value().clear(); 4156| 2.86M| break; 4157| 0| case json_storage_kind::object: ------------------ | Branch (4157:17): [True: 0, False: 2.86M] ------------------ 4158| 0| cast().value().clear(); 4159| 0| break; 4160| 0| case json_storage_kind::json_ref: ------------------ | Branch (4160:17): [True: 0, False: 2.86M] ------------------ 4161| 0| cast().value().clear(); 4162| 0| break; 4163| 0| default: ------------------ | Branch (4163:17): [True: 0, False: 2.86M] ------------------ 4164| 0| break; 4165| 2.86M| } 4166| 2.86M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2Ev: 2280| 2.68k| { 2281| 2.68k| construct(semantic_tag::none); 2282| 2.68k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_20empty_object_storageEJNS_12semantic_tagEEEEvDpOT0_: 1000| 2.68k| { 1001| 2.68k| ::new (&cast()) StorageType(std::forward(args)...); 1002| 2.68k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_20empty_object_storageEEERT_v: 1009| 7.66k| { 1010| 7.66k| return cast(identity()); 1011| 7.66k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_20empty_object_storageEEE: 1030| 7.66k| { 1031| 7.66k| return empty_object_; 1032| 7.66k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE20empty_object_storageC2ENS_12semantic_tagE: 467| 2.68k| : storage_kind_(static_cast(json_storage_kind::empty_object)), short_str_length_(0), tag_(tag) 468| 2.68k| { 469| 2.68k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE7reserveEm: 3479| 3.42M| { 3480| 3.42M| if (n > 0) ------------------ | Branch (3480:17): [True: 3.42M, False: 0] ------------------ 3481| 3.42M| { 3482| 3.42M| switch (storage_kind()) 3483| 3.42M| { 3484| 3.42M| case json_storage_kind::array: ------------------ | Branch (3484:21): [True: 3.42M, False: 0] ------------------ 3485| 3.42M| cast().value().reserve(n); 3486| 3.42M| break; 3487| 0| case json_storage_kind::empty_object: ------------------ | Branch (3487:21): [True: 0, False: 3.42M] ------------------ 3488| 0| create_object_implicitly(); 3489| 0| cast().value().reserve(n); 3490| 0| break; 3491| 0| case json_storage_kind::object: ------------------ | Branch (3491:21): [True: 0, False: 3.42M] ------------------ 3492| 0| cast().value().reserve(n); 3493| 0| break; 3494| 0| case json_storage_kind::json_ref: ------------------ | Branch (3494:21): [True: 0, False: 3.42M] ------------------ 3495| 0| cast().value().reserve(n); 3496| 0| break; 3497| 0| default: ------------------ | Branch (3497:21): [True: 0, False: 3.42M] ------------------ 3498| 0| break; 3499| 3.42M| } 3500| 3.42M| } 3501| 3.42M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9push_backEOS5_: 4697| 29.3M| { 4698| 29.3M| switch (storage_kind()) 4699| 29.3M| { 4700| 29.3M| case json_storage_kind::array: ------------------ | Branch (4700:17): [True: 29.3M, False: 0] ------------------ 4701| 29.3M| cast().value().push_back(std::move(val)); 4702| 29.3M| break; 4703| 0| case json_storage_kind::json_ref: ------------------ | Branch (4703:17): [True: 0, False: 29.3M] ------------------ 4704| 0| cast().value().push_back(std::move(val)); 4705| 0| break; 4706| 0| default: ------------------ | Branch (4706:17): [True: 0, False: 29.3M] ------------------ 4707| 0| JSONCONS_THROW(json_runtime_error("Attempting to insert into a value that is not an array")); ------------------ | | 35| 0| #define JSONCONS_THROW(exception) throw exception ------------------ 4708| 29.3M| } 4709| 29.3M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4swapERS5_: 1939| 2.49k| { 1940| 2.49k| if (this == &other) ------------------ | Branch (1940:17): [True: 0, False: 2.49k] ------------------ 1941| 0| { 1942| 0| return; 1943| 0| } 1944| 2.49k| if (is_trivial_storage(storage_kind()) && is_trivial_storage(other.storage_kind())) ------------------ | Branch (1944:17): [True: 2.49k, False: 0] | Branch (1944:55): [True: 0, False: 2.49k] ------------------ 1945| 0| { 1946| 0| basic_json temp; 1947| 0| std::memcpy(static_cast(&temp), static_cast(&other), sizeof(basic_json)); 1948| 0| std::memcpy(static_cast(&other), static_cast(this), sizeof(basic_json)); 1949| 0| std::memcpy(static_cast(this), static_cast(&temp), sizeof(basic_json)); 1950| 0| } 1951| 2.49k| else 1952| 2.49k| { 1953| 2.49k| switch (storage_kind()) 1954| 2.49k| { 1955| 0| case json_storage_kind::null: swap_l(other); break; ------------------ | Branch (1955:21): [True: 0, False: 2.49k] ------------------ 1956| 2.49k| case json_storage_kind::empty_object : swap_l(other); break; ------------------ | Branch (1956:21): [True: 2.49k, False: 0] ------------------ 1957| 0| case json_storage_kind::boolean: swap_l(other); break; ------------------ | Branch (1957:21): [True: 0, False: 2.49k] ------------------ 1958| 0| case json_storage_kind::int64: swap_l(other); break; ------------------ | Branch (1958:21): [True: 0, False: 2.49k] ------------------ 1959| 0| case json_storage_kind::uint64: swap_l(other); break; ------------------ | Branch (1959:21): [True: 0, False: 2.49k] ------------------ 1960| 0| case json_storage_kind::half_float: swap_l(other); break; ------------------ | Branch (1960:21): [True: 0, False: 2.49k] ------------------ 1961| 0| case json_storage_kind::float64: swap_l(other); break; ------------------ | Branch (1961:21): [True: 0, False: 2.49k] ------------------ 1962| 0| case json_storage_kind::short_str: swap_l(other); break; ------------------ | Branch (1962:21): [True: 0, False: 2.49k] ------------------ 1963| 0| case json_storage_kind::long_str: swap_l(other); break; ------------------ | Branch (1963:21): [True: 0, False: 2.49k] ------------------ 1964| 0| case json_storage_kind::byte_str: swap_l(other); break; ------------------ | Branch (1964:21): [True: 0, False: 2.49k] ------------------ 1965| 0| case json_storage_kind::array: swap_l(other); break; ------------------ | Branch (1965:21): [True: 0, False: 2.49k] ------------------ 1966| 0| case json_storage_kind::object: swap_l(other); break; ------------------ | Branch (1966:21): [True: 0, False: 2.49k] ------------------ 1967| 0| case json_storage_kind::const_json_ref: swap_l(other); break; ------------------ | Branch (1967:21): [True: 0, False: 2.49k] ------------------ 1968| 0| case json_storage_kind::json_ref: swap_l(other); break; ------------------ | Branch (1968:21): [True: 0, False: 2.49k] ------------------ 1969| 0| default: ------------------ | Branch (1969:21): [True: 0, False: 2.49k] ------------------ 1970| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1971| 0| break; 1972| 2.49k| } 1973| 2.49k| } 1974| 2.49k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_20empty_object_storageEJRS7_EEEvDpOT0_: 1000| 2.49k| { 1001| 2.49k| ::new (&cast()) StorageType(std::forward(args)...); 1002| 2.49k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_12bool_storageEEERT_v: 1009| 180k| { 1010| 180k| return cast(identity()); 1011| 180k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_12bool_storageEEE: 1040| 180k| { 1041| 180k| return boolean_; 1042| 180k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_13int64_storageEEERT_v: 1009| 304k| { 1010| 304k| return cast(identity()); 1011| 304k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_13int64_storageEEE: 1050| 304k| { 1051| 304k| return int64_; 1052| 304k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_14uint64_storageEEERT_v: 1009| 171k| { 1010| 171k| return cast(identity()); 1011| 171k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14uint64_storageEEE: 1060| 171k| { 1061| 171k| return uint64_; 1062| 171k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_14double_storageEEERT_v: 1009| 60.6k| { 1010| 60.6k| return cast(identity()); 1011| 60.6k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14double_storageEEE: 1080| 60.6k| { 1081| 60.6k| return float64_; 1082| 60.6k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castINS5_20short_string_storageEEERT_v: 1009| 25.7M| { 1010| 25.7M| return cast(identity()); 1011| 25.7M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_20short_string_storageEEE: 1090| 25.7M| { 1091| 25.7M| return short_str_; 1092| 25.7M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE6swap_lINS5_20empty_object_storageEEEvRS5_: 1175| 2.49k| { 1176| 2.49k| switch (other.storage_kind()) 1177| 2.49k| { 1178| 0| case json_storage_kind::null : swap_l_r(other); break; ------------------ | Branch (1178:17): [True: 0, False: 2.49k] ------------------ 1179| 0| case json_storage_kind::empty_object : swap_l_r(other); break; ------------------ | Branch (1179:17): [True: 0, False: 2.49k] ------------------ 1180| 0| case json_storage_kind::boolean : swap_l_r(other); break; ------------------ | Branch (1180:17): [True: 0, False: 2.49k] ------------------ 1181| 0| case json_storage_kind::int64 : swap_l_r(other); break; ------------------ | Branch (1181:17): [True: 0, False: 2.49k] ------------------ 1182| 0| case json_storage_kind::uint64 : swap_l_r(other); break; ------------------ | Branch (1182:17): [True: 0, False: 2.49k] ------------------ 1183| 0| case json_storage_kind::half_float : swap_l_r(other); break; ------------------ | Branch (1183:17): [True: 0, False: 2.49k] ------------------ 1184| 0| case json_storage_kind::float64 : swap_l_r(other); break; ------------------ | Branch (1184:17): [True: 0, False: 2.49k] ------------------ 1185| 0| case json_storage_kind::short_str : swap_l_r(other); break; ------------------ | Branch (1185:17): [True: 0, False: 2.49k] ------------------ 1186| 0| case json_storage_kind::long_str : swap_l_r(other); break; ------------------ | Branch (1186:17): [True: 0, False: 2.49k] ------------------ 1187| 0| case json_storage_kind::byte_str : swap_l_r(other); break; ------------------ | Branch (1187:17): [True: 0, False: 2.49k] ------------------ 1188| 2.49k| case json_storage_kind::array : swap_l_r(other); break; ------------------ | Branch (1188:17): [True: 2.49k, False: 0] ------------------ 1189| 0| case json_storage_kind::object : swap_l_r(other); break; ------------------ | Branch (1189:17): [True: 0, False: 2.49k] ------------------ 1190| 0| case json_storage_kind::const_json_ref : swap_l_r(other); break; ------------------ | Branch (1190:17): [True: 0, False: 2.49k] ------------------ 1191| 0| case json_storage_kind::json_ref : swap_l_r(other); break; ------------------ | Branch (1191:17): [True: 0, False: 2.49k] ------------------ 1192| 0| default: ------------------ | Branch (1192:17): [True: 0, False: 2.49k] ------------------ 1193| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1194| 0| break; 1195| 2.49k| } 1196| 2.49k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20empty_object_storageENS5_13array_storageEEEvRS5_: 1161| 2.49k| { 1162| 2.49k| swap_l_r(identity(), identity(), other); 1163| 2.49k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20empty_object_storageENS5_13array_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1167| 2.49k| { 1168| 2.49k| TypeR temp{other.cast()}; 1169| 2.49k| other.construct(cast()); 1170| 2.49k| construct(temp); 1171| 2.49k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2ImEET_NS_12semantic_tagENS2_9enable_ifIXaasr10ext_traits19is_unsigned_integerIS7_EE5valuelestS7_Lm8EEiE4typeE: 2631| 171k| { 2632| 171k| construct(val, tag); 2633| 171k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_14uint64_storageEJRmRNS_12semantic_tagEEEEvDpOT0_: 1000| 171k| { 1001| 171k| ::new (&cast()) StorageType(std::forward(args)...); 1002| 171k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE14uint64_storageC2EmNS_12semantic_tagE: 521| 171k| : storage_kind_(static_cast(json_storage_kind::uint64)), short_str_length_(0), tag_(tag), 522| 171k| val_(val) 523| 171k| { 524| 171k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2IlEET_NS_12semantic_tagENS2_9enable_ifIXaasr10ext_traits17is_signed_integerIS7_EE5valuelestS7_Lm8EEiE4typeE: 2662| 304k| { 2663| 304k| construct(val, tag); 2664| 304k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_13int64_storageEJRlRNS_12semantic_tagEEEEvDpOT0_: 1000| 304k| { 1001| 304k| ::new (&cast()) StorageType(std::forward(args)...); 1002| 304k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE13int64_storageC2ElNS_12semantic_tagE: 501| 304k| : storage_kind_(static_cast(json_storage_kind::int64)), short_str_length_(0), tag_(tag), 502| 304k| val_(val) 503| 304k| { 504| 304k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2EdNS_12semantic_tagE: 2619| 60.6k| { 2620| 60.6k| construct(val, tag); 2621| 60.6k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_14double_storageEJRdRNS_12semantic_tagEEEEvDpOT0_: 1000| 60.6k| { 1001| 60.6k| ::new (&cast()) StorageType(std::forward(args)...); 1002| 60.6k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE14double_storageC2EdNS_12semantic_tagE: 560| 60.6k| : storage_kind_(static_cast(json_storage_kind::float64)), short_str_length_(0), tag_(tag), 561| 60.6k| val_(val) 562| 60.6k| { 563| 60.6k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2ENS_16json_array_arg_tENS_12semantic_tagE: 2406| 3.42M| { 2407| 3.42M| auto ptr = create_array(Allocator()); 2408| 3.42M| construct(ptr, tag); 2409| 3.42M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE12create_arrayIJEEEPNS_10json_arrayIS5_NS2_6vectorEEERKS4_DpOT_: 962| 3.42M| { 963| 3.42M| using stor_allocator_type = typename array_storage::allocator_type; 964| 3.42M| stor_allocator_type stor_alloc(alloc); 965| 3.42M| auto ptr = std::allocator_traits::allocate(stor_alloc, 1); 966| 3.42M| JSONCONS_TRY ------------------ | | 37| 3.42M| #define JSONCONS_TRY try ------------------ 967| 3.42M| { 968| 3.42M| std::allocator_traits::construct(stor_alloc, ext_traits::to_plain_pointer(ptr), 969| 3.42M| std::forward(args)...); 970| 3.42M| } 971| 3.42M| JSONCONS_CATCH(...) 972| 3.42M| { 973| 0| std::allocator_traits::deallocate(stor_alloc, ptr,1); 974| 0| JSONCONS_RETHROW; ------------------ | | 36| 0| #define JSONCONS_RETHROW throw ------------------ 975| 0| } 976| 3.42M| return ptr; 977| 3.42M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_13array_storageEJRPNS_10json_arrayIS5_NS2_6vectorEEERNS_12semantic_tagEEEEvDpOT0_: 1000| 3.42M| { 1001| 3.42M| ::new (&cast()) StorageType(std::forward(args)...); 1002| 3.42M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE13array_storageC2EPNS_10json_arrayIS5_NS2_6vectorEEENS_12semantic_tagE: 727| 3.42M| : storage_kind_(static_cast(json_storage_kind::array)), short_str_length_(0), tag_(tag), ptr_(ptr) 728| 3.42M| { 729| 3.42M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2ENS_9null_typeENS_12semantic_tagE: 2708| 48.3k| { 2709| 48.3k| construct(tag); 2710| 48.3k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_12null_storageEJRNS_12semantic_tagEEEEvDpOT0_: 1000| 48.3k| { 1001| 48.3k| ::new (&cast()) StorageType(std::forward(args)...); 1002| 48.3k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2EbNS_12semantic_tagE: 2718| 180k| { 2719| 180k| construct(val,tag); 2720| 180k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_12bool_storageEJRbRNS_12semantic_tagEEEEvDpOT0_: 1000| 180k| { 1001| 180k| ::new (&cast()) StorageType(std::forward(args)...); 1002| 180k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE12bool_storageC2EbNS_12semantic_tagE: 480| 180k| : storage_kind_(static_cast(json_storage_kind::boolean)), short_str_length_(0), tag_(tag), 481| 180k| val_(val) 482| 180k| { 483| 180k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2ERKNS2_17basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagE: 2566| 25.8M| : basic_json(s.data(), s.size(), tag, allocator_type()) 2567| 25.8M| { 2568| 25.8M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEC2EPKcmNS_12semantic_tagERKS4_: 2596| 25.8M| { 2597| 25.8M| if (length <= short_string_storage::max_length) ------------------ | Branch (2597:17): [True: 25.7M, False: 20.8k] ------------------ 2598| 25.7M| { 2599| 25.7M| construct(s, static_cast(length), tag); 2600| 25.7M| } 2601| 20.8k| else 2602| 20.8k| { 2603| 20.8k| auto ptr = create_long_string(alloc, s, length); 2604| 20.8k| construct(ptr, tag); 2605| 20.8k| } 2606| 25.8M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_20short_string_storageEJRPKchRNS_12semantic_tagEEEEvDpOT0_: 1000| 25.7M| { 1001| 25.7M| ::new (&cast()) StorageType(std::forward(args)...); 1002| 25.7M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE20short_string_storageC2EPKchNS_12semantic_tagE: 582| 25.7M| : storage_kind_(static_cast(json_storage_kind::short_str)), short_str_length_(length), tag_(tag) 583| 25.7M| { 584| 25.7M| JSONCONS_ASSERT(length <= max_length); ------------------ | | 45| 25.7M|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 25.7M] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 585| 25.7M| std::memcpy(data_,p,length*sizeof(char_type)); 586| 25.7M| data_[length] = 0; 587| 25.7M| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE18create_long_stringERKS4_PKcm: 948| 20.8k| { 949| 20.8k| using heap_string_factory_type = jsoncons::heap::heap_string_factory; 950| 20.8k| return heap_string_factory_type::create(data, length, null_type(), alloc); 951| 20.8k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE9constructINS5_19long_string_storageEJRPNS_4heap11heap_stringIcNS_9null_typeES4_EERNS_12semantic_tagEEEEvDpOT0_: 1000| 20.8k| { 1001| 20.8k| ::new (&cast()) StorageType(std::forward(args)...); 1002| 20.8k| } _ZN8jsoncons10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEE19long_string_storageC2EPNS_4heap11heap_stringIcNS_9null_typeES4_EENS_12semantic_tagE: 626| 20.8k| : storage_kind_(static_cast(json_storage_kind::long_str)), short_str_length_(0), tag_(tag), ptr_(ptr) 627| 20.8k| { 628| 20.8k| } _ZN8jsoncons12launder_castIPcNS_4heap11heap_stringIcNS_9null_typeENSt3__19allocatorIcEEEEEET_PT0_: 239| 20.8k| { 240| 20.8k| #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 241| 20.8k| return std::launder(reinterpret_cast(u)); 242| | #elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) > 800 243| | return __builtin_launder(reinterpret_cast(u)); 244| | #else 245| | return reinterpret_cast(u); 246| | #endif 247| 20.8k| } _ZN8jsoncons12launder_castIPNS_4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE9storage_tEcEET_PT0_: 239| 20.8k| { 240| 20.8k| #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 241| 20.8k| return std::launder(reinterpret_cast(u)); 242| | #elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) > 800 243| | return __builtin_launder(reinterpret_cast(u)); 244| | #else 245| | return reinterpret_cast(u); 246| | #endif 247| 20.8k| } _ZN8jsoncons28string_view_constant_of_typeIcEENSt3__117basic_string_viewIT_NS1_11char_traitsIS3_EEEEPKcPKw: 227| 10.7k| { 228| 10.7k| return jsoncons::string_view(c); 229| 10.7k| } _ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2Ev: 58| 14.8k| { 59| 14.8k| } _ZN8jsoncons6detail4spanIKcLm18446744073709551615EEC2EPS2_m: 61| 5.36k| : data_(data), size_(size) 62| 5.36k| { 63| 5.36k| } _ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4sizeEv: 116| 22.8k| { 117| 22.8k| return size_; 118| 22.8k| } _ZNK8jsoncons6detail4spanIKcLm18446744073709551615EE4dataEv: 111| 5.36k| { 112| 5.36k| return data_; 113| 5.36k| } _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEED2Ev: 107| 3.42M| { 108| 3.42M| flatten_and_destroy(); 109| 3.42M| } _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE19flatten_and_destroyEv: 246| 3.42M| { 247| 6.93M| while (!elements_.empty()) ------------------ | Branch (247:20): [True: 3.50M, False: 3.42M] ------------------ 248| 3.50M| { 249| 3.50M| value_type current = std::move(elements_.back()); 250| 3.50M| elements_.pop_back(); 251| 3.50M| switch (current.storage_kind()) 252| 3.50M| { 253| 2.86M| case json_storage_kind::array: ------------------ | Branch (253:21): [True: 2.86M, False: 642k] ------------------ 254| 2.86M| { 255| 2.86M| for (auto&& item : current.array_range()) ------------------ | Branch (255:42): [True: 25.8M, False: 2.86M] ------------------ 256| 25.8M| { 257| 25.8M| if ((item.storage_kind() == json_storage_kind::array || item.storage_kind() == json_storage_kind::object) ------------------ | Branch (257:34): [True: 0, False: 25.8M] | Branch (257:85): [True: 0, False: 25.8M] ------------------ 258| 0| && !item.empty()) // non-empty object or array ------------------ | Branch (258:36): [True: 0, False: 0] ------------------ 259| 0| { 260| 0| elements_.push_back(std::move(item)); 261| 0| } 262| 25.8M| } 263| 2.86M| current.clear(); 264| 2.86M| break; 265| 0| } 266| 0| case json_storage_kind::object: ------------------ | Branch (266:21): [True: 0, False: 3.50M] ------------------ 267| 0| { 268| 0| for (auto&& kv : current.object_range()) ------------------ | Branch (268:40): [True: 0, False: 0] ------------------ 269| 0| { 270| 0| if ((kv.value().storage_kind() == json_storage_kind::array || kv.value().storage_kind() == json_storage_kind::object) ------------------ | Branch (270:34): [True: 0, False: 0] | Branch (270:91): [True: 0, False: 0] ------------------ 271| 0| && !kv.value().empty()) // non-empty object or array ------------------ | Branch (271:36): [True: 0, False: 0] ------------------ 272| 0| { 273| 0| elements_.push_back(std::move(kv.value())); 274| 0| } 275| 0| } 276| 0| current.clear(); 277| 0| break; 278| 0| } 279| 642k| default: ------------------ | Branch (279:21): [True: 642k, False: 2.86M] ------------------ 280| 642k| break; 281| 3.50M| } 282| 3.50M| } 283| 3.42M| } _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE5beginEv: 220| 2.86M| iterator begin() {return elements_.begin();} _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE3endEv: 222| 2.86M| iterator end() {return elements_.end();} _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE5clearEv: 140| 2.86M| void clear() {elements_.clear();} _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE7reserveEm: 151| 3.42M| void reserve(std::size_t n) {elements_.reserve(n);} _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEE9push_backIS6_S5_EENS3_9enable_ifIXsr3std16allocator_traitsIT0_E15is_always_equalE5valueEvE4typeEOT_: 176| 29.3M| { 177| 29.3M| elements_.emplace_back(std::forward(value)); 178| 29.3M| } _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS3_6vectorEEC2Ev: 47| 3.42M| { 48| 3.42M| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_EC2ERKS5_S9_: 74| 2.68k| : allocator_(alloc), 75| 2.68k| result_(), 76| 2.68k| name_(alloc), 77| 2.68k| item_stack_(alloc), 78| 2.68k| structure_stack_(temp_alloc) 79| 2.68k| { 80| 2.68k| item_stack_.reserve(1000); 81| 2.68k| structure_stack_.reserve(100); 82| 2.68k| structure_stack_.emplace_back(structure_type::root_t, 0); 83| 2.68k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E14structure_infoC2ENS7_14structure_typeEm: 51| 3.43M| : type_(type), container_index_(offset) 52| 3.43M| { 53| 3.43M| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E15visit_end_arrayERKNS_11ser_contextERNS3_10error_codeE: 179| 3.42M| { 180| 3.42M| JSONCONS_ASSERT(structure_stack_.size() > 1); ------------------ | | 45| 3.42M|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 3.42M] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 181| 3.42M| JSONCONS_ASSERT(structure_stack_.back().type_ == structure_type::array_t); ------------------ | | 45| 3.42M|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 3.42M] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 182| 3.42M| const size_t container_index = structure_stack_.back().container_index_; 183| 3.42M| JSONCONS_ASSERT(item_stack_.size() > container_index); ------------------ | | 45| 3.42M|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 3.42M] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 184| | 185| 3.42M| auto& container = item_stack_[container_index].value; 186| | 187| 3.42M| const size_t size = item_stack_.size() - (container_index + 1); 188| | //std::cout << "size on item stack: " << size << "\n"; 189| | 190| 3.42M| if (size > 0) ------------------ | Branch (190:13): [True: 3.42M, False: 170] ------------------ 191| 3.42M| { 192| 3.42M| container.reserve(size); 193| 3.42M| auto first = item_stack_.begin() + (container_index+1); 194| 3.42M| auto last = first + size; 195| 32.8M| for (auto it = first; it != last; ++it) ------------------ | Branch (195:35): [True: 29.3M, False: 3.42M] ------------------ 196| 29.3M| { 197| 29.3M| container.push_back(std::move((*it).value)); 198| 29.3M| } 199| 3.42M| item_stack_.erase(first, item_stack_.end()); 200| 3.42M| } 201| | 202| 3.42M| structure_stack_.pop_back(); 203| 3.42M| if (structure_stack_.back().type_ == structure_type::root_t) ------------------ | Branch (203:13): [True: 2.49k, False: 3.42M] ------------------ 204| 2.49k| { 205| 2.49k| result_.swap(item_stack_.front().value); 206| 2.49k| item_stack_.pop_back(); 207| 2.49k| is_valid_ = true; 208| 2.49k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 2.49k|#define JSONCONS_VISITOR_RETURN return true ------------------ 209| 2.49k| } 210| 3.42M| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 3.42M|#define JSONCONS_VISITOR_RETURN return true ------------------ 211| 3.42M| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 296| 171k| { 297| 171k| switch (structure_stack_.back().type_) ------------------ | Branch (297:17): [True: 171k, False: 0] ------------------ 298| 171k| { 299| 0| case structure_type::object_t: ------------------ | Branch (299:13): [True: 0, False: 171k] ------------------ 300| 171k| case structure_type::array_t: ------------------ | Branch (300:13): [True: 171k, False: 0] ------------------ 301| 171k| item_stack_.emplace_back(std::move(name_), index_++, value, tag); 302| 171k| break; 303| 0| case structure_type::root_t: ------------------ | Branch (303:13): [True: 0, False: 171k] ------------------ 304| 0| result_ = Json(value,tag); 305| 0| is_valid_ = true; 306| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 307| 171k| } 308| 171k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 171k|#define JSONCONS_VISITOR_RETURN return true ------------------ 309| 171k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 277| 304k| { 278| 304k| switch (structure_stack_.back().type_) ------------------ | Branch (278:17): [True: 304k, False: 0] ------------------ 279| 304k| { 280| 0| case structure_type::object_t: ------------------ | Branch (280:13): [True: 0, False: 304k] ------------------ 281| 304k| case structure_type::array_t: ------------------ | Branch (281:13): [True: 304k, False: 0] ------------------ 282| 304k| item_stack_.emplace_back(std::move(name_), index_++, value, tag); 283| 304k| break; 284| 0| case structure_type::root_t: ------------------ | Branch (284:13): [True: 0, False: 304k] ------------------ 285| 0| result_ = Json(value,tag); 286| 0| is_valid_ = true; 287| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 288| 304k| } 289| 304k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 304k|#define JSONCONS_VISITOR_RETURN return true ------------------ 290| 304k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 334| 60.6k| { 335| 60.6k| switch (structure_stack_.back().type_) ------------------ | Branch (335:17): [True: 60.6k, False: 0] ------------------ 336| 60.6k| { 337| 0| case structure_type::object_t: ------------------ | Branch (337:13): [True: 0, False: 60.6k] ------------------ 338| 60.6k| case structure_type::array_t: ------------------ | Branch (338:13): [True: 60.6k, False: 0] ------------------ 339| 60.6k| item_stack_.emplace_back(std::move(name_), index_++, value, tag); 340| 60.6k| break; 341| 0| case structure_type::root_t: ------------------ | Branch (341:13): [True: 0, False: 60.6k] ------------------ 342| 0| result_ = Json(value, tag); 343| 0| is_valid_ = true; 344| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 345| 60.6k| } 346| 60.6k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 60.6k|#define JSONCONS_VISITOR_RETURN return true ------------------ 347| 60.6k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E11visit_flushEv: 122| 2.58k| { 123| 2.58k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 166| 3.42M| { 167| 3.42M| if (structure_stack_.back().type_ == structure_type::root_t) ------------------ | Branch (167:13): [True: 2.67k, False: 3.42M] ------------------ 168| 2.67k| { 169| 2.67k| index_ = 0; 170| 2.67k| item_stack_.clear(); 171| 2.67k| is_valid_ = false; 172| 2.67k| } 173| 3.42M| item_stack_.emplace_back(std::move(name_), index_++, json_array_arg, tag); 174| 3.42M| structure_stack_.emplace_back(structure_type::array_t, item_stack_.size()-1); 175| 3.42M| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 3.42M|#define JSONCONS_VISITOR_RETURN return true ------------------ 176| 3.42M| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 366| 48.3k| { 367| 48.3k| switch (structure_stack_.back().type_) ------------------ | Branch (367:17): [True: 48.3k, False: 0] ------------------ 368| 48.3k| { 369| 0| case structure_type::object_t: ------------------ | Branch (369:13): [True: 0, False: 48.3k] ------------------ 370| 48.3k| case structure_type::array_t: ------------------ | Branch (370:13): [True: 48.3k, False: 0] ------------------ 371| 48.3k| item_stack_.emplace_back(std::move(name_), index_++, null_type(), tag); 372| 48.3k| break; 373| 0| case structure_type::root_t: ------------------ | Branch (373:13): [True: 0, False: 48.3k] ------------------ 374| 0| result_ = Json(null_type(), tag); 375| 0| is_valid_ = true; 376| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 377| 48.3k| } 378| 48.3k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 48.3k|#define JSONCONS_VISITOR_RETURN return true ------------------ 379| 48.3k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 350| 180k| { 351| 180k| switch (structure_stack_.back().type_) ------------------ | Branch (351:17): [True: 180k, False: 0] ------------------ 352| 180k| { 353| 0| case structure_type::object_t: ------------------ | Branch (353:13): [True: 0, False: 180k] ------------------ 354| 180k| case structure_type::array_t: ------------------ | Branch (354:13): [True: 180k, False: 0] ------------------ 355| 180k| item_stack_.emplace_back(std::move(name_), index_++, value, tag); 356| 180k| break; 357| 0| case structure_type::root_t: ------------------ | Branch (357:13): [True: 0, False: 180k] ------------------ 358| 0| result_ = Json(value, tag); 359| 0| is_valid_ = true; 360| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 361| 180k| } 362| 180k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 180k|#define JSONCONS_VISITOR_RETURN return true ------------------ 363| 180k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEES5_E12visit_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 220| 25.8M| { 221| 25.8M| switch (structure_stack_.back().type_) ------------------ | Branch (221:17): [True: 25.8M, False: 0] ------------------ 222| 25.8M| { 223| 0| case structure_type::object_t: ------------------ | Branch (223:13): [True: 0, False: 25.8M] ------------------ 224| 25.8M| case structure_type::array_t: ------------------ | Branch (224:13): [True: 25.8M, False: 0] ------------------ 225| 25.8M| item_stack_.emplace_back(std::move(name_), index_++, sv, tag); 226| 25.8M| break; 227| 0| case structure_type::root_t: ------------------ | Branch (227:13): [True: 0, False: 25.8M] ------------------ 228| 0| result_ = Json(sv, tag, allocator_); 229| 0| is_valid_ = true; 230| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 231| 25.8M| } 232| 25.8M| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 25.8M|#define JSONCONS_VISITOR_RETURN return true ------------------ 233| 25.8M| } _ZN8jsoncons15make_error_codeENS_9json_errcE: 141| 8| { 142| 8| return std::error_code(static_cast(result),json_error_category()); 143| 8| } _ZN8jsoncons19json_error_categoryEv: 135| 8| { 136| 8| static json_error_category_impl instance; 137| 8| return instance; 138| 8| } _ZNK8jsoncons24json_error_category_impl7messageEi: 63| 8| { 64| 8| switch (static_cast(ev)) 65| 8| { 66| 0| case json_errc::unexpected_eof: ------------------ | Branch (66:17): [True: 0, False: 8] ------------------ 67| 0| return "Unexpected end of file"; 68| 0| case json_errc::source_error: ------------------ | Branch (68:17): [True: 0, False: 8] ------------------ 69| 0| return "Source error"; 70| 0| case json_errc::syntax_error: ------------------ | Branch (70:17): [True: 0, False: 8] ------------------ 71| 0| return "JSON syntax_error"; 72| 0| case json_errc::extra_character: ------------------ | Branch (72:17): [True: 0, False: 8] ------------------ 73| 0| return "Unexpected non-whitespace character after JSON text"; 74| 0| case json_errc::max_nesting_depth_exceeded: ------------------ | Branch (74:17): [True: 0, False: 8] ------------------ 75| 0| return "Data item nesting exceeds limit in options"; 76| 0| case json_errc::single_quote: ------------------ | Branch (76:17): [True: 0, False: 8] ------------------ 77| 0| return "JSON strings cannot be quoted with single quotes"; 78| 0| case json_errc::illegal_character_in_string: ------------------ | Branch (78:17): [True: 0, False: 8] ------------------ 79| 0| return "Illegal character in string"; 80| 0| case json_errc::extra_comma: ------------------ | Branch (80:17): [True: 0, False: 8] ------------------ 81| 0| return "Extra comma"; 82| 0| case json_errc::expected_key: ------------------ | Branch (82:17): [True: 0, False: 8] ------------------ 83| 0| return "Expected object member key"; 84| 0| case json_errc::expected_value: ------------------ | Branch (84:17): [True: 0, False: 8] ------------------ 85| 0| return "Expected value"; 86| 0| case json_errc::invalid_value: ------------------ | Branch (86:17): [True: 0, False: 8] ------------------ 87| 0| return "Invalid value"; 88| 0| case json_errc::expected_colon: ------------------ | Branch (88:17): [True: 0, False: 8] ------------------ 89| 0| return "Expected name separator ':'"; 90| 0| case json_errc::illegal_control_character: ------------------ | Branch (90:17): [True: 0, False: 8] ------------------ 91| 0| return "Illegal control character in string"; 92| 0| case json_errc::illegal_escaped_character: ------------------ | Branch (92:17): [True: 0, False: 8] ------------------ 93| 0| return "Illegal escaped character in string"; 94| 0| case json_errc::expected_codepoint_surrogate_pair: ------------------ | Branch (94:17): [True: 0, False: 8] ------------------ 95| 0| return "Invalid codepoint, expected another \\u token to begin the second half of a codepoint surrogate pair."; 96| 0| case json_errc::invalid_hex_escape_sequence: ------------------ | Branch (96:17): [True: 0, False: 8] ------------------ 97| 0| return "Invalid codepoint, expected hexadecimal digit."; 98| 0| case json_errc::invalid_unicode_escape_sequence: ------------------ | Branch (98:17): [True: 0, False: 8] ------------------ 99| 0| return "Invalid codepoint, expected four hexadecimal digits."; 100| 0| case json_errc::leading_zero: ------------------ | Branch (100:17): [True: 0, False: 8] ------------------ 101| 0| return "A number cannot have a leading zero"; 102| 0| case json_errc::invalid_number: ------------------ | Branch (102:17): [True: 0, False: 8] ------------------ 103| 0| return "Invalid number"; 104| 0| case json_errc::expected_comma_or_rbrace: ------------------ | Branch (104:17): [True: 0, False: 8] ------------------ 105| 0| return "Expected comma or right brace '}'"; 106| 0| case json_errc::expected_comma_or_rbracket: ------------------ | Branch (106:17): [True: 0, False: 8] ------------------ 107| 0| return "Expected comma or right bracket ']'"; 108| 0| case json_errc::unexpected_rbrace: ------------------ | Branch (108:17): [True: 0, False: 8] ------------------ 109| 0| return "Unexpected right brace '}'"; 110| 0| case json_errc::unexpected_rbracket: ------------------ | Branch (110:17): [True: 0, False: 8] ------------------ 111| 0| return "Unexpected right bracket ']'"; 112| 0| case json_errc::illegal_comment: ------------------ | Branch (112:17): [True: 0, False: 8] ------------------ 113| 0| return "Illegal comment"; 114| 0| case json_errc::expected_continuation_byte: ------------------ | Branch (114:17): [True: 0, False: 8] ------------------ 115| 0| return "Expected continuation byte"; 116| 0| case json_errc::over_long_utf8_sequence: ------------------ | Branch (116:17): [True: 0, False: 8] ------------------ 117| 0| return "Over long UTF-8 sequence"; 118| 0| case json_errc::illegal_codepoint: ------------------ | Branch (118:17): [True: 0, False: 8] ------------------ 119| 0| return "Illegal codepoint (>= 0xd800 && <= 0xdfff)"; 120| 0| case json_errc::illegal_surrogate_value: ------------------ | Branch (120:17): [True: 0, False: 8] ------------------ 121| 0| return "UTF-16 surrogate values are illegal in UTF-32"; 122| 0| case json_errc::unpaired_high_surrogate: ------------------ | Branch (122:17): [True: 0, False: 8] ------------------ 123| 0| return "Expected low surrogate following the high surrogate"; 124| 8| case json_errc::illegal_unicode_character: ------------------ | Branch (124:17): [True: 8, False: 0] ------------------ 125| 8| return "Illegal unicode character"; 126| 0| case json_errc::unexpected_character: ------------------ | Branch (126:17): [True: 0, False: 8] ------------------ 127| 0| return "Unexpected character"; 128| 0| default: ------------------ | Branch (128:17): [True: 0, False: 8] ------------------ 129| 0| return "Unknown JSON parser error"; 130| 8| } 131| 8| } _ZN8jsoncons14json_exceptionD2Ev: 27| 200| virtual ~json_exception() = default; _ZN8jsoncons9ser_errorC1ERKS0_: 208| 100| ser_error(const ser_error& other) = default; _ZN8jsoncons9ser_errorC1ENSt3__110error_codeEmm: 194| 100| : ec_(ec), line_(line), column_(column) 195| 100| { 196| 100| err_ = to_what_arg(ec, "", line, column); 197| 100| } _ZN8jsoncons9ser_error11to_what_argENSt3__110error_codeEPKcmm: 233| 100| { 234| 100| std::string what_arg(s); 235| 100| if (!what_arg.empty()) ------------------ | Branch (235:17): [True: 0, False: 100] ------------------ 236| 0| { 237| 0| what_arg.append(": "); 238| 0| } 239| 100| what_arg.append(ec.message()); 240| 100| if (line != 0 && column != 0) ------------------ | Branch (240:17): [True: 100, False: 0] | Branch (240:30): [True: 100, False: 0] ------------------ 241| 100| { 242| 100| what_arg.append(" at line "); 243| 100| what_arg.append(std::to_string(line)); 244| 100| what_arg.append(" and column "); 245| 100| what_arg.append(std::to_string(column)); 246| 100| } 247| 0| else if (column != 0) ------------------ | Branch (247:22): [True: 0, False: 0] ------------------ 248| 0| { 249| 0| what_arg.append(" at position "); 250| 0| what_arg.append(std::to_string(column)); 251| 0| } 252| 100| return what_arg; 253| 100| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2EOS7_: 49| 50.7M| index_key_value(index_key_value&&) = default; _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRmRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 171k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 171k| { 45| 171k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRlRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 304k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 304k| { 45| 304k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRdRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 60.6k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 60.6k| { 45| 60.6k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRKNS_16json_array_arg_tERNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 3.42M| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 3.42M| { 45| 3.42M| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJNS_9null_typeERNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 48.3k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 48.3k| { 45| 48.3k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRbRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 180k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 180k| { 45| 180k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEEEC2IJRKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERNS_12semantic_tagEEEEONS3_12basic_stringIcSB_S5_EElDpOT_: 43| 25.8M| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 25.8M| { 45| 25.8M| } _ZN8jsoncons18is_trivial_storageENS_17json_storage_kindE: 227| 83.6M| { 228| 83.6M| static const uint8_t mask{ uint8_t(json_storage_kind::long_str) & uint8_t(json_storage_kind::byte_str) 229| 83.6M| & uint8_t(json_storage_kind::array) & uint8_t(json_storage_kind::object) }; 230| 83.6M| return (uint8_t(storage_kind) & mask) != mask; 231| 83.6M| } _ZN8jsoncons19typed_array_visitorD2Ev: 33| 8.06k| virtual ~typed_array_visitor() = default; _ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 414| 171k| { 415| 171k| visit_uint64(value, tag, context, ec); 416| 171k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 171k|#define JSONCONS_VISITOR_RETURN return true ------------------ 417| 171k| } _ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE: 351| 3.42M| { 352| 3.42M| visit_end_array(context, ec); 353| 3.42M| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 3.42M|#define JSONCONS_VISITOR_RETURN return true ------------------ 354| 3.42M| } _ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 423| 304k| { 424| 304k| visit_int64(value, tag, context, ec); 425| 304k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 304k|#define JSONCONS_VISITOR_RETURN return true ------------------ 426| 304k| } _ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 441| 60.6k| { 442| 60.6k| visit_double(value, tag, context, ec); 443| 60.6k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 60.6k|#define JSONCONS_VISITOR_RETURN return true ------------------ 444| 60.6k| } _ZN8jsoncons18basic_json_visitorIcEC2Ev: 103| 8.06k| basic_json_visitor() = default; _ZN8jsoncons26basic_default_json_visitorIcEC2Ev: 811| 2.68k| basic_default_json_visitor() = default; _ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 365| 48.3k| { 366| 48.3k| visit_null(tag, context, ec); 367| 48.3k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 48.3k|#define JSONCONS_VISITOR_RETURN return true ------------------ 368| 48.3k| } _ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE: 383| 25.8M| { 384| 25.8M| visit_string(value, tag, context, ec); 385| 25.8M| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 25.8M|#define JSONCONS_VISITOR_RETURN return true ------------------ 386| 25.8M| } _ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 374| 180k| { 375| 180k| visit_bool(value, tag, context, ec); 376| 180k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 180k|#define JSONCONS_VISITOR_RETURN return true ------------------ 377| 180k| } _ZN8jsoncons18basic_json_visitorIcE5flushEv: 108| 2.58k| { 109| 2.58k| visit_flush(); 110| 2.58k| } _ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 339| 3.42M| { 340| 3.42M| visit_begin_array(tag, context, ec); 341| 3.42M| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 3.42M|#define JSONCONS_VISITOR_RETURN return true ------------------ 342| 3.42M| } _ZN8jsoncons11ser_contextD2Ev: 21| 2.68k| virtual ~ser_context() = default; _ZN8jsoncons13string_sourceIcEC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_PNS3_9enable_ifIXsr10ext_traits14is_sequence_ofISA_cEE5valueEvE4typeE: 451| 2.68k| : data_(s.data()), current_(s.data()), end_(s.data()+s.size()) 452| 2.68k| { 453| 2.68k| } _ZNK8jsoncons13string_sourceIcE8is_errorEv: 469| 2.68k| { 470| 2.68k| return false; 471| 2.68k| } _ZNK8jsoncons13string_sourceIcE3eofEv: 464| 17.5k| { 465| 17.5k| return current_ == end_; 466| 17.5k| } _ZN8jsoncons13string_sourceIcE11read_bufferEv: 498| 2.68k| { 499| 2.68k| const value_type* data = current_; 500| 2.68k| std::size_t length = end_ - current_; 501| 2.68k| current_ = end_; 502| | 503| 2.68k| return span(data, length); 504| 2.68k| } _ZN8jsoncons19text_source_adaptorINS_13string_sourceIcEEEC2IRNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEOT_: 38| 2.68k| : source_(std::forward(source)), bof_(true) 39| 2.68k| { 40| 2.68k| } _ZNK8jsoncons19text_source_adaptorINS_13string_sourceIcEEE8is_errorEv: 48| 2.68k| { 49| 2.68k| return source_.is_error(); 50| 2.68k| } _ZN8jsoncons19text_source_adaptorINS_13string_sourceIcEEE11read_bufferERNSt3__110error_codeE: 53| 17.5k| { 54| 17.5k| if (source_.eof()) ------------------ | Branch (54:17): [True: 14.8k, False: 2.68k] ------------------ 55| 14.8k| { 56| 14.8k| return span(); 57| 14.8k| } 58| | 59| 2.68k| auto s = source_.read_buffer(); 60| 2.68k| const value_type* data = s.data(); 61| 2.68k| std::size_t length = s.size(); 62| | 63| 2.68k| if (bof_ && length > 0) ------------------ | Branch (63:17): [True: 2.68k, False: 0] | Branch (63:25): [True: 2.68k, False: 0] ------------------ 64| 2.68k| { 65| 2.68k| auto r = unicode_traits::detect_encoding_from_bom(data, length); 66| 2.68k| if (!(r.encoding == unicode_traits::encoding_kind::utf8 || r.encoding == unicode_traits::encoding_kind::undetected)) ------------------ | Branch (66:23): [True: 8, False: 2.67k] | Branch (66:76): [True: 2.67k, False: 8] ------------------ 67| 8| { 68| 8| ec = json_errc::illegal_unicode_character; 69| 8| return span(); 70| 8| } 71| 2.67k| length -= (r.ptr - data); 72| 2.67k| data = r.ptr; 73| 2.67k| bof_ = false; 74| 2.67k| } 75| 2.67k| return span(data, length); 76| 2.68k| } _ZN8jsoncons4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE7destroyEPNS0_11heap_stringIcS2_S5_EE: 169| 20.8k| { 170| 20.8k| if (ptr != nullptr) ------------------ | Branch (170:13): [True: 20.8k, False: 0] ------------------ 171| 20.8k| { 172| 20.8k| heap_string_type* rawp = ext_traits::to_plain_pointer(ptr); 173| | 174| 20.8k| char* q = launder_cast(rawp); 175| | 176| 20.8k| char* p = q - ptr->offset_; 177| | 178| 20.8k| std::size_t mem_size = ptr->align_pad_ + aligned_size(ptr->length_*sizeof(char_type)); 179| 20.8k| byte_allocator_type byte_alloc(ptr->get_allocator()); 180| 20.8k| byte_alloc.deallocate(p,mem_size); 181| 20.8k| } 182| 20.8k| } _ZN8jsoncons4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE12aligned_sizeEm: 119| 41.7k| { 120| 41.7k| return sizeof(storage_type) + n; 121| 41.7k| } _ZN8jsoncons4heap16heap_string_baseINS_9null_typeENSt3__19allocatorIcEEE13get_allocatorEv: 35| 20.8k| { 36| 20.8k| return alloc_; 37| 20.8k| } _ZN8jsoncons4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE6createEPKcmS2_RKS5_: 126| 20.8k| { 127| 20.8k| std::size_t len = aligned_size(length*sizeof(char_type)); 128| | 129| 20.8k| std::size_t align = alignof(storage_type); 130| 20.8k| char* q = nullptr; 131| 20.8k| char* storage = nullptr; 132| 20.8k| byte_allocator_type byte_alloc(alloc); 133| 20.8k| uint8_t align_pad = 0; 134| | 135| 20.8k| if (align <= 8) { ------------------ | Branch (135:13): [True: 20.8k, False: 0] ------------------ 136| 20.8k| byte_pointer ptr = byte_alloc.allocate(len); 137| 20.8k| q = ext_traits::to_plain_pointer(ptr); 138| | 139| 20.8k| if (reinterpret_cast(q) % align == 0) { ------------------ | Branch (139:17): [True: 20.8k, False: 0] ------------------ 140| 20.8k| storage = q; 141| 20.8k| } else { 142| 0| byte_alloc.deallocate(ptr, len); 143| 0| } 144| 20.8k| } 145| | 146| 20.8k| if (storage == nullptr) { ------------------ | Branch (146:13): [True: 0, False: 20.8k] ------------------ 147| 0| align_pad = uint8_t(align-1); 148| 0| byte_pointer ptr = byte_alloc.allocate(align_pad+len); 149| 0| q = ext_traits::to_plain_pointer(ptr); 150| 0| storage = align_up(q, align); 151| 0| JSONCONS_ASSERT(storage >= q); ------------------ | | 45| 0|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 0] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 152| 0| } 153| | 154| 20.8k| heap_string_type* ps = new(storage)heap_string_type(extra, byte_alloc); 155| | 156| 20.8k| auto psa = launder_cast(storage); 157| | 158| 20.8k| CharT* p = new(&psa->c)char_type[length + 1]; 159| 20.8k| std::memcpy(p, s, length*sizeof(char_type)); 160| 20.8k| p[length] = 0; 161| 20.8k| ps->p_ = std::pointer_traits::pointer_to(*p); 162| 20.8k| ps->length_ = length; 163| 20.8k| ps->offset_ = (uint8_t)(storage - q); 164| 20.8k| ps->align_pad_ = align_pad; 165| 20.8k| return std::pointer_traits::pointer_to(*ps); 166| 20.8k| } _ZN8jsoncons4heap11heap_stringIcNS_9null_typeENSt3__19allocatorIcEEEC2ES2_RKS5_: 69| 20.8k| : heap_string_base(extra, alloc) 70| 20.8k| { 71| 20.8k| } _ZN8jsoncons4heap16heap_string_baseINS_9null_typeENSt3__19allocatorIcEEEC2ERKS2_RKS5_: 45| 20.8k| : extra_(extra), alloc_(alloc) 46| 20.8k| { 47| 20.8k| } _ZN8jsoncons10ext_traits16to_plain_pointerINS_4heap11heap_stringIcNS_9null_typeENSt3__19allocatorIcEEEEEEPT_SA_: 241| 20.8k| { 242| 20.8k| return (ptr); 243| 20.8k| } _ZN8jsoncons10ext_traits16to_plain_pointerINS_10json_arrayINS_10basic_jsonIcNS_23order_preserving_policyENSt3__19allocatorIcEEEENS5_6vectorEEEEEPT_SC_: 241| 6.85M| { 242| 6.85M| return (ptr); 243| 6.85M| } _ZN8jsoncons10ext_traits16to_plain_pointerIcEEPT_S3_: 241| 20.8k| { 242| 20.8k| return (ptr); 243| 20.8k| } _ZN8jsoncons10ext_traits14integer_limitsIlvE6lowestEv: 110| 305k| { 111| 305k| return std::numeric_limits::lowest(); 112| 305k| } _ZN8jsoncons14dec_to_integerIlcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_: 327| 309k|{ 328| 309k| if (length == 0) ------------------ | Branch (328:9): [True: 0, False: 309k] ------------------ 329| 0| { 330| 0| return to_number_result(s, std::errc::invalid_argument); 331| 0| } 332| | 333| 309k| bool sign = *s == '-'; 334| 309k| s += sign; 335| 309k| length -= sign; 336| | 337| 309k| using U = typename ext_traits::make_unsigned::type; 338| | 339| 309k| U num; 340| 309k| auto ru = dec_to_integer(s, length, num); 341| 309k| if (ru.ec != std::errc{}) ------------------ | Branch (341:9): [True: 3.86k, False: 305k] ------------------ 342| 3.86k| { 343| 3.86k| return to_number_result(ru.ptr, ru.ec); 344| 3.86k| } 345| 305k| if (sign) ------------------ | Branch (345:9): [True: 305k, False: 0] ------------------ 346| 305k| { 347| 305k| if (num > static_cast(-((ext_traits::integer_limits::lowest)()+T(1))) + U(1)) ------------------ | Branch (347:13): [True: 1.20k, False: 304k] ------------------ 348| 1.20k| { 349| 1.20k| return to_number_result(ru.ptr, std::errc::result_out_of_range); 350| 1.20k| } 351| 304k| else 352| 304k| { 353| 304k| value = static_cast(U(0) - num); 354| 304k| return to_number_result(ru.ptr, std::errc{}); 355| 304k| } 356| 305k| } 357| 0| else 358| 0| { 359| 0| if (num > static_cast((ext_traits::integer_limits::max)())) ------------------ | Branch (359:13): [True: 0, False: 0] ------------------ 360| 0| { 361| 0| return to_number_result(ru.ptr, std::errc::result_out_of_range); 362| 0| } 363| 0| else 364| 0| { 365| 0| value = static_cast(num); 366| 0| return to_number_result(ru.ptr, std::errc{}); 367| 0| } 368| 0| } 369| 305k|} _ZN8jsoncons16to_number_resultIcEC2EPKcNSt3__14errcE: 141| 796k| : ptr(ptr_), ec(ec_) 142| 796k| { 143| 796k| } _ZN8jsoncons14dec_to_integerImcEENSt3__19enable_ifIXaasr10ext_traits14integer_limitsIT_EE14is_specializedntsr10ext_traits14integer_limitsIS3_EE9is_signedENS_16to_number_resultIT0_EEE4typeEPKS5_mRS3_: 265| 484k|{ 266| 484k| if (JSONCONS_UNLIKELY(length == 0)) ------------------ | | 78| 484k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 484k] | | ------------------ ------------------ 267| 0| { 268| 0| return to_number_result(s, std::errc::invalid_argument); 269| 0| } 270| | 271| 484k| static constexpr T max_value = (ext_traits::integer_limits::max)(); 272| 484k| static constexpr T max_value_div_10 = max_value / 10; 273| | 274| 484k| T num = 0; 275| 484k| const CharT* cur = s; 276| 484k| const CharT* last = s + length; 277| 484k| static constexpr std::size_t digits10 = static_cast(ext_traits::integer_limits::digits10); 278| 484k| const std::size_t n = (std::min)(digits10, length); 279| 484k| const CharT* stop = s + n; 280| | 281| 1.16M| while (cur < stop) ------------------ | Branch (281:12): [True: 676k, False: 484k] ------------------ 282| 676k| { 283| 676k| uint8_t d; 284| 676k| if (JSONCONS_LIKELY((d = static_cast(*cur - '0')) <= 9) ) ------------------ | | 77| 676k|#define JSONCONS_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (77:28): [True: 676k, False: 0] | | ------------------ ------------------ 285| 676k| { 286| 676k| num = static_cast(d) + num*10; 287| 676k| } 288| 0| else 289| 0| { 290| 0| return to_number_result(cur, std::errc::invalid_argument); 291| 0| } 292| 676k| ++cur; 293| 676k| } 294| 484k| if (cur == last) ------------------ | Branch (294:9): [True: 475k, False: 8.48k] ------------------ 295| 475k| { 296| 475k| value = num; 297| 475k| return to_number_result(cur, std::errc{}); 298| 475k| } 299| 8.48k| if (cur+1 != last) ------------------ | Branch (299:9): [True: 4.10k, False: 4.38k] ------------------ 300| 4.10k| { 301| 4.10k| return to_number_result(cur, std::errc::result_out_of_range); 302| 4.10k| } 303| 4.38k| if (is_digit(*cur)) ------------------ | Branch (303:9): [True: 4.38k, False: 0] ------------------ 304| 4.38k| { 305| 4.38k| if (num > max_value_div_10) ------------------ | Branch (305:13): [True: 1.40k, False: 2.98k] ------------------ 306| 1.40k| { 307| 1.40k| return to_number_result(cur, std::errc::result_out_of_range); 308| 1.40k| } 309| 2.98k| uint8_t d = static_cast(*cur - '0'); 310| 2.98k| num = num*10; 311| 2.98k| if (num > max_value - d) ------------------ | Branch (311:13): [True: 1.52k, False: 1.45k] ------------------ 312| 1.52k| { 313| 1.52k| return to_number_result(s, std::errc::result_out_of_range); 314| 1.52k| } 315| 1.45k| num += d; 316| 1.45k| ++cur; 317| 1.45k| value = num; 318| 1.45k| return to_number_result(cur, std::errc{}); 319| 2.98k| } 320| | 321| 0| return to_number_result(cur, std::errc::invalid_argument); 322| 4.38k|} _ZN8jsoncons8is_digitEc: 83| 4.38k|constexpr bool is_digit(char d) { 84| 4.38k| return is_type(static_cast(d), (uint8_t)(DIGIT_TYPE_ZERO | DIGIT_TYPE_NONZERO)); 85| 4.38k|} _ZN8jsoncons7is_typeEhh: 68| 4.38k|constexpr bool is_type(uint8_t d, uint8_t type) { 69| 4.38k| return (digi_table[d] & type) != 0; 70| 4.38k|} _ZNK8jsoncons16to_number_resultIcEcvbEv: 150| 484k| { 151| 484k| return ec == std::errc{}; 152| 484k| } _ZN8jsoncons16decstr_to_doubleEPKcmRd: 866| 60.6k|{ 867| 60.6k| const char* cur = s+length; 868| 60.6k| char *end = nullptr; 869| 60.6k| val = strtod(s, &end); 870| 60.6k| const char* str_end = end; 871| 60.6k| if (JSONCONS_UNLIKELY(end < cur)) ------------------ | | 78| 60.6k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 5, False: 60.6k] | | ------------------ ------------------ 872| 5| { 873| 5| if (*end == '.') ------------------ | Branch (873:13): [True: 0, False: 5] ------------------ 874| 0| { 875| 0| std::string buf{s, length}; 876| 0| char* dot_ptr = &buf[0] + (cur - end - 1); 877| 0| *dot_ptr = ','; 878| 0| end = nullptr; 879| 0| val = strtod(buf.c_str(), &end); 880| 0| str_end = s + (end - &buf[0]); 881| 0| } 882| 5| if (JSONCONS_UNLIKELY(str_end != cur)) ------------------ | | 78| 5|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 5, False: 0] | | ------------------ ------------------ 883| 5| { 884| 5| return to_number_result{str_end,std::errc::invalid_argument}; 885| 5| } 886| 5| } 887| 60.6k| if (JSONCONS_UNLIKELY(val <= -HUGE_VAL || val >= HUGE_VAL)) ------------------ | | 78| 119k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 2.45k, False: 58.2k] | | | Branch (78:50): [True: 1.32k, False: 59.3k] | | | Branch (78:50): [True: 1.12k, False: 58.2k] | | ------------------ ------------------ 888| 2.45k| { 889| 2.45k| return to_number_result{str_end, std::errc::result_out_of_range}; 890| 2.45k| } 891| 58.2k| return to_number_result{str_end}; 892| 60.6k|} _ZN8jsoncons16to_number_resultIcEC2EPKc: 137| 58.2k| : ptr(ptr_), ec(std::errc{}) 138| 58.2k| { 139| 58.2k| } _ZN8jsoncons14unicode_traits24detect_encoding_from_bomIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_22detect_encoding_resultIS4_EEE4typeEPKS4_m: 65| 2.68k| { 66| 2.68k| const uint8_t bom_utf8[] = {0xef,0xbb,0xbf}; 67| 2.68k| const uint8_t bom_utf16le[] = {0xff,0xfe}; 68| 2.68k| const uint8_t bom_utf16be[] = {0xfe,0xff}; 69| 2.68k| const uint8_t bom_utf32le[] = {0xff,0xfe,0x00,0x00}; 70| 2.68k| const uint8_t bom_utf32be[] = {0x00,0x00,0xfe,0xff}; 71| | 72| 2.68k| if (length >= 4 && !memcmp(data,bom_utf32le,4)) ------------------ | Branch (72:13): [True: 2.43k, False: 257] | Branch (72:28): [True: 1, False: 2.42k] ------------------ 73| 1| { 74| 1| return detect_encoding_result{data+4,encoding_kind::utf32le}; 75| 1| } 76| 2.68k| else if (length >= 4 && !memcmp(data,bom_utf32be,4)) ------------------ | Branch (76:18): [True: 2.42k, False: 257] | Branch (76:33): [True: 1, False: 2.42k] ------------------ 77| 1| { 78| 1| return detect_encoding_result{data+4,encoding_kind::utf32be}; 79| 1| } 80| 2.68k| else if (length >= 2 && !memcmp(data,bom_utf16le,2)) ------------------ | Branch (80:18): [True: 2.65k, False: 31] | Branch (80:33): [True: 5, False: 2.64k] ------------------ 81| 5| { 82| 5| return detect_encoding_result{data+2,encoding_kind::utf16le}; 83| 5| } 84| 2.68k| else if (length >= 2 && !memcmp(data,bom_utf16be,2)) ------------------ | Branch (84:18): [True: 2.64k, False: 31] | Branch (84:33): [True: 1, False: 2.64k] ------------------ 85| 1| { 86| 1| return detect_encoding_result{data+2,encoding_kind::utf16be}; 87| 1| } 88| 2.67k| else if (length >= 3 && !memcmp(data,bom_utf8,3)) ------------------ | Branch (88:18): [True: 2.54k, False: 130] | Branch (88:33): [True: 8, False: 2.54k] ------------------ 89| 8| { 90| 8| return detect_encoding_result{data+3,encoding_kind::utf8}; 91| 8| } 92| 2.67k| else 93| 2.67k| { 94| 2.67k| return detect_encoding_result{data,encoding_kind::undetected}; 95| 2.67k| } 96| 2.68k| } _ZN8jsoncons3csv15make_error_codeENS0_8csv_errcE: 76| 92|{ 77| 92| return std::error_code(static_cast(result),csv_error_category()); 78| 92|} _ZN8jsoncons3csv18csv_error_categoryEv: 69| 92|{ 70| 92| static csv_error_category_impl instance; 71| 92| return instance; 72| 92|} _ZNK8jsoncons3csv23csv_error_category_impl7messageEi: 40| 92| { 41| 92| switch (static_cast(ev)) 42| 92| { 43| 0| case csv_errc::unexpected_eof: ------------------ | Branch (43:13): [True: 0, False: 92] ------------------ 44| 0| return "Unexpected end of file"; 45| 1| case csv_errc::source_error: ------------------ | Branch (45:13): [True: 1, False: 91] ------------------ 46| 1| return "Source error"; 47| 0| case csv_errc::expected_quote: ------------------ | Branch (47:13): [True: 0, False: 92] ------------------ 48| 0| return "Expected quote character"; 49| 0| case csv_errc::syntax_error: ------------------ | Branch (49:13): [True: 0, False: 92] ------------------ 50| 0| return "CSV syntax error"; 51| 0| case csv_errc::invalid_parse_state: ------------------ | Branch (51:13): [True: 0, False: 92] ------------------ 52| 0| return "Invalid CSV parser state"; 53| 0| case csv_errc::invalid_escaped_char: ------------------ | Branch (53:13): [True: 0, False: 92] ------------------ 54| 0| return "Invalid character following quote escape character"; 55| 86| case csv_errc::unexpected_char_between_fields: ------------------ | Branch (55:13): [True: 86, False: 6] ------------------ 56| 86| return "Unexpected character between fields"; 57| 0| case csv_errc::max_nesting_depth_exceeded: ------------------ | Branch (57:13): [True: 0, False: 92] ------------------ 58| 0| return "Data item nesting exceeds limit in options"; 59| 5| case csv_errc::invalid_number: ------------------ | Branch (59:13): [True: 5, False: 87] ------------------ 60| 5| return "Invalid number"; 61| 0| default: ------------------ | Branch (61:13): [True: 0, False: 92] ------------------ 62| 0| return "Unknown CSV parser error"; 63| 92| } 64| 92| } _ZN8jsoncons3csv17basic_csv_optionsIcEC1Ev: 732| 2.68k| basic_csv_options() = default; _ZN8jsoncons3csv24basic_csv_options_commonIcEC2Ev: 303| 2.68k| : flat_{true}, 304| 2.68k| enable_nan_to_num_{false}, 305| 2.68k| enable_inf_to_num_{false}, 306| 2.68k| enable_neginf_to_num_{false}, 307| 2.68k| enable_nan_to_str_{false}, 308| 2.68k| enable_inf_to_str_{false}, 309| 2.68k| enable_neginf_to_str_{false}, 310| 2.68k| enable_str_to_nan_{false}, 311| 2.68k| enable_str_to_inf_{false}, 312| 2.68k| enable_str_to_neginf_{false} 313| 2.68k| { 314| 2.68k| } _ZN8jsoncons3csv24basic_csv_decode_optionsIcEC2Ev: 495| 2.68k| : assume_header_(false), 496| 2.68k| ignore_empty_values_(false), 497| 2.68k| ignore_empty_lines_(true), 498| 2.68k| trim_leading_(false), 499| 2.68k| trim_trailing_(false), 500| 2.68k| trim_leading_inside_quotes_(false), 501| 2.68k| trim_trailing_inside_quotes_(false), 502| 2.68k| unquoted_empty_value_is_null_(false), 503| 2.68k| infer_types_(true), 504| 2.68k| lossless_number_(false) 505| 2.68k| {} _ZN8jsoncons3csv24basic_csv_encode_optionsIcEC2Ev: 640| 2.68k| { 641| 2.68k| line_delimiter_.push_back('\n'); 642| 2.68k| } _ZN8jsoncons3csv24basic_csv_options_commonIcED2Ev: 320| 5.37k| virtual ~basic_csv_options_common() = default; _ZN8jsoncons3csv17basic_csv_optionsIcEC1ERKS2_: 733| 2.68k| basic_csv_options(const basic_csv_options&) = default; _ZN8jsoncons3csv24basic_csv_options_commonIcEC2ERKS2_: 316| 2.68k| basic_csv_options_common(const basic_csv_options_common&) = default; _ZN8jsoncons3csv24basic_csv_decode_optionsIcEC2ERKS2_: 507| 2.68k| basic_csv_decode_options(const basic_csv_decode_options& other) = default; _ZN8jsoncons3csv24basic_csv_encode_optionsIcEC2ERKS2_: 644| 2.68k| basic_csv_encode_options(const basic_csv_encode_options& other) = default; _ZN8jsoncons3csv17basic_csv_optionsIcE13assume_headerEb: 757| 2.68k| { 758| 2.68k| this->assume_header_ = value; 759| 2.68k| return *this; 760| 2.68k| } _ZN8jsoncons3csv17basic_csv_optionsIcE12mapping_kindENS0_16csv_mapping_kindE: 909| 2.68k| { 910| 2.68k| this->mapping_kind_ = value; 911| 2.68k| return *this; 912| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE13assume_headerEv: 540| 2.68k| { 541| 2.68k| return assume_header_; 542| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE15comment_starterEv: 600| 2.68k| { 601| 2.68k| return comment_starter_; 602| 2.68k| } _ZNK8jsoncons3csv24basic_csv_options_commonIcE15field_delimiterEv: 334| 2.68k| { 335| 2.68k| return field_delimiter_; 336| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12header_linesEv: 535| 2.68k| { 536| 2.68k| return (assume_header_ && header_lines_ <= 1) ? 1 : header_lines_; ------------------ | Branch (536:17): [True: 2.68k, False: 0] | Branch (536:35): [True: 2.68k, False: 0] ------------------ 537| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE19ignore_empty_valuesEv: 545| 2.68k| { 546| 2.68k| return ignore_empty_values_; 547| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE18ignore_empty_linesEv: 550| 2.68k| { 551| 2.68k| return ignore_empty_lines_; 552| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE11infer_typesEv: 590| 2.68k| { 591| 2.68k| return infer_types_; 592| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE15lossless_numberEv: 595| 2.68k| { 596| 2.68k| return lossless_number_; 597| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12mapping_kindEv: 605| 2.68k| { 606| 2.68k| return mapping_kind_ != csv_mapping_kind() ? mapping_kind_ : (assume_header() || this->column_names().size() > 0 ? csv_mapping_kind::n_objects : csv_mapping_kind::n_rows); ------------------ | Branch (606:16): [True: 2.68k, False: 0] | Branch (606:71): [True: 0, False: 0] | Branch (606:90): [True: 0, False: 0] ------------------ 607| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE9max_linesEv: 610| 2.68k| { 611| 2.68k| return max_lines_; 612| 2.68k| } _ZNK8jsoncons3csv24basic_csv_options_commonIcE10quote_charEv: 344| 2.68k| { 345| 2.68k| return quote_char_; 346| 2.68k| } _ZNK8jsoncons3csv24basic_csv_options_commonIcE17quote_escape_charEv: 349| 2.68k| { 350| 2.68k| return quote_escape_char_; 351| 2.68k| } _ZNK8jsoncons3csv24basic_csv_options_commonIcE18subfield_delimiterEv: 339| 2.68k| { 340| 2.68k| return subfield_delimiter_; 341| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12trim_leadingEv: 555| 2.68k| { 556| 2.68k| return trim_leading_; 557| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE26trim_leading_inside_quotesEv: 565| 2.68k| { 566| 2.68k| return trim_leading_inside_quotes_; 567| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE13trim_trailingEv: 560| 2.68k| { 561| 2.68k| return trim_trailing_; 562| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE27trim_trailing_inside_quotesEv: 570| 2.68k| { 571| 2.68k| return trim_trailing_inside_quotes_; 572| 2.68k| } _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE28unquoted_empty_value_is_nullEv: 585| 2.68k| { 586| 2.68k| return unquoted_empty_value_is_null_; 587| 2.68k| } _ZNK8jsoncons3csv24basic_csv_options_commonIcE17enable_str_to_nanEv: 384| 2.68k| { 385| 2.68k| return enable_str_to_nan_; 386| 2.68k| } _ZNK8jsoncons3csv24basic_csv_options_commonIcE17enable_str_to_infEv: 394| 2.68k| { 395| 2.68k| return enable_str_to_inf_; 396| 2.68k| } _ZNK8jsoncons3csv24basic_csv_options_commonIcE20enable_str_to_neginfEv: 404| 2.68k| { 405| 2.68k| return enable_str_to_neginf_ || enable_str_to_inf_; ------------------ | Branch (405:16): [True: 0, False: 2.68k] | Branch (405:41): [True: 0, False: 2.68k] ------------------ 406| 2.68k| } _ZN8jsoncons3csv6detail18parse_column_typesIcNSt3__16vectorINS0_13csv_type_infoENS3_9allocatorIS5_EEEEEEvRKNS3_12basic_stringIT_NS3_11char_traitsISA_EENS6_ISA_EEEERT0_: 119| 2.68k|{ 120| 2.68k| const std::map,csv_column_type> type_dictionary = 121| 2.68k| { 122| | 123| 2.68k| {JSONCONS_STRING_VIEW_CONSTANT(CharT,"string"),csv_column_type::string_t}, ------------------ | | 260| 2.68k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) string_view_constant_of_type(Str, JSONCONS_PP_WIDEN(Str)) | | ------------------ | | | | 256| 2.68k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A) | | | | ------------------ | | | | | | 253| 2.68k|#define JSONCONS_PP_EXPAND(X) X | | | | ------------------ | | ------------------ ------------------ 124| 2.68k| {JSONCONS_STRING_VIEW_CONSTANT(CharT,"integer"),csv_column_type::integer_t}, ------------------ | | 260| 2.68k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) string_view_constant_of_type(Str, JSONCONS_PP_WIDEN(Str)) | | ------------------ | | | | 256| 2.68k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A) | | | | ------------------ | | | | | | 253| 2.68k|#define JSONCONS_PP_EXPAND(X) X | | | | ------------------ | | ------------------ ------------------ 125| 2.68k| {JSONCONS_STRING_VIEW_CONSTANT(CharT,"float"),csv_column_type::float_t}, ------------------ | | 260| 2.68k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) string_view_constant_of_type(Str, JSONCONS_PP_WIDEN(Str)) | | ------------------ | | | | 256| 2.68k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A) | | | | ------------------ | | | | | | 253| 2.68k|#define JSONCONS_PP_EXPAND(X) X | | | | ------------------ | | ------------------ ------------------ 126| 2.68k| {JSONCONS_STRING_VIEW_CONSTANT(CharT,"boolean"),csv_column_type::boolean_t} ------------------ | | 260| 2.68k|#define JSONCONS_STRING_VIEW_CONSTANT(CharT, Str) string_view_constant_of_type(Str, JSONCONS_PP_WIDEN(Str)) | | ------------------ | | | | 256| 2.68k|#define JSONCONS_PP_WIDEN(A) JSONCONS_PP_EXPAND(L ## A) | | | | ------------------ | | | | | | 253| 2.68k|#define JSONCONS_PP_EXPAND(X) X | | | | ------------------ | | ------------------ ------------------ 127| 2.68k| }; 128| | 129| 2.68k| column_state state = column_state::sequence; 130| 2.68k| int depth = 0; 131| 2.68k| std::basic_string buffer; 132| | 133| 2.68k| auto p = types.begin(); 134| 2.68k| while (p != types.end()) ------------------ | Branch (134:12): [True: 0, False: 2.68k] ------------------ 135| 0| { 136| 0| switch (state) ------------------ | Branch (136:17): [True: 0, False: 0] ------------------ 137| 0| { 138| 0| case column_state::sequence: ------------------ | Branch (138:13): [True: 0, False: 0] ------------------ 139| 0| { 140| 0| switch (*p) 141| 0| { 142| 0| case ' ': case '\t':case '\r': case '\n': ------------------ | Branch (142:17): [True: 0, False: 0] | Branch (142:27): [True: 0, False: 0] | Branch (142:37): [True: 0, False: 0] | Branch (142:48): [True: 0, False: 0] ------------------ 143| 0| ++p; 144| 0| break; 145| 0| case '[': ------------------ | Branch (145:17): [True: 0, False: 0] ------------------ 146| 0| ++depth; 147| 0| ++p; 148| 0| break; 149| 0| case ']': ------------------ | Branch (149:17): [True: 0, False: 0] ------------------ 150| 0| JSONCONS_ASSERT(depth > 0); ------------------ | | 45| 0|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 0] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 151| 0| --depth; 152| 0| ++p; 153| 0| break; 154| 0| case '*': ------------------ | Branch (154:17): [True: 0, False: 0] ------------------ 155| 0| { 156| 0| JSONCONS_ASSERT(column_types.size() != 0); ------------------ | | 45| 0|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 0] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 157| 0| std::size_t offset = 0; 158| 0| std::size_t level = column_types.size() > 0 ? column_types.back().level: 0; ------------------ | Branch (158:45): [True: 0, False: 0] ------------------ 159| 0| if (level > 0) ------------------ | Branch (159:29): [True: 0, False: 0] ------------------ 160| 0| { 161| 0| for (auto it = column_types.rbegin(); 162| 0| it != column_types.rend() && level == (*it).level; ------------------ | Branch (162:34): [True: 0, False: 0] | Branch (162:34): [True: 0, False: 0] | Branch (162:63): [True: 0, False: 0] ------------------ 163| 0| ++it) 164| 0| { 165| 0| ++offset; 166| 0| } 167| 0| } 168| 0| else 169| 0| { 170| 0| offset = 1; 171| 0| } 172| 0| column_types.emplace_back(csv_column_type::repeat_t,depth,offset); 173| 0| ++p; 174| 0| break; 175| 0| } 176| 0| default: ------------------ | Branch (176:17): [True: 0, False: 0] ------------------ 177| 0| buffer.clear(); 178| 0| state = column_state::label; 179| 0| break; 180| 0| } 181| 0| break; 182| 0| } 183| 0| case column_state::label: ------------------ | Branch (183:13): [True: 0, False: 0] ------------------ 184| 0| { 185| 0| switch (*p) 186| 0| { 187| 0| case '*': ------------------ | Branch (187:21): [True: 0, False: 0] ------------------ 188| 0| { 189| 0| auto it = type_dictionary.find(buffer); 190| 0| if (it != type_dictionary.end()) ------------------ | Branch (190:29): [True: 0, False: 0] ------------------ 191| 0| { 192| 0| column_types.emplace_back((*it).second,depth); 193| 0| buffer.clear(); 194| 0| } 195| 0| else 196| 0| { 197| 0| JSONCONS_ASSERT(false); ------------------ | | 45| 0|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, Folded] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 198| 0| } 199| 0| state = column_state::sequence; 200| 0| break; 201| 0| } 202| 0| case ',': ------------------ | Branch (202:21): [True: 0, False: 0] ------------------ 203| 0| { 204| 0| auto it = type_dictionary.find(buffer); 205| 0| if (it != type_dictionary.end()) ------------------ | Branch (205:29): [True: 0, False: 0] ------------------ 206| 0| { 207| 0| column_types.emplace_back((*it).second,depth); 208| 0| buffer.clear(); 209| 0| } 210| 0| else 211| 0| { 212| 0| JSONCONS_ASSERT(false); ------------------ | | 45| 0|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, Folded] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 213| 0| } 214| 0| ++p; 215| 0| state = column_state::sequence; 216| 0| break; 217| 0| } 218| 0| case ']': ------------------ | Branch (218:21): [True: 0, False: 0] ------------------ 219| 0| { 220| 0| JSONCONS_ASSERT(depth > 0); ------------------ | | 45| 0|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 0] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 221| 0| auto it = type_dictionary.find(buffer); 222| 0| if (it != type_dictionary.end()) ------------------ | Branch (222:29): [True: 0, False: 0] ------------------ 223| 0| { 224| 0| column_types.emplace_back((*it).second,depth); 225| 0| buffer.clear(); 226| 0| } 227| 0| else 228| 0| { 229| 0| JSONCONS_ASSERT(false); ------------------ | | 45| 0|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, Folded] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 230| 0| } 231| 0| --depth; 232| 0| ++p; 233| 0| state = column_state::sequence; 234| 0| break; 235| 0| } 236| 0| default: ------------------ | Branch (236:21): [True: 0, False: 0] ------------------ 237| 0| { 238| 0| buffer.push_back(*p); 239| 0| ++p; 240| 0| break; 241| 0| } 242| 0| } 243| 0| break; 244| 0| } 245| 0| } 246| 0| } 247| 2.68k| if (state == column_state::label) ------------------ | Branch (247:9): [True: 0, False: 2.68k] ------------------ 248| 0| { 249| 0| auto it = type_dictionary.find(buffer); 250| 0| if (it != type_dictionary.end()) ------------------ | Branch (250:13): [True: 0, False: 0] ------------------ 251| 0| { 252| 0| column_types.emplace_back((*it).second,depth); 253| 0| buffer.clear(); 254| 0| } 255| 0| else 256| 0| { 257| 0| JSONCONS_ASSERT(false); ------------------ | | 45| 0|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, Folded] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 258| 0| } 259| 0| } 260| 2.68k|} _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE12column_typesEv: 615| 2.68k| { 616| 2.68k| return column_types_; 617| 2.68k| } _ZN8jsoncons3csv6detail18parse_column_namesIcNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEEvRKNS5_IT_NS6_ISD_EENS8_ISD_EEEERT0_: 66| 5.37k|{ 67| 5.37k| column_state state = column_state::sequence; 68| 5.37k| typename Container::value_type buffer(cont.get_allocator()); 69| | 70| 5.37k| auto p = names.begin(); 71| 5.37k| while (p != names.end()) ------------------ | Branch (71:12): [True: 0, False: 5.37k] ------------------ 72| 0| { 73| 0| switch (state) ------------------ | Branch (73:17): [True: 0, False: 0] ------------------ 74| 0| { 75| 0| case column_state::sequence: ------------------ | Branch (75:13): [True: 0, False: 0] ------------------ 76| 0| { 77| 0| switch (*p) 78| 0| { 79| 0| case ' ': case '\t':case '\r': case '\n': ------------------ | Branch (79:21): [True: 0, False: 0] | Branch (79:31): [True: 0, False: 0] | Branch (79:41): [True: 0, False: 0] | Branch (79:52): [True: 0, False: 0] ------------------ 80| 0| ++p; 81| 0| break; 82| 0| default: ------------------ | Branch (82:21): [True: 0, False: 0] ------------------ 83| 0| buffer.clear(); 84| 0| state = column_state::label; 85| 0| break; 86| 0| } 87| 0| break; 88| 0| } 89| 0| case column_state::label: ------------------ | Branch (89:13): [True: 0, False: 0] ------------------ 90| 0| { 91| 0| switch (*p) 92| 0| { 93| 0| case ',': ------------------ | Branch (93:17): [True: 0, False: 0] ------------------ 94| 0| cont.push_back(buffer); 95| 0| buffer.clear(); 96| 0| ++p; 97| 0| state = column_state::sequence; 98| 0| break; 99| 0| default: ------------------ | Branch (99:17): [True: 0, False: 0] ------------------ 100| 0| buffer.push_back(*p); 101| 0| ++p; 102| 0| break; 103| 0| } 104| 0| break; 105| 0| } 106| 0| } 107| 0| } 108| 5.37k| if (state == column_state::label) ------------------ | Branch (108:9): [True: 0, False: 5.37k] ------------------ 109| 0| { 110| 0| cont.push_back(buffer); 111| 0| buffer.clear(); 112| 0| } 113| | 114| 5.37k|} // namespace detail _ZNK8jsoncons3csv24basic_csv_decode_optionsIcE15column_defaultsEv: 620| 2.68k| { 621| 2.68k| return column_defaults_; 622| 2.68k| } _ZNK8jsoncons3csv24basic_csv_options_commonIcE12column_namesEv: 354| 2.68k| { 355| 2.68k| return column_names_; 356| 2.68k| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEED2Ev: 743| 2.68k| { 744| 2.68k| } _ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE4lineEv: 1505| 100| { 1506| 100| return line_; 1507| 100| } _ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE6columnEv: 1510| 100| { 1511| 100| return column_; 1512| 100| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEEC2ERKNS0_24basic_csv_decode_optionsIcEERKS4_: 631| 2.68k| : alloc_(alloc), 632| 2.68k| state_(csv_parse_state::start), 633| 2.68k| err_handler_(default_csv_parsing()), 634| 2.68k| assume_header_(options.assume_header()), 635| 2.68k| comment_starter_(options.comment_starter()), 636| 2.68k| field_delimiter_(options.field_delimiter()), 637| 2.68k| header_lines_(options.header_lines()), 638| 2.68k| ignore_empty_values_(options.ignore_empty_values()), 639| 2.68k| ignore_empty_lines_(options.ignore_empty_lines()), 640| 2.68k| infer_types_(options.infer_types()), 641| 2.68k| lossless_number_(options.lossless_number()), 642| 2.68k| mapping_kind_(options.mapping_kind()), 643| 2.68k| max_lines_(options.max_lines()), 644| 2.68k| quote_char_(options.quote_char()), 645| 2.68k| quote_escape_char_(options.quote_escape_char()), 646| 2.68k| subfield_delimiter_(options.subfield_delimiter()), 647| 2.68k| trim_leading_(options.trim_leading()), 648| 2.68k| trim_leading_inside_quotes_(options.trim_leading_inside_quotes()), 649| 2.68k| trim_trailing_(options.trim_trailing()), 650| 2.68k| trim_trailing_inside_quotes_(options.trim_trailing_inside_quotes()), 651| 2.68k| unquoted_empty_value_is_null_(options.unquoted_empty_value_is_null()), 652| 2.68k| m_columns_filter_(alloc), 653| 2.68k| stack_(alloc), 654| 2.68k| column_names_(alloc), 655| 2.68k| column_types_(alloc), 656| 2.68k| column_defaults_(alloc), 657| 2.68k| state_stack_(alloc), 658| 2.68k| buffer_(alloc) 659| 2.68k| { 660| 2.68k| if (options.enable_str_to_nan()) ------------------ | Branch (660:13): [True: 0, False: 2.68k] ------------------ 661| 0| { 662| 0| string_double_map_.emplace_back(options.nan_to_str(),std::nan("")); 663| 0| } 664| 2.68k| if (options.enable_str_to_inf()) ------------------ | Branch (664:13): [True: 0, False: 2.68k] ------------------ 665| 0| { 666| 0| string_double_map_.emplace_back(options.inf_to_str(),std::numeric_limits::infinity()); 667| 0| } 668| 2.68k| if (options.enable_str_to_neginf()) ------------------ | Branch (668:13): [True: 0, False: 2.68k] ------------------ 669| 0| { 670| 0| string_double_map_.emplace_back(options.neginf_to_str(),-std::numeric_limits::infinity()); 671| 0| } 672| | 673| 2.68k| jsoncons::csv::detail::parse_column_types(options.column_types(), column_types_); 674| 2.68k| jsoncons::csv::detail::parse_column_names(options.column_defaults(), column_defaults_); 675| 2.68k| jsoncons::csv::detail::parse_column_names(options.column_names(), column_names_); 676| 2.68k| min_column_names_ = column_names_.size(); 677| 2.68k| initialize(); 678| 2.68k| } _ZN8jsoncons3csv6detail16m_columns_filterIcNSt3__19allocatorIcEEEC2ERKS5_: 258| 2.68k| : alloc_(alloc), 259| 2.68k| column_names_(alloc), 260| 2.68k| cached_events_(alloc) 261| 2.68k| { 262| 2.68k| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10initializeEv: 1516| 2.68k| { 1517| 2.68k| stack_.reserve(default_depth); 1518| 2.68k| stack_.push_back(csv_mode::initial); 1519| 2.68k| stack_.push_back((header_lines_ > 0) ? csv_mode::header : csv_mode::data); ------------------ | Branch (1519:26): [True: 2.68k, False: 0] ------------------ 1520| 2.68k| } _ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE7stoppedEv: 778| 20.1k| { 779| 20.1k| return !more_; 780| 20.1k| } _ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE16source_exhaustedEv: 783| 17.5k| { 784| 17.5k| return input_ptr_ == input_end_; 785| 17.5k| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE6updateEPKcm: 1498| 2.67k| { 1499| 2.67k| begin_input_ = data; 1500| 2.67k| input_end_ = data + length; 1501| 2.67k| input_ptr_ = begin_input_; 1502| 2.67k| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10parse_someERNS_18basic_json_visitorIcEERNS2_10error_codeE: 832| 17.5k| { 833| 17.5k| basic_json_visitor& local_visitor = (mapping_kind_ == csv_mapping_kind::m_columns) ------------------ | Branch (833:52): [True: 0, False: 17.5k] ------------------ 834| 17.5k| ? m_columns_filter_ : visitor; 835| | 836| 17.5k| switch (mapping_kind_) 837| 17.5k| { 838| 0| case csv_mapping_kind::m_columns: ------------------ | Branch (838:13): [True: 0, False: 17.5k] ------------------ 839| 0| cursor_mode_ = false; 840| 0| break; 841| 17.5k| default: ------------------ | Branch (841:13): [True: 17.5k, False: 0] ------------------ 842| 17.5k| break; 843| 17.5k| } 844| | 845| 17.5k| const CharT* local_input_end = input_end_; 846| | 847| 17.5k| if (input_ptr_ == local_input_end && more_) ------------------ | Branch (847:13): [True: 14.8k, False: 2.67k] | Branch (847:46): [True: 14.8k, False: 0] ------------------ 848| 14.8k| { 849| 14.8k| switch (state_) 850| 14.8k| { 851| 1| case csv_parse_state::start: ------------------ | Branch (851:17): [True: 1, False: 14.8k] ------------------ 852| 1| ec = csv_errc::source_error; 853| 1| more_ = false; 854| 1| return; 855| 2.23k| case csv_parse_state::before_unquoted_field: ------------------ | Branch (855:17): [True: 2.23k, False: 12.6k] ------------------ 856| 2.23k| case csv_parse_state::before_last_unquoted_field: ------------------ | Branch (856:17): [True: 0, False: 14.8k] ------------------ 857| 2.23k| end_unquoted_string_value(local_visitor, ec); 858| 2.23k| state_ = csv_parse_state::before_last_unquoted_field_tail; 859| 2.23k| break; 860| 2.22k| case csv_parse_state::before_last_unquoted_field_tail: ------------------ | Branch (860:17): [True: 2.22k, False: 12.6k] ------------------ 861| 2.22k| if (stack_.back() == csv_mode::subfields) ------------------ | Branch (861:25): [True: 0, False: 2.22k] ------------------ 862| 0| { 863| 0| stack_.pop_back(); 864| 0| local_visitor.end_array(*this, ec); 865| 0| more_ = !cursor_mode_; 866| 0| if (mapping_kind_ != csv_mapping_kind::m_columns) ------------------ | Branch (866:29): [True: 0, False: 0] ------------------ 867| 0| { 868| 0| if (level() == mark_level_) ------------------ | Branch (868:33): [True: 0, False: 0] ------------------ 869| 0| { 870| 0| more_ = false; 871| 0| } 872| 0| } 873| 0| --level_; 874| 0| } 875| 2.22k| ++column_index_; 876| 2.22k| state_ = csv_parse_state::end_record; 877| 2.22k| break; 878| 250| case csv_parse_state::before_unquoted_string: ------------------ | Branch (878:17): [True: 250, False: 14.5k] ------------------ 879| 250| buffer_.clear(); 880| 250| JSONCONS_FALLTHROUGH; ------------------ | | 564| 250|# define JSONCONS_FALLTHROUGH [[fallthrough]] ------------------ 881| 2.23k| case csv_parse_state::unquoted_string: ------------------ | Branch (881:17): [True: 1.98k, False: 12.8k] ------------------ 882| 2.23k| if (trim_leading_ || trim_trailing_) ------------------ | Branch (882:25): [True: 0, False: 2.23k] | Branch (882:42): [True: 0, False: 2.23k] ------------------ 883| 0| { 884| 0| trim_string_buffer(trim_leading_,trim_trailing_); 885| 0| } 886| 2.23k| if (ignore_empty_values_ && buffer_.empty()) ------------------ | Branch (886:25): [True: 0, False: 2.23k] | Branch (886:49): [True: 0, False: 0] ------------------ 887| 0| { 888| 0| state_ = csv_parse_state::end_record; 889| 0| } 890| 2.23k| else 891| 2.23k| { 892| 2.23k| before_value(local_visitor, ec); 893| 2.23k| state_ = csv_parse_state::before_unquoted_field; 894| 2.23k| } 895| 2.23k| break; 896| 34| case csv_parse_state::before_last_quoted_field: ------------------ | Branch (896:17): [True: 34, False: 14.8k] ------------------ 897| 34| end_quoted_string_value(local_visitor, ec); 898| 34| ++column_index_; 899| 34| state_ = csv_parse_state::end_record; 900| 34| break; 901| 34| case csv_parse_state::escaped_value: ------------------ | Branch (901:17): [True: 34, False: 14.8k] ------------------ 902| 34| if (quote_escape_char_ == quote_char_) ------------------ | Branch (902:25): [True: 34, False: 0] ------------------ 903| 34| { 904| 34| if (!(ignore_empty_values_ && buffer_.empty())) ------------------ | Branch (904:31): [True: 0, False: 34] | Branch (904:55): [True: 0, False: 0] ------------------ 905| 34| { 906| 34| before_value(local_visitor, ec); 907| 34| ++column_; 908| 34| state_ = csv_parse_state::before_last_quoted_field; 909| 34| } 910| 0| else 911| 0| { 912| 0| state_ = csv_parse_state::end_record; 913| 0| } 914| 34| } 915| 0| else 916| 0| { 917| 0| ec = csv_errc::invalid_escaped_char; 918| 0| more_ = false; 919| 0| return; 920| 0| } 921| 34| break; 922| 2.58k| case csv_parse_state::end_record: ------------------ | Branch (922:17): [True: 2.58k, False: 12.2k] ------------------ 923| 2.58k| if (column_index_ > 0) ------------------ | Branch (923:25): [True: 2.27k, False: 312] ------------------ 924| 2.27k| { 925| 2.27k| end_record(local_visitor, ec); 926| 2.27k| } 927| 2.58k| state_ = csv_parse_state::no_more_records; 928| 2.58k| break; 929| 2.58k| case csv_parse_state::no_more_records: ------------------ | Branch (929:17): [True: 2.58k, False: 12.2k] ------------------ 930| 2.58k| switch (stack_.back()) 931| 2.58k| { 932| 120| case csv_mode::header: ------------------ | Branch (932:25): [True: 120, False: 2.46k] ------------------ 933| 120| stack_.pop_back(); 934| 120| break; 935| 2.46k| case csv_mode::data: ------------------ | Branch (935:25): [True: 2.46k, False: 120] ------------------ 936| 2.46k| stack_.pop_back(); 937| 2.46k| break; 938| 0| default: ------------------ | Branch (938:25): [True: 0, False: 2.58k] ------------------ 939| 0| break; 940| 2.58k| } 941| 2.58k| local_visitor.end_array(*this, ec); 942| 2.58k| more_ = !cursor_mode_; 943| 2.58k| if (mapping_kind_ != csv_mapping_kind::m_columns) ------------------ | Branch (943:25): [True: 2.58k, False: 0] ------------------ 944| 2.58k| { 945| 2.58k| if (level() == mark_level_) ------------------ | Branch (945:29): [True: 0, False: 2.58k] ------------------ 946| 0| { 947| 0| more_ = false; 948| 0| } 949| 2.58k| } 950| 2.58k| --level_; 951| | 952| 2.58k| if (mapping_kind_ == csv_mapping_kind::m_columns) ------------------ | Branch (952:25): [True: 0, False: 2.58k] ------------------ 953| 0| { 954| 0| if (!m_columns_filter_.done()) ------------------ | Branch (954:29): [True: 0, False: 0] ------------------ 955| 0| { 956| 0| more_ = m_columns_filter_.replay_parse_events(visitor, actual_cursor_mode_, mark_level_); 957| 0| } 958| 0| else 959| 0| { 960| 0| state_ = csv_parse_state::accept; 961| 0| } 962| 0| } 963| 2.58k| else 964| 2.58k| { 965| 2.58k| state_ = csv_parse_state::accept; 966| 2.58k| } 967| 2.58k| break; 968| 2.58k| case csv_parse_state::accept: ------------------ | Branch (968:17): [True: 2.58k, False: 12.2k] ------------------ 969| 2.58k| if (!(stack_.size() == 1 && stack_.back() == csv_mode::initial)) ------------------ | Branch (969:27): [True: 2.58k, False: 0] | Branch (969:49): [True: 2.58k, False: 0] ------------------ 970| 0| { 971| 0| err_handler_(csv_errc::unexpected_eof, *this); 972| 0| ec = csv_errc::unexpected_eof; 973| 0| more_ = false; 974| 0| return; 975| 0| } 976| 2.58k| stack_.pop_back(); 977| 2.58k| local_visitor.flush(); 978| 2.58k| state_ = csv_parse_state::done; 979| 2.58k| more_ = false; 980| 2.58k| return; 981| 327| default: ------------------ | Branch (981:17): [True: 327, False: 14.5k] ------------------ 982| 327| state_ = csv_parse_state::end_record; 983| 327| break; 984| 14.8k| } 985| 14.8k| } 986| | 987| 187M| for (; (input_ptr_ < local_input_end) && more_;) ------------------ | Branch (987:16): [True: 187M, False: 14.8k] | Branch (987:50): [True: 187M, False: 1] ------------------ 988| 187M| { 989| 187M| CharT curr_char = *input_ptr_; 990| | 991| 187M| switch (state_) 992| 187M| { 993| 4.68M| case csv_parse_state::cr: ------------------ | Branch (993:17): [True: 4.68M, False: 182M] ------------------ 994| 4.68M| ++line_; 995| 4.68M| column_ = 1; 996| 4.68M| switch (*input_ptr_) 997| 4.68M| { 998| 9.99k| case '\n': ------------------ | Branch (998:25): [True: 9.99k, False: 4.67M] ------------------ 999| 9.99k| ++input_ptr_; 1000| 9.99k| state_ = pop_state(); 1001| 9.99k| break; 1002| 4.67M| default: ------------------ | Branch (1002:25): [True: 4.67M, False: 9.99k] ------------------ 1003| 4.67M| state_ = pop_state(); 1004| 4.67M| break; 1005| 4.68M| } 1006| 4.68M| break; 1007| 4.68M| case csv_parse_state::start: ------------------ | Branch (1007:17): [True: 2.67k, False: 187M] ------------------ 1008| 2.67k| if (mapping_kind_ != csv_mapping_kind::m_columns) ------------------ | Branch (1008:25): [True: 2.67k, False: 0] ------------------ 1009| 2.67k| { 1010| 2.67k| local_visitor.begin_array(semantic_tag::none, *this, ec); 1011| 2.67k| more_ = !cursor_mode_; 1012| 2.67k| ++level_; 1013| 2.67k| } 1014| 2.67k| if (assume_header_ && mapping_kind_ == csv_mapping_kind::n_rows && !column_names_.empty()) ------------------ | Branch (1014:25): [True: 2.67k, False: 0] | Branch (1014:43): [True: 2.67k, False: 0] | Branch (1014:88): [True: 0, False: 2.67k] ------------------ 1015| 0| { 1016| 0| column_index_ = 0; 1017| 0| local_visitor.begin_array(semantic_tag::none, *this, ec); 1018| 0| ++level_; 1019| 0| more_ = !cursor_mode_; 1020| 0| state_ = csv_parse_state::expect_comment_or_record; 1021| 0| } 1022| 2.67k| else 1023| 2.67k| { 1024| 2.67k| state_ = csv_parse_state::expect_comment_or_record; 1025| 2.67k| } 1026| 2.67k| break; 1027| 7.23M| case csv_parse_state::comment: ------------------ | Branch (1027:17): [True: 7.23M, False: 180M] ------------------ 1028| 7.23M| switch (curr_char) 1029| 7.23M| { 1030| 1.83M| case '\n': ------------------ | Branch (1030:25): [True: 1.83M, False: 5.40M] ------------------ 1031| 1.83M| { 1032| 1.83M| ++line_; 1033| 1.83M| if (stack_.back() == csv_mode::header) ------------------ | Branch (1033:33): [True: 1.58M, False: 255k] ------------------ 1034| 1.58M| { 1035| 1.58M| ++header_line_offset_; 1036| 1.58M| } 1037| 1.83M| column_ = 1; 1038| 1.83M| state_ = csv_parse_state::expect_comment_or_record; 1039| 1.83M| break; 1040| 0| } 1041| 12.6k| case '\r': ------------------ | Branch (1041:25): [True: 12.6k, False: 7.22M] ------------------ 1042| 12.6k| ++line_; 1043| 12.6k| if (stack_.back() == csv_mode::header) ------------------ | Branch (1043:33): [True: 1.77k, False: 10.8k] ------------------ 1044| 1.77k| { 1045| 1.77k| ++header_line_offset_; 1046| 1.77k| } 1047| 12.6k| column_ = 1; 1048| 12.6k| state_ = csv_parse_state::expect_comment_or_record; 1049| 12.6k| push_state(state_); 1050| 12.6k| state_ = csv_parse_state::cr; 1051| 12.6k| break; 1052| 5.38M| default: ------------------ | Branch (1052:25): [True: 5.38M, False: 1.85M] ------------------ 1053| 5.38M| ++column_; 1054| 5.38M| break; 1055| 7.23M| } 1056| 7.23M| ++input_ptr_; 1057| 7.23M| break; 1058| | 1059| 9.56M| case csv_parse_state::expect_comment_or_record: ------------------ | Branch (1059:17): [True: 9.56M, False: 178M] ------------------ 1060| 9.56M| buffer_.clear(); 1061| 9.56M| if (curr_char == comment_starter_) ------------------ | Branch (1061:25): [True: 1.85M, False: 7.71M] ------------------ 1062| 1.85M| { 1063| 1.85M| state_ = csv_parse_state::comment; 1064| 1.85M| ++column_; 1065| 1.85M| ++input_ptr_; 1066| 1.85M| } 1067| 7.71M| else 1068| 7.71M| { 1069| 7.71M| state_ = csv_parse_state::expect_record; 1070| 7.71M| } 1071| 9.56M| break; 1072| 4.36M| case csv_parse_state::quoted_string: ------------------ | Branch (1072:17): [True: 4.36M, False: 183M] ------------------ 1073| 4.36M| { 1074| 4.36M| if (curr_char == quote_escape_char_) ------------------ | Branch (1074:29): [True: 4.07k, False: 4.35M] ------------------ 1075| 4.07k| { 1076| 4.07k| state_ = csv_parse_state::escaped_value; 1077| 4.07k| } 1078| 4.35M| else if (curr_char == quote_char_) ------------------ | Branch (1078:34): [True: 0, False: 4.35M] ------------------ 1079| 0| { 1080| 0| state_ = csv_parse_state::between_values; 1081| 0| } 1082| 4.35M| else 1083| 4.35M| { 1084| 4.35M| buffer_.push_back(static_cast(curr_char)); 1085| 4.35M| } 1086| 4.36M| } 1087| 4.36M| ++column_; 1088| 4.36M| ++input_ptr_; 1089| 4.36M| break; 1090| 4.04k| case csv_parse_state::escaped_value: ------------------ | Branch (1090:17): [True: 4.04k, False: 187M] ------------------ 1091| 4.04k| { 1092| 4.04k| if (curr_char == quote_char_) ------------------ | Branch (1092:29): [True: 1.20k, False: 2.83k] ------------------ 1093| 1.20k| { 1094| 1.20k| buffer_.push_back(static_cast(curr_char)); 1095| 1.20k| state_ = csv_parse_state::quoted_string; 1096| 1.20k| ++column_; 1097| 1.20k| ++input_ptr_; 1098| 1.20k| } 1099| 2.83k| else if (quote_escape_char_ == quote_char_) ------------------ | Branch (1099:34): [True: 2.83k, False: 0] ------------------ 1100| 2.83k| { 1101| 2.83k| state_ = csv_parse_state::between_values; 1102| 2.83k| } 1103| 0| else 1104| 0| { 1105| 0| ec = csv_errc::invalid_escaped_char; 1106| 0| more_ = false; 1107| 0| return; 1108| 0| } 1109| 4.04k| } 1110| 4.04k| break; 1111| 4.04k| case csv_parse_state::between_values: ------------------ | Branch (1111:17): [True: 3.43k, False: 187M] ------------------ 1112| 3.43k| switch (curr_char) 1113| 3.43k| { 1114| 450| case '\r': ------------------ | Branch (1114:25): [True: 450, False: 2.98k] ------------------ 1115| 1.40k| case '\n': ------------------ | Branch (1115:25): [True: 955, False: 2.47k] ------------------ 1116| 1.40k| { 1117| 1.40k| if (trim_leading_ || trim_trailing_) ------------------ | Branch (1117:33): [True: 0, False: 1.40k] | Branch (1117:50): [True: 0, False: 1.40k] ------------------ 1118| 0| { 1119| 0| trim_string_buffer(trim_leading_,trim_trailing_); 1120| 0| } 1121| 1.40k| if (!(ignore_empty_values_ && buffer_.empty())) ------------------ | Branch (1121:35): [True: 0, False: 1.40k] | Branch (1121:59): [True: 0, False: 0] ------------------ 1122| 1.40k| { 1123| 1.40k| before_value(local_visitor, ec); 1124| 1.40k| state_ = csv_parse_state::before_last_quoted_field; 1125| 1.40k| } 1126| 0| else 1127| 0| { 1128| 0| state_ = csv_parse_state::end_record; 1129| 0| } 1130| 1.40k| break; 1131| 450| } 1132| 2.02k| default: ------------------ | Branch (1132:25): [True: 2.02k, False: 1.40k] ------------------ 1133| 2.02k| if (curr_char == field_delimiter_) ------------------ | Branch (1133:33): [True: 1.33k, False: 693] ------------------ 1134| 1.33k| { 1135| 1.33k| if (trim_leading_ || trim_trailing_) ------------------ | Branch (1135:37): [True: 0, False: 1.33k] | Branch (1135:54): [True: 0, False: 1.33k] ------------------ 1136| 0| { 1137| 0| trim_string_buffer(trim_leading_,trim_trailing_); 1138| 0| } 1139| 1.33k| before_value(local_visitor, ec); 1140| 1.33k| state_ = csv_parse_state::before_quoted_field; 1141| 1.33k| } 1142| 693| else if (subfield_delimiter_ != char_type() && curr_char == subfield_delimiter_) ------------------ | Branch (1142:38): [True: 0, False: 693] | Branch (1142:76): [True: 0, False: 0] ------------------ 1143| 0| { 1144| 0| if (trim_leading_ || trim_trailing_) ------------------ | Branch (1144:37): [True: 0, False: 0] | Branch (1144:54): [True: 0, False: 0] ------------------ 1145| 0| { 1146| 0| trim_string_buffer(trim_leading_,trim_trailing_); 1147| 0| } 1148| 0| before_value(local_visitor, ec); 1149| 0| state_ = csv_parse_state::before_quoted_subfield; 1150| 0| } 1151| 693| else if (curr_char == ' ' || curr_char == '\t') ------------------ | Branch (1151:38): [True: 222, False: 471] | Branch (1151:58): [True: 385, False: 86] ------------------ 1152| 607| { 1153| 607| ++column_; 1154| 607| ++input_ptr_; 1155| 607| } 1156| 86| else 1157| 86| { 1158| 86| ec = csv_errc::unexpected_char_between_fields; 1159| 86| more_ = false; 1160| 86| return; 1161| 86| } 1162| 1.93k| break; 1163| 3.43k| } 1164| 3.34k| break; 1165| 23.1M| case csv_parse_state::before_unquoted_string: ------------------ | Branch (1165:17): [True: 23.1M, False: 164M] ------------------ 1166| 23.1M| { 1167| 23.1M| buffer_.clear(); 1168| 23.1M| state_ = csv_parse_state::unquoted_string; 1169| 23.1M| break; 1170| 3.43k| } 1171| 23.1M| case csv_parse_state::before_unquoted_field: ------------------ | Branch (1171:17): [True: 23.1M, False: 164M] ------------------ 1172| 23.1M| end_unquoted_string_value(local_visitor, ec); 1173| 23.1M| state_ = csv_parse_state::before_unquoted_field_tail; 1174| 23.1M| break; 1175| 23.1M| case csv_parse_state::before_unquoted_field_tail: ------------------ | Branch (1175:17): [True: 23.1M, False: 164M] ------------------ 1176| 23.1M| { 1177| 23.1M| if (stack_.back() == csv_mode::subfields) ------------------ | Branch (1177:25): [True: 0, False: 23.1M] ------------------ 1178| 0| { 1179| 0| stack_.pop_back(); 1180| 0| local_visitor.end_array(*this, ec); 1181| 0| more_ = !cursor_mode_; 1182| 0| if (mapping_kind_ != csv_mapping_kind::m_columns) ------------------ | Branch (1182:29): [True: 0, False: 0] ------------------ 1183| 0| { 1184| 0| if (level() == mark_level_) ------------------ | Branch (1184:33): [True: 0, False: 0] ------------------ 1185| 0| { 1186| 0| more_ = false; 1187| 0| } 1188| 0| } 1189| 0| --level_; 1190| 0| } 1191| 23.1M| ++column_index_; 1192| 23.1M| state_ = csv_parse_state::before_unquoted_string; 1193| 23.1M| ++column_; 1194| 23.1M| ++input_ptr_; 1195| 23.1M| break; 1196| 3.43k| } 1197| 0| case csv_parse_state::before_unquoted_field_tail1: ------------------ | Branch (1197:17): [True: 0, False: 187M] ------------------ 1198| 0| { 1199| 0| if (stack_.back() == csv_mode::subfields) ------------------ | Branch (1199:25): [True: 0, False: 0] ------------------ 1200| 0| { 1201| 0| stack_.pop_back(); 1202| 0| local_visitor.end_array(*this, ec); 1203| 0| more_ = !cursor_mode_; 1204| 0| if (mapping_kind_ != csv_mapping_kind::m_columns) ------------------ | Branch (1204:29): [True: 0, False: 0] ------------------ 1205| 0| { 1206| 0| if (level() == mark_level_) ------------------ | Branch (1206:33): [True: 0, False: 0] ------------------ 1207| 0| { 1208| 0| more_ = false; 1209| 0| } 1210| 0| } 1211| 0| --level_; 1212| 0| } 1213| 0| state_ = csv_parse_state::end_record; 1214| 0| ++column_; 1215| 0| ++input_ptr_; 1216| 0| break; 1217| 3.43k| } 1218| | 1219| 3.42M| case csv_parse_state::before_last_unquoted_field: ------------------ | Branch (1219:17): [True: 3.42M, False: 184M] ------------------ 1220| 3.42M| end_unquoted_string_value(local_visitor, ec); 1221| 3.42M| state_ = csv_parse_state::before_last_unquoted_field_tail; 1222| 3.42M| break; 1223| | 1224| 3.42M| case csv_parse_state::before_last_unquoted_field_tail: ------------------ | Branch (1224:17): [True: 3.42M, False: 184M] ------------------ 1225| 3.42M| if (stack_.back() == csv_mode::subfields) ------------------ | Branch (1225:25): [True: 0, False: 3.42M] ------------------ 1226| 0| { 1227| 0| stack_.pop_back(); 1228| 0| local_visitor.end_array(*this, ec); 1229| 0| more_ = !cursor_mode_; 1230| 0| if (mapping_kind_ != csv_mapping_kind::m_columns) ------------------ | Branch (1230:29): [True: 0, False: 0] ------------------ 1231| 0| { 1232| 0| if (level() == mark_level_) ------------------ | Branch (1232:33): [True: 0, False: 0] ------------------ 1233| 0| { 1234| 0| more_ = false; 1235| 0| } 1236| 0| } 1237| 0| --level_; 1238| 0| } 1239| 3.42M| ++column_index_; 1240| 3.42M| state_ = csv_parse_state::end_record; 1241| 3.42M| break; 1242| | 1243| 0| case csv_parse_state::before_unquoted_subfield: ------------------ | Branch (1243:17): [True: 0, False: 187M] ------------------ 1244| 0| if (stack_.back() == csv_mode::data) ------------------ | Branch (1244:25): [True: 0, False: 0] ------------------ 1245| 0| { 1246| 0| stack_.push_back(csv_mode::subfields); 1247| 0| local_visitor.begin_array(semantic_tag::none, *this, ec); 1248| 0| more_ = !cursor_mode_; 1249| 0| ++level_; 1250| 0| } 1251| 0| state_ = csv_parse_state::before_unquoted_subfield_tail; 1252| 0| break; 1253| 0| case csv_parse_state::before_unquoted_subfield_tail: ------------------ | Branch (1253:17): [True: 0, False: 187M] ------------------ 1254| 0| end_unquoted_string_value(local_visitor, ec); 1255| 0| state_ = csv_parse_state::before_unquoted_string; 1256| 0| ++column_; 1257| 0| ++input_ptr_; 1258| 0| break; 1259| 1.33k| case csv_parse_state::before_quoted_field: ------------------ | Branch (1259:17): [True: 1.33k, False: 187M] ------------------ 1260| 1.33k| end_quoted_string_value(local_visitor, ec); 1261| 1.33k| state_ = csv_parse_state::before_unquoted_field_tail; // return to unquoted 1262| 1.33k| break; 1263| 0| case csv_parse_state::before_quoted_subfield: ------------------ | Branch (1263:17): [True: 0, False: 187M] ------------------ 1264| 0| if (stack_.back() == csv_mode::data) ------------------ | Branch (1264:25): [True: 0, False: 0] ------------------ 1265| 0| { 1266| 0| stack_.push_back(csv_mode::subfields); 1267| 0| local_visitor.begin_array(semantic_tag::none, *this, ec); 1268| 0| more_ = !cursor_mode_; 1269| 0| ++level_; 1270| 0| } 1271| 0| state_ = csv_parse_state::before_quoted_subfield_tail; 1272| 0| break; 1273| 0| case csv_parse_state::before_quoted_subfield_tail: ------------------ | Branch (1273:17): [True: 0, False: 187M] ------------------ 1274| 0| end_quoted_string_value(local_visitor, ec); 1275| 0| state_ = csv_parse_state::before_unquoted_string; 1276| 0| ++column_; 1277| 0| ++input_ptr_; 1278| 0| break; 1279| 1.40k| case csv_parse_state::before_last_quoted_field: ------------------ | Branch (1279:17): [True: 1.40k, False: 187M] ------------------ 1280| 1.40k| end_quoted_string_value(local_visitor, ec); 1281| 1.40k| state_ = csv_parse_state::before_last_quoted_field_tail; 1282| 1.40k| break; 1283| 1.40k| case csv_parse_state::before_last_quoted_field_tail: ------------------ | Branch (1283:17): [True: 1.40k, False: 187M] ------------------ 1284| 1.40k| if (stack_.back() == csv_mode::subfields) ------------------ | Branch (1284:25): [True: 0, False: 1.40k] ------------------ 1285| 0| { 1286| 0| stack_.pop_back(); 1287| 0| local_visitor.end_array(*this, ec); 1288| 0| more_ = !cursor_mode_; 1289| 0| if (mapping_kind_ != csv_mapping_kind::m_columns) ------------------ | Branch (1289:29): [True: 0, False: 0] ------------------ 1290| 0| { 1291| 0| if (level() == mark_level_) ------------------ | Branch (1291:33): [True: 0, False: 0] ------------------ 1292| 0| { 1293| 0| more_ = false; 1294| 0| } 1295| 0| } 1296| 0| --level_; 1297| 0| } 1298| 1.40k| ++column_index_; 1299| 1.40k| state_ = csv_parse_state::end_record; 1300| 1.40k| break; 1301| 71.6M| case csv_parse_state::unquoted_string: ------------------ | Branch (1301:17): [True: 71.6M, False: 115M] ------------------ 1302| 71.6M| { 1303| 71.6M| switch (curr_char) 1304| 71.6M| { 1305| 1.31M| case '\n': ------------------ | Branch (1305:25): [True: 1.31M, False: 70.3M] ------------------ 1306| 3.42M| case '\r': ------------------ | Branch (1306:25): [True: 2.10M, False: 69.5M] ------------------ 1307| 3.42M| { 1308| 3.42M| if (trim_leading_ || trim_trailing_) ------------------ | Branch (1308:33): [True: 0, False: 3.42M] | Branch (1308:50): [True: 0, False: 3.42M] ------------------ 1309| 0| { 1310| 0| trim_string_buffer(trim_leading_,trim_trailing_); 1311| 0| } 1312| 3.42M| if (!(ignore_empty_values_ && buffer_.empty())) ------------------ | Branch (1312:35): [True: 0, False: 3.42M] | Branch (1312:59): [True: 0, False: 0] ------------------ 1313| 3.42M| { 1314| 3.42M| before_value(local_visitor, ec); 1315| 3.42M| state_ = csv_parse_state::before_last_unquoted_field; 1316| 3.42M| } 1317| 0| else 1318| 0| { 1319| 0| state_ = csv_parse_state::end_record; 1320| 0| } 1321| 3.42M| break; 1322| 1.31M| } 1323| 68.2M| default: ------------------ | Branch (1323:25): [True: 68.2M, False: 3.42M] ------------------ 1324| 68.2M| if (curr_char == field_delimiter_) ------------------ | Branch (1324:33): [True: 23.1M, False: 45.0M] ------------------ 1325| 23.1M| { 1326| 23.1M| if (trim_leading_ || trim_trailing_) ------------------ | Branch (1326:37): [True: 0, False: 23.1M] | Branch (1326:54): [True: 0, False: 23.1M] ------------------ 1327| 0| { 1328| 0| trim_string_buffer(trim_leading_,trim_trailing_); 1329| 0| } 1330| 23.1M| before_value(local_visitor, ec); 1331| 23.1M| state_ = csv_parse_state::before_unquoted_field; 1332| 23.1M| } 1333| 45.0M| else if (subfield_delimiter_ != char_type() && curr_char == subfield_delimiter_) ------------------ | Branch (1333:38): [True: 0, False: 45.0M] | Branch (1333:76): [True: 0, False: 0] ------------------ 1334| 0| { 1335| 0| if (trim_leading_ || trim_trailing_) ------------------ | Branch (1335:37): [True: 0, False: 0] | Branch (1335:54): [True: 0, False: 0] ------------------ 1336| 0| { 1337| 0| trim_string_buffer(trim_leading_,trim_trailing_); 1338| 0| } 1339| 0| before_value(local_visitor, ec); 1340| 0| state_ = csv_parse_state::before_unquoted_subfield; 1341| 0| } 1342| 45.0M| else if (curr_char == quote_char_) ------------------ | Branch (1342:38): [True: 1.32k, False: 45.0M] ------------------ 1343| 1.32k| { 1344| 1.32k| buffer_.clear(); 1345| 1.32k| state_ = csv_parse_state::quoted_string; 1346| 1.32k| ++column_; 1347| 1.32k| ++input_ptr_; 1348| 1.32k| } 1349| 45.0M| else 1350| 45.0M| { 1351| 45.0M| buffer_.push_back(static_cast(curr_char)); 1352| 45.0M| ++column_; 1353| 45.0M| ++input_ptr_; 1354| 45.0M| } 1355| 68.2M| break; 1356| 71.6M| } 1357| 71.6M| break; 1358| 71.6M| } 1359| 71.6M| case csv_parse_state::expect_record: ------------------ | Branch (1359:17): [True: 10.2M, False: 177M] ------------------ 1360| 10.2M| { 1361| 10.2M| switch (curr_char) 1362| 10.2M| { 1363| 4.29M| case '\n': ------------------ | Branch (1363:25): [True: 4.29M, False: 5.99M] ------------------ 1364| 4.29M| { 1365| 4.29M| if (!ignore_empty_lines_) ------------------ | Branch (1365:33): [True: 0, False: 4.29M] ------------------ 1366| 0| { 1367| 0| begin_record(local_visitor, ec); 1368| 0| state_ = csv_parse_state::end_record; 1369| 0| } 1370| 4.29M| else 1371| 4.29M| { 1372| 4.29M| ++line_; 1373| 4.29M| column_ = 1; 1374| 4.29M| state_ = csv_parse_state::expect_comment_or_record; 1375| 4.29M| ++input_ptr_; 1376| 4.29M| } 1377| 4.29M| break; 1378| 0| } 1379| 2.56M| case '\r': ------------------ | Branch (1379:25): [True: 2.56M, False: 7.71M] ------------------ 1380| 2.56M| if (!ignore_empty_lines_) ------------------ | Branch (1380:33): [True: 0, False: 2.56M] ------------------ 1381| 0| { 1382| 0| begin_record(local_visitor, ec); 1383| 0| state_ = csv_parse_state::end_record; 1384| 0| } 1385| 2.56M| else 1386| 2.56M| { 1387| 2.56M| ++input_ptr_; 1388| 2.56M| push_state(state_); 1389| 2.56M| state_ = csv_parse_state::cr; 1390| 2.56M| } 1391| 2.56M| break; 1392| 3.29k| case ' ': ------------------ | Branch (1392:25): [True: 3.29k, False: 10.2M] ------------------ 1393| 76.7k| case '\t': ------------------ | Branch (1393:25): [True: 73.4k, False: 10.2M] ------------------ 1394| 76.7k| if (!trim_leading_) ------------------ | Branch (1394:33): [True: 76.7k, False: 0] ------------------ 1395| 76.7k| { 1396| 76.7k| buffer_.push_back(static_cast(curr_char)); 1397| 76.7k| begin_record(local_visitor, ec); 1398| 76.7k| state_ = csv_parse_state::unquoted_string; 1399| 76.7k| } 1400| 76.7k| ++column_; 1401| 76.7k| ++input_ptr_; 1402| 76.7k| break; 1403| 3.34M| default: ------------------ | Branch (1403:25): [True: 3.34M, False: 6.93M] ------------------ 1404| 3.34M| begin_record(local_visitor, ec); 1405| 3.34M| if (curr_char == quote_char_) ------------------ | Branch (1405:33): [True: 1.64k, False: 3.34M] ------------------ 1406| 1.64k| { 1407| 1.64k| buffer_.clear(); 1408| 1.64k| state_ = csv_parse_state::quoted_string; 1409| 1.64k| ++column_; 1410| 1.64k| ++input_ptr_; 1411| 1.64k| } 1412| 3.34M| else 1413| 3.34M| { 1414| 3.34M| state_ = csv_parse_state::unquoted_string; 1415| 3.34M| } 1416| 3.34M| break; 1417| 10.2M| } 1418| 10.2M| break; 1419| 10.2M| } 1420| 10.2M| case csv_parse_state::end_record: ------------------ | Branch (1420:17): [True: 3.42M, False: 184M] ------------------ 1421| 3.42M| { 1422| 3.42M| switch (curr_char) 1423| 3.42M| { 1424| 1.31M| case '\n': ------------------ | Branch (1424:25): [True: 1.31M, False: 2.10M] ------------------ 1425| 1.31M| { 1426| 1.31M| ++line_; 1427| 1.31M| column_ = 1; 1428| 1.31M| state_ = csv_parse_state::expect_comment_or_record; 1429| 1.31M| end_record(local_visitor, ec); 1430| 1.31M| ++input_ptr_; 1431| 1.31M| break; 1432| 0| } 1433| 2.10M| case '\r': ------------------ | Branch (1433:25): [True: 2.10M, False: 1.31M] ------------------ 1434| 2.10M| ++line_; 1435| 2.10M| column_ = 1; 1436| 2.10M| state_ = csv_parse_state::expect_comment_or_record; 1437| 2.10M| end_record(local_visitor, ec); 1438| 2.10M| push_state(state_); 1439| 2.10M| state_ = csv_parse_state::cr; 1440| 2.10M| ++input_ptr_; 1441| 2.10M| break; 1442| 0| case ' ': ------------------ | Branch (1442:25): [True: 0, False: 3.42M] ------------------ 1443| 0| case '\t': ------------------ | Branch (1443:25): [True: 0, False: 3.42M] ------------------ 1444| 0| ++column_; 1445| 0| ++input_ptr_; 1446| 0| break; 1447| 0| default: ------------------ | Branch (1447:25): [True: 0, False: 3.42M] ------------------ 1448| 0| err_handler_(csv_errc::syntax_error, *this); 1449| 0| ec = csv_errc::syntax_error; 1450| 0| more_ = false; 1451| 0| return; 1452| 3.42M| } 1453| 3.42M| break; 1454| 3.42M| } 1455| 3.42M| default: ------------------ | Branch (1455:17): [True: 0, False: 187M] ------------------ 1456| 0| err_handler_(csv_errc::invalid_parse_state, *this); 1457| 0| ec = csv_errc::invalid_parse_state; 1458| 0| more_ = false; 1459| 0| return; 1460| 187M| } 1461| 187M| if (line_ > max_lines_) ------------------ | Branch (1461:17): [True: 0, False: 187M] ------------------ 1462| 0| { 1463| 0| state_ = csv_parse_state::done; 1464| 0| more_ = false; 1465| 0| } 1466| 187M| } 1467| 14.9k| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE25end_unquoted_string_valueERNS_18basic_json_visitorIcEERNS2_10error_codeE: 1756| 26.5M| { 1757| 26.5M| switch (stack_.back()) 1758| 26.5M| { 1759| 13.4M| case csv_mode::data: ------------------ | Branch (1759:13): [True: 13.4M, False: 13.0M] ------------------ 1760| 13.4M| case csv_mode::subfields: ------------------ | Branch (1760:13): [True: 0, False: 26.5M] ------------------ 1761| 13.4M| switch (mapping_kind_) ------------------ | Branch (1761:25): [True: 13.4M, False: 0] ------------------ 1762| 13.4M| { 1763| 13.4M| case csv_mapping_kind::n_rows: ------------------ | Branch (1763:17): [True: 13.4M, False: 0] ------------------ 1764| 13.4M| if (unquoted_empty_value_is_null_ && buffer_.empty()) ------------------ | Branch (1764:25): [True: 0, False: 13.4M] | Branch (1764:58): [True: 0, False: 0] ------------------ 1765| 0| { 1766| 0| visitor.null_value(semantic_tag::none, *this, ec); 1767| 0| more_ = !cursor_mode_; 1768| 0| } 1769| 13.4M| else 1770| 13.4M| { 1771| 13.4M| end_value(visitor, infer_types_, ec); 1772| 13.4M| } 1773| 13.4M| break; 1774| 0| case csv_mapping_kind::n_objects: ------------------ | Branch (1774:17): [True: 0, False: 13.4M] ------------------ 1775| 0| if (!(ignore_empty_values_ && buffer_.empty())) ------------------ | Branch (1775:27): [True: 0, False: 0] | Branch (1775:51): [True: 0, False: 0] ------------------ 1776| 0| { 1777| 0| if (column_index_ < column_names_.size() + offset_) ------------------ | Branch (1777:29): [True: 0, False: 0] ------------------ 1778| 0| { 1779| 0| if (unquoted_empty_value_is_null_ && buffer_.empty()) ------------------ | Branch (1779:33): [True: 0, False: 0] | Branch (1779:66): [True: 0, False: 0] ------------------ 1780| 0| { 1781| 0| visitor.null_value(semantic_tag::none, *this, ec); 1782| 0| more_ = !cursor_mode_; 1783| 0| } 1784| 0| else 1785| 0| { 1786| 0| end_value(visitor, infer_types_, ec); 1787| 0| } 1788| 0| } 1789| 0| else if (depth_ > 0) ------------------ | Branch (1789:34): [True: 0, False: 0] ------------------ 1790| 0| { 1791| 0| if (unquoted_empty_value_is_null_ && buffer_.empty()) ------------------ | Branch (1791:33): [True: 0, False: 0] | Branch (1791:66): [True: 0, False: 0] ------------------ 1792| 0| { 1793| 0| visitor.null_value(semantic_tag::none, *this, ec); 1794| 0| more_ = !cursor_mode_; 1795| 0| } 1796| 0| else 1797| 0| { 1798| 0| end_value(visitor, infer_types_, ec); 1799| 0| } 1800| 0| } 1801| 0| } 1802| 0| break; 1803| 0| case csv_mapping_kind::m_columns: ------------------ | Branch (1803:17): [True: 0, False: 13.4M] ------------------ 1804| 0| if (!(ignore_empty_values_ && buffer_.empty())) ------------------ | Branch (1804:27): [True: 0, False: 0] | Branch (1804:51): [True: 0, False: 0] ------------------ 1805| 0| { 1806| 0| end_value(visitor, infer_types_, ec); 1807| 0| } 1808| 0| else 1809| 0| { 1810| 0| m_columns_filter_.skip_column(); 1811| 0| } 1812| 0| break; 1813| 13.4M| } 1814| 13.4M| break; 1815| 13.4M| default: ------------------ | Branch (1815:13): [True: 13.0M, False: 13.4M] ------------------ 1816| 13.0M| break; 1817| 26.5M| } 1818| 26.5M| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE9end_valueERNS_18basic_json_visitorIcEEbRNS2_10error_codeE: 1884| 13.4M| { 1885| 13.4M| auto it = std::find_if(string_double_map_.begin(), string_double_map_.end(), string_maps_to_double{ buffer_ }); 1886| 13.4M| if (it != string_double_map_.end()) ------------------ | Branch (1886:13): [True: 0, False: 13.4M] ------------------ 1887| 0| { 1888| 0| visitor.double_value((*it).second, semantic_tag::none, *this, ec); 1889| 0| more_ = !cursor_mode_; 1890| 0| } 1891| 13.4M| else if (column_index_ < column_types_.size() + offset_) ------------------ | Branch (1891:18): [True: 0, False: 13.4M] ------------------ 1892| 0| { 1893| 0| if (column_types_[column_index_ - offset_].col_type == csv_column_type::repeat_t) ------------------ | Branch (1893:17): [True: 0, False: 0] ------------------ 1894| 0| { 1895| 0| offset_ = offset_ + column_types_[column_index_ - offset_].rep_count; 1896| 0| if (column_index_ - offset_ + 1 < column_types_.size()) ------------------ | Branch (1896:21): [True: 0, False: 0] ------------------ 1897| 0| { 1898| 0| if (column_index_ == offset_ || depth_ > column_types_[column_index_-offset_].level) ------------------ | Branch (1898:25): [True: 0, False: 0] | Branch (1898:53): [True: 0, False: 0] ------------------ 1899| 0| { 1900| 0| visitor.end_array(*this, ec); 1901| 0| more_ = !cursor_mode_; 1902| 0| if (mapping_kind_ != csv_mapping_kind::m_columns) ------------------ | Branch (1902:29): [True: 0, False: 0] ------------------ 1903| 0| { 1904| 0| if (level() == mark_level_) ------------------ | Branch (1904:33): [True: 0, False: 0] ------------------ 1905| 0| { 1906| 0| more_ = false; 1907| 0| } 1908| 0| } 1909| 0| --level_; 1910| 0| } 1911| 0| depth_ = column_index_ == offset_ ? 0 : column_types_[column_index_ - offset_].level; ------------------ | Branch (1911:30): [True: 0, False: 0] ------------------ 1912| 0| } 1913| 0| } 1914| 0| if (depth_ < column_types_[column_index_ - offset_].level) ------------------ | Branch (1914:17): [True: 0, False: 0] ------------------ 1915| 0| { 1916| 0| visitor.begin_array(semantic_tag::none, *this, ec); 1917| 0| more_ = !cursor_mode_; 1918| 0| depth_ = column_types_[column_index_ - offset_].level; 1919| 0| ++level_; 1920| 0| } 1921| 0| else if (depth_ > column_types_[column_index_ - offset_].level) ------------------ | Branch (1921:22): [True: 0, False: 0] ------------------ 1922| 0| { 1923| 0| visitor.end_array(*this, ec); 1924| 0| more_ = !cursor_mode_; 1925| 0| if (mapping_kind_ != csv_mapping_kind::m_columns) ------------------ | Branch (1925:21): [True: 0, False: 0] ------------------ 1926| 0| { 1927| 0| if (level() == mark_level_) ------------------ | Branch (1927:25): [True: 0, False: 0] ------------------ 1928| 0| { 1929| 0| more_ = false; 1930| 0| } 1931| 0| } 1932| 0| --level_; 1933| 0| depth_ = column_types_[column_index_ - offset_].level; 1934| 0| } 1935| 0| switch (column_types_[column_index_ - offset_].col_type) 1936| 0| { 1937| 0| case csv_column_type::integer_t: ------------------ | Branch (1937:17): [True: 0, False: 0] ------------------ 1938| 0| { 1939| 0| std::basic_istringstream,char_allocator_type> iss{buffer_}; 1940| 0| int64_t val; 1941| 0| iss >> val; 1942| 0| if (!iss.fail()) ------------------ | Branch (1942:29): [True: 0, False: 0] ------------------ 1943| 0| { 1944| 0| visitor.int64_value(val, semantic_tag::none, *this, ec); 1945| 0| more_ = !cursor_mode_; 1946| 0| } 1947| 0| else 1948| 0| { 1949| 0| if (column_index_ - offset_ < column_defaults_.size() && column_defaults_[column_index_ - offset_].length() > 0) ------------------ | Branch (1949:33): [True: 0, False: 0] | Branch (1949:86): [True: 0, False: 0] ------------------ 1950| 0| { 1951| 0| basic_json_parser parser(alloc_); 1952| 0| parser.update(column_defaults_[column_index_ - offset_].data(),column_defaults_[column_index_ - offset_].length()); 1953| 0| parser.parse_some(visitor); 1954| 0| parser.finish_parse(visitor); 1955| 0| } 1956| 0| else 1957| 0| { 1958| 0| visitor.null_value(semantic_tag::none, *this, ec); 1959| 0| more_ = !cursor_mode_; 1960| 0| } 1961| 0| } 1962| 0| } 1963| 0| break; 1964| 0| case csv_column_type::float_t: ------------------ | Branch (1964:17): [True: 0, False: 0] ------------------ 1965| 0| { 1966| 0| if (lossless_number_) ------------------ | Branch (1966:29): [True: 0, False: 0] ------------------ 1967| 0| { 1968| 0| visitor.string_value(buffer_,semantic_tag::bigdec, *this, ec); 1969| 0| more_ = !cursor_mode_; 1970| 0| } 1971| 0| else 1972| 0| { 1973| 0| std::basic_istringstream, char_allocator_type> iss{ buffer_ }; 1974| 0| double val; 1975| 0| iss >> val; 1976| 0| if (!iss.fail()) ------------------ | Branch (1976:33): [True: 0, False: 0] ------------------ 1977| 0| { 1978| 0| visitor.double_value(val, semantic_tag::none, *this, ec); 1979| 0| more_ = !cursor_mode_; 1980| 0| } 1981| 0| else 1982| 0| { 1983| 0| if (column_index_ - offset_ < column_defaults_.size() && column_defaults_[column_index_ - offset_].length() > 0) ------------------ | Branch (1983:37): [True: 0, False: 0] | Branch (1983:90): [True: 0, False: 0] ------------------ 1984| 0| { 1985| 0| basic_json_parser parser(alloc_); 1986| 0| parser.update(column_defaults_[column_index_ - offset_].data(),column_defaults_[column_index_ - offset_].length()); 1987| 0| parser.parse_some(visitor); 1988| 0| parser.finish_parse(visitor); 1989| 0| } 1990| 0| else 1991| 0| { 1992| 0| visitor.null_value(semantic_tag::none, *this, ec); 1993| 0| more_ = !cursor_mode_; 1994| 0| } 1995| 0| } 1996| 0| } 1997| 0| } 1998| 0| break; 1999| 0| case csv_column_type::boolean_t: ------------------ | Branch (1999:17): [True: 0, False: 0] ------------------ 2000| 0| { 2001| 0| if (buffer_.length() == 1 && buffer_[0] == '0') ------------------ | Branch (2001:29): [True: 0, False: 0] | Branch (2001:54): [True: 0, False: 0] ------------------ 2002| 0| { 2003| 0| visitor.bool_value(false, semantic_tag::none, *this, ec); 2004| 0| more_ = !cursor_mode_; 2005| 0| } 2006| 0| else if (buffer_.length() == 1 && buffer_[0] == '1') ------------------ | Branch (2006:34): [True: 0, False: 0] | Branch (2006:59): [True: 0, False: 0] ------------------ 2007| 0| { 2008| 0| visitor.bool_value(true, semantic_tag::none, *this, ec); 2009| 0| more_ = !cursor_mode_; 2010| 0| } 2011| 0| else if (buffer_.length() == 5 && ((buffer_[0] == 'f' || buffer_[0] == 'F') && (buffer_[1] == 'a' || buffer_[1] == 'A') && (buffer_[2] == 'l' || buffer_[2] == 'L') && (buffer_[3] == 's' || buffer_[3] == 'S') && (buffer_[4] == 'e' || buffer_[4] == 'E'))) ------------------ | Branch (2011:34): [True: 0, False: 0] | Branch (2011:61): [True: 0, False: 0] | Branch (2011:82): [True: 0, False: 0] | Branch (2011:105): [True: 0, False: 0] | Branch (2011:126): [True: 0, False: 0] | Branch (2011:149): [True: 0, False: 0] | Branch (2011:170): [True: 0, False: 0] | Branch (2011:193): [True: 0, False: 0] | Branch (2011:214): [True: 0, False: 0] | Branch (2011:237): [True: 0, False: 0] | Branch (2011:258): [True: 0, False: 0] ------------------ 2012| 0| { 2013| 0| visitor.bool_value(false, semantic_tag::none, *this, ec); 2014| 0| more_ = !cursor_mode_; 2015| 0| } 2016| 0| else if (buffer_.length() == 4 && ((buffer_[0] == 't' || buffer_[0] == 'T') && (buffer_[1] == 'r' || buffer_[1] == 'R') && (buffer_[2] == 'u' || buffer_[2] == 'U') && (buffer_[3] == 'e' || buffer_[3] == 'E'))) ------------------ | Branch (2016:34): [True: 0, False: 0] | Branch (2016:61): [True: 0, False: 0] | Branch (2016:82): [True: 0, False: 0] | Branch (2016:105): [True: 0, False: 0] | Branch (2016:126): [True: 0, False: 0] | Branch (2016:149): [True: 0, False: 0] | Branch (2016:170): [True: 0, False: 0] | Branch (2016:193): [True: 0, False: 0] | Branch (2016:214): [True: 0, False: 0] ------------------ 2017| 0| { 2018| 0| visitor.bool_value(true, semantic_tag::none, *this, ec); 2019| 0| more_ = !cursor_mode_; 2020| 0| } 2021| 0| else 2022| 0| { 2023| 0| if (column_index_ - offset_ < column_defaults_.size() && column_defaults_[column_index_ - offset_].length() > 0) ------------------ | Branch (2023:33): [True: 0, False: 0] | Branch (2023:86): [True: 0, False: 0] ------------------ 2024| 0| { 2025| 0| basic_json_parser parser(alloc_); 2026| 0| parser.update(column_defaults_[column_index_ - offset_].data(),column_defaults_[column_index_ - offset_].length()); 2027| 0| parser.parse_some(visitor); 2028| 0| parser.finish_parse(visitor); 2029| 0| } 2030| 0| else 2031| 0| { 2032| 0| visitor.null_value(semantic_tag::none, *this, ec); 2033| 0| more_ = !cursor_mode_; 2034| 0| } 2035| 0| } 2036| 0| } 2037| 0| break; 2038| 0| default: ------------------ | Branch (2038:17): [True: 0, False: 0] ------------------ 2039| 0| if (buffer_.length() > 0) ------------------ | Branch (2039:25): [True: 0, False: 0] ------------------ 2040| 0| { 2041| 0| visitor.string_value(buffer_, semantic_tag::none, *this, ec); 2042| 0| more_ = !cursor_mode_; 2043| 0| } 2044| 0| else 2045| 0| { 2046| 0| if (column_index_ < column_defaults_.size() + offset_ && column_defaults_[column_index_ - offset_].length() > 0) ------------------ | Branch (2046:29): [True: 0, False: 0] | Branch (2046:82): [True: 0, False: 0] ------------------ 2047| 0| { 2048| 0| basic_json_parser parser(alloc_); 2049| 0| parser.update(column_defaults_[column_index_ - offset_].data(),column_defaults_[column_index_ - offset_].length()); 2050| 0| parser.parse_some(visitor); 2051| 0| parser.finish_parse(visitor); 2052| 0| } 2053| 0| else 2054| 0| { 2055| 0| visitor.string_value(string_view_type(), semantic_tag::none, *this, ec); 2056| 0| more_ = !cursor_mode_; 2057| 0| } 2058| 0| } 2059| 0| break; 2060| 0| } 2061| 0| } 2062| 13.4M| else 2063| 13.4M| { 2064| 13.4M| if (infer_types) ------------------ | Branch (2064:17): [True: 13.4M, False: 1.83k] ------------------ 2065| 13.4M| { 2066| 13.4M| end_value_with_numeric_check(visitor, ec); 2067| 13.4M| } 2068| 1.83k| else 2069| 1.83k| { 2070| 1.83k| visitor.string_value(buffer_, semantic_tag::none, *this, ec); 2071| 1.83k| more_ = !cursor_mode_; 2072| 1.83k| } 2073| 13.4M| } 2074| 13.4M| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE28end_value_with_numeric_checkERNS_18basic_json_visitorIcEERNS2_10error_codeE: 2097| 13.4M| { 2098| 13.4M| numeric_check_state state = numeric_check_state::initial; 2099| 13.4M| bool is_negative = false; 2100| | //int precision = 0; 2101| | //uint8_t decimal_places = 0; 2102| | 2103| 13.4M| auto last = buffer_.end(); 2104| | 2105| 13.4M| std::string buffer; 2106| 32.7M| for (auto p = buffer_.begin(); state != numeric_check_state::not_a_number && p != last; ++p) ------------------ | Branch (2106:40): [True: 30.2M, False: 2.48M] | Branch (2106:86): [True: 19.2M, False: 11.0M] ------------------ 2107| 19.2M| { 2108| 19.2M| switch (state) 2109| 19.2M| { 2110| 3.29M| case numeric_check_state::initial: ------------------ | Branch (2110:17): [True: 3.29M, False: 15.9M] ------------------ 2111| 3.29M| { 2112| 3.29M| switch (*p) 2113| 3.29M| { 2114| 62.3k| case 'n':case 'N': ------------------ | Branch (2114:21): [True: 1.30k, False: 3.29M] | Branch (2114:30): [True: 60.9k, False: 3.23M] ------------------ 2115| 62.3k| if ((last-p) == 4 && (p[1] == 'u' || p[1] == 'U') && (p[2] == 'l' || p[2] == 'L') && (p[3] == 'l' || p[3] == 'L')) ------------------ | Branch (2115:29): [True: 51.9k, False: 10.3k] | Branch (2115:47): [True: 871, False: 51.1k] | Branch (2115:62): [True: 49.3k, False: 1.73k] | Branch (2115:79): [True: 48.4k, False: 1.75k] | Branch (2115:94): [True: 469, False: 1.28k] | Branch (2115:111): [True: 3.02k, False: 45.9k] | Branch (2115:126): [True: 45.3k, False: 608] ------------------ 2116| 48.3k| { 2117| 48.3k| state = numeric_check_state::null; 2118| 48.3k| } 2119| 13.9k| else 2120| 13.9k| { 2121| 13.9k| state = numeric_check_state::not_a_number; 2122| 13.9k| } 2123| 62.3k| break; 2124| 185k| case 't':case 'T': ------------------ | Branch (2124:21): [True: 5.47k, False: 3.28M] | Branch (2124:30): [True: 179k, False: 3.11M] ------------------ 2125| 185k| if ((last-p) == 4 && (p[1] == 'r' || p[1] == 'R') && (p[2] == 'u' || p[2] == 'U') && (p[3] == 'e' || p[3] == 'U')) ------------------ | Branch (2125:29): [True: 170k, False: 15.2k] | Branch (2125:47): [True: 162k, False: 7.47k] | Branch (2125:62): [True: 6.69k, False: 779] | Branch (2125:79): [True: 167k, False: 1.92k] | Branch (2125:94): [True: 1.30k, False: 614] | Branch (2125:111): [True: 166k, False: 2.17k] | Branch (2125:126): [True: 460, False: 1.71k] ------------------ 2126| 166k| { 2127| 166k| state = numeric_check_state::boolean_true; 2128| 166k| } 2129| 18.3k| else 2130| 18.3k| { 2131| 18.3k| state = numeric_check_state::not_a_number; 2132| 18.3k| } 2133| 185k| break; 2134| 43.1k| case 'f':case 'F': ------------------ | Branch (2134:21): [True: 8.04k, False: 3.28M] | Branch (2134:30): [True: 35.1k, False: 3.25M] ------------------ 2135| 43.1k| if ((last-p) == 5 && (p[1] == 'a' || p[1] == 'A') && (p[2] == 'l' || p[2] == 'L') && (p[3] == 's' || p[3] == 'S') && (p[4] == 'e' || p[4] == 'E')) ------------------ | Branch (2135:29): [True: 16.9k, False: 26.1k] | Branch (2135:47): [True: 14.6k, False: 2.33k] | Branch (2135:62): [True: 1.97k, False: 358] | Branch (2135:79): [True: 15.5k, False: 1.13k] | Branch (2135:94): [True: 341, False: 795] | Branch (2135:111): [True: 13.9k, False: 1.91k] | Branch (2135:126): [True: 1.41k, False: 500] | Branch (2135:143): [True: 3.09k, False: 12.2k] | Branch (2135:158): [True: 10.7k, False: 1.50k] ------------------ 2136| 13.8k| { 2137| 13.8k| state = numeric_check_state::boolean_false; 2138| 13.8k| } 2139| 29.3k| else 2140| 29.3k| { 2141| 29.3k| state = numeric_check_state::not_a_number; 2142| 29.3k| } 2143| 43.1k| break; 2144| 355k| case '-': ------------------ | Branch (2144:21): [True: 355k, False: 2.93M] ------------------ 2145| 355k| is_negative = true; 2146| 355k| buffer.push_back(*p); 2147| 355k| state = numeric_check_state::minus; 2148| 355k| break; 2149| 86.3k| case '0': ------------------ | Branch (2149:21): [True: 86.3k, False: 3.20M] ------------------ 2150| | //++precision; 2151| 86.3k| buffer.push_back(*p); 2152| 86.3k| state = numeric_check_state::zero; 2153| 86.3k| break; 2154| 168k| case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': ------------------ | Branch (2154:21): [True: 14.5k, False: 3.27M] | Branch (2154:30): [True: 7.63k, False: 3.28M] | Branch (2154:39): [True: 114k, False: 3.17M] | Branch (2154:48): [True: 5.77k, False: 3.28M] | Branch (2154:57): [True: 7.43k, False: 3.28M] | Branch (2154:66): [True: 3.48k, False: 3.28M] | Branch (2154:75): [True: 9.72k, False: 3.28M] | Branch (2154:84): [True: 2.34k, False: 3.29M] | Branch (2154:93): [True: 3.16k, False: 3.28M] ------------------ 2155| | //++precision; 2156| 168k| buffer.push_back(*p); 2157| 168k| state = numeric_check_state::integer; 2158| 168k| break; 2159| 2.39M| default: ------------------ | Branch (2159:21): [True: 2.39M, False: 901k] ------------------ 2160| 2.39M| state = numeric_check_state::not_a_number; 2161| 2.39M| break; 2162| 3.29M| } 2163| 3.29M| break; 2164| 3.29M| } 2165| 3.29M| case numeric_check_state::zero: ------------------ | Branch (2165:17): [True: 57.3k, False: 19.1M] ------------------ 2166| 57.3k| { 2167| 57.3k| switch (*p) 2168| 57.3k| { 2169| 45.3k| case '.': ------------------ | Branch (2169:25): [True: 45.3k, False: 11.9k] ------------------ 2170| 45.3k| { 2171| 45.3k| buffer.push_back('.'); 2172| 45.3k| state = numeric_check_state::fraction1; 2173| 45.3k| } 2174| 45.3k| break; 2175| 2.69k| case 'e':case 'E': ------------------ | Branch (2175:21): [True: 1.39k, False: 55.9k] | Branch (2175:30): [True: 1.30k, False: 56.0k] ------------------ 2176| 2.69k| buffer.push_back(*p); 2177| 2.69k| state = numeric_check_state::exp1; 2178| 2.69k| break; 2179| 9.27k| default: ------------------ | Branch (2179:21): [True: 9.27k, False: 48.0k] ------------------ 2180| 9.27k| state = numeric_check_state::not_a_number; 2181| 9.27k| break; 2182| 57.3k| } 2183| 57.3k| break; 2184| 57.3k| } 2185| 14.6M| case numeric_check_state::integer: ------------------ | Branch (2185:17): [True: 14.6M, False: 4.53M] ------------------ 2186| 14.6M| { 2187| 14.6M| switch (*p) 2188| 14.6M| { 2189| 14.6M| case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': ------------------ | Branch (2189:21): [True: 12.1M, False: 2.55M] | Branch (2189:30): [True: 232k, False: 14.4M] | Branch (2189:39): [True: 163k, False: 14.5M] | Branch (2189:48): [True: 632k, False: 14.0M] | Branch (2189:57): [True: 57.1k, False: 14.6M] | Branch (2189:66): [True: 655k, False: 14.0M] | Branch (2189:75): [True: 42.8k, False: 14.6M] | Branch (2189:84): [True: 56.9k, False: 14.6M] | Branch (2189:93): [True: 484k, False: 14.2M] | Branch (2189:102): [True: 190k, False: 14.5M] ------------------ 2190| | //++precision; 2191| 14.6M| buffer.push_back(*p); 2192| 14.6M| break; 2193| 13.8k| case '.': ------------------ | Branch (2193:21): [True: 13.8k, False: 14.6M] ------------------ 2194| 13.8k| buffer.push_back('.'); 2195| 13.8k| state = numeric_check_state::fraction1; 2196| 13.8k| break; 2197| 13.9k| case 'e':case 'E': ------------------ | Branch (2197:21): [True: 8.11k, False: 14.6M] | Branch (2197:30): [True: 5.86k, False: 14.6M] ------------------ 2198| 13.9k| buffer.push_back(*p); 2199| 13.9k| state = numeric_check_state::exp1; 2200| 13.9k| break; 2201| 9.54k| default: ------------------ | Branch (2201:21): [True: 9.54k, False: 14.6M] ------------------ 2202| 9.54k| state = numeric_check_state::not_a_number; 2203| 9.54k| break; 2204| 14.6M| } 2205| 14.6M| break; 2206| 14.6M| } 2207| 14.6M| case numeric_check_state::minus: ------------------ | Branch (2207:17): [True: 330k, False: 18.8M] ------------------ 2208| 330k| { 2209| 330k| switch (*p) 2210| 330k| { 2211| 300k| case '0': ------------------ | Branch (2211:21): [True: 300k, False: 30.4k] ------------------ 2212| | //++precision; 2213| 300k| buffer.push_back(*p); 2214| 300k| state = numeric_check_state::zero; 2215| 300k| break; 2216| 23.7k| case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': ------------------ | Branch (2216:21): [True: 8.18k, False: 322k] | Branch (2216:30): [True: 3.63k, False: 326k] | Branch (2216:39): [True: 5.78k, False: 324k] | Branch (2216:48): [True: 1.21k, False: 329k] | Branch (2216:57): [True: 710, False: 329k] | Branch (2216:66): [True: 674, False: 329k] | Branch (2216:75): [True: 312, False: 330k] | Branch (2216:84): [True: 684, False: 329k] | Branch (2216:93): [True: 2.56k, False: 327k] ------------------ 2217| | //++precision; 2218| 23.7k| buffer.push_back(*p); 2219| 23.7k| state = numeric_check_state::integer; 2220| 23.7k| break; 2221| 6.64k| default: ------------------ | Branch (2221:21): [True: 6.64k, False: 323k] ------------------ 2222| 6.64k| state = numeric_check_state::not_a_number; 2223| 6.64k| break; 2224| 330k| } 2225| 330k| break; 2226| 330k| } 2227| 330k| case numeric_check_state::fraction1: ------------------ | Branch (2227:17): [True: 56.5k, False: 19.1M] ------------------ 2228| 56.5k| { 2229| 56.5k| switch (*p) 2230| 56.5k| { 2231| 54.6k| case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': ------------------ | Branch (2231:21): [True: 3.03k, False: 53.5k] | Branch (2231:30): [True: 442, False: 56.1k] | Branch (2231:39): [True: 506, False: 56.0k] | Branch (2231:48): [True: 253, False: 56.2k] | Branch (2231:57): [True: 173, False: 56.3k] | Branch (2231:66): [True: 262, False: 56.2k] | Branch (2231:75): [True: 646, False: 55.9k] | Branch (2231:84): [True: 4.67k, False: 51.8k] | Branch (2231:93): [True: 44.1k, False: 12.4k] | Branch (2231:102): [True: 519, False: 56.0k] ------------------ 2232| | //++precision; 2233| | //++decimal_places; 2234| 54.6k| buffer.push_back(*p); 2235| 54.6k| state = numeric_check_state::fraction; 2236| 54.6k| break; 2237| 1.90k| default: ------------------ | Branch (2237:21): [True: 1.90k, False: 54.6k] ------------------ 2238| 1.90k| state = numeric_check_state::not_a_number; 2239| 1.90k| break; 2240| 56.5k| } 2241| 56.5k| break; 2242| 56.5k| } 2243| 56.5k| case numeric_check_state::fraction: ------------------ | Branch (2243:17): [True: 23.6k, False: 19.2M] ------------------ 2244| 23.6k| { 2245| 23.6k| switch (*p) 2246| 23.6k| { 2247| 21.5k| case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': ------------------ | Branch (2247:21): [True: 4.11k, False: 19.5k] | Branch (2247:30): [True: 1.17k, False: 22.4k] | Branch (2247:39): [True: 956, False: 22.6k] | Branch (2247:48): [True: 3.44k, False: 20.2k] | Branch (2247:57): [True: 706, False: 22.9k] | Branch (2247:66): [True: 2.97k, False: 20.6k] | Branch (2247:75): [True: 749, False: 22.9k] | Branch (2247:84): [True: 2.40k, False: 21.2k] | Branch (2247:93): [True: 2.16k, False: 21.4k] | Branch (2247:102): [True: 2.86k, False: 20.7k] ------------------ 2248| | //++precision; 2249| | //++decimal_places; 2250| 21.5k| buffer.push_back(*p); 2251| 21.5k| break; 2252| 946| case 'e':case 'E': ------------------ | Branch (2252:21): [True: 212, False: 23.4k] | Branch (2252:30): [True: 734, False: 22.9k] ------------------ 2253| 946| buffer.push_back(*p); 2254| 946| state = numeric_check_state::exp1; 2255| 946| break; 2256| 1.14k| default: ------------------ | Branch (2256:21): [True: 1.14k, False: 22.5k] ------------------ 2257| 1.14k| state = numeric_check_state::not_a_number; 2258| 1.14k| break; 2259| 23.6k| } 2260| 23.6k| break; 2261| 23.6k| } 2262| 23.6k| case numeric_check_state::exp1: ------------------ | Branch (2262:17): [True: 14.6k, False: 19.2M] ------------------ 2263| 14.6k| { 2264| 14.6k| switch (*p) 2265| 14.6k| { 2266| 1.75k| case '-': ------------------ | Branch (2266:21): [True: 1.75k, False: 12.8k] ------------------ 2267| 1.75k| buffer.push_back(*p); 2268| 1.75k| break; 2269| 1.08k| case '+': ------------------ | Branch (2269:21): [True: 1.08k, False: 13.5k] ------------------ 2270| 1.08k| break; 2271| 10.9k| case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': ------------------ | Branch (2271:21): [True: 297, False: 14.3k] | Branch (2271:30): [True: 505, False: 14.1k] | Branch (2271:39): [True: 1.80k, False: 12.8k] | Branch (2271:48): [True: 1.30k, False: 13.3k] | Branch (2271:57): [True: 1.08k, False: 13.5k] | Branch (2271:66): [True: 467, False: 14.1k] | Branch (2271:75): [True: 599, False: 14.0k] | Branch (2271:84): [True: 958, False: 13.6k] | Branch (2271:93): [True: 937, False: 13.6k] | Branch (2271:102): [True: 3.02k, False: 11.5k] ------------------ 2272| 10.9k| state = numeric_check_state::exp; 2273| 10.9k| buffer.push_back(*p); 2274| 10.9k| break; 2275| 787| default: ------------------ | Branch (2275:21): [True: 787, False: 13.8k] ------------------ 2276| 787| state = numeric_check_state::not_a_number; 2277| 787| break; 2278| 14.6k| } 2279| 14.6k| break; 2280| 14.6k| } 2281| 57.8k| case numeric_check_state::exp: ------------------ | Branch (2281:17): [True: 57.8k, False: 19.1M] ------------------ 2282| 57.8k| { 2283| 57.8k| switch (*p) 2284| 57.8k| { 2285| 54.9k| case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': ------------------ | Branch (2285:21): [True: 6.93k, False: 50.9k] | Branch (2285:30): [True: 5.39k, False: 52.4k] | Branch (2285:39): [True: 2.76k, False: 55.0k] | Branch (2285:48): [True: 6.85k, False: 50.9k] | Branch (2285:57): [True: 3.08k, False: 54.7k] | Branch (2285:66): [True: 6.07k, False: 51.7k] | Branch (2285:75): [True: 1.36k, False: 56.4k] | Branch (2285:84): [True: 2.70k, False: 55.1k] | Branch (2285:93): [True: 5.53k, False: 52.3k] | Branch (2285:102): [True: 14.2k, False: 43.6k] ------------------ 2286| 54.9k| buffer.push_back(*p); 2287| 54.9k| break; 2288| 2.89k| default: ------------------ | Branch (2288:21): [True: 2.89k, False: 54.9k] ------------------ 2289| 2.89k| state = numeric_check_state::not_a_number; 2290| 2.89k| break; 2291| 57.8k| } 2292| 57.8k| break; 2293| 57.8k| } 2294| 701k| default: ------------------ | Branch (2294:17): [True: 701k, False: 18.5M] ------------------ 2295| 701k| break; 2296| 19.2M| } 2297| 19.2M| } 2298| | 2299| 13.4M| switch (state) 2300| 13.4M| { 2301| 48.3k| case numeric_check_state::null: ------------------ | Branch (2301:13): [True: 48.3k, False: 13.4M] ------------------ 2302| 48.3k| visitor.null_value(semantic_tag::none, *this, ec); 2303| 48.3k| more_ = !cursor_mode_; 2304| 48.3k| break; 2305| 166k| case numeric_check_state::boolean_true: ------------------ | Branch (2305:13): [True: 166k, False: 13.3M] ------------------ 2306| 166k| visitor.bool_value(true, semantic_tag::none, *this, ec); 2307| 166k| more_ = !cursor_mode_; 2308| 166k| break; 2309| 13.8k| case numeric_check_state::boolean_false: ------------------ | Branch (2309:13): [True: 13.8k, False: 13.4M] ------------------ 2310| 13.8k| visitor.bool_value(false, semantic_tag::none, *this, ec); 2311| 13.8k| more_ = !cursor_mode_; 2312| 13.8k| break; 2313| 329k| case numeric_check_state::zero: ------------------ | Branch (2313:13): [True: 329k, False: 13.1M] ------------------ 2314| 484k| case numeric_check_state::integer: ------------------ | Branch (2314:13): [True: 154k, False: 13.3M] ------------------ 2315| 484k| { 2316| 484k| if (is_negative) ------------------ | Branch (2316:21): [True: 309k, False: 174k] ------------------ 2317| 309k| { 2318| 309k| int64_t val{ 0 }; 2319| 309k| auto result = jsoncons::dec_to_integer(buffer_.data(), buffer_.length(), val); 2320| 309k| if (result) ------------------ | Branch (2320:25): [True: 304k, False: 5.06k] ------------------ 2321| 304k| { 2322| 304k| visitor.int64_value(val, semantic_tag::none, *this, ec); 2323| 304k| more_ = !cursor_mode_; 2324| 304k| } 2325| 5.06k| else // Must be overflow 2326| 5.06k| { 2327| 5.06k| visitor.string_value(buffer_, semantic_tag::bigint, *this, ec); 2328| 5.06k| more_ = !cursor_mode_; 2329| 5.06k| } 2330| 309k| } 2331| 174k| else 2332| 174k| { 2333| 174k| uint64_t val{ 0 }; 2334| 174k| auto result = jsoncons::dec_to_integer(buffer_.data(), buffer_.length(), val); 2335| 174k| if (result) ------------------ | Branch (2335:25): [True: 171k, False: 3.17k] ------------------ 2336| 171k| { 2337| 171k| visitor.uint64_value(val, semantic_tag::none, *this, ec); 2338| 171k| more_ = !cursor_mode_; 2339| 171k| } 2340| 3.17k| else if (result.ec == std::errc::result_out_of_range) ------------------ | Branch (2340:30): [True: 3.17k, False: 0] ------------------ 2341| 3.17k| { 2342| 3.17k| visitor.string_value(buffer_, semantic_tag::bigint, *this, ec); 2343| 3.17k| more_ = !cursor_mode_; 2344| 3.17k| } 2345| 0| else 2346| 0| { 2347| 0| ec = csv_errc::invalid_number; 2348| 0| more_ = false; 2349| 0| return; 2350| 0| } 2351| 174k| } 2352| 484k| break; 2353| 484k| } 2354| 484k| case numeric_check_state::fraction: ------------------ | Branch (2354:13): [True: 52.5k, False: 13.4M] ------------------ 2355| 60.6k| case numeric_check_state::exp: ------------------ | Branch (2355:13): [True: 8.09k, False: 13.4M] ------------------ 2356| 60.6k| { 2357| 60.6k| if (lossless_number_) ------------------ | Branch (2357:21): [True: 0, False: 60.6k] ------------------ 2358| 0| { 2359| 0| visitor.string_value(buffer_,semantic_tag::bigdec, *this, ec); 2360| 0| more_ = !cursor_mode_; 2361| 0| } 2362| 60.6k| else 2363| 60.6k| { 2364| 60.6k| double d{0}; 2365| 60.6k| auto result = jsoncons::decstr_to_double(buffer.c_str(), buffer.length(), d); 2366| 60.6k| if (result.ec == std::errc::result_out_of_range) ------------------ | Branch (2366:25): [True: 2.45k, False: 58.2k] ------------------ 2367| 2.45k| { 2368| 2.45k| d = buffer.front() == '-' ? -HUGE_VAL : HUGE_VAL; ------------------ | Branch (2368:29): [True: 1.32k, False: 1.12k] ------------------ 2369| 2.45k| } 2370| 58.2k| else if (result.ec == std::errc::invalid_argument) ------------------ | Branch (2370:30): [True: 5, False: 58.2k] ------------------ 2371| 5| { 2372| 5| ec = csv_errc::invalid_number; 2373| 5| more_ = false; 2374| 5| return; 2375| 5| } 2376| 60.6k| visitor.double_value(d, semantic_tag::none, *this, ec); 2377| 60.6k| more_ = !cursor_mode_; 2378| 60.6k| } 2379| 60.6k| break; 2380| 60.6k| } 2381| 12.7M| default: ------------------ | Branch (2381:13): [True: 12.7M, False: 773k] ------------------ 2382| 12.7M| { 2383| 12.7M| visitor.string_value(buffer_, semantic_tag::none, *this, ec); 2384| 12.7M| more_ = !cursor_mode_; 2385| 12.7M| break; 2386| 60.6k| } 2387| 13.4M| } 2388| 13.4M| } _ZNK8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE5levelEv: 753| 3.34k| { 754| 3.34k| return level_; 755| 3.34k| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE12before_valueERNS_18basic_json_visitorIcEERNS2_10error_codeE: 1525| 26.5M| { 1526| 26.5M| switch (stack_.back()) 1527| 26.5M| { 1528| 13.0M| case csv_mode::header: ------------------ | Branch (1528:13): [True: 13.0M, False: 13.4M] ------------------ 1529| 13.0M| if (trim_leading_inside_quotes_ || trim_trailing_inside_quotes_) ------------------ | Branch (1529:21): [True: 0, False: 13.0M] | Branch (1529:52): [True: 0, False: 13.0M] ------------------ 1530| 0| { 1531| 0| trim_string_buffer(trim_leading_inside_quotes_,trim_trailing_inside_quotes_); 1532| 0| } 1533| 13.0M| if (line_ == (header_line_+header_line_offset_) && column_index_ >= min_column_names_) ------------------ | Branch (1533:21): [True: 13.0M, False: 0] | Branch (1533:68): [True: 13.0M, False: 0] ------------------ 1534| 13.0M| { 1535| 13.0M| column_names_.push_back(buffer_); 1536| 13.0M| if (assume_header_ && mapping_kind_ == csv_mapping_kind::n_rows) ------------------ | Branch (1536:25): [True: 13.0M, False: 0] | Branch (1536:43): [True: 13.0M, False: 0] ------------------ 1537| 13.0M| { 1538| 13.0M| visitor.string_value(buffer_, semantic_tag::none, *this, ec); 1539| 13.0M| more_ = !cursor_mode_; 1540| 13.0M| } 1541| 13.0M| } 1542| 13.0M| break; 1543| 13.4M| case csv_mode::data: ------------------ | Branch (1543:13): [True: 13.4M, False: 13.0M] ------------------ 1544| 13.4M| if (mapping_kind_ == csv_mapping_kind::n_objects) ------------------ | Branch (1544:21): [True: 0, False: 13.4M] ------------------ 1545| 0| { 1546| 0| if (!(ignore_empty_values_ && buffer_.empty())) ------------------ | Branch (1546:27): [True: 0, False: 0] | Branch (1546:51): [True: 0, False: 0] ------------------ 1547| 0| { 1548| 0| if (column_index_ < column_names_.size() + offset_) ------------------ | Branch (1548:29): [True: 0, False: 0] ------------------ 1549| 0| { 1550| 0| visitor.key(column_names_[column_index_ - offset_], *this, ec); 1551| 0| more_ = !cursor_mode_; 1552| 0| } 1553| 0| } 1554| 0| } 1555| 13.4M| break; 1556| 0| default: ------------------ | Branch (1556:13): [True: 0, False: 26.5M] ------------------ 1557| 0| break; 1558| 26.5M| } 1559| 26.5M| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE23end_quoted_string_valueERNS_18basic_json_visitorIcEERNS2_10error_codeE: 1822| 2.77k| { 1823| 2.77k| switch (stack_.back()) 1824| 2.77k| { 1825| 1.83k| case csv_mode::data: ------------------ | Branch (1825:13): [True: 1.83k, False: 934] ------------------ 1826| 1.83k| case csv_mode::subfields: ------------------ | Branch (1826:13): [True: 0, False: 2.77k] ------------------ 1827| 1.83k| if (trim_leading_inside_quotes_ || trim_trailing_inside_quotes_) ------------------ | Branch (1827:21): [True: 0, False: 1.83k] | Branch (1827:52): [True: 0, False: 1.83k] ------------------ 1828| 0| { 1829| 0| trim_string_buffer(trim_leading_inside_quotes_,trim_trailing_inside_quotes_); 1830| 0| } 1831| 1.83k| switch (mapping_kind_) ------------------ | Branch (1831:25): [True: 1.83k, False: 0] ------------------ 1832| 1.83k| { 1833| 1.83k| case csv_mapping_kind::n_rows: ------------------ | Branch (1833:17): [True: 1.83k, False: 0] ------------------ 1834| 1.83k| end_value(visitor, false, ec); 1835| 1.83k| break; 1836| 0| case csv_mapping_kind::n_objects: ------------------ | Branch (1836:17): [True: 0, False: 1.83k] ------------------ 1837| 0| if (!(ignore_empty_values_ && buffer_.empty())) ------------------ | Branch (1837:27): [True: 0, False: 0] | Branch (1837:51): [True: 0, False: 0] ------------------ 1838| 0| { 1839| 0| if (column_index_ < column_names_.size() + offset_) ------------------ | Branch (1839:29): [True: 0, False: 0] ------------------ 1840| 0| { 1841| 0| if (unquoted_empty_value_is_null_ && buffer_.empty()) ------------------ | Branch (1841:33): [True: 0, False: 0] | Branch (1841:66): [True: 0, False: 0] ------------------ 1842| 0| { 1843| 0| visitor.null_value(semantic_tag::none, *this, ec); 1844| 0| more_ = !cursor_mode_; 1845| 0| } 1846| 0| else 1847| 0| { 1848| 0| end_value(visitor, false, ec); 1849| 0| } 1850| 0| } 1851| 0| else if (depth_ > 0) ------------------ | Branch (1851:34): [True: 0, False: 0] ------------------ 1852| 0| { 1853| 0| if (unquoted_empty_value_is_null_ && buffer_.empty()) ------------------ | Branch (1853:33): [True: 0, False: 0] | Branch (1853:66): [True: 0, False: 0] ------------------ 1854| 0| { 1855| 0| visitor.null_value(semantic_tag::none, *this, ec); 1856| 0| more_ = !cursor_mode_; 1857| 0| } 1858| 0| else 1859| 0| { 1860| 0| end_value(visitor, false, ec); 1861| 0| } 1862| 0| } 1863| 0| } 1864| 0| break; 1865| 0| case csv_mapping_kind::m_columns: ------------------ | Branch (1865:17): [True: 0, False: 1.83k] ------------------ 1866| 0| if (!(ignore_empty_values_ && buffer_.empty())) ------------------ | Branch (1866:27): [True: 0, False: 0] | Branch (1866:51): [True: 0, False: 0] ------------------ 1867| 0| { 1868| 0| end_value(visitor, false, ec); 1869| 0| } 1870| 0| else 1871| 0| { 1872| 0| m_columns_filter_.skip_column(); 1873| 0| } 1874| 0| break; 1875| 1.83k| } 1876| 1.83k| break; 1877| 1.83k| default: ------------------ | Branch (1877:13): [True: 934, False: 1.83k] ------------------ 1878| 934| break; 1879| 2.77k| } 1880| 2.77k| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10end_recordERNS_18basic_json_visitorIcEERNS2_10error_codeE: 1613| 3.42M| { 1614| 3.42M| if (!column_types_.empty()) ------------------ | Branch (1614:13): [True: 0, False: 3.42M] ------------------ 1615| 0| { 1616| 0| switch (mapping_kind_) 1617| 0| { 1618| 0| case csv_mapping_kind::n_rows: ------------------ | Branch (1618:17): [True: 0, False: 0] ------------------ 1619| 0| case csv_mapping_kind::n_objects: ------------------ | Branch (1619:17): [True: 0, False: 0] ------------------ 1620| 0| if (depth_ > 0) ------------------ | Branch (1620:25): [True: 0, False: 0] ------------------ 1621| 0| { 1622| 0| visitor.end_array(*this, ec); 1623| 0| more_ = !cursor_mode_; 1624| 0| if (level_ == mark_level_) ------------------ | Branch (1624:29): [True: 0, False: 0] ------------------ 1625| 0| { 1626| 0| more_ = false; 1627| 0| } 1628| 0| --level_; 1629| 0| depth_ = 0; 1630| 0| } 1631| 0| break; 1632| 0| case csv_mapping_kind::m_columns: ------------------ | Branch (1632:17): [True: 0, False: 0] ------------------ 1633| 0| if (depth_ > 0) ------------------ | Branch (1633:25): [True: 0, False: 0] ------------------ 1634| 0| { 1635| 0| visitor.end_array(*this, ec); 1636| 0| more_ = !cursor_mode_; 1637| 0| --level_; 1638| 0| depth_ = 0; 1639| 0| } 1640| 0| break; 1641| 0| default: ------------------ | Branch (1641:17): [True: 0, False: 0] ------------------ 1642| 0| break; 1643| 0| } 1644| 0| } 1645| 3.42M| switch (stack_.back()) 1646| 3.42M| { 1647| 759| case csv_mode::header: ------------------ | Branch (1647:13): [True: 759, False: 3.42M] ------------------ 1648| 759| if (line_ >= header_lines_) ------------------ | Branch (1648:21): [True: 759, False: 0] ------------------ 1649| 759| { 1650| 759| stack_.back() = csv_mode::data; 1651| 759| } 1652| 759| switch (mapping_kind_) 1653| 759| { 1654| 759| case csv_mapping_kind::n_rows: ------------------ | Branch (1654:21): [True: 759, False: 0] ------------------ 1655| 759| if (assume_header_) ------------------ | Branch (1655:29): [True: 759, False: 0] ------------------ 1656| 759| { 1657| 759| visitor.end_array(*this, ec); 1658| 759| more_ = !cursor_mode_; 1659| 759| if (level() == mark_level_) ------------------ | Branch (1659:33): [True: 0, False: 759] ------------------ 1660| 0| { 1661| 0| more_ = false; 1662| 0| } 1663| 759| --level_; 1664| 759| } 1665| 759| break; 1666| 0| case csv_mapping_kind::m_columns: ------------------ | Branch (1666:21): [True: 0, False: 759] ------------------ 1667| 0| m_columns_filter_.initialize(column_names_); 1668| 0| break; 1669| 0| default: ------------------ | Branch (1669:21): [True: 0, False: 759] ------------------ 1670| 0| break; 1671| 759| } 1672| 759| break; 1673| 3.42M| case csv_mode::data: ------------------ | Branch (1673:13): [True: 3.42M, False: 759] ------------------ 1674| 3.42M| case csv_mode::subfields: ------------------ | Branch (1674:13): [True: 0, False: 3.42M] ------------------ 1675| 3.42M| { 1676| 3.42M| switch (mapping_kind_) ------------------ | Branch (1676:25): [True: 3.42M, False: 0] ------------------ 1677| 3.42M| { 1678| 3.42M| case csv_mapping_kind::n_rows: ------------------ | Branch (1678:21): [True: 3.42M, False: 0] ------------------ 1679| 3.42M| visitor.end_array(*this, ec); 1680| 3.42M| more_ = !cursor_mode_; 1681| 3.42M| if (level_ == mark_level_) ------------------ | Branch (1681:29): [True: 0, False: 3.42M] ------------------ 1682| 0| { 1683| 0| more_ = false; 1684| 0| } 1685| 3.42M| --level_; 1686| 3.42M| break; 1687| 0| case csv_mapping_kind::n_objects: ------------------ | Branch (1687:21): [True: 0, False: 3.42M] ------------------ 1688| 0| visitor.end_object(*this, ec); 1689| 0| more_ = !cursor_mode_; 1690| 0| if (level_ == mark_level_) ------------------ | Branch (1690:29): [True: 0, False: 0] ------------------ 1691| 0| { 1692| 0| more_ = false; 1693| 0| } 1694| 0| --level_; 1695| 0| break; 1696| 0| case csv_mapping_kind::m_columns: ------------------ | Branch (1696:21): [True: 0, False: 3.42M] ------------------ 1697| 0| visitor.end_array(*this, ec); 1698| 0| more_ = !cursor_mode_; 1699| 0| --level_; 1700| 0| break; 1701| 3.42M| } 1702| 3.42M| break; 1703| 3.42M| } 1704| 3.42M| default: ------------------ | Branch (1704:13): [True: 0, False: 3.42M] ------------------ 1705| 0| break; 1706| 3.42M| } 1707| 3.42M| column_index_ = 0; 1708| 3.42M| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE9pop_stateEv: 2396| 4.68M| { 2397| 4.68M| JSONCONS_ASSERT(!state_stack_.empty()) ------------------ | | 45| 4.68M|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 4.68M] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 2398| 4.68M| csv_parse_state state = state_stack_.back(); 2399| 4.68M| state_stack_.pop_back(); 2400| 4.68M| return state; 2401| 4.68M| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE10push_stateENS0_15csv_parse_stateE: 2391| 4.68M| { 2392| 4.68M| state_stack_.push_back(state); 2393| 4.68M| } _ZN8jsoncons3csv16basic_csv_parserIcNSt3__19allocatorIcEEE12begin_recordERNS_18basic_json_visitorIcEERNS2_10error_codeE: 1563| 3.42M| { 1564| 3.42M| offset_ = 0; 1565| | 1566| 3.42M| if (stack_.back() == csv_mode::header && line_ > (header_lines_+header_line_offset_)) ------------------ | Branch (1566:13): [True: 2.60k, False: 3.42M] | Branch (1566:50): [True: 1.73k, False: 867] ------------------ 1567| 1.73k| { 1568| 1.73k| stack_.back() = csv_mode::data; 1569| 1.73k| } 1570| 3.42M| switch (stack_.back()) 1571| 3.42M| { 1572| 867| case csv_mode::header: ------------------ | Branch (1572:13): [True: 867, False: 3.42M] ------------------ 1573| 867| switch (mapping_kind_) 1574| 867| { 1575| 867| case csv_mapping_kind::n_rows: ------------------ | Branch (1575:21): [True: 867, False: 0] ------------------ 1576| 867| if (assume_header_ && line_ == (header_line_+header_line_offset_)) ------------------ | Branch (1576:29): [True: 867, False: 0] | Branch (1576:47): [True: 867, False: 0] ------------------ 1577| 867| { 1578| 867| visitor.begin_array(semantic_tag::none, *this, ec); 1579| 867| more_ = !cursor_mode_; 1580| 867| ++level_; 1581| 867| } 1582| 867| break; 1583| 0| default: ------------------ | Branch (1583:21): [True: 0, False: 867] ------------------ 1584| 0| break; 1585| 867| } 1586| 867| break; 1587| 3.42M| case csv_mode::data: ------------------ | Branch (1587:13): [True: 3.42M, False: 867] ------------------ 1588| 3.42M| switch (mapping_kind_) 1589| 3.42M| { 1590| 3.42M| case csv_mapping_kind::n_rows: ------------------ | Branch (1590:21): [True: 3.42M, False: 0] ------------------ 1591| 3.42M| visitor.begin_array(semantic_tag::none, *this, ec); 1592| 3.42M| more_ = !cursor_mode_; 1593| 3.42M| ++level_; 1594| 3.42M| break; 1595| 0| case csv_mapping_kind::n_objects: ------------------ | Branch (1595:21): [True: 0, False: 3.42M] ------------------ 1596| 0| visitor.begin_object(semantic_tag::none, *this, ec); 1597| 0| more_ = !cursor_mode_; 1598| 0| ++level_; 1599| 0| break; 1600| 0| case csv_mapping_kind::m_columns: ------------------ | Branch (1600:21): [True: 0, False: 3.42M] ------------------ 1601| 0| break; 1602| 0| default: ------------------ | Branch (1602:21): [True: 0, False: 3.42M] ------------------ 1603| 0| break; 1604| 3.42M| } 1605| 3.42M| break; 1606| 3.42M| default: ------------------ | Branch (1606:13): [True: 0, False: 3.42M] ------------------ 1607| 0| break; 1608| 3.42M| } 1609| 3.42M| } _ZN8jsoncons3csv16basic_csv_readerIcNS_13string_sourceIcEENSt3__19allocatorIcEEED2Ev: 109| 2.68k| ~basic_csv_reader() noexcept = default; _ZN8jsoncons3csv16basic_csv_readerIcNS_13string_sourceIcEENSt3__19allocatorIcEEEC2IRNS4_12basic_stringIcNS4_11char_traitsIcEES6_EEEEOT_RNS_18basic_json_visitorIcEERKNS0_24basic_csv_decode_optionsIcEERKS6_: 62| 2.68k| : source_(std::forward(source)), 63| 2.68k| visitor_(visitor), 64| 2.68k| parser_(options, alloc) 65| | 66| 2.68k| { 67| 2.68k| } _ZN8jsoncons3csv16basic_csv_readerIcNS_13string_sourceIcEENSt3__19allocatorIcEEE4readEv: 112| 2.68k| { 113| 2.68k| std::error_code ec; 114| 2.68k| read(ec); 115| 2.68k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 2.68k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 100, False: 2.58k] | | ------------------ ------------------ 116| 100| { 117| 100| JSONCONS_THROW(ser_error(ec,parser_.line(),parser_.column())); ------------------ | | 35| 100| #define JSONCONS_THROW(exception) throw exception ------------------ 118| 100| } 119| 2.68k| } _ZN8jsoncons3csv16basic_csv_readerIcNS_13string_sourceIcEENSt3__19allocatorIcEEE4readERNS4_10error_codeE: 122| 2.68k| { 123| 2.68k| read_internal(ec); 124| 2.68k| } _ZN8jsoncons3csv16basic_csv_readerIcNS_13string_sourceIcEENSt3__19allocatorIcEEE13read_internalERNS4_10error_codeE: 144| 2.68k| { 145| 2.68k| if (source_.is_error()) ------------------ | Branch (145:17): [True: 0, False: 2.68k] ------------------ 146| 0| { 147| 0| ec = csv_errc::source_error; 148| 0| return; 149| 0| } 150| 20.1k| while (!parser_.stopped()) ------------------ | Branch (150:20): [True: 17.5k, False: 2.58k] ------------------ 151| 17.5k| { 152| 17.5k| if (parser_.source_exhausted()) ------------------ | Branch (152:21): [True: 17.5k, False: 0] ------------------ 153| 17.5k| { 154| 17.5k| auto s = source_.read_buffer(ec); 155| 17.5k| if (JSONCONS_UNLIKELY(ec)) return; ------------------ | | 78| 17.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 8, False: 17.5k] | | ------------------ ------------------ 156| 17.5k| if (s.size() > 0) ------------------ | Branch (156:25): [True: 2.67k, False: 14.8k] ------------------ 157| 2.67k| { 158| 2.67k| parser_.update(s.data(),s.size()); 159| 2.67k| } 160| 17.5k| } 161| 17.5k| parser_.parse_some(visitor_, ec); 162| 17.5k| if (JSONCONS_UNLIKELY(ec)) return; ------------------ | | 78| 17.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 92, False: 17.4k] | | ------------------ ------------------ 163| 17.5k| } 164| 2.68k| }