conversions.cc 44.8 KB
Newer Older
1
// Copyright 2011 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4

5
#include "src/numbers/conversions.h"
6

7
#include <limits.h>
8
#include <stdarg.h>
9
#include <cmath>
10

11
#include "src/common/assert-scope.h"
12
#include "src/execution/off-thread-isolate.h"
13
#include "src/handles/handles.h"
14
#include "src/heap/factory.h"
15 16
#include "src/numbers/dtoa.h"
#include "src/numbers/strtod.h"
17
#include "src/objects/bigint.h"
18
#include "src/objects/objects-inl.h"
19
#include "src/strings/char-predicates-inl.h"
20 21
#include "src/utils/allocation.h"
#include "src/utils/utils.h"
22

23
#if defined(_STLP_VENDOR_CSTD)
24
// STLPort doesn't import fpclassify into the std namespace.
25 26 27
#define FPCLASSIFY_NAMESPACE
#else
#define FPCLASSIFY_NAMESPACE std
28 29
#endif

30 31
namespace v8 {
namespace internal {
32

33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
inline double JunkStringValue() {
  return bit_cast<double, uint64_t>(kQuietNaNMask);
}

inline double SignedZero(bool negative) {
  return negative ? uint64_to_double(Double::kSignMask) : 0.0;
}

inline bool isDigit(int x, int radix) {
  return (x >= '0' && x <= '9' && x < '0' + radix) ||
         (radix > 10 && x >= 'a' && x < 'a' + radix - 10) ||
         (radix > 10 && x >= 'A' && x < 'A' + radix - 10);
}

inline bool isBinaryDigit(int x) { return x == '0' || x == '1'; }

template <class Iterator, class EndMark>
bool SubStringEquals(Iterator* current, EndMark end, const char* substring) {
  DCHECK(**current == *substring);
  for (substring++; *substring != '\0'; substring++) {
    ++*current;
    if (*current == end || **current != *substring) return false;
  }
  ++*current;
  return true;
}

// Returns true if a nonspace character has been found and false if the
// end was been reached before finding a nonspace character.
template <class Iterator, class EndMark>
63
inline bool AdvanceToNonspace(Iterator* current, EndMark end) {
64
  while (*current != end) {
65
    if (!IsWhiteSpaceOrLineTerminator(**current)) return true;
66 67 68 69 70 71 72
    ++*current;
  }
  return false;
}

// Parsing integers with radix 2, 4, 8, 16, 32. Assumes current != end.
template <int radix_log_2, class Iterator, class EndMark>
73
double InternalStringToIntDouble(Iterator current, EndMark end, bool negative,
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
                                 bool allow_trailing_junk) {
  DCHECK(current != end);

  // Skip leading 0s.
  while (*current == '0') {
    ++current;
    if (current == end) return SignedZero(negative);
  }

  int64_t number = 0;
  int exponent = 0;
  const int radix = (1 << radix_log_2);

  int lim_0 = '0' + (radix < 10 ? radix : 10);
  int lim_a = 'a' + (radix - 10);
  int lim_A = 'A' + (radix - 10);

  do {
    int digit;
    if (*current >= '0' && *current < lim_0) {
      digit = static_cast<char>(*current) - '0';
    } else if (*current >= 'a' && *current < lim_a) {
      digit = static_cast<char>(*current) - 'a' + 10;
    } else if (*current >= 'A' && *current < lim_A) {
      digit = static_cast<char>(*current) - 'A' + 10;
    } else {
100
      if (allow_trailing_junk || !AdvanceToNonspace(&current, end)) {
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
        break;
      } else {
        return JunkStringValue();
      }
    }

    number = number * radix + digit;
    int overflow = static_cast<int>(number >> 53);
    if (overflow != 0) {
      // Overflow occurred. Need to determine which direction to round the
      // result.
      int overflow_bits_count = 1;
      while (overflow > 1) {
        overflow_bits_count++;
        overflow >>= 1;
      }

      int dropped_bits_mask = ((1 << overflow_bits_count) - 1);
      int dropped_bits = static_cast<int>(number) & dropped_bits_mask;
      number >>= overflow_bits_count;
      exponent = overflow_bits_count;

      bool zero_tail = true;
      while (true) {
        ++current;
        if (current == end || !isDigit(*current, radix)) break;
        zero_tail = zero_tail && *current == '0';
        exponent += radix_log_2;
      }

131
      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
        return JunkStringValue();
      }

      int middle_value = (1 << (overflow_bits_count - 1));
      if (dropped_bits > middle_value) {
        number++;  // Rounding up.
      } else if (dropped_bits == middle_value) {
        // Rounding to even to consistency with decimals: half-way case rounds
        // up if significant part is odd and down otherwise.
        if ((number & 1) != 0 || !zero_tail) {
          number++;  // Rounding up.
        }
      }

      // Rounding up may cause overflow.
      if ((number & (static_cast<int64_t>(1) << 53)) != 0) {
        exponent++;
        number >>= 1;
      }
      break;
    }
    ++current;
  } while (current != end);

  DCHECK(number < ((int64_t)1 << 53));
  DCHECK(static_cast<int64_t>(static_cast<double>(number)) == number);

  if (exponent == 0) {
    if (negative) {
      if (number == 0) return -0.0;
      number = -number;
    }
    return static_cast<double>(number);
  }

167
  DCHECK_NE(number, 0);
168 169 170
  return std::ldexp(static_cast<double>(negative ? -number : number), exponent);
}

171 172 173 174 175 176 177 178 179
namespace {

// Subclasses of StringToIntHelper get access to internal state:
enum class State { kRunning, kError, kJunk, kEmpty, kZero, kDone };

enum class Sign { kNegative, kPositive, kNone };

}  // namespace

180
// ES6 18.2.5 parseInt(string, radix) (with NumberParseIntHelper subclass);
181 182
// and BigInt parsing cases from https://tc39.github.io/proposal-bigint/
// (with StringToBigIntHelper subclass).
183
template <typename LocalIsolate>
184
class StringToIntHelper {
185
 public:
186
  StringToIntHelper(LocalIsolate* isolate, Handle<String> subject, int radix)
187 188 189
      : isolate_(isolate), subject_(subject), radix_(radix) {
    DCHECK(subject->IsFlat());
  }
190

191
  // Used for the StringToBigInt operation.
192
  StringToIntHelper(LocalIsolate* isolate, Handle<String> subject)
193 194 195 196
      : isolate_(isolate), subject_(subject) {
    DCHECK(subject->IsFlat());
  }

197 198
  // Used for parsing BigInt literals, where the input is a Zone-allocated
  // buffer of one-byte digits, along with an optional radix prefix.
199
  StringToIntHelper(LocalIsolate* isolate, const uint8_t* subject, int length)
200
      : isolate_(isolate), raw_one_byte_subject_(subject), length_(length) {}
201
  virtual ~StringToIntHelper() = default;
202

203 204 205 206
 protected:
  // Subclasses must implement these:
  virtual void AllocateResult() = 0;
  virtual void ResultMultiplyAdd(uint32_t multiplier, uint32_t part) = 0;
207

208 209 210 211 212 213
  // Subclasses must call this to do all the work.
  void ParseInt();

