Changeset 129723 in webkit


Ignore:
Timestamp:
Sep 26, 2012 7:11:13 PM (12 years ago)
Author:
haraken@chromium.org
Message:

Move IDL extended attributes to the location specified in WebIDL
​https://bugs.webkit.org/show_bug.cgi?id=26398

Patch by Takashi Sakamoto <​tasak@google.com> on 2012-08-09
Reviewed by Kentaro Hara.

Recreated a new IDLParser based on the WebIDL spec:
​http://dev.w3.org/2006/webapi/WebIDL/

Firstly merges two grammars (editors draft and WebKit current IDL) and
generates IDL parser by using python script. The generated parser is
modified to generate the same outputs as the previous IDLParser.pm.
The new IDLParser.pm can parse both WebIDL grammar.

No new tests. Tested by comparing with sources generated by
the previous IDLParser.pm.

  • bindings/scripts/IDLParser.pm:

(new):
(assertTokenValue):
(assertTokenType):
(assertUnexpectedToken):
(Parse):
A method to start parsing a IDL file. Arguments and return values are
the same as the previous IDLParser.pm's Parse method.
(nextToken):
Implemented to see a next token, because of LL(1).
(getToken):
Returns current token, and update next and current token.
(getTokenInternal):
According to the regular expressions defined in WebIDL spec, extracts
one new token from a text string. The order of the regular expressions
to be tested is important, i.e. "0." should be considered as a float
token, but if firstly checks the integer regular expression, "0." is
considered as "0" and ".".
(parseDefinition):
(parseCallbackOrInterface):
(parseCallbackRestOrInterface):
(parseInterface):
(parsePartial):
(parsePartialDefinition):
(parsePartialInterface):
(parseInterfaceMember):
(parseDictionary):
(parseDictionaryMember):
(parsePartialDictionary):
(parseDefaultValue):
(parseException):
(parseExceptionMembers):
(parseEnum):
(parseEnumValueList):
(parseCallbackRest):
(parseTypedef):
(parseImplementsStatement):
(parseConst):
(parseConstValue):
(parseBooleanLiteral):
(parseFloatLiteral):
(parseAttributeOrOperationOrIterator):
(parseSerializer):
(parseSerializationPattern):
(parseQualifier):
(parseAttributeOrOperationRest):
(parseAttribute):
(parseAttributeRest):
(parseOperationOrIterator):
(parseSpecialOperation):
(parseSpecial):
(parseOperationOrIteratorRest):
(parseIteratorRest):
(parseOptionalIteratorInterfaceOrObject):
(parseOperationRest):
(parseArguments):
(parseArgument):
(parseOptionalOrRequiredArgument):
(parseArgumentName):
(parseExceptionMember):
(parseExceptionField):
(parseExtendedAttributeList):
(parseExtendedAttribute):
(parseExtendedAttributeRest2):
(parseArgumentNameKeyword):
(parseType):
(parseSingleType):
(parseUnionType):
(parseNonAnyType):
(parsePrimitiveType):
(parseUnrestrictedFloatType):
(parseFloatType):
(parseUnsignedIntegerType):
(parseNull):
(parseGet):
(parseInheritsGetter):
(parseSetGetRaises):
(parseGetRaises2):
(parseSetRaises):
(parseSetRaises3):
(parseDefinitionOld):
(parseModule):
(parseInterfaceOld):
(parseInterfaceMemberOld):
(parseDictionaryOld):
(parseDictionaryMemberOld):
(parseExceptionOld):
(parseEnumOld):
(parseAttributeOrOperationOrIteratorOld):
(parseAttributeOrOperationRestOld):
(parseAttributeOld):
(parseIn):
(parseOptionalSemicolon):
(applyMemberList):
(applyExtendedAttributeList):

  • bindings/scripts/test/CPP/WebDOMTestObj.cpp:

(WebDOMTestObj::longAttr):
(WebDOMTestObj::setLongAttr):
(WebDOMTestObj::voidMethodWithArgs):
(WebDOMTestObj::longMethod):
(WebDOMTestObj::longMethodWithArgs):
(WebDOMTestObj::objMethodWithArgs):
(WebDOMTestObj::convert1):
(WebDOMTestObj::convert2):
(WebDOMTestObj::convert3):
(WebDOMTestObj::convert4):
(WebDOMTestObj::convert5):

  • bindings/scripts/test/CPP/WebDOMTestObj.h:
  • bindings/scripts/test/GObject/WebKitDOMTestObj.cpp:

(webkit_dom_test_obj_set_property):
(webkit_dom_test_obj_get_property):
(webkit_dom_test_obj_class_init):
(webkit_dom_test_obj_void_method_with_args):
(webkit_dom_test_obj_long_method):
(webkit_dom_test_obj_long_method_with_args):
(webkit_dom_test_obj_obj_method_with_args):
(webkit_dom_test_obj_convert1):
(webkit_dom_test_obj_convert2):
(webkit_dom_test_obj_convert3):
(webkit_dom_test_obj_convert4):
(webkit_dom_test_obj_convert5):
(webkit_dom_test_obj_get_long_attr):
(webkit_dom_test_obj_set_long_attr):

  • bindings/scripts/test/GObject/WebKitDOMTestObj.h:
  • bindings/scripts/test/JS/JSTestObj.cpp:

(WebCore):
(WebCore::jsTestObjLongAttr):
(WebCore::setJSTestObjLongAttr):
(WebCore::jsTestObjPrototypeFunctionVoidMethodWithArgs):
(WebCore::jsTestObjPrototypeFunctionLongMethod):
(WebCore::jsTestObjPrototypeFunctionLongMethodWithArgs):
(WebCore::jsTestObjPrototypeFunctionObjMethodWithArgs):
(WebCore::jsTestObjPrototypeFunctionMethodReturningSequence):
(WebCore::jsTestObjPrototypeFunctionOverloadedMethod2):
(WebCore::jsTestObjPrototypeFunctionOverloadedMethod4):
(WebCore::jsTestObjPrototypeFunctionConvert1):
(WebCore::jsTestObjPrototypeFunctionConvert2):
(WebCore::jsTestObjPrototypeFunctionConvert3):
(WebCore::jsTestObjPrototypeFunctionConvert4):
(WebCore::jsTestObjPrototypeFunctionConvert5):

  • bindings/scripts/test/JS/JSTestObj.h:

(WebCore):

  • bindings/scripts/test/ObjC/DOMTestObj.h:
  • bindings/scripts/test/ObjC/DOMTestObj.mm:

(-[DOMTestObj longAttr]):
(-[DOMTestObj setLongAttr:]):
(-[DOMTestObj voidMethodWithArgs:strArg:objArg:]):
(-[DOMTestObj longMethod]):
(-[DOMTestObj longMethodWithArgs:strArg:objArg:]):
(-[DOMTestObj objMethodWithArgs:strArg:objArg:]):
(-[DOMTestObj customMethodWithArgs:strArg:objArg:]):
(-[DOMTestObj convert1:]):
(-[DOMTestObj convert2:]):
(-[DOMTestObj convert3:]):
(-[DOMTestObj convert4:]):
(-[DOMTestObj convert5:]):

  • bindings/scripts/test/TestObj.idl:

Removed the line which has only "JSC, V8".
Added argument to convert1, ... convert5.

  • bindings/scripts/test/V8/V8TestObj.cpp:

(WebCore::TestObjV8Internal::longAttrAttrGetter):
(WebCore::TestObjV8Internal::longAttrAttrSetter):
(WebCore::TestObjV8Internal::voidMethodWithArgsCallback):
(WebCore::TestObjV8Internal::longMethodCallback):
(WebCore::TestObjV8Internal::longMethodWithArgsCallback):
(WebCore::TestObjV8Internal::objMethodWithArgsCallback):
(WebCore::TestObjV8Internal::methodReturningSequenceCallback):
(WebCore::TestObjV8Internal::overloadedMethod2Callback):
(WebCore::TestObjV8Internal::overloadedMethod4Callback):
(WebCore::TestObjV8Internal::enabledAtRuntimeMethod1Callback):
(WebCore::TestObjV8Internal::enabledAtRuntimeMethod2Callback):
(WebCore::TestObjV8Internal::enabledPerContextMethod1Callback):
(WebCore::TestObjV8Internal::enabledPerContextMethod2Callback):
(WebCore::TestObjV8Internal::convert1Callback):
(WebCore::TestObjV8Internal::convert2Callback):
(WebCore::TestObjV8Internal::convert3Callback):
(WebCore::TestObjV8Internal::convert4Callback):
(WebCore::TestObjV8Internal::convert5Callback):
(WebCore):
(WebCore::ConfigureV8TestObjTemplate):

  • Modules/webaudio/AudioBufferSourceNode.idl:

As only restricted extended attribute syntax is supported, modify the
idl from [...] [...] to [..., ...].

Location:
trunk/Source/WebCore
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r129721 r129723  
     12012-08-09  Takashi Sakamoto  <tasak@google.com>
     2
     3        Move IDL extended attributes to the location specified in WebIDL
     4        https://bugs.webkit.org/show_bug.cgi?id=26398
     5
     6        Reviewed by Kentaro Hara.
     7
     8        Recreated a new IDLParser based on the WebIDL spec:
     9        http://dev.w3.org/2006/webapi/WebIDL/
     10
     11        Firstly merges two grammars (editors draft and WebKit current IDL) and
     12        generates IDL parser by using python script. The generated parser is
     13        modified to generate the same outputs as the previous IDLParser.pm.
     14        The new IDLParser.pm can parse both WebIDL grammar.
     15
     16        No new tests. Tested by comparing with sources generated by
     17        the previous IDLParser.pm.
     18
     19        * bindings/scripts/IDLParser.pm:
     20        (new):
     21        (assertTokenValue):
     22        (assertTokenType):
     23        (assertUnexpectedToken):
     24        (Parse):
     25        A method to start parsing a IDL file. Arguments and return values are
     26        the same as the previous IDLParser.pm's Parse method.
     27        (nextToken):
     28        Implemented to see a next token, because of LL(1).
     29        (getToken):
     30        Returns current token, and update next and current token.
     31        (getTokenInternal):
     32        According to the regular expressions defined in WebIDL spec, extracts
     33        one new token from a text string. The order of the regular expressions
     34        to be tested is important, i.e. "0." should be considered as a float
     35        token, but if firstly checks the integer regular expression, "0." is
     36        considered as "0" and ".".
     37        (parseDefinition):
     38        (parseCallbackOrInterface):
     39        (parseCallbackRestOrInterface):
     40        (parseInterface):
     41        (parsePartial):
     42        (parsePartialDefinition):
     43        (parsePartialInterface):
     44        (parseInterfaceMember):
     45        (parseDictionary):
     46        (parseDictionaryMember):
     47        (parsePartialDictionary):
     48        (parseDefaultValue):
     49        (parseException):
     50        (parseExceptionMembers):
     51        (parseEnum):
     52        (parseEnumValueList):
     53        (parseCallbackRest):
     54        (parseTypedef):
     55        (parseImplementsStatement):
     56        (parseConst):
     57        (parseConstValue):
     58        (parseBooleanLiteral):
     59        (parseFloatLiteral):
     60        (parseAttributeOrOperationOrIterator):
     61        (parseSerializer):
     62        (parseSerializationPattern):
     63        (parseQualifier):
     64        (parseAttributeOrOperationRest):
     65        (parseAttribute):
     66        (parseAttributeRest):
     67        (parseOperationOrIterator):
     68        (parseSpecialOperation):
     69        (parseSpecial):
     70        (parseOperationOrIteratorRest):
     71        (parseIteratorRest):
     72        (parseOptionalIteratorInterfaceOrObject):
     73        (parseOperationRest):
     74        (parseArguments):
     75        (parseArgument):
     76        (parseOptionalOrRequiredArgument):
     77        (parseArgumentName):
     78        (parseExceptionMember):
     79        (parseExceptionField):
     80        (parseExtendedAttributeList):
     81        (parseExtendedAttribute):
     82        (parseExtendedAttributeRest2):
     83        (parseArgumentNameKeyword):
     84        (parseType):
     85        (parseSingleType):
     86        (parseUnionType):
     87        (parseNonAnyType):
     88        (parsePrimitiveType):
     89        (parseUnrestrictedFloatType):
     90        (parseFloatType):
     91        (parseUnsignedIntegerType):
     92        (parseNull):
     93        (parseGet):
     94        (parseInheritsGetter):
     95        (parseSetGetRaises):
     96        (parseGetRaises2):
     97        (parseSetRaises):
     98        (parseSetRaises3):
     99        (parseDefinitionOld):
     100        (parseModule):
     101        (parseInterfaceOld):
     102        (parseInterfaceMemberOld):
     103        (parseDictionaryOld):
     104        (parseDictionaryMemberOld):
     105        (parseExceptionOld):
     106        (parseEnumOld):
     107        (parseAttributeOrOperationOrIteratorOld):
     108        (parseAttributeOrOperationRestOld):
     109        (parseAttributeOld):
     110        (parseIn):
     111        (parseOptionalSemicolon):
     112        (applyMemberList):
     113        (applyExtendedAttributeList):
     114        * bindings/scripts/test/CPP/WebDOMTestObj.cpp:
     115        (WebDOMTestObj::longAttr):
     116        (WebDOMTestObj::setLongAttr):
     117        (WebDOMTestObj::voidMethodWithArgs):
     118        (WebDOMTestObj::longMethod):
     119        (WebDOMTestObj::longMethodWithArgs):
     120        (WebDOMTestObj::objMethodWithArgs):
     121        (WebDOMTestObj::convert1):
     122        (WebDOMTestObj::convert2):
     123        (WebDOMTestObj::convert3):
     124        (WebDOMTestObj::convert4):
     125        (WebDOMTestObj::convert5):
     126        * bindings/scripts/test/CPP/WebDOMTestObj.h:
     127        * bindings/scripts/test/GObject/WebKitDOMTestObj.cpp:
     128        (webkit_dom_test_obj_set_property):
     129        (webkit_dom_test_obj_get_property):
     130        (webkit_dom_test_obj_class_init):
     131        (webkit_dom_test_obj_void_method_with_args):
     132        (webkit_dom_test_obj_long_method):
     133        (webkit_dom_test_obj_long_method_with_args):
     134        (webkit_dom_test_obj_obj_method_with_args):
     135        (webkit_dom_test_obj_convert1):
     136        (webkit_dom_test_obj_convert2):
     137        (webkit_dom_test_obj_convert3):
     138        (webkit_dom_test_obj_convert4):
     139        (webkit_dom_test_obj_convert5):
     140        (webkit_dom_test_obj_get_long_attr):
     141        (webkit_dom_test_obj_set_long_attr):
     142        * bindings/scripts/test/GObject/WebKitDOMTestObj.h:
     143        * bindings/scripts/test/JS/JSTestObj.cpp:
     144        (WebCore):
     145        (WebCore::jsTestObjLongAttr):
     146        (WebCore::setJSTestObjLongAttr):
     147        (WebCore::jsTestObjPrototypeFunctionVoidMethodWithArgs):
     148        (WebCore::jsTestObjPrototypeFunctionLongMethod):
     149        (WebCore::jsTestObjPrototypeFunctionLongMethodWithArgs):
     150        (WebCore::jsTestObjPrototypeFunctionObjMethodWithArgs):
     151        (WebCore::jsTestObjPrototypeFunctionMethodReturningSequence):
     152        (WebCore::jsTestObjPrototypeFunctionOverloadedMethod2):
     153        (WebCore::jsTestObjPrototypeFunctionOverloadedMethod4):
     154        (WebCore::jsTestObjPrototypeFunctionConvert1):
     155        (WebCore::jsTestObjPrototypeFunctionConvert2):
     156        (WebCore::jsTestObjPrototypeFunctionConvert3):
     157        (WebCore::jsTestObjPrototypeFunctionConvert4):
     158        (WebCore::jsTestObjPrototypeFunctionConvert5):
     159        * bindings/scripts/test/JS/JSTestObj.h:
     160        (WebCore):
     161        * bindings/scripts/test/ObjC/DOMTestObj.h:
     162        * bindings/scripts/test/ObjC/DOMTestObj.mm:
     163        (-[DOMTestObj longAttr]):
     164        (-[DOMTestObj setLongAttr:]):
     165        (-[DOMTestObj voidMethodWithArgs:strArg:objArg:]):
     166        (-[DOMTestObj longMethod]):
     167        (-[DOMTestObj longMethodWithArgs:strArg:objArg:]):
     168        (-[DOMTestObj objMethodWithArgs:strArg:objArg:]):
     169        (-[DOMTestObj customMethodWithArgs:strArg:objArg:]):
     170        (-[DOMTestObj convert1:]):
     171        (-[DOMTestObj convert2:]):
     172        (-[DOMTestObj convert3:]):
     173        (-[DOMTestObj convert4:]):
     174        (-[DOMTestObj convert5:]):
     175        * bindings/scripts/test/TestObj.idl:
     176        Removed the line which has only "JSC, V8".
     177        Added argument to convert1, ... convert5.
     178        * bindings/scripts/test/V8/V8TestObj.cpp:
     179        (WebCore::TestObjV8Internal::longAttrAttrGetter):
     180        (WebCore::TestObjV8Internal::longAttrAttrSetter):
     181        (WebCore::TestObjV8Internal::voidMethodWithArgsCallback):
     182        (WebCore::TestObjV8Internal::longMethodCallback):
     183        (WebCore::TestObjV8Internal::longMethodWithArgsCallback):
     184        (WebCore::TestObjV8Internal::objMethodWithArgsCallback):
     185        (WebCore::TestObjV8Internal::methodReturningSequenceCallback):
     186        (WebCore::TestObjV8Internal::overloadedMethod2Callback):
     187        (WebCore::TestObjV8Internal::overloadedMethod4Callback):
     188        (WebCore::TestObjV8Internal::enabledAtRuntimeMethod1Callback):
     189        (WebCore::TestObjV8Internal::enabledAtRuntimeMethod2Callback):
     190        (WebCore::TestObjV8Internal::enabledPerContextMethod1Callback):
     191        (WebCore::TestObjV8Internal::enabledPerContextMethod2Callback):
     192        (WebCore::TestObjV8Internal::convert1Callback):
     193        (WebCore::TestObjV8Internal::convert2Callback):
     194        (WebCore::TestObjV8Internal::convert3Callback):
     195        (WebCore::TestObjV8Internal::convert4Callback):
     196        (WebCore::TestObjV8Internal::convert5Callback):
     197        (WebCore):
     198        (WebCore::ConfigureV8TestObjTemplate):
     199        * Modules/webaudio/AudioBufferSourceNode.idl:
     200        As only restricted extended attribute syntax is supported, modify the
     201        idl from [...] [...] to [..., ...].
     202
    12032012-09-26  Yoshifumi Inoue  <yosin@chromium.org>
    2204

  • trunk/Source/WebCore/Modules/webaudio/AudioBufferSourceNode.idl

    r129260 r129723  
    4646
    4747        [V8MeasureAs=WebAudioStart] void start(in double when);
    48         [V8MeasureAs=WebAudioStart] [ImplementedAs=startGrain] void start(in double when, in double grainOffset, in double grainDuration);
     48        [V8MeasureAs=WebAudioStart, ImplementedAs=startGrain] void start(in double when, in double grainOffset, in double grainDuration);
    4949        void stop(in double when);
    5050

  • trunk/Source/WebCore/bindings/scripts/IDLParser.pm

    r122912 r129723  
    2222package IDLParser;
    2323
     24use Class::Struct;
     25
    2426use strict;
    25 use re 'eval';
    2627
    2728use IPC::Open2;
    … …  
    2930use preprocessor;
    3031
    31 use constant MODE_UNDEF    => 0; # Default mode.
    32 
    33 use constant MODE_MODULE  => 10; # 'module' section
    34 use constant MODE_INTERFACE  => 11; # 'interface' section
    35 use constant MODE_EXCEPTION  => 12; # 'exception' section
    36 
    37 # Helper variables
    38 my @temporaryContent;
    39 
    40 my $parseMode;
    41 my $preservedParseMode;
    42 
    43 my $beQuiet; # Should not display anything on STDOUT?
    44 my $document; # Will hold the resulting 'idlDocument'
    45 my $parentsOnly; # If 1, parse only enough to populate parents list
    46 
    47 sub InitializeGlobalData
    48 {
    49     @temporaryContent = "";
    50 
    51     $parseMode = MODE_UNDEF;
    52     $preservedParseMode = MODE_UNDEF;
    53 
    54     $document = 0;
    55     $parentsOnly = 0;
    56 }
    57 
    58 # Default Constructor
    59 sub new
    60 {
    61     my $object = shift;
    62     my $reference = { };
    63 
    64     InitializeGlobalData();
    65 
    66     $beQuiet = shift;
    67 
    68     bless($reference, $object);
    69     return $reference;
    70 }
    71 
    72 # Returns the parsed 'idlDocument'
     32use constant StringToken => 0;
     33use constant IntegerToken => 1;
     34use constant FloatToken => 2;
     35use constant IdentifierToken => 3;
     36use constant OtherToken => 4;
     37use constant EmptyToken => 5;
     38
     39struct( Token => {
     40    type => '$', # type of token
     41    value => '$' # value of token
     42});
     43
     44sub new {
     45    my $class = shift;
     46
     47    my $emptyToken = Token->new();
     48    $emptyToken->type(EmptyToken);
     49    $emptyToken->value("empty");
     50
     51    my $self = {
     52        DocumentContent => "",
     53        EmptyToken => $emptyToken,
     54        NextToken => $emptyToken,
     55        Token => $emptyToken,
     56        Line => "",
     57        LineNumber => 1
     58    };
     59    return bless $self, $class;
     60}
     61
     62sub assertTokenValue
     63{
     64    my $self = shift;
     65    my $token = shift;
     66    my $value = shift;
     67    my $line = shift;
     68    my $msg = "Next token should be " . $value . ", but " . $token->value() . " at " . $self->{Line};
     69    if (defined ($line)) {
     70        $msg .= " IDLParser.pm:" . $line;
     71    }
     72    die $msg unless $token->value() eq $value;
     73}
     74
     75sub assertTokenType
     76{
     77    my $self = shift;
     78    my $token = shift;
     79    my $type = shift;
     80    die "Next token's type should be " . $type . ", but " . $token->type() . " at " . $self->{Line} unless $token->type() eq $type;
     81}
     82
     83sub assertUnexpectedToken
     84{
     85    my $self = shift;
     86    my $token = shift;
     87    my $line = shift;
     88    my $msg = "Unexpected token " . $token . " at " . $self->{Line};
     89    if (defined ($line)) {
     90        $msg .= " IDLParser.pm:" . $line;
     91    }
     92    die $msg;
     93}
     94
    7395sub Parse
    7496{
    75     my $object = shift;
     97    my $self = shift;
    7698    my $fileName = shift;
    7799    my $defines = shift;
    78100    my $preprocessor = shift;
    79     $parentsOnly = shift;
    80 
    81     print " | *** Starting to parse $fileName...\n |\n" unless $beQuiet;
    82     my @documentContent = applyPreprocessor($fileName, $defines, $preprocessor);
    83 
    84     my $dataAvailable = 0;
    85 
    86     # Simple IDL Parser (tm)
    87     foreach (@documentContent) {
    88         my $newParseMode = $object->DetermineParseMode($_);
    89 
    90         if ($newParseMode ne MODE_UNDEF) {
    91             if ($dataAvailable eq 0) {
    92                 $dataAvailable = 1; # Start node building...
    93             } else {
    94                 $object->ProcessSection();
     101
     102    my @definitions = ();
     103
     104    my @lines = applyPreprocessor($fileName, $defines, $preprocessor);
     105    $self->{Line} = $lines[0];
     106    $self->{DocumentContent} = join(' ', @lines);
     107
     108    $self->getToken();
     109    eval {
     110        my $result = $self->parseDefinitions();
     111        push(@definitions, @{$result});
     112
     113        my $next = $self->nextToken();
     114        $self->assertTokenType($next, EmptyToken);
     115    };
     116    die $@ . " in $fileName" if $@;
     117
     118    die "No document found" unless @definitions;
     119
     120    my $document;
     121    if ($#definitions == 0 && ref($definitions[0]) eq "idlDocument") {
     122        $document = $definitions[0];
     123    } else {
     124        $document = new idlDocument();
     125        $document->module("");
     126        push(@{$document->classes}, @definitions);
     127    }
     128
     129    $document->fileName($fileName);
     130    return $document;
     131}
     132
     133sub nextToken
     134{
     135    my $self = shift;
     136    return $self->{NextToken};
     137}
     138
     139sub getToken
     140{
     141    my $self = shift;
     142    $self->{Token} = $self->{NextToken};
     143    $self->{NextToken} = $self->getTokenInternal();
     144    return $self->{Token};
     145}
     146
     147my $whitespaceTokenPattern = '^[\t\n\r ]*[\n\r]';
     148my $floatTokenPattern = '^(-?(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][+-]?[0-9]+)?|[0-9]+[Ee][+-]?[0-9]+))';
     149my $integerTokenPattern = '^(-?[1-9][0-9]*|-?0[Xx][0-9A-Fa-f]+|-?0[0-7]*)';
     150my $stringTokenPattern = '^(\"[^\"]*\")';
     151my $identifierTokenPattern = '^([A-Z_a-z][0-9A-Z_a-z]*)';
     152my $otherTokenPattern = '^(::|\.\.\.|[^\t\n\r 0-9A-Z_a-z])';
     153
     154sub getTokenInternal
     155{
     156    my $self = shift;
     157
     158    if ($self->{DocumentContent} =~ /$whitespaceTokenPattern/) {
     159        $self->{DocumentContent} =~ s/($whitespaceTokenPattern)//;
     160        my $skipped = $1;
     161        $self->{LineNumber}++ while ($skipped =~ /\n/g);
     162        if ($self->{DocumentContent} =~ /^([^\n\r]+)/) {
     163            $self->{Line} = $self->{LineNumber} . ":" . $1;
     164        } else {
     165            $self->{Line} = "Unknown";
     166        }
     167    }
     168    $self->{DocumentContent} =~ s/^([\t\n\r ]+)//;
     169    if ($self->{DocumentContent} eq "") {
     170        return $self->{EmptyToken};
     171    }
     172
     173    my $token = Token->new();
     174    if ($self->{DocumentContent} =~ /$floatTokenPattern/) {
     175        $token->type(FloatToken);
     176        $token->value($1);
     177        $self->{DocumentContent} =~ s/$floatTokenPattern//;
     178        return $token;
     179    }
     180    if ($self->{DocumentContent} =~ /$integerTokenPattern/) {
     181        $token->type(IntegerToken);
     182        $token->value($1);
     183        $self->{DocumentContent} =~ s/$integerTokenPattern//;
     184        return $token;
     185    }
     186    if ($self->{DocumentContent} =~ /$stringTokenPattern/) {
     187        $token->type(StringToken);
     188        $token->value($1);
     189        $self->{DocumentContent} =~ s/$stringTokenPattern//;
     190        return $token;
     191    }
     192    if ($self->{DocumentContent} =~ /$identifierTokenPattern/) {
     193        $token->type(IdentifierToken);
     194        $token->value($1);
     195        $self->{DocumentContent} =~ s/$identifierTokenPattern//;
     196        return $token;
     197    }
     198    if ($self->{DocumentContent} =~ /$otherTokenPattern/) {
     199        $token->type(OtherToken);
     200        $token->value($1);
     201        $self->{DocumentContent} =~ s/$otherTokenPattern//;
     202        return $token;
     203    }
     204    die "Failed in tokenizing at " . $self->{Line};
     205}
     206
     207my $nextAttributeOld_1 = '^(attribute|inherit|readonly)$';
     208my $nextPrimitiveType_1 = '^(int|long|short|unsigned)$';
     209my $nextPrimitiveType_2 = '^(double|float|unrestricted)$';
     210my $nextSetGetRaises2_1 = '^(;|getraises|setraises)$';
     211my $nextArgumentList_1 = '^(\(|ByteString|DOMString|Date|\[|any|boolean|byte|double|float|in|int|long|object|octet|optional|sequence|short|unrestricted|unsigned)$';
     212my $nextNonAnyType_1 = '^(boolean|byte|double|float|int|long|octet|short|unrestricted|unsigned)$';
     213my $nextInterfaceMemberOld_1 = '^(\(|ByteString|DOMString|Date|any|attribute|boolean|byte|creator|deleter|double|float|getter|inherit|int|legacycaller|long|object|octet|readonly|sequence|serializer|setter|short|static|stringifier|unrestricted|unsigned|void)$';
     214my $nextOptionalIteratorInterfaceOrObject_1 = '^(;|=)$';
     215my $nextAttributeOrOperationOrIterator_1 = '^(static|stringifier)$';
     216my $nextAttributeOrOperationOrIterator_2 = '^(\(|ByteString|DOMString|Date|any|boolean|byte|creator|deleter|double|float|getter|int|legacycaller|long|object|octet|sequence|setter|short|unrestricted|unsigned|void)$';
     217my $nextUnrestrictedFloatType_1 = '^(double|float)$';
     218my $nextExtendedAttributeRest3_1 = '^(,|\])$';
     219my $nextExceptionField_1 = '^(\(|ByteString|DOMString|Date|any|boolean|byte|double|float|int|long|object|octet|sequence|short|unrestricted|unsigned)$';
     220my $nextType_1 = '^(ByteString|DOMString|Date|any|boolean|byte|double|float|int|long|object|octet|sequence|short|unrestricted|unsigned)$';
     221my $nextSpecials_1 = '^(creator|deleter|getter|legacycaller|setter)$';
     222my $nextDefinitions_1 = '^(callback|dictionary|enum|exception|interface|partial|typedef)$';
     223my $nextExceptionMembers_1 = '^(\(|ByteString|DOMString|Date|\[|any|boolean|byte|const|double|float|int|long|object|octet|optional|sequence|short|unrestricted|unsigned)$';
     224my $nextAttributeRest_1 = '^(attribute|readonly)$';
     225my $nextSingleType_1 = '^(ByteString|DOMString|Date|boolean|byte|double|float|int|long|object|octet|sequence|short|unrestricted|unsigned)$';
     226my $nextGet_1 = '^(;|getraises|getter|setraises|setter)$';
     227my $nextArgumentName_1 = '^(attribute|callback|const|creator|deleter|dictionary|enum|exception|getter|implements|inherit|interface|legacycaller|partial|serializer|setter|static|stringifier|typedef|unrestricted)$';
     228my $nextConstValue_1 = '^(false|true)$';
     229my $nextConstValue_2 = '^(-|Infinity|NaN)$';
     230my $nextDefinition_1 = '^(callback|interface)$';
     231my $nextAttributeOrOperationRest_1 = '^(\(|ByteString|DOMString|Date|any|boolean|byte|double|float|int|long|object|octet|sequence|short|unrestricted|unsigned|void)$';
     232my $nextUnsignedIntegerType_1 = '^(int|long|short)$';
     233my $nextInterfaceMembers_1 = '^(\(|ByteString|DOMString|Date|any|attribute|boolean|byte|const|creator|deleter|double|float|getter|inherit|int|legacycaller|long|object|octet|readonly|sequence|serializer|setter|short|static|stringifier|unrestricted|unsigned|void)$';
     234my $nextDefaultValue_1 = '^(-|Infinity|NaN|false|null|true)$';
     235
     236sub parseDefinitions
     237{
     238    my $self = shift;
     239    my @definitions = ();
     240
     241    while (1) {
     242        my $next = $self->nextToken();
     243        my $definition;
     244        if ($next->value() eq "[") {
     245            my $extendedAttributeList = $self->parseExtendedAttributeList();
     246            $definition = $self->parseDefinition($extendedAttributeList);
     247        } elsif ($next->type() == IdentifierToken || $next->value() =~ /$nextDefinitions_1/) {
     248            $definition = $self->parseDefinitionOld();
     249        } else {
     250            last;
     251        }
     252        if (defined ($definition)) {
     253            push(@definitions, $definition);
     254        }
     255    }
     256    return \@definitions;
     257}
     258
     259sub parseDefinition
     260{
     261    my $self = shift;
     262    my $extendedAttributeList = shift;
     263
     264    my $next = $self->nextToken();
     265    if ($next->value() =~ /$nextDefinition_1/) {
     266        return $self->parseCallbackOrInterface($extendedAttributeList);
     267    }
     268    if ($next->value() eq "partial") {
     269        return $self->parsePartial($extendedAttributeList);
     270    }
     271    if ($next->value() eq "dictionary") {
     272        return $self->parseDictionary($extendedAttributeList);
     273    }
     274    if ($next->value() eq "exception") {
     275        return $self->parseException($extendedAttributeList);
     276    }
     277    if ($next->value() eq "enum") {
     278        return $self->parseEnum($extendedAttributeList);
     279    }
     280    if ($next->value() eq "typedef") {
     281        return $self->parseTypedef($extendedAttributeList);
     282    }
     283    if ($next->type() == IdentifierToken) {
     284        return $self->parseImplementsStatement($extendedAttributeList);
     285    }
     286    $self->assertUnexpectedToken($next->value(), __LINE__);
     287}
     288
     289sub parseCallbackOrInterface
     290{
     291    my $self = shift;
     292    my $extendedAttributeList = shift;
     293
     294    my $next = $self->nextToken();
     295    if ($next->value() eq "callback") {
     296        $self->assertTokenValue($self->getToken(), "callback", __LINE__);
     297        return $self->parseCallbackRestOrInterface($extendedAttributeList);
     298    }
     299    if ($next->value() eq "interface") {
     300        return $self->parseInterface($extendedAttributeList);
     301    }
     302    $self->assertUnexpectedToken($next->value(), __LINE__);
     303}
     304
     305sub parseCallbackRestOrInterface
     306{
     307    my $self = shift;
     308    my $extendedAttributeList = shift;
     309
     310    my $next = $self->nextToken();
     311    if ($next->value() eq "interface") {
     312        return $self->parseInterface($extendedAttributeList);
     313    }
     314    if ($next->type() == IdentifierToken) {
     315        return $self->parseCallbackRest($extendedAttributeList);
     316    }
     317    $self->assertUnexpectedToken($next->value(), __LINE__);
     318}
     319
     320sub parseInterface
     321{
     322    my $self = shift;
     323    my $extendedAttributeList = shift;
     324
     325    my $next = $self->nextToken();
     326    if ($next->value() eq "interface") {
     327        my $dataNode = new domClass();
     328        $self->assertTokenValue($self->getToken(), "interface", __LINE__);
     329        my $interfaceNameToken = $self->getToken();
     330        $self->assertTokenType($interfaceNameToken, IdentifierToken);
     331        $dataNode->name($interfaceNameToken->value());
     332        push(@{$dataNode->parents}, @{$self->parseInheritance()});
     333        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     334        my $interfaceMembers = $self->parseInterfaceMembers();
     335        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     336        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     337        applyMemberList($dataNode, $interfaceMembers);
     338        applyExtendedAttributeList($dataNode, $extendedAttributeList);
     339        return $dataNode;
     340    }
     341    $self->assertUnexpectedToken($next->value(), __LINE__);
     342}
     343
     344sub parsePartial
     345{
     346    my $self = shift;
     347    my $extendedAttributeList = shift;
     348
     349    my $next = $self->nextToken();
     350    if ($next->value() eq "partial") {
     351        $self->assertTokenValue($self->getToken(), "partial", __LINE__);
     352        return $self->parsePartialDefinition($extendedAttributeList);
     353    }
     354    $self->assertUnexpectedToken($next->value(), __LINE__);
     355}
     356
     357sub parsePartialDefinition
     358{
     359    my $self = shift;
     360    my $extendedAttributeList = shift;
     361
     362    my $next = $self->nextToken();
     363    if ($next->value() eq "interface") {
     364        return $self->parsePartialInterface($extendedAttributeList);
     365    }
     366    if ($next->value() eq "dictionary") {
     367        return $self->parsePartialDictionary($extendedAttributeList);
     368    }
     369    $self->assertUnexpectedToken($next->value(), __LINE__);
     370}
     371
     372sub parsePartialInterface
     373{
     374    my $self = shift;
     375    my $extendedAttributeList = shift;
     376
     377    my $next = $self->nextToken();
     378    if ($next->value() eq "interface") {
     379        $self->assertTokenValue($self->getToken(), "interface", __LINE__);
     380        $self->assertTokenType($self->getToken(), IdentifierToken);
     381        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     382        $self->parseInterfaceMembers();
     383        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     384        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     385        return;
     386    }
     387    $self->assertUnexpectedToken($next->value(), __LINE__);
     388}
     389
     390sub parseInterfaceMembers
     391{
     392    my $self = shift;
     393    my @interfaceMembers = ();
     394
     395    while (1) {
     396        my $next = $self->nextToken();
     397        my $interfaceMember;
     398
     399        if ($next->value() eq "[") {
     400            my $extendedAttributeList = $self->parseExtendedAttributeList();
     401            $interfaceMember = $self->parseInterfaceMember($extendedAttributeList);
     402        } elsif ($next->type() == IdentifierToken || $next->value() =~ /$nextInterfaceMembers_1/) {
     403            $interfaceMember = $self->parseInterfaceMemberOld();
     404        } else {
     405            last;
     406        }
     407        if (defined $interfaceMember) {
     408            push(@interfaceMembers, $interfaceMember);
     409        }
     410    }
     411    return \@interfaceMembers;
     412}
     413
     414sub parseInterfaceMember
     415{
     416    my $self = shift;
     417    my $extendedAttributeList = shift;
     418
     419    my $next = $self->nextToken();
     420    if ($next->value() eq "const") {
     421        return $self->parseConst($extendedAttributeList);
     422    }
     423    if ($next->type() == IdentifierToken || $next->value() =~ /$nextInterfaceMemberOld_1/) {
     424        return $self->parseAttributeOrOperationOrIterator($extendedAttributeList);
     425    }
     426    $self->assertUnexpectedToken($next->value(), __LINE__);
     427}
     428
     429sub parseDictionary
     430{
     431    my $self = shift;
     432    my $extendedAttributeList = shift;
     433
     434    my $next = $self->nextToken();
     435    if ($next->value() eq "dictionary") {
     436        $self->assertTokenValue($self->getToken(), "dictionary", __LINE__);
     437        $self->assertTokenType($self->getToken(), IdentifierToken);
     438        $self->parseInheritance();
     439        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     440        $self->parseDictionaryMembers();
     441        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     442        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     443        return;
     444    }
     445    $self->assertUnexpectedToken($next->value(), __LINE__);
     446}
     447
     448sub parseDictionaryMembers
     449{
     450    my $self = shift;
     451
     452    while (1) {
     453        my $next = $self->nextToken();
     454        if ($next->value() eq "[") {
     455            my $extendedAttributeList = $self->parseExtendedAttributeList();
     456            $self->parseDictionaryMember($extendedAttributeList);
     457        } elsif ($next->type() == IdentifierToken || $next->value() =~ /$nextExceptionField_1/) {
     458            $self->parseDictionaryMemberOld();
     459        } else {
     460            last;
     461        }
     462    }
     463}
     464
     465sub parseDictionaryMember
     466{
     467    my $self = shift;
     468    my $extendedAttributeList = shift;
     469
     470    my $next = $self->nextToken();
     471    if ($next->type() == IdentifierToken || $next->value() =~ /$nextExceptionField_1/) {
     472        $self->parseType();
     473        $self->assertTokenType($self->getToken(), IdentifierToken);
     474        $self->parseDefault();
     475        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     476        return;
     477    }
     478    $self->assertUnexpectedToken($next->value(), __LINE__);
     479}
     480
     481sub parsePartialDictionary
     482{
     483    my $self = shift;
     484    my $next = $self->nextToken();
     485    if ($next->value() eq "dictionary") {
     486        $self->assertTokenValue($self->getToken(), "dictionary", __LINE__);
     487        $self->assertTokenType($self->getToken(), IdentifierToken);
     488        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     489        $self->parseDictionaryMembers();
     490        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     491        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     492        return;
     493    }
     494    $self->assertUnexpectedToken($next->value(), __LINE__);
     495}
     496
     497sub parseDefault
     498{
     499    my $self = shift;
     500    my $next = $self->nextToken();
     501    if ($next->value() eq "=") {
     502        $self->assertTokenValue($self->getToken(), "=", __LINE__);
     503        return $self->parseDefaultValue();
     504    }
     505}
     506
     507sub parseDefaultValue
     508{
     509    my $self = shift;
     510    my $next = $self->nextToken();
     511    if ($next->type() == FloatToken || $next->type() == IntegerToken || $next->value() =~ /$nextDefaultValue_1/) {
     512        return $self->parseConstValue();
     513    }
     514    if ($next->type() == StringToken) {
     515        return $self->getToken()->value();
     516    }
     517    $self->assertUnexpectedToken($next->value(), __LINE__);
     518}
     519
     520sub parseException
     521{
     522    my $self = shift;
     523    my $extendedAttributeList = shift;
     524
     525    my $next = $self->nextToken();
     526    if ($next->value() eq "exception") {
     527        my $dataNode = new domClass();
     528        $self->assertTokenValue($self->getToken(), "exception", __LINE__);
     529        my $exceptionNameToken = $self->getToken();
     530        $self->assertTokenType($exceptionNameToken, IdentifierToken);
     531        $dataNode->name($exceptionNameToken->value());
     532        $dataNode->isException(1);
     533        push(@{$dataNode->parents}, @{$self->parseInheritance()});
     534        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     535        my $exceptionMembers = $self->parseExceptionMembers();
     536        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     537        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     538        applyMemberList($dataNode, $exceptionMembers);
     539        applyExtendedAttributeList($dataNode, $extendedAttributeList);
     540        return $dataNode;
     541    }
     542    $self->assertUnexpectedToken($next->value(), __LINE__);
     543}
     544
     545sub parseExceptionMembers
     546{
     547    my $self = shift;
     548    my @members = ();
     549
     550    while (1) {
     551        my $next = $self->nextToken();
     552        if ($next->type() == IdentifierToken || $next->value() =~ /$nextExceptionMembers_1/) {
     553            my $extendedAttributeList = $self->parseExtendedAttributeListAllowEmpty();
     554            #my $member = $self->parseExceptionMember($extendedAttributeList);
     555            my $member = $self->parseInterfaceMember($extendedAttributeList);
     556            if (defined ($member)) {
     557                push(@members, $member);
    95558            }
    96         }
    97 
    98         # Update detected data stream mode...
    99         if ($newParseMode ne MODE_UNDEF) {
    100             $parseMode = $newParseMode;
    101         }
    102 
    103         push(@temporaryContent, $_);
    104     }
    105 
    106     # Check if there is anything remaining to parse...
    107     if (($parseMode ne MODE_UNDEF) and ($#temporaryContent > 0)) {
    108         $object->ProcessSection();
    109     }
    110 
    111     print " | *** Finished parsing!\n" unless $beQuiet;
    112  
    113     $document->fileName($fileName);
    114 
    115     return $document;
    116 }
    117 
    118 sub ParseModule
    119 {
    120     my $object = shift;
     559        } else {
     560            last;
     561        }
     562    }
     563    return \@members;
     564}
     565
     566sub parseInheritance
     567{
     568    my $self = shift;
     569    my @parent = ();
     570
     571    my $next = $self->nextToken();
     572    if ($next->value() eq ":") {
     573        $self->assertTokenValue($self->getToken(), ":", __LINE__);
     574        my $token = $self->getToken();
     575        $self->assertTokenType($token, IdentifierToken);
     576        push(@parent, $token->value());
     577        # Multiple inheritance?
     578        push(@parent, @{$self->parseIdentifiers()});
     579    }
     580    return \@parent;
     581}
     582
     583sub parseEnum
     584{
     585    my $self = shift;
     586    my $extendedAttributeList = shift;
     587
     588    my $next = $self->nextToken();
     589    if ($next->value() eq "enum") {
     590        $self->assertTokenValue($self->getToken(), "enum", __LINE__);
     591        $self->assertTokenType($self->getToken(), IdentifierToken);
     592        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     593        $self->parseEnumValueList();
     594        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     595        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     596        return;
     597    }
     598    $self->assertUnexpectedToken($next->value(), __LINE__);
     599}
     600
     601sub parseEnumValueList
     602{
     603    my $self = shift;
     604    my $next = $self->nextToken();
     605    if ($next->type() == StringToken) {
     606        $self->assertTokenType($self->getToken(), StringToken);
     607        $self->parseEnumValues();
     608        return;
     609    }
     610    $self->assertUnexpectedToken($next->value(), __LINE__);
     611}
     612
     613sub parseEnumValues
     614{
     615    my $self = shift;
     616    my $next = $self->nextToken();
     617    if ($next->value() eq ",") {
     618        $self->assertTokenValue($self->getToken(), ",", __LINE__);
     619        $self->assertTokenType($self->getToken(), StringToken);
     620        $self->parseEnumValues();
     621    }
     622}
     623
     624sub parseCallbackRest
     625{
     626    my $self = shift;
     627    my $extendedAttributeList = shift;
     628
     629    my $next = $self->nextToken();
     630    if ($next->type() == IdentifierToken) {
     631        $self->assertTokenType($self->getToken(), IdentifierToken);
     632        $self->assertTokenValue($self->getToken(), "=", __LINE__);
     633        $self->parseReturnType();
     634        $self->assertTokenValue($self->getToken(), "(", __LINE__);
     635        $self->parseArgumentList();
     636        $self->assertTokenValue($self->getToken(), ")", __LINE__);
     637        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     638        return;
     639    }
     640    $self->assertUnexpectedToken($next->value(), __LINE__);
     641}
     642
     643sub parseTypedef
     644{
     645    my $self = shift;
     646    my $extendedAttributeList = shift;
     647
     648    my $next = $self->nextToken();
     649    if ($next->value() eq "typedef") {
     650        $self->assertTokenValue($self->getToken(), "typedef", __LINE__);
     651        $self->parseExtendedAttributeList();
     652        $self->parseType();
     653        $self->assertTokenType($self->getToken(), IdentifierToken);
     654        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     655        return;
     656    }
     657    $self->assertUnexpectedToken($next->value(), __LINE__);
     658}
     659
     660sub parseImplementsStatement
     661{
     662    my $self = shift;
     663    my $extendedAttributeList = shift;
     664
     665    my $next = $self->nextToken();
     666    if ($next->type() == IdentifierToken) {
     667        $self->assertTokenType($self->getToken(), IdentifierToken);
     668        $self->assertTokenValue($self->getToken(), "implements", __LINE__);
     669        $self->assertTokenType($self->getToken(), IdentifierToken);
     670        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     671        return;
     672    }
     673    $self->assertUnexpectedToken($next->value(), __LINE__);
     674}
     675
     676sub parseConst
     677{
     678    my $self = shift;
     679    my $extendedAttributeList = shift;
     680
     681    my $next = $self->nextToken();
     682    if ($next->value() eq "const") {
     683        my $newDataNode = new domConstant();
     684        $self->assertTokenValue($self->getToken(), "const", __LINE__);
     685        $newDataNode->type($self->parseConstType());
     686        my $constNameToken = $self->getToken();
     687        $self->assertTokenType($constNameToken, IdentifierToken);
     688        $newDataNode->name($constNameToken->value());
     689        $self->assertTokenValue($self->getToken(), "=", __LINE__);
     690        $newDataNode->value($self->parseConstValue());
     691        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     692        $newDataNode->extendedAttributes($extendedAttributeList);
     693        return $newDataNode;
     694    }
     695    $self->assertUnexpectedToken($next->value(), __LINE__);
     696}
     697
     698sub parseConstValue
     699{
     700    my $self = shift;
     701    my $next = $self->nextToken();
     702    if ($next->value() =~ /$nextConstValue_1/) {
     703        return $self->parseBooleanLiteral();
     704    }
     705    if ($next->value() eq "null") {
     706        $self->assertTokenValue($self->getToken(), "null", __LINE__);
     707        return "null";
     708    }
     709    if ($next->type() == FloatToken || $next->value() =~ /$nextConstValue_2/) {
     710        return $self->parseFloatLiteral();
     711    }
     712    # backward compatibility
     713    if ($next->type() == StringToken) {
     714        return $self->getToken()->value();
     715    }
     716    if ($next->type() == IntegerToken) {
     717        return $self->getToken()->value();
     718    }
     719    $self->assertUnexpectedToken($next->value(), __LINE__);
     720}
     721
     722sub parseBooleanLiteral
     723{
     724    my $self = shift;
     725    my $next = $self->nextToken();
     726    if ($next->value() eq "true") {
     727        $self->assertTokenValue($self->getToken(), "true", __LINE__);
     728        return "true";
     729    }
     730    if ($next->value() eq "false") {
     731        $self->assertTokenValue($self->getToken(), "false", __LINE__);
     732        return "false";
     733    }
     734    $self->assertUnexpectedToken($next->value(), __LINE__);
     735}
     736
     737sub parseFloatLiteral
     738{
     739    my $self = shift;
     740    my $next = $self->nextToken();
     741    if ($next->value() eq "-") {
     742        $self->assertTokenValue($self->getToken(), "-", __LINE__);
     743        $self->assertTokenValue($self->getToken(), "Infinity", __LINE__);
     744        return "-Infinity";
     745    }
     746    if ($next->value() eq "Infinity") {
     747        $self->assertTokenValue($self->getToken(), "Infinity", __LINE__);
     748        return "Infinity";
     749    }
     750    if ($next->value() eq "NaN") {
     751        $self->assertTokenValue($self->getToken(), "NaN", __LINE__);
     752        return "NaN";
     753    }
     754    if ($next->type() == FloatToken) {
     755        return $self->getToken()->value();
     756    }
     757    $self->assertUnexpectedToken($next->value(), __LINE__);
     758}
     759
     760sub parseAttributeOrOperationOrIterator
     761{
     762    my $self = shift;
     763    my $extendedAttributeList = shift;
     764
     765    my $next = $self->nextToken();
     766    if ($next->value() eq "serializer") {
     767        return $self->parseSerializer($extendedAttributeList);
     768    }
     769    if ($next->value() =~ /$nextAttributeOrOperationOrIterator_1/) {
     770        my $qualifier = $self->parseQualifier();
     771        my $newDataNode = $self->parseAttributeOrOperationRest($extendedAttributeList);
     772        if (defined($newDataNode) && $qualifier eq "static") {
     773            $newDataNode->isStatic(1);
     774        }
     775        return $newDataNode;
     776    }
     777    if ($next->value() =~ /$nextAttributeOld_1/) {
     778        return $self->parseAttribute($extendedAttributeList);
     779    }
     780    if ($next->type() == IdentifierToken || $next->value() =~ /$nextAttributeOrOperationOrIterator_2/) {
     781        return $self->parseOperationOrIterator($extendedAttributeList);
     782    }
     783    $self->assertUnexpectedToken($next->value(), __LINE__);
     784}
     785
     786sub parseSerializer
     787{
     788    my $self = shift;
     789    my $extendedAttributeList = shift;
     790
     791    my $next = $self->nextToken();
     792    if ($next->value() eq "serializer") {
     793        $self->assertTokenValue($self->getToken(), "serializer", __LINE__);
     794        return $self->parseSerializerRest($extendedAttributeList);
     795    }
     796    $self->assertUnexpectedToken($next->value(), __LINE__);
     797}
     798
     799sub parseSerializerRest
     800{
     801    my $self = shift;
     802    my $extendedAttributeList = shift;
     803
     804    my $next = $self->nextToken();
     805    if ($next->value() eq "=") {
     806        $self->assertTokenValue($self->getToken(), "=", __LINE__);
     807        return $self->parseSerializationPattern($extendedAttributeList);
     808    }
     809    if ($next->type() == IdentifierToken || $next->value() eq "(") {
     810        return $self->parseOperationRest($extendedAttributeList);
     811    }
     812}
     813
     814sub parseSerializationPattern
     815{
     816    my $self = shift;
     817    my $extendedAttributeList = shift;
     818
     819    my $next = $self->nextToken();
     820    if ($next->value() eq "{") {
     821        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     822        $self->parseSerializationPatternMap();
     823        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     824        return;
     825    }
     826    if ($next->value() eq "[") {
     827        $self->assertTokenValue($self->getToken(), "[", __LINE__);
     828        $self->parseSerializationPatternList();
     829        $self->assertTokenValue($self->getToken(), "]", __LINE__);
     830        return;
     831    }
     832    if ($next->type() == IdentifierToken) {
     833        $self->assertTokenType($self->getToken(), IdentifierToken);
     834        return;
     835    }
     836    $self->assertUnexpectedToken($next->value(), __LINE__);
     837}
     838
     839sub parseSerializationPatternMap
     840{
     841    my $self = shift;
     842    my $next = $self->nextToken();
     843    if ($next->value() eq "getter") {
     844        $self->assertTokenValue($self->getToken(), "getter", __LINE__);
     845        return;
     846    }
     847    if ($next->value() eq "inherit") {
     848        $self->assertTokenValue($self->getToken(), "inherit", __LINE__);
     849        $self->parseIdentifiers();
     850        return;
     851    }
     852    if ($next->type() == IdentifierToken) {
     853        $self->assertTokenType($self->getToken(), IdentifierToken);
     854        $self->parseIdentifiers();
     855    }
     856}
     857
     858sub parseSerializationPatternList
     859{
     860    my $self = shift;
     861    my $next = $self->nextToken();
     862    if ($next->value() eq "getter") {
     863        $self->assertTokenValue($self->getToken(), "getter", __LINE__);
     864        return;
     865    }
     866    if ($next->type() == IdentifierToken) {
     867        $self->assertTokenType($self->getToken(), IdentifierToken);
     868        $self->parseIdentifiers();
     869    }
     870}
     871
     872sub parseIdentifiers
     873{
     874    my $self = shift;
     875    my @idents = ();
     876
     877    while (1) {
     878        my $next = $self->nextToken();
     879        if ($next->value() eq ",") {
     880            $self->assertTokenValue($self->getToken(), ",", __LINE__);
     881            my $token = $self->getToken();
     882            $self->assertTokenType($token, IdentifierToken);
     883            push(@idents, $token->value());
     884        } else {
     885            last;
     886        }
     887    }
     888    return \@idents;
     889}
     890
     891sub parseQualifier
     892{
     893    my $self = shift;
     894
     895    my $next = $self->nextToken();
     896    if ($next->value() eq "static") {
     897        $self->assertTokenValue($self->getToken(), "static", __LINE__);
     898        return "static";
     899    }
     900    if ($next->value() eq "stringifier") {
     901        $self->assertTokenValue($self->getToken(), "stringifier", __LINE__);
     902        return "stringifier";
     903    }
     904    $self->assertUnexpectedToken($next->value(), __LINE__);
     905}
     906
     907sub parseAttributeOrOperationRest
     908{
     909    my $self = shift;
     910    my $extendedAttributeList = shift;
     911
     912    my $next = $self->nextToken();
     913    if ($next->value() =~ /$nextAttributeRest_1/) {
     914        return $self->parseAttributeRest($extendedAttributeList);
     915    }
     916    if ($next->value() eq ";") {
     917        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     918        return;
     919    }
     920    if ($next->type() == IdentifierToken || $next->value() =~ /$nextAttributeOrOperationRest_1/) {
     921        my $returnType = $self->parseReturnType();
     922        my $dataNode = $self->parseOperationRest($extendedAttributeList);
     923        if (defined ($dataNode)) {
     924            $dataNode->signature->type($returnType);
     925        }
     926        return $dataNode;
     927    }
     928    $self->assertUnexpectedToken($next->value(), __LINE__);
     929}
     930
     931sub parseAttribute
     932{
     933    my $self = shift;
     934    my $extendedAttributeList = shift;
     935
     936    my $next = $self->nextToken();
     937    if ($next->value() =~ /$nextAttributeOld_1/) {
     938        $self->parseInherit();
     939        return $self->parseAttributeRest($extendedAttributeList);
     940    }
     941    $self->assertUnexpectedToken($next->value(), __LINE__);
     942}
     943
     944sub parseAttributeRest
     945{
     946    my $self = shift;
     947    my $extendedAttributeList = shift;
     948
     949    my $next = $self->nextToken();
     950    if ($next->value() =~ /$nextAttributeRest_1/) {
     951        my $newDataNode = new domAttribute();
     952        if ($self->parseReadOnly()) {
     953            $newDataNode->type("readonly attribute");
     954        } else {
     955            $newDataNode->type("attribute");
     956        }
     957        $self->assertTokenValue($self->getToken(), "attribute", __LINE__);
     958        $newDataNode->signature(new domSignature());
     959        $newDataNode->signature->type($self->parseType());
     960        my $token = $self->getToken();
     961        $self->assertTokenType($token, IdentifierToken);
     962        $newDataNode->signature->name($token->value());
     963        my $getRef = $self->parseGet();
     964        if (defined $getRef) {
     965            push(@{$newDataNode->getterExceptions}, @{$getRef->{"getraises"}});
     966            push(@{$newDataNode->setterExceptions}, @{$getRef->{"setraises"}});
     967        }
     968        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     969        $newDataNode->signature->extendedAttributes($extendedAttributeList);
     970        return $newDataNode;
     971    }
     972    $self->assertUnexpectedToken($next->value(), __LINE__);
     973}
     974
     975sub parseInherit
     976{
     977    my $self = shift;
     978    my $next = $self->nextToken();
     979    if ($next->value() eq "inherit") {
     980        $self->assertTokenValue($self->getToken(), "inherit", __LINE__);
     981        return 1;
     982    }
     983    return 0;
     984}
     985
     986sub parseReadOnly
     987{
     988    my $self = shift;
     989    my $next = $self->nextToken();
     990    if ($next->value() eq "readonly") {
     991        $self->assertTokenValue($self->getToken(), "readonly", __LINE__);
     992        return 1;
     993    }
     994    return 0;
     995}
     996
     997sub parseOperationOrIterator
     998{
     999    my $self = shift;
     1000    my $extendedAttributeList = shift;
     1001
     1002    my $next = $self->nextToken();
     1003    if ($next->value() =~ /$nextSpecials_1/) {
     1004        return $self->parseSpecialOperation($extendedAttributeList);
     1005    }
     1006    if ($next->type() == IdentifierToken || $next->value() =~ /$nextAttributeOrOperationRest_1/) {
     1007        my $returnType = $self->parseReturnType();
     1008        my $dataNode = $self->parseOperationOrIteratorRest($extendedAttributeList);
     1009        if (defined ($dataNode)) {
     1010            $dataNode->signature->type($returnType);
     1011        }
     1012        return $dataNode;
     1013    }
     1014    $self->assertUnexpectedToken($next->value(), __LINE__);
     1015}
     1016
     1017sub parseSpecialOperation
     1018{
     1019    my $self = shift;
     1020    my $extendedAttributeList = shift;
     1021
     1022    my $next = $self->nextToken();
     1023    if ($next->value() =~ /$nextSpecials_1/) {
     1024        $self->parseSpecial();
     1025        $self->parseSpecials();
     1026        my $returnType = $self->parseReturnType();
     1027        my $dataNode = $self->parseOperationRest($extendedAttributeList);
     1028        if (defined ($dataNode)) {
     1029            $dataNode->signature->type($returnType);
     1030        }
     1031        return $dataNode;
     1032    }
     1033    $self->assertUnexpectedToken($next->value(), __LINE__);
     1034}
     1035
     1036sub parseSpecials
     1037{
     1038    my $self = shift;
     1039
     1040    while (1) {
     1041        my $next = $self->nextToken();
     1042        if ($next->value() =~ /$nextSpecials_1/) {
     1043            $self->parseSpecial();
     1044        } else {
     1045            last;
     1046        }
     1047    }
     1048    return [];
     1049}
     1050
     1051sub parseSpecial
     1052{
     1053    my $self = shift;
     1054    my $next = $self->nextToken();
     1055    if ($next->value() eq "getter") {
     1056        $self->assertTokenValue($self->getToken(), "getter", __LINE__);
     1057        return "getter";
     1058    }
     1059    if ($next->value() eq "setter") {
     1060        $self->assertTokenValue($self->getToken(), "setter", __LINE__);
     1061        return "setter";
     1062    }
     1063    if ($next->value() eq "creator") {
     1064        $self->assertTokenValue($self->getToken(), "creator", __LINE__);
     1065        return "creator";
     1066    }
     1067    if ($next->value() eq "deleter") {
     1068        $self->assertTokenValue($self->getToken(), "deleter", __LINE__);
     1069        return "deleter";
     1070    }
     1071    if ($next->value() eq "legacycaller") {
     1072        $self->assertTokenValue($self->getToken(), "legacycaller", __LINE__);
     1073        return "legacycaller";
     1074    }
     1075    $self->assertUnexpectedToken($next->value(), __LINE__);
     1076}
     1077
     1078sub parseOperationOrIteratorRest
     1079{
     1080    my $self = shift;
     1081    my $extendedAttributeList = shift;
     1082
     1083    my $next = $self->nextToken();
     1084    if ($next->value() eq "iterator") {
     1085        return $self->parseIteratorRest($extendedAttributeList);
     1086    }
     1087    if ($next->type() == IdentifierToken || $next->value() eq "(") {
     1088        return $self->parseOperationRest($extendedAttributeList);
     1089    }
     1090    $self->assertUnexpectedToken($next->value(), __LINE__);
     1091}
     1092
     1093sub parseIteratorRest
     1094{
     1095    my $self = shift;
     1096    my $extendedAttributeList = shift;
     1097
     1098    my $next = $self->nextToken();
     1099    if ($next->value() eq "iterator") {
     1100        $self->assertTokenValue($self->getToken(), "iterator", __LINE__);
     1101        $self->parseOptionalIteratorInterfaceOrObject($extendedAttributeList);
     1102        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     1103        return;
     1104    }
     1105    $self->assertUnexpectedToken($next->value(), __LINE__);
     1106}
     1107
     1108sub parseOptionalIteratorInterfaceOrObject
     1109{
     1110    my $self = shift;
     1111    my $extendedAttributeList = shift;
     1112
     1113    my $next = $self->nextToken();
     1114    if ($next->value() =~ /$nextOptionalIteratorInterfaceOrObject_1/) {
     1115        return $self->parseOptionalIteratorInterface($extendedAttributeList);
     1116    }
     1117    if ($next->value() eq "object") {
     1118        $self->assertTokenValue($self->getToken(), "object", __LINE__);
     1119        return;
     1120    }
     1121    $self->assertUnexpectedToken($next->value(), __LINE__);
     1122}
     1123
     1124sub parseOptionalIteratorInterface
     1125{
     1126    my $self = shift;
     1127    my $extendedAttributeList = shift;
     1128
     1129    my $next = $self->nextToken();
     1130    if ($next->value() eq "=") {
     1131        $self->assertTokenValue($self->getToken(), "=", __LINE__);
     1132        $self->assertTokenType($self->getToken(), IdentifierToken);
     1133    }
     1134}
     1135
     1136sub parseOperationRest
     1137{
     1138    my $self = shift;
     1139    my $extendedAttributeList = shift;
     1140
     1141    my $next = $self->nextToken();
     1142    if ($next->type() == IdentifierToken || $next->value() eq "(") {
     1143        my $newDataNode = new domFunction();
     1144        $newDataNode->signature(new domSignature());
     1145        my $name = $self->parseOptionalIdentifier();
     1146        $newDataNode->signature->name($name);
     1147        $self->assertTokenValue($self->getToken(), "(", $name, __LINE__);
     1148        push(@{$newDataNode->parameters}, @{$self->parseArgumentList()});
     1149        $self->assertTokenValue($self->getToken(), ")", __LINE__);
     1150        push(@{$newDataNode->raisesExceptions}, @{$self->parseRaises()});
     1151        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     1152        $newDataNode->signature->extendedAttributes($extendedAttributeList);
     1153        return $newDataNode;
     1154    }
     1155    $self->assertUnexpectedToken($next->value(), __LINE__);
     1156}
     1157
     1158sub parseOptionalIdentifier
     1159{
     1160    my $self = shift;
     1161    my $next = $self->nextToken();
     1162    if ($next->type() == IdentifierToken) {
     1163        my $token = $self->getToken();
     1164        return $token->value();
     1165    }
     1166    return "";
     1167}
     1168
     1169sub parseArgumentList
     1170{
     1171    my $self = shift;
     1172    my @arguments = ();
     1173
     1174    my $next = $self->nextToken();
     1175    if ($next->type() == IdentifierToken || $next->value() =~ /$nextArgumentList_1/) {
     1176        push(@arguments, $self->parseArgument());
     1177        push(@arguments, @{$self->parseArguments()});
     1178    }
     1179    return \@arguments;
     1180}
     1181
     1182sub parseArguments
     1183{
     1184    my $self = shift;
     1185    my @arguments = ();
     1186
     1187    while (1) {
     1188        my $next = $self->nextToken();
     1189        if ($next->value() eq ",") {
     1190            $self->assertTokenValue($self->getToken(), ",", __LINE__);
     1191            push(@arguments, $self->parseArgument());
     1192        } else {
     1193            last;
     1194        }
     1195    }
     1196    return \@arguments;
     1197}
     1198
     1199sub parseArgument
     1200{
     1201    my $self = shift;
     1202    my $next = $self->nextToken();
     1203    if ($next->type() == IdentifierToken || $next->value() =~ /$nextArgumentList_1/) {
     1204        my $in = $self->parseIn();
     1205        my $extendedAttributeList = $self->parseExtendedAttributeListAllowEmpty();
     1206        my $argument = $self->parseOptionalOrRequiredArgument($extendedAttributeList);
     1207        $argument->direction($self->parseIn());
     1208        return $argument;
     1209    }
     1210    $self->assertUnexpectedToken($next->value(), __LINE__);
     1211}
     1212
     1213sub parseOptionalOrRequiredArgument
     1214{
     1215    my $self = shift;
     1216    my $extendedAttributeList = shift;
     1217
     1218    my $paramDataNode = new domSignature();
     1219    $paramDataNode->extendedAttributes($extendedAttributeList);
     1220
     1221    my $next = $self->nextToken();
     1222    if ($next->value() eq "optional") {
     1223        $self->assertTokenValue($self->getToken(), "optional", __LINE__);
     1224        my $type = $self->parseType();
     1225        # domDataNode can only consider last "?".
     1226        if ($type =~ /\?$/) {
     1227            $paramDataNode->isNullable(1);
     1228        } else {
     1229            $paramDataNode->isNullable(0);
     1230        }
     1231        # Remove all "?" if exists, e.g. "object?[]?" -> "object[]".
     1232        $type =~ s/\?//g;
     1233        $paramDataNode->type($type);
     1234        $paramDataNode->name($self->parseArgumentName());
     1235        $self->parseDefault();
     1236        return $paramDataNode;
     1237    }
     1238    if ($next->type() == IdentifierToken || $next->value() =~ /$nextExceptionField_1/) {
     1239        my $type = $self->parseType();
     1240        # domDataNode can only consider last "?".
     1241        if ($type =~ /\?$/) {
     1242            $paramDataNode->isNullable(1);
     1243        } else {
     1244            $paramDataNode->isNullable(0);
     1245        }
     1246        # Remove all "?" if exists, e.g. "object?[]?" -> "object[]".
     1247        $type =~ s/\?//g;
     1248        $paramDataNode->type($type);
     1249        $self->parseEllipsis();
     1250        $paramDataNode->name($self->parseArgumentName());
     1251        return $paramDataNode;
     1252    }
     1253    $self->assertUnexpectedToken($next->value(), __LINE__);
     1254}
     1255
     1256sub parseArgumentName
     1257{
     1258    my $self = shift;
     1259    my $next = $self->nextToken();
     1260    if ($next->value() =~ /$nextArgumentName_1/) {
     1261        return $self->parseArgumentNameKeyword();
     1262    }
     1263    if ($next->type() == IdentifierToken) {
     1264        return $self->getToken()->value();
     1265    }
     1266    $self->assertUnexpectedToken($next->value(), __LINE__);
     1267}
     1268
     1269sub parseEllipsis
     1270{
     1271    my $self = shift;
     1272    my $next = $self->nextToken();
     1273    if ($next->value() eq "...") {
     1274        $self->assertTokenValue($self->getToken(), "...", __LINE__);
     1275        return 1;
     1276    }
     1277    return 0;
     1278}
     1279
     1280sub parseExceptionMember
     1281{
     1282    my $self = shift;
     1283    my $extendedAttributeList = shift;
     1284
     1285    my $next = $self->nextToken();
     1286    if ($next->value() eq "const") {
     1287        return $self->parseConst($extendedAttributeList);
     1288    }
     1289    if ($next->type() == IdentifierToken || $next->value() =~ /$nextExceptionField_1/) {
     1290        return $self->parseExceptionField($extendedAttributeList);
     1291    }
     1292    $self->assertUnexpectedToken($next->value(), __LINE__);
     1293}
     1294
     1295sub parseExceptionField
     1296{
     1297    my $self = shift;
     1298    my $extendedAttributeList = shift;
     1299
     1300    my $next = $self->nextToken();
     1301    if ($next->type() == IdentifierToken || $next->value() =~ /$nextExceptionField_1/) {
     1302        my $newDataNode = new domAttribute();
     1303        $newDataNode->type("readonly attribute");
     1304        $newDataNode->signature(new domSignature());
     1305        $newDataNode->signature->type($self->parseType());
     1306        my $token = $self->getToken();
     1307        $self->assertTokenType($token, IdentifierToken);
     1308        $newDataNode->signature->name($token->value());
     1309        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     1310        $newDataNode->signature->extendedAttributes($extendedAttributeList);
     1311        return $newDataNode;
     1312    }
     1313    $self->assertUnexpectedToken($next->value(), __LINE__);
     1314}
     1315
     1316sub parseExtendedAttributeListAllowEmpty
     1317{
     1318    my $self = shift;
     1319    my $next = $self->nextToken();
     1320    if ($next->value() eq "[") {
     1321        return $self->parseExtendedAttributeList();
     1322    }
     1323    return {};
     1324}
     1325
     1326sub parseExtendedAttributeList
     1327{
     1328    my $self = shift;
     1329    my $next = $self->nextToken();
     1330    if ($next->value() eq "[") {
     1331        $self->assertTokenValue($self->getToken(), "[", __LINE__);
     1332        my $extendedAttributeList = {};
     1333        my $attr = $self->parseExtendedAttribute();
     1334        for my $key (keys %{$attr}) {
     1335            $extendedAttributeList->{$key} = $attr->{$key};
     1336        }
     1337        $attr = $self->parseExtendedAttributes();
     1338        for my $key (keys %{$attr}) {
     1339            $extendedAttributeList->{$key} = $attr->{$key};
     1340        }
     1341        $self->assertTokenValue($self->getToken(), "]", __LINE__);
     1342        return $extendedAttributeList;
     1343    }
     1344    $self->assertUnexpectedToken($next->value(), __LINE__);
     1345}
     1346
     1347sub parseExtendedAttributes
     1348{
     1349    my $self = shift;
     1350    my $extendedAttributeList = {};
     1351
     1352    while (1) {
     1353        my $next = $self->nextToken();
     1354        if ($next->value() eq ",") {
     1355            $self->assertTokenValue($self->getToken(), ",", __LINE__);
     1356            my $attr = $self->parseExtendedAttribute2();
     1357            for my $key (keys %{$attr}) {
     1358                $extendedAttributeList->{$key} = $attr->{$key};
     1359            }
     1360        } else {
     1361            last;
     1362        }
     1363    }
     1364    return $extendedAttributeList;
     1365}
     1366
     1367sub parseExtendedAttribute
     1368{
     1369    my $self = shift;
     1370    my $next = $self->nextToken();
     1371    if ($next->type() == IdentifierToken) {
     1372        my $token = $self->getToken();
     1373        return $self->parseExtendedAttributeRest($token->value());
     1374    }
     1375    # backward compatibility. Spec doesn' allow "[]". But WebKit requires.
     1376    if ($next->value() eq ']') {
     1377        return {};
     1378    }
     1379    $self->assertUnexpectedToken($next->value(), __LINE__);
     1380}
     1381
     1382sub parseExtendedAttribute2
     1383{
     1384    my $self = shift;
     1385    my $next = $self->nextToken();
     1386    if ($next->type() == IdentifierToken) {
     1387        my $token = $self->getToken();
     1388        return $self->parseExtendedAttributeRest($token->value());
     1389    }
     1390    return {};
     1391}
     1392
     1393sub parseExtendedAttributeRest
     1394{
     1395    my $self = shift;
     1396    my $name = shift;
     1397    my $attrs = {};
     1398
     1399    my $next = $self->nextToken();
     1400    if ($next->value() eq "(") {
     1401        $self->assertTokenValue($self->getToken(), "(", __LINE__);
     1402        $attrs->{$name} = $self->parseArgumentList();
     1403        $self->assertTokenValue($self->getToken(), ")", __LINE__);
     1404        return $attrs;
     1405    }
     1406    if ($next->value() eq "=") {
     1407        $self->assertTokenValue($self->getToken(), "=", __LINE__);
     1408        $attrs->{$name} = $self->parseExtendedAttributeRest2();
     1409        return $attrs;
     1410    }
     1411
     1412    if ($name eq "Constructor") {
     1413        $attrs->{$name} = [];
     1414    } else {
     1415        $attrs->{$name} = "VALUE_IS_MISSING";
     1416    }
     1417    return $attrs;
     1418}
     1419
     1420sub parseExtendedAttributeRest2
     1421{
     1422    my $self = shift;
     1423    my $next = $self->nextToken();
     1424    if ($next->type() == IdentifierToken) {
     1425        my $token = $self->getToken();
     1426        return $self->parseExtendedAttributeRest3($token->value());
     1427    }
     1428    if ($next->type() == IntegerToken) {
     1429        my $token = $self->getToken();
     1430        return $token->value();
     1431    }
     1432    $self->assertUnexpectedToken($next->value(), __LINE__);
     1433}
     1434
     1435sub parseExtendedAttributeRest3
     1436{
     1437    my $self = shift;
     1438    my $name = shift;
     1439
     1440    my $next = $self->nextToken();
     1441    if ($next->value() eq "&") {
     1442        $self->assertTokenValue($self->getToken(), "&", __LINE__);
     1443        my $token = $self->getToken();
     1444        $self->assertTokenType($token, IdentifierToken);
     1445        return $name . "&" . $token->value();
     1446    }
     1447    if ($next->value() eq "|") {
     1448        $self->assertTokenValue($self->getToken(), "|", __LINE__);
     1449        my $token = $self->getToken();
     1450        $self->assertTokenType($token, IdentifierToken);
     1451        return $name . "|" . $token->value();
     1452    }
     1453    if ($next->value() eq "(") {
     1454        my $attr = {};
     1455        $self->assertTokenValue($self->getToken(), "(", __LINE__);
     1456        $attr->{$name} = $self->parseArgumentList();
     1457        $self->assertTokenValue($self->getToken(), ")", __LINE__);
     1458        return $attr;
     1459    }
     1460    if ($next->type() == IdentifierToken || $next->value() =~ /$nextExtendedAttributeRest3_1/) {
     1461        my @names = ();
     1462        push(@names, $name);
     1463        push(@names, @{$self->parseIdentifierList()});
     1464        return join(' ', @names);
     1465    }
     1466    $self->assertUnexpectedToken($next->value());
     1467}
     1468
     1469sub parseIdentifierList
     1470{
     1471    my $self = shift;
     1472    my @names = ();
     1473
     1474    while (1) {
     1475        my $next = $self->nextToken();
     1476        if ($next->type() == IdentifierToken) {
     1477            push(@names, $self->getToken()->value());
     1478        } else {
     1479            last;
     1480        }
     1481    }
     1482    return \@names;
     1483}
     1484
     1485sub parseArgumentNameKeyword
     1486{
     1487    my $self = shift;
     1488    my $next = $self->nextToken();
     1489    if ($next->value() eq "attribute") {
     1490        return $self->getToken()->value();
     1491    }
     1492    if ($next->value() eq "callback") {
     1493        return $self->getToken()->value();
     1494    }
     1495    if ($next->value() eq "const") {
     1496        return $self->getToken()->value();
     1497    }
     1498    if ($next->value() eq "creator") {
     1499        return $self->getToken()->value();
     1500    }
     1501    if ($next->value() eq "deleter") {
     1502        return $self->getToken()->value();
     1503    }
     1504    if ($next->value() eq "dictionary") {
     1505        return $self->getToken()->value();
     1506    }
     1507    if ($next->value() eq "enum") {
     1508        return $self->getToken()->value();
     1509    }
     1510    if ($next->value() eq "exception") {
     1511        return $self->getToken()->value();
     1512    }
     1513    if ($next->value() eq "getter") {
     1514        return $self->getToken()->value();
     1515    }
     1516    if ($next->value() eq "implements") {
     1517        return $self->getToken()->value();
     1518    }
     1519    if ($next->value() eq "inherit") {
     1520        return $self->getToken()->value();
     1521    }
     1522    if ($next->value() eq "interface") {
     1523        return $self->getToken()->value();
     1524    }
     1525    if ($next->value() eq "legacycaller") {
     1526        return $self->getToken()->value();
     1527    }
     1528    if ($next->value() eq "partial") {
     1529        return $self->getToken()->value();
     1530    }
     1531    if ($next->value() eq "serializer") {
     1532        return $self->getToken()->value();
     1533    }
     1534    if ($next->value() eq "setter") {
     1535        return $self->getToken()->value();
     1536    }
     1537    if ($next->value() eq "static") {
     1538        return $self->getToken()->value();
     1539    }
     1540    if ($next->value() eq "stringifier") {
     1541        return $self->getToken()->value();
     1542    }
     1543    if ($next->value() eq "typedef") {
     1544        return $self->getToken()->value();
     1545    }
     1546    if ($next->value() eq "unrestricted") {
     1547        return $self->getToken()->value();
     1548    }
     1549    $self->assertUnexpectedToken($next->value(), __LINE__);
     1550}
     1551
     1552sub parseType
     1553{
     1554    my $self = shift;
     1555    my $next = $self->nextToken();
     1556    if ($next->value() eq "(") {
     1557        $self->parseUnionType();
     1558        $self->parseTypeSuffix();
     1559        return;
     1560    }
     1561    if ($next->type() == IdentifierToken || $next->value() =~ /$nextType_1/) {
     1562        return $self->parseSingleType();
     1563    }
     1564    $self->assertUnexpectedToken($next->value(), __LINE__);
     1565}
     1566
     1567sub parseSingleType
     1568{
     1569    my $self = shift;
     1570    my $next = $self->nextToken();
     1571    if ($next->value() eq "any") {
     1572        $self->assertTokenValue($self->getToken(), "any", __LINE__);
     1573        return "any" . $self->parseTypeSuffixStartingWithArray();
     1574    }
     1575    if ($next->type() == IdentifierToken || $next->value() =~ /$nextSingleType_1/) {
     1576        return $self->parseNonAnyType();
     1577    }
     1578    $self->assertUnexpectedToken($next->value(), __LINE__);
     1579}
     1580
     1581sub parseUnionType
     1582{
     1583    my $self = shift;
     1584    my $next = $self->nextToken();
     1585    if ($next->value() eq "(") {
     1586        $self->assertTokenValue($self->getToken(), "(", __LINE__);
     1587        $self->parseUnionMemberType();
     1588        $self->assertTokenValue($self->getToken(), "or", __LINE__);
     1589        $self->parseUnionMemberType();
     1590        $self->parseUnionMemberTypes();
     1591        $self->assertTokenValue($self->getToken(), ")", __LINE__);
     1592        return;
     1593    }
     1594    $self->assertUnexpectedToken($next->value(), __LINE__);
     1595}
     1596
     1597sub parseUnionMemberType
     1598{
     1599    my $self = shift;
     1600    my $next = $self->nextToken();
     1601    if ($next->value() eq "(") {
     1602        $self->parseUnionType();
     1603        $self->parseTypeSuffix();
     1604        return;
     1605    }
     1606    if ($next->value() eq "any") {
     1607        $self->assertTokenValue($self->getToken(), "any", __LINE__);
     1608        $self->assertTokenValue($self->getToken(), "[", __LINE__);
     1609        $self->assertTokenValue($self->getToken(), "]", __LINE__);
     1610        $self->parseTypeSuffix();
     1611        return;
     1612    }
     1613    if ($next->type() == IdentifierToken || $next->value() =~ /$nextSingleType_1/) {
     1614        $self->parseNonAnyType();
     1615        return;
     1616    }
     1617    $self->assertUnexpectedToken($next->value(), __LINE__);
     1618}
     1619
     1620sub parseUnionMemberTypes
     1621{
     1622    my $self = shift;
     1623    my $next = $self->nextToken();
     1624    if ($next->value() eq "or") {
     1625        $self->assertTokenValue($self->getToken(), "or", __LINE__);
     1626        $self->parseUnionMemberType();
     1627        $self->parseUnionMemberTypes();
     1628    }
     1629}
     1630
     1631sub parseNonAnyType
     1632{
     1633    my $self = shift;
     1634    my $next = $self->nextToken();
     1635    if ($next->value() =~ /$nextNonAnyType_1/) {
     1636        return $self->parsePrimitiveType() . $self->parseTypeSuffix();
     1637    }
     1638    if ($next->value() eq "ByteString") {
     1639        $self->assertTokenValue($self->getToken(), "ByteString", __LINE__);
     1640        return "ByteString" . $self->parseTypeSuffix();
     1641    }
     1642    if ($next->value() eq "DOMString") {
     1643        $self->assertTokenValue($self->getToken(), "DOMString", __LINE__);
     1644        return "DOMString" . $self->parseTypeSuffix();
     1645    }
     1646    if ($next->value() eq "sequence") {
     1647        $self->assertTokenValue($self->getToken(), "sequence", __LINE__);
     1648        $self->assertTokenValue($self->getToken(), "<", __LINE__);
     1649        my $type = $self->parseType();
     1650        $self->assertTokenValue($self->getToken(), ">", __LINE__);
     1651        return "sequence<" . $type . ">" . $self->parseNull();
     1652    }
     1653    if ($next->value() eq "object") {
     1654        $self->assertTokenValue($self->getToken(), "object", __LINE__);
     1655        return "object" . $self->parseTypeSuffix();
     1656    }
     1657    if ($next->value() eq "Date") {
     1658        $self->assertTokenValue($self->getToken(), "Date", __LINE__);
     1659        return "Date" . $self->parseTypeSuffix();
     1660    }
     1661    if ($next->type() == IdentifierToken) {
     1662        my $token = $self->getToken();
     1663        return $token->value() . $self->parseTypeSuffix();
     1664    }
     1665    $self->assertUnexpectedToken($next->value(), __LINE__);
     1666}
     1667
     1668sub parseConstType
     1669{
     1670    my $self = shift;
     1671    my $next = $self->nextToken();
     1672    if ($next->value() =~ /$nextNonAnyType_1/) {
     1673        return $self->parsePrimitiveType() . $self->parseNull();
     1674    }
     1675    if ($next->type() == IdentifierToken) {
     1676        my $token = $self->getToken();
     1677        return $token->value() . $self->parseNull();
     1678    }
     1679    $self->assertUnexpectedToken($next->value(), __LINE__);
     1680}
     1681
     1682sub parsePrimitiveType
     1683{
     1684    my $self = shift;
     1685    my $next = $self->nextToken();
     1686    if ($next->value() =~ /$nextPrimitiveType_1/) {
     1687        return $self->parseUnsignedIntegerType();
     1688    }
     1689    if ($next->value() =~ /$nextPrimitiveType_2/) {
     1690        return $self->parseUnrestrictedFloatType();
     1691    }
     1692    if ($next->value() eq "boolean") {
     1693        $self->assertTokenValue($self->getToken(), "boolean", __LINE__);
     1694        return "boolean";
     1695    }
     1696    if ($next->value() eq "byte") {
     1697        $self->assertTokenValue($self->getToken(), "byte", __LINE__);
     1698        return "byte";
     1699    }
     1700    if ($next->value() eq "octet") {
     1701        $self->assertTokenValue($self->getToken(), "octet", __LINE__);
     1702        return "octet";
     1703    }
     1704    $self->assertUnexpectedToken($next->value(), __LINE__);
     1705}
     1706
     1707sub parseUnrestrictedFloatType
     1708{
     1709    my $self = shift;
     1710    my $next = $self->nextToken();
     1711    if ($next->value() eq "unrestricted") {
     1712        $self->assertTokenValue($self->getToken(), "unrestricted", __LINE__);
     1713        return "unrestricted" . $self->parseFloatType();
     1714    }
     1715    if ($next->value() =~ /$nextUnrestrictedFloatType_1/) {
     1716        return $self->parseFloatType();
     1717    }
     1718    $self->assertUnexpectedToken($next->value(), __LINE__);
     1719}
     1720
     1721sub parseFloatType
     1722{
     1723    my $self = shift;
     1724    my $next = $self->nextToken();
     1725    if ($next->value() eq "float") {
     1726        $self->assertTokenValue($self->getToken(), "float", __LINE__);
     1727        return "float";
     1728    }
     1729    if ($next->value() eq "double") {
     1730        $self->assertTokenValue($self->getToken(), "double", __LINE__);
     1731        return "double";
     1732    }
     1733    $self->assertUnexpectedToken($next->value(), __LINE__);
     1734}
     1735
     1736sub parseUnsignedIntegerType
     1737{
     1738    my $self = shift;
     1739    my $next = $self->nextToken();
     1740    if ($next->value() eq "unsigned") {
     1741        $self->assertTokenValue($self->getToken(), "unsigned", __LINE__);
     1742        return "unsigned " . $self->parseIntegerType();
     1743    }
     1744    if ($next->value() =~ /$nextUnsignedIntegerType_1/) {
     1745        return $self->parseIntegerType();
     1746    }
     1747    $self->assertUnexpectedToken($next->value(), __LINE__);
     1748}
     1749
     1750sub parseIntegerType
     1751{
     1752    my $self = shift;
     1753    my $next = $self->nextToken();
     1754    if ($next->value() eq "short") {
     1755        $self->assertTokenValue($self->getToken(), "short", __LINE__);
     1756        return "short";
     1757    }
     1758    if ($next->value() eq "int") {
     1759        $self->assertTokenValue($self->getToken(), "int", __LINE__);
     1760        return "int";
     1761    }
     1762    if ($next->value() eq "long") {
     1763        $self->assertTokenValue($self->getToken(), "long", __LINE__);
     1764        if ($self->parseOptionalLong()) {
     1765            return "long long";
     1766        }
     1767        return "long";
     1768    }
     1769    $self->assertUnexpectedToken($next->value(), __LINE__);
     1770}
     1771
     1772sub parseOptionalLong
     1773{
     1774    my $self = shift;
     1775    my $next = $self->nextToken();
     1776    if ($next->value() eq "long") {
     1777        $self->assertTokenValue($self->getToken(), "long", __LINE__);
     1778        return 1;
     1779    }
     1780    return 0;
     1781}
     1782
     1783sub parseTypeSuffix
     1784{
     1785    my $self = shift;
     1786    my $next = $self->nextToken();
     1787    if ($next->value() eq "[") {
     1788        $self->assertTokenValue($self->getToken(), "[", __LINE__);
     1789        $self->assertTokenValue($self->getToken(), "]", __LINE__);
     1790        return "[]" . $self->parseTypeSuffix();
     1791    }
     1792    if ($next->value() eq "?") {
     1793        $self->assertTokenValue($self->getToken(), "?", __LINE__);
     1794        return "?" . $self->parseTypeSuffixStartingWithArray();
     1795    }
     1796    return "";
     1797}
     1798
     1799sub parseTypeSuffixStartingWithArray
     1800{
     1801    my $self = shift;
     1802    my $next = $self->nextToken();
     1803    if ($next->value() eq "[") {
     1804        $self->assertTokenValue($self->getToken(), "[", __LINE__);
     1805        $self->assertTokenValue($self->getToken(), "]", __LINE__);
     1806        return "[]" . $self->parseTypeSuffix();
     1807    }
     1808    return "";
     1809}
     1810
     1811sub parseNull
     1812{
     1813    my $self = shift;
     1814    my $next = $self->nextToken();
     1815    if ($next->value() eq "?") {
     1816        $self->assertTokenValue($self->getToken(), "?", __LINE__);
     1817        return "?";
     1818    }
     1819    return "";
     1820}
     1821
     1822sub parseReturnType
     1823{
     1824    my $self = shift;
     1825    my $next = $self->nextToken();
     1826    if ($next->value() eq "void") {
     1827        $self->assertTokenValue($self->getToken(), "void", __LINE__);
     1828        return "void";
     1829    }
     1830    if ($next->type() == IdentifierToken || $next->value() =~ /$nextExceptionField_1/) {
     1831        return $self->parseType();
     1832    }
     1833    $self->assertUnexpectedToken($next->value(), __LINE__);
     1834}
     1835
     1836sub parseGet
     1837{
     1838    my $self = shift;
     1839    my $next = $self->nextToken();
     1840    if ($next->value() eq "inherits") {
     1841        my $attr = {};
     1842        $self->parseInheritsGetter();
     1843        $attr->{"inherits"} = 1;
     1844        $attr->{"getraises"} = [];
     1845        $attr->{"setraises"} = $self->parseSetRaises();
     1846        return $attr;
     1847    }
     1848    if ($next->value() =~ /$nextGet_1/) {
     1849        return $self->parseSetGetRaises();
     1850    }
     1851}
     1852
     1853sub parseInheritsGetter
     1854{
     1855    my $self = shift;
     1856    my $next = $self->nextToken();
     1857    if ($next->value() eq "inherits") {
     1858        $self->assertTokenValue($self->getToken(), "inherits", __LINE__);
     1859        $self->assertTokenValue($self->getToken(), "getter", __LINE__);
     1860        return;
     1861    }
     1862    $self->assertUnexpectedToken($next->value(), __LINE__);
     1863}
     1864
     1865sub parseSetGetRaises
     1866{
     1867    my $self = shift;
     1868    my $attr = {};
     1869    $attr->{"inherits"} = 0;
     1870
     1871    my $next = $self->nextToken();
     1872    if ($next->value() eq "setter") {
     1873        $attr->{"setraises"} = $self->parseSetRaises();
     1874        $attr->{"getraises"} = $self->parseGetRaises2();
     1875        return $attr;
     1876    }
     1877    if ($next->value() eq "getter") {
     1878        $attr->{"setraises"} = [];
     1879        $attr->{"getraises"} = $self->parseGetRaises();
     1880        return $attr;
     1881    }
     1882    if ($next->value() =~ /$nextSetGetRaises2_1/) {
     1883        return $self->parseSetGetRaises2();
     1884    }
     1885    $self->assertUnexpectedToken($next->value(), __LINE__);
     1886}
     1887
     1888sub parseGetRaises
     1889{
     1890    my $self = shift;
     1891    my $next = $self->nextToken();
     1892
     1893    if ($next->value() eq "getter") {
     1894        $self->assertTokenValue($self->getToken(), "getter", __LINE__);
     1895        $self->assertTokenValue($self->getToken(), "raises", __LINE__);
     1896        return $self->parseExceptionList();
     1897    }
     1898    $self->assertUnexpectedToken($next->value(), __LINE__);
     1899}
     1900
     1901sub parseGetRaises2
     1902{
     1903    my $self = shift;
     1904    my $next = $self->nextToken();
     1905
     1906    if ($next->value() eq ",") {
     1907        $self->assertTokenValue($self->getToken(), ",", __LINE__);
     1908        $self->assertTokenValue($self->getToken(), "getter", __LINE__);
     1909        $self->assertTokenValue($self->getToken(), "raises", __LINE__);
     1910        return $self->parseExceptionList();
     1911    }
     1912    return [];
     1913}
     1914
     1915sub parseSetRaises
     1916{
     1917    my $self = shift;
     1918    my $next = $self->nextToken();
     1919    if ($next->value() eq "setter") {
     1920        $self->assertTokenValue($self->getToken(), "setter", __LINE__);
     1921        $self->assertTokenValue($self->getToken(), "raises", __LINE__);
     1922        return $self->parseExceptionList();
     1923    }
     1924    $self->assertUnexpectedToken($next->value(), __LINE__);
     1925}
     1926
     1927sub parseSetGetRaises2
     1928{
     1929    my $self = shift;
     1930    my $next = $self->nextToken();
     1931    if ($next->value() =~ /$nextSetGetRaises2_1/) {
     1932        my $attr = {};
     1933        $attr->{"inherits"} = 0;
     1934        $attr->{"getraises"} = $self->parseGetRaises3();
     1935        $attr->{"setraises"} = $self->parseSetRaises3();
     1936        return $attr;
     1937    }
     1938    $self->assertUnexpectedToken($next->value(), __LINE__);
     1939}
     1940
     1941sub parseGetRaises3
     1942{
     1943    my $self = shift;
     1944    my $next = $self->nextToken();
     1945    if ($next->value() eq "getraises") {
     1946        $self->assertTokenValue($self->getToken(), "getraises", __LINE__);
     1947        return $self->parseExceptionList();
     1948    }
     1949    return [];
     1950}
     1951
     1952sub parseSetRaises3
     1953{
     1954    my $self = shift;
     1955    my $next = $self->nextToken();
     1956    if ($next->value() eq "setraises") {
     1957        $self->assertTokenValue($self->getToken(), "setraises", __LINE__);
     1958        return $self->parseExceptionList();
     1959    }
     1960    return [];
     1961}
     1962
     1963sub parseExceptionList
     1964{
     1965    my $self = shift;
     1966    my $next = $self->nextToken();
     1967    if ($next->value() eq "(") {
     1968        my @exceptions = ();
     1969        $self->assertTokenValue($self->getToken(), "(", __LINE__);
     1970        my $token = $self->getToken();
     1971        $self->assertTokenType($token, IdentifierToken);
     1972        push(@exceptions, $token->value());
     1973        push(@exceptions, @{$self->parseIdentifiers()});
     1974        $self->assertTokenValue($self->getToken(), ")", __LINE__);
     1975        return \@exceptions;
     1976    }
     1977    $self->assertUnexpectedToken($next->value(), __LINE__);
     1978}
     1979
     1980sub parseRaises
     1981{
     1982    my $self = shift;
     1983    my $next = $self->nextToken();
     1984    if ($next->value() eq "raises") {
     1985        $self->assertTokenValue($self->getToken(), "raises", __LINE__);
     1986        return $self->parseExceptionList();
     1987    }
     1988    return [];
     1989}
     1990
     1991sub parseDefinitionOld
     1992{
     1993    my $self = shift;
     1994    my $next = $self->nextToken();
     1995    if ($next->value() =~ /$nextDefinition_1/) {
     1996        return $self->parseCallbackOrInterfaceOld();
     1997    }
     1998    if ($next->value() eq "partial") {
     1999        return $self->parsePartial({});
     2000    }
     2001    if ($next->value() eq "dictionary") {
     2002        return $self->parseDictionaryOld();
     2003    }
     2004    if ($next->value() eq "exception") {
     2005        return $self->parseExceptionOld();
     2006    }
     2007    if ($next->value() eq "enum") {
     2008        return $self->parseEnumOld();
     2009    }
     2010    if ($next->value() eq "typedef") {
     2011        return $self->parseTypedef({});
     2012    }
     2013    if ($next->value() eq "module") {
     2014        return $self->parseModule();
     2015    }
     2016    if ($next->type() == IdentifierToken) {
     2017        return $self->parseImplementsStatement({});
     2018    }
     2019    $self->assertUnexpectedToken($next->value(), __LINE__);
     2020}
     2021
     2022sub parseModule
     2023{
     2024    my $self = shift;
     2025    my $next = $self->nextToken();
     2026    if ($next->value() eq "module") {
     2027        my $document = new idlDocument();
     2028        $self->assertTokenValue($self->getToken(), "module", __LINE__);
     2029        my $extendedAttributeList = $self->parseExtendedAttributeListAllowEmpty();
     2030        my $token = $self->getToken();
     2031        $self->assertTokenType($token, IdentifierToken);
     2032        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     2033        $document->module($token->value());
     2034        my $definitions = $self->parseDefinitions();
     2035        push(@{$document->classes}, @{$definitions});
     2036        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     2037        $self->parseOptionalSemicolon();
     2038        return $document;
     2039    }
     2040    $self->assertUnexpectedToken($next->value(), __LINE__);
     2041}
     2042
     2043sub parseCallbackOrInterfaceOld
     2044{
     2045    my $self = shift;
     2046    my $next = $self->nextToken();
     2047    if ($next->value() eq "callback") {
     2048        $self->assertTokenValue($self->getToken(), "callback", __LINE__);
     2049        return $self->parseCallbackRestOrInterface({});
     2050    }
     2051    if ($next->value() eq "interface") {
     2052        return $self->parseInterfaceOld();
     2053    }
     2054    $self->assertUnexpectedToken($next->value(), __LINE__);
     2055}
     2056
     2057sub parseInterfaceOld
     2058{
     2059    my $self = shift;
     2060    my $next = $self->nextToken();
     2061    if ($next->value() eq "interface") {
     2062        my $dataNode = new domClass();
     2063        $self->assertTokenValue($self->getToken(), "interface", __LINE__);
     2064        my $extendedAttributeList = $self->parseExtendedAttributeListAllowEmpty();
     2065        my $token = $self->getToken();
     2066        $self->assertTokenType($token, IdentifierToken);
     2067        $dataNode->name($token->value());
     2068        $dataNode->isException(0);
     2069        push(@{$dataNode->parents}, @{$self->parseInheritance()});
     2070        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     2071        my $interfaceMembers = $self->parseInterfaceMembers();
     2072        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     2073        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     2074        applyMemberList($dataNode, $interfaceMembers);
     2075        applyExtendedAttributeList($dataNode, $extendedAttributeList);
     2076        return $dataNode;
     2077    }
     2078    $self->assertUnexpectedToken($next->value(), __LINE__);
     2079}
     2080
     2081sub parseInterfaceMemberOld
     2082{
     2083    my $self = shift;
     2084    my $next = $self->nextToken();
     2085    if ($next->value() eq "const") {
     2086        return $self->parseConst({});
     2087    }
     2088    if ($next->type() == IdentifierToken || $next->value() =~ /$nextInterfaceMemberOld_1/) {
     2089        return $self->parseAttributeOrOperationOrIteratorOld();
     2090    }
     2091    $self->assertUnexpectedToken($next->value(), __LINE__);
     2092}
     2093
     2094sub parseDictionaryOld
     2095{
     2096    my $self = shift;
     2097    my $next = $self->nextToken();
     2098    if ($next->value() eq "dictionary") {
     2099        $self->assertTokenValue($self->getToken(), "dictionary", __LINE__);
     2100        $self->parseExtendedAttributeListAllowEmpty();
     2101        $self->assertTokenType($self->getToken(), IdentifierToken);
     2102        $self->parseInheritance();
     2103        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     2104        $self->parseDictionaryMembers();
     2105        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     2106        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     2107        return;
     2108    }
     2109    $self->assertUnexpectedToken($next->value(), __LINE__);
     2110}
     2111
     2112sub parseDictionaryMemberOld
     2113{
     2114    my $self = shift;
     2115    my $next = $self->nextToken();
     2116    if ($next->type() == IdentifierToken || $next->value() =~ /$nextExceptionField_1/) {
     2117        $self->parseType();
     2118        $self->parseExtendedAttributeListAllowEmpty();
     2119        $self->assertTokenType($self->getToken(), IdentifierToken);
     2120        $self->parseDefault();
     2121        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     2122        return;
     2123    }
     2124    $self->assertUnexpectedToken($next->value(), __LINE__);
     2125}
     2126
     2127sub parseExceptionOld
     2128{
     2129    my $self = shift;
     2130    my $next = $self->nextToken();
     2131    if ($next->value() eq "exception") {
     2132        my $dataNode = new domClass();
     2133        $self->assertTokenValue($self->getToken(), "exception", __LINE__);
     2134        my $extendedAttributeList = $self->parseExtendedAttributeListAllowEmpty();
     2135        my $token = $self->getToken();
     2136        $self->assertTokenType($token, IdentifierToken);
     2137        $dataNode->name($token->value());
     2138        $dataNode->isException(1);
     2139        push(@{$dataNode->parents}, @{$self->parseInheritance()});
     2140        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     2141        my $exceptionMembers = $self->parseInterfaceMembers();
     2142        #$self->parseExceptionMembers();
     2143        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     2144        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     2145        applyMemberList($dataNode, $exceptionMembers);
     2146        applyExtendedAttributeList($dataNode, $extendedAttributeList);
     2147        return $dataNode;
     2148    }
     2149    $self->assertUnexpectedToken($next->value(), __LINE__);
     2150}
     2151
     2152sub parseEnumOld
     2153{
     2154    my $self = shift;
     2155    my $next = $self->nextToken();
     2156    if ($next->value() eq "enum") {
     2157        $self->assertTokenValue($self->getToken(), "enum", __LINE__);
     2158        $self->parseExtendedAttributeListAllowEmpty();
     2159        $self->assertTokenType($self->getToken(), IdentifierToken);
     2160        $self->assertTokenValue($self->getToken(), "{", __LINE__);
     2161        $self->parseEnumValueList();
     2162        $self->assertTokenValue($self->getToken(), "}", __LINE__);
     2163        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     2164        return;
     2165    }
     2166    $self->assertUnexpectedToken($next->value(), __LINE__);
     2167}
     2168
     2169sub parseAttributeOrOperationOrIteratorOld
     2170{
     2171    my $self = shift;
     2172    my $next = $self->nextToken();
     2173    if ($next->value() eq "serializer") {
     2174        return $self->parseSerializer({});
     2175    }
     2176    if ($next->value() =~ /$nextAttributeOrOperationOrIterator_1/) {
     2177        my $qualifier = $self->parseQualifier();
     2178        my $dataNode = $self->parseAttributeOrOperationRestOld();
     2179        if (defined ($dataNode) && $qualifier eq "static") {
     2180            $dataNode->isStatic(1);
     2181        }
     2182        return $dataNode;
     2183    }
     2184    if ($next->value() =~ /$nextAttributeOld_1/) {
     2185        return $self->parseAttributeOld();
     2186    }
     2187    if ($next->type() == IdentifierToken || $next->value() =~ /$nextAttributeOrOperationOrIterator_2/) {
     2188        return $self->parseOperationOrIterator({});
     2189    }
     2190    $self->assertUnexpectedToken($next->value(), __LINE__);
     2191}
     2192
     2193sub parseAttributeOrOperationRestOld
     2194{
     2195    my $self = shift;
     2196    my $next = $self->nextToken();
     2197    if ($next->value() =~ /$nextAttributeRest_1/) {
     2198        return $self->parseAttributeRestOld();
     2199    }
     2200    if ($next->value() eq ";") {
     2201        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     2202        return;
     2203    }
     2204    if ($next->type() == IdentifierToken || $next->value() =~ /$nextAttributeOrOperationRest_1/) {
     2205        my $returnType = $self->parseReturnType();
     2206        my $dataNode = $self->parseOperationRest({});
     2207        if (defined ($dataNode)) {
     2208            $dataNode->signature->type($returnType);
     2209        }
     2210        return $dataNode;
     2211    }
     2212    $self->assertUnexpectedToken($next->value(), __LINE__);
     2213}
     2214
     2215sub parseAttributeOld
     2216{
     2217    my $self = shift;
     2218    my $next = $self->nextToken();
     2219    if ($next->value() =~ /$nextAttributeOld_1/) {
     2220        $self->parseInherit();
     2221        return $self->parseAttributeRestOld();
     2222    }
     2223    $self->assertUnexpectedToken($next->value(), __LINE__);
     2224}
     2225
     2226sub parseAttributeRestOld
     2227{
     2228    my $self = shift;
     2229    my $next = $self->nextToken();
     2230    if ($next->value() =~ /$nextAttributeRest_1/) {
     2231        my $newDataNode = new domAttribute();
     2232        if ($self->parseReadOnly()) {
     2233            $newDataNode->type("readonly attribute");
     2234        } else {
     2235            $newDataNode->type("attribute");
     2236        }
     2237        $self->assertTokenValue($self->getToken(), "attribute", __LINE__);
     2238        my $extendedAttributeList = $self->parseExtendedAttributeListAllowEmpty();
     2239        $newDataNode->signature(new domSignature());
     2240        $newDataNode->signature->type($self->parseType());
     2241        $newDataNode->signature->extendedAttributes($extendedAttributeList);
     2242        my $token = $self->getToken();
     2243        $self->assertTokenType($token, IdentifierToken);
     2244        $newDataNode->signature->name($token->value());
     2245        my $getRef = $self->parseGet();
     2246        if (defined $getRef) {
     2247            push(@{$newDataNode->getterExceptions}, @{$getRef->{"getraises"}});
     2248            push(@{$newDataNode->setterExceptions}, @{$getRef->{"setraises"}});
     2249        }
     2250        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     2251        return $newDataNode;
     2252    }
     2253    $self->assertUnexpectedToken($next->value(), __LINE__);
     2254}
     2255
     2256sub parseIn
     2257{
     2258    my $self = shift;
     2259    my $next = $self->nextToken();
     2260    if ($next->value() eq "in") {
     2261        $self->assertTokenValue($self->getToken(), "in", __LINE__);
     2262        return "in";
     2263    }
     2264    return "";
     2265}
     2266
     2267sub parseOptionalSemicolon
     2268{
     2269    my $self = shift;
     2270    my $next = $self->nextToken();
     2271    if ($next->value() eq ";") {
     2272        $self->assertTokenValue($self->getToken(), ";", __LINE__);
     2273    }
     2274}
     2275
     2276sub applyMemberList
     2277{
    1212278    my $dataNode = shift;
    122 
    123     print " |- Trying to parse module...\n" unless $beQuiet;
    124 
    125     my $data = join("", @temporaryContent);
    126     $data =~ /$IDLStructure::moduleSelector/;
    127 
    128     my $moduleName = (defined($1) ? $1 : die("Parsing error!\nSource:\n$data\n)"));
    129     $dataNode->module($moduleName);
    130 
    131     print "  |----> Module; NAME \"$moduleName\"\n |-\n |\n" unless $beQuiet;
    132 }
    133 
    134 sub dumpExtendedAttributes
    135 {
    136     my $padStr = shift;
    137     my $attrs = shift;
    138 
    139     if (!%{$attrs}) {
    140         return "";
    141     }
    142 
    143     my @temp;
    144     while ((my $name, my $value) = each(%{$attrs})) {
    145         push(@temp, "$name=$value");
    146     }
    147 
    148     return $padStr . "[" . join(", ", @temp) . "]";
    149 }
    150 
    151 sub parseExtendedAttributes
    152 {
    153     my $str = shift;
    154     $str =~ s/\[\s*(.*)\s*\]/$1/g;
    155 
    156     my %attrs = ();
    157 
    158     while ($str !~ /^\s*$/) {
    159         # Parse name
    160         if ($str !~ /^\s*([\w\d]+)/) {
    161             die("Invalid extended attribute: '$str'\n");
    162         }
    163         my $name = $1;
    164         $str =~ s/^\s*([\w\d]+)//;
    165 
    166         if ($str =~ /^\s*=/) {
    167             $str =~ s/^\s*=//;
    168             if ($name eq "NamedConstructor") {
    169                 # Parse '=' name '(' arguments ')' ','?
    170                 my $constructorName;
    171                 if ($str =~ /^\s*([\w\d]+)/) {
    172                     $constructorName = $1;
    173                     $str =~ s/^\s*([\w\d]+)//;
    174                 } else {
    175                     die("Invalid extended attribute: '$str'\n");
    176                 }
    177                 if ($str =~ /^\s*\(/) {
    178                     # Parse '(' arguments ')' ','?
    179                     $str =~ s/^\s*\(//;
    180                     if ($str =~ /^([^)]*)\),?/) {
    181                         my $signature = $1;
    182                         $signature =~ s/^(.*?)\s*$/$1/;
    183                         $attrs{$name} = {"ConstructorName" => $constructorName, "Signature" => $signature};
    184                         $str =~ s/^([^)]*)\),?//;
    185                     } else {
    186                         die("Invalid extended attribute: '$str'\n");
    187                     }
    188                 } elsif ($str =~ /^\s*,?/) {
    189                     $attrs{$name} = {"ConstructorName" => $constructorName, "Signature" => ""};
    190                     $str =~ s/^\s*,?//;
    191                 } else {
    192                     die("Invalid extended attribute: '$str'\n");
    193                 }
    194             } else {
    195                 # Parse '=' value ','?
    196                 if ($str =~ /^\s*([^,]*),?/) {
    197                     $attrs{$name} = $1;
    198                     $attrs{$name} =~ s/^(.*?)\s*$/$1/;
    199                     $str =~ s/^\s*([^,]*),?//;
    200                 } else {
    201                     die("Invalid extended attribute: '$str'\n");
    202                 }
    203             }
    204         } elsif ($str =~ /^\s*\(/) {
    205             # Parse '(' arguments ')' ','?
    206             $str =~ s/^\s*\(//;
    207             if ($str =~ /^([^)]*)\),?/) {
    208                 $attrs{$name} = $1;
    209                 $attrs{$name} =~ s/^(.*?)\s*$/$1/;
    210                 $str =~ s/^([^)]*)\),?//;
    211             } else {
    212                 die("Invalid extended attribute: '$str'\n");
    213             }
    214         } elsif ($str =~ /^\s*,?/) {
    215             # Parse '' | ','
    216             if ($name eq "Constructor") {
    217                 $attrs{$name} = "";
    218             } else {
    219                 $attrs{$name} = "VALUE_IS_MISSING";
    220             }
    221             $str =~ s/^\s*,?//;
    222         } else {
    223             die("Invalid extended attribute: '$str'\n");
    224         }
    225     }
    226 
    227     return \%attrs;
    228 }
    229 
    230 sub parseParameters
    231 {
    232     my $newDataNode = shift;
    233     my $methodSignature = shift;
    234 
    235     # Split arguments at commas but only if the comma
    236     # is not within attribute brackets, expressed here
    237     # as being followed by a ']' without a preceding '['.
    238     # Note that this assumes that attributes don't nest.
    239     my @params = split(/,(?![^[]*\])/, $methodSignature);
    240     foreach (@params) {
    241         my $line = $_;
    242 
    243         $line =~ /$IDLStructure::interfaceParameterSelector/;
    244         my $paramDirection = $1;
    245         my $paramExtendedAttributes = (defined($2) ? $2 : " "); chop($paramExtendedAttributes);
    246         my $paramType = (defined($3) ? $3 : die("Parsing error!\nSource:\n$line\n)"));
    247         my $paramTypeSuffix = defined($4) ? $4 : "";
    248         my $paramName = (defined($5) ? $5 : die("Parsing error!\nSource:\n$line\n)"));
    249 
    250         my $isNullable = $paramTypeSuffix eq "?";
    251 
    252         my $paramDataNode = new domSignature();
    253         $paramDataNode->direction($paramDirection);
    254         $paramDataNode->name($paramName);
    255         $paramDataNode->type($paramType);
    256         $paramDataNode->extendedAttributes(parseExtendedAttributes($paramExtendedAttributes));
    257         $paramDataNode->isNullable($isNullable);
    258 
    259         my $arrayRef = $newDataNode->parameters;
    260         push(@$arrayRef, $paramDataNode);
    261 
    262         print "  |   |>  Param; TYPE \"$paramType\" NAME \"$paramName\"" .
    263             dumpExtendedAttributes("\n  |              ", $paramDataNode->extendedAttributes) . "\n" unless $beQuiet;         
    264     }
    265 }
    266 
    267 sub ParseInterface
    268 {
    269     my $object = shift;
     2279    my $members = shift;
     2280
     2281    for my $item (@{$members}) {
     2282        if (ref($item) eq "domAttribute") {
     2283            push(@{$dataNode->attributes}, $item);
     2284            next;
     2285        }
     2286        if (ref($item) eq "domConstant") {
     2287            push(@{$dataNode->constants}, $item);
     2288            next;
     2289        }
     2290        if (ref($item) eq "domFunction") {
     2291            push(@{$dataNode->functions}, $item);
     2292            next;
     2293        }
     2294    }
     2295}
     2296
     2297sub applyExtendedAttributeList
     2298{
    2702299    my $dataNode = shift;
    271     my $sectionName = shift;
    272 
    273     my $data = join("", @temporaryContent);
    274 
    275     # Look for end-of-interface mark
    276     $data =~ /};/g;
    277     $data = substr($data, index($data, $sectionName), pos($data) - length($data));
    278 
    279     $data =~ s/[\n\r]/ /g;
    280 
    281     # Beginning of the regexp parsing magic
    282     if ($sectionName eq "interface" || $sectionName eq "exception") {
    283         print " |- Trying to parse interface...\n" unless $beQuiet;
    284 
    285         my $interfaceName = "";
    286         my $interfaceData = "";
    287 
    288         # Match identifier of the interface, and enclosed data...
    289         $data =~ /$IDLStructure::interfaceSelector/;
    290 
    291         my $isException = (defined($1) ? ($1 eq 'exception') : die("Parsing error!\nSource:\n$data\n)"));
    292         my $interfaceExtendedAttributes = (defined($2) ? $2 : " "); chop($interfaceExtendedAttributes);
    293         $interfaceName = (defined($3) ? $3 : die("Parsing error!\nSource:\n$data\n)"));
    294         my $interfaceBase = (defined($4) ? $4 : "");
    295         $interfaceData = (defined($5) ? $5 : die("Parsing error!\nSource:\n$data\n)"));
    296 
    297         # Fill in known parts of the domClass datastructure now...
    298         $dataNode->isException($isException);
    299         $dataNode->name($interfaceName);
    300         my $extendedAttributes = parseExtendedAttributes($interfaceExtendedAttributes);
    301         if (defined $extendedAttributes->{"Constructor"}) {
    302             my $newDataNode = new domFunction();
    303             $newDataNode->signature(new domSignature());
    304             $newDataNode->signature->name("Constructor");
    305             $newDataNode->signature->extendedAttributes($extendedAttributes);
    306             parseParameters($newDataNode, $extendedAttributes->{"Constructor"});
    307             $extendedAttributes->{"Constructor"} = "VALUE_IS_MISSING";
    308             $dataNode->constructor($newDataNode);
    309         } elsif (defined $extendedAttributes->{"NamedConstructor"}) {
    310             my $newDataNode = new domFunction();
    311             $newDataNode->signature(new domSignature());
    312             $newDataNode->signature->name("NamedConstructor");
    313             $newDataNode->signature->extendedAttributes($extendedAttributes);
    314             parseParameters($newDataNode, $extendedAttributes->{"NamedConstructor"}->{"Signature"});
    315             $extendedAttributes->{"NamedConstructor"} = $extendedAttributes->{"NamedConstructor"}{"ConstructorName"};
    316             $dataNode->constructor($newDataNode);
    317         }
    318         $dataNode->extendedAttributes($extendedAttributes);
    319 
    320         # Inheritance detection
    321         my @interfaceParents = split(/,/, $interfaceBase);
    322         foreach(@interfaceParents) {
    323             my $line = $_;
    324             $line =~ s/\s*//g;
    325 
    326             my $arrayRef = $dataNode->parents;
    327             push(@$arrayRef, $line);
    328         }
    329 
    330         return if $parentsOnly;
    331 
    332         $interfaceData =~ s/[\n\r]/ /g;
    333         my @interfaceMethods = split(/;/, $interfaceData);
    334 
    335         foreach my $line (@interfaceMethods) {
    336             next if $line =~ /^\s*$/;
    337             if ($line =~ /\Wattribute\W/) {
    338                 $line =~ /$IDLStructure::interfaceAttributeSelector/;
    339 
    340                 my $isStatic = defined($1);
    341                 my $attributeType = (defined($2) ? $2 : die("Parsing error!\nSource:\n$line\n)"));
    342                 my $attributeExtendedAttributes = (defined($3) ? $3 : " "); chop($attributeExtendedAttributes);
    343 
    344                 my $attributeDataType = (defined($4) ? $4 : die("Parsing error!\nSource:\n$line\n)"));
    345                 my $attributeDataName = (defined($5) ? $5 : die("Parsing error!\nSource:\n$line\n)"));
    346  
    347                 ('' =~ /^/); # Reset variables needed for regexp matching
    348 
    349                 $line =~ /$IDLStructure::getterRaisesSelector/;
    350                 my $getterException = (defined($1) ? $1 : "");
    351 
    352                 $line =~ /$IDLStructure::setterRaisesSelector/;
    353                 my $setterException = (defined($1) ? $1 : "");
    354 
    355                 my $newDataNode = new domAttribute();
    356                 $newDataNode->type($attributeType);
    357                 $newDataNode->isStatic($isStatic);
    358                 $newDataNode->signature(new domSignature());
    359 
    360                 $newDataNode->signature->name($attributeDataName);
    361                 $newDataNode->signature->type($attributeDataType);
    362                 $newDataNode->signature->extendedAttributes(parseExtendedAttributes($attributeExtendedAttributes));
    363 
    364                 my $arrayRef = $dataNode->attributes;
    365                 push(@$arrayRef, $newDataNode);
    366 
    367                 print "  |  |>  Attribute; STATIC? \"$isStatic\" TYPE \"$attributeType\" DATA NAME \"$attributeDataName\" DATA TYPE \"$attributeDataType\" GET EXCEPTION? \"$getterException\" SET EXCEPTION? \"$setterException\"" .
    368                     dumpExtendedAttributes("\n  |                 ", $newDataNode->signature->extendedAttributes) . "\n" unless $beQuiet;
    369 
    370                 $getterException =~ s/\s+//g;
    371                 $setterException =~ s/\s+//g;
    372                 @{$newDataNode->getterExceptions} = split(/,/, $getterException);
    373                 @{$newDataNode->setterExceptions} = split(/,/, $setterException);
    374             } elsif ($line !~ /^\s*($IDLStructure::extendedAttributeSyntax )?const\s+/) {
    375                 $line =~ /$IDLStructure::interfaceMethodSelector/ or die "Parsing error!\nSource:\n$line\n)";
    376 
    377                 my $methodExtendedAttributes = (defined($1) ? $1 : " "); chop($methodExtendedAttributes);
    378                 my $isStatic = defined($2);
    379                 my $methodType = (defined($3) ? $3 : die("Parsing error!\nSource:\n$line\n)"));
    380                 my $methodName = (defined($4) ? $4 : die("Parsing error!\nSource:\n$line\n)"));
    381                 my $methodSignature = (defined($5) ? $5 : die("Parsing error!\nSource:\n$line\n)"));
    382 
    383                 ('' =~ /^/); # Reset variables needed for regexp matching
    384 
    385                 $line =~ /$IDLStructure::raisesSelector/;
    386                 my $methodException = (defined($1) ? $1 : "");
    387 
    388                 my $newDataNode = new domFunction();
    389 
    390                 $newDataNode->isStatic($isStatic);
    391                 $newDataNode->signature(new domSignature());
    392                 $newDataNode->signature->name($methodName);
    393                 $newDataNode->signature->type($methodType);
    394                 $newDataNode->signature->extendedAttributes(parseExtendedAttributes($methodExtendedAttributes));
    395 
    396                 print "  |  |-  Method; STATIC? \"$isStatic\" TYPE \"$methodType\" NAME \"$methodName\" EXCEPTION? \"$methodException\"" .
    397                     dumpExtendedAttributes("\n  |              ", $newDataNode->signature->extendedAttributes) . "\n" unless $beQuiet;
    398 
    399                 $methodException =~ s/\s+//g;
    400                 @{$newDataNode->raisesExceptions} = split(/,/, $methodException);
    401 
    402                 parseParameters($newDataNode, $methodSignature);
    403 
    404                 my $arrayRef = $dataNode->functions;
    405                 push(@$arrayRef, $newDataNode);
    406             } else {
    407                 $line =~ /$IDLStructure::constantSelector/;
    408                 my $constExtendedAttributes = (defined($1) ? $1 : " "); chop($constExtendedAttributes);
    409                 my $constType = (defined($2) ? $2 : die("Parsing error!\nSource:\n$line\n)"));
    410                 my $constName = (defined($3) ? $3 : die("Parsing error!\nSource:\n$line\n)"));
    411                 my $constValue = (defined($4) ? $4 : die("Parsing error!\nSource:\n$line\n)"));
    412 
    413                 my $newDataNode = new domConstant();
    414                 $newDataNode->name($constName);
    415                 $newDataNode->type($constType);
    416                 $newDataNode->value($constValue);
    417                 $newDataNode->extendedAttributes(parseExtendedAttributes($constExtendedAttributes));
    418 
    419                 my $arrayRef = $dataNode->constants;
    420                 push(@$arrayRef, $newDataNode);
    421 
    422                 print "  |   |>  Constant; TYPE \"$constType\" NAME \"$constName\" VALUE \"$constValue\"\n" unless $beQuiet;
    423             }
    424         }
    425 
    426         print "  |----> Interface; NAME \"$interfaceName\"" .
    427             dumpExtendedAttributes("\n  |                 ", $dataNode->extendedAttributes) . "\n |-\n |\n" unless $beQuiet;
    428     }
    429 }
    430 
    431 # Internal helper
    432 sub DetermineParseMode
    433 {
    434     my $object = shift; 
    435     my $line = shift;
    436 
    437     my $mode = MODE_UNDEF;
    438     if ($_ =~ /module/) {
    439         $mode = MODE_MODULE;
    440     } elsif ($_ =~ /interface/) {
    441         $mode = MODE_INTERFACE;
    442     } elsif ($_ =~ /exception/) {
    443         $mode = MODE_EXCEPTION;
    444     }
    445 
    446     return $mode;
    447 }
    448 
    449 # Internal helper
    450 sub ProcessSection
    451 {
    452     my $object = shift;
    453  
    454     if ($parseMode eq MODE_MODULE) {
    455         die ("Two modules in one file! Fatal error!\n") if ($document ne 0);
    456         $document = new idlDocument();
    457         $object->ParseModule($document);
    458     } elsif ($parseMode eq MODE_INTERFACE || $parseMode eq MODE_EXCEPTION) {
    459         my $node = new domClass();
    460         my $sectionName = $parseMode eq MODE_INTERFACE ? "interface" : "exception";
    461         $object->ParseInterface($node, $sectionName);
    462    
    463         die ("No module specified! Fatal Error!\n") if ($document eq 0);
    464         my $arrayRef = $document->classes;
    465         push(@$arrayRef, $node);
    466     }
    467 
    468     @temporaryContent = "";
     2300    my $extendedAttributeList = shift;
     2301
     2302    if (defined $extendedAttributeList->{"Constructor"}) {
     2303        my $newDataNode = new domFunction();
     2304        $newDataNode->signature(new domSignature());
     2305        $newDataNode->signature->name("Constructor");
     2306        $newDataNode->signature->extendedAttributes($extendedAttributeList);
     2307        push(@{$newDataNode->parameters}, @{$extendedAttributeList->{"Constructor"}});
     2308        $extendedAttributeList->{"Constructor"} = "VALUE_IS_MISSING";
     2309        $dataNode->constructor($newDataNode);
     2310    } elsif (defined $extendedAttributeList->{"NamedConstructor"}) {
     2311        my $newDataNode = new domFunction();
     2312        $newDataNode->signature(new domSignature());
     2313        $newDataNode->signature->name("NamedConstructor");
     2314        $newDataNode->signature->extendedAttributes($extendedAttributeList);
     2315        my %attributes = %{$extendedAttributeList->{"NamedConstructor"}};
     2316        my @attributeKeys = keys (%attributes);
     2317        my $constructorName = $attributeKeys[0];
     2318        push(@{$newDataNode->parameters}, @{$attributes{$constructorName}});
     2319        $extendedAttributeList->{"NamedConstructor"} = $constructorName;
     2320        $dataNode->constructor($newDataNode);
     2321    }
     2322    $dataNode->extendedAttributes($extendedAttributeList);
    4692323}
    4702324
    47123251;
     2326

  • trunk/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.cpp

    r128248 r129723  
    154154}
    155155
    156 long long WebDOMTestObj::Attr() const
    157 {
    158     if (!impl())
    159         return 0;
    160 
    161     return impl()->attr();
    162 }
    163 
    164 void WebDOMTestObj::setAttr(long long newAttr)
    165 {
    166     if (!impl())
    167         return;
    168 
    169     impl()->setAttr(newAttr);
     156int WebDOMTestObj::longAttr() const
     157{
     158    if (!impl())
     159        return 0;
     160
     161    return impl()->longAttr();
     162}
     163
     164void WebDOMTestObj::setLongAttr(int newLongAttr)
     165{
     166    if (!impl())
     167        return;
     168
     169    impl()->setLongAttr(newLongAttr);
    170170}
    171171
    … …  
    426426        return;
    427427
    428     WebCore::ExceptionCode ec = 0;
    429     impl()->setAttrWithGetterException(newAttrWithGetterException, ec);
    430     webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
     428    impl()->setAttrWithGetterException(newAttrWithGetterException);
    431429}
    432430
    … …  
    465463        return;
    466464
    467     WebCore::ExceptionCode ec = 0;
    468     impl()->setStringAttrWithGetterException(newStringAttrWithGetterException, ec);
    469     webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
     465    impl()->setStringAttrWithGetterException(newStringAttrWithGetterException);
    470466}
    471467
    … …  
    678674}
    679675
    680 void WebDOMTestObj::voidMethodWithArgs(long long Arg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
    681 {
    682     if (!impl())
    683         return;
    684 
    685     impl()->voidMethodWithArgs(Arg, strArg, toWebCore(objArg));
    686 }
    687 
    688 long long WebDOMTestObj::Method()
    689 {
    690     if (!impl())
    691         return 0;
    692 
    693     return impl()->method();
    694 }
    695 
    696 long long WebDOMTestObj::MethodWithArgs(long long Arg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
    697 {
    698     if (!impl())
    699         return 0;
    700 
    701     return impl()->methodWithArgs(Arg, strArg, toWebCore(objArg));
     676void WebDOMTestObj::voidMethodWithArgs(int longArg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
     677{
     678    if (!impl())
     679        return;
     680
     681    impl()->voidMethodWithArgs(longArg, strArg, toWebCore(objArg));
     682}
     683
     684int WebDOMTestObj::longMethod()
     685{
     686    if (!impl())
     687        return 0;
     688
     689    return impl()->longMethod();
     690}
     691
     692int WebDOMTestObj::longMethodWithArgs(int longArg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
     693{
     694    if (!impl())
     695        return 0;
     696
     697    return impl()->longMethodWithArgs(longArg, strArg, toWebCore(objArg));
    702698}
    703699
    … …  
    710706}
    711707
    712 WebDOMTestObj WebDOMTestObj::objMethodWithArgs(long long Arg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
     708WebDOMTestObj WebDOMTestObj::objMethodWithArgs(int longArg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
    713709{
    714710    if (!impl())
    715711        return WebDOMTestObj();
    716712
    717     return toWebKit(WTF::getPtr(impl()->objMethodWithArgs(Arg, strArg, toWebCore(objArg))));
     713    return toWebKit(WTF::getPtr(impl()->objMethodWithArgs(longArg, strArg, toWebCore(objArg))));
    718714}
    719715
    … …  
    903899#endif
    904900
    905 void WebDOMTestObj::convert1(const WebDOMa& )
    906 {
    907     if (!impl())
    908         return;
    909 
    910     impl()->convert1(toWebCore());
    911 }
    912 
    913 void WebDOMTestObj::convert2(const WebDOMb& )
    914 {
    915     if (!impl())
    916         return;
    917 
    918     impl()->convert2(toWebCore());
    919 }
    920 
    921 void WebDOMTestObj::convert4(const WebDOMd& )
    922 {
    923     if (!impl())
    924         return;
    925 
    926     impl()->convert4(toWebCore());
    927 }
    928 
    929 void WebDOMTestObj::convert5(const WebDOMe& )
    930 {
    931     if (!impl())
    932         return;
    933 
    934     impl()->convert5(toWebCore());
     901void WebDOMTestObj::convert1(const WebDOMa& value)
     902{
     903    if (!impl())
     904        return;
     905
     906    impl()->convert1(toWebCore(value));
     907}
     908
     909void WebDOMTestObj::convert2(const WebDOMb& value)
     910{
     911    if (!impl())
     912        return;
     913
     914    impl()->convert2(toWebCore(value));
     915}
     916
     917void WebDOMTestObj::convert4(const WebDOMd& value)
     918{
     919    if (!impl())
     920        return;
     921
     922    impl()->convert4(toWebCore(value));
     923}
     924
     925void WebDOMTestObj::convert5(const WebDOMe& value)
     926{
     927    if (!impl())
     928        return;
     929
     930    impl()->convert5(toWebCore(value));
    935931}
    936932

  • trunk/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.h

    r128248 r129723  
    7878    unsigned short unsignedShortAttr() const;
    7979    void setUnsignedShortAttr(unsigned short);
    80     long long Attr() const;
    81     void setAttr(long long);
     80    int longAttr() const;
     81    void setLongAttr(int);
    8282    long long longLongAttr() const;
    8383    void setLongLongAttr(long long);
    … …  
    148148
    149149    void voidMethod();
    150     void voidMethodWithArgs(long long Arg, const WebDOMString& strArg, const WebDOMTestObj& objArg);
    151     long long Method();
    152     long long MethodWithArgs(long long Arg, const WebDOMString& strArg, const WebDOMTestObj& objArg);
     150    void voidMethodWithArgs(int longArg, const WebDOMString& strArg, const WebDOMTestObj& objArg);
     151    int longMethod();
     152    int longMethodWithArgs(int longArg, const WebDOMString& strArg, const WebDOMTestObj& objArg);
    153153    WebDOMTestObj objMethod();
    154     WebDOMTestObj objMethodWithArgs(long long Arg, const WebDOMString& strArg, const WebDOMTestObj& objArg);
     154    WebDOMTestObj objMethodWithArgs(int longArg, const WebDOMString& strArg, const WebDOMTestObj& objArg);
    155155    WebDOMTestObj methodThatRequiresAllArgsAndThrows(const WebDOMString& strArg, const WebDOMTestObj& objArg);
    156156    void serializedValue(const WebDOMString& serializedArg);
    … …  
    183183    void overloadedMethod1(const WebDOMString& type);
    184184#endif
    185     void convert1(const WebDOMa& );
    186     void convert2(const WebDOMb& );
    187     void convert4(const WebDOMd& );
    188     void convert5(const WebDOMe& );
     185    void convert1(const WebDOMa& value);
     186    void convert2(const WebDOMb& value);
     187    void convert4(const WebDOMd& value);
     188    void convert5(const WebDOMe& value);
    189189    WebDOMSVGPoint mutablePointFunction();
    190190    WebDOMSVGPoint immutablePointFunction();

  • trunk/Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.cpp

    r128248 r129723  
    107107    PROP_SHORT_ATTR,
    108108    PROP_UNSIGNED_SHORT_ATTR,
    109     PROP_ATTR,
     109    PROP_LONG_ATTR,
    110110    PROP_LONG_LONG_ATTR,
    111111    PROP_UNSIGNED_LONG_LONG_ATTR,
    … …  
    180180        break;
    181181    }
     182    case PROP_LONG_ATTR: {
     183        coreSelf->setLongAttr((g_value_get_long(value)));
     184        break;
     185    }
    182186    case PROP_UNSIGNED_LONG_LONG_ATTR: {
    183187        coreSelf->setUnsignedLongLongAttr((g_value_get_uint64(value)));
    … …  
    229233    }
    230234    case PROP_ATTR_WITH_GETTER_EXCEPTION: {
    231         WebCore::ExceptionCode ec = 0;
    232         coreSelf->setAttrWithGetterException((g_value_get_long(value)), ec);
     235        coreSelf->setAttrWithGetterException((g_value_get_long(value)));
    233236        break;
    234237    }
    … …  
    239242    }
    240243    case PROP_STRING_ATTR_WITH_GETTER_EXCEPTION: {
    241         WebCore::ExceptionCode ec = 0;
    242         coreSelf->setStringAttrWithGetterException(WTF::String::fromUTF8(g_value_get_string(value)), ec);
     244        coreSelf->setStringAttrWithGetterException(WTF::String::fromUTF8(g_value_get_string(value)));
    243245        break;
    244246    }
    … …  
    330332        break;
    331333    }
    332     case PROP_ATTR: {
    333         g_value_set_int64(value, coreSelf->attr());
     334    case PROP_LONG_ATTR: {
     335        g_value_set_long(value, coreSelf->longAttr());
    334336        break;
    335337    }
    … …  
    594596                                                           WEBKIT_PARAM_READWRITE));
    595597    g_object_class_install_property(gobjectClass,
    596                                     PROP_ATTR,
    597                                     g_param_spec_int64("attr", /* name */
    598                                                            "test_obj_attr", /* short description */
    599                                                            "read-write  gint64 TestObj.attr", /* longer - could do with some extra doc stuff here */
    600                                                            G_MININT64, /* min */
    601 G_MAXINT64, /* max */
     598                                    PROP_LONG_ATTR,
     599                                    g_param_spec_long("long-attr", /* name */
     600                                                           "test_obj_long-attr", /* short description */
     601                                                           "read-write  glong TestObj.long-attr", /* longer - could do with some extra doc stuff here */
     602                                                           G_MINLONG, /* min */
     603G_MAXLONG, /* max */
    6026040, /* default */
    603605                                                           WEBKIT_PARAM_READWRITE));
    … …  
    932934
    933935void
    934 webkit_dom_test_obj_void_method_with_args(WebKitDOMTestObj* self, gint64 Arg, const gchar* strArg, WebKitDOMTestObj* objArg)
     936webkit_dom_test_obj_void_method_with_args(WebKitDOMTestObj* self, glong longArg, const gchar* strArg, WebKitDOMTestObj* objArg)
    935937{
    936938    g_return_if_fail(self);
    … …  
    945947        g_return_if_fail(convertedObjArg);
    946948    }
    947     item->voidMethodWithArgs(Arg, convertedStrArg, convertedObjArg);
    948 }
    949 
    950 gint64
    951 webkit_dom_test_obj_method(WebKitDOMTestObj* self)
    952 {
    953     g_return_val_if_fail(self, 0);
    954     WebCore::JSMainThreadNullState state;
    955     WebCore::TestObj* item = WebKit::core(self);
    956     gint64 result = item->Method();
    957     return result;
    958 }
    959 
    960 gint64
    961 webkit_dom_test_obj_method_with_args(WebKitDOMTestObj* self, gint64 Arg, const gchar* strArg, WebKitDOMTestObj* objArg)
     949    item->voidMethodWithArgs(longArg, convertedStrArg, convertedObjArg);
     950}
     951
     952glong
     953webkit_dom_test_obj_long_method(WebKitDOMTestObj* self)
     954{
     955    g_return_val_if_fail(self, 0);
     956    WebCore::JSMainThreadNullState state;
     957    WebCore::TestObj* item = WebKit::core(self);
     958    glong result = item->longMethod();
     959    return result;
     960}
     961
     962glong
     963webkit_dom_test_obj_long_method_with_args(WebKitDOMTestObj* self, glong longArg, const gchar* strArg, WebKitDOMTestObj* objArg)
    962964{
    963965    g_return_val_if_fail(self, 0);
    … …  
    972974        g_return_val_if_fail(convertedObjArg, 0);
    973975    }
    974     gint64 result = item->MethodWithArgs(Arg, convertedStrArg, convertedObjArg);
     976    glong result = item->longMethodWithArgs(longArg, convertedStrArg, convertedObjArg);
    975977    return result;
    976978}
    … …  
    988990
    989991WebKitDOMTestObj*
    990 webkit_dom_test_obj_obj_method_with_args(WebKitDOMTestObj* self, gint64 Arg, const gchar* strArg, WebKitDOMTestObj* objArg)
     992webkit_dom_test_obj_obj_method_with_args(WebKitDOMTestObj* self, glong longArg, const gchar* strArg, WebKitDOMTestObj* objArg)
    991993{
    992994    g_return_val_if_fail(self, 0);
    … …  
    10011003        g_return_val_if_fail(convertedObjArg, 0);
    10021004    }
    1003     RefPtr<WebCore::TestObj> gobjectResult = WTF::getPtr(item->objMethodWithArgs(Arg, convertedStrArg, convertedObjArg));
     1005    RefPtr<WebCore::TestObj> gobjectResult = WTF::getPtr(item->objMethodWithArgs(longArg, convertedStrArg, convertedObjArg));
    10041006    WebKitDOMTestObj* result = WebKit::kit(gobjectResult.get());
    10051007    return result;
    … …  
    13451347
    13461348void
    1347 webkit_dom_test_obj_convert1(WebKitDOMTestObj* self, WebKitDOMa* )
    1348 {
    1349     g_return_if_fail(self);
    1350     WebCore::JSMainThreadNullState state;
    1351     WebCore::TestObj* item = WebKit::core(self);
    1352     g_return_if_fail();
    1353     WebCore::a* converted = 0;
    1354     if () {
    1355         converted = WebKit::core();
    1356         g_return_if_fail(converted);
    1357     }
    1358     item->convert1(converted);
    1359 }
    1360 
    1361 void
    1362 webkit_dom_test_obj_convert2(WebKitDOMTestObj* self, WebKitDOMb* )
    1363 {
    1364     g_return_if_fail(self);
    1365     WebCore::JSMainThreadNullState state;
    1366     WebCore::TestObj* item = WebKit::core(self);
    1367     g_return_if_fail();
    1368     WebCore::b* converted = 0;
    1369     if () {
    1370         converted = WebKit::core();
    1371         g_return_if_fail(converted);
    1372     }
    1373     item->convert2(converted);
    1374 }
    1375 
    1376 void
    1377 webkit_dom_test_obj_convert4(WebKitDOMTestObj* self, WebKitDOMd* )
    1378 {
    1379     g_return_if_fail(self);
    1380     WebCore::JSMainThreadNullState state;
    1381     WebCore::TestObj* item = WebKit::core(self);
    1382     g_return_if_fail();
    1383     WebCore::d* converted = 0;
    1384     if () {
    1385         converted = WebKit::core();
    1386         g_return_if_fail(converted);
    1387     }
    1388     item->convert4(converted);
    1389 }
    1390 
    1391 void
    1392 webkit_dom_test_obj_convert5(WebKitDOMTestObj* self, WebKitDOMe* )
    1393 {
    1394     g_return_if_fail(self);
    1395     WebCore::JSMainThreadNullState state;
    1396     WebCore::TestObj* item = WebKit::core(self);
    1397     g_return_if_fail();
    1398     WebCore::e* converted = 0;
    1399     if () {
    1400         converted = WebKit::core();
    1401         g_return_if_fail(converted);
    1402     }
    1403     item->convert5(converted);
     1349webkit_dom_test_obj_convert1(WebKitDOMTestObj* self, WebKitDOMa* value)
     1350{
     1351    g_return_if_fail(self);
     1352    WebCore::JSMainThreadNullState state;
     1353    WebCore::TestObj* item = WebKit::core(self);
     1354    g_return_if_fail(value);
     1355    WebCore::a* convertedValue = 0;
     1356    if (value) {
     1357        convertedValue = WebKit::core(value);
     1358        g_return_if_fail(convertedValue);
     1359    }
     1360    item->convert1(convertedValue);
     1361}
     1362
     1363void
     1364webkit_dom_test_obj_convert2(WebKitDOMTestObj* self, WebKitDOMb* value)
     1365{
     1366    g_return_if_fail(self);
     1367    WebCore::JSMainThreadNullState state;
     1368    WebCore::TestObj* item = WebKit::core(self);
     1369    g_return_if_fail(value);
     1370    WebCore::b* convertedValue = 0;
     1371    if (value) {
     1372        convertedValue = WebKit::core(value);
     1373        g_return_if_fail(convertedValue);
     1374    }
     1375    item->convert2(convertedValue);
     1376}
     1377
     1378void
     1379webkit_dom_test_obj_convert4(WebKitDOMTestObj* self, WebKitDOMd* value)
     1380{
     1381    g_return_if_fail(self);
     1382    WebCore::JSMainThreadNullState state;
     1383    WebCore::TestObj* item = WebKit::core(self);
     1384    g_return_if_fail(value);
     1385    WebCore::d* convertedValue = 0;
     1386    if (value) {
     1387        convertedValue = WebKit::core(value);
     1388        g_return_if_fail(convertedValue);
     1389    }
     1390    item->convert4(convertedValue);
     1391}
     1392
     1393void
     1394webkit_dom_test_obj_convert5(WebKitDOMTestObj* self, WebKitDOMe* value)
     1395{
     1396    g_return_if_fail(self);
     1397    WebCore::JSMainThreadNullState state;
     1398    WebCore::TestObj* item = WebKit::core(self);
     1399    g_return_if_fail(value);
     1400    WebCore::e* convertedValue = 0;
     1401    if (value) {
     1402        convertedValue = WebKit::core(value);
     1403        g_return_if_fail(convertedValue);
     1404    }
     1405    item->convert5(convertedValue);
    14041406}
    14051407
    … …  
    15221524}
    15231525
    1524 gint64
    1525 webkit_dom_test_obj_get_attr(WebKitDOMTestObj* self)
    1526 {
    1527     g_return_val_if_fail(self, 0);
    1528     WebCore::JSMainThreadNullState state;
    1529     WebCore::TestObj* item = WebKit::core(self);
    1530     gint64 result = item->attr();
    1531     return result;
    1532 }
    1533 
    1534 void
    1535 webkit_dom_test_obj_set_attr(WebKitDOMTestObj* self, gint64 value)
    1536 {
    1537     g_return_if_fail(self);
    1538     WebCore::JSMainThreadNullState state;
    1539     WebCore::TestObj* item = WebKit::core(self);
    1540     item->setAttr(value);
     1526glong
     1527webkit_dom_test_obj_get_long_attr(WebKitDOMTestObj* self)
     1528{
     1529    g_return_val_if_fail(self, 0);
     1530    WebCore::JSMainThreadNullState state;
     1531    WebCore::TestObj* item = WebKit::core(self);
     1532    glong result = item->longAttr();
     1533    return result;
     1534}
     1535
     1536void
     1537webkit_dom_test_obj_set_long_attr(WebKitDOMTestObj* self, glong value)
     1538{
     1539    g_return_if_fail(self);
     1540    WebCore::JSMainThreadNullState state;
     1541    WebCore::TestObj* item = WebKit::core(self);
     1542    item->setLongAttr(value);
    15411543}
    15421544
    … …  
    18661868
    18671869void
    1868 webkit_dom_test_obj_set_attr_with_getter_exception(WebKitDOMTestObj* self, glong value, GError** error)
    1869 {
    1870     g_return_if_fail(self);
    1871     WebCore::JSMainThreadNullState state;
    1872     WebCore::TestObj* item = WebKit::core(self);
    1873     WebCore::ExceptionCode ec = 0;
    1874     item->setAttrWithGetterException(value, ec);
    1875     if (ec) {
    1876         WebCore::ExceptionCodeDescription ecdesc(ec);
    1877         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
    1878     }
     1870webkit_dom_test_obj_set_attr_with_getter_exception(WebKitDOMTestObj* self, glong value)
     1871{
     1872    g_return_if_fail(self);
     1873    WebCore::JSMainThreadNullState state;
     1874    WebCore::TestObj* item = WebKit::core(self);
     1875    item->setAttrWithGetterException(value);
    18791876}
    18801877
    … …  
    19151912
    19161913void
    1917 webkit_dom_test_obj_set_string_attr_with_getter_exception(WebKitDOMTestObj* self, const gchar* value, GError** error)
     1914webkit_dom_test_obj_set_string_attr_with_getter_exception(WebKitDOMTestObj* self, const gchar* value)
    19181915{
    19191916    g_return_if_fail(self);
    … …  
    19221919    g_return_if_fail(value);
    19231920    WTF::String convertedValue = WTF::String::fromUTF8(value);
    1924     WebCore::ExceptionCode ec = 0;
    1925     item->setStringAttrWithGetterException(convertedValue, ec);
    1926     if (ec) {
    1927         WebCore::ExceptionCodeDescription ecdesc(ec);
    1928         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
    1929     }
     1921    item->setStringAttrWithGetterException(convertedValue);
    19301922}
    19311923
    … …  
    20182010
    20192011void
    2020 webkit_dom_test_obj_set_with_script_state_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value, GError** error)
     2012webkit_dom_test_obj_set_with_script_state_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value)
    20212013{
    20222014    g_return_if_fail(self);
    … …  
    20292021        g_return_if_fail(convertedValue);
    20302022    }
    2031     WebCore::ExceptionCode ec = 0;
    2032     item->setWithScriptStateAttributeRaises(convertedValue, ec);
    2033     if (ec) {
    2034         WebCore::ExceptionCodeDescription ecdesc(ec);
    2035         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
    2036     }
     2023    item->setWithScriptStateAttributeRaises(convertedValue);
    20372024}
    20382025
    … …  
    20542041
    20552042void
    2056 webkit_dom_test_obj_set_with_script_execution_context_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value, GError** error)
     2043webkit_dom_test_obj_set_with_script_execution_context_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value)
    20572044{
    20582045    g_return_if_fail(self);
    … …  
    20652052        g_return_if_fail(convertedValue);
    20662053    }
    2067     WebCore::ExceptionCode ec = 0;
    2068     item->setWithScriptExecutionContextAttributeRaises(convertedValue, ec);
    2069     if (ec) {
    2070         WebCore::ExceptionCodeDescription ecdesc(ec);
    2071         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
    2072     }
     2054    item->setWithScriptExecutionContextAttributeRaises(convertedValue);
    20732055}
    20742056
    … …  
    21162098
    21172099void
    2118 webkit_dom_test_obj_set_with_script_execution_context_and_script_state_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value, GError** error)
     2100webkit_dom_test_obj_set_with_script_execution_context_and_script_state_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value)
    21192101{
    21202102    g_return_if_fail(self);
    … …  
    21272109        g_return_if_fail(convertedValue);
    21282110    }
    2129     WebCore::ExceptionCode ec = 0;
    2130     item->setWithScriptExecutionContextAndScriptStateAttributeRaises(convertedValue, ec);
    2131     if (ec) {
    2132         WebCore::ExceptionCodeDescription ecdesc(ec);
    2133         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
    2134     }
     2111    item->setWithScriptExecutionContextAndScriptStateAttributeRaises(convertedValue);
    21352112}
    21362113

  • trunk/Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestObj.h

    r128248 r129723  
    5959 * webkit_dom_test_obj_void_method_with_args:
    6060 * @self: A #WebKitDOMTestObj
    61  * @Arg: A #gint64
     61 * @longArg: A #glong
    6262 * @strArg: A #gchar
    6363 * @objArg: A #WebKitDOMTestObj
    … …  
    6767**/
    6868WEBKIT_API void
    69 webkit_dom_test_obj_void_method_with_args(WebKitDOMTestObj* self, gint64 Arg, const gchar* strArg, WebKitDOMTestObj* objArg);
    70 
    71 /**
    72  * webkit_dom_test_obj_method:
    73  * @self: A #WebKitDOMTestObj
    74  *
    75  * Returns:
    76  *
    77 **/
    78 WEBKIT_API gint64
    79 webkit_dom_test_obj_method(WebKitDOMTestObj* self);
    80 
    81 /**
    82  * webkit_dom_test_obj_method_with_args:
    83  * @self: A #WebKitDOMTestObj
    84  * @Arg: A #gint64
     69webkit_dom_test_obj_void_method_with_args(WebKitDOMTestObj* self, glong longArg, const gchar* strArg, WebKitDOMTestObj* objArg);
     70
     71/**
     72 * webkit_dom_test_obj_long_method:
     73 * @self: A #WebKitDOMTestObj
     74 *
     75 * Returns:
     76 *
     77**/
     78WEBKIT_API glong
     79webkit_dom_test_obj_long_method(WebKitDOMTestObj* self);
     80
     81/**
     82 * webkit_dom_test_obj_long_method_with_args:
     83 * @self: A #WebKitDOMTestObj
     84 * @longArg: A #glong
    8585 * @strArg: A #gchar
    8686 * @objArg: A #WebKitDOMTestObj
    … …  
    8989 *
    9090**/
    91 WEBKIT_API gint64
    92 webkit_dom_test_obj_method_with_args(WebKitDOMTestObj* self, gint64 Arg, const gchar* strArg, WebKitDOMTestObj* objArg);
     91WEBKIT_API glong
     92webkit_dom_test_obj_long_method_with_args(WebKitDOMTestObj* self, glong longArg, const gchar* strArg, WebKitDOMTestObj* objArg);
    9393
    9494/**
    … …  
    105105 * webkit_dom_test_obj_obj_method_with_args:
    106106 * @self: A #WebKitDOMTestObj
    107  * @Arg: A #gint64
     107 * @longArg: A #glong
    108108 * @strArg: A #gchar
    109109 * @objArg: A #WebKitDOMTestObj
    … …  
    113113**/
    114114WEBKIT_API WebKitDOMTestObj*
    115 webkit_dom_test_obj_obj_method_with_args(WebKitDOMTestObj* self, gint64 Arg, const gchar* strArg, WebKitDOMTestObj* objArg);
     115webkit_dom_test_obj_obj_method_with_args(WebKitDOMTestObj* self, glong longArg, const gchar* strArg, WebKitDOMTestObj* objArg);
    116116
    117117/**
    … …  
    401401 * webkit_dom_test_obj_convert1:
    402402 * @self: A #WebKitDOMTestObj
    403  * @: A #WebKitDOMa
    404  *
    405  * Returns:
    406  *
    407 **/
    408 WEBKIT_API void
    409 webkit_dom_test_obj_convert1(WebKitDOMTestObj* self, WebKitDOMa* );
     403 * @value: A #WebKitDOMa
     404 *
     405 * Returns:
     406 *
     407**/
     408WEBKIT_API void
     409webkit_dom_test_obj_convert1(WebKitDOMTestObj* self, WebKitDOMa* value);
    410410
    411411/**
    412412 * webkit_dom_test_obj_convert2:
    413413 * @self: A #WebKitDOMTestObj
    414  * @: A #WebKitDOMb
    415  *
    416  * Returns:
    417  *
    418 **/
    419 WEBKIT_API void
    420 webkit_dom_test_obj_convert2(WebKitDOMTestObj* self, WebKitDOMb* );
     414 * @value: A #WebKitDOMb
     415 *
     416 * Returns:
     417 *
     418**/
     419WEBKIT_API void
     420webkit_dom_test_obj_convert2(WebKitDOMTestObj* self, WebKitDOMb* value);
    421421
    422422/**
    423423 * webkit_dom_test_obj_convert4:
    424424 * @self: A #WebKitDOMTestObj
    425  * @: A #WebKitDOMd
    426  *
    427  * Returns:
    428  *
    429 **/
    430 WEBKIT_API void
    431 webkit_dom_test_obj_convert4(WebKitDOMTestObj* self, WebKitDOMd* );
     425 * @value: A #WebKitDOMd
     426 *
     427 * Returns:
     428 *
     429**/
     430WEBKIT_API void
     431webkit_dom_test_obj_convert4(WebKitDOMTestObj* self, WebKitDOMd* value);
    432432
    433433/**
    434434 * webkit_dom_test_obj_convert5:
    435435 * @self: A #WebKitDOMTestObj
    436  * @: A #WebKitDOMe
    437  *
    438  * Returns:
    439  *
    440 **/
    441 WEBKIT_API void
    442 webkit_dom_test_obj_convert5(WebKitDOMTestObj* self, WebKitDOMe* );
     436 * @value: A #WebKitDOMe
     437 *
     438 * Returns:
     439 *
     440**/
     441WEBKIT_API void
     442webkit_dom_test_obj_convert5(WebKitDOMTestObj* self, WebKitDOMe* value);
    443443
    444444/**
    … …  
    559559
    560560/**
    561  * webkit_dom_test_obj_get_attr:
    562  * @self: A #WebKitDOMTestObj
    563  *
    564  * Returns:
    565  *
    566 **/
    567 WEBKIT_API gint64
    568 webkit_dom_test_obj_get_attr(WebKitDOMTestObj* self);
    569 
    570 /**
    571  * webkit_dom_test_obj_set_attr:
    572  * @self: A #WebKitDOMTestObj
    573  * @value: A #gint64
    574  *
    575  * Returns:
    576  *
    577 **/
    578 WEBKIT_API void
    579 webkit_dom_test_obj_set_attr(WebKitDOMTestObj* self, gint64 value);
     561 * webkit_dom_test_obj_get_long_attr:
     562 * @self: A #WebKitDOMTestObj
     563 *
     564 * Returns:
     565 *
     566**/
     567WEBKIT_API glong
     568webkit_dom_test_obj_get_long_attr(WebKitDOMTestObj* self);
     569
     570/**
     571 * webkit_dom_test_obj_set_long_attr:
     572 * @self: A #WebKitDOMTestObj
     573 * @value: A #glong
     574 *
     575 * Returns:
     576 *
     577**/
     578WEBKIT_API void
     579webkit_dom_test_obj_set_long_attr(WebKitDOMTestObj* self, glong value);
    580580
    581581/**
    … …  
    909909 * @self: A #WebKitDOMTestObj
    910910 * @value: A #glong
    911  * @error: #GError
    912  *
    913  * Returns:
    914  *
    915 **/
    916 WEBKIT_API void
    917 webkit_dom_test_obj_set_attr_with_getter_exception(WebKitDOMTestObj* self, glong value, GError** error);
     911 *
     912 * Returns:
     913 *
     914**/
     915WEBKIT_API void
     916webkit_dom_test_obj_set_attr_with_getter_exception(WebKitDOMTestObj* self, glong value);
    918917
    919918/**
    … …  
    954953 * @self: A #WebKitDOMTestObj
    955954 * @value: A #gchar
    956  * @error: #GError
    957  *
    958  * Returns:
    959  *
    960 **/
    961 WEBKIT_API void
    962 webkit_dom_test_obj_set_string_attr_with_getter_exception(WebKitDOMTestObj* self, const gchar* value, GError** error);
     955 *
     956 * Returns:
     957 *
     958**/
     959WEBKIT_API void
     960webkit_dom_test_obj_set_string_attr_with_getter_exception(WebKitDOMTestObj* self, const gchar* value);
    963961
    964962/**
    … …  
    10411039 * @self: A #WebKitDOMTestObj
    10421040 * @value: A #WebKitDOMTestObj
     1041 *
     1042 * Returns: (transfer none):
     1043 *
     1044**/
     1045WEBKIT_API void
     1046webkit_dom_test_obj_set_with_script_state_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value);
     1047
     1048/**
     1049 * webkit_dom_test_obj_get_with_script_execution_context_attribute_raises:
     1050 * @self: A #WebKitDOMTestObj
    10431051 * @error: #GError
    10441052 *
    … …  
    10461054 *
    10471055**/
    1048 WEBKIT_API void
    1049 webkit_dom_test_obj_set_with_script_state_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value, GError** error);
    1050 
    1051 /**
    1052  * webkit_dom_test_obj_get_with_script_execution_context_attribute_raises:
     1056WEBKIT_API WebKitDOMTestObj*
     1057webkit_dom_test_obj_get_with_script_execution_context_attribute_raises(WebKitDOMTestObj* self, GError** error);
     1058
     1059/**
     1060 * webkit_dom_test_obj_set_with_script_execution_context_attribute_raises:
     1061 * @self: A #WebKitDOMTestObj
     1062 * @value: A #WebKitDOMTestObj
     1063 *
     1064 * Returns: (transfer none):
     1065 *
     1066**/
     1067WEBKIT_API void
     1068webkit_dom_test_obj_set_with_script_execution_context_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value);
     1069
     1070/**
     1071 * webkit_dom_test_obj_get_with_script_execution_context_and_script_state_attribute:
     1072 * @self: A #WebKitDOMTestObj
     1073 *
     1074 * Returns: (transfer none):
     1075 *
     1076**/
     1077WEBKIT_API WebKitDOMTestObj*
     1078webkit_dom_test_obj_get_with_script_execution_context_and_script_state_attribute(WebKitDOMTestObj* self);
     1079
     1080/**
     1081 * webkit_dom_test_obj_set_with_script_execution_context_and_script_state_attribute:
     1082 * @self: A #WebKitDOMTestObj
     1083 * @value: A #WebKitDOMTestObj
     1084 *
     1085 * Returns: (transfer none):
     1086 *
     1087**/
     1088WEBKIT_API void
     1089webkit_dom_test_obj_set_with_script_execution_context_and_script_state_attribute(WebKitDOMTestObj* self, WebKitDOMTestObj* value);
     1090
     1091/**
     1092 * webkit_dom_test_obj_get_with_script_execution_context_and_script_state_attribute_raises:
    10531093 * @self: A #WebKitDOMTestObj
    10541094 * @error: #GError
    … …  
    10581098**/
    10591099WEBKIT_API WebKitDOMTestObj*
    1060 webkit_dom_test_obj_get_with_script_execution_context_attribute_raises(WebKitDOMTestObj* self, GError** error);
    1061 
    1062 /**
    1063  * webkit_dom_test_obj_set_with_script_execution_context_attribute_raises:
     1100webkit_dom_test_obj_get_with_script_execution_context_and_script_state_attribute_raises(WebKitDOMTestObj* self, GError** error);
     1101
     1102/**
     1103 * webkit_dom_test_obj_set_with_script_execution_context_and_script_state_attribute_raises:
    10641104 * @self: A #WebKitDOMTestObj
    10651105 * @value: A #WebKitDOMTestObj
    1066  * @error: #GError
    1067  *
    1068  * Returns: (transfer none):
    1069  *
    1070 **/
    1071 WEBKIT_API void
    1072 webkit_dom_test_obj_set_with_script_execution_context_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value, GError** error);
    1073 
    1074 /**
    1075  * webkit_dom_test_obj_get_with_script_execution_context_and_script_state_attribute:
    1076  * @self: A #WebKitDOMTestObj
    1077  *
    1078  * Returns: (transfer none):
    1079  *
    1080 **/
    1081 WEBKIT_API WebKitDOMTestObj*
    1082 webkit_dom_test_obj_get_with_script_execution_context_and_script_state_attribute(WebKitDOMTestObj* self);
    1083 
    1084 /**
    1085  * webkit_dom_test_obj_set_with_script_execution_context_and_script_state_attribute:
    1086  * @self: A #WebKitDOMTestObj
    1087  * @value: A #WebKitDOMTestObj
    1088  *
    1089  * Returns: (transfer none):
    1090  *
    1091 **/
    1092 WEBKIT_API void
    1093 webkit_dom_test_obj_set_with_script_execution_context_and_script_state_attribute(WebKitDOMTestObj* self, WebKitDOMTestObj* value);
    1094 
    1095 /**
    1096  * webkit_dom_test_obj_get_with_script_execution_context_and_script_state_attribute_raises:
    1097  * @self: A #WebKitDOMTestObj
    1098  * @error: #GError
    1099  *
    1100  * Returns: (transfer none):
    1101  *
    1102 **/
    1103 WEBKIT_API WebKitDOMTestObj*
    1104 webkit_dom_test_obj_get_with_script_execution_context_and_script_state_attribute_raises(WebKitDOMTestObj* self, GError** error);
    1105 
    1106 /**
    1107  * webkit_dom_test_obj_set_with_script_execution_context_and_script_state_attribute_raises:
    1108  * @self: A #WebKitDOMTestObj
    1109  * @value: A #WebKitDOMTestObj
    1110  * @error: #GError
    1111  *
    1112  * Returns: (transfer none):
    1113  *
    1114 **/
    1115 WEBKIT_API void
    1116 webkit_dom_test_obj_set_with_script_execution_context_and_script_state_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value, GError** error);
     1106 *
     1107 * Returns: (transfer none):
     1108 *
     1109**/
     1110WEBKIT_API void
     1111webkit_dom_test_obj_set_with_script_execution_context_and_script_state_attribute_raises(WebKitDOMTestObj* self, WebKitDOMTestObj* value);
    11171112
    11181113/**

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp

    r128655 r129723  
    8787    { "shortAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjShortAttr), (intptr_t)setJSTestObjShortAttr, NoIntrinsic },
    8888    { "unsignedShortAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedShortAttr), (intptr_t)setJSTestObjUnsignedShortAttr, NoIntrinsic },
    89     { "Attr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttr), (intptr_t)setJSTestObjAttr, NoIntrinsic },
     89    { "longAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongAttr), (intptr_t)setJSTestObjLongAttr, NoIntrinsic },
    9090    { "longLongAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongLongAttr), (intptr_t)setJSTestObjLongLongAttr, NoIntrinsic },
    9191    { "unsignedLongLongAttr", DontDelete, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedLongLongAttr), (intptr_t)setJSTestObjUnsignedLongLongAttr, NoIntrinsic },
    … …  
    267267    { "voidMethod", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethod), (intptr_t)0, NoIntrinsic },
    268268    { "voidMethodWithArgs", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethodWithArgs), (intptr_t)3, NoIntrinsic },
    269     { "Method", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethod), (intptr_t)0, NoIntrinsic },
    270     { "MethodWithArgs", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithArgs), (intptr_t)3, NoIntrinsic },
     269    { "longMethod", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethod), (intptr_t)0, NoIntrinsic },
     270    { "longMethodWithArgs", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethodWithArgs), (intptr_t)3, NoIntrinsic },
    271271    { "objMethod", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethod), (intptr_t)0, NoIntrinsic },
    272272    { "objMethodWithArgs", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethodWithArgs), (intptr_t)3, NoIntrinsic },
    … …  
    464464
    465465
    466 JSValue jsTestObjAttr(ExecState* exec, JSValue slotBase, PropertyName)
    467 {
    468     JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
    469     UNUSED_PARAM(exec);
    470     TestObj* impl = static_cast<TestObj*>(castedThis->impl());
    471     JSValue result = jsNumber(impl->attr());
     466JSValue jsTestObjLongAttr(ExecState* exec, JSValue slotBase, PropertyName)
     467{
     468    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(slotBase));
     469    UNUSED_PARAM(exec);
     470    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
     471    JSValue result = jsNumber(impl->longAttr());
    472472    return result;
    473473}
    … …  
    10021002
    10031003
    1004 void setJSTestObjAttr(ExecState* exec, JSObject* thisObject, JSValue value)
    1005 {
    1006     UNUSED_PARAM(exec);
    1007     JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
    1008     TestObj* impl = static_cast<TestObj*>(castedThis->impl());
    1009     impl->setAttr(static_cast<long long>(value.toInteger(exec)));
     1004void setJSTestObjLongAttr(ExecState* exec, JSObject* thisObject, JSValue value)
     1005{
     1006    UNUSED_PARAM(exec);
     1007    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
     1008    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
     1009    impl->setLongAttr(value.toInt32(exec));
    10101010}
    10111011
    … …  
    11601160    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
    11611161    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
    1162     ExceptionCode ec = 0;
    1163     impl->setAttrWithGetterException(value.toInt32(exec), ec);
    1164     setDOMException(exec, ec);
     1162    impl->setAttrWithGetterException(value.toInt32(exec));
    11651163}
    11661164
    … …  
    11821180    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
    11831181    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
    1184     ExceptionCode ec = 0;
    1185     impl->setStringAttrWithGetterException(value.isEmpty() ? String() : value.toString(exec)->value(exec), ec);
    1186     setDOMException(exec, ec);
     1182    impl->setStringAttrWithGetterException(value.isEmpty() ? String() : value.toString(exec)->value(exec));
    11871183}
    11881184
    … …  
    12321228    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
    12331229    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
    1234     ExceptionCode ec = 0;
    1235     impl->setWithScriptStateAttributeRaises(exec, toTestObj(value), ec);
    1236     setDOMException(exec, ec);
     1230    impl->setWithScriptStateAttributeRaises(exec, toTestObj(value));
    12371231}
    12381232
    … …  
    12431237    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
    12441238    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
    1245     ExceptionCode ec = 0;
    12461239    ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
    12471240    if (!scriptContext)
    12481241        return;
    1249     impl->setWithScriptExecutionContextAttributeRaises(scriptContext, toTestObj(value), ec);
    1250     setDOMException(exec, ec);
     1242    impl->setWithScriptExecutionContextAttributeRaises(scriptContext, toTestObj(value));
    12511243}
    12521244
    … …  
    12691261    JSTestObj* castedThis = jsCast<JSTestObj*>(thisObject);
    12701262    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
    1271     ExceptionCode ec = 0;
    12721263    ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
    12731264    if (!scriptContext)
    12741265        return;
    1275     impl->setWithScriptExecutionContextAndScriptStateAttributeRaises(exec, scriptContext, toTestObj(value), ec);
    1276     setDOMException(exec, ec);
     1266    impl->setWithScriptExecutionContextAndScriptStateAttributeRaises(exec, scriptContext, toTestObj(value));
    12771267}
    12781268
    … …  
    14521442    if (exec->argumentCount() < 3)
    14531443        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    1454     long long Arg(static_cast<long long>(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toInteger(exec)));
     1444    int longArg(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toInt32(exec));
    14551445    if (exec->hadException())
    14561446        return JSValue::encode(jsUndefined());
    … …  
    14611451    if (exec->hadException())
    14621452        return JSValue::encode(jsUndefined());
    1463     impl->voidMethodWithArgs(Arg, strArg, objArg);
    1464     return JSValue::encode(jsUndefined());
    1465 }
    1466 
    1467 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethod(ExecState* exec)
    1468 {
    1469     JSValue thisValue = exec->hostThisValue();
    1470     if (!thisValue.inherits(&JSTestObj::s_info))
    1471         return throwVMTypeError(exec);
    1472     JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(thisValue));
    1473     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSTestObj::s_info);
    1474     TestObj* impl = static_cast<TestObj*>(castedThis->impl());
    1475 
    1476     JSC::JSValue result = jsNumber(impl->method());
     1453    impl->voidMethodWithArgs(longArg, strArg, objArg);
     1454    return JSValue::encode(jsUndefined());
     1455}
     1456
     1457EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethod(ExecState* exec)
     1458{
     1459    JSValue thisValue = exec->hostThisValue();
     1460    if (!thisValue.inherits(&JSTestObj::s_info))
     1461        return throwVMTypeError(exec);
     1462    JSTestObj* castedThis = jsCast<JSTestObj*>(asObject(thisValue));
     1463    ASSERT_GC_OBJECT_INHERITS(castedThis, &JSTestObj::s_info);
     1464    TestObj* impl = static_cast<TestObj*>(castedThis->impl());
     1465
     1466    JSC::JSValue result = jsNumber(impl->longMethod());
    14771467    return JSValue::encode(result);
    14781468}
    14791469
    1480 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithArgs(ExecState* exec)
     1470EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethodWithArgs(ExecState* exec)
    14811471{
    14821472    JSValue thisValue = exec->hostThisValue();
    … …  
    14881478    if (exec->argumentCount() < 3)
    14891479        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    1490     long long Arg(static_cast<long long>(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toInteger(exec)));
     1480    int longArg(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toInt32(exec));
    14911481    if (exec->hadException())
    14921482        return JSValue::encode(jsUndefined());
    … …  
    14981488        return JSValue::encode(jsUndefined());
    14991489
    1500     JSC::JSValue result = jsNumber(impl->methodWithArgs(Arg, strArg, objArg));
     1490    JSC::JSValue result = jsNumber(impl->longMethodWithArgs(longArg, strArg, objArg));
    15011491    return JSValue::encode(result);
    15021492}
    … …  
    15251515    if (exec->argumentCount() < 3)
    15261516        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    1527     long long Arg(static_cast<long long>(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toInteger(exec)));
     1517    int longArg(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toInt32(exec));
    15281518    if (exec->hadException())
    15291519        return JSValue::encode(jsUndefined());
    … …  
    15351525        return JSValue::encode(jsUndefined());
    15361526
    1537     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->objMethodWithArgs(Arg, strArg, objArg)));
     1527    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->objMethodWithArgs(longArg, strArg, objArg)));
    15381528    return JSValue::encode(result);
    15391529}
    … …  
    15661556    if (exec->argumentCount() < 1)
    15671557        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    1568     long long Arg(static_cast<long long>(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toInteger(exec)));
    1569     if (exec->hadException())
    1570         return JSValue::encode(jsUndefined());
    1571 
    1572     JSC::JSValue result = jsArray(exec, castedThis->globalObject(), impl->methodReturningSequence(Arg));
     1558    int longArg(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toInt32(exec));
     1559    if (exec->hadException())
     1560        return JSValue::encode(jsUndefined());
     1561
     1562    JSC::JSValue result = jsArray(exec, castedThis->globalObject(), impl->methodReturningSequence(longArg));
    15731563    return JSValue::encode(result);
    15741564}
    … …  
    21452135    }
    21462136
    2147     long long Arg(static_cast<long long>(MAYBE_MISSING_PARAMETER(exec, 1, DefaultIsUndefined).toInteger(exec)));
    2148     if (exec->hadException())
    2149         return JSValue::encode(jsUndefined());
    2150     impl->overloadedMethod(objArg, Arg);
     2137    int longArg(MAYBE_MISSING_PARAMETER(exec, 1, DefaultIsUndefined).toInt32(exec));
     2138    if (exec->hadException())
     2139        return JSValue::encode(jsUndefined());
     2140    impl->overloadedMethod(objArg, longArg);
    21512141    return JSValue::encode(jsUndefined());
    21522142}
    … …  
    21792169    if (exec->argumentCount() < 1)
    21802170        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    2181     long long Arg(static_cast<long long>(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toInteger(exec)));
    2182     if (exec->hadException())
    2183         return JSValue::encode(jsUndefined());
    2184     impl->overloadedMethod(Arg);
     2171    int longArg(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined).toInt32(exec));
     2172    if (exec->hadException())
     2173        return JSValue::encode(jsUndefined());
     2174    impl->overloadedMethod(longArg);
    21852175    return JSValue::encode(jsUndefined());
    21862176}
    … …  
    24862476    if (exec->argumentCount() < 1)
    24872477        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    2488     a* (toa(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined)));
    2489     if (exec->hadException())
    2490         return JSValue::encode(jsUndefined());
    2491     impl->convert1();
     2478    a* value(toa(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined)));
     2479    if (exec->hadException())
     2480        return JSValue::encode(jsUndefined());
     2481    impl->convert1(value);
    24922482    return JSValue::encode(jsUndefined());
    24932483}
    … …  
    25032493    if (exec->argumentCount() < 1)
    25042494        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    2505     b* (tob(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined)));
    2506     if (exec->hadException())
    2507         return JSValue::encode(jsUndefined());
    2508     impl->convert2();
     2495    b* value(tob(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined)));
     2496    if (exec->hadException())
     2497        return JSValue::encode(jsUndefined());
     2498    impl->convert2(value);
    25092499    return JSValue::encode(jsUndefined());
    25102500}
    … …  
    25202510    if (exec->argumentCount() < 1)
    25212511        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    2522     d* (tod(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined)));
    2523     if (exec->hadException())
    2524         return JSValue::encode(jsUndefined());
    2525     impl->convert4();
     2512    d* value(tod(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined)));
     2513    if (exec->hadException())
     2514        return JSValue::encode(jsUndefined());
     2515    impl->convert4(value);
    25262516    return JSValue::encode(jsUndefined());
    25272517}
    … …  
    25372527    if (exec->argumentCount() < 1)
    25382528        return throwVMError(exec, createNotEnoughArgumentsError(exec));
    2539     e* (toe(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined)));
    2540     if (exec->hadException())
    2541         return JSValue::encode(jsUndefined());
    2542     impl->convert5();
     2529    e* value(toe(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined)));
     2530    if (exec->hadException())
     2531        return JSValue::encode(jsUndefined());
     2532    impl->convert5(value);
    25432533    return JSValue::encode(jsUndefined());
    25442534}

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.h

    r128442 r129723  
    155155JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethod(JSC::ExecState*);
    156156JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethodWithArgs(JSC::ExecState*);
    157 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethod(JSC::ExecState*);
    158 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithArgs(JSC::ExecState*);
     157JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethod(JSC::ExecState*);
     158JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethodWithArgs(JSC::ExecState*);
    159159JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethod(JSC::ExecState*);
    160160JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethodWithArgs(JSC::ExecState*);
    … …  
    229229JSC::JSValue jsTestObjUnsignedShortAttr(JSC::ExecState*, JSC::JSValue, JSC::PropertyName);
    230230void setJSTestObjUnsignedShortAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
    231 JSC::JSValue jsTestObjAttr(JSC::ExecState*, JSC::JSValue, JSC::PropertyName);
    232 void setJSTestObjAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
     231JSC::JSValue jsTestObjLongAttr(JSC::ExecState*, JSC::JSValue, JSC::PropertyName);
     232void setJSTestObjLongAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);
    233233JSC::JSValue jsTestObjLongLongAttr(JSC::ExecState*, JSC::JSValue, JSC::PropertyName);
    234234void setJSTestObjLongLongAttr(JSC::ExecState*, JSC::JSObject*, JSC::JSValue);

  • trunk/Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.h

    r128248 r129723  
    7171@property short shortAttr;
    7272@property unsigned short unsignedShortAttr;
    73 @property long long Attr;
     73@property int longAttr;
    7474@property long long longLongAttr;
    7575@property unsigned long long unsignedLongLongAttr;
    … …  
    118118
    119119- (void)voidMethod;
    120 - (void)voidMethodWithArgs:(long long)Arg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg;
    121 - (long long)Method;
    122 - (long long)MethodWithArgs:(long long)Arg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg;
     120- (void)voidMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg;
     121- (int)longMethod;
     122- (int)longMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg;
    123123- (DOMTestObj *)objMethod;
    124 - (DOMTestObj *)objMethodWithArgs:(long long)Arg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg;
     124- (DOMTestObj *)objMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg;
    125125- (DOMTestObj *)methodThatRequiresAllArgsAndThrows:(NSString *)strArg objArg:(DOMTestObj *)objArg;
    126126- (void)serializedValue:(NSString *)serializedArg;
    … …  
    129129- (void)methodWithException;
    130130- (void)customMethod;
    131 - (void)customMethodWithArgs:(long long)Arg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg;
     131- (void)customMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg;
    132132- (void)addEventListener:(NSString *)type listener:(id <DOMEventListener>)listener useCapture:(BOOL)useCapture;
    133133- (void)removeEventListener:(NSString *)type listener:(id <DOMEventListener>)listener useCapture:(BOOL)useCapture;
    … …  
    166166#endif
    167167- (DOMSVGDocument *)getSVGDocument;
    168 - (void)convert1:(DOMa *);
    169 - (void)convert2:(DOMb *);
    170 - (void)convert4:(DOMd *);
    171 - (void)convert5:(DOMe *);
     168- (void)convert1:(DOMa *)value;
     169- (void)convert2:(DOMb *)value;
     170- (void)convert4:(DOMd *)value;
     171- (void)convert5:(DOMe *)value;
    172172- (DOMSVGPoint *)mutablePointFunction;
    173173- (DOMSVGPoint *)immutablePointFunction;

  • trunk/Source/WebCore/bindings/scripts/test/ObjC/DOMTestObj.mm

    r128248 r129723  
    141141}
    142142
    143 - (long long)Attr
    144 {
    145     WebCore::JSMainThreadNullState state;
    146     return IMPL->attr();
    147 }
    148 
    149 - (void)setAttr:(long long)newAttr
    150 {
    151     WebCore::JSMainThreadNullState state;
    152     IMPL->setAttr(newAttr);
     143- (int)longAttr
     144{
     145    WebCore::JSMainThreadNullState state;
     146    return IMPL->longAttr();
     147}
     148
     149- (void)setLongAttr:(int)newLongAttr
     150{
     151    WebCore::JSMainThreadNullState state;
     152    IMPL->setLongAttr(newLongAttr);
    153153}
    154154
    … …  
    349349{
    350350    WebCore::JSMainThreadNullState state;
    351     WebCore::ExceptionCode ec = 0;
    352     IMPL->setAttrWithGetterException(newAttrWithGetterException, ec);
    353     WebCore::raiseOnDOMError(ec);
     351    IMPL->setAttrWithGetterException(newAttrWithGetterException);
    354352}
    355353
    … …  
    380378{
    381379    WebCore::JSMainThreadNullState state;
    382     WebCore::ExceptionCode ec = 0;
    383     IMPL->setStringAttrWithGetterException(newStringAttrWithGetterException, ec);
    384     WebCore::raiseOnDOMError(ec);
     380    IMPL->setStringAttrWithGetterException(newStringAttrWithGetterException);
    385381}
    386382
    … …  
    451447    ASSERT(newWithScriptStateAttributeRaises);
    452448
    453     WebCore::ExceptionCode ec = 0;
    454     IMPL->setWithScriptStateAttributeRaises(core(newWithScriptStateAttributeRaises), ec);
    455     WebCore::raiseOnDOMError(ec);
     449    IMPL->setWithScriptStateAttributeRaises(core(newWithScriptStateAttributeRaises));
    456450}
    457451
    … …  
    470464    ASSERT(newWithScriptExecutionContextAttributeRaises);
    471465
    472     WebCore::ExceptionCode ec = 0;
    473     IMPL->setWithScriptExecutionContextAttributeRaises(core(newWithScriptExecutionContextAttributeRaises), ec);
    474     WebCore::raiseOnDOMError(ec);
     466    IMPL->setWithScriptExecutionContextAttributeRaises(core(newWithScriptExecutionContextAttributeRaises));
    475467}
    476468
    … …  
    503495    ASSERT(newWithScriptExecutionContextAndScriptStateAttributeRaises);
    504496
    505     WebCore::ExceptionCode ec = 0;
    506     IMPL->setWithScriptExecutionContextAndScriptStateAttributeRaises(core(newWithScriptExecutionContextAndScriptStateAttributeRaises), ec);
    507     WebCore::raiseOnDOMError(ec);
     497    IMPL->setWithScriptExecutionContextAndScriptStateAttributeRaises(core(newWithScriptExecutionContextAndScriptStateAttributeRaises));
    508498}
    509499
    … …  
    740730}
    741731
    742 - (void)voidMethodWithArgs:(long long)Arg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
    743 {
    744     WebCore::JSMainThreadNullState state;
    745     IMPL->voidMethodWithArgs(Arg, strArg, core(objArg));
    746 }
    747 
    748 - (long long)Method
    749 {
    750     WebCore::JSMainThreadNullState state;
    751     return IMPL->method();
    752 }
    753 
    754 - (long long)MethodWithArgs:(long long)Arg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
    755 {
    756     WebCore::JSMainThreadNullState state;
    757     return IMPL->methodWithArgs(Arg, strArg, core(objArg));
     732- (void)voidMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
     733{
     734    WebCore::JSMainThreadNullState state;
     735    IMPL->voidMethodWithArgs(longArg, strArg, core(objArg));
     736}
     737
     738- (int)longMethod
     739{
     740    WebCore::JSMainThreadNullState state;
     741    return IMPL->longMethod();
     742}
     743
     744- (int)longMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
     745{
     746    WebCore::JSMainThreadNullState state;
     747    return IMPL->longMethodWithArgs(longArg, strArg, core(objArg));
    758748}
    759749
    … …  
    764754}
    765755
    766 - (DOMTestObj *)objMethodWithArgs:(long long)Arg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
    767 {
    768     WebCore::JSMainThreadNullState state;
    769     return kit(WTF::getPtr(IMPL->objMethodWithArgs(Arg, strArg, core(objArg))));
     756- (DOMTestObj *)objMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
     757{
     758    WebCore::JSMainThreadNullState state;
     759    return kit(WTF::getPtr(IMPL->objMethodWithArgs(longArg, strArg, core(objArg))));
    770760}
    771761
    … …  
    811801}
    812802
    813 - (void)customMethodWithArgs:(long long)Arg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
    814 {
    815     WebCore::JSMainThreadNullState state;
    816     IMPL->customMethodWithArgs(Arg, strArg, core(objArg));
     803- (void)customMethodWithArgs:(int)longArg strArg:(NSString *)strArg objArg:(DOMTestObj *)objArg
     804{
     805    WebCore::JSMainThreadNullState state;
     806    IMPL->customMethodWithArgs(longArg, strArg, core(objArg));
    817807}
    818808
    … …  
    1006996}
    1007997
    1008 - (void)convert1:(DOMa *)
    1009 {
    1010     WebCore::JSMainThreadNullState state;
    1011     IMPL->convert1(core());
    1012 }
    1013 
    1014 - (void)convert2:(DOMb *)
    1015 {
    1016     WebCore::JSMainThreadNullState state;
    1017     IMPL->convert2(core());
    1018 }
    1019 
    1020 - (void)convert4:(DOMd *)
    1021 {
    1022     WebCore::JSMainThreadNullState state;
    1023     IMPL->convert4(core());
    1024 }
    1025 
    1026 - (void)convert5:(DOMe *)
    1027 {
    1028     WebCore::JSMainThreadNullState state;
    1029     IMPL->convert5(core());
     998- (void)convert1:(DOMa *)value
     999{
     1000    WebCore::JSMainThreadNullState state;
     1001    IMPL->convert1(core(value));
     1002}
     1003
     1004- (void)convert2:(DOMb *)value
     1005{
     1006    WebCore::JSMainThreadNullState state;
     1007    IMPL->convert2(core(value));
     1008}
     1009
     1010- (void)convert4:(DOMd *)value
     1011{
     1012    WebCore::JSMainThreadNullState state;
     1013    IMPL->convert4(core(value));
     1014}
     1015
     1016- (void)convert5:(DOMe *)value
     1017{
     1018    WebCore::JSMainThreadNullState state;
     1019    IMPL->convert5(core(value));
    10301020}
    10311021

  • trunk/Source/WebCore/bindings/scripts/test/TestObj.idl

    r128788 r129723  
    5252        attribute [V8MeasureAs=TestFeature] TestObj testObjAttr;
    5353
    54         JS, V8
    5554        // WK_ucfirst, WK_lcfirst exceptional cases.
    5655        attribute TestObj                  XMLObjAttr;
    … …  
    227226            raises(DOMException);
    228227
    229         void convert1(in [TreatReturnedNullStringAs=Null] a);
    230         void convert2(in [TreatReturnedNullStringAs=Undefined] b);
    231         void convert4(in [TreatNullAs=NullString] d);
    232         void convert5(in [TreatNullAs=NullString, TreatUndefinedAs=NullString] e);
     228        void convert1(in [TreatReturnedNullStringAs=Null] a value);
     229        void convert2(in [TreatReturnedNullStringAs=Undefined] b value);
     230        void convert4(in [TreatNullAs=NullString] d value);
     231        void convert5(in [TreatNullAs=NullString, TreatUndefinedAs=NullString] e value);
    233232
    234233        attribute SVGPoint mutablePoint;

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestObj.cpp

    r128788 r129723  
    162162}
    163163
    164 static v8::Handle<v8::Value> AttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
    165 {
    166     INC_STATS("DOM.TestObj.Attr._get");
    167     TestObj* imp = V8TestObj::toNative(info.Holder());
    168     return v8::Number::New(static_cast<double>(imp->attr()));
    169 }
    170 
    171 static void AttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
    172 {
    173     INC_STATS("DOM.TestObj.Attr._set");
    174     TestObj* imp = V8TestObj::toNative(info.Holder());
    175     long long v = toInt64(value);
    176     imp->setAttr(WTF::getPtr(v));
     164static v8::Handle<v8::Value> longAttrAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
     165{
     166    INC_STATS("DOM.TestObj.longAttr._get");
     167    TestObj* imp = V8TestObj::toNative(info.Holder());
     168    return v8Integer(imp->longAttr(), info.GetIsolate());
     169}
     170
     171static void longAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
     172{
     173    INC_STATS("DOM.TestObj.longAttr._set");
     174    TestObj* imp = V8TestObj::toNative(info.Holder());
     175    int v = toInt32(value);
     176    imp->setLongAttr(v);
    177177    return;
    178178}
    … …  
    452452    TestObj* imp = V8TestObj::toNative(info.Holder());
    453453    int v = toInt32(value);
    454     ExceptionCode ec = 0;
    455     imp->setAttrWithGetterException(v, ec);
    456     if (UNLIKELY(ec))
    457         setDOMException(ec, info.GetIsolate());
     454    imp->setAttrWithGetterException(v);
    458455    return;
    459456}
    … …  
    494491    TestObj* imp = V8TestObj::toNative(info.Holder());
    495492    STRING_TO_V8PARAMETER_EXCEPTION_BLOCK_VOID(V8Parameter<>, v, value);
    496     ExceptionCode ec = 0;
    497     imp->setStringAttrWithGetterException(v, ec);
    498     if (UNLIKELY(ec))
    499         setDOMException(ec, info.GetIsolate());
     493    imp->setStringAttrWithGetterException(v);
    500494    return;
    501495}
    … …  
    583577    TestObj* imp = V8TestObj::toNative(info.Holder());
    584578    TestObj* v = V8TestObj::HasInstance(value) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(value)) : 0;
    585     ExceptionCode ec = 0;
    586579    ScriptState* state = ScriptState::current();
    587580    if (!state)
    588581        return;
    589     imp->setWithScriptStateAttributeRaises(state, WTF::getPtr(v), ec);
    590     if (UNLIKELY(ec))
    591         setDOMException(ec, info.GetIsolate());
     582    imp->setWithScriptStateAttributeRaises(state, WTF::getPtr(v));
    592583    if (state.hadException())
    593584        throwError(state.exception(), info.GetIsolate());
    … …  
    612603    TestObj* imp = V8TestObj::toNative(info.Holder());
    613604    TestObj* v = V8TestObj::HasInstance(value) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(value)) : 0;
    614     ExceptionCode ec = 0;
    615605    ScriptExecutionContext* scriptContext = getScriptExecutionContext();
    616     imp->setWithScriptExecutionContextAttributeRaises(scriptContext, WTF::getPtr(v), ec);
    617     if (UNLIKELY(ec))
    618         setDOMException(ec, info.GetIsolate());
     606    imp->setWithScriptExecutionContextAttributeRaises(scriptContext, WTF::getPtr(v));
    619607    return;
    620608}
    … …  
    668656    TestObj* imp = V8TestObj::toNative(info.Holder());
    669657    TestObj* v = V8TestObj::HasInstance(value) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(value)) : 0;
    670     ExceptionCode ec = 0;
    671658    ScriptState* state = ScriptState::current();
    672659    if (!state)
    673660        return;
    674661    ScriptExecutionContext* scriptContext = getScriptExecutionContext();
    675     imp->setWithScriptExecutionContextAndScriptStateAttributeRaises(state, scriptContext, WTF::getPtr(v), ec);
    676     if (UNLIKELY(ec))
    677         setDOMException(ec, info.GetIsolate());
     662    imp->setWithScriptExecutionContextAndScriptStateAttributeRaises(state, scriptContext, WTF::getPtr(v));
    678663    if (state.hadException())
    679664        throwError(state.exception(), info.GetIsolate());
    … …  
    10691054        return throwNotEnoughArgumentsError(args.GetIsolate());
    10701055    TestObj* imp = V8TestObj::toNative(args.Holder());
    1071     EXCEPTION_BLOCK(long long, Arg, toInt64(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1056    EXCEPTION_BLOCK(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    10721057    STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
    10731058    EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined))) : 0);
    1074     imp->voidMethodWithArgs(Arg, strArg, objArg);
    1075     return v8Undefined();
    1076 }
    1077 
    1078 static v8::Handle<v8::Value> MethodCallback(const v8::Arguments& args)
    1079 {
    1080     INC_STATS("DOM.TestObj.Method");
    1081     TestObj* imp = V8TestObj::toNative(args.Holder());
    1082     return v8::Number::New(static_cast<double>(imp->Method()));
    1083 }
    1084 
    1085 static v8::Handle<v8::Value> MethodWithArgsCallback(const v8::Arguments& args)
    1086 {
    1087     INC_STATS("DOM.TestObj.MethodWithArgs");
     1059    imp->voidMethodWithArgs(longArg, strArg, objArg);
     1060    return v8Undefined();
     1061}
     1062
     1063static v8::Handle<v8::Value> longMethodCallback(const v8::Arguments& args)
     1064{
     1065    INC_STATS("DOM.TestObj.longMethod");
     1066    TestObj* imp = V8TestObj::toNative(args.Holder());
     1067    return v8Integer(imp->longMethod(), args.GetIsolate());
     1068}
     1069
     1070static v8::Handle<v8::Value> longMethodWithArgsCallback(const v8::Arguments& args)
     1071{
     1072    INC_STATS("DOM.TestObj.longMethodWithArgs");
    10881073    if (args.Length() < 3)
    10891074        return throwNotEnoughArgumentsError(args.GetIsolate());
    10901075    TestObj* imp = V8TestObj::toNative(args.Holder());
    1091     EXCEPTION_BLOCK(long long, Arg, toInt64(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1076    EXCEPTION_BLOCK(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    10921077    STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
    10931078    EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined))) : 0);
    1094     return v8::Number::New(static_cast<double>(imp->MethodWithArgs(Arg, strArg, objArg)));
     1079    return v8Integer(imp->longMethodWithArgs(longArg, strArg, objArg), args.GetIsolate());
    10951080}
    10961081
    … …  
    11091094        return throwNotEnoughArgumentsError(args.GetIsolate());
    11101095    TestObj* imp = V8TestObj::toNative(args.Holder());
    1111     EXCEPTION_BLOCK(long long, Arg, toInt64(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1096    EXCEPTION_BLOCK(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    11121097    STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, strArg, MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined));
    11131098    EXCEPTION_BLOCK(TestObj*, objArg, V8TestObj::HasInstance(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined)) ? V8TestObj::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 2, DefaultIsUndefined))) : 0);
    1114     return toV8(imp->objMethodWithArgs(Arg, strArg, objArg), args.Holder(), args.GetIsolate());
     1099    return toV8(imp->objMethodWithArgs(longArg, strArg, objArg), args.Holder(), args.GetIsolate());
    11151100}
    11161101
    … …  
    11321117        return throwNotEnoughArgumentsError(args.GetIsolate());
    11331118    TestObj* imp = V8TestObj::toNative(args.Holder());
    1134     EXCEPTION_BLOCK(long long, Arg, toInt64(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    1135     return v8Array(imp->methodReturningSequence(Arg), args.GetIsolate());
     1119    EXCEPTION_BLOCK(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1120    return v8Array(imp->methodReturningSequence(longArg), args.GetIsolate());
    11361121}
    11371122
    … …  
    15391524        return v8Undefined();
    15401525    }
    1541     EXCEPTION_BLOCK(long long, Arg, toInt64(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)));
    1542     imp->overloadedMethod(objArg, Arg);
     1526    EXCEPTION_BLOCK(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 1, DefaultIsUndefined)));
     1527    imp->overloadedMethod(objArg, longArg);
    15431528    return v8Undefined();
    15441529}
    … …  
    15611546        return throwNotEnoughArgumentsError(args.GetIsolate());
    15621547    TestObj* imp = V8TestObj::toNative(args.Holder());
    1563     EXCEPTION_BLOCK(long long, Arg, toInt64(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    1564     imp->overloadedMethod(Arg);
     1548    EXCEPTION_BLOCK(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1549    imp->overloadedMethod(longArg);
    15651550    return v8Undefined();
    15661551}
    … …  
    17471732        return throwNotEnoughArgumentsError(args.GetIsolate());
    17481733    TestObj* imp = V8TestObj::toNative(args.Holder());
    1749     EXCEPTION_BLOCK(long long, Arg, toInt64(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    1750     imp->enabledAtRuntimeMethod1(Arg);
     1734    EXCEPTION_BLOCK(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1735    imp->enabledAtRuntimeMethod1(longArg);
    17511736    return v8Undefined();
    17521737}
    … …  
    17581743        return throwNotEnoughArgumentsError(args.GetIsolate());
    17591744    TestObj* imp = V8TestObj::toNative(args.Holder());
    1760     EXCEPTION_BLOCK(long long, Arg, toInt64(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    1761     imp->enabledAtRuntimeMethod2(Arg);
     1745    EXCEPTION_BLOCK(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1746    imp->enabledAtRuntimeMethod2(longArg);
    17621747    return v8Undefined();
    17631748}
    … …  
    17691754        return throwNotEnoughArgumentsError(args.GetIsolate());
    17701755    TestObj* imp = V8TestObj::toNative(args.Holder());
    1771     EXCEPTION_BLOCK(long long, Arg, toInt64(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    1772     imp->enabledPerContextMethod1(Arg);
     1756    EXCEPTION_BLOCK(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1757    imp->enabledPerContextMethod1(longArg);
    17731758    return v8Undefined();
    17741759}
    … …  
    17801765        return throwNotEnoughArgumentsError(args.GetIsolate());
    17811766    TestObj* imp = V8TestObj::toNative(args.Holder());
    1782     EXCEPTION_BLOCK(long long, Arg, toInt64(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
    1783     imp->enabledPerContextMethod2(Arg);
     1767    EXCEPTION_BLOCK(int, longArg, toInt32(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)));
     1768    imp->enabledPerContextMethod2(longArg);
    17841769    return v8Undefined();
    17851770}
    … …  
    18261811        return throwNotEnoughArgumentsError(args.GetIsolate());
    18271812    TestObj* imp = V8TestObj::toNative(args.Holder());
    1828     EXCEPTION_BLOCK(a*, , V8a::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8a::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
    1829     imp->convert1();
     1813    EXCEPTION_BLOCK(a*, value, V8a::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8a::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     1814    imp->convert1(value);
    18301815    return v8Undefined();
    18311816}
    … …  
    18371822        return throwNotEnoughArgumentsError(args.GetIsolate());
    18381823    TestObj* imp = V8TestObj::toNative(args.Holder());
    1839     EXCEPTION_BLOCK(b*, , V8b::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8b::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
    1840     imp->convert2();
     1824    EXCEPTION_BLOCK(b*, value, V8b::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8b::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     1825    imp->convert2(value);
    18411826    return v8Undefined();
    18421827}
    … …  
    18481833        return throwNotEnoughArgumentsError(args.GetIsolate());
    18491834    TestObj* imp = V8TestObj::toNative(args.Holder());
    1850     EXCEPTION_BLOCK(d*, , V8d::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8d::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
    1851     imp->convert4();
     1835    EXCEPTION_BLOCK(d*, value, V8d::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8d::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     1836    imp->convert4(value);
    18521837    return v8Undefined();
    18531838}
    … …  
    18591844        return throwNotEnoughArgumentsError(args.GetIsolate());
    18601845    TestObj* imp = V8TestObj::toNative(args.Holder());
    1861     EXCEPTION_BLOCK(e*, , V8e::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8e::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
    1862     imp->convert5();
     1846    EXCEPTION_BLOCK(e*, value, V8e::HasInstance(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined)) ? V8e::toNative(v8::Handle<v8::Object>::Cast(MAYBE_MISSING_PARAMETER(args, 0, DefaultIsUndefined))) : 0);
     1847    imp->convert5(value);
    18631848    return v8Undefined();
    18641849}
    … …  
    19251910    // Attribute 'unsignedShortAttr' (Type: 'attribute' ExtAttr: '')
    19261911    {"unsignedShortAttr", TestObjV8Internal::unsignedShortAttrAttrGetter, TestObjV8Internal::unsignedShortAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
    1927     // Attribute 'Attr' (Type: 'attribute' ExtAttr: '')
    1928     {"Attr", TestObjV8Internal::AttrAttrGetter, TestObjV8Internal::AttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
     1912    // Attribute 'longAttr' (Type: 'attribute' ExtAttr: '')
     1913    {"longAttr", TestObjV8Internal::longAttrAttrGetter, TestObjV8Internal::longAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
    19291914    // Attribute 'longLongAttr' (Type: 'attribute' ExtAttr: '')
    19301915    {"longLongAttr", TestObjV8Internal::longLongAttrAttrGetter, TestObjV8Internal::longLongAttrAttrSetter, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
    … …  
    20412026static const V8DOMConfiguration::BatchedCallback V8TestObjCallbacks[] = {
    20422027    {"voidMethod", TestObjV8Internal::voidMethodCallback},
    2043     {"Method", TestObjV8Internal::MethodCallback},
     2028    {"longMethod", TestObjV8Internal::longMethodCallback},
    20442029    {"objMethod", TestObjV8Internal::objMethodCallback},
    20452030    {"methodReturningSequence", TestObjV8Internal::methodReturningSequenceCallback},
    … …  
    21812166    proto->Set(v8::String::NewSymbol("voidMethodWithArgs"), v8::FunctionTemplate::New(TestObjV8Internal::voidMethodWithArgsCallback, v8Undefined(), voidMethodWithArgsSignature));
    21822167
    2183     // Custom Signature 'MethodWithArgs'
    2184     const int MethodWithArgsArgc = 3;
    2185     v8::Handle<v8::FunctionTemplate> MethodWithArgsArgv[MethodWithArgsArgc] = { v8::Handle<v8::FunctionTemplate>(), v8::Handle<v8::FunctionTemplate>(), V8TestObj::GetRawTemplate() };
    2186     v8::Handle<v8::Signature> MethodWithArgsSignature = v8::Signature::New(desc, MethodWithArgsArgc, MethodWithArgsArgv);
    2187     proto->Set(v8::String::NewSymbol("MethodWithArgs"), v8::FunctionTemplate::New(TestObjV8Internal::MethodWithArgsCallback, v8Undefined(), MethodWithArgsSignature));
     2168    // Custom Signature 'longMethodWithArgs'
     2169    const int longMethodWithArgsArgc = 3;
     2170    v8::Handle<v8::FunctionTemplate> longMethodWithArgsArgv[longMethodWithArgsArgc] = { v8::Handle<v8::FunctionTemplate>(), v8::Handle<v8::FunctionTemplate>(), V8TestObj::GetRawTemplate() };
     2171    v8::Handle<v8::Signature> longMethodWithArgsSignature = v8::Signature::New(desc, longMethodWithArgsArgc, longMethodWithArgsArgv);
     2172    proto->Set(v8::String::NewSymbol("longMethodWithArgs"), v8::FunctionTemplate::New(TestObjV8Internal::longMethodWithArgsCallback, v8Undefined(), longMethodWithArgsSignature));
    21882173
    21892174    // Custom Signature 'objMethodWithArgs'
Note: See TracChangeset for help on using the changeset viewer.