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; } }
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; }
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; }
// Add a node to set of nodes referenced in this scope void UTL_Scope::add_to_referenced(AST_Decl *e, idl_bool recursive) { UTL_Scope *s; AST_Decl **tmp; AST_Interface *itf; long oreferenced_allocated; long i; if (e == NULL) return ; // Special cases for forward declared interfaces and valuetypes in // the scope in which they're defined. Cannot add before full // definition is seen if ((e->node_type() == AST_Decl::NT_interface) || (e->node_type() == AST_Decl::NT_value)) { itf = AST_Interface::narrow_from_decl(e); if (itf != NULL && itf->defined_in() == this && !itf->is_defined()) return ; } // Only insert if it is not there already if (referenced(e)) return ; // Make sure there's space for one more if (pd_referenced_allocated == pd_referenced_used) { oreferenced_allocated = pd_referenced_allocated; pd_referenced_allocated += INCREMENT; tmp = new AST_Decl * [pd_referenced_allocated]; for (i = 0; i < oreferenced_allocated; i++) tmp[i] = pd_referenced[i]; delete [] pd_referenced; pd_referenced = tmp; } // Insert new reference pd_referenced[pd_referenced_used++] = e; // Now, if recursive is specified and "this" is not a common ancestor // of the referencing scope and the scope of definition of "e" then // add "e" to the set of referenced nodes in the parent of "this" if (recursive && !(e->has_ancestor(ScopeAsDecl(this)))) { s = e->defined_in(); if (s != NULL) s->add_to_referenced(e, recursive); } }
static AST_Decl * add_type(AST_Type *type) { AST_Decl * result = 0; UTL_Scope * scope = 0; switch (type->node_type()) { case AST_Decl::NT_array: result = idl_global->root()->add_array(AST_Array::narrow_from_decl(type)); break; case AST_Decl::NT_enum: result = type->defined_in()->add_enum(AST_Enum::narrow_from_decl(type)); scope = AST_Enum::narrow_from_decl(type); break; case AST_Decl::NT_sequence: result = idl_global->root()->add_sequence(AST_Sequence::narrow_from_decl(type)); break; case AST_Decl::NT_string: result = idl_global->root()->add_string(AST_String::narrow_from_decl(type)); break; case AST_Decl::NT_struct: result = type->defined_in()-> add_structure(AST_Structure::narrow_from_decl(type)); scope = AST_Structure::narrow_from_decl(type); break; case AST_Decl::NT_union: result = type->defined_in()->add_union(AST_Union::narrow_from_decl(type)); scope = AST_Union::narrow_from_decl(type); break; default: // for non-complex types, like predefined types // no additional add needed, assume everything is ok result = (AST_Decl *) 1; break; } if (scope) result = scope->call_add(); return result; }
bool AST_InterfaceFwd::full_def_seen (void) { UTL_Scope *s = this->defined_in (); AST_Interface *i = 0; // If a full definition is seen in a previous module opening // or anywhere in the current scope (before or after our // declaration, reture TRUE. if (AST_Decl::NT_module == s->scope_node_type ()) { AST_Module *m = AST_Module::narrow_from_scope (s); AST_Decl *d = m->look_in_prev_mods_local (this->local_name (), false); if (0 != d) { i = AST_Interface::narrow_from_decl (d); if (0 != i && i->is_defined ()) { return true; } } } for (UTL_ScopeActiveIterator iter (s, UTL_Scope::IK_decls); !iter.is_done (); iter.next ()) { i = AST_Interface::narrow_from_decl (iter.item ()); if (0 != i && this->local_name ()->compare (i->local_name ())) { if (i->is_defined ()) { return true; } } } return false; }
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; } }
bool AST_illegal_recursive_type (AST_Decl *t) { if (t == 0) { return false; } AST_Decl::NodeType nt; AST_Type *ut = AST_Type::narrow_from_decl (t); if (ut != 0) { ut = ut->unaliased_type (); nt = ut->node_type (); } else { nt = t->node_type (); } if (nt == AST_Decl::NT_interface) { // Check for interface->struct/union->....->interface nesting. // return AST_illegal_interface_recursion (t); } else if (nt != AST_Decl::NT_struct && nt != AST_Decl::NT_union) { // Structs and unions fall through to the check below. return false; // NOT ILLEGAL. } bool check_for_struct = false; bool check_for_union = false; AST_Structure *st1 = 0; AST_Union *un1 = 0; // Narrow the type appropriately so comparison will work. if (t->node_type () == AST_Decl::NT_struct) { check_for_struct = true; st1 = AST_Structure::narrow_from_decl (t); if (st1 == 0) { return false; // NOT ILLEGAL. } } else if (t->node_type () == AST_Decl::NT_union) { check_for_union = true; un1 = AST_Union::narrow_from_decl (t); if (un1 == 0) { return false; // NOT ILLEGAL. } } UTL_Scope *s = 0; AST_Structure *st2 = 0; AST_Union *un2 = 0; // OK, iterate up the stack. for (UTL_ScopeStackActiveIterator i (idl_global->scopes ()); !i.is_done (); i.next ()) { s = i.item (); // If we hit a NULL we're done since it means that we're nested inside // a sequence, where recursive types may be used. if (s == 0) { return false; // NOT ILLEGAL. } // OK, must check this scope. if (s->scope_node_type () == AST_Decl::NT_struct && check_for_struct == true) { st2 = AST_Structure::narrow_from_scope (s); if (st2 != 0 && st2 == st1) { return true; // ILLEGAL RECURSIVE TYPE USE. } } else if (s->scope_node_type () == AST_Decl::NT_union && check_for_union == true) { un2 = AST_Union::narrow_from_scope (s); if (un2 != 0 && un2 == un1) { return true; // ILLEGAL RECURSIVE TYPE USE. } } } // No more scopes to check. This type was used legally. return false; // NOT ILLEGAL. }
int be_visitor_ami_pre_proc::visit_interface (be_interface *node) { // We check for an imported node after generating the reply handler. if (node->is_local () || node->is_abstract ()) { return 0; } // The following 3 IF blocks are checks for CCM-related nodes, which // we want to skip until we get AMI integrated with CIAO. // Skip the *EventConsumer added for each eventtype. if (node->is_event_consumer ()) { return 0; } // Check for home equivalent interface. The lookup will find the // home itself, which was declared first. Identifier *node_lname = node->AST_Decl::local_name (); AST_Decl *first_stored = node->defined_in ()->lookup_by_name_local (node_lname, false); if (0 != first_stored && first_stored->node_type () == AST_Decl::NT_home) { return 0; } ACE_CString lname (node_lname->get_string ()); // Skip the *Explict and *Implicit interfaces added for a home. if (lname.substr (lname.length () - 6) == "plicit") { UTL_Scope *s = node->defined_in (); Identifier local_id (lname.substr (0, lname.length () - 8).c_str ()); AST_Decl *d = s->lookup_by_name_local (&local_id, false); local_id.destroy (); if (0 != d) { return 0; } } AST_Module *module = AST_Module::narrow_from_scope (node->defined_in ()); if (!module) { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_ami_pre_proc::" "visit_interface - " "module is null\n"), -1); } be_interface *reply_handler = this->create_reply_handler (node); if (reply_handler) { reply_handler->set_defined_in (node->defined_in ()); // Insert the ami handler after the node, the // exception holder will be placed between these two later. module->be_add_interface (reply_handler, node); // Remember from whom we were cloned reply_handler->original_interface (node); // If this was created for an imported node, it will be wrong // unless we set it. reply_handler->set_imported (node->imported ()); } else { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_ami_pre_proc::" "visit_interface - " "creating the reply handler failed\n"), -1); } if (this->visit_scope (node) == -1) { ACE_ERROR_RETURN ((LM_ERROR, "(%N:%l) be_visitor_ami_pre_proc::" "visit_interface - " "visit scope failed\n"), -1); } return 0; }
void FE_ComponentHeader::compile_supports (UTL_NameList *supports) { if (supports == 0) { return; } AST_Decl *d = 0; UTL_ScopedName *item = 0; AST_Interface *iface = 0; AST_Type *t = 0; long j = 0; long k = 0; // Compute expanded flattened non-repeating list of interfaces // which this one inherits from. for (UTL_NamelistActiveIterator l (supports); !l.is_done (); l.next ()) { item = l.item (); // Check that scope stack is valid. if (idl_global->scopes ().top () == 0) { idl_global->err ()->lookup_error (item); // This is probably the result of bad IDL. // We will crash if we continue from here. throw Bailout (); } // Look it up. UTL_Scope *s = idl_global->scopes ().top (); d = s->lookup_by_name (item, true); if (d == 0) { AST_Decl *sad = ScopeAsDecl (s); if (sad->node_type () == AST_Decl::NT_module) { AST_Module *m = AST_Module::narrow_from_decl (sad); d = m->look_in_prev_mods_local (item->last_component ()); } } // Not found? if (d == 0) { idl_global->err ()->lookup_error (item); // This is probably the result of bad IDL. // We will crash if we continue from here. throw Bailout (); } // Remove typedefs, if any. if (d->node_type () == AST_Decl::NT_typedef) { d = AST_Typedef::narrow_from_decl (d)->primitive_base_type (); } AST_Decl::NodeType nt = d->node_type (); t = AST_Type::narrow_from_decl (d); if (nt == AST_Decl::NT_interface) { iface = AST_Interface::narrow_from_decl (d); // Undefined interface? if (!iface->is_defined ()) { idl_global->err ()->inheritance_fwd_error ( this->interface_name_, iface); continue; } // Local interface? (illegal for components to support). if (iface->is_local ()) { idl_global->err ()->unconstrained_interface_expected ( this->name (), iface->name ()); continue; } } else if (nt == AST_Decl::NT_param_holder) { AST_Param_Holder *ph = AST_Param_Holder::narrow_from_decl (d); nt = ph->info ()->type_; if (nt != AST_Decl::NT_type && nt != AST_Decl::NT_interface) { idl_global->err ()->mismatched_template_param ( ph->info ()->name_.c_str ()); continue; } } else { idl_global->err ()->interface_expected (d); continue; } // OK, see if we have to add this to the list of interfaces // inherited from. this->compile_one_inheritance (t); } // OK, install in interface header. // First the flat list (all ancestors). if (this->iused_flat_ > 0) { ACE_NEW (this->inherits_flat_, AST_Interface *[this->iused_flat_]); for (j = 0; j < this->iused_flat_; ++j) { this->inherits_flat_[j] = this->iseen_flat_[j]; } this->n_inherits_flat_ = this->iused_flat_; }
AST_Decl *UTL_Scope::call_add() { AST_Decl *result = NULL; AST_Decl *decl; UTL_ScopeActiveIterator *i; UTL_Scope *scope; i = new UTL_ScopeActiveIterator(this, UTL_Scope::IK_decls); while (!(i->is_done())) { decl = i->item(); scope = 0; switch (decl->node_type()) { case AST_Decl::NT_argument: result = add_argument(AST_Argument::narrow_from_decl(decl)); break; case AST_Decl::NT_array: result = add_array(AST_Array::narrow_from_decl(decl)); break; case AST_Decl::NT_attr: result = add_attribute(AST_Attribute::narrow_from_decl(decl)); break; case AST_Decl::NT_const: result = add_constant(AST_Constant::narrow_from_decl(decl)); break; case AST_Decl::NT_enum: scope = AST_Enum::narrow_from_decl(decl); result = add_enum(AST_Enum::narrow_from_decl(decl)); break; case AST_Decl::NT_enum_val: result = add_enum_val(AST_EnumVal::narrow_from_decl(decl)); break; case AST_Decl::NT_except: scope = AST_Exception::narrow_from_decl(decl); result = add_exception(AST_Exception::narrow_from_decl(decl)); break; case AST_Decl::NT_field: result = add_field(AST_Field::narrow_from_decl(decl)); break; case AST_Decl::NT_interface: scope = AST_Interface::narrow_from_decl(decl); result = add_interface(AST_Interface::narrow_from_decl(decl)); break; case AST_Decl::NT_interface_fwd: result = add_interface_fwd(AST_InterfaceFwd::narrow_from_decl(decl)); break; case AST_Decl::NT_module: scope = AST_Module::narrow_from_decl(decl); result = add_module(AST_Module::narrow_from_decl(decl)); break; case AST_Decl::NT_op: result = add_operation(AST_Operation::narrow_from_decl(decl)); scope = AST_Operation::narrow_from_decl(decl); break; case AST_Decl::NT_pre_defined: result = add_predefined_type(AST_PredefinedType::narrow_from_decl(decl)); break; case AST_Decl::NT_sequence: result = add_sequence(AST_Sequence::narrow_from_decl(decl)); break; case AST_Decl::NT_string: result = add_string(AST_String::narrow_from_decl(decl)); break; case AST_Decl::NT_struct: result = add_structure(AST_Structure::narrow_from_decl(decl)); scope = AST_Structure::narrow_from_decl(decl); break; case AST_Decl::NT_typedef: result = add_typedef(AST_Typedef::narrow_from_decl(decl)); break; case AST_Decl::NT_union: result = add_union(AST_Union::narrow_from_decl(decl)); scope = AST_Union::narrow_from_decl(decl); break; case AST_Decl::NT_union_branch: result = add_union_branch(AST_UnionBranch::narrow_from_decl(decl)); break; // case AST_Decl::NT_opaque: // result = add_opaque(AST_Opaque::narrow_from_decl(decl)); // break; case AST_Decl::NT_value: result = add_valuetype (AST_Value::narrow_from_decl (decl)); scope = AST_Value::narrow_from_decl (decl); break; case AST_Decl::NT_value_fwd: result = add_valuetype_fwd(AST_ValueFwd::narrow_from_decl(decl)); break; case AST_Decl::NT_state_member: result = add_state_member(AST_StateMember::narrow_from_decl(decl)); break; default: return NULL; } if (scope) scope->call_add(); i->next(); } delete i; return result; }
/* * Implements lookup by name for scoped names */ AST_Decl * UTL_Scope::lookup_by_name(UTL_ScopedName *e, idl_bool treat_as_ref, idl_bool in_parent) { AST_Decl *d; UTL_Scope *t = NULL; /* * Empty name? error */ if (e == NULL) { return NULL; } /* * If name starts with "::" or "" start search up in global scope */ if (is_global_name(e->head())) { /* * Get parent scope */ d = ScopeAsDecl(this); if (d == NULL) return NULL; t = d->defined_in(); /* * If this is the global scope.. */ if (t == NULL) { /* * Look up tail of name starting here */ d = lookup_by_name((UTL_ScopedName *) e->tail(), treat_as_ref); /* * Now return whatever we have */ return d; } /* * OK, not global scope yet, so simply iterate with parent scope */ d = t->lookup_by_name(e, treat_as_ref); /* * If treat_as_ref is true and d is not NULL, add d to * set of nodes referenced here */ if (treat_as_ref && d != NULL) add_to_referenced(d, I_FALSE); /* * Now return what we have */ return d; } /* * The name does not start with "::" * * Is name defined here? */ d = lookup_by_name_local (e->head ()); /* * Special case for scope which is an interface. We have to look * in the inherited interfaces as well.. */ if (d == NULL) { if (pd_scope_node_type == AST_Decl::NT_interface) { d = look_in_inherited(e, treat_as_ref); if (treat_as_ref && d != NULL) { add_to_referenced(d, I_FALSE); /* * OK, now return whatever we found */ return d; } } } /* Only traverse parent scope chain if not in inherited interface. */ if (d == NULL && !in_parent) { /* * OK, not found. Go down parent scope chain. */ d = ScopeAsDecl(this); if (d != NULL) { t = d->defined_in(); if (t == NULL) d = NULL; else d = t->lookup_by_name(e, treat_as_ref); } /* * If treat_as_ref is true and d is not NULL, add d to * set of nodes referenced here */ if (treat_as_ref && d != NULL) add_to_referenced(d, I_FALSE); /* * OK, now return whatever we found */ return d; } /* * OK, start of name is defined. Now loop doing local lookups * of subsequent elements of the name */ d = iter_lookup_by_name_local(d, e, treat_as_ref); /* * If treat_as_ref is true and d is not NULL, add d to set * of nodes referenced here. */ if (treat_as_ref && d != NULL) add_to_referenced(d, I_FALSE); /* * All OK, name fully resolved */ return d; }
/* * Helper function for lookup_by_name. Iterates doing local lookups of * subsequent components of a scoped name */ static AST_Decl * iter_lookup_by_name_local(AST_Decl *d, UTL_ScopedName *e, idl_bool treat_as_ref) { Identifier *s; AST_Typedef *td; UTL_IdListActiveIterator *i; UTL_Scope *sc; i = new UTL_IdListActiveIterator(e); for (i->next(); !(i->is_done()); ) { s = i->item(); /* * Update iterator before loop. This is needed for the check for * typedef, since we only want to look at the base type if there * actually are more components of the name to resolve. */ i->next(); /* * Next component in name was not found */ if (d == NULL) { return NULL; } /* * If this is a typedef and we're not done, we should get the * base type to get the scope it defines (if any) */ if (!(i->is_done())) { while (d != NULL && d->node_type() == AST_Decl::NT_typedef) { td = AST_Typedef::narrow_from_decl(d); if (td == NULL) return NULL; d = td->base_type(); } if (d == NULL) return NULL; } /* * Try to convert the AST_Decl to a UTL_Scope */ sc = DeclAsScope(d); if (sc == NULL) return NULL; /* * Look up the next element */ d = sc->lookup_by_name_local (s); } /* * OK, done with the loop */ return d; }
AST_Decl * UTL_Scope::lookup_primitive_type (AST_Expression::ExprType et) { AST_Decl *as_decl; UTL_Scope *ancestor; AST_PredefinedType *t; UTL_ScopeActiveIterator *i; AST_PredefinedType::PredefinedType pdt = AST_PredefinedType::PT_unknown; as_decl = ScopeAsDecl (this); if (as_decl == NULL) return NULL; ancestor = as_decl->defined_in(); if (ancestor != NULL) return ancestor->lookup_primitive_type(et); switch (et) { case AST_Expression::EV_short: pdt = AST_PredefinedType::PT_short; break; case AST_Expression::EV_ushort: pdt = AST_PredefinedType::PT_ushort; break; case AST_Expression::EV_long: pdt = AST_PredefinedType::PT_long; break; case AST_Expression::EV_ulong: pdt = AST_PredefinedType::PT_ulong; break; case AST_Expression::EV_longlong: pdt = AST_PredefinedType::PT_longlong; break; case AST_Expression::EV_ulonglong: pdt = AST_PredefinedType::PT_ulonglong; break; case AST_Expression::EV_float: pdt = AST_PredefinedType::PT_float; break; case AST_Expression::EV_double: pdt = AST_PredefinedType::PT_double; break; case AST_Expression::EV_longdouble: pdt = AST_PredefinedType::PT_longdouble; break; case AST_Expression::EV_char: pdt = AST_PredefinedType::PT_char; break; case AST_Expression::EV_wchar: pdt = AST_PredefinedType::PT_wchar; break; case AST_Expression::EV_octet: pdt = AST_PredefinedType::PT_octet; break; case AST_Expression::EV_bool: pdt = AST_PredefinedType::PT_boolean; break; case AST_Expression::EV_any: pdt = AST_PredefinedType::PT_any; break; case AST_Expression::EV_void: pdt = AST_PredefinedType::PT_void; break; case AST_Expression::EV_string: case AST_Expression::EV_wstring: case AST_Expression::EV_none: return NULL; } i = new UTL_ScopeActiveIterator(this, UTL_Scope::IK_decls); while (!(i->is_done())) { as_decl = i->item(); if (as_decl->node_type() == AST_Decl::NT_pre_defined) { t = AST_PredefinedType::narrow_from_decl(as_decl); if (t == NULL) { i->next(); continue; } if (t->pt() == pdt) { delete i; return t; } } i->next(); } delete i; return NULL; }