  // Subclasses may override this.
  virtual void HandleSpecialCases() {}

214 215 216 217 218 219 220
  // Subclass constructors should call these for configuration before calling
  // ParseInt().
  void set_allow_binary_and_octal_prefixes() {
    allow_binary_and_octal_prefixes_ = true;
  }
  void set_disallow_trailing_junk() { allow_trailing_junk_ = false; }

221 222
  bool IsOneByte() const {
    return raw_one_byte_subject_ != nullptr ||
223
           String::IsOneByteRepresentationUnderneath(*subject_);
224 225 226 227 228 229
  }

  Vector<const uint8_t> GetOneByteVector() {
    if (raw_one_byte_subject_ != nullptr) {
      return Vector<const uint8_t>(raw_one_byte_subject_, length_);
    }
230 231
    DisallowHeapAllocation no_gc;
    return subject_->GetFlatContent(no_gc).ToOneByteVector();
232 233 234
  }

  Vector<const uc16> GetTwoByteVector() {
235 236
    DisallowHeapAllocation no_gc;
    return subject_->GetFlatContent(no_gc).ToUC16Vector();
237 238
  }

239
  LocalIsolate* isolate() { return isolate_; }
240 241 242
  int radix() { return radix_; }
  int cursor() { return cursor_; }
  int length() { return length_; }
243 244
  bool negative() { return sign_ == Sign::kNegative; }
  Sign sign() { return sign_; }
245 246
  State state() { return state_; }
  void set_state(State state) { state_ = state; }
247 248

 private:
249 250 251 252 253
  template <class Char>
  void DetectRadixInternal(Char current, int length);
  template <class Char>
  void ParseInternal(Char start);

254 255
  LocalIsolate* isolate_;
  Handle<String> subject_;
256 257
  const uint8_t* raw_one_byte_subject_ = nullptr;
  int radix_ = 0;
258 259
  int cursor_ = 0;
  int length_ = 0;
260
  Sign sign_ = Sign::kNone;
261
  bool leading_zero_ = false;
262 263
  bool allow_binary_and_octal_prefixes_ = false;
  bool allow_trailing_junk_ = true;
264
  State state_ = State::kRunning;
265 266
};

267 268
template <typename LocalIsolate>
void StringToIntHelper<LocalIsolate>::ParseInt() {
269 270
  {
    DisallowHeapAllocation no_gc;
271 272
    if (IsOneByte()) {
      Vector<const uint8_t> vector = GetOneByteVector();
273
      DetectRadixInternal(vector.begin(), vector.length());
274
    } else {
275
      Vector<const uc16> vector = GetTwoByteVector();
276
      DetectRadixInternal(vector.begin(), vector.length());
277 278
    }
  }
279
  if (state_ != State::kRunning) return;
280 281
  AllocateResult();
  HandleSpecialCases();
282
  if (state_ != State::kRunning) return;
283 284
  {
    DisallowHeapAllocation no_gc;
285 286
    if (IsOneByte()) {
      Vector<const uint8_t> vector = GetOneByteVector();
287
      DCHECK_EQ(length_, vector.length());
288
      ParseInternal(vector.begin());
289
    } else {
290
      Vector<const uc16> vector = GetTwoByteVector();
291
      DCHECK_EQ(length_, vector.length());
292
      ParseInternal(vector.begin());
293 294
    }
  }
295
  DCHECK_NE(state_, State::kRunning);
296 297
}

298
template <typename LocalIsolate>
299
template <class Char>
300 301
void StringToIntHelper<LocalIsolate>::DetectRadixInternal(Char current,
                                                          int length) {
302 303 304
  Char start = current;
  length_ = length;
  Char end = start + length;
305

306
  if (!AdvanceToNonspace(&current, end)) {
307
    return set_state(State::kEmpty);
308 309 310 311 312 313
  }

  if (*current == '+') {
    // Ignore leading sign; skip following spaces.
    ++current;
    if (current == end) {
314
      return set_state(State::kJunk);
315
    }
316
    sign_ = Sign::kPositive;
317 318 319
  } else if (*current == '-') {
    ++current;
    if (current == end) {
320
      return set_state(State::kJunk);
321
    }
322
    sign_ = Sign::kNegative;
323 324 325 326 327 328 329
  }

  if (radix_ == 0) {
    // Radix detection.
    radix_ = 10;
    if (*current == '0') {
      ++current;
330
      if (current == end) return set_state(State::kZero);
331 332 333
      if (*current == 'x' || *current == 'X') {
        radix_ = 16;
        ++current;
334
        if (current == end) return set_state(State::kJunk);
335
      } else if (allow_binary_and_octal_prefixes_ &&
336 337 338
                 (*current == 'o' || *current == 'O')) {
        radix_ = 8;
        ++current;
339
        if (current == end) return set_state(State::kJunk);
340
      } else if (allow_binary_and_octal_prefixes_ &&
341 342 343
                 (*current == 'b' || *current == 'B')) {
        radix_ = 2;
        ++current;
344
        if (current == end) return set_state(State::kJunk);
345 346 347 348 349 350 351 352
      } else {
        leading_zero_ = true;
      }
    }
  } else if (radix_ == 16) {
    if (*current == '0') {
      // Allow "0x" prefix.
      ++current;
353
      if (current == end) return set_state(State::kZero);
354 355
      if (*current == 'x' || *current == 'X') {
        ++current;
356
        if (current == end) return set_state(State::kJunk);
357 358 359 360 361 362 363 364 365
      } else {
        leading_zero_ = true;
      }
    }
  }
  // Skip leading zeros.
  while (*current == '0') {
    leading_zero_ = true;
    ++current;
366
    if (current == end) return set_state(State::kZero);
367 368 369
  }

  if (!leading_zero_ && !isDigit(*current, radix_)) {
370
    return set_state(State::kJunk);
371 372 373 374 375
  }

  DCHECK(radix_ >= 2 && radix_ <= 36);
  STATIC_ASSERT(String::kMaxLength <= INT_MAX);
  cursor_ = static_cast<int>(current - start);
376 377
}

378
template <typename LocalIsolate>
379
template <class Char>
380
void StringToIntHelper<LocalIsolate>::ParseInternal(Char start) {
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
  Char current = start + cursor_;
  Char end = start + length_;

  // The following code causes accumulating rounding error for numbers greater
  // than ~2^56. It's explicitly allowed in the spec: "if R is not 2, 4, 8, 10,
  // 16, or 32, then mathInt may be an implementation-dependent approximation to
  // the mathematical integer value" (15.1.2.2).

  int lim_0 = '0' + (radix_ < 10 ? radix_ : 10);
  int lim_a = 'a' + (radix_ - 10);
  int lim_A = 'A' + (radix_ - 10);

  // NOTE: The code for computing the value may seem a bit complex at
  // first glance. It is structured to use 32-bit multiply-and-add
  // loops as long as possible to avoid losing precision.

  bool done = false;
  do {
    // Parse the longest part of the string starting at {current}
    // possible while keeping the multiplier, and thus the part
    // itself, within 32 bits.
    uint32_t part = 0, multiplier = 1;
    while (true) {
      uint32_t d;
      if (*current >= '0' && *current < lim_0) {
        d = *current - '0';
      } else if (*current >= 'a' && *current < lim_a) {
        d = *current - 'a' + 10;
      } else if (*current >= 'A' && *current < lim_A) {
        d = *current - 'A' + 10;
      } else {
        done = true;
        break;
      }

      // Update the value of the part as long as the multiplier fits
      // in 32 bits. When we can't guarantee that the next iteration
      // will not overflow the multiplier, we stop parsing the part
      // by leaving the loop.
420
      const uint32_t kMaximumMultiplier = 0xFFFFFFFFU / 36;
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
      uint32_t m = multiplier * static_cast<uint32_t>(radix_);
      if (m > kMaximumMultiplier) break;
      part = part * radix_ + d;
      multiplier = m;
      DCHECK(multiplier > part);

      ++current;
      if (current == end) {
        done = true;
        break;
      }
    }

    // Update the value and skip the part in the string.
    ResultMultiplyAdd(multiplier, part);
  } while (!done);

438
  if (!allow_trailing_junk_ && AdvanceToNonspace(&current, end)) {
439
    return set_state(State::kJunk);
440 441
  }

442
  return set_state(State::kDone);
443 444
}

445
class NumberParseIntHelper : public StringToIntHelper<Isolate> {
446 447 448 449 450 451 452
 public:
  NumberParseIntHelper(Isolate* isolate, Handle<String> string, int radix)
      : StringToIntHelper(isolate, string, radix) {}

