TAO/TAO_IDL/be/be_visitor_arg_traits.cpp

   1 //=============================================================================
   2 /**
   3 *  @file   be_visitor_arg_traits.cpp
   4 *
   5 *  This visitor generates template specializations for argument traits classes.
   6 *
   7 *  @author Jeff Parsons <j.parsons@vanderbilt.edu>
   8 */
   9 //=============================================================================
  10
  11 #include "be_visitor_arg_traits.h"
  12 #include "be_visitor_context.h"
  13 #include "be_root.h"
  14 #include "be_module.h"
  15 #include "be_interface.h"
  16 #include "be_valuebox.h"
  17 #include "be_valuetype.h"
  18 #include "be_interface_fwd.h"
  19 #include "be_valuetype_fwd.h"
  20 #include "be_component_fwd.h"
  21 #include "be_connector.h"
  22 #include "be_home.h"
  23 #include "be_eventtype.h"
  24 #include "be_eventtype_fwd.h"
  25 #include "be_operation.h"
  26 #include "be_attribute.h"
  27 #include "be_argument.h"
  28 #include "be_array.h"
  29 #include "be_enum.h"
  30 #include "be_predefined_type.h"
  31 #include "be_sequence.h"
  32 #include "be_string.h"
  33 #include "be_structure.h"
  34 #include "be_field.h"
  35 #include "be_union.h"
  36 #include "be_union_branch.h"
  37 #include "be_typedef.h"
  38 #include "be_helper.h"
  39 #include "be_extern.h"
  40 #include "utl_identifier.h"
  41 #include "idl_defines.h"
  42 #include "nr_extern.h"
  43 #include "ace/Log_Msg.h"
  44
  45 #include <string>
  46
  47 be_visitor_arg_traits::be_visitor_arg_traits (const char *S,
  48                                               be_visitor_context *ctx)
  49   : be_visitor_scope (ctx),
  50     S_ (ACE::strnew (S))
  51 {
  52 }
  53
  54 be_visitor_arg_traits::~be_visitor_arg_traits (void)
  55 {
  56   delete [] this->S_;
  57 }
  58
  59 int
  60 be_visitor_arg_traits::visit_root (be_root *node)
  61 {
  62   TAO_OutStream *os = this->ctx_->stream ();
  63
  64   TAO_INSERT_COMMENT (os);
  65
  66   *os << be_nl
  67       << be_global->core_versioning_begin ();
  68
  69   *os << be_nl_2
  70       << "// Arg traits specializations." << be_nl
  71       << "namespace TAO" << be_nl
  72       << "{" << be_idt;
  73
  74   if (be_global->ami_call_back ())
  75     {
  76       int const status =
  77         this->visit_valuetype (be_global->messaging_exceptionholder ());
  78
  79       if (-1 == status)
  80         {
  81           ACE_ERROR_RETURN ((LM_ERROR,
  82                              "(%N:%l) be_visitor_arg_traits::"
  83                              "visit_root - visit "
  84                              "Messaging::ExceptionHolder failed\n"),
  85                             -1);
  86         }
  87     }
  88
  89   if (this->visit_scope (node) == -1)
  90     {
  91       ACE_ERROR_RETURN ((LM_ERROR,
  92                          "(%N:%l) be_visitor_arg_traits::"
  93                          "visit_root - visit scope failed\n"),
  94                         -1);
  95     }
  96
  97   *os << be_uidt_nl
  98       << "}" << be_nl;
  99
 100   *os << be_global->core_versioning_end () << be_nl;
 101
 102   return 0;
 103 }
 104
 105 int
 106 be_visitor_arg_traits::visit_module (be_module *node)
 107 {
 108  if (this->visit_scope (node) == -1)
 109     {
 110       ACE_ERROR_RETURN ((LM_ERROR,
 111                          "(%N:%l) be_visitor_arg_traits::"
 112                          "visit_module - visit scope failed\n"),
 113                         -1);
 114     }
 115
 116   return 0;
 117 }
 118
 119 int
 120 be_visitor_arg_traits::visit_interface (be_interface *node)
 121 {
 122   if (node->imported ())
 123     {
 124       // Arg traits will presumably already be generated, but
 125       // perhaps from another compilation unit. We mark it
 126       // generated because if we get here from a typedef in
 127       // the main file, we should skip it.
 128       this->generated (node, true);
 129       return 0;
 130     }
 131
 132    // A local interface can never be an argument.
 133    if (node->is_local () || this->generated (node))
 134     {
 135       return 0;
 136     }
 137
 138   this->generated (node, true);
 139
 140   TAO_OutStream *os = this->ctx_->stream ();
 141
 142   TAO_INSERT_COMMENT (os);
 143
 144   std::string guard_suffix =
 145     std::string (this->S_) + std::string ("arg_traits");
 146
 147   // The guard should be generated to prevent multiple declarations,
 148   // since a forward declaration may appear more than once.
 149   os->gen_ifdef_macro (node->flat_name (), guard_suffix.c_str (), false);
 150
 151   *os << be_nl_2
 152       << "template<>" << be_nl
 153       << "class "
 154       << " " << this->S_ << "Arg_Traits< ::"
 155       << node->name () << ">" << be_idt_nl
 156       << ": public" << be_idt << be_idt_nl
 157       << "Object_" << this->S_ << "Arg_Traits_T<" << be_idt << be_idt_nl
 158       << "::" << node->name () << "_ptr," << be_nl
 159       << "::" << node->name () << "_var," << be_nl
 160       << "::" << node->name () << "_out";
 161
 162   if (ACE_OS::strlen (this->S_) == 0)
 163     {
 164       *os << "," << be_nl
 165           << "TAO::Objref_Traits<" << node->name () << ">";
 166     }
 167
 168   *os << "," << be_nl << this->insert_policy ()
 169       << be_uidt_nl
 170       << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
 171       << "{" << be_nl
 172       << "};";
 173
 174   os->gen_endif ();
 175
 176   if (this->visit_scope (node) != 0)
 177     {
 178       ACE_ERROR_RETURN ((LM_ERROR,
 179                          "(%N:%l) be_visitor_arg_traits::"
 180                          "visit_interface - visit scope failed\n"),
 181                         -1);
 182     }
 183
 184   return 0;
 185 }
 186
 187 int
 188 be_visitor_arg_traits::visit_interface_fwd (be_interface_fwd *node)
 189 {
 190   if (node->imported ())
 191     {
 192       // Arg traits will presumably already be generated, but
 193       // perhaps from another compilation unit. We mark it
 194       // generated because if we get here from a typedef in
 195       // the main file, we should skip it.
 196       this->generated (node, true);
 197       return 0;
 198     }
 199
 200   // If a full definition with the same name in the same scope
 201   // has been seen, then it will have gone through visit_interface()
 202   // already.
 203   if (this->generated (node))
 204     {
 205       return 0;
 206     }
 207
 208   be_interface *fd =
 209     dynamic_cast<be_interface*> (node->full_definition ());
 210
 211   // The logic in visit_interface() should handle what gets generated
 212   // and what doesn't.
 213   if (this->visit_interface (fd) != 0)
 214     {
 215       ACE_ERROR_RETURN ((LM_ERROR,
 216                          "(%N:%l) be_visitor_arg_traits::"
 217                          "visit_interface_fwd - code generation failed\n"),
 218                         -1);
 219     }
 220
 221   this->generated (node, true);
 222   return 0;
 223 }
 224
 225 int
 226 be_visitor_arg_traits::visit_valuebox (be_valuebox *node)
 227 {
 228   if (node->imported ())
 229     {
 230       // Arg traits will presumably already be generated, but
 231       // perhaps from another compilation unit. We mark it
 232       // generated because if we get here from a typedef in
 233       // the main file, we should skip it.
 234       this->generated (node, true);
 235       return 0;
 236     }
 237
 238   if (this->generated (node))
 239     {
 240       return 0;
 241     }
 242
 243   TAO_OutStream & os = *this->ctx_->stream ();
 244
 245   TAO_INSERT_COMMENT (&os);
 246
 247   os << be_nl_2
 248       << "template<>" << be_nl
 249       << "class "
 250       << this->S_ << "Arg_Traits< ::"
 251       << node->name () << ">" << be_idt_nl
 252       << ": public" << be_idt << be_idt_nl
 253       << "Object_" << this->S_ << "Arg_Traits_T<" << be_idt << be_idt_nl
 254       << "::" << node->name () << " *," << be_nl
 255       << "::" << node->name () << "_var," << be_nl
 256       << "::" << node->name () << "_out";
 257
 258   // The SArgument classes don't need the traits parameter (yet?)
 259   if (ACE_OS::strlen (this->S_) == 0)
 260     {
 261       os << "," << be_nl
 262           << "TAO::Value_Traits<" << node->name () << ">";
 263     }
 264
 265   os << "," << be_nl << this->insert_policy()
 266       << be_uidt_nl
 267       << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
 268       << "{" << be_nl
 269       << "};";
 270
 271   this->generated (node, true);
 272   return 0;
 273 }
 274
 275 int
 276 be_visitor_arg_traits::visit_valuetype (be_valuetype *node)
 277 {
 278   if (node->imported ())
 279     {
 280       // Arg traits will presumably already be generated, but
 281       // perhaps from another compilation unit. We mark it
 282       // generated because if we get here from a typedef in
 283       // the main file, we should skip it.
 284       this->generated (node, true);
 285       return 0;
 286     }
 287
 288   if (this->generated (node))
 289     {
 290       return 0;
 291     }
 292
 293   /// Put this here to prevent infinite recursion with recursive
 294   /// valuetypes.
 295   this->generated (node, true);
 296
 297   TAO_OutStream & os = *this->ctx_->stream ();
 298
 299   TAO_INSERT_COMMENT (&os);
 300
 301   std::string guard_suffix =
 302     std::string (this->S_) + std::string ("arg_traits");
 303
 304   // The guard should be generated to prevent multiple declarations,
 305   // since a forward declaration may appear more than once.
 306   os.gen_ifdef_macro (node->flat_name (), guard_suffix.c_str (), false);
 307
 308   os << be_nl_2
 309       << "template<>" << be_nl
 310       << "class "
 311       << this->S_ << "Arg_Traits< ::"
 312       << node->name () << ">" << be_idt_nl
 313       << ": public" << be_idt << be_idt_nl
 314       << "Object_" << this->S_ << "Arg_Traits_T<" << be_idt << be_idt_nl
 315       << "::" << node->name () << " *," << be_nl
 316       << "::" << node->name () << "_var," << be_nl
 317       << "::" << node->name () << "_out";
 318
 319   // The SArgument classes don't need the traits parameter (yet?)
 320   if (ACE_OS::strlen (this->S_) == 0)
 321     {
 322       os << "," << be_nl
 323           << "TAO::Value_Traits<" << node->name () << ">";
 324     }
 325
 326   os << "," << be_nl << this->insert_policy()
 327       << be_uidt_nl
 328       << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
 329       << "{" << be_nl
 330       << "};";
 331
 332   os.gen_endif ();
 333
 334   if (this->visit_scope (node) != 0)
 335     {
 336       ACE_ERROR_RETURN ((LM_ERROR,
 337                          "(%N:%l) be_visitor_arg_traits::"
 338                          "visit_valuetype - visit scope failed\n"),
 339                         -1);
 340     }
 341
 342   return 0;
 343 }
 344
 345 int
 346 be_visitor_arg_traits::visit_valuetype_fwd (be_valuetype_fwd *node)
 347 {
 348   if (node->imported ())
 349     {
 350       // Arg traits will presumably already be generated, but
 351       // perhaps from another compilation unit. We mark it
 352       // generated because if we get here from a typedef in
 353       // the main file, we should skip it.
 354       this->generated (node, true);
 355       return 0;
 356     }
 357
 358   if (this->generated (node))
 359     {
 360       return 0;
 361     }
 362
 363   be_valuetype *fd =
 364     dynamic_cast<be_valuetype*> (node->full_definition ());
 365
 366   // The logic in visit_valuetype() should handle what gets generated
 367   // and what doesn't.
 368   int status = this->visit_valuetype (fd);
 369
 370   if (status != 0)
 371     {
 372       ACE_ERROR_RETURN ((LM_ERROR,
 373                          "(%N:%l) be_visitor_arg_traits::"
 374                          "visit_valuetype_fwd - code generation failed\n"),
 375                         -1);
 376     }
 377
 378   this->generated (node, true);
 379   return 0;
 380 }
 381
 382 int
 383 be_visitor_arg_traits::visit_eventtype (be_eventtype *node)
 384 {
 385   return this->visit_valuetype (node);
 386 }
 387
 388 int
 389 be_visitor_arg_traits::visit_eventtype_fwd (be_eventtype_fwd *node)
 390 {
 391   return this->visit_valuetype_fwd (node);
 392 }
 393
 394 int
 395 be_visitor_arg_traits::visit_operation (be_operation *node)
 396 {
 397   if (this->generated (node) || node->is_local () || node->imported ())
 398     {
 399       return 0;
 400     }
 401
 402   AST_Type *rt = node->return_type ();
 403   AST_Decl::NodeType nt = rt->node_type ();
 404
 405   // If our return type is an unaliased bounded (w)string, we create
 406   // an empty struct using the operation's flat name for the type,
 407   // and use this type as the Arg_Traits<> template parameter. All
 408   // this is necessary because there could be any number of such
 409   // return types, all identical, in the same interface, valuetype,
 410   // translation unit, or build, and we need a unique type for the
 411   // Arg_Traits<> template parameter.
 412   if (nt == AST_Decl::NT_string || nt == AST_Decl::NT_wstring)
 413     {
 414       AST_String *str = dynamic_cast<AST_String*> (rt);
 415       ACE_CDR::ULong bound = str->max_size ()->ev ()->u.ulval;
 416
 417       if (bound > 0)
 418         {
 419           TAO_OutStream *os = this->ctx_->stream ();
 420
 421           TAO_INSERT_COMMENT (os);
 422
 423           std::string guard_suffix =
 424             std::string (this->S_) + std::string ("arg_traits");
 425
 426           // The guard should be generated to prevent multiple declarations,
 427           // since a bounded (w)string of the same length may be used or typedef'd
 428           // more than once.
 429
 430           os->gen_ifdef_macro (node->flat_name (), guard_suffix.c_str (), false);
 431
 432           bool wide = (str->width () != 1);
 433
 434           *os << be_nl_2;
 435
 436           // Avoid generating a duplicate structure in the skeleton.
 437           if (ACE_OS::strlen (this->S_) == 0)
 438             {
 439               *os << "struct " << node->flat_name () << " {};"
 440                   << be_nl_2;
 441             }
 442
 443           *os << "template<>" << be_nl
 444               << "class "
 445               << this->S_ << "Arg_Traits<"
 446               << node->flat_name ()
 447               << ">" << be_idt_nl
 448               << ": public" << be_idt << be_idt_nl
 449               << "BD_String_" << this->S_ << "Arg_Traits_T<" << be_nl
 450               << "CORBA::" << (wide ? "W" : "") << "String_var," << be_nl
 451               << bound << "," << be_nl
 452               << this->insert_policy()
 453               << ">"
 454               << be_uidt << be_uidt << be_uidt_nl
 455               << "{" << be_nl
 456               << "};";
 457
 458           os->gen_endif ();
 459         }
 460     }
 461
 462   // This will catch (in visit_argument() below) any parameters that
 463   // are unaliased, bounded (w)strings.
 464   if (this->visit_scope (node) != 0)
 465     {
 466       ACE_ERROR_RETURN ((LM_ERROR,
 467                          ACE_TEXT ("be_visitor_arg_traits::")
 468                          ACE_TEXT ("visit_operation - visit scope failed\n")),
 469                         -1);
 470     }
 471
 472   this->generated (node, true);
 473   return 0;
 474 }
 475
 476 int
 477 be_visitor_arg_traits::visit_attribute (be_attribute *node)
 478 {
 479   if (this->ctx_->alias () != 0 || this->generated (node))
 480     {
 481       return 0;
 482     }
 483
 484   AST_String *st = dynamic_cast<AST_String*> (node->field_type ());
 485
 486   if (st == 0)
 487     {
 488       return 0;
 489     }
 490
 491   ACE_CDR::ULong bound = st->max_size ()->ev ()->u.ulval;
 492
 493   if (bound == 0)
 494     {
 495       return 0;
 496     }
 497
 498   TAO_OutStream *os = this->ctx_->stream ();
 499
 500   TAO_INSERT_COMMENT (os);
 501
 502   std::string guard_suffix =
 503     std::string (this->S_) + std::string ("arg_traits");
 504
 505   // The guard should be generated to prevent multiple declarations,
 506   // since a bounded (w)string of the same length may be used or typedef'd
 507   // more than once.
 508
 509   os->gen_ifdef_macro (node->flat_name (), guard_suffix.c_str (), false);
 510
 511   bool wide = (st->width () != 1);
 512
 513   // It is legal IDL to declare a bounded (w)string as an operation
 514   // parameter type. There could be any number of identical
 515   // declarations in the same build, translation unit, or even in
 516   // the same operation, so we use the argument's flat name to
 517   // declare an empty struct, and use that struct as the template
 518   // parameter for Arg_Traits<>.
 519
 520   *os << be_nl;
 521
 522   // Avoid generating a duplicate structure in the skeleton.
 523   if (ACE_OS::strlen (this->S_) == 0)
 524     {
 525       *os << "struct " << node->flat_name () << " {};"
 526           << be_nl_2;
 527     }
 528
 529   *os << "template<>" << be_nl
 530       << "class "
 531       << this->S_ << "Arg_Traits<"
 532       << node->flat_name ()
 533       << ">" << be_idt_nl
 534       << ": public" << be_idt << be_idt_nl
 535       << "BD_String_" << this->S_ << "Arg_Traits_T<" << be_nl
 536       << "CORBA::" << (wide ? "W" : "") << "String_var," << be_nl
 537       << bound << "," << be_nl
 538       << this->insert_policy()
 539       << ">"
 540       << be_uidt << be_uidt << be_uidt_nl
 541       << "{" << be_nl
 542       << "};";
 543
 544   os->gen_endif ();
 545
 546   this->generated (node, true);
 547   return 0;
 548 }
 549
 550 int
 551 be_visitor_arg_traits::visit_argument (be_argument *node)
 552 {
 553   if (this->ctx_->alias () != 0 || this->generated (node))
 554     {
 555       return 0;
 556     }
 557
 558   AST_Type *bt = node->field_type ();
 559   AST_Decl::NodeType nt = bt->node_type ();
 560
 561   // We are interested here only in unaliased, bounded
 562   // (w)strings.
 563
 564   if (nt != AST_Decl::NT_string && nt != AST_Decl::NT_wstring)
 565     {
 566       return 0;
 567     }
 568
 569   be_string *st = dynamic_cast<be_string*> (bt);
 570   ACE_CDR::ULong bound = st->max_size ()->ev ()->u.ulval;
 571
 572   if (bound == 0)
 573     {
 574       return 0;
 575     }
 576
 577   TAO_OutStream *os = this->ctx_->stream ();
 578
 579   TAO_INSERT_COMMENT (os);
 580
 581   std::string guard_suffix =
 582     std::string (this->S_) + std::string ("arg_traits");
 583
 584   // The guard should be generated to prevent multiple declarations,
 585   // since a bounded (w)string of the same length may be used or typedef'd
 586   // more than once.
 587
 588   os->gen_ifdef_macro (node->flat_name (), guard_suffix.c_str (), false);
 589
 590   bool wide = (st->width () != 1);
 591
 592   // It is legal IDL to declare a bounded (w)string as an operation
 593   // parameter type. There could be any number of identical
 594   // declarations in the same build, translation unit, or even in
 595   // the same operation, so we use the argument's flat name to
 596   // declare an empty struct, and use that struct as the template
 597   // parameter for Arg_Traits<>.
 598   *os << be_nl_2;
 599
 600   AST_Decl *op = ScopeAsDecl (node->defined_in ());
 601   AST_Decl *intf = ScopeAsDecl (op->defined_in ());
 602   ACE_CString arg_flat_name (intf->flat_name ());
 603   arg_flat_name += '_';
 604   arg_flat_name += op->local_name ()->get_string ();
 605   arg_flat_name += '_';
 606   arg_flat_name += node->local_name ()->get_string ();
 607
 608   // Avoid generating a duplicate structure in the skeleton.
 609   if (ACE_OS::strlen (this->S_) == 0)
 610     {
 611       *os << "struct " << arg_flat_name.c_str () << " {};"
 612           << be_nl_2;
 613     }
 614
 615   *os << "template<>" << be_nl
 616       << "class "
 617       << this->S_ << "Arg_Traits<"
 618       << arg_flat_name.c_str ()
 619       << ">" << be_idt_nl
 620       << ": public" << be_idt << be_idt_nl
 621       << "BD_String_" << this->S_ << "Arg_Traits_T<" << be_nl
 622       << "CORBA::" << (wide ? "W" : "") << "String_var," << be_nl
 623       << bound << "," << be_nl
 624       << this->insert_policy()
 625       << be_uidt_nl
 626       << ">"
 627       << be_uidt << be_uidt << be_uidt_nl
 628       << "{" << be_nl
 629       << "};";
 630
 631   os->gen_endif ();
 632
 633   this->generated (node, true);
 634   return 0;
 635 }
 636
 637 int
 638 be_visitor_arg_traits::visit_sequence (be_sequence *node)
 639 {
 640   if (node->imported ())
 641     {
 642       // Arg traits will presumably already be generated, but
 643       // perhaps from another compilation unit. We mark it
 644       // generated because if we get here from a typedef in
 645       // the main file, we should skip it.
 646       this->generated (node, true);
 647       return 0;
 648     }
 649
 650   if (idl_global->dcps_sequence_type_defined (node->full_name ()))
 651     {
 652       this->generated (node, true);
 653       return 0;
 654     }
 655
 656   if (this->generated (node))
 657     {
 658       return 0;
 659     }
 660
 661   this->generated (node, true);
 662
 663   TAO_OutStream *os = this->ctx_->stream ();
 664   be_typedef *alias = this->ctx_->alias ();
 665
 666   /// No arg traits for anonymous sequences.
 667   if (alias == 0)
 668     {
 669       return 0;
 670     }
 671
 672   TAO_INSERT_COMMENT (os);
 673
 674   bool use_vec = (node->unbounded () && be_global->alt_mapping ());
 675   UTL_ScopedName *sn = alias->name ();
 676
 677   *os << be_nl_2
 678       << "template<>" << be_nl
 679       << "class " << this->S_ << "Arg_Traits< ::" << sn << ">"
 680       << be_idt_nl
 681       << ": public" << be_idt << be_idt_nl
 682       << (use_vec ? "Vector_" : "Var_Size_")
 683       << this->S_ << "Arg_Traits_T<" << be_idt << be_idt_nl
 684       << "::" << sn << "," << be_nl
 685       << this->insert_policy () << be_uidt_nl
 686       << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
 687       << "{" << be_nl
 688       << "};";
 689
 690   return 0;
 691 }
 692
 693 int
 694 be_visitor_arg_traits::visit_string (be_string *node)
 695 {
 696   if (node->imported ())
 697     {
 698       // Arg traits will presumably already be generated, but
 699       // perhaps from another compilation unit. We mark it
 700       // generated because if we get here from a typedef in
 701       // the main file, we should skip it.
 702       this->generated (node, true);
 703       return 0;
 704     }
 705
 706   if (this->generated (node) && !this->ctx_->alias())
 707     {
 708       return 0;
 709     }
 710
 711   ACE_CDR::ULong bound = node->max_size ()->ev ()->u.ulval;
 712   be_type *alias = this->ctx_->alias ();
 713
 714   // Unbounded (w)string args are handled as a predefined type.
 715   // Bounded (w)strings must come in as a typedef - they can't
 716   // be used directly as arguments or return types.
 717   if (bound == 0)
 718     {
 719       return 0;
 720     }
 721
 722   bool wide = (node->width () != 1);
 723
 724   TAO_OutStream *os = this->ctx_->stream ();
 725
 726   std::string guard_suffix =
 727     std::string (this->S_) + std::string ("arg_traits");
 728
 729   // The guard should be generated to prevent multiple declarations,
 730   // since a bounded (w)string of the same length may be used or typedef'd
 731   // more than once.
 732
 733   if (alias == 0)
 734     {
 735       os->gen_ifdef_macro (node->flat_name (), guard_suffix.c_str (), false);
 736     }
 737   else
 738     {
 739       // Form a unique macro name using the local name and the bound.
 740       ACE_CDR::ULong l = bound;
 741       int num_digits = 0;
 742
 743       while (l > 0)
 744         {
 745           l /= 10 ;
 746           ++num_digits ;
 747         }
 748
 749       size_t bound_length = num_digits + 1;
 750       char* bound_string = 0;
 751       ACE_NEW_RETURN (bound_string, char[bound_length], -1) ;
 752       ACE_OS::sprintf (bound_string, ACE_UINT32_FORMAT_SPECIFIER_ASCII, bound);
 753
 754       size_t cat_length = ACE_OS::strlen (alias->local_name ()->get_string ()) +
 755                           ACE_OS::strlen (bound_string) +
 756                           1;
 757       char* cat_string = 0;
 758       ACE_NEW_RETURN (cat_string, char[cat_length], -1) ;
 759       ACE_OS::strcpy (cat_string, alias->local_name ()->get_string ()) ;
 760       ACE_OS::strcat (cat_string, bound_string);
 761
 762       os->gen_ifdef_macro (cat_string, guard_suffix.c_str (), false);
 763
 764       delete [] cat_string;
 765       delete [] bound_string;
 766     }
 767
 768   // Avoid generating a duplicate structure in the skeleton since
 769   // it has already been generated in *C.h.
 770   if (ACE_OS::strlen (this->S_) == 0)
 771     {
 772       // A workaround 'dummy' type, since bounded (w)strings are all
 773       // generated as typedefs of (w)char *.
 774       *os << be_nl_2
 775           << "struct ";
 776
 777       if (alias == 0)
 778         {
 779           *os << node->flat_name ();
 780         }
 781       else
 782         {
 783           *os << alias->local_name () << "_" << bound;
 784         }
 785
 786       *os << " {};";
 787     }
 788
 789   *os << be_nl_2
 790       << "template<>" << be_nl
 791       << "class "
 792       << this->S_ << "Arg_Traits<";
 793
 794   if (0 == alias)
 795     {
 796       *os << node->flat_name ();
 797     }
 798   else
 799     {
 800       *os << alias->local_name () << "_" << bound;
 801     }
 802
 803   *os << ">" << be_idt_nl
 804       << ": public" << be_idt << be_idt_nl
 805       << "BD_String_" << this->S_ << "Arg_Traits_T<"
 806       << be_idt << be_idt_nl
 807       << "CORBA::" << (wide ? "W" : "") << "String_var," << be_nl
 808       << bound << "," << be_nl
 809       << this->insert_policy()
 810       << be_uidt << be_uidt_nl
 811       << ">"
 812       << be_uidt << be_uidt << be_uidt_nl
 813       << "{" << be_nl
 814       << "};";
 815
 816   os->gen_endif ();
 817
 818   this->generated (node, true);
 819   return 0;
 820 }
 821
 822 int
 823 be_visitor_arg_traits::visit_array (be_array *node)
 824 {
 825   if (node->imported ())
 826     {
 827       // Arg traits will presumably already be generated, but
 828       // perhaps from another compilation unit. We mark it
 829       // generated because if we get here from a typedef in
 830       // the main file, we should skip it.
 831       this->generated (node, true);
 832       return 0;
 833     }
 834
 835  // Add the alias check here because anonymous arrays can't be
 836  // operation arguments.
 837  if (this->generated (node) || this->ctx_->alias () == 0)
 838     {
 839       return 0;
 840     }
 841
 842   TAO_OutStream *os = this->ctx_->stream ();
 843
 844   *os << be_nl_2
 845       << "template<>" << be_nl
 846       << "class "
 847       << this->S_ << "Arg_Traits< ::"
 848       << node->name () << "_tag>" << be_idt_nl
 849       << ": public" << be_idt << be_idt_nl;
 850
 851   *os << (node->size_type () == AST_Type::FIXED ? "Fixed" : "Var")
 852       << "_Array_" << this->S_ << "Arg_Traits_T<" << be_idt << be_idt_nl
 853       << "::" << node->name ()
 854       << (node->size_type () == AST_Type::VARIABLE ? "_out" : "_var")
 855       << "," << be_nl;
 856
 857   *os << "::" << node->name () << "_forany";
 858
 859   *os << "," << be_nl << this->insert_policy();
 860
 861   *os << be_uidt_nl
 862       << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
 863       << "{" << be_nl
 864       << "};";
 865
 866   this->generated (node, true);
 867   return 0;
 868 }
 869
 870 int
 871 be_visitor_arg_traits::visit_enum (be_enum *node)
 872 {
 873   if (node->imported ())
 874     {
 875       // Arg traits will presumably already be generated, but
 876       // perhaps from another compilation unit. We mark it
 877       // generated because if we get here from a typedef in
 878       // the main file, we should skip it.
 879       this->generated (node, true);
 880       return 0;
 881     }
 882
 883   if (this->generated (node))
 884     {
 885       return 0;
 886     }
 887
 888   TAO_OutStream *os = this->ctx_->stream ();
 889
 890   TAO_INSERT_COMMENT (os);
 891
 892   *os << be_nl_2
 893       << "template<>" << be_nl
 894       << "class "
 895       << this->S_ << "Arg_Traits< ::"
 896       << node->name () << ">" << be_idt_nl
 897       << ": public" << be_idt << be_idt_nl;
 898
 899   *os << "Basic_" << this->S_ << "Arg_Traits_T<" << be_idt << be_idt_nl
 900       << "::" << node->name () << "," << be_nl
 901       << this->insert_policy() << be_uidt_nl
 902       << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
 903       << "{" << be_nl
 904       << "};";
 905
 906   this->generated (node, true);
 907   return 0;
 908 }
 909
 910 int
 911 be_visitor_arg_traits::visit_structure (be_structure *node)
 912 {
 913   if (node->imported ())
 914     {
 915       // Arg traits will presumably already be generated, but
 916       // perhaps from another compilation unit. We mark it
 917       // generated because if we get here from a typedef in
 918       // the main file, we should skip it.
 919       this->generated (node, true);
 920       return 0;
 921     }
 922
 923   if (this->generated (node))
 924     {
 925       return 0;
 926     }
 927
 928   // This should be generated even for imported nodes. The ifdef guard prevents
 929   // multiple declarations.
 930   TAO_OutStream *os = this->ctx_->stream ();
 931
 932   TAO_INSERT_COMMENT (os);
 933
 934   *os << be_nl_2
 935       << "template<>" << be_nl
 936       << "class "
 937       << this->S_ << "Arg_Traits< ::"
 938       << node->name () << ">" << be_idt_nl
 939       << ": public" << be_idt << be_idt_nl;
 940
 941   *os << (node->size_type () == AST_Type::FIXED ? "Fixed" : "Var")
 942       << "_Size_" << this->S_ << "Arg_Traits_T<" << be_idt << be_idt_nl;
 943
 944   *os << "::" << node->name () << "," << be_nl\
 945       << this->insert_policy () << be_uidt_nl
 946       << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
 947       << "{" << be_nl
 948       << "};";
 949
 950   /* Set this before visiting the scope so things like
 951
 952       interface foo
 953       {
 954         struct bar
 955         {
 956           ....
 957           foo foo_member;
 958         };
 959
 960         void op (in bar inarg);
 961       };
 962
 963      will not cause infinite recursion in this visitor.
 964   */
 965
 966   this->generated (node, true);
 967
 968   if (this->visit_scope (node) != 0)
 969     {
 970       ACE_ERROR_RETURN ((LM_ERROR,
 971                          "(%N:%l) be_visitor_arg_traits::"
 972                          "visit_structure - visit scope failed\n"),
 973                         -1);
 974     }
 975
 976   return 0;
 977 }
 978
 979 int
 980 be_visitor_arg_traits::visit_field (be_field *node)
 981 {
 982   be_type *bt = dynamic_cast<be_type*> (node->field_type ());
 983
 984   if (!bt)
 985     {
 986       ACE_ERROR_RETURN ((LM_ERROR,
 987                          "(%N:%l) be_visitor_arg_traits::"
 988                          "visit_field - "
 989                          "Bad field type\n"),
 990                         -1);
 991     }
 992
 993   // Valuetypes may not be *declared* in a field, so this will
 994   // get handled elsewhere, and will also avoid nested valuetype
 995   // recursion. So we set the field node as processed (the
 996   // field *type* may not have been reached yet) and return.
 997   AST_Decl::NodeType nt = bt->base_node_type ();
 998
 999   if (nt == AST_Decl::NT_valuetype || nt == AST_Decl::NT_eventtype)
1000     {
1001       node->cli_traits_gen (true);
1002       return 0;
1003     }
1004
1005   if (bt->accept (this) == -1)
1006     {
1007       ACE_ERROR_RETURN ((LM_ERROR,
1008                          "(%N:%l) be_visitor_arg_traits::"
1009                          "visit_field - "
1010                          "codegen for field type failed\n"),
1011                         -1);
1012     }
1013
1014   this->generated (node, true);
1015   this->generated (bt, true);
1016
1017   return 0;
1018 }
1019
1020 int
1021 be_visitor_arg_traits::visit_union (be_union *node)
1022 {
1023   if (node->imported ())
1024     {
1025       // Arg traits will presumably already be generated, but
1026       // perhaps from another compilation unit. We mark it
1027       // generated because if we get here from a typedef in
1028       // the main file, we should skip it.
1029       this->generated (node, true);
1030       return 0;
1031     }
1032
1033   if (this->generated (node))
1034     {
1035       return 0;
1036     }
1037
1038   // This should be generated even for imported nodes. The ifdef guard prevents
1039   // multiple declarations.
1040   TAO_OutStream *os = this->ctx_->stream ();
1041
1042   TAO_INSERT_COMMENT (os);
1043
1044   *os << be_nl_2
1045       << "template<>" << be_nl
1046       << "class "
1047       << this->S_ << "Arg_Traits< ::"
1048       << node->name () << ">" << be_idt_nl
1049       << ": public" << be_idt << be_idt_nl;
1050
1051   *os << (node->size_type () == AST_Type::FIXED ? "Fixed" : "Var")
1052       << "_Size_" << this->S_ << "Arg_Traits_T<" << be_idt << be_idt_nl
1053       << "::" << node->name () << "," << be_nl
1054       << this->insert_policy ();
1055
1056   *os << be_uidt_nl
1057       << ">" << be_uidt << be_uidt << be_uidt << be_uidt_nl
1058       << "{" << be_nl
1059       << "};";
1060
1061   /* Set this before visiting the scope so things like
1062
1063       interface foo
1064       {
1065         struct bar
1066         {
1067           ....
1068           foo foo_member;
1069         };
1070
1071         void op (in bar inarg);
1072       };
1073
1074      will not cause infinite recursion in this visitor.
1075   */
1076
1077   this->generated (node, true);
1078
1079   int status = this->visit_scope (node);
1080
1081   if (status != 0)
1082     {
1083       ACE_ERROR_RETURN ((LM_ERROR,
1084                          "(%N:%l) be_visitor_arg_traits::"
1085                          "visit_union - visit scope failed\n"),
1086                         -1);
1087     }
1088
1089   return 0;
1090 }
1091
1092 int
1093 be_visitor_arg_traits::visit_union_branch (be_union_branch *node)
1094 {
1095   be_type *bt = dynamic_cast<be_type*> (node->field_type ());
1096
1097   if (!bt)
1098     {
1099       ACE_ERROR_RETURN ((LM_ERROR,
1100                          "(%N:%l) be_visitor_arg_traits::"
1101                          "visit_union_branch - "
1102                          "Bad union_branch type\n"),
1103                         -1);
1104     }
1105
1106   if (bt->accept (this) == -1)
1107     {
1108       ACE_ERROR_RETURN ((LM_ERROR,
1109                          "(%N:%l) be_visitor_arg_traits::"
1110                          "visit_union_branch - "
1111                          "codegen for union_branch type failed\n"),
1112                         -1);
1113     }
1114
1115   this->generated (node, true);
1116   return 0;
1117 }
1118
1119 int
1120 be_visitor_arg_traits::visit_typedef (be_typedef *node)
1121 {
1122   if (node->imported ())
1123     {
1124       // Arg traits will presumably already be generated, but
1125       // perhaps from another compilation unit. We mark it
1126       // generated because if we get here from a typedef in
1127       // the main file, we should skip it.
1128       this->generated (node, true);
1129       return 0;
1130     }
1131
1132   if (this->generated (node))
1133     {
1134       return 0;
1135     }
1136
1137   // Had to move up the spot where the typedef is marked as
1138   // having its arg traits instantiation already generated.
1139   // Consider the case where the base type is an interface,
1140   // the typedef occurs inside the interface, and the typdef
1141   // is used as an arg in an operation of a derived interface.
1142   // When the scope of the base interface is visited
1143   // as part of the arg traits visitation, we had infinite
1144   // recursion and a stack overflow.
1145   this->generated (node, true);
1146
1147   this->ctx_->alias (node);
1148
1149   // Make a decision based on the primitive base type.
1150   be_type *bt = node->primitive_base_type ();
1151
1152   if (!bt || (bt->accept (this) == -1))
1153     {
1154       ACE_ERROR_RETURN ((LM_ERROR,
1155                          "(%N:%l) be_visitor_arg_traits::"
1156                          "visit_typedef - "
1157                          "Bad primitive type\n"),
1158                         -1);
1159     }
1160
1161   this->ctx_->alias (0);
1162   return 0;
1163 }
1164
1165 int
1166 be_visitor_arg_traits::visit_component (be_component *node)
1167 {
1168   return this->visit_interface (node);
1169 }
1170
1171 int
1172 be_visitor_arg_traits::visit_component_fwd (be_component_fwd *node)
1173 {
1174   return this->visit_interface_fwd (node);
1175 }
1176
1177 int
1178 be_visitor_arg_traits::visit_connector (be_connector *node)
1179 {
1180   return this->visit_component (node);
1181 }
1182
1183 int
1184 be_visitor_arg_traits::visit_home (be_home *node)
1185 {
1186   return this->visit_interface (node);
1187 }
1188
1189 bool
1190 be_visitor_arg_traits::generated (be_decl *node) const
1191 {
1192   if (ACE_OS::strcmp (this->S_, "") == 0)
1193     {
1194       switch (this->ctx_->state ())
1195         {
1196           case TAO_CodeGen::TAO_ROOT_CH:
1197             return node->cli_arg_traits_gen ();
1198           case TAO_CodeGen::TAO_ROOT_SH:
1199             return node->srv_arg_traits_gen ();
1200           default:
1201             return 0;
1202         }
1203     }
1204
1205   return node->srv_sarg_traits_gen ();
1206 }
1207
1208 void
1209 be_visitor_arg_traits::generated (be_decl *node,
1210                                   bool val)
1211 {
1212   if (ACE_OS::strcmp (this->S_, "") == 0)
1213     {
1214       switch (this->ctx_->state ())
1215         {
1216           case TAO_CodeGen::TAO_ROOT_CH:
1217             node->cli_arg_traits_gen (val);
1218             return;
1219           case TAO_CodeGen::TAO_ROOT_SH:
1220             node->srv_arg_traits_gen (val);
1221             return;
1222           default:
1223             return;
1224         }
1225     }
1226
1227   node->srv_sarg_traits_gen (val);
1228 }
1229
1230 const char *
1231 be_visitor_arg_traits::insert_policy (void)
1232 {
1233   if (be_global->any_support ())
1234     {
1235       if (be_global->gen_anytypecode_adapter ())
1236         {
1237           return "TAO::Any_Insert_Policy_AnyTypeCode_Adapter";
1238         }
1239       else
1240         {
1241           return "TAO::Any_Insert_Policy_Stream";
1242         }
1243     }
1244   else
1245     {
1246       return "TAO::Any_Insert_Policy_Noop";
1247     }
1248 }