conversions.cc 44.2 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/handles/handles.h"
13
#include "src/heap/factory.h"
14 15
#include "src/numbers/dtoa.h"
#include "src/numbers/strtod.h"
16
#include "src/objects/bigint.h"
17
#include "src/objects/objects-inl.h"
18
#include "src/strings/char-predicates-inl.h"
19 20
#include "src/utils/allocation.h"
#include "src/utils/utils.h"
21

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

29 30
namespace v8 {
namespace internal {
31

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
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>
62
inline bool AdvanceToNonspace(Iterator* current, EndMark end) {
63
  while (*current != end) {
64
    if (!IsWhiteSpaceOrLineTerminator(**current)) return true;
65 66 67 68 69 70 71
    ++*current;
  }
  return false;
}

// Parsing integers with radix 2, 4, 8, 16, 32. Assumes current != end.
template <int radix_log_2, class Iterator, class EndMark>
72
double InternalStringToIntDouble(Iterator current, EndMark end, bool negative,
73 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
                                 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 {
99
      if (allow_trailing_junk || !AdvanceToNonspace(&current, end)) {
100 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
        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;
      }

130
      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
131 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
        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);
  }

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

// ES6 18.2.5 parseInt(string, radix) (with NumberParseIntHelper subclass);
171 172
// and BigInt parsing cases from https://tc39.github.io/proposal-bigint/
// (with StringToBigIntHelper subclass).
173
class StringToIntHelper {
174
 public:
175 176 177 178
  StringToIntHelper(Isolate* isolate, Handle<String> subject, int radix)
      : isolate_(isolate), subject_(subject), radix_(radix) {
    DCHECK(subject->IsFlat());
  }
179

180 181 182 183 184 185
  // Used for the StringToBigInt operation.
  StringToIntHelper(Isolate* isolate, Handle<String> subject)
      : isolate_(isolate), subject_(subject) {
    DCHECK(subject->IsFlat());
  }

186 187 188 189
  // Used for parsing BigInt literals, where the input is a Zone-allocated
  // buffer of one-byte digits, along with an optional radix prefix.
  StringToIntHelper(Isolate* isolate, const uint8_t* subject, int length)
      : isolate_(isolate), raw_one_byte_subject_(subject), length_(length) {}
190
  virtual ~StringToIntHelper() = default;
191

192 193 194 195
 protected:
  // Subclasses must implement these:
  virtual void AllocateResult() = 0;
  virtual void ResultMultiplyAdd(uint32_t multiplier, uint32_t part) = 0;
196

197 198 199 200 201 202
  // Subclasses must call this to do all the work.
  void ParseInt();

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

203 204 205 206 207 208 209
  // 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; }

210 211
  bool IsOneByte() const {
    return raw_one_byte_subject_ != nullptr ||
212
           String::IsOneByteRepresentationUnderneath(*subject_);
213 214 215 216 217 218
  }

  Vector<const uint8_t> GetOneByteVector() {
    if (raw_one_byte_subject_ != nullptr) {
      return Vector<const uint8_t>(raw_one_byte_subject_, length_);
    }
219 220
    DisallowHeapAllocation no_gc;
    return subject_->GetFlatContent(no_gc).ToOneByteVector();
221 222 223
  }

  Vector<const uc16> GetTwoByteVector() {
224 225
    DisallowHeapAllocation no_gc;
    return subject_->GetFlatContent(no_gc).ToUC16Vector();
226 227
  }

228
  // Subclasses get access to internal state:
229
  enum State { kRunning, kError, kJunk, kEmpty, kZero, kDone };
230

231 232
  enum class Sign { kNegative, kPositive, kNone };

233 234 235 236
  Isolate* isolate() { return isolate_; }
  int radix() { return radix_; }
  int cursor() { return cursor_; }
  int length() { return length_; }
237 238
  bool negative() { return sign_ == Sign::kNegative; }
  Sign sign() { return sign_; }
239 240
  State state() { return state_; }
  void set_state(State state) { state_ = state; }
241 242

 private:
243 244 245 246 247 248 249
  template <class Char>
  void DetectRadixInternal(Char current, int length);
  template <class Char>
  void ParseInternal(Char start);

  Isolate* isolate_;
  Handle<String> subject_;
250 251
  const uint8_t* raw_one_byte_subject_ = nullptr;
  int radix_ = 0;
252 253
  int cursor_ = 0;
  int length_ = 0;
254
  Sign sign_ = Sign::kNone;
255
  bool leading_zero_ = false;
256 257
  bool allow_binary_and_octal_prefixes_ = false;
  bool allow_trailing_junk_ = true;
258
  State state_ = kRunning;
259 260
};

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

template <class Char>
void StringToIntHelper::DetectRadixInternal(Char current, int length) {
  Char start = current;
  length_ = length;
  Char end = start + length;
296

297
  if (!AdvanceToNonspace(&current, end)) {
298
    return set_state(kEmpty);
299 300 301 302 303 304 305 306
  }

  if (*current == '+') {
    // Ignore leading sign; skip following spaces.
    ++current;
    if (current == end) {
      return set_state(kJunk);
    }
307
    sign_ = Sign::kPositive;
308 309 310 311 312
  } else if (*current == '-') {
    ++current;
    if (current == end) {
      return set_state(kJunk);
    }
313
    sign_ = Sign::kNegative;
314 315 316 317 318 319 320 321 322 323 324 325
  }

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

  if (!leading_zero_ && !isDigit(*current, radix_)) {
    return set_state(kJunk);
  }

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

369 370 371 372 373 374 375 376 377 378 379 380 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
template <class Char>
void StringToIntHelper::ParseInternal(Char start) {
  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.
410
      const uint32_t kMaximumMultiplier = 0xFFFFFFFFU / 36;
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
      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);

428
  if (!allow_trailing_junk_ && AdvanceToNonspace(&current, end)) {
429 430 431
    return set_state(kJunk);
  }

432
  return set_state(kDone);
433 434
}

435 436 437 438 439 440 441 442 443
class NumberParseIntHelper : public StringToIntHelper {
 public:
  NumberParseIntHelper(Isolate* isolate, Handle<String> string, int radix)
      : StringToIntHelper(isolate, string, radix) {}

  double GetResult() {
    ParseInt();
    switch (state()) {
      case kJunk:
444
      case kEmpty:
445 446 447 448 449 450 451 452 453 454 455
        return JunkStringValue();
      case kZero:
        return SignedZero(negative());
      case kDone:
        return negative() ? -result_ : result_;
      case kError:
      case kRunning:
        break;
    }
    UNREACHABLE();
  }
456

457
 protected:
458 459
  void AllocateResult() override {}
  void ResultMultiplyAdd(uint32_t multiplier, uint32_t part) override {
460 461 462 463
    result_ = result_ * multiplier + part;
  }

 private:
464
  void HandleSpecialCases() override {
465 466 467
    bool is_power_of_two = base::bits::IsPowerOfTwo(radix());
    if (!is_power_of_two && radix() != 10) return;
    DisallowHeapAllocation no_gc;
468 469
    if (IsOneByte()) {
      Vector<const uint8_t> vector = GetOneByteVector();
470
      DCHECK_EQ(length(), vector.length());
471 472
      result_ = is_power_of_two ? HandlePowerOfTwoCase(vector.begin())
                                : HandleBaseTenCase(vector.begin());
473
    } else {
474
      Vector<const uc16> vector = GetTwoByteVector();
475
      DCHECK_EQ(length(), vector.length());
476 477
      result_ = is_power_of_two ? HandlePowerOfTwoCase(vector.begin())
                                : HandleBaseTenCase(vector.begin());
478 479
    }
    set_state(kDone);
480
  }
481 482 483 484 485 486 487 488 489 490

  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:
491 492
        return InternalStringToIntDouble<1>(current, end, negative,
                                            allow_trailing_junk);
493
      case 4:
494 495
        return InternalStringToIntDouble<2>(current, end, negative,
                                            allow_trailing_junk);
496
      case 8:
497 498
        return InternalStringToIntDouble<3>(current, end, negative,
                                            allow_trailing_junk);
499 500

      case 16:
501 502
        return InternalStringToIntDouble<4>(current, end, negative,
                                            allow_trailing_junk);
503 504

