idl_parser: Add support for the record<K, V> WebIDL type.

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 874 matching lines @@
 
   # [78] Moved BYTESTRING, DOMSTRING, OBJECT, DATE, REGEXP to PrimitiveType
   # Moving all built-in types into PrimitiveType makes it easier to
   # differentiate between them and 'identifier', since p[1] would be a string in
   # both cases.
   def p_NonAnyType(self, p):
     """NonAnyType : PrimitiveType TypeSuffix
                   | PromiseType Null
                   | identifier TypeSuffix
                   | SEQUENCE '<' Type '>' Null
-                  | FROZENARRAY '<' Type '>' Null"""
+                  | FROZENARRAY '<' Type '>' Null
+                  | RecordType 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:
       cls = 'Sequence' if p[1] == 'sequence' else 'FrozenArray'
       p[0] = self.BuildProduction(cls, p, 1, ListFromConcat(p[3], p[5]))
 
   # [79] NOT IMPLEMENTED (BufferRelatedType)
 
   # [80]
   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]
 
 
-  # [81] Added BYTESTRING, DOMSTRING, OBJECT, DATE, REGEXP
+  # [81] Added StringType, OBJECT, DATE, REGEXP
   def p_PrimitiveType(self, p):
     """PrimitiveType : UnsignedIntegerType
                      | UnrestrictedFloatType
+                     | StringType
                      | BOOLEAN
                      | BYTE
                      | OCTET
-                     | BYTESTRING
-                     | DOMSTRING
                      | OBJECT
                      | DATE
                      | REGEXP"""
     if type(p[1]) == str:
       p[0] = self.BuildNamed('PrimitiveType', p, 1)
     else:
       p[0] = p[1]
 
 
   # [82]
@@ skipping 130 matching lines @@
     value = self.BuildAttribute('VALUE', p[4])
     p[0] = self.BuildNamed('ExtAttribute', p, 1, value)
 
   # [98]
   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)
 
+  # [99]
+  def p_StringType(self, p):
+    """StringType : BYTESTRING
+                  | DOMSTRING
+                  | USVSTRING"""
+    p[0] = self.BuildNamed('StringType', p, 1)
+
+  # [100]
+  def p_RecordType(self, p):
+    """RecordType : RECORD '<' StringType ',' Type '>'"""
+    p[0] = self.BuildProduction('Record', p, 2, ListFromConcat(p[3], p[5]))
+
+  # [100.1] Error recovery for RecordType.
+  def p_RecordTypeError(self, p):
+    """RecordType : RECORD '<' error ',' Type '>'"""
+    p[0] = self.BuildError(p, 'RecordType')
+
 #
 # Parser Errors
 #
 # p_error is called whenever the parser can not find a pattern match for
 # a set of items from the current state.  The p_error function defined here
 # is triggered logging an error, and parsing recovery happens as the
 # p_<type>_error functions defined above are called.  This allows the parser
 # to continue so as to capture more than one error per file.
 #
   def p_error(self, t):
@@ skipping 42 matching lines @@
     self._last_error_lineno = 0
     self._last_error_pos = 0
 
 
 #
 # BuildProduction
 #
 # Production is the set of items sent to a grammar rule resulting in a new
 # item being returned.
 #
+# cls - The type of item being producted
 # p - Is the Yacc production object containing the stack of items
 # index - Index into the production of the name for the item being produced.
-# cls - The type of item being producted
 # childlist - The children of the new item
   def BuildProduction(self, cls, p, index, childlist=None):
     try:
       if not childlist:
         childlist = []
 
       filename = self.lexer.Lexer().filename
       lineno = p.lineno(index)
       pos = p.lexpos(index)
       out = IDLNode(cls, filename, lineno, pos, childlist)
@@ skipping 134 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:]))