Dartium Roll 38 roll

bindings/scripts/blink_idl_parser.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 53 matching lines @@
 sys.path.insert(1, third_party)
 from ply import yacc
 
 # Base parser is in Chromium src/tools/idl_parser
 tools_dir = os.path.join(module_path, os.pardir, os.pardir, os.pardir, os.pardir, os.pardir, 'tools')
 sys.path.append(tools_dir)
 from idl_parser.idl_parser import IDLParser, ListFromConcat
 from idl_parser.idl_parser import ParseFile as parse_file
 
 from blink_idl_lexer import BlinkIDLLexer
+import blink_idl_lexer
 
 
 # Explicitly set starting symbol to rule defined only in base parser.
 # BEWARE that the starting symbol should NOT be defined in both the base parser
 # and the derived one, as otherwise which is used depends on which line number
 # is lower, which is fragile. Instead, either use one in base parser or
 # create a new symbol, so that this is unambiguous.
 # FIXME: unfortunately, this doesn't work in PLY 3.4, so need to duplicate the
 # rule below.
 STARTING_SYMBOL = 'Definitions'
@@ skipping 241 matching lines @@
     # FIXME: Upstream
     def p_TypeSuffix(self, p):
         """TypeSuffix : '[' ']' TypeSuffix
                       | '?' TypeSuffixStartingWithArray
                       |"""
         if len(p) == 4:
             p[0] = self.BuildProduction('Array', p, 1, p[3])
         elif len(p) == 3:
             p[0] = ListFromConcat(self.BuildTrue('NULLABLE'), p[2])
 
-    # [b76.1] Add support for compound Extended Attribute values (A&B and A|B)
+    # [b94] Add support for OR Extended Attribute values "A|B"
     def p_ExtendedAttributeIdentList(self, p):
-        """ExtendedAttributeIdentList : identifier '=' identifier '&' IdentAndList
+        """ExtendedAttributeIdentList : identifier '=' '(' IdentifierList ')'
                                       | identifier '=' identifier '|' IdentOrList"""
-        value = self.BuildAttribute('VALUE', p[3] + p[4] + p[5])
+        if type(p[4]) is list:
+            value = self.BuildAttribute('VALUE', ','.join(p[4]))
+        else:
+            value = self.BuildAttribute('VALUE', p[3] + p[4] + p[5])
         p[0] = self.BuildNamed('ExtAttribute', p, 1, value)
 
-    # [b76.2] A&B&C
-    def p_IdentAndList(self, p):
-        """IdentAndList : identifier '&' IdentAndList
-                        | identifier"""
-        if len(p) > 3:
-            p[0] = p[1] + p[2] + p[3]
-        else:
-            p[0] = p[1]
-
-    # [b76.3] A|B|C
+    # [b94.1] A|B|C
     def p_IdentOrList(self, p):
         """IdentOrList : identifier '|' IdentOrList
                        | identifier"""
         if len(p) > 3:
             p[0] = p[1] + p[2] + p[3]
         else:
             p[0] = p[1]
 
     # Blink extension: Add support for compound Extended Attribute values over string literals ("A"|"B")
     def p_ExtendedAttributeStringLiteralList(self, p):
@@ skipping 11 matching lines @@
             return ls[1].value
 
         if len(p) > 3:
             p[0] = unwrap_string(p[1]) + p[2] + p[3]
         else:
             p[0] = unwrap_string(p[1])
 
     def __init__(self,
                  # common parameters
                  debug=False,
+                 # local parameters
+                 rewrite_tables=False,
                  # idl_parser parameters
                  lexer=None, verbose=False, mute_error=False,
                  # yacc parameters
                  outputdir='', optimize=True, write_tables=False,
                  picklefile=None):
         if debug:
             # Turn off optimization and caching, and write out tables,
             # to help debugging
             optimize = False
             outputdir = None
             picklefile = None
             write_tables = True
         if outputdir:
             picklefile = picklefile or os.path.join(outputdir, 'parsetab.pickle')
+            if rewrite_tables:
+                try:
+                    os.unlink(picklefile)
+                except OSError:
+                    pass
 
         lexer = lexer or BlinkIDLLexer(debug=debug,
                                        outputdir=outputdir,
                                        optimize=optimize)
         self.lexer = lexer
         self.tokens = lexer.KnownTokens()
         # Using SLR (instead of LALR) generates the table faster,
         # but produces the same output. This is ok b/c Web IDL (and Blink IDL)
         # is an SLR grammar (as is often the case for simple LL(1) grammars).
         #
@@ skipping 19 matching lines @@
         self._parse_errors = 0
         self._parse_warnings = 0
         self._last_error_msg = None
         self._last_error_lineno = 0
         self._last_error_pos = 0
 
 
 ################################################################################
 
 def main(argv):
-    # If file itself executed, cache parse table
+    # If file itself executed, cache lex/parse tables
     try:
         outputdir = argv[1]
     except IndexError as err:
         print 'Usage: %s OUTPUT_DIR' % argv[0]
         return 1
-    parser = BlinkIDLParser(outputdir=outputdir)
+    blink_idl_lexer.main(argv)
+    # Important: rewrite_tables=True causes the cache file to be deleted if it
+    # exists, thus making sure that PLY doesn't load it instead of regenerating
+    # the parse table.
+    parser = BlinkIDLParser(outputdir=outputdir, rewrite_tables=True)
 
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv))