Make String.fromCharCodes take start/end.

runtime/lib/string.cc

Index: runtime/lib/string.cc
diff --git a/runtime/lib/string.cc b/runtime/lib/string.cc
index 19222eb8c1d9db2bc6cc71d0c13fd35806462aa8..ea4df8209ad452512ffbf6cb1ec1f6065c26652b 100644
--- a/runtime/lib/string.cc
+++ b/runtime/lib/string.cc
@@ -42,32 +42,40 @@ DEFINE_NATIVE_ENTRY(String_fromEnvironment, 3) {
 }
 
 
-DEFINE_NATIVE_ENTRY(StringBase_createFromCodePoints, 1) {
+DEFINE_NATIVE_ENTRY(StringBase_createFromCodePoints, 3) {
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, list, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Smi, start_obj, arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Smi, end_obj, arguments->NativeArgAt(2));
+
+  intptr_t start = start_obj.Value();
+  intptr_t end = end_obj.Value();
+  ASSERT(0 <= start);
+  ASSERT(start <= end);

[srdjan, 2014/09/17 15:31:58]

Please explain in comment why  you cannot guarantee that list is a valid
argument, while you can guarantee that 'start' and 'end' are valid.

[Lasse Reichstein Nielsen, 2014/09/18 09:03:00]

Good point. It's probably safer to check it and throw proper ArgumentErrors.

+
   if (!list.IsGrowableObjectArray() && !list.IsArray()) {
     Exceptions::ThrowArgumentError(list);
   }
 
   Array& a = Array::Handle();
-  intptr_t array_len;
   if (list.IsGrowableObjectArray()) {
     const GrowableObjectArray& growableArray = GrowableObjectArray::Cast(list);
     a ^= growableArray.data();
-    array_len = growableArray.Length();
+    ASSERT(end <= growableArray.Length());
   } else {
     a ^= Array::Cast(list).raw();
-    array_len = a.Length();
+    ASSERT(end <= a.Length());
   }
 
   Zone* zone = isolate->current_zone();
 
   // Unbox the array and determine the maximum element width.
   bool is_one_byte_string = true;
+  intptr_t array_len = end - start;
   intptr_t utf16_len = array_len;
   int32_t* utf32_array = zone->Alloc<int32_t>(array_len);
   Instance& index_object = Instance::Handle(isolate);
   for (intptr_t i = 0; i < array_len; i++) {
-    index_object ^= a.At(i);
+    index_object ^= a.At(start + i);
     if (!index_object.IsSmi()) {
       Exceptions::ThrowArgumentError(index_object);
     }
@@ -155,43 +163,82 @@ DEFINE_NATIVE_ENTRY(OneByteString_allocate, 1) {
 }
 
 
-DEFINE_NATIVE_ENTRY(OneByteString_allocateFromOneByteList, 1) {
+DEFINE_NATIVE_ENTRY(OneByteString_allocateFromOneByteList, 3) {
   Instance& list = Instance::CheckedHandle(arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Smi, start_obj, arguments->NativeArgAt(1));
+  GET_NON_NULL_NATIVE_ARGUMENT(Smi, end_obj, arguments->NativeArgAt(2));
+
+  intptr_t start = start_obj.Value();
+  intptr_t end = end_obj.Value();
+  if (start < 0) {
+    const Array& args = Array::Handle(Array::New(1));
+    args.SetAt(0, start_obj);
+    Exceptions::ThrowByType(Exceptions::kArgument, args);
+  }
+  intptr_t length = end - start;
+  if (length < 0) {
+    const Array& args = Array::Handle(Array::New(1));
+    args.SetAt(0, end_obj);
+    Exceptions::ThrowByType(Exceptions::kArgument, args);
+  }
+  ASSERT(length >= 0);
   if (list.IsTypedData()) {
     const TypedData& array = TypedData::Cast(list);
-    intptr_t length = array.LengthInBytes();
-    return OneByteString::New(array, 0, length);
+    if (end > array.LengthInBytes()) {
+      const Array& args = Array::Handle(Array::New(1));
+      args.SetAt(0, end_obj);
+      Exceptions::ThrowByType(Exceptions::kArgument, args);
+    }
+    return OneByteString::New(array, start, length);
   } else if (list.IsExternalTypedData()) {
     const ExternalTypedData& array = ExternalTypedData::Cast(list);
-    intptr_t length = array.LengthInBytes();
-    return OneByteString::New(array, 0, length);
+    if (end > array.LengthInBytes()) {
+      const Array& args = Array::Handle(Array::New(1));
+      args.SetAt(0, end_obj);
+      Exceptions::ThrowByType(Exceptions::kArgument, args);
+    }
+    return OneByteString::New(array, start, length);
   } else if (RawObject::IsTypedDataViewClassId(list.GetClassId())) {
     const Instance& view = Instance::Cast(list);
-    intptr_t length = Smi::Value(TypedDataView::Length(view));
+    if (end > Smi::Value(TypedDataView::Length(view))) {
+      const Array& args = Array::Handle(Array::New(1));
+      args.SetAt(0, end_obj);
+      Exceptions::ThrowByType(Exceptions::kArgument, args);
+    }
     const Instance& data_obj = Instance::Handle(TypedDataView::Data(view));
     intptr_t data_offset = Smi::Value(TypedDataView::OffsetInBytes(view));
     if (data_obj.IsTypedData()) {
       const TypedData& array = TypedData::Cast(data_obj);
-      return OneByteString::New(array, data_offset, length);
+      return OneByteString::New(array, data_offset + start, length);
     } else if (data_obj.IsExternalTypedData()) {
       const ExternalTypedData& array = ExternalTypedData::Cast(data_obj);
-      return OneByteString::New(array, data_offset, length);
+      return OneByteString::New(array, data_offset + start, length);
     }
   } else if (list.IsArray()) {
     const Array& array = Array::Cast(list);
-    intptr_t length = array.Length();
+    if (end > array.Length()) {
+      const Array& args = Array::Handle(Array::New(1));
+      args.SetAt(0, end_obj);
+      Exceptions::ThrowByType(Exceptions::kArgument, args);
+    }
     String& string = String::Handle(OneByteString::New(length, Heap::kNew));
     for (int i = 0; i < length; i++) {
-      intptr_t value = Smi::Value(reinterpret_cast<RawSmi*>(array.At(i)));
+      intptr_t value =
+          Smi::Value(reinterpret_cast<RawSmi*>(array.At(start + i)));
       OneByteString::SetCharAt(string, i, value);
     }
     return string.raw();
   } else if (list.IsGrowableObjectArray()) {
     const GrowableObjectArray& array = GrowableObjectArray::Cast(list);
-    intptr_t length = array.Length();
+    if (end > array.Length()) {
+      const Array& args = Array::Handle(Array::New(1));
+      args.SetAt(0, end_obj);
+      Exceptions::ThrowByType(Exceptions::kArgument, args);
+    }
     String& string = String::Handle(OneByteString::New(length, Heap::kNew));
     for (int i = 0; i < length; i++) {
-      intptr_t value = Smi::Value(reinterpret_cast<RawSmi*>(array.At(i)));
+      intptr_t value =
+          Smi::Value(reinterpret_cast<RawSmi*>(array.At(start + i)));
       OneByteString::SetCharAt(string, i, value);
     }
     return string.raw();