path: root/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)