WIP IDL compiler rewrite

Source/bindings/scripts/CodeGeneratorV8.pm

 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
 # Copyright (C) 2006 Apple Computer, Inc.
 # Copyright (C) 2007, 2008, 2009, 2012 Google Inc.
 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
 # Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
 # Copyright (C) 2012 Ericsson AB. All rights reserved.
@@ skipping 260 matching lines @@
     bless($reference, $object);
     return $reference;
 }
 
 
 sub IDLFileForInterface
 {
     my $interfaceName = shift;
 
     unless ($idlFiles) {
+#    use Data::Dumper;
+#    print "[direc]", Dumper($idlDirectories), "\n";
         my @directories = map { $_ = "$sourceRoot/$_" if -d "$sourceRoot/$_"; $_ } @$idlDirectories;
         push(@directories, ".");
+#        print "[directories]", Dumper(@directories), "\n";
 
         $idlFiles = { };
         foreach my $idlFile (@$dependentIdlFiles) {
             $idlFiles->{fileparse(basename($idlFile), ".idl")} = $idlFile;
         }
+#        use Data::Dumper;
+#        print "[idlFiles]", Dumper($idlFiles), "\n";
 
         my $wanted = sub {
+#            print "<find> ", $File::Find::name, "\n";
             $idlFiles->{$1} = $File::Find::name if /^([A-Z].*)\.idl$/;
             $File::Find::prune = 1 if /^\../;
         };
         find($wanted, @directories);
+#        print "[idlFiles]", scalar(keys($idlFiles)), "\n";
     }
 
     return $idlFiles->{$interfaceName};
 }
 
 sub ParseInterface
 {
     my $interfaceName = shift;
 
     if (exists $cachedInterfaces->{$interfaceName}) {
@@ skipping 18 matching lines @@
     }
 
     die("Could NOT find interface definition for $interfaceName in $filename");
 }
 
 sub GenerateInterface
 {
     my $object = shift;
     my $interface = shift;
 
+    print "[Parents of] ", $interface->name, "\n";
+#    ForAllParents($interface, sub {
+#        my $parent = shift;
+#        print "    - ", $parent->name, "\n"
+#    });
     %callbackFunctionTypeHash = map { $_->name => $_ } @{$idlDocument->callbackFunctions};
     %enumTypeHash = map { $_->name => $_->values } @{$idlDocument->enumerations};
     my $v8ClassName = GetV8ClassName($interface);
     my $defineName = $v8ClassName . "_h";
     my $internalNamespace = GetImplName($interface) . "V8Internal";
 
     my $conditionalString = GenerateConditionalString($interface);
     my $conditionalIf = "";
     my $conditionalEndif = "";
     if ($conditionalString) {
@@ skipping 107 matching lines @@
     if ($type eq "CSSStyleSheet") {
         AddToImplIncludes("core/css/CSSImportRule.h");
     }
 }
 
 sub HeaderFilesForInterface
 {
     my $interfaceName = shift;
     my $implClassName = shift;
 
+    use Data::Dumper;
     my @includes = ();
     if (IsTypedArrayType($interfaceName)) {
         push(@includes, "wtf/${interfaceName}.h");
     } elsif ($interfaceName =~ /SVGPathSeg/) {
         $interfaceName =~ s/Abs|Rel//;
         push(@includes, "core/svg/${interfaceName}.h");
     } elsif (!SkipIncludeHeader($interfaceName)) {
         my $idlFilename = IDLFileForInterface($interfaceName) or die("Could NOT find IDL file for interface \"$interfaceName\" $!\n");
         my $idlRelPath= "bindings/" . File::Spec->abs2rel($idlFilename, $sourceRoot);
         push(@includes, dirname($idlRelPath) . "/" . $implClassName . ".h");
     }
+#    print "[HeaderFilesForInterface]", Dumper(@includes);
     return @includes;
 }
 
 sub NeedsOpaqueRootForGC
 {
     my $interface = shift;
     return $interface->extendedAttributes->{"GenerateIsReachable"} || $interface->extendedAttributes->{"CustomIsReachable"};
 }
 
 sub GenerateOpaqueRootForGC
@@ skipping 131 matching lines @@
 sub GenerateHeader
 {
     my $object = shift;
     my $interface = shift;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
 
     # Copy contents of parent interfaces except the first parent.
-    my @parents;
-    AddMethodsConstantsAndAttributesFromParentInterfaces($interface, \@parents);
+    AddMethodsConstantsAndAttributesFromParentInterfaces($interface); # needed for SVG* only
     LinkOverloadedFunctions($interface);
 
     # Ensure the IsDOMNodeType function is in sync.
-    die("IsDOMNodeType is out of date with respect to $interfaceName") if IsDOMNodeType($interfaceName) != InheritsInterface($interface, "Node");
+    my $_dom = IsDOMNodeType($interfaceName) ? "DOM" : "";
+    my $_inh = InheritsInterface($interface, "Node") ? "INH" : "";
+    if(IsDOMNodeType($interfaceName) != InheritsInterface($interface, "Node")) {
+#    print "[DOMDOM] $_dom $_inh  ", $interface->name, "\n";
+        die("IsDOMNodeType is out of date with respect to $interfaceName")
+    }
 
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
 
     if ($v8ClassName !~ /SVG/) {
+        use Data::Dumper;
+        print "Parents", Dumper($interface->parents);
         for my $parent (@{$interface->parents}) {
+            print "ADD H  $parent\n";
             AddToHeaderIncludes("V8${parent}.h");
         }
     }
     AddToHeaderIncludes("bindings/v8/WrapperTypeInfo.h");
     AddToHeaderIncludes("bindings/v8/V8Binding.h");
     AddToHeaderIncludes("bindings/v8/V8DOMWrapper.h");
     AddToHeaderIncludes(HeaderFilesForInterface($interfaceName, $implClassName));
     foreach my $headerInclude (sort keys(%headerIncludes)) {
         $header{includes}->add("#include \"${headerInclude}\"\n");
     }
@@ skipping 54 matching lines @@
     static v8::Handle<v8::ObjectTemplate> GetShadowObjectTemplate(v8::Isolate*, WrapperWorldType);
 END
     }
 
     my @enabledPerContextFunctions;
     foreach my $function (@{$interface->functions}) {
         my $name = $function->name;
         next if $name eq "";
         my $attrExt = $function->extendedAttributes;
 
-        if (HasCustomMethod($attrExt) && !$attrExt->{"ImplementedBy"} && $function->{overloadIndex} == 1) {
+#        if (HasCustomMethod($attrExt) && !$attrExt->{"ImplementedBy"} && $function->{overloadIndex} == 1) {
+        if (HasCustomMethod($attrExt) && $function->{overloadIndex} == 1) {
             my $conditionalString = GenerateConditionalString($function);
             $header{classPublic}->add("#if ${conditionalString}\n") if $conditionalString;
             $header{classPublic}->add(<<END);
     static void ${name}MethodCustom(const v8::FunctionCallbackInfo<v8::Value>&);
 END
             $header{classPublic}->add("#endif // ${conditionalString}\n") if $conditionalString;
         }
         if ($attrExt->{"EnabledPerContext"}) {
             push(@enabledPerContextFunctions, $function);
         }
     }
 
     if (IsConstructable($interface)) {
         $header{classPublic}->add("    static void constructorCallback(const v8::FunctionCallbackInfo<v8::Value>&);\n");
 END
     }
     if (HasCustomConstructor($interface)) {
         $header{classPublic}->add("    static void constructorCustom(const v8::FunctionCallbackInfo<v8::Value>&);\n");
     }
 
     my @enabledPerContextAttributes;
     foreach my $attribute (@{$interface->attributes}) {
         my $name = $attribute->name;
         my $attrExt = $attribute->extendedAttributes;
         my $conditionalString = GenerateConditionalString($attribute);
-        if (HasCustomGetter($attrExt) && !$attrExt->{"ImplementedBy"}) {
+#        if (HasCustomGetter($attrExt) && !$attrExt->{"ImplementedBy"}) {
+        if (HasCustomGetter($attrExt)) {
             $header{classPublic}->add("#if ${conditionalString}\n") if $conditionalString;
             $header{classPublic}->add(<<END);
     static void ${name}AttrGetterCustom(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>&);
 END
             $header{classPublic}->add("#endif // ${conditionalString}\n") if $conditionalString;
         }
-        if (HasCustomSetter($attrExt) && !$attrExt->{"ImplementedBy"}) {
+#        if (HasCustomSetter($attrExt) && !$attrExt->{"ImplementedBy"}) {
+        if (HasCustomSetter($attrExt)) {
             $header{classPublic}->add("#if ${conditionalString}\n") if $conditionalString;
             $header{classPublic}->add(<<END);
     static void ${name}AttrSetterCustom(v8::Local<v8::String> name, v8::Local<v8::Value>, const v8::PropertyCallbackInfo<void>&);
 END
             $header{classPublic}->add("#endif // ${conditionalString}\n") if $conditionalString;
         }
         if ($attrExt->{"EnabledPerContext"}) {
             push(@enabledPerContextAttributes, $attribute);
         }
     }
@@ skipping 66 matching lines @@
 template<>
 class WrapperTypeTraits<${nativeType} > {
 public:
     static WrapperTypeInfo* info() { return &${v8ClassName}::info; }
 };
 
 END
 
     my $customWrap = $interface->extendedAttributes->{"CustomToV8"};
     if ($noToV8) {
-        die "Can't suppress toV8 for subclass\n" if @parents;
+        my $hasParent = 0;
+        ForAllParents($interface, sub {
+            my $parent = shift;
+            $hasParent = 1;
+        });
+        die "Can't suppress toV8 for subclass\n" if $hasParent;
     } elsif ($noWrap) {
         die "Must have custom toV8\n" if !$customWrap;
         $header{nameSpaceWebCore}->add(<<END);
 class ${nativeType};
 v8::Handle<v8::Value> toV8(${nativeType}*, v8::Handle<v8::Object> creationContext, v8::Isolate*);
 v8::Handle<v8::Value> toV8ForMainWorld(${nativeType}*, v8::Handle<v8::Object> creationContext, v8::Isolate*);
 
 template<class HolderContainer, class Wrappable>
 inline v8::Handle<v8::Value> toV8Fast(${nativeType}* impl, const HolderContainer& container, Wrappable*)
 {
@@ skipping 2993 matching lines @@
     my $interface = shift;
     my $code = "";
 
     if ($interface->extendedAttributes->{"MasqueradesAsUndefined"})
     {
         $code .= "    desc->InstanceTemplate()->MarkAsUndetectable();\n";
     }
     return $code;
 }
 
+# __IMPL__
 sub GenerateImplementation
 {
     my $object = shift;
     my $interface = shift;
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $nativeType = GetNativeTypeForConversions($interface);
 
     AddToImplIncludes("bindings/v8/V8Binding.h");
@@ skipping 348 matching lines @@
     v8::Local<v8::Signature> defaultSignature;
 END
     if ($interface->extendedAttributes->{"EnabledAtRuntime"}) {
         my $enable_function = GetRuntimeEnableFunctionName($interface);
         $code .= <<END;
     if (!${enable_function}())
         defaultSignature = V8DOMConfiguration::configureTemplate(desc, \"\", $parentClassTemplate, ${v8ClassName}::internalFieldCount, 0, 0, 0, 0, isolate, currentWorldType);
     else
 END
     }
+=memo
+static v8::Local<v8::Signature> configureTemplate(
+    v8::Handle<v8::FunctionTemplate>, 
+    const char* interfaceName, 
+    v8::Handle<v8::FunctionTemplate> parentClass, 
+    size_t fieldCount, 
+    
+    const BatchedAttribute*, 
+    size_t attributeCount, 
+    const BatchedMethod*, 
+    size_t callbackCount, 
+    v8::Isolate*, 
+    WrapperWorldType);
+=cut
     $code .=  <<END;
     defaultSignature = V8DOMConfiguration::configureTemplate(desc, \"${interfaceName}\", $parentClassTemplate, ${v8ClassName}::internalFieldCount,
 END
     # Set up our attributes if we have them
     if ($has_attributes) {
         $code .= <<END;
         ${v8ClassName}Attrs, WTF_ARRAY_LENGTH(${v8ClassName}Attrs),
 END
     } else {
         $code .= <<END;
@@ skipping 329 matching lines @@
     {
         ASSERT(value->IsObject());
         ASSERT(context);
         return adoptRef(new ${v8ClassName}(v8::Handle<v8::Object>::Cast(value), context));
     }
 
     virtual ~${v8ClassName}();
 
 END
 
+#print "[CallbackHeader]", $interface->name, "\n";
+
     # Functions
     my $numFunctions = @{$interface->functions};
     if ($numFunctions > 0) {
         $header{classPublic}->add("    // Functions\n");
         foreach my $function (@{$interface->functions}) {
             my $code = "    virtual " . GetNativeTypeForCallbacks($function->type) . " " . $function->name . "(";
 
             my @args = ();
             my @params = @{$function->parameters};
             foreach my $param (@params) {
@@ skipping 39 matching lines @@
 
 END
 
     $implementation{nameSpaceWebCore}->add(<<END);
 ${v8ClassName}::~${v8ClassName}()
 {
 }
 
 END
 
+#print "[CallbackImp]", $interface->name, "\n";
+
     # Functions
     my $numFunctions = @{$interface->functions};
     if ($numFunctions > 0) {
         $implementation{nameSpaceWebCore}->add("// Functions\n");
         foreach my $function (@{$interface->functions}) {
             my $code = "";
             my @params = @{$function->parameters};
             next if $function->extendedAttributes->{"Custom"};
 
             AddIncludesForType($function->type);
@@ skipping 364 matching lines @@
         $type .= "<$mode>";
     }
 
     return $type;
 }
 
 sub GetNativeType
 {
     my $type = shift;
     my $isParameter = shift;
+    my $isw = IsWrapperType($type) ? "WT":"";
+print "[GetNativeType] $type, $isParameter $isw\n" if $type eq "ObjectArray";
 
     my $svgNativeType = GetSVGTypeNeedingTearOff($type);
     if ($svgNativeType) {
         if ($svgNativeType =~ /List$/) {
             return "${svgNativeType}*";
         } else {
             return "RefPtr<${svgNativeType} >";
         }
     }
 
@@ skipping 15 matching lines @@
     return "Dictionary" if $type eq "Dictionary";
 
     return "RefPtr<DOMStringList>" if $type eq "DOMStringList";
     return "RefPtr<MediaQueryListListener>" if $type eq "MediaQueryListListener";
     return "RefPtr<NodeFilter>" if $type eq "NodeFilter";
     return "RefPtr<SerializedScriptValue>" if $type eq "SerializedScriptValue";
     return "RefPtr<XPathNSResolver>" if $type eq "XPathNSResolver";
 
     die "UnionType is not supported" if IsUnionType($type);
 
+print "[GetNativeType] here\n" if $type eq "ObjectArray";
     # We need to check [ImplementedAs] extended attribute for wrapper types.
     if (IsWrapperType($type)) {
         my $interface = ParseInterface($type);
         my $implClassName = GetImplName($interface);
         return $isParameter ? "${implClassName}*" : "RefPtr<${implClassName}>";
     }
     return "RefPtr<${type}>" if IsRefPtrType($type) and not $isParameter;
 
     my $arrayOrSequenceType = GetArrayOrSequenceType($type);
 
     if ($arrayOrSequenceType) {
         my $nativeType = GetNativeType($arrayOrSequenceType);
         $nativeType .= " " if ($nativeType =~ />$/);
         return "Vector<${nativeType}>";
     }
 
     # Default, assume native type is a pointer with same type name as idl type
     return "${type}*";
 }
 
 sub GetNativeTypeForCallbacks
 {
     my $type = shift;
+#    print "#####\n[Callback] DOMString\n" if $type eq "DOMString";
+#    print "#####\n[Callback] SerializedScriptValue\n" if $type eq "SerializedScriptValue";
+    
     return "const String&" if $type eq "DOMString";
     return "PassRefPtr<SerializedScriptValue>" if $type eq "SerializedScriptValue";
 
     # Callbacks use raw pointers, so pass isParameter = 1
     return GetNativeType($type, 1);
 }
 
 sub JSValueToNative
 {
     my $type = shift;
@@ skipping 479 matching lines @@
     }
     open FH, ">", $fileName or die "Couldn't open $fileName: $!\n";
     print FH $contents;
     close FH;
 }
 
 sub ForAllParents
 {
     my $interface = shift;
     my $beforeRecursion = shift;
-    my $afterRecursion = shift;
 
     my $recurse;
     $recurse = sub {
         my $currentInterface = shift;
 
         for (@{$currentInterface->parents}) {
             my $interfaceName = $_;
             my $parentInterface = ParseInterface($interfaceName);
 
             if ($beforeRecursion) {
                 &$beforeRecursion($parentInterface) eq 'prune' and next;
             }
             &$recurse($parentInterface);
-            &$afterRecursion($parentInterface) if $afterRecursion;
         }
     };
 
     &$recurse($interface);
 }
 
 sub AddMethodsConstantsAndAttributesFromParentInterfaces
 {
     # Add to $interface all of its inherited interface members, except for those
     # inherited through $interface's first listed parent.  If an array reference
     # is passed in as $parents, the names of all ancestor interfaces visited
     # will be appended to the array. The names of $interface's first listed parent
     # and its ancestors will also be appended to $parents.
 
     my $interface = shift;
-    my $parents = shift;
 
     my $first = 1;
     ForAllParents($interface, sub {
         my $currentInterface = shift;
 
         if ($first) {
             # Ignore first parent class, already handled by the generation itself.
             $first = 0;
 
-            # Just collect the names of the direct ancestor interfaces,
-            # if necessary.
-            push(@$parents, $currentInterface->name);
-            ForAllParents($currentInterface, sub {
-                my $currentInterface = shift;
-                push(@$parents, $currentInterface->name);
-            });
             return 'prune';
         }
 
-        # Collect the name of this additional parent.
-        push(@$parents, $currentInterface->name) if $parents;
-
+        # SVG* only!
+#        print $interface->name, "[Came here with]", $currentInterface->name, "\n";
         # Add this parent's members to $interface.
         push(@{$interface->constants}, @{$currentInterface->constants});
         push(@{$interface->functions}, @{$currentInterface->functions});
         push(@{$interface->attributes}, @{$currentInterface->attributes});
     });
 }
 
 sub FindSuperMethod
 {
     my ($interface, $functionName) = @_;
     my $indexer;
-    ForAllParents($interface, undef, sub {
+    ForAllParents($interface, sub {
         my $currentInterface = shift;
         foreach my $function (@{$currentInterface->functions}) {
             if ($function->name eq $functionName) {
                 $indexer = $function;
                 return 'prune';
             }
         }
     });
     return $indexer;
 }
@@ skipping 404 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;