TAO/orbsvcs/IFR_Service/ifr_adding_visitor_exception.cpp

   1 /* -*- c++ -*- */
   2 #include "orbsvcs/Log_Macros.h"
   3 #include "ast_enum.h"
   4 #include "ast_exception.h"
   5 #include "ast_expression.h"
   6 #include "ast_field.h"
   7 #include "ast_union.h"
   8 #include "utl_identifier.h"
   9
  10 #include "ifr_adding_visitor_exception.h"
  11 #include "ifr_adding_visitor_structure.h"
  12 #include "ifr_adding_visitor_union.h"
  13
  14 ifr_adding_visitor_exception::ifr_adding_visitor_exception (
  15     AST_Decl *scope,
  16     bool in_reopened
  17   )
  18   : ifr_adding_visitor (scope,
  19                         in_reopened)
  20 {
  21 }
  22
  23 ifr_adding_visitor_exception::~ifr_adding_visitor_exception (void)
  24 {
  25 }
  26
  27 // Specialized visit_scope method for exceptions only.
  28 int
  29 ifr_adding_visitor_exception::visit_scope (UTL_Scope *node)
  30 {
  31   // If the exception has members that are scopes but not exceptions,
  32   // the regular visit_scope method should be called instead.
  33   if (node->scope_node_type () != AST_Decl::NT_except)
  34     {
  35       return ifr_adding_visitor::visit_scope (node);
  36     }
  37
  38   AST_Exception *e = dynamic_cast<AST_Exception*> (node);
  39
  40   CORBA::ULong const nfields = static_cast<CORBA::ULong> (e->nfields ());
  41
  42   this->members_.length (nfields);
  43
  44   AST_Field **f = 0;
  45
  46   try
  47     {
  48       // Visit each field.
  49       for (CORBA::ULong i = 0; i < nfields; ++i)
  50         {
  51           if (e->field (f, i) != 0)
  52             {
  53               ORBSVCS_ERROR_RETURN ((
  54                   LM_ERROR,
  55                   ACE_TEXT ("(%N:%l) ifr_adding_visitor_exception::")
  56                   ACE_TEXT ("visit_scope -")
  57                   ACE_TEXT (" field node access failed\n")
  58                 ),
  59                 -1
  60               );
  61             }
  62
  63           AST_Type *ft = (*f)->field_type ();
  64
  65           bool defined_here = ft->is_child (this->scope_);
  66
  67           // If the struct member is defined in the struct, we have to
  68           // do some visiting - otherwise we can just look up the entry.
  69           if (defined_here)
  70             {
  71               if (ft->ast_accept (this) == -1)
  72                 {
  73                   ORBSVCS_ERROR_RETURN ((
  74                       LM_ERROR,
  75                       ACE_TEXT ("(%N:%l) ifr_adding_visitor_exception::")
  76                       ACE_TEXT ("visit_scope -")
  77                       ACE_TEXT (" failed to accept visitor\n")
  78                     ),
  79                     -1
  80                   );
  81                 }
  82             }
  83           else
  84             {
  85               // Updates ir_current_.
  86               this->get_referenced_type (ft);
  87             }
  88
  89           this->members_[i].name =
  90             CORBA::string_dup ((*f)->local_name ()->get_string ());
  91
  92           // IfR method create_exception does not use this - it just needs
  93           // to be non-zero for marshaling.
  94           this->members_[i].type =
  95             CORBA::TypeCode::_duplicate (CORBA::_tc_void);
  96
  97           this->members_[i].type_def =
  98             CORBA::IDLType::_duplicate (this->ir_current_.in ());
  99         }
 100     }
 101   catch (const CORBA::Exception& ex)
 102     {
 103       ex._tao_print_exception (
 104         ACE_TEXT (
 105           "ifr_adding_visitor_structure::visit_scope"));
 106
 107       return -1;
 108     }
 109
 110   return 0;
 111 }
 112
 113 int
 114 ifr_adding_visitor_exception::visit_structure (AST_Structure *node)
 115 {
 116   try
 117     {
 118       // Is this union already in the respository?
 119       CORBA::Contained_var prev_def =
 120         be_global->repository ()->lookup_id (node->repoID ());
 121
 122       // If not, create a new entry.
 123       if (CORBA::is_nil (prev_def.in ()))
 124         {
 125           ifr_adding_visitor_structure visitor (node);
 126           int retval = visitor.visit_structure (node);
 127
 128           if (retval == 0)
 129             {
 130               // Get the result of the visit.
 131               this->ir_current_ =
 132                 CORBA::IDLType::_duplicate (visitor.ir_current ());
 133             }
 134
 135           return retval;
 136         }
 137       else
 138         {
 139           // If the line below is true, we are clobbering a previous
 140           // entry (from another IDL file) of another type. In that
 141           // case we do what other ORB vendors do, and destroy the
 142           // original entry, create the new one, and let the user beware.
 143           if (!node->ifr_added ())
 144             {
 145               prev_def->destroy ();
 146
 147               // This call will take the other branch.
 148               return this->visit_structure (node);
 149             }
 150
 151           this->ir_current_ =
 152             CORBA::IDLType::_narrow (prev_def.in ());
 153         }
 154     }
 155   catch (const CORBA::Exception& ex)
 156     {
 157       ex._tao_print_exception (
 158         ACE_TEXT (
 159           "ifr_adding_visitor_exception::visit_structure"));
 160
 161       return -1;
 162     }
 163
 164   return 0;
 165 }
 166
 167 int
 168 ifr_adding_visitor_exception::visit_exception (AST_Exception *node)
 169 {
 170   try
 171     {
 172       CORBA::ExceptionDef_var new_def;
 173       CORBA::Contained_var prev_def =
 174         be_global->repository ()->lookup_id (node->repoID ());
 175
 176       if (CORBA::is_nil (prev_def.in ()))
 177         {
 178           CORBA::StructMemberSeq dummyMembers;
 179           dummyMembers.length (0);
 180           CORBA::Container_ptr current_scope =
 181             CORBA::Container::_nil ();
 182
 183           if (be_global->ifr_scopes ().top (current_scope) != 0)
 184             {
 185               ORBSVCS_ERROR_RETURN ((
 186                   LM_ERROR,
 187                   ACE_TEXT ("(%N:%l) ifr_adding_visitor_exception::")
 188                   ACE_TEXT ("visit_exception -")
 189                   ACE_TEXT (" scope stack is empty\n")
 190                 ),
 191                 -1
 192               );
 193             }
 194
 195           new_def =
 196             current_scope->create_exception (node->repoID (),
 197                                             node->local_name ()->get_string (),
 198                                             node->version (),
 199                                             dummyMembers);
 200
 201           if (be_global->ifr_scopes ().push (new_def.in ()) != 0)
 202             {
 203               ORBSVCS_ERROR_RETURN ((
 204                   LM_ERROR,
 205                   ACE_TEXT ("(%N:%l) ifr_adding_visitor_exception::")
 206                   ACE_TEXT ("visit_exception -")
 207                   ACE_TEXT (" scope push failed\n")
 208                 ),
 209                 -1
 210               );
 211             }
 212
 213           // Then add the real exception members.
 214           if (this->add_members (node, new_def.in ()) == -1)
 215             {
 216               ORBSVCS_ERROR_RETURN ((
 217                 LM_ERROR,
 218                 ACE_TEXT ("(%N:%l) ifr_adding_visitor_exception::")
 219                 ACE_TEXT ("visit_exception -")
 220                 ACE_TEXT (" visit_scope failed\n")),
 221                 -1);
 222             }
 223
 224           CORBA::Container_ptr used_scope =
 225             CORBA::Container::_nil ();
 226
 227           // Pop the new IR object back off the scope stack.
 228           if (be_global->ifr_scopes ().pop (used_scope) != 0)
 229             {
 230               ORBSVCS_ERROR_RETURN ((
 231                   LM_ERROR,
 232                   ACE_TEXT ("(%N:%l) ifr_adding_visitor_exception::")
 233                   ACE_TEXT ("visit_exception -")
 234                   ACE_TEXT (" scope pop failed\n")
 235                 ),
 236                 -1
 237               );
 238             }
 239         }
 240       else
 241       {
 242           new_def = CORBA::ExceptionDef::_narrow (prev_def.in ());
 243
 244           if (be_global->ifr_scopes ().push (new_def.in ()) != 0)
 245             {
 246               ORBSVCS_ERROR_RETURN ((
 247                   LM_ERROR,
 248                   ACE_TEXT ("(%N:%l) ifr_adding_visitor_exception::")
 249                   ACE_TEXT ("visit_exception -")
 250                   ACE_TEXT (" scope push failed\n")
 251                 ),
 252                 -1
 253               );
 254             }
 255
 256           // Then add the real exception members.
 257           if (this->add_members (node, new_def.in ()) == -1)
 258             {
 259               ORBSVCS_ERROR_RETURN ((
 260                 LM_ERROR,
 261                 ACE_TEXT ("(%N:%l) ifr_adding_visitor_exception::")
 262                 ACE_TEXT ("visit_exception -")
 263                 ACE_TEXT (" visit_scope failed\n")),
 264                 -1);
 265             }
 266
 267           CORBA::Container_ptr used_scope =
 268             CORBA::Container::_nil ();
 269
 270           // Pop the new IR object back off the scope stack.
 271           if (be_global->ifr_scopes ().pop (used_scope) != 0)
 272             {
 273               ORBSVCS_ERROR_RETURN ((
 274                   LM_ERROR,
 275                   ACE_TEXT ("(%N:%l) ifr_adding_visitor_exception::")
 276                   ACE_TEXT ("visit_exception -")
 277                   ACE_TEXT (" scope pop failed\n")
 278                 ),
 279                 -1
 280               );
 281             }
 282         }
 283     }
 284   catch (const CORBA::Exception& ex)
 285     {
 286       ex._tao_print_exception (
 287         ACE_TEXT (
 288           "ifr_adding_visitor_exception::visit_exception"));
 289
 290       return -1;
 291     }
 292
 293   return 0;
 294 }
 295
 296 int
 297 ifr_adding_visitor_exception::visit_enum (AST_Enum *node)
 298 {
 299   try
 300     {
 301       // Is this enum already in the respository?
 302       CORBA::Contained_var prev_def =
 303         be_global->repository ()->lookup_id (node->repoID ());
 304
 305       // If not, create a new entry.
 306       if (CORBA::is_nil (prev_def.in ()))
 307         {
 308           CORBA::ULong member_count = static_cast<CORBA::ULong> (node->member_count ());
 309
 310           CORBA::EnumMemberSeq members (member_count);
 311           members.length (member_count);
 312
 313           UTL_ScopedName *member_name = 0;
 314
 315           // Get a list of the member names.
 316           for (CORBA::ULong i = 0; i < member_count; ++i)
 317             {
 318               member_name = node->value_to_name (i);
 319
 320               members[i] =
 321                 CORBA::string_dup (
 322                     member_name->last_component ()->get_string ()
 323                   );
 324             }
 325
 326           this->ir_current_ =
 327             be_global->repository ()->create_enum (
 328                                           node->repoID (),
 329                                           node->local_name ()->get_string (),
 330                                           node->version (),
 331                                           members
 332                                         );
 333
 334           node->ifr_added (true);
 335         }
 336       else
 337         {
 338           // If the line below is true, we are clobbering a previous
 339           // entry (from another IDL file) of another type. In that
 340           // case we do what other ORB vendors do, and destroy the
 341           // original entry, create the new one, and let the user beware.
 342           if (!node->ifr_added ())
 343             {
 344               prev_def->destroy ();
 345
 346               // This call will take the other branch.
 347               return this->visit_enum (node);
 348             }
 349
 350           this->ir_current_ =
 351             CORBA::IDLType::_narrow (prev_def.in ());
 352         }
 353     }
 354   catch (const CORBA::Exception& ex)
 355     {
 356       ex._tao_print_exception (
 357         ACE_TEXT (
 358           "ifr_adding_visitor_exception::visit_enum"));
 359
 360       return -1;
 361     }
 362
 363   return 0;
 364 }
 365
 366 int
 367 ifr_adding_visitor_exception::visit_union (AST_Union *node)
 368 {
 369   try
 370     {
 371       // Is this union already in the respository?
 372       CORBA::Contained_var prev_def =
 373         be_global->repository ()->lookup_id (node->repoID ());
 374
 375       // If not, create a new entry.
 376       if (CORBA::is_nil (prev_def.in ()))
 377         {
 378           ifr_adding_visitor_union visitor (node);
 379           int retval = visitor.visit_union (node);
 380
 381           if (retval == 0)
 382             {
 383               // Get the result of the visit.
 384               this->ir_current_ =
 385                 CORBA::IDLType::_duplicate (visitor.ir_current ());
 386             }
 387
 388           return retval;
 389         }
 390       else
 391         {
 392           // If the line below is true, we are clobbering a previous
 393           // entry (from another IDL file) of another type. In that
 394           // case we do what other ORB vendors do, and destroy the
 395           // original entry, create the new one, and let the user beware.
 396           if (!node->ifr_added ())
 397             {
 398               prev_def->destroy ();
 399
 400               // This call will take the other branch.
 401               return this->visit_union (node);
 402             }
 403
 404           this->ir_current_ =
 405             CORBA::IDLType::_narrow (prev_def.in ());
 406         }
 407     }
 408   catch (const CORBA::Exception& ex)
 409     {
 410       ex._tao_print_exception (
 411         ACE_TEXT (
 412           "ifr_adding_visitor_exception::visit_union"));
 413
 414       return -1;
 415     }
 416
 417   return 0;
 418 }
 419
 420 CORBA::IDLType_ptr
 421 ifr_adding_visitor_exception::ir_current (void) const
 422 {
 423   return this->ir_current_.in ();
 424 }
 425
 426 int
 427 ifr_adding_visitor_exception::add_members (AST_Exception *node,
 428                                            CORBA::ExceptionDef_ptr except_def)
 429 {
 430   if (this->visit_scope (node) == -1)
 431     {
 432       ORBSVCS_ERROR_RETURN ((
 433           LM_ERROR,
 434           ACE_TEXT ("(%N:%l) ifr_adding_visitor_exception::")
 435           ACE_TEXT ("visit_exception -")
 436           ACE_TEXT (" visit_scope failed\n")
 437         ),
 438         -1
 439       );
 440     }
 441
 442   except_def->members (this->members_);
 443
 444   node->ifr_added (true);
 445   return 0;
 446 }