TAO/TAO_IDL/ast/ast_annotation_appl.cpp

   1 #include "ast_annotation_appl.h"
   2 #include "ast_annotation_member.h"
   3
   4 AST_Annotation_Appl::Param::Param ()
   5   : id (nullptr),
   6     expr (nullptr),
   7     used (false)
   8 {
   9 }
  10
  11 AST_Annotation_Appl::Param::~Param ()
  12 {
  13   if (id)
  14     {
  15       id->destroy ();
  16     }
  17   delete id;
  18   if (expr)
  19     {
  20       expr->destroy ();
  21     }
  22   delete expr;
  23 }
  24
  25 void
  26 AST_Annotation_Appl::delete_params (AST_Annotation_Appl::Params* params)
  27 {
  28   if (params)
  29     {
  30       Params::ITERATOR iter (*params);
  31       while (!iter.done ())
  32         {
  33           Param **i = nullptr;
  34           iter.next (i);
  35           delete *i;
  36           iter.advance ();
  37         }
  38       delete params;
  39     }
  40 }
  41
  42 AST_Decl::NodeType const AST_Annotation_Appl::NT = AST_Decl::NT_annotation_appl;
  43
  44 AST_Annotation_Appl::AST_Annotation_Appl (
  45   UTL_ScopedName *name, AST_Annotation_Appl::Params *params)
  46   : AST_Decl (NT, name),
  47     AST_Type (NT, name),
  48     AST_ConcreteType (NT, name),
  49     UTL_Scope (NT),
  50     AST_Structure (name, false, false),
  51     AST_Annotation_Decl (name),
  52     original_name_ (name->get_string_copy ()),
  53     params_ (params),
  54     annotation_decl_ (nullptr)
  55 {
  56 }
  57
  58 AST_Annotation_Appl::~AST_Annotation_Appl ()
  59 {
  60   delete [] original_name_;
  61   delete_params (params_);
  62   AST_Structure::destroy ();
  63 }
  64
  65 void AST_Annotation_Appl::dump (ACE_OSTREAM_TYPE &o)
  66 {
  67   dump_i (o, original_name_);
  68   if (params_)
  69     {
  70       dump_i (o, "(");
  71       Params::ITERATOR iter (*params_);
  72       while (!iter.done ())
  73         {
  74           Param **i = nullptr;
  75           iter.next (i);
  76           if ((*i)->id)
  77             {
  78               (*i)->id->dump (o);
  79               dump_i (o, " = ");
  80             }
  81           (*i)->expr->dump (o);
  82           iter.advance ();
  83           if (!iter.done ())
  84             {
  85               dump_i (o, ", ");
  86             }
  87         }
  88       dump_i (o, ")");
  89     }
  90 }
  91
  92 int AST_Annotation_Appl::ast_accept (ast_visitor *)
  93 {
  94   return 0;
  95 }
  96
  97 void AST_Annotation_Appl::destroy ()
  98 {
  99 }
 100
 101 const char *AST_Annotation_Appl::original_name () const
 102 {
 103   return original_name_;
 104 }
 105
 106 bool
 107 AST_Annotation_Appl::apply_from (AST_Annotation_Decl *decl)
 108 {
 109   // Apply Each Member From the Annotation Declaration
 110   for (UTL_ScopeActiveIterator si (
 111       decl,
 112       UTL_Scope::IK_decls);
 113     !si.is_done ();
 114     si.next ())
 115     {
 116       AST_Annotation_Member *member =
 117         dynamic_cast<AST_Annotation_Member*> (si.item ());
 118       if (member)
 119         {
 120           AST_Annotation_Member *new_member = fe_add_annotation_member (
 121               new AST_Annotation_Member (member->name (), member));
 122
 123           /*
 124            * Check to see if we have a parameter that matches this. If not,
 125            * make sure that the member has a default value.
 126            */
 127           Param *param = find_param (member->local_name ()->get_string ());
 128           if (param)
 129             {
 130               new_member->value (new AST_Expression (param->expr, member->expr_type()));
 131               if (new_member->invalid_value ())
 132               {
 133                 idl_global->err ()->invalid_annotation_param_type (
 134                   this, member, param->expr);
 135                 return false;
 136               }
 137               param->used = true;
 138             }
 139           else if (!new_member->value ())
 140             {
 141               idl_global->err ()->annotation_param_missing_error (
 142                 this, member);
 143               return false;
 144             }
 145         }
 146     }
 147
 148   // Make sure all the parameters were used
 149   if (params_)
 150     {
 151       for (Param::Iterator it (*params_);
 152           !it.done (); it.advance ())
 153         {
 154           Param **param = nullptr;
 155           it.next (param);
 156           if ((*param) && !(*param)->used)
 157             {
 158               idl_global->err ()->invalid_annotation_param_error (
 159                 this, decl, (*param)->id);
 160               return false;
 161             }
 162         }
 163     }
 164
 165   annotation_decl_ = decl;
 166
 167   return true;
 168 }
 169
 170 AST_Annotation_Appl::Params *
 171 AST_Annotation_Appl::params ()
 172 {
 173   return params_;
 174 }
 175
 176 AST_Annotation_Decl *
 177 AST_Annotation_Appl::annotation_decl ()
 178 {
 179   return annotation_decl_;
 180 }
 181
 182 AST_Annotation_Appl::Param *
 183 AST_Annotation_Appl::find_param (const char *name)
 184 {
 185   if (params_)
 186     {
 187       // Check for single nameless parameter
 188       if (params_->size () == 1)
 189         {
 190           Param *top = nullptr;
 191           params_->top (top);
 192           if (top && !top->id && top->expr)
 193             {
 194               // Don't reuse it if used
 195               return top->used ? nullptr : top;
 196             }
 197         }
 198       for (Param::Iterator it (*params_);
 199           !it.done (); it.advance ())
 200         {
 201           Param **param = nullptr;
 202           it.next (param);
 203           if ((*param) && (*param)->id && !ACE_OS::strcmp ((*param)->id->get_string (), name))
 204             {
 205               return (*param);
 206             }
 207         }
 208     }
 209
 210   return nullptr;
 211 }