Change the way we generate versions

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 17 matching lines @@
 import re
 import sys
 import time
 
 from idl_ast import IDLAst
 from idl_log import ErrOut, InfoOut, WarnOut
 from idl_lexer import IDLLexer
 from idl_node import IDLAttribute, IDLFile, IDLNode
 from idl_option import GetOption, Option, ParseOptions
 from idl_lint import Lint
+from idl_visitor import IDLVisitor
 
 from ply import lex
 from ply import yacc
 
 Option('build_debug', 'Debug tree building.')
 Option('parse_debug', 'Debug parse reduction steps.')
 Option('token_debug', 'Debug token generation.')
 Option('dump_tree', 'Dump the tree.')
 Option('srcroot', 'Working directory.', default=os.path.join('..', 'api'))
 Option('include_private', 'Include private IDL directory in default API paths.')
@@ skipping 187 matching lines @@
     """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
+                | bad_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"""
     p[0] = p[2]
 
+  # Recover from error and continue parsing at the next top match.
+  def p_bad_decl(self, p):
+    """bad_decl : modifiers SYMBOL error '}' ';'"""
+    p[0] = []
+
 #
 # 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)
 
 #
@@ skipping 171 matching lines @@
 # A describe block is defined at the top level.  It provides a mechanism for
 # attributing a group of ext_attr to a describe_list.  Members of the
 # describe list are language specific 'Type' declarations
 #
   def p_describe_block(self, p):
     """describe_block : modifiers DESCRIBE '{' describe_list '}' ';'"""
     children = ListFromConcat(p[1], p[4])
     p[0] = self.BuildProduction('Describe', p, 2, children)
     if self.parse_debug: DumpReduction('describe_block', p)
 
+  # Recover from describe error and continue parsing at the next top match.
+  def p_describe_error(self, p):
+    """describe_list : error describe_list"""
+    p[0] = []
+
   def p_describe_list(self, p):
     """describe_list : modifiers SYMBOL ';' describe_list
                      | modifiers ENUM ';' describe_list
                      | modifiers STRUCT ';' describe_list
                      | modifiers TYPEDEF ';' describe_list
                      | """
     if len(p) > 1:
       Type = self.BuildNamed('Type', p, 2, p[1])
       p[0] = ListFromConcat(Type, p[4])
 
