Make String.fromCharCodes take start/end.

runtime/lib/string.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/bootstrap_natives.h"
 
 #include "include/dart_api.h"
 #include "vm/exceptions.h"
 #include "vm/dart_api_impl.h"
 #include "vm/isolate.h"
@@ skipping 24 matching lines @@
               String::New(Error::Cast(error).ToErrorCString())));
     } else if (!Dart_IsNull(result)) {
       Exceptions::ThrowArgumentError(
           String::Handle(String::New("Illegal environment value")));
     }
   }
   return default_value.raw();
 }
 
 
-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);
     }
     intptr_t value = Smi::Cast(index_object).Value();
     if (Utf::IsOutOfRange(value)) {
       Exceptions::ThrowByType(Exceptions::kArgument, Object::empty_array());
       UNREACHABLE();
     }
     // Now it is safe to cast the value.
     int32_t value32 = static_cast<int32_t>(value);
@@ skipping 67 matching lines @@
   return result.raw();
 }
 
 
 DEFINE_NATIVE_ENTRY(OneByteString_allocate, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, length_obj, arguments->NativeArgAt(0));
   return OneByteString::New(length_obj.Value(), Heap::kNew);
 }
 
 
-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();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 DEFINE_NATIVE_ENTRY(OneByteString_setAt, 3) {
@@ skipping 139 matching lines @@
       ? String::Handle(OneByteString::New(length_value, Heap::kNew))
       : String::Handle(TwoByteString::New(length_value, Heap::kNew));
   NoGCScope no_gc;
 
   uint16_t* data_position = reinterpret_cast<uint16_t*>(codeUnits.DataAddr(0));
   String::Copy(result, 0, data_position, length_value);
   return result.raw();
 }
 
 }  // namespace dart