def __init__(self, tree, config): # configuration parameters from command options self.config = config # module's namespace stack self.module = [] # main dictionary self.dict = {} self.dict['tree'] = [] # idl file name idl_fname = ast.mainFile() self.dict['idl_fname'] = idl_fname # included idl files incs = [] idl_incs = ast.includes() for inc in idl_incs: d = self.createHeaderInfo(inc) if inc == idl_fname: self.dict.update(d) elif self.config['ImplicitInclude']: # -Wbimplicit option makes process included IDLs d = self.createHeaderInfo(inc) incs.append(d) self.dict['idl_includes'] = incs # other includes self.dict['include_h'] = self.config["IncludeHeaders"] # type mapping self.typemap = self.config['TypeMapping'] # now configurations can be accessed by self.config["key"] # keep track of all interfaces for later use self.__allInterfaces = [] self.tk_map = { idltype.tk_null : "tk_null", idltype.tk_void : "tk_void", idltype.tk_short : "tk_short", idltype.tk_long : "tk_long", idltype.tk_ushort : "tk_ushort", idltype.tk_ulong : "tk_ulong", idltype.tk_float : "tk_float", idltype.tk_double : "tk_double", idltype.tk_boolean : "tk_boolean", idltype.tk_char : "tk_char", idltype.tk_octet : "tk_octet", idltype.tk_any : "tk_any", idltype.tk_TypeCode : "tk_TypeCode", idltype.tk_Principal : "tk_Principal", idltype.tk_objref : "tk_objref", idltype.tk_struct : "tk_struct", idltype.tk_union : "tk_union", idltype.tk_enum : "tk_enum", idltype.tk_string : "tk_string", idltype.tk_sequence : "tk_sequence", idltype.tk_array : "tk_array", idltype.tk_alias : "tk_alias", idltype.tk_except : "tk_except", idltype.tk_longlong : "tk_longlong", idltype.tk_ulonglong : "tk_ulonglong", idltype.tk_longdouble : "tk_longdouble", idltype.tk_wchar : "tk_wchar", idltype.tk_wstring : "tk_wstring", idltype.tk_fixed : "tk_fixed", idltype.tk_value : "tk_value", idltype.tk_value_box : "tk_value_box", idltype.tk_native : "tk_native", idltype.tk_abstract_interface : "tk_abstract_interface", idltype.tk_local_interface : "tk_local_interface" } self.corba_primitive = { "CORBA::Short" : "short int", "CORBA::UShort" : "unsigned short int", "CORBA::Long" : "int", "CORBA::ULong" : "unsigned int", "CORBA::Float" : "float", "CORBA::Double" : "double", "CORBA::Char" : "char", "CORBA::Boolean" : "bool", "char*" : "::std::string", "CORBA::Any" : "::std::string", "CORBA::TypeCode_ptr" : "::std::string" }
def monolithic(stream, tree): """Creates one large header with all definitions inside""" guard = id.Name([config.state['Basename']]).guard() header(stream, guard) # Extra DLL include stuff? if config.state['DLLIncludes']: sub_include_pre = output.StringStream() sub_include_post = output.StringStream() sub_include_pre .out(template.sub_include_pre, guard=guard) sub_include_post.out(template.sub_include_post, guard=guard) else: sub_include_pre = "" sub_include_post = "" # Add in any direct C++ from toplevel pragma if present cxx_direct_include = [] directive = "hh " for pragma in tree.pragmas(): # ignore all pragmas but those in the main file if pragma.file() != tree.file(): continue if pragma.text()[:len(directive)] == directive: cxx_direct_include.append(pragma.text()[len(directive):]) includes = output.StringStream() # produce #includes for all files included by the IDL for include in ast.includes(): # skip the main file if ast.mainFile() == include: continue # the old C++ BE makes orb.idl a special case # (might now be a redundant test) # dirname == directory containing the include file # filename == extensionless filename # ext == extension (typically .idl) (root, ext) = os.path.splitext(include) (dirname, filename) = os.path.split(root) # Name for external include guard. Always use the same suffix, # rather than taking suffix from the config. guardname = id.Name([filename]).guard() + "_hh" if config.state['Keep Include Path']: filename = root cxx_include = filename + config.state['HH Suffix'] if config.state['Use Quotes']: cxx_include = '"' + cxx_include + '"' else: cxx_include = "<" + cxx_include + ">" includes.out(template.main_include, guardname = guardname, guard_prefix = config.state['GuardPrefix'], filename = cxx_include) # generate the header definitions def forward_dec(stream = stream, tree = tree): forward = omniidl_be.cxx.header.forward.init(stream) tree.accept(forward) def main_defs(stream = stream, tree = tree): defs = omniidl_be.cxx.header.defs.init(stream) tree.accept(defs) def main_poa(stream = stream, tree = tree): # includes inline (non-flat) tie templates poa = omniidl_be.cxx.header.poa.init(stream) tree.accept(poa) def main_obv(stream = stream, tree = tree): obv = omniidl_be.cxx.header.obv.init(stream) tree.accept(obv) def other_tie(stream = stream, tree = tree): if config.state['Normal Tie'] and config.state['BOA Skeletons']: tie = omniidl_be.cxx.header.tie.BOATieTemplates(stream) tree.accept(tie) if config.state['Flattened Tie']: tie = omniidl_be.cxx.header.tie.FlatTieTemplates(stream) tree.accept(tie) def main_opers(stream = stream, tree = tree): opers = omniidl_be.cxx.header.opers.init(stream) tree.accept(opers) def main_marshal(stream = stream, tree = tree): marshal = omniidl_be.cxx.header.marshal.init(stream) tree.accept(marshal) # other stuff stream.out(template.main, cxx_direct_include = "\n".join(cxx_direct_include), includes = includes, forward_declarations = forward_dec, defs = main_defs, poa = main_poa, obv = main_obv, other_tie = other_tie, operators = main_opers, marshalling = main_marshal, guard = guard, sub_include_pre = sub_include_pre, sub_include_post = sub_include_post)
def monolithic(stream, tree): """Creates one large header with all definitions inside""" guard = id.Name([config.state['Basename']]).guard() header(stream, guard) # Extra DLL include stuff? if config.state['DLLIncludes']: sub_include_pre = output.StringStream() sub_include_post = output.StringStream() sub_include_pre.out(template.sub_include_pre, guard=guard) sub_include_post.out(template.sub_include_post, guard=guard) else: sub_include_pre = "" sub_include_post = "" # Add in any direct C++ from toplevel pragma if present cxx_direct_include = [] directive = "hh " for pragma in tree.pragmas(): # ignore all pragmas but those in the main file if pragma.file() != tree.file(): continue if pragma.text()[:len(directive)] == directive: cxx_direct_include.append(pragma.text()[len(directive):]) includes = output.StringStream() # produce #includes for all files included by the IDL for include in ast.includes(): # skip the main file if ast.mainFile() == include: continue # the old C++ BE makes orb.idl a special case # (might now be a redundant test) # dirname == directory containing the include file # filename == extensionless filename # ext == extension (typically .idl) (root, ext) = os.path.splitext(include) (dirname, filename) = os.path.split(root) # Name for external include guard. Always use the same suffix, # rather than taking suffix from the config. guardname = id.Name([filename]).guard() + "_hh" if config.state['Keep Include Path']: filename = root cxx_include = filename + config.state['HH Suffix'] if config.state['Use Quotes']: cxx_include = '"' + cxx_include + '"' else: cxx_include = "<" + cxx_include + ">" includes.out(template.main_include, guardname=guardname, guard_prefix=config.state['GuardPrefix'], filename=cxx_include) # generate the header definitions def forward_dec(stream=stream, tree=tree): forward = omniidl_be.cxx.header.forward.init(stream) tree.accept(forward) def main_defs(stream=stream, tree=tree): defs = omniidl_be.cxx.header.defs.init(stream) tree.accept(defs) def main_poa(stream=stream, tree=tree): # includes inline (non-flat) tie templates poa = omniidl_be.cxx.header.poa.init(stream) tree.accept(poa) def main_obv(stream=stream, tree=tree): obv = omniidl_be.cxx.header.obv.init(stream) tree.accept(obv) def other_tie(stream=stream, tree=tree): if config.state['Normal Tie'] and config.state['BOA Skeletons']: tie = omniidl_be.cxx.header.tie.BOATieTemplates(stream) tree.accept(tie) if config.state['Flattened Tie']: tie = omniidl_be.cxx.header.tie.FlatTieTemplates(stream) tree.accept(tie) def main_opers(stream=stream, tree=tree): opers = omniidl_be.cxx.header.opers.init(stream) tree.accept(opers) def main_marshal(stream=stream, tree=tree): marshal = omniidl_be.cxx.header.marshal.init(stream) tree.accept(marshal) # other stuff stream.out(template.main, cxx_direct_include="\n".join(cxx_direct_include), includes=includes, forward_declarations=forward_dec, defs=main_defs, poa=main_poa, obv=main_obv, other_tie=other_tie, operators=main_opers, marshalling=main_marshal, guard=guard, sub_include_pre=sub_include_pre, sub_include_post=sub_include_post)