Add runtime function for string to array conversion.

src/runtime.cc

 // Copyright 2006-2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4195 matching lines @@
 
   int right = length;
   if (trimRight) {
     while (right > left && IsTrimWhiteSpace(s->Get(right - 1))) {
       right--;
     }
   }
   return s->SubString(left, right);
 }
 
+
+// Copies ascii characters to the given fixed array looking up
+// one-char strings in the cache. Gives up on the first char that is
+// not in the cache. Returns the length of the successfully copied
+// prefix.
+static int CopyCachedAsciiCharsToArray(const char* chars,
+                                       FixedArray* elements,
+                                       int length) {
+  AssertNoAllocation nogc;
+  FixedArray* ascii_cache = Heap::single_character_string_cache();
+  Object* undefined = Heap::undefined_value();
+  for (int i = 0; i < length; ++i) {
+    Object* value = ascii_cache->get(chars[i]);
+    if (value == undefined) return i;
+    ASSERT(!Heap::InNewSpace(value));
+    elements->set(i, value, SKIP_WRITE_BARRIER);
+  }
+  return length;
+}
+
+
+// Converts a String to JSArray.
+// For example, "foo" => ["f", "o", "o"].
+static Object* Runtime_StringToArray(Arguments args) {
+  HandleScope scope;
+  ASSERT(args.length() == 1);
+  CONVERT_ARG_CHECKED(String, s, 0);
+
+  s->TryFlatten();
+  const int length = s->length();
+
+  Handle<FixedArray> elements = Factory::NewUninitializedFixedArray(length);
+  if (s->IsFlat()) {
+    if (s->IsAsciiRepresentation()) {
+      Vector<const char> chars = s->ToAsciiVector();
+      int num_copied_from_cache = CopyCachedAsciiCharsToArray(chars.start(),
+                                                              *elements,
+                                                              length);
+      for (int i = num_copied_from_cache; i < length; ++i) {
+        elements->set(i, *LookupSingleCharacterStringFromCode(chars[i]),
+                      UPDATE_WRITE_BARRIER);

[Mads Ager (chromium), 2010/03/04 13:30:56]

Just omit the WriteBarrierMode here since the default is to update the write
barrier.  The same for the two occurrences below.

[Vitaly Repeshko, 2010/03/04 14:03:12]

Done.

+      }
+    } else {
+      ASSERT(s->IsTwoByteRepresentation());
+      Vector<const uc16> chars = s->ToUC16Vector();
+      for (int i = 0; i < length; ++i) {
+        elements->set(i, *LookupSingleCharacterStringFromCode(chars[i]),
+                      UPDATE_WRITE_BARRIER);
+      }
+    }
+  } else {
+    for (int i = 0; i < length; ++i) {
+      elements->set(i, *LookupSingleCharacterStringFromCode(s->Get(i)),
+                    UPDATE_WRITE_BARRIER);
+    }
+  }
+
+#ifdef DEBUG
+  for (int i = 0; i < length; ++i) {
+    ASSERT(String::cast(elements->get(i))->length() == 1);
+  }
+#endif
+
+  return *Factory::NewJSArrayWithElements(elements);
+}
+
+
 bool Runtime::IsUpperCaseChar(uint16_t ch) {
   unibrow::uchar chars[unibrow::ToUppercase::kMaxWidth];
   int char_length = to_upper_mapping.get(ch, 0, chars);
   return char_length == 0;
 }
 
 
 static Object* Runtime_NumberToString(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
@@ skipping 4256 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     Counters::gc_last_resort_from_js.Increment();
     Heap::CollectAllGarbage(false);
   }
 }
 
 
 } }  // namespace v8::internal