  double GetResult() {
    ParseInt();
    switch (state()) {
453 454
      case State::kJunk:
      case State::kEmpty:
455
        return JunkStringValue();
456
      case State::kZero:
457
        return SignedZero(negative());
458
      case State::kDone:
459
        return negative() ? -result_ : result_;
460 461
      case State::kError:
      case State::kRunning:
462 463 464 465
        break;
    }
    UNREACHABLE();
  }
466

467
 protected:
468 469
  void AllocateResult() override {}
  void ResultMultiplyAdd(uint32_t multiplier, uint32_t part) override {
470 471 472 473
    result_ = result_ * multiplier + part;
  }

 private:
474
  void HandleSpecialCases() override {
475 476 477
    bool is_power_of_two = base::bits::IsPowerOfTwo(radix());
    if (!is_power_of_two && radix() != 10) return;
    DisallowHeapAllocation no_gc;
478 479
    if (IsOneByte()) {
      Vector<const uint8_t> vector = GetOneByteVector();
480
      DCHECK_EQ(length(), vector.length());
481 482
      result_ = is_power_of_two ? HandlePowerOfTwoCase(vector.begin())
                                : HandleBaseTenCase(vector.begin());
483
    } else {
484
      Vector<const uc16> vector = GetTwoByteVector();
485
      DCHECK_EQ(length(), vector.length());
486 487
      result_ = is_power_of_two ? HandlePowerOfTwoCase(vector.begin())
                                : HandleBaseTenCase(vector.begin());
488
    }
489
    set_state(State::kDone);
490
  }
491 492 493 494 495 496 497 498 499 500

  template <class Char>
  double HandlePowerOfTwoCase(Char start) {
    Char current = start + cursor();
    Char end = start + length();
    const bool allow_trailing_junk = true;
    // GetResult() will take care of the sign bit, so ignore it for now.
    const bool negative = false;
    switch (radix()) {
      case 2:
501 502
        return InternalStringToIntDouble<1>(current, end, negative,
                                            allow_trailing_junk);
503
      case 4:
504 505
        return InternalStringToIntDouble<2>(current, end, negative,
                                            allow_trailing_junk);
506
      case 8:
507 508
        return InternalStringToIntDouble<3>(current, end, negative,
                                            allow_trailing_junk);
509 510

      case 16:
511 512
        return InternalStringToIntDouble<4>(current, end, negative,
                                            allow_trailing_junk);
513 514

      case 32:
515 516
        return InternalStringToIntDouble<5>(current, end, negative,
                                            allow_trailing_junk);
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
      default:
        UNREACHABLE();
    }
  }

  template <class Char>
  double HandleBaseTenCase(Char start) {
    // Parsing with strtod.
    Char current = start + cursor();
    Char end = start + length();
    const int kMaxSignificantDigits = 309;  // Doubles are less than 1.8e308.
    // The buffer may contain up to kMaxSignificantDigits + 1 digits and a zero
    // end.
    const int kBufferSize = kMaxSignificantDigits + 2;
    char buffer[kBufferSize];
    int buffer_pos = 0;
    while (*current >= '0' && *current <= '9') {
      if (buffer_pos <= kMaxSignificantDigits) {
        // If the number has more than kMaxSignificantDigits it will be parsed
        // as infinity.
537
        DCHECK_LT(buffer_pos, kBufferSize);
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
        buffer[buffer_pos++] = static_cast<char>(*current);
      }
      ++current;
      if (current == end) break;
    }

    SLOW_DCHECK(buffer_pos < kBufferSize);
    buffer[buffer_pos] = '\0';
    Vector<const char> buffer_vector(buffer, buffer_pos);
    return Strtod(buffer_vector, 0);
  }

