JS binding code generator doesn't handle "attribute unsigned long[]" well
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 23 Apr 2012 11:34:27 +0000 (11:34 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 23 Apr 2012 11:34:27 +0000 (11:34 +0000)
https://bugs.webkit.org/show_bug.cgi?id=84540

Patch by Vineet Chaudhary <rgf748@motorola.com> on 2012-04-23
Reviewed by Kentaro Hara.

Codegenerator should handle spaces with the sequence<> to support
numeric types like "unsigned long", "int" .. etc. and primitive types
like "boolean", "Date" etc.

Tests: bindings/scripts/test/TestObj.idl

* bindings/scripts/CodeGenerator.pm:
(SkipIncludeHeader): Rename AvoidInclusionOfType to SkipIncludeHeader.
(GetArrayType):
* bindings/scripts/CodeGeneratorJS.pm:
(AddIncludesForType):
(NativeToJSValue):
* bindings/scripts/CodeGeneratorObjC.pm:
(AddIncludesForType):
(GenerateImplementation):
* bindings/scripts/CodeGeneratorV8.pm:
(AddIncludesForType):
(GetHeaderClassInclude):
(GenerateNormalAttrGetter):
(NativeToJSValue):
* bindings/scripts/IDLStructure.pm:
* bindings/scripts/test/JS/JSTestObj.cpp:
(WebCore):
(WebCore::jsTestObjIntSequenceAttr):
(WebCore::jsTestObjShortSequenceAttr):
(WebCore::jsTestObjLongSequenceAttr):
(WebCore::jsTestObjLongLongSequenceAttr):
(WebCore::jsTestObjUnsignedIntSequenceAttr):
(WebCore::jsTestObjUnsignedShortSequenceAttr):
(WebCore::jsTestObjUnsignedLongSequenceAttr):
(WebCore::jsTestObjUnsignedLongLongSequenceAttr):
(WebCore::jsTestObjFloatSequenceAttr):
(WebCore::jsTestObjDoubleSequenceAttr):
(WebCore::jsTestObjBooleanSequenceAttr):
(WebCore::jsTestObjVoidSequenceAttr):
(WebCore::jsTestObjDateSequenceAttr):
(WebCore::setJSTestObjSequenceAttr):
(WebCore::setJSTestObjIntSequenceAttr):
(WebCore::setJSTestObjShortSequenceAttr):
(WebCore::setJSTestObjLongSequenceAttr):
(WebCore::setJSTestObjLongLongSequenceAttr):
(WebCore::setJSTestObjUnsignedIntSequenceAttr):
(WebCore::setJSTestObjUnsignedShortSequenceAttr):
(WebCore::setJSTestObjUnsignedLongSequenceAttr):
(WebCore::setJSTestObjUnsignedLongLongSequenceAttr):
(WebCore::setJSTestObjFloatSequenceAttr):
(WebCore::setJSTestObjDoubleSequenceAttr):
(WebCore::setJSTestObjBooleanSequenceAttr):
(WebCore::setJSTestObjVoidSequenceAttr):
(WebCore::setJSTestObjDateSequenceAttr):
* bindings/scripts/test/JS/JSTestObj.h:
(WebCore):
* bindings/scripts/test/ObjC/DOMTestObj.h:
* bindings/scripts/test/TestObj.idl:
* bindings/scripts/test/V8/V8TestObj.cpp:
(WebCore::TestObjV8Internal::intSequenceAttrAttrGetter):
(TestObjV8Internal):
(WebCore::TestObjV8Internal::intSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::shortSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::shortSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::longSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::longSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::longLongSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::longLongSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::unsignedIntSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::unsignedIntSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::unsignedShortSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::unsignedShortSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::unsignedLongSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::unsignedLongSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::unsignedLongLongSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::unsignedLongLongSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::floatSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::floatSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::doubleSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::doubleSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::booleanSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::booleanSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::voidSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::voidSequenceAttrAttrSetter):
(WebCore::TestObjV8Internal::dateSequenceAttrAttrGetter):
(WebCore::TestObjV8Internal::dateSequenceAttrAttrSetter):
(WebCore):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@114887 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebCore/ChangeLog
Source/WebCore/bindings/scripts/CodeGenerator.pm
Source/WebCore/bindings/scripts/CodeGeneratorJS.pm
Source/WebCore/bindings/scripts/CodeGeneratorObjC.pm
Source/WebCore/bindings/scripts/CodeGeneratorV8.pm
Source/WebCore/bindings/scripts/IDLStructure.pm
Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestObj.h
Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.h
Source/WebCore/bindings/scripts/test/TestObj.idl
Source/WebCore/bindings/scripts/test/V8/V8TestObj.cpp

index 084090b..1a360cb 100644 (file)
@@ -1,3 +1,94 @@
+2012-04-23  Vineet Chaudhary  <rgf748@motorola.com>
+
+        JS binding code generator doesn't handle "attribute unsigned long[]" well
+        https://bugs.webkit.org/show_bug.cgi?id=84540
+
+        Reviewed by Kentaro Hara.
+
+        Codegenerator should handle spaces with the sequence<> to support
+        numeric types like "unsigned long", "int" .. etc. and primitive types
+        like "boolean", "Date" etc.
+
+        Tests: bindings/scripts/test/TestObj.idl
+
+        * bindings/scripts/CodeGenerator.pm:
+        (SkipIncludeHeader): Rename AvoidInclusionOfType to SkipIncludeHeader.
+        (GetArrayType):
+        * bindings/scripts/CodeGeneratorJS.pm:
+        (AddIncludesForType):
+        (NativeToJSValue):
+        * bindings/scripts/CodeGeneratorObjC.pm:
+        (AddIncludesForType):
+        (GenerateImplementation):
+        * bindings/scripts/CodeGeneratorV8.pm:
+        (AddIncludesForType):
+        (GetHeaderClassInclude):
+        (GenerateNormalAttrGetter):
+        (NativeToJSValue):
+        * bindings/scripts/IDLStructure.pm:
+        * bindings/scripts/test/JS/JSTestObj.cpp:
+        (WebCore):
+        (WebCore::jsTestObjIntSequenceAttr):
+        (WebCore::jsTestObjShortSequenceAttr):
+        (WebCore::jsTestObjLongSequenceAttr):
+        (WebCore::jsTestObjLongLongSequenceAttr):
+        (WebCore::jsTestObjUnsignedIntSequenceAttr):
+        (WebCore::jsTestObjUnsignedShortSequenceAttr):
+        (WebCore::jsTestObjUnsignedLongSequenceAttr):
+        (WebCore::jsTestObjUnsignedLongLongSequenceAttr):
+        (WebCore::jsTestObjFloatSequenceAttr):
+        (WebCore::jsTestObjDoubleSequenceAttr):
+        (WebCore::jsTestObjBooleanSequenceAttr):
+        (WebCore::jsTestObjVoidSequenceAttr):
+        (WebCore::jsTestObjDateSequenceAttr):
+        (WebCore::setJSTestObjSequenceAttr):
+        (WebCore::setJSTestObjIntSequenceAttr):
+        (WebCore::setJSTestObjShortSequenceAttr):
+        (WebCore::setJSTestObjLongSequenceAttr):
+        (WebCore::setJSTestObjLongLongSequenceAttr):
+        (WebCore::setJSTestObjUnsignedIntSequenceAttr):
+        (WebCore::setJSTestObjUnsignedShortSequenceAttr):
+        (WebCore::setJSTestObjUnsignedLongSequenceAttr):
+        (WebCore::setJSTestObjUnsignedLongLongSequenceAttr):
+        (WebCore::setJSTestObjFloatSequenceAttr):
+        (WebCore::setJSTestObjDoubleSequenceAttr):
+        (WebCore::setJSTestObjBooleanSequenceAttr):
+        (WebCore::setJSTestObjVoidSequenceAttr):
+        (WebCore::setJSTestObjDateSequenceAttr):
+        * bindings/scripts/test/JS/JSTestObj.h:
+        (WebCore):
+        * bindings/scripts/test/ObjC/DOMTestObj.h:
+        * bindings/scripts/test/TestObj.idl:
+        * bindings/scripts/test/V8/V8TestObj.cpp:
+        (WebCore::TestObjV8Internal::intSequenceAttrAttrGetter):
+        (TestObjV8Internal):
+        (WebCore::TestObjV8Internal::intSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::shortSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::shortSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::longSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::longSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::longLongSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::longLongSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::unsignedIntSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::unsignedIntSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::unsignedShortSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::unsignedShortSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::unsignedLongSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::unsignedLongSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::unsignedLongLongSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::unsignedLongLongSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::floatSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::floatSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::doubleSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::doubleSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::booleanSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::booleanSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::voidSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::voidSequenceAttrAttrSetter):
+        (WebCore::TestObjV8Internal::dateSequenceAttrAttrGetter):
+        (WebCore::TestObjV8Internal::dateSequenceAttrAttrSetter):
+        (WebCore):
+
 2012-04-23  Andreas Kling  <kling@webkit.org>
 
         Unreviewed assertion fix for Chromium bots.
index af57151..4698f74 100644 (file)
@@ -340,11 +340,15 @@ sub ParseInterface
 
 # Helpers for all CodeGenerator***.pm modules
 
-sub AvoidInclusionOfType
+sub SkipIncludeHeader
 {
     my $object = shift;
     my $type = shift;
 
+    return 1 if $primitiveTypeHash{$type};
+    return 1 if $numericTypeHash{$type};
+    return 1 if $type eq "String";
+
     # Special case: SVGPoint.h / SVGNumber.h do not exist.
     return 1 if $type eq "SVGPoint" or $type eq "SVGNumber";
     return 0;
@@ -450,7 +454,7 @@ sub GetArrayType
     my $object = shift;
     my $type = shift;
 
-    return $1 if $type =~ /^sequence<([\w\d_]+)>.*/;
+    return $1 if $type =~ /^sequence<([\w\d_\s]+)>.*/;
     return "";
 }
 
index 23275be..7e3cf6e 100644 (file)
@@ -248,7 +248,7 @@ sub AddIncludesForType
 
     # When we're finished with the one-file-per-class
     # reorganization, we won't need these special cases.
-    if ($codeGenerator->IsPrimitiveType($type) or $codeGenerator->AvoidInclusionOfType($type)
+    if ($codeGenerator->IsPrimitiveType($type) or $codeGenerator->SkipIncludeHeader($type)
         or $type eq "DOMString" or $type eq "DOMObject" or $type eq "Array" or $type eq "DOMTimeStamp") {
     } elsif ($type =~ /SVGPathSeg/) {
         my $joinedName = $type;
@@ -3025,7 +3025,7 @@ sub NativeToJSValue
 
     my $arrayType = $codeGenerator->GetArrayType($type);
     if ($arrayType) {
-        if ($arrayType ne "String") {
+        if (!$codeGenerator->SkipIncludeHeader($arrayType)) {
             AddToImplIncludes("JS$arrayType.h", $conditional);
             AddToImplIncludes("$arrayType.h", $conditional);
         }
@@ -3053,9 +3053,9 @@ sub NativeToJSValue
         # Default, include header with same name.
         AddToImplIncludes("JS$type.h", $conditional);
         if (IsTypedArrayType($type)) {
-            AddToImplIncludes("<wtf/$type.h>", $conditional) if not $codeGenerator->AvoidInclusionOfType($type);
+            AddToImplIncludes("<wtf/$type.h>", $conditional) if not $codeGenerator->SkipIncludeHeader($type);
         } else {
-            AddToImplIncludes("$type.h", $conditional) if not $codeGenerator->AvoidInclusionOfType($type);
+            AddToImplIncludes("$type.h", $conditional) if not $codeGenerator->SkipIncludeHeader($type);
         }
     }
 
index ffd07dc..0a96489 100644 (file)
@@ -634,7 +634,7 @@ sub AddIncludesForType
     $implIncludes{"NameNodeList.h"} = 1 if $type eq "NodeList";
 
     # Default, include the same named file (the implementation) and the same name prefixed with "DOM". 
-    $implIncludes{"$type.h"} = 1 if not $codeGenerator->AvoidInclusionOfType($type);
+    $implIncludes{"$type.h"} = 1 if not $codeGenerator->SkipIncludeHeader($type);
     $implIncludes{"DOM${type}Internal.h"} = 1;
 }
 
@@ -1133,7 +1133,7 @@ sub GenerateImplementation
     if ($interfaceName =~ /(\w+)(Abs|Rel)$/) {
         $implIncludes{"$1.h"} = 1;
     } else {
-        if (!$codeGenerator->AvoidInclusionOfType($implClassName)) {
+        if (!$codeGenerator->SkipIncludeHeader($implClassName)) {
             $implIncludes{"$implClassName.h"} = 1 ;
         } elsif ($codeGenerator->IsSVGTypeNeedingTearOff($implClassName)) {
             my $includeType = $codeGenerator->GetSVGWrappedTypeNeedingTearOff($implClassName);
@@ -1345,7 +1345,7 @@ sub GenerateImplementation
                 my $type = $attribute->signature->type;
                 if ($codeGenerator->IsSVGTypeNeedingTearOff($type) and not $implClassName =~ /List$/) {
                     my $idlTypeWithNamespace = GetSVGTypeWithNamespace($type);
-                    $implIncludes{"$type.h"} = 1 if not $codeGenerator->AvoidInclusionOfType($type);
+                    $implIncludes{"$type.h"} = 1 if not $codeGenerator->SkipIncludeHeader($type);
                     if ($codeGenerator->IsSVGTypeWithWritablePropertiesNeedingTearOff($type) and not defined $attribute->signature->extendedAttributes->{"Immutable"}) {
                         $idlTypeWithNamespace =~ s/SVGPropertyTearOff</SVGStaticPropertyTearOff<$implClassNameWithNamespace, /;
                         $implIncludes{"SVGStaticPropertyTearOff.h"} = 1;
index 5e7b25e..4e768d0 100644 (file)
@@ -144,7 +144,7 @@ sub AddIncludesForType
     if (IsTypedArrayType($type)) {
         AddToImplIncludes("wtf/${type}.h");
     }
-    if (!$codeGenerator->IsPrimitiveType($type) and !$codeGenerator->IsStringType($type) and !$codeGenerator->AvoidInclusionOfType($type) and $type ne "Date") {
+    if (!$codeGenerator->IsPrimitiveType($type) and !$codeGenerator->IsStringType($type) and !$codeGenerator->SkipIncludeHeader($type) and $type ne "Date") {
         # default, include the same named file
         AddToImplIncludes(GetV8HeaderName(${type}));
 
@@ -521,7 +521,7 @@ sub GetHeaderClassInclude
         $className =~ s/Abs|Rel//;
     }
     return "wtf/${className}.h" if IsTypedArrayType($className);
-    return "" if ($codeGenerator->AvoidInclusionOfType($className));
+    return "" if ($codeGenerator->SkipIncludeHeader($className));
     return "${className}.h";
 }
 
@@ -915,10 +915,11 @@ END
 
         my $arrayType = $codeGenerator->GetArrayType($returnType);
         if ($arrayType) {
-            AddToImplIncludes("V8$arrayType.h");
-            AddToImplIncludes("$arrayType.h");
-            push(@implContentDecls, "    const Vector<RefPtr<$arrayType> > vector = ${getterString};\n");
-            push(@implContentDecls, "    return v8Array(vector);\n");
+            if (!$codeGenerator->SkipIncludeHeader($arrayType)) {
+                AddToImplIncludes("V8$arrayType.h");
+                AddToImplIncludes("$arrayType.h");
+            }
+            push(@implContentDecls, "    return v8Array(${getterString});\n");
             push(@implContentDecls, "}\n\n");
             return;
         }
@@ -3801,7 +3802,7 @@ sub NativeToJSValue
 
     my $arrayType = $codeGenerator->GetArrayType($type);
     if ($arrayType) {
-        if ($arrayType ne "String") {
+        if (!$codeGenerator->SkipIncludeHeader($arrayType)) {
             AddToImplIncludes("V8$arrayType.h");
             AddToImplIncludes("$arrayType.h");
         }
index 90e0e2d..7c9039f 100644 (file)
@@ -88,7 +88,7 @@ our $constValue = '("[^"\r\n]*")|(0[xX][a-fA-F0-9]+)|(-?[0-9]*)';
 our $idlDataType = '[a-zA-Z0-9\ ]';   # Generic data type identifier
 
 # Magic IDL parsing regular expressions
-my $supportedTypes = "((?:(?:unsigned )?(?:int|short|(?:long )?long)|(?:$idlIdNs*))(?:\\[\\]|<(?:$idlIdNs*)>)?)";
+my $supportedTypes = "((?:(?:unsigned )?(?:int|short|(?:long )?long)|(?:$idlIdNs*))(?:\\[\\]|<(?:$idlIdNsList*)>)?)";
 
 # Special IDL notations. This regular expression extracts the string between the first [ and its corresponding ].
 our $extendedAttributeSyntax = qr/\[[^\[\]]*(?:(??{$IDLStructure::extendedAttributeSyntax})[^\[\]]*)*\]/x; # Used for extended attributes
index 49e5fc0..0e13c79 100644 (file)
@@ -90,6 +90,19 @@ static const HashTableValue JSTestObjTableValues[] =
     { "stringAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttr), (intptr_t)setJSTestObjStringAttr, NoIntrinsic },
     { "testObjAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestObjAttr), (intptr_t)setJSTestObjTestObjAttr, NoIntrinsic },
     { "sequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjSequenceAttr), (intptr_t)setJSTestObjSequenceAttr, NoIntrinsic },
+    { "intSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjIntSequenceAttr), (intptr_t)setJSTestObjIntSequenceAttr, NoIntrinsic },
+    { "shortSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjShortSequenceAttr), (intptr_t)setJSTestObjShortSequenceAttr, NoIntrinsic },
+    { "longSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongSequenceAttr), (intptr_t)setJSTestObjLongSequenceAttr, NoIntrinsic },
+    { "longLongSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongLongSequenceAttr), (intptr_t)setJSTestObjLongLongSequenceAttr, NoIntrinsic },
+    { "unsignedIntSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedIntSequenceAttr), (intptr_t)setJSTestObjUnsignedIntSequenceAttr, NoIntrinsic },
+    { "unsignedShortSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedShortSequenceAttr), (intptr_t)setJSTestObjUnsignedShortSequenceAttr, NoIntrinsic },
+    { "unsignedLongSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedLongSequenceAttr), (intptr_t)setJSTestObjUnsignedLongSequenceAttr, NoIntrinsic },
+    { "unsignedLongLongSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedLongLongSequenceAttr), (intptr_t)setJSTestObjUnsignedLongLongSequenceAttr, NoIntrinsic },
+    { "floatSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjFloatSequenceAttr), (intptr_t)setJSTestObjFloatSequenceAttr, NoIntrinsic },
+    { "doubleSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjDoubleSequenceAttr), (intptr_t)setJSTestObjDoubleSequenceAttr, NoIntrinsic },
+    { "booleanSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjBooleanSequenceAttr), (intptr_t)setJSTestObjBooleanSequenceAttr, NoIntrinsic },
+    { "voidSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjVoidSequenceAttr), (intptr_t)setJSTestObjVoidSequenceAttr, NoIntrinsic },
+    { "dateSequenceAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjDateSequenceAttr), (intptr_t)setJSTestObjDateSequenceAttr, NoIntrinsic },
     { "XMLObjAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjXMLObjAttr), (intptr_t)setJSTestObjXMLObjAttr, NoIntrinsic },
     { "create", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCreate), (intptr_t)setJSTestObjCreate, NoIntrinsic },
     { "reflectedStringAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedStringAttr), (intptr_t)setJSTestObjReflectedStringAttr, NoIntrinsic },
@@ -146,7 +159,7 @@ static const HashTableValue JSTestObjTableValues[] =
     { 0, 0, 0, 0, NoIntrinsic }
 };
 
-static const HashTable JSTestObjTable = { 138, 127, JSTestObjTableValues, 0 };
+static const HashTable JSTestObjTable = { 265, 255, JSTestObjTableValues, 0 };
 /* Hash table for constructor */
 
 static const HashTableValue JSTestObjConstructorTableValues[] =
@@ -490,6 +503,136 @@ JSValue jsTestObjSequenceAttr(ExecState* exec, JSValue slotBase, const Identifie
 }
 
 
+JSValue jsTestObjIntSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->intSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjShortSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->shortSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjLongSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->longSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjLongLongSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->longLongSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjUnsignedIntSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->unsignedIntSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjUnsignedShortSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->unsignedShortSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjUnsignedLongSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->unsignedLongSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjUnsignedLongLongSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->unsignedLongLongSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjFloatSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->floatSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjDoubleSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->doubleSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjBooleanSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->booleanSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjVoidSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->voidSequenceAttr());
+    return result;
+}
+
+
+JSValue jsTestObjDateSequenceAttr(ExecState* exec, JSValue slotBase, const Identifier&)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
+    UNUSED_PARAM(exec);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    JSValue result = jsArray(exec, castedThis->globalObject(), impl->dateSequenceAttr());
+    return result;
+}
+
+
 JSValue jsTestObjXMLObjAttr(ExecState* exec, JSValue slotBase, const Identifier&)
 {
     JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
@@ -987,6 +1130,110 @@ void setJSTestObjSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue val
 }
 
 
+void setJSTestObjIntSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setIntSequenceAttr(toNativeArray<int>(exec, value));
+}
+
+
+void setJSTestObjShortSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setShortSequenceAttr(toNativeArray<short>(exec, value));
+}
+
+
+void setJSTestObjLongSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setLongSequenceAttr(toNativeArray<long>(exec, value));
+}
+
+
+void setJSTestObjLongLongSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setLongLongSequenceAttr(toNativeArray<long long>(exec, value));
+}
+
+
+void setJSTestObjUnsignedIntSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setUnsignedIntSequenceAttr(toNativeArray<unsigned int>(exec, value));
+}
+
+
+void setJSTestObjUnsignedShortSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setUnsignedShortSequenceAttr(toNativeArray<unsigned short>(exec, value));
+}
+
+
+void setJSTestObjUnsignedLongSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setUnsignedLongSequenceAttr(toNativeArray<unsigned long>(exec, value));
+}
+
+
+void setJSTestObjUnsignedLongLongSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setUnsignedLongLongSequenceAttr(toNativeArray<unsigned long long>(exec, value));
+}
+
+
+void setJSTestObjFloatSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setFloatSequenceAttr(toNativeArray<float>(exec, value));
+}
+
+
+void setJSTestObjDoubleSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setDoubleSequenceAttr(toNativeArray<double>(exec, value));
+}
+
+
+void setJSTestObjBooleanSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setBooleanSequenceAttr(toNativeArray<boolean>(exec, value));
+}
+
+
+void setJSTestObjVoidSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setVoidSequenceAttr(toNativeArray<void>(exec, value));
+}
+
+
+void setJSTestObjDateSequenceAttr(ExecState* exec, JSObject* thisObject, JSValue value)
+{
+    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
+    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
+    impl->setDateSequenceAttr(toNativeArray<Date>(exec, value));
+}
+
+
 void setJSTestObjXMLObjAttr(ExecState* exec, JSObject* thisObject, JSValue value)
 {
     JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
index 12fa698..b8dca2e 100644 (file)
@@ -235,6 +235,32 @@ JSC::JSValue jsTestObjTestObjAttr(JSC::ExecState*, JSC::JSValue, const JSC::Iden
 void setJSTestObjTestObjAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
 JSC::JSValue jsTestObjSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
 void setJSTestObjSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjIntSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjIntSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjShortSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjShortSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjLongSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjLongSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjLongLongSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjLongLongSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjUnsignedIntSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjUnsignedIntSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjUnsignedShortSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjUnsignedShortSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjUnsignedLongSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjUnsignedLongSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjUnsignedLongLongSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjUnsignedLongLongSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjFloatSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjFloatSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjDoubleSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjDoubleSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjBooleanSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjBooleanSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjVoidSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjVoidSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
+JSC::JSValue jsTestObjDateSequenceAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
+void setJSTestObjDateSequenceAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
 JSC::JSValue jsTestObjXMLObjAttr(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
 void setJSTestObjXMLObjAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
 JSC::JSValue jsTestObjCreate(JSC::ExecState*, JSC::JSValue, const JSC::Identifier&);
index e32d3f4..831a50f 100644 (file)
@@ -82,8 +82,6 @@ enum {
 - (void)setStringAttr:(NSString *)newStringAttr;
 - (DOMTestObj *)testObjAttr;
 - (void)setTestObjAttr:(DOMTestObj *)newTestObjAttr;
-- (DOMsequence<ScriptProfile> *)sequenceAttr;
-- (void)setSequenceAttr:(DOMsequence<ScriptProfile> *)newSequenceAttr;
 - (DOMTestObj *)XMLObjAttr;
 - (void)setXMLObjAttr:(DOMTestObj *)newXMLObjAttr;
 - (BOOL)create;
index ed849ad..488c99a 100644 (file)
@@ -45,7 +45,22 @@ module test {
         attribute unsigned long long       unsignedLongLongAttr;
         attribute DOMString                stringAttr;
         attribute TestObj                  testObjAttr;
+
+        // Sequence Attributes
         attribute sequence<ScriptProfile>  sequenceAttr;
+        attribute sequence<int> intSequenceAttr;
+        attribute sequence<short> shortSequenceAttr;
+        attribute sequence<long> longSequenceAttr;
+        attribute sequence<long long> longLongSequenceAttr;
+        attribute sequence<unsigned int> unsignedIntSequenceAttr;
+        attribute sequence<unsigned short> unsignedShortSequenceAttr;
+        attribute sequence<unsigned long> unsignedLongSequenceAttr;
+        attribute sequence<unsigned long long> unsignedLongLongSequenceAttr;
+        attribute sequence<float> floatSequenceAttr;
+        attribute sequence<double> doubleSequenceAttr;
+        attribute sequence<boolean> booleanSequenceAttr;
+        attribute sequence<void> voidSequenceAttr;
+        attribute sequence<Date> dateSequenceAttr;
 
         JS, V8
         // WK_ucfirst, WK_lcfirst exceptional cases.
index 610f2c7..dfa4d3a 100644 (file)
@@ -235,6 +235,214 @@ static void sequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Val
     return;
 }
 
+static v8::Handle<v8::Value> intSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.intSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->intSequenceAttr());
+}
+
+static void intSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.intSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<int> v = toNativeArray<int>(value);
+    imp->setIntSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> shortSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.shortSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->shortSequenceAttr());
+}
+
+static void shortSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.shortSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<short> v = toNativeArray<short>(value);
+    imp->setShortSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> longSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.longSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->longSequenceAttr());
+}
+
+static void longSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.longSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<long> v = toNativeArray<long>(value);
+    imp->setLongSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> longLongSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.longLongSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->longLongSequenceAttr());
+}
+
+static void longLongSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.longLongSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<long long> v = toNativeArray<long long>(value);
+    imp->setLongLongSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> unsignedIntSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.unsignedIntSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->unsignedIntSequenceAttr());
+}
+
+static void unsignedIntSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.unsignedIntSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<unsigned int> v = toNativeArray<unsigned int>(value);
+    imp->setUnsignedIntSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> unsignedShortSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.unsignedShortSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->unsignedShortSequenceAttr());
+}
+
+static void unsignedShortSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.unsignedShortSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<unsigned short> v = toNativeArray<unsigned short>(value);
+    imp->setUnsignedShortSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> unsignedLongSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.unsignedLongSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->unsignedLongSequenceAttr());
+}
+
+static void unsignedLongSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.unsignedLongSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<unsigned long> v = toNativeArray<unsigned long>(value);
+    imp->setUnsignedLongSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> unsignedLongLongSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.unsignedLongLongSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->unsignedLongLongSequenceAttr());
+}
+
+static void unsignedLongLongSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.unsignedLongLongSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<unsigned long long> v = toNativeArray<unsigned long long>(value);
+    imp->setUnsignedLongLongSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> floatSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.floatSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->floatSequenceAttr());
+}
+
+static void floatSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.floatSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<float> v = toNativeArray<float>(value);
+    imp->setFloatSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> doubleSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.doubleSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->doubleSequenceAttr());
+}
+
+static void doubleSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.doubleSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<double> v = toNativeArray<double>(value);
+    imp->setDoubleSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> booleanSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.booleanSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->booleanSequenceAttr());
+}
+
+static void booleanSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.booleanSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<boolean> v = toNativeArray<boolean>(value);
+    imp->setBooleanSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> voidSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.voidSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->voidSequenceAttr());
+}
+
+static void voidSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.voidSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<void> v = toNativeArray<void>(value);
+    imp->setVoidSequenceAttr(v);
+    return;
+}
+
+static v8::Handle<v8::Value> dateSequenceAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.dateSequenceAttr._get");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    return v8Array(imp->dateSequenceAttr());
+}
+
+static void dateSequenceAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    INC_STATS("DOM.TestObj.dateSequenceAttr._set");
+    TestObj* imp = V8TestObj::toNative(info.Holder());
+    Vector<Date> v = toNativeArray<Date>(value);
+    imp->setDateSequenceAttr(v);
+    return;
+}
+
 static v8::Handle<v8::Value> XMLObjAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
     INC_STATS("DOM.TestObj.XMLObjAttr._get");
