TAO/TAO_IDL/be/be_visitor_valuebox/field_ch.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    field_ch.cpp
   5  *
   6  *   Visitor for the structure fields in valuebox class.
   7  *   This one generates code for access to structure members
   8  *   in the client header.
   9  *
  10  *   Based on be_visitor_union_branch/public_ch.  In general we
  11  *   generate the same method signatures as that visitor but cannot
  12  *   use it directly because a valuebox is not a scope and because
  13  *   the structure is visited prior to visiting the valuebox.
  14  *
  15  *  @author Gary Maxey
  16  */
  17 //=============================================================================
  18
  19 #include "valuebox.h"
  20
  21 be_visitor_valuebox_field_ch::be_visitor_valuebox_field_ch (
  22     be_visitor_context *ctx
  23   )
  24   : be_visitor_decl (ctx)
  25 {
  26 }
  27
  28 be_visitor_valuebox_field_ch::~be_visitor_valuebox_field_ch (void)
  29 {
  30 }
  31
  32 int
  33 be_visitor_valuebox_field_ch::visit_field (be_field *node)
  34 {
  35   be_type *bt = dynamic_cast<be_type*> (node->field_type ());
  36
  37   if (!bt)
  38     {
  39       ACE_ERROR_RETURN ((LM_ERROR,
  40                          "(%N:%l) be_visitor_valuebox_field_ch::"
  41                          "visit_field - "
  42                          "Bad field type\n"
  43                          ),
  44                         -1);
  45     }
  46
  47   this->ctx_->node (node);
  48
  49   if (bt->accept (this) == -1)
  50     {
  51       ACE_ERROR_RETURN ((LM_ERROR,
  52                          "(%N:%l) be_visitor_valuebox_field_ch::"
  53                          "visit_union_branch - "
  54                          "codegen for valuebox field failed\n"),
  55                         -1);
  56     }
  57
  58   return 0;
  59 }
  60
  61 // Visit operations on all possible data types  that a union_branch can be.
  62
  63 int
  64 be_visitor_valuebox_field_ch::visit_array (be_array *node)
  65 {
  66   be_decl *field = this->ctx_->node ();
  67   be_type *bt = 0;
  68
  69   // Check if we are visiting this via a visit to a typedef node.
  70   if (this->ctx_->alias ())
  71     {
  72       bt = this->ctx_->alias ();
  73     }
  74   else
  75     {
  76       bt = node;
  77     }
  78
  79   if (!field)
  80     {
  81       ACE_ERROR_RETURN ((LM_ERROR,
  82                          "(%N:%l) be_visitor_valuebox_field_ch::"
  83                          "visit_array - "
  84                          "bad context information\n"),
  85                         -1);
  86     }
  87
  88   TAO_OutStream *os = this->ctx_->stream ();
  89
  90
  91   char fname [NAMEBUFSIZE];
  92   ACE_OS::memset (fname,
  93                   '\0',
  94                   NAMEBUFSIZE);
  95
  96   if (bt->node_type () != AST_Decl::NT_typedef)
  97     {
  98       // For anonymous arrays ...
  99       // We have to generate a name for us that has an underscope prepended to
 100       // our local name. This needs to be inserted after the parent's name.
 101       if (bt->is_nested ())
 102         {
 103           be_decl *parent =
 104                  dynamic_cast<be_scope*> (bt->defined_in ())->decl ();
 105           ACE_OS::sprintf (fname,
 106                            "%s::_%s",
 107                            parent->full_name (),
 108                            bt->local_name ()->get_string ());
 109         }
 110       else
 111         {
 112           ACE_OS::sprintf (fname,
 113                            "_%s",
 114                            bt->full_name ());
 115         }
 116     }
 117   else
 118     { // Typedefed node.
 119       ACE_OS::sprintf (fname,
 120                        "%s",
 121                        bt->full_name ());
 122     }
 123
 124
 125   TAO_INSERT_COMMENT (os);
 126
 127   *os << "void " << field->local_name () << " (" << fname << ");" << be_nl;
 128
 129   *os << "const " << fname << "_slice *" << field->local_name ()
 130       << " (void) const;" << be_nl;
 131
 132   return 0;
 133 }
 134
 135 int
 136 be_visitor_valuebox_field_ch::visit_enum (be_enum *node)
 137 {
 138   be_decl *field = this->ctx_->node ();
 139   be_type *bt = 0;
 140
 141   // Check if we are visiting this via a visit to a typedef node.
 142   if (this->ctx_->alias ())
 143     {
 144       bt = this->ctx_->alias ();
 145     }
 146   else
 147     {
 148       bt = node;
 149     }
 150
 151   if (!field)
 152     {
 153       ACE_ERROR_RETURN ((LM_ERROR,
 154                          "(%N:%l) be_visitor_valuebox_field_ch::"
 155                          "visit_enum - "
 156                          "bad context information\n"),
 157                         -1);
 158     }
 159
 160   TAO_OutStream *os = this->ctx_->stream ();
 161
 162   TAO_INSERT_COMMENT (os);
 163
 164   this->emit_member_set (field, bt, "", "");
 165   this->emit_member_get (field, bt, "", "", "const");
 166
 167   return 0;
 168 }
 169
 170 int
 171 be_visitor_valuebox_field_ch::visit_interface (be_interface *node)
 172 {
 173   be_decl *field = this->ctx_->node ();
 174   be_type *bt = 0;
 175
 176   // Check if we are visiting this via a visit to a typedef node.
 177   if (this->ctx_->alias ())
 178     {
 179       bt = this->ctx_->alias ();
 180     }
 181   else
 182     {
 183       bt = node;
 184     }
 185
 186   if (!field)
 187     {
 188       ACE_ERROR_RETURN ((LM_ERROR,
 189                          "(%N:%l) be_visitor_valuebox_field_ch::"
 190                          "visit_interface - "
 191                          "bad context information\n"),
 192                         -1);
 193     }
 194
 195   TAO_OutStream *os = this->ctx_->stream ();
 196
 197   TAO_INSERT_COMMENT (os);
 198
 199   this->emit_member_set (field, bt, "", "_ptr");
 200   this->emit_member_get (field, bt, "", "_ptr", "const");
 201
 202   return 0;
 203 }
 204
 205 int
 206 be_visitor_valuebox_field_ch::visit_interface_fwd (be_interface_fwd *node)
 207 {
 208   be_decl *field = this->ctx_->node ();
 209   be_type *bt = 0;
 210
 211   // Check if we are visiting this via a visit to a typedef node.
 212   if (this->ctx_->alias ())
 213     {
 214       bt = this->ctx_->alias ();
 215     }
 216   else
 217     {
 218       bt = node;
 219     }
 220
 221   if (!field)
 222     {
 223       ACE_ERROR_RETURN ((LM_ERROR,
 224                          "(%N:%l) be_visitor_valuebox_field_ch::"
 225                          "visit_interface_fwd - "
 226                          "bad context information\n"),
 227                         -1);
 228     }
 229
 230   TAO_OutStream *os = this->ctx_->stream ();
 231
 232   TAO_INSERT_COMMENT (os);
 233
 234   this->emit_member_set (field, bt, "", "_ptr");
 235   this->emit_member_get (field, bt, "", "_ptr", "const");
 236
 237   return 0;
 238 }
 239
 240 int
 241 be_visitor_valuebox_field_ch::visit_valuetype (be_valuetype *)
 242 {
 243   // Valuetype is not a valid component of a valuebox
 244   return 0;
 245 }
 246
 247 int
 248 be_visitor_valuebox_field_ch::visit_valuetype_fwd (be_valuetype_fwd *)
 249 {
 250   // Valuetype is not a valid component of a valuebox
 251   return 0;
 252 }
 253
 254 int
 255 be_visitor_valuebox_field_ch::visit_predefined_type (be_predefined_type *node)
 256 {
 257   be_decl *field = this->ctx_->node ();
 258   be_type *bt = 0;
 259
 260   // Check if we are visiting this via a visit to a typedef node.
 261   if (this->ctx_->alias ())
 262     {
 263       bt = this->ctx_->alias ();
 264     }
 265   else
 266     {
 267       bt = node;
 268     }
 269
 270   if (!field)
 271     {
 272       ACE_ERROR_RETURN ((LM_ERROR,
 273                          "(%N:%l) be_visitor_valuebox_field_ch::"
 274                          "visit_predefined_type - "
 275                          "bad context information\n"),
 276                         -1);
 277     }
 278
 279   TAO_OutStream *os = this->ctx_->stream ();
 280
 281   TAO_INSERT_COMMENT (os);
 282
 283   switch (node->pt ())
 284     {
 285     case AST_PredefinedType::PT_pseudo:
 286     case AST_PredefinedType::PT_object:
 287       this->emit_member_set (field, bt, " ::", "_ptr");
 288       this->emit_member_get (field, bt, " ::", "_ptr", "const");
 289
 290       break;
 291     case AST_PredefinedType::PT_any:
 292       this->emit_member_set (field, bt, "const ::", " &");
 293       this->emit_member_get (field, bt, "const ::", " &", "const");
 294       this->emit_member_get (field, bt, " ::", " &", "");
 295       break;
 296     case AST_PredefinedType::PT_void:
 297       break;
 298     default:
 299       this->emit_member_set (field, bt, " ::", "");
 300       this->emit_member_get (field, bt, " ::", "", "const");
 301     }
 302
 303   return 0;
 304 }
 305
 306 int
 307 be_visitor_valuebox_field_ch::visit_sequence (be_sequence *node)
 308 {
 309   be_decl *field = this->ctx_->node ();
 310   be_type *bt = 0;
 311
 312   // Check if we are visiting this via a visit to a typedef node.
 313   if (this->ctx_->alias ())
 314     {
 315       bt = this->ctx_->alias ();
 316     }
 317   else
 318     {
 319       bt = node;
 320     }
 321
 322   if (!field)
 323     {
 324       ACE_ERROR_RETURN ((LM_ERROR,
 325                          "(%N:%l) be_visitor_valuebox_field_ch::"
 326                          "visit_sequence - "
 327                          "bad context information\n"),
 328                         -1);
 329     }
 330
 331   TAO_OutStream *os = this->ctx_->stream ();
 332
 333   TAO_INSERT_COMMENT (os);
 334
 335   this->emit_member_set (field, bt, "const ", " &");
 336   this->emit_member_get (field, bt, "const ", " &", "const");
 337   this->emit_member_get (field, bt, "", " &", "");
 338
 339
 340   return 0;
 341 }
 342
 343 int
 344 be_visitor_valuebox_field_ch::visit_string (be_string *node)
 345 {
 346   be_decl *field = this->ctx_->node ();
 347   be_type *bt = 0;
 348
 349   // Check if we are visiting this via a visit to a typedef node.
 350   if (this->ctx_->alias ())
 351     {
 352       bt = this->ctx_->alias ();
 353     }
 354   else
 355     {
 356       bt = node;
 357     }
 358
 359   if (!field)
 360     {
 361       ACE_ERROR_RETURN ((LM_ERROR,
 362                          "(%N:%l) be_visitor_valuebox_field_ch::"
 363                          "visit_string - "
 364                          "bad context information\n"),
 365                         -1);
 366     }
 367
 368   TAO_OutStream *os = this->ctx_->stream ();
 369
 370   TAO_INSERT_COMMENT (os);
 371
 372   this->emit_member_set (field, bt, "", "");
 373   this->emit_member_set (field, bt, "const ", "");
 374
 375   const char *string_type = "";
 376   if (node->node_type () == AST_Decl::NT_string)
 377     {
 378       string_type = "String";
 379     }
 380   else if (node->node_type () == AST_Decl::NT_wstring)
 381     {
 382       string_type = "WString";
 383     }
 384
 385   *os << "void " << field->local_name ()
 386       << " (const ::CORBA::" << string_type << "_var &);" << be_nl;
 387
 388   this->emit_member_get (field, bt, "const ", "", "const");
 389
 390   return 0;
 391 }
 392
 393 int
 394 be_visitor_valuebox_field_ch::visit_structure (be_structure *node)
 395 {
 396   be_decl *field = this->ctx_->node ();
 397   be_type *bt = 0;
 398
 399   // Check if we are visiting this via a visit to a typedef node.
 400   if (this->ctx_->alias ())
 401     {
 402       bt = this->ctx_->alias ();
 403     }
 404   else
 405     {
 406       bt = node;
 407     }
 408
 409   if (!field)
 410     {
 411       ACE_ERROR_RETURN ((LM_ERROR,
 412                          "(%N:%l) be_visitor_valuebox_field_ch::"
 413                          "visit_structure - "
 414                          "bad context information\n"),
 415                         -1);
 416     }
 417
 418   TAO_OutStream *os = this->ctx_->stream ();
 419
 420   TAO_INSERT_COMMENT (os);
 421
 422   this->emit_member_set (field, bt, "const ", " &");
 423   this->emit_member_get (field, bt, "const ", " &", "const");
 424   this->emit_member_get (field, bt, "", " &", "");
 425
 426   return 0;
 427 }
 428
 429 int
 430 be_visitor_valuebox_field_ch::visit_typedef (be_typedef *node)
 431 {
 432   this->ctx_->alias (node);
 433
 434   // Make a decision based on the primitive base type.
 435   be_type *bt = node->primitive_base_type ();
 436
 437   if (!bt || (bt->accept (this) == -1))
 438     {
 439       ACE_ERROR_RETURN ((LM_ERROR,
 440                          "(%N:%l) be_visitor_union_branch_spec_ch::"
 441                          "visit_typedef - "
 442                          "Bad primitive type\n"),
 443                         -1);
 444     }
 445
 446   this->ctx_->alias (0);
 447   return 0;
 448 }
 449
 450 int
 451 be_visitor_valuebox_field_ch::visit_union (be_union *node)
 452 {
 453   be_decl *field = this->ctx_->node ();
 454   be_type *bt = 0;
 455
 456   // Check if we are visiting this via a visit to a typedef node.
 457   if (this->ctx_->alias ())
 458     {
 459       bt = this->ctx_->alias ();
 460     }
 461   else
 462     {
 463       bt = node;
 464     }
 465
 466   if (!field)
 467     {
 468       ACE_ERROR_RETURN ((LM_ERROR,
 469                          "(%N:%l) be_visitor_valuebox_field_ch::"
 470                          "visit_union - "
 471                          "bad context information\n"
 472                          ),
 473                         -1);
 474     }
 475
 476   TAO_OutStream *os = this->ctx_->stream ();
 477
 478
 479   TAO_INSERT_COMMENT (os);
 480
 481   this->emit_member_set (field, bt, "const ", " &");
 482   this->emit_member_get (field, bt, "const ", " &", "const");
 483   this->emit_member_get (field, bt, "", " &", "");
 484
 485   return 0;
 486 }
 487
 488
 489 void
 490 be_visitor_valuebox_field_ch::emit_member_set (be_decl *field,
 491                                                be_type *field_type,
 492                                                const char *const_arg,
 493                                                const char *arg_modifier)
 494 {
 495   TAO_OutStream *os = this->ctx_->stream ();
 496
 497   *os << "void " << field->local_name ()
 498       << " (" << const_arg << field_type->name () << arg_modifier << ");"
 499       << be_nl;
 500
 501 }
 502
 503
 504 void
 505 be_visitor_valuebox_field_ch::emit_member_get (be_decl *field,
 506                                                be_type *field_type,
 507                                                const char *const_prefix,
 508                                                const char *type_suffix,
 509                                                const char *const_method)
 510 {
 511   TAO_OutStream *os = this->ctx_->stream ();
 512
 513   *os << const_prefix << field_type->name () << type_suffix << " "
 514       << field->local_name () << " (void) " << const_method << ";" << be_nl;
 515 }