Simplify Custom Element constructors to be functions, not wrappers

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 17 matching lines @@
 
 use constant StringToken => 0;
 use constant IntegerToken => 1;
 use constant FloatToken => 2;
 use constant IdentifierToken => 3;
 use constant OtherToken => 4;
 use constant EmptyToken => 5;
 
 # Used to represent a parsed IDL document
 struct( idlDocument => {
+    fileName => '$', # file name
+    callbackFunctions => '@',
+    enumerations => '@', # All parsed enumerations
     interfaces => '@', # All parsed interfaces
-    enumerations => '@', # All parsed enumerations
-    fileName => '$', # file name
+});
+
+struct( CallbackFunction => {

[haraken, 2013/06/10 09:11:03]

Nit: CallbackFunction => callbackFunction

+    name => '$',
+    returnType => '$',

[haraken, 2013/06/10 09:11:03]

Nit: Use 'type' for consistency with other data structure.

+    arguments => '@',

[haraken, 2013/06/10 09:11:03]

Nit: Use 'parameters' for consistency with other data structure.

 });
 
 # 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
@@ skipping 150 matching lines @@
     };
     die $@ . " in $fileName" if $@;
 
     my $document = idlDocument->new();
     $document->fileName($fileName);
     foreach my $definition (@definitions) {
         if (ref($definition) eq "domInterface") {
             push(@{$document->interfaces}, $definition);
         } elsif (ref($definition) eq "domEnum") {
             push(@{$document->enumerations}, $definition);
+        } elsif (ref($definition) eq "CallbackFunction") {
+            push(@{$document->callbackFunctions}, $definition);
         } else {
             die "Unrecognized IDL definition kind: \"" . ref($definition) . "\"";
         }
     }
     return $document;
 }
 
 sub nextToken
 {
     my $self = shift;
@@ skipping 582 matching lines @@
     return \@values; # empty list (end of enumeration-values)
 }
 
 sub parseCallbackRest
 {
     my $self = shift;
     my $extendedAttributeList = shift;
 
     my $next = $self->nextToken();
     if ($next->type() == IdentifierToken) {
-        $self->assertTokenType($self->getToken(), IdentifierToken);
+        my $callback = CallbackFunction->new();
+        my $name = $self->getToken();
+        $self->assertTokenType($name, IdentifierToken);
+        $callback->name($name->value());
         $self->assertTokenValue($self->getToken(), "=", __LINE__);
-        $self->parseReturnType();
+        $callback->returnType($self->parseReturnType());
         $self->assertTokenValue($self->getToken(), "(", __LINE__);
-        $self->parseArgumentList();
+        $callback->arguments($self->parseArgumentList());
         $self->assertTokenValue($self->getToken(), ")", __LINE__);
         $self->assertTokenValue($self->getToken(), ";", __LINE__);
-        return;
+        return $callback;
     }
     $self->assertUnexpectedToken($next->value(), __LINE__);
 }
 
 sub parseTypedef
 {
     my $self = shift;
     my $extendedAttributeList = shift;
     die "Extended attributes are not applicable to typedefs themselves: " . $self->{Line} if %{$extendedAttributeList};
 
@@ skipping 500 matching lines @@
 {
     my $self = shift;
     my $extendedAttributeList = shift;
 
     my $next = $self->nextToken();
     if ($next->type() == IdentifierToken || $next->value() eq "(") {
         my $newDataNode = domFunction->new();
         $newDataNode->signature(domSignature->new());
         my $name = $self->parseOptionalIdentifier();
         $newDataNode->signature->name($name);
-        $self->assertTokenValue($self->getToken(), "(", $name, __LINE__);
+        $self->assertTokenValue($self->getToken(), "(", __LINE__);
         push(@{$newDataNode->parameters}, @{$self->parseArgumentList()});
         $self->assertTokenValue($self->getToken(), ")", __LINE__);
         $self->assertTokenValue($self->getToken(), ";", __LINE__);
         $newDataNode->signature->extendedAttributes($extendedAttributeList);
         return $newDataNode;
     }
     $self->assertUnexpectedToken($next->value(), __LINE__);
 }
 
 sub parseOptionalIdentifier
@@ skipping 873 matching lines @@
             $customConstructor->{overloadedIndex} = $index++;
             push(@{$interface->customConstructors}, $customConstructor);
         }
         delete $extendedAttributeList->{"CustomConstructors"};
         $extendedAttributeList->{"CustomConstructor"} = "VALUE_IS_MISSING";
     }
     $interface->extendedAttributes($extendedAttributeList);
 }
 
 1;