Add primitive WebGL ArrayBuffer() support to d8

src/d8.cc

-// Copyright 2011 the V8 project authors. All rights reserved.
+// Copyright 2012 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
 //       with the distribution.
@@ skipping 262 matching lines @@
     if (source.IsEmpty()) {
       return ThrowException(String::New("Error loading file"));
     }
     if (!ExecuteString(source, String::New(*file), false, true)) {
       return ThrowException(String::New("Error executing file"));
     }
   }
   return Undefined();
 }
 
+static int convertToInt(Local<Value> value_in, TryCatch* try_catch) {

[Jakob Kummerow, 2012/01/11 10:17:53]

Rename to convertToUint?

[danno, 2012/01/11 13:07:41]

Done.

+  if (value_in->IsUint32()) {
+    return value_in->Uint32Value();
+  }
+
+  Local<Value> number = value_in->ToNumber();
+  if (number.IsEmpty()) {
+    ASSERT(try_catch->HasCaught());
+    return 0;
+  }
+
+  ASSERT(number->IsNumber());
+  Local<Int32> int32 = number->ToInt32();
+  if (int32.IsEmpty()) {
+    ASSERT(try_catch->HasCaught());
+    return 0;
+  }
+  int32_t raw_value = int32->Int32Value();
+  if (try_catch->HasCaught()) {
+    return 0;
+  }
+  if (raw_value < 0) {
+    ThrowException(String::New("Array length must not be negative."));
+    return 0;
+  }
+
+  static const int kMaxLength = 0x3fffffff;
+#ifndef V8_SHARED
+  ASSERT(kMaxLength == i::ExternalArray::kMaxLength);
+#endif  // V8_SHARED
+  if (raw_value > static_cast<int32_t>(kMaxLength)) {
+    ThrowException(
+        String::New("Array length exceeds maximum length."));
+  }
+  return static_cast<size_t>(raw_value);
+}
+
+
+const char kArrayBufferReferencePropName[] = "_array_buffer_ref";
+
 
 Handle<Value> Shell::CreateExternalArray(const Arguments& args,
                                          ExternalArrayType type,
                                          size_t element_size) {
   ASSERT(element_size == 1 || element_size == 2 || element_size == 4 ||
          element_size == 8);
-  if (args.Length() != 1) {
-    return ThrowException(
-        String::New("Array constructor needs one parameter."));
+  TryCatch try_catch;
+  size_t derived_from_element_size = 1;
+  if (args[0]->IsNumber()) {
+    if (args.Length() != 1) {
+      return ThrowException(
+          String::New("Array constructor with length must have "
+                      "one parameter."));
+    }
+  } else {
+    if (args.Length() > 3 || args.Length() == 0) {

[Jakob Kummerow, 2012/01/11 10:17:53]

Arguments.operator[] is benign enough to simply return 'undefined' for args[0]
if args.Length == 0, but nevertheless I'd prefer to check for Length() > 0
before doing anything else (you can print a better error message that way, too).

[danno, 2012/01/11 13:07:41]

Done.

+      return ThrowException(
+          String::New("Array constructor from ArrayBuffer must "
+                      "have 1-3 parameters."));
+    }
   }
-  static const int kMaxLength = 0x3fffffff;
-#ifndef V8_SHARED
-  ASSERT(kMaxLength == i::ExternalArray::kMaxLength);
-#endif  // V8_SHARED
-  size_t length = 0;
-  TryCatch try_catch;
-  if (args[0]->IsUint32()) {
-    length = args[0]->Uint32Value();
-  } else {
-    Local<Number> number = args[0]->ToNumber();
-    if (number.IsEmpty()) {
-      ASSERT(try_catch.HasCaught());
-      return try_catch.Exception();
+
+  Local<Value> length_value = (args.Length() == 1)
+      ? (args[0]->IsNumber()
+         ? args[0]
+         : args[0]->ToObject()->Get(String::New("length")))
+      : args[2];

[Jakob Kummerow, 2012/01/11 10:17:53]

args[2] is optional and could be undefined. As implemented, the code defaults to
0 in that case, which is not correct.

[danno, 2012/01/11 13:07:41]

Done.

+  int length = convertToInt(length_value, &try_catch);
+  if (try_catch.HasCaught()) return try_catch.Exception();
+
+  void* data = NULL;
+  if (!args[0]->IsNumber()) {
+    Handle<Object> array = args[0]->ToObject();
+    data = array->GetIndexedPropertiesExternalArrayData();
+    if (data == NULL) {
+      return ThrowException(
+          String::New("ArrayBuffer doesn't have data"));
     }
-    ASSERT(number->IsNumber());
-    Local<Int32> int32 = number->ToInt32();
-    if (int32.IsEmpty()) {
-      if (try_catch.HasCaught()) {
-        return try_catch.Exception();
-      }
+    derived_from_element_size =
+        array->Get(String::New("BYTES_PER_ELEMENT"))->ToInt32()->Int32Value();

[Jakob Kummerow, 2012/01/11 10:17:53]

My reading of the spec at
http://www.khronos.org/registry/typedarray/specs/latest/#7 is that |array| must
be an ArrayBuffer (and cannot be another kind of TypedArray), so
BYTES_PER_ELEMENTS is always 1, and you'll have to throw an exception if a
TypedArray is passed in.
Further, IIUC, the "length" parameter specifies the new array's length in terms
of number of elements in the new array, so all this conversion-fu is
unnecessary.

[danno, 2012/01/11 13:07:41]

Done.

+    length *= derived_from_element_size;
+    length /= element_size;
+  }
+
+  size_t offset = 0;
+  if (args.Length() > 1) {
+    offset = convertToInt(args[1], &try_catch);
+    if (try_catch.HasCaught()) return try_catch.Exception();
+
+    if (offset % element_size != 0) {
+      return ThrowException(
+          String::New("offset must be multiple of element_size"));
     }
-    int32_t raw_length = int32->Int32Value();
-    if (try_catch.HasCaught()) {
-      return try_catch.Exception();
-    }
-    if (raw_length < 0) {
-      return ThrowException(String::New("Array length must not be negative."));
-    }
-    if (raw_length > static_cast<int32_t>(kMaxLength)) {
-      return ThrowException(
-          String::New("Array length exceeds maximum length."));
-    }
-    length = static_cast<size_t>(raw_length);
   }
-  if (length > static_cast<size_t>(kMaxLength)) {
-    return ThrowException(String::New("Array length exceeds maximum length."));
-  }
-  void* data = calloc(length, element_size);
-  if (data == NULL) {
-    return ThrowException(String::New("Memory allocation failed."));
-  }
+
   Handle<Object> array = Object::New();
   Persistent<Object> persistent_array = Persistent<Object>::New(array);
   persistent_array.MakeWeak(data, ExternalArrayWeakCallback);
   persistent_array.MarkIndependent();
-  array->SetIndexedPropertiesToExternalArrayData(data, type,
-                                                 static_cast<int>(length));
+  if (data == NULL) {
+    data = calloc(length, element_size);
+    if (data == NULL) {
+      return ThrowException(String::New("Memory allocation failed."));
+    }
+  } else {
+    // Hold a reference to the ArrayBuffer so it's buffer doesn't get collected.

[Jakob Kummerow, 2012/01/11 10:17:53]

s/it's/its/

[danno, 2012/01/11 13:07:41]

Done.

+    array->Set(String::New(kArrayBufferReferencePropName), args[0], ReadOnly);
+  }
+  array->SetIndexedPropertiesToExternalArrayData(
+      reinterpret_cast<uint8_t*>(data) + offset, type,

[Jakob Kummerow, 2012/01/11 10:17:53]

Whoa... please add checks that both |offset| and |offset + length*element_size|
are within the existing |data| buffer.

[danno, 2012/01/11 13:07:41]

Done.

+      static_cast<int>(length));
   array->Set(String::New("length"),
              Int32::New(static_cast<int32_t>(length)), ReadOnly);
   array->Set(String::New("BYTES_PER_ELEMENT"),
              Int32::New(static_cast<int32_t>(element_size)));
   return array;
 }
 
 
 void Shell::ExternalArrayWeakCallback(Persistent<Value> object, void* data) {
-  free(data);
-  object.Dispose();
+  Handle<String> prop_name = String::New(kArrayBufferReferencePropName);
+  Handle<Object> converted_object = object->ToObject();
+  Local<Value> prop_value = converted_object->Get(prop_name);
+  if (!prop_value->IsObject()) {
+    free(data);
+    object.Dispose();
+  }
 }
 
 
+Handle<Value> Shell::ArrayBuffer(const Arguments& args) {
+  return CreateExternalArray(args, v8::kExternalByteArray, sizeof(int8_t));
+}
+
+
 Handle<Value> Shell::Int8Array(const Arguments& args) {
   return CreateExternalArray(args, v8::kExternalByteArray, sizeof(int8_t));
 }
 
 
 Handle<Value> Shell::Uint8Array(const Arguments& args) {
   return CreateExternalArray(args, kExternalUnsignedByteArray, sizeof(uint8_t));
 }
 
 
@@ skipping 321 matching lines @@
                        FunctionTemplate::New(ReadLine));
   global_template->Set(String::New("load"), FunctionTemplate::New(Load));
   global_template->Set(String::New("quit"), FunctionTemplate::New(Quit));
   global_template->Set(String::New("version"), FunctionTemplate::New(Version));
   global_template->Set(String::New("enableProfiler"),
                        FunctionTemplate::New(EnableProfiler));
   global_template->Set(String::New("disableProfiler"),
                        FunctionTemplate::New(DisableProfiler));
 
   // Bind the handlers for external arrays.
+  global_template->Set(String::New("ArrayBuffer"),
+                       FunctionTemplate::New(ArrayBuffer));
   global_template->Set(String::New("Int8Array"),
                        FunctionTemplate::New(Int8Array));
   global_template->Set(String::New("Uint8Array"),
                        FunctionTemplate::New(Uint8Array));
   global_template->Set(String::New("Int16Array"),
                        FunctionTemplate::New(Int16Array));
   global_template->Set(String::New("Uint16Array"),
                        FunctionTemplate::New(Uint16Array));
   global_template->Set(String::New("Int32Array"),
                        FunctionTemplate::New(Int32Array));
@@ skipping 687 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif