handle the special snowflakes that are Integer Indexed Exotic objects

src/conversions.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <limits.h>
 #include <stdarg.h>
 #include <cmath>
 
 #include "src/v8.h"
 
 #include "src/assert-scope.h"
+#include "src/char-predicates-inl.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
 #include "src/dtoa.h"
 #include "src/factory.h"
 #include "src/list-inl.h"
 #include "src/strtod.h"
 #include "src/utils.h"
 
 #ifndef _STLP_VENDOR_CSTD
 // STLPort doesn't import fpclassify into the std namespace.
@@ skipping 473 matching lines @@
       return StringToDouble(unicode_cache, flat.ToOneByteVector(), flags,
                             empty_string_val);
     } else {
       return StringToDouble(unicode_cache, flat.ToUC16Vector(), flags,
                             empty_string_val);
     }
   }
 }
 
 
+bool IsNonArrayIndexInteger(String* string) {
+  const int kBufferSize = 64;
+  const int kUint32MaxChars = 11;
+  uint16_t buffer[kBufferSize];
+  int offset = 0;
+  const int length = string->length();
+  DCHECK_NE(0, length);
+  // First iteration, check for minus, 0 followed by anything else, etc.
+  {
+    int to = std::min(offset + kUint32MaxChars, length);
+    String::WriteToFlat(string, buffer, offset, to);
+    bool negative = false;
+    if (buffer[offset] == '-') {
+      negative = true;
+      ++offset;
+      if (offset == to) return false;  // Just '-' is bad.
+    }
+    if (buffer[offset] == '0') {
+      ++offset;
+      return offset == 2 && offset == to;  // Match just '-0'.

[Toon Verwaest, 2015/03/10 14:26:09]

Quite some boilerplate pretending to be in a loop while you're not ... return to
== 2; without ++offset?

+    }
+    uint64_t acc = 0;

[Toon Verwaest, 2015/03/10 14:26:10]

Wrap the entire "fast-path" into
if (!negative) {....}}
And use the case below
while (offset != length) {...}
for negative values. That's probably faster given that you don't need to keep
track of the value, you'll always return "true" for all-decimal-digit negative
values, just like for guaranteed-out-of-32bit-range positive values.

+    for (; offset < to; ++offset) {
+      uint64_t digit = buffer[offset] - '0';
+      if (digit > 9) return false;
+      acc = 10 * acc + digit;
+    }
+    // String is consumed.  Evaluate what we have.
+    if (offset == length) {
+      if (negative) return true;
+      return acc > static_cast<uint64_t>(std::numeric_limits<uint32_t>::max());
+    }
+  }
+  // Consume rest of string.  If we get here, we're way out of uint32_t bounds.
+  while (offset != length) {
+    int to = std::min(offset + kBufferSize, length);
+    String::WriteToFlat(string, buffer, offset, to);
+    for (; offset < to; ++offset) {
+      if (!IsDecimalDigit(buffer[offset])) return false;
+    }
+  }
+  return true;
+}
 } }  // namespace v8::internal