      case 32:
505 506
        return InternalStringToIntDouble<5>(current, end, negative,
                                            allow_trailing_junk);
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
      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.
527
        DCHECK_LT(buffer_pos, kBufferSize);
528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
        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>
549 550
double InternalStringToDouble(Iterator current, EndMark end, int flags,
                              double empty_string_val) {
551 552 553 554 555 556 557 558
  // 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'.
559
  if (!AdvanceToNonspace(&current, end)) {
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
    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;
  char buffer[kBufferSize];  // NOLINT: size is known at compile time.
  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();
    }

607
    if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
608 609 610
      return JunkStringValue();
    }

611
    DCHECK_EQ(buffer_pos, 0);
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
    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".
      }

629
      return InternalStringToIntDouble<4>(current, end, false,
630 631 632 633 634 635 636 637 638
                                          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".
      }

639
      return InternalStringToIntDouble<3>(current, end, false,
640 641 642 643 644 645 646 647 648
                                          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".
      }

649
      return InternalStringToIntDouble<1>(current, end, false,
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
                                          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) {
665
      DCHECK_LT(buffer_pos, kBufferSize);
666 667 668 669 670 671 672 673 674 675 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
      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) {
710
        DCHECK_LT(buffer_pos, kBufferSize);
711 712 713 714 715 716 717 718 719 720 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
        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);
  }

781
  if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
782 783 784 785 786 787 788
    return JunkStringValue();
  }

parsing_done:
  exponent += insignificant_digits;

  if (octal) {
789 790
    return InternalStringToIntDouble<3>(buffer, buffer + buffer_pos,
                                        sign == NEGATIVE, allow_trailing_junk);
791 792 793 794 795 796 797 798 799 800 801 802
  }

  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;
803 804
}

805
double StringToDouble(const char* str, int flags, double empty_string_val) {
806 807 808
  // 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);
809 810
}

811
double StringToDouble(Vector<const uint8_t> str, int flags,
812
                      double empty_string_val) {
813 814
  return InternalStringToDouble(str.begin(), str.end(), flags,
                                empty_string_val);
815 816
}

817
double StringToDouble(Vector<const uc16> str, int flags,
818
                      double empty_string_val) {
819 820
  const uc16* end = str.begin() + str.length();
  return InternalStringToDouble(str.begin(), end, flags, empty_string_val);
821 822
}

823 824 825
double StringToInt(Isolate* isolate, Handle<String> string, int radix) {
  NumberParseIntHelper helper(isolate, string, radix);
  return helper.GetResult();
826 827
}

828
class StringToBigIntHelper : public StringToIntHelper {
829
 public:
830
  enum class Behavior { kStringToBigInt, kLiteral };
831 832

  // Used for StringToBigInt operation (BigInt constructor and == operator).
833
  StringToBigIntHelper(Isolate* isolate, Handle<String> string)
834 835 836 837 838
      : StringToIntHelper(isolate, string),
        behavior_(Behavior::kStringToBigInt) {
    set_allow_binary_and_octal_prefixes();
    set_disallow_trailing_junk();
  }
839

840 841
  // Used for parsing BigInt literals, where the input is a buffer of
  // one-byte ASCII digits, along with an optional radix prefix.
842
  StringToBigIntHelper(Isolate* isolate, const uint8_t* string, int length)
843
      : StringToIntHelper(isolate, string, length),
844 845 846
        behavior_(Behavior::kLiteral) {
    set_allow_binary_and_octal_prefixes();
  }
847

848 849
  MaybeHandle<BigInt> GetResult() {
    ParseInt();
850 851 852 853
    if (behavior_ == Behavior::kStringToBigInt && sign() != Sign::kNone &&
        radix() != 10) {
      return MaybeHandle<BigInt>();
    }
854
    if (state() == kEmpty) {
855
      if (behavior_ == Behavior::kStringToBigInt) {
856 857 858 859 860
        set_state(kZero);
      } else {
        UNREACHABLE();
      }
    }
861 862
    switch (state()) {
      case kJunk:
863
        if (should_throw() == kThrowOnError) {
864 865 866 867
          THROW_NEW_ERROR(isolate(),
                          NewSyntaxError(MessageTemplate::kBigIntInvalidString),
                          BigInt);
        } else {
868
          DCHECK_EQ(should_throw(), kDontThrow);
869 870
          return MaybeHandle<BigInt>();
        }
871
      case kZero:
872
        return BigInt::Zero(isolate());
873
      case kError:
874
        DCHECK_EQ(should_throw() == kThrowOnError,
875
                  isolate()->has_pending_exception());
876 877
        return MaybeHandle<BigInt>();
      case kDone:
878
        return BigInt::Finalize(result_, negative());
879
      case kEmpty:
880 881 882 883 884
      case kRunning:
        break;
    }
    UNREACHABLE();
  }
885

886
 protected:
887
  void AllocateResult() override {
888 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?
    int charcount = length() - cursor();
893 894
    // For literals, we pretenure the allocated BigInt, since it's about
    // to be stored in the interpreter's constants array.
895 896 897
    AllocationType allocation = behavior_ == Behavior::kLiteral
                                    ? AllocationType::kOld
                                    : AllocationType::kYoung;
898
    MaybeHandle<FreshlyAllocatedBigInt> maybe = BigInt::AllocateFor(
899
        isolate(), radix(), charcount, should_throw(), allocation);
900 901 902 903 904
    if (!maybe.ToHandle(&result_)) {
      set_state(kError);
    }
  }

905
  void ResultMultiplyAdd(uint32_t multiplier, uint32_t part) override {
906 907
    BigInt::InplaceMultiplyAdd(result_, static_cast<uintptr_t>(multiplier),
                               static_cast<uintptr_t>(part));
908 909 910
  }

