| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | // Copyright 2018 Ulf Adams | ||
| 2 | // | ||
| 3 | // The contents of this file may be used under the terms of the Apache License, | ||
| 4 | // Version 2.0. | ||
| 5 | // | ||
| 6 | // (See accompanying file LICENSE-Apache or copy at | ||
| 7 | // http://www.apache.org/licenses/LICENSE-2.0) | ||
| 8 | // | ||
| 9 | // Alternatively, the contents of this file may be used under the terms of | ||
| 10 | // the Boost Software License, Version 1.0. | ||
| 11 | // (See accompanying file LICENSE-Boost or copy at | ||
| 12 | // https://www.boost.org/LICENSE_1_0.txt) | ||
| 13 | // | ||
| 14 | // Unless required by applicable law or agreed to in writing, this software | ||
| 15 | // is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | ||
| 16 | // KIND, either express or implied. | ||
| 17 | |||
| 18 | /* | ||
| 19 | This is a derivative work | ||
| 20 | */ | ||
| 21 | |||
| 22 | #ifndef BOOST_JSON_DETAIL_RYU_DETAIL_COMMON_HPP | ||
| 23 | #define BOOST_JSON_DETAIL_RYU_DETAIL_COMMON_HPP | ||
| 24 | |||
| 25 | #include <boost/json/detail/config.hpp> | ||
| 26 | #include <string.h> | ||
| 27 | |||
| 28 | namespace boost { | ||
| 29 | namespace json { | ||
| 30 | namespace detail { | ||
| 31 | |||
| 32 | namespace ryu { | ||
| 33 | namespace detail { | ||
| 34 | |||
| 35 | constexpr int DOUBLE_MANTISSA_BITS = 52; | ||
| 36 | constexpr int DOUBLE_EXPONENT_BITS = 11; | ||
| 37 | constexpr int DOUBLE_BIAS = 1023; | ||
| 38 | |||
| 39 | #if defined(_M_IX86) || defined(_M_ARM) | ||
| 40 | #define BOOST_JSON_RYU_32_BIT_PLATFORM | ||
| 41 | #endif | ||
| 42 | |||
| 43 | inline uint32_t decimalLength9(const uint32_t v) { | ||
| 44 | // Function precondition: v is not a 10-digit number. | ||
| 45 | // (f2s: 9 digits are sufficient for round-tripping.) | ||
| 46 | // (d2fixed: We print 9-digit blocks.) | ||
| 47 | BOOST_ASSERT(v < 1000000000); | ||
| 48 | if (v >= 100000000) { return 9; } | ||
| 49 | if (v >= 10000000) { return 8; } | ||
| 50 | if (v >= 1000000) { return 7; } | ||
| 51 | if (v >= 100000) { return 6; } | ||
| 52 | if (v >= 10000) { return 5; } | ||
| 53 | if (v >= 1000) { return 4; } | ||
| 54 | if (v >= 100) { return 3; } | ||
| 55 | if (v >= 10) { return 2; } | ||
| 56 | return 1; | ||
| 57 | } | ||
| 58 | |||
| 59 | // Returns e == 0 ? 1 : ceil(log_2(5^e)). | ||
| 60 | 2634 | inline int32_t pow5bits(const int32_t e) { | |
| 61 | // This approximation works up to the point that the multiplication overflows at e = 3529. | ||
| 62 | // If the multiplication were done in 64 bits, it would fail at 5^4004 which is just greater | ||
| 63 | // than 2^9297. | ||
| 64 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2634 times.
|
2634 | BOOST_ASSERT(e >= 0); |
| 65 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2634 times.
|
2634 | BOOST_ASSERT(e <= 3528); |
| 66 | 2634 | return (int32_t) (((((uint32_t) e) * 1217359) >> 19) + 1); | |
| 67 | } | ||
| 68 | |||
| 69 | // Returns floor(log_10(2^e)). | ||
| 70 | 128 | inline uint32_t log10Pow2(const int32_t e) { | |
| 71 | // The first value this approximation fails for is 2^1651 which is just greater than 10^297. | ||
| 72 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 128 times.
|
128 | BOOST_ASSERT(e >= 0); |
| 73 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 128 times.
|
128 | BOOST_ASSERT(e <= 1650); |
| 74 | 128 | return (((uint32_t) e) * 78913) >> 18; | |
| 75 | } | ||
| 76 | |||
| 77 | // Returns floor(log_10(5^e)). | ||
| 78 | 134 | inline uint32_t log10Pow5(const int32_t e) { | |
| 79 | // The first value this approximation fails for is 5^2621 which is just greater than 10^1832. | ||
| 80 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 134 times.
|
134 | BOOST_ASSERT(e >= 0); |
| 81 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 134 times.
|
134 | BOOST_ASSERT(e <= 2620); |
| 82 | 134 | return (((uint32_t) e) * 732923) >> 20; | |
| 83 | } | ||
| 84 | |||
| 85 | 11 | inline int copy_special_str(char * const result, const bool sign, const bool exponent, const bool mantissa) { | |
| 86 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 8 times.
|
11 | if (mantissa) { |
| 87 | 3 | memcpy(result, "NaN", 3); | |
| 88 | 3 | return 3; | |
| 89 | } | ||
| 90 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
|
8 | if (sign) { |
| 91 | 4 | result[0] = '-'; | |
| 92 | } | ||
| 93 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2 times.
|
8 | if (exponent) { |
| 94 | 6 | memcpy(result + sign, "Infinity", 8); | |
| 95 | 6 | return sign + 8; | |
| 96 | } | ||
| 97 | 2 | memcpy(result + sign, "0E0", 3); | |
| 98 | 2 | return sign + 3; | |
| 99 | } | ||
| 100 | |||
| 101 | inline | ||
| 102 | int | ||
| 103 | 60 | copy_special_str_conforming( | |
| 104 | char* const result, bool sign, bool exponent, bool mantissa) | ||
| 105 | { | ||
| 106 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 57 times.
|
60 | if (mantissa) |
| 107 | { | ||
| 108 | 3 | memcpy(result, "null", 4); | |
| 109 | 3 | return 4; | |
| 110 | } | ||
| 111 | |||
| 112 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 37 times.
|
57 | if (sign) |
| 113 | 20 | result[0] = '-'; | |
| 114 | |||
| 115 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 51 times.
|
57 | if (exponent) |
| 116 | { | ||
| 117 | 6 | memcpy(result + sign, "1e99999", 7); | |
| 118 | 6 | return sign + 7; | |
| 119 | } | ||
| 120 | |||
| 121 | 51 | memcpy(result + sign, "0E0", 3); | |
| 122 | 51 | return sign + 3; | |
| 123 | } | ||
| 124 | |||
| 125 | inline uint32_t float_to_bits(const float f) { | ||
| 126 | uint32_t bits = 0; | ||
| 127 | memcpy(&bits, &f, sizeof(float)); | ||
| 128 | return bits; | ||
| 129 | } | ||
| 130 | |||
| 131 | 609 | inline uint64_t double_to_bits(const double d) { | |
| 132 | 609 | uint64_t bits = 0; | |
| 133 | 609 | memcpy(&bits, &d, sizeof(double)); | |
| 134 | 609 | return bits; | |
| 135 | } | ||
| 136 | |||
| 137 | } // detail | ||
| 138 | } // ryu | ||
| 139 | |||
| 140 | } // detail | ||
| 141 | } // namespace json | ||
| 142 | } // namespace boost | ||
| 143 | |||
| 144 | #endif | ||
| 145 |