📄 be_interface.cpp
字号:
ACE_OS::strcat (macro,
def_curr);
}
return macro;
}
// Am I in some kind of a multiple inheritance?
int
be_interface::in_mult_inheritance (void)
{
if (this->in_mult_inheritance_ == -1)
{
// Compute once for all.
// Determine if we are in some form of a multiple inheritance.
if (this->traverse_inheritance_graph (
be_interface::in_mult_inheritance_helper,
0
) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"be_interface::in_mult_inheritance "
"error determining mult inheritance\n"),
-1);
}
}
return this->in_mult_inheritance_;
}
void
be_interface::in_mult_inheritance (int mi)
{
if (this->in_mult_inheritance_ == -1)
{
this->in_mult_inheritance_ = mi;
}
}
void
be_interface::redefine (AST_Interface *from)
{
be_interface *bi = be_interface::narrow_from_decl (from);
this->var_out_seq_decls_gen_ = bi->var_out_seq_decls_gen_;
AST_Interface::redefine (from);
}
// Generate default constructors.
void
be_interface::gen_def_ctors (TAO_OutStream *os)
{
this->traverse_inheritance_graph (
be_interface::gen_def_ctors_helper,
os
);
return;
}
int
be_interface::gen_def_ctors_helper (be_interface* node,
be_interface* base,
TAO_OutStream *os)
{
static int first = 0;
if (node != base)
{
if (first)
{
*os << be_global->impl_class_prefix () << base->flat_name ()
<< be_global->impl_class_suffix () << " ()";
first = 0;
}
else
{
*os << ", " << be_global->impl_class_prefix () << base->flat_name ()
<< be_global->impl_class_suffix () << " ()";
}
}
else
{
*os << ":";
first = 1;
}
return 1;
}
void
be_interface::gen_stub_ctor (TAO_OutStream *os)
{
// Generate the constructor from stub and servant.
if (!this->is_local ())
{
*os << be_nl << be_nl
<< "ACE_INLINE" << be_nl;
*os << this->name () << "::"
<< this->local_name () << " ("
<< be_idt << be_idt_nl
<< "TAO_Stub *objref," << be_nl
<< "CORBA::Boolean _tao_collocated," << be_nl
<< "TAO_Abstract_ServantBase *servant," << be_nl
<< "TAO_ORB_Core *oc" << be_uidt_nl
<< ")" << be_nl
<< ": ";
if (this->has_mixed_parentage_ && ! this->is_abstract ())
{
*os << "ACE_NESTED_CLASS (CORBA, AbstractBase) ("
<< be_idt << be_idt << be_idt_nl
<< "objref," << be_nl
<< "_tao_collocated," << be_nl
<< "servant" << be_uidt_nl
<< ")" << be_uidt;
int status =
this->traverse_inheritance_graph (
be_interface::gen_abstract_init_helper,
os,
I_TRUE
);
if (status == -1)
{
ACE_ERROR ((LM_ERROR,
"be_interface::gen_stub_ctor - "
"inheritance graph traversal failed\n"));
}
}
if (this->has_mixed_parentage_ && ! this->is_abstract ())
{
*os << "," << be_nl;
}
else
{
*os << be_idt;
}
if (is_abstract_)
{
if (this->pd_n_inherits == 0)
{
*os << "ACE_NESTED_CLASS (CORBA, AbstractBase) ("
<< be_idt << be_idt_nl
<< "objref," << be_nl
<< "_tao_collocated," << be_nl
<< "servant" << be_uidt_nl
<< ")" << be_uidt;
}
}
else
{
*os << "ACE_NESTED_CLASS (CORBA, Object) ("
<< be_idt << be_idt_nl
<< "objref," << be_nl
<< "_tao_collocated," << be_nl
<< "servant," << be_nl
<< "oc" << be_uidt_nl
<< ")" << be_uidt;
}
*os << "," << be_nl
<< "the"<< this->base_proxy_broker_name () << "_ (0)"
<< be_uidt << be_uidt;
*os << be_nl << "{" << be_idt_nl
<< "this->" << this->flat_name ()
<< "_setup_collocation (_tao_collocated);";
if (this->is_abstract ())
{
*os << be_nl
<< "ACE_UNUSED_ARG (oc);";
}
*os << be_uidt_nl
<< "}";
}
}
// Generate the forward declarations and static methods used by the
// interface _var and _out template classes, as well as by the
// template sequence classes for object references.
void
be_interface:: gen_var_out_seq_decls (void)
{
if (this->var_out_seq_decls_gen_ == 1)
{
return;
}
const char *lname = this->local_name ();
TAO_OutStream *os = tao_cg->client_header ();
*os << be_nl << be_nl << "// TAO_IDL - Generated from" << be_nl
<< "// " << __FILE__ << ":" << __LINE__;
// Generate the ifdefined macro for this interface.
os->gen_ifdef_macro (this->flat_name (),
"var_out");
*os << be_nl << be_nl
<< "class " << lname << ";" << be_nl
<< "typedef " << lname << " *" << lname << "_ptr;";
*os << be_nl << be_nl
<< "typedef" << be_idt_nl
<< "TAO_Objref_Var_T<" << be_idt << be_idt_nl
<< lname << be_uidt_nl
<< ">" << be_uidt_nl
<< lname << "_var;" << be_uidt_nl << be_nl
<< "typedef" << be_idt_nl
<< "TAO_Objref_Out_T<" << be_idt << be_idt_nl
<< lname << be_uidt_nl
<< ">" << be_uidt_nl
<< lname << "_out;" << be_uidt;
os->gen_endif ();
this->var_out_seq_decls_gen_ = 1;
}
// ****************************************************************
TAO_IDL_Inheritance_Hierarchy_Worker::~TAO_IDL_Inheritance_Hierarchy_Worker (
void
)
{
}
class TAO_IDL_Gen_OpTable_Worker : public TAO_IDL_Inheritance_Hierarchy_Worker
{
public:
TAO_IDL_Gen_OpTable_Worker (const char *skeleton_name);
virtual int emit (be_interface *derived_interface,
TAO_OutStream *os,
be_interface *base_interface);
private:
const char *skeleton_name_;
};
TAO_IDL_Gen_OpTable_Worker::
TAO_IDL_Gen_OpTable_Worker (const char *skeleton_name)
: skeleton_name_ (skeleton_name)
{
}
int
TAO_IDL_Gen_OpTable_Worker::emit (be_interface *derived_interface,
TAO_OutStream *os,
be_interface *base_interface)
{
// Generate entries for the derived class using the properties of its
// ancestors.
be_interface *bi = be_interface::narrow_from_decl (base_interface);
return bi->gen_optable_entries (derived_interface,
this->skeleton_name_,
os);
}
int
be_interface::gen_operation_table (const char *flat_name,
const char *skeleton_class_name)
{
// Check out the op_lookup_strategy.
switch (be_global->lookup_strategy ())
{
case BE_GlobalData::TAO_DYNAMIC_HASH:
{
// Init the outstream appropriately.
TAO_OutStream *os = this->strategy_->get_out_stream ();
// Start from current indentation level.
os->indent ();
// Start the table generation.
*os << "static const TAO_operation_db_entry " << flat_name
<< "_operations [] = {" << be_idt_nl;
// Make sure the queues are empty.
this->insert_queue.reset ();
this->del_queue.reset ();
// Insert ourselves in the queue.
if (insert_queue.enqueue_tail (this) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%N:%l) be_interface::gen_operation_table - "
"error generating entries\n"),
-1);
}
// Traverse the graph.
TAO_IDL_Gen_OpTable_Worker worker (skeleton_class_name);
if (this->traverse_inheritance_graph (worker, os) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%N:%l) be_interface::gen_operation_table - "
"inheritance graph traversal failed\n"), -1);
}
// Generate the skeleton for the is_a method.
*os << "{\"_is_a\", &" << skeleton_class_name
<< "::_is_a_skel, 0, 0}," << be_nl;
this->skel_count_++;
*os << "{\"_non_existent\", &" << skeleton_class_name
<< "::_non_existent_skel, 0, 0}," << be_nl;
this->skel_count_++;
*os << "{\"_component\", &" << skeleton_class_name
<< "::_component_skel, 0, 0}," << be_nl;
this->skel_count_++;
*os << "{\"_interface\", &" << skeleton_class_name
<< "::_interface_skel, 0, 0}" << be_uidt_nl;
this->skel_count_++;
*os << "};" << be_nl << be_nl;
*os << "static const CORBA::Long _tao_" << flat_name
<< "_optable_size = sizeof (ACE_Hash_Map_Entry<const char *,"
<< " TAO::Operation_Skeletons>) * (" << (3 * this->skel_count_)
<< ");" << be_nl;
*os << "static char _tao_" << flat_name << "_optable_pool "
<< "[_tao_" << flat_name << "_optable_size];" << be_nl;
*os << "static ACE_Static_Allocator_Base _tao_" << flat_name
<< "_allocator (_tao_" << flat_name << "_optable_pool, "
<< "_tao_" << flat_name << "_optable_size);" << be_nl;
*os << "static TAO_Dynamic_Hash_OpTable tao_"
<< flat_name << "_optable " << "(" << be_idt << be_idt_nl
<< flat_name << "_operations," << be_nl
<< this->skel_count_ << "," << be_nl
<< 2 * this->skel_count_ << "," << be_nl
<< "&_tao_" << flat_name << "_allocator" << be_uidt_nl
<< ");" << be_uidt_nl;
}
break;
case BE_GlobalData::TAO_LINEAR_SEARCH:
// For generating linear search also, we are calling GPERF
// only.
case BE_GlobalData::TAO_BINARY_SEARCH:
// For generating binary search also, we are calling GPERF
// only.
case BE_GlobalData::TAO_PERFECT_HASH:
// For each interface in the IDL, have a new temp file to
// collect the input for the gperf program.
{
// Temp file name.
// We must randomize this a bit in order to avoid problems with
// processing more than one idl file (in separate processes) with
// the same name (in different directories).
char *temp_file = 0;
ACE_NEW_RETURN (temp_file,
char [ACE_OS::strlen (idl_global->temp_dir ())
+ 11 // The number of possible digits in
// a 32-bit number plus a dot
+ ACE_OS::strlen (flat_name)
+ ACE_OS::strlen (".gperf")
+ 1],
-1);
// This degree of randomness is necessary because there was an obscure
// chance of even this arriving at colliding filenames on multiprocessor
// machines when the IDL compiler was run at exactly the same time.
ACE_RANDR_TYPE seed = (ACE_static_cast(ACE_RANDR_TYPE, ACE_OS::time())
+ ACE_static_cast(ACE_RANDR_TYPE, ACE_OS::getpid ()));
ACE_OS::sprintf (temp_file,
"%s%d.%s.gperf",
idl_global->temp_dir (),
ACE_OS::rand_r(seed),
flat_name);
// QNX can't handle individual file names (path components)
// longer than 48 characters.
#if defined(__QNX__)
size_t temp_dir_len = ACE_OS::strlen (idl_global->temp_dir ());
if (ACE_OS::strlen (temp_file) > temp_dir_len + 47)
{
temp_file[temp_dir_len + 47] = 0;
}
#endif /* defined(__QNX__) */
// Save this file name with the codegen singleton.
tao_cg->gperf_input_filename (temp_file);
// Make a new outstream to hold the gperf_temp_file for this
// interface.
// Retrieve the singleton instance to the outstream factory.
TAO_OutStream_Factory *factory = TAO_OUTSTREAM_FACTORY::instance ();
// Get a new instance for the temp file.
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -