void
TAO_ExtValueDef_i::exceptions (ACE_Configuration_Section_Key &key,
const char *sub_section,
const CORBA::ExceptionDefSeq &exceptions)
{
CORBA::ULong length = exceptions.length ();
if (length == 0)
{
return;
}
ACE_Configuration_Section_Key excepts_key;
this->repo_->config ()->open_section (key,
sub_section,
1,
excepts_key);
this->repo_->config ()->set_integer_value (excepts_key,
"count",
length);
char *stringified = 0;
char *type_path = 0;
for (CORBA::ULong i = 0; i < length; ++i)
{
type_path =
TAO_IFR_Service_Utils::reference_to_path (exceptions[i]);
stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->set_string_value (excepts_key,
stringified,
type_path);
}
}
void
TAO_IFR_Service_Utils::set_exceptions (
ACE_Configuration *config,
ACE_Configuration_Section_Key &key,
const char *sub_section,
const CORBA::ExceptionDefSeq &exceptions
)
{
CORBA::ULong length = exceptions.length ();
if (length == 0)
{
return;
}
// Create new subsection because we are either creating a new entry
// or are calling from a mutator which has already removed the old one.
ACE_Configuration_Section_Key excepts_key;
config->open_section (key,
sub_section,
1,
excepts_key);
config->set_integer_value (excepts_key,
"count",
length);
char *type_path = 0;
for (CORBA::ULong i = 0; i < length; ++i)
{
type_path =
TAO_IFR_Service_Utils::reference_to_path (exceptions[i]);
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
config->set_string_value (excepts_key,
stringified,
type_path);
}
}
CORBA::OperationDef_ptr
TAO_InterfaceDef_i::create_operation_i (const char *id,
const char *name,
const char *version,
CORBA::IDLType_ptr result,
CORBA::OperationMode mode,
const CORBA::ParDescriptionSeq ¶ms,
const CORBA::ExceptionDefSeq &exceptions,
const CORBA::ContextIdSeq &contexts)
{
// This will throw an exception if a name clash is found.
// create_common() will check for all other errors.
this->check_inherited (name,
CORBA::dk_Operation);
TAO_Container_i::tmp_name_holder_ = name;
ACE_Configuration_Section_Key new_key;
// Common to all IR objects created in CORBA::Container.
ACE_TString path =
TAO_IFR_Service_Utils::create_common (CORBA::dk_Interface,
CORBA::dk_Operation,
this->section_key_,
new_key,
this->repo_,
id,
name,
&TAO_Container_i::same_as_tmp_name,
version,
"ops");
// Get the TypeCode for the return type.
ACE_TString result_path (TAO_IFR_Service_Utils::reference_to_path (result));
TAO_IDLType_i *result_impl =
TAO_IFR_Service_Utils::path_to_idltype (result_path,
this->repo_);
CORBA::TypeCode_var rettype =
result_impl->type_i ();
CORBA::TCKind kind = rettype->kind ();
// Oneway operations cannot have a non-void return type.
if (mode == CORBA::OP_ONEWAY && kind != CORBA::tk_void)
{
throw CORBA::BAD_PARAM (CORBA::OMGVMCID | 31, CORBA::COMPLETED_NO);
}
this->repo_->config ()->set_string_value (new_key,
"result",
result_path);
// Store the operation mode.
this->repo_->config ()->set_integer_value (new_key,
"mode",
mode);
CORBA::ULong i = 0;
// Store the operation's parameter info.
CORBA::ULong length = params.length ();
if (length > 0)
{
ACE_Configuration_Section_Key params_key;
this->repo_->config ()->open_section (new_key,
"params",
1,
params_key);
this->repo_->config ()->set_integer_value (params_key,
"count",
length);
char *type_path = 0;
for (i = 0; i < length; ++i)
{
// Oneway operations cannot have INOUT or OUT parameters.
if (mode == CORBA::OP_ONEWAY && params[i].mode != CORBA::PARAM_IN)
{
throw CORBA::BAD_PARAM (31, CORBA::COMPLETED_NO);
}
ACE_Configuration_Section_Key param_key;
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->open_section (params_key,
stringified,
1,
param_key);
this->repo_->config ()->set_string_value (param_key,
"name",
params[i].name.in ());
type_path =
TAO_IFR_Service_Utils::reference_to_path (
params[i].type_def.in ()
);
this->repo_->config ()->set_string_value (param_key,
"type_path",
type_path);
this->repo_->config ()->set_integer_value (param_key,
"mode",
params[i].mode);
}
}
// Store the operation's exception info.
length = exceptions.length ();
if (length > 0)
{
// Oneway operations cannot throw any user exceptions.
if (mode == CORBA::OP_ONEWAY)
{
throw CORBA::BAD_PARAM (CORBA::OMGVMCID | 31, CORBA::COMPLETED_NO);
}
ACE_Configuration_Section_Key excepts_key;
this->repo_->config ()->open_section (new_key,
"excepts",
1,
excepts_key);
char *type_path = 0;
for (i = 0; i < length; ++i)
{
type_path =
TAO_IFR_Service_Utils::reference_to_path (exceptions[i]);
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->set_string_value (excepts_key,
stringified,
type_path);
}
}
// Store the operation's context info.
length = contexts.length ();
if (length > 0)
{
ACE_Configuration_Section_Key contexts_key;
this->repo_->config ()->open_section (new_key,
"contexts",
1,
contexts_key);
for (i = 0; i < length; ++i)
{
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->set_string_value (contexts_key,
stringified,
contexts[i].in ());
}
}
// Create the object reference.
CORBA::Object_var obj =
TAO_IFR_Service_Utils::create_objref (CORBA::dk_Operation,
path.c_str (),
this->repo_);
CORBA::OperationDef_var retval =
CORBA::OperationDef::_narrow (obj.in ());
return retval._retn ();
}
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;
}