path: root/chromium/ppapi/native_client/src/tools/srpcgen.py

#!/usr/bin/env python
# Copyright (c) 2012 The Native Client Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Build "SRPC" interfaces from specifications.

SRPC interfaces consist of one or more interface classes, typically defined
in a set of .srpc files.  The specifications are Python dictionaries, with a
top level 'name' element and an 'rpcs' element.  The rpcs element is a list
containing a number of rpc methods, each of which has a 'name', an 'inputs',
and an 'outputs' element.  These elements are lists of input or output
parameters, which are lists pairs containing a name and type.  The set of
types includes all the SRPC basic types.

These SRPC specifications are used to generate a header file and either a
server or client stub file, as determined by the command line flag -s or -c.
"""

import getopt
import sys
import os

COPYRIGHT_AND_AUTOGEN_COMMENT = """\
// Copyright (c) 2012 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.
//
// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
//
// Automatically generated code.  See srpcgen.py
//
// NaCl Simple Remote Procedure Call interface abstractions.
"""

HEADER_INCLUDE_GUARD_START = """\
#ifndef %(include_guard)s
#define %(include_guard)s
"""

HEADER_INCLUDE_GUARD_END = """\
\n\n#endif  // %(include_guard)s
"""

HEADER_FILE_INCLUDES = """\
#ifndef __native_client__
#include "native_client/src/include/portability.h"
#endif  // __native_client__
%(EXTRA_INCLUDES)s
"""

SOURCE_FILE_INCLUDES = """\
#include "%(srpcgen_h)s"
#ifdef __native_client__
#ifndef UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P) do { (void) P; } while (0)
#endif  // UNREFERENCED_PARAMETER
#else
#include "native_client/src/include/portability.h"
#endif  // __native_client__
%(EXTRA_INCLUDES)s
"""

# For both .cc and .h files.
EXTRA_INCLUDES = [
  '#include "native_client/src/shared/srpc/nacl_srpc.h"',
]

types = {'bool': ['b', 'bool', 'u.bval', ''],
         'char[]': ['C', 'char*', 'arrays.carr', 'u.count'],
         'double': ['d', 'double', 'u.dval', ''],
         'double[]': ['D', 'double*', 'arrays.darr', 'u.count'],
         'handle': ['h', 'NaClSrpcImcDescType', 'u.hval', ''],
         'int32_t': ['i', 'int32_t', 'u.ival', ''],
         'int32_t[]': ['I', 'int32_t*', 'arrays.iarr', 'u.count'],
         'int64_t': ['l', 'int64_t', 'u.lval', ''],
         'int64_t[]': ['L', 'int64_t', 'arrays.larr', 'u.count'],
         'PP_Instance': ['i', 'PP_Instance', 'u.ival', ''],
         'PP_Module': ['i', 'PP_Module', 'u.ival', ''],
         'PP_Resource': ['i', 'PP_Resource', 'u.ival', ''],
         'string': ['s', 'const char*', 'arrays.str', ''],
        }

def AddInclude(name):
  """Adds an include to the include section of both .cc and .h files."""
  EXTRA_INCLUDES.append('#include "%s"' % name)


def HeaderFileIncludes():
  """Includes are sorted alphabetically."""
  EXTRA_INCLUDES.sort()
  return HEADER_FILE_INCLUDES % {
      'EXTRA_INCLUDES': '\n'.join(EXTRA_INCLUDES),
      }


def SourceFileIncludes(srpcgen_h_file):
  """Includes are sorted alphabetically."""
  EXTRA_INCLUDES.sort()
  return SOURCE_FILE_INCLUDES % {
      'EXTRA_INCLUDES': '\n'.join(EXTRA_INCLUDES),
      'srpcgen_h': srpcgen_h_file
      }


def PrintHeaderFileTop(output, include_guard):
  """Prints the header of the .h file including copyright,
     header comment, include guard and includes."""
  print >>output, COPYRIGHT_AND_AUTOGEN_COMMENT
  print >>output, HEADER_INCLUDE_GUARD_START % {'include_guard': include_guard}
  print >>output, HeaderFileIncludes()


def PrintHeaderFileBottom(output, include_guard):
  """Prints the footer of the .h file including copyright,
     header comment, include guard and includes."""
  print >>output, HEADER_INCLUDE_GUARD_END % {'include_guard': include_guard}


def PrintSourceFileTop(output, srpcgen_h_file):
  """Prints the header of the .cc file including copyright,
     header comment and includes."""
  print >>output, COPYRIGHT_AND_AUTOGEN_COMMENT
  print >>output, SourceFileIncludes(srpcgen_h_file)


def CountName(name):
  """Returns the name of the auxiliary count member used for array typed."""
  return '%s_bytes' % name


def FormatRpcPrototype(is_server, class_name, indent, rpc):
  """Returns a string for the prototype of an individual RPC."""

  def FormatArgs(is_output, args):
    """Returns a string containing the formatted arguments for an RPC."""

    def FormatArg(is_output, arg):
      """Returns a string containing a formatted argument to an RPC."""
      if is_output:
        suffix = '* '
      else:
        suffix = ' '
      s = ''
      type_info = types[arg[1]]
      if type_info[3]:
        s += 'nacl_abi_size_t%s%s, %s %s' % (suffix,
                                     CountName(arg[0]),
                                     type_info[1],
                                     arg[0])
      else:
        s += '%s%s%s' % (type_info[1], suffix, arg[0])
      return s
    s = ''
    for arg in args:
      s += ',\n    %s%s' % (indent, FormatArg(is_output, arg))
    return s
  if is_server:
    ret_type = 'void'
  else:
    ret_type = 'NaClSrpcError'
  s = '%s %s%s(\n' % (ret_type, class_name, rpc['name'])
  # Until SRPC uses RPC/Closure on the client side, these must be different.
  if is_server:
    s += '    %sNaClSrpcRpc* rpc,\n' % indent
    s += '    %sNaClSrpcClosure* done' % indent
  else:
    s += '    %sNaClSrpcChannel* channel' % indent
  s += '%s' % FormatArgs(False, rpc['inputs'])
  s += '%s' % FormatArgs(True, rpc['outputs'])
  s += ')'
  return  s


def PrintHeaderFile(output, is_server, guard_name, interface_name, specs):
  """Prints out the header file containing the prototypes for the RPCs."""
  PrintHeaderFileTop(output, guard_name)
  s = ''
  # iterate over all the specified interfaces
  if is_server:
    suffix = 'Server'
  else:
    suffix = 'Client'
  for spec in specs:
    class_name = spec['name'] + suffix
    rpcs = spec['rpcs']
    s += 'class %s {\n public:\n' % class_name
    for rpc in rpcs:
      s += '  static %s;\n' % FormatRpcPrototype(is_server, '', '  ', rpc)
    s += '\n private:\n  %s();\n' % class_name
    s += '  %s(const %s&);\n' % (class_name, class_name)
    s += '  void operator=(const %s);\n' % class_name
    s += '};  // class %s\n\n' % class_name
  if is_server:
    s += 'class %s {\n' % interface_name
    s += ' public:\n'
    s += '  static NaClSrpcHandlerDesc srpc_methods[];\n'
    s += '};  // class %s' % interface_name
  print >>output, s
  PrintHeaderFileBottom(output, guard_name)


def PrintServerFile(output, header_name, interface_name, specs):
  """Print the server (stub) .cc file."""

  def FormatDispatchPrototype(indent, rpc):
    """Format the prototype of a dispatcher method."""
    s = '%sstatic void %sDispatcher(\n' % (indent, rpc['name'])
    s += '%s    NaClSrpcRpc* rpc,\n' % indent
    s += '%s    NaClSrpcArg** inputs,\n' % indent
    s += '%s    NaClSrpcArg** outputs,\n' % indent
    s += '%s    NaClSrpcClosure* done\n' % indent
    s += '%s)' % indent
    return s

  def FormatMethodString(rpc):
    """Format the SRPC text string for a single rpc method."""

    def FormatTypes(args):
      s = ''
      for arg in args:
        s += types[arg[1]][0]
      return s
    s = '  { "%s:%s:%s", %sDispatcher },\n' % (rpc['name'],
                                               FormatTypes(rpc['inputs']),
                                               FormatTypes(rpc['outputs']),
                                               rpc['name'])
    return s

  def FormatCall(class_name, indent, rpc):
    """Format a call from a dispatcher method to its stub."""

    def FormatArgs(is_output, args):
      """Format the arguments passed to the stub."""

      def FormatArg(is_output, num, arg):
        """Format an argument passed to a stub."""
        if is_output:
          prefix = 'outputs[' + str(num) + ']->'
          addr_prefix = '&('
          addr_suffix = ')'
        else:
          prefix = 'inputs[' + str(num) + ']->'
          addr_prefix = ''
          addr_suffix = ''
        type_info = types[arg[1]]
        if type_info[3]:
          s = '%s%s%s%s, %s%s' % (addr_prefix,
                                  prefix,
                                  type_info[3],
                                  addr_suffix,
                                  prefix,
                                  type_info[2])
        else:
          s = '%s%s%s%s' % (addr_prefix, prefix, type_info[2], addr_suffix)
        return s
      # end FormatArg
      s = ''
      num = 0
      for arg in args:
        s += ',\n%s    %s' % (indent, FormatArg(is_output, num, arg))
        num += 1
      return s
    # end FormatArgs
    s = '%s::%s(\n%s    rpc,\n' % (class_name, rpc['name'], indent)
    s += '%s    done' % indent
    s += FormatArgs(False, rpc['inputs'])
    s += FormatArgs(True, rpc['outputs'])
    s += '\n%s)' % indent
    return s
  # end FormatCall

  PrintSourceFileTop(output, header_name)
  s = 'namespace {\n\n'
  for spec in specs:
    class_name = spec['name'] + 'Server'
    rpcs = spec['rpcs']
    for rpc in rpcs:
      s += '%s {\n' % FormatDispatchPrototype('', rpc)
      if rpc['inputs'] == []:
        s += '  UNREFERENCED_PARAMETER(inputs);\n'
      if rpc['outputs'] == []:
        s += '  UNREFERENCED_PARAMETER(outputs);\n'
      s += '  %s;\n' % FormatCall(class_name, '  ', rpc)
      s += '}\n\n'
  s += '}  // namespace\n\n'
  s += 'NaClSrpcHandlerDesc %s::srpc_methods[] = {\n' % interface_name
  for spec in specs:
    class_name = spec['name'] + 'Server'
    rpcs = spec['rpcs']
    for rpc in rpcs:
      s += FormatMethodString(rpc)
  s += '  { NULL, NULL }\n};\n'
  print >>output, s


def PrintClientFile(output, header_name, specs, thread_check):
  """Prints the client (proxy) .cc file."""

  def InstanceInputArg(rpc):
    """Returns the name of the PP_Instance arg or None if there is none."""
    for arg in rpc['inputs']:
      if arg[1] == 'PP_Instance':
        return arg[0]
    return None

  def DeadNexeHandling(rpc, retval):
    """Generates the code necessary to handle death of a nexe during the rpc
       call. This is only possible if PP_Instance arg is present, otherwise"""
    instance = InstanceInputArg(rpc);
    if instance is not None:
      check = ('  if (%s == NACL_SRPC_RESULT_INTERNAL)\n'
               '    ppapi_proxy::CleanUpAfterDeadNexe(%s);\n')
      return check % (retval, instance)
    return ''  # No handling


  def FormatCall(rpc):
    """Format a call to the generic dispatcher, NaClSrpcInvokeBySignature."""

    def FormatTypes(args):
      """Format a the type signature string for either inputs or outputs."""
      s = ''
      for arg in args:
        s += types[arg[1]][0]
      return s
    def FormatArgs(args):
      """Format the arguments for the call to the generic dispatcher."""

      def FormatArg(arg):
        """Format a single argument for the call to the generic dispatcher."""
        s = ''
        type_info = types[arg[1]]
        if type_info[3]:
          s += '%s, ' % CountName(arg[0])
        s += arg[0]
        return s
      # end FormatArg
      s = ''
      for arg in args:
        s += ',\n      %s' % FormatArg(arg)
      return s
    #end FormatArgs
    s = '(\n      channel,\n      "%s:%s:%s"' % (rpc['name'],
                                                 FormatTypes(rpc['inputs']),
                                                 FormatTypes(rpc['outputs']))
    s += FormatArgs(rpc['inputs'])
    s += FormatArgs(rpc['outputs']) + '\n  )'
    return s
  # end FormatCall

  # We need this to handle dead nexes.
  if header_name.startswith('trusted'):
    AddInclude('native_client/src/shared/ppapi_proxy/browser_globals.h')
  if thread_check:
    AddInclude('native_client/src/shared/ppapi_proxy/plugin_globals.h')
    AddInclude('ppapi/c/ppb_core.h')
    AddInclude('native_client/src/shared/platform/nacl_check.h')
  PrintSourceFileTop(output, header_name)
  s = ''

  for spec in specs:
    class_name = spec['name'] + 'Client'
    rpcs = spec['rpcs']
    for rpc in rpcs:
      s += '%s  {\n' % FormatRpcPrototype('', class_name + '::', '', rpc)
      if thread_check and rpc['name'] not in ['PPB_GetInterface',
                                              'PPB_Core_CallOnMainThread']:
        error = '"%s: PPAPI calls are not supported off the main thread\\n"'
        s += '  VCHECK(ppapi_proxy::PPBCoreInterface()->IsMainThread(),\n'
        s += '         (%s,\n' % error
        s += '          __FUNCTION__));\n'
      s += '  NaClSrpcError retval;\n'
      s += '  retval = NaClSrpcInvokeBySignature%s;\n' % FormatCall(rpc)
      if header_name.startswith('trusted'):
        s += DeadNexeHandling(rpc, 'retval')
      s += '  return retval;\n'
      s += '}\n\n'
  print >>output, s

def MakePath(name):
  paths = name.split(os.sep)
  path = os.sep.join(paths[:-1])
  try:
    os.makedirs(path)
  except OSError:
    return


def main(argv):
  usage = 'Usage: srpcgen.py <-c | -s> [--include=<name>] [--ppapi]'
  usage = usage + ' <iname> <gname> <.h> <.cc> <specs>'

  mode = None
  ppapi = False
  thread_check = False
  try:
    long_opts = ['include=', 'ppapi', 'thread-check']
    opts, pargs = getopt.getopt(argv[1:], 'cs', long_opts)
  except getopt.error, e:
    print >>sys.stderr, 'Illegal option:', str(e)
    print >>sys.stderr, usage
    return 1

  # Get the class name for the interface.
  interface_name = pargs[0]
  # Get the name for the token used as a multiple inclusion guard in the header.
  include_guard_name = pargs[1]
  # Get the name of the header file to be generated.
  h_file_name = pargs[2]
  MakePath(h_file_name)
  # Note we open output files in binary mode so that on Windows the files
  # will always get LF line-endings rather than CRLF.
  h_file = open(h_file_name, 'wb')
  # Get the name of the source file to be generated.  Depending upon whether
  # -c or -s is generated, this file contains either client or server methods.
  cc_file_name = pargs[3]
  MakePath(cc_file_name)
  cc_file = open(cc_file_name, 'wb')
  # The remaining arguments are the spec files to be compiled.
  spec_files = pargs[4:]

  for opt, val in opts:
    if opt == '-c':
      mode = 'client'
    elif opt == '-s':
      mode = 'server'
    elif opt == '--include':
      h_file_name = val
    elif opt == '--ppapi':
      ppapi = True
    elif opt == '--thread-check':
      thread_check = True

  if ppapi:
    AddInclude("ppapi/c/pp_instance.h")
    AddInclude("ppapi/c/pp_module.h")
    AddInclude("ppapi/c/pp_resource.h")

  # Convert to forward slash paths if needed
  h_file_name = "/".join(h_file_name.split("\\"))

  # Verify we picked server or client mode
  if not mode:
    print >>sys.stderr, 'Neither -c nor -s specified'
    usage()
    return 1

  # Combine the rpc specs from spec_files into rpcs.
  specs = []
  for spec_file in spec_files:
    code_obj = compile(open(spec_file, 'r').read(), 'file', 'eval')
    specs.append(eval(code_obj))
  # Print out the requested files.
  if mode == 'client':
    PrintHeaderFile(h_file, False, include_guard_name, interface_name, specs)
    PrintClientFile(cc_file, h_file_name, specs, thread_check)
  elif mode == 'server':
    PrintHeaderFile(h_file, True, include_guard_name, interface_name, specs)
    PrintServerFile(cc_file, h_file_name, interface_name, specs)

  return 0


if __name__ == '__main__':
  sys.exit(main(sys.argv))