Add constants and primitive type readonly attributes to Python IDL compiler

Source/bindings/scripts/deprecated_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 4135 matching lines @@
             AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedByImplName));
         }
         if ($attrExt->{"EnabledAtRuntime"}) {
             push(@constantsEnabledAtRuntime, $constant);
         } else {
             my $conditionalString = GenerateConditionalString($constant);
             $code .= "#if ${conditionalString}\n" if $conditionalString;
             $code .= <<END;
     {"${name}", $value},
 END
-            $code .= "#endif\n" if $conditionalString;
+            $code .= "#endif // $conditionalString\n" if $conditionalString;
         }
     }
     if ($has_constants) {
         $code .= "};\n\n";
         $code .= join "", GenerateCompileTimeCheckForEnumsIfNeeded($interface);
         $implementation{nameSpaceWebCore}->add($code);
     }
 
     if (!HasCustomConstructor($interface)) {
         if ($interface->extendedAttributes->{"NamedConstructor"}) {
@@ skipping 67 matching lines @@
         ${v8ClassName}Methods, WTF_ARRAY_LENGTH(${v8ClassName}Methods), isolate, currentWorldType);
 END
     } else {
         $code .= <<END;
         0, 0, isolate, currentWorldType);
 END
     }
 
     AddToImplIncludes("wtf/UnusedParam.h");
     $code .= <<END;
-    UNUSED_PARAM(defaultSignature); // In some cases, it will not be used.
+    UNUSED_PARAM(defaultSignature);
 END
 
     if (IsConstructable($interface)) {
         $code .= "    desc->SetCallHandler(${v8ClassName}::constructorCallback);\n";
         my $interfaceLength = GetInterfaceLength($interface);
         $code .= "    desc->SetLength(${interfaceLength});\n";
     }
 
     if ($access_check or @enabledAtRuntimeAttributes or @normalFunctions or $has_constants) {
         $code .=  <<END;
     v8::Local<v8::ObjectTemplate> instance = desc->InstanceTemplate();
     v8::Local<v8::ObjectTemplate> proto = desc->PrototypeTemplate();
-    UNUSED_PARAM(instance); // In some cases, it will not be used.
-    UNUSED_PARAM(proto); // In some cases, it will not be used.
+    UNUSED_PARAM(instance);
+    UNUSED_PARAM(proto);
 END
     }
 
     if ($access_check) {
         $code .=  "    $access_check\n";
     }
 
     # Setup the enable-at-runtime attributes if we have them
     foreach my $runtime_attr (@enabledAtRuntimeAttributes) {
         next if grep { $_ eq $runtime_attr } @enabledPerContextAttributes;
@@ skipping 19 matching lines @@
         $code .= "\n#if ${conditionalString}\n" if $conditionalString;
         $code .= "    if (${enable_function}()) {\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 .= "\n#endif // ${conditionalString}\n" if $conditionalString;
     }
 
+    if ($has_constants) {
+        $code .= <<END;
+    V8DOMConfiguration::installConstants(desc, proto, ${v8ClassName}Constants, WTF_ARRAY_LENGTH(${v8ClassName}Constants), isolate);
+END
+    }
+
     $code .= GenerateImplementationIndexedPropertyAccessors($interface);
     $code .= GenerateImplementationNamedPropertyAccessors($interface);
     $code .= GenerateImplementationLegacyCall($interface);
     $code .= GenerateImplementationMasqueradesAsUndefined($interface);
 
     # Define our functions with Set() or SetAccessor()
     my $total_functions = 0;
     foreach my $function (@normalFunctions) {
         # Only one accessor is needed for overloaded methods:
         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;
 
-    if ($has_constants) {
-        $code .= <<END;
-    V8DOMConfiguration::installConstants(desc, proto, ${v8ClassName}Constants, WTF_ARRAY_LENGTH(${v8ClassName}Constants), isolate);
-END
-    }
-
     # Special cases
     if ($interfaceName eq "Window") {
         $code .= <<END;
 
     proto->SetInternalFieldCount(V8Window::internalFieldCount);
     desc->SetHiddenPrototype(true);
     instance->SetInternalFieldCount(V8Window::internalFieldCount);
     // Set access check callbacks, but turned off initially.
     // When a context is detached from a frame, turn on the access check.
     // Turning on checks also invalidates inline caches of the object.
@@ skipping 88 matching lines @@
     if (@enabledPerContextFunctions) {
         my $code = "";
         $code .= <<END;
 void ${v8ClassName}::installPerContextPrototypeProperties(v8::Handle<v8::Object> proto, v8::Isolate* isolate)
 {
     UNUSED_PARAM(proto);
 END
         # Setup the enable-by-settings functions if we have them
         $code .=  <<END;
     v8::Local<v8::Signature> defaultSignature = v8::Signature::New(GetTemplate(isolate, worldType(isolate)));
-    UNUSED_PARAM(defaultSignature); // In some cases, it will not be used.
+    UNUSED_PARAM(defaultSignature);
 
     ScriptExecutionContext* context = toScriptExecutionContext(proto->CreationContext());
 END
 
         foreach my $runtimeFunc (@enabledPerContextFunctions) {
             my $enableFunction = GetContextEnableFunction($runtimeFunc);
             my $functionLength = GetFunctionLength($runtimeFunc);
             my $conditionalString = GenerateConditionalString($runtimeFunc);
             $code .= "\n#if ${conditionalString}\n" if $conditionalString;
             $code .= "    if (context && context->isDocument() && ${enableFunction}(toDocument(context)))\n";
@@ skipping 1531 matching lines @@
             my $conditionalString = GenerateConditionalString($constant);
             push(@checks, "#if ${conditionalString}\n") if $conditionalString;
 
             if ($constant->extendedAttributes->{"ImplementedBy"}) {
                 my $implementedByImplName = GetImplNameFromImplementedBy($constant->extendedAttributes->{"ImplementedBy"});
                 push(@checks, "COMPILE_ASSERT($value == " . $implementedByImplName . "::$name, ${implClassName}Enum${name}IsWrongUseDoNotCheckConstants);\n");
             } else {
                 push(@checks, "COMPILE_ASSERT($value == ${implClassName}::$name, ${implClassName}Enum${name}IsWrongUseDoNotCheckConstants);\n");
             }
 
-            push(@checks, "#endif\n") if $conditionalString;
+            push(@checks, "#endif // $conditionalString\n") if $conditionalString;
         }
         push(@checks, "\n");
     }
     return @checks;
 }
 
 sub ExtendedAttributeContains
 {
     my $callWith = shift;
     return 0 unless $callWith;
@@ skipping 33 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;