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; }