@@ -1814,6 +2022,32 @@ static const BatchedAttribute TestObjAttrs[] = {
     {"testObjAttr", TestObjV8Internal::testObjAttrAttrGetter, TestObjV8Internal::testObjAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
     // Attribute 'sequenceAttr' (Type: 'attribute' ExtAttr: '')
     {"sequenceAttr", TestObjV8Internal::sequenceAttrAttrGetter, TestObjV8Internal::sequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'intSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"intSequenceAttr", TestObjV8Internal::intSequenceAttrAttrGetter, TestObjV8Internal::intSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'shortSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"shortSequenceAttr", TestObjV8Internal::shortSequenceAttrAttrGetter, TestObjV8Internal::shortSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'longSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"longSequenceAttr", TestObjV8Internal::longSequenceAttrAttrGetter, TestObjV8Internal::longSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'longLongSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"longLongSequenceAttr", TestObjV8Internal::longLongSequenceAttrAttrGetter, TestObjV8Internal::longLongSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'unsignedIntSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"unsignedIntSequenceAttr", TestObjV8Internal::unsignedIntSequenceAttrAttrGetter, TestObjV8Internal::unsignedIntSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'unsignedShortSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"unsignedShortSequenceAttr", TestObjV8Internal::unsignedShortSequenceAttrAttrGetter, TestObjV8Internal::unsignedShortSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'unsignedLongSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"unsignedLongSequenceAttr", TestObjV8Internal::unsignedLongSequenceAttrAttrGetter, TestObjV8Internal::unsignedLongSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'unsignedLongLongSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"unsignedLongLongSequenceAttr", TestObjV8Internal::unsignedLongLongSequenceAttrAttrGetter, TestObjV8Internal::unsignedLongLongSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'floatSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"floatSequenceAttr", TestObjV8Internal::floatSequenceAttrAttrGetter, TestObjV8Internal::floatSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'doubleSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"doubleSequenceAttr", TestObjV8Internal::doubleSequenceAttrAttrGetter, TestObjV8Internal::doubleSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'booleanSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"booleanSequenceAttr", TestObjV8Internal::booleanSequenceAttrAttrGetter, TestObjV8Internal::booleanSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'voidSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"voidSequenceAttr", TestObjV8Internal::voidSequenceAttrAttrGetter, TestObjV8Internal::voidSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
+    // Attribute 'dateSequenceAttr' (Type: 'attribute' ExtAttr: '')
+    {"dateSequenceAttr", TestObjV8Internal::dateSequenceAttrAttrGetter, TestObjV8Internal::dateSequenceAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
     // Attribute 'XMLObjAttr' (Type: 'attribute' ExtAttr: '')
     {"XMLObjAttr", TestObjV8Internal::XMLObjAttrAttrGetter, TestObjV8Internal::XMLObjAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
     // Attribute 'create' (Type: 'attribute' ExtAttr: '')