TAO/TAO_IDL/be/be_sequence.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    be_sequence.cpp
   5  *
   6  *  Extension of class AST_Sequence that provides additional means for C++
   7  *  mapping.
   8  *
   9  *  @author Copyright 1994-1995 by Sun Microsystems
  10  *  @author Inc. and Aniruddha Gokhale
  11  */
  12 //=============================================================================
  13
  14 #include "be_sequence.h"
  15 #include "be_typedef.h"
  16 #include "be_interface.h"
  17 #include "be_interface_fwd.h"
  18 #include "be_predefined_type.h"
  19 #include "be_field.h"
  20 #include "be_string.h"
  21 #include "be_visitor.h"
  22 #include "be_helper.h"
  23 #include "be_extern.h"
  24
  25 #include "utl_identifier.h"
  26 #include "idl_defines.h"
  27 #include "nr_extern.h"
  28 #include "global_extern.h"
  29
  30 #include "ace/Log_Msg.h"
  31
  32 be_sequence::be_sequence (AST_Expression *v,
  33                           AST_Type *t,
  34                           UTL_ScopedName *n,
  35                           bool local,
  36                           bool abstract)
  37   : COMMON_Base (t->is_local () || local,
  38                  abstract),
  39     AST_Decl (AST_Decl::NT_sequence,
  40               n,
  41               true),
  42     AST_Type (AST_Decl::NT_sequence,
  43               n),
  44     AST_ConcreteType (AST_Decl::NT_sequence,
  45                       n),
  46     AST_Sequence (v,
  47                   t,
  48                   n,
  49                   t->is_local () || local,
  50                   abstract),
  51     UTL_Scope (AST_Decl::NT_sequence),
  52     be_scope (AST_Decl::NT_sequence),
  53     be_decl (AST_Decl::NT_sequence,
  54              n),
  55     be_type (AST_Decl::NT_sequence,
  56              n),
  57     mt_ (be_sequence::MNG_UNKNOWN),
  58     field_node_ (nullptr)
  59 {
  60   // Always the case.
  61   this->has_constructor (true);
  62
  63   // Don't want to set any bits below for imported nodes.
  64   if (this->imported ())
  65     {
  66       return;
  67     }
  68
  69   // This one gets set for all sequences, in addition to any specialized
  70   // one that may get set below.
  71   idl_global->seq_seen_ = true;
  72   idl_global->var_size_decl_seen_ = true;
  73
  74   // Don't need the return value - just set the member.
  75   (void) this->managed_type ();
  76
  77   switch (this->mt_)
  78     {
  79       case MNG_OBJREF:
  80         idl_global->iface_seq_seen_ = true;
  81         break;
  82       case MNG_PSEUDO:
  83         idl_global->pseudo_seq_seen_ = true;
  84         break;
  85       case MNG_VALUE:
  86         idl_global->vt_seq_seen_ = true;
  87         break;
  88       case MNG_STRING:
  89         idl_global->string_seq_seen_ = true;
  90         break;
  91       case MNG_WSTRING:
  92         idl_global->wstring_seq_seen_ = true;
  93         break;
  94       default:
  95         break;
  96     }
  97
  98   AST_Type *const base_type = primitive_base_type ();
  99   if (base_type && base_type->node_type () == AST_Decl::NT_pre_defined)
 100     {
 101       AST_PredefinedType *pdt = dynamic_cast<AST_PredefinedType*> (base_type);
 102       switch (pdt->pt ())
 103         {
 104           case AST_PredefinedType::PT_octet:
 105             idl_global->octet_seq_seen_ = true;
 106             break;
 107           default:
 108             break;
 109         }
 110     }
 111 }
 112
 113 be_type *
 114 be_sequence::base_type () const
 115 {
 116   return
 117     dynamic_cast<be_type*> (
 118       this->AST_Sequence::base_type ());
 119 }
 120
 121 be_type *
 122 be_sequence::primitive_base_type () const
 123 {
 124   be_type *type_node = base_type ();
 125   if (type_node && type_node->node_type () == AST_Decl::NT_typedef)
 126     {
 127       be_typedef *const typedef_node = dynamic_cast<be_typedef *> (type_node);
 128       if (!typedef_node) return nullptr;
 129       type_node = typedef_node->primitive_base_type ();
 130     }
 131   return type_node;
 132 }
 133
 134 // Helper to create_name.
 135 char *
 136 be_sequence::gen_name ()
 137 {
 138   char namebuf [NAMEBUFSIZE];
 139   be_type *bt = nullptr;
 140
 141   // Reset the buffer.
 142   ACE_OS::memset (namebuf,
 143                   '\0',
 144                   NAMEBUFSIZE);
 145
 146   // Retrieve the base type.
 147   bt = dynamic_cast<be_type*> (this->base_type ());
 148
 149   if (bt == nullptr)
 150     {
 151       ACE_ERROR_RETURN ((LM_ERROR,
 152                          "(%N:%l) be_sequence::"
 153                          "gen_name - "
 154                          "bad base type\n"),
 155                         0);
 156     }
 157
 158   // If this is non-zero, add its local name to the generated name,
 159   // for uniqueness.
 160   be_field *fn = this->field_node_;
 161
 162   if (bt->node_type () == AST_Decl::NT_sequence)
 163     {
 164       // Our base type is an anonymous sequence.
 165       be_sequence *seq = dynamic_cast<be_sequence*> (bt);
 166
 167       if (seq == nullptr)
 168         {
 169           ACE_ERROR_RETURN ((LM_ERROR,
 170                              "(%N:%l) be_sequence::"
 171                              "gen_name - "
 172                              "error converting base type to sequence\n"),
 173                             0);
 174         }
 175
 176       // If the nested sequence were defined in
 177       // the scope of the enclosing sequence, we would have to
 178       // not only define the nested class in two places, but also
 179       // deal with the fact that, for the template classes, the
 180       // enclosing sequence's template type is a class defined
 181       // inside it. So we define the nested sequence in the next
 182       // scope up, and the existing code generation works for both
 183       // template and non-template implementations of IDL sequences.
 184       UTL_Scope *parent = this->defined_in ();
 185       seq->set_defined_in (parent);
 186       char *seq_name = seq->gen_name ();
 187
 188       ACE_OS::sprintf (namebuf,
 189                        "_tao_seq_%s_%s",
 190                        seq_name,
 191                        fn ? fn->local_name ()->get_string () : "");
 192       ACE::strdelete (seq_name);
 193     }
 194   else
 195     {
 196       ACE_OS::sprintf (namebuf,
 197                        "_tao_seq_%s_",
 198                        bt->flat_name ());
 199     }
 200
 201   // Append the size (if any).
 202   if (this->unbounded () == false)
 203     {
 204       char ulval_str [NAMEBUFSIZE];
 205       ACE_OS::sprintf (ulval_str,
 206                        "_" ACE_UINT32_FORMAT_SPECIFIER_ASCII,
 207                        this->max_size ()->ev ()->u.ulval);
 208       ACE_OS::strcat (namebuf,
 209                       ulval_str);
 210     }
 211
 212   return ACE::strnew (namebuf);
 213 }
 214
 215 // Create a name for ourselves.
 216 int
 217 be_sequence::create_name (be_typedef *node)
 218 {
 219   static char *namebuf = nullptr;
 220   UTL_ScopedName *n = nullptr;
 221
 222   // Scope in which we are defined.
 223   be_decl *scope = nullptr;
 224
 225   // If there is a typedef node, we use its name as our name.
 226   if (node)
 227     {
 228       this->set_name (
 229           dynamic_cast<UTL_ScopedName *> (node->name ()->copy ())
 230         );
 231     }
 232   else
 233     {
 234       // Generate a local name.
 235       namebuf = this->gen_name ();
 236
 237       // Now see if we have a fully scoped name and if so, generate one.
 238       UTL_Scope *us = this->defined_in ();
 239
 240       scope = dynamic_cast<be_scope*> (us)->decl ();
 241
 242       if (scope != nullptr)
 243         {
 244           // Make a copy of the enclosing scope's name.
 245           n = (UTL_ScopedName *) scope->name ()->copy ();
 246
 247           Identifier *id = nullptr;
 248           ACE_NEW_RETURN (id,
 249                           Identifier (namebuf),
 250                           -1);
 251
 252           UTL_ScopedName *conc_name = nullptr;
 253           ACE_NEW_RETURN (conc_name,
 254                           UTL_ScopedName (id,
 255                                           nullptr),
 256                           -1);
 257
 258           // Add our local name as the last component.
 259           n->nconc (conc_name);
 260
 261           // Set the fully scoped name.
 262           this->set_name (n);
 263         }
 264       else
 265         {
 266           // We better be not here because we must be inside some scope,
 267           // at least the ROOT scope.
 268           return -1;
 269         }
 270
 271       ACE::strdelete (namebuf);
 272     }
 273
 274   return 0;
 275 }
 276
 277 // Does this sequence have a managed type sequence element?
 278 be_sequence::MANAGED_TYPE
 279 be_sequence::managed_type ()
 280 {
 281   if (this->mt_ == be_sequence::MNG_UNKNOWN) // Not calculated yet.
 282     {
 283       // Base types.
 284       be_type *const base_type = primitive_base_type ();
 285       if (!base_type)
 286         ACE_ERROR_RETURN ((LM_ERROR,
 287                            "TAO_IDL (%N:%l) "
 288                            "dynamic_cast<be_type*> "
 289                            "failed\n"),
 290                           be_sequence::MNG_UNKNOWN);
 291
 292       // Determine if we need a managed type and which one.
 293       switch (base_type->node_type ())
 294         {
 295           case AST_Decl::NT_interface:
 296           case AST_Decl::NT_interface_fwd:
 297           case AST_Decl::NT_component:
 298           case AST_Decl::NT_component_fwd:
 299           case AST_Decl::NT_connector:
 300             this->mt_ = be_sequence::MNG_OBJREF;
 301             break;
 302           case AST_Decl::NT_valuebox:
 303           case AST_Decl::NT_valuetype:
 304           case AST_Decl::NT_valuetype_fwd:
 305           case AST_Decl::NT_eventtype:
 306           case AST_Decl::NT_eventtype_fwd:
 307             this->mt_ = be_sequence::MNG_VALUE;
 308             break;
 309           case AST_Decl::NT_string:
 310             this->mt_ = be_sequence::MNG_STRING;
 311             break;
 312           case AST_Decl::NT_wstring:
 313             this->mt_ = be_sequence::MNG_WSTRING;
 314             break;
 315           case AST_Decl::NT_pre_defined:
 316             {
 317               be_predefined_type * const bpd =
 318                 dynamic_cast<be_predefined_type*> (base_type);
 319
 320               AST_PredefinedType::PredefinedType pt = bpd->pt ();
 321
 322               switch (pt)
 323                 {
 324                   case AST_PredefinedType::PT_pseudo:
 325                   case AST_PredefinedType::PT_object:
 326                   case AST_PredefinedType::PT_abstract:
 327                     this->mt_ = be_sequence::MNG_PSEUDO;
 328                     break;
 329                   case AST_PredefinedType::PT_value:
 330                     this->mt_ = be_sequence::MNG_VALUE;
 331                     break;
 332                   default:
 333                     this->mt_ = be_sequence::MNG_NONE;
 334                     break;
 335                 }
 336             }
 337             break;
 338           default:
 339             this->mt_ = be_sequence::MNG_NONE;
 340         }
 341     }
 342
 343   return this->mt_;
 344 }
 345
 346 // Add this be_sequence to the locally defined types in this scope
 347 AST_Sequence *
 348 be_sequence::fe_add_sequence (AST_Sequence *t)
 349 {
 350   if (t == nullptr)
 351     {
 352       return nullptr;
 353     }
 354
 355   this->add_to_local_types (t);
 356   return t;
 357 }
 358
 359 // Overridden method
 360 be_decl *
 361 be_sequence::decl ()
 362 {
 363   return this;
 364 }
 365
 366 // Overridden method
 367 void
 368 be_sequence::gen_ostream_operator (TAO_OutStream *os,
 369                                    bool /* use_underscore */)
 370 {
 371   *os << be_nl
 372       << "std::ostream& operator<< (" << be_idt << be_idt_nl
 373       << "std::ostream &strm," << be_nl
 374       << "const " << this->name () << " &_tao_sequence" << be_uidt_nl
 375       << ")" << be_uidt_nl
 376       << "{" << be_idt_nl
 377       << "strm << \"" << this->name () << "[\";" << be_nl_2;
 378
 379   if (be_global->alt_mapping ())
 380     {
 381       *os << "for (CORBA::ULong i = 0; i < _tao_sequence.size (); ++i)";
 382     }
 383   else
 384     {
 385       *os << "for (CORBA::ULong i = 0; i < _tao_sequence.length (); ++i)";
 386     }
 387
 388   *os << be_idt_nl
 389       << "{" << be_idt_nl
 390       << "if (i != 0)" << be_idt_nl
 391       << "{" << be_idt_nl
 392       << "strm << \", \";" << be_uidt_nl
 393       << "}" << be_uidt_nl << be_nl
 394       << "strm << _tao_sequence[i];" << be_uidt_nl
 395       << "}" << be_uidt_nl << be_nl
 396       << "return strm << \"]\";" << be_uidt_nl
 397       << "}" << be_nl;
 398 }
 399
 400 int
 401 be_sequence::accept (be_visitor *visitor)
 402 {
 403   return visitor->visit_sequence (this);
 404 }
 405
 406
 407 const char *
 408 be_sequence::instance_name ()
 409 {
 410   static char namebuf[NAMEBUFSIZE];
 411   ACE_OS::memset (namebuf,
 412                   '\0',
 413                   NAMEBUFSIZE);
 414
 415   be_type *const prim_type = primitive_base_type ();
 416   if (!prim_type)
 417     {
 418       ACE_ERROR ((LM_ERROR,
 419                   "(%N:%l) be_visitor_sequence_ch::"
 420                   "gen_instantiate_name - "
 421                   "Bad element type\n"));
 422
 423       return namebuf;
 424     }
 425
 426   // Generate the appropriate sequence type.
 427   switch (this->managed_type ())
 428     {
 429     case be_sequence::MNG_PSEUDO:
 430     case be_sequence::MNG_OBJREF:
 431       if (this->unbounded ())
 432         {
 433           ACE_OS::sprintf (namebuf,
 434                            "_TAO_unbounded_object_reference_sequence_%s",
 435                            prim_type->local_name ()->get_string ());
 436         }
 437       else
 438         {
 439           ACE_OS::sprintf (namebuf,
 440                            "_TAO_bounded_object_reference_sequence_%s_"
 441                            ACE_UINT32_FORMAT_SPECIFIER_ASCII,
 442                            prim_type->local_name ()->get_string (),
 443                            this->max_size ()->ev ()->u.ulval);
 444         }
 445
 446       break;
 447     case be_sequence::MNG_VALUE:
 448       if (this->unbounded ())
 449         {
 450           ACE_OS::sprintf (namebuf,
 451                            "_TAO_unbounded_valuetype_sequence_%s",
 452                            prim_type->local_name ()->get_string ());
 453         }
 454       else
 455         {
 456           ACE_OS::sprintf (namebuf,
 457                            "_TAO_bounded_valuetype_sequence_%s_"
 458                            ACE_UINT32_FORMAT_SPECIFIER_ASCII,
 459                            prim_type->local_name ()->get_string (),
 460                            this->max_size ()->ev ()->u.ulval);
 461         }
 462
 463       break;
 464     case be_sequence::MNG_STRING:
 465       if (this->unbounded ())
 466         {
 467           ACE_OS::sprintf (namebuf,
 468                            "::TAO::unbounded_basic_string_sequence<char>");
 469         }
 470       else
 471         {
 472           ACE_OS::sprintf (namebuf,
 473                            "_TAO_unbounded_string_sequence_%s",
 474                            prim_type->local_name ()->get_string ());
 475         }
 476
 477       break;
 478     case be_sequence::MNG_WSTRING:
 479       if (this->unbounded ())
 480         {
 481           ACE_OS::sprintf (namebuf,
 482                            "::TAO::unbounded_basic_string_sequence<CORBA::WChar>");
 483         }
 484       else
 485         {
 486           ACE_OS::sprintf (namebuf,
 487                            "_TAO_bounded_wstring_sequence_%s",
 488                            prim_type->local_name ()->get_string ());
 489         }
 490
 491       break;
 492     default: // Not a managed type.
 493       if (this->unbounded ())
 494         {
 495           // TAO provides extensions for octet sequences, first find out
 496           // if the base type is an octet (or an alias for octet)
 497           be_predefined_type *predef =
 498             dynamic_cast<be_predefined_type*> (prim_type);
 499
 500           if (predef != nullptr
 501               && predef->pt() == AST_PredefinedType::PT_octet)
 502             {
 503               ACE_OS::sprintf (namebuf,
 504                                "::TAO::unbounded_value_sequence<CORBA::Octet>");
 505             }
 506           else
 507             {
 508               ACE_OS::sprintf (namebuf,
 509                                "_TAO_unbounded_value_sequence_%s",
 510                                prim_type->local_name ()->get_string ());
 511             }
 512         }
 513       else
 514         {
 515           ACE_OS::sprintf (namebuf,
 516                            "_TAO_bounded_value_sequence_%s_"
 517                            ACE_UINT32_FORMAT_SPECIFIER_ASCII,
 518                            prim_type->local_name ()->get_string (),
 519                            this->max_size ()->ev ()->u.ulval);
 520         }
 521
 522       break;
 523     }
 524
 525   return namebuf;
 526 }
 527
 528 int
 529 be_sequence::gen_base_class_name (TAO_OutStream *os,
 530                                   const char * linebreak,
 531                                   AST_Decl *ctx_scope)
 532 {
 533   be_type *elem = dynamic_cast<be_type*> (this->base_type ());
 534   /*
 535   if (be_global->alt_mapping () && this->unbounded ())
 536     {
 537       *os << "std::vector<" << elem->nested_type_name (ctx_scope)
 538           << ">";
 539
 540       return 0;
 541     }
 542 */
 543   // Generate the appropriate base class type.
 544   switch (this->managed_type ())
 545     {
 546     case be_sequence::MNG_OBJREF:
 547     case be_sequence::MNG_PSEUDO:
 548       if (this->unbounded ())
 549         {
 550           *os << "::TAO::unbounded_object_reference_sequence<" << linebreak
 551               << be_idt << be_idt_nl
 552               << elem->nested_type_name (ctx_scope) << "," << linebreak
 553               << be_nl;
 554           *os << elem->nested_type_name (ctx_scope, "_var") << linebreak
 555               << be_uidt_nl
 556               << ">" << be_uidt;
 557         }
 558       else
 559         {
 560           *os << "::TAO::bounded_object_reference_sequence<" << linebreak
 561               << be_idt << be_idt_nl
 562               << elem->nested_type_name (ctx_scope) << "," << linebreak << be_nl;
 563           *os << elem->nested_type_name (ctx_scope, "_var") << ","
 564               << linebreak << be_nl;
 565           *os << this->max_size ()->ev ()->u.ulval << linebreak << be_uidt_nl
 566               << ">" << be_uidt;
 567         }
 568
 569       break;
 570     case be_sequence::MNG_VALUE:
 571       if (this->unbounded ())
 572         {
 573           *os << "::TAO::unbounded_valuetype_sequence<" << linebreak
 574               << be_idt << be_idt_nl
 575               << elem->nested_type_name (ctx_scope) << "," << linebreak
 576               << be_nl;
 577           *os << elem->nested_type_name (ctx_scope, "_var") << linebreak
 578               << be_uidt_nl
 579               << ">" << be_uidt;
 580         }
 581       else
 582         {
 583           *os << "::TAO::bounded_valuetype_sequence<" << linebreak
 584               << be_idt << be_idt_nl
 585               << elem->nested_type_name (ctx_scope) << "," << linebreak
 586               << be_nl;
 587           *os << elem->nested_type_name (ctx_scope, "_var") << ","
 588               << linebreak << be_nl
 589               << this->max_size ()->ev ()->u.ulval << linebreak << be_uidt_nl
 590               << ">" << be_uidt;
 591         }
 592
 593       break;
 594     case be_sequence::MNG_STRING:
 595       {
 596         be_type *const prim_type = primitive_base_type ();
 597         if (!prim_type)
 598           {
 599             ACE_ERROR_RETURN ((LM_ERROR,
 600                                "(%N:%l) be_sequence::"
 601                                "gen_base_class_name - "
 602                                "Bad element type\n"),
 603                               -1);
 604           }
 605         if (prim_type->node_type () == AST_Decl::NT_string)
 606           {
 607             be_string *str =
 608               dynamic_cast<be_string*> (prim_type);
 609             if (!str)
 610               {
 611                 ACE_ERROR_RETURN ((LM_ERROR,
 612                                    "(%N:%l) be_sequence::"
 613                                    "gen_base_class_name - "
 614                                    "bad string node\n"),
 615                                   -1);
 616               }
 617
 618             // We need to make a distinction between bounded and
 619             // unbounded strings.
 620             if (str->max_size ()->ev ()->u.ulval != 0)
 621               {
 622                 if (this->unbounded ())
 623                   {
 624                     *os << "::TAO::unbounded_bd_string_sequence<char, "
 625                         << str->max_size ()->ev ()->u.ulval << ">";
 626                   }
 627                 else
 628                   {
 629                     *os << "::TAO::bounded_bd_string_sequence<char, "
 630                         << this->max_size ()->ev ()->u.ulval << ", "
 631                         << str->max_size ()->ev ()->u.ulval << ">";
 632                   }
 633               }
 634             else
 635               {
 636                 if (this->unbounded ())
 637                   {
 638                     *os << "::TAO::unbounded_basic_string_sequence<char>";
 639                   }
 640                 else
 641                   {
 642                     *os << "::TAO::bounded_basic_string_sequence<char, "
 643                         << this->max_size ()->ev ()->u.ulval << ">";
 644                   }
 645               }
 646           }
 647       }
 648
 649       break;
 650     case be_sequence::MNG_WSTRING:
 651       {
 652         be_type *const prim_type = primitive_base_type ();
 653         if (!prim_type)
 654           {
 655             ACE_ERROR_RETURN ((LM_ERROR,
 656                                "(%N:%l) be_sequence::"
 657                                "gen_base_class_name - "
 658                                "Bad element type\n"),
 659                               -1);
 660           }
 661         if (prim_type->node_type () == AST_Decl::NT_wstring)
 662           {
 663             be_string *str =
 664               dynamic_cast<be_string*> (prim_type);
 665             if (!str)
 666               {
 667                 ACE_ERROR_RETURN ((LM_ERROR,
 668                                    "(%N:%l) be_sequence::"
 669                                    "gen_base_class_name - "
 670                                    "bad string node\n"),
 671                                   -1);
 672               }
 673
 674             // We need to make a distinction between bounded and
 675             // unbounded strings.
 676             if (str->max_size ()->ev ()->u.ulval != 0)
 677               {
 678                 if (this->unbounded ())
 679                   {
 680                     *os << "::TAO::unbounded_bd_string_sequence<CORBA::WChar, "
 681                         << str->max_size ()->ev ()->u.ulval << ">";
 682                   }
 683                 else
 684                   {
 685                     *os << "::TAO::bounded_bd_string_sequence<CORBA::WChar, "
 686                         << this->max_size ()->ev ()->u.ulval << ", "
 687                         << str->max_size ()->ev ()->u.ulval << ">";
 688                   }
 689               }
 690             else
 691               {
 692                 if (this->unbounded ())
 693                   {
 694                     *os << "::TAO::unbounded_basic_string_sequence<CORBA::WChar>";
 695                   }
 696                 else
 697                   {
 698                     *os << "::TAO::bounded_basic_string_sequence<CORBA::WChar, "
 699                         << this->max_size ()->ev ()->u.ulval << ">";
 700                   }
 701               }
 702           }
 703       }
 704
 705       break;
 706     default: // Not a managed type.
 707       switch (elem->base_node_type ())
 708         {
 709           case AST_Decl::NT_array:
 710             if (this->unbounded ())
 711               {
 712                 *os << "::TAO::unbounded_array_sequence<" << linebreak
 713                     << be_idt << be_idt_nl
 714                     << elem->nested_type_name (ctx_scope) << "," << linebreak
 715                     << be_nl;
 716                 *os << elem->nested_type_name (ctx_scope) << "_slice,"
 717                     << linebreak << be_nl
 718                     << elem->nested_type_name (ctx_scope) << "_tag"
 719                     << linebreak << be_uidt_nl
 720                     << ">" << be_uidt;
 721               }
 722             else
 723               {
 724                 *os << "::TAO::bounded_array_sequence<" << linebreak
 725                     << be_idt << be_idt_nl
 726                     << elem->nested_type_name (ctx_scope) << "," << linebreak
 727                     << be_nl;
 728                 *os << elem->nested_type_name (ctx_scope) << "_slice,"
 729                     << linebreak << be_nl
 730                     << elem->nested_type_name (ctx_scope) << "_tag,"
 731                     << linebreak << be_nl
 732                     << this->max_size ()->ev ()->u.ulval << linebreak
 733                     << be_uidt_nl
 734                     << ">" << be_uidt;
 735               }
 736
 737             break;
 738           default:
 739             {
 740               be_type *const base_type = primitive_base_type ();
 741               if (!base_type)
 742                 {
 743                   ACE_ERROR_RETURN ((LM_ERROR,
 744                                      "(%N:%l) be_sequence::"
 745                                      "gen_base_class_name - "
 746                                      "Bad element type\n"),
 747                                     -1);
 748                 }
 749
 750               const char *tag = "";
 751               if (base_type->node_type () == AST_Decl::NT_pre_defined)
 752                 {
 753                   be_predefined_type *const predefined_type =
 754                     dynamic_cast<be_predefined_type*> (base_type);
 755                   if (!predefined_type)
 756                     ACE_ERROR_RETURN ((LM_ERROR,
 757                                        "(%N:%l) be_sequence::"
 758                                        "gen_base_class_name - "
 759                                        "Bad element type\n"),
 760                                       -1);
 761                   switch (predefined_type->pt ())
 762                     {
 763                       case AST_PredefinedType::PT_uint8:
 764                         tag = ", CORBA::IDLv4::UInt8_tag";
 765                         break;
 766                       case AST_PredefinedType::PT_int8:
 767                         tag = ", CORBA::IDLv4::Int8_tag";
 768                         break;
 769                       default:
 770                         break;
 771                     }
 772                 }
 773
 774               *os
 775                 << "::TAO::" << (unbounded () ? "un" : "") << "bounded_value_sequence< "
 776                 << elem->nested_type_name (ctx_scope);
 777               if (!unbounded ())
 778                 *os << "," << this->max_size ()->ev ()->u.ulval;
 779               *os << tag << ">";
 780             }
 781             break;
 782         }
 783
 784       break;
 785   }
 786
 787   return 0;
 788 }
 789
 790 be_field *
 791 be_sequence::field_node () const
 792 {
 793   return this->field_node_;
 794 }
 795
 796 void
 797 be_sequence::field_node (be_field *node)
 798 {
 799   this->field_node_ = node;
 800 }
 801
 802 // Overriden method.
 803 void
 804 be_sequence::compute_tc_name ()
 805 {
 806   // Sequence TypeCodes can only be accessed through an alias
 807   // TypeCode.  Generate a TypeCode name that is meant for internal
 808   // use alone.
 809
 810   Identifier * tao_id = nullptr;
 811   ACE_NEW (tao_id,
 812            Identifier ("TAO"));
 813
 814   ACE_NEW (this->tc_name_,
 815            UTL_ScopedName (tao_id,
 816                            nullptr));
 817
 818   char bound[30] = { 0 };
 819
 820   ACE_OS::sprintf (bound,
 821                    "_" ACE_UINT32_FORMAT_SPECIFIER_ASCII,
 822                    this->max_size ()->ev ()->u.ulval);
 823
 824   ACE_CString local_tc_name =
 825     ACE_CString ("tc_")
 826     + ACE_CString (this->flat_name ())
 827     + ACE_CString (bound);
 828
 829   Identifier * typecode_scope = nullptr;
 830   ACE_NEW (typecode_scope,
 831            Identifier ("TypeCode"));
 832
 833   UTL_ScopedName * tc_scope_conc_name = nullptr;
 834   ACE_NEW (tc_scope_conc_name,
 835            UTL_ScopedName (typecode_scope,
 836                            nullptr));
 837
 838   this->tc_name_->nconc (tc_scope_conc_name);
 839
 840   Identifier * id = nullptr;
 841   ACE_NEW (id,
 842            Identifier (local_tc_name.c_str ()));
 843
 844   UTL_ScopedName * conc_name = nullptr;
 845   ACE_NEW (conc_name,
 846            UTL_ScopedName (id,
 847                            nullptr));
 848
 849   this->tc_name_->nconc (conc_name);
 850 }
 851
 852 const char *
 853 be_sequence::smart_fwd_helper_name (AST_Decl *ctx_scope,
 854                                     be_type *elem)
 855 {
 856   if (ScopeAsDecl (elem->defined_in ()) == ctx_scope)
 857     {
 858       ACE_CString retval = "tao_";
 859       retval += elem->local_name ()->get_string ();
 860       return retval.rep ();
 861     }
 862
 863   return elem->fwd_helper_name ();
 864 }
 865
 866 void
 867 be_sequence::destroy ()
 868 {
 869   // Call the destroy methods of our base classes.
 870   this->be_scope::destroy ();
 871   this->be_type::destroy ();
 872   this->AST_Sequence::destroy ();
 873 }