Empty reflected attributes and string literals in extended attributes.

Source/bindings/scripts/idl_parser.pm

 #
 # KDOM IDL parser
 #
 # Copyright (C) 2005 Nikolas Zimmermann <wildfox@kde.org>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Library General Public
 # License as published by the Free Software Foundation; either
 # version 2 of the License, or (at your option) any later version.
 #
@@ skipping 215 matching lines @@
     my $self = shift;
     $self->{Token} = $self->{NextToken};
     $self->{NextToken} = $self->getTokenInternal();
     return $self->{Token};
 }
 
 my $whitespaceTokenPattern = '^[\t\n\r ]*[\n\r]';
 my $floatTokenPattern = '^(-?(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][+-]?[0-9]+)?|[0-9]+[Ee][+-]?[0-9]+))';
 my $integerTokenPattern = '^(-?[1-9][0-9]*|-?0[Xx][0-9A-Fa-f]+|-?0[0-7]*)';
 my $stringTokenPattern = '^(\"[^\"]*\")';
-my $identifierTokenPattern = '^([A-Z_a-z][0-9A-Z_a-z]*)';
+my $identifierTokenPattern = '^([A-Z_a-z][0-9A-Z_a-z-]*)';

[haraken, 2014/01/08 10:45:38]

This isn't a right change.

The Web IDL grammar says the identifier should be [A-Z_a-z][0-9A-Z_a-z]*

http://www.w3.org/TR/WebIDL/#idl-grammar

[sof, 2014/01/08 10:50:12]

Either the "identifier" syntactic category is reused to encompass this, or a new
one is needed.

[Nils Barth (inactive), 2014/01/08 11:28:29]

To concur with haraken:
AFAICT, we want this to hold string values, so we should use string literals,
not abuse identifiers.

Simplest would be to allow extended attribute values to be (lists of)
identifiers *or* string literals; that's not much of a stretch from where we
currently are.

Other thoughts:

For ReflectOnly, where we want to give an enumerated list of values, most
natural seems to be:
define an enumeration for the allowed values
(the enumeration has an name, which is an identifier),
and use the enumeration name as the value.
E.g.,
enum CorsValues {"anonymous", "use-credentials"};

...
    [Reflect, ReflectOnly=CorsValues]
(This doesn't handle ReflectEmpty though.)

The other alternative that comes to mind is to allow string literals in extended
attribute values.
This seems ok, as we're already abusing extended attribute values to allow
A=X|Y, which violates spec, and extended attributes are exactly the place that
we do implementation-specific things.

...so we'd write:
[Reflect, ReflectOnly="anonymous"|"use-credentials", ReflectEmpty="anonymous",
ReflectInvalid="anonymous"]

The basic problem is that we want to include more complex data in extended
attributes, so key-value pairs (where value is an identifier) is really
limiting.

 my $otherTokenPattern = '^(::|\.\.\.|[^\t\n\r 0-9A-Z_a-z])';
 
 sub getTokenInternal
 {
     my $self = shift;
 
     if ($self->{DocumentContent} =~ /$whitespaceTokenPattern/) {
         $self->{DocumentContent} =~ s/($whitespaceTokenPattern)//;
         my $skipped = $1;
         $self->{LineNumber}++ while ($skipped =~ /\n/g);
@@ skipping 1964 matching lines @@
             $customConstructor->overloadedIndex($index++);
             push(@{$interface->customConstructors}, $customConstructor);
         }
         delete $extendedAttributeList->{"CustomConstructors"};
         $extendedAttributeList->{"CustomConstructor"} = "VALUE_IS_MISSING";
     }
     $interface->extendedAttributes($extendedAttributeList);
 }
 
 1;