path: root/ppapi/generators/idl_c_proto.py

#!/usr/bin/python
#
# Copyright (c) 2011 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.

""" Generator for C style prototypes and definitions """

import glob
import os
import sys

from idl_log import ErrOut, InfoOut, WarnOut
from idl_node import IDLNode
from idl_ast import IDLAst
from idl_option import GetOption, Option, ParseOptions
from idl_parser import ParseFiles

Option('cgen_debug', 'Debug generate.')

class CGenError(Exception):
  def __init__(self, msg):
    self.value = value

  def __str__(self):
    return repr(self.value)


class CGen(object):
  # TypeMap
  #
  # TypeMap modifies how an object is stored or passed, for example pointers
  # are passed as 'const' if they are 'in' parameters, and structures are
  # preceeded by the keyword 'struct' as well as using a pointer.
  #
  TypeMap = {
    'Array': {
      'in': 'const %s',
      'inout': '%s*',
      'out': '%s*',
      'store': '%s',
      'return': '%s'
    },
    'Callspec': {
      'in': '%s',
      'inout': '%s',
      'out': '%s',
      'store': '%s',
      'return': '%s'
    },
    'Enum': {
      'in': '%s',
      'inout': '%s*',
      'out': '%s*',
      'store': '%s',
      'return': '%s'
    },
    'Struct': {
      'in': 'const %s*',
      'inout': '%s*',
      'out': '%s*',
      'return': ' %s*',
      'store': '%s'
    },
    'mem_t': {
      'in': 'const %s',
      'inout': '%s',
      'out': '%s',
      'return': '%s',
      'store': '%s'
    },
    'str_t': {
      'in': 'const %s',
      'inout': '%s',
      'out': '%s',
      'return': 'const %s',
      'store': '%s'
    },
    'TypeValue': {
      'in': '%s',
      'inout': '%s*',
      'out': '%s*',
      'return': '%s',
      'store': '%s'
    },
  }


  #
  # RemapName
  #
  # A diction array of PPAPI types that are converted to language specific
  # types before being returned by by the C generator
  #
  RemapName = {
  'float_t': 'float',
  'double_t': 'double',
  'handle_t': 'int',
  'mem_t': 'void*',
  'str_t': 'char*',
  'interface_t' : 'const void*'
  }

  def __init__(self):
    self.dbg_depth = 0
    self.vmin = 0.0
    self.vmax = 1e100
    self.release = 'M14'

  def SetVersionMap(self, node):
    self.vmin = 0.0
    self.vmax = 1e100
    for version in node.GetListOf('LabelItem'):
      if version.GetName() == GetOption('version'):
        self.vmin = float(version.GetProperty('VALUE'))
        self.vmax = float(version.GetProperty('VALUE'))

  #
  # Debug Logging functions
  #
  def Log(self, txt):
    if not GetOption('cgen_debug'): return
    tabs = ''
    for tab in range(self.dbg_depth): tabs += '  '
    print '%s%s' % (tabs, txt)

  def LogEnter(self, txt):
    if txt: self.Log(txt)
    self.dbg_depth += 1

  def LogExit(self, txt):
    self.dbg_depth -= 1
    if txt: self.Log(txt)

  #
  # Return the array specification of the object.
  #
  def GetArraySpec(self, node):
    assert(node.cls == 'Array')
    out = ''
    fixed = node.GetProperty('FIXED')
    if fixed:
      return '[%s]' % fixed
    else:
      return '[]'

  #
  # GetTypeName
  #
  # For any valid 'typed' object such as Member or Typedef
  # the typenode object contains the typename
  #
  # For a given node return the type name by passing mode.
  #
  def GetTypeName(self, node, prefix=''):
    self.LogEnter('GetTypeName of %s' % node)

    # For Members, Params, and Typedef's your want type it refers to
    if node.IsA('Member', 'Param', 'Typedef'):
      typeref = node.GetType(self.release)
    else:
      typeref = node

    if typeref is None:
      raise CGenError('No type for %s' % node)

    # If the type is a (BuiltIn) Type then return it's name
    # remapping as needed
    if typeref.IsA('Type'):
      name = CGen.RemapName.get(typeref.GetName(), None)
      if name is None: name = typeref.GetName()
      name = '%s%s' % (prefix, name)

    # For structures, preceed with 'struct' or 'union' as appropriate
    elif typeref.IsA('Interface', 'Struct'):
      if typeref.GetProperty('union'):
        name = 'union %s%s' % (prefix, typeref.GetName())
      else:
        name = 'struct %s%s' % (prefix, typeref.GetName())

    # If it's an enum, or typedef then return the Enum's name
    elif typeref.IsA('Enum', 'Typedef'):
      name = '%s%s' % (prefix, typeref.GetName())

    else:
      raise RuntimeError('Getting name of non-type %s.' % node)
    self.LogExit('GetTypeName %s is %s' % (node, name))
    return name


  #
  # GetRootType
  #
  # For a given node return basic type of that object.  This is
  # either a 'Type', 'Callspec', or 'Array'
  #
  def GetRootTypeMode(self, node, mode):
    self.LogEnter('GetRootType of %s' % node)
    # If it has an array spec, then treat it as an array regardless of type
    if node.GetOneOf('Array'):
      rootType = 'Array'
    # Or if it has a callspec, treat it as a function
    elif node.GetOneOf('Callspec'):
      rootType, mode = self.GetRootTypeMode(node.GetType(self.release),
                                            'return')

    # If it's a plain typedef, try that object's root type
    elif node.IsA('Member', 'Param', 'Typedef'):
      rootType, mode = self.GetRootTypeMode(node.GetType(self.release), mode)

    # If it's an Enum, then it's normal passing rules
    elif node.IsA('Enum'):
      rootType = node.cls

    # If it's an Interface or Struct, we may be passing by value
    elif node.IsA('Interface', 'Struct'):
      if mode == 'return':
        if node.GetProperty('returnByValue'):
          rootType = 'TypeValue'
        else:
          rootType = node.cls
      else:
        if node.GetProperty('passByValue'):
          rootType = 'TypeValue'
        else:
          rootType = node.cls

    # If it's an Basic Type, check if it's a special type
    elif node.IsA('Type'):
      if node.GetName() in CGen.TypeMap:
        rootType = node.GetName()
      else:
        rootType = 'TypeValue'
    else:
      raise RuntimeError('Getting root type of non-type %s.' % node)
    self.LogExit('RootType is "%s"' % rootType)
    return rootType, mode


  def GetTypeByMode(self, node, mode):
    self.LogEnter('GetTypeByMode of %s mode=%s' % (node, mode))
    name = self.GetTypeName(node)
    ntype, mode = self.GetRootTypeMode(node, mode)
    out = CGen.TypeMap[ntype][mode] % name
    self.LogExit('GetTypeByMode %s = %s' % (node, out))
    return out


  # Get the passing mode of the object (in, out, inout).
  def GetParamMode(self, node):
    self.Log('GetParamMode for %s' % node)
    if node.GetProperty('in'): return 'in'
    if node.GetProperty('out'): return 'out'
    if node.GetProperty('inout'): return 'inout'
    return 'return'

  #
  # GetComponents
  #
  # Returns the signature components of an object as a tuple of
  # (rtype, name, arrays, callspec) where:
  #   rtype - The store or return type of the object.
  #   name - The name of the object.
  #   arrays - A list of array dimensions as [] or [<fixed_num>].
  #   args -  None of not a function, otherwise  a list of parameters.
  #
  def GetComponents(self, node, mode):
    self.LogEnter('GetComponents mode %s for %s' % (mode, node))

    # Generate passing type by modifying root type
    rtype = self.GetTypeByMode(node, mode)
    if node.IsA('Enum', 'Interface', 'Struct'):
      rname = node.GetName()
    else:
      rname = node.GetType(self.release).GetName()

    if rname in CGen.RemapName:
      rname = CGen.RemapName[rname]
    if '%' in rtype:
      rtype = rtype % rname
    name = node.GetName()
    arrayspec = [self.GetArraySpec(array) for array in node.GetListOf('Array')]
    callnode = node.GetOneOf('Callspec')
    if callnode:
      callspec = []
      for param in callnode.GetListOf('Param'):
        mode = self.GetParamMode(param)
        ptype, pname, parray, pspec = self.GetComponents(param, mode)
        callspec.append((ptype, pname, parray, pspec))
    else:
      callspec = None

    self.LogExit('GetComponents: %s, %s, %s, %s' %
                 (rtype, name, arrayspec, callspec))
    return (rtype, name, arrayspec, callspec)


  def Compose(self, rtype, name, arrayspec, callspec, prefix, func_as_ptr):
    self.LogEnter('Compose: %s %s' % (rtype, name))
    arrayspec = ''.join(arrayspec)
    name = '%s%s%s' % (prefix, name, arrayspec)
    if callspec is None:
      out = '%s %s' % (rtype, name)
    else:
      params = []
      for ptype, pname, parray, pspec in callspec:
        params.append(self.Compose(ptype, pname, parray, pspec, '', True))
      if func_as_ptr: name = '(*%s)' % name
      out = '%s %s(%s)' % (rtype, name, ', '.join(params))
    self.LogExit('Exit Compose: %s' % out)
    return out

  #
  # GetSignature
  #
  # Returns the 'C' style signature of the object
  #  prefix - A prefix for the object's name
  #  func_as_ptr - Formats a function as a function pointer
  #
  def GetSignature(self, node, mode, prefix='', func_as_ptr=True):
    self.LogEnter('GetSignature %s %s as func=%s' % (node, mode, func_as_ptr))
    rtype, name, arrayspec, callspec = self.GetComponents(node, mode)
    out = self.Compose(rtype, name, arrayspec, callspec, prefix, func_as_ptr)
    self.LogExit('Exit GetSignature: %s' % out)
    return out

  def GetMacro(self, node):
    name = node.GetName()
    name = name.upper()
    return "%s_INTERFACE" % name

  def GetDefine(self, name, value):
    out = '#define %s %s' % (name, value)
    if len(out) > 80:
      out = '#define %s \\\n    %s' % (name, value)
    return '%s\n' % out

  # Define an Typedef.
  def DefineTypedef(self, node, prefix='', comment=False):
    out = 'typedef %s;\n' % self.GetSignature(node, 'return', prefix, True)
    self.Log('DefineTypedef: %s' % out)
    return out

  # Define an Enum.
  def DefineEnum(self, node, prefix='', comment=False):
    self.LogEnter('DefineEnum %s' % node)
    unnamed =  node.GetProperty('unnamed')
    if unnamed:
      out = 'enum {'
    else:
      out = 'typedef enum {'
    name = '%s%s' % (prefix, node.GetName())
    enumlist = []
    for child in node.GetListOf('EnumItem'):
      value = child.GetProperty('VALUE')
      comment_txt = ''
      if comment:
        for comment_node in child.GetListOf('Comment'):
          comment_txt += self.Comment(comment_node, tabs=1)
        if comment_txt:
          comment_txt = '%s' % comment_txt
      if value:
        item_txt = '%s%s = %s' % (prefix, child.GetName(), value)
      else:
        item_txt = '%s%s' % (prefix, child.GetName())
      enumlist.append('%s  %s' % (comment_txt, item_txt))
    self.LogExit('Exit DefineEnum')

    if unnamed:
      out = '%s\n%s\n};\n' % (out, ',\n'.join(enumlist))
    else:
      out = '%s\n%s\n} %s;\n' % (out, ',\n'.join(enumlist), name)
    return out

  def DefineMember(self, node, prefix='', comment=False):
    self.LogEnter('DefineMember %s' % node)