  double result_ = 0;
};

// Converts a string to a double value. Assumes the Iterator supports
// the following operations:
// 1. current == end (other ops are not allowed), current != end.
// 2. *current - gets the current character in the sequence.
// 3. ++current (advances the position).
template <class Iterator, class EndMark>
559 560
double InternalStringToDouble(Iterator current, EndMark end, int flags,
                              double empty_string_val) {
561 562 563 564 565 566 567 568
  // To make sure that iterator dereferencing is valid the following
  // convention is used:
  // 1. Each '++current' statement is followed by check for equality to 'end'.
  // 2. If AdvanceToNonspace returned false then current == end.
  // 3. If 'current' becomes be equal to 'end' the function returns or goes to
  // 'parsing_done'.
  // 4. 'current' is not dereferenced after the 'parsing_done' label.
  // 5. Code before 'parsing_done' may rely on 'current != end'.
569
  if (!AdvanceToNonspace(&current, end)) {
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
    return empty_string_val;
  }

  const bool allow_trailing_junk = (flags & ALLOW_TRAILING_JUNK) != 0;

  // Maximum number of significant digits in decimal representation.
  // The longest possible double in decimal representation is
  // (2^53 - 1) * 2 ^ -1074 that is (2 ^ 53 - 1) * 5 ^ 1074 / 10 ^ 1074
  // (768 digits). If we parse a number whose first digits are equal to a
  // mean of 2 adjacent doubles (that could have up to 769 digits) the result
  // must be rounded to the bigger one unless the tail consists of zeros, so
  // we don't need to preserve all the digits.
  const int kMaxSignificantDigits = 772;

  // The longest form of simplified number is: "-<significant digits>'.1eXXX\0".
  const int kBufferSize = kMaxSignificantDigits + 10;
586
  char buffer[kBufferSize];
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
  int buffer_pos = 0;

  // Exponent will be adjusted if insignificant digits of the integer part
  // or insignificant leading zeros of the fractional part are dropped.
  int exponent = 0;
  int significant_digits = 0;
  int insignificant_digits = 0;
  bool nonzero_digit_dropped = false;

  enum Sign { NONE, NEGATIVE, POSITIVE };

  Sign sign = NONE;

  if (*current == '+') {
    // Ignore leading sign.
    ++current;
    if (current == end) return JunkStringValue();
    sign = POSITIVE;
  } else if (*current == '-') {
    ++current;
    if (current == end) return JunkStringValue();
    sign = NEGATIVE;
  }

  static const char kInfinityString[] = "Infinity";
  if (*current == kInfinityString[0]) {
    if (!SubStringEquals(&current, end, kInfinityString)) {
      return JunkStringValue();
    }

617
    if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
618 619 620
      return JunkStringValue();
    }

621
    DCHECK_EQ(buffer_pos, 0);
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
    return (sign == NEGATIVE) ? -V8_INFINITY : V8_INFINITY;
  }

  bool leading_zero = false;
  if (*current == '0') {
    ++current;
    if (current == end) return SignedZero(sign == NEGATIVE);

    leading_zero = true;

    // It could be hexadecimal value.
    if ((flags & ALLOW_HEX) && (*current == 'x' || *current == 'X')) {
      ++current;
      if (current == end || !isDigit(*current, 16) || sign != NONE) {
        return JunkStringValue();  // "0x".
      }

639
      return InternalStringToIntDouble<4>(current, end, false,
640 641 642 643 644 645 646 647 648
                                          allow_trailing_junk);

      // It could be an explicit octal value.
    } else if ((flags & ALLOW_OCTAL) && (*current == 'o' || *current == 'O')) {
      ++current;
      if (current == end || !isDigit(*current, 8) || sign != NONE) {
        return JunkStringValue();  // "0o".
      }

649
      return InternalStringToIntDouble<3>(current, end, false,
650 651 652 653 654 655 656 657 658
                                          allow_trailing_junk);

      // It could be a binary value.
    } else if ((flags & ALLOW_BINARY) && (*current == 'b' || *current == 'B')) {
      ++current;
      if (current == end || !isBinaryDigit(*current) || sign != NONE) {
        return JunkStringValue();  // "0b".
      }

659
      return InternalStringToIntDouble<1>(current, end, false,
660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
                                          allow_trailing_junk);
    }

    // Ignore leading zeros in the integer part.
    while (*current == '0') {
      ++current;
      if (current == end) return SignedZero(sign == NEGATIVE);
    }
  }

  bool octal = leading_zero && (flags & ALLOW_IMPLICIT_OCTAL) != 0;

  // Copy significant digits of the integer part (if any) to the buffer.
  while (*current >= '0' && *current <= '9') {
    if (significant_digits < kMaxSignificantDigits) {
675
      DCHECK_LT(buffer_pos, kBufferSize);
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
      buffer[buffer_pos++] = static_cast<char>(*current);
      significant_digits++;
      // Will later check if it's an octal in the buffer.
    } else {
      insignificant_digits++;  // Move the digit into the exponential part.
      nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
    }
    octal = octal && *current < '8';
    ++current;
    if (current == end) goto parsing_done;
  }

  if (significant_digits == 0) {
    octal = false;
  }

  if (*current == '.') {
    if (octal && !allow_trailing_junk) return JunkStringValue();
    if (octal) goto parsing_done;

    ++current;
    if (current == end) {
      if (significant_digits == 0 && !leading_zero) {
        return JunkStringValue();
      } else {
        goto parsing_done;
      }
    }

    if (significant_digits == 0) {
      // octal = false;
      // Integer part consists of 0 or is absent. Significant digits start after
      // leading zeros (if any).
      while (*current == '0') {
        ++current;
        if (current == end) return SignedZero(sign == NEGATIVE);
        exponent--;  // Move this 0 into the exponent.
      }
    }

    // There is a fractional part.  We don't emit a '.', but adjust the exponent
    // instead.
    while (*current >= '0' && *current <= '9') {
      if (significant_digits < kMaxSignificantDigits) {
720
        DCHECK_LT(buffer_pos, kBufferSize);
721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790
        buffer[buffer_pos++] = static_cast<char>(*current);
        significant_digits++;
        exponent--;
      } else {
        // Ignore insignificant digits in the fractional part.
        nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
      }
      ++current;
      if (current == end) goto parsing_done;
    }
  }

  if (!leading_zero && exponent == 0 && significant_digits == 0) {
    // If leading_zeros is true then the string contains zeros.
    // If exponent < 0 then string was [+-]\.0*...
    // If significant_digits != 0 the string is not equal to 0.
    // Otherwise there are no digits in the string.
    return JunkStringValue();
  }

  // Parse exponential part.
  if (*current == 'e' || *current == 'E') {
    if (octal) return JunkStringValue();
    ++current;
    if (current == end) {
      if (allow_trailing_junk) {
        goto parsing_done;
      } else {
        return JunkStringValue();
      }
    }
    char sign = '+';
    if (*current == '+' || *current == '-') {
      sign = static_cast<char>(*current);
      ++current;
      if (current == end) {
        if (allow_trailing_junk) {
          goto parsing_done;
        } else {
          return JunkStringValue();
        }
      }
    }

    if (current == end || *current < '0' || *current > '9') {
      if (allow_trailing_junk) {
        goto parsing_done;
      } else {
        return JunkStringValue();
      }
    }

    const int max_exponent = INT_MAX / 2;
    DCHECK(-max_exponent / 2 <= exponent && exponent <= max_exponent / 2);
    int num = 0;
    do {
      // Check overflow.
      int digit = *current - '0';
      if (num >= max_exponent / 10 &&
          !(num == max_exponent / 10 && digit <= max_exponent % 10)) {
        num = max_exponent;
      } else {
        num = num * 10 + digit;
      }
      ++current;
    } while (current != end && *current >= '0' && *current <= '9');

    exponent += (sign == '-' ? -num : num);
  }

791
  if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
792 793 794 795 796 797 798
    return JunkStringValue();
  }

parsing_done:
  exponent += insignificant_digits;

  if (octal) {
799 800
    return InternalStringToIntDouble<3>(buffer, buffer + buffer_pos,
                                        sign == NEGATIVE, allow_trailing_junk);
801 802 803 804 805 806 807 808 809 810 811 812
  }

  if (nonzero_digit_dropped) {
    buffer[buffer_pos++] = '1';
    exponent--;
  }

  SLOW_DCHECK(buffer_pos < kBufferSize);
  buffer[buffer_pos] = '\0';

  double converted = Strtod(Vector<const char>(buffer, buffer_pos), exponent);
  return (sign == NEGATIVE) ? -converted : converted;
813 814
}

815
double StringToDouble(const char* str, int flags, double empty_string_val) {
816 817 818
  // We use {OneByteVector} instead of {CStrVector} to avoid instantiating the
  // InternalStringToDouble() template for {const char*} as well.
  return StringToDouble(OneByteVector(str), flags, empty_string_val);
819 820
}

821
double StringToDouble(Vector<const uint8_t> str, int flags,
822
                      double empty_string_val) {
823 824
  return InternalStringToDouble(str.begin(), str.end(), flags,
                                empty_string_val);
825 826
}

827
double StringToDouble(Vector<const uc16> str, int flags,
828
                      double empty_string_val) {
829 830
  const uc16* end = str.begin() + str.length();
  return InternalStringToDouble(str.begin(), end, flags, empty_string_val);
831 832
}

833 834 835
double StringToInt(Isolate* isolate, Handle<String> string, int radix) {
  NumberParseIntHelper helper(isolate, string, radix);
  return helper.GetResult();
836 837
}

838 839
template <typename LocalIsolate>
class StringToBigIntHelper : public StringToIntHelper<LocalIsolate> {
840
 public:
841
  enum class Behavior { kStringToBigInt, kLiteral };
842 843

  // Used for StringToBigInt operation (BigInt constructor and == operator).
844 845
  StringToBigIntHelper(LocalIsolate* isolate, Handle<String> string)
      : StringToIntHelper<LocalIsolate>(isolate, string),
846
        behavior_(Behavior::kStringToBigInt) {
847 848
    this->set_allow_binary_and_octal_prefixes();
    this->set_disallow_trailing_junk();
849
  }
850

851 852
  // Used for parsing BigInt literals, where the input is a buffer of
  // one-byte ASCII digits, along with an optional radix prefix.
853 854
  StringToBigIntHelper(LocalIsolate* isolate, const uint8_t* string, int length)
      : StringToIntHelper<LocalIsolate>(isolate, string, length),
855
        behavior_(Behavior::kLiteral) {
856
    this->set_allow_binary_and_octal_prefixes();
857
  }
858

859
  MaybeHandle<BigInt> GetResult() {
860 861 862
    this->ParseInt();
    if (behavior_ == Behavior::kStringToBigInt && this->sign() != Sign::kNone &&
        this->radix() != 10) {
863
      return MaybeHandle<BigInt>();
864
    }
865
    if (this->state() == State::kEmpty) {
866
      if (behavior_ == Behavior::kStringToBigInt) {
867
        this->set_state(State::kZero);
868 869 870 871
      } else {
        UNREACHABLE();
      }
    }
872 873 874
    switch (this->state()) {
      case State::kJunk:
      case State::kError:
875
        return MaybeHandle<BigInt>();
876
      case State::kZero:
877
        return BigInt::Zero(this->isolate(), allocation_type());
878 879 880 881
      case State::kDone:
        return BigInt::Finalize<Isolate>(result_, this->negative());
      case State::kEmpty:
      case State::kRunning:
882 883 884 885
        break;
    }
    UNREACHABLE();
  }
886

887
 protected:
888
  void AllocateResult() override {
889 890 891 892
    // We have to allocate a BigInt that's big enough to fit the result.
    // Conseratively assume that all remaining digits are significant.
    // Optimization opportunity: Would it makes sense to scan for trailing
    // junk before allocating the result?
893
    int charcount = this->length() - this->cursor();
894 895 896
    MaybeHandle<FreshlyAllocatedBigInt> maybe =
        BigInt::AllocateFor(this->isolate(), this->radix(), charcount,
                            kDontThrow, allocation_type());
897
    if (!maybe.ToHandle(&result_)) {
898
      this->set_state(State::kError);
899 900 901
    }
  }

902
  void ResultMultiplyAdd(uint32_t multiplier, uint32_t part) override {
903
    BigInt::InplaceMultiplyAdd(*result_, static_cast<uintptr_t>(multiplier),
904
                               static_cast<uintptr_t>(part));
905 906
  }

907 908 909 910 911 912 913
  AllocationType allocation_type() {
    // For literals, we pretenure the allocated BigInt, since it's about
    // to be stored in the interpreter's constants array.
    return behavior_ == Behavior::kLiteral ? AllocationType::kOld
                                           : AllocationType::kYoung;
  }

914
 private:
915
  Handle<FreshlyAllocatedBigInt> result_;
916
  Behavior behavior_;
917 918
};

919
MaybeHandle<BigInt> StringToBigInt(Isolate* isolate, Handle<String> string) {
920
  string = String::Flatten(isolate, string);
921
  StringToBigIntHelper<Isolate> helper(isolate, string);
922 923
  return helper.GetResult();
}
924

