IDL parser: align with current Web IDL specification

tools/idl_parser/idl_parser.py

 #!/usr/bin/env python
 # Copyright (c) 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """ Parser for PPAPI IDL """
 
 #
 # IDL Parser
 #
@@ skipping 175 matching lines @@
 # http://www.w3.org/TR/WebIDL/#idl-grammar
 #
   # [1]
   def p_Definitions(self, p):
     """Definitions : ExtendedAttributeList Definition Definitions
            | """
     if len(p) > 1:
       p[2].AddChildren(p[1])
       p[0] = ListFromConcat(p[2], p[3])
 
-      # [2] Add INLINE definition
+  # [2] Add INLINE definition

[Jens Widell, 2014/06/12 13:34:36]

I don't know what this comment is about. :-) There doesn't seem to be any
"inline" anywhere.

[noelallen1, 2014/06/12 19:33:37]

This really should just be:
 # [2] 
To signify it's defining the 2nd item in the WebIDL grammar.

   def p_Definition(self, p):
     """Definition : CallbackOrInterface
                   | Partial
                   | Dictionary
                   | Exception
                   | Enum
                   | Typedef
                   | ImplementsStatement"""
     p[0] = p[1]
 
@@ skipping 15 matching lines @@
   def p_CallbackRestOrInterface(self, p):
     """CallbackRestOrInterface : CallbackRest
                                | Interface"""
     p[0] = p[1]
 
   # [5]
   def p_Interface(self, p):
     """Interface : INTERFACE identifier Inheritance '{' InterfaceMembers '}' ';'"""
     p[0] = self.BuildNamed('Interface', p, 2, ListFromConcat(p[3], p[5]))
 
-  # [6] Error recovery for PARTIAL
+  # [6]
   def p_Partial(self, p):
     """Partial : PARTIAL PartialDefinition"""
     p[2].AddChildren(self.BuildTrue('Partial'))
     p[0] = p[2]
 
