blob: bacc8e3d46dc601aadd37ad39fe0995161b2d950 [file] [log] [blame]
#!/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
import os
from string import Template
import sys
import textwrap
import zipfile
from util import build_utils
from util import java_cpp_utils
# List of C++ types that are compatible with the Java code generated by this
# script.
#
# This script can parse .idl files however, at present it ignores special
# rules such as [cpp_enum_prefix_override="ax_attr"].
ENUM_FIXED_TYPE_WHITELIST = ['char', 'unsigned char',
'short', 'unsigned short',
'int', 'int8_t', 'int16_t', 'int32_t', 'uint8_t', 'uint16_t']
class EnumDefinition(object):
def __init__(self, original_enum_name=None, class_name_override=None,
enum_package=None, entries=None, comments=None, fixed_type=None):
self.original_enum_name = original_enum_name
self.class_name_override = class_name_override
self.enum_package = enum_package
self.entries = collections.OrderedDict(entries or [])
self.comments = collections.OrderedDict(comments or [])
self.prefix_to_strip = None
self.fixed_type = fixed_type
def AppendEntry(self, key, value):
if key in self.entries:
raise Exception('Multiple definitions of key %s found.' % key)
self.entries[key] = value
def AppendEntryComment(self, key, value):
if key in self.comments:
raise Exception('Multiple definitions of key %s found.' % key)
self.comments[key] = value
@property
def class_name(self):
return self.class_name_override or self.original_enum_name
def Finalize(self):
self._Validate()
self._AssignEntryIndices()
self._StripPrefix()
self._NormalizeNames()
def _Validate(self):
assert self.class_name
assert self.enum_package
assert self.entries
if self.fixed_type and self.fixed_type not in ENUM_FIXED_TYPE_WHITELIST:
raise Exception('Fixed type %s for enum %s not whitelisted.' %
(self.fixed_type, self.class_name))
def _AssignEntryIndices(self):
# Enums, if given no value, are given the value of the previous enum + 1.
if not all(self.entries.values()):
prev_enum_value = -1
for key, value in self.entries.iteritems():
if not value:
self.entries[key] = prev_enum_value + 1
elif value in self.entries:
self.entries[key] = self.entries[value]
else:
try:
self.entries[key] = int(value)
except ValueError:
raise Exception('Could not interpret integer from enum value "%s" '
'for key %s.' % (value, key))
prev_enum_value = self.entries[key]
def _StripPrefix(self):
prefix_to_strip = self.prefix_to_strip
if not prefix_to_strip:
shout_case = self.original_enum_name
shout_case = re.sub('(?!^)([A-Z]+)', r'_\1', shout_case).upper()
shout_case += '_'
prefixes = [shout_case, self.original_enum_name,
'k' + self.original_enum_name]
for prefix in prefixes:
if all([w.startswith(prefix) for w in self.entries.keys()]):
prefix_to_strip = prefix
break
else:
prefix_to_strip = ''
def StripEntries(entries):
ret = collections.OrderedDict()
for k, v in entries.iteritems():
stripped_key = k.replace(prefix_to_strip, '', 1)
if isinstance(v, basestring):
stripped_value = v.replace(prefix_to_strip, '')
else:
stripped_value = v
ret[stripped_key] = stripped_value
return ret
self.entries = StripEntries(self.entries)
self.comments = StripEntries(self.comments)
def _NormalizeNames(self):
self.entries = _TransformKeys(self.entries, java_cpp_utils.KCamelToShouty)
self.comments = _TransformKeys(self.comments, java_cpp_utils.KCamelToShouty)
def _TransformKeys(d, func):
"""Normalize keys in |d| and update references to old keys in |d| values."""
normal_keys = {k: func(k) for k in d}
ret = collections.OrderedDict()
for k, v in d.iteritems():
# Need to transform values as well when the entry value was explicitly set
# (since it could contain references to other enum entry values).
if isinstance(v, basestring):
for normal_key in normal_keys:
v = v.replace(normal_key, normal_keys[normal_key])
ret[normal_keys[k]] = v
return ret
class DirectiveSet(object):
class_name_override_key = 'CLASS_NAME_OVERRIDE'
enum_package_key = 'ENUM_PACKAGE'
prefix_to_strip_key = 'PREFIX_TO_STRIP'
known_keys = [class_name_override_key, enum_package_key, prefix_to_strip_key]
def __init__(self):
self._directives = {}
def Update(self, key, value):
if key not in DirectiveSet.known_keys:
raise Exception("Unknown directive: " + key)
self._directives[key] = value
@property
def empty(self):
return len(self._directives) == 0
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]*)')
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_error_re = re.compile(r'^\s*//\s+GENERATED_JAVA_(\w+)\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*')
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
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):
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._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 _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 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 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 '
'"// GENERATED_JAVA_ENUM_PACKAGE: foo"?' %
source_path)
for enum_definition in enum_definitions:
package_path = enum_definition.enum_package.replace('.', os.path.sep)
file_name = enum_definition.class_name + '.java'
output_path = os.path.join(package_path, file_name)
output = GenerateOutput(source_path, enum_definition)
yield output_path, output
def DoParseHeaderFile(path):
with open(path) as f:
return HeaderParser(f.readlines(), path).ParseDefinitions()
def GenerateOutput(source_path, enum_definition):
template = Template("""
// Copyright ${YEAR} 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.
// This file is autogenerated by
// ${SCRIPT_NAME}
// From
// ${SOURCE_PATH}
package ${PACKAGE};
import android.support.annotation.IntDef;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@IntDef({
${INT_DEF}
})
@Retention(RetentionPolicy.SOURCE)
public @interface ${CLASS_NAME} {
${ENUM_ENTRIES}
}
""")
enum_template = Template(' int ${NAME} = ${VALUE};')
enum_entries_string = []
enum_names = []
for enum_name, enum_value in enum_definition.entries.iteritems():
values = {
'NAME': enum_name,
'VALUE': enum_value,
}
enum_comments = enum_definition.comments.get(enum_name)
if enum_comments:
enum_comments_indent = ' * '
comments_line_wrapper = textwrap.TextWrapper(
initial_indent=enum_comments_indent,
subsequent_indent=enum_comments_indent,
width=100)
enum_entries_string.append(' /**')
enum_entries_string.append('\n'.join(
comments_line_wrapper.wrap(enum_comments)))
enum_entries_string.append(' */')
enum_entries_string.append(enum_template.substitute(values))
if enum_name != "NUM_ENTRIES":
enum_names.append(enum_definition.class_name + '.' + enum_name)
enum_entries_string = '\n'.join(enum_entries_string)
enum_names_indent = ' ' * 4
wrapper = textwrap.TextWrapper(initial_indent = enum_names_indent,
subsequent_indent = enum_names_indent,
width = 100)
enum_names_string = '\n'.join(wrapper.wrap(', '.join(enum_names)))
values = {
'CLASS_NAME': enum_definition.class_name,
'ENUM_ENTRIES': enum_entries_string,
'PACKAGE': enum_definition.enum_package,
'INT_DEF': enum_names_string,
'SCRIPT_NAME': java_cpp_utils.GetScriptName(),
'SOURCE_PATH': source_path,
'YEAR': str(date.today().year)
}
return template.substitute(values)
def DoMain(argv):
usage = 'usage: %prog [options] [output_dir] input_file(s)...'
parser = optparse.OptionParser(usage=usage)
build_utils.AddDepfileOption(parser)
parser.add_option('--srcjar',
help='When specified, a .srcjar at the given path is '
'created instead of individual .java files.')
options, args = parser.parse_args(argv)
if not args:
parser.error('Need to specify at least one input file')
input_paths = args
with build_utils.AtomicOutput(options.srcjar) as f:
with zipfile.ZipFile(f, '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, add_pydeps=False)
if __name__ == '__main__':
DoMain(sys.argv[1:])