コード例 #1
0
ファイル: ast_module.cpp プロジェクト: osrf/opensplice
/*
 * 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;
}
コード例 #2
0
ファイル: ast_module.cpp プロジェクト: osrf/opensplice
/*
 * 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;
}
コード例 #3
0
ファイル: ast_module.cpp プロジェクト: S73417H/opensplice
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;
}
コード例 #4
0
ファイル: ast_value.cpp プロジェクト: diorahman/opensplice
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;
}
コード例 #5
0
ファイル: ast_exception.cpp プロジェクト: S73417H/opensplice
/*
 * 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;
}
コード例 #6
0
ファイル: ast_module.cpp プロジェクト: S73417H/opensplice
/*
 * 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;
}
コード例 #7
0
ファイル: ast_module.cpp プロジェクト: S73417H/opensplice
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;
}
コード例 #8
0
ファイル: ast_module.cpp プロジェクト: S73417H/opensplice
/*
 * 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;
}