-  # [6.1] Error recovery for Enums
+  # [6.1] Error recovery for Partial
   def p_PartialError(self, p):
     """Partial : PARTIAL error"""
     p[0] = self.BuildError(p, 'Partial')
 
   # [7]
   def p_PartialDefinition(self, p):
     """PartialDefinition : PartialDictionary
                          | PartialInterface"""
     p[0] = p[1]
 
   # [8]
   def p_PartialInterface(self, p):
     """PartialInterface : INTERFACE identifier '{' InterfaceMembers '}' ';'"""
     p[0] = self.BuildNamed('Interface', p, 2, p[4])
 
   # [9]
   def p_InterfaceMembers(self, p):
     """InterfaceMembers : ExtendedAttributeList InterfaceMember InterfaceMembers
                         |"""
     if len(p) > 1:
       p[2].AddChildren(p[1])
       p[0] = ListFromConcat(p[2], p[3])
 
   # [10]
   def p_InterfaceMember(self, p):
     """InterfaceMember : Const
-                       | AttributeOrOperation"""
+                       | AttributeOrOperationOrIterator"""
     p[0] = p[1]
 
   # [11]
   def p_Dictionary(self, p):
     """Dictionary : DICTIONARY identifier Inheritance '{' DictionaryMembers '}' ';'"""
     p[0] = self.BuildNamed('Dictionary', p, 2, ListFromConcat(p[3], p[5]))
 
   # [11.1] Error recovery for regular Dictionary
   def p_DictionaryError(self, p):
     """Dictionary : DICTIONARY error ';'"""
@@ skipping 70 matching lines @@
     """Enum : ENUM identifier '{' EnumValueList '}' ';'"""
     p[0] = self.BuildNamed('Enum', p, 2, p[4])
 
   # [20.1] Error recovery for Enums
   def p_EnumError(self, p):
     """Enum : ENUM error ';'"""
     p[0] = self.BuildError(p, 'Enum')
 
   # [21]
   def p_EnumValueList(self, p):
-    """EnumValueList : ExtendedAttributeList string EnumValues"""
+    """EnumValueList : ExtendedAttributeList string EnumValueListComma"""
     enum = self.BuildNamed('EnumItem', p, 2, p[1])
     p[0] = ListFromConcat(enum, p[3])
 
   # [22]
-  def p_EnumValues(self, p):
-    """EnumValues : ',' ExtendedAttributeList string EnumValues
-                  |"""
+  def p_EnumValueListComma(self, p):
+    """EnumValueListComma : ',' EnumValueListString
+                          |"""
     if len(p) > 1:
-      enum = self.BuildNamed('EnumItem', p, 3, p[2])
-      p[0] = ListFromConcat(enum, p[4])
+      p[0] = p[2]
 
   # [23]
+  def p_EnumValueListString(self, p):
+    """EnumValueListString : ExtendedAttributeList string EnumValueListComma
+                           |"""
+    if len(p) > 1:
+      enum = self.BuildNamed('EnumItem', p, 2, p[1])
+      p[0] = ListFromConcat(enum, p[3])
+
+  # [24]

[noelallen1, 2014/06/12 19:33:37]

This does not match:
   http://www.w3.org/TR/WebIDL/#idl-grammar
   [24]	Typedef	"typedef" ExtendedAttributeList Type identifier ";"

The number [x] refers to the equivalent WebIDL definition.  If you are using a
newer or experimental spec other than: http://www.w3.org/TR/WebIDL/#idl-grammar
then make use to update the comment above referencing this link.

   def p_CallbackRest(self, p):
     """CallbackRest : identifier '=' ReturnType '(' ArgumentList ')' ';'"""
     arguments = self.BuildProduction('Arguments', p, 4, p[5])
     p[0] = self.BuildNamed('Callback', p, 1, ListFromConcat(p[3], arguments))
 
-  # [24]
+  # [25]
   def p_Typedef(self, p):
     """Typedef : TYPEDEF ExtendedAttributeListNoComments Type identifier ';'"""
     p[0] = self.BuildNamed('Typedef', p, 4, ListFromConcat(p[2], p[3]))
 
-  # [24.1] Error recovery for Typedefs
+  # [25.1] Error recovery for Typedefs
   def p_TypedefError(self, p):
     """Typedef : TYPEDEF error ';'"""
     p[0] = self.BuildError(p, 'Typedef')
 
-  # [25]
+  # [26]
   def p_ImplementsStatement(self, p):
     """ImplementsStatement : identifier IMPLEMENTS identifier ';'"""
     name = self.BuildAttribute('REFERENCE', p[3])
     p[0] = self.BuildNamed('Implements', p, 1, name)
 
-  # [26]
+  # [27]
   def p_Const(self,  p):
     """Const : CONST ConstType identifier '=' ConstValue ';'"""
     value = self.BuildProduction('Value', p, 5, p[5])
     p[0] = self.BuildNamed('Const', p, 3, ListFromConcat(p[2], value))
 
-  # [27]
+  # [28]
   def p_ConstValue(self, p):
     """ConstValue : BooleanLiteral
                   | FloatLiteral
                   | integer
                   | null"""
     if type(p[1]) == str:
       p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'integer'),
                             self.BuildAttribute('NAME', p[1]))
     else:
       p[0] = p[1]
 
-  # [27.1] Add definition for NULL
+  # [28.1] Add definition for NULL
   def p_null(self, p):
     """null : NULL"""
     p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'NULL'),
                           self.BuildAttribute('NAME', 'NULL'))
 
-  # [28]
+  # [29]
   def p_BooleanLiteral(self, p):
     """BooleanLiteral : TRUE
                       | FALSE"""
     value = self.BuildAttribute('VALUE', Boolean(p[1] == 'true'))
     p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'boolean'), value)
 
-  # [29]
+  # [30]
   def p_FloatLiteral(self, p):
     """FloatLiteral : float
                     | '-' INFINITY
                     | INFINITY
                     | NAN """
     if len(p) > 2:
       val = '-Infinity'
     else:
       val = p[1]
     p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'float'),
                           self.BuildAttribute('VALUE', val))
 
-  # [30]
-  def p_AttributeOrOperation(self, p):
-    """AttributeOrOperation : STRINGIFIER StringifierAttributeOrOperation
-                            | Attribute
-                            | Operation"""
-    if len(p) > 2:
-      p[0] = p[2]
-    else:
-      p[0] = p[1]
-
-  # [31]
-  def p_StringifierAttributeOrOperation(self, p):
-    """StringifierAttributeOrOperation : Attribute
-                                       | OperationRest
-                                       | ';'"""
-    if p[1] == ';':
-      p[0] = self.BuildAttribute('STRINGIFIER', Boolean(True))
-    else:
-      p[0] = ListFromConcat(self.BuildAttribute('STRINGIFIER', p[1]), p[1])
+  # [31] Removed unsupported: Serializer, Stringifier
+  def p_AttributeOrOperationOrIterator(self, p):
+    """AttributeOrOperationOrIterator : StaticMember
+                                      | Attribute
+                                      | OperationOrIterator"""
+    p[0] = p[1]
 
   # [32]
-  def p_Attribute(self, p):
-    """Attribute : Inherit ReadOnly ATTRIBUTE Type identifier ';'"""
-    p[0] = self.BuildNamed('Attribute', p, 5,
-                           ListFromConcat(p[1], p[2], p[4]))
+  # def p_Serializer(self, p):

[noelallen1, 2014/06/12 19:33:36]

I have mixed feeling about these place holders.  I think it's great to update
the numbers above to match the spec, but adding these NOT_IMPLEMENTED
definitions implies an updating burden for something that's a comment.

Would it be just as easy to understand yet simpler to maintain if we just had a
single comment:

# [32 - 39]  NOT IMPLEMENTED

I could be convinced either way.

+  #   """Serializer : SERIALIZER SerializerRest"""
+  #   NOT_IMPLEMENTED
 
   # [33]
+  # def p_SerializerRest(self, p):
+  #   """SerializerRest : OperationRest
+  #                     | '=' SerializationPattern
+  #                     |"""
+  #   NOT_IMPLEMENTED
+
+  # [34]
+  # def p_SerializationPattern(self, p):
+  #   """SerializationPattern : '{' SerializationPatternMap '}'
+  #                           | '[' SerializationPatternList ']'
+  #                           | identifier"""
+  #   NOT_IMPLEMENTED
+
+  # [35]
+  # def p_SerializationPatternMap(self, p):
+  #   """SerializationPatternMap : GETTER
+  #                              | INHERIT Identifiers
+  #                              | identifier Identifiers
+  #                              |"""
+  #   NOT_IMPLEMENTED
+
+  # [36]
+  # def p_SerializationPatternList(self, p):
+  #   """SerializationPatternList : GETTER
+  #                               | identifier Identifiers
+  #                               |"""
+  #   NOT_IMPLEMENTED
+
+  # [37]
+  # def p_Identifiers(self, p):
+  #   """Identifiers : ',' identifier Identifiers
+  #                  |"""
+  #   return ListFromConcat(p[2], p[3])
+
+  # [38]
+  # def p_Stringifier(self, p):
+  #   """Stringifier : STRINGIFIER StringifierRest"""
+  #   NOT_IMPLEMENTED
+
+  # [39]
+  # def p_StringifierRest(self, p):
+  #   """StringifierRest : AttributeRest
+  #                      | ReturnType OperationRest
+  #                      | ';'"""
+  #   NOT_IMPLEMENTED
+
+  # [40]
+  def p_StaticMember(self, p):
+    """StaticMember : STATIC StaticMemberRest"""
+    p[2].AddChildren(self.BuildTrue('STATIC'))
+    p[0] = p[2]
+
+  # [41]
+  def p_StaticMemberRest(self, p):
+    """StaticMemberRest : AttributeRest
+                        | ReturnType OperationRest"""
+    if len(p) == 2:
+      p[0] = p[1]
+    else:
+      p[2].AddChildren(p[1])
+      p[0] = p[2]
+
+  # [42]
+  def p_Attribute(self, p):
+    """Attribute : Inherit AttributeRest"""
+    p[2].AddChildren(ListFromConcat(p[1]))
+    p[0] = p[2]
+
+  # [43]
+  def p_AttributeRest(self, p):
+    """AttributeRest : ReadOnly ATTRIBUTE Type identifier ';'"""
+    p[0] = self.BuildNamed('Attribute', p, 4,
+                           ListFromConcat(p[1], p[3]))
+
+  # [44]
   def p_Inherit(self, p):
     """Inherit : INHERIT
                |"""
     if len(p) > 1:
       p[0] = self.BuildTrue('INHERIT')
 
