Fix broken change to d8 typed 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 320 matching lines @@
     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[0]->IsObject() &&
-      args[0]->ToObject()->GetHiddenValue(
-          String::New(kArrayBufferMarkerPropName))->IsTrue();
+      !args[0]->ToObject()->GetHiddenValue(
+          String::New(kArrayBufferMarkerPropName)).IsEmpty();
   // Currently, only the following constructors are supported:
   //   ArrayBuffer(unsigned long length)
   //   TypedArray(unsigned long length)
   //   TypedArray(ArrayBuffer buffer,
   //              optional unsigned long byteOffset,
   //              optional unsigned long length)
   size_t length;
   size_t byteLength;
   size_t byteOffset;
   void* data = NULL;
@@ skipping 13 matching lines @@
     if (try_catch.HasCaught()) return try_catch.Exception();
     if (data == NULL && byteLength != 0) {
       return ThrowException(String::New("ArrayBuffer does not have data"));
     }
 
     if (args.Length() < 2 || args[1]->IsUndefined()) {
       byteOffset = 0;
     } else {
       byteOffset = convertToUint(args[1], &try_catch);
       if (try_catch.HasCaught()) return try_catch.Exception();
+      if (byteOffset > byteLength) {
+        return ThrowException(
+            String::New("byteOffset out of bounds"));

[Michael Starzinger, 2012/05/30 14:25:08]

That should fit into one line.

+      }
       if (byteOffset % element_size != 0) {
         return ThrowException(
             String::New("byteOffset must be multiple of element_size"));
       }
     }
 
     if (args.Length() < 3 || args[2]->IsUndefined()) {
       if (byteLength % element_size != 0) {
         return ThrowException(
             String::New("buffer size must be multiple of element_size"));
       }
       length = (byteLength - byteOffset) / element_size;
     } else {
       length = convertToUint(args[2], &try_catch);
       if (try_catch.HasCaught()) return try_catch.Exception();
     }
 
     if (byteOffset + length * element_size > byteLength) {
-      return ThrowException(
-          String::New("byteOffset or length out of bounds"));
+      return ThrowException(String::New("length out of bounds"));
     }
     byteLength = byteOffset + length * element_size;
 
     // Hold a reference to the ArrayBuffer so its buffer doesn't get collected.
     array->SetHiddenValue(
         String::New(kArrayBufferReferencePropName), args[0]);
   } else {
     length = convertToUint(args[0], &try_catch);
     byteLength = length * element_size;
     byteOffset = 0;
@@ skipping 41 matching lines @@
   }
   return array;
 }
 
 
 void Shell::ExternalArrayWeakCallback(Persistent<Value> object, void* data) {
   HandleScope scope;
   Handle<String> prop_name = String::New(kArrayBufferReferencePropName);
   Handle<Object> converted_object = object->ToObject();
   Local<Value> prop_value = converted_object->GetHiddenValue(prop_name);
-  if (data != NULL && !prop_value->IsObject()) {
+  if (data != NULL && prop_value.IsEmpty()) {
     data = reinterpret_cast<size_t*>(data) - kExternalArrayAllocationHeaderSize;
     V8::AdjustAmountOfExternalAllocatedMemory(
         -static_cast<int>(*reinterpret_cast<size_t*>(data)));
     free(data);
   }
   object.Dispose();
 }
 
 
 Handle<Value> Shell::ArrayBuffer(const Arguments& args) {
@@ skipping 1086 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif