WIP IDL compiler rewrite

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 180 matching lines @@
 
 my %enumTypeHash = ();
 
 my %svgAttributesInHTMLHash = ("class" => 1, "id" => 1, "onabort" => 1, "onclick" => 1,
                                "onerror" => 1, "onload" => 1, "onmousedown" => 1,
                                "onmouseenter" => 1, "onmouseleave" => 1,
                                "onmousemove" => 1, "onmouseout" => 1, "onmouseover" => 1,
                                "onmouseup" => 1, "onresize" => 1, "onscroll" => 1,
                                "onunload" => 1);
 
+### DONE
 my %svgTypeNeedingTearOff = (
     "SVGAngle" => "SVGPropertyTearOff<SVGAngle>",
     "SVGLength" => "SVGPropertyTearOff<SVGLength>",
     "SVGLengthList" => "SVGListPropertyTearOff<SVGLengthList>",
     "SVGMatrix" => "SVGPropertyTearOff<SVGMatrix>",
     "SVGNumber" => "SVGPropertyTearOff<SVGNumber>",
     "SVGNumberList" => "SVGListPropertyTearOff<SVGNumberList>",
     "SVGPathSegList" => "SVGPathSegListPropertyTearOff",
     "SVGPoint" => "SVGPropertyTearOff<SVGPoint>",
     "SVGPointList" => "SVGListPropertyTearOff<SVGPointList>",
@@ skipping 49 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 (@$interfaceIdlFiles) {
             $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}) {
         return $cachedInterfaces->{$interfaceName};
     }
 
     # Step #1: Find the IDL file associated with 'interface'
     my $filename = IDLFileForInterface($interfaceName)
       or die("Could NOT find IDL file for interface \"$interfaceName\" $!\n");
 
-    print "  |  |>  Parsing parent IDL \"$filename\" for interface \"$interfaceName\"\n" if $verbose;
+#    use Carp qw(cluck);
+#    cluck "HEY";
+#    print "  |  |>  Parsing parent IDL \"$filename\" for interface \"$interfaceName\"\n" if $verbose;
+    print "  |  |>  Parsing $interfaceName ( $filename )\n";
 
     # Step #2: Parse the found IDL file (in quiet mode).
     my $parser = deprecated_idl_parser->new(1);
     my $document = $parser->Parse($filename, $preprocessor);
 
     foreach my $interface (@{$document->interfaces}) {
         if ($interface->name eq $interfaceName or $interface->isPartial) {
             $cachedInterfaces->{$interfaceName} = $interface;
             return $interface;
         }
     }
 
     die("Could NOT find interface definition for $interfaceName in $filename");
 }
 
 sub GenerateInterface
 {
     my $object = shift;
     my $interface = shift;
 
+    print "[GenerateInterface] ", $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 54 matching lines @@
     } else {
         $object->GenerateHeader($interface);
         $object->GenerateImplementation($interface);
     }
 }
 
 sub AddToImplIncludes
 {
     my $header = shift;
     $implIncludes{$header} = 1;
+    if($header eq "core/svg/properties/SVGAnimatedPropertyTearOff.h") {
+#        use Carp qw(cluck);
+#        cluck "HEY";
+    }
 }
 
 sub AddToHeaderIncludes
 {
     my @includes = @_;
 
     for my $include (@includes) {
         $headerIncludes{$include} = 1;
     }
 }
 
+### DONE
 sub SkipIncludeHeader
 {
     my $type = shift;
 
     return 1 if IsPrimitiveType($type);
     return 1 if IsEnumType($type);
     return 1 if IsCallbackFunctionType($type);
     return 1 if $type eq "DOMString";
     return 0;
 }
 
 sub AddIncludesForType
 {
     my $type = shift;
+#    print "BEBE AddIncludesForType ", $type, "\n";
 
     return if SkipIncludeHeader($type);
 
     # Default includes
     if ($type eq "EventListener" or $type eq "EventHandler") {
         AddToImplIncludes("core/dom/EventListener.h");
     } elsif ($type eq "SerializedScriptValue") {
         AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
     } elsif ($type eq "any" || IsCallbackFunctionType($type)) {
         AddToImplIncludes("bindings/v8/ScriptValue.h");
     } elsif (IsTypedArrayType($type)) {
         AddToImplIncludes("bindings/v8/custom/V8${type}Custom.h");
     } else {
         AddToImplIncludes("V8${type}.h");
     }
 }
 
 sub HeaderFilesForInterface
 {
     my $interfaceName = shift;
     my $implClassName = shift;
 
+    use Data::Dumper;
     my @includes = ();
     if (IsTypedArrayType($interfaceName)) {
+        ### DONE
         push(@includes, "wtf/${interfaceName}.h");
     } elsif (!SkipIncludeHeader($interfaceName)) {
+        ### DONE
         my $idlFilename = IDLFileForInterface($interfaceName) or die("Could NOT find IDL file for interface \"$interfaceName\" $!\n");
         my $idlRelPath= "bindings/" . File::Spec->abs2rel($idlFilename, $sourceRoot);
+#        print "GEHEHE ", $idlRelPath, "\n";
+#        print "GEHEHE ", dirname($idlRelPath), "\n";
         push(@includes, dirname($idlRelPath) . "/" . $implClassName . ".h");
     }
+#    print "[HeaderFilesForInterface]", Dumper(@includes);
     return @includes;
 }
 
+### DONE
 sub NeedsOpaqueRootForGC
 {
     my $interface = shift;
     return $interface->extendedAttributes->{"GenerateIsReachable"} || $interface->extendedAttributes->{"CustomIsReachable"};
 }
 
+### DONE
 sub GenerateOpaqueRootForGC
 {
     my $interface = shift;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
 
     if ($interface->extendedAttributes->{"CustomIsReachable"}) {
         return;
     }
 
@@ skipping 13 matching lines @@
     }
 
     $code .= <<END;
     return object;
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 }
 
+### DONE
 sub GetSVGPropertyTypes
 {
     my $implType = shift;
 
     my $svgPropertyType;
     my $svgListPropertyType;
     my $svgNativeType;
 
     return ($svgPropertyType, $svgListPropertyType, $svgNativeType) if not $implType =~ /SVG/;
 
@@ skipping 87 matching lines @@
     my $object = shift;
     my $interface = shift;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
 
     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" : "";
+#    print "[DOMDOM] $_dom $_inh  ", $interface->name, "\n";
+    if(IsDOMNodeType($interfaceName) != InheritsInterface($interface, "Node")) {
+        die("IsDOMNodeType is out of date with respect to $interfaceName")
+    }
 
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
 
     my $parentInterface = $interface->parent;
     AddToHeaderIncludes("V8${parentInterface}.h") if $parentInterface;
     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");
     }
 
+    ### DONE
     $header{nameSpaceWebCore}->addHeader("\ntemplate<typename PropertyType> class SVGPropertyTearOff;\n") if $svgPropertyType;
     if ($svgNativeType) {
         if ($svgNativeType =~ /SVGStaticListPropertyTearOff/) {
             $header{nameSpaceWebCore}->addHeader("\ntemplate<typename PropertyType> class SVGStaticListPropertyTearOff;\n");
         } else {
             $header{nameSpaceWebCore}->addHeader("\ntemplate<typename PropertyType> class SVGListPropertyTearOff;\n");
         }
     }
 
+    ### DONE
     $header{nameSpaceWebCore}->addHeader("\nclass Dictionary;") if IsConstructorTemplate($interface, "Event");
 
+    ### impl_class_name and svg_type_needing_tear_off in python generator
     my $nativeType = GetNativeTypeForConversions($interface);
     if ($interface->extendedAttributes->{"NamedConstructor"}) {
         $header{nameSpaceWebCore}->addHeader(<<END);
 
 class V8${nativeType}Constructor {
 public:
     static v8::Handle<v8::FunctionTemplate> GetTemplate(v8::Isolate*, WrapperWorldType);
     static WrapperTypeInfo info;
 };
 END
@@ skipping 31 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) && $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 466 matching lines @@
     v8::Handle<v8::Value> data = info.Data();
     ASSERT(data->IsExternal());
     V8PerContextData* perContextData = V8PerContextData::from(info.Holder()->CreationContext());
     if (!perContextData)
         return;
     v8SetReturnValue(info, perContextData->constructorForType(WrapperTypeInfo::unwrap(data)));
 }
 END
 }
 
+### macro get_feature_observation_parameter in template
 sub GenerateFeatureObservation
 {
     my $measureAs = shift;
 
     if ($measureAs) {
         AddToImplIncludes("core/page/UseCounter.h");
         return "    UseCounter::count(activeDOMWindow(), UseCounter::${measureAs});\n";
     }
 
     return "";
 }
 
+### macro deprecation_notification_parameter in template
 sub GenerateDeprecationNotification
 {
     my $deprecateAs = shift;
     if ($deprecateAs) {
         AddToImplIncludes("core/page/PageConsole.h");
         AddToImplIncludes("core/page/UseCounter.h");
         return "    UseCounter::countDeprecation(activeDOMWindow(), UseCounter::${deprecateAs});\n";
     }
     return "";
 }
 
