def DefineMember(filenode, node, member, release, include_version, meta):
"""Returns a definition for a member function of an interface.
Args:
filenode - IDLNode for the file
node - IDLNode for the interface
member - IDLNode for the member function
release - release to generate
include_version - include the version in emitted function name.
meta - ThunkMetadata for header hints
Returns:
A string with the member definition.
"""
cgen = CGen()
rtype, name, arrays, args = cgen.GetComponents(member, release, 'return')
if _IsTypeCheck(node, member):
body = ' %s\n' % _MakeEnterLine(filenode, node, args[0], False, None, meta)
body += ' return PP_FromBool(enter.succeeded());'
elif member.GetName() == 'Create':
body = _MakeCreateMemberBody(node, member, args)
else:
body = _MakeNormalMemberBody(filenode, node, member, rtype, args, meta)
signature = cgen.GetSignature(member, release, 'return', func_as_ptr=False,
include_version=include_version)
member_code = '%s {\n%s\n}' % (signature, body)
return cgen.Indent(member_code, tabs=0)
def WriteTail(self, out, filenode, releases, options):
__pychecker__ = 'unusednames=options'
cgen = CGen()
version_list = []
out.Write('\n\n')
for node in filenode.GetListOf('Interface'):
build_list = node.GetUniqueReleases(releases)
for build in build_list:
version = node.GetVersion(build).replace('.', '_')
thunk_name = 'g_' + node.GetName().lower() + '_thunk_' + \
version
thunk_type = '_'.join((node.GetName(), version))
version_list.append((thunk_type, thunk_name))
declare_line = 'const %s %s = {' % (thunk_type, thunk_name)
if len(declare_line) > 80:
declare_line = 'const %s\n %s = {' % (thunk_type,
thunk_name)
out.Write('%s\n' % declare_line)
generated_functions = []
members = node.GetListOf('Member')
for child in members:
rtype, name, arrays, args = cgen.GetComponents(
child, build, 'return')
if child.InReleases([build]):
if not _IsNewestMember(child, members, releases):
version = child.GetVersion(
child.first_release[build]).replace('.', '_')
name += '_' + version
generated_functions.append(name)
out.Write(',\n'.join(
[' &%s' % f for f in generated_functions]))
out.Write('\n};\n\n')
out.Write('} // namespace\n')
out.Write('\n')
for thunk_type, thunk_name in version_list:
thunk_decl = ('PPAPI_THUNK_EXPORT const %s* Get%s_Thunk() {\n' %
(thunk_type, thunk_type))
if len(thunk_decl) > 80:
thunk_decl = (
'PPAPI_THUNK_EXPORT const %s*\n Get%s_Thunk() {\n' %
(thunk_type, thunk_type))
out.Write(thunk_decl)
out.Write(' return &%s;\n' % thunk_name)
out.Write('}\n')
out.Write('\n')
out.Write('} // namespace thunk\n')
out.Write('} // namespace ppapi\n')
def DefineMember(filenode, node, member, release, include_version, meta):
"""Returns a definition for a member function of an interface.
Args:
filenode - IDLNode for the file
node - IDLNode for the interface
member - IDLNode for the member function
release - release to generate
include_version - include the version in emitted function name.
meta - ThunkMetadata for header hints
Returns:
A string with the member definition.
"""
cgen = CGen()
rtype, name, arrays, args = cgen.GetComponents(member, release, 'return')
log_body = '\"%s::%s()\";' % (
node.GetName(), cgen.GetStructName(member, release, include_version))
if len(log_body) > 69: # Prevent lines over 80 characters.
body = 'VLOG(4) <<\n'
body += ' %s\n' % log_body
else:
body = 'VLOG(4) << %s\n' % log_body
if _IsTypeCheck(node, member, args):
body += '%s\n' % _MakeEnterLine(filenode, node, member, args[0], False,
None, meta)
body += 'return PP_FromBool(enter.succeeded());'
elif member.GetName() == 'Create' or member.GetName() == 'CreateTrusted':
body += _MakeCreateMemberBody(node, member, args)
else:
body += _MakeNormalMemberBody(filenode, release, node, member, rtype,
args, include_version, meta)
signature = cgen.GetSignature(member,
release,
'return',
func_as_ptr=False,
include_version=include_version)
return '%s\n%s\n}' % (cgen.Indent('%s {' % signature,
tabs=0), cgen.Indent(body, tabs=1))
def _GetOutputParams(member, release):
"""Returns output parameters (and their types) for a member function.
Args:
member - IDLNode for the member function
release - Release to get output parameters for
Returns:
A list of name strings for all output parameters of the member
function.
"""
out_params = []
callnode = member.GetOneOf('Callspec')
if callnode:
cgen = CGen()
for param in callnode.GetListOf('Param'):
mode = cgen.GetParamMode(param)
if mode == 'out':
# We use the 'store' mode when getting the parameter type, since we
# need to call sizeof() for memset().
_, pname, _, _ = cgen.GetComponents(param, release, 'store')
out_params.append(pname)
return out_params
def WriteTail(self, out, filenode, releases, options):
__pychecker__ = 'unusednames=options'
cgen = CGen()
version_list = []
out.Write('\n\n')
for node in filenode.GetListOf('Interface'):
build_list = node.GetUniqueReleases(releases)
for build in build_list:
version = node.GetVersion(build).replace('.', '_')
thunk_name = 'g_' + node.GetName().lower() + '_thunk_' + \
version
thunk_type = '_'.join((node.GetName(), version))
version_list.append((thunk_type, thunk_name))
out.Write('const %s %s = {\n' % (thunk_type, thunk_name))
for child in node.GetListOf('Member'):
rtype, name, arrays, args = cgen.GetComponents(
child, build, 'return')
if child.InReleases([build]): # TEST
out.Write(' &%s,\n' % name)
out.Write('};\n\n')
out.Write('} // namespace\n')
out.Write('\n')
for thunk_type, thunk_name in version_list:
thunk_decl = 'const %s* Get%s_Thunk() {\n' % (thunk_type,
thunk_type)
if len(thunk_decl) > 80:
thunk_decl = 'const %s*\n Get%s_Thunk() {\n' % (thunk_type,
thunk_type)
out.Write(thunk_decl)
out.Write(' return &%s;\n' % thunk_name)
out.Write('}\n')
out.Write('\n')
out.Write('} // namespace thunk\n')
out.Write('} // namespace ppapi\n')
class PnaclGen(WrapperGen):
"""PnaclGen generates shim code to bridge the Gcc ABI with PNaCl.
This subclass of WrapperGenerator takes the IDL sources and
generates shim methods for bridging the calling conventions between GCC
and PNaCl (LLVM). Some of the PPAPI methods do not need shimming, so
this will also detect those situations and provide direct access to the
original PPAPI methods (rather than the shim methods).
"""
def __init__(self):
WrapperGen.__init__(self, 'Pnacl', 'Pnacl Shim Gen', 'pnacl',
'Generate the PNaCl shim.')
self.cgen = CGen()
self._skip_opt = False
############################################################
def OwnHeaderFile(self):
"""Return the header file that specifies the API of this wrapper.
We do not generate the header files. """
return 'ppapi/generators/pnacl_shim.h'
def InterfaceVersionNeedsWrapping(self, iface, version):
"""Return true if the interface+version has ANY methods that
need wrapping.
"""
if self._skip_opt:
return True
for member in iface.GetListOf('Member'):
release = member.GetRelease(version)
if self.MemberNeedsWrapping(member, release):
return True
return False
def MemberNeedsWrapping(self, member, release):
"""Return true if a particular member function at a particular
release needs wrapping.
"""
if self._skip_opt:
return True
if not member.InReleases([release]):
return False
ret, name, array, args_spec = self.cgen.GetComponents(
member, release, 'store')
return self.TypeNeedsWrapping(ret,
[]) or self.ArgsNeedWrapping(args_spec)
def ArgsNeedWrapping(self, args):
"""Return true if any parameter in the list needs wrapping.
"""
for arg in args:
(type_str, name, array_dims, more_args) = arg
if self.TypeNeedsWrapping(type_str, array_dims):
return True
return False
def TypeNeedsWrapping(self, type_node, array_dims):
"""Return true if a parameter type needs wrapping.
Currently, this is true for byval aggregates.
"""
is_aggregate = type_node.startswith('struct') or \
type_node.startswith('union')
is_reference = (type_node.find('*') != -1 or array_dims != [])
return is_aggregate and not is_reference
############################################################
def ConvertByValueReturnType(self, ret, args_spec):
if self.TypeNeedsWrapping(ret, array_dims=[]):
args_spec = [(ret, '_struct_result', [], None)] + args_spec
ret2 = 'void'
wrap_return = True
else:
ret2 = ret
wrap_return = False
return wrap_return, ret2, args_spec
def ConvertByValueArguments(self, args_spec):
args = []
for type_str, name, array_dims, more_args in args_spec:
if self.TypeNeedsWrapping(type_str, array_dims):
type_str += '*'
args.append((type_str, name, array_dims, more_args))
return args
def FormatArgs(self, c_operator, args_spec):
args = []
for type_str, name, array_dims, more_args in args_spec:
if self.TypeNeedsWrapping(type_str, array_dims):
args.append(c_operator + name)
else:
args.append(name)
return ', '.join(args)
def GenerateWrapperForPPBMethod(self, iface, member):
result = []
func_prefix = self.WrapperMethodPrefix(iface.node, iface.release)
ret, name, array, cspec = self.cgen.GetComponents(
member, iface.release, 'store')
wrap_return, ret2, cspec2 = self.ConvertByValueReturnType(ret, cspec)
cspec2 = self.ConvertByValueArguments(cspec2)
sig = self.cgen.Compose(ret2,
name,
array,
cspec2,
prefix=func_prefix,
func_as_ptr=False,
include_name=True,
unsized_as_ptr=False)
result.append('static %s {\n' % sig)
result.append(' const struct %s *iface = %s.real_iface;\n' %
(iface.struct_name, self.GetWrapperInfoName(iface)))
return_prefix = ''
if wrap_return:
return_prefix = '*_struct_result = '
elif ret != 'void':
return_prefix = 'return '
result.append(
' %siface->%s(%s);\n}\n\n' %
(return_prefix, member.GetName(), self.FormatArgs('*', cspec)))
return result
def GenerateWrapperForPPPMethod(self, iface, member):
result = []
func_prefix = self.WrapperMethodPrefix(iface.node, iface.release)
sig = self.cgen.GetSignature(member, iface.release, 'store',
func_prefix, False)
result.append('static %s {\n' % sig)
result.append(' const struct %s *iface = %s.real_iface;\n' %
(iface.struct_name, self.GetWrapperInfoName(iface)))
ret, name, array, cspec = self.cgen.GetComponents(
member, iface.release, 'store')
wrap_return, ret2, cspec = self.ConvertByValueReturnType(ret, cspec)
cspec2 = self.ConvertByValueArguments(cspec)
temp_fp = self.cgen.Compose(ret2,
name,
array,
cspec2,
prefix='temp_fp',
func_as_ptr=True,
include_name=False,
unsized_as_ptr=False)
cast = self.cgen.Compose(ret2,
name,
array,
cspec2,
prefix='',
func_as_ptr=True,
include_name=False,
unsized_as_ptr=False)
result.append(' %s =\n ((%s)iface->%s);\n' %
(temp_fp, cast, member.GetName()))
return_prefix = ''
if wrap_return:
result.append(' %s _struct_result;\n' % ret)
elif ret != 'void':
return_prefix = 'return '
result.append(' %stemp_fp(%s);\n' %
(return_prefix, self.FormatArgs('&', cspec)))
if wrap_return:
result.append(' return _struct_result;\n')
result.append('}\n\n')
return result
def GenerateRange(self, ast, releases, options):
"""Generate shim code for a range of releases.
"""
self._skip_opt = GetOption('disable_pnacl_opt')
self.SetOutputFile(GetOption('pnaclshim'))
return WrapperGen.GenerateRange(self, ast, releases, options)
class PepperGen(WrapperGen):
"""PepperGen generates code entry points for C# PInvoking API.
This subclass of WrapperGenerator takes the IDL sources and
generates the DLL PInvoke entryp points between C# and the
the Native C++ PepperPlugin.
"""
def __init__(self):
WrapperGen.__init__(self, 'Pepper', 'Pepper Gen', 'pepper',
'Generate the Pepper DLL export.')
self.cgen = CGen()
self._skip_opt = False
self._skip_region_gen = False
#
# RemapParameter
#
# A diction array of parameter types that need to be remappted
#
RemapParameter = {
# 'struct PP_Var*': 'const char*',
}
#
# WrapArgument
#
# A diction array of parameter types that need to be wrapped
#
WrapArgument = {
'struct PP_Var': '%s',
'struct PP_CompletionCallback': '%s',
'struct PP_ArrayOutput': '%s'
}
#
# WrapReturn
#
# A diction array of parameter types that need to be wrapped
#
WrapReturn = {
# 'struct PP_Var': 'Var(%s).AsString().c_str()'
}
#
# ExcludeInterface
#
# A dictionary of interfaces that we will not generate for
#
ExcludeInterface = ['PPB_Audio_1_0']
############################################################
def OwnHeaderFile(self):
"""Return the header file that specifies the API of this wrapper.
We do not generate the header files. """
return 'pepper_entrypoints.h'
def WriteCopyright(self, out):
now = datetime.now()
c = """/* Copyright (c) %s Xamarin. */
/* NOTE: this is auto-generated from IDL */
""" % now.year
out.Write(c)
def GenerateHelperFunctions(self, out):
"""Generate helper functions.
"""
out.Write("""#ifndef PEPPER_EXPORT
#define PEPPER_EXPORT __declspec(dllexport)
#endif
using namespace pp;
namespace Pepper {
namespace {
// Specialize this function to return the interface string corresponding to the
// PP?_XXX structure.
template <typename T> const char* interface_name() {
return NULL;
}
template <typename T> inline T const* get_interface() {
static T const* funcs = reinterpret_cast<T const*>(
pp::Module::Get()->GetBrowserInterface(interface_name<T>()));
return funcs;
}
template <typename T> inline bool has_interface() {
return get_interface<T>() != NULL;
}
}
}
""")
def GenerateFixedFunctions(self, out):
"""Write out the set of constant functions (those that do not depend on
the current Pepper IDL).
"""
def InterfaceVersionNeedsWrapping(self, iface, version):
"""Return true if the interface+version has ANY methods that
need wrapping.
"""
if self._skip_opt:
return True
if iface.GetName().endswith('Trusted'):
return False
# TODO(dmichael): We have no way to wrap PPP_ interfaces without an
# interface string. If any ever need wrapping, we'll need to figure out a
# way to get the plugin-side of the Pepper proxy (within the IRT) to access
# and use the wrapper.
if iface.GetProperty("no_interface_string"):
return False
for member in iface.GetListOf('Member'):
release = member.GetRelease(version)
if self.MemberNeedsWrapping(member, release):
return True
return False
def MemberNeedsWrapping(self, member, release):
"""Return true if a particular member function at a particular
release needs wrapping.
"""
if self._skip_opt:
return True
if not member.InReleases([release]):
return False
ret, name, array, args_spec = self.cgen.GetComponents(
member, release, 'store')
return self.TypeNeedsWrapping(ret,
[]) or self.ArgsNeedWrapping(args_spec)
def ArgsNeedWrapping(self, args):
"""Return true if any parameter in the list needs wrapping.
"""
for arg in args:
(type_str, name, array_dims, more_args) = arg
if self.TypeNeedsWrapping(type_str, array_dims):
return True
# we always return true here so all interfaces are generated
return True
def TypeNeedsWrapping(self, type_node, array_dims):
"""Return true if a parameter type needs wrapping.
Currently, this is true for byval aggregates.
"""
#is_aggregate = type_node.startswith('struct') or \
# type_node.startswith('union')
is_aggregate = type_node.startswith('union')
is_reference = (type_node.find('*') != -1 or array_dims != [])
return is_aggregate and not is_reference
############################################################
def ConvertByValueReturnType(self, ret, args_spec):
if self.TypeNeedsWrapping(ret, array_dims=[]):
args_spec = [(ret, '_struct_result', [], None)] + args_spec
ret2 = 'void'
wrap_return = True
else:
ret2 = ret
wrap_return = False
return wrap_return, ret2, args_spec
def ConvertByValueArguments(self, args_spec):
args = []
for type_str, name, array_dims, more_args in args_spec:
if self.TypeNeedsWrapping(type_str, array_dims):
type_str += '*'
args.append((type_str, name, array_dims, more_args))
return args
def FormatArgs(self, c_operator, args_spec):
args = []
for type_str, name, array_dims, more_args in args_spec:
if self.TypeNeedsWrapping(type_str, array_dims):
if type_str in PepperGen.WrapArgument:
args.append(PepperGen.WrapArgument[type_str] % name)
else:
args.append(c_operator + name)
else:
if type_str in PepperGen.WrapArgument:
args.append(PepperGen.WrapArgument[type_str] % name)
else:
if type_str.startswith(
'struct ') and type_str.rfind('*') < 0:
args.append('&%s' % name)
else:
args.append(name)
return ', '.join(args)
def GenerateWrapperForMethodGroup(self, iface_releases, comments=True):
result = []
if len(iface_releases) == 0:
return ''
iface = iface_releases[len(iface_releases) - 1]
if not iface.needs_wrapping:
if comments:
result.append(
'/* Not generating entry point methods for %s */\n\n' %
iface.struct_name)
return ''.join(result)
if self._skip_region_gen:
result.append('\t\t/* Begin entry point methods for %s */\n\n' %
iface.node.GetName())
else:
result.append(
'\t\t#pragma region /* Begin entry point methods for %s */\n\n'
% iface.node.GetName())
generator = PPKind.ChoosePPFunc(
iface, self.GenerateWrapperForPPBMethodReleases,
self.GenerateWrapperForPPPMethodReleases)
for member in iface.node.GetListOf('Member'):
# Skip the method if it's not actually in the release.
if not member.InReleases([iface.release]):
continue
result.extend(generator(iface, member, iface_releases))
if comments:
if self._skip_region_gen:
result.append(
'\t\t/* End entry point generation for %s */\n\n' %
iface.node.GetName())
else:
result.append(
'\t\t#pragma endregion /* End entry point generation for %s */\n\n'
% iface.node.GetName())
return ''.join(result)
def GenerateWrapperForMethods(self, iface_releases, comments=True):
"""Return a string representing the code for each wrapper method
(using a string rather than writing to the file directly for testing.)
"""
result = []
result.append("""namespace Pepper {
/* We don't want name mangling for these external functions. We only need
* 'extern "C"' if we're compiling with a C++ compiler.
*/
#ifdef __cplusplus
extern "C" {
#endif
namespace {\n\n""")
iface_release_group = []
rangeName = iface_releases[0].node.GetName()
for x in range(len(iface_releases)):
if iface_releases[x].node.GetName() == rangeName:
iface_release_group.append(iface_releases[x])
else:
print("Generating entry points for %s for %d release(s)." %
(rangeName, len(iface_release_group)))
result.append(
self.GenerateWrapperForMethodGroup(iface_release_group,
comments))
rangeName = iface_releases[x].node.GetName()
iface_release_group = []
iface_release_group.append(iface_releases[x])
print("Generating entry points for %s for %d release(s)." %
(rangeName, len(iface_release_group)))
if len(iface_release_group) > 0:
result.append(
self.GenerateWrapperForMethodGroup(iface_release_group,
comments))
result.append(""" }
#ifdef __cplusplus
} /* extern "C" */
#endif
}\n""")
return ''.join(result)
def WrapperMethodPrefix(self, iface, release):
return '%s_' % (iface.GetName())
def Compose(self, rtype, name, arrayspec, callspec, prefix, func_as_ptr,
include_name, unsized_as_ptr):
self.cgen.LogEnter('Compose: %s %s' % (rtype, name))
arrayspec = ''.join(arrayspec)
# Switch unsized array to a ptr. NOTE: Only last element can be unsized.
if unsized_as_ptr and arrayspec[-2:] == '[]':
prefix += '*'
arrayspec = arrayspec[:-2]
if not include_name:
name = prefix + arrayspec
else:
name = prefix + name + arrayspec
if callspec is None:
if rtype in PepperGen.RemapParameter:
rtype = PepperGen.RemapParameter[rtype]
out = '%s %s' % (rtype, name)
else:
params = []
for ptype, pname, parray, pspec in callspec:
params.append(
self.Compose(ptype,
pname,
parray,
pspec,
'',
True,
include_name=True,
unsized_as_ptr=unsized_as_ptr))
if func_as_ptr:
name = '(*%s)' % name
if not params:
params = ['void']
out = '%s %s(%s)' % (rtype, name, ', '.join(params))
self.cgen.LogExit('Exit Compose: %s' % out)
return out
def GenerateWrapperForPPBMethodReleases(self, iface, member,
iface_releases):
result = []
func_prefix = self.WrapperMethodPrefix(iface.node, iface.release)
if func_prefix == 'PPB_Graphics2D_':
func_prefix = func_prefix
ret, name, array, cspec = self.cgen.GetComponents(
member, iface.release, 'store')
wrap_return, ret2, cspec2 = self.ConvertByValueReturnType(ret, cspec)
cspec2 = self.ConvertByValueArguments(cspec2)
if ret2 in PepperGen.RemapParameter:
ret2 = PepperGen.RemapParameter[ret2]
sig = self.Compose(ret2,
name,
array,
cspec2,
prefix=func_prefix,
func_as_ptr=False,
include_name=True,
unsized_as_ptr=False)
result.append('\t\tPEPPER_EXPORT %s {\n' % sig)
return_prefix = ''
if wrap_return:
return_prefix = ''
elif ret != 'void':
return_prefix = 'return '
first = True
for iface_release in reversed(iface_releases):
# Skip the method if it's not actually in the release.
if not member.InReleases([iface_release.release]):
continue
if self.GetWrapperInfoName(
iface_release) in PepperGen.ExcludeInterface:
continue
if first:
result.append('\t\t\tif (has_interface<%s>()) {\n' %
self.GetWrapperInfoName(iface_release))
result.append(
'\t\t\t\t%sget_interface<%s>()->%s(%s);\n' %
(return_prefix, self.GetWrapperInfoName(iface_release),
member.GetName(), self.FormatArgs('*', cspec)))
result.append('\t\t\t}\n')
first = False
else:
result.append('\t\t\telse if (has_interface<%s>()) {\n' %
self.GetWrapperInfoName(iface_release))
result.append(
'\t\t\t\t%sget_interface<%s>()->%s(%s);\n' %
(return_prefix, self.GetWrapperInfoName(iface_release),
member.GetName(), self.FormatArgs('*', cspec)))
result.append('\t\t\t}\n')
dfltValue = ''
if ret2 in RemapDefaultValue:
dfltValue = RemapDefaultValue[ret2]
else:
dfltValue = "NULL"
result.append('\t\t\treturn %s;\n\t\t}\n\n' % dfltValue)
return result
def GenerateWrapperForPPPMethodReleases(self, iface, member,
iface_releases):
# We just call the PPB code from here unless something changes.
return self.GenerateWrapperForPPBMethodReleases(
iface, member, iface_releases)
def DeclareWrapperInfos(self, iface_releases, out):
"""The wrapper methods usually need access to the real_iface, so we must
declare these wrapper infos ahead of time (there is a circular dependency).
"""
out.Write(
'/* BEGIN Declarations for all Interface Definitions. */\n\n')
out.Write('namespace Pepper {\n\tnamespace {\n')
for iface in iface_releases:
if iface.needs_wrapping:
out.Write(
"""\t\ttemplate <> const char* interface_name<%s>() {\n\t\t\treturn %s;\n\t\t}\n"""
% (self.GetWrapperInfoName(iface),
self.cgen.GetInterfaceMacro(iface.node, iface.version)))
out.Write('\t}\n}\n')
out.Write('/* END Declarations for all Interface Definitions. */\n\n')
def GetWrapperInfoName(self, iface):
return '%s' % (iface.struct_name)
def GetWrapperMetadataName(self):
return '__%sWrapperInfo' % self.wrapper_prefix
def GenerateWrapperInfoAndCollection(self, iface_releases, out):
"""Do not generate this as it is not needed"""
def GenerateWrapperInterfaces(self, iface_releases, out):
"""Do not generate this as it is not needed"""
def GenerateRange(self, ast, releases, options):
"""Generate entry point code for a range of releases.
"""
self._skip_opt = GetOption('disable_pepper_opt')
self._skip_region_gen = GetOption('disable_region_gen')
self.SetOutputFile(GetOption('pepperfile'))
return WrapperGen.GenerateRange(self, ast, releases, options)
class PnaclGen(WrapperGen):
"""PnaclGen generates shim code to bridge the Gcc ABI with PNaCl.
This subclass of WrapperGenerator takes the IDL sources and
generates shim methods for bridging the calling conventions between GCC
and PNaCl (LLVM). Some of the PPAPI methods do not need shimming, so
this will also detect those situations and provide direct access to the
original PPAPI methods (rather than the shim methods).
"""
def __init__(self):
WrapperGen.__init__(self,
'Pnacl',
'Pnacl Shim Gen',
'pnacl',
'Generate the PNaCl shim.')
self.cgen = CGen()
self._skip_opt = False
self._pnacl_attribute = '__attribute__((pnaclcall))'
############################################################
def OwnHeaderFile(self):
"""Return the header file that specifies the API of this wrapper.
We do not generate the header files. """
return 'ppapi/generators/pnacl_shim.h'
def InterfaceNeedsWrapper(self, iface, releases):
"""Return true if the interface has ANY methods that need wrapping.
"""
if self._skip_opt:
return True
for release in iface.GetUniqueReleases(releases):
version = iface.GetVersion(release)
if self.InterfaceVersionNeedsWrapping(iface, version):
return True
return False
def InterfaceVersionNeedsWrapping(self, iface, version):
"""Return true if the interface+version has ANY methods that
need wrapping.
"""
if self._skip_opt:
return True
for member in iface.GetListOf('Member'):
release = member.GetRelease(version)
if self.MemberNeedsWrapping(member, release):
return True
return False
def MemberNeedsWrapping(self, member, release):
"""Return true if a particular member function at a particular
release needs wrapping.
"""
if self._skip_opt:
return True
if not member.InReleases([release]):
return False
ret, name, array, args_spec = self.cgen.GetComponents(member,
release,
'store')
return self.TypeNeedsWrapping(ret, []) or self.ArgsNeedWrapping(args_spec)
def ArgsNeedWrapping(self, args):
"""Return true if any parameter in the list needs wrapping.
"""
for arg in args:
(type_str, name, array_dims, more_args) = arg
if self.TypeNeedsWrapping(type_str, array_dims):
return True
return False
def TypeNeedsWrapping(self, type_node, array_dims):
"""Return true if a parameter type needs wrapping.
Currently, this is true for byval aggregates.
"""
is_aggregate = type_node.startswith('struct') or \
type_node.startswith('union')
is_reference = (type_node.find('*') != -1 or array_dims != [])
return is_aggregate and not is_reference
############################################################
def GenerateWrapperForPPBMethod(self, iface, member):
result = []
func_prefix = self.WrapperMethodPrefix(iface.node, iface.release)
sig = self.cgen.GetSignature(member, iface.release, 'store',
func_prefix, False)
result.append('static %s\n%s {\n' % (self._pnacl_attribute, sig))
result.append(' const struct %s *iface = %s.real_iface;\n' %
(iface.struct_name, self.GetWrapperInfoName(iface)))
ret, name, array, cspec = self.cgen.GetComponents(member,
iface.release,
'store')
ret_str, args_str = self.GetReturnArgs(ret, cspec)
result.append(' %siface->%s(%s);\n}\n\n' % (ret_str,
member.GetName(), args_str))
return result
def GenerateWrapperForPPPMethod(self, iface, member):
result = []
func_prefix = self.WrapperMethodPrefix(iface.node, iface.release)
sig = self.cgen.GetSignature(member, iface.release, 'store',
func_prefix, False)
result.append('static %s {\n' % sig)
result.append(' const struct %s *iface = %s.real_iface;\n' %
(iface.struct_name, self.GetWrapperInfoName(iface)))
temp_fp = self.cgen.GetSignature(member, iface.release, 'return',
'temp_fp',
func_as_ptr=True,
ptr_prefix=self._pnacl_attribute + ' ',
include_name=False)
cast = self.cgen.GetSignature(member, iface.release, 'return',
prefix='',
func_as_ptr=True,
ptr_prefix=self._pnacl_attribute + ' ',
include_name=False)
result.append(' %s = ((%s)iface->%s);\n' % (temp_fp,
cast,
member.GetName()))
ret, name, array, cspec = self.cgen.GetComponents(member,
iface.release,
'store')
ret_str, args_str = self.GetReturnArgs(ret, cspec)
result.append(' %stemp_fp(%s);\n}\n\n' % (ret_str, args_str))
return result
def GenerateRange(self, ast, releases, options):
"""Generate shim code for a range of releases.
"""
self._skip_opt = GetOption('disable_pnacl_opt')
self.SetOutputFile(GetOption('pnaclshim'))
return WrapperGen.GenerateRange(self, ast, releases, options)
class RPCGen(object):
def __init__(self):
self.cgen = CGen()
self.interfaceStructs = []
self.pppInterfaceGetters = []
def AddProp(self,
release,
s,
prefix,
member,
isOutParam=False,
callnode=None,
derefSizeIs=True):
out = ''
key = member.GetName()
if not member.InReleases([release]):
out += '/* skipping %s */\n' % key
return
type = member.GetType(release).GetName()
array = member.GetOneOf('Array')
interfaceMember = member.parent
interface = interfaceMember.parent.parent
customSerializer = getCustom(interface.GetName(),
interfaceMember.GetName(),
member.GetName())
array = customSerializer.get('array', array)
isOutParam = customSerializer.get('isOutParam', isOutParam)
if isOutParam:
out += ' AddProp(' + s + ', "' + key + '", PointerToString(' + prefix + key + '));\n'
elif array:
if customSerializer:
type = customSerializer.get('arrayType', type)
count = array.GetProperty('FIXED') if isinstance(array,
IDLNode) else None
if not count:
size_is = member.GetProperty('size_is()')
if size_is:
size_is = size_is[0]
count = prefix + size_is
if callnode:
for param in callnode.GetListOf('Param'):
if param.GetName() == size_is:
if self.cgen.GetParamMode(
param) == 'out' and derefSizeIs:
count = '*' + count
break
else:
size_as = member.GetProperty('size_as')
count = size_as
if customSerializer:
count = customSerializer.get('arraySize', count)
out += ' {\n'
out += ' BeginProp(' + s + ', "' + key + '");\n'
out += ' BeginElements(' + s + ');\n'
out += ' for (uint32_t _n = 0; '
if count:
out += '_n < ' + count
else:
sentinel = customSerializer.get('arraySentinel', '0')
out += prefix + key + '[_n] != ' + sentinel
out += '; ++_n) {\n'
out += ' AddElement(' + s + ', ToString_' + type + '(' + prefix + key + '[_n]));\n'
out += ' }\n'
out += ' EndElements(' + s + ');\n'
out += ' }\n'
else:
out += ' AddProp(' + s + ', "' + key + '", ToString_' + type + '(' + prefix + key + '));\n'
return out
def FromJSON(self, release, prefix, outvalue, node, create, callnode=None):
out = ''
type = node.GetType(release).GetName()
array = node.GetOneOf('Array')
interfaceMember = node.parent
interface = interfaceMember.parent.parent
customParser = getCustom(interface.GetName(),
interfaceMember.GetName(), node.GetName())
array = customParser.get('array', array)
create = customParser.get('create', create)
name = node.GetName()
outvalue = prefix + outvalue
if array:
if customParser:
type = customParser.get('arrayType', type)
fixed = array.GetProperty('FIXED') if isinstance(array,
IDLNode) else None
count = fixed
if type == 'char':
assert count > 0
out += ' FromJSON_charArray(iterator, ' + outvalue + ', ' + str(
count) + ');\n'
else:
if not count:
size_is = node.GetProperty('size_is()')
if size_is:
size_is = size_is[0]
count = prefix + size_is
if callnode:
for param in callnode.GetListOf('Param'):
if param.GetName() == size_is:
if self.cgen.GetParamMode(param) == 'out':
count = '*' + count
break
else:
size_as = node.GetProperty('size_as')
count = size_as
if customParser:
count = customParser.get('arraySize', count)
out += '\n'
out += ' {\n'
out += ' size_t children = iterator.expectArrayAndGotoFirstItem();\n'
if count:
out += ' if (children > ' + count + ') {\n'
out += ' Fail("Too many items in array\\n", "");\n'
out += ' }\n'
if create and not fixed:
if not count:
count = 'children'
out += ' ' + outvalue + ' = new ' + self.cgen.GetTypeByMode(
node, release, 'store') + '[' + count + '];\n'
out += ' for (uint32_t _n = 0; _n < children; ++_n) {\n'
out += ' FromJSON_' + type + '(iterator, (' + outvalue + ')[_n]);\n'
out += ' }\n'
out += ' // FIXME Null out remaining items?\n'
out += ' }\n'
else:
out += ' FromJSON_' + type + '(iterator, ' + outvalue + ');\n'
return out
def MemberFromJSON(self, release, prefix, member, create):
key = member.GetName()
if not member.InReleases([release]):
return '/* skipping %s */\n' % key
return self.FromJSON(release, prefix, key, member, create)
DerefOutType = {
'Array': {
'out': '*'
},
'Enum': '*',
'Struct': '*',
'cstr_t': '*',
'TypeValue': '*',
}
def DefineInterfaceMethodSerializer(self, iface, releases, node, release):
customSerializer = getCustom(iface.GetName(), node.GetName(), None)
if not node.InReleases([release]):
return '/* skipping %s */\n' % node.GetName()
if customSerializer and customSerializer.get('skip', False):
return self.cgen.GetSignature(node,
release,
'ref',
'',
func_as_ptr=False,
include_version=True) + ";\n"
out = ''
out += 'static '
out += self.cgen.GetSignature(node,
release,
'ref',
'',
func_as_ptr=False,
include_version=True)
out += ' {\n'
out += ' stringstream ss;\n'
out += ' BeginProps(ss);\n'
out += ' AddProp(ss, "__interface", "\\"' + iface.GetName(
) + '\\"");\n'
out += ' AddProp(ss, "__version", "\\"' + iface.GetVersion(
release) + '\\"");\n'
out += ' AddProp(ss, "__method", "\\"' + node.GetName() + '\\"");\n'
callnode = node.GetOneOf('Callspec')
hasOutParams = False
if callnode:
for param in callnode.GetListOf('Param'):
mode = self.cgen.GetParamMode(param)
ntype, mode = self.cgen.GetRootTypeMode(param, release, mode)
mode = getCustom(param.parent.parent.parent.GetName(),
param.parent.GetName(),
param.GetName()).get('mode', mode)
if mode == "out" or mode == "inout":
hasOutParams = hasOutParams or not (ntype == 'mem_t'
and mode == "inout")
out += self.AddProp(release, 'ss', '', param, mode == "out",
callnode)
out += ' EndProps(ss);\n'
if node.GetProperty('ref'):
mode = 'ref'
else:
mode = 'store'
rtype = self.cgen.GetTypeByMode(node.GetType(release), release,
'store')
out += '#ifndef INTERPOSE\n'
out += ' '
if rtype != 'void' or hasOutParams:
out += 'string json = RPCWithResult'
else:
out += 'RPC'
if customSerializer and customSerializer.get('maybeNonMainThread',
False):
out += '<MaybeNonMainThread>'
else:
out += '<MainThreadOnly>'
out += '(ss);\n'
if rtype != 'void' or hasOutParams:
if rtype != 'void':
out += ' ' + rtype + ' rval;\n'
out += ' JSONIterator iterator(json);\n'
out += ' iterator.expectArrayAndGotoFirstItem();\n'
if hasOutParams:
out += ' iterator.expectArrayAndGotoFirstItem();\n'
if rtype != 'void':
customRval = getCustom(iface.GetName(), node.GetName(),
"rval").get('convert')
if customRval:
out += customRval
else:
out += ' FromJSON_' + node.GetType(
release).GetName() + '(iterator, rval);\n'
if hasOutParams:
out += ' iterator.expectObjectAndGotoFirstProperty();\n'
for param in callnode.GetListOf('Param'):
mode = self.cgen.GetParamMode(param)
ntype, mode = self.cgen.GetRootTypeMode(
param, release, mode)
mode = getCustom(param.parent.parent.parent.GetName(),
param.parent.GetName(),
param.GetName()).get('mode', mode)
if mode == "out" or mode == "inout":
if ntype == 'mem_t' and mode == "inout":
continue
if ntype == 'Struct' and mode == 'out':
out += ' if (!!' + param.GetName() + ') {\n'
to_indent = ' iterator.skip();\n'
deref = self.DerefOutType.get(ntype, '')
if isinstance(deref, dict):
deref = deref.get(mode, '')
to_indent += self.FromJSON(release, '',
deref + param.GetName(),
param, mode == 'out',
callnode)
if ntype == 'Struct' and mode == 'out':
out += re.sub(r"(^|\n)(?!(\n|$))",
r'\1' + (2 * ' '), to_indent)
out += ' }\n'
else:
out += to_indent
if rtype != 'void':
out += ' return rval;\n'
out += '#else // !INTERPOSE\n'
out += ' printf("%s\\n", ss.str().c_str());\n'
#out += ' printf("Calling: %p\\n", RealGetInterface("' + self.cgen.GetInterfaceString(iface, iface.GetVersion(release)) + '"));\n'
#out += ' printf(" -> %p\\n", ((' + self.cgen.GetStructName(iface, release, include_version=True) + '*)RealGetInterface("' + self.cgen.GetInterfaceString(iface, iface.GetVersion(release)) + '"))->' + node.GetName() + ');\n'
out += ' '
rtype = self.cgen.GetTypeByMode(node.GetType(release), release,
'return')
params = []
for param in callnode.GetListOf('Param'):
mode = self.cgen.GetParamMode(param)
ntype, mode = self.cgen.GetRootTypeMode(param, release, mode)
if mode == "in" and param.GetType(
release).GetName() == 'PP_CompletionCallback':
out += 'PP_CompletionCallback logging_' + param.GetName(
) + ';\n'
out += ' logging_' + param.GetName(
) + '.func = &Logging_PP_CompletionCallback;\n'
out += ' logging_' + param.GetName(
) + '.user_data = new PP_CompletionCallback(' + param.GetName(
) + ');\n'
out += ' logging_' + param.GetName(
) + '.flags = ' + param.GetName() + '.flags;\n'
out += ' '
params.append('logging_' + param.GetName())
elif mode == "in" and param.GetType(
release).GetName() == 'PPP_Class_Deprecated':
out += 'Logging_PPP_Class_Deprecated_holder* logging_' + param.GetName(
) + ' = new Logging_PPP_Class_Deprecated_holder();\n'
out += ' logging_' + param.GetName(
) + '->_real_PPP_Class_Deprecated = ' + param.GetName() + ';\n'
out += ' logging_' + param.GetName(
) + '->object = object_data;\n'
out += ' object_data = logging_' + param.GetName() + ';\n'
out += ' '
params.append('&_interpose_PPP_Class_Deprecated_1_0')
elif mode == "return" and param.GetType(release).GetName(
) == 'PPB_Audio_Callback' and param.GetVersion(release) == "1.0":
out += 'Logging_PPB_Audio_Callback_1_0_holder* ' + param.GetName(
) + '_holder = new Logging_PPB_Audio_Callback_1_0_holder();\n'
out += ' ' + param.GetName(
) + '_holder->func = ' + param.GetName() + ';\n'
out += ' ' + param.GetName(
) + '_holder->user_data = user_data;\n'
out += ' user_data = ' + param.GetName() + '_holder;\n'
out += ' '
params.append('Logging_PPB_Audio_Callback_1_0')
else:
params.append(param.GetName())
if rtype != 'void':
out += rtype + ' rval = '
out += '((' + self.cgen.GetStructName(
iface, release, include_version=True
) + '*)RealGetInterface("' + self.cgen.GetInterfaceString(
iface, iface.GetVersion(release)) + '"))->' + node.GetName(
) + '(' + ', '.join(params) + ');\n'
if rtype != 'void' or hasOutParams:
out += ' printf("RPC response: [");\n'
if hasOutParams:
out += ' printf("[");\n'
if rtype != 'void':
out += ' printf("%s", ToString_' + node.GetType(
release).GetName() + '(rval).c_str());\n'
if hasOutParams:
if rtype != 'void':
out += ' printf(",");\n'
out += ' std::stringstream os;\n'
out += ' BeginProps(os);\n'
for param in callnode.GetListOf('Param'):
mode = self.cgen.GetParamMode(param)
ntype, mode = self.cgen.GetRootTypeMode(
param, release, mode)
if mode == "out" or mode == "inout":
if mode == "out" and (ntype == 'Struct'
or ntype == 'TypeValue'):
out += ' if (!!' + param.GetName() + ') {\n'
out += self.AddProp(release, 'os', '', param, False,
callnode)
if mode == "out" and (ntype == 'Struct'
or ntype == 'TypeValue'):
out += ' }\n'
out += ' EndProps(os);\n'
out += ' printf("%s]", os.str().c_str());\n'
out += ' printf("]\\n");\n'
if rtype != 'void':
out += ' return rval;\n'
out += '#endif // !INTERPOSE\n'
out += '}\n'
return out
def DefineInterfaceMethodParser(self, iface, releases, node, release):
if not node.InReleases([release]):
return '/* skipping %s */\n' % node.GetName()
version = self.GetNodeName(iface, release, releases)
out = ''
out += 'char* Call_%s_%s(const %s* _interface, JSONIterator& iterator) {\n' % (
iface.GetName(), node.GetName(), version)
callnode = node.GetOneOf('Callspec')
params = []
hasOutParams = False
for param in callnode.GetListOf('Param'):
mode = self.cgen.GetParamMode(param)
ptype, pname, parray, pspec = self.cgen.GetComponents(
param, release, "store")
out += ' ' + self.cgen.Compose(ptype,
pname,
parray,
pspec,
'',
func_as_ptr=True,
include_name=True,
unsized_as_ptr=True) + ';\n'
if mode == 'out':
if len(parray) > 0:
out += ' iterator.skip();\n'
out += ' PointerValueFromJSON(iterator, ' + pname + ');\n'
else:
out += ' iterator.skip();\n'
out += self.FromJSON(release, '', pname, param, True, callnode)
hasOutParams = hasOutParams or mode == "out" or mode == "inout"
if node.GetProperty('ref'):
mode = 'ref'
else:
mode = 'store'
rtype = self.cgen.GetTypeByMode(node.GetType(release), release,
'store')
out += ' '
if rtype != 'void':
out += rtype + ' rval;\n'
out += ' rval = '
params = []
for param in callnode.GetListOf('Param'):
mode = self.cgen.GetParamMode(param)
ntype, mode = self.cgen.GetRootTypeMode(param, release, mode)
ptype, pname, parray, pspec = self.cgen.GetComponents(
param, release, mode)
if mode == 'out' or ntype == 'Struct' or (mode == 'constptr_in' and
ntype == 'TypeValue'):
pname = '&' + pname
pname = '(' + self.cgen.Compose(ptype,
pname,
parray,
pspec,
'',
func_as_ptr=True,
include_name=False,
unsized_as_ptr=True) + ')' + pname
params.append(pname)
out += '_interface->' + node.GetName() + '(' + ", ".join(
params) + ');\n'
if rtype != 'void' or hasOutParams:
typeref = node.GetType(release)
if hasOutParams:
out += ' stringstream os;\n'
out += ' BeginElements(os);\n'
if rtype != 'void':
out += ' AddElement(os, ToString_' + typeref.GetName(
) + '(rval).c_str());\n'
out += ' BeginElement(os);\n'
out += ' BeginProps(os);\n'
for param in callnode.GetListOf('Param'):
mode = self.cgen.GetParamMode(param)
ntype, mode = self.cgen.GetRootTypeMode(
param, release, mode)
ptype, pname, parray, pspec = self.cgen.GetComponents(
param, release, mode)
if mode == 'out' or mode == 'inout':
out += self.AddProp(release,
'os',
'',
param,
False,
callnode,
derefSizeIs=False)
out += ' EndProps(os);\n'
out += ' EndElements(os);\n'
out += ' return strdup(os.str().c_str());\n'
else:
out += ' return strdup(ToString_' + typeref.GetName(
) + '(rval).c_str());\n'
else:
out += ' return nullptr;\n'
out += '}\n'
return out
def DefineInterface(self, node, releases, declareOnly):
out = ''
if node.GetName() == "PPB_NaCl_Private":
# skip
return out
isPPP = node.GetName()[0:4] == "PPP_"
build_list = node.GetUniqueReleases(releases)
for release in build_list:
name = self.cgen.GetStructName(node, release, include_version=True)
if declareOnly:
out += '#ifdef INTERPOSE\n'
out += 'static ' + name + ' *_real_' + name + ';\n'
out += '#endif // INTERPOSE\n'
if isPPP:
version = self.GetNodeName(node, release, build_list)
if declareOnly:
out += 'static char* Call_%s(void* _interface, JSONIterator& iterator);\n' % (
version)
continue
members = node.GetListOf('Member')
for member in members:
out += self.DefineInterfaceMethodParser(
node, build_list, member, release)
out += 'char* Call_%s(const void* _interface, JSONIterator& iterator) {\n' % (
version)
out += ' iterator.skip();\n'
out += ' const Token& member = iterator.getCurrentStringAndGotoNext();\n'
out += ' string memberName = member.value();\n'
for member in members:
if not member.InReleases([release]):
out += '/* skipping %s */\n' % member.GetName()
continue
out += ' if (!memberName.compare("' + member.GetName(
) + '")) {\n'
out += ' return Call_' + node.GetName(
) + '_' + member.GetName(
) + '((const ' + version + '*)_interface, iterator);\n'
out += ' }\n'
out += ' return nullptr;\n'
out += '}\n'
self.pppInterfaceGetters.append(
(self.cgen.GetInterfaceString(node,
node.GetVersion(release)),
'Call_' + version))
continue
version = self.cgen.GetStructName(node,
release,
include_version=True)
if declareOnly:
out += 'const string ToString_%s(const %s *v);\n' % (
node.GetName(), version)
continue
ns = 'ns_' + version
out += 'namespace ' + ns + ' {\n'
members = node.GetListOf('Member')
for member in members:
out += self.DefineInterfaceMethodSerializer(
node, releases, member, release)
out += '}\n'
self.interfaceStructs.append(
(self.cgen.GetInterfaceString(node, node.GetVersion(release)),
'_' + name))
out += 'static ' + name + ' _' + name + ' = {\n'
for member in members:
if not member.InReleases([release]):
continue
memberName = self.cgen.GetStructName(member, release, True)
out += ' ' + ns + '::' + memberName + ',\n'
out += '};\n'
out += 'const string ToString_%s(const %s *v) {\n' % (
node.GetName(), version)
out += ' stringstream s;\n'
out += ' s << v;\n'
out += ' return s.str();\n'
out += '}\n'
return out
def GetNodeName(self, node, release, build_list):
return self.cgen.GetStructName(
node, release, include_version=(release != build_list[-1]))
@staticmethod
def SerializerAndParserSignatures(typename, type):
s = ('const string ToString_%s(const %s *v)',
'const string ToString_%s(const %s &v)',
'void FromJSON_%s(JSONIterator& iterator, %s &value)')
return (sig % (typename, type) for sig in s)
def DefineTypedefSerializerAndParser(self, node, releases, declareOnly):
out = ''
build_list = node.GetUniqueReleases(releases)
for release in build_list:
type = self.GetNodeName(node, release, build_list)
typeref = node.GetType(release)
(toStringFromPointer, toStringFromRef,
fromJSONToRef) = self.SerializerAndParserSignatures(
node.GetName(), type)
isFuncPtr = node.GetOneOf('Callspec')
if declareOnly:
if not isFuncPtr:
out += toStringFromPointer + ";\n"
out += toStringFromRef + ";\n"
out += fromJSONToRef + ";\n"
continue
if not isFuncPtr:
out += toStringFromPointer + ' {\n'
out += ' return ToString_%s(v);\n' % (typeref.GetName())
out += '}\n'
out += toStringFromRef + ' {\n'
if isFuncPtr:
out += ' return PointerToString(v);\n'
else:
out += ' return ToString_%s(&v);\n' % (node.GetName())
out += '}\n'
out += fromJSONToRef + ' {\n'
if isFuncPtr:
out += ' PointerValueFromJSON(iterator, value);\n'
else:
out += ' FromJSON_%s(iterator, value);\n' % (
typeref.GetName())
out += '}\n'
return out
def DefineStructSerializerAndParser(self, node, releases, declareOnly):
out = ''
build_list = node.GetUniqueReleases(releases)
for release in build_list:
name = node.GetName()
version = self.GetNodeName(node, release, build_list)
(toStringFromPointer, toStringFromRef,
fromJSONToRef) = self.SerializerAndParserSignatures(
name, version)
if declareOnly:
out += toStringFromPointer + ";\n"
out += toStringFromRef + ";\n"
out += fromJSONToRef + ";\n"
continue
out += toStringFromPointer + ' {\n'
out += ' if (!v) {\n'
out += ' return "null";\n'
out += ' }\n'
out += ' return ToString_%s(*v);\n' % (name)
out += '}\n'
out += toStringFromRef + ' {\n'
out += ' stringstream x;\n'
out += ' BeginProps(x);\n'
members = node.GetListOf('Member')
for member in members:
out += self.AddProp(release, 'x', 'v.', member)
out += ' EndProps(x);\n'
out += ' return x.str();\n'
out += '}\n'
out += fromJSONToRef + ' {\n'
out += ' const JSON::Token& current = iterator.getCurrentAndGotoNext();\n'
# FIXME Should we warn here somehow? It might be ok to return null in
# error conditions, so maybe not.
out += ' if (current.isPrimitive() && !current.value().compare("null")) {\n'
out += ' return;\n'
out += ' }\n'
out += ' if (!current.isObject()) {\n'
out += ' Fail("Expected object!", "");\n'
out += ' }\n'
if node.GetProperty('union'):
out += ' string name = iterator.getCurrentStringAndGotoNext().value();\n'
out += " else ".join(
map(
lambda m: ' if (!name.compare(\"' + m.GetName(
) + '\")) {\n ' + self.MemberFromJSON(
release, 'value.', m, False) + ' }',
members)) + "\n"
else:
for member in members:
typeref = member.GetType(release)
out += ' iterator.skip();\n'
out += self.MemberFromJSON(release, 'value.', member,
False)
out += '}\n'
return out
def DefineEnumSerializerAndParser(self, node, releases, declareOnly):
if node.GetProperty('unnamed'):
return ''
out = ''
name = node.GetName()
(toStringFromPointer, toStringFromRef,
fromJSONToRef) = self.SerializerAndParserSignatures(name, name)
if declareOnly:
out += toStringFromPointer + ";\n"
out += toStringFromRef + ";\n"
out += fromJSONToRef + ";\n"
return out
out += toStringFromPointer + ' {\n'
out += ' switch (*v) {\n'
next = 0
emitted = set()
for child in node.GetListOf('EnumItem'):
value = child.GetName()
label = child.GetProperty('VALUE')
if not label:
label = str(next)
next = next + 1
if label in emitted:
continue
emitted.add(label)
emitted.add(value)
out += ' case ' + label + ':\n'
out += ' return "\\"' + value + '\\"";\n'
out += ' default:\n'
out += ' return "\\"???\\"";\n'
out += ' }\n'
out += '}\n'
out += toStringFromRef + ' {\n'
out += ' return ToString_%s(&v);\n' % (name)
out += '}\n'
out += fromJSONToRef + ' {\n'
out += ' long int v;\n'
out += ' FromJSON_int(iterator, v);\n'
out += ' value = %s(v);\n' % (name)
out += '}\n'
return out
def Define(self, node, releases, declareOnly):
# Skip if this node is not in this release
if not node.InReleases(releases):
return "/* skipping %s */\n" % node
if node.IsA('Typedef'):
return self.DefineTypedefSerializerAndParser(
node, releases, declareOnly)
if node.IsA('Struct'):
return self.DefineStructSerializerAndParser(
node, releases, declareOnly)
if node.IsA('Enum'):
return self.DefineEnumSerializerAndParser(node, releases,
declareOnly)
if node.IsA('Interface'):
return self.DefineInterface(node, releases, declareOnly)
return ''
def _MakeNormalMemberBody(filenode, release, node, member, rtype, args,
include_version, meta):
"""Returns the body of a typical function.
Args:
filenode - IDLNode for the file
release - release to generate body for
node - IDLNode for the interface
member - IDLNode for the member function
rtype - Return type for the member function
args - List of 4-tuple arguments for the member function
include_version - whether to include the version in the invocation
meta - ThunkBodyMetadata for header hints
"""
is_callback_func = args[len(args) - 1][0] == 'struct PP_CompletionCallback'
if is_callback_func:
call_args = args[:-1] + [('', 'enter.callback()', '', '')]
meta.AddInclude('ppapi/c/pp_completion_callback.h')
else:
call_args = args
if args[0][0] == 'PP_Instance':
call_arglist = ', '.join(a[1] for a in call_args)
function_container = 'functions'
else:
call_arglist = ', '.join(a[1] for a in call_args[1:])
function_container = 'object'
function_name = member.GetName()
if include_version:
version = node.GetVersion(release).replace('.', '_')
function_name += version
invocation = 'enter.%s()->%s(%s)' % (function_container,
function_name,
call_arglist)
handle_errors = not (member.GetProperty('report_errors') == 'False')
if is_callback_func:
body = '%s\n' % _MakeEnterLine(filenode, node, args[0], handle_errors,
args[len(args) - 1][1], meta)
body += 'if (enter.failed())\n'
value = member.GetProperty('on_failure')
if value is None:
value = 'enter.retval()'
body += ' return %s;\n' % value
body += 'return enter.SetResult(%s);' % invocation
elif rtype == 'void':
# On failure, zero out all output parameters.
out_params = []
callnode = member.GetOneOf('Callspec')
if callnode:
cgen = CGen()
for param in callnode.GetListOf('Param'):
mode = cgen.GetParamMode(param)
if mode == 'out':
# We use the 'store' mode when getting the parameter type, since we
# need to call sizeof() for memset().
ptype, pname, _, _ = cgen.GetComponents(param, release, 'store')
out_params.append((pname, ptype))
body = '%s\n' % _MakeEnterLine(filenode, node, args[0], handle_errors,
None, meta)
if not out_params:
body += 'if (enter.succeeded())\n'
body += ' %s;' % invocation
else:
body += 'if (enter.succeeded()) {\n'
body += ' %s;\n' % invocation
body += ' return;\n'
body += '}'
for param in out_params:
body += '\nmemset(%s, 0, sizeof(%s));' % param
meta.AddBuiltinInclude('string.h')
else:
value = member.GetProperty('on_failure')
if value is None:
value = _GetDefaultFailureValue(rtype)
if value is None:
raise TGenError('No default value for rtype %s' % rtype)
body = '%s\n' % _MakeEnterLine(filenode, node, args[0], handle_errors,
None, meta)
body += 'if (enter.failed())\n'
body += ' return %s;\n' % value
body += 'return %s;' % invocation
return body
