Clean up code generator before implementing [ExposeV8GetterAndSetter]

Source/bindings/scripts/code_generator_v8.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 3118 matching lines @@
     my @propAttributeList;
     if ($attrExt->{"NotEnumerable"} || $isConstructor) {
         push(@propAttributeList, "v8::DontEnum");
     }
     if ($attrExt->{"Unforgeable"} && !$isConstructor) {
         push(@propAttributeList, "v8::DontDelete");
     }
     @propAttributeList = ("v8::None") unless @propAttributeList;
     my $propAttribute = join(" | ", @propAttributeList);
 
-    my $on_proto = "0 /* on instance */";
+    my $onProto = "0 /* on instance */";
     my $data = "0";  # no data
 
     # Constructor
     if ($isConstructor) {
         my $constructorType = $attribute->type;
         $constructorType =~ s/Constructor$//;
 
         # For NamedConstructors we do not generate a header file. The code for the NamedConstructor
         # gets generated when we generate the code for its interface.
         if ($constructorType !~ /Constructor$/) {
@@ skipping 18 matching lines @@
     }
 
     # Read only attributes
     if (IsReadonly($attribute)) {
         $setter = "0";
         $setterForMainWorld = "0";
     }
 
     # An accessor can be installed on the proto
     if ($attrExt->{"OnProto"}) {
-        $on_proto = "1 /* on proto */";
+        $onProto = "1 /* on proto */";
     }
 
     if (!$attrExt->{"PerWorldBindings"}) {
       $getterForMainWorld = "0";
       $setterForMainWorld = "0";
     }
 
-    return ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, "static_cast<v8::PropertyAttribute>($propAttribute)", $on_proto);
+    return ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, "static_cast<v8::PropertyAttribute>($propAttribute)", $onProto);
 }
 
 sub GenerateAttributeConfiguration
 {
     my $interface = shift;
     my $attribute = shift;
     my $delimiter = shift;
     my $indent = shift;
     my $code = "";
 
-    my ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $on_proto) = GenerateAttributeConfigurationParameters($interface, $attribute);
+    my ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $onProto) = GenerateAttributeConfigurationParameters($interface, $attribute);
 
-    $code .= $indent . "    {\"$attrName\", $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $on_proto}" . $delimiter . "\n";
+    $code .= $indent . "    {\"$attrName\", $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $onProto}" . $delimiter . "\n";
     return $code;
 }
 
 sub GenerateStaticAttribute
 {
     my $interface = shift;
     my $attribute = shift;
     my $attrExt = $attribute->extendedAttributes;
     my $code = "";
 
-    my ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $on_proto) = GenerateAttributeConfigurationParameters($interface, $attribute);
+    my ($attrName, $getter, $setter, $getterForMainWorld, $setterForMainWorld, $data, $accessControl, $propAttribute, $onProto) = GenerateAttributeConfigurationParameters($interface, $attribute);
 
     die "Static attributes do not support optimized getters or setters for the main world" if $getterForMainWorld || $setterForMainWorld;
 
     my $conditionalString = GenerateConditionalString($attribute);
 
     $code .= "#if ${conditionalString}\n" if $conditionalString;
     $code .= "    desc->SetNativeDataProperty(v8::String::NewSymbol(\"$attrName\"), $getter, $setter, v8::External::New($data), $propAttribute, v8::Handle<v8::AccessorSignature>(), $accessControl);\n";
     $code .= "#endif // ${conditionalString}\n" if $conditionalString;
 
     return $code;
@@ skipping 1076 matching lines @@
     AddToImplIncludes("bindings/v8/V8DOMConfiguration.h");
     # Put the attributes that disallow shadowing on the shadow object.
     if (@disallowsShadowing) {
         my $code = "";
         $code .= "static const V8DOMConfiguration::AttributeConfiguration shadowAttributes[] = {\n";
         $code .= GenerateAttributeConfigurationArray($interface, \@disallowsShadowing);
         $code .= "};\n\n";
         $implementation{nameSpaceWebCore}->add($code);
     }
 
