Make length property return useful values for DOM bindings functions

Source/bindings/scripts/IDLParser.pm

 # 
 # KDOM IDL parser
 #
 # Copyright (C) 2005 Nikolas Zimmermann <wildfox@kde.org>
 # 
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Library General Public
 # License as published by the Free Software Foundation; either
 # version 2 of the License, or (at your option) any later version.
 # 
@@ skipping 31 matching lines @@
 
 # Used to represent 'interface' blocks
 struct( domInterface => {
     name => '$',      # Class identifier
     parents => '@',      # List of strings
     constants => '@',    # List of 'domConstant'
     functions => '@',    # List of 'domFunction'
     attributes => '@',    # List of 'domAttribute'    
     extendedAttributes => '$', # Extended attributes
     constructors => '@', # Constructors, list of 'domFunction'
+    customConstructors => '@', # Custom constructors, list of 'domFunction'
     isException => '$', # Used for exception interfaces
 });
 
 # Used to represent domInterface contents (name of method, signature)
 struct( domFunction => {
     isStatic => '$',
     signature => '$',    # Return type/Object name/extended attributes
     parameters => '@',    # List of 'domSignature'
 });
 
@@ skipping 304 matching lines @@
             foreach my $constant (@{$definition->constants}) {
                 if (exists $typedefs{$constant->type}) {
                     my $typedef = $typedefs{$constant->type};
                     $self->assertNoExtendedAttributesInTypedef($constant->type, __LINE__);
                     $constant->type($typedef->type);
                 }
             }
             foreach my $attribute (@{$definition->attributes}) {
                 $self->applyTypedefsForSignature($attribute->signature);
             }
-            foreach my $function (@{$definition->functions}, @{$definition->constructors}) {
+            foreach my $function (@{$definition->functions}, @{$definition->constructors}, @{$definition->customConstructors}) {
                 $self->applyTypedefsForSignature($function->signature);
                 foreach my $signature (@{$function->parameters}) {
                     $self->applyTypedefsForSignature($signature);
                 }
             }
         }
     }
 }
 
 sub applyTypedefsForSignature
@@ skipping 744 matching lines @@
         $self->assertTokenValue($self->getToken(), "attribute", __LINE__);
         $newDataNode->signature(domSignature->new());
         my $type = $self->parseType();
         $newDataNode->signature->isNullable(typeHasNullableSuffix($type));
         # Remove all "?" in the type declaration, e.g. "double?" -> "double".
         $newDataNode->signature->type(typeRemoveNullableSuffix($type));
         my $token = $self->getToken();
         $self->assertTokenType($token, IdentifierToken);
         $newDataNode->signature->name($token->value());
         $self->assertTokenValue($self->getToken(), ";", __LINE__);
+        # CustomConstructor may also be used on attributes.
+        if (defined $extendedAttributeList->{"CustomConstructors"}) {
+            delete $extendedAttributeList->{"CustomConstructors"};
+            $extendedAttributeList->{"CustomConstructor"} = "VALUE_IS_MISSING";
+        }
         $newDataNode->signature->extendedAttributes($extendedAttributeList);
         return $newDataNode;
     }
     $self->assertUnexpectedToken($next->value(), __LINE__);
 }
 
 sub parseInherit
 {
     my $self = shift;
     my $next = $self->nextToken();
@@ skipping 339 matching lines @@
     my $attr = shift;
 
     for my $key (keys %{$attr}) {
         if ($key eq "Constructor") {
             push(@{$extendedAttributeList->{"Constructors"}}, $attr->{$key});
         } elsif ($key eq "Constructors") {
             my @constructors = @{$attr->{$key}};
             foreach my $constructor (@constructors) {
                 push(@{$extendedAttributeList->{"Constructors"}}, $constructor);
             }
+        } elsif ($key eq "CustomConstructor") {
+            push(@{$extendedAttributeList->{"CustomConstructors"}}, $attr->{$key});
+        } elsif ($key eq "CustomConstructors") {
+           my @customConstructors = @{$attr->{$key}};
+            foreach my $customConstructor (@customConstructors) {
+                push(@{$extendedAttributeList->{"CustomConstructors"}}, $customConstructor);
+            }
         } else {
             $extendedAttributeList->{$key} = $attr->{$key};
         }
     }
 }
 
 sub parseExtendedAttributeList
 {
     my $self = shift;
     my $next = $self->nextToken();
@@ skipping 66 matching lines @@
         $attrs->{$name} = $self->parseArgumentList();
         $self->assertTokenValue($self->getToken(), ")", __LINE__);
         return $attrs;
     }
     if ($next->value() eq "=") {
         $self->assertTokenValue($self->getToken(), "=", __LINE__);
         $attrs->{$name} = $self->parseExtendedAttributeRest2();
         return $attrs;
     }
 
-    if ($name eq "Constructor") {
+    if ($name eq "Constructor" || $name eq "CustomConstructor") {
         $attrs->{$name} = [];
     } else {
         $attrs->{$name} = "VALUE_IS_MISSING";
     }
     return $attrs;
 }
 
 sub parseExtendedAttributeRest2
 {
     my $self = shift;
@@ skipping 574 matching lines @@
         $newDataNode->signature(domSignature->new());
         $newDataNode->signature->name("NamedConstructor");
         $newDataNode->signature->extendedAttributes($extendedAttributeList);
         my %attributes = %{$extendedAttributeList->{"NamedConstructor"}};
         my @attributeKeys = keys (%attributes);
         my $constructorName = $attributeKeys[0];
         push(@{$newDataNode->parameters}, @{$attributes{$constructorName}});
         $extendedAttributeList->{"NamedConstructor"} = $constructorName;
         push(@{$interface->constructors}, $newDataNode);
     }
+    if (defined $extendedAttributeList->{"CustomConstructors"}) {
+        my @customConstructorParams = @{$extendedAttributeList->{"CustomConstructors"}};
+        my $index = (@customConstructorParams == 1) ? 0 : 1;
+        foreach my $param (@customConstructorParams) {
+            my $customConstructor = domFunction->new();
+            $customConstructor->signature(domSignature->new());
+            $customConstructor->signature->name("CustomConstructor");
+            $customConstructor->signature->extendedAttributes($extendedAttributeList);
+            $customConstructor->parameters($param);
+            $customConstructor->{overloadedIndex} = $index++;
+            push(@{$interface->customConstructors}, $customConstructor);
+        }
+        delete $extendedAttributeList->{"CustomConstructors"};
+        $extendedAttributeList->{"CustomConstructor"} = "VALUE_IS_MISSING";
+    }
     $interface->extendedAttributes($extendedAttributeList);
 }
 
 1;