TAO/TAO_IDL/be/be_visitor_interface/interface.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    interface.cpp
   5  *
   6  *  Visitor generating code for Interfaces. This is a generic visitor.
   7  *
   8  *  @author Aniruddha Gokhale
   9  */
  10 //=============================================================================
  11
  12 #include "interface.h"
  13
  14 be_visitor_interface::be_visitor_interface (be_visitor_context *ctx)
  15   : be_visitor_scope (ctx)
  16 {
  17 }
  18
  19 be_visitor_interface::~be_visitor_interface ()
  20 {
  21 }
  22
  23 // This method must be overridden by the derived interface visitors.
  24 int
  25 be_visitor_interface::visit_interface (be_interface *)
  26 {
  27   return -1;
  28 }
  29
  30 int
  31 be_visitor_interface::visit_scope (be_scope *node)
  32 {
  33   if (this->be_visitor_scope::visit_scope (node) == -1)
  34     {
  35       return -1;
  36     }
  37
  38   be_interface *intf = dynamic_cast<be_interface*> (node);
  39
  40   if (intf == nullptr)
  41     {
  42       return 0;
  43     }
  44
  45   if (intf->is_abstract ())
  46     {
  47       return 0;
  48     }
  49
  50   if (! intf->has_mixed_parentage ())
  51     {
  52       return 0;
  53     }
  54
  55   be_interface::tao_code_emitter helper = nullptr;
  56
  57   switch (this->ctx_->state ())
  58     {
  59       case TAO_CodeGen::TAO_INTERFACE_CH:
  60         helper =
  61           be_visitor_interface_ch::gen_abstract_ops_helper;
  62         break;
  63       case TAO_CodeGen::TAO_ROOT_CS:
  64         helper =
  65           be_visitor_interface_cs::gen_abstract_ops_helper;
  66         break;
  67       case TAO_CodeGen::TAO_ROOT_SH:
  68         helper =
  69           be_visitor_interface_sh::gen_abstract_ops_helper;
  70         break;
  71       case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SH:
  72         helper =
  73           be_visitor_interface_direct_proxy_impl_sh::gen_abstract_ops_helper;
  74         break;
  75       case TAO_CodeGen::TAO_ROOT_SS:
  76         helper =
  77           be_visitor_interface_ss::gen_abstract_ops_helper;
  78         break;
  79       case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SS:
  80         helper =
  81           be_visitor_interface_direct_proxy_impl_ss::gen_abstract_ops_helper;
  82         break;
  83       default:
  84         break;
  85     }
  86
  87   if (helper == nullptr)
  88     {
  89       return 0;
  90     }
  91
  92   // 'abstract_paths_only' arg is FALSE here because we want to traverse
  93   // through concrete parents to get to all the abstract ones. The helper
  94   // will do nothing unless the base interface passed to it is abstract.
  95   int status =
  96     intf->traverse_inheritance_graph (helper,
  97                                       this->ctx_->stream (),
  98                                       false);
  99
 100   if (status == -1)
 101     {
 102       ACE_ERROR_RETURN ((LM_ERROR,
 103                          "be_visitor_interface_*::"
 104                          "visit_scope - "
 105                          "traversal of inheritance graph failed\n"),
 106                         -1);
 107     }
 108
 109   return 0;
 110 }
 111
 112 int
 113 be_visitor_interface::is_amh_rh_node (be_interface *node)
 114 {
 115    //If, is implied-IDL
 116   if (node->original_interface () != nullptr)
 117     {
 118       // and the name starts with AMH
 119       if (ACE_OS::strncmp (node->local_name (), "AMH", 3) == 0)
 120         {
 121           // then it is an AMH node.
 122           return 1;
 123         }
 124     }
 125
 126   return 0;
 127 }
 128
 129 void
 130 be_visitor_interface::add_abstract_op_args (AST_Operation *old_op,
 131                                             be_operation &new_op)
 132 {
 133   AST_Decl *d = nullptr;
 134
 135   for (UTL_ScopeActiveIterator si (old_op, UTL_Scope::IK_decls);
 136        !si.is_done ();
 137        si.next ())
 138     {
 139       d = si.item ();
 140       new_op.add_to_scope (d);
 141     }
 142
 143   UTL_ExceptList *excep_list = old_op->exceptions ();
 144
 145   if (nullptr != excep_list)
 146     {
 147       new_op.be_add_exceptions (excep_list->copy ());
 148     }
 149 }
 150
 151 // All common visit methods for interface visitor.
 152
 153 int
 154 be_visitor_interface::visit_attribute (be_attribute *node)
 155 {
 156   // Instantiate a visitor context with a copy of our context. This info
 157   // will be modified based on what type of node we are visiting.
 158   be_visitor_context ctx (*this->ctx_);
 159   ctx.node (node);
 160
 161   // Same visitor for all the above cases where an action is taken.
 162   be_visitor_attribute visitor (&ctx);
 163
 164   if (node->accept (&visitor) == -1)
 165     {
 166       ACE_ERROR_RETURN ((LM_ERROR,
 167                          "(%N:%l) be_visitor_interface::"
 168                          "visit_attribute - "
 169                          "failed to accept visitor\n"),
 170                         -1);
 171     }
 172
 173   return 0;
 174 }
 175
 176 int
 177 be_visitor_interface::visit_constant (be_constant *node)
 178 {
 179   // Instantiate a visitor context with a copy of our context. This info
 180   // will be modified based on what type of node we are visiting
 181   be_visitor_context ctx (*this->ctx_);
 182   ctx.node (node);
 183   int status = 0;
 184
 185   switch (this->ctx_->state ())
 186     {
 187     case TAO_CodeGen::TAO_INTERFACE_CH:
 188       {
 189         be_visitor_constant_ch visitor (&ctx);
 190         status = node->accept (&visitor);
 191         break;
 192       }
 193     case TAO_CodeGen::TAO_ROOT_CS:
 194       {
 195         be_visitor_constant_cs visitor (&ctx);
 196         status = node->accept (&visitor);
 197         break;
 198       }
 199     default:
 200       return 0; // nothing to be done
 201     }
 202
 203   if (status == -1)
 204     {
 205       ACE_ERROR_RETURN ((LM_ERROR,
 206                          "(%N:%l) be_visitor_interface::"
 207                          "visit_constant - "
 208                          "failed to accept visitor\n"),
 209                         -1);
 210     }
 211
 212   return 0;
 213 }
 214
 215 int
 216 be_visitor_interface::visit_native (be_native *node)
 217 {
 218   // Instantiate a visitor context with a copy of our context. This info
 219   // will be modified based on what type of node we are visiting
 220   be_visitor_context ctx (*this->ctx_);
 221   ctx.node (node);
 222   int status = 0;
 223
 224   switch (this->ctx_->state ())
 225     {
 226     case TAO_CodeGen::TAO_INTERFACE_CH:
 227       {
 228         be_visitor_native_ch visitor (&ctx);
 229         status = node->accept (&visitor);
 230         break;
 231       }
 232     default:
 233       return 0; // nothing to be done
 234     }
 235
 236   if (status == -1)
 237     {
 238       ACE_ERROR_RETURN ((LM_ERROR,
 239                          "(%N:%l) be_visitor_interface::"
 240                          "visit_native - "
 241                          "failed to accept visitor\n"),
 242                         -1);
 243     }
 244
 245   return 0;
 246 }
 247
 248 int
 249 be_visitor_interface::visit_enum (be_enum *node)
 250 {
 251   // Instantiate a visitor context with a copy of our context. This info
 252   // will be modified based on what type of node we are visiting
 253   be_visitor_context ctx (*this->ctx_);
 254   ctx.node (node);
 255   int status = 0;
 256
 257   switch (this->ctx_->state ())
 258     {
 259     case TAO_CodeGen::TAO_INTERFACE_CH:
 260       {
 261         be_visitor_enum_ch visitor (&ctx);
 262         status = node->accept (&visitor);
 263         break;
 264       }
 265     case TAO_CodeGen::TAO_ROOT_CS:
 266       {
 267         be_visitor_enum_cs visitor (&ctx);
 268         status = node->accept (&visitor);
 269         break;
 270       }
 271     case TAO_CodeGen::TAO_ROOT_ANY_OP_CH:
 272       {
 273         be_visitor_enum_any_op_ch visitor (&ctx);
 274         status = node->accept (&visitor);
 275         break;
 276       }
 277     case TAO_CodeGen::TAO_ROOT_ANY_OP_CS:
 278       {
 279         be_visitor_enum_any_op_cs visitor (&ctx);
 280         status = node->accept (&visitor);
 281         break;
 282       }
 283     case TAO_CodeGen::TAO_ROOT_CDR_OP_CH:
 284       {
 285         be_visitor_enum_cdr_op_ch visitor (&ctx);
 286         status = node->accept (&visitor);
 287         break;
 288       }
 289     case TAO_CodeGen::TAO_ROOT_CDR_OP_CS:
 290       {
 291         be_visitor_enum_cdr_op_cs visitor (&ctx);
 292         status = node->accept (&visitor);
 293         break;
 294       }
 295     default:
 296       return 0; // nothing to be done
 297     }
 298
 299   if (status == -1)
 300     {
 301       ACE_ERROR_RETURN ((LM_ERROR,
 302                          "(%N:%l) be_visitor_interface::"
 303                          "visit_enum - "
 304                          "failed to accept visitor\n"),
 305                         -1);
 306     }
 307
 308   return 0;
 309 }
 310
 311 // visit an exception
 312 int
 313 be_visitor_interface::visit_exception (be_exception *node)
 314 {
 315   // Instantiate a visitor context with a copy of our context. This info
 316   // will be modified based on what type of node we are visiting.
 317   be_visitor_context ctx (*this->ctx_);
 318   ctx.node (node);
 319   int status = 0;
 320
 321   switch (this->ctx_->state ())
 322     {
 323     case TAO_CodeGen::TAO_INTERFACE_CH:
 324       {
 325         be_visitor_exception_ch visitor (&ctx);
 326         status = node->accept (&visitor);
 327         break;
 328       }
 329     case TAO_CodeGen::TAO_ROOT_CI:
 330       {
 331         be_visitor_exception_ci visitor (&ctx);
 332         status = node->accept (&visitor);
 333         break;
 334       }
 335     case TAO_CodeGen::TAO_ROOT_CS:
 336       {
 337         be_visitor_exception_cs visitor (&ctx);
 338         status = node->accept (&visitor);
 339         break;
 340       }
 341     case TAO_CodeGen::TAO_ROOT_ANY_OP_CH:
 342       {
 343         be_visitor_exception_any_op_ch visitor (&ctx);
 344         status = node->accept (&visitor);
 345         break;
 346       }
 347     case TAO_CodeGen::TAO_ROOT_ANY_OP_CS:
 348       {
 349         be_visitor_exception_any_op_cs visitor (&ctx);
 350         status = node->accept (&visitor);
 351         break;
 352       }
 353     case TAO_CodeGen::TAO_ROOT_CDR_OP_CH:
 354       {
 355         be_visitor_exception_cdr_op_ch visitor (&ctx);
 356         status = node->accept (&visitor);
 357         break;
 358       }
 359     case TAO_CodeGen::TAO_ROOT_CDR_OP_CS:
 360       {
 361         be_visitor_exception_cdr_op_cs visitor (&ctx);
 362         status = node->accept (&visitor);
 363         break;
 364       }
 365     default:
 366                   return 0; // nothing to be done
 367     }
 368
 369   if (status == -1)
 370     {
 371       ACE_ERROR_RETURN ((LM_ERROR,
 372                          "(%N:%l) be_visitor_interface::"
 373                          "visit_exception - "
 374                          "failed to accept visitor\n"),
 375                         -1);
 376     }
 377
 378   return 0;
 379 }
 380
 381 // visit an operation
 382 int
 383 be_visitor_interface::visit_operation (be_operation *node)
 384 {
 385   // Instantiate a visitor context with a copy of our context. This info
 386   // will be modified ased on what type of node we are visiting
 387   be_visitor_context ctx (*this->ctx_);
 388   ctx.node (node);
 389   int status = 1;
 390
 391   switch (this->ctx_->state ())
 392     {
 393     // These first two cases may have the context state changed
 394     // by a strategy, so we use the visitor factory below.
 395     case TAO_CodeGen::TAO_INTERFACE_CH:
 396       {
 397         ctx.state (TAO_CodeGen::TAO_OPERATION_CH);
 398         be_visitor_operation_ch visitor (&ctx);
 399         status = node->accept (&visitor);
 400         break;
 401       }
 402     case TAO_CodeGen::TAO_ROOT_CS:
 403       ctx.state (TAO_CodeGen::TAO_OPERATION_CS);
 404
 405       if (node->is_sendc_ami ())
 406         {
 407           be_visitor_operation_ami_cs visitor (&ctx);
 408           status = node->accept (&visitor);
 409         }
 410       else
 411         {
 412           be_visitor_operation_cs visitor (&ctx);
 413           status = node->accept (&visitor);
 414         }
 415
 416       break;
 417     case TAO_CodeGen::TAO_ROOT_SH:
 418       {
 419         be_visitor_operation_sh visitor (&ctx);
 420         status = node->accept (&visitor);
 421         break;
 422       }
 423     case TAO_CodeGen::TAO_ROOT_EXH:
 424     case TAO_CodeGen::TAO_ROOT_IH:
 425       {
 426         be_visitor_operation_ih visitor (&ctx);
 427         status = node->accept (&visitor);
 428         break;
 429       }
 430     case TAO_CodeGen::TAO_ROOT_SS:
 431       {
 432         be_visitor_operation_ss visitor (&ctx);
 433         status = node->accept (&visitor);
 434         break;
 435       }
 436     case TAO_CodeGen::TAO_ROOT_IS:
 437       {
 438         be_visitor_operation_is visitor (&ctx);
 439         status = node->accept (&visitor);
 440         break;
 441       }
 442     case TAO_CodeGen::TAO_ROOT_TIE_SH:
 443       {
 444         be_visitor_operation_tie_sh visitor (&ctx);
 445         status = node->accept (&visitor);
 446         break;
 447       }
 448     case TAO_CodeGen::TAO_ROOT_TIE_SS:
 449       {
 450         be_visitor_operation_tie_ss visitor (&ctx);
 451         status = node->accept (&visitor);
 452         break;
 453       }
 454     case TAO_CodeGen::TAO_INTERFACE_SMART_PROXY_CH:
 455       {
 456         be_visitor_operation_smart_proxy_ch visitor (&ctx);
 457         status = node->accept (&visitor);
 458         break;
 459       }
 460     case TAO_CodeGen::TAO_INTERFACE_SMART_PROXY_CS:
 461       {
 462         be_visitor_operation_smart_proxy_cs visitor (&ctx);
 463         status = node->accept (&visitor);
 464         break;
 465       }
 466     case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SH:
 467       {
 468         be_visitor_operation_proxy_impl_xh visitor (&ctx);
 469         status = node->accept (&visitor);
 470         break;
 471       }
 472     case TAO_CodeGen::TAO_INTERFACE_AMH_RH_SH:
 473       {
 474         be_visitor_amh_rh_operation_sh visitor (&ctx);
 475         status = node->accept (&visitor);
 476         break;
 477       }
 478     case TAO_CodeGen::TAO_INTERFACE_AMH_RH_SS:
 479       {
 480         be_visitor_amh_rh_operation_ss visitor (&ctx);
 481         status = node->accept (&visitor);
 482         break;
 483       }
 484     case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SS:
 485       {
 486         be_visitor_operation_direct_proxy_impl_ss visitor (&ctx);
 487         status = node->accept (&visitor);
 488         break;
 489       }
 490     case TAO_CodeGen::TAO_ROOT_ANY_OP_CH:
 491     case TAO_CodeGen::TAO_ROOT_ANY_OP_CS:
 492     case TAO_CodeGen::TAO_ROOT_CDR_OP_CH:
 493     case TAO_CodeGen::TAO_ROOT_CDR_OP_CS:
 494     case TAO_CodeGen::TAO_ROOT_CI:
 495       return 0; // nothing to be done
 496     default:
 497       {
 498         ACE_ERROR_RETURN ((LM_ERROR,
 499                            "(%N:%l) be_visitor_interface::"
 500                            "visit_operation - "
 501                            "Bad context state\n"),
 502                           -1);
 503       }
 504     }
 505
 506   if (status == 0)
 507     {
 508       return 0;
 509     }
 510   else if (status == -1)
 511     {
 512       ACE_ERROR_RETURN ((LM_ERROR,
 513                          "(%N:%l) be_visitor_interface::"
 514                          "visit_operation - "
 515                          "failed to accept visitor\n"),
 516                         -1);
 517     }
 518
 519   return 0;
 520 }
 521
 522 int
 523 be_visitor_interface::visit_structure (be_structure *node)
 524 {
 525   // Instantiate a visitor context with a copy of our context. This info
 526   // will be modified based on what type of node we are visiting.
 527   be_visitor_context ctx (*this->ctx_);
 528   ctx.node (node);
 529   int status = 0;
 530
 531   switch (this->ctx_->state ())
 532     {
 533     case TAO_CodeGen::TAO_INTERFACE_CH:
 534       {
 535         be_visitor_structure_ch visitor (&ctx);
 536         status = node->accept (&visitor);
 537         break;
 538       }
 539     case TAO_CodeGen::TAO_ROOT_CI:
 540       {
 541         be_visitor_structure_ci visitor (&ctx);
 542         status = node->accept (&visitor);
 543         break;
 544       }
 545     case TAO_CodeGen::TAO_ROOT_CS:
 546       {
 547         be_visitor_structure_cs visitor (&ctx);
 548         status = node->accept (&visitor);
 549         break;
 550       }
 551     case TAO_CodeGen::TAO_ROOT_ANY_OP_CH:
 552       {
 553         be_visitor_structure_any_op_ch visitor (&ctx);
 554         status = node->accept (&visitor);
 555         break;
 556       }
 557     case TAO_CodeGen::TAO_ROOT_ANY_OP_CS:
 558       {
 559         be_visitor_structure_any_op_cs visitor (&ctx);
 560         status = node->accept (&visitor);
 561         break;
 562       }
 563     case TAO_CodeGen::TAO_ROOT_CDR_OP_CH:
 564       {
 565         be_visitor_structure_cdr_op_ch visitor (&ctx);
 566         status = node->accept (&visitor);
 567         break;
 568       }
 569     case TAO_CodeGen::TAO_ROOT_CDR_OP_CS:
 570       {
 571         be_visitor_structure_cdr_op_cs visitor (&ctx);
 572         status = node->accept (&visitor);
 573         break;
 574       }
 575     default:
 576       return 0; // nothing to be done
 577     }
 578
 579   if (status == -1)
 580     {
 581       ACE_ERROR_RETURN ((LM_ERROR,
 582                          "(%N:%l) be_visitor_interface::"
 583                          "visit_structure - "
 584                          "failed to accept visitor\n"),
 585                         -1);
 586     }
 587
 588   return 0;
 589 }
 590
 591 int
 592 be_visitor_interface::visit_structure_fwd (be_structure_fwd *node)
 593 {
 594   // Instantiate a visitor context with a copy of our context. This info
 595   // will be modified based on what type of node we are visiting.
 596   be_visitor_context ctx (*this->ctx_);
 597   ctx.node (node);
 598   int status = 0;
 599
 600   switch (this->ctx_->state ())
 601     {
 602     case TAO_CodeGen::TAO_INTERFACE_CH:
 603       {
 604         be_visitor_structure_fwd_ch visitor (&ctx);
 605         status = node->accept (&visitor);
 606         break;
 607       }
 608     default:
 609       return 0; // nothing to be done
 610     }
 611
 612   if (status == -1)
 613     {
 614       ACE_ERROR_RETURN ((LM_ERROR,
 615                          "(%N:%l) be_visitor_interface::"
 616                          "visit_structure_fwd - "
 617                          "failed to accept visitor\n"),
 618                         -1);
 619     }
 620
 621   return 0;
 622 }
 623
 624 int
 625 be_visitor_interface::visit_union (be_union *node)
 626 {
 627   // Instantiate a visitor context with a copy of our context. This info
 628   // will be modified based on what type of node we are visiting.
 629   be_visitor_context ctx (*this->ctx_);
 630   ctx.node (node);
 631   int status = 0;
 632
 633   switch (this->ctx_->state ())
 634     {
 635     case TAO_CodeGen::TAO_INTERFACE_CH:
 636       {
 637         be_visitor_union_ch visitor (&ctx);
 638         status = node->accept (&visitor);
 639         break;
 640       }
 641     case TAO_CodeGen::TAO_ROOT_CI:
 642       {
 643         be_visitor_union_ci visitor (&ctx);
 644         status = node->accept (&visitor);
 645         break;
 646       }
 647     case TAO_CodeGen::TAO_ROOT_CS:
 648       {
 649         be_visitor_union_cs visitor (&ctx);
 650         status = node->accept (&visitor);
 651         break;
 652       }
 653     case TAO_CodeGen::TAO_ROOT_ANY_OP_CH:
 654       {
 655         be_visitor_union_any_op_ch visitor (&ctx);
 656         status = node->accept (&visitor);
 657         break;
 658       }
 659     case TAO_CodeGen::TAO_ROOT_ANY_OP_CS:
 660       {
 661         be_visitor_union_any_op_cs visitor (&ctx);
 662         status = node->accept (&visitor);
 663         break;
 664       }
 665     case TAO_CodeGen::TAO_ROOT_CDR_OP_CH:
 666       {
 667         be_visitor_union_cdr_op_ch visitor (&ctx);
 668         status = node->accept (&visitor);
 669         break;
 670       }
 671     case TAO_CodeGen::TAO_ROOT_CDR_OP_CS:
 672       {
 673         be_visitor_union_cdr_op_cs visitor (&ctx);
 674         status = node->accept (&visitor);
 675         break;
 676       }
 677     default:
 678                   return 0; // nothing to be done
 679     }
 680
 681   if (status == -1)
 682     {
 683       ACE_ERROR_RETURN ((LM_ERROR,
 684                          "(%N:%l) be_visitor_interface::"
 685                          "visit_union - "
 686                          "failed to accept visitor\n"),
 687                         -1);
 688     }
 689
 690   return 0;
 691 }
 692
 693 int
 694 be_visitor_interface::visit_union_fwd (be_union_fwd *node)
 695 {
 696   // Instantiate a visitor context with a copy of our context. This info
 697   // will be modified based on what type of node we are visiting.
 698   be_visitor_context ctx (*this->ctx_);
 699   ctx.node (node);
 700   int status = 0;
 701
 702   switch (this->ctx_->state ())
 703     {
 704     case TAO_CodeGen::TAO_INTERFACE_CH:
 705       {
 706         be_visitor_union_fwd_ch visitor (&ctx);
 707         status = node->accept (&visitor);
 708         break;
 709       }
 710     default:
 711       return 0; // nothing to be done
 712     }
 713
 714   if (status == -1)
 715     {
 716       ACE_ERROR_RETURN ((LM_ERROR,
 717                          "(%N:%l) be_visitor_interface::"
 718                          "visit_union_fwd - "
 719                          "failed to accept visitor\n"),
 720                         -1);
 721     }
 722
 723   return 0;
 724 }
 725
 726 int
 727 be_visitor_interface::visit_typedef (be_typedef *node)
 728 {
 729   // Instantiate a visitor context with a copy of our context. This info
 730   // will be modified based on what type of node we are visiting.
 731   be_visitor_context ctx (*this->ctx_);
 732   ctx.node (node);
 733   int status = 0;
 734
 735   switch (this->ctx_->state ())
 736     {
 737     case TAO_CodeGen::TAO_INTERFACE_CH:
 738       {
 739         be_visitor_typedef_ch visitor (&ctx);
 740         status = node->accept (&visitor);
 741         break;
 742       }
 743     case TAO_CodeGen::TAO_ROOT_CI:
 744       {
 745         be_visitor_typedef_ci visitor (&ctx);
 746         status = node->accept (&visitor);
 747         break;
 748       }
 749     case TAO_CodeGen::TAO_ROOT_CS:
 750       {
 751         be_visitor_typedef_cs visitor (&ctx);
 752         status = node->accept (&visitor);
 753         break;
 754       }
 755     case TAO_CodeGen::TAO_ROOT_ANY_OP_CH:
 756       {
 757         be_visitor_typedef_any_op_ch visitor (&ctx);
 758         status = node->accept (&visitor);
 759         break;
 760       }
 761     case TAO_CodeGen::TAO_ROOT_ANY_OP_CS:
 762       {
 763         be_visitor_typedef_any_op_cs visitor (&ctx);
 764         status = node->accept (&visitor);
 765         break;
 766       }
 767     case TAO_CodeGen::TAO_ROOT_CDR_OP_CH:
 768       {
 769         be_visitor_typedef_cdr_op_ch visitor (&ctx);
 770         status = node->accept (&visitor);
 771         break;
 772       }
 773     case TAO_CodeGen::TAO_ROOT_CDR_OP_CS:
 774       {
 775         be_visitor_typedef_cdr_op_cs visitor (&ctx);
 776         status = node->accept (&visitor);
 777         break;
 778       }
 779     default:
 780                   return 0; // nothing to be done
 781     }
 782
 783   if (status == -1)
 784     {
 785       ACE_ERROR_RETURN ((LM_ERROR,
 786                          "(%N:%l) be_visitor_interface::"
 787                          "visit_typedef - "
 788                          "failed to accept visitor\n"),
 789                         -1);
 790     }
 791
 792   return 0;
 793 }