TAO/TAO_IDL/be/be_union.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    be_union.cpp
   5  *
   6  *  Extension of class AST_Union that provides additional means for C++
   7  *  mapping.
   8  *
   9  *  @author Copyright 1994-1995 by Sun Microsystems
  10  *  @author Inc. and Aniruddha Gokhale
  11  */
  12 //=============================================================================
  13
  14 #include "be_union.h"
  15 #include "be_union_branch.h"
  16 #include "be_union_label.h"
  17 #include "be_visitor.h"
  18 #include "be_codegen.h"
  19 #include "be_helper.h"
  20 #include "be_extern.h"
  21
  22 #include "ast_union_branch.h"
  23 #include "ast_enum.h"
  24 #include "utl_identifier.h"
  25 #include "idl_defines.h"
  26 #include "global_extern.h"
  27
  28 be_union::be_union (AST_ConcreteType *dt,
  29                     UTL_ScopedName *n,
  30                     bool local,
  31                     bool abstract)
  32   : COMMON_Base (local,
  33                  abstract),
  34     AST_Decl (AST_Decl::NT_union,
  35               n),
  36     AST_Type (AST_Decl::NT_union,
  37               n),
  38     AST_ConcreteType (AST_Decl::NT_union,
  39                       n),
  40     UTL_Scope (AST_Decl::NT_union),
  41     AST_Structure (AST_Decl::NT_union,
  42                    n,
  43                    local,
  44                    abstract),
  45     AST_Union (dt,
  46                n,
  47                local,
  48                abstract),
  49     be_scope (AST_Decl::NT_union),
  50     be_decl (AST_Decl::NT_union,
  51              n),
  52     be_type (AST_Decl::NT_union,
  53              n)
  54 {
  55   // Always the case.
  56   this->has_constructor (true);
  57
  58   if (!this->imported ())
  59     {
  60       idl_global->aggregate_seen_ = true;
  61
  62       idl_global->union_seen_ = true;
  63     }
  64 }
  65
  66 void
  67 be_union::redefine (AST_Structure *from)
  68 {
  69   be_union *bu = dynamic_cast<be_union*> (from);
  70   this->common_varout_gen_ = bu->common_varout_gen_;
  71   AST_Union::redefine (from);
  72 }
  73
  74 bool
  75 be_union::has_duplicate_case_labels ()
  76 {
  77   for (UTL_ScopeActiveIterator si (this, UTL_Scope::IK_decls);
  78        !si.is_done ();
  79        si.next ())
  80     {
  81       AST_Decl *d = si.item ();
  82       AST_UnionBranch *ub =
  83         dynamic_cast<AST_UnionBranch*> (d);
  84
  85       if (ub->label_list_length () > 1)
  86         {
  87           return true;
  88         }
  89     }
  90
  91   return false;
  92 }
  93
  94 void
  95 be_union::gen_ostream_operator (TAO_OutStream *os,
  96                                 bool /*use_underscore*/)
  97 {
  98   *os << be_nl
  99       << "std::ostream& operator<< (" << be_idt << be_idt_nl
 100       << "std::ostream &strm," << be_nl
 101       << "const " << this->name () << " &_tao_union" << be_uidt_nl
 102       << ")" << be_uidt_nl
 103       << "{" << be_idt_nl
 104       << "strm << \"" << this->name () << "(\";" << be_nl_2
 105       << "switch (_tao_union._d ())" << be_nl
 106       << "{" << be_idt;
 107
 108   for (long i = 0; i < this->pd_decls_used; ++i)
 109     {
 110       be_union_branch *ub =
 111         dynamic_cast<be_union_branch*> (this->pd_decls[i]);
 112
 113       // We don't want any decls, just members.
 114       if (ub == nullptr)
 115         {
 116           continue;
 117         }
 118
 119       *os << be_nl;
 120
 121       unsigned long ll_len = ub->label_list_length ();
 122
 123       for (unsigned long j = 0; j < ll_len; ++j)
 124         {
 125           // Check if we are printing the default case.
 126           if (ub->label (j)->label_kind () == AST_UnionLabel::UL_default)
 127             {
 128               *os << "default:";
 129             }
 130           else
 131             {
 132               *os << "case ";
 133
 134               ub->gen_label_value (os, j);
 135
 136               *os << ":";
 137             }
 138
 139           if (j == ll_len - 1)
 140             {
 141               *os << be_idt_nl;
 142             }
 143           else
 144             {
 145               *os << be_nl;
 146             }
 147         }
 148
 149       ACE_CString instance_name ("_tao_union.");
 150       instance_name += ub->local_name ()->get_string ();
 151
 152       *os << "strm << ";
 153
 154       be_type *ub_ft = dynamic_cast<be_type*> (ub->field_type ());
 155       AST_Decl::NodeType ub_nt = ub_ft->node_type ();
 156       // catch anonymous Array member types
 157       bool ub_use_underscore = ub_nt == AST_Decl::NT_array;
 158
 159       ub->gen_member_ostream_operator (os,
 160                                        instance_name.c_str (),
 161                                        ub_use_underscore,
 162                                        true);
 163
 164       *os << ";" << be_nl
 165           << "break;" << be_uidt;
 166     }
 167
 168   // Some compilers complain unless this is present, but only
 169   // if not all values are covered in case statements.
 170   if (this->gen_empty_default_label ())
 171     {
 172       *os << be_nl
 173           << "default:" << be_idt_nl
 174           << "break;" << be_uidt;
 175     }
 176
 177   *os << be_uidt_nl
 178       << "}" << be_nl_2
 179       << "return strm << \")\";" << be_uidt_nl
 180       << "}" << be_nl;
 181 }
 182
 183 void
 184 be_union::destroy ()
 185 {
 186   // Call the destroy methods of our base classes.
 187   this->be_scope::destroy ();
 188   this->be_type::destroy ();
 189   this->AST_Union::destroy ();
 190 }
 191
 192 // Visitor method.
 193 int
 194 be_union::accept (be_visitor *visitor)
 195 {
 196   return visitor->visit_union (this);
 197 }
 198
 199 bool
 200 be_union::gen_empty_default_label ()
 201 {
 202   // A non-empty explicit default label will be generated.
 203   if (this->default_index () != -1)
 204     {
 205       return false;
 206     }
 207
 208   AST_ConcreteType *disc = this->disc_type ();
 209   if (disc == nullptr)
 210     {
 211       return true; // In reality this is an error.
 212     }
 213
 214   AST_Decl::NodeType nt = disc->node_type ();
 215   ACE_UINT64 n_labels = this->nlabels ();
 216
 217   if (nt == AST_Decl::NT_enum)
 218     {
 219       // Enums in CORBA are always 32bits in size, so unless
 220       // there are that many enum labels in the set, it is
 221       // incomplete (reguardless as to the actual member_count).
 222       return (n_labels <= ACE_UINT32_MAX);
 223     }
 224
 225   AST_PredefinedType *pdt = dynamic_cast<AST_PredefinedType*> (disc);
 226   if (pdt == nullptr)
 227     {
 228       return true; // In reality this is an error.
 229     }
 230
 231   switch (pdt->pt ())
 232     {
 233     case AST_PredefinedType::PT_boolean:
 234       return (n_labels < 2);
 235
 236     case AST_PredefinedType::PT_char:
 237     case AST_PredefinedType::PT_octet:
 238       return (n_labels <= ACE_OCTET_MAX);
 239
 240     case AST_PredefinedType::PT_short:
 241     case AST_PredefinedType::PT_ushort:
 242     case AST_PredefinedType::PT_wchar:
 243       return (n_labels <= ACE_UINT16_MAX);
 244
 245     case AST_PredefinedType::PT_long:
 246     case AST_PredefinedType::PT_ulong:
 247       return (n_labels <= ACE_UINT32_MAX);
 248
 249     case AST_PredefinedType::PT_longlong:
 250     case AST_PredefinedType::PT_ulonglong:
 251       // We would wrap to 0 here - we are using a 64 bit count
 252       // this case is so marginal as to always be incomplete.
 253       return true;
 254
 255     // Keep fussy compilers happy.
 256     default:
 257       break;
 258     }
 259
 260   return true;
 261 }
 262
 263 AST_UnionBranch *
 264 be_union::be_add_union_branch (AST_UnionBranch *b)
 265 {
 266   return this->fe_add_union_branch (b);
 267 }
 268
 269 ACE_UINT64
 270 be_union::nlabels ()
 271 {
 272   ACE_UINT64 retval = 0;
 273
 274   for (UTL_ScopeActiveIterator si (this, UTL_Scope::IK_decls);
 275        !si.is_done ();
 276        si.next ())
 277     {
 278       AST_Decl *d = si.item ();
 279       AST_UnionBranch *ub =
 280         dynamic_cast<AST_UnionBranch*> (d);
 281
 282       if (ub != nullptr)
 283         {
 284           retval += ub->label_list_length ();
 285         }
 286     }
 287
 288   return retval;
 289 }