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