TAO/TAO_IDL/be/be_visitor_xplicit_pre_proc.cpp

   1 /**
   2  *  @file   be_visitor_xplicit_pre_proc.cpp
   3  *
   4  *  @author Jeff Parsons
   5  */
   6 //=============================================================================
   7
   8 #include "be_visitor_xplicit_pre_proc.h"
   9 #include "be_home.h"
  10 #include "be_component.h"
  11 #include "be_interface.h"
  12 #include "be_operation.h"
  13 #include "be_argument.h"
  14 #include "be_finder.h"
  15 #include "be_exception.h"
  16 #include "be_field.h"
  17 #include "be_valuebox.h"
  18 #include "be_eventtype.h"
  19 #include "be_typedef.h"
  20 #include "be_predefined_type.h"
  21 #include "be_enum.h"
  22 #include "be_enum_val.h"
  23 #include "be_union.h"
  24 #include "be_union_fwd.h"
  25 #include "be_union_branch.h"
  26 #include "be_attribute.h"
  27 #include "be_constant.h"
  28 #include "be_array.h"
  29 #include "be_sequence.h"
  30 #include "be_string.h"
  31 #include "be_native.h"
  32
  33 #include "ast_module.h"
  34
  35 #include "utl_namelist.h"
  36 #include "utl_labellist.h"
  37 #include "utl_exprlist.h"
  38 #include "utl_exceptlist.h"
  39
  40 #include "fe_obv_header.h"
  41 #include "nr_extern.h"
  42 #include "global_extern.h"
  43
  44 be_visitor_xplicit_pre_proc::be_visitor_xplicit_pre_proc (
  45       be_visitor_context *ctx)
  46   : be_visitor_ccm_pre_proc (ctx),
  47     xplicit_ (nullptr),
  48     type_holder_ (nullptr),
  49     ref_type_ (false)
  50 {
  51 }
  52
  53 be_visitor_xplicit_pre_proc::~be_visitor_xplicit_pre_proc ()
  54 {
  55 }
  56
  57 int
  58 be_visitor_xplicit_pre_proc::visit_home (be_home *node)
  59 {
  60   UTL_NameList *parent_list = this->compute_inheritance (node);
  61
  62   FE_InterfaceHeader header (nullptr,
  63                              parent_list,
  64                              false,
  65                              false,
  66                              true);
  67
  68   // We're at global scope here so we need to fool the scope stack
  69   // for a minute so the correct repo id can be calculated at
  70   // interface construction time.
  71   AST_Module *m =
  72     dynamic_cast<AST_Module*> (node->defined_in ());
  73
  74   idl_global->scopes ().push (m);
  75
  76   UTL_ScopedName *explicit_name =
  77     this->create_scoped_name (
  78       "",
  79       node->original_local_name ()->get_string (),
  80       "Explicit",
  81       m);
  82
  83   be_interface *i = nullptr;
  84   ACE_NEW_RETURN (i,
  85                   be_interface (explicit_name,
  86                                 header.inherits (),
  87                                 header.n_inherits (),
  88                                 header.inherits_flat (),
  89                                 header.n_inherits_flat (),
  90                                 false,
  91                                 false),
  92                   0);
  93
  94   (void) m->be_add_interface (i);
  95
  96   i->original_interface (node);
  97   i->set_imported (node->imported ());
  98
  99   // So we can generate the proper typecode.
 100   i->home_equiv (true);
 101
 102   idl_global->scopes ().push (i);
 103
 104   if (this->visit_scope (node) != 0)
 105     {
 106       ACE_ERROR_RETURN ((LM_ERROR,
 107                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 108                          ACE_TEXT ("visit_home - code generation ")
 109                          ACE_TEXT ("for home scope failed\n")),
 110                         0);
 111     }
 112
 113   // Through with the explicit interface scope
 114   idl_global->scopes ().pop ();
 115
 116   explicit_name->destroy ();
 117   delete explicit_name;
 118   explicit_name = nullptr;
 119
 120   header.destroy ();
 121
 122   parent_list->destroy ();
 123   delete parent_list;
 124   parent_list = nullptr;
 125
 126   // Through with the scope containing the home.
 127   idl_global->scopes ().pop ();
 128
 129   this->xplicit_ = i;
 130
 131   return 0;
 132 }
 133
 134 int
 135 be_visitor_xplicit_pre_proc::visit_operation (be_operation *node)
 136 {
 137   UTL_ScopedName sn (node->local_name (), nullptr);
 138
 139   be_operation *home_op = nullptr;
 140   ACE_NEW_RETURN (home_op,
 141                   be_operation (node->return_type (),
 142                                 node->flags (),
 143                                 &sn,
 144                                 false,
 145                                 false),
 146                   -1);
 147
 148   UTL_ExceptList *excep_list = node->exceptions ();
 149   if (nullptr != excep_list)
 150     {
 151       home_op->be_add_exceptions (excep_list->copy ());
 152     }
 153
 154   idl_global->scopes ().top ()->add_to_scope (home_op);
 155   idl_global->scopes ().push (home_op);
 156
 157   if (this->visit_scope (node) != 0)
 158     {
 159       ACE_ERROR_RETURN ((LM_ERROR,
 160                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 161                          ACE_TEXT ("visit_operation - code generation ")
 162                          ACE_TEXT ("for scope failed\n")),
 163                         -1);
 164     }
 165
 166   idl_global->scopes ().pop ();
 167
 168   return 0;
 169 }
 170
 171 int
 172 be_visitor_xplicit_pre_proc::visit_argument (be_argument *node)
 173 {
 174   UTL_ScopedName sn (node->local_name (), nullptr);
 175
 176   this->ref_type_ = true;
 177
 178   be_type *ft =
 179     dynamic_cast<be_type*> (node->field_type ());
 180
 181   if (ft->accept (this) != 0)
 182     {
 183       ACE_ERROR_RETURN ((LM_ERROR,
 184                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 185                          ACE_TEXT ("visit_argument - code generation ")
 186                          ACE_TEXT ("for arg type failed\n")),
 187                         -1);
 188     }
 189
 190   this->ref_type_ = false;
 191
 192   AST_Type *arg_type =
 193     dynamic_cast<AST_Type*> (this->type_holder_);
 194
 195   be_argument *added_arg = nullptr;
 196   ACE_NEW_RETURN (added_arg,
 197                   be_argument (node->direction (),
 198                                arg_type,
 199                                &sn),
 200                   -1);
 201
 202   idl_global->scopes ().top ()->add_to_scope (added_arg);
 203
 204   return 0;
 205 }
 206
 207 int
 208 be_visitor_xplicit_pre_proc::visit_factory (be_factory *node)
 209 {
 210   UTL_ScopedName sn (node->local_name (), nullptr);
 211
 212   AST_Home *f_home =
 213     dynamic_cast<AST_Home*> (node->defined_in ());
 214
 215   be_operation *added_factory = nullptr;
 216   ACE_NEW_RETURN (added_factory,
 217                   be_operation (f_home->managed_component (),
 218                                 AST_Operation::OP_noflags,
 219                                 &sn,
 220                                 false,
 221                                 false),
 222                   -1);
 223
 224   idl_global->scopes ().top ()->add_to_scope (added_factory);
 225   idl_global->scopes ().push (added_factory);
 226
 227   if (this->visit_scope (node) != 0)
 228     {
 229       ACE_ERROR_RETURN ((LM_ERROR,
 230                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 231                          ACE_TEXT ("visit_factory - code generation ")
 232                          ACE_TEXT ("for scope failed\n")),
 233                         -1);
 234     }
 235
 236   idl_global->scopes ().pop ();
 237
 238   return 0;
 239 }
 240
 241 int
 242 be_visitor_xplicit_pre_proc::visit_finder (be_finder *node)
 243 {
 244   UTL_ScopedName sn (node->local_name (), nullptr);
 245
 246   AST_Home *f_home =
 247     dynamic_cast<AST_Home*> (node->defined_in ());
 248
 249   be_operation *added_finder = nullptr;
 250   ACE_NEW_RETURN (added_finder,
 251                   be_operation (f_home->managed_component (),
 252                                 AST_Operation::OP_noflags,
 253                                 &sn,
 254                                 false,
 255                                 false),
 256                   -1);
 257
 258   idl_global->scopes ().top ()->add_to_scope (added_finder);
 259   idl_global->scopes ().push (added_finder);
 260
 261   if (this->visit_scope (node) != 0)
 262     {
 263       ACE_ERROR_RETURN ((LM_ERROR,
 264                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 265                          ACE_TEXT ("visit_finder - code generation ")
 266                          ACE_TEXT ("for scope failed\n")),
 267                         -1);
 268     }
 269
 270   idl_global->scopes ().pop ();
 271
 272   return 0;
 273 }
 274
 275 int
 276 be_visitor_xplicit_pre_proc::visit_interface (be_interface *node)
 277 {
 278   // Interface can't be declared inside a home, no need to call
 279   // check_and_store().
 280   this->type_holder_ = node;
 281
 282   return 0;
 283 }
 284
 285 int
 286 be_visitor_xplicit_pre_proc::visit_valuebox (be_valuebox *node)
 287 {
 288   // Valuebox can't be declared inside a home, no need to call
 289   // check_and_store().
 290   this->type_holder_ = node;
 291
 292   return 0;
 293 }
 294
 295 int
 296 be_visitor_xplicit_pre_proc::visit_valuetype (be_valuetype *node)
 297 {
 298   // Valuetype can't be declared inside a home, no need to call
 299   // check_and_store().
 300   this->type_holder_ = node;
 301
 302   return 0;
 303 }
 304
 305 int
 306 be_visitor_xplicit_pre_proc::visit_eventtype (be_eventtype *node)
 307 {
 308   // Eventtype can't be declared inside a home, no need to call
 309   // check_and_store().
 310   this->type_holder_ = node;
 311
 312   return 0;
 313 }
 314
 315 int
 316 be_visitor_xplicit_pre_proc::visit_structure (be_structure *node)
 317 {
 318   if (this->ref_type_)
 319     {
 320       this->check_and_store (node);
 321       return 0;
 322     }
 323
 324   UTL_ScopedName sn (node->local_name (), nullptr);
 325
 326   be_structure *added_struct = nullptr;
 327   ACE_NEW_RETURN (added_struct,
 328                   be_structure (&sn,
 329                                 false,
 330                                 false),
 331                   -1);
 332
 333   idl_global->scopes ().top ()->add_to_scope (added_struct);
 334   idl_global->scopes ().push (added_struct);
 335
 336   if (this->visit_scope (node) != 0)
 337     {
 338       ACE_ERROR_RETURN ((LM_ERROR,
 339                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 340                          ACE_TEXT ("visit_structure - code generation ")
 341                          ACE_TEXT ("for scope failed\n")),
 342                         -1);
 343     }
 344
 345   return 0;
 346 }
 347
 348 int
 349 be_visitor_xplicit_pre_proc::visit_structure_fwd (
 350   be_structure_fwd *node)
 351 {
 352   UTL_ScopedName sn (node->local_name (), nullptr);
 353
 354   be_structure *dummy = nullptr;
 355   ACE_NEW_RETURN (dummy,
 356                   be_structure (&sn,
 357                                 false,
 358                                 false),
 359                   -1);
 360
 361   be_structure_fwd *added_struct_fwd = nullptr;
 362   ACE_NEW_RETURN (added_struct_fwd,
 363                   be_structure_fwd (dummy,
 364                                     &sn),
 365                   -1);
 366
 367   dummy->fwd_decl (added_struct_fwd);
 368
 369   idl_global->scopes ().top ()->add_to_scope (added_struct_fwd);
 370
 371   return 0;
 372 }
 373
 374 int
 375 be_visitor_xplicit_pre_proc::visit_exception (be_exception *node)
 376 {
 377   UTL_ScopedName sn (node->local_name (), nullptr);
 378
 379   be_exception *added_excep = nullptr;
 380   ACE_NEW_RETURN (added_excep,
 381                   be_exception (&sn,
 382                                 false,
 383                                 false),
 384                   -1);
 385
 386   idl_global->scopes ().top ()->add_to_scope (added_excep);
 387   idl_global->scopes ().push (added_excep);
 388
 389   if (this->visit_scope (node) != 0)
 390     {
 391       ACE_ERROR_RETURN ((LM_ERROR,
 392                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 393                          ACE_TEXT ("visit_exception - code generation ")
 394                          ACE_TEXT ("for scope failed\n")),
 395                         -1);
 396     }
 397
 398   idl_global->scopes ().pop ();
 399
 400   return 0;
 401 }
 402
 403 int
 404 be_visitor_xplicit_pre_proc::visit_enum (be_enum *node)
 405 {
 406   if (this->ref_type_)
 407     {
 408       this->check_and_store (node);
 409       return 0;
 410     }
 411
 412   UTL_ScopedName sn (node->local_name (), nullptr);
 413
 414   be_enum *added_enum = nullptr;
 415   ACE_NEW_RETURN (added_enum,
 416                   be_enum (&sn,
 417                            false,
 418                            false),
 419                   -1);
 420
 421   idl_global->scopes ().top ()->add_to_scope (added_enum);
 422   idl_global->scopes ().push (added_enum);
 423
 424   if (this->visit_scope (node) != 0)
 425     {
 426       ACE_ERROR_RETURN ((LM_ERROR,
 427                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 428                          ACE_TEXT ("visit_enum - code generation ")
 429                          ACE_TEXT ("for scope failed\n")),
 430                         -1);
 431     }
 432
 433   return 0;
 434 }
 435
 436 int
 437 be_visitor_xplicit_pre_proc::visit_field (be_field *node)
 438 {
 439   this->ref_type_ = true;
 440
 441   be_type *ft =
 442     dynamic_cast<be_type*> (node->field_type ());
 443
 444   if (ft->accept (this) != 0)
 445     {
 446       ACE_ERROR_RETURN ((LM_ERROR,
 447                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 448                          ACE_TEXT ("visit_field - code generation ")
 449                          ACE_TEXT ("for field type failed\n")),
 450                         -1);
 451     }
 452
 453   this->ref_type_ = false;
 454
 455   UTL_ScopedName sn (node->local_name (), nullptr);
 456   AST_Type *field_type =
 457     dynamic_cast<AST_Type*> (this->type_holder_);
 458
 459   be_field *added_field = nullptr;
 460   ACE_NEW_RETURN (added_field,
 461                   be_field (field_type,
 462                             &sn,
 463                             node->visibility ()),
 464                   -1);
 465
 466   idl_global->scopes ().top ()->add_to_scope (added_field);
 467
 468   return 0;
 469 }
 470
 471 int
 472 be_visitor_xplicit_pre_proc::visit_attribute (be_attribute *node)
 473 {
 474   be_type *ft =
 475     dynamic_cast<be_type*> (node->field_type ());
 476
 477   this->ref_type_ = true;
 478
 479   if (ft->accept (this) != 0)
 480     {
 481       ACE_ERROR_RETURN ((LM_ERROR,
 482                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 483                          ACE_TEXT ("visit_attribute - code generation ")
 484                          ACE_TEXT ("for attribute type failed\n")),
 485                         -1);
 486     }
 487
 488   this->ref_type_ = false;
 489
 490   AST_Type *attr_type =
 491     dynamic_cast<AST_Type*> (this->type_holder_);
 492
 493   UTL_ScopedName sn (node->local_name (), nullptr);
 494
 495   be_attribute *added_attr = nullptr;
 496   ACE_NEW_RETURN (added_attr,
 497                   be_attribute (node->readonly (),
 498                                 attr_type,
 499                                 &sn,
 500                                 false,
 501                                 false),
 502                   -1);
 503
 504   idl_global->scopes ().top ()->add_to_scope (added_attr);
 505
 506   return 0;
 507 }
 508
 509 int
 510 be_visitor_xplicit_pre_proc::visit_union (be_union *node)
 511 {
 512   if (this->ref_type_)
 513     {
 514       this->check_and_store (node);
 515       return 0;
 516     }
 517
 518   be_type *ud =
 519     dynamic_cast<be_type*> (node->disc_type ());
 520
 521   this->ref_type_ = true;
 522
 523   if (ud->accept (this) != 0)
 524     {
 525       ACE_ERROR_RETURN ((LM_ERROR,
 526                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 527                          ACE_TEXT ("visit_union - code generation ")
 528                          ACE_TEXT ("for discriminator type failed\n")),
 529                         -1);
 530     }
 531
 532   this->ref_type_ = false;
 533
 534   AST_ConcreteType *disc =
 535     dynamic_cast<AST_ConcreteType*> (this->type_holder_);
 536
 537   UTL_ScopedName sn (node->local_name (), nullptr);
 538
 539   be_union *added_union = nullptr;
 540   ACE_NEW_RETURN (added_union,
 541                   be_union (disc,
 542                             &sn,
 543                             false,
 544                             false),
 545                   -1);
 546
 547   idl_global->scopes ().top ()->add_to_scope (added_union);
 548   idl_global->scopes ().push (added_union);
 549
 550   if (this->visit_scope (node) != 0)
 551     {
 552       ACE_ERROR_RETURN ((LM_ERROR,
 553                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 554                          ACE_TEXT ("visit_union - code generation ")
 555                          ACE_TEXT ("for scope failed\n")),
 556                         -1);
 557     }
 558
 559   return 0;
 560 }
 561
 562 int
 563 be_visitor_xplicit_pre_proc::visit_union_fwd (be_union_fwd *node)
 564 {
 565   UTL_ScopedName sn (node->local_name (), nullptr);
 566
 567   be_union *dummy = nullptr;
 568   ACE_NEW_RETURN (dummy,
 569                   be_union (nullptr,
 570                             &sn,
 571                             false,
 572                             false),
 573                   -1);
 574
 575   be_union_fwd *added_union_fwd = nullptr;
 576   ACE_NEW_RETURN (added_union_fwd,
 577                   be_union_fwd (dummy,
 578                                 &sn),
 579                   -1);
 580
 581   dummy->fwd_decl (added_union_fwd);
 582
 583   idl_global->scopes ().top ()->add_to_scope (added_union_fwd);
 584
 585   return 0;
 586 }
 587
 588 int
 589 be_visitor_xplicit_pre_proc::visit_union_branch (
 590   be_union_branch *node)
 591 {
 592   be_type *ft =
 593     dynamic_cast<be_type*> (node->field_type ());
 594
 595   this->ref_type_ = true;
 596
 597   if (ft->accept (this) != 0)
 598     {
 599       ACE_ERROR_RETURN ((LM_ERROR,
 600                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 601                          ACE_TEXT ("visit_union_branch - code generation ")
 602                          ACE_TEXT ("for branch type failed\n")),
 603                         -1);
 604     }
 605
 606   this->ref_type_ = false;
 607
 608   AST_Type *bt =
 609     dynamic_cast<AST_Type*> (this->type_holder_);
 610
 611   UTL_ScopedName sn (node->local_name (), nullptr);
 612
 613   // The union branch owns its label list so we have to copy it.
 614   UTL_LabelList *ll = node->labels ()->copy ();
 615
 616   be_union_branch *added_branch = nullptr;
 617   ACE_NEW_RETURN (added_branch,
 618                   be_union_branch (ll, bt, &sn),
 619                   -1);
 620
 621   // fe_add_union_branch() does necessary things besides calling
 622   // add_to_scope() so we need to reuse it.
 623
 624   be_union *u =
 625     dynamic_cast<be_union*> (idl_global->scopes ().top ());
 626
 627   u->be_add_union_branch (added_branch);
 628
 629   return 0;
 630 }
 631
 632 int
 633 be_visitor_xplicit_pre_proc::visit_union_label (be_union_label *)
 634 {
 635   return 0;
 636 }
 637
 638 int
 639 be_visitor_xplicit_pre_proc::visit_constant (be_constant *node)
 640 {
 641   if (this->ref_type_)
 642     {
 643       this->check_and_store (node);
 644       return 0;
 645     }
 646
 647   AST_Expression *new_v = nullptr;
 648   ACE_NEW_RETURN (new_v,
 649                   AST_Expression (node->constant_value (),
 650                                   node->et ()),
 651                   -1);
 652
 653   UTL_ScopedName sn (node->local_name (), nullptr);
 654
 655   be_constant *added_const = nullptr;
 656   ACE_NEW_RETURN (added_const,
 657                   be_constant (node->et (),
 658                                new_v,
 659                                &sn),
 660                   -1);
 661
 662   idl_global->scopes ().top ()->add_to_scope (added_const);
 663
 664   return 0;
 665 }
 666
 667 int
 668 be_visitor_xplicit_pre_proc::visit_enum_val (be_enum_val *node)
 669 {
 670   if (this->ref_type_)
 671     {
 672       this->type_holder_ = node;
 673       return 0;
 674     }
 675
 676   UTL_ScopedName sn (node->local_name (), nullptr);
 677
 678   be_enum_val *added_enum_val = nullptr;
 679   ACE_NEW_RETURN (added_enum_val,
 680                   be_enum_val (node->constant_value ()->ev ()->u.ulval,
 681                                &sn),
 682                   -1);
 683
 684   idl_global->scopes ().top ()->add_to_scope (added_enum_val);
 685
 686   return 0;
 687 }
 688
 689 int
 690 be_visitor_xplicit_pre_proc::visit_array (be_array *node)
 691 {
 692   be_type *bt =
 693     dynamic_cast<be_type*> (node->base_type ());
 694
 695   bool tmp = this->ref_type_;
 696   this->ref_type_ = true;
 697
 698   if (bt->accept (this) != 0)
 699     {
 700       ACE_ERROR_RETURN ((LM_ERROR,
 701                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 702                          ACE_TEXT ("visit_array - code generation ")
 703                          ACE_TEXT ("for base type failed\n")),
 704                         -1);
 705     }
 706
 707   this->ref_type_ = tmp;
 708
 709   AST_Expression *v = nullptr;
 710   UTL_ExprList *v_list = nullptr;
 711
 712   for (ACE_CDR::ULong i = 0; i < node->n_dims (); ++i)
 713     {
 714       ACE_NEW_RETURN (v,
 715                       AST_Expression (node->dims ()[i],
 716                                       AST_Expression::EV_ulong),
 717                       -1);
 718
 719       UTL_ExprList *el = nullptr;
 720       ACE_NEW_RETURN (el,
 721                       UTL_ExprList (v, nullptr),
 722                       -1);
 723
 724       if (v_list == nullptr)
 725         {
 726           v_list = el;
 727         }
 728       else
 729         {
 730           v_list->nconc (el);
 731         }
 732     }
 733
 734   UTL_ScopedName sn (node->local_name (), nullptr);
 735
 736   be_array *added_array = nullptr;
 737   ACE_NEW_RETURN (added_array,
 738                   be_array (&sn,
 739                             node->n_dims (),
 740                             v_list,
 741                             false,
 742                             false),
 743                   -1);
 744
 745   // No need to add this new node to any scope - it's anonymous
 746   // and owned by the node that references it.
 747
 748   if (v_list != nullptr)
 749     {
 750       v_list->destroy ();
 751       delete v_list;
 752       v_list = nullptr;
 753     }
 754
 755   AST_Type *base_type =
 756     dynamic_cast<AST_Type*> (this->type_holder_);
 757
 758   added_array->set_base_type (base_type);
 759
 760   this->type_holder_ = added_array;
 761
 762   return 0;
 763 }
 764
 765 int
 766 be_visitor_xplicit_pre_proc::visit_sequence (be_sequence *node)
 767 {
 768   be_type *bt =
 769     dynamic_cast<be_type*> (node->base_type ());
 770
 771   bool tmp = this->ref_type_;
 772   this->ref_type_ = true;
 773
 774   if (bt->accept (this) != 0)
 775     {
 776       ACE_ERROR_RETURN ((LM_ERROR,
 777                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 778                          ACE_TEXT ("visit_sequence - code generation ")
 779                          ACE_TEXT ("for element type failed\n")),
 780                         -1);
 781     }
 782
 783   this->ref_type_ = tmp;
 784
 785   AST_Expression *v = node->max_size ();
 786
 787   AST_Expression *bound = nullptr;
 788   ACE_NEW_RETURN (bound,
 789                   AST_Expression (v,
 790                                   AST_Expression::EV_ulong),
 791                   -1);
 792
 793   Identifier id ("sequence");
 794   UTL_ScopedName sn (&id, nullptr);
 795
 796   AST_Type *ft =
 797     dynamic_cast<AST_Type*> (this->type_holder_);
 798
 799   ACE_NEW_RETURN (this->type_holder_,
 800                   be_sequence (bound,
 801                                ft,
 802                                &sn,
 803                                false,
 804                                false),
 805                   -1);
 806
 807   // No need to add this new node to any scope - it's anonymous
 808   // and owned by the node that references it.
 809
 810   return 0;
 811 }
 812
 813 int
 814 be_visitor_xplicit_pre_proc::visit_string (be_string *node)
 815 {
 816   if (this->ref_type_)
 817     {
 818       this->check_and_store (node);
 819       return 0;
 820     }
 821
 822   AST_Expression *b = node->max_size ();
 823
 824   if (b->ev ()->u.ulval == 0)
 825     {
 826       this->type_holder_ = node;
 827       return 0;
 828     }
 829
 830   AST_Expression *bound = nullptr;
 831   ACE_NEW_RETURN (bound,
 832                   AST_Expression (b,
 833                                   AST_Expression::EV_ulong),
 834                   -1);
 835
 836   Identifier id ("string");
 837   UTL_ScopedName sn (&id, nullptr);
 838
 839   ACE_NEW_RETURN (this->type_holder_,
 840                   be_string (AST_Decl::NT_string,
 841                              &sn,
 842                              bound,
 843                              node->width ()),
 844                   -1);
 845
 846   return 0;
 847 }
 848
 849 int
 850 be_visitor_xplicit_pre_proc::visit_typedef (be_typedef *node)
 851 {
 852   if (this->ref_type_)
 853     {
 854       this->check_and_store (node);
 855       return 0;
 856     }
 857
 858   be_type *t =
 859     dynamic_cast<be_type*> (node->field_type ());
 860
 861   this->ref_type_ = true;
 862
 863   if (t->accept (this) != 0)
 864     {
 865       ACE_ERROR_RETURN ((LM_ERROR,
 866                          ACE_TEXT ("be_visitor_xplicit_pre_proc::")
 867                          ACE_TEXT ("visit_typedef - code generation ")
 868                          ACE_TEXT ("for base type failed\n")),
 869                         -1);
 870     }
 871
 872   this->ref_type_ = false;
 873
 874   UTL_ScopedName sn (node->local_name (), nullptr);
 875   AST_Type *bt =
 876     dynamic_cast<AST_Type*> (this->type_holder_);
 877
 878   be_typedef *added_typedef = nullptr;
 879   ACE_NEW_RETURN (added_typedef,
 880                   be_typedef (bt,
 881                               &sn,
 882                               false,
 883                               false),
 884                   -1);
 885
 886   idl_global->scopes ().top ()->add_to_scope (added_typedef);
 887
 888   return 0;
 889 }
 890
 891 int
 892 be_visitor_xplicit_pre_proc::visit_native (be_native *node)
 893 {
 894   if (this->ref_type_)
 895     {
 896       this->check_and_store (node);
 897       return 0;
 898     }
 899
 900   UTL_ScopedName sn (node->local_name (), nullptr);
 901
 902   be_native *added_native = nullptr;
 903   ACE_NEW_RETURN (added_native,
 904                   be_native (&sn),
 905                   -1);
 906
 907   idl_global->scopes ().top ()->add_to_scope (added_native);
 908
 909   return 0;
 910 }
 911
 912 int
 913 be_visitor_xplicit_pre_proc::visit_predefined_type (
 914   be_predefined_type *node)
 915 {
 916   this->type_holder_ = node;
 917
 918   return 0;
 919 }
 920
 921 be_interface *
 922 be_visitor_xplicit_pre_proc::xplicit () const
 923 {
 924   return this->xplicit_;
 925 }
 926
 927 void
 928 be_visitor_xplicit_pre_proc::check_and_store (AST_Decl *node)
 929 {
 930   UTL_ScopedName *tmpl_tail =
 931     this->xplicit_iface_rel_name (node);
 932
 933   if (tmpl_tail != nullptr)
 934     {
 935       AST_Decl *d =
 936         idl_global->scopes ().top ()->lookup_by_name (
 937           tmpl_tail,
 938           true);
 939
 940       this->type_holder_ = d;
 941
 942       tmpl_tail->destroy ();
 943       delete tmpl_tail;
 944       tmpl_tail = nullptr;
 945     }
 946   else
 947     {
 948       this->type_holder_ = node;
 949     }
 950 }
 951
 952 UTL_ScopedName *
 953 be_visitor_xplicit_pre_proc::xplicit_iface_rel_name (AST_Decl *d)
 954 {
 955   AST_Decl *tmp = d;
 956   ACE_CString name (d->full_name ());
 957
 958   while (tmp != nullptr)
 959     {
 960       if (dynamic_cast<be_home*> (tmp) != nullptr)
 961         {
 962           ACE_CString head (tmp->local_name ()->get_string ());
 963
 964           ACE_CString::size_type start = name.find (head) + 2;
 965
 966           ACE_CString tail (name.substr (start + head.length ()));
 967
 968           return FE_Utils::string_to_scoped_name (tail.c_str ());
 969         }
 970
 971       tmp = ScopeAsDecl (tmp->defined_in ());
 972     }
 973
 974   return nullptr;
 975 }