+### DONE
 sub GenerateActivityLogging
 {
     my $accessType = shift;
     my $interface = shift;
     my $propertyName = shift;
 
     my $interfaceName = $interface->name;
 
     AddToImplIncludes("bindings/v8/V8Binding.h");
     AddToImplIncludes("bindings/v8/V8DOMActivityLogger.h");
@@ skipping 33 matching lines @@
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $attrExt = $attribute->extendedAttributes;
     my $attrName = $attribute->name;
 
+    ### DONE
     my $conditionalString = GenerateConditionalString($attribute);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
 
     $code .= "static void ${attrName}AttrGetterCallback${forMainWorldSuffix}(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)\n";
     $code .= "{\n";
+    ### DONE
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"Blink\", \"DOMGetter\");\n";
     $code .= GenerateFeatureObservation($attrExt->{"MeasureAs"});
+    ### DONE
     $code .= GenerateDeprecationNotification($attrExt->{"DeprecateAs"});
+    ### DONE
     if (HasActivityLogging($forMainWorldSuffix, $attrExt, "Getter")) {
         $code .= GenerateActivityLogging("Getter", $interface, "${attrName}");
     }
     if (HasCustomGetter($attrExt)) {
+        ### DONE
         $code .= "    ${v8ClassName}::${attrName}AttrGetterCustom(name, info);\n";
     } else {
+        ### TODO
         $code .= "    ${implClassName}V8Internal::${attrName}AttrGetter${forMainWorldSuffix}(name, info);\n";
     }
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"V8\", \"Execution\");\n";
     $code .= "}\n\n";
+    ### DONE
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
 
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateNormalAttrGetter
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
+print " [GenerateNormalAttrGetter]", $attribute->type, " ", $attribute->name, "\n";
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $attrExt = $attribute->extendedAttributes;
     my $attrName = $attribute->name;
     my $attrType = $attribute->type;
 
     if (HasCustomGetter($attrExt)) {
         return;
     }
 
     AssertNotSequenceType($attrType);
     my $nativeType = GetNativeType($attribute->type, $attribute->extendedAttributes, "");
     my $svgNativeType = GetSVGTypeNeedingTearOff($interfaceName);
 
     my $conditionalString = GenerateConditionalString($attribute);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= <<END;
 static void ${attrName}AttrGetter${forMainWorldSuffix}(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
 END
+    ### First, get impl_class instance
     if ($svgNativeType) {
+        ### TODO
         my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($interfaceName);
         if ($svgWrappedNativeType =~ /List/) {
             $code .= <<END;
     $svgNativeType* imp = ${v8ClassName}::toNative(info.Holder());
 END
         } else {
             $code .= <<END;
     $svgNativeType* wrapper = ${v8ClassName}::toNative(info.Holder());
     $svgWrappedNativeType& impInstance = wrapper->propertyReference();
     $svgWrappedNativeType* imp = &impInstance;
 END
         }
     } elsif ($attrExt->{"OnProto"} || $attrExt->{"Unforgeable"}) {
+        ### TODO
         if ($interfaceName eq "Window") {
             $code .= <<END;
     v8::Handle<v8::Object> holder = info.Holder();
 END
         } else {
             # perform lookup first
             $code .= <<END;
     v8::Handle<v8::Object> holder = info.This()->FindInstanceInPrototypeChain(${v8ClassName}::GetTemplate(info.GetIsolate(), worldType(info.GetIsolate())));
     if (holder.IsEmpty())
         return;
 END
         }
         $code .= <<END;
     ${implClassName}* imp = ${v8ClassName}::toNative(holder);
 END
     } else {
+        ### DONE
         my $reflect = $attribute->extendedAttributes->{"Reflect"};
         my $url = $attribute->extendedAttributes->{"URL"};
         if ($reflect && !$url && InheritsInterface($interface, "Node") && $attrType eq "DOMString") {
             # Generate super-compact call for regular attribute getter:
             my ($functionName, @arguments) = GetterExpression($interfaceName, $attribute);
             $code .= "    Element* imp = V8Element::toNative(info.Holder());\n";
             $code .= "    v8SetReturnValueString(info, imp->${functionName}(" . join(", ", @arguments) . "), info.GetIsolate());\n";
             $code .= "    return;\n";
             $code .= "}\n\n";
             $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
             $implementation{nameSpaceInternal}->add($code);
             return;
             # Skip the rest of the function!
         }
         if ($attribute->type eq "SerializedScriptValue" && $attrExt->{"CachedAttribute"}) {
             $code .= <<END;
     v8::Handle<v8::String> propertyName = v8::String::NewSymbol("${attrName}");
     v8::Handle<v8::Value> value = info.Holder()->GetHiddenValue(propertyName);
     if (!value.IsEmpty()) {
         v8SetReturnValue(info, value);
         return;
     }
 END
         }
         if (!$attribute->isStatic) {
+            ### generally this is taken.
             $code .= <<END;
     ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
 END
         }
     }
 
+    ### DONE
     # Generate security checks if necessary
     if ($attribute->extendedAttributes->{"CheckSecurityForNode"}) {
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(imp->" . GetImplName($attribute) . "())) {\n";
         $code .= "        v8SetReturnValueNull(info);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
 
     my $useExceptions = 1 if $attribute->extendedAttributes->{"GetterRaisesException"} ||  $attribute->extendedAttributes->{"RaisesException"};
@@ skipping 28 matching lines @@
     $code .= $subCode;
     unshift(@arguments, @$arg);
     $getterString = "${functionName}(" . join(", ", @arguments) . ")";
 
     my $expression;
     if ($attribute->type eq "EventHandler" && $interface->name eq "Window") {
         $code .= "    if (!imp->document())\n";
         $code .= "        return;\n";
     }
 
+    ### TODO: always use intermediate variable v!
     if ($useExceptions || $isNullable) {
         if ($nativeType =~ /^V8StringResource/) {
+            ### is it necessary???
             $code .= "    " . ConvertToV8StringResource($attribute, $nativeType, "v", $getterString) . ";\n";
         } else {
+            # Done
             $code .= "    $nativeType v = $getterString;\n";
         }
 
+        ### DONE
         if ($isNullable) {
             $code .= "    if (isNull) {\n";
             $code .= "        v8SetReturnValueNull(info);\n";
             $code .= "        return;\n";
             $code .= "    }\n";
         }
 
         if ($useExceptions) {
+            ### DONE
             if ($useExceptions) {
                 $code .= "    if (UNLIKELY(es.throwIfNeeded()))\n";
                 $code .= "        return;\n";
             }
 
             if (ExtendedAttributeContains($attribute->extendedAttributes->{"CallWith"}, "ScriptState")) {
+                ### TODO
                 $code .= "    if (state.hadException()) {\n";
                 $code .= "        throwError(state.exception());\n";
                 $code .= "        return;\n";
                 $code .= "    }\n";
             }
         }
 
+        ## getter_expression in python
         $expression = "v";
         $expression .= ".release()" if (IsRefPtrType($returnType));
     } else {
         # Can inline the function call into the return statement to avoid overhead of using a Ref<> temporary
         $expression = $getterString;
         # Fix amigious conversion problem, by casting to the base type first ($getterString returns a type that inherits from SVGAnimatedEnumeration, not the base class directly).
         $expression = "static_pointer_cast<SVGAnimatedEnumeration>($expression)" if $returnType eq "SVGAnimatedEnumeration";
     }
 
+#    print "[BAR] ", $expression, "\n" if $interface->name eq "WebKitSourceBuffer";
+    ### FIXME: remove this special case!
     if (ShouldKeepAttributeAlive($interface, $attribute, $returnType)) {
+        ### DONE
         my $arrayType = GetArrayType($returnType);
         if ($arrayType) {
             AddIncludeForType("V8$arrayType.h");
             $code .= "    v8SetReturnValue(info, v8Array(${getterString}, info.GetIsolate()));\n";
             $code .= "    return;\n";
             $code .= "}\n\n";
             $implementation{nameSpaceInternal}->add($code);
             return;
         }
 
         AddIncludesForType($returnType);
         AddToImplIncludes("bindings/v8/V8HiddenPropertyName.h");
         # Check for a wrapper in the wrapper cache. If there is one, we know that a hidden reference has already
         # been created. If we don't find a wrapper, we create both a wrapper and a hidden reference.
         my $nativeReturnType = GetNativeType($returnType);
+        # getterString is native_value_expression in python generator
         my $v8ReturnType = "V8" . $returnType;
         $code .= "    $nativeReturnType result = ${getterString};\n";
         if ($forMainWorldSuffix) {
           $code .= "    v8::Handle<v8::Value> wrapper = result.get() ? v8::Handle<v8::Value>(DOMDataStore::getWrapper${forMainWorldSuffix}<${v8ReturnType}>(result.get())) : v8Undefined();\n";
         } else {
           $code .= "    v8::Handle<v8::Value> wrapper = result.get() ? v8::Handle<v8::Value>(DOMDataStore::getWrapper<${v8ReturnType}>(result.get(), info.GetIsolate())) : v8Undefined();\n";
         }
         $code .= "    if (wrapper.IsEmpty()) {\n";
         $code .= "        wrapper = toV8(result.get(), info.Holder(), info.GetIsolate());\n"; # FIXME: Could use wrap here since the wrapper is empty.
         $code .= "        if (!wrapper.IsEmpty())\n";
         $code .= "            V8HiddenPropertyName::setNamedHiddenReference(info.Holder(), \"${attrName}\", wrapper);\n";
         $code .= "    }\n";
         $code .= "    v8SetReturnValue(info, wrapper);\n";
         $code .= "    return;\n";
         $code .= "}\n\n";
         $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
         $implementation{nameSpaceInternal}->add($code);
         return;
     }
 
     if ((IsSVGAnimatedType($interfaceName) or $interfaceName eq "SVGViewSpec") and IsSVGTypeNeedingTearOff($attrType)) {
+        ### DONE
         AddToImplIncludes("V8$attrType.h");
         my $svgNativeType = GetSVGTypeNeedingTearOff($attrType);
         # Convert from abstract SVGProperty to real type, so the right toJS() method can be invoked.
         if ($forMainWorldSuffix eq "ForMainWorld") {
             $code .= "    v8SetReturnValue(info, toV8ForMainWorld(static_cast<$svgNativeType*>($expression), info.Holder(), info.GetIsolate()));\n";
         } else {
             $code .= "    v8SetReturnValue(info, toV8Fast(static_cast<$svgNativeType*>($expression), info, imp));\n";
         }
         $code .= "    return;\n";
     } elsif (IsSVGTypeNeedingTearOff($attrType) and not $interfaceName =~ /List$/) {
+        ### DONE
         AddToImplIncludes("V8$attrType.h");
         AddToImplIncludes("core/svg/properties/SVGPropertyTearOff.h");
         my $tearOffType = GetSVGTypeNeedingTearOff($attrType);
         my $wrappedValue;
         if (IsSVGTypeWithWritablePropertiesNeedingTearOff($attrType) and not defined $attribute->extendedAttributes->{"Immutable"}) {
             my $getter = $expression;
             $getter =~ s/imp->//;
             $getter =~ s/\(\)//;
 
             my $updateMethod = "&${implClassName}::update" . FirstLetterToUpperCase($getter);
@@ skipping 17 matching lines @@
         } else {
                 $wrappedValue = "WTF::getPtr(${tearOffType}::create($expression))";
         }
         if ($forMainWorldSuffix eq "ForMainWorld") {
             $code .= "    v8SetReturnValue(info, toV8ForMainWorld($wrappedValue, info.Holder(), info.GetIsolate()));\n";
         } else {
             $code .= "    v8SetReturnValue(info, toV8Fast($wrappedValue, info, imp));\n";
         }
         $code .= "    return;\n";
     } elsif ($attribute->type eq "SerializedScriptValue" && $attrExt->{"CachedAttribute"}) {
+        ### DONE
         my $getterFunc = ToMethodName($attribute->name);
         $code .= <<END;
     RefPtr<SerializedScriptValue> serialized = imp->${getterFunc}();
     value = serialized ? serialized->deserialize() : v8::Handle<v8::Value>(v8::Null(info.GetIsolate()));
     info.Holder()->SetHiddenValue(propertyName, value);
     v8SetReturnValue(info, value);
     return;
 END
     } elsif ($attribute->type eq "EventHandler") {
+        ### DONE
         AddToImplIncludes("bindings/v8/V8AbstractEventListener.h");
         my $getterFunc = ToMethodName($attribute->name);
         # FIXME: Pass the main world ID for main-world-only getters.
         $code .= "    EventListener* listener = imp->${getterFunc}(isolatedWorldForIsolate(info.GetIsolate()));\n";
         $code .= "    v8SetReturnValue(info, listener ? v8::Handle<v8::Value>(V8AbstractEventListener::cast(listener)->getListenerObject(imp->scriptExecutionContext())) : v8::Handle<v8::Value>(v8::Null(info.GetIsolate())));\n";
         $code .= "    return;\n";
     } else {
+        ### main
         my $nativeValue = NativeToJSValue($attribute->type, $attribute->extendedAttributes, $expression, "    ", "", "info.Holder()", "info.GetIsolate()", "info", "imp", $forMainWorldSuffix, "return");
         $code .= "${nativeValue}\n";
         $code .= "    return;\n";
     }
 
     $code .= "}\n\n";  # end of getter
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
@@ skipping 21 matching lines @@
     # depending on the attribute name.
     return 0 if $attrName eq "self";
 
     # FIXME: Remove these hard-coded hacks.
     return 0 if $returnType eq "EventTarget";
     return 0 if $returnType eq "SerializedScriptValue";
     return 0 if $returnType eq "Window";
     return 0 if $returnType =~ /SVG/;
     return 0 if $returnType =~ /HTML/;
 
+#    print "[FOO] ", $returnType, "\n";
     return 1;
 }
 
+### TODO
 sub GenerateReplaceableAttrSetterCallback
 {
     my $interface = shift;
     my $implClassName = GetImplName($interface);
 
     my $code = "";
     $code .= "static void ${implClassName}ReplaceableAttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)\n";
     $code .= "{\n";
     $code .= GenerateFeatureObservation($interface->extendedAttributes->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($interface->extendedAttributes->{"DeprecateAs"});
@@ skipping 29 matching lines @@
     }
 
     $code .= <<END;
     info.This()->ForceSet(name, value);
 }
 
 END
     $implementation{nameSpaceInternal}->add($code);
 }
 
+### DONE ... macro custom_element_invocation in python
 sub GenerateCustomElementInvocationScopeIfNeeded
 {
     my $code = "";
     my $ext = shift;
     my $annotation = $ext->{"CustomElementCallbacks"} || "";
 
     if ($annotation eq "None") {
         # Explicit CustomElementCallbacks=None overrides any other
         # heuristic.
         return $code;
@@ skipping 14 matching lines @@
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $attrExt = $attribute->extendedAttributes;
     my $attrName = $attribute->name;
 
     my $conditionalString = GenerateConditionalString($attribute);
     my $code = "";
+    ### DONE
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
 
     $code .= "static void ${attrName}AttrSetterCallback${forMainWorldSuffix}(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)\n";
     $code .= "{\n";
+    ### DONE
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"Blink\", \"DOMSetter\");\n";
+    ### DONE
     $code .= GenerateFeatureObservation($attrExt->{"MeasureAs"});
+    ### DONE
     $code .= GenerateDeprecationNotification($attrExt->{"DeprecateAs"});
+    ### DONE
     if (HasActivityLogging($forMainWorldSuffix, $attrExt, "Setter")) {
         $code .= GenerateActivityLogging("Setter", $interface, "${attrName}");
     }
+    ### DONE
     $code .= GenerateCustomElementInvocationScopeIfNeeded($attrExt);
     if (HasCustomSetter($attrExt)) {
+        ### DONE
         $code .= "    ${v8ClassName}::${attrName}AttrSetterCustom(name, value, info);\n";
     } else {
+        ### DONE
         $code .= "    ${implClassName}V8Internal::${attrName}AttrSetter${forMainWorldSuffix}(name, value, info);\n";
     }
+    ### DONE
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"V8\", \"Execution\");\n";
     $code .= "}\n\n";
+    ### DONE
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
 sub GenerateNormalAttrSetter
 {
     my $attribute = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
@@ skipping 12 matching lines @@
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= "static void ${attrName}AttrSetter${forMainWorldSuffix}(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info)\n";
     $code .= "{\n";
 
     # If the "StrictTypeChecking" extended attribute is present, and the attribute's type is an
     # interface type, then if the incoming value does not implement that interface, a TypeError is
     # thrown rather than silently passing NULL to the C++ code.
     # Per the Web IDL and ECMAScript specifications, incoming values can always be converted to both
     # strings and numbers, so do not throw TypeError if the attribute is of these types.
+    ### TODO
     if ($attribute->extendedAttributes->{"StrictTypeChecking"}) {
         my $argType = $attribute->type;
         if (IsWrapperType($argType)) {
             $code .= "    if (!isUndefinedOrNull(value) && !V8${argType}::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate()))) {\n";
             $code .= "        throwTypeError(info.GetIsolate());\n";
             $code .= "        return;\n";
             $code .= "    }\n";
         }
     }
 
     my $svgNativeType = GetSVGTypeNeedingTearOff($interfaceName);
     if ($svgNativeType) {
+        ### TODO
         my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($interfaceName);
         if ($svgWrappedNativeType =~ /List$/) {
             $code .= <<END;
     $svgNativeType* imp = ${v8ClassName}::toNative(info.Holder());
 END
         } else {
             AddToImplIncludes("bindings/v8/ExceptionState.h");
             $code .= "    $svgNativeType* wrapper = ${v8ClassName}::toNative(info.Holder());\n";
             $code .= "    if (wrapper->isReadOnly()) {\n";
             $code .= "        setDOMException(NoModificationAllowedError, info.GetIsolate());\n";
             $code .= "        return;\n";
             $code .= "    }\n";
             $code .= "    $svgWrappedNativeType& impInstance = wrapper->propertyReference();\n";
             $code .= "    $svgWrappedNativeType* imp = &impInstance;\n";
         }
     } elsif ($attrExt->{"OnProto"}) {
+        ### TODO
         $code .= <<END;
     ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
 END
     } else {
+        ### main path
         my $reflect = $attribute->extendedAttributes->{"Reflect"};
         if ($reflect && InheritsInterface($interface, "Node") && $attrType eq "DOMString") {
             # Generate super-compact call for regular attribute setter:
             my $contentAttributeName = $reflect eq "VALUE_IS_MISSING" ? lc $attrName : $reflect;
             my $namespace = NamespaceForAttributeName($interfaceName, $contentAttributeName);
             AddToImplIncludes("${namespace}.h");
             $code .= "    Element* imp = V8Element::toNative(info.Holder());\n";
             $code .= "    V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, stringResource, value);\n";
             $code .= "    imp->setAttribute(${namespace}::${contentAttributeName}Attr, stringResource);\n";
             $code .= "}\n\n";
             $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
             $implementation{nameSpaceInternal}->add($code);
             return;
             # Skip the rest of the function!
         }
 
         if (!$attribute->isStatic) {
             $code .= <<END;
     ${implClassName}* imp = ${v8ClassName}::toNative(info.Holder());
 END
         }
     }
 
     my $nativeType = GetNativeType($attribute->type, $attribute->extendedAttributes, "parameter");
     if ($attribute->type eq "EventHandler") {
+        ### DONE
         if ($interface->name eq "Window") {
             $code .= "    if (!imp->document())\n";
             $code .= "        return;\n";
         }
     } else {
+        ### DONE
         $code .= JSValueToNativeStatement($attribute->type, $attribute->extendedAttributes, "value", "v", "    ", "info.GetIsolate()");
     }
 
+    ### TODO
     if (IsEnumType($attrType)) {
         # setter ignores invalid enumeration values
         my @enumValues = ValidEnumValues($attrType);
         my @validEqualities = ();
         foreach my $enumValue (@enumValues) {
             push(@validEqualities, "string == \"$enumValue\"");
         }
         my $enumValidationExpression = join(" || ", @validEqualities);
         $code .= <<END;
     String string = v;
@@ skipping 126 matching lines @@
 
         $parameterIndex++;
     }
     my $res = join(" && ", @andExpression);
     $res = "($res)" if @andExpression > 1;
     return $res;
 }
 
 # As per Web IDL specification, the length of a function Object is
 # its number of mandatory parameters.
+### get_function_mandatory_parameters in python generator
 sub GetFunctionLength
 {
     my $function = shift;
 
     my $numMandatoryParams = 0;
     foreach my $parameter (@{$function->parameters}) {
         # Abort as soon as we find the first optional parameter as no mandatory
         # parameter can follow an optional one.
         last if $parameter->isOptional;
         $numMandatoryParams++;
@@ skipping 19 matching lines @@
             last;
         }
         $numParameters++;
     }
     if (!$hasVariadic) {
         push(@orExpression, GenerateParametersCheckExpression($numParameters, $function));
     }
     return ($numMandatoryParams, join(" || ", @orExpression));
 }
 
+### TODO
 sub GenerateOverloadedFunction
 {
     my $function = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     # Generate code for choosing the correct overload to call. Overloads are
     # chosen based on the total number of arguments passed and the type of
     # values passed in non-primitive argument slots. When more than a single
     # overload is applicable, precedence is given according to the order of
@@ skipping 50 matching lines @@
     }
 
     my $conditionalString = GenerateConditionalString($function);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= <<END;
 static void ${name}MethodCallback${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
 END
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"Blink\", \"DOMMethod\");\n";
+    ### DONE
     $code .= GenerateFeatureObservation($function->extendedAttributes->{"MeasureAs"});
+    ### DONE
     $code .= GenerateDeprecationNotification($function->extendedAttributes->{"DeprecateAs"});
+    ### DONE
     if (HasActivityLogging($forMainWorldSuffix, $function->extendedAttributes, "Access")) {
         $code .= GenerateActivityLogging("Method", $interface, "${name}");
     }
     if (HasCustomMethod($function->extendedAttributes)) {
         $code .= "    ${v8ClassName}::${name}MethodCustom(args);\n";
     } else {
         $code .= "    ${implClassName}V8Internal::${name}Method${forMainWorldSuffix}(args);\n";
     }
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"V8\", \"Execution\");\n";
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
+### __FUNC__
 sub GenerateFunction
 {
+    print " [GenerateFunction]\n";
     my $function = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $name = $function->name;
     my $implName = GetImplName($function);
     my $funcExt = $function->extendedAttributes;
 
     if (HasCustomMethod($funcExt) || $name eq "") {
         return;
     }
 
     if (@{$function->{overloads}} > 1) {
         # Append a number to an overloaded method's name to make it unique:
         $name = $name . $function->{overloadIndex};
     }
 
     my $conditionalString = GenerateConditionalString($function);
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= "static void ${name}Method${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& args)\n";
     $code .= "{\n";
 
     if ($name eq "addEventListener" || $name eq "removeEventListener") {
+        ### TODO
         my $lookupType = ($name eq "addEventListener") ? "OrCreate" : "Only";
         my $passRefPtrHandling = ($name eq "addEventListener") ? "" : ".get()";
         my $hiddenDependencyAction = ($name eq "addEventListener") ? "create" : "remove";
 
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         AddToImplIncludes("bindings/v8/V8EventListenerList.h");
         AddToImplIncludes("core/page/DOMWindow.h");
         $code .= <<END;
     EventTarget* impl = ${v8ClassName}::toNative(args.Holder());
     if (DOMWindow* window = impl->toDOMWindow()) {
@@ skipping 12 matching lines @@
             ${hiddenDependencyAction}HiddenDependency(args.Holder(), args[1], ${v8ClassName}::eventListenerCacheIndex, args.GetIsolate());
     }
 }
 
 END
         $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
         $implementation{nameSpaceInternal}->add($code);
         return;
     }
 
+    ### DONE
     $code .= GenerateArgumentsCountCheck($function, $interface);
 
     if ($name eq "set" and IsConstructorTemplate($interface, "TypedArray")) {
+        ### TODO
         AddToImplIncludes("bindings/v8/custom/V8ArrayBufferViewCustom.h");
         $code .= <<END;
     setWebGLArrayHelper<$implClassName, ${v8ClassName}>(args);
 }
 
 END
         $implementation{nameSpaceInternal}->add($code);
         return;
     }
 
+    ### TODO
     my ($svgPropertyType, $svgListPropertyType, $svgNativeType) = GetSVGPropertyTypes($interfaceName);
 
+    ### TODO
     if ($svgNativeType) {
         my $nativeClassName = GetNativeType($interfaceName);
         if ($interfaceName =~ /List$/) {
             $code .= "    $nativeClassName imp = ${v8ClassName}::toNative(args.Holder());\n";
         } else {
             AddToImplIncludes("bindings/v8/ExceptionState.h");
             AddToImplIncludes("core/dom/ExceptionCode.h");
             $code .= "    $nativeClassName wrapper = ${v8ClassName}::toNative(args.Holder());\n";
             $code .= "    if (wrapper->isReadOnly()) {\n";
             $code .= "        setDOMException(NoModificationAllowedError, args.GetIsolate());\n";
             $code .= "        return;\n";
             $code .= "    }\n";
             my $svgWrappedNativeType = GetSVGWrappedTypeNeedingTearOff($interfaceName);
             $code .= "    $svgWrappedNativeType& impInstance = wrapper->propertyReference();\n";
             $code .= "    $svgWrappedNativeType* imp = &impInstance;\n";
         }
     } elsif (!$function->isStatic) {
+        ### main
         $code .= <<END;
     ${implClassName}* imp = ${v8ClassName}::toNative(args.Holder());
 END
     }
 
+    ### TODO
     $code .= GenerateCustomElementInvocationScopeIfNeeded($funcExt);
 
     # Check domain security if needed
+    ### TODO
     if ($interface->extendedAttributes->{"CheckSecurity"} && !$function->extendedAttributes->{"DoNotCheckSecurity"}) {
         # We have not find real use cases yet.
         AddToImplIncludes("core/page/Frame.h");
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= <<END;
     if (!BindingSecurity::shouldAllowAccessToFrame(imp->frame()))
         return;
 END
     }
 
+    ### DONE
     my $raisesExceptions = $function->extendedAttributes->{"RaisesException"};
     if (!$raisesExceptions) {
         foreach my $parameter (@{$function->parameters}) {
             if ($parameter->extendedAttributes->{"IsIndex"}) {
                 $raisesExceptions = 1;
             }
         }
     }
 
+    ### DONE
     if ($raisesExceptions) {
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         $code .= "    ExceptionState es(args.GetIsolate());\n";
     }
 
+    ### TODO
     if ($function->extendedAttributes->{"CheckSecurityForNode"}) {
         AddToImplIncludes("bindings/v8/BindingSecurity.h");
         $code .= "    if (!BindingSecurity::shouldAllowAccessToNode(imp->" . GetImplName($function) . "(es))) {\n";
         $code .= "        v8SetReturnValueNull(args);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
 END
     }
 
+    ### main DONE
+    print " [GenerateParametersCheck]\n";
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface, $forMainWorldSuffix);
     $code .= $parameterCheckString;
 
     # Build the function call string.
+    ### TODO
+    ### main
+    if($paramIndex != @{$function->parameters}) {
+        ## Never
+    }
     $code .= GenerateFunctionCallString($function, $paramIndex, "    ", $interface, $forMainWorldSuffix, %replacements);
     $code .= "}\n\n";
     $code .= "#endif // ${conditionalString}\n\n" if $conditionalString;
     $implementation{nameSpaceInternal}->add($code);
 }
 
