From 88ba81a3d7aac49cb0e283fe5e8eadf7edd8c35d Mon Sep 17 00:00:00 2001 From: parsons Date: Wed, 16 Apr 2003 05:17:48 +0000 Subject: ChangeLogTag: Wed Apr 16 000:14:10 2003 Jeff Parsons --- TAO/ChangeLog_ref | 17 ++ TAO/TAO_IDL/be/be_sequence.cpp | 45 +++-- TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp | 186 +++++++++++---------- TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp | 25 ++- TAO/TAO_IDL/be_include/be_sequence.h | 4 + TAO/TAO_IDL/be_include/be_type.h | 1 + TAO/tao/Array_VarOut_T.inl | 12 +- TAO/tao/Seq_VarOut_T.inl | 4 +- TAO/tests/Param_Test/recursive_union.cpp | 6 +- 9 files changed, 191 insertions(+), 109 deletions(-) diff --git a/TAO/ChangeLog_ref b/TAO/ChangeLog_ref index 170eb8b598a..c83dc51aac6 100644 --- a/TAO/ChangeLog_ref +++ b/TAO/ChangeLog_ref @@ -1,3 +1,20 @@ +Wed Apr 16 000:14:10 2003 Jeff Parsons + + * TAO_IDL/be/be_sequence.cpp: + * TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp: + * TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp: + * TAO_IDL/be_include/be_sequence.h: + * TAO_IDL/be_include/be_type.h: + * tao/Array_VarOut_T.inl: + * tao/Seq_VarOut_T.inl: + + Changes to remove compile errors in Param_Test and IDL_Test. + + * tests/Param_Test/recursive_union.cpp: + + Changed use of TAO-specific recursive member names to + spec-defined and generated recursive member names. + Mon Apr 14 17:10:59 2003 Jeff Parsons * tao/TAO.dsp: diff --git a/TAO/TAO_IDL/be/be_sequence.cpp b/TAO/TAO_IDL/be/be_sequence.cpp index 3a072c83d13..15d58887b74 100644 --- a/TAO/TAO_IDL/be/be_sequence.cpp +++ b/TAO/TAO_IDL/be/be_sequence.cpp @@ -29,6 +29,7 @@ #include "be_helper.h" #include "utl_identifier.h" #include "idl_defines.h" +#include "nr_extern.h" #include "ace/Log_Msg.h" ACE_RCSID (be, @@ -488,8 +489,10 @@ be_sequence::gen_base_class_name (TAO_OutStream *os, *os << "TAO_Unbounded_Object_Sequence<" << be_idt << be_idt_nl << elem->nested_type_name (elem_scope) << "," << be_nl; *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl - << elem->fwd_helper_name () << "_life," << be_nl - << elem->fwd_helper_name () << "_cast" << be_uidt_nl + << this->smart_fwd_helper_name (elem_scope, elem) + << "_life," << be_nl + << this->smart_fwd_helper_name (elem_scope, elem) + << "_cast" << be_uidt_nl << ">" << be_uidt; } else @@ -497,8 +500,10 @@ be_sequence::gen_base_class_name (TAO_OutStream *os, *os << "TAO_Bounded_Object_Sequence<" << be_idt << be_idt_nl << elem->nested_type_name (elem_scope) << "," << be_nl; *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl - << elem->fwd_helper_name () << "_life," << be_nl - << elem->fwd_helper_name () << "_cast," << be_nl + << this->smart_fwd_helper_name (elem_scope, elem) + << "_life," << be_nl + << this->smart_fwd_helper_name (elem_scope, elem) + << "_cast," << be_nl << this->max_size ()->ev ()->u.ulval << be_uidt_nl << ">" << be_uidt; } @@ -510,7 +515,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os, *os << "TAO_Unbounded_Abstract_Sequence<" << be_idt << be_idt_nl << elem->nested_type_name (elem_scope) << "," << be_nl; *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl - << elem->fwd_helper_name () << "_life" << be_uidt_nl + << this->smart_fwd_helper_name (elem_scope, elem) + << "_life" << be_uidt_nl << ">" << be_uidt; } else @@ -518,7 +524,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os, *os << "TAO_Bounded_Abstract_Sequence<" << be_idt << be_idt_nl << elem->nested_type_name (elem_scope) << "," << be_nl; *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl - << elem->fwd_helper_name () << "_life," << be_nl + << this->smart_fwd_helper_name (elem_scope, elem) + << "_life," << be_nl << this->max_size ()->ev ()->u.ulval << be_uidt_nl << ">" << be_uidt; } @@ -548,7 +555,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os, *os << "TAO_Unbounded_Valuetype_Sequence<" << be_idt << be_idt_nl << elem->nested_type_name (elem_scope) << "," << be_nl; *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl - << elem->fwd_helper_name () << "_life" << be_uidt_nl + << this->smart_fwd_helper_name (elem_scope, elem) + << "_life" << be_uidt_nl << ">" << be_uidt; } else @@ -556,7 +564,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os, *os << "TAO_Bounded_Valuetype_Sequence<" << be_idt << be_idt_nl << elem->nested_type_name (elem_scope) << "," << be_nl; *os << elem->nested_type_name (elem_scope, "_var") << "," << be_nl - << elem->fwd_helper_name () << "_life," << be_nl + << this->smart_fwd_helper_name (elem_scope, elem) + << "_life," << be_nl << this->max_size ()->ev ()->u.ulval << be_uidt_nl << ">" << be_uidt; } @@ -595,7 +604,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os, *os << "TAO_Unbounded_Array_Sequence<" << be_idt << be_idt_nl << elem->nested_type_name (elem_scope) << "," << be_nl - << elem->fwd_helper_name () << "_life" << be_uidt_nl + << this->smart_fwd_helper_name (elem_scope, elem) + << "_life" << be_uidt_nl << ">" << be_uidt; } else @@ -603,7 +613,8 @@ be_sequence::gen_base_class_name (TAO_OutStream *os, *os << "TAO_Bounded_Array_Sequence<" << be_idt << be_idt_nl << elem->nested_type_name (elem_scope) << "," << be_nl - << elem->fwd_helper_name () << "_life," << be_nl + << this->smart_fwd_helper_name (elem_scope, elem) + << "_life," << be_nl << this->max_size ()->ev ()->u.ulval << be_uidt_nl << ">" << be_uidt; } @@ -645,6 +656,20 @@ be_sequence::field_node (be_field *node) this->field_node_ = node; } +const char * +be_sequence::smart_fwd_helper_name (AST_Decl *elem_scope, + be_type *elem) +{ + if (ScopeAsDecl (this->defined_in ()) == elem_scope) + { + ACE_CString retval = "tao_"; + retval += elem->local_name ()->get_string (); + return retval.rep (); + } + + return elem->fwd_helper_name (); +} + void be_sequence::destroy (void) { diff --git a/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp b/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp index 8481ffa1788..388e021b90e 100644 --- a/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp +++ b/TAO/TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp @@ -38,15 +38,6 @@ be_visitor_sequence_cdr_op_cs::~be_visitor_sequence_cdr_op_cs (void) int be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node) { - if (this->ctx_->alias ()) - { - // We are here because the base type of the sequence node is - // itself a typedef'd sequence i.e., this is nested call resulting - // from bt->accept(0 below. For the case of sequence of - // anonymous sequence, see comment below. - return this->visit_node (node); - } - if (node->cli_stub_cdr_op_gen () || node->imported () || node->is_local ()) @@ -73,21 +64,30 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node) // Save the sequence node for further use. this->ctx_->node (node); + // If our element type is an anonymous sequence, generate code for it here. + if (bt->node_type () == AST_Decl::NT_sequence) + { + if (bt->accept (this) == -1) + { + ACE_ERROR_RETURN ((LM_ERROR, + "be_visitor_sequence_cdr_op_cs::" + "visit_sequence - " + "Base type codegen failed\n"), + -1); + } + } + *os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl << "// " << __FILE__ << ":" << __LINE__ << be_nl << be_nl; - // If we're an anonymous sequence, we must protect against - // being declared more than once. - if (!this->ctx_->tdef ()) - { - *os << "#if !defined _TAO_CDR_OP_" - << node->flat_name () << "_CPP_" << be_nl - << "#define _TAO_CDR_OP_" << node->flat_name () << "_CPP_" - << be_nl << be_nl; - } + *os << "#if !defined _TAO_CDR_OP_" + << node->flat_name () << "_CPP_" << be_nl + << "#define _TAO_CDR_OP_" << node->flat_name () << "_CPP_" + << be_nl << be_nl; // Set the sub state as generating code for the output operator. this->ctx_->sub_state (TAO_CodeGen::TAO_CDR_OUTPUT); + *os << "CORBA::Boolean operator<< (" << be_idt << be_idt_nl << "TAO_OutputCDR &strm," << be_nl << "const " << node->name () @@ -103,28 +103,13 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node) // Now encode the sequence elements. *os << "// Encode all elements." << be_nl; - if (bt->node_type () == AST_Decl::NT_sequence) - { - this->visit_node (node); - } - else - { - if (bt->accept (this) == -1) - { - ACE_ERROR_RETURN ((LM_ERROR, - "be_visitor_sequence_cdr_op_cs::" - "visit_sequence - " - "Base type codegen failed\n"), - -1); - } - } + this->visit_node (bt); *os << "}" << be_uidt_nl << be_nl << "return 0;" << be_uidt_nl << "}" << be_nl << be_nl; // Set the sub state as generating code for the input operator. - os->indent (); this->ctx_->sub_state(TAO_CodeGen::TAO_CDR_INPUT); *os << "CORBA::Boolean operator>> (" << be_idt << be_idt_nl @@ -180,6 +165,7 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node) *os << "// Set the length of the sequence." << be_nl << "_tao_sequence.length (_tao_seq_len);" << be_nl << be_nl; + // Now we do a check for the sequence length to be non zero. // If length is 0 we return true. *os << "// If length is 0 we return true." << be_nl; @@ -190,39 +176,21 @@ be_visitor_sequence_cdr_op_cs::visit_sequence (be_sequence *node) *os << "// Retrieve all the elements." << be_nl; - - if (bt->node_type () == AST_Decl::NT_sequence) - { - this->visit_node (node); - } - else - { - if (bt->accept (this) == -1) - { - ACE_ERROR_RETURN ((LM_ERROR, - "be_visitor_sequence_cdr_op_cs::" - "visit_sequence - " - "Base type codegen failed\n"), - -1); - } - } + this->visit_node (bt); if (expr->ev ()->u.ulval > 0) { // We are dealing with a bounded sequence. - *os << "}" << be_uidt << be_uidt_nl; + *os << be_nl << "}" << be_uidt << be_uidt; } - *os << "}" << be_uidt_nl << be_nl + *os << be_nl << "}" << be_uidt_nl << be_nl << "return 0;" << be_uidt_nl << "}"; - if (!this->ctx_->tdef ()) - { - *os << be_nl << be_nl - << "#endif /* _TAO_CDR_OP_" - << node->flat_name () << "_CPP_ */"; - } + *os << be_nl << be_nl + << "#endif /* _TAO_CDR_OP_" + << node->flat_name () << "_CPP_ */"; node->cli_stub_cdr_op_gen (1); return 0; @@ -562,15 +530,18 @@ be_visitor_sequence_cdr_op_cs::visit_node (be_type *bt) -1); } - // If the type was a string, an obj ref, or a pseudo-obj, we are dealing - // with a manager type and hence we must use the appropriate in() and - // out() methods. - // + AST_Decl::NodeType nt = bt->node_type (); + + if (nt == AST_Decl::NT_typedef) + { + be_typedef *td = be_typedef::narrow_from_decl (bt); + nt = td->base_node_type (); + } switch (this->ctx_->sub_state ()) { case TAO_CodeGen::TAO_CDR_INPUT: - switch (bt->node_type ()) + switch (nt) { case AST_Decl::NT_array: if (bt->accept (&visitor) == -1) @@ -681,19 +652,36 @@ be_visitor_sequence_cdr_op_cs::visit_node (be_type *bt) -1); } - AST_PredefinedType::PredefinedType pdt = pt->pt (); - - if (pdt == AST_PredefinedType::PT_pseudo - || pdt == AST_PredefinedType::PT_object - || pdt == AST_PredefinedType::PT_value) + switch (pt->pt ()) { - *os << "_tao_marshal_flag = (strm >> _tao_sequence[i].out ());" - << be_uidt_nl; - } - else - { - *os << "_tao_marshal_flag = (strm >> _tao_sequence[i]);" - << be_uidt_nl; + case AST_PredefinedType::PT_pseudo: + case AST_PredefinedType::PT_object: + case AST_PredefinedType::PT_value: + *os << "_tao_marshal_flag = (strm >> _tao_sequence[i].out ());"; + break; + case AST_PredefinedType::PT_char: + *os << "_tao_marshal_flag =" << be_idt_nl + << "(strm >> CORBA::Any::to_char (_tao_sequence[i]));" + << be_uidt; + break; + case AST_PredefinedType::PT_wchar: + *os << "_tao_marshal_flag =" << be_idt_nl + << "(strm >> CORBA::Any::to_wchar (_tao_sequence[i]));" + << be_uidt; + break; + case AST_PredefinedType::PT_boolean: + *os << "_tao_marshal_flag =" << be_idt_nl + << "(strm >> CORBA::Any::to_boolean (_tao_sequence[i]));" + << be_uidt; + break; + case AST_PredefinedType::PT_octet: + *os << "_tao_marshal_flag =" << be_idt_nl + << "(strm >> CORBA::Any::to_octet (_tao_sequence[i]));" + << be_uidt; + break; + default: + *os << "_tao_marshal_flag = (strm >> _tao_sequence[i]);"; + break; } } @@ -705,11 +693,12 @@ be_visitor_sequence_cdr_op_cs::visit_node (be_type *bt) break; } - *os << "}"; + *os << be_uidt_nl + << "}"; break; case TAO_CodeGen::TAO_CDR_OUTPUT: - switch (bt->node_type ()) + switch (nt) { case AST_Decl::NT_array: if (bt->accept (&visitor) == -1) @@ -814,17 +803,36 @@ be_visitor_sequence_cdr_op_cs::visit_node (be_type *bt) -1); } - AST_PredefinedType::PredefinedType pdt = pt->pt (); - - if (pdt == AST_PredefinedType::PT_pseudo - || pdt == AST_PredefinedType::PT_object - || pdt == AST_PredefinedType::PT_value) + switch (pt->pt ()) { - *os << "_tao_marshal_flag = (strm << _tao_sequence[i].in ());"; - } - else - { - *os << "_tao_marshal_flag = (strm << _tao_sequence[i]);"; + case AST_PredefinedType::PT_pseudo: + case AST_PredefinedType::PT_object: + case AST_PredefinedType::PT_value: + *os << "_tao_marshal_flag = (strm << _tao_sequence[i].in ());"; + break; + case AST_PredefinedType::PT_char: + *os << "_tao_marshal_flag =" << be_idt_nl + << "(strm << CORBA::Any::from_char (_tao_sequence[i]));" + << be_uidt; + break; + case AST_PredefinedType::PT_wchar: + *os << "_tao_marshal_flag =" << be_idt_nl + << "(strm << CORBA::Any::from_wchar (_tao_sequence[i]));" + << be_uidt; + break; + case AST_PredefinedType::PT_boolean: + *os << "_tao_marshal_flag =" << be_idt_nl + << "(strm << CORBA::Any::from_boolean (_tao_sequence[i]));" + << be_uidt; + break; + case AST_PredefinedType::PT_octet: + *os << "_tao_marshal_flag =" << be_idt_nl + << "(strm << CORBA::Any::from_octet (_tao_sequence[i]));" + << be_uidt; + break; + default: + *os << "_tao_marshal_flag = (strm << _tao_sequence[i]);"; + break; } } @@ -847,8 +855,8 @@ be_visitor_sequence_cdr_op_cs::visit_node (be_type *bt) -1); } - *os << be_uidt_nl<< be_nl; + *os << be_uidt_nl << be_nl; *os << "return _tao_marshal_flag;" << be_uidt_nl; - + return 0; } diff --git a/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp b/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp index faed84b3860..0ca8edd7e1d 100644 --- a/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp +++ b/TAO/TAO_IDL/be/be_visitor_sequence/sequence_ch.cpp @@ -372,13 +372,27 @@ be_visitor_sequence_ch::gen_varout_typedefs (be_sequence *node, default: // Not a managed type. { AST_Type::SIZE_TYPE st = elem->size_type (); + be_typedef *td = be_typedef::narrow_from_decl (elem); + AST_Decl::NodeType nt = elem->node_type (); + + if (td != 0) + { + nt = td->base_node_type (); + } *os << "typedef" << be_idt_nl << (st == AST_Type::FIXED ? "TAO_FixedSeq_Var_T<" : "TAO_VarSeq_Var_T<") << be_idt << be_idt_nl << node->local_name () << "," << be_nl - << elem->nested_type_name (scope) << be_uidt_nl + << elem->nested_type_name (scope); + + if (nt == AST_Decl::NT_array) + { + *os << "_slice *"; + } + + *os << be_uidt_nl << ">" << be_uidt_nl << node->local_name () << "_var;" << be_uidt; @@ -387,7 +401,14 @@ be_visitor_sequence_ch::gen_varout_typedefs (be_sequence *node, << "TAO_Seq_Out_T<" << be_idt << be_idt_nl << node->local_name () << "," << be_nl << node->local_name () << "_var," << be_nl - << elem->nested_type_name (scope) << be_uidt_nl + << elem->nested_type_name (scope); + + if (nt == AST_Decl::NT_array) + { + *os << "_slice *"; + } + + *os << be_uidt_nl << ">" << be_uidt_nl << node->local_name () << "_out;" << be_uidt; } diff --git a/TAO/TAO_IDL/be_include/be_sequence.h b/TAO/TAO_IDL/be_include/be_sequence.h index 74f89274fbd..77d73afe16b 100644 --- a/TAO/TAO_IDL/be_include/be_sequence.h +++ b/TAO/TAO_IDL/be_include/be_sequence.h @@ -103,6 +103,10 @@ protected: virtual char *gen_name (void); // Helper to create_name. +private: + const char *smart_fwd_helper_name (AST_Decl *elem_scope, + be_type *elem); + private: MANAGED_TYPE mt_; // Our managed type. diff --git a/TAO/TAO_IDL/be_include/be_type.h b/TAO/TAO_IDL/be_include/be_type.h index a73d51f21da..3eb97f4bdfc 100644 --- a/TAO/TAO_IDL/be_include/be_type.h +++ b/TAO/TAO_IDL/be_include/be_type.h @@ -57,6 +57,7 @@ public: void gen_fwd_helper_name (void); const char *fwd_helper_name (void) const; + void fwd_helper_name (const char *name); // Accessor to the member. void gen_common_varout (TAO_OutStream *os); diff --git a/TAO/tao/Array_VarOut_T.inl b/TAO/tao/Array_VarOut_T.inl index c5b1c141e32..8822fbe0543 100644 --- a/TAO/tao/Array_VarOut_T.inl +++ b/TAO/tao/Array_VarOut_T.inl @@ -64,7 +64,10 @@ ACE_INLINE const T_slice * TAO_Array_Var_Base_T::in (void) const { - return this->ptr_; + // @@@ (JP) This looks scary I know but it helps MSVC understand + // things better when the array is multi-dimensional. + return ACE_const_cast (const T_slice *, + this->ptr_); } template @@ -134,7 +137,7 @@ TAO_VarArray_Var_T::TAO_VarArray_Var_T (void) template ACE_INLINE TAO_VarArray_Var_T::TAO_VarArray_Var_T (T_slice * p) - : TAO_VarArray_Var_T (p) + : TAO_Array_Var_Base_T (p) {} template @@ -316,7 +319,10 @@ ACE_INLINE const T_slice * TAO_Array_Forany_T::in (void) const { - return this->ptr_; + // @@@ (JP) This looks scary I know but it helps MSVC understand + // things better when the array is multi-dimensional. + return ACE_const_cast (const T_slice *, + this->ptr_); } template diff --git a/TAO/tao/Seq_VarOut_T.inl b/TAO/tao/Seq_VarOut_T.inl index 09c4455f25a..5402cb95771 100644 --- a/TAO/tao/Seq_VarOut_T.inl +++ b/TAO/tao/Seq_VarOut_T.inl @@ -145,7 +145,7 @@ ACE_INLINE T_elem & TAO_FixedSeq_Var_T::operator[] (CORBA::ULong index) { - return this->ptr_->operator[] (index); + return (T_elem &) this->ptr_->operator[] (index); } template @@ -153,7 +153,7 @@ ACE_INLINE const T_elem & TAO_FixedSeq_Var_T::operator[] (CORBA::ULong index) const { - return ACE_const_cast (const T_elem &, this->ptr_->operator[] (index)); + return (const T_elem &) this->ptr_->operator[] (index)); } // *************************************************************** diff --git a/TAO/tests/Param_Test/recursive_union.cpp b/TAO/tests/Param_Test/recursive_union.cpp index 12034ad2c16..dc0852cfa6a 100644 --- a/TAO/tests/Param_Test/recursive_union.cpp +++ b/TAO/tests/Param_Test/recursive_union.cpp @@ -208,7 +208,7 @@ Test_Recursive_Union::deep_init (Param_Test::Recursive_Union &ru, ru.nested_member (nru); - Param_Test::Recursive_Union::_tao_seq_Recursive_Union tmp (MAX_SEQ_LENGTH); + Param_Test::Recursive_Union::_rec_member_seq tmp (MAX_SEQ_LENGTH); ru.rec_member (tmp); @@ -223,7 +223,7 @@ Test_Recursive_Union::deep_init (Param_Test::Recursive_Union &ru, // This line is TAO-specific, but some compilers we support // are broken in their handling of the portable scoped typedef // required by CORBA 2.3 - Param_Test::Recursive_Union::_tao_seq_Recursive_Union tmp (MAX_SEQ_LENGTH); + Param_Test::Recursive_Union::_rec_member_seq tmp (MAX_SEQ_LENGTH); tmp.length (len); @@ -261,7 +261,7 @@ Test_Recursive_Union::deep_init_nested (Param_Test::nested_rec_union &nu, // This line is TAO-specific, but some compilers we support // are broken in their handling of the portable scoped typedef // required by CORBA 2.3 - Param_Test::nested_rec_union::_tao_seq_nested_rec_union tmp (MAX_SEQ_LENGTH); + Param_Test::nested_rec_union::_nested_rec_member_seq tmp (MAX_SEQ_LENGTH); tmp.length (len); -- cgit v1.2.1