 private:
911
  ShouldThrow should_throw() const { return kDontThrow; }
912

913
  Handle<FreshlyAllocatedBigInt> result_;
914
  Behavior behavior_;
915 916
};

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

923
MaybeHandle<BigInt> BigIntLiteral(Isolate* isolate, const char* string) {
924
  StringToBigIntHelper helper(isolate, reinterpret_cast<const uint8_t*>(string),
925 926 927 928
                              static_cast<int>(strlen(string)));
  return helper.GetResult();
}

929
const char* DoubleToCString(double v, Vector<char> buffer) {
930
  switch (FPCLASSIFY_NAMESPACE::fpclassify(v)) {
931 932 933 934 935 936
    case FP_NAN:
      return "NaN";
    case FP_INFINITE:
      return (v < 0.0 ? "-Infinity" : "Infinity");
    case FP_ZERO:
      return "0";
937
    default: {
938 939 940 941 942
      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);
      }
943
      SimpleStringBuilder builder(buffer.begin(), buffer.length());
944 945
      int decimal_point;
      int sign;
946
      const int kV8DtoaBufferCapacity = kBase10MaximalLength + 1;
947
      char decimal_rep[kV8DtoaBufferCapacity];
948
      int length;
949

950
      DoubleToAscii(v, DTOA_SHORTEST, 0,
951 952
                    Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
                    &length, &decimal_point);
953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983

      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;
984
        builder.AddDecimalInteger(exponent);
985
      }
986
      return builder.Finalize();
987 988 989 990 991
    }
  }
}

const char* IntToCString(int n, Vector<char> buffer) {
992 993
  bool negative = true;
  if (n >= 0) {
994
    n = -n;
995
    negative = false;
996 997 998 999 1000
  }
  // Build the string backwards from the least significant digit.
  int i = buffer.length();
  buffer[--i] = '\0';
  do {
1001 1002
    // We ensured n <= 0, so the subtraction does the right addition.
    buffer[--i] = '0' - (n % 10);
1003 1004 1005
    n /= 10;
  } while (n);
  if (negative) buffer[--i] = '-';
1006
  return buffer.begin() + i;
1007 1008 1009
}

char* DoubleToFixedCString(double value, int f) {
1010
  const int kMaxDigitsBeforePoint = 21;
1011
  const double kFirstNonFixed = 1e21;
1012 1013
  DCHECK_GE(f, 0);
  DCHECK_LE(f, kMaxFractionDigits);
1014 1015 1016 1017 1018 1019 1020 1021

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

1022 1023 1024
  // If abs_value has more than kMaxDigitsBeforePoint digits before the point
  // use the non-fixed conversion routine.
  if (abs_value >= kFirstNonFixed) {
1025
    char arr[kMaxFractionDigits];
1026
    Vector<char> buffer(arr, arraysize(arr));
1027 1028 1029 1030 1031 1032
    return StrDup(DoubleToCString(value, buffer));
  }

  // Find a sufficiently precise decimal representation of n.
  int decimal_point;
  int sign;
1033
  // Add space for the '\0' byte.
1034
  const int kDecimalRepCapacity =
1035
      kMaxDigitsBeforePoint + kMaxFractionDigits + 1;
1036 1037
  char decimal_rep[kDecimalRepCapacity];
  int decimal_rep_length;
1038
  DoubleToAscii(value, DTOA_FIXED, f,
1039 1040
                Vector<char>(decimal_rep, kDecimalRepCapacity), &sign,
                &decimal_rep_length, &decimal_point);
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051

  // 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) {
1052 1053
    zero_postfix_length =
        decimal_point + f - decimal_rep_length - zero_prefix_length;
1054 1055 1056 1057
  }

  unsigned rep_length =
      zero_prefix_length + decimal_rep_length + zero_postfix_length;
1058
  SimpleStringBuilder rep_builder(rep_length + 1);
1059 1060 1061 1062 1063 1064 1065 1066
  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;
1067
  SimpleStringBuilder builder(result_size + 1);
1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
  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();
}

1078
static char* CreateExponentialRepresentation(char* decimal_rep, int exponent,
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
                                             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;
1091
  SimpleStringBuilder builder(result_size + 1);
1092 1093 1094 1095 1096 1097

  if (negative) builder.AddCharacter('-');
  builder.AddCharacter(decimal_rep[0]);
  if (significant_digits != 1) {
    builder.AddCharacter('.');
    builder.AddString(decimal_rep + 1);
1098 1099 1100
    size_t rep_length = strlen(decimal_rep);
    DCHECK_GE(significant_digits, rep_length);
    builder.AddPadding('0', significant_digits - static_cast<int>(rep_length));
1101 1102 1103 1104
  }

  builder.AddCharacter('e');
  builder.AddCharacter(negative_exponent ? '-' : '+');
1105
  builder.AddDecimalInteger(exponent);
1106 1107 1108 1109 1110
  return builder.Finalize();
}

char* DoubleToExponentialCString(double value, int f) {
  // f might be -1 to signal that f was undefined in JavaScript.
1111
  DCHECK(f >= -1 && f <= kMaxFractionDigits);
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121

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

  // Find a sufficiently precise decimal representation of n.
  int decimal_point;
  int sign;
1122 1123 1124
  // 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.
1125
  const int kV8DtoaBufferCapacity = kMaxFractionDigits + 1 + 1;
1126 1127
  // Make sure that the buffer is big enough, even if we fall back to the
  // shortest representation (which happens when f equals -1).
1128
  DCHECK_LE(kBase10MaximalLength, kMaxFractionDigits + 1);
1129
  char decimal_rep[kV8DtoaBufferCapacity];
1130 1131
  int decimal_rep_length;

1132
  if (f == -1) {
1133
    DoubleToAscii(value, DTOA_SHORTEST, 0,
1134 1135
                  Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
                  &decimal_rep_length, &decimal_point);
1136
    f = decimal_rep_length - 1;
1137
  } else {
1138
    DoubleToAscii(value, DTOA_PRECISION, f + 1,
1139 1140
                  Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
                  &decimal_rep_length, &decimal_point);
1141
  }
1142
  DCHECK_GT(decimal_rep_length, 0);
1143
  DCHECK(decimal_rep_length <= f + 1);
1144 1145 1146

  int exponent = decimal_point - 1;
  char* result =
1147
      CreateExponentialRepresentation(decimal_rep, exponent, negative, f + 1);
1148 1149 1150 1151 1152

  return result;
}