+### get_call_with_parameter and call_with_statements macro in python
+### DONE
 sub GenerateCallWith
 {
     my $callWith = shift;
     return ([], "") unless $callWith;
     my $indent = shift;
     my $returnVoid = shift;
     my $function = shift;
     my $code = "";
 
     my @callWithArgs;
@@ skipping 16 matching lines @@
     }
     if (ExtendedAttributeContains($callWith, "ActiveWindow")) {
         push(@callWithArgs, "activeDOMWindow()");
     }
     if (ExtendedAttributeContains($callWith, "FirstWindow")) {
         push(@callWithArgs, "firstDOMWindow()");
     }
     return ([@callWithArgs], $code);
 }
 
+### no corresponds function in python generator. write in template.
 sub GenerateArgumentsCountCheck
 {
     my $function = shift;
     my $interface = shift;
 
     my $numMandatoryParams = 0;
     my $allowNonOptional = 1;
     foreach my $param (@{$function->parameters}) {
         if ($param->isOptional or $param->isVariadic) {
             $allowNonOptional = 0;
         } else {
             die "An argument must not be declared to be optional unless all subsequent arguments to the operation are also optional." if !$allowNonOptional;
             $numMandatoryParams++;
         }
     }
 
     my $argumentsCountCheckString = "";
     if ($numMandatoryParams >= 1) {
         $argumentsCountCheckString .= "    if (args.Length() < $numMandatoryParams) {\n";
         $argumentsCountCheckString .= "        throwNotEnoughArgumentsError(args.GetIsolate());\n";
         $argumentsCountCheckString .= "        return;\n";
         $argumentsCountCheckString .= "    }\n";
     }
     return $argumentsCountCheckString;
 }
 
