TAO/TAO_IDL/be/be_visitor_operation/argument.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    argument.cpp
   5  *
   6  *  Visitor that calls the visitor for arguments.
   7  *
   8  *  @author Aniruddha Gokhale
   9  */
  10 //=============================================================================
  11
  12 #include "operation.h"
  13
  14 // ************************************************************
  15 // Generic operation visitor to handle the pre/post
  16 // do_static_call/upcall stuff with arguments.
  17 // ************************************************************
  18
  19 be_visitor_operation_argument::be_visitor_operation_argument (
  20     be_visitor_context *ctx
  21   )
  22   : be_visitor_operation (ctx)
  23 {
  24 }
  25
  26 be_visitor_operation_argument::~be_visitor_operation_argument ()
  27 {
  28 }
  29
  30 int
  31 be_visitor_operation_argument::post_process (be_decl *bd)
  32 {
  33   TAO_OutStream *os = this->ctx_->stream ();
  34
  35   // If we are not the last parameter, we insert a comma. This is only
  36   // applicable for the upcalls or the call to (de)marshal that we use in the
  37   // interpreted marshaling.
  38   switch (this->ctx_->state ())
  39     {
  40     case TAO_CodeGen::TAO_OPERATION_ARG_UPCALL_SS:
  41     case TAO_CodeGen::TAO_OPERATION_ARG_DEMARSHAL_SS:
  42       if (!this->last_node (bd))
  43         {
  44           *os << "," << be_nl;
  45         }
  46
  47       break;
  48     case TAO_CodeGen::TAO_OPERATION_COLLOCATED_ARG_UPCALL_SS:
  49       if (!this->last_node (bd))
  50         {
  51           *os << ",";
  52         }
  53
  54       break;
  55     default:
  56       break;
  57     }
  58
  59   return 0;
  60 }
  61
  62 int
  63 be_visitor_operation_argument::visit_operation (be_operation *node)
  64 {
  65   // All we do is hand over code generation to our scope.
  66   if (this->visit_scope (node) == -1)
  67     {
  68       ACE_ERROR_RETURN ((LM_ERROR,
  69                          "(%N:%l) be_visitor_operation_argument::"
  70                          "visit_operation - "
  71                          "codegen for scope failed\n"),
  72                         -1);
  73     }
  74
  75   return 0;
  76 }
  77
  78 int
  79 be_visitor_operation_argument::visit_argument (be_argument *node)
  80 {
  81   // Get the visitor that will dump the argument's mapping in the operation
  82   // signature.
  83   be_visitor_context ctx (*this->ctx_);
  84
  85   // First grab the interface definition inside which this operation is
  86   // defined. We need this since argument types may very well be declared
  87   // inside the scope of the interface node. In such cases, we would like to
  88   // generate the appropriate relative scoped names.
  89   be_operation *op =
  90     dynamic_cast<be_operation*> (this->ctx_->scope ());
  91
  92   if (op == nullptr)
  93     {
  94       ACE_ERROR_RETURN ((LM_ERROR,
  95                          "(%N:%l) be_visitor_arglist::"
  96                          "visit_argument - "
  97                          "Bad operation\n"),
  98                         -1);
  99     }
 100
 101   // We need the interface node in which this operation was defined. However,
 102   // if this operation node was an attribute node in disguise, we get this
 103   // information from the context.
 104   be_interface *intf;
 105   intf = this->ctx_->attribute ()
 106     ? dynamic_cast<be_interface*> (this->ctx_->attribute ()->defined_in ())
 107     : dynamic_cast<be_interface*> (op->defined_in ());
 108
 109   if (!intf)
 110     {
 111       ACE_ERROR_RETURN ((LM_ERROR,
 112                          "(%N:%l) be_visitor_arglist::"
 113                          "visit_argument - "
 114                          "Bad interface\n"),
 115                         -1);
 116     }
 117
 118   ctx.scope (intf);
 119   int status = 0;
 120
 121   switch (this->ctx_->state ())
 122     {
 123     case TAO_CodeGen::TAO_OPERATION_ARG_INVOKE_CS:
 124       {
 125         be_visitor_args_invoke_cs visitor (&ctx);
 126         status = node->accept (&visitor);
 127         break;
 128       }
 129     case TAO_CodeGen::TAO_OPERATION_ARG_DECL_SS:
 130       {
 131         be_visitor_args_vardecl_ss visitor (&ctx);
 132         status = node->accept (&visitor);
 133         break;
 134       }
 135     case TAO_CodeGen::TAO_OPERATION_ARG_DEMARSHAL_SS:
 136       {
 137         be_visitor_args_marshal_ss visitor (&ctx);
 138         status = node->accept (&visitor);
 139         break;
 140       }
 141     case TAO_CodeGen::TAO_OPERATION_COLLOCATED_ARG_UPCALL_SS:
 142       {
 143         ctx.state (TAO_CodeGen::TAO_ARGUMENT_COLLOCATED_UPCALL_SS);
 144         be_visitor_args_upcall_ss visitor (&ctx);
 145         status = node->accept (&visitor);
 146         break;
 147       }
 148     case TAO_CodeGen::TAO_OPERATION_ARG_UPCALL_SS:
 149       {
 150         be_visitor_args_upcall_ss visitor (&ctx);
 151         status = node->accept (&visitor);
 152         break;
 153       }
 154     default:
 155       {
 156         ACE_ERROR_RETURN ((LM_ERROR,
 157                            "(%N:%l) be_visitor_argument::"
 158                            "visit_argument - "
 159                            "Bad context\n"),
 160                           -1);
 161       }
 162     }
 163
 164   if (status == -1)
 165     {
 166       ACE_ERROR_RETURN ((LM_ERROR,
 167                          "(%N:%l) be_visitor_argument::"
 168
 169                          "visit_argument - "
 170                          "codegen for argument failed\n"),
 171                         -1);
 172     }
 173
 174   return 0;
 175 }