TAO/TAO_IDL/ast/ast_template_module.cpp

   1 #include "ast_template_module.h"
   2 #include "ast_template_module_ref.h"
   3 #include "ast_constant.h"
   4 #include "ast_enum.h"
   5 #include "ast_typedef.h"
   6 #include "ast_visitor.h"
   7
   8 #include "utl_err.h"
   9 #include "utl_string.h"
  10 #include "utl_strlist.h"
  11 #include "global_extern.h"
  12 #include "nr_extern.h"
  13
  14 AST_Decl::NodeType const
  15 AST_Template_Module::NT = AST_Decl::NT_module;
  16
  17 AST_Template_Module::AST_Template_Module (
  18       UTL_ScopedName *n,
  19       FE_Utils::T_PARAMLIST_INFO *template_params)
  20   : COMMON_Base (false,
  21                  false),
  22     AST_Decl (AST_Decl::NT_module,
  23               n),
  24     UTL_Scope (AST_Decl::NT_module),
  25     AST_Module (n),
  26     AST_Type (AST_Decl::NT_module,
  27               n),
  28     template_params_ (template_params)
  29 {
  30 }
  31
  32 AST_Template_Module::~AST_Template_Module ()
  33 {
  34 }
  35
  36 FE_Utils::T_PARAMLIST_INFO *
  37 AST_Template_Module::template_params () const
  38 {
  39   return this->template_params_;
  40 }
  41
  42 bool
  43 AST_Template_Module::match_arg_names (FE_Utils::T_ARGLIST *args)
  44 {
  45   if (args->size () != this->template_params_->size ())
  46     {
  47       idl_global->err ()->error1 (UTL_Error::EIDL_T_ARG_LENGTH,
  48                                   this);
  49       return false;
  50     }
  51
  52   size_t slot = 0UL;
  53
  54   for (FE_Utils::T_ARGLIST::CONST_ITERATOR i (*args);
  55        !i.done ();
  56        i.advance (), ++slot)
  57     {
  58       AST_Decl **item = nullptr;
  59       i.next (item);
  60       AST_Decl *d = *item;
  61
  62       if (d->node_type () == AST_Decl::NT_typedef)
  63         {
  64           AST_Typedef *td = dynamic_cast<AST_Typedef*> (d);
  65
  66           d = td->primitive_base_type ();
  67         }
  68
  69       FE_Utils::T_Param_Info *param = nullptr;
  70       (void) this->template_params_->get (param, slot);
  71
  72       if (!this->match_one_param (param, d))
  73         {
  74           UTL_ScopedName *n = d->name ();
  75           const char *s = nullptr;
  76
  77           if (!n)
  78             {
  79               AST_Constant *c = dynamic_cast<AST_Constant *> (d);
  80               s = AST_Expression::exprtype_to_string (c->et ());
  81             }
  82           else
  83             {
  84               s = d->full_name ();
  85             }
  86
  87           idl_global->err ()->mismatched_template_param (s);
  88
  89           return false;
  90         }
  91     }
  92
  93   return true;
  94 }
  95
  96 bool
  97 AST_Template_Module::match_param_refs (UTL_StrList *refs,
  98                                        UTL_Scope *decl_scope)
  99 {
 100   UTL_Scope *s = decl_scope;
 101   AST_Template_Module *enclosing = nullptr;
 102
 103   while (enclosing == nullptr && s != nullptr)
 104     {
 105       enclosing = dynamic_cast<AST_Template_Module*> (s);
 106       s = ScopeAsDecl (s)->defined_in ();
 107     }
 108
 109   if (enclosing == nullptr)
 110     {
 111       ACE_ERROR_RETURN ((LM_ERROR,
 112                          ACE_TEXT ("AST_Template_Module::")
 113                          ACE_TEXT ("match_param_refs - ")
 114                          ACE_TEXT ("enclosing template ")
 115                          ACE_TEXT ("module scope not found\n")),
 116                         false);
 117     }
 118
 119   for (UTL_StrlistActiveIterator i (refs);
 120        !i.is_done ();
 121        i.next ())
 122     {
 123       FE_Utils::T_Param_Info *enclosing_param =
 124         enclosing->find_param (i.item ());
 125
 126       if (enclosing_param == nullptr)
 127         {
 128           // Enclosing param not found
 129           return false;
 130         }
 131
 132       if (!this->match_param_by_type (enclosing_param))
 133         {
 134           // Referenced param type not matched to enclosiong param.
 135           return false;
 136         }
 137     }
 138
 139   return true;
 140 }
 141
 142 void
 143 AST_Template_Module::destroy ()
 144 {
 145   delete this->template_params_;
 146   this->template_params_ = nullptr;
 147
 148   this->AST_Module::destroy ();
 149 }
 150
 151 int
 152 AST_Template_Module::ast_accept (ast_visitor *visitor)
 153 {
 154   return visitor->visit_template_module (this);
 155 }
 156
 157 AST_Template_Module_Ref *
 158 AST_Template_Module::fe_add_template_module_ref (
 159   AST_Template_Module_Ref *m)
 160 {
 161   return dynamic_cast<AST_Template_Module_Ref*> (this->fe_add_ref_decl (m));
 162 }
 163
 164 void
 165 AST_Template_Module::dump (ACE_OSTREAM_TYPE & /* o */)
 166 {
 167 }
 168
 169 bool
 170 AST_Template_Module::match_one_param (FE_Utils::T_Param_Info *param,
 171                                       AST_Decl *d)
 172 {
 173   if (param->type_ == AST_Decl::NT_type)
 174     {
 175       return true;
 176     }
 177
 178   if (d->node_type () == AST_Decl::NT_typedef)
 179     {
 180       AST_Typedef *td = dynamic_cast<AST_Typedef*> (d);
 181       d = td->primitive_base_type ();
 182     }
 183
 184   AST_Decl::NodeType other_type = d->node_type ();
 185
 186   if (other_type == AST_Decl::NT_const)
 187     {
 188       AST_Constant *c = dynamic_cast<AST_Constant*> (d);
 189
 190       AST_Expression *ex = c->constant_value ();
 191
 192       AST_Expression::AST_ExprValue *ev =
 193         ex->check_and_coerce (param->const_type_,
 194                               param->enum_const_type_decl_);
 195
 196       if (ev == nullptr)
 197         {
 198           idl_global->err ()->coercion_error (ex,
 199                                               param->const_type_);
 200         }
 201
 202       bool retval = (ev != nullptr);
 203       delete ev;
 204       ev = nullptr;
 205       return retval;
 206     }
 207
 208   return (param->type_ == other_type);
 209 }
 210
 211 FE_Utils::T_Param_Info *
 212 AST_Template_Module::find_param (UTL_String *name)
 213 {
 214   for (FE_Utils::T_PARAMLIST_INFO::CONST_ITERATOR i (
 215          *this->template_params_);
 216        !i.done ();
 217        i.advance ())
 218     {
 219       FE_Utils::T_Param_Info *param = nullptr;
 220       i.next (param);
 221
 222       if (param->name_ == name->get_string ())
 223         {
 224           return param;
 225         }
 226     }
 227
 228   return nullptr;
 229 }
 230
 231 bool
 232 AST_Template_Module::match_param_by_type (
 233   FE_Utils::T_Param_Info *param)
 234 {
 235   for (FE_Utils::T_PARAMLIST_INFO::CONST_ITERATOR i (
 236          *this->template_params_);
 237        !i.done ();
 238        i.advance ())
 239     {
 240       FE_Utils::T_Param_Info *my_param = nullptr;
 241       i.next (my_param);
 242
 243       if (param->type_ == my_param->type_)
 244         {
 245           if (param->type_ == AST_Decl::NT_const)
 246             {
 247               if (param->const_type_ == my_param->const_type_)
 248                 {
 249                   if (param->const_type_ == AST_Expression::EV_enum)
 250                     {
 251                       if (param->enum_const_type_decl_
 252                             == my_param->enum_const_type_decl_)
 253                         {
 254                           return true;
 255                         }
 256                     }
 257                   else
 258                     {
 259                       return true;
 260                     }
 261                 }
 262             }
 263           else
 264             {
 265               return true;
 266             }
 267         }
 268     }
 269
 270   idl_global->err ()->mismatched_template_param (
 271     param->name_.c_str ());
 272
 273   return false;
 274 }