+### see macro.template
 sub GenerateParametersCheck
 {
     my $function = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
     my $style = shift || "new";
 
     my $parameterCheckString = "";
     my $paramIndex = 0;
     my %replacements = ();
 
     foreach my $parameter (@{$function->parameters}) {
         my $nativeType = GetNativeType($parameter->type, $parameter->extendedAttributes, "parameter");
 
         # Optional arguments without [Default=...] should generate an early call with fewer arguments.
         # Optional arguments with [Optional=...] should not generate the early call.
         # Optional Dictionary arguments always considered to have default of empty dictionary.
+        ### DONE  early_call in python
         if ($parameter->isOptional && !$parameter->extendedAttributes->{"Default"} && $nativeType ne "Dictionary" && !IsCallbackInterface($parameter->type)) {
             $parameterCheckString .= "    if (args.Length() <= $paramIndex)";
             my $functionCall = GenerateFunctionCallString($function, $paramIndex, "    " x 2, $interface, $forMainWorldSuffix, %replacements);
-            my $multiLine = ($functionCall =~ tr/\n//) > 1;
+            my $multiLine = ($functionCall =~ tr/\n//) > 1; # always true
             $parameterCheckString .= $multiLine ? " {\n" : "\n";
             $parameterCheckString .= $functionCall;
             $parameterCheckString .= $multiLine ? "    }\n" : "\n";
         }
 
         my $parameterName = $parameter->name;
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         if (IsCallbackInterface($parameter->type)) {
             my $v8ClassName = "V8" . $parameter->type;
             AddToImplIncludes("$v8ClassName.h");
             if ($parameter->isOptional) {
+                ### DONE
                 $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName;\n";
                 $parameterCheckString .= "    if (args.Length() > $paramIndex && !args[$paramIndex]->IsNull() && !args[$paramIndex]->IsUndefined()) {\n";
                 $parameterCheckString .= "        if (!args[$paramIndex]->IsFunction()) {\n";
                 $parameterCheckString .= "            throwTypeError(args.GetIsolate());\n";
                 $parameterCheckString .= "            return;\n";
                 $parameterCheckString .= "        }\n";
                 $parameterCheckString .= "        $parameterName = ${v8ClassName}::create(args[$paramIndex], getScriptExecutionContext());\n";
                 $parameterCheckString .= "    }\n";
             } else {
+                ### was DONE ?
                 $parameterCheckString .= "    if (args.Length() <= $paramIndex || ";
                 if ($parameter->isNullable) {
                     $parameterCheckString .= "!(args[$paramIndex]->IsFunction() || args[$paramIndex]->IsNull())";
                 } else {
                     $parameterCheckString .= "!args[$paramIndex]->IsFunction()";
                 }
                 $parameterCheckString .= ") {\n";
                 $parameterCheckString .= "        throwTypeError(args.GetIsolate());\n";
                 $parameterCheckString .= "        return;\n";
                 $parameterCheckString .= "    }\n";
                 $parameterCheckString .= "    RefPtr<" . $parameter->type . "> $parameterName = ";
                 $parameterCheckString .= "args[$paramIndex]->IsNull() ? 0 : " if $parameter->isNullable;
                 $parameterCheckString .= "${v8ClassName}::create(args[$paramIndex], getScriptExecutionContext());\n";
             }
         } elsif ($parameter->extendedAttributes->{"Clamp"}) {
+                ### DONE
                 my $nativeValue = "${parameterName}NativeValue";
                 my $paramType = $parameter->type;
                 $parameterCheckString .= "    $paramType $parameterName = 0;\n";
                 $parameterCheckString .= "    V8TRYCATCH_VOID(double, $nativeValue, args[$paramIndex]->NumberValue());\n";
                 $parameterCheckString .= "    if (!std::isnan($nativeValue))\n";
                 $parameterCheckString .= "        $parameterName = clampTo<$paramType>($nativeValue);\n";
         } elsif ($parameter->type eq "SerializedScriptValue") {
+            ### DONE
             AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
             $parameterCheckString .= "    bool ${parameterName}DidThrow = false;\n";
             $parameterCheckString .= "    $nativeType $parameterName = SerializedScriptValue::create(args[$paramIndex], 0, 0, ${parameterName}DidThrow, args.GetIsolate());\n";
             $parameterCheckString .= "    if (${parameterName}DidThrow)\n";
             $parameterCheckString .= "        return;\n";
         } elsif ($parameter->isVariadic) {
+            ### DONE
             my $nativeElementType = GetNativeType($parameter->type);
             if ($nativeElementType =~ />$/) {
-                $nativeElementType .= " ";
+                $nativeElementType .= " "; # TODO
             }
 
             my $argType = $parameter->type;
             if (IsWrapperType($argType)) {
                 $parameterCheckString .= "    Vector<$nativeElementType> $parameterName;\n";
                 $parameterCheckString .= "    for (int i = $paramIndex; i < args.Length(); ++i) {\n";
                 $parameterCheckString .= "        if (!V8${argType}::HasInstance(args[i], args.GetIsolate(), worldType(args.GetIsolate()))) {\n";
                 $parameterCheckString .= "            throwTypeError(args.GetIsolate());\n";
                 $parameterCheckString .= "            return;\n";
                 $parameterCheckString .= "        }\n";
                 $parameterCheckString .= "        $parameterName.append(V8${argType}::toNative(v8::Handle<v8::Object>::Cast(args[i])));\n";
                 $parameterCheckString .= "    }\n";
             } else {
                 $parameterCheckString .= "    V8TRYCATCH_VOID(Vector<$nativeElementType>, $parameterName, toNativeArguments<$nativeElementType>(args, $paramIndex));\n";
             }
         } elsif ($nativeType =~ /^V8StringResource/) {
+            ### DONE
             my $default = defined $parameter->extendedAttributes->{"Default"} ? $parameter->extendedAttributes->{"Default"} : "";
             my $jsValue = $parameter->isOptional && $default eq "NullString" ? "argumentOrNull(args, $paramIndex)" : "args[$paramIndex]";
             $parameterCheckString .= JSValueToNativeStatement($parameter->type, $parameter->extendedAttributes, $jsValue, $parameterName, "    ", "args.GetIsolate()");
             if (IsEnumType($parameter->type)) {
                 my @enumValues = ValidEnumValues($parameter->type);
                 my @validEqualities = ();
                 foreach my $enumValue (@enumValues) {
                     push(@validEqualities, "string == \"$enumValue\"");
                 }
                 my $enumValidationExpression = join(" || ", @validEqualities);
@@ skipping 24 matching lines @@
             my $jsValue = $parameter->isOptional && $default eq "NullString" ? "argumentOrNull(args, $paramIndex)" : "args[$paramIndex]";
             $parameterCheckString .= JSValueToNativeStatement($parameter->type, $parameter->extendedAttributes, $jsValue, $parameterName, "    ", "args.GetIsolate()");
             if ($nativeType eq 'Dictionary') {
                 $parameterCheckString .= "    if (!$parameterName.isUndefinedOrNull() && !$parameterName.isObject()) {\n";
                 $parameterCheckString .= "        throwTypeError(\"Not an object.\", args.GetIsolate());\n";
                 $parameterCheckString .= "        return;\n";
                 $parameterCheckString .= "    }\n";
             }
         }
 
+        ### DONE
         if ($parameter->extendedAttributes->{"IsIndex"}) {
             AddToImplIncludes("core/dom/ExceptionCode.h");
             $parameterCheckString .= "    if (UNLIKELY($parameterName < 0)) {\n";
             $parameterCheckString .= "        setDOMException(IndexSizeError, args.GetIsolate());\n";
             $parameterCheckString .= "        return;\n";
             $parameterCheckString .= "    }\n";
         }
 
         $paramIndex++;
     }
+    print "PARAM STRING\n", $parameterCheckString, "\n" if $interface->name eq "CanvasGradient";
+    # $paramIndex == len(parameters)
     return ($parameterCheckString, $paramIndex, %replacements);
 }
 
 sub GenerateOverloadedConstructorCallback
 {
     my $interface = shift;
     my $implClassName = GetImplName($interface);
 
     my $code = "";
     $code .= <<END;
@@ skipping 17 matching lines @@
         $code .= "    }\n";
     }
     $code .= <<END;
     throwTypeError(args.GetIsolate());
     return;
 END
     $code .= "}\n\n";
     $implementation{nameSpaceInternal}->add($code);
 }
 
+### get_single_constructor_callback_parameter in python code generator
+### DONE
 sub GenerateSingleConstructorCallback
 {
     my $interface = shift;
     my $function = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $overloadedIndexString = "";
     if ($function->overloadedIndex > 0) {
         $overloadedIndexString .= $function->overloadedIndex;
     }
 
-    my $raisesExceptions = $function->extendedAttributes->{"RaisesException"};
+    my $raisesExceptions = $function->extendedAttributes->{"RaisesException"}; ### never be true!
     if ($interface->extendedAttributes->{"ConstructorRaisesException"}) {
-        $raisesExceptions = 1;
+        $raisesExceptions = 1; ### exist
     }
     if (!$raisesExceptions) {
         foreach my $parameter (@{$function->parameters}) {
             if ($parameter->extendedAttributes->{"IsIndex"}) {
                 $raisesExceptions = 1;
+                # Never executed!
             }
         }
     }
 
     my @beforeArgumentList;
     my @afterArgumentList;
     my $code = "";
     $code .= <<END;
 static void constructor${overloadedIndexString}(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
@@ skipping 77 matching lines @@
         $leastConstructorLength = 255;
         foreach my $constructor (@constructors, @customConstructors) {
             my $constructorLength = GetFunctionLength($constructor);
             $leastConstructorLength = $constructorLength if ($constructorLength < $leastConstructorLength);
         }
     }
 
     return $leastConstructorLength;
 }
 
+### DONE
 sub GenerateConstructorCallback
 {
     my $interface = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $code = "";
     $code .= "void ${v8ClassName}::constructorCallback(const v8::FunctionCallbackInfo<v8::Value>& args)\n";
     $code .= "{\n";
     $code .= "    TRACE_EVENT_SCOPED_SAMPLING_STATE(\"Blink\", \"DOMConstructor\");\n";
+    ### DONE
     $code .= GenerateFeatureObservation($interface->extendedAttributes->{"MeasureAs"});
+    ### DONE
     $code .= GenerateDeprecationNotification($interface->extendedAttributes->{"DeprecateAs"});
+    ### DONE
     $code .= GenerateConstructorHeader();
     if (HasCustomConstructor($interface)) {
         $code .= "    ${v8ClassName}::constructorCustom(args);\n";
     } else {
         $code .= "    ${implClassName}V8Internal::constructor(args);\n";
     }
     $code .= "}\n\n";
     $implementation{nameSpaceWebCore}->add($code);
 }
 
 sub GenerateConstructor
 {
     my $interface = shift;
 
     if (@{$interface->constructors} == 1) {
+        ### DONE
         GenerateSingleConstructorCallback($interface, @{$interface->constructors}[0]);
     } else {
+        ### TODO
         foreach my $constructor (@{$interface->constructors}) {
             GenerateSingleConstructorCallback($interface, $constructor);
         }
         GenerateOverloadedConstructorCallback($interface);
     }
 }
 
 sub GenerateEventConstructor
 {
     my $interface = shift;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
 
+    ### TODO MERGE
     my @anyAttributeNames;
     my @serializableAnyAttributeNames;
     foreach my $attribute (@{$interface->attributes}) {
         if ($attribute->type eq "any") {
             push(@anyAttributeNames, $attribute->name);
             if (!$attribute->extendedAttributes->{"Unserializable"}) {
                 push(@serializableAnyAttributeNames, $attribute->name);
             }
         }
     }
 
     AddToImplIncludes("bindings/v8/Dictionary.h");
+    ### DONE
     $implementation{nameSpaceInternal}->add(<<END);
 static void constructor(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     if (args.Length() < 1) {
         throwNotEnoughArgumentsError(args.GetIsolate());
         return;
     }
 
     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, type, args[0]);
 END
@@ skipping 40 matching lines @@
         $implementation{nameSpaceInternal}->add("    }\n\n");
     }
 
     $implementation{nameSpaceInternal}->add(<<END);
     v8::Handle<v8::Object> wrapper = args.Holder();
     V8DOMWrapper::associateObjectWithWrapper<${v8ClassName}>(event.release(), &${v8ClassName}::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
     v8SetReturnValue(args, wrapper);
 }
 END
 
+    ### DONE
     my $code = "";
     $code .= <<END;
 bool fill${implClassName}Init(${implClassName}Init& eventInit, const Dictionary& options)
 {
 END
 
     if ($interface->parent) {
         my $interfaceBase = $interface->parent;
         $code .= <<END;
     if (!fill${interfaceBase}Init(eventInit, options))
         return false;
 
 END
     }
 
+    ### TODO
     foreach my $attribute (@{$interface->attributes}) {
         if ($attribute->extendedAttributes->{"InitializedByEventConstructor"}) {
             if ($attribute->type ne "any") {
                 my $attributeName = $attribute->name;
                 my $attributeImplName = GetImplName($attribute);
                 my $deprecation = $attribute->extendedAttributes->{"DeprecateAs"};
                 my $dictionaryGetter = "options.get(\"$attributeName\", eventInit.$attributeImplName)";
                 if ($attribute->extendedAttributes->{"DeprecateAs"}) {
                     $code .= "    if ($dictionaryGetter)\n";
                     $code .= "    " . GenerateDeprecationNotification($attribute->extendedAttributes->{"DeprecateAs"});
                 } else {
                     $code .= "    $dictionaryGetter;\n";
                 }
             }
         }
     }
 
     $code .= <<END;
     return true;
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 }
 
+### DONE
 sub GenerateNamedConstructor
 {
     my $function = shift;
     my $interface = shift;
 
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
+    # thif is always false here
     my $raisesExceptions = $function->extendedAttributes->{"RaisesException"};
+#    print "NEVER\n" if $raisesExceptions;
     if ($interface->extendedAttributes->{"ConstructorRaisesException"}) {
         $raisesExceptions = 1;
     }
     if (!$raisesExceptions) {
         foreach my $parameter (@{$function->parameters}) {
             if ($parameter->extendedAttributes->{"IsIndex"}) {
+                # NEVER!
+#                print "NEVER\n";
                 $raisesExceptions = 1;
             }
         }
     }
 
     my $maybeObserveFeature = GenerateFeatureObservation($function->extendedAttributes->{"MeasureAs"});
     my $maybeDeprecateFeature = GenerateDeprecationNotification($function->extendedAttributes->{"DeprecateAs"});
 
     my @beforeArgumentList;
     my @afterArgumentList;
 
     my $toActiveDOMObject = "0";
     if (InheritsExtendedAttribute($interface, "ActiveDOMObject")) {
         $toActiveDOMObject = "${v8ClassName}::toActiveDOMObject";
     }
 
     my $toEventTarget = "0";
     if (InheritsInterface($interface, "EventTarget")) {
         $toEventTarget = "${v8ClassName}::toEventTarget";
     }
+#    print "GEHEHE", $interface->name, "\n";
 
     AddToImplIncludes("core/page/Frame.h");
     $implementation{nameSpaceWebCore}->add(<<END);
 WrapperTypeInfo ${v8ClassName}Constructor::info = { ${v8ClassName}Constructor::GetTemplate, ${v8ClassName}::derefObject, $toActiveDOMObject, $toEventTarget, 0, ${v8ClassName}::installPerContextPrototypeProperties, 0, WrapperTypeObjectPrototype };
 
 END
 
     my $code = "";
     $code .= <<END;
 static void ${v8ClassName}ConstructorCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
 END
+    ### DONE
     $code .= $maybeObserveFeature if $maybeObserveFeature;
+    ### DONE
     $code .= $maybeDeprecateFeature if $maybeDeprecateFeature;
+    ### DONE
     $code .= GenerateConstructorHeader();
     AddToImplIncludes("V8Document.h");
+    ### DONE
     $code .= <<END;
     Document* document = currentDocument();
 
     // Make sure the document is added to the DOM Node map. Otherwise, the ${implClassName} instance
     // may end up being the only node in the map and get garbage-collected prematurely.
     toV8(document, args.Holder(), args.GetIsolate());
 
 END
 
+    ### DONE
     $code .= GenerateArgumentsCountCheck($function, $interface);
 
+    ### DONE
     if ($raisesExceptions) {
         AddToImplIncludes("bindings/v8/ExceptionState.h");
         $code .= "    ExceptionState es(args.GetIsolate());\n";
     }
 
+    ### DONE
     my ($parameterCheckString, $paramIndex, %replacements) = GenerateParametersCheck($function, $interface);
     $code .= $parameterCheckString;
 
+    ### DONE
     push(@beforeArgumentList, "document");
 
+    ### DONE
     if ($interface->extendedAttributes->{"ConstructorRaisesException"}) {
         push(@afterArgumentList, "es");
     }
 
+    ### DONE
     my @argumentList;
     my $index = 0;
     foreach my $parameter (@{$function->parameters}) {
         last if $index eq $paramIndex;
         if ($replacements{$parameter->name}) {
             push(@argumentList, $replacements{$parameter->name});
         } else {
             push(@argumentList, $parameter->name);
         }
         $index++;
     }
 
+    ### DONE
     my $argumentString = join(", ", @beforeArgumentList, @argumentList, @afterArgumentList);
+    ### DONE
     $code .= "\n";
     $code .= "    RefPtr<${implClassName}> impl = ${implClassName}::createForJSConstructor(${argumentString});\n";
     $code .= "    v8::Handle<v8::Object> wrapper = args.Holder();\n";
 
+    ### DONE
     if ($interface->extendedAttributes->{"ConstructorRaisesException"}) {
         $code .= "    if (es.throwIfNeeded())\n";
         $code .= "        return;\n";
     }
 
+    ### DONE
     $code .= <<END;
 
     V8DOMWrapper::associateObjectWithWrapper<${v8ClassName}>(impl.release(), &${v8ClassName}Constructor::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent);
     args.GetReturnValue().Set(wrapper);
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 
+    ### DONE
     $code = <<END;
 v8::Handle<v8::FunctionTemplate> ${v8ClassName}Constructor::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     // This is only for getting a unique pointer which we can pass to privateTemplate.
     static const char* privateTemplateUniqueKey = "${v8ClassName}Constructor::GetTemplatePrivateTemplate";
     V8PerIsolateData* data = V8PerIsolateData::from(isolate);
     v8::Handle<v8::FunctionTemplate> result = data->privateTemplateIfExists(currentWorldType, &privateTemplateUniqueKey);
     if (!result.IsEmpty())
         return result;
 
     TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink\", \"BuildDOMTemplate");
     v8::HandleScope scope(isolate);
     result = v8::FunctionTemplate::New(${v8ClassName}ConstructorCallback);
 
     v8::Local<v8::ObjectTemplate> instance = result->InstanceTemplate();
     instance->SetInternalFieldCount(${v8ClassName}::internalFieldCount);
     result->SetClassName(v8::String::NewSymbol("${implClassName}"));
     result->Inherit(${v8ClassName}::GetTemplate(isolate, currentWorldType));
     data->setPrivateTemplate(currentWorldType, &privateTemplateUniqueKey, result);
 
     return scope.Close(result);
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 }
 
+### DONE
 sub GenerateConstructorHeader
 {
     AddToImplIncludes("bindings/v8/V8ObjectConstructor.h");
     my $content = <<END;
     if (!args.IsConstructCall()) {
         throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate());
         return;
     }
 
     if (ConstructorMode::current() == ConstructorMode::WrapExistingObject) {
@@ skipping 15 matching lines @@
         my $conditionalString = GenerateConditionalString($attribute);
         my $subCode = "";
         $subCode .= "#if ${conditionalString}\n" if $conditionalString;
         $subCode .= GenerateSingleBatchedAttribute($interface, $attribute, ",", "");
         $subCode .= "#endif // ${conditionalString}\n" if $conditionalString;
         $code .= $subCode;
     }
     return $code;
 }
 