-  # [34]
+  # [45]
   def p_ReadOnly(self, p):
     """ReadOnly : READONLY
-               |"""
+                |"""
     if len(p) > 1:
       p[0] = self.BuildTrue('READONLY')
 
-  # [35]
-  def p_Operation(self, p):
-    """Operation : Qualifiers OperationRest"""
-    p[2].AddChildren(p[1])
-    p[0] = p[2]
-
-  # [36]
-  def p_Qualifiers(self, p):
-    """Qualifiers : STATIC
-                  | Specials"""
-    if p[1] == 'static':
-      p[0] = self.BuildTrue('STATIC')
+  # [46]
+  def p_OperationOrIterator(self, p):
+    """OperationOrIterator : ReturnType OperationOrIteratorRest
+                           | SpecialOperation"""
+    if len(p) == 3:
+      p[2].AddChildren(p[1])
+      p[0] = p[2]
     else:
       p[0] = p[1]
 
-  # [37]
+  # [47]
+  def p_SpecialOperation(self, p):
+    """SpecialOperation : Special Specials ReturnType OperationRest"""
+    p[4].AddChildren(ListFromConcat(p[1], p[2], p[3]))
+    p[0] = p[4]
+
+  # [48]
   def p_Specials(self, p):
     """Specials : Special Specials
                 | """
     if len(p) > 1:
       p[0] = ListFromConcat(p[1], p[2])
 
-  # [38]
+  # [49]
   def p_Special(self, p):
     """Special : GETTER
                | SETTER
                | CREATOR
                | DELETER
                | LEGACYCALLER"""
     p[0] = self.BuildTrue(p[1].upper())
 
+  # [50] Removed unsupported: IteratorRest
+  def p_OperationOrIteratorRest(self, p):
+    """OperationOrIteratorRest : OperationRest"""
+    p[0] = p[1]
 
-  # [39]
+  # [51]
+  # def p_IteratorRest(self, p):
+  #   """IteratorRest : ITERATOR OptionalIteratorInterfaceOrObject ';'"""
+  #   NOT_IMPLEMENTED
+
+  # [52]
+  # def p_OptionalIteratorInterfaceOrObject(self, p):
+  #   """OptionalIteratorInterfaceOrObject : OptionalIteratorInterface
+  #                                        | OBJECT"""
+  #   NOT_IMPLEMENTED
+
+  # [53]
+  # def p_OptionalIteratorInterface(self, p):
+  #   """OptionalIteratorInterface : '=' identifier
+  #                                |"""
+  #   NOT_IMPLEMENTED
+
+  # [54]
   def p_OperationRest(self, p):
