Remove the Pepper IDL generator from JSON schema compiler.

tools/json_schema_compiler/ppapi_generator.py

-# Copyright 2013 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
-import datetime
-import os.path
-import sys
-
-import code
-import cpp_util
-import model
-
-try:
-  import jinja2
-except ImportError:
-  sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..',
-                               'third_party'))
-  import jinja2
-
-
-class _PpapiGeneratorBase(object):
-  """A base class for ppapi generators.
-
-  Implementations should set TEMPLATE_NAME to a string containing the name of
-  the template file without its extension. The template will be rendered with
-  the following symbols available:
-    name: A string containing the name of the namespace.
-    enums: A list of enums within the namespace.
-    types: A list of types within the namespace, sorted such that no element
-        depends on an earlier element.
-    events: A dict of events within the namespace.
-    functions: A dict of functions within the namespace.
-    year: An int containing the current year.
-    source_file: The name of the input file.
-  """
-
-  def __init__(self, namespace):
-    self._namespace = namespace
-    self._required_types = {}
-    self._array_types = set()
-    self._optional_types = set()
-    self._optional_array_types = set()
-    self._dependencies = collections.OrderedDict()
-    self._types = []
-    self._enums = []
-
-    self.jinja_environment = jinja2.Environment(
-        loader=jinja2.FileSystemLoader(os.path.join(os.path.dirname(__file__),
-                                                    'templates', 'ppapi')))
-    self._SetupFilters()
-    self._ResolveTypeDependencies()
-
-  def _SetupFilters(self):
-    self.jinja_environment.filters.update({
-      'ppapi_type': self.ToPpapiType,
-      'classname': cpp_util.Classname,
-      'enum_value': self.EnumValueName,
-      'return_type': self.GetFunctionReturnType,
-      'format_param_type': self.FormatParamType,
-      'needs_optional': self.NeedsOptional,
-      'needs_array': self.NeedsArray,
-      'needs_optional_array': self.NeedsOptionalArray,
-      'has_array_outs': self.HasArrayOuts,
-    })
-
-  def Render(self, template_name, values):
-    generated_code = code.Code()
-    template = self.jinja_environment.get_template(
-        '%s.template' % template_name)
-    generated_code.Append(template.render(values))
-    return generated_code
-
-  def Generate(self):
-    """Generates a Code object for a single namespace."""
-    return self.Render(self.TEMPLATE_NAME, {
-      'name': self._namespace.name,
-      'enums': self._enums,
-      'types': self._types,
-      'events': self._namespace.events,
-      'functions': self._namespace.functions,
-      # TODO(sammc): Don't change years when regenerating existing output files.
-      'year': datetime.date.today().year,
-      'source_file': self._namespace.source_file,
-    })
-
-  def _ResolveTypeDependencies(self):
-    """Calculates the transitive closure of the types in _required_types.
-
-    Returns a tuple containing the list of struct types and the list of enum
-    types. The list of struct types is ordered such that no type depends on a
-    type later in the list.
-
-    """
-    if self._namespace.functions:
-      for function in self._namespace.functions.itervalues():
-        self._FindFunctionDependencies(function)
-
-    if self._namespace.events:
-      for event in self._namespace.events.itervalues():
-        self._FindFunctionDependencies(event)
-    resolved_types = set()
-    while resolved_types < set(self._required_types):
-      for typename in sorted(set(self._required_types) - resolved_types):
-        type_ = self._required_types[typename]
-        self._dependencies.setdefault(typename, set())
-        for member in type_.properties.itervalues():
-          self._RegisterDependency(member, self._NameComponents(type_))
-        resolved_types.add(typename)
-    while self._dependencies:
-      for name, deps in self._dependencies.items():
-        if not deps:
-          if (self._required_types[name].property_type ==
-              model.PropertyType.ENUM):
-            self._enums.append(self._required_types[name])
-          else:
-            self._types.append(self._required_types[name])
-          for deps in self._dependencies.itervalues():
-            deps.discard(name)
-          del self._dependencies[name]
-          break
-      else:
-        raise ValueError('Circular dependency %s' % self._dependencies)
-
-  def _FindFunctionDependencies(self, function):
-    for param in function.params:
-      self._RegisterDependency(param, None)
-    if function.callback:
-      for param in function.callback.params:
-        self._RegisterDependency(param, None)
-    if function.returns:
-      self._RegisterTypeDependency(function.returns, None, False, False)
-
-  def _RegisterDependency(self, member, depender):
-    self._RegisterTypeDependency(member.type_, depender, member.optional, False)
-
-  def _RegisterTypeDependency(self, type_, depender, optional, array):
-    if type_.property_type == model.PropertyType.ARRAY:
-      self._RegisterTypeDependency(type_.item_type, depender, optional, True)
-    elif type_.property_type == model.PropertyType.REF:
-      self._RegisterTypeDependency(self._namespace.types[type_.ref_type],
-                                   depender, optional, array)
-    elif type_.property_type in (model.PropertyType.OBJECT,
-                                 model.PropertyType.ENUM):
-      name_components = self._NameComponents(type_)
-      self._required_types[name_components] = type_
-      if depender:
-        self._dependencies.setdefault(depender, set()).add(
-            name_components)
-      if array:
-        self._array_types.add(name_components)
-        if optional:
-          self._optional_array_types.add(name_components)
-      elif optional:
-        self._optional_types.add(name_components)
-
-  @staticmethod
-  def _NameComponents(entity):
-    """Returns a tuple of the fully-qualified name of an entity."""
-    names = []
-    while entity:
-      if (not isinstance(entity, model.Type) or
-          entity.property_type != model.PropertyType.ARRAY):
-        names.append(entity.name)
-      entity = entity.parent
-    return tuple(reversed(names[:-1]))
-
-  def ToPpapiType(self, type_, array=False, optional=False):
-    """Returns a string containing the name of the Pepper C type for |type_|.
-
-    If array is True, returns the name of an array of |type_|. If optional is
-    True, returns the name of an optional |type_|. If both array and optional
-    are True, returns the name of an optional array of |type_|.
-    """
-    if isinstance(type_, model.Function) or type_.property_type in (
-        model.PropertyType.OBJECT, model.PropertyType.ENUM):
-      return self._FormatPpapiTypeName(
-          array, optional, '_'.join(
-              cpp_util.Classname(s) for s in self._NameComponents(type_)),
-              namespace=cpp_util.Classname(self._namespace.name))
-    elif type_.property_type == model.PropertyType.REF:
-      return self.ToPpapiType(self._namespace.types[type_.ref_type],
-                              optional=optional, array=array)
-    elif type_.property_type == model.PropertyType.ARRAY:
-      return self.ToPpapiType(type_.item_type, array=True,
-                              optional=optional)
-    elif type_.property_type == model.PropertyType.STRING and not array:
-      return 'PP_Var'
-    elif array or optional:
-      if type_.property_type in self._PPAPI_COMPOUND_PRIMITIVE_TYPE_MAP:
-        return self._FormatPpapiTypeName(
-            array, optional,
-            self._PPAPI_COMPOUND_PRIMITIVE_TYPE_MAP[type_.property_type], '')
-    return self._PPAPI_PRIMITIVE_TYPE_MAP.get(type_.property_type, 'PP_Var')
-
-  _PPAPI_PRIMITIVE_TYPE_MAP = {
-    model.PropertyType.BOOLEAN: 'PP_Bool',
-    model.PropertyType.DOUBLE: 'double_t',
-    model.PropertyType.INT64: 'int64_t',
-    model.PropertyType.INTEGER: 'int32_t',
-  }
-  _PPAPI_COMPOUND_PRIMITIVE_TYPE_MAP = {
-    model.PropertyType.BOOLEAN: 'Bool',
-    model.PropertyType.DOUBLE: 'Double',
-    model.PropertyType.INT64: 'Int64',
-    model.PropertyType.INTEGER: 'Int32',
-    model.PropertyType.STRING: 'String',
-  }
-
-  @staticmethod
-  def _FormatPpapiTypeName(array, optional, name, namespace=''):
-    if namespace:
-      namespace = '%s_' % namespace
-    if array:
-      if optional:
-        return 'PP_%sOptional_%s_Array' % (namespace, name)
-      return 'PP_%s%s_Array' % (namespace, name)
-    if optional:
-      return 'PP_%sOptional_%s' % (namespace, name)
-    return 'PP_%s%s' % (namespace, name)
-
-  def NeedsOptional(self, type_):
-    """Returns True if an optional |type_| is required."""
-    return self._NameComponents(type_) in self._optional_types
-
-  def NeedsArray(self, type_):
-    """Returns True if an array of |type_| is required."""
-    return self._NameComponents(type_) in self._array_types
-
-  def NeedsOptionalArray(self, type_):
-    """Returns True if an optional array of |type_| is required."""
-    return self._NameComponents(type_) in self._optional_array_types
-
-  def FormatParamType(self, param):
-    """Formats the type of a parameter or property."""
-    return self.ToPpapiType(param.type_, optional=param.optional)
-
-  @staticmethod
-  def GetFunctionReturnType(function):
-    return 'int32_t' if function.callback or function.returns else 'void'
-
-  def EnumValueName(self, enum_value, enum_type):
-    """Returns a string containing the name for an enum value."""
-    return '%s_%s' % (self.ToPpapiType(enum_type).upper(),
-                      enum_value.name.upper())
-
-  def _ResolveType(self, type_):
-    if type_.property_type == model.PropertyType.REF:
-      return self._ResolveType(self._namespace.types[type_.ref_type])
-    if type_.property_type == model.PropertyType.ARRAY:
-      return self._ResolveType(type_.item_type)
-    return type_
-
-  def _IsOrContainsArray(self, type_):
-    if type_.property_type == model.PropertyType.ARRAY:
-      return True
-    type_ = self._ResolveType(type_)
-    if type_.property_type == model.PropertyType.OBJECT:
-      return any(self._IsOrContainsArray(param.type_)
-                 for param in type_.properties.itervalues())
-    return False
-
-  def HasArrayOuts(self, function):
-    """Returns True if the function produces any arrays as outputs.
-
-    This includes arrays that are properties of other objects.
-    """
-    if function.callback:
-      for param in function.callback.params:
-        if self._IsOrContainsArray(param.type_):
-          return True
-    return function.returns and self._IsOrContainsArray(function.returns)
-
-
-class _IdlGenerator(_PpapiGeneratorBase):
-  TEMPLATE_NAME = 'idl'
-
-
-class _GeneratorWrapper(object):
-  def __init__(self, generator_factory):
-    self._generator_factory = generator_factory
-
-  def Generate(self, namespace):
-    return self._generator_factory(namespace).Generate()
-
-
-class PpapiGenerator(object):
-  def __init__(self):
-    self.idl_generator = _GeneratorWrapper(_IdlGenerator)