925 926 927 928 929
template <typename LocalIsolate>
MaybeHandle<BigInt> BigIntLiteral(LocalIsolate* isolate, const char* string) {
  StringToBigIntHelper<LocalIsolate> helper(
      isolate, reinterpret_cast<const uint8_t*>(string),
      static_cast<int>(strlen(string)));
930 931
  return helper.GetResult();
}
932 933 934
template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
    MaybeHandle<BigInt> BigIntLiteral(Isolate* isolate, const char* string);
template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
935 936
    MaybeHandle<BigInt> BigIntLiteral(OffThreadIsolate* isolate,
                                      const char* string);
937

938
const char* DoubleToCString(double v, Vector<char> buffer) {
939
  switch (FPCLASSIFY_NAMESPACE::fpclassify(v)) {
940 941 942 943 944 945
    case FP_NAN:
      return "NaN";
    case FP_INFINITE:
      return (v < 0.0 ? "-Infinity" : "Infinity");
    case FP_ZERO:
      return "0";
946
    default: {
947 948 949 950 951
      if (IsInt32Double(v)) {
        // This will trigger if v is -0 and -0.0 is stringified to "0".
        // (see ES section 7.1.12.1 #sec-tostring-applied-to-the-number-type)
        return IntToCString(FastD2I(v), buffer);
      }
952
      SimpleStringBuilder builder(buffer.begin(), buffer.length());
953 954
      int decimal_point;
      int sign;
955
      const int kV8DtoaBufferCapacity = kBase10MaximalLength + 1;
956
      char decimal_rep[kV8DtoaBufferCapacity];
957
      int length;
958

959
      DoubleToAscii(v, DTOA_SHORTEST, 0,
960 961
                    Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
                    &length, &decimal_point);
962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992

      if (sign) builder.AddCharacter('-');

      if (length <= decimal_point && decimal_point <= 21) {
        // ECMA-262 section 9.8.1 step 6.
        builder.AddString(decimal_rep);
        builder.AddPadding('0', decimal_point - length);

      } else if (0 < decimal_point && decimal_point <= 21) {
        // ECMA-262 section 9.8.1 step 7.
        builder.AddSubstring(decimal_rep, decimal_point);
        builder.AddCharacter('.');
        builder.AddString(decimal_rep + decimal_point);

      } else if (decimal_point <= 0 && decimal_point > -6) {
        // ECMA-262 section 9.8.1 step 8.
        builder.AddString("0.");
        builder.AddPadding('0', -decimal_point);
        builder.AddString(decimal_rep);

      } else {
        // ECMA-262 section 9.8.1 step 9 and 10 combined.
        builder.AddCharacter(decimal_rep[0]);
        if (length != 1) {
          builder.AddCharacter('.');
          builder.AddString(decimal_rep + 1);
        }
        builder.AddCharacter('e');
        builder.AddCharacter((decimal_point >= 0) ? '+' : '-');
        int exponent = decimal_point - 1;
        if (exponent < 0) exponent = -exponent;
993
        builder.AddDecimalInteger(exponent);
994
      }
995
      return builder.Finalize();
996 997 998 999 1000
    }
  }
}

const char* IntToCString(int n, Vector<char> buffer) {
1001 1002
  bool negative = true;
  if (n >= 0) {
1003
    n = -n;
1004
    negative = false;
1005 1006 1007 1008 1009
  }
  // Build the string backwards from the least significant digit.
  int i = buffer.length();
  buffer[--i] = '\0';
  do {
1010 1011
    // We ensured n <= 0, so the subtraction does the right addition.
    buffer[--i] = '0' - (n % 10);
1012 1013 1014
    n /= 10;
  } while (n);
  if (negative) buffer[--i] = '-';
1015
  return buffer.begin() + i;
1016 1017 1018
}

char* DoubleToFixedCString(double value, int f) {
1019
  const int kMaxDigitsBeforePoint = 21;
1020
  const double kFirstNonFixed = 1e21;
1021 1022
  DCHECK_GE(f, 0);
  DCHECK_LE(f, kMaxFractionDigits);
1023 1024 1025 1026 1027 1028 1029 1030

  bool negative = false;
  double abs_value = value;
  if (value < 0) {
    abs_value = -value;
    negative = true;
  }

1031 1032 1033
  // If abs_value has more than kMaxDigitsBeforePoint digits before the point
  // use the non-fixed conversion routine.
  if (abs_value >= kFirstNonFixed) {
1034
    char arr[kMaxFractionDigits];
1035
    Vector<char> buffer(arr, arraysize(arr));
1036 1037 1038 1039 1040 1041
    return StrDup(DoubleToCString(value, buffer));
  }

  // Find a sufficiently precise decimal representation of n.
  int decimal_point;
  int sign;
1042
  // Add space for the '\0' byte.
1043
  const int kDecimalRepCapacity =
1044
      kMaxDigitsBeforePoint + kMaxFractionDigits + 1;
1045 1046
  char decimal_rep[kDecimalRepCapacity];
  int decimal_rep_length;
1047
  DoubleToAscii(value, DTOA_FIXED, f,
1048 1049
                Vector<char>(decimal_rep, kDecimalRepCapacity), &sign,
                &decimal_rep_length, &decimal_point);
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060

  // Create a representation that is padded with zeros if needed.
  int zero_prefix_length = 0;
  int zero_postfix_length = 0;

  if (decimal_point <= 0) {
    zero_prefix_length = -decimal_point + 1;
    decimal_point = 1;
  }

  if (zero_prefix_length + decimal_rep_length < decimal_point + f) {
1061 1062
    zero_postfix_length =
        decimal_point + f - decimal_rep_length - zero_prefix_length;
1063 1064 1065 1066
  }

  unsigned rep_length =
      zero_prefix_length + decimal_rep_length + zero_postfix_length;
1067
  SimpleStringBuilder rep_builder(rep_length + 1);
1068 1069 1070 1071 1072 1073 1074 1075
  rep_builder.AddPadding('0', zero_prefix_length);
  rep_builder.AddString(decimal_rep);
  rep_builder.AddPadding('0', zero_postfix_length);
  char* rep = rep_builder.Finalize();

  // Create the result string by appending a minus and putting in a
  // decimal point if needed.
  unsigned result_size = decimal_point + f + 2;
1076
  SimpleStringBuilder builder(result_size + 1);
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
  if (negative) builder.AddCharacter('-');
  builder.AddSubstring(rep, decimal_point);
  if (f > 0) {
    builder.AddCharacter('.');
    builder.AddSubstring(rep + decimal_point, f);
  }
  DeleteArray(rep);
  return builder.Finalize();
}

