/* * Add this AST_Enum node (an enum declaration) to this scope */ AST_Enum *AST_Module::fe_add_enum(AST_Enum *t) { AST_Decl *d; /* * Already defined and cannot be redefined? Or already used? */ if ((d = lookup_for_add (t)) != NULL) { if (!can_be_redefined (d)) { idl_global->err()->error3(UTL_Error::EIDL_REDEF, t, this, d); return NULL; } if (referenced (d)) { idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, t, this, d); return NULL; } } /* * Add it to scope */ add_to_scope(t); /* * Add it to set of locally referenced symbols */ add_to_referenced(t, false); return t; }
/* * 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; }
/* * Add this AST_Module node (a module declaration) to this scope */ AST_Module *AST_Module::fe_add_module (AST_Module * t) { /* Add new module to scope */ add_to_scope(t); /* Add to set of locally referenced symbols */ add_to_referenced(t, false); return t; }
AST_StateMember *AST_Value::fe_add_state_member(AST_StateMember *t) { AST_Decl *d; /* * Can't add to interface which was not yet defined */ if (!is_defined()) { idl_global->err()->error2(UTL_Error::EIDL_DECL_NOT_DEFINED, this, t); return NULL; } /* * Already defined and cannot be redefined? Or already used? */ if ((d = lookup_for_add (t)) != NULL) { if (!can_be_redefined(d)) { idl_global->err()->error3(UTL_Error::EIDL_REDEF, t, this, d); return NULL; } if (referenced(d)) { idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, t, this, d); return NULL; } if (t->has_ancestor(d)) { idl_global->err()->redefinition_in_scope(t, d); return NULL; } } /* * Add it to scope */ add_to_scope(t); /* * Add it to set of locally referenced symbols */ add_to_referenced(t, I_FALSE); return t; }
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; }
/* * Add this AST_EnumVal (enumerator declaration) to the current scope. * This is done to conform to the C++ scoping rules which declare * enumerators in the enclosing scope (in addition to declaring them * in the enum itself) */ AST_EnumVal *AST_Exception::fe_add_enum_val(AST_EnumVal *t) { AST_Decl *d; /* * Already defined and cannot be redefined? Or already used? */ if ((d = lookup_for_add (t)) != NULL) { if (!can_be_redefined(d)) { idl_global->err()->error3(UTL_Error::EIDL_REDEF, t, this, d); return NULL; } if (referenced(d)) { idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, t, this, d); return NULL; } if (t->has_ancestor(d)) { idl_global->err()->redefinition_in_scope(t, d); return NULL; } } /* * Add it to scope */ add_to_scope(t); /* * Add it to set of locally referenced symbols */ add_to_referenced(t, I_FALSE); return t; }
/* * Add this AST_Union node (a union declaration) to this module * scope. May be a declaration or a pre-declaration. */ AST_Union *AST_Module::fe_add_union (AST_Union * u) { AST_Decl * d = lookup_for_add (u); if (d) { /* Check for existing declaration or pre-declaration */ if (d->node_type () == AST_Decl::NT_union) { AST_Union * fwd = AST_Union::narrow_from_decl (d); if (fwd->is_defined () && u->is_defined ()) { idl_global->err()->error3 (UTL_Error::EIDL_REDEF, u, this, d); } else { if (! fwd->is_defined () && u->is_defined ()) { reorder (d); } // Return existing delete u; u = fwd; } } else { idl_global->err()->error3 (UTL_Error::EIDL_REDEF, u, this, d); } } else { add_to_scope (u); add_to_referenced (u, false); } return u; }
/* * Add this AST_Module node (a module declaration) to this scope */ AST_Module *AST_Module::fe_add_module (AST_Module * t) { AST_Decl *d; /* * Already defined and cannot be redefined? Or already used? */ d = lookup_for_add (t); if (d != NULL) { if (!can_be_redefined (d)) { idl_global->err()->error3 (UTL_Error::EIDL_REDEF, t, this, d); return NULL; } if (t->has_ancestor (d)) { idl_global->err()->redefinition_in_scope (t, d); return NULL; } /* Return existing module */ t = AST_Module::narrow_from_decl (d); } else { /* * Add new module to scope */ add_to_scope(t); /* Add to set of locally referenced symbols */ add_to_referenced(t, I_FALSE); } return t; }
AST_Opaque* AST_Module::fe_add_opaque(AST_Opaque* o) { AST_Decl *d; /* * Already defined and cannot be redefined? Or already used? */ if ((d = lookup_for_add (o)) != NULL) { if (!can_be_redefined(d)) { idl_global->err()->error3(UTL_Error::EIDL_REDEF, o, this, d); return NULL; } if (referenced(d)) { idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, o, this, d); return NULL; } } /* * Add it to scope */ add_to_scope(o); /* * Add it to set of locally referenced symbols */ add_to_referenced(o, I_FALSE); return o; }
/* * Add this AST_Value node (a value type declaration) to this scope */ AST_BoxedValue *AST_Module::fe_add_boxed_valuetype(AST_BoxedValue *v) { AST_Decl *predef; AST_Interface *fwd; /* * Already defined? */ if ((predef = lookup_for_add (v)) != NULL) { /* * Treat fwd declared interfaces specially */ if (predef->node_type() == AST_Decl::NT_value) { fwd = AST_Value::narrow_from_decl(predef); if (fwd == NULL) return NULL; if (!fwd->is_defined()) { /* Forward declared and not defined yet */ if (fwd->defined_in() != this) { idl_global->err() ->error3(UTL_Error::EIDL_SCOPE_CONFLICT, fwd, v, this); return NULL; } } /* * OK, not illegal redef of forward declaration. Now check whether * it has been referenced already */ else if (referenced(predef)) { idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, v, this, predef); return NULL; } } else if (!can_be_redefined(predef)) { idl_global->err()->error3(UTL_Error::EIDL_REDEF, v, this, predef); return NULL; } else if (referenced(predef)) { idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, v, this, predef); return NULL; } else if (v->has_ancestor(predef)) { idl_global->err()->redefinition_in_scope(v, predef); 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; }
/* * 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; }