RubyGems - couchbase - Versions diffs - 3.0.0.alpha.4-x86_64-linux → 3.5.0-x86_64-linux - Mend

couchbase 3.0.0.alpha.4-x86_64-linux → 3.5.0-x86_64-linux

Files changed (2212) hide show

data/ext/third_party/json/include/tao/json/external/double.hpp DELETED Viewed

@@ -1,1313 +0,0 @@
-// This header include/tao/json/external/double.hpp contains
-// modified portions of the double-conversion library from
-//   https://www.github.com/google/double-conversion
-// which is licensed as follows:
-// Copyright 2006-2011 the V8 project authors. All rights reserved.
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-//       copyright notice, this list of conditions and the following
-//       disclaimer in the documentation and/or other materials provided
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#ifndef TAO_JSON_EXTERNAL_DOUBLE_HPP
-#define TAO_JSON_EXTERNAL_DOUBLE_HPP
-// clang-format off
-#include <limits.h>
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <cstdlib>
-#include <cstring>
-// Double operations detection based on target architecture.
-// Linux uses a 80bit wide floating point stack on x86. This induces double
-// rounding, which in turn leads to wrong results.
-// An easy way to test if the floating-point operations are correct is to
-// evaluate: 89255.0/1e22. If the floating-point stack is 64 bits wide then
-// the result is equal to 89255e-22.
-// The best way to test this, is to create a division-function and to compare
-// the output of the division with the expected result. (Inlining must be
-// disabled.)
-// On Linux,x86 89255e-22 != Div_double(89255.0/1e22)
-#if defined(_M_X64) || defined(__x86_64__) ||                           \
-   defined(__ARMEL__) || defined(__avr32__) || defined(_M_ARM) || defined(_M_ARM64) || \
-   defined(__hppa__) || defined(__ia64__) ||                            \
-   defined(__mips__) ||                                                 \
-   defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) ||    \
-   defined(_POWER) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) ||     \
-   defined(__sparc__) || defined(__sparc) || defined(__s390__) ||       \
-   defined(__SH4__) || defined(__alpha__) ||                            \
-   defined(_MIPS_ARCH_MIPS32R2) ||                                      \
-   defined(__AARCH64EL__) || defined(__aarch64__)
-#define TAO_JSON_DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
-#elif defined(__mc68000__)
-#undef TAO_JSON_DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS
-#elif defined(_M_IX86) || defined(__i386__) || defined(__i386)
-#if defined(_WIN32)
-// Windows uses a 64bit wide floating point stack.
-#define TAO_JSON_DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
-#else
-#undef TAO_JSON_DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS
-#endif  // _WIN32
-#else
-#error Target architecture was not detected as supported by Double-Conversion.
-#endif
-#if defined(__GNUC__)
-#define TAO_JSON_DOUBLE_CONVERSION_UNUSED __attribute__((unused))
-#else
-#define TAO_JSON_DOUBLE_CONVERSION_UNUSED
-#endif
-#if defined(_WIN32) && !defined(__MINGW32__)
-typedef signed char int8_t;
-typedef unsigned char uint8_t;
-typedef short int16_t;
-typedef unsigned short uint16_t;
-typedef int int32_t;
-typedef unsigned int uint32_t;
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-// intptr_t and friends are defined in crtdefs.h through stdio.h.
-#else
-#include <stdint.h>
-#endif
-typedef uint16_t uc16;
-#define TAO_JSON_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
-#ifndef TAO_JSON_GDCV8_ARRAY_SIZE
-#define TAO_JSON_GDCV8_ARRAY_SIZE(a)                             \
-   ((sizeof(a) / sizeof(*(a))) /                        \
-    static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
-#endif
-namespace tao::json::double_conversion
-{
-   static const int kCharSize = sizeof( char );
-   template <typename T>
-   class Vector {
-   public:
-      Vector() : start_(nullptr), length_(0) {}
-      Vector(T* data, int len) : start_(data), length_(len) {
-         assert(len == 0 || (len > 0 && data != nullptr));
-      }
-      int length() const { return length_; }
-      T& operator[](int index) const {
-         assert(0 <= index && index < length_);
-         return start_[index];
-      }
-   private:
-      T* start_;
-      int length_;
-   };
-   template <class Dest, class Source>
-   inline Dest BitCast(const Source& source) {
-      TAO_JSON_DOUBLE_CONVERSION_UNUSED
-         typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
-      Dest dest;
-      std::memmove(&dest, &source, sizeof(dest));
-      return dest;
-   }
-   template <class Dest, class Source>
-   inline Dest BitCast(Source* source) {
-      return BitCast<Dest>(reinterpret_cast<uintptr_t>(source));
-   }
-   class Bignum
-   {
-   public:
-      static const int kMaxSignificantBits = 3584;
-      Bignum();
-      void AssignUInt16(uint16_t value);
-      void AssignUInt64(uint64_t value);
-      void AssignDecimalString(Vector<const char> value);
-      void AssignPowerUInt16(uint16_t base, int exponent);
-      void AddUInt64(uint64_t operand);
-      void AddBignum(const Bignum& other);
-      void SubtractBignum(const Bignum& other);
-      void Square();
-      void ShiftLeft(int shift_amount);
-      void MultiplyByUInt32(uint32_t factor);
-      void MultiplyByUInt64(uint64_t factor);
-      void MultiplyByPowerOfTen(int exponent);
-      static int Compare(const Bignum& a, const Bignum& b);
-      static bool LessEqual(const Bignum& a, const Bignum& b) {
-         return Compare(a, b) <= 0;
-      }
-   private:
-      typedef uint32_t Chunk;
-      typedef uint64_t DoubleChunk;
-      static const int kChunkSize = sizeof(Chunk) * 8;
-      static const int kDoubleChunkSize = sizeof(DoubleChunk) * 8;
-      static const int kBigitSize = 28;
-      static const Chunk kBigitMask = (1 << kBigitSize) - 1;
-      static const int kBigitCapacity = kMaxSignificantBits / kBigitSize;
-      void EnsureCapacity(int size) {
-         assert(size <= kBigitCapacity);
-         (void)size;
-      }
-      void Align(const Bignum& other);
-      void Clamp();
-      bool IsClamped() const;
-      void Zero();
-      void BigitsShiftLeft(int shift_amount);
-      int BigitLength() const { return used_digits_ + exponent_; }
-      Chunk BigitAt(int index) const;
-      void SubtractTimes(const Bignum& other, int factor);
-      Chunk bigits_buffer_[kBigitCapacity];
-      Vector<Chunk> bigits_;
-      int used_digits_;
-      int exponent_;
-      Bignum( const Bignum & ) = delete;
-      void operator= ( const Bignum & ) = delete;
-   };
-   inline Bignum::Bignum()
-         : bigits_(bigits_buffer_, kBigitCapacity), used_digits_(0), exponent_(0) {
-      for (int i = 0; i < kBigitCapacity; ++i) {
-         bigits_[i] = 0;
-      }
-   }
-   template<typename S>
-   inline int BitSize(S value) {
-      (void) value;  // Mark variable as used.
-      return 8 * sizeof(value);
-   }
-   inline void Bignum::AssignUInt16(uint16_t value) {
-      assert(kBigitSize >= BitSize(value));
-      Zero();
-      if (value == 0) return;
-      EnsureCapacity(1);
-      bigits_[0] = value;
-      used_digits_ = 1;
-   }
-   inline void Bignum::AssignUInt64(uint64_t value) {
-      const int kUInt64Size = 64;
-      Zero();
-      if (value == 0) return;
-      int needed_bigits = kUInt64Size / kBigitSize + 1;
-      EnsureCapacity(needed_bigits);
-      for (int i = 0; i < needed_bigits; ++i) {
-         bigits_[i] = value & kBigitMask;
-         value = value >> kBigitSize;
-      }
-      used_digits_ = needed_bigits;
-      Clamp();
-   }
-   inline uint64_t ReadUInt64(Vector<const char> buffer,
-                              int from,
-                              int digits_to_read) {
-      uint64_t result = 0;
-      for (int i = from; i < from + digits_to_read; ++i) {
-         int digit = buffer[i] - '0';
-         assert(0 <= digit && digit <= 9);
-         result = result * 10 + digit;
-      }
-      return result;
-   }
-   inline void Bignum::AssignDecimalString(Vector<const char> value) {
-      const int kMaxUint64DecimalDigits = 19;
-      Zero();
-      int length = value.length();
-      unsigned int pos = 0;
-      while (length >= kMaxUint64DecimalDigits) {
-         uint64_t digits = ReadUInt64(value, pos, kMaxUint64DecimalDigits);
-         pos += kMaxUint64DecimalDigits;
-         length -= kMaxUint64DecimalDigits;
-         MultiplyByPowerOfTen(kMaxUint64DecimalDigits);
-         AddUInt64(digits);
-      }
-      uint64_t digits = ReadUInt64(value, pos, length);
-      MultiplyByPowerOfTen(length);
-      AddUInt64(digits);
-      Clamp();
-   }
-   inline void Bignum::AddUInt64(uint64_t operand) {
-      if (operand == 0) return;
-      Bignum other;
-      other.AssignUInt64(operand);
-      AddBignum(other);
-   }
-   inline void Bignum::AddBignum(const Bignum& other) {
-      assert(IsClamped());
-      assert(other.IsClamped());
-      Align(other);
-      EnsureCapacity(1 + (std::max)(BigitLength(), other.BigitLength()) - exponent_);
-      Chunk carry = 0;
-      int bigit_pos = other.exponent_ - exponent_;
-      assert(bigit_pos >= 0);
-      for (int i = 0; i < other.used_digits_; ++i) {
-         Chunk sum = bigits_[bigit_pos] + other.bigits_[i] + carry;
-         bigits_[bigit_pos] = sum & kBigitMask;
-         carry = sum >> kBigitSize;
-         bigit_pos++;
-      }
-      while (carry != 0) {
-         Chunk sum = bigits_[bigit_pos] + carry;
-         bigits_[bigit_pos] = sum & kBigitMask;
-         carry = sum >> kBigitSize;
-         bigit_pos++;
-      }
-      used_digits_ = (std::max)(bigit_pos, used_digits_);
-      assert(IsClamped());
-   }
-   inline void Bignum::SubtractBignum(const Bignum& other) {
-      assert(IsClamped());
-      assert(other.IsClamped());
-      assert(LessEqual(other, *this));
-      Align(other);
-      int offset = other.exponent_ - exponent_;
-      Chunk borrow = 0;
-      int i;
-      for (i = 0; i < other.used_digits_; ++i) {
-         assert((borrow == 0) || (borrow == 1));
-         Chunk difference = bigits_[i + offset] - other.bigits_[i] - borrow;
-         bigits_[i + offset] = difference & kBigitMask;
-         borrow = difference >> (kChunkSize - 1);
-      }
-      while (borrow != 0) {
-         Chunk difference = bigits_[i + offset] - borrow;
-         bigits_[i + offset] = difference & kBigitMask;
-         borrow = difference >> (kChunkSize - 1);
-         ++i;
-      }
-      Clamp();
-   }
-   inline void Bignum::ShiftLeft(int shift_amount) {
-      if (used_digits_ == 0) return;
-      exponent_ += shift_amount / kBigitSize;
-      int local_shift = shift_amount % kBigitSize;
-      EnsureCapacity(used_digits_ + 1);
-      BigitsShiftLeft(local_shift);
-   }
-   inline void Bignum::MultiplyByUInt32(uint32_t factor) {
-      if (factor == 1) return;
-      if (factor == 0) {
-         Zero();
-         return;
-      }
-      if (used_digits_ == 0) return;
-      assert(kDoubleChunkSize >= kBigitSize + 32 + 1);
-      DoubleChunk carry = 0;
-      for (int i = 0; i < used_digits_; ++i) {
-         DoubleChunk product = static_cast<DoubleChunk>(factor) * bigits_[i] + carry;
-         bigits_[i] = static_cast<Chunk>(product & kBigitMask);
-         carry = (product >> kBigitSize);
-      }
-      while (carry != 0) {
-         EnsureCapacity(used_digits_ + 1);
-         bigits_[used_digits_] = carry & kBigitMask;
-         used_digits_++;
-         carry >>= kBigitSize;
-      }
-   }
-   inline void Bignum::MultiplyByUInt64(uint64_t factor) {
-      if (factor == 1) return;
-      if (factor == 0) {
-         Zero();
-         return;
-      }
-      assert(kBigitSize < 32);
-      uint64_t carry = 0;
-      uint64_t low = factor & 0xFFFFFFFF;
-      uint64_t high = factor >> 32;
-      for (int i = 0; i < used_digits_; ++i) {
-         uint64_t product_low = low * bigits_[i];
-         uint64_t product_high = high * bigits_[i];
-         uint64_t tmp = (carry & kBigitMask) + product_low;
-         bigits_[i] = tmp & kBigitMask;
-         carry = (carry >> kBigitSize) + (tmp >> kBigitSize) +
-            (product_high << (32 - kBigitSize));
-      }
-      while (carry != 0) {
-         EnsureCapacity(used_digits_ + 1);
-         bigits_[used_digits_] = carry & kBigitMask;
-         used_digits_++;
-         carry >>= kBigitSize;
-      }
-   }
-   inline void Bignum::MultiplyByPowerOfTen(int exponent) {
-      const uint64_t kFive27 = TAO_JSON_UINT64_2PART_C(0x6765c793, fa10079d);
-      const uint16_t kFive1 = 5;
-      const uint16_t kFive2 = kFive1 * 5;
-      const uint16_t kFive3 = kFive2 * 5;
-      const uint16_t kFive4 = kFive3 * 5;
-      const uint16_t kFive5 = kFive4 * 5;
-      const uint16_t kFive6 = kFive5 * 5;
-      const uint32_t kFive7 = kFive6 * 5;
-      const uint32_t kFive8 = kFive7 * 5;
-      const uint32_t kFive9 = kFive8 * 5;
-      const uint32_t kFive10 = kFive9 * 5;
-      const uint32_t kFive11 = kFive10 * 5;
-      const uint32_t kFive12 = kFive11 * 5;
-      const uint32_t kFive13 = kFive12 * 5;
-      const uint32_t kFive1_to_12[] =
-         { kFive1, kFive2, kFive3, kFive4, kFive5, kFive6,
-           kFive7, kFive8, kFive9, kFive10, kFive11, kFive12 };
-      assert(exponent >= 0);
-      if (exponent == 0) return;
-      if (used_digits_ == 0) return;
-      int remaining_exponent = exponent;
-      while (remaining_exponent >= 27) {
-         MultiplyByUInt64(kFive27);
-         remaining_exponent -= 27;
-      }
-      while (remaining_exponent >= 13) {
-         MultiplyByUInt32(kFive13);
-         remaining_exponent -= 13;
-      }
-      if (remaining_exponent > 0) {
-         MultiplyByUInt32(kFive1_to_12[remaining_exponent - 1]);
-      }
-      ShiftLeft(exponent);
-   }
-   inline void Bignum::Square() {
-      assert(IsClamped());
-      int product_length = 2 * used_digits_;
-      EnsureCapacity(product_length);
-      if ((1 << (2 * (kChunkSize - kBigitSize))) <= used_digits_) {
-         std::abort();  // Unimplemented.
-      }
-      DoubleChunk accumulator = 0;
-      int copy_offset = used_digits_;
-      for (int i = 0; i < used_digits_; ++i) {
-         bigits_[copy_offset + i] = bigits_[i];
-      }
-      for (int i = 0; i < used_digits_; ++i) {
-         int bigit_index1 = i;
-         int bigit_index2 = 0;
-         while (bigit_index1 >= 0) {
-            Chunk chunk1 = bigits_[copy_offset + bigit_index1];
-            Chunk chunk2 = bigits_[copy_offset + bigit_index2];
-            accumulator += static_cast<DoubleChunk>(chunk1) * chunk2;
-            bigit_index1--;
-            bigit_index2++;
-         }
-         bigits_[i] = static_cast<Chunk>(accumulator) & kBigitMask;
-         accumulator >>= kBigitSize;
-      }
-      for (int i = used_digits_; i < product_length; ++i) {
-         int bigit_index1 = used_digits_ - 1;
-         int bigit_index2 = i - bigit_index1;
-         while (bigit_index2 < used_digits_) {
-            Chunk chunk1 = bigits_[copy_offset + bigit_index1];
-            Chunk chunk2 = bigits_[copy_offset + bigit_index2];
-            accumulator += static_cast<DoubleChunk>(chunk1) * chunk2;
-            bigit_index1--;
-            bigit_index2++;
-         }
-         bigits_[i] = static_cast<Chunk>(accumulator) & kBigitMask;
-         accumulator >>= kBigitSize;
-      }
-      assert(accumulator == 0);
-      used_digits_ = product_length;
-      exponent_ *= 2;
-      Clamp();
-   }
-   inline void Bignum::AssignPowerUInt16(uint16_t base, int power_exponent) {
-      assert(base != 0);
-      assert(power_exponent >= 0);
-      if (power_exponent == 0) {
-         AssignUInt16(1);
-         return;
-      }
-      Zero();
-      int shifts = 0;
-      while ((base & 1) == 0) {
-         base >>= 1;
-         shifts++;
-      }
-      int bit_size = 0;
-      int tmp_base = base;
-      while (tmp_base != 0) {
-         tmp_base >>= 1;
-         bit_size++;
-      }
-      int final_size = bit_size * power_exponent;
-      EnsureCapacity(final_size / kBigitSize + 2);
-      int mask = 1;
-      while (power_exponent >= mask) mask <<= 1;
-      mask >>= 2;
-      uint64_t this_value = base;
-      bool delayed_multipliciation = false;
-      const uint64_t max_32bits = 0xFFFFFFFF;
-      while (mask != 0 && this_value <= max_32bits) {
-         this_value = this_value * this_value;
-         if ((power_exponent & mask) != 0) {
-            uint64_t base_bits_mask =
-               ~((static_cast<uint64_t>(1) << (64 - bit_size)) - 1);
-            bool high_bits_zero = (this_value & base_bits_mask) == 0;
-            if (high_bits_zero) {
-               this_value *= base;
-            } else {
-               delayed_multipliciation = true;
-            }
-         }
-         mask >>= 1;
-      }
-      AssignUInt64(this_value);
-      if (delayed_multipliciation) {
-         MultiplyByUInt32(base);
-      }
-      while (mask != 0) {
-         Square();
-         if ((power_exponent & mask) != 0) {
-            MultiplyByUInt32(base);
-         }
-         mask >>= 1;
-      }
-      ShiftLeft(shifts * power_exponent);
-   }
-   inline Bignum::Chunk Bignum::BigitAt(int index) const {
-      if (index >= BigitLength()) return 0;
-      if (index < exponent_) return 0;
-      return bigits_[index - exponent_];
-   }
-   inline int Bignum::Compare(const Bignum& a, const Bignum& b) {
-      assert(a.IsClamped());
-      assert(b.IsClamped());
-      int bigit_length_a = a.BigitLength();
-      int bigit_length_b = b.BigitLength();
-      if (bigit_length_a < bigit_length_b) return -1;
-      if (bigit_length_a > bigit_length_b) return +1;
-      for (int i = bigit_length_a - 1; i >= (std::min)(a.exponent_, b.exponent_); --i) {
-         const Chunk bigit_a = a.BigitAt(i);
-         const Chunk bigit_b = b.BigitAt(i);
-         if (bigit_a < bigit_b) return -1;
-         if (bigit_a > bigit_b) return +1;
-      }
-      return 0;
-   }
-   inline void Bignum::Clamp() {
-      while (used_digits_ > 0 && bigits_[used_digits_ - 1] == 0) {
-         used_digits_--;
-      }
-      if (used_digits_ == 0) {
-         exponent_ = 0;
-      }
-   }
-   inline bool Bignum::IsClamped() const {
-      return used_digits_ == 0 || bigits_[used_digits_ - 1] != 0;
-   }
-   inline void Bignum::Zero() {
-      for (int i = 0; i < used_digits_; ++i) {
-         bigits_[i] = 0;
-      }
-      used_digits_ = 0;
-      exponent_ = 0;
-   }
-   inline void Bignum::Align(const Bignum& other) {
-      if (exponent_ > other.exponent_) {
-         int zero_digits = exponent_ - other.exponent_;
-         EnsureCapacity(used_digits_ + zero_digits);
-         for (int i = used_digits_ - 1; i >= 0; --i) {
-            bigits_[i + zero_digits] = bigits_[i];
-         }
-         for (int i = 0; i < zero_digits; ++i) {
-            bigits_[i] = 0;
-         }
-         used_digits_ += zero_digits;
-         exponent_ -= zero_digits;
-         assert(used_digits_ >= 0);
-         assert(exponent_ >= 0);
-      }
-   }
-   inline void Bignum::BigitsShiftLeft(int shift_amount) {
-      assert(shift_amount < kBigitSize);
-      assert(shift_amount >= 0);
-      Chunk carry = 0;
-      for (int i = 0; i < used_digits_; ++i) {
-         Chunk new_carry = bigits_[i] >> (kBigitSize - shift_amount);
-         bigits_[i] = ((bigits_[i] << shift_amount) + carry) & kBigitMask;
-         carry = new_carry;
-      }
-      if (carry != 0) {
-         bigits_[used_digits_] = carry;
-         used_digits_++;
-      }
-   }
-   inline void Bignum::SubtractTimes(const Bignum& other, int factor) {
-      assert(exponent_ <= other.exponent_);
-      if (factor < 3) {
-         for (int i = 0; i < factor; ++i) {
-            SubtractBignum(other);
-         }
-         return;
-      }
-      Chunk borrow = 0;
-      int exponent_diff = other.exponent_ - exponent_;
-      for (int i = 0; i < other.used_digits_; ++i) {
-         DoubleChunk product = static_cast<DoubleChunk>(factor) * other.bigits_[i];
-         DoubleChunk remove = borrow + product;
-         Chunk difference = bigits_[i + exponent_diff] - (remove & kBigitMask);
-         bigits_[i + exponent_diff] = difference & kBigitMask;
-         borrow = static_cast<Chunk>((difference >> (kChunkSize - 1)) +
-                                     (remove >> kBigitSize));
-      }
-      for (int i = other.used_digits_ + exponent_diff; i < used_digits_; ++i) {
-         if (borrow == 0) return;
-         Chunk difference = bigits_[i] - borrow;
-         bigits_[i] = difference & kBigitMask;
-         borrow = difference >> (kChunkSize - 1);
-      }
-      Clamp();
-   }
-   class DiyFp
-   {
-   public:
-      static const int kSignificandSize = 64;
-      DiyFp() : f_(0), e_(0) {}
-      DiyFp(uint64_t significand, int exponent) : f_(significand), e_(exponent) {}
-      void Subtract(const DiyFp& other) {
-         assert(e_ == other.e_);
-         assert(f_ >= other.f_);
-         f_ -= other.f_;
-      }
-      static DiyFp Minus(const DiyFp& a, const DiyFp& b) {
-         DiyFp result = a;
-         result.Subtract(b);
-         return result;
-      }
-      void Multiply(const DiyFp& other)
-      {
-         const uint64_t kM32 = 0xFFFFFFFFU;
-         uint64_t a = f_ >> 32;
-         uint64_t b = f_ & kM32;
-         uint64_t c = other.f_ >> 32;
-         uint64_t d = other.f_ & kM32;
-         uint64_t ac = a * c;
-         uint64_t bc = b * c;
-         uint64_t ad = a * d;
-         uint64_t bd = b * d;
-         uint64_t tmp = (bd >> 32) + (ad & kM32) + (bc & kM32);
-         tmp += 1U << 31;
-         uint64_t result_f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
-         e_ += other.e_ + 64;
-         f_ = result_f;
-      }
-      static DiyFp Times(const DiyFp& a, const DiyFp& b)
-      {
-         DiyFp result = a;
-         result.Multiply(b);
-         return result;
-      }
-      void Normalize() {
-         assert(f_ != 0);
-         uint64_t significand = f_;
-         int exponent = e_;
-         const uint64_t k10MSBits = TAO_JSON_UINT64_2PART_C(0xFFC00000, 00000000);
-         while ((significand & k10MSBits) == 0) {
-            significand <<= 10;
-            exponent -= 10;
-         }
-         while ((significand & kUint64MSB) == 0) {
-            significand <<= 1;
-            exponent--;
-         }
-         f_ = significand;
-         e_ = exponent;
-      }
-      static DiyFp Normalize(const DiyFp& a) {
-         DiyFp result = a;
-         result.Normalize();
-         return result;
-      }
-      uint64_t f() const { return f_; }
-      int e() const { return e_; }
-      void set_f(uint64_t new_value) { f_ = new_value; }
-      void set_e(int new_value) { e_ = new_value; }
-   private:
-      static const uint64_t kUint64MSB = TAO_JSON_UINT64_2PART_C(0x80000000, 00000000);
-      uint64_t f_;
-      int e_;
-   };
-   static uint64_t double_to_uint64(double d) { return BitCast<uint64_t>(d); }
-   static double uint64_to_double(uint64_t d64) { return BitCast<double>(d64); }
-   class Double {
-   public:
-      static const uint64_t kSignMask = TAO_JSON_UINT64_2PART_C(0x80000000, 00000000);
-      static const uint64_t kExponentMask = TAO_JSON_UINT64_2PART_C(0x7FF00000, 00000000);
-      static const uint64_t kSignificandMask = TAO_JSON_UINT64_2PART_C(0x000FFFFF, FFFFFFFF);
-      static const uint64_t kHiddenBit = TAO_JSON_UINT64_2PART_C(0x00100000, 00000000);
-      static const int kPhysicalSignificandSize = 52;
-      static const int kSignificandSize = 53;
-      Double() : d64_(0) {}
-      explicit Double(double d) : d64_(double_to_uint64(d)) {}
-      explicit Double(uint64_t d64) : d64_(d64) {}
-      explicit Double(DiyFp diy_fp)
-            : d64_(DiyFpToUint64(diy_fp)) {}
-      DiyFp AsDiyFp() const {
-         assert(Sign() > 0);
-         assert(!IsSpecial());
-         return DiyFp(Significand(), Exponent());
-      }
-      DiyFp AsNormalizedDiyFp() const {
-         assert(value() > 0.0);
-         uint64_t f = Significand();
-         int e = Exponent();
-         while ((f & kHiddenBit) == 0) {
-            f <<= 1;
-            e--;
-         }
-         f <<= DiyFp::kSignificandSize - kSignificandSize;
-         e -= DiyFp::kSignificandSize - kSignificandSize;
-         return DiyFp(f, e);
-      }
-      uint64_t AsUint64() const {
-         return d64_;
-      }
-      double NextDouble() const {
-         if (d64_ == kInfinity) return Double(kInfinity).value();
-         if (Sign() < 0 && Significand() == 0) {
-            return 0.0;
-         }
-         if (Sign() < 0) {
-            return Double(d64_ - 1).value();
-         } else {
-            return Double(d64_ + 1).value();
-         }
-      }
-      double PreviousDouble() const {
-         if (d64_ == (kInfinity | kSignMask)) return -Double::Infinity();
-         if (Sign() < 0) {
-            return Double(d64_ + 1).value();
-         } else {
-            if (Significand() == 0) return -0.0;
-            return Double(d64_ - 1).value();
-         }
-      }
-      int Exponent() const {
-         if (IsDenormal()) return kDenormalExponent;
-         uint64_t d64 = AsUint64();
-         int biased_e =
-            static_cast<int>((d64 & kExponentMask) >> kPhysicalSignificandSize);
-         return biased_e - kExponentBias;
-      }
-      uint64_t Significand() const {
-         uint64_t d64 = AsUint64();
-         uint64_t significand = d64 & kSignificandMask;
-         if (!IsDenormal()) {
-            return significand + kHiddenBit;
-         } else {
-            return significand;
-         }
-      }
-      bool IsDenormal() const {
-         uint64_t d64 = AsUint64();
-         return (d64 & kExponentMask) == 0;
-      }
-      bool IsSpecial() const {
-         uint64_t d64 = AsUint64();
-         return (d64 & kExponentMask) == kExponentMask;
-      }
-      bool IsNan() const {
-         uint64_t d64 = AsUint64();
-         return ((d64 & kExponentMask) == kExponentMask) &&
-            ((d64 & kSignificandMask) != 0);
-      }
-      bool IsInfinite() const {
-         uint64_t d64 = AsUint64();
-         return ((d64 & kExponentMask) == kExponentMask) &&
-            ((d64 & kSignificandMask) == 0);
-      }
-      int Sign() const {
-         uint64_t d64 = AsUint64();
-         return (d64 & kSignMask) == 0? 1: -1;
-      }
-      DiyFp UpperBoundary() const {
-         assert(Sign() > 0);
-         return DiyFp(Significand() * 2 + 1, Exponent() - 1);
-      }
-      void NormalizedBoundaries(DiyFp* out_m_minus, DiyFp* out_m_plus) const {
-         assert(value() > 0.0);
-         DiyFp v = this->AsDiyFp();
-         DiyFp m_plus = DiyFp::Normalize(DiyFp((v.f() << 1) + 1, v.e() - 1));
-         DiyFp m_minus;
-         if (LowerBoundaryIsCloser()) {
-            m_minus = DiyFp((v.f() << 2) - 1, v.e() - 2);
-         } else {
-            m_minus = DiyFp((v.f() << 1) - 1, v.e() - 1);
-         }
-         m_minus.set_f(m_minus.f() << (m_minus.e() - m_plus.e()));
-         m_minus.set_e(m_plus.e());
-         *out_m_plus = m_plus;
-         *out_m_minus = m_minus;
-      }
-      bool LowerBoundaryIsCloser() const {
-         bool physical_significand_is_zero = ((AsUint64() & kSignificandMask) == 0);
-         return physical_significand_is_zero && (Exponent() != kDenormalExponent);
-      }
-      double value() const { return uint64_to_double(d64_); }
-      static int SignificandSizeForOrderOfMagnitude(int order) {
-         if (order >= (kDenormalExponent + kSignificandSize)) {
-            return kSignificandSize;
-         }
-         if (order <= kDenormalExponent) return 0;
-         return order - kDenormalExponent;
-      }
-      static double Infinity() {
-         return Double(kInfinity).value();
-      }
-      static double NaN() {
-         return Double(kNaN).value();
-      }
-   private:
-      static const int kExponentBias = 0x3FF + kPhysicalSignificandSize;
-      static const int kDenormalExponent = -kExponentBias + 1;
-      static const int kMaxExponent = 0x7FF - kExponentBias;
-      static const uint64_t kInfinity = TAO_JSON_UINT64_2PART_C(0x7FF00000, 00000000);
-      static const uint64_t kNaN = TAO_JSON_UINT64_2PART_C(0x7FF80000, 00000000);
-      const uint64_t d64_;
-      static uint64_t DiyFpToUint64(DiyFp diy_fp) {
-         uint64_t significand = diy_fp.f();
-         int exponent = diy_fp.e();
-         while (significand > kHiddenBit + kSignificandMask) {
-            significand >>= 1;
-            exponent++;
-         }
-         if (exponent >= kMaxExponent) {
-            return kInfinity;
-         }
-         if (exponent < kDenormalExponent) {
-            return 0;
-         }
-         while (exponent > kDenormalExponent && (significand & kHiddenBit) == 0) {
-            significand <<= 1;
-            exponent--;
-         }
-         uint64_t biased_exponent;
-         if (exponent == kDenormalExponent && (significand & kHiddenBit) == 0) {
-            biased_exponent = 0;
-         } else {
-            biased_exponent = static_cast<uint64_t>(exponent + kExponentBias);
-         }
-         return (significand & kSignificandMask) |
-            (biased_exponent << kPhysicalSignificandSize);
-      }
-      Double( const Double& ) = delete;
-      void operator=( const Double& ) = delete;
-   };
-   struct PowersOfTenCache
-   {
-      static const int kDecimalExponentDistance = 8;
-      static const int kMinDecimalExponent = -348;
-      static const int kMaxDecimalExponent = 340;
-      static void GetCachedPowerForDecimalExponent(int requested_exponent,
-                                                   DiyFp* power,
-                                                   int* found_exponent);
-   };
-   struct CachedPower {
-      uint64_t significand;
-      int16_t binary_exponent;
-      int16_t decimal_exponent;
-   };
-   static const CachedPower kCachedPowers[] = {
-      {TAO_JSON_UINT64_2PART_C(0xfa8fd5a0, 081c0288), -1220, -348},
-      {TAO_JSON_UINT64_2PART_C(0xbaaee17f, a23ebf76), -1193, -340},
-      {TAO_JSON_UINT64_2PART_C(0x8b16fb20, 3055ac76), -1166, -332},
-      {TAO_JSON_UINT64_2PART_C(0xcf42894a, 5dce35ea), -1140, -324},
-      {TAO_JSON_UINT64_2PART_C(0x9a6bb0aa, 55653b2d), -1113, -316},
-      {TAO_JSON_UINT64_2PART_C(0xe61acf03, 3d1a45df), -1087, -308},
-      {TAO_JSON_UINT64_2PART_C(0xab70fe17, c79ac6ca), -1060, -300},
-      {TAO_JSON_UINT64_2PART_C(0xff77b1fc, bebcdc4f), -1034, -292},
-      {TAO_JSON_UINT64_2PART_C(0xbe5691ef, 416bd60c), -1007, -284},
-      {TAO_JSON_UINT64_2PART_C(0x8dd01fad, 907ffc3c), -980, -276},
-      {TAO_JSON_UINT64_2PART_C(0xd3515c28, 31559a83), -954, -268},
-      {TAO_JSON_UINT64_2PART_C(0x9d71ac8f, ada6c9b5), -927, -260},
-      {TAO_JSON_UINT64_2PART_C(0xea9c2277, 23ee8bcb), -901, -252},
-      {TAO_JSON_UINT64_2PART_C(0xaecc4991, 4078536d), -874, -244},
-      {TAO_JSON_UINT64_2PART_C(0x823c1279, 5db6ce57), -847, -236},
-      {TAO_JSON_UINT64_2PART_C(0xc2109436, 4dfb5637), -821, -228},
-      {TAO_JSON_UINT64_2PART_C(0x9096ea6f, 3848984f), -794, -220},
-      {TAO_JSON_UINT64_2PART_C(0xd77485cb, 25823ac7), -768, -212},
-      {TAO_JSON_UINT64_2PART_C(0xa086cfcd, 97bf97f4), -741, -204},
-      {TAO_JSON_UINT64_2PART_C(0xef340a98, 172aace5), -715, -196},
-      {TAO_JSON_UINT64_2PART_C(0xb23867fb, 2a35b28e), -688, -188},
-      {TAO_JSON_UINT64_2PART_C(0x84c8d4df, d2c63f3b), -661, -180},
-      {TAO_JSON_UINT64_2PART_C(0xc5dd4427, 1ad3cdba), -635, -172},
-      {TAO_JSON_UINT64_2PART_C(0x936b9fce, bb25c996), -608, -164},
-      {TAO_JSON_UINT64_2PART_C(0xdbac6c24, 7d62a584), -582, -156},
-      {TAO_JSON_UINT64_2PART_C(0xa3ab6658, 0d5fdaf6), -555, -148},
-      {TAO_JSON_UINT64_2PART_C(0xf3e2f893, dec3f126), -529, -140},
-      {TAO_JSON_UINT64_2PART_C(0xb5b5ada8, aaff80b8), -502, -132},
-      {TAO_JSON_UINT64_2PART_C(0x87625f05, 6c7c4a8b), -475, -124},
-      {TAO_JSON_UINT64_2PART_C(0xc9bcff60, 34c13053), -449, -116},
-      {TAO_JSON_UINT64_2PART_C(0x964e858c, 91ba2655), -422, -108},
-      {TAO_JSON_UINT64_2PART_C(0xdff97724, 70297ebd), -396, -100},
-      {TAO_JSON_UINT64_2PART_C(0xa6dfbd9f, b8e5b88f), -369, -92},
-      {TAO_JSON_UINT64_2PART_C(0xf8a95fcf, 88747d94), -343, -84},
-      {TAO_JSON_UINT64_2PART_C(0xb9447093, 8fa89bcf), -316, -76},
-      {TAO_JSON_UINT64_2PART_C(0x8a08f0f8, bf0f156b), -289, -68},
-      {TAO_JSON_UINT64_2PART_C(0xcdb02555, 653131b6), -263, -60},
-      {TAO_JSON_UINT64_2PART_C(0x993fe2c6, d07b7fac), -236, -52},
-      {TAO_JSON_UINT64_2PART_C(0xe45c10c4, 2a2b3b06), -210, -44},
-      {TAO_JSON_UINT64_2PART_C(0xaa242499, 697392d3), -183, -36},
-      {TAO_JSON_UINT64_2PART_C(0xfd87b5f2, 8300ca0e), -157, -28},
-      {TAO_JSON_UINT64_2PART_C(0xbce50864, 92111aeb), -130, -20},
-      {TAO_JSON_UINT64_2PART_C(0x8cbccc09, 6f5088cc), -103, -12},
-      {TAO_JSON_UINT64_2PART_C(0xd1b71758, e219652c), -77, -4},
-      {TAO_JSON_UINT64_2PART_C(0x9c400000, 00000000), -50, 4},
-      {TAO_JSON_UINT64_2PART_C(0xe8d4a510, 00000000), -24, 12},
-      {TAO_JSON_UINT64_2PART_C(0xad78ebc5, ac620000), 3, 20},
-      {TAO_JSON_UINT64_2PART_C(0x813f3978, f8940984), 30, 28},
-      {TAO_JSON_UINT64_2PART_C(0xc097ce7b, c90715b3), 56, 36},
-      {TAO_JSON_UINT64_2PART_C(0x8f7e32ce, 7bea5c70), 83, 44},
-      {TAO_JSON_UINT64_2PART_C(0xd5d238a4, abe98068), 109, 52},
-      {TAO_JSON_UINT64_2PART_C(0x9f4f2726, 179a2245), 136, 60},
-      {TAO_JSON_UINT64_2PART_C(0xed63a231, d4c4fb27), 162, 68},
-      {TAO_JSON_UINT64_2PART_C(0xb0de6538, 8cc8ada8), 189, 76},
-      {TAO_JSON_UINT64_2PART_C(0x83c7088e, 1aab65db), 216, 84},
-      {TAO_JSON_UINT64_2PART_C(0xc45d1df9, 42711d9a), 242, 92},
-      {TAO_JSON_UINT64_2PART_C(0x924d692c, a61be758), 269, 100},
-      {TAO_JSON_UINT64_2PART_C(0xda01ee64, 1a708dea), 295, 108},
-      {TAO_JSON_UINT64_2PART_C(0xa26da399, 9aef774a), 322, 116},
-      {TAO_JSON_UINT64_2PART_C(0xf209787b, b47d6b85), 348, 124},
-      {TAO_JSON_UINT64_2PART_C(0xb454e4a1, 79dd1877), 375, 132},
-      {TAO_JSON_UINT64_2PART_C(0x865b8692, 5b9bc5c2), 402, 140},
-      {TAO_JSON_UINT64_2PART_C(0xc83553c5, c8965d3d), 428, 148},
-      {TAO_JSON_UINT64_2PART_C(0x952ab45c, fa97a0b3), 455, 156},
-      {TAO_JSON_UINT64_2PART_C(0xde469fbd, 99a05fe3), 481, 164},
-      {TAO_JSON_UINT64_2PART_C(0xa59bc234, db398c25), 508, 172},
-      {TAO_JSON_UINT64_2PART_C(0xf6c69a72, a3989f5c), 534, 180},
-      {TAO_JSON_UINT64_2PART_C(0xb7dcbf53, 54e9bece), 561, 188},
-      {TAO_JSON_UINT64_2PART_C(0x88fcf317, f22241e2), 588, 196},
-      {TAO_JSON_UINT64_2PART_C(0xcc20ce9b, d35c78a5), 614, 204},
-      {TAO_JSON_UINT64_2PART_C(0x98165af3, 7b2153df), 641, 212},
-      {TAO_JSON_UINT64_2PART_C(0xe2a0b5dc, 971f303a), 667, 220},
-      {TAO_JSON_UINT64_2PART_C(0xa8d9d153, 5ce3b396), 694, 228},
-      {TAO_JSON_UINT64_2PART_C(0xfb9b7cd9, a4a7443c), 720, 236},
-      {TAO_JSON_UINT64_2PART_C(0xbb764c4c, a7a44410), 747, 244},
-      {TAO_JSON_UINT64_2PART_C(0x8bab8eef, b6409c1a), 774, 252},
-      {TAO_JSON_UINT64_2PART_C(0xd01fef10, a657842c), 800, 260},
-      {TAO_JSON_UINT64_2PART_C(0x9b10a4e5, e9913129), 827, 268},
-      {TAO_JSON_UINT64_2PART_C(0xe7109bfb, a19c0c9d), 853, 276},
-      {TAO_JSON_UINT64_2PART_C(0xac2820d9, 623bf429), 880, 284},
-      {TAO_JSON_UINT64_2PART_C(0x80444b5e, 7aa7cf85), 907, 292},
-      {TAO_JSON_UINT64_2PART_C(0xbf21e440, 03acdd2d), 933, 300},
-      {TAO_JSON_UINT64_2PART_C(0x8e679c2f, 5e44ff8f), 960, 308},
-      {TAO_JSON_UINT64_2PART_C(0xd433179d, 9c8cb841), 986, 316},
-      {TAO_JSON_UINT64_2PART_C(0x9e19db92, b4e31ba9), 1013, 324},
-      {TAO_JSON_UINT64_2PART_C(0xeb96bf6e, badf77d9), 1039, 332},
-      {TAO_JSON_UINT64_2PART_C(0xaf87023b, 9bf0ee6b), 1066, 340},
-   };
-   static const int kCachedPowersLength = TAO_JSON_GDCV8_ARRAY_SIZE(kCachedPowers);
-   static const int kCachedPowersOffset = 348;
-   static const double kD_1_LOG2_10 = 0.30102999566398114;
-   inline void PowersOfTenCache::GetCachedPowerForDecimalExponent(int requested_exponent,
-                                                                  DiyFp* power,
-                                                                  int* found_exponent) {
-      assert(kMinDecimalExponent <= requested_exponent);
-      assert(requested_exponent < kMaxDecimalExponent + kDecimalExponentDistance);
-      int index =
-         (requested_exponent + kCachedPowersOffset) / kDecimalExponentDistance;
-      CachedPower cached_power = kCachedPowers[index];
-      *power = DiyFp(cached_power.significand, cached_power.binary_exponent);
-      *found_exponent = cached_power.decimal_exponent;
-      assert(*found_exponent <= requested_exponent);
-      assert(requested_exponent < *found_exponent + kDecimalExponentDistance);
-   }
-   static const int kMaxExactDoubleIntegerDecimalDigits = 15;
-   static const int kMaxUint64DecimalDigits = 19;
-   static const int kMaxDecimalPower = 309;
-   static const int kMinDecimalPower = -324;
-   static const uint64_t kMaxUint64 = TAO_JSON_UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF);
-   static const double exact_powers_of_ten[] = {
-      1.0,  // 10^0
-      10.0,
-      100.0,
-      1000.0,
-      10000.0,
-      100000.0,
-      1000000.0,
-      10000000.0,
-      100000000.0,
-      1000000000.0,
-      10000000000.0,  // 10^10
-      100000000000.0,
-      1000000000000.0,
-      10000000000000.0,
-      100000000000000.0,
-      1000000000000000.0,
-      10000000000000000.0,
-      100000000000000000.0,
-      1000000000000000000.0,
-      10000000000000000000.0,
-      100000000000000000000.0,  // 10^20
-      1000000000000000000000.0,
-      10000000000000000000000.0
-   };
-   static const int kExactPowersOfTenSize = TAO_JSON_GDCV8_ARRAY_SIZE(exact_powers_of_ten);
-   static const int kMaxSignificantDecimalDigits = 780;
-   inline uint64_t ReadUint64(Vector<const char> buffer,
-                              int* number_of_read_digits) {
-      uint64_t result = 0;
-      int i = 0;
-      while (i < buffer.length() && result <= (kMaxUint64 / 10 - 1)) {
-         int digit = buffer[i++] - '0';
-         assert(0 <= digit && digit <= 9);
-         result = 10 * result + digit;
-      }
-      *number_of_read_digits = i;
-      return result;
-   }
-   inline void ReadDiyFp(Vector<const char> buffer,
-                         DiyFp* result,
-                         int* remaining_decimals) {
-      int read_digits;
-      uint64_t significand = ReadUint64(buffer, &read_digits);
-      if (buffer.length() == read_digits) {
-         *result = DiyFp(significand, 0);
-         *remaining_decimals = 0;
-      } else {
-         if (buffer[read_digits] >= '5') {
-            significand++;
-         }
-         int exponent = 0;
-         *result = DiyFp(significand, exponent);
-         *remaining_decimals = buffer.length() - read_digits;
-      }
-   }
-   inline bool DoubleStrtod(Vector<const char> trimmed,
-                            int exponent,
-                            double* result) {
-#if !defined(TAO_JSON_DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS)
-      // On x86 the floating-point stack can be 64 or 80 bits wide. If it is
-      // 80 bits wide (as is the case on Linux) then double-rounding occurs and the
-      // result is not accurate.
-      // We know that Windows32 uses 64 bits and is therefore accurate.
-      // Note that the ARM simulator is compiled for 32bits. It therefore exhibits
-      // the same problem.
-      return false;
-#endif
-      if (trimmed.length() <= kMaxExactDoubleIntegerDecimalDigits) {
-         int read_digits;
-         if (exponent < 0 && -exponent < kExactPowersOfTenSize) {
-            *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
-            assert(read_digits == trimmed.length());
-            *result /= exact_powers_of_ten[-exponent];
-            return true;
-         }
-         if (0 <= exponent && exponent < kExactPowersOfTenSize) {
-            *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
-            assert(read_digits == trimmed.length());
-            *result *= exact_powers_of_ten[exponent];
-            return true;
-         }
-         int remaining_digits =
-            kMaxExactDoubleIntegerDecimalDigits - trimmed.length();
-         if ((0 <= exponent) &&
-             (exponent - remaining_digits < kExactPowersOfTenSize)) {
-            *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
-            assert(read_digits == trimmed.length());
-            *result *= exact_powers_of_ten[remaining_digits];
-            *result *= exact_powers_of_ten[exponent - remaining_digits];
-            return true;
-         }
-      }
-      return false;
-   }
-   inline DiyFp AdjustmentPowerOfTen(int exponent) {
-      assert(0 < exponent);
-      assert(exponent < PowersOfTenCache::kDecimalExponentDistance);
-      assert(PowersOfTenCache::kDecimalExponentDistance == 8);
-      switch (exponent) {
-         case 1: return DiyFp(TAO_JSON_UINT64_2PART_C(0xa0000000, 00000000), -60);
-         case 2: return DiyFp(TAO_JSON_UINT64_2PART_C(0xc8000000, 00000000), -57);
-         case 3: return DiyFp(TAO_JSON_UINT64_2PART_C(0xfa000000, 00000000), -54);
-         case 4: return DiyFp(TAO_JSON_UINT64_2PART_C(0x9c400000, 00000000), -50);
-         case 5: return DiyFp(TAO_JSON_UINT64_2PART_C(0xc3500000, 00000000), -47);
-         case 6: return DiyFp(TAO_JSON_UINT64_2PART_C(0xf4240000, 00000000), -44);
-         case 7: return DiyFp(TAO_JSON_UINT64_2PART_C(0x98968000, 00000000), -40);
-         default:
-            std::abort();
-      }
-   }
-   inline bool DiyFpStrtod(Vector<const char> buffer,
-                           int exponent,
-                           double* result) {
-      DiyFp input;
-      int remaining_decimals;
-      ReadDiyFp(buffer, &input, &remaining_decimals);
-      const int kDenominatorLog = 3;
-      const int kDenominator = 1 << kDenominatorLog;
-      exponent += remaining_decimals;
-      uint64_t error = (remaining_decimals == 0 ? 0 : kDenominator / 2);
-      int old_e = input.e();
-      input.Normalize();
-      error <<= old_e - input.e();
-      assert(exponent <= PowersOfTenCache::kMaxDecimalExponent);
-      if (exponent < PowersOfTenCache::kMinDecimalExponent) {
-         *result = 0.0;
-         return true;
-      }
-      DiyFp cached_power;
-      int cached_decimal_exponent;
-      PowersOfTenCache::GetCachedPowerForDecimalExponent(exponent,
-                                                         &cached_power,
-                                                         &cached_decimal_exponent);
-      if (cached_decimal_exponent != exponent) {
-         int adjustment_exponent = exponent - cached_decimal_exponent;
-         DiyFp adjustment_power = AdjustmentPowerOfTen(adjustment_exponent);
-         input.Multiply(adjustment_power);
-         if (kMaxUint64DecimalDigits - buffer.length() >= adjustment_exponent) {
-            assert(DiyFp::kSignificandSize == 64);
-         } else {
-            error += kDenominator / 2;
-         }
-      }
-      input.Multiply(cached_power);
-      int error_b = kDenominator / 2;
-      int error_ab = (error == 0 ? 0 : 1);
-      int fixed_error = kDenominator / 2;
-      error += error_b + error_ab + fixed_error;
-      old_e = input.e();
-      input.Normalize();
-      error <<= old_e - input.e();
-      int order_of_magnitude = DiyFp::kSignificandSize + input.e();
-      int effective_significand_size =
-         Double::SignificandSizeForOrderOfMagnitude(order_of_magnitude);
-      int precision_digits_count =
-         DiyFp::kSignificandSize - effective_significand_size;
-      if (precision_digits_count + kDenominatorLog >= DiyFp::kSignificandSize) {
-         int shift_amount = (precision_digits_count + kDenominatorLog) -
-            DiyFp::kSignificandSize + 1;
-         input.set_f(input.f() >> shift_amount);
-         input.set_e(input.e() + shift_amount);
-         error = (error >> shift_amount) + 1 + kDenominator;
-         precision_digits_count -= shift_amount;
-      }
-      assert(DiyFp::kSignificandSize == 64);
-      assert(precision_digits_count < 64);
-      uint64_t one64 = 1;
-      uint64_t precision_bits_mask = (one64 << precision_digits_count) - 1;
-      uint64_t precision_bits = input.f() & precision_bits_mask;
-      uint64_t half_way = one64 << (precision_digits_count - 1);
-      precision_bits *= kDenominator;
-      half_way *= kDenominator;
-      DiyFp rounded_input(input.f() >> precision_digits_count,
-                          input.e() + precision_digits_count);
-      if (precision_bits >= half_way + error) {
-         rounded_input.set_f(rounded_input.f() + 1);
-      }
-      *result = Double(rounded_input).value();
-      if (half_way - error < precision_bits && precision_bits < half_way + error) {
-         return false;
-      } else {
-         return true;
-      }
-   }
-   inline int CompareBufferWithDiyFp(Vector<const char> buffer,
-                                     int exponent,
-                                     DiyFp diy_fp) {
-      assert(buffer.length() + exponent <= kMaxDecimalPower + 1);
-      assert(buffer.length() + exponent > kMinDecimalPower);
-      assert(buffer.length() <= kMaxSignificantDecimalDigits);
-      assert(((kMaxDecimalPower + 1) * 333 / 100) < Bignum::kMaxSignificantBits);
-      Bignum buffer_bignum;
-      Bignum diy_fp_bignum;
-      buffer_bignum.AssignDecimalString(buffer);
-      diy_fp_bignum.AssignUInt64(diy_fp.f());
-      if (exponent >= 0) {
-         buffer_bignum.MultiplyByPowerOfTen(exponent);
-      } else {
-         diy_fp_bignum.MultiplyByPowerOfTen(-exponent);
-      }
-      if (diy_fp.e() > 0) {
-         diy_fp_bignum.ShiftLeft(diy_fp.e());
-      } else {
-         buffer_bignum.ShiftLeft(-diy_fp.e());
-      }
-      return Bignum::Compare(buffer_bignum, diy_fp_bignum);
-   }
-   inline bool ComputeGuess(Vector<const char> trimmed, int exponent,
-                            double* guess) {
-      if (trimmed.length() == 0) {
-         *guess = 0.0;
-         return true;
-      }
-      if (exponent + trimmed.length() - 1 >= kMaxDecimalPower) {
-         *guess = Double::Infinity();
-         return true;
-      }
-      if (exponent + trimmed.length() <= kMinDecimalPower) {
-         *guess = 0.0;
-         return true;
-      }
-      if (DoubleStrtod(trimmed, exponent, guess) ||
-          DiyFpStrtod(trimmed, exponent, guess)) {
-         return true;
-      }
-      if (*guess == Double::Infinity()) {
-         return true;
-      }
-      return false;
-   }
-   inline double Strtod( Vector< const char > buffer, int exponent )
-   {
-      double guess;
-      if (ComputeGuess(buffer, exponent, &guess)) {
-         return guess;
-      }
-      DiyFp upper_boundary = Double(guess).UpperBoundary();
-      int comparison = CompareBufferWithDiyFp(buffer, exponent, upper_boundary);
-      if (comparison < 0) {
-         return guess;
-      } else if (comparison > 0) {
-         return Double(guess).NextDouble();
-      } else if ((Double(guess).Significand() & 1) == 0) {
-         return guess;
-      } else {
-         return Double(guess).NextDouble();
-      }
-   }
-}  // namespace tao::json::double_conversion
-#endif