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 (void)
  33 {
  34 }
  35
  36 FE_Utils::T_PARAMLIST_INFO *
  37 AST_Template_Module::template_params (void) 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 = 0;
  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 = 0;
  70       (void) this->template_params_->get (param, slot);
  71       const char *s = 0;
  72
  73       if (! this->match_one_param (param, d))
  74         {
  75           UTL_ScopedName *n = d->name ();
  76
  77           if (n == 0)
  78             {
  79               AST_Constant *c = dynamic_cast<AST_Constant*> (d);
  80
  81               s = c->exprtype_to_string ();
  82             }
  83           else
  84             {
  85               s = d->full_name ();
  86             }
  87
  88           idl_global->err ()->mismatched_template_param (s);
  89
  90           return false;
  91         }
  92     }
  93
  94   return true;
  95 }
  96
  97 bool
  98 AST_Template_Module::match_param_refs (UTL_StrList *refs,
  99                                        UTL_Scope *decl_scope)
 100 {
 101   UTL_Scope *s = decl_scope;
 102   AST_Template_Module *enclosing = 0;
 103
 104   while (enclosing == 0 && s != 0)
 105     {
 106       enclosing = dynamic_cast<AST_Template_Module*> (s);
 107       s = ScopeAsDecl (s)->defined_in ();
 108     }
 109
 110   if (enclosing == 0)
 111     {
 112       ACE_ERROR_RETURN ((LM_ERROR,
 113                          ACE_TEXT ("AST_Template_Module::")
 114                          ACE_TEXT ("match_param_refs - ")
 115                          ACE_TEXT ("enclosing template ")
 116                          ACE_TEXT ("module scope not found\n")),
 117                         false);
 118     }
 119
 120   for (UTL_StrlistActiveIterator i (refs);
 121        !i.is_done ();
 122        i.next ())
 123     {
 124       FE_Utils::T_Param_Info *enclosing_param =
 125         enclosing->find_param (i.item ());
 126
 127       if (enclosing_param == 0)
 128         {
 129           // Enclosing param not found
 130           return false;
 131         }
 132
 133       if (!this->match_param_by_type (enclosing_param))
 134         {
 135           // Referenced param type not matched to enclosiong param.
 136           return false;
 137         }
 138     }
 139
 140   return true;
 141 }
 142
 143 void
 144 AST_Template_Module::destroy (void)
 145 {
 146   delete this->template_params_;
 147   this->template_params_ = 0;
 148
 149   this->AST_Module::destroy ();
 150 }
 151
 152 int
 153 AST_Template_Module::ast_accept (ast_visitor *visitor)
 154 {
 155   return visitor->visit_template_module (this);
 156 }
 157
 158 AST_Template_Module_Ref *
 159 AST_Template_Module::fe_add_template_module_ref (
 160   AST_Template_Module_Ref *m)
 161 {
 162   return dynamic_cast<AST_Template_Module_Ref*> (this->fe_add_ref_decl (m));
 163 }
 164
 165 void
 166 AST_Template_Module::dump (ACE_OSTREAM_TYPE & /* o */)
 167 {
 168 }
 169
 170 bool
 171 AST_Template_Module::match_one_param (FE_Utils::T_Param_Info *param,
 172                                       AST_Decl *d)
 173 {
 174   if (param->type_ == AST_Decl::NT_type)
 175     {
 176       return true;
 177     }
 178
 179   if (d->node_type () == AST_Decl::NT_typedef)
 180     {
 181       AST_Typedef *td = dynamic_cast<AST_Typedef*> (d);
 182       d = td->primitive_base_type ();
 183     }
 184
 185   AST_Decl::NodeType other_type = d->node_type ();
 186
 187   if (other_type == AST_Decl::NT_const)
 188     {
 189       AST_Constant *c = dynamic_cast<AST_Constant*> (d);
 190
 191       AST_Expression *ex = c->constant_value ();
 192
 193       AST_Expression::AST_ExprValue *ev =
 194         ex->check_and_coerce (param->const_type_,
 195                               param->enum_const_type_decl_);
 196
 197       if (ev == 0)
 198         {
 199           idl_global->err ()->coercion_error (ex,
 200                                               param->const_type_);
 201         }
 202
 203       bool retval = (ev != 0);
 204       delete ev;
 205       ev = 0;
 206       return retval;
 207     }
 208
 209   return (param->type_ == other_type);
 210 }
 211
 212 FE_Utils::T_Param_Info *
 213 AST_Template_Module::find_param (UTL_String *name)
 214 {
 215   for (FE_Utils::T_PARAMLIST_INFO::CONST_ITERATOR i (
 216          *this->template_params_);
 217        !i.done ();
 218        i.advance ())
 219     {
 220       FE_Utils::T_Param_Info *param = 0;
 221       i.next (param);
 222
 223       if (param->name_ == name->get_string ())
 224         {
 225           return param;
 226         }
 227     }
 228
 229   return 0;
 230 }
 231
 232 bool
 233 AST_Template_Module::match_param_by_type (
 234   FE_Utils::T_Param_Info *param)
 235 {
 236   for (FE_Utils::T_PARAMLIST_INFO::CONST_ITERATOR i (
 237          *this->template_params_);
 238        !i.done ();
 239        i.advance ())
 240     {
 241       FE_Utils::T_Param_Info *my_param = 0;
 242       i.next (my_param);
 243
 244       if (param->type_ == my_param->type_)
 245         {
 246           if (param->type_ == AST_Decl::NT_const)
 247             {
 248               if (param->const_type_ == my_param->const_type_)
 249                 {
 250                   if (param->const_type_ == AST_Expression::EV_enum)
 251                     {
 252                       if (param->enum_const_type_decl_
 253                             == my_param->enum_const_type_decl_)
 254                         {
 255                           return true;
 256                         }
 257                     }
 258                   else
 259                     {
 260                       return true;
 261                     }
 262                 }
 263             }
 264           else
 265             {
 266               return true;
 267             }
 268         }
 269     }
 270
 271   idl_global->err ()->mismatched_template_param (
 272     param->name_.c_str ());
 273
 274   return false;
 275 }
 276
 277 IMPL_NARROW_FROM_DECL (AST_Template_Module)
 278 IMPL_NARROW_FROM_SCOPE (AST_Template_Module)
 279