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