Add support for Chrome Apps to IDL lexer/parser

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 205 matching lines @@
     """top : COMMENT COMMENT ext_attr_block top_list"""
 
     Copyright = self.BuildComment('Copyright', p, 1)
     Filedoc = self.BuildComment('Comment', p, 2)
 
     p[0] = ListFromConcat(Copyright, Filedoc, p[3], p[4])
     if self.parse_debug: DumpReduction('top', p)
 
   # Build a list of top level items.
   def p_top_list(self, p):
-    """top_list : describe_block top_list
+    """top_list : callback_decl top_list
+                | describe_block top_list
+                | dictionary_block top_list
                 | enum_block top_list
                 | inline top_list
                 | interface_block top_list
                 | label_block top_list
+                | namespace top_list
                 | struct_block top_list
                 | typedef_decl top_list
                 | """
     if len(p) > 2:
       p[0] = ListFromConcat(p[1], p[2])
     if self.parse_debug: DumpReduction('top_list', p)
 
   # Recover from error and continue parsing at the next top match.
   def p_top_error(self, p):
     """top_list : error top_list"""
@@ skipping 19 matching lines @@
                 | """
     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:])
+
+
+#
+# Dictionary
+#
+# A dictionary contains 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[5]))
+
+#
+# Callback
+#
+# A callback is essentially a single function declaration (outside of an
+# Interface).
+#
+  def p_callback_decl(self, p):
+    """callback_decl : modifiers CALLBACK SYMBOL '=' SYMBOL param_list ';'"""
+    children = ListFromConcat(p[1], p[6])
+    p[0] = self.BuildNamed('Callback', p, 3, children)
+
+
+#
 # Inline
 #
 # Inline blocks define option code to be emitted based on language tag,
 # in the form of:
 # #inline <LANGUAGE>
 # <CODE>
 # #endinl
 #
   def p_inline(self, p):
     """inline : modifiers INLINE"""
@@ skipping 195 matching lines @@
       p[0] = ListFromConcat(array, p[3])
     # If there are 4 tokens plus a return slot it is a fixed array
     elif len(p) == 5:
       count = self.BuildAttribute('FIXED', p[2])
       array = self.BuildProduction('Array', p, 2, [count])
       p[0] = ListFromConcat(array, p[4])
     # If there is only a return slot, do not fill it for this terminator.
     elif len(p) == 1: return
     if self.parse_debug: DumpReduction('arrays', p)
 
+
+# An identifier is a legal value for a parameter or attribute name. Lots of
+# existing IDL files use "callback" as a parameter/attribute name, so we allow
+# a SYMBOL or the CALLBACK keyword.
+  def p_identifier(self, p):
+    """identifier : SYMBOL
+                  | CALLBACK"""
+    p[0] = p[1]
+    # Save the line number of the underlying token (otherwise it gets
+    # discarded), since we use it in the productions with an identifier in
+    # them.
+    p.set_lineno(0, p.lineno(1))
+
 #
 # Parameter List
 #
 # A parameter list is a collection of arguments which are passed to a
 # function.
 #
   def p_param_list(self, p):
     """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 SYMBOL arrays SYMBOL"""
-    typeref = self.BuildAttribute('TYPEREF', p[2])
-    children = ListFromConcat(p[1],typeref, p[3])
-    p[0] = self.BuildNamed('Param', p, 4, children)
+    """param_item : modifiers optional SYMBOL 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_optional(self, p):
+    """optional : OPTIONAL
+                | """
+    if len(p) == 2:
+      p[0] = self.BuildAttribute('OPTIONAL', True)
+
+
   def p_param_cont(self, p):
     """param_cont : ',' param_item param_cont
                   | """
     if len(p) > 1:
       p[0] = ListFromConcat(p[2], p[3])
       if self.parse_debug: DumpReduction('param_cont', p)
 
   def p_param_error(self, p):
     """param_cont : error param_cont"""
     p[0] = p[2]
 
 
 #
 # Typedef
 #
-# A typedef creates a new referencable type.  The tyepdef can specify an array
+# A typedef creates a new referencable type.  The typedef can specify an array
 # definition as well as a function declaration.
 #
   def p_typedef_data(self, p):
     """typedef_decl : modifiers TYPEDEF SYMBOL SYMBOL ';' """
     typeref = self.BuildAttribute('TYPEREF', p[3])
     children = ListFromConcat(p[1], typeref)
     p[0] = self.BuildNamed('Typedef', p, 4, children)
     if self.parse_debug: DumpReduction('typedef_data', p)
 
   def p_typedef_array(self, p):
@@ skipping 74 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 SYMBOL """
+    """member_attribute : modifiers SYMBOL arrays questionmark identifier"""
     typeref = self.BuildAttribute('TYPEREF', p[2])