-    my $has_attributes = 0;
+    my $hasAttributes = 0;
     if (@normalAttributes) {
-        $has_attributes = 1;
+        $hasAttributes = 1;
         my $code = "";
         $code .= "static const V8DOMConfiguration::AttributeConfiguration ${v8ClassName}Attributes[] = {\n";
         $code .= GenerateAttributeConfigurationArray($interface, \@normalAttributes);
         $code .= "};\n\n";
         $implementation{nameSpaceWebCore}->add($code);
     }
 
     # Setup table of standard callback functions
-    my $num_callbacks = 0;
-    my $has_callbacks = 0;
+    my $hasFunctions = 0;
     $code = "";
     foreach my $function (@normalFunctions) {
-        # Only one table entry is needed for overloaded methods:
+        # Only one table entry is needed for overloaded functions:
         next if $function->{overloadIndex} > 1;
         # Don't put any nonstandard functions into this table:
         next if !IsStandardFunction($interface, $function);
         next if $function->name eq "";
-        if (!$has_callbacks) {
-            $has_callbacks = 1;
+        if (!$hasFunctions) {
+            $hasFunctions = 1;
             $code .= "static const V8DOMConfiguration::MethodConfiguration ${v8ClassName}Methods[] = {\n";
         }
         my $name = $function->name;
         my $methodForMainWorld = "0";
         if ($function->extendedAttributes->{"PerWorldBindings"}) {
             $methodForMainWorld = "${implClassName}V8Internal::${name}MethodCallbackForMainWorld";
         }
         my $functionLength = GetFunctionLength($function);
         my $conditionalString = GenerateConditionalString($function);
         $code .= "#if ${conditionalString}\n" if $conditionalString;
         $code .= <<END;
     {"$name", ${implClassName}V8Internal::${name}MethodCallback, ${methodForMainWorld}, ${functionLength}},
 END
         $code .= "#endif // ${conditionalString}\n" if $conditionalString;
-        $num_callbacks++;
     }
-    $code .= "};\n\n"  if $has_callbacks;
+    $code .= "};\n\n"  if $hasFunctions;
     $implementation{nameSpaceWebCore}->add($code);
 
-    my $has_constants = 0;
+    my $hasConstants = 0;
     if (@{$interface->constants}) {
-        $has_constants = 1;
+        $hasConstants = 1;
     }
 
     if (!HasCustomConstructor($interface)) {
         if ($interface->extendedAttributes->{"NamedConstructor"}) {
             GenerateNamedConstructor(@{$interface->constructors}[0], $interface);
         } elsif ($interface->extendedAttributes->{"Constructor"}) {
             GenerateConstructor($interface);
         } elsif (IsConstructorTemplate($interface, "Event")) {
             GenerateEventConstructor($interface);
         }
     }
     if (IsConstructable($interface)) {
         GenerateConstructorCallback($interface);
     }
 
-    my $access_check = "";
+    my $accessCheck = "";
     if ($interface->extendedAttributes->{"CheckSecurity"} && $interfaceName ne "Window") {
-        $access_check = "instance->SetAccessCheckCallbacks(${implClassName}V8Internal::namedSecurityCheck, ${implClassName}V8Internal::indexedSecurityCheck, v8::External::New(const_cast<WrapperTypeInfo*>(&${v8ClassName}::wrapperTypeInfo)));";
+        $accessCheck = "instance->SetAccessCheckCallbacks(${implClassName}V8Internal::namedSecurityCheck, ${implClassName}V8Internal::indexedSecurityCheck, v8::External::New(const_cast<WrapperTypeInfo*>(&${v8ClassName}::wrapperTypeInfo)));";
     }
 
     # For the Window interface, generate the shadow object template
     # configuration method.
     if ($interfaceName eq "Window") {
         $implementation{nameSpaceWebCore}->add(<<END);
 static void ConfigureShadowObjectTemplate(v8::Handle<v8::ObjectTemplate> templ, v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     V8DOMConfiguration::installAttributes(templ, v8::Handle<v8::ObjectTemplate>(), shadowAttributes, WTF_ARRAY_LENGTH(shadowAttributes), isolate, currentWorldType);
 
     // Install a security handler with V8.
     templ->SetAccessCheckCallbacks(V8Window::namedSecurityCheckCustom, V8Window::indexedSecurityCheckCustom, v8::External::New(const_cast<WrapperTypeInfo*>(&V8Window::wrapperTypeInfo)));
     templ->SetInternalFieldCount(V8Window::internalFieldCount);
 }
 END
     }
 
     if (!$parentClassTemplate) {
         $parentClassTemplate = "v8::Local<v8::FunctionTemplate>()";
     }
 
     # Generate the template configuration method
     $code =  <<END;
 static v8::Handle<v8::FunctionTemplate> Configure${v8ClassName}Template(v8::Handle<v8::FunctionTemplate> desc, v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     desc->ReadOnlyPrototype();
 
     v8::Local<v8::Signature> defaultSignature;
 END
+
+    # Define constants, attributes, accessors and operations.
     if ($interface->extendedAttributes->{"RuntimeEnabled"}) {
         my $runtimeEnabledFunction = GetRuntimeEnabledFunctionName($interface);
         $code .= <<END;
     if (!${runtimeEnabledFunction}())
         defaultSignature = V8DOMConfiguration::installDOMClassTemplate(desc, \"\", $parentClassTemplate, ${v8ClassName}::internalFieldCount, 0, 0, 0, 0, isolate, currentWorldType);
     else
 END
     }
-    $code .=  <<END;
-    defaultSignature = V8DOMConfiguration::installDOMClassTemplate(desc, \"${interfaceName}\", $parentClassTemplate, ${v8ClassName}::internalFieldCount,
-END
-    # Set up our attributes if we have them
-    if ($has_attributes) {
-        $code .= <<END;
-        ${v8ClassName}Attributes, WTF_ARRAY_LENGTH(${v8ClassName}Attributes),
-END
-    } else {
-        $code .= <<END;
-        0, 0,
-END
-    }
-
-    if ($has_callbacks) {
-        $code .= <<END;
-        ${v8ClassName}Methods, WTF_ARRAY_LENGTH(${v8ClassName}Methods), isolate, currentWorldType);
-END
-    } else {
-        $code .= <<END;
-        0, 0, isolate, currentWorldType);
-END
-    }
+    $code .=  "    defaultSignature = V8DOMConfiguration::installDOMClassTemplate(desc, \"${interfaceName}\", $parentClassTemplate, ${v8ClassName}::internalFieldCount, ";
+    $code .=  $hasAttributes ? "${v8ClassName}Attributes, WTF_ARRAY_LENGTH(${v8ClassName}Attributes)," : "0, 0,";

[Nils Barth (inactive), 2013/10/31 07:00:36]

You want a trailing ' ' here to replace the newline.

[haraken, 2013/10/31 07:02:27]

Done.

+    $code .= $hasFunctions ? "${v8ClassName}Methods, WTF_ARRAY_LENGTH(${v8ClassName}Methods), isolate, currentWorldType);\n" : "0, 0, isolate, currentWorldType);\n";
 
     AddToImplIncludes("wtf/UnusedParam.h");
-    $code .= <<END;
-    UNUSED_PARAM(defaultSignature);
-END
+    $code .= "    UNUSED_PARAM(defaultSignature);\n";
 
     if (IsConstructable($interface)) {
         $code .= "    desc->SetCallHandler(${v8ClassName}::constructorCallback);\n";
         my $interfaceLength = GetInterfaceLength($interface);
         $code .= "    desc->SetLength(${interfaceLength});\n";
     }
 
-    if ($access_check or @runtimeEnabledAttributes or @normalFunctions or $has_constants) {
+    if ($accessCheck or @runtimeEnabledAttributes or @normalFunctions or $hasConstants) {
         $code .=  <<END;
     v8::Local<v8::ObjectTemplate> instance = desc->InstanceTemplate();
     v8::Local<v8::ObjectTemplate> proto = desc->PrototypeTemplate();
     UNUSED_PARAM(instance);
     UNUSED_PARAM(proto);
 END
     }
 
-    if ($access_check) {
-        $code .=  "    $access_check\n";
+    if ($accessCheck) {
+        $code .=  "    $accessCheck\n";
     }
 
-    # Setup the enable-at-runtime attributes if we have them
-    foreach my $runtime_attr (@runtimeEnabledAttributes) {
-        my $runtimeEnabledFunction = GetRuntimeEnabledFunctionName($runtime_attr);
-        my $conditionalString = GenerateConditionalString($runtime_attr);
+    # Define runtime enabled attributes.
+    foreach my $runtimeEnabledAttribute (@runtimeEnabledAttributes) {
+        my $runtimeEnabledFunction = GetRuntimeEnabledFunctionName($runtimeEnabledAttribute);
+        my $conditionalString = GenerateConditionalString($runtimeEnabledAttribute);
         $code .= "#if ${conditionalString}\n" if $conditionalString;
         $code .= "    if (${runtimeEnabledFunction}()) {\n";
         $code .= "        static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\\\n";
-        $code .= GenerateAttributeConfiguration($interface, $runtime_attr, ";", "    ");
+        $code .= GenerateAttributeConfiguration($interface, $runtimeEnabledAttribute, ";", "    ");
         $code .= <<END;
         V8DOMConfiguration::installAttribute(instance, proto, attributeConfiguration, isolate, currentWorldType);
     }
 END
         $code .= "#endif // ${conditionalString}\n" if $conditionalString;
     }
 
-    my @constantsEnabledAtRuntime;
-    if ($has_constants) {
+    my @runtimeEnabledConstants;
+    if ($hasConstants) {
+        # Define constants.
         $code .= "    static const V8DOMConfiguration::ConstantConfiguration ${v8ClassName}Constants[] = {\n";
         foreach my $constant (@{$interface->constants}) {
             my $name = $constant->name;
             my $value = $constant->value;
             my $attrExt = $constant->extendedAttributes;
             my $implementedBy = $attrExt->{"ImplementedBy"};
             if ($implementedBy) {
                 my $implementedByImplName = GetImplNameFromImplementedBy($implementedBy);
                 AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedByImplName));
             }
             if ($attrExt->{"RuntimeEnabled"}) {
-                push(@constantsEnabledAtRuntime, $constant);
+                push(@runtimeEnabledConstants, $constant);
             } else {
                 $code .= <<END;
         {"${name}", $value},
 END
             }
         }
         $code .= "    };\n";
         $code .= <<END;
     V8DOMConfiguration::installConstants(desc, proto, ${v8ClassName}Constants, WTF_ARRAY_LENGTH(${v8ClassName}Constants), isolate);
 END
-        # Setup the enable-at-runtime constants if we have them
-        foreach my $runtime_const (@constantsEnabledAtRuntime) {
-            my $runtimeEnabledFunction = GetRuntimeEnabledFunctionName($runtime_const);
-            my $name = $runtime_const->name;
-            my $value = $runtime_const->value;
+        # Define runtime enabled constants.
+        foreach my $runtimeEnabledConstant (@runtimeEnabledConstants) {
+            my $runtimeEnabledFunction = GetRuntimeEnabledFunctionName($runtimeEnabledConstant);
+            my $name = $runtimeEnabledConstant->name;
+            my $value = $runtimeEnabledConstant->value;
             $code .= "    if (${runtimeEnabledFunction}()) {\n";
             $code .= <<END;
         static const V8DOMConfiguration::ConstantConfiguration constantConfiguration = {"${name}", static_cast<signed int>(${value})};
         V8DOMConfiguration::installConstants(desc, proto, &constantConfiguration, 1, isolate);
 END
             $code .= "    }\n";
         }
         $code .= join "", GenerateCompileTimeCheckForEnumsIfNeeded($interface);
     }
 
     $code .= GenerateImplementationIndexedPropertyAccessors($interface);
     $code .= GenerateImplementationNamedPropertyAccessors($interface);
     $code .= GenerateImplementationLegacyCall($interface);
     $code .= GenerateImplementationMasqueradesAsUndefined($interface);
 
-    # Define our functions with Set() or SetAccessor()
+    # Define operations.
     my $total_functions = 0;
     foreach my $function (@normalFunctions) {
-        # Only one accessor is needed for overloaded methods:
+        # Only one accessor is needed for overloaded operations.
         next if $function->{overloadIndex} > 1;
         next if $function->name eq "";
 
         $total_functions++;
         next if IsStandardFunction($interface, $function);
         $code .= GenerateNonStandardFunction($interface, $function);
-        $num_callbacks++;
     }
 
-    die "Wrong number of callbacks generated for $interfaceName ($num_callbacks, should be $total_functions)" if $num_callbacks != $total_functions;

[haraken, 2013/10/31 06:47:47]

This check is not helpful. So removed.

[Nils Barth (inactive), 2013/10/31 07:00:36]

Agreed; this is just saying "code is confusing enough that it's not even clear
that we're looping over all functions"!

-
     # Define static attributes.
     foreach my $attribute (@staticAttributes) {
         $code .= GenerateStaticAttribute($interface, $attribute);
     }
 
     # Special cases
     if ($interfaceName eq "Window") {
         $code .= <<END;
 
     proto->SetInternalFieldCount(V8Window::internalFieldCount);
@@ skipping 56 matching lines @@
 END
 
     if (@perContextEnabledAttributes) {
         my $code = "";
         $code .= <<END;
 void ${v8ClassName}::installPerContextEnabledProperties(v8::Handle<v8::Object> instance, ${nativeType}* impl, v8::Isolate* isolate)
 {
     v8::Local<v8::Object> proto = v8::Local<v8::Object>::Cast(instance->GetPrototype());
 END
 
-        # Setup the enable-by-settings attributes if we have them
+        # Define per-context enabled attributes.
         foreach my $perContextEnabledAttribute (@perContextEnabledAttributes) {
             my $contextEnabledFunction = GetContextEnabledFunctionName($perContextEnabledAttribute);
             $code .= "    if (${contextEnabledFunction}(impl->document())) {\n";
 
             $code .= "        static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\\\n";
             $code .= GenerateAttributeConfiguration($interface, $perContextEnabledAttribute, ";", "    ");
             $code .= <<END;
         V8DOMConfiguration::installAttribute(instance, proto, attributeConfiguration, isolate);
 END
             $code .= "    }\n";
         }
         $code .= <<END;
 }
 
 END
         $implementation{nameSpaceWebCore}->add($code);
     }
 
     if (@perContextEnabledFunctions) {
         my $code = "";
         $code .= <<END;
 void ${v8ClassName}::installPerContextEnabledPrototypeProperties(v8::Handle<v8::Object> proto, v8::Isolate* isolate)
 {
     UNUSED_PARAM(proto);
 END
-        # Setup the enable-by-settings functions if we have them
+        # Define per-context enabled operations.
         $code .=  <<END;
     v8::Local<v8::Signature> defaultSignature = v8::Signature::New(GetTemplate(isolate, worldType(isolate)));
     UNUSED_PARAM(defaultSignature);
 
     ExecutionContext* context = toExecutionContext(proto->CreationContext());
 END
 
-        foreach my $runtimeFunc (@perContextEnabledFunctions) {
-            my $contextEnabledFunction = GetContextEnabledFunctionName($runtimeFunc);
-            my $functionLength = GetFunctionLength($runtimeFunc);
-            my $conditionalString = GenerateConditionalString($runtimeFunc);
+        foreach my $perContextEnabledFunction (@perContextEnabledFunctions) {
+            my $contextEnabledFunction = GetContextEnabledFunctionName($perContextEnabledFunction);
+            my $functionLength = GetFunctionLength($perContextEnabledFunction);
+            my $conditionalString = GenerateConditionalString($perContextEnabledFunction);
             $code .= "\n#if ${conditionalString}\n" if $conditionalString;
             $code .= "    if (context && context->isDocument() && ${contextEnabledFunction}(toDocument(context)))\n";
-            my $name = $runtimeFunc->name;
+            my $name = $perContextEnabledFunction->name;
             $code .= <<END;
         proto->Set(v8::String::NewSymbol("${name}"), v8::FunctionTemplate::New(${implClassName}V8Internal::${name}MethodCallback, v8Undefined(), defaultSignature, $functionLength)->GetFunction());
 END
             $code .= "#endif // ${conditionalString}\n" if $conditionalString;
         }
 
         $code .= <<END;
 }
 
 END
@@ skipping 1642 matching lines @@
 
     return 1 if $interface->extendedAttributes->{"CustomToV8"};
     return 1 if $interface->extendedAttributes->{"SpecialWrapFor"};
     return 1 if InheritsInterface($interface, "Document");
     return 1 if SVGTypeNeedsToHoldContextElement($interface->name);
 
     return 0;
 }
 
 1;