#    out = ''
#    if comment:
#      for doc in node.GetListOf('Comment'):
#        out += self.Comment(doc)
    out = '%s;' % self.GetSignature(node, 'store', '', True)
    self.LogExit('Exit DefineMember')
    return out

  # Define a Struct.
  def DefineStruct(self, node, prefix='', comment=False):
    out = ''
    if node.IsA('Interface'):
      release = 'M14'
      name = node.GetName()
      macro = node.GetProperty('macro')
      if not macro:
        macro = self.GetMacro(node)
      label = node.GetLabel()
      if label:
        for vers in label.versions:
          strver = str(vers).replace('.', '_')
          out += self.GetDefine('%s_%s' % (macro, strver),
                                '"%s;%s"' % (name, vers))
          if label.GetRelease(vers) == release:
            out += self.GetDefine(macro, '%s_%s' % (macro, strver))
        out += '\n'

    self.LogEnter('DefineStruct %s' % node)
    if node.GetProperty('union'):
      out += 'union %s%s {\n' % (prefix, node.GetName())
    else:
      out += 'struct %s%s {\n' % (prefix, node.GetName())

    # Generate Member Functions
    members = []
    for child in node.GetListOf('Member'):
      member = self.Define(child, tabs=1, comment=comment)
      if not member:
        continue
      members.append(member)
    out += '%s\n};\n' % '\n'.join(members)
    self.LogExit('Exit DefineStruct')
    return out

  def DefineType(self, node, prefix='', comment=False):
    return ''

  #
  # Copyright and Comment
  #
  # Generate a comment or copyright block
  #
  def Copyright(self, node, tabs=0):
    lines = node.GetName().split('\n')
    return self.CommentLines(lines, tabs)

  def Comment(self, node, prefix=None, tabs=0):
    comment = node.GetName()

    # Ignore comments that do not have a '*' marker
