TAO/TAO_IDL/ast/ast_array.cpp

   1 /*
   2
   3 COPYRIGHT
   4
   5 Copyright 1992, 1993, 1994 Sun Microsystems, Inc.  Printed in the United
   6 States of America.  All Rights Reserved.
   7
   8 This product is protected by copyright and distributed under the following
   9 license restricting its use.
  10
  11 The Interface Definition Language Compiler Front End (CFE) is made
  12 available for your use provided that you include this license and copyright
  13 notice on all media and documentation and the software program in which
  14 this product is incorporated in whole or part. You may copy and extend
  15 functionality (but may not remove functionality) of the Interface
  16 Definition Language CFE without charge, but you are not authorized to
  17 license or distribute it to anyone else except as part of a product or
  18 program developed by you or with the express written consent of Sun
  19 Microsystems, Inc. ("Sun").
  20
  21 The names of Sun Microsystems, Inc. and any of its subsidiaries or
  22 affiliates may not be used in advertising or publicity pertaining to
  23 distribution of Interface Definition Language CFE as permitted herein.
  24
  25 This license is effective until terminated by Sun for failure to comply
  26 with this license.  Upon termination, you shall destroy or return all code
  27 and documentation for the Interface Definition Language CFE.
  28
  29 INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED AS IS WITH NO WARRANTIES OF
  30 ANY KIND INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS
  31 FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR ARISING FROM A COURSE OF
  32 DEALING, USAGE OR TRADE PRACTICE.
  33
  34 INTERFACE DEFINITION LANGUAGE CFE IS PROVIDED WITH NO SUPPORT AND WITHOUT
  35 ANY OBLIGATION ON THE PART OF Sun OR ANY OF ITS SUBSIDIARIES OR AFFILIATES
  36 TO ASSIST IN ITS USE, CORRECTION, MODIFICATION OR ENHANCEMENT.
  37
  38 SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES SHALL HAVE NO LIABILITY WITH
  39 RESPECT TO THE INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY
  40 INTERFACE DEFINITION LANGUAGE CFE OR ANY PART THEREOF.
  41
  42 IN NO EVENT WILL SUN OR ANY OF ITS SUBSIDIARIES OR AFFILIATES BE LIABLE FOR
  43 ANY LOST REVENUE OR PROFITS OR OTHER SPECIAL, INDIRECT AND CONSEQUENTIAL
  44 DAMAGES, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  45
  46 Use, duplication, or disclosure by the government is subject to
  47 restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  48 Technical Data and Computer Software clause at DFARS 252.227-7013 and FAR
  49 52.227-19.
  50
  51 Sun, Sun Microsystems and the Sun logo are trademarks or registered
  52 trademarks of Sun Microsystems, Inc.
  53
  54 SunSoft, Inc.
  55 2550 Garcia Avenue
  56 Mountain View, California  94043
  57
  58 NOTE:
  59
  60 SunOS, SunSoft, Sun, Solaris, Sun Microsystems or the Sun logo are
  61 trademarks or registered trademarks of Sun Microsystems, Inc.
  62
  63 */
  64
  65 // AST_Array nodes denote array type and field modifiers.
  66 // AST_Array nodes have a list of dimensions (a UTL_ExprList)
  67 // a count of the number of dimensions and a base type (a
  68 // subtype of AST_ConcreteType. This means that we cannot have
  69 // arrays of AST_Interfaces???
  70
  71 #include "ast_array.h"
  72 #include "ast_expression.h"
  73 #include "ast_param_holder.h"
  74 #include "ast_visitor.h"
  75
  76 #include "utl_exprlist.h"
  77 #include "utl_identifier.h"
  78 #include "ace/Log_Msg.h"
  79 #include "ace/OS_Memory.h"
  80
  81 AST_Decl::NodeType const
  82 AST_Array::NT = AST_Decl::NT_array;
  83
  84 AST_Array::AST_Array (UTL_ScopedName *n,
  85                       ACE_CDR::ULong nd,
  86                       UTL_ExprList *ds,
  87                       bool local,
  88                       bool abstract)
  89   : COMMON_Base (local,
  90                  abstract),
  91     AST_Decl (AST_Decl::NT_array,
  92               n,
  93               true),
  94     AST_Type (AST_Decl::NT_array,
  95               n),
  96     AST_ConcreteType (AST_Decl::NT_array,
  97                       n),
  98     pd_n_dims (nd),
  99     pd_base_type (0),
 100     owns_base_type_ (false)
 101 {
 102   this->pd_dims = this->compute_dims (ds,
 103                                       nd);
 104 }
 105
 106 AST_Array::~AST_Array (void)
 107 {
 108 }
 109
 110 // Private operations.
 111
 112 // Compute how many dimensions there are and collect their expressions
 113 // into an array.
 114 AST_Expression **
 115 AST_Array::compute_dims (UTL_ExprList *ds,
 116                          ACE_CDR::ULong nds)
 117 {
 118   if (ds == 0)
 119     {
 120       return 0;
 121     }
 122
 123   AST_Expression **result = 0;
 124   ACE_NEW_RETURN (result,
 125                   AST_Expression *[nds],
 126                   0);
 127
 128   UTL_ExprlistActiveIterator iter (ds);
 129
 130   for (ACE_CDR::ULong i = 0;
 131        !iter.is_done () && i < nds;
 132        iter.next (), i++)
 133     {
 134       AST_Expression *orig = iter.item ();
 135       AST_Param_Holder *ph = orig->param_holder ();
 136
 137       AST_Expression::ExprType ex_type =
 138         (ph == 0 ? orig->ev ()->et : ph->info ()->const_type_);
 139
 140       AST_Expression *copy = 0;
 141       ACE_NEW_RETURN (copy,
 142                       AST_Expression (orig,
 143                                       ex_type),
 144                       0);
 145
 146       result[i] = copy;
 147     }
 148
 149   return result;
 150 }
 151
 152 // Redefinition of inherited virtual operations.
 153
 154 // Dump this AST_Array node to the ostream o.
 155 void
 156 AST_Array::dump (ACE_OSTREAM_TYPE &o)
 157 {
 158   pd_base_type->dump (o);
 159
 160   this->dump_i (o, " ");
 161
 162   this->local_name ()->dump (o);
 163
 164   for (ACE_CDR::ULong i = 0; i < this->pd_n_dims; i++)
 165     {
 166       this->dump_i (o, "[");
 167
 168       pd_dims[i]->dump (o);
 169
 170       this->dump_i (o, "]");
 171     }
 172 }
 173
 174 int
 175 AST_Array::ast_accept (ast_visitor *visitor)
 176 {
 177   return visitor->visit_array (this);
 178 }
 179
 180 // Compute the size type of the node in question.
 181 int
 182 AST_Array::compute_size_type (void)
 183 {
 184   AST_Type *type = this->base_type ();
 185
 186   if (!type)
 187     {
 188       ACE_ERROR_RETURN ((LM_ERROR,
 189                          "(%N:%l) be_array::compute_size_type - "
 190                          "bad base type\n"),
 191                         -1);
 192     }
 193
 194   // Our size type is the same as our type.
 195   this->size_type (type->size_type ());
 196
 197   this->has_constructor (type->has_constructor ());
 198
 199   return 0;
 200 }
 201
 202 // Data accessors.
 203 ACE_CDR::ULong
 204 AST_Array::n_dims (void)
 205 {
 206   return this->pd_n_dims;
 207 }
 208
 209 AST_Expression **
 210 AST_Array::dims (void)
 211 {
 212   return this->pd_dims;
 213 }
 214
 215 AST_Type *
 216 AST_Array::base_type (void) const
 217 {
 218   return this->pd_base_type;
 219 }
 220
 221 void
 222 AST_Array::set_base_type (AST_Type *nbt)
 223 {
 224   this->pd_base_type = nbt;
 225   this->is_local_ = nbt->is_local ();
 226   AST_Decl::NodeType bnt = nbt->node_type ();
 227
 228   if (bnt == AST_Decl::NT_sequence
 229       || bnt == AST_Decl::NT_param_holder)
 230     {
 231       this->owns_base_type_ = true;
 232     }
 233 }
 234
 235 bool
 236 AST_Array::legal_for_primary_key (void) const
 237 {
 238   return this->base_type ()->legal_for_primary_key ();
 239 }
 240
 241 void
 242 AST_Array::destroy (void)
 243 {
 244   if (this->owns_base_type_)
 245     {
 246       this->pd_base_type->destroy ();
 247       delete this->pd_base_type;
 248       this->pd_base_type = 0;
 249     }
 250
 251   for (ACE_CDR::ULong i = 0; i < this->pd_n_dims; ++i)
 252     {
 253       this->pd_dims[i]->destroy ();
 254       delete this->pd_dims[i];
 255       this->pd_dims[i] = 0;
 256     }
 257
 258   delete [] this->pd_dims;
 259   this->pd_dims = 0;
 260   this->pd_n_dims = 0;
 261
 262   this->AST_ConcreteType::destroy ();
 263 }
 264
 265 void
 266 AST_Array::set_dims (AST_Expression **ds,
 267                      ACE_CDR::ULong nds)
 268 {
 269   this->pd_dims = ds;
 270   this->pd_n_dims = nds;
 271 }
 272
 273 IMPL_NARROW_FROM_DECL(AST_Array)
 274
 275 AST_Annotation_Appls &
 276 AST_Array::base_type_annotations ()
 277 {
 278   return base_type_annotations_;
 279 }
 280
 281 void
 282 AST_Array::base_type_annotations (const AST_Annotation_Appls &annotations)
 283 {
 284   base_type_annotations_ = annotations;
 285 }