char* DoubleToPrecisionCString(double value, int p) {
1153
  const int kMinimalDigits = 1;
1154
  DCHECK(p >= kMinimalDigits && p <= kMaxFractionDigits);
1155
  USE(kMinimalDigits);
1156 1157 1158 1159 1160 1161 1162 1163 1164 1165

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

  // Find a sufficiently precise decimal representation of n.
  int decimal_point;
  int sign;
1166
  // Add one for the terminating null character.
1167
  const int kV8DtoaBufferCapacity = kMaxFractionDigits + 1;
1168
  char decimal_rep[kV8DtoaBufferCapacity];
1169 1170
  int decimal_rep_length;

1171
  DoubleToAscii(value, DTOA_PRECISION, p,
1172 1173
                Vector<char>(decimal_rep, kV8DtoaBufferCapacity), &sign,
                &decimal_rep_length, &decimal_point);
1174
  DCHECK(decimal_rep_length <= p);
1175 1176 1177

  int exponent = decimal_point - 1;

1178
  char* result = nullptr;
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188

  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.
1189 1190
    unsigned result_size =
        (decimal_point <= 0) ? -decimal_point + p + 3 : p + 2;
1191
    SimpleStringBuilder builder(result_size + 1);
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
    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) {
1206 1207 1208 1209
          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));
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
          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) {
1222
  DCHECK(radix >= 2 && radix <= 36);
1223 1224
  DCHECK(std::isfinite(value));
  DCHECK_NE(0.0, value);
1225 1226 1227
  // Character array used for conversion.
  static const char chars[] = "0123456789abcdefghijklmnopqrstuvwxyz";

1228 1229
  // 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
1230 1231 1232 1233
  // 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;
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
  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);
1246 1247
  delta = std::max(Double(0.0).NextDouble(), delta);
  DCHECK_GT(delta, 0.0);
1248
  if (fraction >= delta) {
1249 1250 1251 1252 1253 1254 1255 1256 1257 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
    // 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;
        }
      }
1283
    } while (fraction >= delta);
1284
  }
1285

1286 1287 1288 1289 1290
  // Compute integer digits. Fill unrepresented digits with zero.
  while (Double(integer / radix).Exponent() > 0) {
    integer /= radix;
    buffer[--integer_cursor] = '0';
  }
1291
  do {
1292
    double remainder = Modulo(integer, radix);
1293 1294
    buffer[--integer_cursor] = chars[static_cast<int>(remainder)];
    integer = (integer - remainder) / radix;
1295 1296 1297 1298 1299
  } while (integer > 0);

  // Add sign and terminate string.
  if (negative) buffer[--integer_cursor] = '-';
  buffer[fraction_cursor++] = '\0';
1300 1301
  DCHECK_LT(fraction_cursor, kBufferSize);
  DCHECK_LE(0, integer_cursor);
1302 1303 1304 1305
  // 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;
1306 1307
}

1308
// ES6 18.2.4 parseFloat(string)
1309
double StringToDouble(Isolate* isolate, Handle<String> string, int flags,
1310 1311
                      double empty_string_val) {
  Handle<String> flattened = String::Flatten(isolate, string);
1312 1313
  {
    DisallowHeapAllocation no_gc;
1314
    String::FlatContent flat = flattened->GetFlatContent(no_gc);
1315 1316
    DCHECK(flat.IsFlat());
    if (flat.IsOneByte()) {
1317
      return StringToDouble(flat.ToOneByteVector(), flags, empty_string_val);
1318
    } else {
1319
      return StringToDouble(flat.ToUC16Vector(), flags, empty_string_val);
1320
    }
1321 1322 1323
  }
}

1324
bool IsSpecialIndex(String string) {
dcarney's avatar
dcarney committed
1325 1326
  // Max length of canonical double: -X.XXXXXXXXXXXXXXXXX-eXXX
  const int kBufferSize = 24;
1327
  const int length = string.length();
dcarney's avatar
dcarney committed
1328
  if (length == 0 || length > kBufferSize) return false;
1329
  uint16_t buffer[kBufferSize];
dcarney's avatar
dcarney committed
1330 1331 1332
  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.
1333
  int offset = 0;
dcarney's avatar
dcarney committed
1334 1335 1336 1337 1338 1339 1340 1341 1342
  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;
        }
1343
      }
dcarney's avatar
dcarney committed
1344 1345 1346 1347 1348 1349 1350 1351
      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;
1352 1353
    }
  }
dcarney's avatar
dcarney committed
1354 1355 1356 1357 1358 1359 1360
  // 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]);
1361
    }
dcarney's avatar
dcarney committed
1362 1363 1364 1365 1366 1367 1368 1369
    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);
1370
  double d = StringToDouble(vector, NO_FLAGS);
dcarney's avatar
dcarney committed
1371 1372 1373 1374 1375 1376 1377
  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;
1378 1379 1380
  }
  return true;
}
1381 1382
}  // namespace internal
}  // namespace v8
1383 1384

#undef FPCLASSIFY_NAMESPACE