TAO/orbsvcs/IFR_Service/ifr_adding_visitor_structure.cpp

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