TAO/TAO_IDL/be/be_visitor_interface/interface_ss.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    interface_ss.cpp
   5  *
   6  *  Visitor generating code for Interfaces in the server skeletons file.
   7  *
   8  *  @author Aniruddha Gokhale
   9  */
  10 //=============================================================================
  11
  12 #include "interface.h"
  13 #include "global_extern.h"
  14 #include "ast_generator.h"
  15 #include "ast_string.h"
  16
  17 be_visitor_interface_ss::be_visitor_interface_ss (be_visitor_context *ctx)
  18   : be_visitor_interface (ctx)
  19 {
  20 }
  21
  22 be_visitor_interface_ss::~be_visitor_interface_ss ()
  23 {
  24 }
  25
  26 int
  27 be_visitor_interface_ss::visit_interface (be_interface *node)
  28 {
  29   if (node->srv_skel_gen ()
  30       || node->imported ()
  31       || node->is_abstract ())
  32     {
  33       return 0;
  34     }
  35
  36   if (node->is_local ())
  37     {
  38       if (this->is_amh_rh_node (node))
  39         {
  40           // Create amh_rh_visitors.
  41           be_visitor_amh_rh_interface_ss amh_rh_ss_intf (this->ctx_);
  42           amh_rh_ss_intf.visit_interface (node);
  43         }
  44
  45       return 0;
  46     }
  47
  48   if (this->generate_amh_classes (node) == -1)
  49     {
  50       return -1;
  51     }
  52   ACE_CString full_skel_name_holder =
  53     this->generate_full_skel_name (node);
  54
  55   const char *full_skel_name = full_skel_name_holder.c_str ();
  56
  57   ACE_CString flat_name_holder =
  58     this->generate_flat_name (node);
  59
  60   const char *flat_name = flat_name_holder.c_str ();
  61
  62   int status =
  63     node->gen_operation_table (flat_name,
  64                                full_skel_name);
  65
  66   if (status == -1)
  67     {
  68       ACE_ERROR_RETURN ((LM_ERROR,
  69                          ACE_TEXT ("be_visitor_interface_ss::")
  70                          ACE_TEXT ("visit_interface - ")
  71                          ACE_TEXT ("codegen for operation ")
  72                          ACE_TEXT ("table failed\n")),
  73                         -1);
  74     }
  75
  76   if (this->generate_proxy_classes (node) == -1)
  77     {
  78       ACE_ERROR_RETURN ((LM_ERROR,
  79                          ACE_TEXT ("be_visitor_interface_ss::")
  80                          ACE_TEXT ("visit_interface - ")
  81                          ACE_TEXT ("codegen for proxy classes\n")),
  82                         -1);
  83     }
  84
  85   TAO_OutStream *os = this->ctx_->stream ();
  86
  87   *os << be_nl_2;
  88
  89   TAO_INSERT_COMMENT (os);
  90
  91   *os << be_nl_2;
  92
  93   // Find if we are at the top scope or inside some module,
  94   // pre-compute the prefix that must be added to the local name in
  95   // each case.
  96   const char *local_name_prefix = "";
  97
  98   if (!node->is_nested ())
  99     {
 100       local_name_prefix = "POA_";
 101     }
 102
 103   ACE_CString node_local_name_holder =
 104     this->generate_local_name (node);
 105
 106   const char *node_local_name = node_local_name_holder.c_str ();
 107
 108   *os << full_skel_name << "::"
 109       << local_name_prefix << node_local_name
 110       << " ()";
 111
 112   if (node->nmembers () == 0)
 113     {
 114       *os << be_idt_nl << ": TAO_ServantBase ()" << be_uidt_nl;
 115     }
 116   else
 117     {
 118       *os << be_nl;
 119     }
 120
 121   // Default constructor body.
 122   *os << "{" << be_idt_nl
 123       << "this->optable_ = std::addressof (tao_" << flat_name
 124       << "_optable);" << be_uidt_nl
 125       << "}" << be_nl_2;
 126
 127   // Generate code for elements in the scope (e.g., operations).
 128   if (this->visit_scope (node) == -1)
 129     {
 130       ACE_ERROR_RETURN ((LM_ERROR,
 131                          ACE_TEXT ("be_visitor_interface_ss::")
 132                          ACE_TEXT ("visit_interface - ")
 133                          ACE_TEXT ("codegen for scope failed\n")),
 134                         -1);
 135     }
 136
 137   *os << be_nl_2;
 138
 139   TAO_INSERT_COMMENT (os);
 140
 141   *os << be_nl_2;
 142
 143   // Generate code for the _is_a override.
 144   *os << be_nl_2
 145       << "::CORBA::Boolean " << full_skel_name
 146       << "::_is_a (const char* value)" << be_nl
 147       << "{" << be_idt_nl
 148       << "return" << be_idt_nl
 149       << "(" << be_idt_nl;
 150
 151   if (node->traverse_inheritance_graph (be_interface::is_a_helper, os) == -1)
 152     {
 153       ACE_ERROR_RETURN ((LM_ERROR,
 154                          ACE_TEXT ("be_visitor_interface_ss::")
 155                          ACE_TEXT ("visit_interface - ")
 156                          ACE_TEXT ("traversal of inhertance ")
 157                          ACE_TEXT ("graph failed\n")),
 158                         -1);
 159     }
 160
 161   *os << "std::strcmp (value, \"IDL:omg.org/CORBA/Object:1.0\") == 0";
 162
 163   if (node->has_mixed_parentage ())
 164     {
 165       *os << " ||" << be_nl
 166           << "std::strcmp (value, \"IDL:omg.org/CORBA/AbstractBase:1.0\") == 0";
 167     }
 168
 169   *os << be_uidt_nl
 170       << ");" << be_uidt << be_uidt_nl
 171       << "}" << be_nl_2;
 172
 173   *os << "const char* " << full_skel_name
 174       << "::_interface_repository_id () const"
 175       << be_nl;
 176   *os << "{" << be_idt_nl;
 177   *os << "return \"" << node->repoID () << "\";" << be_uidt_nl;
 178   *os << "}";
 179
 180   // Print out dispatch method.
 181   this->dispatch_method (node);
 182
 183   this->this_method (node);
 184
 185   if (be_global->gen_tie_classes () && !node->tie_skel_gen ())
 186     {
 187       // Generate the TIE class.
 188       be_visitor_context ctx (*this->ctx_);
 189       ctx.state (TAO_CodeGen::TAO_ROOT_TIE_SS);
 190       ctx.stream (tao_cg->server_template_skeletons ());
 191       be_visitor_interface_tie_ss visitor (&ctx);
 192
 193       if (node->accept (&visitor) == -1)
 194         {
 195           ACE_ERROR_RETURN ((LM_ERROR,
 196                              ACE_TEXT ("be_visitor_interface_ss::")
 197                              ACE_TEXT ("visit_interface - ")
 198                              ACE_TEXT ("codegen for TIE ")
 199                              ACE_TEXT ("class failed\n")),
 200                             -1);
 201         }
 202
 203       // AMH generation reuses this visit_interface(), hence the flag.
 204       node->tie_skel_gen (true);
 205     }
 206
 207   return 0;
 208 }
 209
 210 int
 211 be_visitor_interface_ss::visit_component (be_component *node)
 212 {
 213   return this->visit_interface (node);
 214 }
 215
 216 int
 217 be_visitor_interface_ss::visit_connector (be_connector *node)
 218 {
 219   return this->visit_interface (node);
 220 }
 221
 222 int
 223 be_visitor_interface_ss::gen_abstract_ops_helper (
 224   be_interface *node,
 225   be_interface *base,
 226   TAO_OutStream *os)
 227 {
 228   if (!base->is_abstract ())
 229     {
 230       return 0;
 231     }
 232
 233   AST_Decl *d = nullptr;
 234   be_visitor_context ctx;
 235   ctx.stream (os);
 236   ctx.state (TAO_CodeGen::TAO_ROOT_SS);
 237
 238   for (UTL_ScopeActiveIterator si (base, UTL_Scope::IK_decls);
 239        !si.is_done ();
 240        si.next ())
 241     {
 242       d = si.item ();
 243
 244       if (d == nullptr)
 245         {
 246           ACE_ERROR_RETURN ((LM_ERROR,
 247                              ACE_TEXT ("be_visitor_interface_ss::")
 248                              ACE_TEXT ("gen_abstract_ops_helper - ")
 249                              ACE_TEXT ("bad node in this scope\n")),
 250                             -1);
 251         }
 252
 253       AST_Decl::NodeType nt = d->node_type ();
 254
 255       UTL_ScopedName *item_new_name = nullptr;
 256       UTL_ScopedName *new_name = nullptr;
 257
 258       if (AST_Decl::NT_op == nt || AST_Decl::NT_attr == nt)
 259         {
 260           ACE_NEW_RETURN (item_new_name,
 261                           UTL_ScopedName (d->local_name ()->copy (),
 262                                           nullptr),
 263                           -1);
 264
 265           new_name = (UTL_ScopedName *) node->name ()->copy ();
 266           new_name->nconc (item_new_name);
 267         }
 268       else
 269         {
 270           continue;
 271         }
 272
 273       // We pass the node's is_abstract flag to the operation
 274       // constructor so we will get the right generated operation
 275       // body if we are regenerating an operation from an
 276       // abstract interface in a concrete interface or component.
 277       if (AST_Decl::NT_op == nt)
 278         {
 279           be_operation *op = dynamic_cast<be_operation*> (d);
 280           UTL_ScopedName *old_name =
 281             (UTL_ScopedName *) op->name ()->copy ();
 282           op->set_name (new_name);
 283           op->set_defined_in (node);
 284           op->is_abstract (node->is_abstract ());
 285
 286           be_visitor_operation_ss op_visitor (&ctx);
 287           op_visitor.visit_operation (op);
 288
 289           op->set_name (old_name);
 290           op->set_defined_in (base);
 291           op->is_abstract (base->is_abstract ());
 292         }
 293       else if (AST_Decl::NT_attr == nt)
 294         {
 295           AST_Attribute *attr =
 296             dynamic_cast<AST_Attribute*> (d);
 297           be_attribute new_attr (attr->readonly (),
 298                                  attr->field_type (),
 299                                  nullptr,
 300                                  attr->is_local (),
 301                                  attr->is_abstract ());
 302           new_attr.set_defined_in (node);
 303           new_attr.set_name (new_name);
 304
 305           UTL_ExceptList *get_exceptions =
 306             attr->get_get_exceptions ();
 307
 308           if (nullptr != get_exceptions)
 309             {
 310               new_attr.be_add_get_exceptions (get_exceptions->copy ());
 311             }
 312
 313           UTL_ExceptList *set_exceptions =
 314             attr->get_set_exceptions ();
 315
 316           if (nullptr != set_exceptions)
 317             {
 318               new_attr.be_add_set_exceptions (set_exceptions->copy ());
 319             }
 320
 321           be_visitor_attribute attr_visitor (&ctx);
 322           attr_visitor.visit_attribute (&new_attr);
 323           ctx.attribute (nullptr);
 324           new_attr.destroy ();
 325         }
 326     }
 327
 328   return 0;
 329 }
 330
 331 void
 332 be_visitor_interface_ss::this_method (be_interface *node)
 333 {
 334   TAO_OutStream *os = this->ctx_->stream ();
 335
 336   *os << be_nl_2;
 337
 338   TAO_INSERT_COMMENT (os);
 339
 340   *os << be_nl_2;
 341
 342   // The _this () operation.
 343   *os << node->full_name () << " *" << be_nl
 344       << node->full_skel_name ()
 345       << "::_this ()" << be_nl
 346       << "{" << be_idt_nl
 347       << "TAO_Stub_Auto_Ptr stub (this->_create_stub ());"
 348       << be_nl;
 349
 350   *os << "::CORBA::Boolean const _tao_opt_colloc = "
 351       << "stub->servant_orb_var ()->orb_core ()->"
 352       << "optimize_collocation_objects ();" << be_nl;
 353
 354   /* Coverity whines about an unused return value from _nil() when
 355      initializing tmp.  Just use zero instead. */
 356   *os << "::CORBA::Object_var obj = "
 357       << "new (std::nothrow) ::CORBA::Object (stub.get (), _tao_opt_colloc, this);" << be_nl
 358       << "if (obj.ptr ())" << be_idt_nl
 359       << "{" << be_idt_nl;
 360
 361   *os << "(void) stub.release ();" << be_nl
 362       << "return "
 363       << "TAO::Narrow_Utils<::" << node->name () << ">::unchecked_narrow ("
 364       << "obj.in ());";
 365
 366   *os << be_uidt_nl
 367       << "}"
 368       << be_uidt_nl << "return {};" << be_uidt_nl << "}";
 369 }
 370
 371 void
 372 be_visitor_interface_ss::dispatch_method (be_interface *node)
 373 {
 374   TAO_OutStream *os = this->ctx_->stream ();
 375
 376   *os << be_nl_2;
 377
 378   TAO_INSERT_COMMENT (os);
 379
 380   *os << be_nl_2;
 381
 382   *os << "void " << node->full_skel_name ()
 383       << "::_dispatch (" << be_idt_nl
 384       << "TAO_ServerRequest & req," << be_nl
 385       << "TAO::Portable_Server::Servant_Upcall* servant_upcall)"
 386       << be_uidt_nl;
 387   *os << "{" << be_idt_nl;
 388   *os << "this->synchronous_upcall_dispatch (req, servant_upcall, this);"
 389       << be_uidt_nl;
 390   *os << "}";
 391 }
 392
 393 int
 394 be_visitor_interface_ss::generate_amh_classes (be_interface *node)
 395 {
 396   // We have to check for any abstract ancestor until AMH is integrated
 397   // with abstract interfaces. If the node itself is abstract, this
 398   // visitor would not be created.
 399   if (be_global->gen_amh_classes () && !node->has_mixed_parentage ())
 400     {
 401       be_visitor_amh_interface_ss amh_intf (this->ctx_);
 402       return amh_intf.visit_interface (node);
 403     }
 404
 405   return 0;
 406 }
 407
 408 int
 409 be_visitor_interface_ss::generate_proxy_classes (be_interface *node)
 410 {
 411   if (be_global->gen_direct_collocation ())
 412     {
 413       be_visitor_context ctx = *this->ctx_;
 414       ctx.state (TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SS);
 415       be_visitor_interface_direct_proxy_impl_ss idpi_visitor (&ctx);
 416
 417       if (node->accept (&idpi_visitor) == -1)
 418         {
 419           ACE_ERROR_RETURN ((LM_ERROR,
 420                              ACE_TEXT ("be_visitor_interface_cs::")
 421                              ACE_TEXT ("generate_proxy_classes - ")
 422                              ACE_TEXT ("codegen for Base Proxy ")
 423                              ACE_TEXT ("Broker class failed\n")),
 424                             -1);
 425         }
 426     }
 427
 428   return 0;
 429 }
 430
 431 ACE_CString
 432 be_visitor_interface_ss::generate_flat_name (be_interface *node)
 433 {
 434   return ACE_CString (node->flat_name ());
 435 }
 436
 437 ACE_CString
 438 be_visitor_interface_ss::generate_local_name (be_interface *node)
 439 {
 440   return ACE_CString (node->local_name ());
 441 }
 442
 443 ACE_CString
 444 be_visitor_interface_ss::generate_full_skel_name  (be_interface *node)
 445 {
 446   return ACE_CString (node->full_skel_name ());
 447 }