TAO/TAO_IDL/be/be_visitor_operation/operation_ss.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    operation_ss.cpp
   5  *
   6  *  Visitor generating code for Operation in the server skeleton
   7  *
   8  *  @author Aniruddha Gokhale
   9  */
  10 //=============================================================================
  11
  12 #include "operation.h"
  13
  14 be_visitor_operation_ss::be_visitor_operation_ss (be_visitor_context *ctx)
  15   : be_visitor_operation (ctx)
  16 {
  17 }
  18
  19 be_visitor_operation_ss::~be_visitor_operation_ss ()
  20 {
  21 }
  22
  23 int
  24 be_visitor_operation_ss::visit_operation (be_operation * node)
  25 {
  26   /// No server-side code generation for these implied IDL nodes.
  27   if (node->is_sendc_ami ())
  28     {
  29       return 0;
  30     }
  31
  32   TAO_OutStream *os = this->ctx_->stream ();
  33   be_type *bt = nullptr;
  34
  35   this->ctx_->node (node);
  36
  37   os->indent ();
  38
  39   // If there is an argument of type "native", return immediately.
  40   if (node->has_native ())
  41     {
  42       return 0;
  43     }
  44
  45   // Retrieve the operation return type.
  46   bt = dynamic_cast<be_type*> (node->return_type ());
  47
  48   if (!bt)
  49     {
  50       ACE_ERROR_RETURN ((LM_ERROR,
  51                          ACE_TEXT ("be_visitor_operation_ss::")
  52                          ACE_TEXT ("visit_operation - ")
  53                          ACE_TEXT ("Bad return type\n")),
  54                         -1);
  55     }
  56
  57   return this->gen_skel_operation_body (node, bt);
  58 }
  59
  60 int
  61 be_visitor_operation_ss::visit_argument (be_argument *node)
  62 {
  63   // This method is used to generate the ParamData table entry.
  64
  65   TAO_OutStream *os = this->ctx_->stream ();
  66
  67   // Retrieve the type for this argument.
  68   be_type *bt = dynamic_cast<be_type*> (node->field_type ());
  69
  70   if (!bt)
  71     {
  72       ACE_ERROR_RETURN ((LM_ERROR,
  73                          "(%N:%l) be_visitor_operation_ss::"
  74                          "visit_argument - "
  75                          "Bad argument type\n"),
  76                         -1);
  77     }
  78
  79   os->indent ();
  80   *os << "{" << bt->tc_name () << ", ";
  81   switch (node->direction ())
  82     {
  83     case AST_Argument::dir_IN:
  84       *os << "::CORBA::ARG_IN, ";
  85       break;
  86     case AST_Argument::dir_INOUT:
  87       *os << "::CORBA::ARG_INOUT, ";
  88       break;
  89     case AST_Argument::dir_OUT:
  90       *os << "::CORBA::ARG_OUT, ";
  91       break;
  92     }
  93   *os << "0}";
  94
  95   return 0;
  96 }
  97
  98 int
  99 be_visitor_operation_ss::gen_pre_skel_info (be_operation * node)
 100 {
 101   be_visitor_context ctx = *this->ctx_;
 102   be_visitor_operation_exceptlist_ss visitor (&ctx);
 103
 104   if (node->accept (&visitor) == -1)
 105     {
 106       ACE_ERROR_RETURN ((LM_ERROR,
 107                          "(%N:%l) "
 108                          "be_visitor_operation_ss::"
 109                          "gen_pre_skel_info - "
 110                          "Exception TypeCode list generation error\n"),
 111                         -1);
 112     }
 113
 114   return 0;
 115 }
 116
 117 int
 118 be_visitor_operation_ss::gen_skel_operation_body (be_operation * node,
 119                                                   be_type * return_type)
 120 {
 121   TAO_OutStream * const os = this->ctx_->stream ();
 122
 123   // We need the interface node in which this operation was
 124   // defined.  However, if this operation node was an attribute node
 125   // in disguise, we get this information from the context.
 126   UTL_Scope *s = this->ctx_->attribute ()
 127                  ? this->ctx_->attribute ()->defined_in ()
 128                  : node->defined_in ();
 129
 130   be_interface *intf = dynamic_cast<be_interface*> (s);
 131
 132   if (intf == nullptr)
 133     {
 134       ACE_ERROR_RETURN ((LM_ERROR,
 135                          ACE_TEXT ("be_visitor_operation_ss::")
 136                          ACE_TEXT ("visit_operation - ")
 137                          ACE_TEXT ("bad interface scope\n")),
 138                         -1);
 139     }
 140
 141   ACE_CString upcall_command_name =
 142     this->ctx_->port_prefix ()
 143     + ACE_CString (node->local_name ()->get_string ()) + "_"
 144     + ACE_CString (intf->local_name ());
 145
 146   // Check if we are an attribute node in disguise.
 147   if (this->ctx_->attribute ())
 148     {
 149       // Now check if we are a "get" or "set" operation.
 150       if (node->nmembers () == 1)
 151         {
 152           upcall_command_name = "_set_" + upcall_command_name;
 153         }
 154       else
 155         {
 156           upcall_command_name = "_get_" + upcall_command_name;
 157         }
 158     }
 159
 160   // Generate the local class encapsulating the actual servant upcall
 161   // command/invocation.
 162   be_visitor_operation_upcall_command_ss upcall_command_visitor (this->ctx_);
 163   upcall_command_visitor.visit (node,
 164                                 intf->full_skel_name (),
 165                                 upcall_command_name.c_str ());
 166
 167   TAO_INSERT_COMMENT (os);
 168
 169   *os << "void " << intf->full_skel_name () << "::";
 170
 171   // Check if we are an attribute node in disguise.
 172   if (this->ctx_->attribute ())
 173     {
 174       // Now check if we are a "get" or "set" operation.
 175       if (node->nmembers () == 1)
 176         {
 177           *os << "_set_";
 178         }
 179       else
 180         {
 181           *os << "_get_";
 182         }
 183     }
 184
 185   *os << this->ctx_->port_prefix ().c_str () << node->local_name ()
 186       << "_skel (" << be_idt_nl
 187       << "TAO_ServerRequest & server_request," << be_nl
 188       << "TAO::Portable_Server::Servant_Upcall *TAO_INTERCEPTOR (servant_upcall)," << be_nl
 189       << "TAO_ServantBase *servant)" << be_uidt_nl;
 190
 191   // Generate the actual code for the skeleton. However, if any of the
 192   // argument types is "native", we do not generate any skeleton
 193   // last argument - is always CORBA::Environment.
 194   *os << "{" << be_idt;
 195
 196   // Generate all the tables and other pre-skel info.
 197   if (this->gen_pre_skel_info (node) == -1)
 198     {
 199       ACE_ERROR_RETURN ((LM_ERROR,
 200                          "(%N:%l) be_visitor_operation_ss::"
 201                          "visit_operation - "
 202                          "gen_pre_skel_info failed\n"),
 203                         -1);
 204     }
 205
 206   // Declare return type helper class.
 207
 208   *os << "TAO::SArg_Traits< ";
 209
 210   this->gen_arg_template_param_name (node,
 211                                      return_type,
 212                                      os);
 213
 214   *os << ">::ret_val retval;";
 215
 216   // Declare the argument helper classes.
 217   this->gen_skel_body_arglist (node, os);
 218
 219   *os << be_nl_2
 220       << "TAO::Argument * const args[] =" << be_idt_nl
 221       << "{" << be_idt_nl
 222       << "std::addressof(retval)";
 223
 224   for (UTL_ScopeActiveIterator arg_list_iter (node, UTL_Scope::IK_decls);
 225        ! arg_list_iter.is_done ();
 226        arg_list_iter.next ())
 227     {
 228       AST_Argument * const arg =
 229         dynamic_cast<AST_Argument*> (arg_list_iter.item ());
 230
 231       *os << "," << be_nl
 232           << "std::addressof(_tao_" << arg->local_name () << ")";
 233     }
 234
 235   *os << be_uidt_nl
 236       << "};" << be_uidt_nl << be_nl;
 237
 238   // Get the right object implementation.
 239   *os << intf->full_skel_name () << " * const impl =" << be_idt_nl
 240       << "dynamic_cast<"
 241       << intf->full_skel_name () << " *> (servant);" << be_uidt << be_nl_2;
 242
 243   *os << "if (!impl)" << be_idt_nl
 244       << "{" << be_idt_nl
 245       << "throw ::CORBA::INTERNAL ();" << be_uidt_nl
 246       << "}" << be_uidt << be_nl_2;
 247
 248   // Upcall_Command instantiation.
 249   *os << upcall_command_name.c_str()
 250       << " command (" << be_idt_nl
 251       << "impl";
 252
 253   if (!node->void_return_type () || node->argument_count () > 0)
 254     {
 255       // server_request.operation_details () will be non-zero in the
 256       // thru-POA collocation case.  Use them if available.
 257       *os << "," << be_nl;
 258
 259       if (be_global->gen_thru_poa_collocation ())
 260         *os << "server_request.operation_details ()," << be_nl;
 261
 262       *os << "args";
 263     }
 264
 265   *os << ");" << be_uidt_nl << be_nl;
 266
 267   *os << "TAO::Upcall_Wrapper upcall_wrapper;" << be_nl
 268       << "upcall_wrapper.upcall (server_request" << be_nl
 269       << "                       , args" << be_nl
 270       << "                       , " << (node->argument_count () + 1) << be_nl
 271       << "                       , command"
 272       << "\n#if TAO_HAS_INTERCEPTORS == 1" << be_nl
 273       << "                       , servant_upcall" << be_nl;
 274
 275   if (node->exceptions () && be_global->tc_support ())
 276     {
 277       *os << "                       , exceptions" << be_nl
 278           << "                       , " << node->exceptions ()->length ();
 279     }
 280   else
 281     {
 282       *os << "                       , nullptr" << be_nl
 283           << "                       , 0";
 284     }
 285
 286   *os << "\n#endif  /* TAO_HAS_INTERCEPTORS == 1 */" << be_nl
 287       << "                       );" << be_uidt_nl
 288       << "}" << be_nl_2;
 289
 290   return 0;
 291 }
 292
 293 void
 294 be_visitor_operation_ss::gen_skel_body_arglist (be_operation * node,
 295                                                 TAO_OutStream * os)
 296 {
 297   for (UTL_ScopeActiveIterator arg_decl_iter (node, UTL_Scope::IK_decls);
 298        ! arg_decl_iter.is_done ();
 299        arg_decl_iter.next ())
 300     {
 301       AST_Argument * const arg =
 302         dynamic_cast<AST_Argument*> (arg_decl_iter.item ());
 303
 304       *os << be_nl
 305           << "TAO::SArg_Traits< ";
 306
 307       this->gen_arg_template_param_name (arg,
 308                                          arg->field_type (),
 309                                          os);
 310
 311       *os << ">::";
 312
 313       switch (arg->direction ())
 314         {
 315           case AST_Argument::dir_IN:
 316             *os << "in";
 317             break;
 318           case AST_Argument::dir_INOUT:
 319             *os << "inout";
 320             break;
 321           case AST_Argument::dir_OUT:
 322             *os << "out";
 323           default:
 324             break;
 325         }
 326
 327       *os << "_arg_val _tao_" << arg->local_name () << ";";
 328     }
 329 }