#    if comment[0] != '*' and not prefix: return ''

    lines = comment.split('\n')
    if prefix:
      prefix = prefix.split('\n')
      if prefix[0] == '*' and lines[0] == '*':
        lines = prefix + lines[1:]
      else:
        lines = prefix + lines;
    return self.CommentLines(lines, tabs)

  def CommentLines(self, lines, tabs=0):
    tab = ''.join(['  ' for i in range(tabs)])
    if lines[-1] == '':
      return '%s/*' % tab + ('\n%s *' % tab).join(lines) + '/\n'
    else:
      return '%s/*' % tab + ('\n%s *' % tab).join(lines) + ' */\n'


  # Define a top level object.
  def Define(self, node, tabs=0, prefix='', comment=False):
    if True:
#    try:
      self.LogEnter('Define %s tab=%d prefix="%s"' % (node,tabs,prefix))

      node_nim = node.GetProperty('version')
      node_max = node.GetProperty('deprecate')

      if node_nim is not None:
        node_nim = float(node_nim)
      else:
        node_nim = 0.0

      if node_max is not None:
        node_max = float(node_max)
      else:
        node_max = 1.0e100

      label = node.GetLabel()
      if label:
        lver = label.GetVersion('M14')

        # Verify that we are in a valid version.
        if node_max <= lver: return ''
        if node_nim > lver: return ''

      declmap = {
        'Describe' : CGen.DefineType,
        'Enum' : CGen.DefineEnum,
        'Function' : CGen.DefineMember,
        'Interface' : CGen.DefineStruct,
        'Member' : CGen.DefineMember,
        'Struct' : CGen.DefineStruct,
        'Type' : CGen.DefineType,
        'Typedef' : CGen.DefineTypedef,
      }

      if node.cls == 'Inline':
        return node.GetProperty('VALUE')

      if node.cls == 'Label':
        return ''

      out = ''
      comment_txt = ''
      if comment:
        for doc in node.GetListOf('Comment'):
          comment_txt += self.Comment(doc)

      func = declmap.get(node.cls)
      if not func:
        ErrOut.Log('Failed to define %s named %s' % (node.cls, node.GetName()))

      define_txt = func(self, node, prefix=prefix, comment=comment)
      if comment_txt:
        out += '%s%s' % (comment_txt, define_txt)
      else:
        out += define_txt

      tab = ''
      for i in range(tabs):
        tab += '  '

      lines = []
      for line in out.split('\n'):
        # Add indentation
        line = '%s%s' % (tab, line)
        if len(line) > 80:
          left = line.rfind('(') + 1
          args = line[left:].split(',')
          line_max = 0
          for arg in args:
            if len(arg) > line_max: line_max = len(arg)

          if left + line_max >= 80:
            space = '%s    ' % tab
            args =  (',\n%s' % space).join([arg.strip() for arg in args])
            lines.append('%s\n%s%s' % (line[:left], space, args))
          else:
            space = ' '.join(['' for i in range(left)])
            args =  (',\n%s' % space).join(args)
            lines.append('%s%s' % (line[:left], args))
        else:
          lines.append(line.rstrip())

  #    out = tab + ('\n%s' % tab).join(out.split('\n')) + '\n'
      self.LogExit('Exit Define')
      return '\n'.join(lines)