-    """OperationRest : ReturnType OptionalIdentifier '(' ArgumentList ')' ';'"""
-    arguments = self.BuildProduction('Arguments', p, 3, p[4])
-    p[0] = self.BuildNamed('Operation', p, 2, ListFromConcat(p[1], arguments))
+    """OperationRest : OptionalIdentifier '(' ArgumentList ')' ';'"""
+    arguments = self.BuildProduction('Arguments', p, 2, p[3])
+    p[0] = self.BuildNamed('Operation', p, 1, arguments)
 
-  # [40]
+  # [55]
   def p_OptionalIdentifier(self, p):
     """OptionalIdentifier : identifier
                           |"""
     if len(p) > 1:
       p[0] = p[1]
     else:
       p[0] = '_unnamed_'
 
-  # [41]
+  # [56]
   def p_ArgumentList(self, p):
     """ArgumentList : Argument Arguments
                     |"""
     if len(p) > 1:
       p[0] = ListFromConcat(p[1], p[2])
 
-  # [41.1] ArgumentList error recovery
+  # [56.1] ArgumentList error recovery
   def p_ArgumentListError(self, p):
     """ArgumentList : error """
     p[0] = self.BuildError(p, 'ArgumentList')
 
-  # [42]
+  # [57]
   def p_Arguments(self, p):
     """Arguments : ',' Argument Arguments
                  |"""
     if len(p) > 1:
       p[0] = ListFromConcat(p[2], p[3])
 
-  # [43]
+  # [58]
   def p_Argument(self, p):
     """Argument : ExtendedAttributeList OptionalOrRequiredArgument"""
     p[2].AddChildren(p[1])
     p[0] = p[2]
 
-
-  # [44]
+  # [59]
   def p_OptionalOrRequiredArgument(self, p):
     """OptionalOrRequiredArgument : OPTIONAL Type ArgumentName Default
                                   | Type Ellipsis ArgumentName"""
     if len(p) > 4:
       arg = self.BuildNamed('Argument', p, 3, ListFromConcat(p[2], p[4]))
       arg.AddChildren(self.BuildTrue('OPTIONAL'))
     else:
       arg = self.BuildNamed('Argument', p, 3, ListFromConcat(p[1], p[2]))
     p[0] = arg
 
-  # [45]
+  # [60]
   def p_ArgumentName(self, p):
     """ArgumentName : ArgumentNameKeyword
                     | identifier"""
     p[0] = p[1]
 
-  # [46]
+  # [61]
   def p_Ellipsis(self, p):
     """Ellipsis : ELLIPSIS
                 |"""
     if len(p) > 1:
       p[0] = self.BuildNamed('Argument', p, 1)
       p[0].AddChildren(self.BuildTrue('ELLIPSIS'))
 
-  # [47]
+  # [62]
   def p_ExceptionMember(self, p):
     """ExceptionMember : Const
                        | ExceptionField"""
     p[0] = p[1]
 
-  # [48]
+  # [63]
   def p_ExceptionField(self, p):
     """ExceptionField : Type identifier ';'"""
     p[0] = self.BuildNamed('ExceptionField', p, 2, p[1])
 
-  # [48.1] Error recovery for ExceptionMembers
+  # [63.1] Error recovery for ExceptionMembers
   def p_ExceptionFieldError(self, p):
     """ExceptionField : error"""
     p[0] = self.BuildError(p, 'ExceptionField')
 
-  # [49] No comment version for mid statement attributes.
+  # [64] No comment version for mid statement attributes.
   def p_ExtendedAttributeListNoComments(self, p):
     """ExtendedAttributeListNoComments : '[' ExtendedAttribute ExtendedAttributes ']'
                                        | """
     if len(p) > 2:
       items = ListFromConcat(p[2], p[3])
       p[0] = self.BuildProduction('ExtAttributes', p, 1, items)
 
-  # [49.1] Add optional comment field for start of statements.
+  # [64.1] Add optional comment field for start of statements.
   def p_ExtendedAttributeList(self, p):
     """ExtendedAttributeList : Comments '[' ExtendedAttribute ExtendedAttributes ']'
                              | Comments """
     if len(p) > 2:
       items = ListFromConcat(p[3], p[4])
       attribs = self.BuildProduction('ExtAttributes', p, 2, items)
       p[0] = ListFromConcat(p[1], attribs)
     else:
       p[0] = p[1]
 
-  # [50]
+  # [65]
   def p_ExtendedAttributes(self, p):
     """ExtendedAttributes : ',' ExtendedAttribute ExtendedAttributes
                           |"""
     if len(p) > 1:
       p[0] = ListFromConcat(p[2], p[3])
 
   # We only support:
   #    [ identifier ]
   #    [ identifier = identifier ]
   #    [ identifier ( ArgumentList )]
   #    [ identifier = identifier ( ArgumentList )]
-  # [51] map directly to 74-77
-  # [52-54, 56] are unsupported
+  # [66] map directly to [91-93, 95]
+  # [67-69, 71] are unsupported
   def p_ExtendedAttribute(self, p):
     """ExtendedAttribute : ExtendedAttributeNoArgs
                          | ExtendedAttributeArgList
                          | ExtendedAttributeIdent
                          | ExtendedAttributeNamedArgList"""
     p[0] = p[1]
 
-  # [55]
+  # [70]
   def p_ArgumentNameKeyword(self, p):
     """ArgumentNameKeyword : ATTRIBUTE
                            | CALLBACK
                            | CONST
                            | CREATOR
                            | DELETER
                            | DICTIONARY
                            | ENUM
                            | EXCEPTION
                            | GETTER
                            | IMPLEMENTS
                            | INHERIT
                            | LEGACYCALLER
                            | PARTIAL
+                           | SERIALIZER
                            | SETTER
                            | STATIC
                            | STRINGIFIER
                            | TYPEDEF
                            | UNRESTRICTED"""
     p[0] = p[1]
 
-  # [57]
+  # [72]
   def p_Type(self, p):
     """Type : SingleType
             | UnionType TypeSuffix"""
     if len(p) == 2:
       p[0] = self.BuildProduction('Type', p, 1, p[1])
     else:
       p[0] = self.BuildProduction('Type', p, 1, ListFromConcat(p[1], p[2]))
 
-  # [58]
+  # [73]
   def p_SingleType(self, p):
     """SingleType : NonAnyType
                   | ANY TypeSuffixStartingWithArray"""
     if len(p) == 2:
       p[0] = p[1]
     else:
       p[0] = ListFromConcat(self.BuildProduction('Any', p, 1), p[2])
 
-  # [59]
+  # [74]
   def p_UnionType(self, p):
     """UnionType : '(' UnionMemberType OR UnionMemberType UnionMemberTypes ')'"""
 
-  # [60]
+  # [75]
   def p_UnionMemberType(self, p):
     """UnionMemberType : NonAnyType
                        | UnionType TypeSuffix
                        | ANY '[' ']' TypeSuffix"""
-  # [61]
+  # [76]
   def p_UnionMemberTypes(self, p):
     """UnionMemberTypes : OR UnionMemberType UnionMemberTypes
                         |"""
 
-  # [62] Moved DATE, DOMSTRING, OBJECT to PrimitiveType
+  # [77] Moved BYTESTRING, DOMSTRING, OBJECT, DATE, REGEXP to PrimitiveType

[Jens Widell, 2014/06/12 13:34:36]

I don't know why any of these are moved, but I guessed that moving all the ones
I added too made sense. All I can think of is that it avoids duplicating
TypeSuffix once for each type.

[noelallen1, 2014/06/12 20:39:31]

Moved just to make parsing easier.  Otherwise it's harder to differentiate
'identifier' and one of these 'PrimitiveType'.

[Nils Barth (inactive), 2014/06/16 06:50:47]

Thanks for explaining!
Could this be aligned with spec, or is that difficult?

Jens:
Could you add a comment (and possibly FIXME) to explain this?

[Jens Widell, 2014/06/16 10:53:11]

