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