Allow multi-line enum entries in java_cpp_enum.py.

build/android/gyp/java_cpp_enum.py

 #!/usr/bin/env python
 #
 # Copyright 2014 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.
 
 import collections
 from datetime import date
 import re
 import optparse
@@ skipping 112 matching lines @@
   def UpdateDefinition(self, definition):
     definition.class_name_override = self._directives.get(
         DirectiveSet.class_name_override_key, '')
     definition.enum_package = self._directives.get(
         DirectiveSet.enum_package_key)
     definition.prefix_to_strip = self._directives.get(
         DirectiveSet.prefix_to_strip_key)
 
 
 class HeaderParser(object):
-  single_line_comment_re = re.compile(r'\s*//\s*([^\n]+)')
+  single_line_comment_re = re.compile(r'\s*//\s*([^\n]*)')
   multi_line_comment_start_re = re.compile(r'\s*/\*')
   enum_line_re = re.compile(r'^\s*(\w+)(\s*\=\s*([^,\n]+))?,?')
   enum_end_re = re.compile(r'^\s*}\s*;\.*$')
   generator_directive_re = re.compile(
       r'^\s*//\s+GENERATED_JAVA_(\w+)\s*:\s*([\.\w]+)$')
   multi_line_generator_directive_start_re = re.compile(
       r'^\s*//\s+GENERATED_JAVA_(\w+)\s*:\s*\(([\.\w]*)$')
   multi_line_directive_continuation_re = re.compile(
       r'^\s*//\s+([\.\w]+)$')
   multi_line_directive_end_re = re.compile(
       r'^\s*//\s+([\.\w]*)\)$')
 
   optional_class_or_struct_re = r'(class|struct)?'
   enum_name_re = r'(\w+)'
   optional_fixed_type_re = r'(\:\s*(\w+\s*\w+?))?'
   enum_start_re = re.compile(r'^\s*(?:\[cpp.*\])?\s*enum\s+' +
       optional_class_or_struct_re + '\s*' + enum_name_re + '\s*' +
       optional_fixed_type_re + '\s*{\s*$')
 
   def __init__(self, lines, path=None):
     self._lines = lines
     self._path = path
     self._enum_definitions = []
     self._in_enum = False
     self._current_definition = None
     self._current_comments = []
     self._generator_directives = DirectiveSet()
     self._multi_line_generator_directive = None
+    self._current_enum_entry = ''
 
   def _ApplyGeneratorDirectives(self):
     self._generator_directives.UpdateDefinition(self._current_definition)
     self._generator_directives = DirectiveSet()
 
   def ParseDefinitions(self):
     for line in self._lines:
       self._ParseLine(line)
     return self._enum_definitions
 
   def _ParseLine(self, line):
     if self._multi_line_generator_directive:
       self._ParseMultiLineDirectiveLine(line)
     elif not self._in_enum:
       self._ParseRegularLine(line)
     else:
       self._ParseEnumLine(line)
 
   def _ParseEnumLine(self, line):
-    enum_comment = HeaderParser.single_line_comment_re.match(line)
-    if enum_comment:
-      self._current_comments.append(enum_comment.groups()[0])
-      return
-    if HeaderParser.multi_line_comment_start_re.match(line):
-      raise Exception('Multi-line comments in enums are not supported in ' +
-                      self._path)
-    enum_end = HeaderParser.enum_end_re.match(line)
-    enum_entry = HeaderParser.enum_line_re.match(line)
-    if enum_end:
-      self._ApplyGeneratorDirectives()
-      self._current_definition.Finalize()
-      self._enum_definitions.append(self._current_definition)
-      self._in_enum = False
-    elif enum_entry:
+    def _ParseCurrentEnumEntry():

[agrieve, 2016/10/04 15:57:28]

Looks like these helpers don't use their outer context. You should make them
siblings rather than nested.

[estevenson, 2016/10/04 16:15:25]

Done.

+      if not self._current_enum_entry:
+        return
+
+      enum_entry = HeaderParser.enum_line_re.match(self._current_enum_entry)
+      if not enum_entry:
+        raise Exception('Unexpected error while attempting to parse %s as enum '
+                        'entry.' % self._current_enum_entry)
+
       enum_key = enum_entry.groups()[0]
       enum_value = enum_entry.groups()[2]
       self._current_definition.AppendEntry(enum_key, enum_value)
       if self._current_comments:
          self._current_definition.AppendEntryComment(
                  enum_key, ' '.join(self._current_comments))
          self._current_comments = []
+      self._current_enum_entry = ''
+
+    def _AddToCurrentEnumEntry(line):
+      self._current_enum_entry += ' ' + line.strip()
+
+    def _FinalizeCurrentEnumEntry():
+      if self._current_enum_entry:
+        _ParseCurrentEnumEntry()
+      self._ApplyGeneratorDirectives()
+      self._current_definition.Finalize()
+      self._enum_definitions.append(self._current_definition)
+      self._in_enum = False
+
+    if HeaderParser.multi_line_comment_start_re.match(line):
+      raise Exception('Multi-line comments in enums are not supported in ' +
+                      self._path)
+
+    enum_comment = HeaderParser.single_line_comment_re.match(line)
+    if enum_comment:
+      comment = enum_comment.groups()[0]
+      if comment:
+        self._current_comments.append(comment)
+    elif HeaderParser.enum_end_re.match(line):
+      _FinalizeCurrentEnumEntry()
+    else:
+      _AddToCurrentEnumEntry(line)
+      if ',' in line:
+        _ParseCurrentEnumEntry()
 
   def _ParseMultiLineDirectiveLine(self, line):
     multi_line_directive_continuation = (
         HeaderParser.multi_line_directive_continuation_re.match(line))
     multi_line_directive_end = (
         HeaderParser.multi_line_directive_end_re.match(line))
 
     if multi_line_directive_continuation:
       value_cont = multi_line_directive_continuation.groups()[0]
       self._multi_line_generator_directive[1].append(value_cont)
@@ skipping 145 matching lines @@
   with zipfile.ZipFile(options.srcjar, 'w', zipfile.ZIP_STORED) as srcjar:
     for output_path, data in DoGenerate(input_paths):
       build_utils.AddToZipHermetic(srcjar, output_path, data=data)
 
   if options.depfile:
     build_utils.WriteDepfile(options.depfile, options.srcjar)
 
 
 if __name__ == '__main__':
   DoMain(sys.argv[1:])