def typeName(type):
assert isinstance(type, types.Type)
d_type = type.deref()
# dereference the type, until just -before- it becomes a
# sequence. Since a sequence doesn't have a scopedName(),
# we use the scopedName() of the immediately preceeding
# typedef which is an instance of idltype.Declared
while type.typedef() and \
not types.Type(type.type().decl().alias().aliasType()).sequence():
type = types.Type(type.type().decl().alias().aliasType())
if name_map.has_key(type.type().kind()):
return name_map[type.type().kind()]
if type.string():
bound = ""
if type.type().bound() != 0:
bound = str(type.type().bound())
return bound + "string"
if type.wstring():
bound = ""
if type.type().bound() != 0:
bound = str(type.type().bound())
return bound + "wstring"
if isinstance(type.type(), idltype.Fixed):
return str(type.type().digits()) + "_" + \
str(type.type().scale()) + "fixed"
if isinstance(type.type(), idltype.Declared):
return id.Name(type.type().scopedName()).guard()
util.fatalError("Error generating mangled name")
def recurse(type, constr=0):
assert isinstance(type, types.Type)
deref_type = type.deref()
if isinstance(type.type(), idltype.Declared):
base_decl = type.type().decl()
save_resolving_dependency = self.__resolving_dependency
if not constr:
self.__resolving_dependency = 1
base_decl.accept(self)
self.__resolving_dependency = save_resolving_dependency
elif deref_type.sequence():
seqType = deref_type.type().seqType()
if isinstance(seqType, idltype.Declared):
base_decl = seqType.decl()
save_resolving_dependency = self.__resolving_dependency
self.__resolving_dependency = 1
base_decl.accept(self)
self.__resolving_dependency = save_resolving_dependency
elif types.Type(seqType).sequence():
# anonymous sequence
recurse(types.Type(seqType.seqType()))
def visitTypedef(node):
aliasType = types.Type(node.aliasType())
d_type = aliasType.deref()
if node.constrType():
aliasType.type().decl().accept(self)
for d in node.declarators():
scopedName = id.Name(d.scopedName())
if d_type.sequence() and not aliasType.typedef():
seqType = types.Type(d_type.type().seqType())
d_seqType = seqType.deref()
if d_seqType.structforward() or d_seqType.unionforward():
fqname = scopedName.fullyQualify()
name = id.mapID(d.identifier())
element = d_seqType.base()
bound = d_type.type().bound()
derived = d_type.sequenceTemplate()
if bound > 0:
stream.out(template.sequence_forward_bounded_defns,
bound=bound, fqname=fqname, name=name,
element=element, derived=derived)
else:
stream.out(template.sequence_forward_unbounded_defns,
fqname=fqname, name=name,
element=element, derived=derived)
stream.out(template.sequence_forward_defns,
fqname=fqname, name=name, element=element)
def out_ami_poller(self, stream, ami_method, poller_method, cd_names):
assign_res = []
ami_args = iter(poller_method.arg_names())
timeout_arg = next(ami_args)
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)
if s_is_var:
assign_res.append("%s = _call_desc->result._retn();" %
next(ami_args))
else:
assign_res.append("%s = _call_desc->result;" %
next(ami_args))
for n, argument in enumerate(self.__arguments):
if not argument.is_out():
continue
arg_ident = next(ami_args)
arg_n = "_call_desc->arg_%d" % n
argtype = types.Type(argument.paramType())
((h_is_const,h_is_ptr),(s_is_holder,s_is_var)) = \
_arg_info(argtype,argument.direction())
if s_is_holder:
if s_is_var:
assign_res.append("%s = %s._retn();" % (arg_ident, arg_n))
else:
assign_res.append("%s = %s;" % (arg_ident, arg_n))
else:
if s_is_var:
assign_res.append("%s = %s_._retn();" % (arg_ident, arg_n))
else:
if argtype.array():
assign_res.append("%s_copy(%s, %s_);" %
(argtype.base(), arg_ident, arg_n))
else:
assign_res.append("%s = %s_;" % (arg_ident, arg_n))
if assign_res:
tmpl = template.interface_ami_poller_method
else:
tmpl = template.interface_ami_poller_method_empty
stream.out(tmpl,
cd_name_c = cd_names[0],
cd_name_p = cd_names[1],
timeout_arg = timeout_arg,
assign_res = "\n".join(assign_res))
def visitTypedef(node):
environment = id.lookup(node)
is_global_scope = not (self.__insideModule or self.__insideInterface)
aliasType = types.Type(node.aliasType())
d_type = aliasType.deref()
if node.constrType():
aliasType.type().decl().accept(self)
fq_aliased = aliasType.base(environment)
for d in node.declarators():
scopedName = id.Name(d.scopedName())
decl_dims = d.sizes()
decl_dims_str = cxx.dimsToString(decl_dims)
decl_first_dim_str = ""
if decl_dims != []:
decl_first_dim_str = cxx.dimsToString([decl_dims[0]])
full_dims = decl_dims + aliasType.dims()
is_array = full_dims != []
is_array_declarator = decl_dims != []
fq_derived = scopedName.fullyQualify()
if d_type.sequence() and not aliasType.typedef():
seqType = types.Type(d_type.type().seqType())
d_seqType = seqType.deref()
if d_seqType.structforward() or d_seqType.unionforward():
fqname = scopedName.fullyQualify()
name = id.mapID(d.identifier())
element = d_seqType.base()
bound = d_type.type().bound()
derived = d_type.sequenceTemplate()
if (bound > 0):
stream.out(template.sequence_forward_bounded_defns,
bound=bound,
fqname=fqname,
name=name,
element=element,
derived=derived)
else:
stream.out(template.sequence_forward_unbounded_defns,
fqname=fqname,
name=name,
element=element,
derived=derived)
stream.out(template.sequence_forward_defns,
fqname=fqname,
name=name,
element=element)
def visitOperation(node):
returnType = types.Type(node.returnType())
if returnType.string():
returnType.type().accept(self)
elif returnType.wstring():
returnType.type().accept(self)
for p in node.parameters():
paramType = types.Type(p.paramType())
if paramType.string():
paramType.type().accept(self)
elif paramType.wstring():
paramType.type().accept(self)
def createReturn(self, operation):
"""
corba:
base_type:
ret_type:
decl_type:
tk:
local:
base_type:
ret_type:
decl_type:
tk:
"""
dict = self.createDecl('return')
cdict = dict['corba']
ldict = dict['local']
retType = types.Type(operation.returnType())
(corba_type, local_type, is_primitive) = self.getType(retType)
cdict['base_type'] = corba_type
ldict['base_type'] = local_type
if is_primitive != None:
cdict['is_primitive'] = is_primitive
retn_type = types.Type(operation.returnType()).op(types.RET)
retn_type = retn_type.replace('CORBA', '::CORBA')
retn_type = retn_type.replace('RTC', '::RTC')
retn_type = retn_type.replace('SDOPackage', '::SDOPackage')
retn_type = retn_type.replace('::::', '::')
cdict['retn_type'] = retn_type
if retType.objref(): local_rtype = local_type + '*'
else: local_rtype = local_type
ldict['retn_type'] = local_rtype
cdict['tk'] = ldict['tk'] = self.tk_map[retType.kind()]
if retType.deref().sequence():
retType = retType.deref()
if retType.sequence():
seqType = types.Type(retType.type().seqType())
# get type of element of sequence
(corba_etype, local_etype, is_primitive) = self.getType(seqType)
cdict['deref_tk'] = self.tk_map[seqType.kind()]
else:
derefType = retType.deref()
(corba_dtype, local_dtype, is_primitive) = self.getType(derefType)
cdict['deref_tk'] = self.tk_map[derefType.kind()]
return dict
def visitValueBox(node):
boxedType = types.Type(node.boxedType())
recurse(boxedType, node.constrType())
scopedName = node.scopedName()
mangled_name = mangleName(config.state['Private Prefix'] +\
"_tc_", scopedName)
if alreadyDefined(mangled_name):
return
repoID = node.repoId()
typecode = mkTypeCode(boxedType)
scopedName = node.scopedName()
boxed_name = id.Name(scopedName).simple()
tophalf.out("""\
static CORBA::TypeCode_ptr @mangled_name@ = CORBA::TypeCode::PR_value_box_tc("@repoID@", "@name@", @typecode@, &@pprefix@_tcTrack);
""",
mangled_name=mangled_name,
repoID=repoID,
name=boxed_name,
typecode=typecode,
pprefix=config.state['Private Prefix'])
defineName(mangled_name)
external_linkage(node)
def visitTypedef(node):
aliasType = types.Type(node.aliasType())
recurse(aliasType, node.constrType())
for declarator in node.declarators():
declarator.accept(self)
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 visitDeclarator(declarator):
# this must be a typedef declarator
node = declarator.alias()
aliasType = types.Type(node.aliasType())
recurse(aliasType)
scopedName = declarator.scopedName()
mangled_name = mangleName(config.state['Private Prefix'] + "_tc_",
scopedName)
if alreadyDefined(mangled_name):
return
repoID = declarator.repoId()
typecode = mkTypeCode(aliasType, declarator)
scopedName = declarator.scopedName()
typedef_name = id.Name(scopedName).simple()
tophalf.out("""\
static CORBA::TypeCode_ptr @mangled_name@ = CORBA::TypeCode::PR_alias_tc("@repoID@", "@name@", @typecode@, &@pprefix@_tcTrack);
""",
mangled_name=mangled_name,
repoID=repoID,
name=typedef_name,
typecode=typecode,
pprefix=config.state['Private Prefix'])
defineName(mangled_name)
external_linkage(declarator)
def createMember(self, decl, member, env):
dict = self.createDecl('member')
cdict = dict['corba']
ldict = dict['local']
memberType = types.Type(member.memberType())
memtype = memberType.member(env)
(ctype, ltype, is_primitive) = self.getType(memberType)
cdict['base_type'] = ctype
cdict['tk'] = self.tk_map[memberType.kind()]
ldict['base_type'] = ltype
cdict['member_name'] = id.mapID(decl.identifier())
cdict['member_dims'] = decl.sizes()
ldict['member_name'] = cdict['member_name']
ldict['member_dims'] = cdict['member_dims']
if memberType.objref():
corba_mtype = ctype
local_mtype = ltype + '*'
else:
corba_mtype = ctype
local_mtype = ltype
cdict['member_type'] = corba_mtype
ldict['member_type'] = local_mtype
return dict
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 createUnionIdent(self, dict, node):
"""
共用体宣言のの識別子に関するディクショナリの生成
corba:
idl_name: 宣言のidl上の識別子
name: C++にマッピングされた識別子
name_fq: C++識別子の完全修飾名
scoped_name: [] リスト形式の完全修飾名
switch_type: switchの型
switch_fq_type: switchの完全修飾型
deref_switch_type: switchの非参照型
local:
idl_name: 宣言のidl上の識別子
name: C++にマッピングされた識別子
name_fq: C++識別子の完全修飾名
scoped_name: [] リスト形式の完全修飾名
"""
self.createIdent(dict, node)
cdict = dict['corba']
ldict = dict['local']
switchType = types.Type(node.switchType())
ast.markDefaultCase(node)
hasDefault = ast.defaultCase(node) != None
(ctype, ltype, is_primitive) = self.getType(switchType)
cdict['switch_fq_type'] = ctype
cdict['switch_type'] = ctype.split('::')[-1]
ldict['switch_fq_type'] = ltype
ldict['switch_type'] = ltype.split('::')[-1]
return
def out_implcall(self, stream, operation, localcall_fn):
assert isinstance(stream, output.Stream)
ctor_args = [
localcall_fn, "\"" + operation + "\"",
str(len(operation) + 1),
str(1)
]
prepare_out_args = []
if self.__has_out_args:
for n, argument in enumerate(self.__arguments):
if argument.is_out() and not argument.is_in():
arg_n = "_call_desc.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 not s_is_holder:
rvalue = arg_n + "_"
if s_is_var:
rvalue = rvalue + ".out()"
if h_is_ptr:
rvalue = "&" + rvalue
prepare_out_args.append(arg_n + " = " + rvalue + ";")
# main block of code goes here
stream.out(template.interface_operation_dispatch,
idl_operation_name=operation,
call_descriptor=self.__name,
call_desc_args=", ".join(ctor_args),
prepare_out_args="\n".join(prepare_out_args))
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 createArgs(self, operation, env):
"""
corba:
base_type:
arg_type:
arg_name:
var_name:
decl_type:
direction:
tk:
local:
base_type:
arg_type:
arg_name:
var_name:
decl_type:
direction:
tk:
"""
args = []
direction = ['in', 'out', 'inout','return']
for arg in operation.parameters():
# corba args information
dict = self.createDecl('arg')
cdict = dict['corba']
ldict = dict['local']
paramType = types.Type(arg.paramType())
(corba_type, local_type, is_primitive) = self.getType(paramType)
cdict['base_type'] = corba_type
ldict['base_type'] = local_type
if is_primitive != None:
cdict['is_primitive'] = is_primitive
arg_name = id.mapID(arg.identifier())
cdict['arg_name'] = arg_name
ldict['arg_name'] = arg_name
cdict['var_name'] = '_' + arg_name
ldict['var_name'] = '_' + arg_name
direction_val = direction[arg.direction()]
cdict['direction'] = direction_val
ldict['direction'] = direction_val
cdict['tk'] = ldict['tk'] = self.tk_map[paramType.kind()]
arg_type = paramType.op(types.direction(arg), use_out = 0)
arg_type = arg_type.replace('CORBA', '::CORBA')
arg_type = arg_type.replace('RTC', '::RTC')
arg_type = arg_type.replace('SDOPackage', '::SDOPackage')
arg_type = arg_type.replace('::::', '::')
cdict['arg_type'] = arg_type
out = arg.is_out()
self.createArg(dict, paramType, out)
args.append(dict)
return args
def marshal(stream=stream, node=node, env=environment):
for n in node.members():
memberType = types.Type(n.memberType())
for d in n.declarators():
scopedName = id.Name(d.scopedName())
member_name = scopedName.simple()
skutil.marshall(stream, env, memberType, d, member_name, "_n")
return
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 produce_signature(returnType, parameters, raises, oneway, ami):
returnType = types.Type(returnType)
d_returnType = returnType.deref()
# return type
if d_returnType.void():
sig = "void"
else:
sig = canonTypeName(returnType, useScopedName=1)
if oneway:
# Can only validly happen with void return, but you never know
# what the future may hold.
sig = ONEWAY_SEPARATOR + sig
# parameter list
for param in parameters:
if param.is_in() and param.is_out():
sig = sig + INOUT_SEPARATOR
elif param.is_in():
sig = sig + IN_SEPARATOR
elif param.is_out():
sig = sig + OUT_SEPARATOR
sig = sig + canonTypeName(types.Type(param.paramType()),
useScopedName=1)
# exception list
raises = skutil.sort_exceptions(raises)
def exception_signature(exception):
cname = CANNON_NAME_SEPARATOR +\
id.Name(exception.scopedName()).guard()
return EXCEPTION_SEPARATOR + cname
raises_sigs = list(map(exception_signature, raises))
raises_str = "".join(raises_sigs)
sig = sig + raises_str
if ami:
sig = sig + ASYNC_TAG
return sig
def addOps(self,node,ops):
for i in node.inherits():
self.addOps(i,ops)
for d in node.contents():
if isinstance(d, idlast.Operation):
new_op = CC.Operation(d.identifier(),baseTypes[d.returnType().kind()])
# Get the c++ mappping of the return type
cxxRT = types.Type(d.returnType())
new_op.cxxReturnType = cxxRT.base()
# if new_op.returnType == 'string':
# print foo2.base()
#print new_op.name + "::" + d.identifier() + "()"
#tmpstr = node.identifier() + "::" + d.identifier() + "("
#tmpstr2 = " " + node.identifier() + "::" + d.identifier() + "("
if hasattr(d,'parameters'):
for p in d.parameters():
new_param = CC.Param(p.identifier())
t = p.paramType()
# Get the c++ mapping of the type
cxxT = types.Type(t)
new_param.cxxType = cxxT.op(types.direction(p))
if hasattr(t,'scopedName'):
#print ' '*8 + str(t.scopedName()),
new_param.dataType = idlutil.ccolonName(t.scopedName())
else:
if isinstance(t,idltype.Type):
#print ' '*8 + baseTypes[t.kind()],
new_param.dataType = baseTypes[t.kind()]
if p.is_in() and p.is_out():
new_param.direction = 'inout'
elif p.is_out():
new_param.direction = 'out'
else:
new_param.direction = 'in'
new_op.params.append(new_param)
#tmpstr += new_param.direction + " " + new_param.dataType + ","
#tmpstr2 += new_param.direction + " " + new_param.cxxType + ","
ops.append(new_op)
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")
def __out_marshalArgument_shared(self,stream,is_in):
for n, argument in enumerate(self.__arguments):
if (is_in and not argument.is_in()) or \
(not is_in and not argument.is_out()): continue
arg_n = "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
skutil.marshall(stream, None, argtype, None, arg_n, "_n")
def visitConst(node):
environment = id.lookup(node)
constType = types.Type(node.constType())
d_constType = constType.deref()
if d_constType.string():
type_string = "char *"
elif d_constType.wstring():
type_string = "::CORBA::WChar *"
elif d_constType.fixed():
type_string = constType.base()
else:
type_string = d_constType.base()
scopedName = id.Name(node.scopedName())
name = scopedName.fullyQualify()
value = d_constType.literal(node.value(), environment)
init_in_def = d_constType.representable_by_int()
if init_in_def:
if self.__insideInterface:
stream.out(template.const_in_interface,
type = type_string, name = name, value = value)
else:
stream.out(template.const_init_in_def,
type = type_string, name = name, value = value)
return
# not init_in_def
if self.__insideModule and not self.__insideInterface:
scopedName = node.scopedName()
scopedName = map(id.mapID, scopedName)
open_namespace = ""
close_namespace = ""
for s in scopedName[:-1]:
open_namespace = open_namespace + "namespace " + s + " { "
close_namespace = close_namespace + "} "
simple_name = scopedName[-1]
stream.out(template.const_namespace,
open_namespace = open_namespace,
close_namespace = close_namespace,
type = type_string, simple_name = simple_name,
name = name, value = value)
else:
stream.out(template.const_simple,
type = type_string, name = name, value = value)
def retConversion(self, type):
"""
Returns two values:
- storing: will be used as "${storing} (${hpp_method_call})."
- converting: will be copied as such after the line above.
"""
if type.void():
return "", ""
if type.char() or type.floating() or type.boolean() or type.integer():
return "return", ""
if type.string():
return "return ::hpp::corbaServer::c_str", ""
if type.typedef():
if type.type().name() in ("size_t", "size_type", "value_type"):
return "return", ""
elif type.type().name() == "floatSeq":
return "return hpp::corbaServer::vectorToFloatSeq", ""
elif type.type().name() == "Transform_":
return "return hpp::corbaServer::toHppTransform", ""
else:
unaliased = type.deref()
if unaliased.sequence():
innerType = types.Type(unaliased.type().seqType())
if innerType.objref():
if isinstance(innerType.type().decl(), idlast.Forward):
base = get_base_class(
innerType.type().decl().fullDecl())
else:
base = get_base_class(innerType.type().decl())
return "return hpp::corbaServer::vectorToSeqServant<{outType},{innerBaseType},{innerType}>(server_)"\
.format(innerBaseType=hpp_servant_name(id.Name(base.scopedName())),
innerType=hpp_servant_name(id.Name(innerType.type().scopedName())),
outType=id.Name(type.type().scopedName()).fullyQualify(cxx=1)), ""
else:
print("Unhandled sequence of", innerType.type().name())
else:
print("Unhandled type", type.type().name())
return "", ""
if type.objref():
if isinstance(type.type().decl(), idlast.Forward):
base = get_base_class(type.type().decl().fullDecl())
else:
base = get_base_class(type.type().decl())
store = "{type} __return__".format(type=self.toCppNamespace(
id.Name(type.type().scopedName()).suffix(
"Ptr_t")).fullyQualify(cxx=1))
conv = "return makeServantDownCast<{basetype},{type}>(server_, __return__)._retn();" \
.format(type=hpp_servant_name(id.Name(type.type().scopedName())),
basetype=hpp_servant_name(id.Name(base.scopedName())))
return store, conv
print(type.type(), type.kind())
return "", ""
def getType(self, typeobj):
"""
CORBA と Local の型名を取得する
"""
corba_type = typeobj.base()
# for omniidl4 4.1.1-2
if corba_type[:2] == "::":
corba_type = corba_type[2:]
is_primitive = None
# if CORBA to Local mapping is specified explicitly
if self.typemap.has_key(corba_type):
local_type = self.typemap[corba_type]
# if CORBA type is primitive, string or Any
elif self.corba_primitive.has_key(corba_type):
local_type = self.corba_primitive[corba_type]
if corba_type[:5] == 'CORBA':
corba_type = '::' + corba_type
tk = self.tk_map[typeobj.kind()]
primitive = ["tk_short", "tk_long", "tk_ushort",
"tk_ulong", "tk_float", "tk_double",
"tk_boolean", "tk_char", "tk_octet"]
if primitive.count(tk) > 0:
is_primitive = 'YES'
# other case
else:
corba_scoped_type = corba_type.split('::')
corba_ns = corba_scoped_type[:-1]
corba_base = corba_scoped_type[-1]
local_ns = corba_ns + self.config['IfaceNs']
local_scope = string.join(local_ns, '::')
if typeobj.objref():
corba_base = corba_base[:corba_base.rfind('_ptr')]
local_type = local_scope + '::' + \
self.config['IfacePrefix'] + \
corba_base + \
self.config['IfaceSuffix']
elif typeobj.sequence():
seqType = types.Type(typeobj.type().seqType())
# get type of element of sequence
(corba_etype, local_etype, eis_primitive) = self.getType(seqType)
if seqType.objref():
local_etype = local_etype + '*'
local_type = "std::vector< " + local_etype + " >"
else:
local_type = local_scope + '::' + corba_base
corba_type = '::' + corba_type
local_type = '::' + local_type
return (corba_type, local_type, is_primitive)
def createUnionCases(self, dict, node):
cases = []
switchType = types.Type(node.switchType())
ast.markDefaultCase(node)
outer_environment = id.lookup(node)
environment = outer_environment.enter(node.identifier())
for case in node.cases():
c = self.createUnionCase(case, node, switchType, environment)
if c != None:
cases.append(c)
dict['cases'] = cases
return dict
def createTypedef(self, aliasType, decl, env):
"""
typedef宣言に関するディクショナリの生成
corba:
derived_type: 導出型名
derived_fq_type: 完全修飾導出型名
deref_type: 非参照型名
deref_fq_type: 完全修飾非参型名
tk: TypeCode
local:
derived_type: 導出型名
derived_fq_type: 完全修飾導出型名
deref_type: 非参照型名
deref_fq_type: 完全修飾非参型名
"""
dict = self.createDecl('typedef')
cdict = dict['corba']
ldict = dict['local']
(cdict['base_type'], ldict['base_type'], is_primitive) = self.getType(aliasType)
derivedName = id.mapID(decl.identifier())
alias_dims = aliasType.dims()
cdict['derived_type'] = derivedName
ldict['derived_type'] = derivedName
corba_ns = '::' + string.join(cdict['corba_ns'], '::')
local_ns = '::' + string.join(ldict['iface_ns'], '::')
cdict['derived_type_fq'] = corba_ns + '::' + derivedName
ldict['derived_type_fq'] = local_ns + '::' + derivedName
cdict['tk'] = tk = self.tk_map[aliasType.kind()]
primitive = ["tk_short", "tk_long", "tk_ushort",
"tk_ulong", "tk_float", "tk_double",
"tk_boolean", "tk_char", "tk_octet"]
if primitive.count(tk) > 0:
cdict['is_primitive'] = 'YES'
if aliasType.sequence():
seqType = types.Type(aliasType.type().seqType())
# get type of element of sequence
(corba_etype, local_etype, is_primitive) = self.getType(seqType)
cdict['element_tk'] = self.tk_map[seqType.kind()]
if seqType.objref():
cdict['element_type_fq'] = corba_etype
ldict['element_type_fq'] = local_etype + '*'
else:
cdict['element_type_fq'] = corba_etype
ldict['element_type_fq'] = local_etype
return dict
def visitTypedef(self, node):
environment = id.lookup(node)
scope = environment.scope()
aliasType = types.Type(node.aliasType())
aliasTypeID = aliasType.member(environment)
if node.constrType():
node.aliasType().decl().accept(self)
for decl in node.declarators():
dict = self.createTypedef(aliasType, decl, environment)
self.dict['tree'].append(dict)
return
def _from_Callable(self, use_out):
# Grab the IDL environment
ifc = self.callable().interface()
environment = ifc.environment().enter("_objref_" + ifc.name().simple())
# Kept as a type object because in .cc part the _return_ type
# must be fully qualified.
self._return_type = types.Type(self.callable().returnType())
# Parameters are always relative, both in .hh and .cc
(param_types, param_names) = ([], [])
for p in self.callable().parameters():
pType = types.Type(p.paramType())
direction = types.direction(p)
param_types.append(
pType.op(direction, environment, use_out=use_out))
# Special ugly case. If the IDL says something like (in foo::bar
# bar), the parameter name may be the same as the relative type
# name. We mangle the parameter name if this happens.
typeBase = pType.base(environment)
ident = id.mapID(p.identifier())
if typeBase == ident:
ident = "_" + ident
param_names.append(ident)
# an operation has optional context
if self.callable().contexts() != []:
param_types.append("::CORBA::Context_ptr")
param_names.append("_ctxt")
self._arg_types = param_types
self._arg_names = param_names
self._name = self.callable().method_name()