+### get_single_batched_attribute in python
 sub GenerateSingleBatchedAttribute
 {
     my $interface = shift;
     my $attribute = shift;
     my $delimiter = shift;
     my $indent = shift;
     my $code = "";
     my $attrName = $attribute->name;
     my $attrExt = $attribute->extendedAttributes;
     my $implClassName = GetImplName($interface);
@@ skipping 195 matching lines @@
         $code .= "    } else {\n";
         $code .= "        ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${implClassName}V8Internal::${name}MethodCallback, v8Undefined(), ${signature}, $functionLength)$property_attributes);\n";
         $code .= "    }\n";
     } else {
         $code .= "    ${conditional}$template->Set(v8::String::NewSymbol(\"$name\"), v8::FunctionTemplate::New(${implClassName}V8Internal::${name}MethodCallback, v8Undefined(), ${signature}, $functionLength)$property_attributes);\n";
     }
     $code .= "#endif // ${conditionalString}\n" if $conditionalString;
     return $code;
 }
 
+### DONE
+# get_is_null_expression in python
 sub GenerateIsNullExpression
 {
     my $type = shift;
     my $variableName = shift;
+    ### DONE
     if (IsUnionType($type)) {
         my $types = $type->unionMemberTypes;
         my @expression = ();
         for my $i (0 .. scalar(@$types)-1) {
             my $unionMemberType = $types->[$i];
             my $unionMemberVariable = $variableName . $i;
             my $isNull = GenerateIsNullExpression($unionMemberType, $unionMemberVariable);
             push @expression, $isNull;
         }
         return join " && ", @expression;
     }
+    ### DONE
     if (IsRefPtrType($type)) {
         return "!${variableName}";
     } elsif ($type eq "DOMString") {
         return "${variableName}.isNull()";
     } else {
         return "";
     }
 }
 
 sub GenerateIfElseStatement
@@ skipping 25 matching lines @@
 {
     my $interface = shift;
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
 
     my $indexedGetterFunction = GetIndexedGetterFunction($interface);
     if ($indexedGetterFunction) {
         my $hasCustomIndexedGetter = $indexedGetterFunction->extendedAttributes->{"Custom"};
         if (!$hasCustomIndexedGetter) {
+            ### working
             GenerateImplementationIndexedPropertyGetter($interface, $indexedGetterFunction);
         }
+        ### working
         GenerateImplementationIndexedPropertyGetterCallback($interface, $hasCustomIndexedGetter);
     }
 
+    ### TODO
     my $indexedSetterFunction = GetIndexedSetterFunction($interface);
     if ($indexedSetterFunction) {
         my $hasCustomIndexedSetter = $indexedSetterFunction->extendedAttributes->{"Custom"};
         if (!$hasCustomIndexedSetter) {
             GenerateImplementationIndexedPropertySetter($interface, $indexedSetterFunction);
         }
         GenerateImplementationIndexedPropertySetterCallback($interface, $hasCustomIndexedSetter);
     }
 
+    ### TODO
     my $indexedDeleterFunction = GetIndexedDeleterFunction($interface);
     if ($indexedDeleterFunction) {
         my $hasCustomIndexedDeleter = $indexedDeleterFunction->extendedAttributes->{"Custom"};
         if (!$hasCustomIndexedDeleter) {
             GenerateImplementationIndexedPropertyDeleter($interface, $indexedDeleterFunction);
         }
         GenerateImplementationIndexedPropertyDeleterCallback($interface, $hasCustomIndexedDeleter);
     }
 
+    ### DONE
     my $indexedEnumeratorFunction = $indexedGetterFunction;
     $indexedEnumeratorFunction = 0 if $indexedGetterFunction && $indexedGetterFunction->extendedAttributes->{"NotEnumerable"};
 
+    ### DONE
     my $indexedQueryFunction = 0;
     # If there is an enumerator, there MUST be a query method to properly communicate property attributes.
     my $hasQuery = $indexedQueryFunction || $indexedEnumeratorFunction;
 
+    ### DONE
     my $setOn = "Instance";
 
     # V8 has access-check callback API (see ObjectTemplate::SetAccessCheckCallbacks) and it's used on Window
     # instead of deleters or enumerators. In addition, the getter should be set on prototype template, to
     # get implementation straight out of the Window prototype regardless of what prototype is actually set
     # on the object.
     if ($interfaceName eq "Window") {
         $setOn = "Prototype";
     }
 
+    ### DONE
     my $code = "";
     if ($indexedGetterFunction || $indexedSetterFunction || $indexedDeleterFunction || $indexedEnumeratorFunction || $hasQuery) {
         $code .= "    desc->${setOn}Template()->SetIndexedPropertyHandler(${implClassName}V8Internal::indexedPropertyGetterCallback";
         $code .= $indexedSetterFunction ? ", ${implClassName}V8Internal::indexedPropertySetterCallback" : ", 0";
         $code .= ", 0"; # IndexedPropertyQuery -- not being used at the moment.
         $code .= $indexedDeleterFunction ? ", ${implClassName}V8Internal::indexedPropertyDeleterCallback" : ", 0";
         $code .= $indexedEnumeratorFunction ? ", indexedPropertyEnumerator<${implClassName}>" : ", 0";
         $code .= ");\n";
     }
 
     return $code;
 }
 
 sub GenerateImplementationIndexedPropertyGetter
 {
     my $interface = shift;
     my $indexedGetterFunction = shift;
     my $implClassName = GetImplName($interface);
     my $v8ClassName = GetV8ClassName($interface);
     my $methodName = GetImplName($indexedGetterFunction);
 
     my $returnType = $indexedGetterFunction->type;
     my $nativeType = GetNativeType($returnType);
     my $nativeValue = "element";
     $nativeValue .= ".release()" if (IsRefPtrType($returnType));
+    ### DONE
     my $isNull = GenerateIsNullExpression($returnType, "element");
+    ### DONE
     my $returnJSValueCode = NativeToJSValue($indexedGetterFunction->type, $indexedGetterFunction->extendedAttributes, $nativeValue, "    ", "", "info.Holder()", "info.GetIsolate()", "info", "collection", "", "return");
     my $raisesExceptions = $indexedGetterFunction->extendedAttributes->{"RaisesException"};
+    ### DONE
     my $methodCallCode = GenerateMethodCall($returnType, "element", "collection->${methodName}", "index", $raisesExceptions);
+    ### DONE
     my $getterCode = "static void indexedPropertyGetter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info)\n";
     $getterCode .= "{\n";
     $getterCode .= "    ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));\n";
     $getterCode .= "    ${implClassName}* collection = ${v8ClassName}::toNative(info.Holder());\n";
+    ### DONE
     if ($raisesExceptions) {
         $getterCode .= "    ExceptionState es(info.GetIsolate());\n";
     }
+    ### DONE but use function_call later
     $getterCode .= $methodCallCode . "\n";
+    ### DONE
     if ($raisesExceptions) {
         $getterCode .= "    if (es.throwIfNeeded())\n";
         $getterCode .= "        return;\n";
     }
     if (IsUnionType($returnType)) {
+        ### TDOO
         $getterCode .= "${returnJSValueCode}\n";
         $getterCode .= "    return;\n";
     } else {
+        ### DONE
         $getterCode .= "    if (${isNull})\n";
         $getterCode .= "        return;\n";
         $getterCode .= $returnJSValueCode . "\n";
     }
     $getterCode .= "}\n\n";
     $implementation{nameSpaceInternal}->add($getterCode);
 }
 
 sub GenerateImplementationIndexedPropertyGetterCallback
 {
@@ skipping 82 matching lines @@
     if ($treatNullAs && $treatNullAs ne "NullString") {
         push @conditions, "value->IsNull()";
         push @statements, "collection->${treatNullAs}(index$extraArguments);";
     }
     if ($treatUndefinedAs && $treatUndefinedAs ne "NullString") {
         push @conditions, "value->IsUndefined()";
         push @statements, "collection->${treatUndefinedAs}(index$extraArguments);";
     }
     push @conditions, "";
     push @statements, "collection->${methodName}(index, propertyValue$extraArguments);";
+    # TODO
     $code .= GenerateIfElseStatement("bool", "result", \@conditions, \@statements);
 
     $code .= "    if (!result)\n";
     $code .= "        return;\n";
     if ($raisesExceptions) {
         $code .= "    if (es.throwIfNeeded())\n";
         $code .= "        return;\n";
     }
     $code .= "    v8SetReturnValue(info, value);\n";
     $code .= "}\n\n";
@@ skipping 163 matching lines @@
     if ($hasCustom) {
         $code .= "    ${v8ClassName}::namedPropertyQueryCustom(name, info);\n";
     } else {
         $code .= "    ${implClassName}V8Internal::namedPropertyQuery(name, info);\n";
     }
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"V8\", \"Execution\");\n";
     $code .= "}\n\n";
     $implementation{nameSpaceInternal}->add($code);
 }
 
