int be_visitor_amh_pre_proc::add_exception_reply (be_operation *node, be_interface *response_handler, be_valuetype *exception_holder) { UTL_ScopedName *operation_name = node->compute_name ("", "_excep"); be_operation *node_excep = 0; ACE_NEW_RETURN (node_excep, be_operation (be_global->void_type (), AST_Operation::OP_noflags, operation_name, 1, 0), -1); node_excep->set_name (operation_name); Identifier *arg_id = 0; ACE_NEW_RETURN (arg_id, Identifier ("holder"), -1); UTL_ScopedName *arg_name = 0; ACE_NEW_RETURN (arg_name, UTL_ScopedName (arg_id, 0), -1); be_argument *argument = 0; ACE_NEW_RETURN (argument, be_argument (AST_Argument::dir_IN, exception_holder, arg_name), -1); argument->set_name (arg_name); argument->set_defined_in (node_excep); node_excep->be_add_argument (argument); node_excep->set_defined_in (response_handler); if (0 == response_handler->be_add_operation (node_excep)) { return -1; } return 0; }
UTL_ScopedName * FE_Utils::string_to_scoped_name (const char *s) { UTL_ScopedName *retval = 0; ACE_CString str (s); Identifier *id = 0; UTL_ScopedName *sn = 0; while (! str.empty ()) { // Skip a leading double colon. if (str.find (':') == 0) { str = str.substr (2); } // Find the next double colon (if any) and get the next // name segment. ACE_CString::size_type pos = str.find (':'); ACE_CString lname (str.substr (0, pos)); // Construct a UTL_ScopedName segment. ACE_NEW_RETURN (id, Identifier (lname.c_str ()), 0); ACE_NEW_RETURN (sn, UTL_ScopedName (id, 0), 0); // Either make it the head of a new list or the tail of // an existing one. if (retval == 0) { retval = sn; } else { retval->nconc (sn); } // Update the working string. str = str.substr (pos); } return retval; }
int ast_visitor_tmpl_module_inst::visit_valuetype (AST_ValueType *node) { UTL_NameList *parent_names = this->create_name_list (node->inherits (), node->n_inherits ()); UTL_NameList *supports_names = this->create_name_list (node->supports (), node->n_supports ()); Identifier *node_id = 0; ACE_NEW_RETURN (node_id, Identifier (node->local_name ()->get_string ()), -1); UTL_ScopedName *local_name = 0; ACE_NEW_RETURN (local_name, UTL_ScopedName (node_id, 0), -1); AST_ValueType *added_vtype = 0; FE_OBVHeader header (local_name, parent_names, supports_names, (parent_names != 0 ? parent_names->truncatable () : false), this->for_eventtype_); if (this->for_eventtype_) { added_vtype = idl_global->gen ()->create_eventtype (header.name (), header.inherits (), header.n_inherits (), header.inherits_concrete (), header.inherits_flat (), header.n_inherits_flat (), header.supports (), header.n_supports (), header.supports_concrete (), false, header.truncatable (), false); } else { added_vtype = idl_global->gen ()->create_valuetype (header.name (), header.inherits (), header.n_inherits (), header.inherits_concrete (), header.inherits_flat (), header.n_inherits_flat (), header.supports (), header.n_supports (), header.supports_concrete (), false, header.truncatable (), false); } if (parent_names != 0) { parent_names->destroy (); delete parent_names; parent_names = 0; } if (supports_names != 0) { supports_names->destroy (); delete supports_names; supports_names = 0; } idl_global->scopes ().top ()->add_to_scope (added_vtype); // Update the scope management. idl_global->scopes ().push (added_vtype); if (this->visit_scope (node) != 0) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("ast_visitor_tmpl_module_inst::") ACE_TEXT ("visit_valuetype - ") ACE_TEXT ("visit_scope failed\n")), -1); } // Through with this scope. idl_global->scopes ().pop (); // Reset the flag. this->for_eventtype_ = false; return 0; }
int ast_visitor_tmpl_module_inst::visit_home (AST_Home *node) { UTL_ScopedName *base_name = 0; AST_Decl *parent = this->reify_type (node->base_home ()); if (parent != 0) { base_name = parent->name (); } UTL_NameList *supports_names = this->create_name_list (node->supports (), node->n_supports ()); UTL_ScopedName *managed_comp_name = 0; AST_Component *managed_comp = AST_Component::narrow_from_decl ( this->reify_type (node->managed_component ())); if (managed_comp != 0) { managed_comp_name = managed_comp->name (); } UTL_ScopedName *p_key_name = 0; AST_ValueType *p_key = AST_ValueType::narrow_from_decl ( this->reify_type (node->primary_key ())); if (p_key != 0) { p_key_name = p_key->name (); } Identifier *node_id = 0; ACE_NEW_RETURN (node_id, Identifier (node->local_name ()->get_string ()), -1); UTL_ScopedName *local_name = 0; ACE_NEW_RETURN (local_name, UTL_ScopedName (node_id, 0), -1); FE_HomeHeader header (local_name, base_name, supports_names, managed_comp_name, p_key_name); AST_Home *added_home = idl_global->gen ()->create_home (header.name (), header.base_home (), header.managed_component (), header.primary_key (), header.supports (), header.n_supports (), header.supports_flat (), header.n_supports_flat ()); if (supports_names != 0) { supports_names->destroy (); delete supports_names; supports_names = 0; } idl_global->scopes ().top ()->add_to_scope (added_home); // Update the scope management. idl_global->scopes ().push (added_home); if (this->visit_scope (node) != 0) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("ast_visitor_tmpl_module_inst::") ACE_TEXT ("visit_home - ") ACE_TEXT ("visit_scope failed\n")), -1); } // Through with this scope. idl_global->scopes ().pop (); return 0; }
int ast_visitor_tmpl_module_inst::visit_component (AST_Component *node) { UTL_ScopedName *base_name = 0; AST_Decl *parent = this->reify_type (node->base_component ()); if (parent != 0) { base_name = parent->name (); } UTL_NameList *supports_names = this->create_name_list (node->supports (), node->n_supports ()); Identifier *node_id = 0; ACE_NEW_RETURN (node_id, Identifier (node->local_name ()->get_string ()), -1); UTL_ScopedName *local_name = 0; ACE_NEW_RETURN (local_name, UTL_ScopedName (node_id, 0), -1); FE_ComponentHeader header (local_name, base_name, supports_names, false); AST_Component *added_comp = idl_global->gen ()->create_component (header.name (), header.base_component (), header.supports (), header.n_supports (), header.supports_flat (), header.n_supports_flat ()); if (supports_names != 0) { supports_names->destroy (); delete supports_names; supports_names = 0; } idl_global->scopes ().top ()->add_to_scope (added_comp); // Update the scope management. idl_global->scopes ().push (added_comp); if (this->visit_scope (node) != 0) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("ast_visitor_tmpl_module_inst::") ACE_TEXT ("visit_component - ") ACE_TEXT ("visit_scope failed\n")), -1); } // Through with this scope. idl_global->scopes ().pop (); 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; }
be_operation * be_visitor_ami_pre_proc::create_sendc_operation (be_operation *node) { if (node->flags () == AST_Operation::OP_oneway) { // We do nothing for oneways! return 0; } Identifier *id = 0; UTL_ScopedName *sn = 0; // Create the new name // Prepend "sendc_" to the name of the operation ACE_CString original_op_name ( node->name ()->last_component ()->get_string ()); ACE_CString new_op_name = ACE_CString ("sendc_") + original_op_name; UTL_ScopedName *op_name = static_cast<UTL_ScopedName *> (node->name ()->copy ()); op_name->last_component ()->replace_string (new_op_name.c_str ()); idl_global->scopes ().push (node->defined_in ()); // Create the operation be_operation *op = 0; ACE_NEW_RETURN (op, be_operation (be_global->void_type (), AST_Operation::OP_noflags, op_name, false, false), 0); idl_global->scopes ().pop (); op->set_name (op_name); // Create the first argument, which is a Reply Handler // Look up the field type. UTL_Scope *s = node->defined_in (); be_interface *parent = be_interface::narrow_from_scope (s); // Add the pre- and suffix ACE_CString handler_local_name; this->generate_name ( handler_local_name, "AMI_", parent->name ()->last_component ()->get_string (), "Handler"); AST_Interface *handler = parent->ami_handler (); if (0 == handler) { op->destroy (); delete op; op = 0; ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("be_visitor_ami_pre_proc::") ACE_TEXT ("create_sendc_operation - ") ACE_TEXT ("null reply ") ACE_TEXT ("handler found\n")), 0); } be_interface *field_type = be_interface::narrow_from_decl (handler); ACE_NEW_RETURN (id, Identifier ("ami_handler"), 0); UTL_ScopedName *tmp = 0; ACE_NEW_RETURN (tmp, UTL_ScopedName (id, 0), 0); sn = (UTL_ScopedName *)op->name ()->copy (); sn->nconc (tmp); be_argument *arg = 0; ACE_NEW_RETURN (arg, be_argument (AST_Argument::dir_IN, field_type, // is also a valuetype sn), 0); arg->set_defined_in (op); arg->set_name (sn); op->be_add_argument (arg); if (field_type->imported ()) { field_type->seen_in_operation (false); } // 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) { ACE_ERROR_RETURN (( LM_ERROR, "(%N:%l) be_visitor_ami_pre_proc::create_sendc_method - " "bad node in this scope\n" ), 0 ); } AST_Argument *original_arg = AST_Argument::narrow_from_decl (d); if (original_arg->direction () == AST_Argument::dir_IN || original_arg->direction () == AST_Argument::dir_INOUT) { // 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), 0); arg->set_defined_in (op); arg->set_name (new_name); op->be_add_argument (arg); } } // end of while loop } // end of if op->is_sendc_ami (true); op->is_attr_op (node->is_attr_op ()); return op; }
AST_String::AST_String (AST_Decl::NodeType nt, UTL_ScopedName *n, AST_Expression *ms, long wide) : COMMON_Base (), AST_Decl (nt, n, true), AST_Type (nt, n), AST_ConcreteType (nt, n), pd_max_size (ms), pd_width (wide) { // Always the case. this->size_type (AST_Type::VARIABLE); Identifier *id = 0; UTL_ScopedName *new_name = 0; UTL_ScopedName *conc_name = 0; bool narrow = this->width () == (ssize_t) sizeof (char); ACE_NEW (id, Identifier (narrow ? "char *" : "WChar *")); ACE_NEW (conc_name, UTL_ScopedName (id, 0)); if (narrow) { new_name = conc_name; } else { ACE_NEW (id, Identifier ("CORBA")); ACE_NEW (new_name, UTL_ScopedName (id, conc_name)); } this->set_name (new_name); unsigned long bound = ms->ev ()->u.ulval; static char namebuf[NAMEBUFSIZE]; static char boundbuf[NAMEBUFSIZE]; ACE_OS::memset (namebuf, '\0', NAMEBUFSIZE); ACE_OS::memset (boundbuf, '\0', NAMEBUFSIZE); if (bound) { ACE_OS::sprintf (boundbuf, "_%ld", bound); } ACE_OS::sprintf (namebuf, "CORBA_%sSTRING%s", (wide == 1 ? "" : "W"), boundbuf); this->flat_name_ = ACE::strnew (namebuf); }
int be_visitor_interface_ss::gen_abstract_ops_helper ( be_interface *node, be_interface *base, TAO_OutStream *os) { if (!base->is_abstract ()) { return 0; } AST_Decl *d = 0; be_visitor_context ctx; ctx.stream (os); ctx.state (TAO_CodeGen::TAO_ROOT_SS); for (UTL_ScopeActiveIterator si (base, UTL_Scope::IK_decls); !si.is_done (); si.next ()) { d = si.item (); if (d == 0) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("be_visitor_interface_ss::") ACE_TEXT ("gen_abstract_ops_helper - ") ACE_TEXT ("bad node in this scope\n")), -1); } AST_Decl::NodeType nt = d->node_type (); UTL_ScopedName *item_new_name = 0; UTL_ScopedName *new_name = 0; if (AST_Decl::NT_op == nt || AST_Decl::NT_attr == nt) { ACE_NEW_RETURN (item_new_name, UTL_ScopedName (d->local_name ()->copy (), 0), -1); new_name = (UTL_ScopedName *) node->name ()->copy (); new_name->nconc (item_new_name); } else { continue; } // We pass the node's is_abstract flag to the operation // constructor so we will get the right generated operation // body if we are regenerating an operation from an // abstract interface in a concrete interface or component. if (AST_Decl::NT_op == nt) { be_operation *op = be_operation::narrow_from_decl (d); UTL_ScopedName *old_name = (UTL_ScopedName *) op->name ()->copy (); op->set_name (new_name); op->set_defined_in (node); op->is_abstract (node->is_abstract ()); be_visitor_operation_ss op_visitor (&ctx); op_visitor.visit_operation (op); op->set_name (old_name); op->set_defined_in (base); op->is_abstract (base->is_abstract ()); } else if (AST_Decl::NT_attr == nt) { AST_Attribute *attr = AST_Attribute::narrow_from_decl (d); be_attribute new_attr (attr->readonly (), attr->field_type (), 0, attr->is_local (), attr->is_abstract ()); new_attr.set_defined_in (node); new_attr.set_name (new_name); UTL_ExceptList *get_exceptions = attr->get_get_exceptions (); if (0 != get_exceptions) { new_attr.be_add_get_exceptions (get_exceptions->copy ()); } UTL_ExceptList *set_exceptions = attr->get_set_exceptions (); if (0 != set_exceptions) { new_attr.be_add_set_exceptions (set_exceptions->copy ()); } be_visitor_attribute attr_visitor (&ctx); attr_visitor.visit_attribute (&new_attr); ctx.attribute (0); new_attr.destroy (); } } return 0; }
int be_visitor_interface_cs::gen_abstract_ops_helper (be_interface *node, be_interface *base, TAO_OutStream *os) { // If the derived interface is local, the abstract parent's operation // was generated as pure virtual. if (!base->is_abstract () || node->is_local ()) { return 0; } AST_Decl *d = 0; be_visitor_context ctx; ctx.stream (os); for (UTL_ScopeActiveIterator si (base, UTL_Scope::IK_decls); !si.is_done (); si.next ()) { d = si.item (); if (d == 0) { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_interface_cs::" "gen_abstract_ops_helper - " "bad node in this scope\n"), -1); } if (d->node_type () == AST_Decl::NT_op) { UTL_ScopedName *item_new_name = 0; ACE_NEW_RETURN (item_new_name, UTL_ScopedName (d->local_name ()->copy (), 0), -1); UTL_ScopedName *new_op_name = (UTL_ScopedName *)node->name ()->copy (); new_op_name->nconc (item_new_name); be_operation *op = be_operation::narrow_from_decl (d); UTL_ScopedName *old_op_name = (UTL_ScopedName *) op->name ()->copy (); op->set_name (new_op_name); op->set_defined_in (node); op->is_abstract (node->is_abstract ()); ctx.state (TAO_CodeGen::TAO_OPERATION_CS); be_visitor_operation_cs op_visitor (&ctx); op_visitor.visit_operation (op); op->set_name (old_op_name); op->set_defined_in (base); op->is_abstract (base->is_abstract ()); } } 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; }
int be_visitor_amh_pre_proc::add_normal_reply (be_operation *node, be_interface *response_handler) { 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 *> (response_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, 1, 0), -1); operation->set_name (op_name); // If return type is non-void add it as first argument if (!node->void_return_type ()) { Identifier *arg_id = 0; ACE_NEW_RETURN (arg_id, Identifier ("return_value"), -1); UTL_ScopedName *arg_name = 0; ACE_NEW_RETURN (arg_name, UTL_ScopedName (arg_id, 0), -1); // Create the argument be_argument *arg = 0; ACE_NEW_RETURN (arg, be_argument (AST_Argument::dir_IN, node->return_type (), arg_name), -1); arg->set_name (arg_name); // Add the response handler to the argument list operation->be_add_argument (arg); } // Iterate over the arguments and put all the out and inout arguments // into the new method. for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls); !si.is_done (); si.next ()) { AST_Decl *d = si.item (); if (!d) { operation->destroy (); delete operation; operation = 0; ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("be_visitor_amh_pre_proc::") ACE_TEXT ("add_normal_reply - ") ACE_TEXT ("bad node in this scope\n")), -1); } //be_decl *arg = be_decl::narrow_from_decl (d); 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; ACE_NEW_RETURN (arg, be_argument (AST_Argument::dir_IN, original_arg->field_type (), original_arg->name ()), -1); operation->be_add_argument (arg); } } operation->set_defined_in (response_handler); // We do not copy the exceptions because the exceptions // are delivered by the excep methods. // After having generated the operation we insert it into the // response handler interface. if (0 == response_handler->be_add_operation (operation)) { return -1; } return 0; }
// Overriden method. void be_predefined_type::compute_tc_name (void) { // Start with the head as the CORBA namespace. Identifier *corba_id = 0; ACE_NEW (corba_id, Identifier ("CORBA")); ACE_NEW (this->tc_name_, UTL_ScopedName (corba_id, 0)); Identifier *id = 0; UTL_ScopedName *conc_name = 0; switch (this->pt ()) { case AST_PredefinedType::PT_void: ACE_NEW (id, Identifier ("_tc_void")); break; case AST_PredefinedType::PT_long: ACE_NEW (id, Identifier ("_tc_long")); break; case AST_PredefinedType::PT_longlong: ACE_NEW (id, Identifier ("_tc_longlong")); break; case AST_PredefinedType::PT_ulong: ACE_NEW (id, Identifier ("_tc_ulong")); break; case AST_PredefinedType::PT_ulonglong: ACE_NEW (id, Identifier ("_tc_ulonglong")); break; case AST_PredefinedType::PT_short: ACE_NEW (id, Identifier ("_tc_short")); break; case AST_PredefinedType::PT_ushort: ACE_NEW (id, Identifier ("_tc_ushort")); break; case AST_PredefinedType::PT_float: ACE_NEW (id, Identifier ("_tc_float")); break; case AST_PredefinedType::PT_double: ACE_NEW (id, Identifier ("_tc_double")); break; case AST_PredefinedType::PT_longdouble: ACE_NEW (id, Identifier ("_tc_longdouble")); break; case AST_PredefinedType::PT_char: ACE_NEW (id, Identifier ("_tc_char")); break; case AST_PredefinedType::PT_wchar: ACE_NEW (id, Identifier ("_tc_wchar")); break; case AST_PredefinedType::PT_octet: ACE_NEW (id, Identifier ("_tc_octet")); break; case AST_PredefinedType::PT_boolean: ACE_NEW (id, Identifier ("_tc_boolean")); break; case AST_PredefinedType::PT_any: ACE_NEW (id, Identifier ("_tc_any")); break; case AST_PredefinedType::PT_object: ACE_NEW (id, Identifier ("_tc_Object")); break; case AST_PredefinedType::PT_value: ACE_NEW (id, Identifier ("_tc_ValueBase")); break; case AST_PredefinedType::PT_abstract: ACE_NEW (id, Identifier ("_tc_AbstractBase")); break; case AST_PredefinedType::PT_pseudo: { char tcname [100]; ACE_OS::sprintf (tcname, "_tc_%s", this->name ()->last_component ()->get_string ()); ACE_NEW (id, Identifier (tcname)); break; } default: ACE_ERROR ((LM_WARNING, "Unknown or invalid predefined type")); break; } ACE_NEW (conc_name, UTL_ScopedName (id, 0)); this->tc_name_->nconc (conc_name); }
int ast_visitor_tmpl_module_inst::visit_interface (AST_Interface *node) { UTL_NameList *parent_names = this->create_name_list (node->inherits (), node->n_inherits ()); Identifier *node_id = 0; ACE_NEW_RETURN (node_id, Identifier (node->local_name ()->get_string ()), -1); UTL_ScopedName *local_name = 0; ACE_NEW_RETURN (local_name, UTL_ScopedName (node_id, 0), -1); FE_InterfaceHeader header (local_name, parent_names, node->is_local (), node->is_abstract (), true); AST_Interface *added_iface = idl_global->gen ()->create_interface (header.name (), header.inherits (), header.n_inherits (), header.inherits_flat (), header.n_inherits_flat (), header.is_local (), header.is_abstract ()); if (parent_names != 0) { parent_names->destroy (); delete parent_names; parent_names = 0; } idl_global->scopes ().top ()->add_to_scope (added_iface); // If this interface has both abstract and concrete parents, // extra code needs to be generated for it, such as overrides // of _is_nil() and release(). added_iface->analyze_parentage (); // Update the scope stack. idl_global->scopes ().push (added_iface); if (this->visit_scope (node) != 0) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("ast_visitor_tmpl_module_inst::") ACE_TEXT ("visit_interface - ") ACE_TEXT ("visit_scope failed\n")), -1); } // Through with this scope. idl_global->scopes ().pop (); return 0; }
void be_type::compute_tc_name (void) { static char namebuf [NAMEBUFSIZE]; UTL_ScopedName *n = this->name (); if (this->tc_name_ != 0) { this->tc_name_->destroy (); delete this->tc_name_; this->tc_name_ = 0; } ACE_OS::memset (namebuf, '\0', NAMEBUFSIZE); while (n->tail () != 0) { // Does not exist. if (this->tc_name_ == 0) { ACE_NEW (this->tc_name_, UTL_ScopedName (n->head ()->copy (), 0)); } else { UTL_ScopedName *conc_name = 0; ACE_NEW (conc_name, UTL_ScopedName (n->head ()->copy (), 0)); this->tc_name_->nconc (conc_name); } n = (UTL_ScopedName *)n->tail (); } ACE_OS::sprintf (namebuf, "_tc_%s", n->last_component ()->get_string ()); Identifier *id = 0; ACE_NEW (id, Identifier (namebuf)); // Does not exist. if (this->tc_name_ == 0) { ACE_NEW (this->tc_name_, UTL_ScopedName (id, 0)); } else { UTL_ScopedName *conc_name = 0; ACE_NEW (conc_name, UTL_ScopedName (id, 0)); this->tc_name_->nconc (conc_name); } }
int be_visitor_attribute::visit_attribute (be_attribute *node) { this->ctx_->node (node); this->ctx_->attribute (node); UTL_Scope *s = node->defined_in (); AST_Decl *d = ScopeAsDecl (s); ACE_CString op_name (this->ctx_->port_prefix ()); op_name += node->local_name ()->get_string (); Identifier *op_id = 0; ACE_NEW_RETURN (op_id, Identifier (op_name.c_str ()), -1); UTL_ScopedName *op_ln = 0; ACE_NEW_RETURN (op_ln, UTL_ScopedName (op_id, 0), -1); UTL_ScopedName *op_sn = static_cast<UTL_ScopedName *> (d->name ()->copy ()); op_sn->nconc (op_ln); // first the "get" operation be_operation get_op (node->field_type (), AST_Operation::OP_noflags, 0, node->is_local (), node->is_abstract ()); get_op.set_defined_in (s); get_op.set_name (op_sn); UTL_ExceptList *get_exceptions = node->get_get_exceptions (); if (0 != get_exceptions) { get_op.be_add_exceptions (get_exceptions->copy ()); } be_visitor_context ctx (*this->ctx_); int status = 1; switch (this->ctx_->state ()) { // These two cases are the only ones that could involve a strategy. case TAO_CodeGen::TAO_ROOT_CH: case TAO_CodeGen::TAO_INTERFACE_CH: { ctx.state (TAO_CodeGen::TAO_OPERATION_CH); be_visitor_operation_ch visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_CS: { ctx.state (TAO_CodeGen::TAO_OPERATION_CS); be_visitor_operation_cs visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_SH: { be_visitor_operation_sh visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_IH: { be_visitor_operation_ih visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_SS: { be_visitor_operation_ss visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_IS: { be_visitor_operation_is visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SH: { be_visitor_operation_proxy_impl_xh visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SS: { be_visitor_operation_direct_proxy_impl_ss visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_INTERFACE_SMART_PROXY_CH: { be_visitor_operation_smart_proxy_ch visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_INTERFACE_SMART_PROXY_CS: { be_visitor_operation_smart_proxy_cs visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_TIE_SH: { be_visitor_operation_tie_sh visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_TIE_SS: { be_visitor_operation_tie_ss visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_SVTH: case TAO_CodeGen::TAO_ROOT_SVH: { be_visitor_operation_ch visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_SVTS: case TAO_CodeGen::TAO_ROOT_SVS: { be_visitor_operation_svs visitor (&ctx); visitor.scope (this->op_scope_); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_EXH: { be_visitor_operation_ch visitor (&ctx); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_EXS: { be_visitor_operation_exs visitor (&ctx); visitor.scope (this->op_scope_); visitor.class_extension (this->exec_class_extension_.c_str ()); status = get_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_CNH: case TAO_CodeGen::TAO_ROOT_CNS: break; default: get_op.destroy (); return 0; } if (status == -1) { get_op.destroy (); ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_attribute::" "visit_attribute - " "codegen for get_attribute failed\n"), -1); } // Do nothing for readonly attributes. if (node->readonly ()) { get_op.destroy (); return 0; } status = 1; // Create the set method. Identifier id ("void"); UTL_ScopedName sn (&id, 0); // The return type is "void". be_predefined_type rt (AST_PredefinedType::PT_void, &sn); // Argument type is the same as the attribute type. AST_Argument *arg = idl_global->gen ()->create_argument (AST_Argument::dir_IN, node->field_type (), node->name ()); arg->set_name ((UTL_IdList *) node->name ()->copy ()); // Create the operation. be_operation set_op (&rt, AST_Operation::OP_noflags, 0, node->is_local (), node->is_abstract ()); set_op.set_defined_in (node->defined_in ()); set_op.set_name (static_cast<UTL_ScopedName *> (op_sn->copy ())); set_op.be_add_argument (arg); UTL_ExceptList *set_exceptions = node->get_set_exceptions (); if (0 != set_exceptions) { set_op.be_add_exceptions (set_exceptions->copy ()); } ctx = *this->ctx_; status = 1; switch (this->ctx_->state ()) { // These two cases are the only ones that could involved a strategy. case TAO_CodeGen::TAO_ROOT_CH: case TAO_CodeGen::TAO_INTERFACE_CH: { ctx.state (TAO_CodeGen::TAO_OPERATION_CH); be_visitor_operation_ch visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_CS: { ctx.state (TAO_CodeGen::TAO_OPERATION_CS); be_visitor_operation_cs visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_SH: { be_visitor_operation_sh visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_IH: { be_visitor_operation_ih visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_SS: { be_visitor_operation_ss visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_IS: { be_visitor_operation_is visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SH: { be_visitor_operation_proxy_impl_xh visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SS: { be_visitor_operation_direct_proxy_impl_ss visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_INTERFACE_SMART_PROXY_CH: { be_visitor_operation_smart_proxy_ch visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_INTERFACE_SMART_PROXY_CS: { be_visitor_operation_smart_proxy_cs visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_TIE_SH: { be_visitor_operation_tie_sh visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_TIE_SS: { be_visitor_operation_tie_ss visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_SVTH: case TAO_CodeGen::TAO_ROOT_SVH: { be_visitor_operation_ch visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_SVTS: case TAO_CodeGen::TAO_ROOT_SVS: { be_visitor_operation_svs visitor (&ctx); visitor.scope (this->op_scope_); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_EXH: { be_visitor_operation_ch visitor (&ctx); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_EXS: { be_visitor_operation_exs visitor (&ctx); visitor.scope (this->op_scope_); visitor.class_extension (this->exec_class_extension_.c_str ()); status = set_op.accept (&visitor); break; } case TAO_CodeGen::TAO_ROOT_CNH: case TAO_CodeGen::TAO_ROOT_CNS: break; default: // Error. set_op.destroy (); rt.destroy (); ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_attribute::" "visit_attribute - " "bad codegen state\n"), -1); } if (status == 0) { get_op.destroy (); set_op.destroy (); rt.destroy (); return 0; } else if (status == -1) { get_op.destroy (); set_op.destroy (); rt.destroy (); ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_attribute::" "visit_attribute - " "codegen for get_attribute failed\n"), -1); } get_op.destroy (); set_op.destroy (); rt.destroy (); return 0; }