TAO/TAO_IDL/be/be_visitor_attribute/attribute.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    attribute.cpp
   5  *
   6  *  Visitor for generation of code for Attribute
   7  *
   8  *  @author Aniruddha Gokhale
   9  */
  10 //=============================================================================
  11
  12 #include "attribute.h"
  13
  14 // Attribute gets mapped to one or possibly two operations based on whether
  15 // it is readonly or not. The two operations "get" and "set" the value of the
  16 // attribute.
  17 //
  18 // code generation for attributes is achieved by mapping an attribute node to
  19 // a corresponding operation node. The reason is that we do not want to
  20 // duplicate the code. However, an attribute node and an operation node have
  21 // different interfaces. Hence we need some form of an adapter that can take us
  22 // from an attribute node to an operation node. The following paragraph
  23 // describes how this is accomplished.
  24 //
  25 // For a "get" operation on the attribute, we create an operation node with the
  26 // same name as the attribute and a return type which is the same as the type
  27 // of the attribute. This operation has no arguments.
  28 //
  29 // For a "set" operation on the attribute (if it is not readonly), we create an
  30 // operation node with a "void" return type and an "in" parameter of the same
  31 // type as the attribute.
  32
  33 // In both cases the context will hold sufficient information to indicate that
  34 // the operation node is really an attribute node.
  35
  36 // *************************************************************************
  37 // primary visitor for "attribute". The context state decides the next state
  38 // *************************************************************************
  39
  40 be_visitor_attribute::be_visitor_attribute (be_visitor_context *ctx)
  41   : be_visitor_decl (ctx),
  42     for_facets_ (false),
  43     op_scope_ (0),
  44     exec_class_extension_ ("_exec_i")
  45 {
  46 }
  47
  48 be_visitor_attribute::~be_visitor_attribute (void)
  49 {
  50 }
  51
  52 int
  53 be_visitor_attribute::visit_attribute (be_attribute *node)
  54 {
  55   this->ctx_->node (node);
  56   this->ctx_->attribute (node);
  57
  58   UTL_Scope *s = node->defined_in ();
  59   AST_Decl *d = ScopeAsDecl (s);
  60   ACE_CString op_name (this->ctx_->port_prefix ());
  61   op_name += node->local_name ()->get_string ();
  62   Identifier *op_id = 0;
  63   ACE_NEW_RETURN (op_id,
  64                   Identifier (op_name.c_str ()),
  65                   -1);
  66
  67   UTL_ScopedName *op_ln = 0;
  68   ACE_NEW_RETURN (op_ln,
  69                   UTL_ScopedName (op_id, 0),
  70                   -1);
  71
  72   UTL_ScopedName *op_sn =
  73     static_cast<UTL_ScopedName *> (d->name ()->copy ());
  74   op_sn->nconc (op_ln);
  75
  76   // first the "get" operation
  77   be_operation get_op (node->field_type (),
  78                        AST_Operation::OP_noflags,
  79                        0,
  80                        node->is_local (),
  81                        node->is_abstract ());
  82
  83   get_op.set_defined_in (s);
  84   get_op.set_name (op_sn);
  85   UTL_ExceptList *get_exceptions = node->get_get_exceptions ();
  86
  87   if (0 != get_exceptions)
  88     {
  89       get_op.be_add_exceptions (get_exceptions->copy ());
  90     }
  91
  92   be_visitor_context ctx (*this->ctx_);
  93   int status = 1;
  94
  95   switch (this->ctx_->state ())
  96     {
  97     // These two cases are the only ones that could involve a strategy.
  98     case TAO_CodeGen::TAO_ROOT_CH:
  99     case TAO_CodeGen::TAO_INTERFACE_CH:
 100       {
 101         ctx.state (TAO_CodeGen::TAO_OPERATION_CH);
 102         be_visitor_operation_ch visitor (&ctx);
 103         status = get_op.accept (&visitor);
 104         break;
 105       }
 106     case TAO_CodeGen::TAO_ROOT_CS:
 107       {
 108         ctx.state (TAO_CodeGen::TAO_OPERATION_CS);
 109         be_visitor_operation_cs visitor (&ctx);
 110         status = get_op.accept (&visitor);
 111         break;
 112       }
 113     case TAO_CodeGen::TAO_ROOT_SH:
 114       {
 115         be_visitor_operation_sh visitor (&ctx);
 116         status = get_op.accept (&visitor);
 117         break;
 118       }
 119     case TAO_CodeGen::TAO_ROOT_IH:
 120       {
 121         be_visitor_operation_ih visitor (&ctx);
 122         status = get_op.accept (&visitor);
 123         break;
 124       }
 125     case TAO_CodeGen::TAO_ROOT_SS:
 126       {
 127         be_visitor_operation_ss visitor (&ctx);
 128         status = get_op.accept (&visitor);
 129         break;
 130       }
 131     case TAO_CodeGen::TAO_ROOT_IS:
 132       {
 133         be_visitor_operation_is visitor (&ctx);
 134         status = get_op.accept (&visitor);
 135         break;
 136       }
 137     case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SH:
 138       {
 139         be_visitor_operation_proxy_impl_xh visitor (&ctx);
 140         status = get_op.accept (&visitor);
 141         break;
 142       }
 143     case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SS:
 144       {
 145         be_visitor_operation_direct_proxy_impl_ss visitor (&ctx);
 146         status = get_op.accept (&visitor);
 147         break;
 148       }
 149     case TAO_CodeGen::TAO_INTERFACE_SMART_PROXY_CH:
 150       {
 151         be_visitor_operation_smart_proxy_ch visitor (&ctx);
 152         status = get_op.accept (&visitor);
 153         break;
 154       }
 155     case TAO_CodeGen::TAO_INTERFACE_SMART_PROXY_CS:
 156       {
 157         be_visitor_operation_smart_proxy_cs visitor (&ctx);
 158         status = get_op.accept (&visitor);
 159         break;
 160       }
 161     case TAO_CodeGen::TAO_ROOT_TIE_SH:
 162       {
 163         be_visitor_operation_tie_sh visitor (&ctx);
 164         status = get_op.accept (&visitor);
 165         break;
 166       }
 167     case TAO_CodeGen::TAO_ROOT_TIE_SS:
 168       {
 169         be_visitor_operation_tie_ss visitor (&ctx);
 170         status = get_op.accept (&visitor);
 171         break;
 172       }
 173     case TAO_CodeGen::TAO_ROOT_SVTH:
 174     case TAO_CodeGen::TAO_ROOT_SVH:
 175       {
 176         be_visitor_operation_ch visitor (&ctx);
 177         status = get_op.accept (&visitor);
 178         break;
 179       }
 180     case TAO_CodeGen::TAO_ROOT_SVTS:
 181     case TAO_CodeGen::TAO_ROOT_SVS:
 182       {
 183         be_visitor_operation_svs visitor (&ctx);
 184         visitor.scope (this->op_scope_);
 185         status = get_op.accept (&visitor);
 186         break;
 187       }
 188     case TAO_CodeGen::TAO_ROOT_EXH:
 189       {
 190         be_visitor_operation_ch visitor (&ctx);
 191         status = get_op.accept (&visitor);
 192         break;
 193       }
 194     case TAO_CodeGen::TAO_ROOT_EXS:
 195       {
 196         be_visitor_operation_exs visitor (&ctx);
 197         visitor.scope (this->op_scope_);
 198         visitor.class_extension (this->exec_class_extension_.c_str ());
 199         status = get_op.accept (&visitor);
 200         break;
 201       }
 202     case TAO_CodeGen::TAO_ROOT_CNH:
 203     case TAO_CodeGen::TAO_ROOT_CNS:
 204       break;
 205     default:
 206       get_op.destroy ();
 207       return 0;
 208     }
 209
 210   if (status == -1)
 211     {
 212       get_op.destroy ();
 213       ACE_ERROR_RETURN ((LM_ERROR,
 214                          "(%N:%l) be_visitor_attribute::"
 215                          "visit_attribute - "
 216                          "codegen for get_attribute failed\n"),
 217                         -1);
 218     }
 219
 220   // Do nothing for readonly attributes.
 221   if (node->readonly ())
 222     {
 223       get_op.destroy ();
 224       return 0;
 225     }
 226
 227   status = 1;
 228
 229   // Create the set method.
 230   Identifier id ("void");
 231   UTL_ScopedName sn (&id,
 232                      0);
 233
 234   // The return type  is "void".
 235   be_predefined_type rt (AST_PredefinedType::PT_void,
 236                          &sn);
 237
 238   // Argument type is the same as the attribute type.
 239   AST_Argument *arg =
 240     idl_global->gen ()->create_argument (AST_Argument::dir_IN,
 241                                          node->field_type (),
 242                                          node->name ());
 243
 244   arg->set_name ((UTL_IdList *) node->name ()->copy ());
 245
 246   // Create the operation.
 247   be_operation set_op (&rt,
 248                        AST_Operation::OP_noflags,
 249                        0,
 250                        node->is_local (),
 251                        node->is_abstract ());
 252   set_op.set_defined_in (node->defined_in ());
 253   set_op.set_name (static_cast<UTL_ScopedName *> (op_sn->copy ()));
 254   set_op.be_add_argument (arg);
 255
 256   UTL_ExceptList *set_exceptions = node->get_set_exceptions ();
 257
 258   if (0 != set_exceptions)
 259     {
 260       set_op.be_add_exceptions (set_exceptions->copy ());
 261     }
 262
 263   ctx = *this->ctx_;
 264   status = 1;
 265
 266   switch (this->ctx_->state ())
 267     {
 268     // These two cases are the only ones that could involved a strategy.
 269     case TAO_CodeGen::TAO_ROOT_CH:
 270     case TAO_CodeGen::TAO_INTERFACE_CH:
 271       {
 272         ctx.state (TAO_CodeGen::TAO_OPERATION_CH);
 273         be_visitor_operation_ch visitor (&ctx);
 274         status = set_op.accept (&visitor);
 275         break;
 276       }
 277     case TAO_CodeGen::TAO_ROOT_CS:
 278       {
 279         ctx.state (TAO_CodeGen::TAO_OPERATION_CS);
 280         be_visitor_operation_cs visitor (&ctx);
 281         status = set_op.accept (&visitor);
 282         break;
 283       }
 284     case TAO_CodeGen::TAO_ROOT_SH:
 285       {
 286         be_visitor_operation_sh visitor (&ctx);
 287         status = set_op.accept (&visitor);
 288         break;
 289       }
 290     case TAO_CodeGen::TAO_ROOT_IH:
 291       {
 292         be_visitor_operation_ih visitor (&ctx);
 293         status = set_op.accept (&visitor);
 294         break;
 295       }
 296     case TAO_CodeGen::TAO_ROOT_SS:
 297       {
 298         be_visitor_operation_ss visitor (&ctx);
 299         status = set_op.accept (&visitor);
 300         break;
 301       }
 302     case TAO_CodeGen::TAO_ROOT_IS:
 303       {
 304         be_visitor_operation_is visitor (&ctx);
 305         status = set_op.accept (&visitor);
 306         break;
 307       }
 308     case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SH:
 309       {
 310         be_visitor_operation_proxy_impl_xh visitor (&ctx);
 311         status = set_op.accept (&visitor);
 312         break;
 313       }
 314     case TAO_CodeGen::TAO_INTERFACE_DIRECT_PROXY_IMPL_SS:
 315       {
 316         be_visitor_operation_direct_proxy_impl_ss visitor (&ctx);
 317         status = set_op.accept (&visitor);
 318         break;
 319       }
 320     case TAO_CodeGen::TAO_INTERFACE_SMART_PROXY_CH:
 321       {
 322         be_visitor_operation_smart_proxy_ch visitor (&ctx);
 323         status = set_op.accept (&visitor);
 324         break;
 325       }
 326     case TAO_CodeGen::TAO_INTERFACE_SMART_PROXY_CS:
 327       {
 328         be_visitor_operation_smart_proxy_cs visitor (&ctx);
 329         status = set_op.accept (&visitor);
 330         break;
 331       }
 332     case TAO_CodeGen::TAO_ROOT_TIE_SH:
 333       {
 334         be_visitor_operation_tie_sh visitor (&ctx);
 335         status = set_op.accept (&visitor);
 336         break;
 337       }
 338     case TAO_CodeGen::TAO_ROOT_TIE_SS:
 339       {
 340         be_visitor_operation_tie_ss visitor (&ctx);
 341         status = set_op.accept (&visitor);
 342         break;
 343       }
 344     case TAO_CodeGen::TAO_ROOT_SVTH:
 345     case TAO_CodeGen::TAO_ROOT_SVH:
 346       {
 347         be_visitor_operation_ch visitor (&ctx);
 348         status = set_op.accept (&visitor);
 349         break;
 350       }
 351     case TAO_CodeGen::TAO_ROOT_SVTS:
 352     case TAO_CodeGen::TAO_ROOT_SVS:
 353       {
 354         be_visitor_operation_svs visitor (&ctx);
 355         visitor.scope (this->op_scope_);
 356         status = set_op.accept (&visitor);
 357         break;
 358       }
 359     case TAO_CodeGen::TAO_ROOT_EXH:
 360       {
 361         be_visitor_operation_ch visitor (&ctx);
 362         status = set_op.accept (&visitor);
 363         break;
 364       }
 365     case TAO_CodeGen::TAO_ROOT_EXS:
 366       {
 367         be_visitor_operation_exs visitor (&ctx);
 368         visitor.scope (this->op_scope_);
 369         visitor.class_extension (this->exec_class_extension_.c_str ());
 370         status = set_op.accept (&visitor);
 371         break;
 372       }
 373     case TAO_CodeGen::TAO_ROOT_CNH:
 374     case TAO_CodeGen::TAO_ROOT_CNS:
 375       break;
 376     default:
 377       // Error.
 378       set_op.destroy ();
 379       rt.destroy ();
 380       ACE_ERROR_RETURN ((LM_ERROR,
 381                          "(%N:%l) be_visitor_attribute::"
 382                          "visit_attribute - "
 383                          "bad codegen state\n"),
 384                         -1);
 385     }
 386
 387   if (status == 0)
 388     {
 389       get_op.destroy ();
 390       set_op.destroy ();
 391       rt.destroy ();
 392       return 0;
 393     }
 394   else if (status == -1)
 395     {
 396       get_op.destroy ();
 397       set_op.destroy ();
 398       rt.destroy ();
 399       ACE_ERROR_RETURN ((LM_ERROR,
 400                          "(%N:%l) be_visitor_attribute::"
 401                          "visit_attribute - "
 402                          "codegen for get_attribute failed\n"),
 403                         -1);
 404     }
 405
 406   get_op.destroy ();
 407   set_op.destroy ();
 408   rt.destroy ();
 409   return 0;
 410 }
 411
 412 void
 413 be_visitor_attribute::for_facets (bool val)
 414 {
 415   this->for_facets_ = val;
 416 }
 417
 418 void
 419 be_visitor_attribute::op_scope (be_decl *node)
 420 {
 421   this->op_scope_ = node;
 422 }
 423
 424 void
 425 be_visitor_attribute::exec_class_extension (const char *extension)
 426 {
 427   this->exec_class_extension_ = extension;
 428 }