def CheckTypedefs(filenode, releases):
"""Checks that typedefs don't specify callbacks that take some structs.
See http://crbug.com/233439 for details.
"""
cgen = CGen()
# TODO(teravest): Fix the following callback to pass PP_Var by pointer
# instead of by value.
node_whitelist = ['PP_Ext_Alarms_OnAlarm_Func_Dev_0_1']
for node in filenode.GetListOf('Typedef'):
if node.GetName() in node_whitelist:
continue
build_list = node.GetUniqueReleases(releases)
callnode = node.GetOneOf('Callspec')
if callnode:
for param in callnode.GetListOf('Param'):
if param.GetListOf('Array'):
continue
if cgen.GetParamMode(param) != 'in':
continue
t = param.GetType(build_list[0])
while t.IsA('Typedef'):
t = t.GetType(build_list[0])
if t.IsA('Struct'):
raise Exception('%s is a struct in callback %s. '
'See http://crbug.com/233439' %
(t.GetName(), node.GetName()))
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 __init__(self):
WrapperGen.__init__(self,
'Pnacl',
'Pnacl Shim Gen',
'pnacl',
'Generate the PNaCl shim.')
self.cgen = CGen()
self._skip_opt = False
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 GenerateHeader(out, filenode, releases):
cgen = CGen()
pref = ''
do_comments = True
# Generate definitions.
last_group = None
top_types = ['Typedef', 'Interface', 'Struct', 'Enum', 'Inline']
for node in filenode.GetListOf(*top_types):
# Skip if this node is not in this release
if not node.InReleases(releases):
print "Skiping %s" % node
continue
# End/Start group marker
if do_comments:
last_group = WriteGroupMarker(out, node, last_group)
if node.IsA('Inline'):
item = node.GetProperty('VALUE')
# If 'C++' use __cplusplus wrapper
if node.GetName() == 'cc':
item = '#ifdef __cplusplus\n%s\n#endif /* __cplusplus */\n\n' % item
# If not C++ or C, then skip it
elif not node.GetName() == 'c':
continue
if item: out.Write(item)
continue
#
# Otherwise we are defining a file level object, so generate the
# correct document notation.
#
item = cgen.Define(node, releases, prefix=pref, comment=True)
if not item: continue
asize = node.GetProperty('assert_size()')
if asize:
name = '%s%s' % (pref, node.GetName())
if node.IsA('Struct'):
form = 'PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(%s, %s);\n'
elif node.IsA('Enum'):
if node.GetProperty('notypedef'):
form = 'PP_COMPILE_ASSERT_ENUM_SIZE_IN_BYTES(%s, %s);\n'
else:
form = 'PP_COMPILE_ASSERT_SIZE_IN_BYTES(%s, %s);\n'
else:
form = 'PP_COMPILE_ASSERT_SIZE_IN_BYTES(%s, %s);\n'
item += form % (name, asize[0])
if item: out.Write(item)
if last_group:
out.Write(CommentLines(['*', ' @}', '']) + '\n')
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 WriteHead(self, out, filenode, releases, options, meta):
__pychecker__ = 'unusednames=options'
cgen = CGen()
cright_node = filenode.GetChildren()[0]
assert(cright_node.IsA('Copyright'))
out.Write('%s\n' % cgen.Copyright(cright_node, cpp_style=True))
# Wrap the From ... modified ... comment if it would be >80 characters.
from_text = 'From %s' % (
filenode.GetProperty('NAME').replace(os.sep,'/'))
modified_text = 'modified %s.' % (
filenode.GetProperty('DATETIME'))
if len(from_text) + len(modified_text) < 74:
out.Write('// %s %s\n\n' % (from_text, modified_text))
else:
out.Write('// %s,\n// %s\n\n' % (from_text, modified_text))
if meta.BuiltinIncludes():
for include in sorted(meta.BuiltinIncludes()):
out.Write('#include <%s>\n' % include)
out.Write('\n')
# TODO(teravest): Don't emit includes we don't need.
includes = ['ppapi/c/pp_errors.h',
'ppapi/shared_impl/tracked_callback.h',
'ppapi/thunk/enter.h',
'ppapi/thunk/ppb_instance_api.h',
'ppapi/thunk/resource_creation_api.h',
'ppapi/thunk/thunk.h']
includes.append(_GetHeaderFileName(filenode))
for api in meta.Apis():
includes.append('ppapi/thunk/%s.h' % api.lower())
for i in meta.Includes():
includes.append(i)
for include in sorted(includes):
out.Write('#include "%s"\n' % include)
out.Write('\n')
out.Write('namespace ppapi {\n')
out.Write('namespace thunk {\n')
out.Write('\n')
out.Write('namespace {\n')
out.Write('\n')
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 CheckTypedefs(filenode, releases):
"""Checks that typedefs don't specify callbacks that take some structs.
See http://crbug.com/233439 for details.
"""
cgen = CGen()
for node in filenode.GetListOf('Typedef'):
build_list = node.GetUniqueReleases(releases)
callnode = node.GetOneOf('Callspec')
if callnode:
for param in callnode.GetListOf('Param'):
if param.GetListOf('Array'):
continue
if cgen.GetParamMode(param) != 'in':
continue
t = param.GetType(build_list[0])
while t.IsA('Typedef'):
t = t.GetType(build_list[0])
if t.IsA('Struct') and t.GetProperty('passByValue'):
raise Exception('%s is a struct in callback %s. '
'See http://crbug.com/233439' %
(t.GetName(), node.GetName()))
def WriteHead(self, out, filenode, releases, options, meta):
__pychecker__ = 'unusednames=options'
cgen = CGen()
cright_node = filenode.GetChildren()[0]
assert(cright_node.IsA('Copyright'))
out.Write('%s\n' % cgen.Copyright(cright_node, cpp_style=True))
from_text = 'From %s' % (
filenode.GetProperty('NAME').replace(os.sep,'/'))
modified_text = 'modified %s.' % (
filenode.GetProperty('DATETIME'))
out.Write('// %s %s\n\n' % (from_text, modified_text))
meta.AddBuiltinInclude('stdint.h')
if meta.BuiltinIncludes():
for include in sorted(meta.BuiltinIncludes()):
out.Write('#include <%s>\n' % include)
out.Write('\n')
# TODO(teravest): Don't emit includes we don't need.
includes = ['ppapi/c/pp_errors.h',
'ppapi/shared_impl/tracked_callback.h',
'ppapi/thunk/enter.h',
'ppapi/thunk/ppapi_thunk_export.h']
includes.append(_GetHeaderFileName(filenode))
for api in meta.Apis():
includes.append('%s' % api.lower())
for i in meta.Includes():
includes.append(i)
for include in sorted(includes):
out.Write('#include "%s"\n' % include)
out.Write('\n')
out.Write('namespace ppapi {\n')
out.Write('namespace thunk {\n')
out.Write('\n')
out.Write('namespace {\n')
out.Write('\n')
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')
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 CheckPassByValue(filenode, releases):
"""Checks that new pass-by-value structs are not introduced.
See http://crbug.com/233439 for details.
"""
cgen = CGen()
# DO NOT add any more entries to this whitelist.
# http://crbug.com/233439
type_whitelist = ['PP_ArrayOutput', 'PP_CompletionCallback',
'PP_Ext_EventListener', 'PP_FloatPoint',
'PP_Point', 'PP_TouchPoint', 'PP_Var']
nodes_to_check = filenode.GetListOf('Struct')
nodes_to_check.extend(filenode.GetListOf('Union'))
for node in nodes_to_check:
if node.GetName() in type_whitelist:
continue
build_list = node.GetUniqueReleases(releases)
if node.GetProperty('passByValue'):
raise Exception('%s is a new passByValue struct or union. '
'See http://crbug.com/233439' % node.GetName())
if node.GetProperty('returnByValue'):
raise Exception('%s is a new returnByValue struct or union. '
'See http://crbug.com/233439' % node.GetName())
def __init__(self, wrapper_prefix, s1, s2, s3):
Generator.__init__(self, s1, s2, s3)
self.wrapper_prefix = wrapper_prefix
self._skip_opt = False
self.output_file = None
self.cgen = CGen()
class WrapperGen(Generator):
"""WrapperGen - An abstract class that generates wrappers for PPAPI methods.
This generates a wrapper PPB and PPP GetInterface, which directs users
to wrapper PPAPI methods. Wrapper PPAPI methods may perform arbitrary
work before invoking the real PPAPI method (supplied by the original
GetInterface functions).
Subclasses must implement GenerateWrapperForPPBMethod (and PPP).
Optionally, subclasses can implement InterfaceNeedsWrapper to
filter out interfaces that do not actually need wrappers (those
interfaces can jump directly to the original interface functions).
"""
def __init__(self, wrapper_prefix, s1, s2, s3):
Generator.__init__(self, s1, s2, s3)
self.wrapper_prefix = wrapper_prefix
self._skip_opt = False
self.output_file = None
self.cgen = CGen()
def SetOutputFile(self, fname):
self.output_file = fname
def GenerateRelease(self, ast, release, options):
return self.GenerateRange(ast, [release], options)
@staticmethod
def GetHeaderName(name):
"""Get the corresponding ppapi .h file from each IDL filename.
"""
name = os.path.splitext(name)[0] + '.h'
name = name.replace(os.sep, '/')
return 'ppapi/c/' + name
def WriteCopyrightGeneratedTime(self, out):
now = datetime.now()
c = """/* Copyright (c) %s 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.
*/
/* Last generated from IDL: %s. */
""" % (now.year, datetime.ctime(now))
out.Write(c)
def GetWrapperMetadataName(self):
return '__%sWrapperInfo' % self.wrapper_prefix
def GenerateHelperFunctions(self, out):
"""Generate helper functions to avoid dependencies on libc.
"""
out.Write("""/* Use local strcmp to avoid dependency on libc. */
static int mystrcmp(const char* s1, const char *s2) {
while((*s1 && *s2) && (*s1++ == *s2++));
return *(--s1) - *(--s2);
}\n
""")
def GenerateFixedFunctions(self, out):
"""Write out the set of constant functions (those that do not depend on
the current Pepper IDL).
"""
out.Write(
"""
static PPB_GetInterface __real_PPBGetInterface;
static PPP_GetInterface_Type __real_PPPGetInterface;
void __set_real_%(wrapper_prefix)s_PPBGetInterface(PPB_GetInterface real) {
__real_PPBGetInterface = real;
}
void __set_real_%(wrapper_prefix)s_PPPGetInterface(PPP_GetInterface_Type real) {
__real_PPPGetInterface = real;
}
/* Map interface string -> wrapper metadata */
static struct %(wrapper_struct)s *%(wrapper_prefix)sPPBShimIface(
const char *name) {
struct %(wrapper_struct)s **next = s_ppb_wrappers;
while (*next != NULL) {
if (mystrcmp(name, (*next)->iface_macro) == 0) return *next;
++next;
}
return NULL;
}
/* Map interface string -> wrapper metadata */
static struct %(wrapper_struct)s *%(wrapper_prefix)sPPPShimIface(
const char *name) {
struct %(wrapper_struct)s **next = s_ppp_wrappers;
while (*next != NULL) {
if (mystrcmp(name, (*next)->iface_macro) == 0) return *next;
++next;
}
return NULL;
}
const void *__%(wrapper_prefix)s_PPBGetInterface(const char *name) {
struct %(wrapper_struct)s *wrapper = %(wrapper_prefix)sPPBShimIface(name);
if (wrapper == NULL) {
/* We don't have an IDL for this, for some reason. Take our chances. */
return (*__real_PPBGetInterface)(name);
}
/* Initialize the real_iface if it hasn't been. The wrapper depends on it. */
if (wrapper->real_iface == NULL) {
const void *iface = (*__real_PPBGetInterface)(name);
if (NULL == iface) return NULL;
wrapper->real_iface = iface;
}
if (wrapper->wrapped_iface) {
return wrapper->wrapped_iface;
} else {
return wrapper->real_iface;
}
}
const void *__%(wrapper_prefix)s_PPPGetInterface(const char *name) {
struct %(wrapper_struct)s *wrapper = %(wrapper_prefix)sPPPShimIface(name);
if (wrapper == NULL) {
/* We don't have an IDL for this, for some reason. Take our chances. */
return (*__real_PPPGetInterface)(name);
}
/* Initialize the real_iface if it hasn't been. The wrapper depends on it. */
if (wrapper->real_iface == NULL) {
const void *iface = (*__real_PPPGetInterface)(name);
if (NULL == iface) return NULL;
wrapper->real_iface = iface;
}
if (wrapper->wrapped_iface) {
return wrapper->wrapped_iface;
} else {
return wrapper->real_iface;
}
}
""" % {
'wrapper_struct': self.GetWrapperMetadataName(),
'wrapper_prefix': self.wrapper_prefix,
})
############################################################
def InterfaceNeedsWrapper(self, iface, releases):
"""Return true if the interface has ANY methods that need wrapping.
"""
return True
def OwnHeaderFile(self):
"""Return the header file that specifies the API of this wrapper.
We do not generate the header files. """
raise Exception('Child class must implement this')
############################################################
def DetermineInterfaces(self, ast, releases):
"""Get a list of interfaces along with whatever metadata we need.
"""
iface_releases = []
for filenode in ast.GetListOf('File'):
# If this file has errors, skip it
if filenode in self.skip_list:
if GetOption('verbose'):
InfoOut.Log('WrapperGen: Skipping %s due to errors\n' %
filenode.GetName())
continue
file_name = self.GetHeaderName(filenode.GetName())
ifaces = filenode.GetListOf('Interface')
for iface in ifaces:
releases_for_iface = iface.GetUniqueReleases(releases)
for release in releases_for_iface:
version = iface.GetVersion(release)
struct_name = self.cgen.GetStructName(iface,
release,
include_version=True)
needs_wrap = self.InterfaceVersionNeedsWrapping(
iface, version)
if not needs_wrap:
if GetOption('verbose'):
InfoOut.Log(
'Interface %s ver %s does not need wrapping' %
(struct_name, version))
iface_releases.append(
Interface(iface, release, version, struct_name,
needs_wrap, file_name))
return iface_releases
def GenerateIncludes(self, iface_releases, out):
"""Generate the list of #include that define the original interfaces.
"""
self.WriteCopyrightGeneratedTime(out)
# First include own header.
out.Write('#include "%s"\n\n' % self.OwnHeaderFile())
# Get typedefs for PPB_GetInterface.
out.Write('#include "%s"\n' % self.GetHeaderName('ppb.h'))
# Get a conservative list of all #includes that are needed,
# whether it requires wrapping or not. We currently depend on the macro
# string for comparison, even when it is not wrapped, to decide when
# to use the original/real interface.
header_files = set()
for iface in iface_releases:
header_files.add(iface.header_file)
for header in sorted(header_files):
out.Write('#include "%s"\n' % header)
out.Write('\n')
def WrapperMethodPrefix(self, iface, release):
return '%s_%s_%s_' % (self.wrapper_prefix, release, iface.GetName())
def GetReturnArgs(self, ret_type, args_spec):
if ret_type != 'void':
ret = 'return '
else:
ret = ''
if args_spec:
args = []
for arg in args_spec:
args.append(arg[1])
args = ', '.join(args)
else:
args = ''
return (ret, args)
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' % sig)
result.append(' while(1) { /* Not implemented */ } \n')
result.append('}\n')
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(' while(1) { /* Not implemented */ } \n')
result.append('}\n')
return 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 = []
for iface in iface_releases:
if not iface.needs_wrapping:
if comments:
result.append(
'/* Not generating wrapper methods for %s */\n\n' %
iface.struct_name)
continue
if comments:
result.append('/* Begin wrapper methods for %s */\n\n' %
iface.struct_name)
generator = PPKind.ChoosePPFunc(iface,
self.GenerateWrapperForPPBMethod,
self.GenerateWrapperForPPPMethod)
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))
if comments:
result.append('/* End wrapper methods for %s */\n\n' %
iface.struct_name)
return ''.join(result)
def GenerateWrapperInterfaces(self, iface_releases, out):
for iface in iface_releases:
if not iface.needs_wrapping:
out.Write('/* Not generating wrapper interface for %s */\n\n' %
iface.struct_name)
continue
out.Write(
'struct %s %s_Wrappers_%s = {\n' %
(iface.struct_name, self.wrapper_prefix, iface.struct_name))
methods = []
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
prefix = self.WrapperMethodPrefix(iface.node, iface.release)
cast = self.cgen.GetSignature(member,
iface.release,
'return',
prefix='',
func_as_ptr=True,
ptr_prefix='',
include_name=False)
methods.append(
' .%s = (%s)&%s%s' %
(member.GetName(), cast, prefix, member.GetName()))
out.Write(' ' + ',\n '.join(methods) + '\n')
out.Write('};\n\n')
def GetWrapperInfoName(self, iface):
return '%s_WrapperInfo_%s' % (self.wrapper_prefix, iface.struct_name)
def GenerateWrapperInfoAndCollection(self, iface_releases, out):
for iface in iface_releases:
iface_macro = self.cgen.GetInterfaceMacro(iface.node,
iface.version)
if iface.needs_wrapping:
wrap_iface = '(void *) &%s_Wrappers_%s' % (self.wrapper_prefix,
iface.struct_name)
else:
wrap_iface = 'NULL /* Still need slot for real_iface */'
out.Write("""static struct %s %s = {
.iface_macro = %s,
.wrapped_iface = %s,
.real_iface = NULL
};\n\n""" % (self.GetWrapperMetadataName(), self.GetWrapperInfoName(iface),
iface_macro, wrap_iface))
# Now generate NULL terminated arrays of the above wrapper infos.
ppb_wrapper_infos = []
ppp_wrapper_infos = []
for iface in iface_releases:
appender = PPKind.ChoosePPFunc(iface, ppb_wrapper_infos.append,
ppp_wrapper_infos.append)
appender(' &%s' % self.GetWrapperInfoName(iface))
ppb_wrapper_infos.append(' NULL')
ppp_wrapper_infos.append(' NULL')
out.Write(
'static struct %s *s_ppb_wrappers[] = {\n%s\n};\n\n' %
(self.GetWrapperMetadataName(), ',\n'.join(ppb_wrapper_infos)))
out.Write(
'static struct %s *s_ppp_wrappers[] = {\n%s\n};\n\n' %
(self.GetWrapperMetadataName(), ',\n'.join(ppp_wrapper_infos)))
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 Wrapper Infos */\n\n')
for iface in iface_releases:
out.Write('static struct %s %s;\n' %
(self.GetWrapperMetadataName(),
self.GetWrapperInfoName(iface)))
out.Write('/* END Declarations for all Wrapper Infos. */\n\n')
def GenerateRange(self, ast, releases, options):
"""Generate shim code for a range of releases.
"""
# Remember to set the output filename before running this.
out_filename = self.output_file
if out_filename is None:
ErrOut.Log('Did not set filename for writing out wrapper\n')
return 1
InfoOut.Log("Generating %s for %s" %
(out_filename, self.wrapper_prefix))
out = IDLOutFile(out_filename)
# Get a list of all the interfaces along with metadata.
iface_releases = self.DetermineInterfaces(ast, releases)
# Generate the includes.
self.GenerateIncludes(iface_releases, out)
out.Write(self.GetGuardStart())
# Write out static helper functions (mystrcmp).
self.GenerateHelperFunctions(out)
# Declare list of WrapperInfo before actual wrapper methods, since
# they reference each other.
self.DeclareWrapperInfos(iface_releases, out)
# Generate wrapper functions for each wrapped method in the interfaces.
result = self.GenerateWrapperForMethods(iface_releases)
out.Write(result)
# Collect all the wrapper functions into interface structs.
self.GenerateWrapperInterfaces(iface_releases, out)
# Generate a table of the wrapped interface structs that can be looked up.
self.GenerateWrapperInfoAndCollection(iface_releases, out)
# Write out the IDL-invariant functions.
self.GenerateFixedFunctions(out)
out.Write(self.GetGuardEnd())
out.Close()
return 0
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)
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
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)
def GenerateHead(self, out, filenode, releases, options):
cgen = CGen()
gpath = GetOption('guard')
release = releases[0]
def_guard = GetOutFileName(filenode, relpath=gpath)
def_guard = def_guard.replace(os.sep, '_').replace('.',
'_').upper() + '_'
cright_node = filenode.GetChildren()[0]
assert (cright_node.IsA('Copyright'))
fileinfo = filenode.GetChildren()[1]
assert (fileinfo.IsA('Comment'))
out.Write('%s\n' % cgen.Copyright(cright_node))
out.Write('/* From %s modified %s. */\n\n' %
(filenode.GetProperty('NAME').replace(
os.sep, '/'), filenode.GetProperty('DATETIME')))
out.Write('#ifndef %s\n#define %s\n\n' % (def_guard, def_guard))
# Generate set of includes
deps = set()
for release in releases:
deps |= filenode.GetDeps(release)
includes = set([])
for dep in deps:
depfile = dep.GetProperty('FILE')
if depfile:
includes.add(depfile)
includes = [
GetOutFileName(include, relpath=gpath).replace(os.sep, '/')
for include in includes
]
includes.append('ppapi/c/pp_macros.h')
# Assume we need stdint if we "include" C or C++ code
if filenode.GetListOf('Include'):
includes.append('ppapi/c/pp_stdint.h')
includes = sorted(set(includes))
cur_include = GetOutFileName(filenode,
relpath=gpath).replace(os.sep, '/')
for include in includes:
if include == cur_include: continue
out.Write('#include "%s"\n' % include)
# Generate all interface defines
out.Write('\n')
for node in filenode.GetListOf('Interface'):
idefs = ''
name = self.GetVersionString(node)
macro = node.GetProperty('macro')
if not macro:
macro = self.GetMacro(node)
unique = node.GetUniqueReleases(releases)
for rel in unique:
version = node.GetVersion(rel)
strver = str(version).replace('.', '_')
idefs += self.GetDefine('%s_%s' % (macro, strver),
'"%s;%s"' % (name, version))
idefs += self.GetDefine(macro, '%s_%s' % (macro, strver)) + '\n'
out.Write(idefs)
# Generate the @file comment
out.Write('%s\n' % Comment(fileinfo, prefix='*\n @file'))
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)
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
def GenerateHead(self, out, filenode, releases, options):
__pychecker__ = 'unusednames=options'
cgen = CGen()
gpath = GetOption('guard')
def_guard = GetOutFileName(filenode, relpath=gpath)
def_guard = def_guard.replace(os.sep, '_').replace('.',
'_').upper() + '_'
cright_node = filenode.GetChildren()[0]
assert (cright_node.IsA('Copyright'))
fileinfo = filenode.GetChildren()[1]
assert (fileinfo.IsA('Comment'))
out.Write('%s\n' % cgen.Copyright(cright_node))
# Wrap the From ... modified ... comment if it would be >80 characters.
from_text = 'From %s' % (filenode.GetProperty('NAME').replace(
os.sep, '/'))
modified_text = 'modified %s.' % (filenode.GetProperty('DATETIME'))
if len(from_text) + len(modified_text) < 74:
out.Write('/* %s %s */\n\n' % (from_text, modified_text))
else:
out.Write('/* %s,\n * %s\n */\n\n' % (from_text, modified_text))
out.Write('#ifndef %s\n#define %s\n\n' % (def_guard, def_guard))
# Generate set of includes
deps = set()
for release in releases:
deps |= filenode.GetDeps(release)
includes = set([])
for dep in deps:
depfile = dep.GetProperty('FILE')
if depfile:
includes.add(depfile)
includes = [
GetOutFileName(include, relpath=gpath).replace(os.sep, '/')
for include in includes
]
includes.append('ppapi/c/pp_macros.h')
# Assume we need stdint if we "include" C or C++ code
if filenode.GetListOf('Include'):
includes.append('ppapi/c/pp_stdint.h')
includes = sorted(set(includes))
cur_include = GetOutFileName(filenode,
relpath=gpath).replace(os.sep, '/')
for include in includes:
if include == cur_include: continue
out.Write('#include "%s"\n' % include)
# Generate all interface defines
out.Write('\n')
for node in filenode.GetListOf('Interface'):
idefs = ''
macro = cgen.GetInterfaceMacro(node)
unique = node.GetUniqueReleases(releases)
# Skip this interface if there are no matching versions
if not unique: continue
for rel in unique:
version = node.GetVersion(rel)
name = cgen.GetInterfaceString(node, version)
strver = str(version).replace('.', '_')
idefs += cgen.GetDefine('%s_%s' % (macro, strver),
'"%s"' % name)
idefs += cgen.GetDefine(macro, '%s_%s' % (macro, strver)) + '\n'
out.Write(idefs)
# Generate the @file comment
out.Write('%s\n' % Comment(fileinfo, prefix='*\n @file'))
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 GenerateHead(self, out, filenode, releases, options):
__pychecker__ = 'unusednames=options'
proto = ProtoResolver()
proto.Visit(filenode, None)
cgen = CGen()
gpath = GetOption('guard')
def_guard = GetHeaderFromNode(filenode, relpath=gpath)
def_guard = def_guard.replace(os.sep, '_').replace('.',
'_').upper() + '_'
cright_node = filenode.GetChildren()[0]
assert (cright_node.IsA('Copyright'))
fileinfo = filenode.GetChildren()[1]
assert (fileinfo.IsA('Comment'))
out.Write('%s\n' % cgen.Copyright(cright_node))
# Wrap the From ... modified ... comment if it would be >80 characters.
from_text = 'From %s' % GetPathFromNode(filenode).replace(os.sep, '/')
modified_text = 'modified %s.' % (filenode.GetProperty('DATETIME'))
if len(from_text) + len(modified_text) < 74:
out.Write('/* %s %s */\n\n' % (from_text, modified_text))
else:
out.Write('/* %s,\n * %s\n */\n\n' % (from_text, modified_text))
out.Write('#ifndef %s\n#define %s\n\n' % (def_guard, def_guard))
# Generate set of includes
deps = set()
for release in releases:
deps |= filenode.GetDeps(release)
includes = set([])
for dep in deps:
depfile = dep.GetProperty('FILE')
if depfile:
includes.add(depfile)
includes = [
GetHeaderFromNode(include, relpath=gpath).replace(os.sep, '/')
for include in includes
]
includes.append('ppapi/c/pp_macros.h')
# Assume we need stdint if we "include" C or C++ code
if filenode.GetListOf('Include'):
includes.append('ppapi/c/pp_stdint.h')
includes = sorted(set(includes))
cur_include = GetHeaderFromNode(filenode,
relpath=gpath).replace(os.sep, '/')
for include in includes:
if include == cur_include: continue
out.Write('#include "%s"\n' % include)
# Generate Prototypes
if proto.struct_map:
out.Write('\n/* Struct prototypes */\n')
for struct in proto.struct_map:
out.Write('struct %s;\n' % struct)
# Create a macro for the highest available release number.
if filenode.GetProperty('NAME').endswith('pp_macros.idl'):
releasestr = ' '.join(releases)
if releasestr:
release_numbers = re.findall('[\d\_]+', releasestr)
release = re.findall('\d+', release_numbers[-1])[0]
if release:
out.Write('\n#define PPAPI_RELEASE %s\n' % release)
# Generate all interface defines
out.Write('\n')
for node in filenode.GetListOf('Interface'):
idefs = ''
macro = cgen.GetInterfaceMacro(node)
unique = node.GetUniqueReleases(releases)
# Skip this interface if there are no matching versions
if not unique: continue
for rel in unique:
version = node.GetVersion(rel)
name = cgen.GetInterfaceString(node, version)
strver = str(version).replace('.', '_')
idefs += cgen.GetDefine('%s_%s' % (macro, strver),
'"%s"' % name)
idefs += cgen.GetDefine(macro, '%s_%s' % (macro, strver)) + '\n'
out.Write(idefs)
# Generate the @file comment
out.Write('%s\n' % Comment(fileinfo, prefix='*\n @file'))
def __init__(self):
self.cgen = CGen()
self.interfaceStructs = []
self.pppInterfaceGetters = []