-  def p_describe_error(self, p):
-    """describe_list : error describe_list"""
-    p[0] = p[2]
-
 #
 # Constant Values (integer, value)
 #
 # Constant values can be found at various levels.  A Constant value is returns
 # as the string value after validated against a FLOAT, HEX, INT, OCT or
 # STRING pattern as appropriate.
 #
   def p_value(self, p):
     """value : FLOAT
              | HEX
@@ skipping 171 matching lines @@
 # Enumeration
 #
 # An enumeration is a set of named integer constants.  An enumeration
 # is valid type which can be referenced in other definitions.
 #
   def p_enum_block(self, p):
     """enum_block : modifiers ENUM SYMBOL '{' enum_list '}' ';'"""
     p[0] = self.BuildNamed('Enum', p, 3, ListFromConcat(p[1], p[5]))
     if self.parse_debug: DumpReduction('enum_block', p)
 
+  # Recover from enum error and continue parsing at the next top match.
+  def p_enum_errorA(self, p):
+    """enum_block : modifiers ENUM error '{' enum_list '}' ';'"""
+    p[0] = []
+
+  def p_enum_errorB(self, p):
+    """enum_block : modifiers ENUM error ';'"""
+    p[0] = []
+
   def p_enum_list(self, p):
     """enum_list : modifiers SYMBOL '=' expression enum_cont
                  | modifiers SYMBOL enum_cont"""
     if len(p) > 4:
       val  = self.BuildAttribute('VALUE', p[4])
       enum = self.BuildNamed('EnumItem', p, 2, ListFromConcat(val, p[1]))
       p[0] = ListFromConcat(enum, p[5])
     else:
       enum = self.BuildNamed('EnumItem', p, 2, p[1])
       p[0] = ListFromConcat(enum, p[3])
@@ skipping 75 matching lines @@
 #
 # 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)
 
+  def p_interface_error(self, p):
+    """interface_block : modifiers INTERFACE error '{' interface_list '}' ';'"""
+    p[0] = []
+
   def p_interface_list(self, p):
     """interface_list : member_function ';' interface_list
                       | """
     if len(p) > 1 :
       p[0] = ListFromConcat(p[1], p[3])
       if self.parse_debug: DumpReduction('interface_list', p)
 
-  def p_interface_error(self, p):
-    """interface_list : error interface_list"""
-    p[0] = p[2]
 
 #
 # Struct
 #
 # A struct is a named collection of members which in turn reference other
 # types.  The struct is a referencable type.
 #
   def p_struct_block(self, p):
     """struct_block : modifiers STRUCT SYMBOL '{' struct_list '}' ';'"""
     children = ListFromConcat(p[1], p[5])
     p[0] = self.BuildNamed('Struct', p, 3, children)
     if self.parse_debug: DumpReduction('struct_block', p)
 
+  # Recover from struct error and continue parsing at the next top match.
+  def p_struct_error(self, p):
+    """enum_block : modifiers STRUCT error '{' struct_list '}' ';'"""
+    p[0] = []
+
   def p_struct_list(self, p):
     """struct_list : member_attribute ';' struct_list
                    | member_function ';' struct_list
                    |"""
     if len(p) > 1: p[0] = ListFromConcat(p[1], p[3])
 
-  def p_struct_error(self, p):
-    """struct_list : error struct_list"""
-    p[0] = p[2]
 
 #
 # 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 recover 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.
 #
@@ skipping 308 matching lines @@
   ast = ParseFiles(testnames)
   InfoOut.SetConsole(True)
 
   errs = ast.GetProperty('ERRORS')
   if errs:
     ErrOut.Log("Failed namespace test.")
   else:
     InfoOut.Log("Passed namespace test.")
   return errs
 
+
+
+def FindVersionError(releases, node):
+  err_cnt = 0
+  if node.IsA('Interface', 'Struct'):
+    comment_list = []
+    comment = node.GetOneOf('Comment')
+    if comment:
+      print comment.GetName()
+    if comment and comment.GetName()[:4] == 'REL:':
+      comment_list = comment.GetName()[5:].strip().split(' ')
+      print comment_list
+
+    if len(comment_list) != len(releases):
+      node.Error("Mismatch size of releases: %s vs %s." % (
+          comment_list, releases))
+      err_cnt += 1
+    else:
+      first_list = [node.first_release[rel] for rel in releases]
+      if first_list != comment_list:
+        node.Error("Mismatch in releases: %s vs %s." % (
+            comment_list, first_list))
+        err_cnt += 1
+
+  for child in node.GetChildren():
+    err_cnt += FindVersionError(releases, child)
+  return err_cnt
+
+
+def TestVersionFiles(filter):
+  idldir = os.path.split(sys.argv[0])[0]
+  idldir = os.path.join(idldir, 'test_version', '*.idl')
+  filenames = glob.glob(idldir)
+  testnames = []
+
+  for filename in filenames:
+    if filter and filename not in filter: continue
+    testnames.append(filename)
+
+  # If we have no files to test, then skip this test
+  if not testnames:
+    InfoOut.Log('No files to test for version.')
+    return 0
+
+  ast = ParseFiles(testnames)
+  errs = FindVersionError(ast.releases, ast)
+
+  if errs:
+    ErrOut.Log("Failed version test.")
+  else:
+    InfoOut.Log("Passed version test.")
+  return errs
+
+
 default_dirs = ['.', 'trusted', 'dev', 'private']
 def ParseFiles(filenames):
   parser = IDLParser()
   filenodes = []
 
   if not filenames:
     filenames = []
     srcroot = GetOption('srcroot')
     dirs = default_dirs
     if GetOption('include_private'):
@@ skipping 17 matching lines @@
   return ast
 
 
 def Main(args):
   filenames = ParseOptions(args)
 
   # If testing...
   if GetOption('test'):
     errs = TestErrorFiles(filenames)
     errs = TestNamespaceFiles(filenames)
+    errs = TestVersionFiles(filenames)
     if errs:
       ErrOut.Log("Parser failed with %d errors." % errs)
       return  -1
     return 0
 
   # Otherwise, build the AST
   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:]))
+