1087
static char* CreateExponentialRepresentation(char* decimal_rep, int exponent,
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
                                             bool negative,
                                             int significant_digits) {
  bool negative_exponent = false;
  if (exponent < 0) {
    negative_exponent = true;
    exponent = -exponent;
  }

  // Leave room in the result for appending a minus, for a period, the
  // letter 'e', a minus or a plus depending on the exponent, and a
  // three digit exponent.
  unsigned result_size = significant_digits + 7;
1100
  SimpleStringBuilder builder(result_size + 1);
1101 1102 1103 1104 1105 1106

  if (negative) builder.AddCharacter('-');
  builder.AddCharacter(decimal_rep[0]);
  if (significant_digits != 1) {
    builder.AddCharacter('.');
    builder.AddString(decimal_rep + 1);
1107 1108 1109
    size_t rep_length = strlen(decimal_rep);
    DCHECK_GE(significant_digits, rep_length);
    builder.AddPadding('0', significant_digits - static_cast<int>(rep_length));
1110 1111 1112 1113
  }

  builder.AddCharacter('e');
  builder.AddCharacter(negative_exponent ? '-' : '+');
1114
  builder.AddDecimalInteger(exponent);
1115 1116 1117 1118 1119
  return builder.Finalize();
}

char* DoubleToExponentialCString(double value, int f) {
  // f might be -1 to signal that f was undefined in JavaScript.
1120
  DCHECK(f >= -1 && f <= kMaxFractionDigits);
1121 1122 1123 1124 1125 1126 1127 1128 1129 1130

  bool negative = false;
  if (value < 0) {
    value = -value;
    negative = true;
  }

  // Find a sufficiently precise decimal representation of n.
  int decimal_point;
  int sign;
1131 1132 1133
  // f corresponds to the digits after the point. There is always one digit
  // before the point. The number of requested_digits equals hence f + 1.
  // And we have to add one character for the null-terminator.
1134
  const int kV8DtoaBufferCapacity = kMaxFractionDigits + 1 + 1;
1135 1136
  // Make sure that the buffer is big enough, even if we fall back to the
  // shortest representation (which happens when f equals -1).
1137
  DCHECK_LE(kBase10MaximalLength, kMaxFractionDigits + 1);
1138
  char decimal_rep[kV8DtoaBufferCapacity];
1139 1140
  int decimal_rep_length;

1141
  if (f == -1) {
1142
    DoubleToAscii(value, DTOA_SHORTEST, 0,
1143 1144
                  Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
                  &decimal_rep_length, &decimal_point);
1145
    f = decimal_rep_length - 1;
1146
  } else {
1147
    DoubleToAscii(value, DTOA_PRECISION, f + 1,
1148 1149
                  Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
                  &decimal_rep_length, &decimal_point);
1150
  }
1151
  DCHECK_GT(decimal_rep_length, 0);
1152
  DCHECK(decimal_rep_length <= f + 1);
1153 1154 1155

  int exponent = decimal_point - 1;
  char* result =
1156
      CreateExponentialRepresentation(decimal_rep, exponent, negative, f + 1);
1157 1158 1159 1160 1161

  return result;
}

char* DoubleToPrecisionCString(double value, int p) {
1162
  const int kMinimalDigits = 1;
1163
  DCHECK(p >= kMinimalDigits && p <= kMaxFractionDigits);
1164
  USE(kMinimalDigits);
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174

  bool negative = false;
  if (value < 0) {
    value = -value;
    negative = true;
  }

  // Find a sufficiently precise decimal representation of n.
  int decimal_point;
  int sign;
1175
  // Add one for the terminating null character.
1176
  const int kV8DtoaBufferCapacity = kMaxFractionDigits + 1;
1177
  char decimal_rep[kV8DtoaBufferCapacity];
1178 1179
  int decimal_rep_length;

1180
  DoubleToAscii(value, DTOA_PRECISION, p,
1181 1182
                Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
                &decimal_rep_length, &decimal_point);
1183
  DCHECK(decimal_rep_length <= p);
1184 1185 1186

  int exponent = decimal_point - 1;

1187
  char* result = nullptr;
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197

  if (exponent < -6 || exponent >= p) {
    result =
        CreateExponentialRepresentation(decimal_rep, exponent, negative, p);
  } else {
    // Use fixed notation.
    //
    // Leave room in the result for appending a minus, a period and in
    // the case where decimal_point is not positive for a zero in
    // front of the period.
1198 1199
    unsigned result_size =
        (decimal_point <= 0) ? -decimal_point + p + 3 : p + 2;
1200
    SimpleStringBuilder builder(result_size + 1);
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
    if (negative) builder.AddCharacter('-');
    if (decimal_point <= 0) {
      builder.AddString("0.");
      builder.AddPadding('0', -decimal_point);
      builder.AddString(decimal_rep);
      builder.AddPadding('0', p - decimal_rep_length);
    } else {
      const int m = Min(decimal_rep_length, decimal_point);
      builder.AddSubstring(decimal_rep, m);
      builder.AddPadding('0', decimal_point - decimal_rep_length);
      if (decimal_point < p) {
        builder.AddCharacter('.');
        const int extra = negative ? 2 : 1;
        if (decimal_rep_length > decimal_point) {
1215 1216 1217 1218
          const size_t len = strlen(decimal_rep + decimal_point);
          DCHECK_GE(kMaxInt, len);
          const int n =
              Min(static_cast<int>(len), p - (builder.position() - extra));
1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
          builder.AddSubstring(decimal_rep + decimal_point, n);
        }
        builder.AddPadding('0', extra + (p - builder.position()));
      }
    }
    result = builder.Finalize();
  }

  return result;
}

