UTL_ExceptList *
ast_visitor_tmpl_module_inst::reify_exception_list (
UTL_ExceptList *orig)
{
if (orig == 0)
{
return 0;
}
UTL_ExceptList *retval = 0;
for (UTL_ExceptlistActiveIterator i (orig);
!i.is_done ();
i.next ())
{
AST_Type *ex =
AST_Type::narrow_from_decl (this->reify_type (i.item ()));
UTL_ExceptList *ex_list = 0;
ACE_NEW_RETURN (ex_list,
UTL_ExceptList (ex, 0),
0);
if (retval == 0)
{
retval = ex_list;
}
else
{
retval->nconc (ex_list);
}
}
return retval;
}
int
ir_simulator_visitor::visit_operation (AST_Operation *node)
{
XMI_TRACE ("operation");
Incr_Guard guard (this->associating_);
if (!this->associating_)
{
// not associating, imported, not my concern
if (node->imported ())
{
return 0;
}
// not imported, but not associating, need to set the guard
else
{
guard.arm ();
}
}
// associating, import
else
{
node->set_imported (false);
}
try
{
// ACE_DEBUG ((LM_DEBUG, "foo"));
if (node->return_type ())
{
// ACE_DEBUG ((LM_DEBUG, "bar"));
node->return_type ()->ast_accept (this);
}
// **** arguments
// **** exceptions
UTL_ExceptList *exceptions = node->exceptions ();
if (exceptions != 0 && exceptions->length () > 0)
{
for (UTL_ExceptlistActiveIterator ei (exceptions);
!ei.is_done ();
ei.next ())
{
ei.item ()->ast_accept (this);
}
}
this->visit_scope (node);
}
catch (Error &err)
{
err.node (node);
}
return 0;
}
int
be_visitor_ami_pre_proc::create_excep_operation (be_operation *node,
be_interface *reply_handler)
{
if (node->flags () == AST_Operation::OP_oneway)
{
// We do nothing for oneways!
return 0;
}
// Create the return type, which is "void".
Identifier *id = 0;
UTL_ScopedName *sn = 0;
// Create the argument.
ACE_NEW_RETURN (id,
Identifier ("excep_holder"),
-1);
ACE_NEW_RETURN (sn,
UTL_ScopedName (id,
0),
-1);
be_valuetype *excep_holder = be_global->messaging_exceptionholder ();
be_argument *arg = 0;
ACE_NEW_RETURN (arg,
be_argument (AST_Argument::dir_IN,
excep_holder, // is also a valuetype
sn),
-1);
arg->set_name (sn);
UTL_ScopedName *tmp = (UTL_ScopedName *)sn->copy ();
// Create the new name
// Append _excep to the name of the operation
ACE_CString original_op_name (
node->name ()->last_component ()->get_string ()
);
ACE_CString new_op_name = original_op_name + ACE_CString ("_excep");
UTL_ScopedName *op_name =
static_cast<UTL_ScopedName *> (reply_handler->name ()->copy ());
ACE_NEW_RETURN (id,
Identifier (new_op_name.c_str ()),
-1);
ACE_NEW_RETURN (sn,
UTL_ScopedName (id,
0),
-1);
op_name->nconc (sn);
AST_PredefinedType *rt = be_global->void_type ();
// Create the operation.
be_operation *operation = 0;
ACE_NEW_RETURN (operation,
be_operation (rt,
AST_Operation::OP_noflags,
op_name,
false,
false),
-1);
operation->set_name (op_name);
operation->be_add_argument (arg);
operation->set_defined_in (reply_handler);
UTL_ScopedName *arg_name =
dynamic_cast<UTL_ScopedName *> (op_name->copy ());
arg_name->nconc (tmp);
arg->set_name (arg_name);
arg->set_defined_in (operation);
// Copy the exceptions since the user exception information may
// be needed when collocation is disabled.
UTL_ExceptList *exceptions = node->exceptions ();
if (0 != exceptions)
{
operation->be_add_exceptions (exceptions->copy ());
}
reply_handler->be_add_operation (operation);
operation->is_excep_ami (true);
return 0;
}
int
be_visitor_ami_pre_proc::create_reply_handler_operation (
be_operation *node,
be_interface *reply_handler)
{
if (!node)
{
return -1;
}
if (node->flags () == AST_Operation::OP_oneway)
{
// We do nothing for oneways!
return 0;
}
Identifier *id = 0;
UTL_ScopedName *sn = 0;
ACE_CString original_op_name (
node->name ()->last_component ()->get_string ()
);
UTL_ScopedName *op_name =
static_cast<UTL_ScopedName *> (reply_handler->name ()-> copy ());
ACE_NEW_RETURN (id,
Identifier (original_op_name.c_str ()),
-1);
ACE_NEW_RETURN (sn,
UTL_ScopedName (id,
0),
-1);
op_name->nconc (sn);
// Create the operation.
be_operation *operation = 0;
ACE_NEW_RETURN (operation,
be_operation (be_global->void_type (),
AST_Operation::OP_noflags,
op_name,
0,
0),
-1);
operation->set_name (op_name);
// If return type is non-void add it as first argument.
if (!node->void_return_type ())
{
ACE_NEW_RETURN (id,
Identifier ("ami_return_val"),
-1);
UTL_ScopedName *tmp = 0;
ACE_NEW_RETURN (tmp,
UTL_ScopedName (id,
0),
-1);
sn = (UTL_ScopedName *)operation->name ()->copy ();
sn->nconc (tmp);
// Create the argument.
be_argument *arg = 0;
ACE_NEW_RETURN (arg,
be_argument (AST_Argument::dir_IN,
node->return_type (),
sn),
-1);
arg->set_defined_in (operation);
arg->set_name (sn);
// Add the reply handler to the argument list.
operation->be_add_argument (arg);
}
// Iterate over the arguments and put all the in and inout
// into the new method.
if (node->nmembers () > 0)
{
// Initialize an iterator to iterate thru our scope.
for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls);
!si.is_done ();
si.next ())
{
AST_Decl *d = si.item ();
if (d == 0)
{
operation->destroy ();
delete operation;
operation = 0;
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("be_visitor_ami_pre_proc::")
ACE_TEXT ("create_reply_handler_operation - ")
ACE_TEXT ("bad node in this scope\n")),
-1);
}
AST_Argument *original_arg = AST_Argument::narrow_from_decl (d);
if (original_arg->direction () == AST_Argument::dir_INOUT ||
original_arg->direction () == AST_Argument::dir_OUT)
{
// Create the argument.
be_argument *arg = 0;
UTL_ScopedName *new_name =
(UTL_ScopedName *)original_arg->name ()->copy ();
ACE_NEW_RETURN (arg,
be_argument (AST_Argument::dir_IN,
original_arg->field_type (),
new_name),
-1);
arg->set_defined_in (operation);
arg->set_name (new_name);
operation->be_add_argument (arg);
}
} // end of while loop
} // end of if
operation->set_defined_in (reply_handler);
// Copy the exceptions.
if (node->exceptions ())
{
UTL_ExceptList *exceptions = node->exceptions ();
if (0 != exceptions)
{
operation->be_add_exceptions (exceptions->copy ());
}
}
// After having generated the operation we insert it into the
// reply handler interface.
if (0 == reply_handler->be_add_operation (operation))
{
return -1;
}
operation->is_attr_op (node->is_attr_op ());
return 0;
}
int
ifr_adding_visitor_operation::visit_operation (AST_Operation *node)
{
try
{
// If this operation is already in the repository (for example, if
// we are processing the IDL file a second time inadvertently), we
// just return 0. The IDL file must be legal, otherwise the IDL
// compiler front end would have told us.
CORBA::Contained_var prev_def =
be_global->repository ()->lookup_id (node->repoID ());
if (!CORBA::is_nil (prev_def.in ()))
{
return 0;
}
// Build the parameter list. Our overridden version of visit_argument
// will look up each parameter and add its repository entry to
// our params_ member.
CORBA::ULong length = static_cast<CORBA::ULong> (node->argument_count ());
this->params_.length (length);
if (this->visit_scope (node) == -1)
{
ORBSVCS_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("(%N:%l) ifr_adding_visitor_operation::")
ACE_TEXT ("visit_operation -")
ACE_TEXT (" visit_scope failed\n")
),
-1
);
}
this->index_ = 0;
// Build the exception list.
UTL_ExceptList *excepts = node->exceptions ();
if (excepts != 0)
{
length = static_cast<CORBA::ULong> (excepts->length ());
}
else
{
length = 0;
}
CORBA::ExceptionDefSeq exceptions (length);
exceptions.length (length);
AST_Type *ex = 0;
CORBA::ULong i = 0;
for (UTL_ExceptlistActiveIterator ex_iter (excepts);
!ex_iter.is_done ();
ex_iter.next (), ++i)
{
ex = ex_iter.item ();
prev_def =
be_global->repository ()->lookup_id (ex->repoID ());
exceptions[i] =
CORBA::ExceptionDef::_narrow (prev_def.in ());
}
// Build the context list.
UTL_StrList *ctx_list = node->context ();
if (ctx_list != 0)
{
length = static_cast<CORBA::ULong> (ctx_list->length ());
}
else
{
length = 0;
}
CORBA::ContextIdSeq contexts (length);
contexts.length (length);
UTL_StrlistActiveIterator ctx_iter (ctx_list);
UTL_String *str = 0;
i = 0;
while (!ctx_iter.is_done ())
{
str = ctx_iter.item ();
contexts[i++] = str->get_string ();
ctx_iter.next ();
}
// Get the return type.
AST_Type *return_type = node->return_type ();
// Updates ir_current_.
this->get_referenced_type (return_type);
// Is the operation oneway?
CORBA::OperationMode mode = node->flags () == AST_Operation::OP_oneway
? CORBA::OP_ONEWAY
: CORBA::OP_NORMAL;
// Create the repository entry.
CORBA::Container_ptr current_scope =
CORBA::Container::_nil ();
if (be_global->ifr_scopes ().top (current_scope) == 0)
{
AST_Decl *op_scope = ScopeAsDecl (node->defined_in ());
AST_Decl::NodeType nt = op_scope->node_type ();
if (nt == AST_Decl::NT_interface)
{
CORBA::InterfaceDef_var iface =
CORBA::InterfaceDef::_narrow (current_scope);
CORBA::OperationDef_var new_def =
iface->create_operation (node->repoID (),
node->local_name ()->get_string (),
node->version (),
this->ir_current_.in (),
mode,
this->params_,
exceptions,
contexts);
}
else
{
CORBA::ValueDef_var vtype =
CORBA::ValueDef::_narrow (current_scope);
CORBA::OperationDef_var new_def =
vtype->create_operation (node->repoID (),
node->local_name ()->get_string (),
node->version (),
this->ir_current_.in (),
mode,
this->params_,
exceptions,
contexts);
}
}
else
{
ORBSVCS_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("(%N:%l) ifr_adding_visitor_operation::")
ACE_TEXT ("visit_operation -")
ACE_TEXT (" scope stack is empty\n")
),
-1
);
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
ACE_TEXT (
"ifr_adding_visitor_operation::visit_operation"));
return -1;
}
return 0;
}
int
be_visitor_amh_pre_proc::create_raise_operation (
be_decl *node,
be_valuetype *excep_holder,
Operation_Kind operation_kind
)
{
Identifier *id = 0;
UTL_ScopedName *sn = 0;
be_operation *orig_op = 0;
if (operation_kind == NORMAL)
{
orig_op = be_operation::narrow_from_decl (node);
}
// Name the operation properly
UTL_ScopedName *op_name =
static_cast<UTL_ScopedName *> (excep_holder->name ()->copy ());
ACE_CString new_local_name ("raise_");
if (operation_kind == SET_OPERATION)
{
new_local_name += "set_";
}
else if (operation_kind == GET_OPERATION)
{
new_local_name += "get_";
}
new_local_name += node->name ()->last_component ()->get_string ();
ACE_NEW_RETURN (id,
Identifier (new_local_name.c_str ()),
-1);
ACE_NEW_RETURN (sn,
UTL_ScopedName (id,
0),
-1);
op_name->nconc (sn);
be_operation *operation = 0;
ACE_NEW_RETURN (operation,
be_operation (be_global->void_type (),
AST_Operation::OP_noflags,
op_name,
0,
0),
-1);
operation->set_name (op_name);
operation->set_defined_in (excep_holder);
if (operation_kind == NORMAL)
{
if (orig_op)
{
// Copy the exceptions.
UTL_ExceptList *exceptions = orig_op->exceptions ();
if (0 != exceptions)
{
operation->be_add_exceptions (exceptions->copy ());
}
}
}
// After having generated the operation we insert it into the
// exceptionholder valuetype.
if (0 == excep_holder->be_add_operation (operation))
{
return -1;
}
return 0;
}
