Added no argument constructor support to external arrays.

src/d8.cc

 // 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
@@ skipping 312 matching lines @@
                                          ExternalArrayType type,
                                          size_t element_size) {
   TryCatch try_catch;
   bool is_array_buffer_construct = element_size == 0;
   if (is_array_buffer_construct) {
     type = v8::kExternalByteArray;
     element_size = 1;
   }
   ASSERT(element_size == 1 || element_size == 2 || element_size == 4 ||
          element_size == 8);
-  if (args.Length() == 0) {
-    return ThrowException(
-        String::New("Array constructor must have at least one "
-                    "parameter."));
-  }
+
   bool first_arg_is_array_buffer =
+      args.Length() > 0 &&
       args[0]->IsObject() &&
       args[0]->ToObject()->Get(
           String::New(kArrayBufferMarkerPropName))->IsTrue();
   // Currently, only the following constructors are supported:
+  //   TypedArray()
   //   TypedArray(unsigned long length)
   //   TypedArray(ArrayBuffer buffer,
   //              optional unsigned long byteOffset,
   //              optional unsigned long length)
   if (args.Length() > 3) {
     return ThrowException(
         String::New("Array constructor from ArrayBuffer must "
-                    "have 1-3 parameters."));
+                    "have 0-3 parameters."));
   }
 
-  Local<Value> length_value = (args.Length() < 3)
-      ? (first_arg_is_array_buffer
-         ? args[0]->ToObject()->Get(String::New("length"))
-         : args[0])
-      : args[2];
-  size_t length = convertToUint(length_value, &try_catch);
-  if (try_catch.HasCaught()) return try_catch.Exception();
+  size_t length;
+  if (args.Length() > 0) {
+    Local<Value> length_value = (args.Length() < 3)
+        ? (first_arg_is_array_buffer
+           ? args[0]->ToObject()->Get(String::New("length"))
+           : args[0])
+        : args[2];
+    length = convertToUint(length_value, &try_catch);
+    if (try_catch.HasCaught()) return try_catch.Exception();
+  } else {
+    length = 0;
+  }
 
   void* data = NULL;
   size_t offset = 0;
 
   Handle<Object> array = Object::New();
   if (first_arg_is_array_buffer) {
     Handle<Object> derived_from = args[0]->ToObject();
     data = derived_from->GetIndexedPropertiesExternalArrayData();
 
     size_t array_buffer_length = convertToUint(
@@ skipping 51 matching lines @@
     array->Set(String::New(kArrayBufferReferencePropName), args[0], ReadOnly);
   }
 
   if (is_array_buffer_construct) {
     array->Set(String::New(kArrayBufferMarkerPropName), True(), ReadOnly);
   }
 
   Persistent<Object> persistent_array = Persistent<Object>::New(array);
   persistent_array.MakeWeak(data, ExternalArrayWeakCallback);
   persistent_array.MarkIndependent();
-  if (data == NULL && length != 0) {
+  if (data == NULL) {
     data = calloc(length, element_size);
     if (data == NULL) {
       return ThrowException(String::New("Memory allocation failed."));
     }
   }
 
   array->SetIndexedPropertiesToExternalArrayData(
       reinterpret_cast<uint8_t*>(data) + offset, type,
       static_cast<int>(length));
   array->Set(String::New("length"),
@@ skipping 1089 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif