IDL: various adjustments to match Web IDL specification better

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 241 matching lines @@
     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]
+  # [10] Removed unsupported: Serializer
   def p_InterfaceMember(self, p):
     """InterfaceMember : Const
-                       | AttributeOrOperationOrIterator"""
-    p[0] = p[1]
-
-  # [10.1] Removed unsupported: Serializer
-  def p_AttributeOrOperationOrIterator(self, p):
-    """AttributeOrOperationOrIterator : Stringifier
-                                      | StaticMember
-                                      | ReadWriteAttribute
-                                      | OperationOrIterator"""
+                       | Operation
+                       | Stringifier
+                       | StaticMember
+                       | Iterable
+                       | ReadonlyMember
+                       | ReadWriteAttribute
+                       | ReadWriteMaplike
+                       | ReadWriteSetlike"""
     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 189 matching lines @@
       p[0] = p[1]
 
   # [37]
   def p_StaticMember(self, p):
     """StaticMember : STATIC StaticMemberRest"""
     p[2].AddChildren(self.BuildTrue('STATIC'))
     p[0] = p[2]
 
   # [38]
   def p_StaticMemberRest(self, p):
-    """StaticMemberRest : AttributeRest
+    """StaticMemberRest : ReadOnly AttributeRest
                         | ReturnType OperationRest"""
     if len(p) == 2:
       p[0] = p[1]
     else:
       p[2].AddChildren(p[1])
       p[0] = p[2]
 
-  # [39] NOT IMPLEMENTED (ReadOnlyMember)
-  # [40] NOT IMPLEMENTED (ReadOnlyMemberReset)
+  # [39]
+  def p_ReadonlyMember(self, p):
+    """ReadonlyMember : READONLY ReadonlyMemberRest"""
+    p[2].AddChildren(self.BuildTrue('READONLY'))
+    p[0] = p[2]
+
+  # [40]
+  def p_ReadonlyMemberRest(self, p):
+    """ReadonlyMemberRest : AttributeRest
+                          | MaplikeRest
+                          | SetlikeRest"""
+    p[0] = p[1]
 
   # [41]
   def p_ReadWriteAttribute(self, p):
-    """ReadWriteAttribute : Inherit AttributeRest"""
-    p[2].AddChildren(ListFromConcat(p[1]))
-    p[0] = p[2]
-
-  # [41] Deprecated - Remove this entry after blink stops using it.
-  def p_Attribute(self, p):
-    """Attribute : ReadWriteAttribute"""
-    p[0] = p[1]
+    """ReadWriteAttribute : INHERIT ReadOnly AttributeRest
+                          | AttributeRest"""
+    if len(p) > 2:
+      inherit = self.BuildTrue('INHERIT')
+      p[3].AddChildren(ListFromConcat(inherit, p[2]))
+      p[0] = p[3]
+    else:
+      p[0] = p[1]
 
   # [42]
   def p_AttributeRest(self, p):
-    """AttributeRest : ReadOnly ATTRIBUTE Type identifier ';'"""
-    p[0] = self.BuildNamed('Attribute', p, 4,
-                           ListFromConcat(p[1], p[3]))
+    """AttributeRest : ATTRIBUTE Type AttributeName ';'"""
+    p[0] = self.BuildNamed('Attribute', p, 3, p[2])
 
-  # [43] NOT IMPLEMENTED (AttributeName)
-  # [44] NOT IMPLEMENTED (AttributeNameKeyword)
+  # [43]
+  def p_AttributeName(self, p):
+    """AttributeName : AttributeNameKeyword
+                     | identifier"""
+    p[0] = p[1]
 
-  # [45]
-  def p_Inherit(self, p):
-    """Inherit : INHERIT
-               |"""
-    if len(p) > 1:
-      p[0] = self.BuildTrue('INHERIT')
+  # [44]
+  def p_AttributeNameKeyword(self, p):
+    """AttributeNameKeyword : REQUIRED"""
+    p[0] = p[1]

[haraken, 2014/12/15 15:11:13]

p[0] = self.BuildTrue('REQUIRED') ?

[Jens Widell, 2014/12/15 15:30:32]

No, this is simply a grammar workaround to allow attributes named "required"
despite that (now) being a keyword, so the output should be a string.

+
+  # [45] Unreferenced in the specification

[Jens Widell, 2014/12/15 11:35:15]

This is:

[45] Inherit → "inherit"
               | ε

The productions that include the inherit keyword however all use "inherit"
directly instead of referencing this.

 
   # [46]
   def p_ReadOnly(self, p):
     """ReadOnly : READONLY
                 |"""
     if len(p) > 1:
       p[0] = self.BuildTrue('READONLY')
 
   # [47]
-  def p_OperationOrIterator(self, p):
-    """OperationOrIterator : ReturnType OperationOrIteratorRest
-                           | SpecialOperation"""
+  def p_Operation(self, p):
+    """Operation : ReturnType OperationRest
+                 | SpecialOperation"""
     if len(p) == 3:
       p[2].AddChildren(p[1])
       p[0] = p[2]
     else:
       p[0] = p[1]
 
   # [48]
   def p_SpecialOperation(self, p):
     """SpecialOperation : Special Specials ReturnType OperationRest"""
     p[4].AddChildren(ListFromConcat(p[1], p[2], p[3]))
     p[0] = p[4]
 
   # [49]
   def p_Specials(self, p):
     """Specials : Special Specials
                 | """
     if len(p) > 1:
       p[0] = ListFromConcat(p[1], p[2])
 
   # [50]
   def p_Special(self, p):
     """Special : GETTER
                | SETTER
                | CREATOR
                | DELETER
                | LEGACYCALLER"""
     p[0] = self.BuildTrue(p[1].upper())
 
   # [51]
-  def p_OperationOrIteratorRest(self, p):
-    """OperationOrIteratorRest : OperationRest"""
-    p[0] = p[1]
-
-  # [51]
   def p_OperationRest(self, p):
     """OperationRest : OptionalIdentifier '(' ArgumentList ')' ';'"""
     arguments = self.BuildProduction('Arguments', p, 2, p[3])
     p[0] = self.BuildNamed('Operation', p, 1, arguments)
 
   # [52]
   def p_OptionalIdentifier(self, p):
     """OptionalIdentifier : identifier
                           |"""
     if len(p) > 1:
@@ skipping 65 matching lines @@
   # [] Unspecified
   def p_ExceptionField(self, p):
     """ExceptionField : Type identifier ';'"""
     p[0] = self.BuildNamed('ExceptionField', p, 2, p[1])
 
   # [] Error recovery for ExceptionMembers - Unspecified
   def p_ExceptionFieldError(self, p):
     """ExceptionField : error"""
     p[0] = self.BuildError(p, 'ExceptionField')
 
-  # [59] NOT IMPLEMENTED (Iterable)
-  # [60] NOT IMPLEMENTED (OptionalType)
-  # [61] NOT IMPLEMENTED (ReadWriteMaplike)
-  # [62] NOT IMPLEMENTED (ReadWriteSetlike)
-  # [63] NOT IMPLEMENTED (MaplikeRest)
-  # [64] NOT IMPLEMENTED (SetlikeRest)
+  # [59]
+  def p_Iterable(self, p):
+    """Iterable : ITERABLE '<' Type OptionalType '>' ';'
+                | LEGACYITERABLE '<' Type '>' ';'"""
+    if len(p) > 6:
+      childlist = ListFromConcat(p[3], p[4])
+      p[0] = self.BuildProduction('Iterable', p, 2, childlist)
+    else:
+      p[0] = self.BuildProduction('LegacyIterable', p, 2, p[3])
+
+  # [60]
+  def p_OptionalType(self, p):
+    """OptionalType : ',' Type
+                    |"""
+    if len(p) > 1:

[haraken, 2014/12/15 15:11:13]

if len(p) > 2:

[Jens Widell, 2014/12/15 15:30:32]

The pattern in cases like this is "len(p) > 1". See for instance [50] Specials()
or [52] OptionalIdentifier() above.

+      p[0] = p[2]
+
+  # [61]
+  def p_ReadWriteMaplike(self, p):
+    """ReadWriteMaplike : MaplikeRest"""
+    p[0] = p[1]
+
+  # [62]
+  def p_ReadWriteSetlike(self, p):
+    """ReadWriteSetlike : SetlikeRest"""
+    p[0] = p[1]
+
+  # [63]
+  def p_MaplikeRest(self, p):
+    """MaplikeRest : MAPLIKE '<' Type ',' Type '>' ';'"""
+    childlist = ListFromConcat(p[3], p[5])
+    p[0] = self.BuildProduction('Maplike', p, 2, childlist)
+
+  # [64]
+  def p_SetlikeRest(self, p):
+    """SetlikeRest : SETLIKE '<' Type '>' ';'"""
+    p[0] = self.BuildProduction('Setlike', p, 2, p[3])
 
   # [65] 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)
 
   # [65.1] Add optional comment field for start of statements.
@@ skipping 490 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:]))