-    children = ListFromConcat(p[1], typeref)
-    p[0] = self.BuildNamed('Member', p, 3, children)
-    if self.parse_debug: DumpReduction('attribute', p)
-
-  def p_member_attribute_array(self, p):
-    """member_attribute : modifiers SYMBOL arrays SYMBOL """
-    typeref = self.BuildAttribute('TYPEREF', p[2])
-    children = ListFromConcat(p[1], typeref, p[3])
-    p[0] = self.BuildNamed('Member', p, 4, children)
+    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_function(self, p):
-    """member_function : modifiers SYMBOL SYMBOL param_list"""
-    typeref = self.BuildAttribute('TYPEREF', p[2])
-    children = ListFromConcat(p[1], typeref, p[4])
-    p[0] = self.BuildNamed('Member', p, 3, children)
+    """member_function : modifiers static SYMBOL SYMBOL param_list"""
+    typeref = self.BuildAttribute('TYPEREF', p[3])
+    children = ListFromConcat(p[1], p[2], typeref, p[5])
+    p[0] = self.BuildNamed('Member', p, 4, 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)
+
+  def p_questionmark(self, p):
+    """questionmark : '?'
+                    | """
+    if len(p) == 2:
+      p[0] = self.BuildAttribute('OPTIONAL', True)
+
 #
 # Interface
 #
 # An interface is a named collection of functions.
 #
   def p_interface_block(self, p):
     """interface_block : modifiers INTERFACE SYMBOL '{' interface_list '}' ';'"""
     p[0] = self.BuildNamed('Interface', p, 3, ListFromConcat(p[1], p[5]))
     if self.parse_debug: DumpReduction('interface_block', p)
 
@@ skipping 115 matching lines @@
 
   def BuildNamed(self, cls, p, index, childlist=None):
     if not childlist: childlist = []
     childlist.append(self.BuildAttribute('NAME', p[index]))
     return self.BuildProduction(cls, p, index, childlist)
 
   def BuildComment(self, cls, p, index):
     name = p[index]
 
     # Remove comment markers
+    lines = []
     if name[:2] == '//':
-      # For C++ style, remove the preceding '//'
+      # For C++ style, remove any leading whitespace and the '//' marker from
+      # each line.
       form = 'cc'
-      name = name[2:].rstrip()
+      for line in name.split('\n'):
+        start = line.find('//')
+        lines.append(line[start+2:])
     else:
       # For C style, remove ending '*/''
       form = 'c'
-      lines = []
       for line in name[:-2].split('\n'):
         # Remove characters until start marker for this line '*' if found
         # otherwise it should be blank.
         offs = line.find('*')
         if offs >= 0:
           line = line[offs + 1:].rstrip()
         else:
           line = ''
         lines.append(line)
-      name = '\n'.join(lines)
+    name = '\n'.join(lines)
 
     childlist = [self.BuildAttribute('NAME', name),
                  self.BuildAttribute('FORM', form)]
     return self.BuildProduction(cls, p, index, childlist)
 
 #
 # BuildAttribute
 #
 # An ExtendedAttribute is a special production that results in a property
 # which is applied to the adjacent item.  Attributes have no children and
@@ skipping 247 matching lines @@
   ast = ParseFiles(filenames)
   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:]))