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 __out_unmarshalArgument(self,stream): if not self.__has_in_args: return marshal_block = output.StringStream() n = -1 for argument in self.__arguments: n = n + 1 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_" + str(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 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 __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 unmarshal(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.unmarshall(stream, env, memberType, d, member_name, "_n") return
def unmarshal(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.unmarshall(stream, env, memberType, d, member_name, "_n") 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 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 visitException(node): scopedName = id.Name(node.scopedName()) name = scopedName.simple() cxx_name = id.mapID(name) 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 = string.replace(memberType_fqname,"_ptr","") + \ "::_duplicate" if isinstance(d_memberType.type().decl(),idlast.Forward): duplicate = string.replace(duplicate,"::_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 = string.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 = string.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) 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 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