def visitInterface(self, node):
self.__allInterfaces.append(node)
scopedName = id.Name(node.scopedName())
cxx_fqname = scopedName.fullyQualify()
impl_flat_name = impl_fullname(scopedName)
fqname = scopedName.fullyQualify(cxx = 0)
# build methods corresponding to attributes, operations etc.
# attributes[] and operations[] will contain lists of function
# signatures eg
# [ char *echoString(const char *mesg) ]
attributes = []
# we need to consider all callables, including inherited ones
# since this implementation class is not inheriting from anywhere
# other than the IDL skeleton
allInterfaces = [node] + ast.allInherits(node)
allCallables = []
for intf in allInterfaces:
allCallables.extend(intf.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 = []
implementations = []
for c in allCallables:
if isinstance(c, idlast.Attribute):
attrType = types.Type(c.attrType())
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():
args = attribname + "(" + inType + ")"
declarations.append("void " + args)
implementations.append("void " + impl_flat_name +\
"::" + args)
declarations.append(returnType + " " + attribname + "()")
implementations.append(returnType + " " + impl_flat_name+\
"::" + attribname + "()")
elif isinstance(c, idlast.Operation):
params = []
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())
params.append(cxx_type + " " + argname)
# deal with possible "context"
if c.contexts() != []:
params.append("CORBA::Context_ptr _ctxt")
return_type = types.Type(c.returnType()).op(types.RET)
opname = id.mapID(c.identifier())
arguments = ", ".join(params)
args = opname + "(" + arguments + ")"
declarations.append(return_type + " " + args + ";")
implementations.append(return_type + " " + impl_flat_name +
"::" + args)
else:
util.fatalError("Internal error generating interface member")
# the class definition has no actual code...
defs = "\n".join(declarations)
# Output the _i class definition definition
self.stream.out(template.interface_def,
impl_fqname = impl_flat_name,
impl_name = impl_flat_name,
fq_name = fqname,
fq_POA_name = "POA_" + cxx_fqname,
operations = defs)
# Output the implementations of the class methods
impls = "".join([ """\
%s
{
// insert code here and remove the warning
#warning "Code missing in function <%s>"
}
""" % (impl,impl) for impl in implementations ])
self.stream.out(template.interface_code,
fqname = fqname,
impl_name = impl_flat_name,
impl_fqname = impl_flat_name,
operations = impls)
def visitInterface(node):
ident = node.identifier()
outer_environment = id.lookup(node)
environment = outer_environment.enter(ident)
insideInterface = self.__insideInterface
self.__insideInterface = 1
# produce skeletons for types declared here
for n in node.declarations():
n.accept(self)
self.__insideInterface = insideInterface
# Call descriptor names are of the form:
# TAG _ PREFIX _ BASE
# Tag represents the type of thing {call descriptor, local callback...}
# Prefix is derived from the first encountered scopedname[1]
# Base is a counter to uniquify the identifier
#
# [1] Since the names are guaranteed unique, the prefix makes the
# names used by two different modules disjoint too. Not sure why
# as they are not externally visible?
I = iface.Interface(node)
I_Helper = iface.I_Helper(I)
I_Helper.cc(stream)
# the class itself
node_name = id.Name(node.scopedName())
if node.local():
objref_name = node_name.prefix("_nil_")
else:
objref_name = node_name.prefix("_objref_")
if node.abstract():
stream.out(template.abstract_interface_duplicate_narrow,
name=node_name.fullyQualify())
else:
if node.local():
stream.out(template.local_interface_duplicate_narrow,
name=node_name.fullyQualify())
else:
stream.out(template.interface_duplicate_narrow,
name=node_name.fullyQualify())
for i in I.allInherits():
if i.abstract():
stream.out(template.interface_narrow_abstract,
name=node_name.fullyQualify())
break
stream.out(template.interface_nil,
name=node_name.fullyQualify(),
objref_name=objref_name.unambiguous(environment),
repoID=node.repoId())
# Output flattened aliases to inherited classes, to workaround an
# MSVC bug.
for i in ast.allInherits(node):
inherits_name = id.Name(i.scopedName())
if inherits_name.needFlatName(environment):
guard_name = inherits_name.guard()
flat_fqname = inherits_name.flatName()
if i.local():
inherits_nil_name = inherits_name.prefix("_nil_")
nil_flat_fqname = inherits_nil_name.flatName()
stream.out(template.local_interface_ALIAS,
guard_name=guard_name,
fqname=inherits_name.fullyQualify(),
flat_fqname=flat_fqname,
nil_fqname=inherits_nil_name.fullyQualify(),
nil_flat_fqname=nil_flat_fqname)
else:
inherits_impl_name = inherits_name.prefix("_impl_")
inherits_objref_name = inherits_name.prefix("_objref_")
impl_flat_fqname = inherits_impl_name.flatName()
objref_flat_fqname = inherits_objref_name.flatName()
stream.out(template.interface_ALIAS,
guard_name=guard_name,
fqname=inherits_name.fullyQualify(),
flat_fqname=flat_fqname,
impl_fqname=inherits_impl_name.fullyQualify(),
impl_flat_fqname=impl_flat_fqname,
objref_fqname=inherits_objref_name.fullyQualify(),
objref_flat_fqname=objref_flat_fqname)
if node.local():
_nil_I = iface._nil_I(I)
_nil_I.cc(stream)
else:
_objref_I = iface._objref_I(I)
_objref_I.cc(stream)
_pof_I = iface._pof_I(I)
_pof_I.cc(stream)
_impl_I = iface._impl_I(I)
_impl_I.cc(stream)
# BOA compatible skeletons
if config.state['BOA Skeletons']:
sk_name = node_name.prefix("_sk_")
stream.out(template.interface_sk,
sk_fqname=sk_name.fullyQualify(),
sk_name=sk_name.unambiguous(environment))
def allInherits(self):
return map(lambda x:Interface(x), ast.allInherits(self._node))
def visitInterface(self, node):
self.__allInterfaces.append(node)
scopedName = id.Name(node.scopedName())
cxx_fqname = scopedName.fullyQualify()
impl_flat_name = impl_fullname(scopedName)
fqname = scopedName.fullyQualify(cxx = 0)
# build methods corresponding to attributes, operations etc.
# attributes[] and operations[] will contain lists of function
# signatures eg
# [ char *echoString(const char *mesg) ]
attributes = []
operations = []
virtual_operations = []
# we need to consider all callables, including inherited ones
# since this implementation class is not inheriting from anywhere
# other than the IDL skeleton
allInterfaces = [node] + ast.allInherits(node)
allCallables = util.fold( map(lambda x:x.callables(), allInterfaces),
[], lambda x, y: x + y )
# declarations[] contains a list of in-class decl signatures
# implementations[] contains a list of out of line impl signatures
# (typically differ by classname::)
declarations = []
implementations = []
for c in allCallables:
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():
args = attribname + "(" + inType + ")"
declarations.append("void " + args)
implementations.append("void " + impl_flat_name +\
"::" + args)
if not attribname in self.ignore_operations:
declarations.append(returnType + " " + attribname + "()")
implementations.append(returnType + " " + impl_flat_name+\
"::" + attribname + "()")
elif isinstance(c, idlast.Operation):
params = []
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())
params.append(cxx_type + " " + argname)
# deal with possible "context"
if c.contexts() != []:
params.append("CORBA::Context_ptr _ctxt")
return_type = types.Type(c.returnType()).op(types.RET)
opname = id.mapID(c.identifier())
if not opname in self.ignore_operations:
arguments = string.join(params, ", ")
args = opname + "(" + arguments + ")"
declarations.append(return_type + " " + args)
implementations.append(return_type + " " + \
impl_flat_name + \
"::" + args)
else:
util.fatalError("Internal error generating interface member")
raise "No code for interface member: " + repr(c)
# the class definition has no actual code...
defs = string.join(map(lambda x:x + ";\n", declarations), "")
# Output the class definition of the implementation
self.stream_h.out(interface_def,
impl_fqname = impl_flat_name,
impl_name = impl_flat_name,
fq_name = fqname,
fq_POA_name = "POA_" + cxx_fqname,
operations = defs)
# Output the class methods implementations
impls = string.join(map(lambda x: x + """\
{
// Please insert your code here and remove the following warning pragma
#ifndef WIN32
#warning "Code missing in function <""" + x + """>"
#endif
}
""",
implementations), "")
self.stream_cpp.out(interface_code,
fqname = fqname,
impl_name = impl_flat_name,
impl_fqname = impl_flat_name,
operations = impls)
def visitInterface(self, node):
self.__allInterfaces.append(node)
scopedName = id.Name(node.scopedName())
cxx_fqname = scopedName.fullyQualify()
impl_flat_name = impl_fullname(scopedName)
fqname = scopedName.fullyQualify(cxx=0)
# build methods corresponding to attributes, operations etc.
# attributes[] and operations[] will contain lists of function
# signatures eg
# [ char *echoString(const char *mesg) ]
attributes = []
# we need to consider all callables, including inherited ones
# since this implementation class is not inheriting from anywhere
# other than the IDL skeleton
allInterfaces = [node] + ast.allInherits(node)
allCallables = []
for intf in allInterfaces:
allCallables.extend(intf.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 = []
implementations = []
for c in allCallables:
if isinstance(c, idlast.Attribute):
attrType = types.Type(c.attrType())
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():
args = attribname + "(" + inType + ")"
declarations.append("void " + args)
implementations.append("void " + impl_flat_name +\
"::" + args)
declarations.append(returnType + " " + attribname + "()")
implementations.append(returnType + " " + impl_flat_name+\
"::" + attribname + "()")
elif isinstance(c, idlast.Operation):
params = []
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())
params.append(cxx_type + " " + argname)
# deal with possible "context"
if c.contexts() != []:
params.append("CORBA::Context_ptr _ctxt")
return_type = types.Type(c.returnType()).op(types.RET)
opname = id.mapID(c.identifier())
arguments = ", ".join(params)
args = opname + "(" + arguments + ")"
declarations.append(return_type + " " + args + ";")
implementations.append(return_type + " " + impl_flat_name +
"::" + args)
else:
util.fatalError("Internal error generating interface member")
# the class definition has no actual code...
defs = "\n".join(declarations)
# Output the _i class definition definition
self.stream.out(template.interface_def,
impl_fqname=impl_flat_name,
impl_name=impl_flat_name,
fq_name=fqname,
fq_POA_name="POA_" + cxx_fqname,
operations=defs)
# Output the implementations of the class methods
impls = "".join([
"""\
%s
{
// insert code here and remove the warning
#warning "Code missing in function <%s>"
}
""" % (impl, impl) for impl in implementations
])
self.stream.out(template.interface_code,
fqname=fqname,
impl_name=impl_flat_name,
impl_fqname=impl_flat_name,
operations=impls)
def visitInterface(node):
ident = node.identifier()
outer_environment = id.lookup(node)
environment = outer_environment.enter(ident)
insideInterface = self.__insideInterface
self.__insideInterface = 1
# produce skeletons for types declared here
for n in node.declarations():
n.accept(self)
self.__insideInterface = insideInterface
# Call descriptor names are of the form:
# TAG _ PREFIX _ BASE
# Tag represents the type of thing {call descriptor, local callback...}
# Prefix is derived from the first encountered scopedname[1]
# Base is a counter to uniquify the identifier
#
# [1] Since the names are guaranteed unique, the prefix makes the
# names used by two different modules disjoint too. Not sure why
# as they are not externally visible?
I = omniidl_be.cxx.iface.Interface(node)
I_Helper = omniidl_be.cxx.iface.instance("I_Helper")(I)
I_Helper.cc(stream)
# the class itself
node_name = id.Name(node.scopedName())
if node.local():
objref_name = node_name.prefix("_nil_")
else:
objref_name = node_name.prefix("_objref_")
if node.abstract():
stream.out(template.abstract_interface_duplicate_narrow,
name = node_name.fullyQualify())
else:
if node.local():
stream.out(template.local_interface_duplicate_narrow,
name = node_name.fullyQualify())
else:
stream.out(template.interface_duplicate_narrow,
name = node_name.fullyQualify())
for i in I.allInherits():
if i.abstract():
stream.out(template.interface_narrow_abstract,
name = node_name.fullyQualify())
break
stream.out(template.interface_nil,
name = node_name.fullyQualify(),
objref_name = objref_name.unambiguous(environment),
repoID = node.repoId())
# Output flattened aliases to inherited classes, to workaround an
# MSVC bug.
for i in ast.allInherits(node):
inherits_name = id.Name(i.scopedName())
if inherits_name.needFlatName(environment):
guard_name = inherits_name.guard()
flat_fqname = inherits_name.flatName()
if i.local():
inherits_nil_name = inherits_name.prefix("_nil_")
nil_flat_fqname = inherits_nil_name.flatName()
stream.out(template.local_interface_ALIAS,
guard_name = guard_name,
fqname = inherits_name.fullyQualify(),
flat_fqname = flat_fqname,
nil_fqname = inherits_nil_name.fullyQualify(),
nil_flat_fqname = nil_flat_fqname)
else:
inherits_impl_name = inherits_name.prefix("_impl_")
inherits_objref_name = inherits_name.prefix("_objref_")
impl_flat_fqname = inherits_impl_name.flatName()
objref_flat_fqname = inherits_objref_name.flatName()
stream.out(template.interface_ALIAS,
guard_name = guard_name,
fqname = inherits_name.fullyQualify(),
flat_fqname = flat_fqname,
impl_fqname = inherits_impl_name.fullyQualify(),
impl_flat_fqname = impl_flat_fqname,
objref_fqname = inherits_objref_name.fullyQualify(),
objref_flat_fqname = objref_flat_fqname)
if node.local():
_nil_I = omniidl_be.cxx.iface.instance("_nil_I")(I)
_nil_I.cc(stream)
else:
_objref_I = omniidl_be.cxx.iface.instance("_objref_I")(I)
_objref_I.cc(stream)
_pof_I = omniidl_be.cxx.iface.instance("_pof_I")(I)
_pof_I.cc(stream)
_impl_I = omniidl_be.cxx.iface.instance("_impl_I")(I)
_impl_I.cc(stream)
# BOA compatible skeletons
if config.state['BOA Skeletons']:
sk_name = node_name.prefix("_sk_")
stream.out(template.interface_sk,
sk_fqname = sk_name.fullyQualify(),
sk_name = sk_name.unambiguous(environment))
def visitInterface(self, node):
self.__allInterfaces.append(node)
# listed scope and interface name
dict = self.createDecl('interface')
self.createInterfaceIdent(dict, node)
self.createInterfaceFileInfo(dict, node)
dict['inherits'] = []
for ihnode in ast.allInherits(node):
idict = self.createDecl('inherit')
self.createInterfaceIdent(idict, ihnode)
self.createInterfaceFileInfo(idict, ihnode)
dict['inherits'].append(idict)
env = id.lookup(node)
allInterfaces = [node]# + ast.allInherits(node)
allCallables = util.fold( map(lambda x:x.callables(), allInterfaces),
[], lambda x, y: x + y )
dict['operations'] = []
dict['attributes'] = []
for c in allCallables:
if isinstance(c, idlast.Attribute):
attrType = types.Type(c.attrType())
d_attrType = attrType.deref()
(corba_atype, local_atype, is_primitive) = self.getType(attrType)
for i in c.identifiers():
ident = id.mapID(i)
returnType = attrType.op(types.RET)
inType = attrType.op(types.IN)
adict = createDecl('attribute')
cdict = adict['corba']
ldict = adict['local']
cdict['base_type'] = corba_atype;
ldict['base_type'] = local_atype
cdict['name'] = ident
adict['return'] = self.createReturn(c)
adict['arg'] = {}
self.createArg(adict['arg'], attrType, False)
dict['attributes'].append(adict)
if c.readonly():
dict['readonly'] = 'yes'
dict['attributes'].append(gdict)
elif isinstance(c, idlast.Operation):
# operations
op_dict = self.createOperation(c)
op_dict['return'] = self.createReturn(c)
op_dict['args'] = self.createArgs(c, env)
dict['operations'].append(op_dict)
else:
util.fatalError("Internal error generating interface member")
raise "No code for interface member: " + repr(c)
# self.dict['interfaces'].append(dict)
self.dict['tree'].append(dict)
return
def allInherits(self):
return [Interface(x) for x in ast.allInherits(self._node)]
def allInherits(self):
return [Interface(x) for x in ast.allInherits(self._node)]
def allInherits(self):
return map(lambda x:Interface(x), ast.allInherits(self._node))
def visitInterface(self, node):
self.__allInterfaces.append(node)
scopedName = id.Name(node.scopedName())
cxx_fqname = scopedName.fullyQualify()
impl_flat_name = impl_fullname(scopedName)
fqname = scopedName.fullyQualify(cxx = 0)
# build methods corresponding to attributes, operations etc.
# attributes[] and operations[] will contain lists of function
# signatures eg
# [ char *echoString(const char *mesg) ]
attributes = []
operations = []
virtual_operations = []
# we need to consider all callables, including inherited ones
# since this implementation class is not inheriting from anywhere
# other than the IDL skeleton
allInterfaces = [node] + ast.allInherits(node)
allCallables = util.fold( map(lambda x:x.callables(), allInterfaces),
[], lambda x, y: x + y )
# declarations[] contains a list of in-class decl signatures
# implementations[] contains a list of out of line impl signatures
# (typically differ by classname::)
declarations = []
implementations = []
for c in allCallables:
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():
args = attribname + "(" + inType + ")"
declarations.append("void " + args)
implementations.append("void " + impl_flat_name +\
"::" + args)
if not attribname in self.ignore_operations:
declarations.append(returnType + " " + attribname + "()")
implementations.append(returnType + " " + impl_flat_name+\
"::" + attribname + "()")
elif isinstance(c, idlast.Operation):
params = []
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())
params.append(cxx_type + " " + argname)
# deal with possible "context"
if c.contexts() != []:
params.append("CORBA::Context_ptr _ctxt")
return_type = types.Type(c.returnType()).op(types.RET)
opname = id.mapID(c.identifier())
if not opname in self.ignore_operations:
arguments = string.join(params, ", ")
args = opname + "(" + arguments + ")"
declarations.append(return_type + " " + args)
implementations.append(return_type + " " + \
impl_flat_name + \
"::" + args)
else:
util.fatalError("Internal error generating interface member")
raise "No code for interface member: " + repr(c)
# the class definition has no actual code...
defs = string.join(map(lambda x:x + ";\n", declarations), "")
# Output the class definition of the implementation
self.stream_h.out(interface_def,
impl_fqname = impl_flat_name,
impl_name = impl_flat_name,
fq_name = fqname,
fq_POA_name = "POA_" + cxx_fqname,
operations = defs)
# Output the class methods implementations
impls = string.join(map(lambda x: x + """\
{
// Please insert your code here and remove the following warning pragma
#ifndef WIN32
#warning "Code missing in function <""" + x + """>"
#endif
}
""",
implementations), "")
self.stream_cpp.out(interface_code,
fqname = fqname,
impl_name = impl_flat_name,
impl_fqname = impl_flat_name,
operations = impls)