+### TODO: use js_value_to_native
+### get_function_call_statements in python
 sub GenerateMethodCall
 {
     my $returnType = shift; # string or UnionType
     my $returnName = shift;
     my $functionExpression = shift;
     my $firstArgument = shift;
     my $raisesExceptions = shift;
 
     my @arguments = ();
     push @arguments, $firstArgument;
@@ skipping 226 matching lines @@
     if (es.throwIfNeeded())
         return;
     if (!result)
         return;
     v8SetReturnValueInt(info, v8::None);
 }
 
 END
 }
 
+### TODO 7/16
 sub GenerateImplementationLegacyCall
 {
     my $interface = shift;
     my $code = "";
 
     my $v8ClassName = GetV8ClassName($interface);
 
     if ($interface->extendedAttributes->{"CustomLegacyCall"}) {
         $code .= "    desc->InstanceTemplate()->SetCallAsFunctionHandler(${v8ClassName}::legacyCallCustom);\n";
     }
     return $code;
 }
 
 sub GenerateImplementationMasqueradesAsUndefined
 {
     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 13 matching lines @@
     my $parentClass = "";
     my $parentClassTemplate = "";
     if ($interface->parent) {
         my $parent = $interface->parent;
         AddToImplIncludes("V8${parent}.h");
         $parentClass = "V8" . $parent;
         $parentClassTemplate = $parentClass . "::GetTemplate(isolate, currentWorldType)";
     }
 
     my $parentClassInfo = $parentClass ? "&${parentClass}::info" : "0";
+    ### only DOMException isException==True
     my $WrapperTypePrototype = $interface->isException ? "WrapperTypeErrorPrototype" : "WrapperTypeObjectPrototype";
 
     if (!IsSVGTypeNeedingTearOff($interfaceName)) {
         my $code = <<END;
 static void initializeScriptWrappableForInterface(${implClassName}* object)
 {
     if (ScriptWrappable::wrapperCanBeStoredInObject(object))
         ScriptWrappable::setTypeInfoInObject(object, &${v8ClassName}::info);
     else
         ASSERT_NOT_REACHED();
@@ skipping 47 matching lines @@
         }
 
         if ($attrType eq "EventHandler" && $interfaceName eq "Window") {
             $attrExt->{"OnProto"} = 1;
         }
 
         if ($attrType eq "SerializedScriptValue") {
             AddToImplIncludes("bindings/v8/SerializedScriptValue.h");
         }
 
+        ### DONE
         GenerateNormalAttrGetter($attribute, $interface, "");
+        ### DONE
         GenerateNormalAttrGetterCallback($attribute, $interface, "");
         if ($attrExt->{"PerWorldBindings"}) {
+            ### DONE
             GenerateNormalAttrGetter($attribute, $interface, "ForMainWorld");
+            ### DONE
             GenerateNormalAttrGetterCallback($attribute, $interface, "ForMainWorld");
         }
         if (!HasCustomSetter($attrExt) && $attrExt->{"Replaceable"}) {
+            ### TODO
             $hasReplaceable = 1;
         } elsif (!IsReadonly($attribute)) {
+            ### DONE(basic)
             GenerateNormalAttrSetter($attribute, $interface, "");
+            ### DONE
             GenerateNormalAttrSetterCallback($attribute, $interface, "");
             if ($attrExt->{"PerWorldBindings"}) {
+              ### DONE(basic)
               GenerateNormalAttrSetter($attribute, $interface, "ForMainWorld");
+              ### DONE
               GenerateNormalAttrSetterCallback($attribute, $interface, "ForMainWorld");
             }
         }
     }
 
     if ($hasConstructors) {
+        ### TODO
         GenerateConstructorGetter($interface);
     }
 
     if ($hasConstructors || $hasReplaceable) {
+        ### TODO
         GenerateReplaceableAttrSetter($interface);
+        ### TODO
         GenerateReplaceableAttrSetterCallback($interface);
     }
 
     if (NeedsOpaqueRootForGC($interface)) {
+        ### DONE
         GenerateOpaqueRootForGC($interface);
     }
 
     if ($interface->extendedAttributes->{"CheckSecurity"} && $interface->name ne "Window") {
+        ### TODO
         GenerateSecurityCheckFunctions($interface);
     }
 
+    ### TODO
     if (IsConstructorTemplate($interface, "TypedArray")) {
         my ($nativeType, $arrayType) = GetNativeTypeOfTypedArray($interface);
         $implementation{nameSpaceWebCore}->add(<<END);
 v8::Handle<v8::Object> wrap($implClassName* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     ASSERT(impl);
     v8::Handle<v8::Object> wrapper = ${v8ClassName}::createWrapper(impl, creationContext, isolate);
     if (!wrapper.IsEmpty())
         wrapper->SetIndexedPropertiesToExternalArrayData(impl->baseAddress(), $arrayType, impl->length());
     return wrapper;
 }
 
 END
     }
 
     my @enabledPerContextFunctions;
     my @normalFunctions;
     my $needsDomainSafeFunctionSetter = 0;
     # Generate methods for functions.
     foreach my $function (@{$interface->functions}) {
         next if $function->name eq "";
+        ### DONE (basic)
         GenerateFunction($function, $interface, "");
         if ($function->extendedAttributes->{"PerWorldBindings"}) {
+            ### TODO
             GenerateFunction($function, $interface, "ForMainWorld");
         }
         if ($function->{overloadIndex} == @{$function->{overloads}}) {
+            ### TODO
             if ($function->{overloadIndex} > 1) {
                 GenerateOverloadedFunction($function, $interface, "");
                 if ($function->extendedAttributes->{"PerWorldBindings"}) {
                     GenerateOverloadedFunction($function, $interface, "ForMainWorld");
                 }
             }
+            ### DONE
             GenerateFunctionCallback($function, $interface, "");
             if ($function->extendedAttributes->{"PerWorldBindings"}) {
+                ### TODO
                 GenerateFunctionCallback($function, $interface, "ForMainWorld");
             }
         }
 
         # If the function does not need domain security check, we need to
         # generate an access getter that returns different function objects
         # for different calling context.
+        ### TODO
         if ($interface->extendedAttributes->{"CheckSecurity"} && $function->extendedAttributes->{"DoNotCheckSecurity"}) {
             if (!HasCustomMethod($function->extendedAttributes) || $function->{overloadIndex} == 1) {
                 GenerateDomainSafeFunctionGetter($function, $interface);
                 if (!$function->extendedAttributes->{"ReadOnly"}) {
                     $needsDomainSafeFunctionSetter = 1;
                 }
             }
         }
 
+        ### TODO
         # Separate out functions that are enabled per context so we can process them specially.
         if ($function->extendedAttributes->{"EnabledPerContext"}) {
             push(@enabledPerContextFunctions, $function);
         } else {
             push(@normalFunctions, $function);
         }
     }
 
     if ($needsDomainSafeFunctionSetter) {
+        ### TODO
         GenerateDomainSafeFunctionSetter($interface);
     }
 
     # Attributes
     my $attributes = $interface->attributes;
 
     # For the Window interface we partition the attributes into the
     # ones that disallows shadowing and the rest.
     my @disallowsShadowing;
     # Also separate out attributes that are enabled at runtime so we can process them specially.
     my @enabledAtRuntimeAttributes;
     my @enabledPerContextAttributes;
     my @normalAttributes;
     foreach my $attribute (@$attributes) {
 
+        ### TODO
         if ($interfaceName eq "Window" && $attribute->extendedAttributes->{"Unforgeable"}) {
             push(@disallowsShadowing, $attribute);
         } elsif ($attribute->extendedAttributes->{"EnabledAtRuntime"} || $attribute->extendedAttributes->{"EnabledPerContext"}) {
             if ($attribute->extendedAttributes->{"EnabledPerContext"}) {
                 push(@enabledPerContextAttributes, $attribute);
             }
             if ($attribute->extendedAttributes->{"EnabledAtRuntime"}) {
                 push(@enabledAtRuntimeAttributes, $attribute);
             }
         } else {
             push(@normalAttributes, $attribute);
         }
     }
     AddToImplIncludes("bindings/v8/V8DOMConfiguration.h");
     $attributes = \@normalAttributes;
     # Put the attributes that disallow shadowing on the shadow object.
+    ### DONE
     if (@disallowsShadowing) {
         my $code = "";
         $code .= "static const V8DOMConfiguration::BatchedAttribute shadowAttrs[] = {\n";
         $code .= GenerateBatchedAttributeData($interface, \@disallowsShadowing);
         $code .= "};\n\n";
         $implementation{nameSpaceWebCore}->add($code);
     }
 
+#    use Data::Dumper;
+#    print "GEHEHE", Dumper($attributes), "\n" if $interface->name eq "File";
     my $has_attributes = 0;
     if (@$attributes) {
         $has_attributes = 1;
         my $code = "";
         $code .= "static const V8DOMConfiguration::BatchedAttribute ${v8ClassName}Attrs[] = {\n";
         $code .= GenerateBatchedAttributeData($interface, $attributes);
         $code .= "};\n\n";
         $implementation{nameSpaceWebCore}->add($code);
     }
 
@@ skipping 34 matching lines @@
     $code = "";
     if (@{$interface->constants}) {
         $has_constants = 1;
         $code .= "static const V8DOMConfiguration::BatchedConstant ${v8ClassName}Consts[] = {\n";
     }
     foreach my $constant (@{$interface->constants}) {
         my $name = $constant->name;
         my $value = $constant->value;
         my $attrExt = $constant->extendedAttributes;
         my $implementedBy = $attrExt->{"ImplementedBy"};
+        ### DONE
         if ($implementedBy) {
             my $implementedByImplName = GetImplNameFromImplementedBy($implementedBy);
             AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedByImplName));
         }
         if ($attrExt->{"EnabledAtRuntime"}) {
+            ### TODO
             push(@constantsEnabledAtRuntime, $constant);
         } else {
+            ### DONE
             my $conditionalString = GenerateConditionalString($constant);
             $code .= "#if ${conditionalString}\n" if $conditionalString;
             # If the value we're dealing with is a hex number, preprocess it into a signed integer
             # here, rather than running static_cast<signed int> in the generated code.
             if (substr($value, 0, 2) eq "0x") {
               $value = unpack('i', pack('I', hex($value)));
             }
             $code .= <<END;
     {"${name}", $value},
 END
             $code .= "#endif\n" if $conditionalString;
         }
     }
     if ($has_constants) {
         $code .= "};\n\n";
         $code .= join "", GenerateCompileTimeCheckForEnumsIfNeeded($interface);
         $implementation{nameSpaceWebCore}->add($code);
     }
 
+    ### working
     if (!HasCustomConstructor($interface)) {
         if ($interface->extendedAttributes->{"NamedConstructor"}) {
+            ### DONE
             GenerateNamedConstructor(@{$interface->constructors}[0], $interface);
         } elsif ($interface->extendedAttributes->{"Constructor"}) {
+            ### DONE
             GenerateConstructor($interface);
         } elsif (IsConstructorTemplate($interface, "Event")) {
+            ### TODO
             GenerateEventConstructor($interface);
         }
     }
     if (IsConstructable($interface)) {
+        ### DONE
         GenerateConstructorCallback($interface);
     }
 
+    ### DONE
     my $access_check = "";
     if ($interface->extendedAttributes->{"CheckSecurity"} && $interfaceName ne "Window") {
         $access_check = "instance->SetAccessCheckCallbacks(${implClassName}V8Internal::namedSecurityCheck, ${implClassName}V8Internal::indexedSecurityCheck, v8::External::New(&${v8ClassName}::info));";
     }
 
+    ### TODO
     # 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::batchConfigureAttributes(templ, v8::Handle<v8::ObjectTemplate>(), shadowAttrs, WTF_ARRAY_LENGTH(shadowAttrs), isolate, currentWorldType);
 
     // Install a security handler with V8.
     templ->SetAccessCheckCallbacks(V8Window::namedSecurityCheckCustom, V8Window::indexedSecurityCheckCustom, v8::External::New(&V8Window::info));
@@ skipping 44 matching lines @@
         $code .= <<END;
         0, 0, isolate, currentWorldType);
 END
     }
 
     AddToImplIncludes("wtf/UnusedParam.h");
     $code .= <<END;
     UNUSED_PARAM(defaultSignature); // In some cases, it will not be used.
 END
 
+    ### TODO
     if (IsConstructable($interface)) {
         $code .= "    desc->SetCallHandler(${v8ClassName}::constructorCallback);\n";
         my $interfaceLength = GetInterfaceLength($interface);
         $code .= "    desc->SetLength(${interfaceLength});\n";
     }
 
+    ### DONE
     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.
 END
     }
 
+    ### DONE
     if ($access_check) {
         $code .=  "    $access_check\n";
     }
 