Aligning with spec would not more difficult than doing

  if type(p[1]) is str:
    if p[1] in ('ByteString' et al):
      p[0] = self.BuildNamed('PrimitiveType', p, 1)
    else:
      p[0] = self.BuildNamed('Typeref', p, 1)

I think. (Not sure 'PrimitiveType' strictly makes sense, but that's the name
with the current code.)

[Nils Barth (inactive), 2014/06/17 05:08:18]

That sounds great!
(Agreed that "primitive type" is a pretty confusing name at this point.)

Noel, WDYT?

[Jens Widell, 2014/06/17 06:18:37]

"Not more difficult" was apparently a bit optimistic. Two more reasons to do
this cropped up:

- The Pepper IDL lexer undefines these keyword tokens, and its parser overrides
PrimitiveType, but it doesn't override NonAnyType. Thus, using these keywords in
NonAnyType makes the grammar definition invalid due to BYTESTRING et al being
undefined. (This can of course be worked around by overriding NonAnyType as
well.)

- ConstType references PrimitiveType directly, meaning moving these types into
the PrimitiveType production makes them available for constants. And we at least
have tests (here and in Blink) for DOMString constants.

[Nils Barth (inactive), 2014/06/17 06:28:25]

Got it; that's a lot of work for minor spec compliance fix,
so fine to omit for now.
(FIXME isn't necessary, as there's a comment explaining the difference.)

   def p_NonAnyType(self, p):
     """NonAnyType : PrimitiveType TypeSuffix
                   | identifier TypeSuffix
                   | SEQUENCE '<' Type '>' Null"""
     if len(p) == 3:
       if type(p[1]) == str:
         typeref = self.BuildNamed('Typeref', p, 1)
       else:
         typeref = p[1]
       p[0] = ListFromConcat(typeref, p[2])
 
     if len(p) == 6:
       p[0] = self.BuildProduction('Sequence', p, 1, ListFromConcat(p[3], p[5]))
 
 
-  # [63]
+  # [78]
   def p_ConstType(self,  p):
     """ConstType : PrimitiveType Null
                  | identifier Null"""
     if type(p[1]) == str:
       p[0] = self.BuildNamed('Typeref', p, 1, p[2])
     else:
       p[1].AddChildren(p[2])
       p[0] = p[1]
 
 
