Support scoped types in PPAPI IDL.

ppapi/generators/idl_parser.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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 250 matching lines @@
 #
 # Modifier List
 #
 #
   def p_modifiers(self, p):
     """modifiers : comments ext_attr_block"""
     p[0] = ListFromConcat(p[1], p[2])
     if self.parse_debug: DumpReduction('modifiers', p)
 
 #
+# Scoped name is a name with an optional scope.
+#
+# Used for types and namespace names. eg. foo_bar.hello_world, or
+# foo_bar.hello_world.SomeType.
+#
+  def p_scoped_name(self, p):
+    """scoped_name : SYMBOL

[Nils Barth (inactive), 2014/03/28 05:01:19]

This should instead be:
scoped_name : SYMBOL scoped_name_rest

scoped_name_rest : '.' scoped_name
                 |

...which makes this LL(1).
(Right branching, 1 token of look-ahead.)

[mtomasz, 2014/03/28 05:19:38]

Done.

[Nils Barth (inactive), 2014/03/28 05:25:13]

Thanks!
LGTM again!

+                   | scoped_name '.' SYMBOL"""
+    p[0] = ''.join(p[1:])
+    if self.parse_debug: DumpReduction('scoped_name', p)
+
+#
+# Type reference
+#
+#
+  def p_typeref(self, p):
+    """typeref : scoped_name"""
+    p[0] = p[1]
+    if self.parse_debug: DumpReduction('typeref', p)
+
+
+#
 # Comments
 #
 # Comments are optional list of C style comment objects.  Comments are returned
 # as a list or None.
 #
   def p_comments(self, p):
     """comments : COMMENT comments
                 | """
     if len(p) > 1:
       child = self.BuildComment('Comment', p, 1)
       p[0] = ListFromConcat(child, p[2])
       if self.parse_debug: DumpReduction('comments', p)
     else:
       if self.parse_debug: DumpReduction('no comments', p)
 
 
 #
 # Namespace
 #
 # A namespace provides a named scope to an enclosed top_list.
 #
   def p_namespace(self, p):
     """namespace : modifiers NAMESPACE namespace_name '{' top_list '}' ';'"""
     children = ListFromConcat(p[1], p[5])
     p[0] = self.BuildNamed('Namespace', p, 3, children)
 
   # We allow namespace names of the form foo.bar.baz.
   def p_namespace_name(self, p):
-    """namespace_name : SYMBOL
-                      | SYMBOL '.' namespace_name"""
-    p[0] = "".join(p[1:])
+    """namespace_name : scoped_name"""
+    p[0] = p[1]
 
 
 #
 # Dictionary
 #
 # A dictionary is a named list of optional and required members.
 #
   def p_dictionary_block(self, p):
     """dictionary_block : modifiers DICTIONARY SYMBOL '{' struct_list '}' ';'"""
     p[0] = self.BuildNamed('Dictionary', p, 3, ListFromConcat(p[1], p[5]))
@@ skipping 302 matching lines @@
     """param_list : '(' param_item param_cont ')'
                   | '(' ')' """
     if len(p) > 3:
       args = ListFromConcat(p[2], p[3])
     else:
       args = []
     p[0] = self.BuildProduction('Callspec', p, 1, args)
     if self.parse_debug: DumpReduction('param_list', p)
 
   def p_param_item(self, p):
-    """param_item : modifiers optional SYMBOL arrays identifier"""
+    """param_item : modifiers optional typeref arrays identifier"""
     typeref = self.BuildAttribute('TYPEREF', p[3])
     children = ListFromConcat(p[1], p[2], typeref, p[4])
     p[0] = self.BuildNamed('Param', p, 5, children)
     if self.parse_debug: DumpReduction('param_item', p)
 
   def p_param_item_union(self, p):
     """param_item : modifiers optional '(' union_list ')' identifier"""
     union = self.BuildAttribute('Union', True)
     children = ListFromConcat(p[1], p[2], p[4], union)
     p[0] = self.BuildNamed('Param', p, 6, children)
@@ skipping 118 matching lines @@
     p[0] = p[2]
     if self.parse_debug: DumpReduction('label_error', p)
 
 
 #
 # Members
 #
 # A member attribute or function of a struct or interface.
 #
   def p_member_attribute(self, p):
-    """member_attribute : modifiers SYMBOL arrays questionmark identifier"""
+    """member_attribute : modifiers typeref arrays questionmark identifier"""
     typeref = self.BuildAttribute('TYPEREF', p[2])
     children = ListFromConcat(p[1], typeref, p[3], p[4])
     p[0] = self.BuildNamed('Member', p, 5, children)
     if self.parse_debug: DumpReduction('attribute', p)
 
   def p_member_attribute_union(self, p):
     """member_attribute : modifiers '(' union_list ')' questionmark identifier"""
     union = self.BuildAttribute('Union', True)
     children = ListFromConcat(p[1], p[3], p[5], union)
     p[0] = self.BuildNamed('Member', p, 6, children)
     if self.parse_debug: DumpReduction('attribute', p)
 
   def p_member_function(self, p):
-    """member_function : modifiers static SYMBOL arrays SYMBOL param_list"""
+    """member_function : modifiers static typeref arrays SYMBOL param_list"""
     typeref = self.BuildAttribute('TYPEREF', p[3])
     children = ListFromConcat(p[1], p[2], typeref, p[4], p[6])
     p[0] = self.BuildNamed('Member', p, 5, children)
     if self.parse_debug: DumpReduction('function', p)
 
   def p_static(self, p):
     """static : STATIC
               | """
     if len(p) == 2:
       p[0] = self.BuildAttribute('STATIC', True)
@@ skipping 474 matching lines @@
   errs = ast.GetProperty('ERRORS')
   if errs:
     ErrOut.Log('Found %d error(s).' % errs);
   InfoOut.Log("%d files processed." % len(filenames))
   return errs
 
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv[1:]))