char* DoubleToRadixCString(double value, int radix) {
1231
  DCHECK(radix >= 2 && radix <= 36);
1232 1233
  DCHECK(std::isfinite(value));
  DCHECK_NE(0.0, value);
1234 1235 1236
  // Character array used for conversion.
  static const char chars[] = "0123456789abcdefghijklmnopqrstuvwxyz";

1237 1238
  // Temporary buffer for the result. We start with the decimal point in the
  // middle and write to the left for the integer part and to the right for the
1239 1240 1241 1242
  // fractional part. 1024 characters for the exponent and 52 for the mantissa
  // either way, with additional space for sign, decimal point and string
  // termination should be sufficient.
  static const int kBufferSize = 2200;
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
  char buffer[kBufferSize];
  int integer_cursor = kBufferSize / 2;
  int fraction_cursor = integer_cursor;

  bool negative = value < 0;
  if (negative) value = -value;

  // Split the value into an integer part and a fractional part.
  double integer = std::floor(value);
  double fraction = value - integer;
  // We only compute fractional digits up to the input double's precision.
  double delta = 0.5 * (Double(value).NextDouble() - value);
1255 1256
  delta = std::max(Double(0.0).NextDouble(), delta);
  DCHECK_GT(delta, 0.0);
1257
  if (fraction >= delta) {
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291
    // Insert decimal point.
    buffer[fraction_cursor++] = '.';
    do {
      // Shift up by one digit.
      fraction *= radix;
      delta *= radix;
      // Write digit.
      int digit = static_cast<int>(fraction);
      buffer[fraction_cursor++] = chars[digit];
      // Calculate remainder.
      fraction -= digit;
      // Round to even.
      if (fraction > 0.5 || (fraction == 0.5 && (digit & 1))) {
        if (fraction + delta > 1) {
          // We need to back trace already written digits in case of carry-over.
          while (true) {
            fraction_cursor--;
            if (fraction_cursor == kBufferSize / 2) {
              CHECK_EQ('.', buffer[fraction_cursor]);
              // Carry over to the integer part.
              integer += 1;
              break;
            }
            char c = buffer[fraction_cursor];
            // Reconstruct digit.
            int digit = c > '9' ? (c - 'a' + 10) : (c - '0');
            if (digit + 1 < radix) {
              buffer[fraction_cursor++] = chars[digit + 1];
              break;
            }
          }
          break;
        }
      }
1292
    } while (fraction >= delta);
1293
  }
1294

1295 1296 1297 1298 1299
  // Compute integer digits. Fill unrepresented digits with zero.
  while (Double(integer / radix).Exponent() > 0) {
    integer /= radix;
    buffer[--integer_cursor] = '0';
  }
1300
  do {
1301
    double remainder = Modulo(integer, radix);
1302 1303
    buffer[--integer_cursor] = chars[static_cast<int>(remainder)];
    integer = (integer - remainder) / radix;
1304 1305 1306 1307 1308
  } while (integer > 0);

  // Add sign and terminate string.
  if (negative) buffer[--integer_cursor] = '-';
  buffer[fraction_cursor++] = '\0';
1309 1310
  DCHECK_LT(fraction_cursor, kBufferSize);
  DCHECK_LE(0, integer_cursor);
1311 1312 1313 1314
  // Allocate new string as return value.
  char* result = NewArray<char>(fraction_cursor - integer_cursor);
  memcpy(result, buffer + integer_cursor, fraction_cursor - integer_cursor);
  return result;
1315 1316
}

1317
// ES6 18.2.4 parseFloat(string)
1318
double StringToDouble(Isolate* isolate, Handle<String> string, int flags,
1319 1320
                      double empty_string_val) {
  Handle<String> flattened = String::Flatten(isolate, string);
1321 1322
  {
    DisallowHeapAllocation no_gc;
1323
    String::FlatContent flat = flattened->GetFlatContent(no_gc);
1324 1325
    DCHECK(flat.IsFlat());
    if (flat.IsOneByte()) {
1326
      return StringToDouble(flat.ToOneByteVector(), flags, empty_string_val);
1327
    } else {
1328
      return StringToDouble(flat.ToUC16Vector(), flags, empty_string_val);
1329
    }
1330 1331 1332
  }
}

1333
bool IsSpecialIndex(String string) {
dcarney's avatar
dcarney committed
1334 1335
  // Max length of canonical double: -X.XXXXXXXXXXXXXXXXX-eXXX
  const int kBufferSize = 24;
1336
  const int length = string.length();
dcarney's avatar
dcarney committed
1337
  if (length == 0 || length > kBufferSize) return false;
1338
  uint16_t buffer[kBufferSize];
dcarney's avatar
dcarney committed
1339 1340 1341
  String::WriteToFlat(string, buffer, 0, length);
  // If the first char is not a digit or a '-' or we can't match 'NaN' or
  // '(-)Infinity', bailout immediately.
1342
  int offset = 0;
dcarney's avatar
dcarney committed
1343 1344 1345 1346 1347 1348 1349 1350 1351
  if (!IsDecimalDigit(buffer[0])) {
    if (buffer[0] == '-') {
      if (length == 1) return false;  // Just '-' is bad.
      if (!IsDecimalDigit(buffer[1])) {
        if (buffer[1] == 'I' && length == 9) {
          // Allow matching of '-Infinity' below.
        } else {
          return false;
        }
1352
      }
dcarney's avatar
dcarney committed
1353 1354 1355 1356 1357 1358 1359 1360
      offset++;
    } else if (buffer[0] == 'I' && length == 8) {
      // Allow matching of 'Infinity' below.
    } else if (buffer[0] == 'N' && length == 3) {
      // Match NaN.
      return buffer[1] == 'a' && buffer[2] == 'N';
    } else {
      return false;
1361 1362
    }
  }
dcarney's avatar
dcarney committed
1363 1364 1365 1366 1367 1368 1369
  // Expected fast path: key is an integer.
  static const int kRepresentableIntegerLength = 15;  // (-)XXXXXXXXXXXXXXX
  if (length - offset <= kRepresentableIntegerLength) {
    const int initial_offset = offset;
    bool matches = true;
    for (; offset < length; offset++) {
      matches &= IsDecimalDigit(buffer[offset]);
1370
    }
dcarney's avatar
dcarney committed
1371 1372 1373 1374 1375 1376 1377 1378
    if (matches) {
      // Match 0 and -0.
      if (buffer[initial_offset] == '0') return initial_offset == length - 1;
      return true;
    }
  }
  // Slow path: test DoubleToString(StringToDouble(string)) == string.
  Vector<const uint16_t> vector(buffer, length);
1379
  double d = StringToDouble(vector, NO_FLAGS);
dcarney's avatar
dcarney committed
1380 1381 1382 1383 1384 1385 1386
  if (std::isnan(d)) return false;
  // Compute reverse string.
  char reverse_buffer[kBufferSize + 1];  // Result will be /0 terminated.
  Vector<char> reverse_vector(reverse_buffer, arraysize(reverse_buffer));
  const char* reverse_string = DoubleToCString(d, reverse_vector);
  for (int i = 0; i < length; ++i) {
    if (static_cast<uint16_t>(reverse_string[i]) != buffer[i]) return false;
1387 1388 1389
  }
  return true;
}
1390 1391
}  // namespace internal
}  // namespace v8
1392 1393

#undef FPCLASSIFY_NAMESPACE