Add support for single line enums to 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 133 matching lines @@
   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*$')
+      optional_fixed_type_re + '\s*{\s*')
+  enum_single_line_re = re.compile(
+      r'^\s*(?:\[cpp.*\])?\s*enum.*{(?P<enum_entries>.*)}.*$')
 
   def __init__(self, lines, path=''):
     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
@@ skipping 20 matching lines @@
     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):
-      self._FinalizeCurrentEnumEntry()
+      self._FinalizeCurrentEnumDefinition()
     else:
       self._AddToCurrentEnumEntry(line)
       if ',' in line:
         self._ParseCurrentEnumEntry()
 
+  def _ParseSingleLineEnum(self, line):
+    for entry in line.split(','):
+      self._AddToCurrentEnumEntry(entry)
+      self._ParseCurrentEnumEntry()
+
+    self._FinalizeCurrentEnumDefinition()
+
   def _ParseCurrentEnumEntry(self):
     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(self, line):
     self._current_enum_entry += ' ' + line.strip()
 
-  def _FinalizeCurrentEnumEntry(self):
+  def _FinalizeCurrentEnumDefinition(self):
     if self._current_enum_entry:
       self._ParseCurrentEnumEntry()
     self._ApplyGeneratorDirectives()
     self._current_definition.Finalize()
     self._enum_definitions.append(self._current_definition)
+    self._current_definition = None
     self._in_enum = False
 
   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)
     elif multi_line_directive_end:
       directive_name = self._multi_line_generator_directive[0]
       directive_value = "".join(self._multi_line_generator_directive[1])
       directive_value += multi_line_directive_end.groups()[0]
       self._multi_line_generator_directive = None
       self._generator_directives.Update(directive_name, directive_value)
     else:
       raise Exception('Malformed multi-line directive declaration in ' +
                       self._path)
 
   def _ParseRegularLine(self, line):
     enum_start = HeaderParser.enum_start_re.match(line)
     generator_directive_error = HeaderParser.generator_error_re.match(line)
     generator_directive = HeaderParser.generator_directive_re.match(line)
     multi_line_generator_directive_start = (
         HeaderParser.multi_line_generator_directive_start_re.match(line))
+    single_line_enum = HeaderParser.enum_single_line_re.match(line)
 
     if generator_directive_error:
       raise Exception('Malformed directive declaration in ' + self._path +
                       '. Use () for multi-line directives. E.g.\n' +
                       '// GENERATED_JAVA_ENUM_PACKAGE: (\n' +
                       '//   foo.package)')
     elif generator_directive:
       directive_name = generator_directive.groups()[0]
       directive_value = generator_directive.groups()[1]
       self._generator_directives.Update(directive_name, directive_value)
     elif multi_line_generator_directive_start:
       directive_name = multi_line_generator_directive_start.groups()[0]
       directive_value = multi_line_generator_directive_start.groups()[1]
       self._multi_line_generator_directive = (directive_name, [directive_value])
-    elif enum_start:
+    elif enum_start or single_line_enum:
       if self._generator_directives.empty:
         return
       self._current_definition = EnumDefinition(
           original_enum_name=enum_start.groups()[1],
           fixed_type=enum_start.groups()[3])
       self._in_enum = True
+      if single_line_enum:
+        self._ParseSingleLineEnum(single_line_enum.group('enum_entries'))
 
 def GetScriptName():
   return os.path.basename(os.path.abspath(sys.argv[0]))
 
 def DoGenerate(source_paths):
   for source_path in source_paths:
     enum_definitions = DoParseHeaderFile(source_path)
     if not enum_definitions:
       raise Exception('No enums found in %s\n'
                       'Did you forget prefixing enums with '
@@ skipping 104 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:])