def visitTypedef(node): if node.constrType(): node.aliasType().decl().accept(self) aliasType = types.Type(node.aliasType()) prefix = config.state['Private Prefix'] for d in node.declarators(): scopedName = id.Name(d.scopedName()) guard_name = scopedName.guard() fqname = scopedName.fullyQualify() if d.sizes(): # Array marshal = output.StringStream() skutil.marshall(marshal, None, aliasType, d, "_a", "_s") unmarshal = output.StringStream() skutil.unmarshall(unmarshal, None, aliasType, d, "_a", "_s") stream.out(template.array, guard_name=guard_name, fqname=fqname, marshal=marshal, unmarshal=unmarshal, private_prefix=prefix) elif aliasType.sequence(): stream.out(template.sequence, guard_name=guard_name, fqname=fqname, private_prefix=prefix)
def run(tree): # The implementation template code stream impl_cpp = output.StringStream() # The implementation template header stream impl_h = output.StringStream() bii = BuildInterfaceImplementations(impl_h, impl_cpp, self.ignore_op) tree.accept(bii) # Generate mplementation class template header stream_h.out(class_h, atmark = "@", impl_h = self.impl_h_filename, include_guard = self.include_guard, skel_h = self.skel_filename, file = self.idl_filename, interfaces = str(impl_h)) # Generate implementation class template code stream_cpp.out(class_cpp, atmark = "@", impl_cpp = self.impl_cpp_filename, impl_h = self.impl_h_filename, file = self.idl_filename, interfaces = str(impl_cpp)) self.ifs = [] for n in bii.allInterfaces(): self.ifs.append(string.join(n.scopedName(), "_") + self.suffix) return self.ifs
def run(tree): # first thing is to build the interface implementations decl = output.StringStream() impl = output.StringStream() bii = BuildInterfaceImplementations(decl, impl) tree.accept(bii) object_downcasts_methods = output.StringStream() add_object_downcasts = output.StringStream() biod = BuildInterfaceObjectDowncasts(object_downcasts_methods, add_object_downcasts) tree.accept(biod) openns, closens = namespaces(bii.environment) guard = id.Name([config.state['Basename']]).guard() # Create header file. hpp_stream.out( template.hpp_file, guard_prefix=config.state['GuardPrefix'], guard=guard, includes=bii.includes, idl_hh=prefix + hh_filename, file=idl_filename, interface_declarations=str(decl), open_namespaces=openns, close_namespaces=closens, ) # Create definition of templated functions. hxx_stream.out( template.hxx_file, guard_prefix=config.state['GuardPrefix'], guard=guard, idl_hpp=prefix + hpp_filename, file=idl_filename, interface_implementations=str(impl), open_namespaces=openns, close_namespaces=closens, ) # Create other definition files. cc_stream.out( template.cc_file, idl_hxx=prefix + hxx_filename, file=idl_filename, object_downcasts_methods=object_downcasts_methods, add_object_downcasts=add_object_downcasts, open_namespaces=openns, close_namespaces=closens, )
def buildStateMembersStructure(node): struct = output.StringStream() mangled_name = mangleName(config.state['Private Prefix'] + \ "_valuemember_", node.scopedName()) if alreadyDefined(mangled_name): # no need to regenerate return struct defineName(mangled_name) members = node.statemembers() array = [] if members: for m in members: memberType = types.Type(m.memberType()) access = m.memberAccess() for d in m.declarators(): this_name = id.Name(d.scopedName()).simple() typecode = mkTypeCode(memberType, d, node) array.append('{"%s", %s, %d}' % (this_name, typecode, access)) struct.out("""\ static CORBA::PR_valueMember @mangled_name@[] = { @members@ };""", members=",\n".join(array), mangled_name=mangled_name) else: struct.out("""\ static CORBA::PR_valueMember* @mangled_name@ = 0;""", mangled_name=mangled_name) return struct
def visitStruct(self, node): if not node.identifier().endswith("Storage"): return if not node.members(): return class Storage(object): pass storage = Storage() storage.members = [] for m in node.members(): type = self.toCppNamespace(id.Name(m.memberType().scopedName())).suffix("Ptr_t") for d in m.declarators(): storage.members.append ((type, d.identifier())) storage.sc = hpp_servant_scope(id.Name(node.scopedName())) sc = node.scopedName() sc[-1] = sc[-1][:-7] storage.class_sc = hpp_servant_scope(id.Name(sc)) st = output.StringStream() st.out (template.storage_decl, storage_class_name = storage.sc.simple(), hpp_base_class = storage.class_sc.simple(), storage_attributes = "\n".join([ t.fullyQualify() + " " + n for t,n in storage.members ]), storage_constr_attr_decl = ", ".join([ t.fullyQualify() + " _" + n for t,n in storage.members ]) + ", ", storage_constr_attr_defs = ", " + ", ".join([ n + " (_" + n + ")" for t,n in storage.members ]), storage_attr_call = ", ".join([ n for t,n in storage.members ]) + ", ", ) storage.decl = str(st) self.storages[storage.class_sc.fullyQualify(cxx=0)] = storage
def buildMembersStructure(node): struct = output.StringStream() mangled_name = mangleName(config.state['Private Prefix'] + \ "_structmember_", node.scopedName()) if alreadyDefined(mangled_name): # no need to regenerate return struct defineName(mangled_name) members = node.members() array = [] for m in members: memberType = types.Type(m.memberType()) for d in m.declarators(): this_name = id.Name(d.scopedName()).simple() typecode = mkTypeCode(memberType, d, node) array.append("{\"" + this_name + "\", " + typecode + "}") if len(members) > 0: struct.out("""\ static CORBA::PR_structMember @mangled_name@[] = { @members@ };""", members=",\n".join(array), mangled_name=mangled_name) return struct
def __out_contextDescriptor(self, stream): if self.__contexts: contexts = output.StringStream() for context in self.__contexts: contexts.out('"' + context + '",') stream.out(template.interface_context_array, context_descriptor=self.__context_name, contexts=str(contexts))
def __out_unmarshalArgument(self,stream): if not self.__has_in_args: return marshal_block = output.StringStream() for n, argument in enumerate(self.__arguments): if not argument.is_in(): continue argtype = types.Type(argument.paramType()) ((h_is_const,h_is_ptr),(s_is_holder,s_is_var)) = \ _arg_info(argtype,argument.direction()) arg_n = "arg_%d" % n if s_is_holder: storage_n = arg_n else: storage_n = arg_n + "_" if s_is_var: alloc = "" d_type = argtype.deref(1) if argtype.array(): alloc = argtype.base() + "_alloc()" elif not (d_type.typecode() or d_type.string() or d_type.wstring() or d_type.interface() or d_type.value() or d_type.valuebox()): alloc = "new " + argtype.base() if alloc != "": marshal_block.out(storage_n + " = " + alloc + ";") skutil.unmarshall(marshal_block, None, argtype, None, storage_n, "_n") if not s_is_holder: if s_is_var: if argument.direction() == 0: lvalue = storage_n + ".in()" else: lvalue = storage_n + ".inout()" else: lvalue = storage_n if argtype.array(): lvalue = "&" + lvalue + "[0]" if h_is_ptr: marshal_block.out(arg_n + " = &" + lvalue + ";") else: marshal_block.out(arg_n + " = " + lvalue + ";") if self.__contexts: marshal_block.out(template.interface_proxy_unmarshal_context) stream.out(template.interface_proxy_unmarshal_arguments, call_descriptor = self.__name, marshal_block = marshal_block)
def run(tree): # first thing is to build the interface implementations impl = output.StringStream() bii = BuildInterfaceImplementations(impl) tree.accept(bii) # for each interface we implement we require: # 1. heap allocation allocate = output.StringStream() # 2. POA activation activate = output.StringStream() # 3. reference generation, stringification and output reference = output.StringStream() for i in bii.allInterfaces(): name = id.Name(i.scopedName()) impl_name = impl_fullname(name) # for an implementation class A_B_C_i, generate an instance myA_B_C_i inst_name = "my" + impl_name # allocate an instance of the implementation on the heap allocate.out("@impl_name@* @inst_name@ = new @impl_name@();", impl_name=impl_name, inst_name=inst_name) # activate the object and get a T_var reference to it activate.out("PortableServer::ObjectId_var @inst_name@id = " +\ "poa->activate_object(@inst_name@);", inst_name = inst_name) # get the reference and output it reference.out(template.interface_ior, fqname=name.fullyQualify(cxx=0), inst_name=inst_name) # output the main() routine (all ORB initialisation code etc) stream.out(template.main, idl_hh=self.hh_filename, file=self.idl_filename, interfaces=str(impl), allocate_objects=str(allocate), activate_objects=str(activate), output_references=str(reference))
def hh(self, stream): # build the inheritance list objref_inherits = [] inh = self.interface().inherits() if inh: for i in inh: objref_inherited_name = i.name().prefix("_objref_") uname = objref_inherited_name.unambiguous(self._environment) objref_inherits.append("public virtual " + uname) else: if self.interface().abstract(): objref_inherits = [ "public virtual ::CORBA::_omni_AbstractBaseObjref", "public virtual omniObjRef" ] else: objref_inherits = [ "public virtual ::CORBA::Object", "public virtual omniObjRef" ] if self.interface().abstract(): objref_inherits.append("public virtual " + self.interface().name().simple()) methods = [] for method in self.methods(): if config.state['Virtual Objref Methods']: methods.append(method.hh(virtual = 1, pure = 0)) else: methods.append(method.hh()) if self.ami_methods(): methods.append("\n// AMI methods") for method in self.ami_methods(): methods.append(method.hh()) if config.state['Shortcut']: shortcut = output.StringStream() shortcut.out(header_template.interface_shortcut, name = self.interface().name().simple()) shortcut = str(shortcut) init_shortcut = ": _shortcut(0)" else: shortcut = "" init_shortcut = "" stream.out(header_template.interface_objref, name = self.interface().name().simple(), inherits = ",\n".join(objref_inherits), operations = "\n".join(methods), shortcut = shortcut, init_shortcut = init_shortcut)
def __out_marshalArgument(self, stream): if not (self.__has_in_args or self.__contexts): return marshal_block = output.StringStream() self.__out_marshalArgument_shared(marshal_block, 1) if self.__contexts: marshal_block.out(template.interface_proxy_marshal_context, name=self.__context_name, count=str(len(self.__contexts))) stream.out(template.interface_proxy_marshal_arguments, call_descriptor=self.__name, marshal_block=marshal_block)
def cc(self, stream): inherits = output.StringStream() for i in self.interface().allInherits(): ancestor = i.name().fullyQualify() inherits.out(omniidl_be.cxx.skel.template.interface_pof_repoID, inherited = ancestor) node_name = self.interface().name() objref_name = node_name.prefix("_objref_") pof_name = node_name.prefix("_pof_") stream.out(omniidl_be.cxx.skel.template.interface_pof, pof_name = pof_name.fullyQualify(), objref_fqname = objref_name.fullyQualify(), name = node_name.fullyQualify(), uname = pof_name.simple(), Other_repoIDs = inherits, idname = node_name.guard())
def __out_marshalReturnedValues(self, stream): if not (self.__has_out_args or self.__has_return_value): return marshal_block = output.StringStream() if self.__has_return_value: argtype = types.Type(self.__returntype) ((h_is_const,h_is_ptr),(s_is_holder,s_is_var)) = \ _arg_info(argtype,3) argname = "result" if (h_is_ptr): argname = "*" + argname skutil.marshall(marshal_block, None, argtype, None, argname, "_n") self.__out_marshalArgument_shared(marshal_block, 0) stream.out(template.interface_proxy_marshal_returnedvalues, call_descriptor=self.__name, marshal_block=marshal_block)
def __out_userException(self, stream): if self.__exceptions: block = output.StringStream() exceptions = skutil.sort_exceptions(self.__exceptions) repoIDs = [] for exception in exceptions: scopedName = exception.scopedName() repoID = scopedName + ["_PD_repoId"] repoID_str = id.Name(repoID).fullyQualify() repoIDs.append(repoID_str) exname = id.Name(scopedName).fullyQualify() block.out(template.interface_proxy_exn_handle, repoID_str = repoID_str, exname = exname) # write the user exception template stream.out(template.interface_proxy_exn, call_descriptor = self.__name, exception_block = str(block), exception_namelist = ",\n".join(repoIDs)) else: stream.out(template.interface_proxy_empty_exn, call_descriptor = self.__name)
def visitInterface(self, node): scopedName = id.Name(node.scopedName()) openns, closens = namespaces(scopedName, self.environment) impl_name = scopedName.simple(cxx=1) impl_tpl_name = impl_tplname (scopedName) cxx_fqname = scopedName.fullyQualify() hpp_class = self.toCppNamespace (scopedName).fullyQualify(cxx=1) fqname = scopedName.fullyQualify(cxx = 0) is_base_class = not bool(node.inherits()) ptr_t = self.toCppNamespace (scopedName.suffix("Ptr_t")).fullyQualify(cxx=1) if is_base_class: key = hpp_servant_name (scopedName) impl_base_name = "ServantBase" if key in self.storages: st = self.storages[key] # declare storage self.interface_declarations.out(st.decl) storage = st.sc.simple() + "< "+ptr_t+" >" else: storage = ptr_t else: baseScopedName = id.Name (node.inherits()[0].scopedName()) key = hpp_servant_name (baseScopedName) impl_base_name = hpp_servant_name (baseScopedName.suffix('Servant')) if key in self.storages: st = self.storages[key] storage = st.sc.simple() + "< "+ptr_t+" >" self.storages[fqname] = st else: storage = ptr_t # build methods corresponding to attributes, operations etc. # attributes[] and operations[] will contain lists of function # signatures eg # [ char *echoString(const char *mesg) ] attributes = [] operations = [] allCallables = node.callables() # declarations contains a list of in-class decl signatures # implementations contains a list of out of line impl signatures # (typically differ by classname::) declarations = output.StringStream() implementations = output.StringStream() for c in allCallables: comments = c.comments() hpp_opname = None comments_impl = [] for comment in comments: if comment.text().startswith("// ") or comment.text().startswith("///"): # Skip this comment pass elif comment.text().startswith("//*"): if not comments_impl: comments_impl.append (" // generated from {}:{}\n".format(node.file(), node.line())) comments_impl.append (comment.text()[3:]) elif comment.text().startswith("//->"): if hpp_opname is not None: raise makeError("Function was already renamed", comment.file(), comment.line()) hpp_opname = comment.text()[4:].strip() if isinstance(c, idlast.Attribute): attrType = types.Type(c.attrType()) d_attrType = attrType.deref() for i in c.identifiers(): attribname = id.mapID(i) returnType = attrType.op(types.RET) inType = attrType.op(types.IN) attributes.append(returnType + " " + attribname + "()") # need a set method if not a readonly attribute if not c.readonly(): declarations.out (template.operation_decl_code, return_type = "void", opname = attribname, arg_defs = inType + " _" + attribname) tmpVar, in_conv, out_conv = self.argConversion ("_" + attribname, attrType, True, False, c) implementations.out (template.operation_impl_code, return_type = "void", impl_tpl_name = impl_tpl_name, opname = attribname, hpp_opname = hpp_opname if hpp_opname else attribname, arg_defs = inType + " _" + attribname, in_conversions = in_conv if in_conv else "", out_conversions = out_conv if out_conv else "", store_return = "", do_return = "", arg_calls = tmpVar) declarations.out (template.operation_decl_code, return_type = returnType, opname = attribname, arg_defs = "") store_return, do_return = self.retConversion (attrType) implementations.out (template.operation_impl_code, return_type = returnType, impl_tpl_name = impl_tpl_name, opname = attribname, hpp_opname = hpp_opname if hpp_opname else attribname, arg_defs = "", in_conversions = "", out_conversions = "", store_return = store_return, do_return = do_return, arg_calls = "") elif isinstance(c, idlast.Operation): params = [] paramNames = [] in_conversions = [] out_conversions = [] for p in c.parameters(): paramType = types.Type(p.paramType()) cxx_type = paramType.op(types.direction(p), use_out = 0) argname = id.mapID(p.identifier()) if not comments_impl: tmpVar, in_conv, out_conv = self.argConversion (argname, paramType, p.is_in(), p.is_out(), p) if in_conv: in_conversions.append(in_conv) if out_conv: out_conversions.append(out_conv) else: tmpVar = argname params.append(cxx_type + " " + argname) paramNames.append(tmpVar) # deal with possible "context" if c.contexts() != []: params.append("CORBA::Context_ptr _ctxt") store_return, do_return = self.retConversion (types.Type(c.returnType())) return_type = types.Type(c.returnType()).op(types.RET) opname = id.mapID(c.identifier()) arguments = ", ".join(params) argumentsCall = ", ".join(paramNames) args = opname + "(" + arguments + ")" declarations.out (template.operation_decl_code, return_type = return_type, opname = opname, arg_defs = arguments) if comments_impl: implementations.out (template.provided_operation_impl_code, return_type = return_type, impl_tpl_name = impl_tpl_name, opname = opname, implementation = "".join(comments_impl), arg_defs = arguments,) elif opname in template.predefined_operations_impl_code: #assert not c.parameters(), "Interface operation str should not have arguments" implementations.out (template.predefined_operations_impl_code[opname], return_type = return_type, impl_tpl_name = impl_tpl_name, opname = opname, conversions = "\n ".join(in_conversions), arg_defs = arguments, store_return = store_return, do_return = do_return, arg_calls = argumentsCall) else: implementations.out (template.operation_impl_code, return_type = return_type, impl_tpl_name = impl_tpl_name, opname = opname, hpp_opname = hpp_opname if hpp_opname is not None else opname, in_conversions = "\n ".join(in_conversions), out_conversions = "\n ".join(out_conversions), arg_defs = arguments, store_return = store_return, do_return = do_return, arg_calls = argumentsCall) else: util.fatalError("Internal error generating interface member") raise AssertionError("No code for interface member: "+repr(c)) openns, closens = namespaces(scopedName, self.environment) # Output the _i class definition definition self.interface_declarations.out( template.base_interface_def if is_base_class else template.inherited_interface_def, fq_name = fqname, impl_tpl_name = impl_tpl_name, impl_base_name = impl_base_name, operations = str(declarations), impl_name = impl_name, fq_POA_name = "POA_" + cxx_fqname, hpp_class = hpp_class, storage = storage, open_namespaces = openns, close_namespaces = closens, ) self.interface_implementations.out( template.base_interface_code if is_base_class else template.inherited_interface_code, fqname = fqname, impl_name = impl_name, impl_tpl_name = impl_tpl_name, impl_base_name = impl_base_name, hpp_class = hpp_class, operations = str(implementations), open_namespaces = openns, close_namespaces = closens, )
def cc(self, stream): def _ptrToObjRef_ptr(self=self, stream=stream): has_abstract = self.interface().abstract() for i in self.interface().allInherits(): if i.abstract(): has_abstract = 1 stream.out( omniidl_be.cxx.skel.template.interface_objref_repoID_ptr, inherits_fqname=i.name().fullyQualify()) if has_abstract: stream.out( omniidl_be.cxx.skel.template.interface_objref_repoID_ptr, inherits_fqname="CORBA::AbstractBase") def _ptrToObjRef_str(self=self, stream=stream): has_abstract = self.interface().abstract() for i in self.interface().allInherits(): if i.abstract(): has_abstract = 1 stream.out( omniidl_be.cxx.skel.template.interface_objref_repoID_str, inherits_fqname=i.name().fullyQualify()) if has_abstract: stream.out( omniidl_be.cxx.skel.template.interface_objref_repoID_str, inherits_fqname="CORBA::AbstractBase") # build the inherits list inherits_str_list = [] for i in self.interface().inherits(): objref_name = i.name().prefix("_objref_") objref_str = objref_name.unambiguous(self._environment) if objref_name.needFlatName(self._environment): objref_str = objref_name.flatName() this_inherits_str = objref_str + "(ior, id)" # FIXME: # The powerpc-aix OMNIORB_BASE_CTOR workaround still works here # (in precendence to the flattened base name) but lacking a # powerpc-aix test machine I can't properly test it. It's probably # not required any more. if objref_name.relName(self._environment) != i.name().fullName(): prefix = [] for x in objref_name.fullName(): if x == "_objref_" + objref_name.relName( self._environment)[0]: break prefix.append(x) inherits_scope_prefix = string.join(prefix, "::") + "::" this_inherits_str = "OMNIORB_BASE_CTOR(" + inherits_scope_prefix +\ ")" + this_inherits_str inherits_str_list.append(this_inherits_str) inherits_str = string.join(inherits_str_list, ",\n") if inherits_str: comma = "," else: comma = "" if config.state['Shortcut']: inherits_str = inherits_str + "," init_shortcut = "_shortcut(0)" else: init_shortcut = "" if config.state['Shortcut'] == 2: release_shortcut = omniidl_be.cxx.skel.template.\ interface_release_refcount_shortcut else: release_shortcut = "" stream.out(omniidl_be.cxx.skel.template.interface_objref, name=self.interface().name().fullyQualify(), fq_objref_name=self.name().fullyQualify(), objref_name=self.name().simple(), inherits_str=inherits_str, comma=comma, _ptrToObjRef_ptr=_ptrToObjRef_ptr, _ptrToObjRef_str=_ptrToObjRef_str, init_shortcut=init_shortcut, release_shortcut=release_shortcut) shortcut_mode = config.state['Shortcut'] if shortcut_mode: inherited = output.StringStream() for i in self.interface().inherits(): objref_name = i.name().prefix("_objref_") objref_str = objref_name.unambiguous(self._environment) if objref_name.needFlatName(self._environment): objref_str = objref_name.flatName() inherited.out( omniidl_be.cxx.skel.template.interface_shortcut_inh, parent=objref_str) if shortcut_mode == 1: tmpl = omniidl_be.cxx.skel.template.interface_shortcut else: tmpl = omniidl_be.cxx.skel.template.interface_shortcut_refcount stream.out(tmpl, name=self.interface().name().fullyQualify(), basename=self.interface().name().simple(), fq_objref_name=self.name().fullyQualify(), inherited=str(inherited)) for method in self.methods(): callable = self._callables[method] # signature is a text string form of the complete operation signature signature = callable.signature() # we only need one descriptor for each _signature_ (not operation) if _proxy_call_descriptors.has_key(signature): call_descriptor = _proxy_call_descriptors[signature] else: call_descriptor = call.CallDescriptor(signature, callable) call_descriptor.out_desc(stream) _proxy_call_descriptors[signature] = call_descriptor # produce a localcall function node_name = self.interface().name() localcall_fn = descriptor.local_callback_fn( node_name, callable.operation_name(), signature) call_descriptor.out_localcall(stream, node_name, callable.method_name(), localcall_fn) # produce member function for this operation/attribute. body = output.StringStream() argnames = method.arg_names() if config.state['Shortcut']: if method.return_type().kind() != idltype.tk_void: callreturn = "return " voidreturn = "" else: callreturn = "" voidreturn = " return;" objref_class = method.parent_class() interface = objref_class.interface() implname = interface.name().prefix("_impl_").unambiguous( self._environment) if config.state['Shortcut'] == 2: tmpl = omniidl_be.cxx.skel.template.\ interface_operation_shortcut_refcount else: tmpl = omniidl_be.cxx.skel.template.\ interface_operation_shortcut body.out(tmpl, impl_type=implname, callreturn=callreturn, voidreturn=voidreturn, args=string.join(argnames, ", "), name=method.name()) intf_env = self._environment.enter( "_objref_" + self.interface().name().simple()) call_descriptor.out_objrefcall(body, callable.operation_name(), argnames, localcall_fn, intf_env) method.cc(stream, body)
def visitException(node): scopedName = id.Name(node.scopedName()) name = scopedName.simple() outer_environment = id.lookup(node) environment = outer_environment.enter(name) scoped_name = scopedName.fullyQualify() # build the default ctor, copy ctor, assignment operator copy_ctor_body = output.StringStream() default_ctor_body = output.StringStream() default_ctor_args = [] assign_op_body = output.StringStream() has_default_ctor = 0 for m in node.members(): has_default_ctor = 1 memberType = types.Type(m.memberType()) if m.constrType(): memberType.type().decl().accept(self) d_memberType = memberType.deref() memberType_fqname = memberType.base() for d in m.declarators(): decl_scopedName = id.Name(d.scopedName()) decl_name = decl_scopedName.simple() decl_dims = d.sizes() full_dims = decl_dims + memberType.dims() is_array = full_dims != [] is_array_declarator = decl_dims != [] memberType_name_arg = memberType.op(types.IN, environment) if is_array_declarator: # we use the internal typedef'ed type if the member is an array # declarator memberType_name_arg = "const " +\ config.state['Private Prefix'] +\ "_" + decl_name elif d_memberType.sequence(): if memberType.typedef(): memberType_name_arg = "const " + id.Name(memberType.type( ).decl().scopedName()).unambiguous(environment) else: memberType_name_arg = "const " + memberType.sequenceTemplate( environment) elif memberType.typecode(): memberType_name_arg = "::CORBA::TypeCode_ptr" index = "" if is_array: blocks = [ cxx.Block(copy_ctor_body), cxx.Block(default_ctor_body), cxx.Block(assign_op_body) ] loops = [ cxx.For(copy_ctor_body, full_dims), cxx.For(default_ctor_body, full_dims), cxx.For(assign_op_body, full_dims) ] index = loops[0].index() # all the same copy_ctor_body.out("""\ @member_name@@index@ = _s.@member_name@@index@;""", member_name=decl_name, index=index) if (d_memberType.interface() and not is_array): # these are special resources which need to be explicitly # duplicated (but not if an array?) duplicate = memberType_fqname.replace("_ptr", "") + \ "::_duplicate" if isinstance(d_memberType.type().decl(), idlast.Forward): duplicate = duplicate.replace("::_dup", "_Helper::dup") default_ctor_body.out("""\ @duplicate@(_@member_name@@index@);""", duplicate=duplicate, member_name=decl_name, index=index) default_ctor_args.append(memberType_name_arg + " _" + decl_name) default_ctor_body.out("""\ @member_name@@index@ = _@member_name@@index@;""", member_name=decl_name, index=index) assign_op_body.out("""\ @member_name@@index@ = _s.@member_name@@index@;""", member_name=decl_name, index=index) if is_array: for loop in loops: loop.end() for block in blocks: block.end() default_ctor = output.StringStream() if has_default_ctor: default_ctor.out(template.exception_default_ctor, scoped_name=scoped_name, name=name, ctor_args=", ".join(default_ctor_args), default_ctor_body=str(default_ctor_body)) # write the main chunk stream.out(template.exception, scoped_name=scoped_name, name=name, copy_ctor_body=str(copy_ctor_body), default_ctor=str(default_ctor), ctor_args=", ".join(default_ctor_args), default_ctor_body=str(default_ctor_body), repoID=node.repoId(), assign_op_body=str(assign_op_body)) # deal with marshalling and demarshalling needs_marshalling = node.members() != [] marshal = output.StringStream() unmarshal = output.StringStream() for m in node.members(): memberType = types.Type(m.memberType()) d_memberType = memberType.deref() for d in m.declarators(): decl_scopedName = id.Name(d.scopedName()) decl_name = decl_scopedName.simple() is_array_declarator = d.sizes() != [] skutil.unmarshall(unmarshal, environment, memberType, d, decl_name, "_n") skutil.marshall(marshal, environment, memberType, d, decl_name, "_n") if needs_marshalling: stream.out(template.exception_operators, scoped_name=scoped_name, marshal=str(marshal), unmarshal=str(unmarshal)) return
def visitUnion(node): outer_environment = id.lookup(node) environment = outer_environment.enter(node.identifier()) scopedName = id.Name(node.scopedName()) name = scopedName.fullyQualify() switchType = types.Type(node.switchType()) exhaustive = ast.exhaustiveMatch(switchType, ast.allCaseLabelValues(node)) defaultCase = ast.defaultCase(node) ast.markDefaultCase(node) hasDefault = defaultCase != None # deal with types constructed here if node.constrType(): node.switchType().decl().accept(self) for n in node.cases(): if n.constrType(): n.caseType().decl().accept(self) # -------------------------------------------------------------- # union::operator{>>, <<}= (cdrStream& _n) [const] # # marshal/ unmarshal individual cases marshal_discriminator = output.StringStream() unmarshal_discriminator = output.StringStream() skutil.marshall(marshal_discriminator, environment, switchType, None, "_pd__d", "_n") skutil.unmarshall(unmarshal_discriminator, environment, switchType, None, "_pd__d", "_n") marshal_cases = output.StringStream() unmarshal_cases = output.StringStream() for c in node.cases(): caseType = types.Type(c.caseType()) decl = c.declarator() decl_scopedName = id.Name(decl.scopedName()) decl_name = decl_scopedName.simple() if defaultCase == c: isDefault = 1 else: isDefault = 0 for l in c.labels(): value = l.value() discrim_value = switchType.literal(value, environment) if l.default(): unmarshal_cases.out("default:") marshal_cases.out("default:") else: unmarshal_cases.out("case " + discrim_value + ":") marshal_cases.out("case " + discrim_value + ":") marshal_cases.inc_indent() skutil.marshall(marshal_cases, environment, caseType, decl, "_pd_" + decl_name, "_n", is_union=1) marshal_cases.out("break;") marshal_cases.dec_indent() unmarshal_cases.inc_indent() unmarshal_cases.out("_pd__default = %d;" % isDefault) skutil.unmarshall(unmarshal_cases, environment, caseType, decl, "_pd_" + decl_name, "_n", is_union=1) unmarshal_cases.out("break;") unmarshal_cases.dec_indent() if not hasDefault and not exhaustive: unmarshal_cases.out("""\ default: _pd__default = 1; break;""") # write the operators stream.out(template.union_operators, name=name, marshal_discriminator=str(marshal_discriminator), unmarshal_discriminator=str(unmarshal_discriminator), marshal_cases=str(marshal_cases), unmarshal_cases=str(unmarshal_cases)) return
def __out_unmarshalReturnedValues(self, stream): if not (self.__has_out_args or self.__has_return_value): return marshal_block = output.StringStream() if self.__has_return_value: argtype = types.Type(self.__returntype) ((h_is_const,h_is_ptr),(s_is_holder,s_is_var)) = \ _arg_info(argtype,3) argname = "result" if s_is_var: alloc = "" d_type = argtype.deref(1) if argtype.array(): alloc = argtype.base() + "_alloc()" elif not (d_type.typecode() or d_type.string() or d_type.wstring() or d_type.interface() or d_type.value() or d_type.valuebox()): alloc = "new " + argtype.base() if alloc != "": marshal_block.out(argname + " = " + alloc + ";") skutil.unmarshall(marshal_block, None, argtype, None, argname, "_n") for n, argument in enumerate(self.__arguments): if not argument.is_out(): continue argtype = types.Type(argument.paramType()) ((h_is_const,h_is_ptr),(s_is_holder,s_is_var)) = \ _arg_info(argtype,argument.direction()) arg_n = "arg_" + str(n) d_type = argtype.deref(1) if s_is_holder: if s_is_var: alloc = "" if argtype.array(): alloc = argtype.base() + "_alloc()" elif not (d_type.typecode() or d_type.string() or d_type.wstring() or d_type.interface() or d_type.value() or d_type.valuebox()): alloc = "new " + argtype.base() if alloc != "": marshal_block.out(arg_n + " = " + alloc + ";") elif h_is_ptr: if d_type.typecode(): marshal_block.out(arg_n + "_ = *" + arg_n + ";\n"+ \ "*" + arg_n + " = " + \ "::CORBA::TypeCode::_nil();") elif d_type.interface(): nilobjref = d_type.base().replace("_ptr", "::_nil()") if isinstance(d_type.type().decl(), idlast.Forward): nilobjref = nilobjref.replace("::_nil()", "_Helper::_nil()") marshal_block.out(arg_n + "_ = *" + arg_n + ";\n" + \ "*" + arg_n + " = " + \ nilobjref + ";") elif d_type.string(): marshal_block.out(arg_n + "_ = *" + arg_n + ";\n"+ \ "*" + arg_n + " = " + \ "(char*) _CORBA_String_helper::empty_string;") elif d_type.wstring(): marshal_block.out(arg_n + "_ = *" + arg_n + ";\n" + \ "*" + arg_n + " = " + \ "(::CORBA::WChar*) _CORBA_WString_helper::empty_wstring;") arg_n = "*" + arg_n skutil.unmarshall(marshal_block, None, argtype, None, arg_n, "_n") stream.out(template.interface_proxy_unmarshal_returnedvalues, call_descriptor=self.__name, marshal_block=marshal_block)
def visitUnion(node): scopedName = node.scopedName() mangled_name = mangleName(config.state['Private Prefix'] +\ "_tc_", scopedName) if alreadyDefined(mangled_name): return startingNode(node) # the key here is to redirect the bottom half to a buffer # just for now oldbottomhalf = self.bottomhalf self.bottomhalf = output.StringStream() insideModule = self.__immediatelyInsideModule self.__immediatelyInsideModule = 0 # need to build a static array of node members in a similar fashion # to structs array = [] switchType = types.Type(node.switchType()) deref_switchType = switchType.deref() if isinstance(switchType.type(), idltype.Declared): save_resolving_dependency = self.__resolving_dependency if not node.constrType(): self.__resolving_dependency = 1 switchType.type().decl().accept(self) self.__resolving_dependency = save_resolving_dependency numlabels = 0 numcases = 0 hasDefault = None for c in node.cases(): numcases = numcases + 1 decl = c.declarator() caseType = types.Type(c.caseType()) save_resolving_dependency = self.__resolving_dependency if not c.constrType(): self.__resolving_dependency = 1 if isinstance(caseType.type(), idltype.Declared): caseType.type().decl().accept(self) elif caseType.sequence(): # anonymous sequence seqType = caseType.type().seqType() while isinstance(seqType, idltype.Sequence): seqType = seqType.seqType() if isinstance(seqType, idltype.Declared): # don't loop forever if not currently_being_defined(seqType.decl()): seqType.decl().accept(self) self.__resolving_dependency = save_resolving_dependency typecode = mkTypeCode(caseType, decl, node) case_name = id.Name(decl.scopedName()).simple() for l in c.labels(): if l.default(): label = "0" hasDefault = numlabels else: label = switchType.literal(l.value()) array.append('{"%s", %s, (CORBA::PR_unionDiscriminator)%s}' % (case_name, typecode, label)) numlabels = numlabels + 1 discrim_tc = mkTypeCode(deref_switchType) repoID = node.repoId() union_name = id.Name(scopedName).simple() unionmember_mangled_name = mangleName( config.state['Private Prefix'] + "_unionMember_", scopedName) default_str = "" if hasDefault is None: default_str = "-1" else: default_str = str(hasDefault) tophalf.out("""\ static CORBA::PR_unionMember @unionmember_mangled_name@[] = { @members@ }; #ifdef @mangled_name@ # undef @mangled_name@ #endif static CORBA::TypeCode_ptr @mangled_name@ = CORBA::TypeCode::PR_union_tc("@repoID@", "@name@", @discrim_tc@, @unionmember_mangled_name@, @labels@, @default_str@, &@pprefix@_tcTrack);""", mangled_name=mangled_name, repoID=repoID, discrim_tc=discrim_tc, unionmember_mangled_name=unionmember_mangled_name, name=union_name, labels=str(numlabels), default_str=default_str, members=",\n".join(array), pprefix=config.state['Private Prefix']) defineName(unionmember_mangled_name) defineName(mangled_name) self.__immediatelyInsideModule = insideModule external_linkage(node) # restore the old bottom half oldbottomhalf.out(str(self.bottomhalf)) self.bottomhalf = oldbottomhalf finishingNode()
def visitUnion(node): outer_environment = id.lookup(node) environment = outer_environment.enter(node.identifier()) scopedName = id.Name(node.scopedName()) name = scopedName.fullyQualify() switchType = types.Type(node.switchType()) exhaustive = ast.exhaustiveMatch(switchType, ast.allCaseLabelValues(node)) defaultCase = ast.defaultCase(node) ast.markDefaultCase(node) defaultMember = "" if defaultCase: defaultLabel = ast.defaultLabel(defaultCase) default_scopedName = id.Name(defaultCase.declarator().scopedName()) defaultMember = default_scopedName.simple() hasDefault = defaultCase != None # Booleans are a special case (isn't everything?) booleanWrap = switchType.boolean() and exhaustive # deal with types constructed here if node.constrType(): node.switchType().decl().accept(self) for n in node.cases(): if n.constrType(): n.caseType().decl().accept(self) # -------------------------------------------------------------- # union::operator{>>, <<}= (cdrStream& _n) [const] # # marshal/ unmarshal individual cases marshal_discriminator = output.StringStream() unmarshal_discriminator = output.StringStream() skutil.marshall(marshal_discriminator,environment, switchType, None, "_pd__d", "_n") skutil.unmarshall(unmarshal_discriminator,environment, switchType, None, "_pd__d", "_n") marshal_cases = output.StringStream() unmarshal_cases = output.StringStream() for c in node.cases(): caseType = types.Type(c.caseType()) decl = c.declarator() decl_scopedName = id.Name(decl.scopedName()) decl_name = decl_scopedName.simple() # *** HERE: only output code once for each case, no matter how # *** many labels; don't bother with the default check -- do # *** it with the switch. Don't think we need _pd__default # *** member. if defaultCase == c: isDefault = 1 else: isDefault = 0 for l in c.labels(): value = l.value() discrim_value = switchType.literal(value, environment) if l.default(): unmarshal_cases.out("default:") else: unmarshal_cases.out("case " + discrim_value + ":") marshal_cases.out("case " + discrim_value + ":") marshal_cases.inc_indent() skutil.marshall(marshal_cases, environment, caseType, decl, "_pd_" + decl_name, "_n") marshal_cases.out("break;") marshal_cases.dec_indent() unmarshal_cases.inc_indent() unmarshal_cases.out("_pd__default = " + str(isDefault) + ";") skutil.unmarshall(unmarshal_cases, environment, caseType, decl, "_pd_" + decl_name, "_n") unmarshal_cases.out("break;") unmarshal_cases.dec_indent() if not hasDefault and not exhaustive: unmarshal_cases.out("""\ default: _pd__default = 1; break;""") if booleanWrap: marshal_cases.out(template.union_default_bool) else: marshal_cases.out(template.union_default) def marshal(stream = stream, exhaustive = exhaustive, hasDefault = hasDefault, defaultCase = defaultCase, environment = environment, defaultMember = defaultMember, marshal_cases = marshal_cases): if not exhaustive: def default(stream = stream, exhaustive = exhaustive, hasDefault = hasDefault, defaultCase = defaultCase, environment = environment, defaultMember = defaultMember): if hasDefault: caseType = types.Type(defaultCase.caseType()) decl = defaultCase.declarator() decl_scopedName = id.Name(decl.scopedName()) decl_name = decl_scopedName.simple() skutil.marshall(stream, environment, caseType, decl, "_pd_" + decl_name, "_n") stream.out(template.union_operators_nonexhaustive, default = default, cases = str(marshal_cases)) else: stream.out(template.union_operators_exhaustive, cases = str(marshal_cases)) # write the operators stream.out(template.union_operators, name = name, marshal_discriminator = str(marshal_discriminator), unmarshal_discriminator = str(unmarshal_discriminator), marshal_cases = marshal, unmarshal_cases = str(unmarshal_cases)) return
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 out_localcall(self, stream, interface_name, operation, function_name): assert isinstance(stream, output.Stream) assert isinstance(interface_name, id.Name) impl_args = [] for n, argument in enumerate(self.__arguments): arg_n = "tcd->arg_" + str(n) argtype = types.Type(argument.paramType()) ((h_is_const,h_is_ptr),(s_is_holder,s_is_var)) = \ _arg_info(argtype,argument.direction()) if h_is_ptr: arg_n = "*" + arg_n if s_is_holder and s_is_var: if argument.is_in(): if argument.is_out(): arg_n = arg_n + ".inout()" else: arg_n = arg_n + ".in()" else: arg_n = arg_n + ".out()" impl_args.append(arg_n) if self.__has_return_value: result_string = "tcd->result = " else: result_string = "" if self.__contexts: impl_args.append("ctxt") # If we have no return value, no arguments, no exceptions, and # no contexts, we don't use the call descriptor argument at # all, so we do not give it a name, so as to avoid warnings on # some compilers. if result_string or impl_args or self.__exceptions or self.__contexts: cd_arg = " cd" else: cd_arg = "" # If we have no return value and no arguments at all then we don't # need to fetch the call descriptor. This suppresses a warning in gcc # about an unused variable. if result_string or impl_args: get_cd = self.__name + "* tcd = (" + self.__name + "*)cd;" else: get_cd = "" impl_call = output.StringStream() catch = output.StringStream() # Deal with context if self.__contexts: impl_call.out(template.interface_callback_context, cname=self.__context_name, count=str(len(self.__contexts))) # Deal with user exceptions raises = self.__exceptions if raises: for exception in raises: ex_scopedName = id.Name(exception.scopedName()) catch.out(template.interface_operation_catch_exn, exname=ex_scopedName.fullyQualify()) impl_call.out(template.interface_callback_tryblock, result=result_string, cxx_operation_name=operation, operation_arguments=", ".join(impl_args), catch=str(catch)) else: impl_call.out(template.interface_callback_invoke, result=result_string, cxx_operation_name=operation, operation_arguments=", ".join(impl_args)) stream.out(template.interface_callback, local_call_descriptor=function_name, cd_arg=cd_arg, get_call_descriptor=get_cd, impl_fqname=interface_name.prefix("_impl_").fullyQualify(), name=interface_name.fullyQualify(), impl_call=str(impl_call))
def visitValue(node): # Used for abstract value too startingNode(node) scopedName = node.scopedName() mangled_name = mangleName(config.state['Private Prefix'] + "_tc_", scopedName) visitValueForward(node) # the key here is to redirect the bottom half to a buffer # just for now oldbottomhalf = self.bottomhalf self.bottomhalf = output.StringStream() insideModule = self.__immediatelyInsideModule self.__immediatelyInsideModule = 0 # handle nested types for n in node.declarations(): n.accept(self) # create the static typecodes for constructed types by setting # the resolving_dependency flag and recursing save_resolving_dependency = self.__resolving_dependency for child in node.statemembers(): memberType = child.memberType() if child.constrType(): self.__resolving_dependency = save_resolving_dependency else: self.__resolving_dependency = 1 if isinstance(memberType, idltype.Declared): decl = memberType.decl() if not currently_being_defined(decl): decl.accept(self) elif isinstance(memberType, idltype.Sequence): # anonymous sequence (maybe sequence<sequence<...<T>>>) # Find the ultimate base type, and if it's user declared then # produce a typecode definition for it. base_type = memberType.seqType() while isinstance(base_type, idltype.Sequence): base_type = base_type.seqType() if isinstance(base_type, idltype.Declared): decl = base_type.decl() if not currently_being_defined(decl): decl.accept(self) self.__resolving_dependency = save_resolving_dependency tophalf.out(str(buildStateMembersStructure(node))) if not alreadyDefined(mangled_name): # only define the name once defineName(mangled_name) valuemember_mangled_name = mangleName( config.state['Private Prefix'] + "_valuemember_", scopedName) assert alreadyDefined(valuemember_mangled_name) num = numStateMembers(node) repoID = node.repoId() value_name = id.Name(scopedName).simple() # Value modifiers modifierl = [] if isinstance(node, idlast.Value): if node.custom(): modifierl.append("CORBA::VM_CUSTOM") if node.truncatable(): modifierl.append("CORBA::VM_TRUNCATABLE") else: assert isinstance(node, idlast.ValueAbs) modifierl.append("CORBA::VM_ABSTRACT") if modifierl: modifiers = "|".join(modifierl) else: modifiers = "CORBA::VM_NONE" # Concrete base inherits = node.inherits() if (isinstance(node, idlast.Value) and inherits and isinstance(inherits[0], idlast.Value)): visitValueForward(inherits[0]) bscopedName = inherits[0].scopedName() concrete_base = mangleName(config.state['Private Prefix'] + "_tc_", bscopedName) else: concrete_base = "CORBA::TypeCode::PR_null_tc()" tophalf.out("""\ #ifdef @mangled_name@ # undef @mangled_name@ #endif static CORBA::TypeCode_ptr @mangled_name@ = CORBA::TypeCode::PR_value_tc("@repoID@", "@name@", @modifiers@, @concrete_base@, @valuemember_mangled_name@, @n@, &@pprefix@_tcTrack); """, mangled_name=mangled_name, modifiers=modifiers, concrete_base=concrete_base, valuemember_mangled_name=valuemember_mangled_name, name=value_name, n=str(num), repoID=repoID, pprefix=config.state['Private Prefix']) self.__immediatelyInsideModule = insideModule external_linkage(node) # restore the old bottom half oldbottomhalf.out(str(self.bottomhalf)) self.bottomhalf = oldbottomhalf finishingNode()
def cc(self, stream): def _ptrToObjRef_ptr(self=self, stream=stream): has_abstract = self.interface().abstract() for i in self.interface().allInherits(): if i.abstract(): has_abstract = 1 stream.out(skel_template.interface_objref_repoID_ptr, inherits_fqname=i.name().fullyQualify()) if has_abstract: stream.out(skel_template.interface_objref_repoID_ptr, inherits_fqname="CORBA::AbstractBase") def _ptrToObjRef_str(self=self, stream=stream): has_abstract = self.interface().abstract() for i in self.interface().allInherits(): if i.abstract(): has_abstract = 1 stream.out(skel_template.interface_objref_repoID_str, inherits_fqname=i.name().fullyQualify()) if has_abstract: stream.out(skel_template.interface_objref_repoID_str, inherits_fqname="CORBA::AbstractBase") # # Build the inherits list inherits_str_list = [] for i in self.interface().inherits(): objref_name = i.name().prefix("_objref_") objref_str = objref_name.unambiguous(self._environment) if objref_name.needFlatName(self._environment): objref_str = objref_name.flatName() this_inherits_str = objref_str + "(ior, id)" inherits_str_list.append(this_inherits_str) inherits_str = ",\n".join(inherits_str_list) if inherits_str: comma = "," else: comma = "" if config.state['Shortcut']: inherits_str = inherits_str + "," init_shortcut = "_shortcut(0)" else: init_shortcut = "" if config.state['Shortcut'] == 2: release_shortcut = skel_template.interface_release_refcount_shortcut else: release_shortcut = "" stream.out(skel_template.interface_objref, name=self.interface().name().fullyQualify(), fq_objref_name=self.name().fullyQualify(), objref_name=self.name().simple(), inherits_str=inherits_str, comma=comma, _ptrToObjRef_ptr=_ptrToObjRef_ptr, _ptrToObjRef_str=_ptrToObjRef_str, init_shortcut=init_shortcut, release_shortcut=release_shortcut) # # Shortcut shortcut_mode = config.state['Shortcut'] if shortcut_mode: inherited = output.StringStream() for i in self.interface().inherits(): objref_name = i.name().prefix("_objref_") objref_str = objref_name.unambiguous(self._environment) if objref_name.needFlatName(self._environment): objref_str = objref_name.flatName() inherited.out(skel_template.interface_shortcut_inh, parent=objref_str) if shortcut_mode == 1: tmpl = skel_template.interface_shortcut else: tmpl = skel_template.interface_shortcut_refcount stream.out(tmpl, name=self.interface().name().fullyQualify(), basename=self.interface().name().simple(), fq_objref_name=self.name().fullyQualify(), inherited=str(inherited)) # # AMI poller poller = self.interface().amiPoller() poller_impl_name = None poller_methods = {} if poller is not None: astdecl = poller.astdecl() poller_impl_name = descriptor.ami_poller_impl(poller.name()) poller_class = AMIPoller(poller_impl_name) method_decls = [] inherited_methods = [] direct_callables = astdecl.callables() for c in astdecl.all_callables(): op = call.operation(poller, c) method_decl = _impl_Method(op, poller_class) method_decls.append(method_decl.hh()) if c not in direct_callables: inherited_methods.append(method_decl) else: poller_methods[op.operation_name()] = method_decl stream.out(skel_template.interface_ami_poller_impl, poller_impl_name=poller_impl_name, poller_name=poller.name().fullyQualify(), method_decls="\n".join(method_decls)) for method in inherited_methods: method.cc(stream, "_wrongOperation();") # # Methods ami_descriptors = {} for method in self.methods(): callable = self._callables[method] stream.out(skel_template.interface_operation_marker, iface=self.interface().name().fullyQualify(), operation=callable.operation_name()) # signature is a text string form of the complete # operation signature signature = callable.signature() # we only need one descriptor for each _signature_ (not operation) if signature in _proxy_call_descriptors: call_descriptor = _proxy_call_descriptors[signature] else: call_descriptor = call.CallDescriptor(signature, callable) call_descriptor.out_desc(stream) _proxy_call_descriptors[signature] = call_descriptor # produce a localcall function node_name = self.interface().name() localcall_fn = descriptor.\ local_callback_fn(node_name, callable.operation_name(), signature) call_descriptor.out_localcall(stream, node_name, callable.method_name(), localcall_fn) # produce member function for this operation/attribute. body = output.StringStream() argnames = method.arg_names() if config.state['Shortcut']: if method.return_type().kind() != idltype.tk_void: callreturn = "return " voidreturn = "" else: callreturn = "" voidreturn = " return;" objref_class = method.parent_class() interface = objref_class.interface() implname = interface.name().prefix("_impl_").\ unambiguous(self._environment) if config.state['Shortcut'] == 2: tmpl = skel_template.interface_operation_shortcut_refcount else: tmpl = skel_template.interface_operation_shortcut body.out(tmpl, impl_type=implname, callreturn=callreturn, voidreturn=voidreturn, args=", ".join(argnames), name=method.name()) intf_env = self._environment.enter( "_objref_" + self.interface().name().simple()) call_descriptor.out_objrefcall(body, callable.operation_name(), argnames, localcall_fn, intf_env) method.cc(stream, body) # Generate AMI descriptor if callable.ami(): cd_names = call_descriptor.out_ami_descriptor( stream, callable, node_name, localcall_fn, poller_impl_name) for ami_method in method._ami_methods: ami_callable = ami_method.callable() body = output.StringStream() ami_op_name = ami_callable.operation_name() if ami_op_name.startswith("sendc_"): call_descriptor.out_ami_sendc(body, ami_method, cd_names, intf_env) else: # sendp call_descriptor.out_ami_sendp(body, ami_method, cd_names, intf_env) poller_body = output.StringStream() poller_method = poller_methods[ami_op_name[6:]] call_descriptor.out_ami_poller(poller_body, ami_method, poller_method, cd_names) poller_method.cc(stream, poller_body) ami_method.cc(stream, body)
def cc(self, stream): def _ptrToObjRef_ptr(self=self, stream=stream): has_abstract = 0 for i in self.interface().allInherits(): if i.abstract(): has_abstract = 1 stream.out(skel_template.interface_objref_repoID_ptr, inherits_fqname=i.name().fullyQualify()) stream.out(skel_template.interface_objref_repoID_ptr, inherits_fqname="CORBA::LocalObject") if has_abstract: stream.out(skel_template.interface_objref_repoID_ptr, inherits_fqname="CORBA::AbstractBase") def _ptrToObjRef_str(self=self, stream=stream): has_abstract = 0 for i in self.interface().allInherits(): if i.abstract(): has_abstract = 1 stream.out(skel_template.interface_objref_repoID_str, inherits_fqname=i.name().fullyQualify()) stream.out(skel_template.interface_objref_repoID_str, inherits_fqname="CORBA::LocalObject") if has_abstract: stream.out(skel_template.interface_objref_repoID_str, inherits_fqname="CORBA::AbstractBase") stream.out(skel_template.local_interface_objref, name=self.interface().name().fullyQualify(), sname=self.interface().name().simple(), fq_nil_name=self.name().fullyQualify(), nil_name=self.name().simple(), _ptrToObjRef_ptr=_ptrToObjRef_ptr, _ptrToObjRef_str=_ptrToObjRef_str) for method in self.methods(): callable = self._callables[method] # signature is a text string form of the complete # operation signature signature = callable.signature() # produce member function for this operation/attribute. body = output.StringStream() argnames = method.arg_names() body.out(skel_template.local_interface_nil_operation) if not method.return_type().void(): body.out(skel_template.local_interface_nil_dummy_return, method=method.name(), args=", ".join(method.arg_names())) method.cc(stream, body) stream.out("\n")
def write_template(name, inherits, node, stream, Template=template.tie_template): # build methods which bind the interface operations and attributes # note that this includes inherited callables since tie # templates are outside the normal inheritance structure where = output.StringStream() # defined_so_far contains keys corresponding to method names which # have been defined already (and which should not be included twice) def buildCallables(interface, where, continuation, defined_so_far={}): interface = ast.remove_ast_typedefs(interface) callables = interface.callables() operations = filter(lambda x: isinstance(x, idlast.Operation), callables) for operation in operations: returnType = types.Type(operation.returnType()) identifier = operation.identifier() if (defined_so_far.has_key(identifier)): # don't repeat it continue defined_so_far[identifier] = 1 parameters = operation.parameters() has_return_value = not returnType.void() # FIXME: return types are fully scoped but argument types # arent? returnType_name = returnType.op(types.RET) operation_name = id.mapID(identifier) signature = [] call = [] for parameter in parameters: paramType = types.Type(parameter.paramType()) # Need to call the _impl operation not the _objref operation param_type_name = paramType.op(types.direction(parameter), use_out=0) param_id = id.mapID(parameter.identifier()) signature.append(param_type_name + " " + param_id) call.append(param_id) # deal with call contextx if operation.contexts() != []: signature.append("::CORBA::Context_ptr _ctxt") call.append("_ctxt") if has_return_value: return_str = "return " else: return_str = "" where.out("""\ @return_type_name@ @operation_name@(@signature@) { @return_str@pd_obj->@operation_name@(@call@); }""", return_type_name=returnType_name, operation_name=operation_name, return_str=return_str, signature=", ".join(signature), call=", ".join(call)) attributes = filter(lambda x: isinstance(x, idlast.Attribute), callables) for attribute in attributes: identifiers = attribute.identifiers() attrType = types.Type(attribute.attrType()) attrType_name_RET = attrType.op(types.RET) attrType_name_IN = attrType.op(types.IN) for identifier in identifiers: if defined_so_far.has_key(identifier): # don't repeat it continue defined_so_far[identifier] = 1 ident = id.mapID(identifier) where.out("""\ @attr_type_ret_name@ @attribute_name@() { return pd_obj->@attribute_name@(); }""", attr_type_ret_name=attrType_name_RET, attribute_name=ident) if not attribute.readonly(): where.out("""\ void @attribute_name@(@attr_type_in_name@ _value) { pd_obj->@attribute_name@(_value); }""", attribute_name=ident, attr_type_in_name=attrType_name_IN) # do the recursive bit for i in interface.inherits(): i = i.fullDecl() continuation(i, where, continuation, defined_so_far) # done return buildCallables(node, where, buildCallables) stream.out(Template, tie_name=name, inherits=inherits, callables=str(where)) return
def visitException(node): scopedName = node.scopedName() mangled_name = mangleName(config.state['Private Prefix'] + "_tc_", scopedName) if alreadyDefined(mangled_name): return defineName(mangled_name) startingNode(node) # the key here is to redirect the bottom half to a buffer # just for now oldbottomhalf = self.bottomhalf self.bottomhalf = output.StringStream() # create the static typecodes for constructed types by setting # the resolving_dependency flag and recursing save_resolving_dependency = self.__resolving_dependency insideModule = self.__immediatelyInsideModule self.__immediatelyInsideModule = 0 for child in node.members(): memberType = child.memberType() if child.constrType(): self.__resolving_dependency = save_resolving_dependency else: self.__resolving_dependency = 1 if isinstance(memberType, idltype.Declared): memberType.decl().accept(self) self.__resolving_dependency = save_resolving_dependency self.__immediatelyInsideModule = insideModule # output the structure of members tophalf.out(str(buildMembersStructure(node))) num = numMembers(node) repoID = node.repoId() ex_name = id.Name(scopedName).simple() structmember_mangled_name = mangleName(config.state['Private Prefix'] + \ "_structmember_", scopedName) if num == 0: structmember_mangled_name = "(CORBA::PR_structMember*) 0" tophalf.out("""\ static CORBA::TypeCode_ptr @mangled_name@ = CORBA::TypeCode::PR_exception_tc("@repoID@", "@name@", @structmember_mangled_name@, @n@, &@pprefix@_tcTrack);""", mangled_name=mangled_name, name=ex_name, n=str(num), structmember_mangled_name=structmember_mangled_name, repoID=repoID, pprefix=config.state['Private Prefix']) external_linkage(node) # restore the old bottom half oldbottomhalf.out(str(self.bottomhalf)) self.bottomhalf = oldbottomhalf finishingNode()
def visitStruct(node): startingNode(node) # the key here is to redirect the bottom half to a buffer # just for now oldbottomhalf = self.bottomhalf self.bottomhalf = output.StringStream() insideModule = self.__immediatelyInsideModule self.__immediatelyInsideModule = 0 # create the static typecodes for constructed types by setting # the resolving_dependency flag and recursing save_resolving_dependency = self.__resolving_dependency for child in node.members(): memberType = child.memberType() if child.constrType(): self.__resolving_dependency = save_resolving_dependency else: self.__resolving_dependency = 1 if isinstance(memberType, idltype.Declared): memberType.decl().accept(self) elif isinstance(memberType, idltype.Sequence): # anonymous sequence (maybe sequence<sequence<...<T>>>) # Find the ultimate base type, and if it's user declared then # produce a typecode definition for it. base_type = memberType.seqType() while isinstance(base_type, idltype.Sequence): base_type = base_type.seqType() # if a struct is recursive, don't loop forever :) if isinstance(base_type, idltype.Declared): decl = base_type.decl() if not currently_being_defined(decl): base_type.decl().accept(self) self.__resolving_dependency = save_resolving_dependency tophalf.out(str(buildMembersStructure(node))) scopedName = node.scopedName() mangled_name = mangleName(config.state['Private Prefix'] + "_tc_", scopedName) if not alreadyDefined(mangled_name): # only define the name once defineName(mangled_name) structmember_mangled_name =\ mangleName(config.state['Private Prefix'] + \ "_structmember_", scopedName) assert alreadyDefined(structmember_mangled_name) num = numMembers(node) repoID = node.repoId() struct_name = id.Name(scopedName).simple() tophalf.out("""\ #ifdef @mangled_name@ # undef @mangled_name@ #endif static CORBA::TypeCode_ptr @mangled_name@ = CORBA::TypeCode::PR_struct_tc("@repoID@", "@name@", @structmember_mangled_name@, @n@, &@pprefix@_tcTrack); """, mangled_name=mangled_name, structmember_mangled_name=structmember_mangled_name, name=struct_name, n=str(num), repoID=repoID, pprefix=config.state['Private Prefix']) self.__immediatelyInsideModule = insideModule external_linkage(node) # restore the old bottom half oldbottomhalf.out(str(self.bottomhalf)) self.bottomhalf = oldbottomhalf finishingNode()