TAO/orbsvcs/IFR_Service/ifr_adding_visitor_operation.cpp

   1 /* -*- c++ -*- */
   2 #include "orbsvcs/Log_Macros.h"
   3 #include "ast_argument.h"
   4 #include "ast_exception.h"
   5 #include "ast_expression.h"
   6 #include "ast_operation.h"
   7 #include "utl_identifier.h"
   8 #include "utl_string.h"
   9
  10 #include "ifr_adding_visitor_operation.h"
  11 #include "utl_exceptlist.h"
  12 #include "utl_strlist.h"
  13 #include "nr_extern.h"
  14
  15 ifr_adding_visitor_operation::ifr_adding_visitor_operation (AST_Decl *scope)
  16   : ifr_adding_visitor (scope),
  17     index_ (0)
  18 {
  19 }
  20
  21 ifr_adding_visitor_operation::~ifr_adding_visitor_operation ()
  22 {
  23 }
  24
  25 int
  26 ifr_adding_visitor_operation::visit_operation (AST_Operation *node)
  27 {
  28   try
  29     {
  30       // If this operation is already in the repository (for example, if
  31       // we are processing the IDL file a second time inadvertently), we
  32       // just return 0. The IDL file must be legal, otherwise the IDL
  33       // compiler front end would have told us.
  34
  35       CORBA::Contained_var prev_def =
  36         be_global->repository ()->lookup_id (node->repoID ());
  37
  38       if (!CORBA::is_nil (prev_def.in ()))
  39         {
  40           return 0;
  41         }
  42
  43       // Build the parameter list. Our overridden version of visit_argument
  44       // will look up each parameter and add its repository entry to
  45       // our params_ member.
  46
  47       CORBA::ULong length = static_cast<CORBA::ULong> (node->argument_count ());
  48
  49       this->params_.length (length);
  50
  51       if (this->visit_scope (node) == -1)
  52         {
  53           ORBSVCS_ERROR_RETURN ((
  54               LM_ERROR,
  55               ACE_TEXT ("(%N:%l) ifr_adding_visitor_operation::")
  56               ACE_TEXT ("visit_operation -")
  57               ACE_TEXT (" visit_scope failed\n")
  58             ),
  59             -1
  60           );
  61         }
  62
  63       this->index_ = 0;
  64
  65       // Build the exception list.
  66
  67       UTL_ExceptList *excepts = node->exceptions ();
  68
  69       if (excepts != 0)
  70         {
  71           length = static_cast<CORBA::ULong> (excepts->length ());
  72         }
  73       else
  74         {
  75           length = 0;
  76         }
  77
  78       CORBA::ExceptionDefSeq exceptions (length);
  79       exceptions.length (length);
  80
  81       AST_Type *ex = 0;
  82       CORBA::ULong i = 0;
  83
  84       for (UTL_ExceptlistActiveIterator ex_iter (excepts);
  85            !ex_iter.is_done ();
  86            ex_iter.next (), ++i)
  87         {
  88           ex = ex_iter.item ();
  89
  90           prev_def =
  91             be_global->repository ()->lookup_id (ex->repoID ());
  92
  93           exceptions[i] =
  94             CORBA::ExceptionDef::_narrow (prev_def.in ());
  95         }
  96
  97       // Build the context list.
  98
  99       UTL_StrList *ctx_list = node->context ();
 100
 101       if (ctx_list != 0)
 102         {
 103           length = static_cast<CORBA::ULong> (ctx_list->length ());
 104         }
 105       else
 106         {
 107           length = 0;
 108         }
 109
 110       CORBA::ContextIdSeq contexts (length);
 111       contexts.length (length);
 112
 113       UTL_StrlistActiveIterator ctx_iter (ctx_list);
 114       UTL_String *str = 0;
 115       i = 0;
 116
 117       while (!ctx_iter.is_done ())
 118         {
 119           str = ctx_iter.item ();
 120
 121           contexts[i++] = str->get_string ();
 122
 123           ctx_iter.next ();
 124         }
 125
 126       // Get the return type.
 127
 128       AST_Type *return_type = node->return_type ();
 129
 130       // Updates ir_current_.
 131       this->get_referenced_type (return_type);
 132
 133       // Is the operation oneway?
 134       CORBA::OperationMode mode = node->flags () == AST_Operation::OP_oneway
 135                                  ? CORBA::OP_ONEWAY
 136                                  : CORBA::OP_NORMAL;
 137
 138       // Create the repository entry.
 139
 140       CORBA::Container_ptr current_scope =
 141         CORBA::Container::_nil ();
 142
 143       if (be_global->ifr_scopes ().top (current_scope) == 0)
 144         {
 145           AST_Decl *op_scope = ScopeAsDecl (node->defined_in ());
 146           AST_Decl::NodeType nt = op_scope->node_type ();
 147
 148           if (nt == AST_Decl::NT_interface)
 149             {
 150               CORBA::InterfaceDef_var iface =
 151                 CORBA::InterfaceDef::_narrow (current_scope);
 152
 153               CORBA::OperationDef_var new_def =
 154                 iface->create_operation (node->repoID (),
 155                                          node->local_name ()->get_string (),
 156                                          node->version (),
 157                                          this->ir_current_.in (),
 158                                          mode,
 159                                          this->params_,
 160                                          exceptions,
 161                                          contexts);
 162             }
 163           else
 164             {
 165               CORBA::ValueDef_var vtype =
 166                 CORBA::ValueDef::_narrow (current_scope);
 167
 168               CORBA::OperationDef_var new_def =
 169                 vtype->create_operation (node->repoID (),
 170                                          node->local_name ()->get_string (),
 171                                          node->version (),
 172                                          this->ir_current_.in (),
 173                                          mode,
 174                                          this->params_,
 175                                          exceptions,
 176                                          contexts);
 177             }
 178         }
 179       else
 180         {
 181           ORBSVCS_ERROR_RETURN ((
 182               LM_ERROR,
 183               ACE_TEXT ("(%N:%l) ifr_adding_visitor_operation::")
 184               ACE_TEXT ("visit_operation -")
 185               ACE_TEXT (" scope stack is empty\n")
 186             ),
 187             -1
 188           );
 189         }
 190     }
 191   catch (const CORBA::Exception& ex)
 192     {
 193       ex._tao_print_exception (
 194         ACE_TEXT (
 195           "ifr_adding_visitor_operation::visit_operation"));
 196
 197       return -1;
 198     }
 199
 200   return 0;
 201 }
 202
 203 int
 204 ifr_adding_visitor_operation::visit_argument (AST_Argument *node)
 205 {
 206   // Get the parameter's name.
 207   this->params_[this->index_].name =
 208     CORBA::string_dup (node->local_name ()->get_string ());
 209
 210   AST_Type *arg_type = node->field_type ();
 211
 212   try
 213     {
 214       // Updates ir_current_.
 215       this->get_referenced_type (arg_type);
 216
 217       this->params_[this->index_].type_def =
 218         CORBA::IDLType::_duplicate (this->ir_current_.in ());
 219
 220
 221       switch (node->direction ())
 222       {
 223         case AST_Argument::dir_IN:
 224           this->params_[this->index_].mode = CORBA::PARAM_IN;
 225           break;
 226         case AST_Argument::dir_OUT:
 227           this->params_[this->index_].mode = CORBA::PARAM_OUT;
 228           break;
 229         case AST_Argument::dir_INOUT:
 230           this->params_[this->index_].mode = CORBA::PARAM_INOUT;
 231           break;
 232       }
 233
 234       // IfR method create_operation does not use this - it just needs
 235       // to be non-zero for marshaling.
 236       this->params_[this->index_].type =
 237         CORBA::TypeCode::_duplicate (CORBA::_tc_void);
 238
 239       ++this->index_;
 240     }
 241   catch (const CORBA::Exception& ex)
 242     {
 243       ex._tao_print_exception (
 244         ACE_TEXT (
 245           "ifr_adding_visitor_operation::visit_argument"));
 246
 247       return -1;
 248     }
 249
 250   return 0;
 251 }