#    except:
    if False:
      node.Error('Failed to resolve.')
      return ''

# Clean a string representing an object definition and return then string
# as a single space delimited set of tokens.
def CleanString(instr):
  instr = instr.strip()
  instr = instr.split()
  return ' '.join(instr)


# Test a file, by comparing all it's objects, with their comments.
def TestFile(filenode):
  cgen = CGen()

  errors = 0
  for node in filenode.GetChildren()[2:]:
    instr = node.GetOneOf('Comment')
    if not instr: continue
    instr.Dump()
    instr = CleanString(instr.GetName())

    outstr = cgen.Define(node)
    if GetOption('verbose'):
      print outstr + '\n'
    outstr = CleanString(outstr)

    if instr != outstr:
      ErrOut.Log('Failed match of\n>>%s<<\n>>%s<<\nto:' % (instr, outstr))
      node.Dump(1, comments=True)
      errors += 1
  return errors


# Build and resolve the AST and compare each file individual.
def TestFiles(filenames):
  if not filenames:
    idldir = os.path.split(sys.argv[0])[0]
    idldir = os.path.join(idldir, 'test_cgen', '*.idl')
    filenames = glob.glob(idldir)

  filenames = sorted(filenames)
  ast = ParseFiles(filenames)

  total_errs = 0
  for filenode in ast.GetListOf('File'):
    errs = TestFile(filenode)
    if errs:
      ErrOut.Log('%s test failed with %d error(s).' %
                 (filenode.GetName(), errs))
      total_errs += errs

  if total_errs:
    ErrOut.Log('Failed generator test.')
  else:
    InfoOut.Log('Passed generator test.')
  return total_errs

def Main(args):
  filenames = ParseOptions(args)
  if GetOption('test'):
    return TestFiles(filenames)
  ast = ParseFiles(filenames)
  for f in ast.GetListOf('File'):
    if f.GetProperty('ERRORS') > 0:
      print 'Skipping %s' % f.GetName()
      continue
    print DefineDepends(node)
    for node in f.GetChildren()[2:]:
      print Define(node, comment=True, prefix='tst_')


if __name__ == '__main__':
  sys.exit(Main(sys.argv[1:]))