-  # [64]
+  # [79]
   def p_PrimitiveType(self, p):
     """PrimitiveType : UnsignedIntegerType
                      | UnrestrictedFloatType
                      | BOOLEAN
                      | BYTE
                      | OCTET
+                     | BYTESTRING
                      | DOMSTRING
+                     | OBJECT
                      | DATE
-                     | OBJECT"""
+                     | REGEXP"""
     if type(p[1]) == str:
       p[0] = self.BuildNamed('PrimitiveType', p, 1)
     else:
       p[0] = p[1]
 
 
-  # [65]
+  # [80]
   def p_UnrestrictedFloatType(self, p):
     """UnrestrictedFloatType : UNRESTRICTED FloatType
                              | FloatType"""
     if len(p) == 2:
       typeref = self.BuildNamed('PrimitiveType', p, 1)
     else:
       typeref = self.BuildNamed('PrimitiveType', p, 2)
       typeref.AddChildren(self.BuildTrue('UNRESTRICTED'))
     p[0] = typeref
 
 
-  # [66]
+  # [81]
   def p_FloatType(self, p):
     """FloatType : FLOAT
                  | DOUBLE"""
     p[0] = p[1]
 
-  # [67]
+  # [82]
   def p_UnsignedIntegerType(self, p):
     """UnsignedIntegerType : UNSIGNED IntegerType
                            | IntegerType"""
     if len(p) == 2:
       p[0] = p[1]
     else:
       p[0] = 'unsigned ' + p[2]
 
-  # [68]
+  # [83]
   def p_IntegerType(self, p):
     """IntegerType : SHORT
                    | LONG OptionalLong"""
     if len(p) == 2:
       p[0] = p[1]
     else:
       p[0] = p[1] + p[2]
 
-  # [69]
+  # [84]
   def p_OptionalLong(self, p):
     """OptionalLong : LONG
                     | """
     if len(p) > 1:
       p[0] = ' ' + p[1]
     else:
       p[0] = ''
 
 
-  # [70] Add support for sized array
+  # [85] Add support for sized array
   def p_TypeSuffix(self, p):
     """TypeSuffix : '[' integer ']' TypeSuffix
                   | '[' ']' TypeSuffix
                   | '?' TypeSuffixStartingWithArray
                   | """
     if len(p) == 5:
       p[0] = self.BuildNamed('Array', p, 2, p[4])
 
     if len(p) == 4:
       p[0] = self.BuildProduction('Array', p, 1, p[3])
 
     if len(p) == 3:
       p[0] = ListFromConcat(self.BuildTrue('NULLABLE'), p[2])
 
 
-  # [71]
+  # [86]
   def p_TypeSuffixStartingWithArray(self, p):
     """TypeSuffixStartingWithArray : '[' ']' TypeSuffix
                                    | """
     if len(p) > 1:
       p[0] = self.BuildProduction('Array', p, 0, p[3])
 
-  # [72]
+  # [87]
   def p_Null(self, p):
     """Null : '?'
             |"""
     if len(p) > 1:
       p[0] = self.BuildTrue('NULLABLE')
 
-  # [73]
+  # [88]
   def p_ReturnType(self, p):
     """ReturnType : Type
                   | VOID"""
     if p[1] == 'void':
       p[0] = self.BuildProduction('Type', p, 1)
       p[0].AddChildren(self.BuildNamed('PrimitiveType', p, 1))
     else:
       p[0] = p[1]
 
-  # [74]
+  # [89]
+  #def p_IdentifierList(self, p):
+  #  """IdentifierList : identifier Identifiers"""
+  #  p[0] = ListFromConcat(p[1], p[2])
+
+  # [90]
+  #def p_Identifiers(self, p):

[Jens Widell, 2014/06/12 13:34:36]

Note that this is identical to [37]. Reported
https://www.w3.org/Bugs/Public/show_bug.cgi?id=26075 about that.

+  #  """Identifiers : ',' identifier Identifiers
+  #                 |"""
+  #  if len(p) > 1:
+  #    p[0] = ListFromConcat(p[2], p[3])
+
+  # [91]
   def p_ExtendedAttributeNoArgs(self, p):
     """ExtendedAttributeNoArgs : identifier"""
     p[0] = self.BuildNamed('ExtAttribute', p, 1)
 
-  # [75]
+  # [92]
   def p_ExtendedAttributeArgList(self, p):
     """ExtendedAttributeArgList : identifier '(' ArgumentList ')'"""
     arguments = self.BuildProduction('Arguments', p, 2, p[3])
     p[0] = self.BuildNamed('ExtAttribute', p, 1, arguments)
 
-  # [76]
+  # [93]
   def p_ExtendedAttributeIdent(self, p):
     """ExtendedAttributeIdent : identifier '=' identifier"""
     value = self.BuildAttribute('VALUE', p[3])
     p[0] = self.BuildNamed('ExtAttribute', p, 1, value)
 
-  # [77]
+  # [95]
   def p_ExtendedAttributeNamedArgList(self, p):
     """ExtendedAttributeNamedArgList : identifier '=' identifier '(' ArgumentList ')'"""
     args = self.BuildProduction('Arguments', p, 4, p[5])
     value = self.BuildNamed('Call', p, 3, args)
     p[0] = self.BuildNamed('ExtAttribute', p, 1, value)
 
 #
 # Parser Errors
 #
 # p_error is called whenever the parser can not find a pattern match for
@@ skipping 205 matching lines @@
 
   print '\n'.join(ast.Tree(accept_props=['PROD']))
   if errors:
     print '\nFound %d errors.\n' % errors
 
   return errors
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))