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 = []