TAO/TAO_IDL/be/be_component.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    be_component.cpp
   5  *
   6  *  Extension of class AST_Component that provides additional means for C++
   7  *  mapping of an interface.
   8  *
   9  *  @author Jeff Parsons
  10  */
  11 //=============================================================================
  12
  13 #include "be_component.h"
  14 #include "be_visitor.h"
  15 #include "be_helper.h"
  16
  17 #include "ast_mirror_port.h"
  18 #include "ast_uses.h"
  19 #include "ast_provides.h"
  20 #include "ast_attribute.h"
  21
  22 #include "global_extern.h"
  23 #include "utl_err.h"
  24
  25 be_component::be_component (UTL_ScopedName *n,
  26                             AST_Component *base_component,
  27                             AST_Type **supports,
  28                             long n_supports,
  29                             AST_Interface **supports_flat,
  30                             long n_supports_flat)
  31   : COMMON_Base (false,
  32                  false),
  33     AST_Decl (AST_Decl::NT_component,
  34               n),
  35     AST_Type (AST_Decl::NT_component,
  36               n),
  37     UTL_Scope (AST_Decl::NT_component),
  38     AST_Interface (n,
  39                    supports,
  40                    n_supports,
  41                    supports_flat,
  42                    n_supports_flat,
  43                    false,
  44                    false),
  45     AST_Component (n,
  46                    base_component,
  47                    supports,
  48                    n_supports,
  49                    supports_flat,
  50                    n_supports_flat),
  51     be_scope (AST_Decl::NT_component),
  52     be_decl (AST_Decl::NT_component,
  53              n),
  54     be_type (AST_Decl::NT_component,
  55              n),
  56     be_interface (n,
  57                   supports,
  58                   n_supports,
  59                   supports_flat,
  60                   n_supports_flat,
  61                   false,
  62                   false),
  63     n_provides_ (0UL),
  64     n_remote_provides_ (0UL),
  65     n_uses_ (0UL),
  66     n_remote_uses_ (0UL),
  67     has_uses_multiple_ (false),
  68     n_publishes_ (0UL),
  69     n_consumes_ (0UL),
  70     n_emits_ (0UL)
  71 {
  72   this->size_type (AST_Type::VARIABLE);
  73   this->has_constructor (true);
  74 }
  75
  76 be_component::~be_component ()
  77 {
  78 }
  79
  80 be_component *
  81 be_component::base_component () const
  82 {
  83   return dynamic_cast<be_component*> (this->AST_Component::base_component ());
  84 }
  85
  86 void
  87 be_component::redefine (AST_Interface *from)
  88 {
  89   be_component *bc = dynamic_cast<be_component*> (from);
  90   this->var_out_seq_decls_gen_ = bc->var_out_seq_decls_gen_;
  91   AST_Component::redefine (from);
  92 }
  93
  94 void
  95 be_component::destroy ()
  96 {
  97   this->be_interface::destroy ();
  98   this->AST_Component::destroy ();
  99 }
 100
 101 int
 102 be_component::accept (be_visitor *visitor)
 103 {
 104   return (idl_global->ignore_idl3 ()
 105             ? 0
 106             : visitor->visit_component (this));
 107 }
 108
 109 AST_Structure *
 110 be_component::be_add_structure (AST_Structure *t)
 111 {
 112   return this->fe_add_structure (t);
 113 }
 114
 115 AST_Typedef *
 116 be_component::be_add_typedef (AST_Typedef *t)
 117 {
 118   return this->fe_add_typedef (t);
 119 }
 120
 121 ACE_CDR::ULong
 122 be_component::n_provides () const
 123 {
 124   return this->n_provides_;
 125 }
 126
 127 ACE_CDR::ULong
 128 be_component::n_remote_provides () const
 129 {
 130   return this->n_remote_provides_;
 131 }
 132
 133 ACE_CDR::ULong
 134 be_component::n_uses () const
 135 {
 136   return this->n_uses_;
 137 }
 138
 139 ACE_CDR::ULong
 140 be_component::n_remote_uses () const
 141 {
 142   return this->n_remote_uses_;
 143 }
 144
 145 bool
 146 be_component::has_uses_multiple () const
 147 {
 148   return this->has_uses_multiple_;
 149 }
 150
 151 ACE_CDR::ULong
 152 be_component::n_publishes () const
 153 {
 154   return this->n_publishes_;
 155 }
 156
 157 ACE_CDR::ULong
 158 be_component::n_consumes () const
 159 {
 160   return this->n_consumes_;
 161 }
 162
 163 ACE_CDR::ULong
 164 be_component::n_emits () const
 165 {
 166   return this->n_emits_;
 167 }
 168
 169 void
 170 be_component::scan (UTL_Scope *s)
 171 {
 172   if (s == nullptr)
 173     {
 174       return;
 175     }
 176
 177   AST_Extended_Port *ep = nullptr;
 178   AST_Mirror_Port *mp = nullptr;
 179   AST_Uses *u = nullptr;
 180   AST_Provides *p = nullptr;
 181   AST_Attribute *a = nullptr;
 182   AST_Decl::NodeType my_nt;
 183   AST_Decl::NodeType scope_nt;
 184
 185   for (UTL_ScopeActiveIterator i (s, UTL_Scope::IK_both);
 186        !i.is_done ();
 187        i.next ())
 188     {
 189       AST_Decl *d = i.item ();
 190
 191       switch (d->node_type ())
 192         {
 193           case AST_Decl::NT_provides:
 194             ++this->n_provides_;
 195             p = dynamic_cast<AST_Provides*> (d);
 196
 197             if (!p->provides_type ()->is_local ())
 198               {
 199                 ++this->n_remote_provides_;
 200               }
 201
 202             continue;
 203           case AST_Decl::NT_uses:
 204             ++this->n_uses_;
 205             u = dynamic_cast<AST_Uses*> (d);
 206
 207             if (u->is_multiple ())
 208               {
 209                 this->has_uses_multiple_ = true;
 210               }
 211
 212             if (!u->uses_type ()->is_local ())
 213               {
 214                 ++this->n_remote_uses_;
 215               }
 216
 217             continue;
 218           case AST_Decl::NT_publishes:
 219             ++this->n_publishes_;
 220             continue;
 221           case AST_Decl::NT_consumes:
 222             ++this->n_consumes_;
 223             continue;
 224           case AST_Decl::NT_emits:
 225             ++this->n_emits_;
 226             continue;
 227           case AST_Decl::NT_ext_port:
 228             ep = dynamic_cast<AST_Extended_Port*> (d);
 229             this->scan (ep->port_type ());
 230             continue;
 231           case AST_Decl::NT_mirror_port:
 232             mp = dynamic_cast<AST_Mirror_Port*> (d);
 233             this->mirror_scan (mp->port_type ());
 234             continue;
 235           case AST_Decl::NT_attr:
 236             a = dynamic_cast<AST_Attribute*> (d);
 237
 238             if (!a->readonly ())
 239               {
 240                 my_nt = this->node_type ();
 241                 scope_nt =
 242                   ScopeAsDecl (a->defined_in ())->node_type ();
 243
 244                 /// Attributes coming from a porttype appear
 245                 /// only on connectors.
 246                 if (my_nt == AST_Decl::NT_component
 247                     && scope_nt == AST_Decl::NT_porttype)
 248                   {
 249                     continue;
 250                   }
 251
 252                 this->has_rw_attributes_ = true;
 253               }
 254
 255             continue;
 256           default:
 257             continue;
 258         }
 259     }
 260
 261   AST_Component *c = dynamic_cast<AST_Component*> (s);
 262   AST_Interface *iface = nullptr;
 263
 264   if (c != nullptr)
 265     {
 266       for (long i = 0; i < c->n_supports (); ++i)
 267         {
 268           // See if the supported interfaces (if any) have attributes.
 269           // If CORBA::Object is supported, DeclAsScope will evaluate
 270           // to 0 and the call to scan() will return immediately.
 271           this->scan (DeclAsScope (c->supports ()[i]));
 272         }
 273
 274       // Check the base component. If there is none, the arg to scan()
 275       // will be 0 and the call will return immediately.
 276       this->scan (c->base_component ());
 277     }
 278   else if ((iface = dynamic_cast<AST_Interface*> (s)) != nullptr)
 279     {
 280       for (long i = 0; i < iface->n_inherits (); ++i)
 281         {
 282           // Will pick up a chain of inheritance,
 283           // no need to use inherits_flat().
 284           this->scan (DeclAsScope (iface->inherits ()[i]));
 285         }
 286     }
 287 }
 288
 289 void
 290 be_component::gen_stub_inheritance (TAO_OutStream *os)
 291 {
 292   this->analyze_parentage ();
 293
 294   *os << "public virtual ::";
 295
 296   AST_Component *parent = this->base_component ();
 297
 298   if (parent != nullptr)
 299     {
 300       *os << parent->name ();
 301     }
 302   else
 303     {
 304       *os << "Components::CCMObject";
 305     }
 306
 307   long nsupports = this->n_inherits ();
 308
 309   if (nsupports > 0)
 310     {
 311       *os << be_idt;
 312
 313       AST_Type **supp_list = this->supports ();
 314
 315       for (long i = 0; i < nsupports; ++i)
 316         {
 317           *os << "," << be_nl
 318               << "public virtual ::"
 319               << supp_list[i]->name ();
 320         }
 321
 322       *os << be_uidt;
 323     }
 324
 325   *os << be_uidt;
 326 }
 327
 328 void
 329 be_component::gen_skel_inheritance (TAO_OutStream *os)
 330 {
 331   AST_Component *base = this->base_component ();
 332
 333   if (base != nullptr)
 334     {
 335       *os << "public virtual POA_" << base->name ();
 336     }
 337   else
 338     {
 339       *os << "public virtual POA_Components::CCMObject";
 340     }
 341
 342   long nsupports = this->n_inherits ();
 343   AST_Type **supports = this->supports ();
 344   AST_Type *supported = nullptr;
 345
 346   for (long i = 0; i < nsupports; ++i)
 347     {
 348       supported = supports[i];
 349
 350       if (supported->is_abstract ())
 351         {
 352           continue;
 353         }
 354
 355       *os << "," << be_nl;
 356       *os << "public virtual POA_" << supported->name ();
 357     }
 358 }
 359
 360 int
 361 be_component::gen_is_a_ancestors (TAO_OutStream *os)
 362 {
 363   AST_Component *ancestor = this;
 364
 365   while (ancestor != nullptr)
 366     {
 367       *os << "std::strcmp (value, \"" << ancestor->repoID () << "\") == 0 ||" << be_nl;
 368
 369       ancestor = ancestor->base_component ();
 370     }
 371
 372   *os << "std::strcmp (value, \"IDL:omg.org/Components/CCMObject:1.0\") == 0" << be_nl;
 373
 374   return 0;
 375 }
 376
 377 void
 378 be_component::mirror_scan (AST_PortType *pt)
 379 {
 380   AST_Uses *u = nullptr;
 381   AST_Provides *p = nullptr;
 382   AST_Attribute *a = nullptr;
 383
 384   for (UTL_ScopeActiveIterator i (pt, UTL_Scope::IK_decls);
 385        !i.is_done ();
 386        i.next ())
 387     {
 388       AST_Decl *d = i.item ();
 389
 390       switch (d->node_type ())
 391         {
 392           case AST_Decl::NT_provides:
 393             ++this->n_uses_;
 394             p = dynamic_cast<AST_Provides*> (d);
 395
 396             if (!p->provides_type ()->is_local ())
 397               {
 398                 ++this->n_remote_uses_;
 399               }
 400
 401             continue;
 402           case AST_Decl::NT_uses:
 403             ++this->n_provides_;
 404             u = dynamic_cast<AST_Uses*> (d);
 405
 406             if (!u->uses_type ()->is_local ())
 407               {
 408                 ++this->n_remote_provides_;
 409               }
 410
 411             continue;
 412           case AST_Decl::NT_attr:
 413             a = dynamic_cast<AST_Attribute*> (d);
 414
 415             if (!a->readonly ())
 416               {
 417                 this->has_rw_attributes_ = true;
 418               }
 419
 420             continue;
 421           default:
 422             continue;
 423         }
 424     }
 425 }
 426