+    ### DONE
     # Setup the enable-at-runtime attrs if we have them
     foreach my $runtime_attr (@enabledAtRuntimeAttributes) {
         next if grep { $_ eq $runtime_attr } @enabledPerContextAttributes;
         my $enable_function = GetRuntimeEnableFunctionName($runtime_attr);
         my $conditionalString = GenerateConditionalString($runtime_attr);
         $code .= "\n#if ${conditionalString}\n" if $conditionalString;
         $code .= "    if (${enable_function}()) {\n";
         $code .= "        static const V8DOMConfiguration::BatchedAttribute attrData =\\\n";
         $code .= GenerateSingleBatchedAttribute($interface, $runtime_attr, ";", "    ");
         $code .= <<END;
         V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate, currentWorldType);
     }
 END
         $code .= "\n#endif // ${conditionalString}\n" if $conditionalString;
     }
 
+    ### DONE
     # Setup the enable-at-runtime constants if we have them
     foreach my $runtime_const (@constantsEnabledAtRuntime) {
         my $enable_function = GetRuntimeEnableFunctionName($runtime_const);
         my $conditionalString = GenerateConditionalString($runtime_const);
         my $name = $runtime_const->name;
         my $value = $runtime_const->value;
         $code .= "\n#if ${conditionalString}\n" if $conditionalString;
         $code .= "    if (${enable_function}()) {\n";
         $code .= <<END;
         static const V8DOMConfiguration::BatchedConstant constData = {"${name}", static_cast<signed int>(${value})};
         V8DOMConfiguration::batchConfigureConstants(desc, proto, &constData, 1, isolate);
 END
         $code .= "    }\n";
         $code .= "\n#endif // ${conditionalString}\n" if $conditionalString;
     }
 
+    ### TODO
     $code .= GenerateImplementationIndexedPropertyAccessors($interface);
+    ### TODO
     $code .= GenerateImplementationNamedPropertyAccessors($interface);
+    ### TODO
     $code .= GenerateImplementationLegacyCall($interface);
+    ### TODO
     $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);
+        ### DONE
         $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;
 
+    ### DONE
     if ($has_constants) {
         $code .= <<END;
     V8DOMConfiguration::batchConfigureConstants(desc, proto, ${v8ClassName}Consts, WTF_ARRAY_LENGTH(${v8ClassName}Consts), isolate);
 END
     }
 
     # Special cases
+    ### TODO
     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.
     instance->SetAccessCheckCallbacks(V8Window::namedSecurityCheckCustom, V8Window::indexedSecurityCheckCustom, v8::External::New(&V8Window::info), false);
 END
     }
+    ### TODO
     if ($interfaceName eq "HTMLDocument" or $interfaceName eq "DedicatedWorkerGlobalScope" or $interfaceName eq "SharedWorkerGlobalScope") {
         $code .= <<END;
     desc->SetHiddenPrototype(true);
 END
     }
 
+    ### DONE
     $code .= <<END;
 
     // Custom toString template
     desc->Set(v8::String::NewSymbol("toString"), V8PerIsolateData::current()->toStringTemplate());
     return desc;
 }
 
 END
     $implementation{nameSpaceWebCore}->add($code);
 
     $implementation{nameSpaceWebCore}->add(<<END);
 v8::Handle<v8::FunctionTemplate> ${v8ClassName}::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     V8PerIsolateData* data = V8PerIsolateData::from(isolate);
     V8PerIsolateData::TemplateMap::iterator result = data->templateMap(currentWorldType).find(&info);
     if (result != data->templateMap(currentWorldType).end())
         return result->value.newLocal(isolate);
 
     TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "BuildDOMTemplate");
     v8::HandleScope handleScope(isolate);
     v8::Handle<v8::FunctionTemplate> templ =
         Configure${v8ClassName}Template(data->rawTemplate(&info, currentWorldType), isolate, currentWorldType);
     data->templateMap(currentWorldType).add(&info, UnsafePersistent<v8::FunctionTemplate>(isolate, templ));
     return handleScope.Close(templ);
 }
 
 END
+    ### DONE
     $implementation{nameSpaceWebCore}->add(<<END);
 bool ${v8ClassName}::HasInstance(v8::Handle<v8::Value> value, v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     return V8PerIsolateData::from(isolate)->hasInstance(&info, value, currentWorldType);
 }
 
 END
+    ### DONE
     $implementation{nameSpaceWebCore}->add(<<END);
 bool ${v8ClassName}::HasInstanceInAnyWorld(v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
     return V8PerIsolateData::from(isolate)->hasInstance(&info, value, MainWorld)
         || V8PerIsolateData::from(isolate)->hasInstance(&info, value, IsolatedWorld)
         || V8PerIsolateData::from(isolate)->hasInstance(&info, value, WorkerWorld);
 }
 
 END
 
+    ### TODO
     if (@enabledPerContextAttributes) {
         my $code = "";
         $code .= <<END;
 void ${v8ClassName}::installPerContextProperties(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 attrs if we have them
         foreach my $runtimeAttr (@enabledPerContextAttributes) {
@@ skipping 15 matching lines @@
             $code .= "    }\n";
             $code .= "#endif // ${conditionalString}\n" if $conditionalString;
         }
         $code .= <<END;
 }
 
 END
         $implementation{nameSpaceWebCore}->add($code);
     }
 
+    ### TODO
     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)));
@@ skipping 15 matching lines @@
             $code .= "#endif // ${conditionalString}\n" if $conditionalString;
         }
 
         $code .= <<END;
 }
 
 END
         $implementation{nameSpaceWebCore}->add($code);
     }
 
+    ### DONE
     if (InheritsExtendedAttribute($interface, "ActiveDOMObject")) {
         # MessagePort is handled like an active dom object even though it doesn't inherit
         # from ActiveDOMObject, so don't try to cast it to ActiveDOMObject.
         my $returnValue = $interfaceName eq "MessagePort" ? "0" : "toNative(object)";
         $implementation{nameSpaceWebCore}->add(<<END);
 ActiveDOMObject* ${v8ClassName}::toActiveDOMObject(v8::Handle<v8::Object> object)
 {
     return $returnValue;
 }
 
 END
     }
 
+    ### DONE
     if (InheritsInterface($interface, "EventTarget")) {
         $implementation{nameSpaceWebCore}->add(<<END);
 EventTarget* ${v8ClassName}::toEventTarget(v8::Handle<v8::Object> object)
 {
     return toNative(object);
 }
 
 END
     }
 
+    ### TODO
     if ($interfaceName eq "Window") {
         $implementation{nameSpaceWebCore}->add(<<END);
 v8::Handle<v8::ObjectTemplate> V8Window::GetShadowObjectTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
 {
     if (currentWorldType == MainWorld) {
         DEFINE_STATIC_LOCAL(v8::Persistent<v8::ObjectTemplate>, V8WindowShadowObjectCacheForMainWorld, ());
         if (V8WindowShadowObjectCacheForMainWorld.IsEmpty()) {
             TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "BuildDOMTemplate");
             v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New();
             ConfigureShadowObjectTemplate(templ, isolate, currentWorldType);
@@ skipping 70 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 = ();
             if (ExtendedAttributeContains($function->extendedAttributes->{"CallWith"}, "ThisValue")) {
                 push(@args, GetNativeType("any") . " thisValue");
             }
             my @params = @{$function->parameters};
             foreach my $param (@params) {
+                print "[gch]", $param->name, "\n" if $interface->name eq "MIDISuccessCallback";
                 push(@args, GetNativeTypeForCallbacks($param->type) . " " . $param->name);
             }
             $code .= join(", ", @args);
             $code .= ");\n";
             $header{classPublic}->add($code);
         }
     }
 
     $header{classPublic}->add(<<END);
 
@@ skipping 29 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 200 matching lines @@
     return $implClassName;
 }
 
 sub GetNamespaceForInterface
 {
     my $interface = shift;
     return "WTF" if IsTypedArrayType($interface->name);
     return "WebCore";
 }
 
+# get_function_call_parameter and macro function_call in python
 sub GenerateFunctionCallString
 {
     my $function = shift;
     my $numberOfParameters = shift;
+    if ($numberOfParameters != @{$function->parameters}) {
+#        print "NEVER\n";
+    }
     my $indent = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
     my %replacements = @_;
 
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
     my $name = GetImplName($function);
     my $returnType = $function->type;
     my $nativeReturnType = GetNativeType($returnType, {}, "");
     my $code = "";
 
     my $isSVGTearOffType = (IsSVGTypeNeedingTearOff($returnType) and not $interfaceName =~ /List$/);
     $nativeReturnType = GetSVGWrappedTypeNeedingTearOff($returnType) if $isSVGTearOffType;
 
     my $index = 0;
 
     my @arguments;
     my $functionName;
     my $implementedBy = $function->extendedAttributes->{"ImplementedBy"};
     if ($implementedBy) {
+        ### DONE
         my $implementedByImplName = GetImplNameFromImplementedBy($implementedBy);
         AddToImplIncludes(HeaderFilesForInterface($implementedBy, $implementedByImplName));
         unshift(@arguments, "imp") if !$function->isStatic;
         $functionName = "${implementedByImplName}::${name}";
     } elsif ($function->isStatic) {
+        ### DONE
         $functionName = "${implClassName}::${name}";
     } else {
+        ### DONE
         $functionName = "imp->${name}";
     }
 
+    ### DONE
     my $callWith = $function->extendedAttributes->{"CallWith"};
     my ($callWithArgs, $subCode) = GenerateCallWith($callWith, $indent, 1, $function);
     $code .= $subCode;
     unshift(@arguments, @$callWithArgs);
-    $index += @$callWithArgs;
-    $numberOfParameters += @$callWithArgs;
+#    $index += @$callWithArgs;
+#    $numberOfParameters += @$callWithArgs;
 
     foreach my $parameter (@{$function->parameters}) {
+        ### DONE
         if ($index eq $numberOfParameters) {
             last;
         }
         my $paramName = $parameter->name;
         my $paramType = $parameter->type;
 
         if ($replacements{$paramName}) {
+            ### DONE
             push @arguments, $replacements{$paramName};
         } elsif ($parameter->type eq "NodeFilter" || $parameter->type eq "XPathNSResolver") {
+            ### DONE
             push @arguments, "$paramName.get()";
         } elsif (IsSVGTypeNeedingTearOff($parameter->type) and not $interfaceName =~ /List$/) {
+            ### DONE
             AddToImplIncludes("core/dom/ExceptionCode.h");
             push @arguments, "$paramName->propertyReference()";
             $code .= $indent . "if (!$paramName) {\n";
             $code .= $indent . "    setDOMException(WebCore::TypeMismatchError, args.GetIsolate());\n";
             $code .= $indent . "    return;\n";
             $code .= $indent . "}\n";
         } elsif ($parameter->type eq "SVGMatrix" and $interfaceName eq "SVGTransformList") {
+            ### DONE
             push @arguments, "$paramName.get()";
         } else {
+            ### main
             push @arguments, $paramName;
         }
         $index++;
     }
 
+    ### DONE
     if ($function->extendedAttributes->{"RaisesException"}) {
         push @arguments, "es";
     }
 
+    ### DONE
+    ### function_call_expression in python
     my $functionString = "$functionName(" . join(", ", @arguments) . ")";
 
+    ### DONE  native_value_expression in python
     my $return = "result";
     my $returnIsRef = IsRefPtrType($returnType);
 
     if ($returnType eq "void") {
+        ### DONE
+        ### function_call_statement in python generator
         $code .= $indent . "$functionString;\n";
     } elsif (ExtendedAttributeContains($callWith, "ScriptState") or $function->extendedAttributes->{"RaisesException"}) {
+        ### DONE
+        ### function_call_statement in python generator
         $code .= $indent . $nativeReturnType . " result = $functionString;\n";
     } else {
+        ### DONE
         # Can inline the function call into the return statement to avoid overhead of using a Ref<> temporary
         $return = $functionString;
         $returnIsRef = 0;
 
+        ### TODO
         if ($interfaceName eq "SVGTransformList" and IsRefPtrType($returnType)) {
             $return = "WTF::getPtr(" . $return . ")";
         }
     }
 
+    ### DONE
     if ($function->extendedAttributes->{"RaisesException"}) {
         $code .= $indent . "if (es.throwIfNeeded())\n";
         $code .= $indent . "    return;\n";
     }
 
+    ### DONE
     if (ExtendedAttributeContains($callWith, "ScriptState")) {
         $code .= $indent . "if (state.hadException()) {\n";
         $code .= $indent . "    v8::Local<v8::Value> exception = state.exception();\n";
         $code .= $indent . "    state.clearException();\n";
         $code .= $indent . "    throwError(exception);\n";
         $code .= $indent . "    return;\n";
         $code .= $indent . "}\n";
     }
 
+    ### TODO
     if ($isSVGTearOffType) {
         AddToImplIncludes("V8$returnType.h");
         AddToImplIncludes("core/svg/properties/SVGPropertyTearOff.h");
         my $svgNativeType = GetSVGTypeNeedingTearOff($returnType);
         # FIXME: Update for all ScriptWrappables.
         if (IsDOMNodeType($interfaceName)) {
             if ($forMainWorldSuffix eq "ForMainWorld") {
                 $code .= $indent . "v8SetReturnValue(args, toV8ForMainWorld(WTF::getPtr(${svgNativeType}::create($return)), args.Holder(), args.GetIsolate()));\n";
             } else {
                 $code .= $indent . "v8SetReturnValue(args, toV8Fast(WTF::getPtr(${svgNativeType}::create($return)), args, imp));\n";
             }
         } else {
             $code .= $indent . "v8SetReturnValue(args, toV8${forMainWorldSuffix}(WTF::getPtr(${svgNativeType}::create($return)), args.Holder(), args.GetIsolate()));\n";
         }
         $code .= $indent . "return;\n";
         return $code;
     }
 
+    ### TODO
     # If the implementing class is a POD type, commit changes
     if (IsSVGTypeNeedingTearOff($interfaceName) and not $interfaceName =~ /List$/) {
         $code .= $indent . "wrapper->commitChange();\n";
     }
 
+    ### DONE
     $return .= ".release()" if ($returnIsRef);
 
     my $nativeValue;
     # FIXME: Update for all ScriptWrappables.
     if (IsDOMNodeType($interfaceName)) {
+        ### DONE
         $nativeValue = NativeToJSValue($function->type, $function->extendedAttributes, $return, $indent, "", "args.Holder()", "args.GetIsolate()", "args", "imp", $forMainWorldSuffix, "return");
     } else {
+        ### DONE
         $nativeValue = NativeToJSValue($function->type, $function->extendedAttributes, $return, $indent, "", "args.Holder()", "args.GetIsolate()", "args", 0, $forMainWorldSuffix, "return");
     }
 
+    ### DONE
     $code .= $nativeValue . "\n";
     $code .= $indent . "return;\n";
 
     return $code;
 }
 
 sub GetNativeType
 {
     my $type = shift;
     my $extendedAttributes = shift;
     my $isParameter = shift;
+    my $isw = IsWrapperType($type) ? "WT":"";
+print "[GetNativeType] $type, $isParameter $isw\n";
 
     my $svgNativeType = GetSVGTypeNeedingTearOff($type);
     if ($svgNativeType) {
         if ($svgNativeType =~ /List$/) {
             return "${svgNativeType}*";
         } else {
             return "RefPtr<${svgNativeType} >";
         }
     }
 
@@ skipping 19 matching lines @@
             $mode = "WithUndefinedOrNullCheck";
         } elsif (($extendedAttributes->{"TreatNullAs"} and $extendedAttributes->{"TreatNullAs"} eq "NullString") or $extendedAttributes->{"Reflect"}) {
             $mode = "WithNullCheck";
         }
         # FIXME: Add the case for 'elsif ($attributeOrParameter->extendedAttributes->{"TreatUndefinedAs"} and $attributeOrParameter->extendedAttributes->{"TreatUndefinedAs"} eq "NullString"))'.
         return "V8StringResource<$mode>";
     }
 
     return "String" if $type eq "DOMString" or IsEnumType($type);
 
