void be_exception::GenerateAssignmentOperator (be_ClientImplementation& source) { ostream & os = source.Stream (); DDS_StdString that (""); be_Type * btype; if (nmembers ()) { that = " that"; } os << ScopedName () << " & " << ScopedName () << "::operator = (const " << LocalName () << " &" << that << ")" << nl; os << "{" << nl; UTL_Scope * s = (UTL_Scope*)narrow((long) & UTL_Scope::type_id); assert (s); UTL_ScopeActiveIterator *it; // Iterate through decls for ( it = new UTL_ScopeActiveIterator (s, UTL_Scope::IK_decls); ! it->is_done (); it->next () ) { AST_Decl * adecl = it->item (); assert (adecl); be_field *bfield = (be_field *) adecl->narrow ((long) & be_field::type_id); if (bfield) { btype = bfield->get_be_type (); if (btype && btype->IsArrayType ()) { // Need to copy array elements os << " " << (char*) BE_Globals::RelativeScope (ScopedName (), bfield->StructMemberTypeName ()) << "_copy (" << bfield->get_local_name () << ", that." << bfield->get_local_name () << ");" << nl; } else { os << " " << bfield->get_local_name () << " = that." << bfield->get_local_name() << ";" << nl; } } } delete it; os << " return *this;" << nl; os << "}" << nl << nl; }
void be_enum::FinishProtoTypeCode() { // flesh out typecode // since enums names are all in a scope and not added directly // we go through the scope and add them all here UTL_Scope* s = (UTL_Scope*)narrow((long) & UTL_Scope::type_id); assert(s); UTL_ScopeActiveIterator* i = 0; i = new UTL_ScopeActiveIterator(s, UTL_Scope::IK_decls); if (s->nmembers() > 0) { for ( ; !(i->is_done()); i->next()) { AST_Decl* d = i->item(); assert(d); m_typecode->member_names.push_back(d->local_name()->get_string()); } delete i; } }
int be_visitor_executor_exh::visit_provides (be_provides *node) { ACE_CString prefix (this->ctx_->port_prefix ()); prefix += node->local_name ()->get_string (); const char *port_name = prefix.c_str (); be_type *impl = node->provides_type (); AST_Decl *scope = ScopeAsDecl (impl->defined_in ()); ACE_CString sname_str (scope->full_name ()); const char *sname = sname_str.c_str (); // No '_cxx_' prefix. const char *lname = impl->original_local_name ()->get_string (); const char *global = (sname_str == "" ? "" : "::"); os_ << be_nl_2 << "/// Factory method and getter for " << port_name << " facet" << be_nl << "/// @return existing instance of facet if one exists, else creates one" << be_nl << "virtual " << global << sname << "::CCM_" << lname << "_ptr" << be_nl << "get_" << port_name << " (void);"; return 0; }
void be_root::GenerateGlobalDecls (be_ClientHeader & source) { UTL_ScopeActiveIterator * i; be_CodeGenerator * cg; AST_Decl * d; UTL_Scope * s = (UTL_Scope*) narrow ((long) & UTL_Scope::type_id); if (s) { // Iterate through decls i = new UTL_ScopeActiveIterator (s, UTL_Scope::IK_decls); while (!(i->is_done ())) { d = i->item (); if (!d->imported ()) { cg = (be_CodeGenerator*) d->narrow ((long) & be_CodeGenerator::type_id); if (cg) { cg->Generate (source); } } i->next (); } delete i; } }
void be_CodeGenerator::Generate(be_ClientImplementation& source) { UTL_ScopeActiveIterator* i; AST_Decl * d; UTL_Scope * s = (UTL_Scope*)narrow((long) & UTL_Scope::type_id); if (s) { i = new UTL_ScopeActiveIterator(s, UTL_Scope::IK_decls); while (!(i->is_done())) { be_CodeGenerator * cg; d = i->item(); if (!d->imported() && (cg = (be_CodeGenerator*)d->narrow((long) & be_CodeGenerator::type_id))) { cg->Generate(source); } i->next(); } delete i; } else { assert(pbfalse); } }
// Dump this AST_Factory node to the ostream o. void AST_Finder::dump (ACE_OSTREAM_TYPE &o) { AST_Decl *d = 0; this->dump_i (o, "finder "); this->local_name ()->dump (o); this->dump_i (o, "("); // Iterator must be explicitly advanced inside the loop. for (UTL_ScopeActiveIterator i (this, IK_decls); !i.is_done ();) { d = i.item (); d->dump (o); i.next (); if (!i.is_done()) { this->dump_i (o, ", "); } } this->dump_i (o, ")"); }
unsigned long be_sequence::isRecursive () { UTL_Scope * scope = 0; be_Type * btype = 0; AST_Decl * adecl = (AST_Decl *)this->narrow((long) & AST_Decl::type_id); assert(adecl); be_Type * base = (be_Type *)base_type()->narrow((long) & be_Type::type_id); assert(base); unsigned long offset = 1; for ( offset = 1; adecl && (scope = adecl->defined_in()) && (btype = (be_Type *)scope->narrow((long) & be_Type::type_id)); ++offset ) { adecl = (AST_Decl *)scope->narrow((long) & AST_Decl::type_id); if (btype->TypeCodeTypeName() == base->TypeCodeTypeName()) { break; } } if (scope && btype) { return offset; } return 0; }
int idl2jni_visitor::visit_scope(UTL_Scope *node) { if (node->nmembers() > 0) { UTL_ScopeActiveIterator si(node, UTL_Scope::IK_decls); AST_Decl *d = 0; while (!si.is_done()) { d = si.item(); if (d == 0) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%N:%l) idl2jni_visitor::visit_") ACE_TEXT("scope - bad node in this scope\n")), -1); } if (d->node_type() == AST_Decl::NT_pre_defined) { si.next(); continue; } if (d->ast_accept(this) == -1) { ACE_ERROR_RETURN((LM_ERROR, ACE_TEXT("(%N:%l) idl2jni_visitor::visit_") ACE_TEXT("scope - failed to accept visitor\n")), -1); } si.next(); } } return 0; }
bool AST_illegal_interface_recursion (AST_Decl *t) { // Can't be 0 since we know we have an interface or valuetype. AST_Decl *d = 0; // If we encounter the argument in an enclosing scope, it's illegal. for (UTL_ScopeStackActiveIterator i (idl_global->scopes ()); !i.is_done (); i.next ()) { d = ScopeAsDecl (i.item ()); // Exceptions cannot be recursive, but may contain a reference // to the interface they are defined in. if (d->node_type () == AST_Decl::NT_except) { return false; } if (d == t) { return true; } } return false; }
int ast_visitor_tmpl_module_inst::visit_scope (UTL_Scope *node) { for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls); !si.is_done (); si.next ()) { AST_Decl *d = si.item (); if (d == 0) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("ast_visitor_tmpl_module_inst::") ACE_TEXT ("visit_scope - ") ACE_TEXT ("bad node in this scope\n")), -1); } // Send the visitor. if (d == 0 || d->ast_accept (this) == -1) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("ast_visitor_tmpl_module_inst::") ACE_TEXT ("visit_scope - ") ACE_TEXT ("codegen for scope failed\n")), -1); } } return 0; }
// Compute the size type of the node in question. int AST_Structure::compute_size_type (void) { for (UTL_ScopeActiveIterator si (this, UTL_Scope::IK_decls); !si.is_done (); si.next ()) { // Get the next AST decl node. AST_Decl *d = si.item (); if (d->node_type () == AST_Decl::NT_enum_val) { continue; } AST_Field *f = AST_Field::narrow_from_decl (d); AST_Type *t = f->field_type (); if (t != 0) { this->size_type (t->size_type ()); // While we're iterating, we might as well do this one too. this->has_constructor (t->has_constructor ()); } else { ACE_DEBUG ((LM_DEBUG, "WARNING (%N:%l) be_structure::compute_size_type - " "narrow_from_decl returned 0\n")); } } return 0; }
DDS_StdString be_Type::EnclosingScopeString(AST_Decl * decl) { DDS_StdString ret; assert(decl); if (decl) { UTL_Scope * enclosingScope = decl->defined_in(); AST_Decl * enclosingDecl; if (enclosingScope) { if ((enclosingDecl = (AST_Decl*)enclosingScope->narrow((long) & AST_Decl::type_id))) { ret = NameToString(enclosingDecl->name(), 0); } else { DDSError((DDS_StdString)"Can't narrow enclosing scope for " + NameToString(decl->name(), 0)); } } } return ret; }
be_argument::be_argument (AST_Argument::Direction d, AST_Type *ft, UTL_ScopedName *n) : COMMON_Base (), AST_Decl (AST_Decl::NT_argument, n), AST_Field (AST_Decl::NT_argument, ft, n), AST_Argument (d, ft, n), be_decl (AST_Decl::NT_argument, n) { AST_Decl *dcl = ScopeAsDecl (this->defined_in ()); // If there have been previous errors, dcl may be 0, // and we don't want to crash, so we check for non-zero. // Also, we don't want to set the bit if the operation is // declared in an included file UNLESS the enclosing // interface is abstract, in which case we regenerate the // operation. if (dcl != 0 && !dcl->is_local () && (idl_global->in_main_file () || dcl->is_abstract ())) { be_type *bt = be_type::narrow_from_decl (ft); bt->seen_in_operation (true); be_util::set_arg_seen_bit (bt); idl_global->need_skeleton_includes_ = true; } }
// Look up the default branch in union. AST_UnionBranch * AST_Union::lookup_default (void) { AST_UnionBranch *b = 0; AST_Decl *d = 0; for (UTL_ScopeActiveIterator i (this, UTL_Scope::IK_both); !i.is_done(); i.next ()) { d = i.item (); if (d->node_type () == AST_Decl::NT_union_branch) { b = AST_UnionBranch::narrow_from_decl (d); if (b == 0) { continue; } if (b->label () != 0 && b->label ()->label_kind () == AST_UnionLabel::UL_default) { idl_global->err ()->error2 (UTL_Error::EIDL_MULTIPLE_BRANCH, this, b); return b; } } } return 0; }
void be_type::gen_fwd_helper_name (void) { AST_Decl *parent = ScopeAsDecl (this->defined_in ()); Identifier *segment = 0; char *tmp = 0; this->fwd_helper_name_.clear (true); if (parent != 0 && parent->node_type () != AST_Decl::NT_root) { for (UTL_IdListActiveIterator i (parent->name ()); !i.is_done (); i.next ()) { segment = i.item (); tmp = segment->get_string (); if (ACE_OS::strcmp (tmp, "") == 0) { continue; } this->fwd_helper_name_ += tmp; this->fwd_helper_name_ += "::"; } } else { this->fwd_helper_name_= ""; } this->fwd_helper_name_ += "tao_"; this->fwd_helper_name_ += this->local_name ()->get_string (); }
// Compute total number of members. int AST_Operation::compute_argument_attr (void) { if (this->argument_count_ != -1) { return 0; } AST_Decl *d = 0; AST_Type *type = 0; AST_Argument *arg = 0; this->argument_count_ = 0; // If there are elements in this scope. if (this->nmembers () > 0) { // Instantiate a scope iterator. for (UTL_ScopeActiveIterator si (this, UTL_Scope::IK_decls); !si.is_done (); si.next ()) { // Get the next AST decl node. d = si.item (); if (d->node_type () == AST_Decl::NT_argument) { this->argument_count_++; arg = AST_Argument::narrow_from_decl (d); if (arg->direction() == AST_Argument::dir_IN || arg->direction() == AST_Argument::dir_INOUT) { this->has_in_arguments_ = true; } type = AST_Type::narrow_from_decl (arg->field_type ()); if (type->node_type () == AST_Decl::NT_native) { this->has_native_ = 1; } } } } type = AST_Type::narrow_from_decl (this->return_type ()); if (type->node_type () == AST_Decl::NT_native) { this->has_native_ = 1; } return 0; }
int ast_visitor_reifying::visit_param_holder (AST_Param_Holder *node) { size_t i = 0; FE_Utils::T_ARGLIST const *t_args = this->ctx_->template_args (); for (FE_Utils::T_PARAMLIST_INFO::ITERATOR iter ( *this->ctx_->template_params ()); !iter.done (); iter.advance (), ++i) { FE_Utils::T_Param_Info *item = 0; iter.next (item); ACE_CString name (item->name_); /// The param holder's info->name_ may be the same as the /// node's local name, but if the node comes from an /// alias, info->name_ will be the name of the alias's /// referenced template module parameter, while the local /// name will be that of the corresponding alias param /// name, which is what we want. if (name == node->local_name ()->get_string ()) { AST_Decl **ret_ptr = 0; if (t_args->get (ret_ptr, i) == 0) { AST_Decl *candidate = *ret_ptr; return candidate->ast_accept (this); } else { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("ast_visitor_reifying::") ACE_TEXT ("visit_param_holder() - access of ") ACE_TEXT ("current template arglist failed - ") ACE_TEXT ("param=%C scope=%C index=%d\n"), item->name_.c_str (), ScopeAsDecl (idl_global->scopes ().top ())->full_name (), i), -1); } } } ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("ast_visitor_reifying::") ACE_TEXT ("visit_param_holder() - no match for ") ACE_TEXT ("template param %C in %C\n"), node->local_name ()->get_string (), ScopeAsDecl (idl_global->scopes ().top ())->full_name ()), -1); }
// Compute the default index. int AST_Union::compute_default_index (void) { AST_Decl *d = 0; AST_UnionBranch *ub = 0; int i = 0; // If default case does not exist, it will have a value of -1 according to // the spec. this->default_index_ = -1; // If there are elements in this scope... if (this->nmembers () > 0) { // Instantiate a scope iterator. for (UTL_ScopeActiveIterator si (this, UTL_Scope::IK_decls); !si.is_done (); si.next ()) { // Get the next AST decl node. d = si.item (); // If an enum is declared in our scope, its members are // added to our scope as well, to detect clashes. if (d->node_type () == AST_Decl::NT_enum_val) { continue; } if (!d->imported ()) { ub = AST_UnionBranch::narrow_from_decl (d); for (unsigned long j = 0; j < ub->label_list_length (); ++j) { // Check if we are printing the default case. AST_UnionLabel::UnionLabel ulk = ub->label (j)->label_kind (); if (ulk == AST_UnionLabel::UL_default) { // Zero based indexing. this->default_index_ = i; } } // TAO's Typecode class keeps only a member count (not // a label count) so this increment has been moved // out of the inner loop. ++i; } } } return 0; }
/* * Add this AST_InterfaceFwd node (a forward declaration of an IDL * interface) to this scope */ AST_InterfaceFwd * AST_Module::fe_add_interface_fwd (AST_InterfaceFwd * i) { AST_Decl * d = lookup_for_add (i); AST_Interface * itf; /* * Already defined and cannot be redefined? Or already used? */ if (d) { if (d->node_type() == AST_Decl::NT_interface && d->defined_in() == this) { itf = AST_Interface::narrow_from_decl (d); if (itf == 0) { return 0; } i->set_full_definition (itf); return i; } if (!can_be_redefined (d)) { idl_global->err()->error3(UTL_Error::EIDL_REDEF, i, this, d); return NULL; } if (referenced (d)) { idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, i, this, d); return NULL; } if (i->has_ancestor (d)) { idl_global->err()->redefinition_in_scope(i, d); return NULL; } } /* * Add it to scope */ add_to_scope (i); /* * Add it to set of locally referenced symbols */ add_to_referenced (i, false); return i; }
AST_ValueFwd *AST_Module::fe_add_valuetype_fwd(AST_ValueFwd *v) { AST_Decl *d; AST_Value *val; /* * Already defined and cannot be redefined? Or already used? */ if ((d = lookup_for_add (v)) != NULL) { if (d->node_type() == AST_Decl::NT_value && d->defined_in() == this) { val = AST_Value::narrow_from_decl(d); if (val == NULL) return NULL; v->set_full_definition(val); return v; } if (!can_be_redefined(d)) { idl_global->err()->error3(UTL_Error::EIDL_REDEF, v, this, d); return NULL; } if (referenced(d)) { idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, v, this, d); return NULL; } if (v->has_ancestor(d)) { idl_global->err()->redefinition_in_scope(v, d); return NULL; } } /* * Add it to scope */ add_to_scope(v); /* * Add it to set of locally referenced symbols */ add_to_referenced(v, I_FALSE); return v; }
// NOTE: No attempt is made to ensure that exceptions are mentioned // only once.. UTL_NameList * AST_Attribute::fe_add_get_exceptions (UTL_NameList *t) { UTL_ScopedName *nl_n = 0; AST_Type *fe = 0; AST_Decl *d = 0; this->pd_get_exceptions = 0; for (UTL_NamelistActiveIterator nl_i (t); !nl_i.is_done (); nl_i.next ()) { nl_n = nl_i.item (); d = this->defined_in ()->lookup_by_name (nl_n, true); if (d == 0) { idl_global->err ()->lookup_error (nl_n); return 0; } AST_Decl::NodeType nt = d->node_type (); if (nt != AST_Decl::NT_except && nt != AST_Decl::NT_param_holder) { idl_global->err ()->error1 (UTL_Error::EIDL_ILLEGAL_RAISES, this); return 0; } fe = AST_Type::narrow_from_decl (d); UTL_ExceptList *el = 0; ACE_NEW_RETURN (el, UTL_ExceptList (fe, 0), 0); if (this->pd_get_exceptions == 0) { this->pd_get_exceptions = el; } else { this->pd_get_exceptions->nconc (el); } } return t; }
// Look up a branch by label. AST_UnionBranch * AST_Union::lookup_label (AST_UnionBranch *b) { AST_UnionLabel *label = b->label (); AST_Expression *lv = label->label_val (); if (label->label_val () == 0) { return b; } AST_Decl *d = 0; AST_UnionBranch *fb = 0; lv->set_ev (lv->coerce (this->pd_udisc_type)); if (lv->ev () == 0) { idl_global->err ()->eval_error (lv); return b; } for (UTL_ScopeActiveIterator i (this, UTL_Scope::IK_decls); !i.is_done(); i.next ()) { d = i.item (); if (d->node_type () == AST_Decl::NT_union_branch) { fb = AST_UnionBranch::narrow_from_decl (d); if (fb == 0) { continue; } if (fb->label() != 0 && fb->label ()->label_kind () == AST_UnionLabel::UL_label && fb->label ()->label_val ()->compare (lv)) { idl_global->err ()->error2 (UTL_Error::EIDL_MULTIPLE_BRANCH, this, b); return b; } } } return 0; }
// // visit_scope // int Provides_Svnt_Impl::visit_scope (UTL_Scope * node) { // Interfaces could be in a different IDL file, so we don't want to // skip them as the default visit_scope implementation does for (UTL_ScopeActiveIterator si (node, UTL_Scope::IK_decls); !si.is_done (); si.next ()) { AST_Decl * d = si.item (); if (0 != d->ast_accept (this)) return -1; } return 0; }
void be_component::mirror_scan (AST_PortType *pt) { AST_Uses *u = 0; AST_Provides *p = 0; AST_Attribute *a = 0; for (UTL_ScopeActiveIterator i (pt, UTL_Scope::IK_decls); !i.is_done (); i.next ()) { AST_Decl *d = i.item (); switch (d->node_type ()) { case AST_Decl::NT_provides: ++this->n_uses_; p = AST_Provides::narrow_from_decl (d); if (!p->provides_type ()->is_local ()) { ++this->n_remote_uses_; } continue; case AST_Decl::NT_uses: ++this->n_provides_; u = AST_Uses::narrow_from_decl (d); if (!u->uses_type ()->is_local ()) { ++this->n_remote_provides_; } continue; case AST_Decl::NT_attr: a = AST_Attribute::narrow_from_decl (d);; if (!a->readonly ()) { this->has_rw_attributes_ = true; } continue; default: continue; } } }
void be_util::gen_nesting_close (TAO_OutStream &os, AST_Decl *node) { AST_Decl *d = ScopeAsDecl (node->defined_in ()); AST_Decl::NodeType nt = d->node_type (); while (nt != AST_Decl::NT_root) { os << be_uidt_nl << "};"; d = ScopeAsDecl (d->defined_in ()); nt = d->node_type (); } }
int be_visitor_executor_exs::visit_provides (be_provides *node) { ACE_CString prefix (this->ctx_->port_prefix ()); prefix += node->local_name ()->get_string (); const char *port_name = prefix.c_str (); be_type *obj = node->provides_type (); const char *iname = obj->original_local_name ()->get_string (); AST_Decl *scope = ScopeAsDecl (obj->defined_in ()); ACE_CString sname_str (scope->full_name ()); const char *sname = sname_str.c_str (); const char *global = (sname_str == "" ? "" : "::"); ACE_CString lname_str (this->ctx_->port_prefix ()); lname_str += node->original_local_name ()->get_string (); const char *lname = lname_str.c_str (); os_ << be_nl_2 << global << sname << "::CCM_" << iname << "_ptr" << be_nl << node_->local_name () << "_exec_i::get_" << port_name << " (void)" << be_nl << "{" << be_idt_nl << "if ( ::CORBA::is_nil (this->ciao_" << port_name << "_.in ()))" << be_idt_nl << "{" << be_idt_nl << lname << "_exec_i *tmp = 0;" << be_nl << "ACE_NEW_RETURN (" << be_idt_nl << "tmp," << be_nl << lname << "_exec_i (" << be_idt_nl << "this->ciao_context_.in ())," << be_nl << global << sname << "::CCM_" << iname << "::_nil ());" << be_uidt << be_nl_2 << "this->ciao_" << port_name << "_ = tmp;" << be_uidt << be_uidt_nl << "}" << be_uidt << be_nl_2 << "return" << be_idt_nl << global << sname << "::CCM_" << iname << "::_duplicate (" << be_idt_nl << "this->ciao_" << port_name << "_.in ());" << be_uidt << be_uidt << be_uidt_nl << "}"; return 0; }
void AST_Root::destroy (void) { long i = 0; AST_Decl *d = 0; // Just destroy and delete everything but the CORBA // module, and the 'void' keyword, in case we are // processing multiple IDL files. // Final cleanup will be done in fini(). long end = this->pd_decls_used; for (i = 2; i < end; ++i) { d = this->pd_decls[i]; d->destroy (); delete d; d = 0; --this->pd_decls_used; } // Same goes for the references and the name // references, leave the first 2. // This array of pointers holds references, no need // for destruction. The array itself will be cleaned // up when AST_Root::fini() calls UTL_Scope::destroy (). for (i = 2; i < this->pd_referenced_used; ++i) { this->pd_referenced[i] = 0; } this->pd_referenced_used = 2; for (i = 2; i < this->pd_name_referenced_used; ++i) { Identifier *id = this->pd_name_referenced[i]; id->destroy (); delete id; id = 0; } this->pd_name_referenced_used = 2; }
void FE_ComponentHeader::compile_inheritance (UTL_ScopedName *base_component) { // If there is a base component, look up the decl and assign our member. // We also inherit its supported interfaces. if (base_component == 0) { return; } UTL_Scope *s = idl_global->scopes ().top_non_null (); AST_Decl *d = s->lookup_by_name (base_component, true); if (d == 0) { idl_global->err ()->lookup_error (base_component); // This is probably the result of bad IDL. // We will crash if we continue from here. throw Bailout (); } if (d->node_type () == AST_Decl::NT_typedef) { d = AST_Typedef::narrow_from_decl (d)->primitive_base_type (); } this->base_component_ = AST_Component::narrow_from_decl (d); if (this->base_component_ == 0) { idl_global->err ()->error1 (UTL_Error::EIDL_ILLEGAL_USE, d); } else if (!this->base_component_->is_defined ()) { idl_global->err ()->inheritance_fwd_error ( this->name (), this->base_component_ ); this->base_component_ = 0; } }
int dds_visitor::visit_constant(AST_Constant* node) { const char* name = node->local_name()->get_string(); BE_Comment_Guard g("CONST", name); ACE_UNUSED_ARG(g); AST_Decl* d = ScopeAsDecl(node->defined_in()); bool nested = d && (d->node_type() == AST_Decl::NT_interface); if (!java_ts_only_) { error_ |= !gen_target_.gen_const(node->name(), nested, node); } return 0; }
AST_Structure * AST_Module::fe_add_structure (AST_Structure * s) { AST_Decl * d = lookup_for_add (s); if (d) { /* Check for existing declaration or pre-declaration */ if (d->node_type () == AST_Decl::NT_struct) { AST_Structure * fwd = AST_Structure::narrow_from_decl (d); if (fwd->is_defined () && s->is_defined ()) { /* Invalid duplicate declaration */ idl_global->err()->error3 (UTL_Error::EIDL_REDEF, s, this, d); } else { if (! fwd->is_defined () && s->is_defined ()) { reorder (d); } // Return existing delete s; s = fwd; } } else { idl_global->err()->error3 (UTL_Error::EIDL_REDEF, s, this, d); } } else { add_to_scope (s); add_to_referenced (s, false); } return s; }