+    ### DONE
     return "Range::CompareHow" if $type eq "CompareHow";
     return "DOMTimeStamp" if $type eq "DOMTimeStamp";
     return "double" if $type eq "Date";
     return "ScriptValue" if $type eq "any" or IsCallbackFunctionType($type);
     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);
 
     if (IsTypedArrayType($type)) {
         return $isParameter ? "${type}*" : "RefPtr<${type}>";
     }
 
     # We need to check [ImplementedAs] extended attribute for wrapper types.
     if (IsWrapperType($type)) {
+#        print "GEHEHE ", $type, "\n";
+#        use Carp qw(cluck);
+#        cluck "HEY";
         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[GetNativeTypeForCallbacks] $type\n" if $type eq "DOMException";
+#    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, {}, "parameter");
 }
 
 sub JSValueToNativeStatement
 {
     my $type = shift;
@@ skipping 107 matching lines @@
         }
         return "toNativeArray<" . GetNativeType($arrayOrSequenceType) . ">($value, $getIsolate)";
     }
 
     AddIncludesForType($type);
 
     AddToImplIncludes("V8${type}.h");
     return "V8${type}::HasInstance($value, $getIsolate, worldType($getIsolate)) ? V8${type}::toNative(v8::Handle<v8::Object>::Cast($value)) : 0";
 }
 
+### DONE
 sub CreateCustomSignature
 {
     my $function = shift;
     my $count = @{$function->parameters};
     my $name = $function->name;
     my $code = "    const int ${name}Argc = ${count};\n" .
       "    v8::Handle<v8::FunctionTemplate> ${name}Argv[${name}Argc] = { ";
     my $first = 1;
     foreach my $parameter (@{$function->parameters}) {
         if ($first) { $first = 0; }
@@ skipping 149 matching lines @@
     my $getIsolate = shift;
     die "An Isolate is mandatory for native value => JS value conversion." unless $getIsolate;
     my $getCallbackInfo = shift || "";
     my $getCallbackInfoArg = $getCallbackInfo ? ", $getCallbackInfo" : "";
     my $getScriptWrappable = shift || "";
     my $getScriptWrappableArg = $getScriptWrappable ? ", $getScriptWrappable" : "";
     my $forMainWorldSuffix = shift || "";
     my $returnValueArg = shift || 0;
     my $isReturnValue = $returnValueArg eq "return";
 
+    print "  [NativeToJSValue]", $type, " ", $nativeValue, "\n";
+#     if $type eq "AudioBuffer";
+
     if (IsUnionType($type)) {
         my $types = $type->unionMemberTypes;
         my @codes = ();
         for my $i (0 .. scalar(@$types)-1) {
             my $unionMemberType = $types->[$i];
             my $unionMemberNumber = $i + 1;
             my $unionMemberVariable = $nativeValue . $i;
             my $unionMemberEnabledVariable = $nativeValue . $i . "Enabled";
             my $unionMemberNativeValue = $unionMemberVariable;
             $unionMemberNativeValue .= ".release()" if (IsRefPtrType($unionMemberType));
@@ skipping 101 matching lines @@
     if ($arrayOrSequenceType) {
         if (IsRefPtrType($arrayOrSequenceType)) {
             AddIncludesForType($arrayOrSequenceType);
         }
         return "${indent}v8SetReturnValue(${getCallbackInfo}, v8Array($nativeValue, $getIsolate));" if $isReturnValue;
         return "$indent$receiver v8Array($nativeValue, $getIsolate);";
     }
 
     AddIncludesForType($type);
 
+    ### DONE
     if ($type eq "SerializedScriptValue") {
         my $returnValue = "$nativeValue ? $nativeValue->deserialize() : v8::Handle<v8::Value>(v8::Null($getIsolate))";
         return "${indent}v8SetReturnValue(${getCallbackInfo}, $returnValue);" if $isReturnValue;
         return "$indent$receiver $returnValue;";
     }
 
     AddToImplIncludes("wtf/RefPtr.h");
     AddToImplIncludes("wtf/GetPtr.h");
 
     if ($getScriptWrappable) {
@@ skipping 104 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 $afterRecursion = shift;  # nbarth: ?
 
     my $recurse;
     $recurse = sub {
         my $currentInterface = shift;
 
         if ($currentInterface->parent) {
             my $parentInterface = ParseInterface($currentInterface->parent);
             if ($beforeRecursion) {
                 &$beforeRecursion($parentInterface) eq 'prune' and return;
             }
             &$recurse($parentInterface);
-            &$afterRecursion($parentInterface) if $afterRecursion;
+            &$afterRecursion($parentInterface) if $afterRecursion;  # nbarth: ?
         }
     };
 
     &$recurse($interface);
 }
 
 sub FindSuperMethod
 {
     my ($interface, $functionName) = @_;
     my $indexer;
-    ForAllParents($interface, undef, sub {
+    ForAllParents($interface, undef, sub {  # nbarth: (undef) ?
         my $currentInterface = shift;
         foreach my $function (@{$currentInterface->functions}) {
             if ($function->name eq $functionName) {
                 $indexer = $function;
                 return 'prune';
             }
         }
     });
     return $indexer;
 }
@@ skipping 30 matching lines @@
     return 0;
 }
 
 sub ValidEnumValues
 {
     my $type = shift;
 
     return @{$enumTypeHash{$type}};
 }
 
+
+# merged with GetSVGTypeNeedingTearOff
 sub IsSVGTypeNeedingTearOff
 {
     my $type = shift;
 
     return 1 if $svgTypeNeedingTearOff{$type};
     return 0;
 }
 
+### DONE
 sub IsSVGTypeWithWritablePropertiesNeedingTearOff
 {
     my $type = shift;
 
     return 1 if $svgTypeWithWritablePropertiesNeedingTearOff{$type};
     return 0;
 }
 
 sub IsTypedArrayType
 {
@@ skipping 11 matching lines @@
     return 0 if GetArrayType($type);
     return 0 if GetSequenceType($type);
     return 0 if $type eq "DOMString";
     return 0 if IsCallbackFunctionType($type);
     return 0 if IsEnumType($type);
     return 0 if IsUnionType($type);
 
     return 1;
 }
 
+### DONE
 sub GetSVGTypeNeedingTearOff
 {
     my $type = shift;
 
     return $svgTypeNeedingTearOff{$type} if exists $svgTypeNeedingTearOff{$type};
     return undef;
 }
 
+### DONE
 sub GetSVGWrappedTypeNeedingTearOff
 {
     my $type = shift;
 
     my $svgTypeNeedingTearOff = GetSVGTypeNeedingTearOff($type);
     return $svgTypeNeedingTearOff if not $svgTypeNeedingTearOff;
 
     if ($svgTypeNeedingTearOff =~ /SVGPropertyTearOff/) {
         $svgTypeNeedingTearOff =~ s/SVGPropertyTearOff<//;
     } elsif ($svgTypeNeedingTearOff =~ /SVGListPropertyTearOff/) {
@@ skipping 49 matching lines @@
     my $param = shift;
     my $ret = ucfirst($param);
     # xmlEncoding becomes XMLEncoding, but xmlllang becomes Xmllang.
     $ret =~ s/Xml/XML/ if $ret =~ /^Xml[^a-z]/;
     $ret =~ s/Css/CSS/ if $ret =~ /^Css[^T]/;  # css -> setCSS, except setCssText.
     $ret =~ s/Ime/IME/ if $ret =~ /^Ime/;  # ime -> setIME
     $ret =~ s/Svg/SVG/ if $ret =~ /^Svg/;  # svg -> setSVG
     return $ret;
 }
 
+### DONE
 # URL becomes url, but SetURL becomes setURL.
 sub ToMethodName
 {
     my $param = shift;
     my $ret = lcfirst($param);
     $ret =~ s/hTML/html/ if $ret =~ /^hTML/;
     $ret =~ s/uRL/url/ if $ret =~ /^uRL/;
     $ret =~ s/jS/js/ if $ret =~ /^jS/;
     $ret =~ s/xML/xml/ if $ret =~ /^xML/;
     $ret =~ s/xSLT/xslt/ if $ret =~ /^xSLT/;
@@ skipping 23 matching lines @@
     my %nameToFunctionsMap = ();
     foreach my $function (@{$interface->functions}) {
         my $name = $function->name;
         $nameToFunctionsMap{$name} = [] if !exists $nameToFunctionsMap{$name} or !$name;  # Nameless functions cannot be overloaded
         push(@{$nameToFunctionsMap{$name}}, $function);
         $function->{overloads} = $nameToFunctionsMap{$name};
         $function->{overloadIndex} = @{$nameToFunctionsMap{$name}};
     }
 }
 
+### DONE
 sub AttributeNameForGetterAndSetter
 {
     my $attribute = shift;
 
     my $attributeName = GetImplName($attribute);
     if ($attribute->extendedAttributes->{"ImplementedAs"}) {
         $attributeName = $attribute->extendedAttributes->{"ImplementedAs"};
     }
     my $attributeType = $attribute->type;
 
     return $attributeName;
 }
 
 sub ContentAttributeName
 {
     my ($interfaceName, $attribute) = @_;
 
     my $contentAttributeName = $attribute->extendedAttributes->{"Reflect"};
     return undef if !$contentAttributeName;
 
     $contentAttributeName = lc AttributeNameForGetterAndSetter($attribute) if $contentAttributeName eq "VALUE_IS_MISSING";
 
     my $namespace = NamespaceForAttributeName($interfaceName, $contentAttributeName);
 
     AddToImplIncludes("${namespace}.h");
     return "WebCore::${namespace}::${contentAttributeName}Attr";
 }
 
+### get_attribute_getter_info in python
+### DONE
 sub GetterExpression
 {
     my ($interfaceName, $attribute) = @_;
 
     my $contentAttributeName = ContentAttributeName($interfaceName, $attribute);
 
     if (!$contentAttributeName) {
         return (ToMethodName(AttributeNameForGetterAndSetter($attribute)));
     }
 
@@ skipping 98 matching lines @@
                 push(@checks, "COMPILE_ASSERT($value == ${implClassName}::$name, ${implClassName}Enum${name}IsWrongUseDoNotCheckConstants);\n");
             }
 
             push(@checks, "#endif\n") if $conditionalString;
         }
         push(@checks, "\n");
     }
     return @checks;
 }
 
+### call_with_contains in python
 sub ExtendedAttributeContains
 {
     my $callWith = shift;
     return 0 unless $callWith;
     my $keyword = shift;
 
     my @callWithKeywords = split /\s*\&\s*/, $callWith;
     return grep { $_ eq $keyword } @callWithKeywords;
 }
 
@@ skipping 27 matching lines @@
         if ($currentInterface->extendedAttributes->{$extendedAttribute}) {
             $found = 1;
         }
         return 1 if $found;
     }, 0);
 
     return $found;
 }
 
 1;